AstNode - bhsd-harry/wikiparser-node GitHub Wiki

目录

Other Languages

简介

AstNode 是所有纯文本节点和其他节点的父类，仿照 Node 类设计，属性和方法也和 Node 类非常相似。

✅ 在 Mini 和 Browser 版本中可用。

Properties

bold

展开

加入的版本：1.8.0

type: boolean
是否粗体。

// bold (main)
var {lastChild} = Parser.parse("'''a\nc[[d]]"),
	{previousSibling} = lastChild,
	firstChild;
assert.equal(lastChild, "[[d]]");
assert.equal(previousSibling, "a\nc");
assert.ok(!lastChild.bold);
assert.ok(previousSibling.bold);
({lastChild} = Parser.parse("<b>'''<b></b></b>x"));
assert.equal(lastChild, "x");
assert.ok(!lastChild.bold);
({lastChild} = Parser.parse("'''[//a b'''c]d"));
({previousSibling: {lastChild: {firstChild}}} = lastChild);
assert.equal(lastChild, "d");
assert.equal(firstChild, "b");
assert.ok(!lastChild.bold);
assert.ok(firstChild.bold);

childNodes

✅ 展开

type: AstNode[]
全部子节点构成的数组，只读。

// childNodes
var root = Parser.parse("[[a]]b"),
	{firstChild, lastChild} = root;
assert.equal(firstChild, "[[a]]");
assert.equal(lastChild, "b");
assert.deepStrictEqual(root.childNodes, [firstChild, lastChild]);
assert.deepStrictEqual(lastChild.childNodes, []);

eof

展开

type: boolean
后方是否还有其他节点（不含后代），只读。

// eof (main)
var root = Parser.parse("a[[b]]\n"),
	{firstChild, firstElementChild} = root,
	{lastChild} = firstElementChild;
assert.equal(firstChild, "a");
assert.equal(firstElementChild, "[[b]]");
assert.equal(lastChild, "b");
assert.ok(root.eof);
assert.ok(!firstChild.eof);
assert.ok(firstElementChild.eof); // 忽略末尾的空白字符
assert.ok(lastChild.eof);

firstChild

✅ 展开

type: AstNode
首位子节点，只读。

// firstChild
var root = Parser.parse("a"),
	{firstChild} = root;
assert.equal(firstChild, "a");
assert.strictEqual(firstChild.firstChild, undefined);

font

展开

加入的版本：1.8.0

type: {bold: boolean, italic: boolean}
字体样式。

// font (main)
var {lastChild} = Parser.parse("'''''a'''{{b}}\nc[[d]]"),
	{previousSibling, previousElementSibling: {firstChild}} = lastChild;
assert.equal(lastChild, "[[d]]");
assert.equal(previousSibling, "\nc");
assert.equal(firstChild, "b");
assert.deepStrictEqual(lastChild.font, {
	italic: false,
	bold: false,
});
assert.deepStrictEqual(previousSibling.font, {
	italic: true,
	bold: false,
});
assert.deepStrictEqual(firstChild.font, {
	italic: false,
	bold: false,
});
({lastChild} = Parser.parse("<i>'''''<b></b></i>x"));
assert.equal(lastChild, "x");
assert.deepStrictEqual(lastChild.font, {
	italic: false,
	bold: true,
});
({lastChild} = Parser.parse("'''''[//a b''c]d"));
({previousSibling: {lastChild: {firstChild}}} = lastChild);
assert.equal(lastChild, "d");
assert.equal(firstChild, "b");
assert.deepStrictEqual(lastChild.font, {
	italic: false,
	bold: true,
});
assert.deepStrictEqual(firstChild.font, {
	italic: true,
	bold: true,
});

isConnected

展开

type: boolean
是否具有根节点，只读。

// isConnected (main)
var root = Parser.parse("a"),
	{firstChild} = root;
