AstElement - bhsd-harry/wikiparser-node GitHub Wiki

目录

Other Languages

简介

AstElement 是非纯文本节点的父类，仿照 HTMLElement 类设计，属性和方法也和 HTMLElement 类非常相似。这个类继承了 AstNode 类的全部属性和方法，这里不再列出。

✅ 在 Mini 和 Browser 版本中可用。
🌐 在 Browser 版本中可用。

Properties

childElementCount

展开

type: number
非文本子节点总数，只读。

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

children

展开

type: Token[]
全部非文本子节点，只读。

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

clientHeight

展开

type: number
内部高度，仅当内部文本 innerText 属性有定义时存在，只读。

// 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(root.innerText, undefined);
assert.strictEqual(firstChild.clientHeight, 2);
assert.strictEqual(root.clientHeight, undefined);

clientWidth

展开

type: number
内部宽度，仅当内部文本 innerText 属性有定义时存在，只读。

// 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(root.innerText, undefined);
assert.strictEqual(firstChild.clientWidth, 1);
assert.strictEqual(root.clientWidth, undefined);

embeds

展开

type: Token[]
所有嵌入的模板和模块，只读。

// 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]);

firstElementChild

展开

type: Token
首位非文本子节点，只读。

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

hidden

展开

type: boolean
是否不可见，只读。

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

images

展开

type: Token[]
所有图片节点，只读。

// images (main)
var root = Parser.parse(
		[[file:a]]<gallery>b</gallery><imagemap>file:c</imagemap>',
	),
	{
		childNodes: [
			file,
			{lastChild: {firstChild: gallery}},
			{lastChild: {firstChild: imagemap}},
		],
	} = root;
assert.equal(file, '[[file:a]]');
assert.equal(gallery, 'b');
assert.equal(imagemap, 'file:c');
assert.deepStrictEqual(root.images, [file, gallery, imagemap]);

lastElementChild

展开

type: Token
末位非文本子节点，只读。

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

length

✅ 展开

type: number
子节点总数。

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

links

展开

type: Token[]
所有内链、外链、自由外链和图片链接，只读。

// links (main)
var root = Parser.parse(
		'#redirect [[x]]\n[[a]][//b]http://c PMID 1[[file:d|link=[[e]]]]',
	),
	{
		childNodes: [
			{lastChild: redirect},
			link,
			extLink,
			freeExtLink,,
			magicLink,
			{lastChild: imageLink},
		],
	} = root;
assert.equal(redirect, '[[x]]');
assert.equal(link, '[[a]]');
assert.equal(extLink, '[//b]');
assert.equal(freeExtLink, 'http://c');
assert.equal(magicLink, 'PMID 1');
assert.equal(imageLink, 'link=[[e]]');
assert.deepStrictEqual(root.links, [
	redirect,
	link,
	extLink,
	freeExtLink,
	magicLink,
	imageLink,
]);

outerText

展开

type: string
等效 text 方法的返回值，只读。

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

parentElement

展开

type: Token
父节点，即 parentNode 属性的别名，只读。

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

Methods

append

✅ 展开

param: AstNode | string 插入节点
在末尾批量插入子节点。

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

caretPositionFromIndex

✅ 展开

param: number 字符位置
returns: {offsetNode: AstNode, offset: number}
找到给定位置。

