wikiparser-node 1.13.2-b → 1.13.3

package/dist/src/arg.js

@@ -0,0 +1,220 @@
+"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 rect_1 = require("../lib/rect");
+const index_1 = require("../index");
+const index_2 = require("./index");
+const atom_1 = require("./atom");
+const hidden_1 = require("./hidden");
+/* NOT FOR BROWSER */
+const constants_1 = require("../util/constants");
+const debug_1 = require("../util/debug");
+const html_1 = require("../util/html");
+/* NOT FOR BROWSER END */
+/**
+ * `{{{}}}`包裹的参数
+ * @classdesc `{childNodes: [AtomToken, ?Token, ...HiddenToken]}`
+ */
+class ArgToken extends index_2.Token {
+    /* NOT FOR BROWSER END */
+    get type() {
+        return '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 = index_1.default.getConfig(), accum = []) {
+        super(undefined, config, accum, {
+            AtomToken: 0, Token: 1, HiddenToken: '2:',
+        });
+        for (const [i, part] of parts.entries()) {
+            if (i === 0) {
+                const token = new atom_1.AtomToken(part, 'arg-name', config, accum, {
+                    'Stage-2': ':', '!HeadingToken': '',
+                });
+                super.insertAt(token);
+            }
+            else if (i > 1) {
+                const token = new hidden_1.HiddenToken(part, config, accum);
+                super.insertAt(token);
+            }
+            else {
+                const token = new index_2.Token(part, config, accum);
+                token.type = 'arg-default';
+                token.setAttribute('stage', 2);
+                super.insertAt(token);
+            }
+        }
+        /* NOT FOR BROWSER */
+        this.protectChildren(0);
+    }
+    /** @private */
+    toString(skip) {
+        return `{{{${super.toString(skip, '|')}}}}`;
+    }
+    /** @private */
+    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;
+    }
+    /** 设置name */
+    #setName() {
+        this.setAttribute('name', this.firstChild.toString(true).trim());
+    }
+    /** @private */
+    afterBuild() {
+        this.#setName();
+        super.afterBuild();
+        /* NOT FOR BROWSER */
+        const /** @implements */ argListener = ({ prevTarget }) => {
+            if (prevTarget === this.firstChild) {
+                this.#setName();
+            }
+        };
+        this.addEventListener(['remove', 'insert', 'replace', 'text'], argListener);
+    }
+    /** @private */
+    lint(start = this.getAbsoluteIndex(), re) {
+        const { childNodes: [argName, argDefault, ...rest] } = this;
+        if (!this.getAttribute('include')) {
+            const e = (0, lint_1.generateForSelf)(this, { start }, 'no-arg', 'unexpected template argument');
+            if (argDefault) {
+                e.fix = { range: [start, e.endIndex], text: argDefault.text() };
+            }
+            return [e];
+        }
+        const errors = argName.lint(start + 3, re);
+        if (argDefault) {
+            errors.push(...argDefault.lint(start + 4 + argName.toString().length, re));
+        }
+        if (rest.length > 0) {
+            const rect = new rect_1.BoundingRect(this, start);
+            errors.push(...rest.map(child => {
+                const e = (0, lint_1.generateForChild)(child, rect, 'no-ignored', 'invisible content inside triple braces');
+                e.startIndex--;
+                e.startCol--;
+                e.suggestions = [
+                    {
+                        desc: 'remove',
+                        range: [e.startIndex, e.endIndex],
+                        text: '',
+                    },
+                    {
+                        desc: 'escape',
+                        range: [e.startIndex, e.startIndex + 1],
+                        text: '{{!}}',
+                    },
+                ];
+                return e;
+            }));
+        }
+        return errors;
+    }
+    /** @private */
+    print() {
+        return super.print({ pre: '{{{', post: '}}}', sep: '|' });
+    }
+    /* NOT FOR BROWSER */
+    cloneNode() {
+        const [name, ...cloned] = this.cloneChildNodes();
+        return debug_1.Shadow.run(() => {
+            // @ts-expect-error abstract class
+            const token = new ArgToken([''], this.getAttribute('config'));
+            token.firstChild.safeReplaceWith(name);
+            token.append(...cloned);
+            return token;
+        });
+    }
+    /** 移除无效部分 */
+    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 插入位置
+     */
+    insertAt(token, i = this.length) {
+        i += i < 0 ? this.length : 0;
+        if (debug_1.Shadow.running) {
+            //
+        }
+        else if (i > 1) {
+            this.constructorError('cannot insert redundant child nodes');
+        }
+        else if (typeof token === 'string') {
+            this.constructorError('cannot insert text nodes');
+        }
+        super.insertAt(token, i);
+        if (i === 1) {
+            token.type = 'arg-default';
+        }
+        return token;
+    }
+    /**
+     * 设置参数名
+     * @param name 新参数名
+     */
+    setName(name) {
+        const { childNodes } = index_1.default.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 = index_1.default.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);
+        }
+    }
+    /** @private */
+    toHtmlInternal(nowrap, nocc) {
+        if (this.length === 1) {
+            const html = (0, html_1.font)(this, this.toString());
+            return nowrap ? html.replaceAll('\n', ' ') : html;
+        }
+        return (0, html_1.font)(this, this.childNodes[1].toHtmlInternal(nowrap, nocc));
+    }
+}
+exports.ArgToken = ArgToken;
+constants_1.classes['ArgToken'] = __filename;