assert.ok(root.isConnected);
assert.ok(firstChild.isConnected);
firstChild.remove();
assert.ok(!firstChild.isConnected);
root.append(firstChild);
assert.ok(firstChild.isConnected);

italic

展开

加入的版本：1.8.0

type: boolean
是否斜体。

// italic (main)
var {lastChild} = Parser.parse("''a\nc[[d]]"),
	{previousSibling} = lastChild,
	firstChild;
assert.equal(lastChild, "[[d]]");
assert.equal(previousSibling, "a\nc");
assert.ok(!lastChild.italic);
assert.ok(previousSibling.italic);
({lastChild} = Parser.parse("<i>''<i></i></i>x"));
assert.equal(lastChild, "x");
assert.ok(!lastChild.italic);
({lastChild} = Parser.parse("''[//a b''c]d"));
({previousSibling: {lastChild: {firstChild}}} = lastChild);
assert.equal(lastChild, "d");
assert.equal(firstChild, "b");
assert.ok(!lastChild.italic);
assert.ok(firstChild.italic);

lastChild

✅ 展开

type: AstNode
末位子节点，只读。

// lastChild
var root = Parser.parse("a"),
	{lastChild} = root;
assert.equal(lastChild, "a");
assert.strictEqual(lastChild.lastChild, undefined);

nextElementSibling

展开

type: Token
后一个非文本兄弟节点，只读。

// nextElementSibling (main)
var {childNodes: [a, b, c]} = Parser.parse("[[a]]b{{c}}");
assert.equal(a, "[[a]]");
assert.equal(b, "b");
assert.equal(c, "{{c}}");
assert.strictEqual(a.nextElementSibling, c);
assert.strictEqual(b.nextElementSibling, c);
assert.strictEqual(c.nextElementSibling, undefined);

nextSibling

✅ 展开

type: AstNode
后一个兄弟节点，只读。

// nextSibling
var {firstChild, lastChild} = Parser.parse("[[a]]b");
assert.equal(firstChild, "[[a]]");
assert.equal(lastChild, "b");
assert.strictEqual(firstChild.nextSibling, lastChild);
assert.strictEqual(lastChild.nextSibling, undefined);

nextVisibleSibling

展开

type: AstNode
后一个可见的兄弟节点，只读。

// nextVisibleSibling (main)
var {firstChild, lastChild} = Parser.parse("[[a]]<!--b--><noinclude>c");
assert.equal(firstChild, "[[a]]");
assert.equal(lastChild, "c");
assert.strictEqual(firstChild.nextVisibleSibling, lastChild);

offsetHeight

✅ 展开

type: number
行数，只读。

// offsetHeight
var root = Parser.parse("a\nb");
assert.strictEqual(root.offsetHeight, 2);

offsetLeft

展开

type: number
相对于父容器的列号（从 0 开始计数），只读。

// offsetLeft (main)
var root = Parser.parse("[[a]]\nb"),
	{firstChild, lastChild} = root;
assert.equal(firstChild, "[[a]]");
assert.strictEqual(root.offsetLeft, 0);
assert.strictEqual(firstChild.offsetLeft, 0);
assert.strictEqual(lastChild.offsetLeft, 5);

offsetTop

展开

type: number
相对于父容器的行号（从 0 开始计数），只读。

// offsetTop (main)
var root = Parser.parse("a\n[[b]]"),
	{firstChild, lastChild} = root;
assert.equal(lastChild, "[[b]]");
assert.strictEqual(root.offsetTop, 0);
assert.strictEqual(firstChild.offsetTop, 0);
assert.strictEqual(lastChild.offsetTop, 1);

offsetWidth

✅ 展开

type: number
最后一行的列数，只读。

// offsetWidth
var root = Parser.parse("ab\nc");
assert.strictEqual(root.offsetWidth, 1);

parentNode

✅ 展开

type: Token
父节点，只读。

// parentNode
var root = Parser.parse("a"),
	{firstChild} = root;
