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
子节点总数。在 Mini 和 Browser 版本中为只读属性。

// 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 选择器
最近的祖先节点。这是一个 TypeScript 泛型函数。

TypeScript 示例：

import type {LinkToken} from "wikiparser-node";
const {firstElementChild: link} = Parser.parse("[[a]]"),
	{firstElementChild} = link!;
firstElementChild!.closest<LinkToken>("link") satisfies LinkToken | undefined;

JavaScript 示例：

// 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
类型选择器。这是一个 TypeScript 泛型函数。

TypeScript 示例：

import type {LinkToken, HtmlToken} from "wikiparser-node";
const root = Parser.parse("[[a]]<i>");
root.getElementByTypes<LinkToken | HtmlToken>(
	"html, link",
) satisfies LinkToken | HtmlToken | undefined;

JavaScript 示例：

// 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[]
标签名选择器。这是一个 TypeScript 泛型函数。

TypeScript 示例：

import type {ExtToken} from "wikiparser-node";
const root = Parser.parse("<pre></pre>");
root.getElementsByTagName<ExtToken>("pre") satisfies ExtToken[];

JavaScript 示例：

// 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");
root = Parser.parse("a");
root.insertAt("c", -1);
assert.equal(root, "ca");
// 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 文件名
param: number 搜索深度
将语法树保存为 JSON。保存的 JSON 文件都在 WikiParser-Node 的 printed/ 路径下。

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

lint

✅ 展开

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

matches

展开

param: string 选择器
returns: boolean
检查是否符合选择器。这是一个 TypeScript 类型谓词。

TypeScript 示例：

import type {HtmlToken} from "wikiparser-node";
const {firstElementChild} = Parser.parse("<br/>");
if (firstElementChild!.matches<HtmlToken>("html")) {
	firstElementChild satisfies HtmlToken;
}

JavaScript 示例：

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

normalize

展开

合并相邻的文本子节点。

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

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 (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
符合选择器的第一个后代节点。这是一个 TypeScript 泛型函数。

TypeScript 示例：

import type {HtmlToken} from "wikiparser-node";
const root = Parser.parse("<p>");
root.querySelector<HtmlToken>("html") satisfies HtmlToken | undefined;

JavaScript 示例：

// 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[]
符合选择器的所有后代节点。这是一个 TypeScript 泛型函数。

TypeScript 示例：

import type {HtmlToken} from "wikiparser-node";
const root = Parser.parse("<p><i>");
root.querySelectorAll<HtmlToken>("html") satisfies HtmlToken[];

JavaScript 示例：

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