Token - bhsd-harry/wikiparser-node GitHub Wiki

目录

Other Languages

简介

这是所有特定维基语法对应节点的父类。Token 类的父类 AstElement 是仿照 HTMLElement 类设计的。本页面仅介绍 Token 类新增的属性和方法。

✅ 在 Mini 和 Browser 版本中可用。

Properties

从 AstElement 继承的属性

从 AstNode 继承的属性

pageName

✅ 展开

加入的版本：1.29.0

type: string | undefined
与节点关联的页面名称。如果未设置页面名称则为 undefined。

// pageName
var root = Parser.parse('');
assert.strictEqual(root.pageName, undefined);
root.pageName = 'help:wiki parser#fragment';
assert.strictEqual(root.pageName, 'Help:Wiki_parser');
root.pageName = '|';
assert.strictEqual(root.pageName, undefined);
root.pageName = '';
assert.strictEqual(root.pageName, '');
root.pageName = undefined;
assert.strictEqual(root.pageName, undefined);

type

✅ 展开

type: string
节点类型。

// type
var root = Parser.parse('');
assert.strictEqual(root.type, 'root');
root.type = 'plain';
assert.strictEqual(root.type, 'plain');

Methods

从 AstElement 继承的方法

从 AstNode 继承的方法

buildLists

展开

加入的版本：1.17.1

构建所有 list-range 节点。

// buildLists (main)
var root = Parser.parse(';*#;a:b:c');
root.buildLists();
assert.deepStrictEqual(root.json(), {
	range: [0, 9],
	type: 'root',
	childNodes: [
		{
			range: [0, 3],
			type: 'list',
			childNodes: [
				{
					range: [0, 3],
					data: ';*#',
				},
			],
		},
		{
			range: [3, 7],
			type: 'list-range',
			childNodes: [
				{
					range: [3, 4],
					type: 'list',
					childNodes: [
						{
							range: [3, 4],
							data: ';',
						},
					],
				},
				{
					range: [4, 5],
					type: 'list-range',
					childNodes: [
						{
							range: [4, 5],
							data: 'a',
						},
					],
				},
				{
					range: [5, 6],
					type: 'dd',
					indent: 1,
					childNodes: [
						{
							range: [5, 6],
							data: ':',
						},
					],
				},
				{
					range: [6, 7],
					type: 'list-range',
					childNodes: [
						{
							range: [6, 7],
							data: 'b',
						},
					],
				},
			],
		},
		{
			range: [7, 8],
			type: 'dd',
			indent: 1,
			childNodes: [
				{
					range: [7, 8],
					data: ':',
				},
			],
		},
		{
			range: [8, 9],
			type: 'list-range',
			childNodes: [
				{
					range: [8, 9],
					data: 'c',
				},
			],
		},
	],
});

cloneNode

展开

returns: this
深拷贝节点。不同类型的节点采用了不同的深拷贝算法。

// cloneNode (main)
var token = Parser.parse('<ref>a[[b]]</ref>').querySelector('ext-inner'),
	cloned;
token.pageName = 'A';
cloned = token.cloneNode();
assert.strictEqual(cloned.type, token.type);
assert.strictEqual(cloned.name, token.name);
assert.strictEqual(cloned.pageName, token.pageName);
assert.deepStrictEqual(cloned, token);

createComment

展开

param: string 注释内容
returns: CommentToken
生成一个 HTML 注释。

// createComment (main)
var root = Parser.parse('');
assert.equal(root.createComment('a-->'), '<!--a--&gt;-->');
assert.equal(root.createComment(), '<!---->');

createElement

展开

param: string 标签名
param: {closing?: boolean, selfClosing?: boolean} 选项
returns: Token
生成一个 HTML 标签或扩展标签。

// createElement (main)
var root = Parser.parse('');
assert.equal(
	root.createElement('includeonly'),
	'<includeonly></includeonly>',
);
assert.equal(
	root.createElement('includeonly', {selfClosing: true}),
	'<includeonly/>',
);
assert.equal(
	root.createElement('REF'),
	'<ref></ref>',
);
assert.equal(
	root.createElement('ref', {selfClosing: true}),
	'<ref/>',
);
assert.equal(
	root.createElement('li'),
	'<li>',
);
assert.equal(
	root.createElement('li', {closing: true}),
	'</li>',
);
assert.equal(
	root.createElement('li', {selfClosing: true}),
	'<li/>',
);

createRange

展开

returns: AstRange
生成一个 AstRange 对象。

// createRange (main)
var root = Parser.parse('text'),
	{firstChild} = root,
	range = root.createRange();
range.setStart(firstChild, 1);
range.setEnd(firstChild, 3);
assert.equal(range, 'ex');

createTextNode