assert.equal(firstChild, "a");
assert.strictEqual(firstChild.parentNode, root);
assert.strictEqual(root.parentNode, undefined);

previousElementSibling

展开

type: Token
前一个非文本兄弟节点，只读。

// previousElementSibling (main)
var {childNodes: [a, b, c]} = Parser.parse("[[a]]b{{c}}");
assert.equal(a, "[[a]]");
assert.equal(b, "b");
assert.equal(c, "{{c}}");
assert.strictEqual(c.previousElementSibling, a);
assert.strictEqual(b.previousElementSibling, a);
assert.strictEqual(a.previousElementSibling, undefined);

previousSibling

✅ 展开

type: AstNode
前一个兄弟节点，只读。

// previousSibling
var {firstChild, lastChild} = Parser.parse("[[a]]b");
assert.equal(firstChild, "[[a]]");
assert.equal(lastChild, "b");
assert.strictEqual(lastChild.previousSibling, firstChild);
assert.strictEqual(firstChild.previousSibling, undefined);

previousVisibleSibling

展开

type: AstNode
前一个可见的兄弟节点，只读。

// previousVisibleSibling (main)
var {firstChild, lastChild} = Parser.parse("a<!--b--><noinclude>{{c}}");
assert.equal(firstChild, "a");
assert.equal(lastChild, "{{c}}");
assert.strictEqual(lastChild.previousVisibleSibling, firstChild);

style

展开

type: {top: number, left: number, height: number, width: number, padding: number}
位置、大小和 padding，只读。

// style (main)
var root = Parser.parse("a\n[[b]]"),
	{firstChild, lastChild} = root;
assert.equal(lastChild, "[[b]]");
assert.deepStrictEqual(root.style, {
	top: 0,
	left: 0,
	height: 2,
	width: 5,
	padding: 0,
});
assert.deepStrictEqual(firstChild.style, {
	top: 0,
	left: 0,
	height: 2,
	width: 0,
	padding: 0,
});
assert.deepStrictEqual(lastChild.style, {
	top: 1,
	left: 0,
	height: 1,
	width: 5,
	padding: 2, // `[[`
});

Methods

addEventListener

展开

param: string | string[] 事件类型
param: Function 监听函数
param: {once?: boolean} 选项
添加事件监听。需搭配 dispatchEvent 方法使用。

// addEventListener (main)
var root = Parser.parse(""),
	counter = 0;
var listener = (_, data) => {
	counter += data;
};
root.addEventListener("x", listener);
root.addEventListener("y", listener, {once: true});
root.dispatchEvent(new Event("x"), 1);
assert.strictEqual(counter, 1);
root.dispatchEvent(new Event("x"), 2);
assert.strictEqual(counter, 3);
root.dispatchEvent(new Event("y"), 3);
assert.strictEqual(counter, 6);
root.dispatchEvent(new Event("y"), 4);
assert.strictEqual(counter, 6);

after

展开

param: AstNode | string 插入节点
在后方批量插入兄弟节点。

// after (main)
var root = Parser.parse("a"),
	{firstChild} = root;
firstChild.after("b", "c");
assert.equal(root, "abc");

before

展开

param: AstNode | string 插入节点
在前方批量插入兄弟节点。

// before (main)
var root = Parser.parse("a"),
	{firstChild} = root;
firstChild.before("b", "c");
assert.equal(root, "bca");

compareDocumentPosition

展开

param: AstNode
returns: number
比较和另一个节点的相对位置。

// compareDocumentPosition (main)
var root = Parser.parse("[[a]]b"),
	{firstElementChild, lastChild} = root,
	{firstChild} = firstElementChild;
