wikiparser-node 1.12.5-b → 1.12.5

package/dist/parser/list.js

@@ -0,0 +1,116 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseList = void 0;
+const html_1 = require("../util/html");
+const list_1 = require("../src/nowiki/list");
+const dd_1 = require("../src/nowiki/dd");
+/* NOT FOR BROWSER */
+const constants_1 = require("../util/constants");
+/* NOT FOR BROWSER END */
+/**
+ * 解析列表
+ * @param wikitext
+ * @param state
+ * @param state.lastPrefix 上一个列表的前缀
+ * @param config
+ * @param accum
+ */
+const parseList = (wikitext, state, config, accum) => {
+    const mt = /^((?:\0\d+[cno]\x7F)*)([;:*#]+\s*)/u.exec(wikitext);
+    if (!mt) {
+        state.lastPrefix = '';
+        return wikitext;
+    }
+    const [total, comment, prefix] = mt, prefix2 = prefix.replace(/;/gu, ':'), commonPrefixLength = (0, html_1.getCommon)(prefix2, state.lastPrefix), parts = (commonPrefixLength > 1 ? prefix.slice(commonPrefixLength - 1) : prefix).split(/(?=;)/u), isDt = parts[0].startsWith(';');
+    let dt = parts.length - (isDt ? 0 : 1);
+    if (commonPrefixLength > 1) {
+        const commonPrefix = prefix.slice(0, commonPrefixLength - 1);
+        if (isDt) {
+            parts.unshift(commonPrefix);
+        }
+        else {
+            parts[0] = commonPrefix + parts[0];
+        }
+    }
+    state.lastPrefix = prefix2;
+    let text = comment + parts.map((_, i) => `\0${accum.length + i}d\x7F`).join('') + wikitext.slice(total.length);
+    for (const part of parts) {
+        // @ts-expect-error abstract class
+        new list_1.ListToken(part, config, accum);
+    }
+    if (!dt) {
+        return text;
+    }
+    const { html: [normalTags] } = config, fullRegex = /:+|-\{|\0\d+[xq]\x7F/gu;
+    let regex = fullRegex, ex = regex.exec(text), lt = 0, lb = false, li = false, lc = 0;
+    /**
+     * 创建`DdToken`
+     * @param syntax `:`
+     * @param index 起点
+     */
+    const dd = (syntax, index) => {
+        // @ts-expect-error abstract class
+        new dd_1.DdToken(syntax, config, accum);
+        return `${text.slice(0, index)}\0${accum.length - 1}d\x7F${text.slice(index + syntax.length)}`;
+    };
+    /**
+     * 更新 `lt`
+     * @param closing 是否是闭合标签
+     */
+    const update = (closing) => {
+        if (!closing) {
+            lt++;
+        }
+        else if (lt) {
+            lt--;
+        }
+    };
+    while (ex && dt) {
+        const { 0: syntax, index } = ex;
+        if (syntax === '-{') {
+            if (!lc) {
+                const { lastIndex } = regex;
+                regex = /-\{|\}-/gu;
+                regex.lastIndex = lastIndex;
+            }
+            lc++;
+        }
+        else if (syntax === '}-') {
+            lc--;
+            if (!lc) {
+                const { lastIndex } = regex;
+                regex = fullRegex;
+                regex.lastIndex = lastIndex;
+            }
+        }
+        else if (syntax.endsWith('x\x7F')) {
+            const { name, closing, selfClosing } = accum[Number(syntax.slice(1, -2))];
+            if (!selfClosing || normalTags.includes(name)) {
+                update(closing);
+            }
+        }
+        else if (syntax.endsWith('q\x7F')) {
+            const { bold, italic } = accum[Number(syntax.slice(1, -2))];
+            if (bold) {
+                update(lb);
+                lb = !lb;
+            }
+            if (italic) {
+                update(li);
+                li = !li;
+            }
+        }
+        else if (lt === 0) { // syntax === ':'
+            if (syntax.length >= dt) {
+                return dd(syntax.slice(0, dt), index);
+            }
+            dt -= syntax.length;
+            regex.lastIndex = index + 4 + String(accum.length).length;
+            text = dd(syntax, index);
+        }
+        ex = regex.exec(text);
+    }
+    return text;
+};
+exports.parseList = parseList;
+constants_1.parsers['parseList'] = __filename;

package/dist/parser/magicLinks.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseMagicLinks = void 0;
+const string_1 = require("../util/string");
+const magicLink_1 = require("../src/magicLink");
+/* NOT FOR BROWSER */
+const constants_1 = require("../util/constants");
+/* NOT FOR BROWSER END */
+const space = String.raw `[\p{Zs}\t]| |&#0*160;|&#x0*a0;`, sp = `(?:${space})+`, spdash = `(?:${space}|-)`, magicLinkPattern = String.raw `(?:RFC|PMID)${sp}\d+\b|ISBN${sp}(?:97[89]${spdash}?)?(?:\d${spdash}?){9}[\dx]\b`;
+/**
+ * 解析自由外链
+ * @param wikitext
+ * @param config
+ * @param accum
+ */
+const parseMagicLinks = (wikitext, config, accum) => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    /(^|[^\p{L}\d_])(?:(?:ftp:\/\/|http:\/\/)((?:\[[\da-f:.]+\]|[^[\]<>"\t\n\p{Zs}])[^[\]<>"\0\t\n\p{Zs}]*)|(?:rfc|pmid)[\p{Zs}\t]+\d+\b|isbn[\p{Zs}\t]+(?:97[89][\p{Zs}\t-]?)?(?:\d[\p{Zs}\t-]?){9}[\dx]\b)/giu;
+    const regex = new RegExp(String.raw `(^|[^\p{L}\d_])(?:(?:${config.protocol})(${string_1.extUrlCharFirst}${string_1.extUrlChar})|${magicLinkPattern})`, 'giu');
+    return wikitext.replace(regex, (m, lead, p1) => {
+        let url = lead ? m.slice(lead.length) : m;
+        if (p1) {
+            let trail = '';
+            const m2 = /&(?:lt|gt|nbsp|#x0*(?:3[ce]|a0)|#0*(?:6[02]|160));/iu.exec(url);
+            if (m2) {
+                trail = url.slice(m2.index);
+                url = url.slice(0, m2.index);
+            }
+            const sep = url.includes('(') ? /[^,;\\.:!?][,;\\.:!?]+$/u : /[^,;\\.:!?)][,;\\.:!?)]+$/u, sepChars = sep.exec(url);
+            if (sepChars) {
+                let correction = 1;
+                if (sepChars[0][1] === ';'
+                    && /&(?:[a-z]+|#x[\da-f]+|#\d+)$/iu.test(url.slice(0, sepChars.index))) {
+                    correction = 2;
+                }
+                trail = url.slice(sepChars.index + correction) + trail;
+                url = url.slice(0, sepChars.index + correction);
+            }
+            if (trail.length >= p1.length) {
+                return m;
+            }
+            // @ts-expect-error abstract class
+            new magicLink_1.MagicLinkToken(url, undefined, config, accum);
+            return `${lead}\0${accum.length - 1}w\x7F${trail}`;
+        }
+        else if (!/^(?:RFC|PMID|ISBN)/u.test(url)) {
+            return m;
+        }
+        // @ts-expect-error abstract class
+        new magicLink_1.MagicLinkToken(url, 'magic-link', config, accum);
+        return `${lead}\0${accum.length - 1}i\x7F`;
+    });
+};
+exports.parseMagicLinks = parseMagicLinks;
+constants_1.parsers['parseMagicLinks'] = __filename;

package/dist/parser/quotes.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseQuotes = void 0;
+const quote_1 = require("../src/nowiki/quote");
+/* NOT FOR BROWSER */
+const constants_1 = require("../util/constants");
+/* NOT FOR BROWSER END */
+/**
+ * 解析单引号
+ * @param wikitext
+ * @param config
+ * @param accum
+ */
+const parseQuotes = (wikitext, config, 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 len = arr[i].length;
+        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].slice(-2, -1) === ' ') {
+                    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) {
+        // @ts-expect-error abstract class
+        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/redirect.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseRedirect = void 0;
+const index_1 = require("../index");
+const redirect_1 = require("../src/redirect");
+/* NOT FOR BROWSER */
+const constants_1 = require("../util/constants");
+/* NOT FOR BROWSER END */
+/**
+ * 解析重定向
+ * @param text
+ * @param config
+ * @param accum
+ */
+const parseRedirect = (text, config, accum) => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-expressions
+    /^(\s*)((?:#redirect|#重定向)\s*(?::\s*)?)\[\[([^\n|\]]+)(\|.*?)?\]\](\s*)/iu;
+    const re = new RegExp(String.raw `^(\s*)((?:${config.redirection.join('|')})\s*(?::\s*)?)\[\[([^\n|\]]+)(\|.*?)?\]\](\s*)`, 'iu'), mt = re.exec(text);
+    if (mt && index_1.default.normalizeTitle(mt[3], 0, false, config, true, true).valid) {
+        text = `\0${accum.length}o\x7F${text.slice(mt[0].length)}`;
+        // @ts-expect-error abstract class
+        new redirect_1.RedirectToken(...mt.slice(1), config, accum);
+        return text;
+    }
+    return false;
+};
+exports.parseRedirect = parseRedirect;
+constants_1.parsers['parseRedirect'] = __filename;

package/dist/parser/selector.js

@@ -0,0 +1,393 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.checkToken = void 0;
+const constants_1 = require("../util/constants");
+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(['>', '+', '~', '']), 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, entity] of specialChars) {
+        selector = selector.replaceAll(entity, 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 [c, entity] of specialChars) {
+        sanitized = sanitized.replaceAll(`\\${c}`, entity);
+    }
+    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;