wikiparser-node 1.2.0-b → 1.2.0

package/dist/parser/quotes.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQuotes = void 0;
+const constants_1 = require("../util/constants");
+const Parser = require("../index");
+const quote_1 = require("../src/nowiki/quote");
+/**
+ * 解析单引号
+ * @param wikitext
+ * @param config
+ * @param accum
+ */
+const parseQuotes = (wikitext, config = Parser.getConfig(), accum = []) => {
+    const arr = wikitext.split(/('{2,})/u), { length } = arr;
+    if (length === 1) {
+        return wikitext;
+    }
+    let nBold = 0, nItalic = 0, firstSingle, firstMulti, firstSpace;
+    for (let i = 1; i < length; i += 2) {
+        const { length: len } = arr[i];
+        switch (len) {
+            case 2:
+                nItalic++;
+                break;
+            case 4:
+                arr[i - 1] += `'`;
+                arr[i] = `'''`;
+            // fall through
+            case 3:
+                nBold++;
+                if (firstSingle !== undefined) {
+                    break;
+                }
+                else if (arr[i - 1].endsWith(' ')) {
+                    if (firstMulti === undefined && firstSpace === undefined) {
+                        firstSpace = i;
+                    }
+                }
+                else if (arr[i - 1].at(-2) === ' ') {
+                    firstSingle = i;
+                }
+                else {
+                    firstMulti ??= i;
+                }
+                break;
+            default:
+                arr[i - 1] += `'`.repeat(len - 5);
+                arr[i] = `'''''`;
+                nItalic++;
+                nBold++;
+        }
+    }
+    if (nItalic % 2 === 1 && nBold % 2 === 1) {
+        const i = firstSingle ?? firstMulti ?? firstSpace;
+        if (i !== undefined) {
+            arr[i] = `''`;
+            arr[i - 1] += `'`;
+        }
+    }
+    for (let i = 1; i < length; i += 2) {
+        new quote_1.QuoteToken(arr[i], config, accum);
+        arr[i] = `\0${accum.length - 1}q\x7F`;
+    }
+    return arr.join('');
+};
+exports.parseQuotes = parseQuotes;
+constants_1.parsers['parseQuotes'] = __filename;

package/dist/parser/selector.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSelector = void 0;
+const constants_1 = require("../util/constants");
+const Parser = require("../index");
+const simplePseudos = new Set([
+    'root',
+    'first-child',
+    'first-of-type',
+    'last-child',
+    'last-of-type',
+    'only-child',
+    'only-of-type',
+    'empty',
+    'parent',
+    'header',
+    'hidden',
+    'visible',
+    'only-whitespace',
+    'any-link',
+    'local-link',
+    'invalid',
+    'required',
+    'optional',
+]);
+const complexPseudos = [
+    'is',
+    'not',
+    'nth-child',
+    'nth-of-type',
+    'nth-last-child',
+    'nth-last-of-type',
+    'contains',
+    'has',
+    'lang',
+    'regex',
+];
+const specialChars = [
+    ['[', '['],
+    [']', ']'],
+    ['(', '('],
+    [')', ')'],
+    ['"', '"'],
+    [`'`, '''],
+    [':', ':'],
+    ['\\', '\'],
+    ['&', '&'],
+];
+const pseudoRegex = new RegExp(`:(${complexPseudos.join('|')})$`, 'u'), regularRegex = /[[(,>+~]|\s+/u, attributeRegex = /^\s*(\w+)\s*(?:([~|^$*!]?=)\s*("[^"]*"|'[^']*'|[^\s[\]]+)(?:\s+(i))?\s*)?\]/u, functionRegex = /^(\s*"[^"]*"\s*|\s*'[^']*'\s*|[^()]*)\)/u, grouping = new Set([',', '>', '+', '~']), combinator = new Set(['>', '+', '~', '']);
+/**
+ * 清理转义符号
+ * @param selector
+ */
+const sanitize = (selector) => {
+    for (const [c, escaped] of specialChars) {
+        selector = selector.replaceAll(`\\${c}`, escaped);
+    }
+    return selector;
+};
+/**
+ * 还原转义符号
+ * @param selector
+ */
+const desanitize = (selector) => {
+    for (const [c, escaped] of specialChars) {
+        selector = selector.replaceAll(escaped, c);
+    }
+    return selector.trim();
+};
+/**
+ * 去除首尾的引号
+ * @param val 属性值或伪选择器函数的参数
+ */
+const deQuote = (val) => /^(["']).*\1$/u.test(val) ? val.slice(1, -1) : val.trim();
+/**
+ * 解析简单伪选择器
+ * @param step 当前顶部
+ * @param str 不含属性和复杂伪选择器的语句
+ * @throws `SyntaxError` 非法的选择器
+ */
+const pushSimple = (step, str) => {
+    const pieces = str.trim().split(':'), 
+    // eslint-disable-next-line unicorn/explicit-length-check
+    i = pieces.slice(1).findIndex(pseudo => simplePseudos.has(pseudo)) + 1 || pieces.length;
+    if (pieces.slice(i).some(pseudo => !simplePseudos.has(pseudo))) {
+        throw new SyntaxError(`非法的选择器！\n${str}\n可能需要将':'转义为'\\:'。`);
+    }
+    step.push(desanitize(pieces.slice(0, i).join(':')), ...pieces.slice(i).map(piece => `:${piece}`));
+};
+/**
+ * 解析选择器
+ * @param selector
+ * @throws `SyntaxError` 非法的选择器
+ */
+const parseSelector = (selector) => {
+    selector = selector.trim();
+    const stack = [[[]]];
+    let sanitized = sanitize(selector), regex = regularRegex, mt = regex.exec(sanitized), [condition] = stack, [step] = condition;
+    while (mt) {
+        let { 0: syntax, index } = mt;
+        if (syntax.trim() === '') {
+            index += syntax.length;
+            const char = sanitized[index];
+            syntax = grouping.has(char) ? char : '';
+        }
+        if (syntax === ',') { // 情形1：并列
+            pushSimple(step, sanitized.slice(0, index));
+            condition = [[]];
+            [step] = condition;
+            stack.push(condition);
+        }
+        else if (combinator.has(syntax)) { // 情形2：关系
+            pushSimple(step, sanitized.slice(0, index));
+            if (!step.some(Boolean)) {
+                throw new SyntaxError(`非法的选择器！\n${selector}\n可能需要通用选择器'*'。`);
+            }
+            step.relation = syntax;
+            step = [];
+            condition.push(step);
+        }
+        else if (syntax === '[') { // 情形3：属性开启
+            pushSimple(step, sanitized.slice(0, index));
+            regex = attributeRegex;
+        }
+        else if (syntax.endsWith(']')) { // 情形4：属性闭合
+            mt[3] &&= desanitize(deQuote(mt[3]));
+            step.push(mt.slice(1));
+            regex = regularRegex;
+        }
+        else if (syntax === '(') { // 情形5：伪选择器开启
+            const pseudoExec = pseudoRegex.exec(sanitized.slice(0, index));
+            if (!pseudoExec) {
+                throw new SyntaxError(`非法的选择器！\n${desanitize(sanitized)}\n请检查伪选择器是否存在。`);
+            }
+            pushSimple(step, sanitized.slice(0, pseudoExec.index));
+            step.push(pseudoExec[1]); // 临时存放复杂伪选择器
+            regex = functionRegex;
+        }
+        else { // 情形6：伪选择器闭合
+            mt.push(step.pop());
+            mt[1] &&= deQuote(mt[1]);
+            step.push(mt.slice(1));
+            regex = regularRegex;
+        }
+        sanitized = sanitized.slice(index + syntax.length);
+        if (grouping.has(syntax)) {
+            sanitized = sanitized.trim();
+        }
+        mt = regex.exec(sanitized);
+    }
+    if (regex === regularRegex) {
+        pushSimple(step, sanitized);
+        const pseudos = new Set(stack.flat(2).filter((e) => typeof e === 'string' && e.startsWith(':')));
+        if (pseudos.size > 0) {
+            Parser.warn('检测到伪选择器，请确认是否需要将":"转义成"\\:"。', pseudos);
+        }
+        return stack;
+    }
+    throw new SyntaxError(`非法的选择器！\n${selector}\n检测到未闭合的'${regex === attributeRegex ? '[' : '('}'`);
+};
+exports.parseSelector = parseSelector;
+constants_1.parsers['parseSelector'] = __filename;

package/dist/parser/table.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTable = void 0;
+const constants_1 = require("../util/constants");
+const Parser = require("../index");
+const index_1 = require("../src/index");
+const index_2 = require("../src/table/index");
+const tr_1 = require("../src/table/tr");
+const td_1 = require("../src/table/td");
+const dd_1 = require("../src/nowiki/dd");
+/** @ignore */
+const isTr = (token) => token.lastChild.constructor !== index_1.Token;
+/**
+ * 解析表格，注意`tr`和`td`包含开头的换行
+ * @param {Token & {firstChild: AstText}} root 根节点
+ * @param config
+ * @param accum
+ */
+const parseTable = ({ firstChild: { data }, type, name }, config = Parser.getConfig(), accum = []) => {
+    const stack = [], lines = data.split('\n');
+    let out = type === 'root' || type === 'parameter-value' || type === 'ext-inner' && name === 'poem'
+        ? ''
+        : `\n${lines.shift()}`;
+    /**
+     * 向表格中插入纯文本
+     * @param str 待插入的文本
+     * @param top 当前解析的表格或表格行
+     */
+    const push = (str, top) => {
+        if (!top) {
+            out += str;
+            return;
+        }
+        const { lastChild } = top;
+        if (isTr(top)) {
+            const token = new index_1.Token(str, config, accum);
+            token.type = 'table-inter';
+            token.setAttribute('stage', 3);
+            top.insertAt(token);
+        }
+        else {
+            lastChild.setText(String(lastChild) + str);
+        }
+    };
+    for (const outLine of lines) {
+        let top = stack.pop();
+        const [spaces] = /^(?:\s|\0\d+c\x7F)*/u.exec(outLine), line = outLine.slice(spaces.length), matchesStart = /^(:*)((?:\s|\0\d+c\x7F)*)(\{\||\{(?:\0\d+c\x7F)*\0\d+!\x7F|\0\d+\{\x7F)(.*)$/u
+            .exec(line);
+        if (matchesStart) {
+            while (top && top.type !== 'td') {
+                top = stack.pop();
+            }
+            const [, indent, moreSpaces, tableSyntax, attr] = matchesStart;
+            if (indent) {
+                new dd_1.DdToken(indent, config, accum);
+            }
+            push(`\n${spaces}${indent && `\0${accum.length - 1}d\x7F`}${moreSpaces}\0${accum.length}b\x7F`, top);
+            stack.push(...top ? [top] : [], new index_2.TableToken(tableSyntax, attr, config, accum));
+            continue;
+        }
+        else if (!top) {
+            out += `\n${outLine}`;
+            continue;
+        }
+        // eslint-disable-next-line operator-linebreak
+        const matches = /^(?:(\|\}|\0\d+!\x7F\}|\0\d+\}\x7F)|(\|-+|\0\d+!\x7F-+|\0\d+-\x7F-*)(?!-)|(!|(?:\||\0\d+!\x7F)\+?))(.*)$/u
+            .exec(line);
+        if (!matches) {
+            push(`\n${outLine}`, top);
+            stack.push(top);
+            continue;
+        }
+        const [, closing, row, cell, attr] = matches;
+        if (closing) {
+            while (top.type !== 'table') {
+                top = stack.pop();
+            }
+            top.close(`\n${spaces}${closing}`, true);
+            push(attr, stack.at(-1));
+        }
+        else if (row) {
+            if (top.type === 'td') {
+                top = stack.pop();
+            }
+            if (top.type === 'tr') {
+                top = stack.pop();
+            }
+            const tr = new tr_1.TrToken(`\n${spaces}${row}`, attr, config, accum);
+            stack.push(top, tr);
+            top.insertAt(tr);
+        }
+        else {
+            if (top.type === 'td') {
+                top = stack.pop();
+            }
+            const regex = cell === '!' ? /!!|(?:\||\0\d+!\x7F){2}|\0\d+\+\x7F/gu : /(?:\||\0\d+!\x7F){2}|\0\d+\+\x7F/gu;
+            let mt = regex.exec(attr), lastIndex = 0, lastSyntax = `\n${spaces}${cell}`;
+            while (mt) {
+                top.insertAt(new td_1.TdToken(lastSyntax, attr.slice(lastIndex, mt.index), config, accum));
+                ({ lastIndex } = regex);
+                [lastSyntax] = mt;
+                mt = regex.exec(attr);
+            }
+            const td = new td_1.TdToken(lastSyntax, attr.slice(lastIndex), config, accum);
+            stack.push(top, td);
+            top.insertAt(td);
+        }
+    }
+    return out.slice(1);
+};
+exports.parseTable = parseTable;
+constants_1.parsers['parseTable'] = __filename;

package/dist/src/arg.d.ts

@@ -0,0 +1,58 @@
+import * as Parser from '../index';
+import { Token } from './index';
+import { AtomToken } from './atom';
+import { HiddenToken } from './hidden';
+import type { LintError } from '../base';
+/**
+ * `{{{}}}`包裹的参数
+ * @classdesc `{childNodes: [AtomToken, ?Token, ...HiddenToken]}`
+ */
+export declare class ArgToken extends Token {
+    #private;
+    readonly type = "arg";
+    readonly name: string;
+    readonly childNodes: [AtomToken] | [AtomToken, Token, ...HiddenToken[]];
+    abstract get children(): [AtomToken] | [AtomToken, Token, ...HiddenToken[]];
+    abstract get firstChild(): AtomToken;
+    abstract get firstElementChild(): AtomToken;
+    abstract get lastChild(): Token;
+    abstract get lastElementChild(): Token;
+    /** 预设值 */
+    get default(): string | false;
+    set default(value: string | false);
+    /** @param parts 以'|'分隔的各部分 */
+    constructor(parts: readonly string[], config?: Parser.Config, accum?: Token[]);
+    /** @override */
+    text(): string;
+    /** @override */
+    lint(start?: number): LintError[];
+    /** @override */
+    print(): string;
+    /** @override */
+    cloneNode(): this;
+    /** 移除无效部分 */
+    removeRedundant(): void;
+    /**
+     * @override
+     * @param i 移除位置
+     */
+    removeAt(i: number): Token;
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     * @throws `RangeError` 不可插入多余子节点
+     * @throws `TypeError` 不可插入文本节点
+     */
+    insertAt<T extends Token>(token: T, i?: number): T;
+    /**
+     * 设置参数名
+     * @param name 新参数名
+     */
+    setName(name: string): void;
+    /**
+     * 设置预设值
+     * @param value 预设值
+     */
+    setDefault(value: string | false): void;
+}

package/dist/src/arg.js

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgToken = void 0;
+const string_1 = require("../util/string");
+const lint_1 = require("../util/lint");
+const constants_1 = require("../util/constants");
+const debug_1 = require("../util/debug");
+const Parser = require("../index");
+const index_1 = require("./index");
+const atom_1 = require("./atom");
+const hidden_1 = require("./hidden");
+/**
+ * `{{{}}}`包裹的参数
+ * @classdesc `{childNodes: [AtomToken, ?Token, ...HiddenToken]}`
+ */
+class ArgToken extends index_1.Token {
+    type = 'arg';
+    /** 预设值 */
+    get default() {
+        return this.childNodes[1]?.text() ?? false;
+    }
+    /* NOT FOR BROWSER */
+    set default(value) {
+        this.setDefault(value);
+    }
+    /* NOT FOR BROWSER END */
+    /** @param parts 以'|'分隔的各部分 */
+    constructor(parts, config = Parser.getConfig(), accum = []) {
+        super(undefined, config, accum, {
+            AtomToken: 0, Token: 1, HiddenToken: '2:',
+        });
+        for (let i = 0; i < parts.length; i++) {
+            if (i === 0) {
+                const token = new atom_1.AtomToken(parts[i], 'arg-name', config, accum, {
+                    'Stage-2': ':', '!HeadingToken': '',
+                });
+                super.insertAt(token);
+            }
+            else if (i > 1) {
+                const token = new hidden_1.HiddenToken(parts[i], config, accum, {
+                    'Stage-2': ':', '!HeadingToken': '',
+                });
+                super.insertAt(token);
+            }
+            else {
+                const token = new index_1.Token(parts[i], config, accum);
+                token.type = 'arg-default';
+                token.setAttribute('stage', 2);
+                super.insertAt(token);
+            }
+        }
+        this.protectChildren(0);
+    }
+    /** @private */
+    toString(omit) {
+        return omit && this.matchesTypes(omit) ? '' : `{{{${super.toString(omit, '|')}}}}`;
+    }
+    /** @override */
+    text() {
+        return `{{{${(0, string_1.text)(this.childNodes.slice(0, 2), '|')}}}}`;
+    }
+    /** @private */
+    getAttribute(key) {
+        return key === 'padding' ? 3 : super.getAttribute(key);
+    }
+    /** @private */
+    getGaps() {
+        return 1;
+    }
+    /** @override */
+    lint(start = this.getAbsoluteIndex()) {
+        if (!this.getAttribute('include')) {
+            return [(0, lint_1.generateForSelf)(this, { start }, 'unexpected template argument')];
+        }
+        const { childNodes: [argName, argDefault, ...rest] } = this, errors = argName.lint(start + 3);
+        if (argDefault) {
+            errors.push(...argDefault.lint(start + 4 + String(argName).length));
+        }
+        if (rest.length > 0) {
+            const rect = { start, ...this.getRootNode().posFromIndex(start) };
+            errors.push(...rest.map(child => {
+                const error = (0, lint_1.generateForChild)(child, rect, 'invisible content inside triple braces'), { startIndex, startCol, excerpt, } = error;
+                return {
+                    ...error,
+                    startIndex: startIndex - 1,
+                    startCol: startCol - 1,
+                    excerpt: `|${excerpt}`,
+                };
+            }));
+        }
+        return errors;
+    }
+    /** @override */
+    print() {
+        return super.print({ pre: '{{{', post: '}}}', sep: '|' });
+    }
+    /* NOT FOR BROWSER */
+    /** @override */
+    cloneNode() {
+        const [name, ...cloned] = this.cloneChildNodes();
+        return debug_1.Shadow.run(() => {
+            const token = new ArgToken([''], this.getAttribute('config'));
+            token.firstChild.safeReplaceWith(name);
+            token.append(...cloned);
+            token.afterBuild();
+            return token;
+        });
+    }
+    /** 设置name */
+    #setName() {
+        this.setAttribute('name', this.firstChild.text().trim());
+    }
+    /** @private */
+    afterBuild() {
+        this.#setName();
+        const /** @implements */ argListener = ({ prevTarget }) => {
+            if (prevTarget === this.firstChild) {
+                this.#setName();
+            }
+        };
+        this.addEventListener(['remove', 'insert', 'replace', 'text'], argListener);
+    }
+    /** 移除无效部分 */
+    removeRedundant() {
+        debug_1.Shadow.run(() => {
+            for (let i = this.length - 1; i > 1; i--) {
+                super.removeAt(i);
+            }
+        });
+    }
+    /**
+     * @override
+     * @param i 移除位置
+     */
+    removeAt(i) {
+        if (i === 1) {
+            this.removeRedundant();
+        }
+        return super.removeAt(i);
+    }
+    /**
+     * @override
+     * @param token 待插入的子节点
+     * @param i 插入位置
+     * @throws `RangeError` 不可插入多余子节点
+     * @throws `TypeError` 不可插入文本节点
+     */
+    insertAt(token, i = this.length) {
+        i += i < 0 ? this.length : 0;
+        if (i > 1) {
+            throw new RangeError(`${this.constructor.name}不可插入多余的子节点！`);
+        }
+        else if (typeof token === 'string') {
+            throw new TypeError(`${this.constructor.name}不可插入文本节点！`);
+        }
+        super.insertAt(token, i);
+        if (i === 1) {
+            token.type = 'arg-default';
+        }
+        return token;
+    }
+    /**
+     * 设置参数名
+     * @param name 新参数名
+     */
+    setName(name) {
+        const { childNodes } = Parser.parse(name, this.getAttribute('include'), 2, this.getAttribute('config'));
+        this.firstChild.replaceChildren(...childNodes);
+    }
+    /**
+     * 设置预设值
+     * @param value 预设值
+     */
+    setDefault(value) {
+        if (value === false) {
+            this.removeAt(1);
+            return;
+        }
+        const root = Parser.parse(value, this.getAttribute('include'), undefined, this.getAttribute('config')), { childNodes: [, oldDefault] } = this;
+        if (oldDefault) {
+            oldDefault.replaceChildren(...root.childNodes);
+        }
+        else {
+            root.type = 'arg-default';
+            this.insertAt(root);
+        }
+    }
+}
+exports.ArgToken = ArgToken;
+constants_1.classes['ArgToken'] = __filename;

package/dist/src/atom.d.ts

@@ -0,0 +1,12 @@
+import * as Parser from '../index';
+import { Token } from './index';
+declare type AtomTypes = 'arg-name' | 'attr-key' | 'attr-value' | 'ext-attr-dirty' | 'html-attr-dirty' | 'table-attr-dirty' | 'converter-flag' | 'converter-rule-variant' | 'converter-rule-to' | 'converter-rule-from' | 'invoke-function' | 'invoke-module' | 'template-name' | 'link-target' | 'param-line';
+/** 不会被继续解析的plain Token */
+export declare class AtomToken extends Token {
+    type: AtomTypes;
+    /** @class */
+    constructor(wikitext: string | undefined, type: AtomTypes, config?: Parser.Config, accum?: Token[], acceptable?: Acceptable);
+    /** @override */
+    cloneNode(): this;
+}
+export {};

package/dist/src/atom.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtomToken = void 0;
+const debug_1 = require("../util/debug");
+const constants_1 = require("../util/constants");
+const Parser = require("../index");
+const index_1 = require("./index");
+/** 不会被继续解析的plain Token */
+class AtomToken extends index_1.Token {
+    /** @class */
+    constructor(wikitext, type, config = Parser.getConfig(), accum = [], acceptable) {
+        super(wikitext, config, accum, acceptable);
+        this.type = type;
+    }
+    /* NOT FOR BROWSER */
+    /** @override */
+    cloneNode() {
+        const cloned = this.cloneChildNodes(), config = this.getAttribute('config'), acceptable = this.getAttribute('acceptable');
+        return debug_1.Shadow.run(() => {
+            const token = new AtomToken(undefined, this.type, config, [], acceptable);
+            token.append(...cloned);
+            return token;
+        });
+    }
+}
+exports.AtomToken = AtomToken;
+constants_1.classes['AtomToken'] = __filename;