assert.equal(firstElementChild, "[[a]]");
assert.equal(firstChild, "a");
assert.strictEqual(root.compareDocumentPosition(root), 0);
assert.ok(root.compareDocumentPosition(firstChild) < 0);
assert.ok(firstChild.compareDocumentPosition(root) > 0);
assert.ok(firstElementChild.compareDocumentPosition(lastChild) < 0);
assert.ok(lastChild.compareDocumentPosition(firstElementChild) > 0);
assert.ok(firstChild.compareDocumentPosition(lastChild) < 0);
assert.ok(lastChild.compareDocumentPosition(firstChild) > 0);

contains

展开

param: AstNode 待检测节点
是否是自身或后代节点。

// contains (main)
var root = Parser.parse("a"),
	{firstChild} = root;
assert.ok(root.contains(root));
assert.ok(root.contains(firstChild));
assert.ok(!firstChild.contains(root));

destroy

展开

销毁节点。会连锁销毁所有祖先节点，所以使用前请先使用 remove 方法从父节点上剥离。

// destroy (main)
var root = Parser.parse("[[a]]"),
	{firstChild} = root;
root.destroy();
assert.strictEqual(firstChild.parentNode, undefined);
assert.strictEqual(root.firstChild, undefined);

dispatchEvent

展开

param: Event 事件对象
param: any 事件数据
触发事件。

// dispatchEvent (main)
var root = Parser.parse("a"),
	{firstChild} = root,
	record = "";
var listener = ({target, currentTarget, prevTarget}) => {
	record += `${target.type} ${currentTarget.type} ${prevTarget?.type}\n`;
};
root.addEventListener("x", listener);
firstChild.addEventListener("x", listener, {once: true});
firstChild.dispatchEvent(new Event("x"));
assert.strictEqual(record, "text text undefined\n");
firstChild.dispatchEvent(new Event("x", {bubbles: true}));
assert.strictEqual(record, "text text undefined\ntext root text\n");
firstChild.dispatchEvent(new Event("x", {bubbles: true}));
assert.strictEqual(
	record,
	"text text undefined\ntext root text\ntext root text\n",
);

getAbsoluteIndex

✅ 展开

returns: number
获取当前节点的绝对位置。

// getAbsoluteIndex
var root = Parser.parse("a[[b]]"),
	{lastChild} = root,
	{firstChild} = lastChild;
assert.equal(lastChild, "[[b]]");
assert.equal(firstChild, "b");
assert.strictEqual(root.getAbsoluteIndex(), 0);
assert.strictEqual(lastChild.getAbsoluteIndex(), 1);
assert.strictEqual(firstChild.getAbsoluteIndex(), 3);

getAncestors

展开

returns: Token[]
获取所有祖先节点（自下而上）。

// getAncestors (main)
var root = Parser.parse("[[a]]"),
	{firstChild} = root,
	{lastChild} = firstChild;
assert.equal(firstChild, "[[a]]");
assert.equal(lastChild, "a");
assert.deepStrictEqual(root.getAncestors(), []);
assert.deepStrictEqual(firstChild.getAncestors(), [root]);
assert.deepStrictEqual(lastChild.getAncestors(), [firstChild, root]);

getBoundingClientRect

✅ 展开

returns: {top: number, left: number, height: number, width: number}
获取当前节点的行列位置和大小。

// getBoundingClientRect
var root = Parser.parse("a\n[[b]]"),
	{firstChild, lastChild} = root;
assert.equal(lastChild, "[[b]]");
assert.deepStrictEqual(root.getBoundingClientRect(), {
	top: 0,
	left: 0,
	height: 2,
	width: 5,
});
assert.deepStrictEqual(firstChild.getBoundingClientRect(), {
	top: 0,
	left: 0,
	height: 2,
	width: 0,
});
assert.deepStrictEqual(lastChild.getBoundingClientRect(), {
	top: 1,
	left: 0,
	height: 1,
	width: 5,
});

getLine

展开

param: number 行号
returns: string
获取某一行的源文本。

// getLine (main)
assert.strictEqual(Parser.parse("a\nb").getLine(0), "a");
assert.strictEqual(Parser.parse("a\nb").getLine(2), undefined);

