wikiparser-node 0.11.0 → 1.0.0-beta.1

package/dist/parser/brackets.js

@@ -0,0 +1,118 @@
+"use strict";
+const string_1 = require("../util/string");
+const Parser = require("../index");
+const HeadingToken = require("../src/heading");
+const TranscludeToken = require("../src/transclude");
+const ArgToken = require("../src/arg");
+/**
+ * 解析花括号
+ * @throws TranscludeToken.constructor()
+ */
+const parseBrackets = (wikitext, config = Parser.getConfig(), accum = []) => {
+    const source = `${config.excludes?.includes('heading') ? '' : '^(\0\\d+c\x7F)*={1,6}|'}\\[\\[|\\{{2,}|-\\{(?!\\{)`, { parserFunction: [, , , subst] } = config, stack = [], closes = { '=': '\n', '{': '\\}{2,}|\\|', '-': '\\}-', '[': '\\]\\]' }, marks = { '!': '!', '!!': '+', '(!': '{', '!)': '}', '!-': '-', '=': '~' };
+    let text = wikitext, regex = new RegExp(source, 'gmu'), mt = regex.exec(text), moreBraces = text.includes('}}'), lastIndex;
+    while (mt || Number(lastIndex) <= text.length && stack.at(-1)?.[0]?.startsWith('=')) {
+        if (mt?.[1]) {
+            const [, { length }] = mt;
+            mt[0] = mt[0].slice(length);
+            mt.index += length;
+        }
+        const { 0: syntax, index: curIndex } = mt ?? { 0: '\n', index: text.length }, top = stack.pop() ?? {}, { 0: open, index, parts, findEqual: topFindEqual, pos: topPos } = top, innerEqual = syntax === '=' && topFindEqual;
+        if (syntax === ']]' || syntax === '}-') { // 情形1：闭合内链或转换
+            lastIndex = curIndex + 2;
+        }
+        else if (syntax === '\n') { // 情形2：闭合标题或文末
+            lastIndex = curIndex + 1;
+            const { pos, findEqual } = stack.at(-1) ?? {};
+            if (pos === undefined || findEqual || (0, string_1.removeComment)(text.slice(pos, index)) !== '') {
+                // eslint-disable-next-line regexp/no-misleading-capturing-group
+                const rmt = /^(={1,6})(.+)\1((?:\s|\0\d+c\x7F)*)$/u
+                    .exec(text.slice(index, curIndex));
+                if (rmt) {
+                    text = `${text.slice(0, index)}\0${accum.length}h\x7F${text.slice(curIndex)}`;
+                    lastIndex = index + 4 + String(accum.length).length;
+                    new HeadingToken(rmt[1].length, rmt.slice(2), config, accum);
+                }
+            }
+        }
+        else if (syntax === '|' || innerEqual) { // 情形3：模板内部，含行首单个'='
+            lastIndex = curIndex + 1;
+            parts.at(-1).push(text.slice(topPos, curIndex));
+            if (syntax === '|') {
+                parts.push([]);
+            }
+            top.pos = lastIndex;
+            top.findEqual = syntax === '|';
+            stack.push(top);
+        }
+        else if (syntax.startsWith('}}')) { // 情形4：闭合模板
+            const close = syntax.slice(0, Math.min(open.length, 3)), rest = open.length - close.length, { length } = accum;
+            lastIndex = curIndex + close.length; // 这不是最终的lastIndex
+            parts.at(-1).push(text.slice(topPos, curIndex));
+            let skip = false, ch = 't';
+            if (close.length === 3) {
+                const argParts = parts.map(part => part.join('=')), str = argParts.length > 1 && (0, string_1.removeComment)(argParts[1]).trim();
+                new ArgToken(argParts, config, accum);
+                if (str && str.endsWith(':') && subst.includes(str.slice(0, -1).toLowerCase())) {
+                    ch = 's';
+                }
+            }
+            else {
+                try {
+                    new TranscludeToken(parts[0][0], parts.slice(1), config, accum);
+                    const name = (0, string_1.removeComment)(parts[0][0]).trim();
+                    if (Object.hasOwn(marks, name)) {
+                        ch = marks[name]; // 标记{{!}}等
+                    }
+                    else if (/^(?:filepath|(?:full|canonical)urle?):.|^server$/iu.test(name)) {
+                        ch = 'm';
+                    }
+                    else if (/^#vardefine:./iu.test(name)) {
+                        ch = 'c';
+                    }
+                }
+                catch (e) {
+                    if (e instanceof SyntaxError && e.message.startsWith('非法的模板名称：')) {
+                        lastIndex = index + open.length;
+                        skip = true;
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            if (!skip) {
+                text = `${text.slice(0, index + rest)}\0${length}${ch}\x7F${text.slice(lastIndex)}`;
+                lastIndex = index + rest + 3 + String(length).length;
+                if (rest > 1) {
+                    stack.push({ 0: open.slice(0, rest), index: index, pos: index + rest, parts: [[]] });
+                }
+                else if (rest === 1 && text[index - 1] === '-') {
+                    stack.push({ 0: '-{', index: index - 1, pos: index + 1, parts: [[]] });
+                }
+            }
+        }
+        else { // 情形5：开启
+            lastIndex = curIndex + syntax.length;
+            if (syntax.startsWith('{')) {
+                mt.pos = lastIndex;
+                mt.parts = [[]];
+            }
+            stack.push(...'0' in top ? [top] : [], mt);
+        }
+        moreBraces &&= text.slice(lastIndex).includes('}}');
+        let curTop = stack.at(-1);
+        if (!moreBraces && curTop?.[0]?.startsWith('{')) {
+            stack.pop();
+            curTop = stack.at(-1);
+        }
+        regex = new RegExp(source + (curTop
+            ? `|${closes[curTop[0][0]]}${curTop.findEqual ? '|=' : ''}`
+            : ''), 'gmu');
+        regex.lastIndex = lastIndex;
+        mt = regex.exec(text);
+    }
+    return text;
+};
+Parser.parsers['parseBrackets'] = __filename;
+module.exports = parseBrackets;

package/dist/parser/commentAndExt.js

@@ -0,0 +1,48 @@
+"use strict";
+const Parser = require("../index");
+const OnlyincludeToken = require("../src/onlyinclude");
+const NoincludeToken = require("../src/nowiki/noinclude");
+const IncludeToken = require("../src/tagPair/include");
+const ExtToken = require("../src/tagPair/ext");
+const CommentToken = require("../src/nowiki/comment");
+/**
+ * 解析HTML注释和扩展标签
+ * @param includeOnly 是否嵌入
+ */
+const parseCommentAndExt = (wikitext, config = Parser.getConfig(), accum = [], includeOnly = false) => {
+    const onlyinclude = /<onlyinclude>(.*?)<\/onlyinclude>/gsu;
+    if (includeOnly && wikitext.search(onlyinclude) !== -1) { // `<onlyinclude>`拥有最高优先级
+        return wikitext.replace(onlyinclude, (_, inner) => {
+            const str = `\0${accum.length}e\x7F`;
+            new OnlyincludeToken(inner, config, accum);
+            return str;
+        }).replace(/(?<=^|\0\d+e\x7F)[^\0]+(?=$|\0\d+e\x7F)/gu, substr => {
+            new NoincludeToken(substr, config, accum);
+            return `\0${accum.length - 1}c\x7F`;
+        });
+    }
+    const ext = config.ext.join('|'), includeRegex = includeOnly ? 'includeonly' : '(?:no|only)include', noincludeRegex = includeOnly ? 'noinclude' : 'includeonly', regex = new RegExp('<!--.*?(?:-->|$)|' // comment
+        + `<${includeRegex}(?:\\s[^>]*?)?>|</${includeRegex}\\s*>|` // <includeonly>
+        + `<(${ext})(\\s[^>]*?)?(?:/>|>(.*?)</(\\1\\s*)>)|` // 扩展标签
+        + `<(${noincludeRegex})(\\s[^>]*?)?(?:/>|>(.*?)(?:</(\\5\\s*)>|$))`, // <noinclude>
+    'gisu');
+    return wikitext.replace(regex, (substr, name, attr, inner, closing, include, includeAttr, includeInner, includeClosing) => {
+        const str = `\0${accum.length}${name ? 'e' : 'c'}\x7F`;
+        if (name) {
+            new ExtToken(name, attr, inner, closing, config, accum);
+        }
+        else if (substr.startsWith('<!--')) {
+            const closed = substr.endsWith('-->');
+            new CommentToken(substr.slice(4, closed ? -3 : undefined), closed, config, accum);
+        }
+        else if (include) {
+            new IncludeToken(include, includeAttr, includeInner, includeClosing, config, accum);
+        }
+        else {
+            new NoincludeToken(substr, config, accum);
+        }
+        return str;
+    });
+};
+Parser.parsers['parseCommentAndExt'] = __filename;
+module.exports = parseCommentAndExt;

package/dist/parser/converter.js

@@ -0,0 +1,31 @@
+"use strict";
+const Parser = require("../index");
+const ConverterToken = require("../src/converter");
+/** 解析语言变体转换 */
+const parseConverter = (wikitext, config = Parser.getConfig(), accum = []) => {
+    const regex1 = /-\{/gu, regex2 = /-\{|\}-/gu, stack = [];
+    let regex = regex1, text = wikitext, mt = regex.exec(text);
+    while (mt) {
+        const { 0: syntax, index } = mt;
+        if (syntax === '}-') {
+            const top = stack.pop(), { length } = accum, str = text.slice(top.index + 2, index), i = str.indexOf('|'), [flags, raw] = i === -1 ? [[], str] : [str.slice(0, i).split(';'), str.slice(i + 1)], temp = raw.replace(/(&[#a-z\d]+);/giu, '$1\x01'), // eslint-disable-line regexp/prefer-lookaround
+            variants = `(?:${config.variants.join('|')})`, rules = temp.split(new RegExp(`;(?=\\s*(?:${variants}|[^;]*?=>\\s*${variants})\\s*:)`, 'u'))
+                .map(rule => rule.replaceAll('\x01', ';'));
+            new ConverterToken(flags, rules, config, accum);
+            text = `${text.slice(0, top.index)}\0${length}v\x7F${text.slice(index + 2)}`;
+            if (stack.length === 0) {
+                regex = regex1;
+            }
+            regex.lastIndex = top.index + 3 + String(length).length;
+        }
+        else {
+            stack.push(mt);
+            regex = regex2;
+            regex.lastIndex = index + 2;
+        }
+        mt = regex.exec(text);
+    }
+    return text;
+};
+Parser.parsers['parseConverter'] = __filename;
+module.exports = parseConverter;

package/dist/parser/externalLinks.js

@@ -0,0 +1,22 @@
+"use strict";
+const string_1 = require("../util/string");
+const Parser = require("../index");
+const ExtLinkToken = require("../src/extLink");
+/** 解析外部链接 */
+const parseExternalLinks = (wikitext, config = Parser.getConfig(), accum = []) => {
+    const regex = new RegExp(`\\[((?:(?:${config.protocol}|//)${string_1.extUrlCharFirst}|\0\\d+m\x7F)${string_1.extUrlChar})(\\p{Zs}*)([^\\]\x01-\x08\x0A-\x1F\uFFFD]*)\\]`, 'giu');
+    return wikitext.replace(regex, (_, url, space, text) => {
+        const { length } = accum, mt = /&[lg]t;/u.exec(url);
+        if (mt) {
+            /* eslint-disable no-param-reassign */
+            url = url.slice(0, mt.index);
+            space = '';
+            text = `${url.slice(mt.index)}${space}${text}`;
+            /* eslint-enable no-param-reassign */
+        }
+        new ExtLinkToken(url, space, text, config, accum);
+        return `\0${length}w\x7F`;
+    });
+};
+Parser.parsers['parseExternalLinks'] = __filename;
+module.exports = parseExternalLinks;

package/dist/parser/hrAndDoubleUnderscore.js

@@ -0,0 +1,35 @@
+"use strict";
+const Parser = require("../index");
+const HrToken = require("../src/nowiki/hr");
+const DoubleUnderscoreToken = require("../src/nowiki/doubleUnderscore");
+const HeadingToken = require("../src/heading");
+/**
+ * 解析`<hr>`和状态开关
+ * @param {Token} root 根节点
+ */
+const parseHrAndDoubleUnderscore = ({ firstChild, type, name }, config = Parser.getConfig(), accum = []) => {
+    const { doubleUnderscore } = config, insensitive = new Set(doubleUnderscore[0]), sensitive = new Set(doubleUnderscore[1]);
+    let { data } = firstChild;
+    if (type !== 'root' && (type !== 'ext-inner' || name !== 'poem')) {
+        data = `\0${data}`;
+    }
+    data = data.replace(/^((?:\0\d+c\x7F)*)(-{4,})/gmu, (_, lead, m) => {
+        new HrToken(m.length, config, accum);
+        return `${lead}\0${accum.length - 1}r\x7F`;
+    }).replace(new RegExp(`__(${doubleUnderscore.flat().join('|')})__`, 'giu'), (m, p1) => {
+        if (insensitive.has(p1.toLowerCase()) || sensitive.has(p1)) {
+            new DoubleUnderscoreToken(p1, config, accum);
+            return `\0${accum.length - 1}u\x7F`;
+        }
+        return m;
+    }).replace(
+    // eslint-disable-next-line regexp/no-misleading-capturing-group
+    /^((?:\0\d+c\x7F)*)(={1,6})(.+)\2((?:[^\S\n]|\0\d+c\x7F)*)$/gmu, (_, lead, equals, heading, trail) => {
+        const text = `${lead}\0${accum.length}h\x7F`;
+        new HeadingToken(equals.length, [heading, trail], config, accum);
+        return text;
+    });
+    return type === 'root' || type === 'ext-inner' && name === 'poem' ? data : data.slice(1);
+};
+Parser.parsers['parseHrAndDoubleUnderscore'] = __filename;
+module.exports = parseHrAndDoubleUnderscore;

package/dist/parser/html.js

@@ -0,0 +1,29 @@
+"use strict";
+const Parser = require("../index");
+const AttributesToken = require("../src/attributes");
+const HtmlToken = require("../src/html");
+/** 解析HTML标签 */
+const parseHtml = (wikitext, config = Parser.getConfig(), accum = []) => {
+    const regex = /^(\/?)([a-z][^\s/>]*)((?:\s|\/(?!>))[^>]*?)?(\/?>)([^<]*)$/iu, elements = new Set(config.html.flat()), bits = wikitext.split('<');
+    let text = bits.shift();
+    for (const x of bits) {
+        const mt = regex.exec(x), t = mt?.[2], name = t?.toLowerCase();
+        if (!mt || !elements.has(name)) {
+            text += `<${x}`;
+            continue;
+        }
+        const [, slash, , params = '', brace, rest] = mt, 
+        attr = new AttributesToken(params, 'html-attrs', name, config, accum), itemprop = attr.getAttr('itemprop');
+        if (name === 'meta' && (itemprop === undefined || attr.getAttr('content') === undefined)
+            || name === 'link' && (itemprop === undefined || attr.getAttr('href') === undefined)) {
+            text += `<${x}`;
+            accum.pop();
+            continue;
+        }
+        text += `\0${accum.length}x\x7F${rest}`;
+        new HtmlToken(t, attr, slash === '/', brace === '/>', config, accum);
+    }
+    return text;
+};
+Parser.parsers['parseHtml'] = __filename;
+module.exports = parseHtml;

package/dist/parser/links.js

@@ -0,0 +1,86 @@
+"use strict";
+const Parser = require("../index");
+const LinkToken = require("../src/link");
+const FileToken = require("../src/link/file");
+const CategoryToken = require("../src/link/category");
+/** 解析内部链接 */
+const parseLinks = (wikitext, config = Parser.getConfig(), accum = []) => {
+    const parseQuotes = require('./quotes.js');
+    const regex = /^((?:(?!\0\d+!\x7F)[^\n<>[\]{}|])+)(?:(\||\0\d+!\x7F)(.*?[^\]]))?\]\](.*)$/su, regexImg = /^((?:(?!\0\d+!\x7F)[^\n<>[\]{}|])+)(\||\0\d+!\x7F)(.*)$/su, regexExt = new RegExp(`^\\s*(?:${config.protocol})`, 'iu'), bits = wikitext.split('[[');
+    let s = bits.shift();
+    for (let i = 0; i < bits.length; i++) {
+        let mightBeImg = false, link, delimiter, text, after;
+        const x = bits[i], m = regex.exec(x);
+        if (m) {
+            [, link, delimiter, text, after] = m;
+            if (after.startsWith(']') && text?.includes('[')) {
+                text += ']';
+                after = after.slice(1);
+            }
+        }
+        else {
+            const m2 = regexImg.exec(x);
+            if (m2) {
+                mightBeImg = true;
+                [, link, delimiter, text] = m2;
+            }
+        }
+        if (link === undefined || regexExt.test(link) || /\0\d+[exhbru]\x7F/u.test(link)) {
+            s += `[[${x}`;
+            continue;
+        }
+        const force = link.trim().startsWith(':');
+        if (force && mightBeImg) {
+            s += `[[${x}`;
+            continue;
+        }
+        const title = Parser.normalizeTitle(link, 0, false, config, true, true, true), { ns, interwiki, valid } = title;
+        if (!valid) {
+            s += `[[${x}`;
+            continue;
+        }
+        else if (mightBeImg) {
+            if (interwiki || ns !== 6) {
+                s += `[[${x}`;
+                continue;
+            }
+            let found = false;
+            for (i++; i < bits.length; i++) {
+                const next = bits[i], p = next.split(']]');
+                if (p.length > 2) {
+                    found = true;
+                    text += `[[${p[0]}]]${p[1]}`;
+                    after = p.slice(2).join(']]');
+                    break;
+                }
+                else if (p.length === 2) {
+                    text += `[[${p[0]}]]${p[1]}`;
+                }
+                else {
+                    text += `[[${next}`;
+                    break;
+                }
+            }
+            text = parseLinks(text, config, accum);
+            if (!found) {
+                s += `[[${link}${delimiter}${text}`;
+                continue;
+            }
+        }
+        text &&= parseQuotes(text, config, accum);
+        s += `\0${accum.length}l\x7F${after}`;
+        let SomeLinkToken = LinkToken;
+        if (!force) {
+            if (!interwiki && ns === 6) {
+                SomeLinkToken = FileToken;
+            }
+            else if (!interwiki && ns === 14) {
+                SomeLinkToken = CategoryToken;
+            }
+        }
+        new SomeLinkToken(link, text, config, accum, delimiter);
+    }
+    return s;
+};
+Parser.parsers['parseLinks'] = __filename;
+module.exports = parseLinks;

package/dist/parser/list.js

@@ -0,0 +1,51 @@
+"use strict";
+const Parser = require("../index");
+const ListToken = require("../src/nowiki/list");
+const DdToken = require("../src/nowiki/dd");
+/** 解析列表 */
+const parseList = (wikitext, config = Parser.getConfig(), accum = []) => {
+    const mt = /^((?:\0\d+c\x7F)*)([;:*#]+)/u.exec(wikitext);
+    if (!mt) {
+        return wikitext;
+    }
+    const [total, comment, prefix] = mt;
+    let text = `${comment}\0${accum.length}d\x7F${wikitext.slice(total.length)}`, dt = prefix.split(';').length - 1;
+    new ListToken(prefix, config, accum);
+    if (!dt) {
+        return text;
+    }
+    let regex = /:+|-\{/gu, ex = regex.exec(text), lc = 0;
+    while (ex && dt) {
+        const { 0: syntax, index } = ex;
+        if (syntax.startsWith(':')) {
+            if (syntax.length >= dt) {
+                new DdToken(':'.repeat(dt), config, accum);
+                return `${text.slice(0, index)}\0${accum.length - 1}d\x7F${text.slice(index + dt)}`;
+            }
+            text = `${text.slice(0, index)}\0${accum.length}d\x7F${text.slice(regex.lastIndex)}`;
+            dt -= syntax.length;
+            regex.lastIndex = index + 4 + String(accum.length).length;
+            new DdToken(syntax, config, accum);
+        }
+        else if (syntax === '-{') {
+            if (!lc) {
+                const { lastIndex } = regex;
+                regex = /-\{|\}-/gu;
+                regex.lastIndex = lastIndex;
+            }
+            lc++;
+        }
+        else {
+            lc--;
+            if (!lc) {
+                const { lastIndex } = regex;
+                regex = /:+|-\{/gu;
+                regex.lastIndex = lastIndex;
+            }
+        }
+        ex = regex.exec(text);
+    }
+    return text;
+};
+Parser.parsers['parseList'] = __filename;
+module.exports = parseList;

package/dist/parser/magicLinks.js

@@ -0,0 +1,32 @@
+"use strict";
+const string_1 = require("../util/string");
+const Parser = require("../index");
+const MagicLinkToken = require("../src/magicLink");
+/** 解析自由外链 */
+const parseMagicLinks = (wikitext, config = Parser.getConfig(), accum = []) => {
+    const regex = new RegExp(`(?<![\\p{L}\\d_])(?:${config.protocol})(${string_1.extUrlCharFirst}${string_1.extUrlChar})`, 'giu');
+    return wikitext.replace(regex, (m, p1) => {
+        let trail = '', url = m;
+        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 = new RegExp(`[,;.:!?${url.includes('(') ? '' : ')'}]+$`, 'u'), sepChars = sep.exec(url);
+        if (sepChars) {
+            let correction = 0;
+            if (sepChars[0].startsWith(';') && /&(?:[a-z]+|#x[\da-f]+|#\d+)$/iu.test(url.slice(0, sepChars.index))) {
+                correction = 1;
+            }
+            trail = `${url.slice(sepChars.index + correction)}${trail}`;
+            url = url.slice(0, sepChars.index + correction);
+        }
+        if (trail.length >= p1.length) {
+            return m;
+        }
+        new MagicLinkToken(url, false, config, accum);
+        return `\0${accum.length - 1}w\x7F${trail}`;
+    });
+};
+Parser.parsers['parseMagicLinks'] = __filename;
+module.exports = parseMagicLinks;

package/dist/parser/quotes.js

@@ -0,0 +1,57 @@
+"use strict";
+const Parser = require("../index");
+const QuoteToken = require("../src/nowiki/quote");
+/** 解析单引号 */
+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) {
+                    break;
+                }
+                else if (arr[i - 1].endsWith(' ')) {
+                    if (!firstMulti && !firstSpace) {
+                        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;
+        arr[i] = `''`;
+        arr[i - 1] += `'`;
+    }
+    for (let i = 1; i < length; i += 2) {
+        new QuoteToken(arr[i].length, config, accum);
+        arr[i] = `\0${accum.length - 1}q\x7F`;
+    }
+    return arr.join('');
+};
+Parser.parsers['parseQuotes'] = __filename;
+module.exports = parseQuotes;

package/dist/parser/selector.js

@@ -0,0 +1,158 @@
+"use strict";
+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',
+    'local-link',
+    'read-only',
+    'read-write',
+    '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(['>', '+', '~', '']);
+/** 清理转义符号 */
+const sanitize = (selector) => {
+    let s = selector;
+    for (const [c, escaped] of specialChars) {
+        s = s.replaceAll(`\\${c}`, escaped);
+    }
+    return s;
+};
+/** 还原转义符号 */
+const desanitize = (selector) => {
+    let str = selector;
+    for (const [c, escaped] of specialChars) {
+        str = str.replaceAll(escaped, c);
+    }
+    return str.trim();
+};
+/**
+ * 去除首尾的引号
+ * @param val 属性值或伪选择器函数的参数
+ */
+const deQuote = (val) => {
+    const quotes = /^(["']).*\1$/u.exec(val)?.[1];
+    return quotes ? 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}`));
+};
+/**
+ * 解析选择器
+ * @throws `SyntaxError` 非法的选择器
+ */
+const parseSelector = (selector) => {
+    const s = selector.trim(), stack = [[[]]];
+    let sanitized = sanitize(s), 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${s}\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：伪选择器闭合
+            const pseudo = step.pop();
+            mt.push(pseudo);
+            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${s}\n检测到未闭合的'${regex === attributeRegex ? '[' : '('}'`);
+};
+Parser.parsers['parseSelector'] = __filename;
+module.exports = parseSelector;