// caretPositionFromIndex
var root = Parser.parse([[a]]bb[[c]]'),
	{firstChild, lastChild} = root,
	{nextSibling, firstChild: {firstChild: target}} = firstChild;
assert.equal(firstChild, '[[a]]');
assert.equal(target, 'a');
assert.equal(nextSibling, 'bb');
assert.equal(lastChild, '[[c]]');
assert.deepStrictEqual(root.caretPositionFromIndex(1), {
	offsetNode: firstChild,
	offset: 1,
});
assert.deepStrictEqual(root.caretPositionFromIndex(2), {
	offsetNode: target,
	offset: 0,
});
assert.deepStrictEqual(root.caretPositionFromIndex(5), {
	offsetNode: firstChild,
	offset: 5,
});
assert.deepStrictEqual(root.caretPositionFromIndex(6), {
	offsetNode: nextSibling,
	offset: 1,
});
assert.deepStrictEqual(root.caretPositionFromIndex(7), {
	offsetNode: lastChild,
	offset: 0,
});
assert.deepStrictEqual(root.caretPositionFromIndex(-1), {
	offsetNode: lastChild,
	offset: 4,
});
assert.deepStrictEqual(root.caretPositionFromIndex(13), undefined);

caretPositionFromPoint

展开

param: number 字符所在列
param: number 字符所在行
returns: {offsetNode: AstNode, offset: number}
找到给定位置。

// caretPositionFromPoint (main)
var root = Parser.parse([[a]]\nb[[c]]'),
	{firstChild, lastChild} = root,
	{nextSibling, firstChild: {firstChild: target}} = firstChild;
assert.equal(firstChild, '[[a]]');
assert.equal(target, 'a');
assert.equal(nextSibling, '\nb');
assert.equal(lastChild, '[[c]]');
assert.deepStrictEqual(root.caretPositionFromPoint(1, 0), {
	offsetNode: firstChild,
	offset: 1,
});
assert.deepStrictEqual(root.caretPositionFromPoint(2, 0), {
	offsetNode: target,
	offset: 0,
});
assert.deepStrictEqual(root.caretPositionFromPoint(5, 0), {
	offsetNode: firstChild,
	offset: 5,
});
assert.deepStrictEqual(root.caretPositionFromPoint(0, 1), {
	offsetNode: nextSibling,
	offset: 1,
});
assert.deepStrictEqual(root.caretPositionFromPoint(1, 1), {
	offsetNode: lastChild,
	offset: 0,
});
assert.deepStrictEqual(root.caretPositionFromPoint(0, 2), undefined);

closest

✅ 展开

param: string 选择器
最近的祖先节点。

// 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);

elementFromIndex

✅ 展开

param: number 字符位置
returns: Token
找到给定位置所在的最外层节点。

// elementFromIndex
var root = Parser.parse([[a]]bb'),
	{firstChild, lastChild} = root,
	{firstChild: target} = firstChild;
assert.equal(firstChild, '[[a]]');
assert.equal(target, 'a');
assert.equal(lastChild, 'bb');
assert.strictEqual(root.elementFromIndex(1), firstChild);
assert.strictEqual(root.elementFromIndex(2), target);
assert.strictEqual(root.elementFromIndex(6), root);

elementFromPoint

✅ 展开

param: number 字符所在列
param: number 字符所在行
returns: Token
找到给定位置所在的最外层节点。

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

elementsFromIndex

展开

param: number 字符位置
returns: Token[]
找到给定位置所在的所有节点。

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

elementsFromPoint

展开

param: number 字符行
param: number 字符列
returns: Token[]
找到给定位置所在的所有节点。

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

getElementById

展开

param: string id 名
returns: Token
id 选择器。

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

getElementByTypes

展开

param: string 以,分隔的节点类型
returns: Token
类型选择器。

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

getElementsByClassName

展开

param: string 类名之一
returns: Token[]
类选择器。

// 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

展开

param: string 标签名
returns: Token[]
标签名选择器。

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

insertAt

✅ 展开

param: AstNode | string 待插入的子节点
param: number 插入位置
returns: AstNode
插入子节点。

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

insertBefore

展开

param: AstNode 插入节点
param: AstNode 指定位置处的子节点
在指定位置前插入子节点。

// insertBefore (main)
var root = Parser.parse('a');
root.insertBefore('b');
assert.equal(root, 'ab');
root.insertBefore('c', root.lastChild);
assert.equal(root, 'acb');

json

🌐 展开

param: string 文件名
将语法树保存为 JSON。保存的 JSON 文件都在 WikiParser-Node 的 printed/ 路径下。

// 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 ',
				},
			],
		},
	],
});

lint

✅ 展开

returns: LintError[] & {output?: string}
报告潜在语法错误，详见各类型节点的文档。

matches

展开

param: string 选择器
returns: boolean
检查是否符合选择器。

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

normalize

展开

合并相邻的文本子节点。

// 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);

prepend

展开

param: AstNode | string 插入节点
在开头批量插入子节点。

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

print

🌐 展开

returns: string
以HTML格式输出，详见各类型节点的文档。

// print
var {firstChild} = Parser.parse('<!-- a -->');
assert.equal(firstChild, '<!-- a -->');
assert.strictEqual(
	firstChild.print(),
	'<span class="wpb-comment">&lt;!-- a --&gt;</span>',
);

querySelector

✅ 展开

param: string 选择器
returns: Token
符合选择器的第一个后代节点。

// querySelector
var root = Parser.parse('a<p><i>'),
	[, p] = root.childNodes;
assert.equal(p, '<p>');
assert.strictEqual(root.querySelector('html'), p);

querySelectorAll

✅ 展开

param: string 选择器
returns: Token[]
符合选择器的所有后代节点。

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

removeAt

✅ 展开

param: number 移除位置
returns: AstNode
移除子节点。

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

removeChild

展开

param: AstNode 子节点
移除子节点。

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

replaceChildren

展开

param: AstNode | string 新的子节点
批量替换子节点。

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

setText

✅ 展开

param: string 新文本
param: number 文本子节点位置
returns: string
修改文本子节点。

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

text

✅ 展开

returns: string
可见部分，详见各类型节点的文档。

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

相关软件包

WikiLint

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

WikiParser-Template

轻量级的维基模板解析器

Wikitext-LSP

维基文本语言服务器协议实现

WikiParser Language Server

用于维基文本的 VS Code 扩展

Related Packages

WikiLint

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

WikiParser-Template

A lightweight Wikitext template parser

Wikitext-LSP

An implementation of the Language Server Protocol for Wikitext

WikiParser Language Server

VS Code extension for Wikitext

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