getLines

✅ 展开

加入的版本：1.16.3

returns: [string, number, number]
获取每一行的源文本和起止位置。

// getLines
assert.deepStrictEqual(
	Parser.parse("a\nb").getLines(),
	[
		["a", 0, 1],
		["b", 2, 3],
	],
);

getRelativeIndex

✅ 展开

returns: number
获取指定子节点（或当前节点自身）相对于其父节点的字符位置。

// getRelativeIndex
var root = Parser.parse("a[[b]]"),
	{lastChild} = root,
	{firstChild} = lastChild;
assert.equal(lastChild, "[[b]]");
assert.equal(firstChild, "b");
assert.strictEqual(root.getRelativeIndex(), 0);
assert.strictEqual(root.getRelativeIndex(0), 0);
assert.strictEqual(root.getRelativeIndex(1), 1);
assert.strictEqual(root.getRelativeIndex(2), 6);
assert.strictEqual(root.getRelativeIndex(-1), 1);
assert.strictEqual(root.getRelativeIndex(-2), 0);
assert.strictEqual(lastChild.getRelativeIndex(), 1);
assert.strictEqual(lastChild.getRelativeIndex(0), 2);
// delimiter `|` is required to append a second child node
assert.strictEqual(lastChild.getRelativeIndex(1), 4);
assert.strictEqual(firstChild.getRelativeIndex(), 2);
assert.strictEqual(firstChild.getRelativeIndex(0), 0);

getRootNode

✅ 展开

returns: Token
获取根节点。

// getRootNode
var root = Parser.parse("[[a]]"),
	{firstChild: {firstChild}} = root;
assert.equal(firstChild, "a");
assert.strictEqual(firstChild.getRootNode(), root);
assert.strictEqual(root.getRootNode(), root);

indexFromPos

✅ 展开

param: number 行号
param: number 列号
returns: number
将字符位置转换为行列号。

// indexFromPos
var root = Parser.parse("a\nb");
assert.strictEqual(root.indexFromPos(0, 0), 0);
assert.strictEqual(root.indexFromPos(0, 1), 1);
assert.strictEqual(root.indexFromPos(1, 0), 2);
assert.strictEqual(root.indexFromPos(1, 1), 3);
assert.strictEqual(root.indexFromPos(2, 0), undefined);
assert.strictEqual(root.indexFromPos(-1, 0), undefined);
assert.strictEqual(root.indexFromPos(0, -1), undefined);
assert.strictEqual(root.indexFromPos(0, 2), undefined);

is

✅ 展开

加入的版本：1.10.0

param: string 节点类型
returns: boolean
判断是否是指定类型的节点。这是一个 TypeScript 类型谓词。

TypeScript 示例：

import type {LinkToken} from "wikiparser-node";
const {firstChild} = Parser.parse("[[a]]");
if (firstChild!.is<LinkToken>("link")) {
	firstChild satisfies LinkToken;
}

JavaScript 示例：

// is
var root = Parser.parse("a");
assert.ok(root.is("root"));
assert.ok(!root.firstChild.is("link"));

isEqualNode

展开

param: AstNode 待比较的节点
returns: boolean
是否是全同节点。

// isEqualNode (main)
var a = Parser.parse("[[a]]"),
	b = Parser.parse("[[a]]").firstChild,
	c = Parser.parse("[[ a]]").firstChild,
	d = a.firstChild,
	e = Parser.parse("<!--[[a]]-->").firstChild.firstChild,
	f = Parser.parse("[[a]]", true).firstChild;
assert.equal(d, "[[a]]");
assert.equal(e, "[[a]]");
assert.ok(!d.isEqualNode(a));
assert.ok(d.isEqualNode(b));
assert.ok(!d.isEqualNode(c));
assert.ok(!d.isEqualNode(e));
assert.ok(d.isEqualNode(f));

listEventListeners

展开

param: string 事件类型
列举事件监听。

