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

Table of Contents

Other Languages

Introduction

AstElement is the parent class of non-text nodes. It is modeled after the HTMLElement class, and has properties and methods very similar to the HTMLElement class. This class inherits all the properties and methods of the AstNode class which are not repeated here.

✅ Available in the Mini and Browser versions.
🌐 Available in the Browser version.

Properties

length

✅ Expand

type: number
Total number of child nodes.

// length
assert.strictEqual(Parser.parse([[a]]b').length, 2);
// length (main)
var root = Parser.parse([[a]]b');
root.length = 1;
assert.equal(root, '[[a]]');

children

Expand

type: Token[]
Total number of non-text child nodes, read-only.

// children (main)
var root = Parser.parse([[a]]b'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.children, [firstChild]);

firstElementChild

Expand

type: Token
First non-text child node, read-only.

// firstElementChild (main)
var root = Parser.parse('b[[a]]'),
	{lastChild} = root;
assert.equal(lastChild, '[[a]]');
assert.strictEqual(root.firstElementChild, lastChild);

lastElementChild

Expand

type: Token
Last non-text child node, read-only.

// lastElementChild (main)
var root = Parser.parse([[a]]b'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(root.lastElementChild, firstChild);

childElementCount

Expand

type: number
Total number of non-text child nodes, read-only.

// childElementCount (main)
assert.strictEqual(Parser.parse([[a]]b').childElementCount, 1);

parentElement

Expand

type: Token
Parent node, alias of the parentNode property, read-only.

// parentElement (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(firstChild.parentElement, root);
assert.strictEqual(root.parentElement, undefined);

outerText

Expand

type: string
Equivalent to the text method, read-only.

// outerText (main)
assert.strictEqual(
	Parser.parse('<!--a-->b{{c|__nocc__}}').outerText,
	'b{{c|}}',
);

hidden

Expand

type: boolean
Whether the node is invisible, read-only.

// hidden (main)
var {firstChild, lastChild} = Parser.parse('<!--a-->__nocc__');
assert.equal(firstChild, '<!--a-->');
assert.equal(lastChild, '__nocc__');
assert.ok(firstChild.hidden);
assert.ok(lastChild.hidden);

clientHeight

Expand

type: number
Inner height, only exists when the innerText property is defined, read-only.

// clientHeight (main)
var root = Parser.parse('<pre>a\nb</pre>'),
	{firstChild} = root;
assert.equal(firstChild, '<pre>a\nb</pre>');
assert.strictEqual(firstChild.innerText, 'a\nb');
assert.strictEqual(firstChild.clientHeight, 2);
assert.strictEqual(root.clientHeight, undefined);

clientWidth

Expand

type: number
Inner width, only exists when the innerText property is defined, read-only.

// clientWidth (main)
var root = Parser.parse('<pre>ab\nc</pre>'),
	{firstChild} = root;
assert.equal(firstChild, '<pre>ab\nc</pre>');
assert.strictEqual(firstChild.innerText, 'ab\nc');
assert.strictEqual(firstChild.clientWidth, 1);
assert.strictEqual(root.clientWidth, undefined);

images

Expand

type: Token[]
All image nodes, read-only.

// images (main)
var root = Parser.parse('[[file:a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[file:a]]');
assert.deepStrictEqual(root.images, [firstChild]);

links

Expand

type: Token[]
All internal links, external links, free external links and image links, read-only.

// links (main)
var root = Parser.parse([[a]][//b]http://c[[file:d|link=e]]'),
	{childNodes: [link, extLink, magicLink, {lastChild}]} = root;
assert.equal(link, '[[a]]');
assert.equal(extLink, '[//b]');
assert.equal(magicLink, 'http://c');
assert.equal(lastChild, 'link=e');
assert.deepStrictEqual(root.links, [
	link,
	extLink,
	magicLink,
	lastChild,
]);

embeds

Expand

type: Token[]
All embedded templates and modules, read-only.

// embeds (main)
var root = Parser.parse('{{a}}{{#invoke:b|c}}'),
	{firstChild, lastChild} = root;
assert.equal(firstChild, '{{a}}');
assert.equal(lastChild, '{{#invoke:b|c}}');
assert.deepStrictEqual(root.embeds, [firstChild, lastChild]);

Methods

text

✅ Expand

returns: string
Visible text. See the documentation for each type of nodes for details.

// text
assert.strictEqual(Parser.parse('<!--a-->b{{c|__nocc__}}').text(), 'b{{c|}}');

closest

✅ Expand

param: string Selector
Closest ancestor node.

// closest
var root = Parser.parse('[[a]]'),
	{firstChild: link} = root,
	{firstChild} = link;
assert.equal(link, '[[a]]');
assert.strictEqual(firstChild.closest('root'), root);
assert.strictEqual(firstChild.closest('root, link'), link);
// closest (main)
var root = Parser.parse('[[a]]'),
	{firstChild: link} = root,
	{firstChild} = link;
assert.equal(link, '[[a]]');
assert.strictEqual(firstChild.closest('link#A'), link);
assert.strictEqual(firstChild.closest('root, link#B'), root);

querySelector

✅ Expand

param: string Selector
returns: Token
First descendant node that matches the selector.

// querySelector
var root = Parser.parse('<p><i>'),
	{firstChild} = root;
assert.equal(firstChild, '<p>');
assert.strictEqual(root.querySelector('html'), firstChild);

querySelectorAll

✅ Expand

param: string Selector
returns: Token[]
All descendant nodes that match the selector.

// querySelectorAll
var root = Parser.parse('<p><i>'),
	{firstChild, lastChild} = root;
assert.equal(firstChild, '<p>');
assert.equal(lastChild, '<i>');
assert.deepStrictEqual(root.querySelectorAll('html'), [
	firstChild,
	lastChild,
]);

caretPositionFromIndex

✅ Expand

param: number Character position
returns: {offsetNode: AstNode, offset: number}
Find the given position.

// caretPositionFromIndex
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.caretPositionFromIndex(1), {
	offsetNode: firstChild,
	offset: 1,
});

elementFromIndex

✅ Expand

param: number Character position
returns: Token
Find the outermost node at the given position.

// elementFromIndex
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(root.elementFromIndex(1), firstChild);

elementFromPoint

✅ Expand

param: number Character column
param: number Character row
returns: Token
Find the outermost node at the given position.

// elementFromPoint
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(root.elementFromPoint(1, 0), firstChild);

lint

✅ Expand

returns: LintError[]
Report potential grammar errors. See the documentation for each type of nodes for details.

print

🌐 Expand

returns: string
Output in HTML format. See the documentation for each type of nodes for details.

json

🌐 Expand

param: string file name
Save the syntax tree as JSON. The saved JSON files are in the printed/ path of WikiParser-Node.

// json
assert.deepStrictEqual(Parser.parse('<!-- a -->').json(), {
	range: [0, 10],
	type: 'root',
	childNodes: [
		{
			range: [0, 10],
			type: 'comment',
			closed: true,
			childNodes: [
				{
					range: [4, 7],
					data: ' a ',
				},
			],
		},
	],
});

removeAt

Expand

param: number Position of the child node to be removed
returns: AstNode
Remove a child node at the specified position.

// removeAt
var root = Parser.parse([[a]]b');
root.removeAt(1);
assert.equal(root, '[[a]]');

insertAt

Expand

param: AstNode | string Child node to be inserted
param: number Position of the child node to be inserted
returns: AstNode
Insert a child node at the specified position.

// insertAt
var root = Parser.parse('a');
root.insertAt('b', 0);
assert.equal(root, 'ba');

append

Expand

param: AstNode | string Child node to be inserted
Batch insert child nodes at the end.

// append
var root = Parser.parse('a');
root.append('b', 'c');
assert.equal(root, 'abc');

replaceChildren

Expand

param: AstNode | string New child nodes
Replace all child nodes.

// replaceChildren
var root = Parser.parse('a[[b]]');
root.replaceChildren('c', 'd');
assert.equal(root, 'cd');

setText

Expand

param: string New text
param: number Position of the text child node to be modified
returns: string
Modify the text child node.

// setText
var root = Parser.parse([[a]]b');
root.setText('c', -1);
assert.equal(root, [[a]]c');

normalize

Expand

Merge adjacent text child nodes.

// normalize
var root = Parser.parse('[[a]]');
root.append('');
assert.strictEqual(root.length, 2);
root.normalize();
assert.strictEqual(root.length, 1);
// normalize (main)
var root = Parser.parse('a');
root.prepend('b');
assert.strictEqual(root.length, 2);
root.normalize();
assert.strictEqual(root.length, 1);

matches

Expand

param: string Selector
returns: boolean
Check if it matches the selector.

// matches (main)
var {firstChild} = Parser.parse('<br/>');
assert.ok(firstChild.matches('root > :is(#br[selfClosing])'));

getElementByTypes

Expand

param: string Token types delimited by ,
returns: Token
Select by token type.

// getElementByTypes (main)
var root = Parser.parse([[a]]<i>'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.strictEqual(root.getElementByTypes('html, link'), firstChild);

getElementById

Expand

param: string id
returns: Token
Select by id.

// getElementById (main)
var root = Parser.parse('<p id=a>'),
	{firstChild} = root;
assert.equal(firstChild, '<p id=a>');
assert.strictEqual(root.getElementById('a'), firstChild);

getElementsByClassName

Expand

param: string Class name
returns: Token[]
Select by class name.

// getElementsByClassName (main)
var root = Parser.parse(`{|class="a b"
|}<p class="a c"><pre class="a d"></pre>`),
	{childNodes: [table, html, ext]} = root;
assert.equal(table, '{|class="a b"\n|}');
assert.equal(table.childNodes[1], 'class="a b"');
assert.equal(html, '<p class="a c">');
assert.equal(html.firstChild, ' class="a c"');
assert.equal(ext, '<pre class="a d"></pre>');
assert.equal(ext.firstChild, ' class="a d"');
assert.deepStrictEqual(root.getElementsByClassName('a'), [
	table,
	table.childNodes[1],
	html,
	html.firstChild,
	ext,
	ext.firstChild,
]);

getElementsByTagName

Expand

param: string Tag name
returns: Token[]
Select by tag name.

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

caretPositionFromPoint

Expand

param: number Character column
param: number Character row
returns: {offsetNode: AstNode, offset: number}
Find the given position.

// caretPositionFromPoint (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.caretPositionFromPoint(1, 0), {
	offsetNode: firstChild,
	offset: 1,
});

elementsFromIndex

Expand

param: number Character position
returns: Token[]
Find all nodes at the given position.

// elementsFromIndex (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.elementsFromIndex(1), [root, firstChild]);

elementsFromPoint

Expand

param: number Character column
param: number Character row
returns: Token[]
Find all nodes at the given position.

// elementsFromPoint (main)
var root = Parser.parse('[[a]]'),
	{firstChild} = root;
assert.equal(firstChild, '[[a]]');
assert.deepStrictEqual(root.elementsFromPoint(1, 0), [root, firstChild]);

prepend

Expand

param: AstNode | string Child nodes to be inserted
Batch insert child nodes at the beginning.

// prepend (main)
var root = Parser.parse('a');
root.prepend('b', 'c');
assert.equal(root, 'bca');

removeChild

Expand

param: AstNode Child node to be removed
Remove a child node.

// removeChild (main)
var root = Parser.parse('a[[b]]');
root.removeChild(root.firstChild);
assert.equal(root, '[[b]]');

insertBefore

Expand

param: AstNode Child node to be inserted
param: AstNode Reference node
Insert a child node before the specified position.

// insertBefore (main)
var root = Parser.parse('a');
root.insertBefore('b', root.firstChild);
assert.equal(root, 'ba');

相关软件包

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** ⚠️