展开

param: string
returns: AstText
生成一个纯文本节点。

// createTextNode (main)
var root = Parser.parse(''),
	text = root.createTextNode('a');
assert.strictEqual(text.type, 'text');
assert.strictEqual(text.data, 'a');
text = root.createTextNode();
assert.strictEqual(text.type, 'text');
assert.strictEqual(text.data, '');

expand

展开

加入的版本：1.10.0

returns: Token
展开模板和部分魔术字。

// expand (main)
var root, copy;
Parser.templates.set(
	'Template:Link_start',
	`[[{{{1|<noinclude>Template:Link start]]</noinclude>}}}<noinclude>
{{doc}}</noinclude>`,
);
root = Parser.parse('{{link start|a}}b|c]]');
copy = root.expand();
assert.deepStrictEqual(copy.childNodes.map(({type}) => type), ['link']);
assert.equal(copy, '[[ab|c]]');

findEnclosingHtml

展开

param: string HTML 标签名（可省略）
returns: AstRange | undefined
获取指定的外层HTML标签。注意纯文本节点无法使用此方法。

// findEnclosingHtml (main)
var root = Parser.parse('<p><b><li/><br><i>{{{|[[a]]}}}</b></p>'),
	arg = root.querySelector('arg'),
	link = arg.querySelector('link');
assert.equal(arg, '{{{|[[a]]}}}');
assert.equal(link, '[[a]]');
assert.strictEqual(root.findEnclosingHtml(), undefined);
assert.equal(
	arg.findEnclosingHtml(),
	'<b><li/><br><i>{{{|[[a]]}}}</b>',
);
assert.equal(
	arg.findEnclosingHtml('p'),
	'<p><b><li/><br><i>{{{|[[a]]}}}</b></p>',
);
assert.equal(
	link.findEnclosingHtml(),
	'<b><li/><br><i>{{{|[[a]]}}}</b>',
);
assert.equal(
	link.findEnclosingHtml('p'),
	'<p><b><li/><br><i>{{{|[[a]]}}}</b></p>',
);

flatten

展开

合并普通节点的普通子节点。

// flatten (main)
var root = Parser.parse(''),
	plain = Parser.parse('a'),
	{firstChild} = plain;
root.append(plain);
root.flatten();
assert.strictEqual(root.lastChild, firstChild);

getCategories

展开

returns: [string, string | undefined][]
获取全部分类及其排序关键词。