// listEventListeners (main)
var {firstChild} = Parser.parse("[[a]]"),
	listeners = firstChild.listEventListeners("remove"),
	f = () => {};
assert.strictEqual(listeners.length, 1);
assert.strictEqual(listeners[0].name, "linkListener"); // 解析器预置的监听函数
firstChild.addEventListener("remove", f);
listeners = firstChild.listEventListeners("remove");
assert.strictEqual(listeners.length, 2);
assert.strictEqual(listeners[1], f);

posFromIndex

✅ 展开

param: number 字符位置
returns: {top: number, left: number}
将字符位置转换为行列号。

// posFromIndex
var root = Parser.parse("a\nb");
assert.deepStrictEqual(root.posFromIndex(3), {top: 1, left: 1});
assert.deepStrictEqual(root.posFromIndex(-1), {top: 1, left: 0});
assert.strictEqual(root.posFromIndex(4), undefined);

remove

展开

param: boolean 是否删除所在的空行，可选
移除当前节点。

// remove (main)
var root = Parser.parse("x\n[[a|b]]\n\ny"),
	{firstElementChild} = root,
	{lastChild} = firstElementChild;
assert.equal(firstElementChild, "[[a|b]]");
assert.equal(lastChild, "b");
lastChild.remove();
assert.equal(firstElementChild, "[[a]]");
firstElementChild.remove(true);
assert.equal(root, "x\n\ny");

removeAllEventListeners

展开

param: string | string[] 事件类型
移除事件的所有监听。

// removeAllEventListeners (main)
var root = Parser.parse(""),
	counter = 0;
var f = () => {
	counter++;
};
var g = () => {
	counter += 2;
};
root.addEventListener("x", f);
root.addEventListener("x", g);
root.addEventListener("y", f);
root.addEventListener("z", g);
root.dispatchEvent(new Event("x"));
assert.strictEqual(counter, 3);
root.dispatchEvent(new Event("y"));
assert.strictEqual(counter, 4);
root.dispatchEvent(new Event("z"));
assert.strictEqual(counter, 6);
root.removeAllEventListeners("x");
root.dispatchEvent(new Event("x"));
assert.strictEqual(counter, 6);
root.dispatchEvent(new Event("y"));
assert.strictEqual(counter, 7);
root.dispatchEvent(new Event("z"));
assert.strictEqual(counter, 9);
root.removeAllEventListeners(["y", "z"]);
root.dispatchEvent(new Event("y"));
root.dispatchEvent(new Event("z"));
assert.strictEqual(counter, 9);

removeEventListener

展开

param: string | string[] 事件类型
param: Function 监听函数
移除事件监听。

// removeEventListener (main)
var root = Parser.parse(""),
	counter = 0;
var listener = () => {
	counter++;
};
root.addEventListener("x", listener);
root.addEventListener("y", listener);
root.addEventListener("z", listener);
root.dispatchEvent(new Event("x"));
assert.strictEqual(counter, 1);
root.dispatchEvent(new Event("y"));
assert.strictEqual(counter, 2);
root.dispatchEvent(new Event("z"));
assert.strictEqual(counter, 3);
root.removeEventListener("x", listener);
root.dispatchEvent(new Event("x"));
assert.strictEqual(counter, 3);
root.dispatchEvent(new Event("y"));
assert.strictEqual(counter, 4);
root.dispatchEvent(new Event("z"));
assert.strictEqual(counter, 5);
root.removeEventListener(["y", "z"], listener);
root.dispatchEvent(new Event("y"));
root.dispatchEvent(new Event("z"));
assert.strictEqual(counter, 5);

replaceWith

展开

param: AstNode | string 插入节点
将当前节点批量替换为新的节点。

// replaceWith (main)
var root = Parser.parse("a"),
	{firstChild} = root;
firstChild.replaceWith("b", "c");
assert.equal(root, "bc");

相关软件包

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