package/dist/src/atom.d.ts

@@ -0,0 +1,14 @@
+import { Token } from './index';
+import type { Config } from '../base';
+declare const atomTypes: readonly ["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"];
+declare type AtomTypes = typeof atomTypes[number];
+/** 不会被继续解析的plain Token */
+export declare class AtomToken extends Token {
+    #private;
+    get type(): AtomTypes;
+    set type(value: AtomTypes);
+    /** @class */
+    constructor(wikitext: string | undefined, type: AtomTypes, config?: Config, accum?: Token[], acceptable?: Acceptable);
+    cloneNode(): this;
+}
+export {};

package/dist/src/atom.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AtomToken = void 0;
+const index_1 = require("./index");
+/* NOT FOR BROWSER */
+const debug_1 = require("../util/debug");
+const constants_1 = require("../util/constants");
+/* NOT FOR BROWSER END */
+const 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 */
+class AtomToken extends index_1.Token {
+    #type;
+    get type() {
+        return this.#type;
+    }
+    set type(value) {
+        if (!atomTypes.includes(value)) {
+            throw new RangeError(`"${value}" is not a valid type for AtomToken!`);
+        }
+        this.#type = value;
+    }
+    /** @class */
+    constructor(wikitext, type, config, accum, acceptable) {
+        super(wikitext, config, accum, acceptable);
+        this.#type = type;
+    }
+    /* NOT FOR BROWSER */
+    cloneNode() {
+        const cloned = this.cloneChildNodes(), config = this.getAttribute('config'), acceptable = this.getAcceptable();
+        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;

package/dist/src/attribute.d.ts

@@ -0,0 +1,64 @@
+import Parser from '../index';
+import { Token } from './index';
+import { AtomToken } from './atom';
+import type { LintError } from '../base';
+import type { AttributesToken } from '../internal';
+export type AttributeTypes = 'ext-attr' | 'html-attr' | 'table-attr';
+/**
+ * 扩展和HTML标签属性
+ * @classdesc `{childNodes: [AtomToken, Token|AtomToken]}`
+ */
+export declare abstract class AttributeToken extends Token {
+    #private;
+    readonly name: string;
+    readonly childNodes: readonly [AtomToken, Token];
+    abstract get firstChild(): AtomToken;
+    abstract get lastChild(): Token;
+    abstract get parentNode(): AttributesToken | undefined;
+    abstract get nextSibling(): AtomToken | this | undefined;
+    abstract get previousSibling(): AtomToken | this | undefined;
+    abstract get children(): [AtomToken, Token];
+    abstract get firstElementChild(): AtomToken;
+    abstract get lastElementChild(): Token;
+    abstract get parentElement(): AttributesToken | undefined;
+    abstract get nextElementSibling(): AtomToken | this | undefined;
+    abstract get previousElementSibling(): AtomToken | this | undefined;
+    get type(): AttributeTypes;
+    /** 标签名 */
+    get tag(): string;
+    /** 引号是否匹配 */
+    get balanced(): boolean;
+    set balanced(value: boolean);
+    /** getValue()的getter */
+    get value(): string | true;
+    set value(value: string | true);
+    /**
+     * @param type 标签类型
+     * @param tag 标签名
+     * @param key 属性名
+     * @param equal 等号
+     * @param value 属性值
+     * @param quotes 引号
+     */
+    constructor(type: AttributeTypes, tag: string, key: string, equal?: string, value?: string, quotes?: readonly [string?, string?], config?: Parser.Config, accum?: Token[]);
+    /** 获取属性值 */
+    getValue(): string | true;
+    cloneNode(): this;
+    /** 转义等号 */
+    escape(): void;
+    /** 闭合引号 */
+    close(): void;
+    /**
+     * 设置属性值
+     * @param value 参数值
+     * @throws `RangeError` 扩展标签属性不能包含 ">"
+     * @throws `RangeError` 同时包含单引号和双引号
+     */
+    setValue(value: string | boolean): void;
+    /**
+     * 修改属性名
+     * @param key 新属性名
+     * @throws `Error` title和alt属性不能更名
+     */
+    rename(key: string): void;
+}

package/dist/src/attribute.js

@@ -0,0 +1,326 @@
+"use strict";
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttributeToken = void 0;
+const lint_1 = require("../util/lint");
+const string_1 = require("../util/string");
+const constants_1 = require("../util/constants");
+const sharable_1 = require("../util/sharable");
+const rect_1 = require("../lib/rect");
+const index_1 = require("../index");
+const index_2 = require("./index");
+const atom_1 = require("./atom");
+/* NOT FOR BROWSER */
+const debug_1 = require("../util/debug");
+const fixed_1 = require("../mixin/fixed");
+const stages = { 'ext-attr': 0, 'html-attr': 2, 'table-attr': 3 };
+const insecureStyle = /expression|(?:accelerator|-o-link(?:-source)?|-o-replace)\s*:|(?:url|image(?:-set)?)\s*\(|attr\s*\([^)]+[\s,]url/u;
+/**
+ * 扩展和HTML标签属性
+ * @classdesc `{childNodes: [AtomToken, Token|AtomToken]}`
+ */
+let AttributeToken = (() => {
+    let _classDecorators = [fixed_1.fixedToken];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = index_2.Token;
+    var AttributeToken = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            AttributeToken = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        #type;
+        #tag;
+        #equal;
+        #quotes;
+        /* NOT FOR BROWSER END */
+        get type() {
+            return this.#type;
+        }
+        /** 标签名 */
+        get tag() {
+            return this.#tag;
+        }
+        /** 引号是否匹配 */
+        get balanced() {
+            return !this.#equal || this.#quotes[0] === this.#quotes[1];
+        }
+        /* NOT FOR BROWSER */
+        set balanced(value) {
+            if (value) {
+                this.close();
+            }
+        }
+        /** getValue()的getter */
+        get value() {
+            return this.getValue();
+        }
+        set value(value) {
+            this.setValue(value);
+        }
+        /* NOT FOR BROWSER END */
+        /**
+         * @param type 标签类型
+         * @param tag 标签名
+         * @param key 属性名
+         * @param equal 等号
+         * @param value 属性值
+         * @param quotes 引号
+         */
+        constructor(type, tag, key, equal = '', value, quotes = [], config = index_1.default.getConfig(), accum = []) {
+            const keyToken = new atom_1.AtomToken(key, 'attr-key', config, accum, type === 'ext-attr' ? { AstText: ':' } : { 'Stage-2': ':', '!ExtToken': '', '!HeadingToken': '' });
+            let valueToken;
+            if (key === 'title' || tag === 'img' && key === 'alt') {
+                valueToken = new index_2.Token(value, config, accum, {
+                    [`Stage-${stages[type]}`]: ':', ConverterToken: ':',
+                });
+                valueToken.type = 'attr-value';
+                valueToken.setAttribute('stage', constants_1.MAX_STAGE - 1);
+            }
+            else if (tag === 'gallery' && key === 'caption'
+                || tag === 'choose' && (key === 'before' || key === 'after')) {
+                const newConfig = {
+                    ...config,
+                    excludes: [...config.excludes, 'heading', 'html', 'table', 'hr', 'list'],
+                };
+                valueToken = new index_2.Token(value, newConfig, accum, {
+                    AstText: ':',
+                    ArgToken: ':',
+                    TranscludeToken: ':',
+                    LinkToken: ':',
+                    FileToken: ':',
+                    CategoryToken: ':',
+                    QuoteToken: ':',
+                    ExtLinkToken: ':',
+                    MagicLinkToken: ':',
+                    ConverterToken: ':',
+                });
+                valueToken.type = 'attr-value';
+                valueToken.setAttribute('stage', 1);
+            }
+            else {
+                valueToken = new atom_1.AtomToken(value, 'attr-value', config, accum, {
+                    [`Stage-${stages[type]}`]: ':',
+                });
+            }
+            super(undefined, config, accum);
+            this.#type = type;
+            this.append(keyToken, valueToken);
+            this.#equal = equal;
+            this.#quotes = [...quotes];
+            this.#tag = tag;
+            this.setAttribute('name', (0, string_1.removeComment)(key).trim().toLowerCase());
+        }
+        /** @private */
+        afterBuild() {
+            if (this.#equal.includes('\0')) {
+                this.#equal = this.buildFromStr(this.#equal, constants_1.BuildMethod.String);
+            }
+            if (this.parentNode) {
+                this.#tag = this.parentNode.name;
+            }
+            this.setAttribute('name', this.firstChild.toString(true).trim().toLowerCase());
+            super.afterBuild();
+        }
+        /** @private */
+        toString(skip) {
+            const [quoteStart = '', quoteEnd = ''] = this.#quotes;
+            return this.#equal ? super.toString(skip, this.#equal + quoteStart) + quoteEnd : this.firstChild.toString(skip);
+        }
+        /** @private */
+        text() {
+            return this.#equal ? `${super.text(`${this.#equal.trim()}"`)}"` : this.firstChild.text();
+        }
+        /** @private */
+        getGaps() {
+            return this.#equal ? this.#equal.length + (this.#quotes[0]?.length ?? 0) : 0;
+        }
+        /** @private */
+        lint(start = this.getAbsoluteIndex(), re) {
+            const errors = super.lint(start, re), { balanced, firstChild, lastChild, type, name, tag } = this, value = this.getValue(), rect = new rect_1.BoundingRect(this, start);
+            if (!balanced) {
+                const e = (0, lint_1.generateForChild)(lastChild, rect, 'unclosed-quote', index_1.default.msg('unclosed $1', 'quotes'), 'warning');
+                e.startIndex--;
+                e.startCol--;
+                const fix = { range: [e.endIndex, e.endIndex], text: this.#quotes[0] };
+                if (lastChild.childNodes.some(({ type: t, data }) => t === 'text' && /\s/u.test(data))) {
+                    e.suggestions = [
+                        {
+                            desc: 'close',
+                            ...fix,
+                        },
+                    ];
+                }
+                else {
+                    e.fix = fix;
+                }
+                errors.push(e);
+            }
+            const attrs = sharable_1.extAttrs[tag], attrs2 = sharable_1.htmlAttrs[tag];
+            if (!attrs?.has(name)
+                && !attrs2?.has(name)
+                // 不是未定义的扩展标签或包含嵌入的HTML标签
+                && (type === 'ext-attr' ? attrs || attrs2 : !/\{\{[^{]+\}\}/u.test(name))
+                && (type === 'ext-attr' && !attrs2
+                    || !/^(?:xmlns:[\w:.-]+|data-(?!ooui|mw|parsoid)[^:]*)$/u.test(name)
+                        && (tag === 'meta' || tag === 'link' || !sharable_1.commonHtmlAttrs.has(name)))) {
+                errors.push((0, lint_1.generateForChild)(firstChild, rect, 'illegal-attr', 'illegal attribute name'));
+            }
+            else if (sharable_1.obsoleteAttrs[tag]?.has(name)) {
+                errors.push((0, lint_1.generateForChild)(firstChild, rect, 'obsolete-attr', 'obsolete attribute', 'warning'));
+            }
+            else if (name === 'style' && typeof value === 'string' && insecureStyle.test(value)) {
+                errors.push((0, lint_1.generateForChild)(lastChild, rect, 'insecure-style', 'insecure style'));
+            }
+            else if (name === 'tabindex' && typeof value === 'string' && value !== '0') {
+                const e = (0, lint_1.generateForChild)(lastChild, rect, 'illegal-attr', 'nonzero tabindex');
+                e.suggestions = [
+                    {
+                        desc: 'remove',
+                        range: [start, e.endIndex],
+                        text: '',
+                    },
+                    {
+                        desc: '0 tabindex',
+                        range: [e.startIndex, e.endIndex],
+                        text: '0',
+                    },
+                ];
+                errors.push(e);
+            }
+            return errors;
+        }
+        /** 获取属性值 */
+        getValue() {
+            return this.#equal ? this.lastChild.text().trim() : this.type === 'ext-attr' || '';
+        }
+        /** @private */
+        print() {
+            const [quoteStart = '', quoteEnd = ''] = this.#quotes;
+            return this.#equal ? super.print({ sep: (0, string_1.escape)(this.#equal) + quoteStart, post: quoteEnd }) : super.print();
+        }
+        /* NOT FOR BROWSER */
+        cloneNode() {
+            const [key, value] = this.cloneChildNodes(), k = key.toString(), config = this.getAttribute('config');
+            return debug_1.Shadow.run(() => {
+                // @ts-expect-error abstract class
+                const token = new AttributeToken(this.type, this.tag, k, this.#equal, '', this.#quotes, config);
+                token.firstChild.safeReplaceWith(key);
+                token.lastChild.safeReplaceWith(value);
+                return token;
+            });
+        }
+        /** 转义等号 */
+        escape() {
+            this.#equal = '{{=}}';
+        }
+        /** 闭合引号 */
+        close() {
+            const [opening] = this.#quotes;
+            if (opening) {
+                this.#quotes[1] = opening;
+            }
+        }
+        /**
+         * 设置属性值
+         * @param value 参数值
+         * @throws `RangeError` 扩展标签属性不能包含 ">"
+         * @throws `RangeError` 同时包含单引号和双引号
+         */
+        setValue(value) {
+            if (value === false) {
+                this.remove();
+                return;
+            }
+            else if (value === true) {
+                this.#equal = '';
+                return;
+            }
+            else if (this.type === 'ext-attr' && value.includes('>')) {
+                throw new RangeError('Attributes of an extension tag cannot contain ">"!');
+            }
+            else if (value.includes('"') && value.includes(`'`)) {
+                throw new RangeError('Attribute values cannot contain single and double quotes simultaneously!');
+            }
+            const config = this.getAttribute('config'), { childNodes } = index_1.default.parse(value, this.getAttribute('include'), stages[this.type] + 1, config);
+            this.lastChild.replaceChildren(...childNodes);
+            if (value.includes('"')) {
+                this.#quotes = [`'`, `'`];
+            }
+            else if (value.includes(`'`) || !this.#quotes[0]) {
+                this.#quotes = ['"', '"'];
+            }
+            else {
+                this.close();
+            }
+        }
+        /**
+         * 修改属性名
+         * @param key 新属性名
+         * @throws `Error` title和alt属性不能更名
+         */
+        rename(key) {
+            if (this.name === 'title' || this.name === 'alt' && this.tag === 'img') {
+                throw new Error(`${this.name} attribute cannot be renamed!`);
+            }
+            const config = this.getAttribute('config'), { childNodes } = index_1.default.parse(key, this.getAttribute('include'), stages[this.type] + 1, config);
+            this.firstChild.replaceChildren(...childNodes);
+        }
+        /** @private */
+        toHtmlInternal() {
+            const { type, name, tag, lastChild } = this;
+            if (type === 'ext-attr' && !(tag in sharable_1.htmlAttrs)
+                || !sharable_1.htmlAttrs[tag]?.has(name)
+                    && !/^(?:xmlns:[\w:.-]+|data-(?!ooui|mw|parsoid)[^:]*)$/u.test(name)
+                    && (tag === 'meta' || tag === 'link' || !sharable_1.commonHtmlAttrs.has(name))) {
+                return '';
+            }
+            const value = lastChild.toHtmlInternal().trim();
+            if (name === 'style' && insecureStyle.test(value) || name === 'tabindex' && value !== '0') {
+                return '';
+            }
+            return `${name}="${(0, string_1.sanitizeAttr)(value.replace(/\s+|&#10;/gu, name === 'id' ? '_' : ' '))}"`;
+        }
+    };
+    return AttributeToken = _classThis;
+})();
+exports.AttributeToken = AttributeToken;
+constants_1.classes['AttributeToken'] = __filename;