wikiparser-node 1.11.1 → 1.12.1-b

package/dist/parser/selector.js

@@ -1,394 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkToken = void 0;
-const constants_1 = require("../util/constants");
-const string_1 = require("../util/string");
-const ranges_1 = require("../lib/ranges");
-const title_1 = require("../lib/title");
-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',
-]), complexPseudos = new Set([
-    'is',
-    'not',
-    'nth-child',
-    'nth-of-type',
-    'nth-last-child',
-    'nth-last-of-type',
-    'contains',
-    'has',
-    'lang',
-    'regex',
-]), specialChars = [
-    ['[', '['],
-    [']', ']'],
-    ['(', '('],
-    [')', ')'],
-    ['"', '"'],
-    [`'`, '''],
-    [':', ':'],
-    ['\\', '\'],
-    ['&', '&'],
-], 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(['>', '+', '~', '']), sanitizeRegex = specialChars.map(([c, escaped]) => [new RegExp((0, string_1.escapeRegExp)(`\\${c}`), 'gu'), escaped]), desanitizeRegex = specialChars.map(([c, escaped]) => [c, new RegExp(escaped, 'gu')]), primitives = new Set(['string', 'number', 'boolean', 'undefined']);
-/**
- * optionally convert to lower cases
- * @param val 属性值
- * @param i 是否对大小写不敏感
- */
-const toCase = (val, i) => i ? val.toLowerCase() : val;
-/**
- * 检查某个下标是否符合表达式
- * @param str 表达式
- * @param i 待检查的下标
- */
-const nth = (str, i) => new ranges_1.Ranges(str).applyTo(i + 1).includes(i);
-/**
- * 是否受保护。保护条件来自Token，这里仅提前用于:required和:optional伪选择器。
- * @param token 节点
- */
-const isProtected = (token) => {
-    const { parentNode } = token;
-    if (!parentNode) {
-        return undefined;
-    }
-    const { childNodes, fixed } = parentNode;
-    return fixed
-        || parentNode.getAttribute('protectedChildren').applyTo(childNodes).includes(childNodes.indexOf(token));
-};
-/**
- * 获取属性
- * @param token 节点
- * @param key 属性键
- */
-const getAttr = (token, key) => {
-    if (typeof token.getAttr === 'function') {
-        const attr = token.getAttr(key);
-        if (attr !== undefined) {
-            return attr;
-        }
-    }
-    const val = token[key];
-    return val instanceof RegExp ? val.source : val;
-};
-/**
- * 检查是否符合解析后的选择器，不含节点关系
- * @param token 节点
- * @param step 解析后的选择器
- * @throws `SyntaxError` 错误的正则伪选择器
- * @throws `SyntaxError` 未定义的伪选择器
- */
-const matches = (token, step) => {
-    const { parentNode, type, name, childNodes, link } = token, children = parentNode?.children, childrenOfType = children?.filter(({ type: t }) => t === type), siblingsCount = children?.length ?? 1, siblingsCountOfType = childrenOfType?.length ?? 1, index = (children?.indexOf(token) ?? 0) + 1, indexOfType = (childrenOfType?.indexOf(token) ?? 0) + 1, lastIndex = siblingsCount - index + 1, lastIndexOfType = siblingsCountOfType - indexOfType + 1;
-    return step.every(selector => {
-        if (typeof selector === 'string') {
-            switch (selector) { // 情形1：简单伪选择器、type和name
-                case '*':
-                    return true;
-                case ':root':
-                    return !parentNode;
-                case ':first-child':
-                    return index === 1;
-                case ':first-of-type':
-                    return indexOfType === 1;
-                case ':last-child':
-                    return lastIndex === 1;
-                case ':last-of-type':
-                    return lastIndexOfType === 1;
-                case ':only-child':
-                    return siblingsCount === 1;
-                case ':only-of-type':
-                    return siblingsCountOfType === 1;
-                case ':empty':
-                    return !childNodes.some(({ type: t, data }) => t !== 'text' || data);
-                case ':parent':
-                    return childNodes.some(({ type: t, data }) => t !== 'text' || data);
-                case ':header':
-                    return type === 'heading';
-                case ':hidden':
-                    return token.text() === '';
-                case ':visible':
-                    return token.text() !== '';
-                case ':only-whitespace':
-                    return token.text().trim() === '';
-                case ':any-link':
-                    return type === 'link'
-                        || type === 'redirect-target'
-                        || type === 'free-ext-link'
-                        || type === 'magic-link'
-                        || type === 'ext-link'
-                        || (type === 'file' || type === 'gallery-image') && link;
-                case ':local-link':
-                    return (type === 'link' || type === 'file' || type === 'gallery-image')
-                        && link instanceof title_1.Title
-                        && link.title === '';
-                case ':invalid':
-                    return type === 'table-inter' || type === 'image-parameter' && name === 'invalid';
-                case ':required':
-                    return isProtected(token) === true;
-                case ':optional':
-                    return isProtected(token) === false;
-                default: {
-                    const [t, n] = selector.split('#');
-                    return (!t || t === type) && (!n || n === name);
-                }
-            }
-        }
-        else if (selector.length === 4) { // 情形2：属性选择器
-            const [key, equal, val = '', i] = selector, isAttr = typeof token.hasAttr === 'function' && typeof token.getAttr === 'function';
-            if (!(key in token) && (!isAttr || !token.hasAttr(key))) {
-                return equal === '!=';
-            }
-            const v = toCase(val, i), thisVal = getAttr(token, key);
-            if (!equal) {
-                return thisVal !== undefined && thisVal !== false;
-            }
-            if (equal === '~=') {
-                const thisVals = typeof thisVal === 'string' ? thisVal.split(/\s/u) : thisVal;
-                return Boolean(thisVals?.[Symbol.iterator])
-                    && [...thisVals].some(w => typeof w === 'string' && toCase(w, i) === v);
-            }
-            else if (!primitives.has(typeof thisVal) && !(thisVal instanceof title_1.Title)) {
-                throw new RangeError(`The complex attribute ${key} cannot be used in a selector!`);
-            }
-            const stringVal = toCase(String(thisVal), i);
-            switch (equal) {
-                case '|=':
-                    return stringVal === v || stringVal.startsWith(`${v}-`);
-                case '^=':
-                    return stringVal.startsWith(v);
-                case '$=':
-                    return stringVal.endsWith(v);
-                case '*=':
-                    return stringVal.includes(v);
-                case '!=':
-                    return stringVal !== v;
-                default: // `=`
-                    return stringVal === v;
-            }
-        }
-        const [s, pseudo] = selector; // 情形3：复杂伪选择器
-        switch (pseudo) {
-            case 'is':
-                return token.matches(s);
-            case 'not':
-                return !token.matches(s);
-            case 'nth-child':
-                return nth(s, index);
-            case 'nth-of-type':
-                return nth(s, indexOfType);
-            case 'nth-last-child':
-                return nth(s, lastIndex);
-            case 'nth-last-of-type':
-                return nth(s, lastIndexOfType);
-            case 'contains':
-                return token.text().includes(s);
-            case 'has':
-                return Boolean(token.querySelector(s));
-            case 'lang': {
-                // eslint-disable-next-line @typescript-eslint/no-unused-expressions
-                /^zh(?:-|$)/iu;
-                const regex = new RegExp(`^${s}(?:-|$)`, 'iu');
-                let node = token;
-                for (; node; node = node.parentNode) {
-                    const lang = node.attributes?.['lang'];
-                    if (lang !== undefined) {
-                        return typeof lang === 'string' && regex.test(lang);
-                    }
-                }
-                return false;
-            }
-            case 'regex': {
-                const mt = /^([^,]+),\s*\/(.+)\/([a-z]*)$/u.exec(s);
-                if (!mt) {
-                    throw new SyntaxError(`Wrong usage of the regex pseudo-selector. Use ":regex('attr, /re/i')" format.`);
-                }
-                try {
-                    return new RegExp(mt[2], mt[3]).test(String(getAttr(token, mt[1].trim())));
-                }
-                catch {
-                    throw new SyntaxError(`Invalid regular expression: /${mt[2]}/${mt[3]}`);
-                }
-            }
-            default:
-                throw new SyntaxError(`Undefined pseudo-selector: ${pseudo}`);
-        }
-    });
-};
-/**
- * 检查是否符合解析后的选择器
- * @param token 节点
- * @param copy 解析后的选择器
- */
-const matchesArray = (token, copy) => {
-    const condition = [...copy];
-    if (matches(token, condition.pop())) {
-        const { parentNode, previousElementSibling } = token;
-        switch (condition.at(-1)?.relation) {
-            case undefined:
-                return true;
-            case '>':
-                return Boolean(parentNode && matchesArray(parentNode, condition));
-            case '+':
-                return Boolean(previousElementSibling && matchesArray(previousElementSibling, condition));
-            case '~': {
-                if (!parentNode) {
-                    return false;
-                }
-                const { children } = parentNode;
-                return children.slice(0, children.indexOf(token)).some(child => matchesArray(child, condition));
-            }
-            default: // ' '
-                return token.getAncestors().some(ancestor => matchesArray(ancestor, condition));
-        }
-    }
-    return false;
-};
-/**
- * 还原转义符号
- * @param selector
- */
-const desanitize = (selector) => {
-    for (const [c, re] of desanitizeRegex) {
-        selector = selector.replace(re, c);
-    }
-    return selector.trim();
-};
-/**
- * 去除首尾的引号
- * @param val 属性值或伪选择器函数的参数
- */
-const deQuote = (val) => /^(["']).*\1$/u.test(val) ? val.slice(1, -1) : val.trim();
-/**
- * 检查节点是否符合选择器
- * @param selector
- */
-const checkToken = (selector) => (token) => {
-    let sanitized = selector.trim();
-    for (const [re, escaped] of sanitizeRegex) {
-        sanitized = sanitized.replace(re, escaped);
-    }
-    const stack = [[[]]];
-    let regex = regularRegex, mt = regex.exec(sanitized), [condition] = stack, [step] = condition;
-    /**
-     * 解析简单伪选择器
-     * @param index 伪选择器的终点位置
-     * @throws `SyntaxError` 选择器排序
-     * @throws `SyntaxError` 非法的选择器
-     */
-    const pushSimple = (index) => {
-        const str = sanitized.slice(0, index).trim();
-        if (!str) {
-            return;
-        }
-        const pieces = str.split(/(?=[:#])/u);
-        for (let i = 0; i < pieces.length; i++) {
-            const piece = pieces[i];
-            if (!/^[:#]/u.test(piece)) {
-                if (step.length > 0) {
-                    throw new SyntaxError(`Invalid selector!\n${selector}\nType selectors must come first.`);
-                }
-                else {
-                    step.push(piece);
-                }
-            }
-            else if (piece.startsWith(':')) {
-                if (simplePseudos.has(piece.slice(1))) {
-                    step.push(piece);
-                }
-                else if (pieces[i - 1]?.startsWith('#')) {
-                    pieces[i - 1] += piece;
-                    pieces.splice(i, 1);
-                    i--;
-                }
-                else {
-                    throw new SyntaxError(`Undefined pseudo selector!\n${desanitize(piece)}`);
-                }
-            }
-        }
-        step.push(...pieces.filter(piece => piece.startsWith('#')).map(desanitize));
-    };
-    /**
-     * 检查是否需要通用选择器
-     * @throws `SyntaxError` 非法的选择器
-     */
-    const needUniversal = () => {
-        if (step.length === 0) {
-            throw new SyntaxError(`Invalid selector!\n${selector}\nYou may need the universal selector '*'.`);
-        }
-    };
-    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(index);
-            needUniversal();
-            condition = [[]];
-            [step] = condition;
-            stack.push(condition);
-        }
-        else if (combinator.has(syntax)) { // 情形2：关系
-            pushSimple(index);
-            needUniversal();
-            step.relation = syntax;
-            step = [];
-            condition.push(step);
-        }
-        else if (syntax === '[') { // 情形3：属性开启
-            pushSimple(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 i = sanitized.lastIndexOf(':', index), pseudo = sanitized.slice(i + 1, index);
-            if (i === -1 || !complexPseudos.has(pseudo)) {
-                throw new SyntaxError(`Undefined pseudo selector!\n${desanitize(sanitized)}`);
-            }
-            pushSimple(i);
-            step.push(pseudo); // 临时存放复杂伪选择器
-            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();
-        needUniversal();
-        return stack.some(copy => matchesArray(token, copy));
-    }
-    throw new SyntaxError(`Unclosed '${regex === attributeRegex ? '[' : '('}' in the selector!\n${desanitize(sanitized)}`);
-};
-exports.checkToken = checkToken;
-constants_1.parsers['parseSelector'] = __filename;

package/dist/parser/table.js

@@ -1,123 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseTable = void 0;
-const constants_1 = require("../util/constants");
-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");
-/**
- * 判断是否为表格行或表格
- * @param token 表格节点
- */
-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, accum) => {
-    const stack = [], lines = data.split('\n');
-    let out = type === 'root' || type === 'parameter-value' || type === 'ext-inner' && name === 'poem'
-        ? ''
-        : `\n${lines.shift()}`, top;
-    /**
-     * 向表格中插入纯文本
-     * @param str 待插入的文本
-     * @param topToken 当前解析的表格或表格行
-     */
-    const push = (str, topToken) => {
-        if (!topToken) {
-            out += str;
-            return;
-        }
-        const { lastChild } = topToken;
-        if (isTr(topToken)) {
-            const token = new index_1.Token(str, config, accum);
-            token.type = 'table-inter';
-            token.setAttribute('stage', 3);
-            topToken.insertAt(token);
-        }
-        else {
-            lastChild.setText(lastChild.toString() + str);
-        }
-    }, 
-    /** 取出最近的表格行 */
-    pop = () => top.type === 'td' ? stack.pop() : top;
-    for (const outLine of lines) {
-        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) {
-                // @ts-expect-error abstract class
-                new dd_1.DdToken(indent, config, accum);
-            }
-            push(`\n${spaces}${indent && `\0${accum.length - 1}d\x7F`}${moreSpaces}\0${accum.length}b\x7F`, top);
-            // @ts-expect-error abstract class
-            stack.push(...top ? [top] : [], new index_2.TableToken(tableSyntax, attr, config, accum));
-            continue;
-        }
-        else if (!top) {
-            out += `\n${outLine}`;
-            continue;
-        }
-        const matches = // eslint-disable-line @stylistic/operator-linebreak
-         /^(?:(\|\}|\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[stack.length - 1]);
-        }
-        else if (row) {
-            top = pop();
-            if (top.type === 'tr') {
-                top = stack.pop();
-            }
-            // @ts-expect-error abstract class
-            const tr = new tr_1.TrToken(`\n${spaces}${row}`, attr, config, accum);
-            stack.push(top, tr);
-            top.insertAt(tr);
-        }
-        else {
-            top = 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}`;
-            /**
-             * 创建表格单元格
-             * @param tr 当前表格行
-             */
-            const newTd = (tr) => {
-                // @ts-expect-error abstract class
-                const td = new td_1.TdToken(lastSyntax, attr.slice(lastIndex, mt?.index), config, accum);
-                tr.insertAt(td);
-                return td;
-            };
-            while (mt) {
-                newTd(top);
-                ({ lastIndex } = regex);
-                [lastSyntax] = mt;
-                mt = regex.exec(attr);
-            }
-            stack.push(top, newTd(top));
-        }
-    }
-    return out.slice(1);
-};
-exports.parseTable = parseTable;
-constants_1.parsers['parseTable'] = __filename;

package/dist/src/arg.d.ts

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