// getCategories (main)
assert.deepStrictEqual(
	Parser.parse([[category:a]][[category:b|c]]').getCategories(),
	[
		['Category:A', undefined],
		['Category:B', 'c'],
	],
);

isInterwiki

展开

param: string 链接标题
returns: RegExpExecArray | null
类似 Parser.isInterwiki 方法，但使用与当前节点相同的解析设置。

lint

✅ 展开

returns: LintError[]
报告潜在语法错误。

// lint
var root = Parser.parse(`<br id=a>
<pre id=a/>
{|id=a
|}`);
assert.deepStrictEqual(root.lint(), [
	{
		rule: 'no-duplicate',
		severity: 'warning',
		message: 'duplicate HTML id',
		startLine: 0,
		startCol: 4,
		startIndex: 4,
		endLine: 0,
		endCol: 8,
		endIndex: 8,
	},
	{
		rule: 'no-duplicate',
		severity: 'warning',
		message: 'duplicate HTML id',
		startLine: 1,
		startCol: 5,
		startIndex: 15,
		endLine: 1,
		endCol: 9,
		endIndex: 19,
	},
	{
		rule: 'no-duplicate',
		severity: 'warning',
		message: 'duplicate HTML id',
		startLine: 2,
		startCol: 2,
		startIndex: 24,
		endLine: 2,
		endCol: 6,
		endIndex: 28,
	},
]);
root = Parser.parse([[category:a]][[category:a|b]]');
assert.deepStrictEqual(root.lint(), [
	{
		rule: 'no-duplicate',
		severity: 'warning',
		message: 'duplicate category',
		startLine: 0,
		startCol: 0,
		startIndex: 0,
		endLine: 0,
		endCol: 14,
		endIndex: 14,
		suggestions: [
			{
				range: [0, 14],
				text: '',
				desc: 'remove',
			},
		],
	},
	{
		rule: 'no-duplicate',
		severity: 'warning',
		message: 'duplicate category',
		startLine: 0,
		startCol: 14,
		startIndex: 14,
		endLine: 0,
		endCol: 30,
		endIndex: 30,
		suggestions: [
			{
				range: [14, 30],
				text: '',
				desc: 'remove',
			},
		],
	},
]);
root = Parser.parse(`<!-- lint-disable no-duplicate -->
[[category:a]][[category:a]]
<!-- lint-enable no-duplicate -->
<a> <!-- lint-disable-line -->
<!-- lint-disable-next-line no-duplicate, tag-like -->
[[category:a]][[category:a]]<a>`);
assert.deepStrictEqual(root.lint(), []);
Parser.lintConfig = {computeEditInfo: false};
root = Parser.parse([[category:a]][[category:a]]');
assert.deepStrictEqual(root.lint(), [
	{
		rule: 'no-duplicate',
		severity: 'warning',
		message: 'duplicate category',
		startLine: 0,
		startCol: 0,
		startIndex: 0,
		endLine: 0,
		endCol: 14,
		endIndex: 14,
	},
	{
		rule: 'no-duplicate',
		severity: 'warning',
		message: 'duplicate category',
		startLine: 0,
		startCol: 14,
		startIndex: 14,
		endLine: 0,
		endCol: 28,
		endIndex: 28,
	},
]);
Parser.lintConfig = {fix: true};
root = Parser.parse('</br>');
assert.strictEqual(root.lint().output, '<br>');

normalizeTitle

✅ 展开

param: string 标题（含或不含命名空间前缀）
param: number 命名空间，默认为 0
returns: Title
规范化页面标题。

// normalizeTitle
var root = Parser.parse(''),
	title;
root.pageName = 'Help:A/1';
title = root.normalizeTitle('../2');
assert.strictEqual(title.title, 'Help:A/2');

safeReplaceWith

展开

param: this 待替换的节点
一些具有特殊语法作用的节点只能使用这个方法替换为同类节点。注意需要使用这个方法的场合一般也需要搭配 AstNode.prototype.destroy 方法。

// safeReplaceWith (main)
var {firstChild, lastChild: {lastChild}} = Parser.parse('<p><p lang="zh">'),
	attrs = lastChild.cloneNode(),
	error;
assert.equal(firstChild, '<p>');
assert.equal(lastChild, ' lang="zh"');
assert.equal(attrs, ' lang="zh"');
try {
	firstChild.lastChild.replaceWith(attrs);
} catch (e) {
	error = e;
}
assert.ok(error instanceof Error);
assert.equal(error.message, 'HtmlToken cannot insert child nodes!');
firstChild.lastChild.safeReplaceWith(attrs);

section

展开

param: number 章节序号
returns: AstRange
获取指定章节。只可用于根节点。

// section (main)
var root = Parser.parse('a\n==1==\nb\n===2===\nc\n==3==\nd');
assert.equal(root.section(0), 'a\n');
assert.equal(root.section(1), '==1==\nb\n===2===\nc\n');
assert.equal(root.section(2), '===2===\nc\n');
assert.equal(root.section(3), '==3==\nd');

root = Parser.parse('a');
assert.equal(root.section(0), 'a');

sections

展开

returns: AstRange[]
获取全部章节（含序言），每个章节均是一个数组。只可用于根节点。

// sections (main)
var root = Parser.parse('a\n==1==\nb\n===2===\nc\n==3==\nd'),
	[s0, s1, s2, s3] = root.sections();
assert.equal(s0, 'a\n');
assert.equal(s1, '==1==\nb\n===2===\nc\n');
assert.equal(s2, '===2===\nc\n');
assert.equal(s3, '==3==\nd');

root = Parser.parse('a');
[s0] = root.sections();
assert.equal(s0, 'a');

solveConst

展开

returns: Token
解析参变量和部分魔术字。

// solveConst (main)
var root = Parser.parse(
		`{{{null}}}{{{|[[a]]}}}{{#if:||[//b]}}{{#switch:|#default={{c}}}}{{#switch:d|d|e=}}`,
	),
	copy = root.solveConst();
assert.deepStrictEqual(
	copy.childNodes.map(({type}) => type),
	['text', 'link', 'ext-link', 'template'],
);
assert.deepStrictEqual(
	copy.childNodes.map(String),
	['{{{null}}}', '[[a]]', '[//b]', '{{c}}'],
);

toHtml

展开

加入的版本：1.10.0

param: boolean 是否禁用换行
returns: string
转换为 HTML。

// toHtml (main)
var root = Parser.parse(`a

<!-- -->

b

[[category:1]] [[category:2]]
[[category:3]]

c`);
root.type = 'plain';
assert.strictEqual(
	root.toHtml(),
	'a\n\nb\n\nc',
);
Parser.templates.set('Template:Dt', ';');
root = Parser.parse('a\n\nb{{dt}}{{dt}}c:d');
assert.strictEqual(
	root.toHtml(),
	'<p>a\n</p><p>b\n</p>\n<dl><dt></dt>\n<dt>c</dt>\n<dd>d</dd></dl>',
);

相关软件包

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