AstRange (EN) - bhsd-harry/wikiparser-node GitHub Wiki

Table of Contents

Other Languages

Introduction

Modeled after the Range class, the properties and methods are also very similar to the Range class. The main difference is that the start and end points of AstRange must be consecutive child nodes of the same node.

All of the following properties and methods are not available in the Mini and Browser versions.

Properties

startContainer

Expand

type: AstNode
The container of the start point, read-only.

// startContainer (main)
var root = Parser.parse([[a]]bc'),
	{lastChild} = root,
	range = root.createRange();
assert.equal(lastChild, 'bc');
range.setStart(root, 1);
assert.strictEqual(range.startContainer, root);
range.setStart(lastChild, 0);
assert.strictEqual(range.startContainer, lastChild);

startOffset

Expand

type: number
The position of the start point, read-only.

// startOffset (main)
var root = Parser.parse([[a]]bc'),
	{lastChild} = root,
	range = root.createRange();
assert.equal(lastChild, 'bc');
range.setStart(root, 1);
assert.strictEqual(range.startOffset, 1);
range.setStart(lastChild, 1);
assert.strictEqual(range.startOffset, 1);

startIndex

Expand

type: number
The absolute position of the start point, read-only.

// startIndex (main)
var root = Parser.parse([[a]]bc'),
	{lastChild} = root,
	range = root.createRange();
assert.equal(lastChild, 'bc');
range.setStart(root, 1);
assert.strictEqual(range.startIndex, 5);
range.setStart(lastChild, 1);
assert.strictEqual(range.startIndex, 6);

startPos

Expand

type: {top: number, left: number}
The row and column position of the start point, read-only.

// startPos (main)
var root = Parser.parse([[a]]\nb'),
	{lastChild} = root,
	range = root.createRange();
assert.equal(lastChild, '\nb');
range.setStart(root, 1);
assert.deepStrictEqual(range.startPos, {top: 0, left: 5});
range.setStart(lastChild, 1);
assert.deepStrictEqual(range.startPos, {top: 1, left: 0});

endContainer

Expand

type: AstNode
The container of the end point, read-only.

// endContainer (main)
var root = Parser.parse([[a]]bc'),
	{lastChild} = root,
	range = root.createRange();
assert.equal(lastChild, 'bc');
range.setEnd(root, 1);
assert.strictEqual(range.endContainer, root);
range.setEnd(lastChild, 0);
assert.strictEqual(range.endContainer, lastChild);

endOffset

Expand

type: number
The position of the end point, read-only.

// endOffset (main)
var root = Parser.parse([[a]]bc'),
	{lastChild} = root,
	range = root.createRange();
assert.equal(lastChild, 'bc');
range.setEnd(root, 1);
assert.strictEqual(range.endOffset, 1);
range.setEnd(lastChild, 1);
assert.strictEqual(range.endOffset, 1);

endIndex

Expand

type: number
The absolute position of the end point, read-only.

// endIndex (main)
var root = Parser.parse([[a]]bc'),
	{lastChild} = root,
	range = root.createRange();
assert.equal(lastChild, 'bc');
range.setEnd(root, 1);
assert.strictEqual(range.endIndex, 5);
range.setEnd(lastChild, 1);
assert.strictEqual(range.endIndex, 6);

endPos

Expand

type: {top: number, left: number}
The row and column position of the end point, read-only.

// endPos (main)
var root = Parser.parse([[a]]\nb'),
	{lastChild} = root,
	range = root.createRange();
assert.equal(lastChild, '\nb');
range.setEnd(root, 1);
assert.deepStrictEqual(range.endPos, {top: 0, left: 5});
range.setEnd(lastChild, 1);
assert.deepStrictEqual(range.endPos, {top: 1, left: 0});

collapsed

Expand

type: boolean
Whether the start and end points are coincident, read-only.

// collapsed (main)
var root = Parser.parse([[a]]b'),
	{lastChild} = root,
	range = root.createRange();
assert.equal(lastChild, 'b');
range.setStart(root, 1);
range.setEnd(root, 1);
assert.ok(range.collapsed);
range.setEnd(lastChild, 0);
assert.ok(!range.collapsed);

commonAncestorContainer

Expand

type: AstNode
The closest common ancestor of the start and end points, read-only.

// commonAncestorContainer (main)
var root = Parser.parse([[a]]b'),
	{firstChild, lastChild} = root,
	range = root.createRange();
assert.equal(firstChild, '[[a]]');
range.setStart(lastChild, 0);
range.setEnd(lastChild, 1);
assert.strictEqual(range.commonAncestorContainer, lastChild);
range.setStart(root, 0);
assert.strictEqual(range.commonAncestorContainer, root);

childNodes

Expand

version added: 1.23.0

type: AstNode[]
The nodes contained in the Range, read-only.

firstChild

Expand

version added: 1.23.0

type: AstNode | undefined
The first node in the Range, read-only.

// firstChild (main)
var root = Parser.parse([[a]]b'),
	range = root.createRange();
range.selectNodeContents(root);
assert.strictEqual(range.firstChild, root.firstChild);

lastChild

Expand

version added: 1.23.0

type: AstNode | undefined
The last node in the Range, read-only.

// lastChild (main)
var root = Parser.parse([[a]]b'),
	range = root.createRange();
range.selectNodeContents(root);
assert.strictEqual(range.lastChild, root.lastChild);

children

Expand

version added: 1.23.0

type: Token[]
The tokens contained in the Range, read-only.

// children (main)
var root = Parser.parse([[a]]b'),
	range = root.createRange();
range.selectNodeContents(root);
assert.deepStrictEqual(range.children, root.children);

firstElementChild

Expand

version added: 1.23.0

type: Token | undefined
The first token in the Range, read-only.

// firstElementChild (main)
var root = Parser.parse('a[[b]]'),
	range = root.createRange();
range.selectNodeContents(root);
assert.strictEqual(range.firstElementChild, root.lastChild);

lastElementChild

Expand

version added: 1.23.0

type: Token | undefined
The last token in the Range, read-only.

// lastElementChild (main)
var root = Parser.parse([[a]]b'),
	range = root.createRange();
range.selectNodeContents(root);
assert.strictEqual(range.lastElementChild, root.firstChild);

childElementCount

Expand

version added: 1.23.0

type: number
Number of tokens in the Range, read-only.

// childElementCount (main)
var root = Parser.parse([[a]]b'),
	range = root.createRange();
range.selectNodeContents(root);
assert.strictEqual(range.childElementCount, 1);

offsetHeight

Expand

version added: 1.23.0

type: number
Number of lines in the Range, read-only.

// offsetHeight (main)
var root = Parser.parse([[a]]\nb'),
	range = root.createRange();
range.selectNodeContents(root);
assert.strictEqual(range.offsetHeight, 2);

offsetWidth

Expand

version added: 1.23.0

type: number
Number of columns in the last line of the Range, read-only.

// offsetWidth (main)
var root = Parser.parse([[a]]\nb'),
	range = root.createRange();
range.selectNodeContents(root);
assert.strictEqual(range.offsetWidth, 1);

Methods

setStart

Expand

param: AstNode Container of the start point
param: number Position of the start point
Set the start point.

setEnd

Expand

param: AstNode Container of the end point
param: number Position of the end point
Set the end point.

setStartAfter

Expand

param: AstNode Node
Set the start point after the node.

// setStartAfter (main)
var root = Parser.parse('a'),
	{firstChild} = root,
	range = root.createRange();
range.setStartAfter(firstChild);
assert.strictEqual(range.startContainer, root);
assert.strictEqual(range.startOffset, 1);

setEndAfter

Expand

param: AstNode Node
Set the end point after the node.

// setEndAfter (main)
var root = Parser.parse('a'),
	{firstChild} = root,
	range = root.createRange();
range.setEndAfter(firstChild);
assert.strictEqual(range.endContainer, root);
assert.strictEqual(range.endOffset, 1);

setStartBefore

Expand

param: AstNode Node
Set the start point before the node.

// setStartBefore (main)
var root = Parser.parse('a'),
	{firstChild} = root,
	range = root.createRange();
range.setStartBefore(firstChild);
assert.strictEqual(range.startContainer, root);
assert.strictEqual(range.startOffset, 0);

setEndBefore

Expand

param: AstNode Node
Set the end point before the node.

// setEndBefore (main)
var root = Parser.parse('a'),
	{firstChild} = root,
	range = root.createRange();
range.setEndBefore(firstChild);
assert.strictEqual(range.endContainer, root);
assert.strictEqual(range.endOffset, 0);

selectNodeContents

Expand

param: AstNode Node
Set the Range to contain the entire contents of the node.

// selectNodeContents (main)
var root = Parser.parse([[a]]b'),
	range = root.createRange();
range.selectNodeContents(root);
assert.strictEqual(range.startContainer, root);
assert.strictEqual(range.startOffset, 0);
assert.strictEqual(range.endContainer, root);
assert.strictEqual(range.endOffset, 2);

selectNode

Expand

param: AstNode Node
Set the Range to contain the entire node.

// selectNode (main)
var root = Parser.parse([[a]]b'),
	{firstChild} = root,
	range = root.createRange();
assert.equal(firstChild, '[[a]]');
range.selectNode(firstChild);
assert.strictEqual(range.startContainer, root);
assert.strictEqual(range.startOffset, 0);
assert.strictEqual(range.endContainer, root);
assert.strictEqual(range.endOffset, 1);

collapse

Expand

param: boolean Whether to collapse to the start point
Collapse the Range to the start or end point.

// collapse (main)
var root = Parser.parse('a'),
	range = root.createRange();
range.setEnd(root, 1);
range.collapse();
assert.strictEqual(range.startContainer, root);
assert.strictEqual(range.startOffset, 1);
range.setStart(root, 0);
range.collapse(true);
assert.strictEqual(range.endContainer, root);
assert.strictEqual(range.endOffset, 0);

comparePoint

Expand

param: AstNode Container of the point
param: number Position of the point
returns: -1 | 0 | 1
Compare the position of the point with the Range.

// comparePoint (main)
var root = Parser.parse('abcd'),
	{firstChild} = root,
	range = root.createRange();
range.setStart(firstChild, 1);
range.setEnd(firstChild, 3);
assert.equal(range, 'bc');
assert.strictEqual(range.comparePoint(firstChild, 0), -1);
assert.strictEqual(range.comparePoint(firstChild, 2), 0);
assert.strictEqual(range.comparePoint(firstChild, 4), 1);
range.selectNodeContents(firstChild);
assert.strictEqual(range.comparePoint(root, 0), -1);
assert.strictEqual(range.comparePoint(root, 1), 1);

isPointInRange

Expand

param: AstNode Container of the point
param: number Position of the point
returns: boolean
Whether the point is in the Range.

// isPointInRange (main)
var root = Parser.parse('abcd'),
	{firstChild} = root,
	range = root.createRange();
range.setStart(firstChild, 1);
range.setEnd(firstChild, 3);
assert.equal(range, 'bc');
assert.ok(!range.isPointInRange(firstChild, 0));
assert.ok(range.isPointInRange(firstChild, 2));
assert.ok(!range.isPointInRange(firstChild, 4));
range.selectNodeContents(firstChild);
assert.ok(!range.isPointInRange(root, 0));
assert.ok(!range.isPointInRange(root, 1));

cloneRange

Expand

returns: AstRange
Clone the AstRange object.

// cloneRange (main)
var root = Parser.parse('a'),
	range = root.createRange();
range.setStart(root, 0);
range.setEnd(root, 1);
assert.deepStrictEqual(range.cloneRange(), range);

detach

Expand

Clear the Range.

// detach (main)
var root = Parser.parse('a'),
	range = root.createRange();
range.setStart(root, 0);
range.setEnd(root, 1);
range.detach();

deleteContents

Expand

Delete the contents of the Range.

// deleteContents (main)
var root = Parser.parse('ab[[c]]{{d}}e'),
	{firstChild, lastChild} = root,
	range = root.createRange();
assert.equal(firstChild, 'ab');
assert.equal(lastChild, 'e');
range.setStart(firstChild, 0);
range.setEnd(firstChild, 1);
assert.equal(range, 'a');
range.deleteContents();
assert.equal(root, 'b[[c]]{{d}}e');
assert.strictEqual(range.startContainer, firstChild);
assert.strictEqual(range.startOffset, 0);
assert.strictEqual(range.endContainer, firstChild);
assert.strictEqual(range.endOffset, 0);
range.detach();
range.setStart(root, 2);
range.setEnd(lastChild, 1);
assert.equal(range, '{{d}}e');
range.deleteContents();
assert.equal(root, 'b[[c]]');
assert.strictEqual(range.startContainer, root);
assert.strictEqual(range.startOffset, 2);
assert.strictEqual(range.endContainer, root);
assert.strictEqual(range.endOffset, 2);
range.setStart(firstChild, 0);
assert.ok(range, 'b[[c]]');
range.deleteContents();
assert.equal(root, '');
assert.strictEqual(range.startContainer, root);
assert.strictEqual(range.startOffset, 1);
assert.strictEqual(range.endContainer, root);
assert.strictEqual(range.endOffset, 1);

remove

Expand

version added: 1.23.0

An alias for deleteContents.

getBoundingClientRect

Expand

returns: {top: number, left: number, height: number, left: number}
Get the row and column position and size of the Range.

// getBoundingClientRect (main)
var root = Parser.parse('ab\n[[c]]'),
	{firstChild} = root,
	range = root.createRange();
assert.equal(firstChild, 'ab\n');
range.setStart(firstChild, 1);
range.setEnd(firstChild, 2);
assert.equal(range, 'b');
assert.deepStrictEqual(range.getBoundingClientRect(), {
	top: 0,
	left: 1,
	height: 1,
	width: 1,
});
range.setEnd(root, 2);
assert.equal(range, 'b\n[[c]]');
assert.deepStrictEqual(range.getBoundingClientRect(), {
	top: 0,
	left: 1,
	height: 2,
	width: 5,
});

getClientRects

Expand

version added: 1.23.0

returns: {top: number, left: number, height: number, left: number}[]
Get the row and column positions and sizes of the nodes in the Range.

// getClientRects (main)
var root = Parser.parse('ab\n[[c]]'),
	range = root.createRange();
range.selectNodeContents(root);
assert.deepStrictEqual(range.getClientRects(), [
	{
		top: 0,
		left: 0,
		height: 2,
		width: 0,
	},
	{
		top: 1,
		left: 0,
		height: 1,
		width: 5,
	},
]);

insertNode

Expand

param: AstNode | string Node or text to insert
param: boolean Whether to insert after the Range, default is to insert before
Insert a node or text before or after the Range.

// insertNode (main)
var root = Parser.parse('abcd'),
	{firstChild} = root,
	range = root.createRange();
range.setStart(firstChild, 1);
range.setEnd(firstChild, 3);
assert.equal(range, 'bc');
range.insertNode('e');
assert.equal(root, 'aebcd');
assert.equal(range, 'bc');
range.insertNode('f', true);
assert.equal(root, 'aebcfd');
assert.equal(range, 'bc');

before

Expand

version added: 1.23.0

param: AstNode | string Nodes or texts to insert
Insert nodes or texts before the Range.

// before (main)
var root = Parser.parse('ab[[c]]'),
	{firstChild} = root,
	range = root.createRange();
range.setStart(firstChild, 1);
range.setEnd(root, 2);
assert.equal(range, 'b[[c]]');
range.before('d', 'e');
assert.equal(root, 'adeb[[c]]');
assert.equal(range, 'b[[c]]');

after

Expand

version added: 1.23.0

param: AstNode | string Nodes or texts to insert
Insert nodes or texts after the Range.

// after (main)
var root = Parser.parse('abc'),
	{firstChild} = root,
	range = root.createRange();
range.setStart(firstChild, 1);
range.setEnd(firstChild, 2);
assert.equal(range, 'b');
range.after('d', 'e');
assert.equal(root, 'abdec');
assert.equal(range, 'b');

replaceWith

Expand

version added: 1.23.0

param: AstNode | string New nodes or texts
Replace the Range with nodes or texts.

// replaceWith (main)
var root = Parser.parse('abc'),
	{firstChild} = root,
	range = root.createRange();
range.setStart(firstChild, 1);
range.setEnd(firstChild, 2);
assert.equal(range, 'b');
range.replaceWith('d', 'e');
assert.equal(root, 'adec');
assert.equal(range, 'de');

append

Expand

version added: 1.23.0

param: AstNode | string Nodes or texts
Append nodes or texts to the end of the Range.

// append (main)
var root = Parser.parse('abc'),
	{firstChild} = root,
	range = root.createRange();
range.setStart(firstChild, 1);
range.setEnd(firstChild, 2);
assert.equal(range, 'b');
range.append('d', 'e');
assert.equal(root, 'abdec');
assert.equal(range, 'bde');

prepend

Expand

version added: 1.23.0

param: AstNode | string Nodes or texts
Prepend nodes or texts to the start of the Range.

// prepend (main)
var root = Parser.parse('abc'),
	{firstChild} = root,
	range = root.createRange();
range.setStart(firstChild, 1);
range.setEnd(firstChild, 2);
assert.equal(range, 'b');
range.prepend('d', 'e');
assert.equal(root, 'adebc');
assert.equal(range, 'deb');

removeChild

Expand

version added: 1.23.0

param: AstNode Child node to remove
Remove a child node from the Range.

// removeChild (main)
var root = Parser.parse('a[[b]]c'),
	{firstElementChild} = root,
	range = root.createRange();
assert.equal(firstElementChild, '[[b]]');
range.selectNodeContents(root);
range.removeChild(firstElementChild);
assert.equal(root, 'ac');
assert.equal(range, 'ac');

extractContents

Expand

returns: AstNode[]
Get all the nodes in the Range.

// extractContents (main)
var root = Parser.parse('abc'),
	{firstChild} = root,
	range = root.createRange();
assert.equal(firstChild, 'abc');
range.setStart(firstChild, 0);
range.setEnd(firstChild, 0);
assert.equal(range, '');
assert.deepStrictEqual(range.extractContents(), []);
range.setEnd(firstChild, 3);
assert.equal(range, 'abc');
assert.deepStrictEqual(
	range.extractContents(),
	[root.createTextNode('abc')],
);
range.setStart(firstChild, 1);
range.setEnd(firstChild, 2);
assert.equal(range, 'b');
assert.deepStrictEqual(
	range.extractContents(),
	[root.createTextNode('b')],
);
range.setEnd(root, 3);
assert.equal(range, 'bc');
assert.deepStrictEqual(range.extractContents(), [
	root.createTextNode('b'),
	root.createTextNode('c'),
]);
range.setStart(root, 0);
assert.equal(range, 'abc');
assert.deepStrictEqual(range.extractContents(), [
	root.createTextNode('a'),
	root.createTextNode('b'),
	root.createTextNode('c'),
]);

cloneContents

Expand

returns: AstNode[]
Clone all the nodes in the Range.

// cloneContents (main)
var root = Parser.parse('ab<p>'),
	{firstChild} = root,
	range = root.createRange(),
	cloned;
assert.equal(firstChild, 'ab');
range.setStart(firstChild, 1);
range.setEnd(root, 2);
assert.equal(range, 'b<p>');
cloned = range.cloneContents();
assert.deepStrictEqual(cloned, [
	root.createTextNode('b'),
	root.createElement('p'),
]);

getRootNode

Expand

version added: 1.23.0

returns: AstNode
Get the root node of the Range.

// getRootNode (main)
var root = Parser.parse('abc'),
	{firstChild} = root,
	range = root.createRange();
range.setStart(firstChild, 1);
assert.strictEqual(range.getRootNode(), root);

closest

Expand

version added: 1.23.0

param: string Selector
returns: Token | undefined
Get the closest ancestor token of the Range that matches the selector.

// closest (main)
var root = Parser.parse('abc'),
	{firstChild} = root,
	range = root.createRange();
range.setStart(firstChild, 1);
range.setEnd(firstChild, 2);
assert.strictEqual(range.closest('root'), root);

querySelector

Expand

version added: 1.23.0

param: string Selector
returns: Token | undefined
Get the first token in the Range that matches the selector.

// querySelector (main)
var root = Parser.parse([[a]]{{b}}'),
	{lastChild} = root,
	range = root.createRange();
assert.equal(lastChild, '{{b}}');
range.selectNodeContents(root);
assert.strictEqual(range.querySelector('template'), lastChild);

getElementByTypes

Expand

version added: 1.23.0

param: string Comma-separated list of element types
returns: Token | undefined
Get the first token in the Range that matches one of the specified element types.

// getElementByTypes (main)
var root = Parser.parse([[a]]{{b}}'),
	{lastChild} = root,
	range = root.createRange();
assert.equal(lastChild, '{{b}}');
range.selectNodeContents(root);
assert.strictEqual(range.getElementByTypes('template'), lastChild);

getElementById

Expand

version added: 1.23.0

param: string Tag id
returns: Token | undefined
Get the first token in the Range that matches the id.

// getElementById (main)
var root = Parser.parse([[a]]<b id="c">'),
	{lastChild} = root,
	range = root.createRange();
assert.equal(lastChild, '<b id="c">');
range.selectNodeContents(root);
assert.strictEqual(range.getElementById('c'), lastChild);

querySelectorAll

Expand

version added: 1.23.0

param: string Selector
returns: Token[]
Get all tokens in the Range that match the selector.

// querySelectorAll (main)
var root = Parser.parse([[a]][[b]]'),
	{firstChild, lastChild} = root,
	range = root.createRange();
assert.equal(firstChild, '[[a]]');
assert.equal(lastChild, '[[b]]');
range.selectNodeContents(root);
assert.deepStrictEqual(
	range.querySelectorAll('link'),
	[firstChild, lastChild],
);

getElementsByClassName

Expand

version added: 1.23.0

param: string Class name
returns: Token[]
Get all tokens in the Range that match the class name.

// getElementsByClassName (main)
var root = Parser.parse('<b class="c">[[a]]<p class="c">'),
	{firstChild, lastChild} = root,
	range = root.createRange();
assert.equal(firstChild, '<b class="c">');
assert.equal(lastChild, '<p class="c">');
range.selectNodeContents(root);
assert.deepStrictEqual(
	range.getElementsByClassName('c'),
	[firstChild, firstChild.firstChild, lastChild, lastChild.firstChild],
);

getElementsByTagName

Expand

version added: 1.23.0

param: string Tag name
returns: Token[]
Get all tokens in the Range that match the tag name.

// getElementsByTagName (main)
var root = Parser.parse('<b>[[a]]<b>'),
	{firstChild, lastChild} = root,
	range = root.createRange();
assert.equal(firstChild, '<b>');
assert.equal(lastChild, '<b>');
range.selectNodeContents(root);
assert.deepStrictEqual(
	range.getElementsByTagName('b'),
	[firstChild, lastChild],
);

escape

Expand

version added: 1.23.0

Escape the nodes in the Range.

// escape (main)
var root = Parser.parse('=\n{|'),
	{firstChild, lastChild} = root,
	range = root.createRange();
assert.equal(firstChild, '=\n');
assert.equal(lastChild, '{|');
range.selectNodeContents(root);
range.escape();
assert.equal(root.toString(), '{{=}}\n{{{!}}');

相关软件包

WikiLint

对维基文本批量执行语法检查的命令行工具

WikiParser Language Server

用于维基文本的 VSCode 扩展

Related Packages

WikiLint

A command-line tool that performs linting on Wikitext in bulk

WikiParser Language Server

VSCode extension for Wikitext

⚠️ **GitHub.com Fallback** ⚠️