wikilint 2.43.0 → 2.45.0

package/dist/mixin/paramLineParent.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.paramLineParent = void 0;
+const debug_1 = require("../util/debug");
+const lint_1 = require("../util/lint");
+const rect_1 = require("../lib/rect");
+const index_1 = __importDefault(require("../index"));
+/**
+ * 子节点为ParamLineToken的类
+ * @ignore
+ */
+const paramLineParent = (constructor) => {
+    LINT: {
+        class ParamLineParent extends constructor {
+            getKeys() {
+                return new Set(this.childNodes.map(({ key }) => key).filter((key) => key !== undefined));
+            }
+            getParams(key) {
+                return this.childNodes.filter(({ key: k }) => k === key);
+            }
+            getDuplicatedParams() {
+                return [...this.getKeys()].map((key) => [key, this.getParams(key)])
+                    .filter(([, { length }]) => length > 1);
+            }
+            lint(start = this.getAbsoluteIndex()) {
+                const errors = super.lint(start), { name, firstChild } = this, rule = 'no-duplicate', { lintConfig } = index_1.default, s = lintConfig.getSeverity(rule, name);
+                if (s) {
+                    const msg = index_1.default.msg('duplicate-ext-parameter', name), rect = new rect_1.BoundingRect(this, start), { computeEditInfo } = lintConfig;
+                    for (const [, params] of this.getDuplicatedParams()) {
+                        const duplication = Array.from({ length: params.length });
+                        for (let i = params.length - 1; i >= 0; i--) {
+                            const param = params[i], e = (0, lint_1.generateForChild)(param, rect, rule, msg, s);
+                            if (computeEditInfo) {
+                                e.suggestions = [(0, lint_1.fixByRemove)(e, param === firstChild ? 0 : -1)];
+                            }
+                            duplication[i] = e;
+                        }
+                        Array.prototype.push.apply(errors, duplication);
+                    }
+                }
+                return errors;
+            }
+        }
+        (0, debug_1.mixin)(ParamLineParent, constructor);
+        return ParamLineParent;
+    }
+};
+exports.paramLineParent = paramLineParent;

package/dist/parser/converter.js

@@ -9,7 +9,7 @@ const converter_1 = require("../src/converter");
  * @param accum
  */
 const parseConverter = (text, config, accum) => {
-    config.regexConverter ??= new RegExp(String.raw `;(?=(?:[^;]*?=>)?\s*(?:${config.variants.join('|')})\s*:|(?:\s|\0\d+[cn]\x7F)*$)`, 'iu');
+    config.regexConverter ??= new RegExp(String.raw `;(?=(?:[^;]*?=>)?\s*(?:${config.variants.join('|')})\s*:|(?:\s|\0\d+[cn]\x7F)*$)`, 'u');
     const regex1 = /-\{/gu, regex2 = /-\{|\}-/gu, stack = [];
     let regex = regex1, mt = regex.exec(text);
     while (mt) {

package/dist/src/arg.js

@@ -38,7 +38,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 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 padded_1 = require("../mixin/padded");
@@ -99,11 +98,17 @@ let ArgToken = (() => {
         }
         /** @private */
         text() {
-            return `{{{${(0, string_1.text)(this.childNodes.slice(0, 2), '|')}}}}`;
+            // eslint-disable-next-line @typescript-eslint/no-useless-default-assignment
+            const { length, childNodes, name = this.#getName() } = this;
+            return length === 1 ? `{{{${name}}}}` : `{{{${name}|${childNodes[1].text()}}}}`;
+        }
+        /** 获取name */
+        #getName() {
+            return this.firstChild.text().trim();
         }
         /** 更新name */
         #setName() {
-            LSP: this.setAttribute('name', this.firstChild.text().trim());
+            LSP: this.setAttribute('name', this.#getName());
         }
         /** @private */
         afterBuild() {
@@ -113,44 +118,21 @@ let ArgToken = (() => {
         /** @private */
         lint(start = this.getAbsoluteIndex(), re) {
             LINT: {
-                const [argName, argDefault, ...rest] = this.childNodes;
-                argName.setAttribute('aIndex', start + 3);
-                const errors = argName.lint(start + 3, re);
-                if (argDefault) {
-                    const index = start + 4 + argName.toString().length;
-                    argDefault.setAttribute('aIndex', index);
-                    const childErrors = argDefault.lint(index, re);
-                    if (childErrors.length > 0) {
-                        Array.prototype.push.apply(errors, childErrors);
-                    }
-                }
-                const rules = ['no-ignored', 'no-arg'], { lintConfig } = index_1.default, { computeEditInfo } = lintConfig, rect = new rect_1.BoundingRect(this, start), s = rules.map(rule => lintConfig.getSeverity(rule, 'arg'));
-                if (s[0] && rest.length > 0) {
-                    Array.prototype.push.apply(errors, rest.map(child => {
-                        const e = (0, lint_1.generateForChild)(child, rect, rules[0], 'invisible-triple-braces', s[0]);
-                        e.startIndex--;
-                        e.startCol--;
-                        if (computeEditInfo) {
-                            e.suggestions = [
-                                (0, lint_1.fixByRemove)(e),
-                                (0, lint_1.fixByEscape)(e.startIndex, '{{!}}'),
-                            ];
-                        }
-                        return e;
-                    }));
-                }
-                if (s[1] && !this.getAttribute('include')) {
-                    const e = (0, lint_1.generateForSelf)(this, rect, rules[1], 'unexpected-argument', s[1]);
-                    if (computeEditInfo && argDefault) {
+                const errors = super.lint(start, re), { lintConfig } = index_1.default, rect = new rect_1.BoundingRect(this, start);
+                let rule = 'no-arg', s = lintConfig.getSeverity(rule);
+                if (s && !this.getAttribute('include')) {
+                    const e = (0, lint_1.generateForSelf)(this, rect, rule, 'unexpected-argument', s), [, argDefault] = this.childNodes;
+                    if (lintConfig.computeEditInfo && argDefault) {
                         e.suggestions = [(0, lint_1.fixBy)(e, 'expand', argDefault.text())];
                     }
                     errors.push(e);
                 }
                 const ext = this.closest('ext');
                 if (ext) {
-                    const rule = 'arg-in-ext', severity = lintConfig.getSeverity(rule, ext.name);
-                    if (severity) {
-                        errors.push((0, lint_1.generateForSelf)(this, rect, rule, 'argument-in-ext', severity));
+                    rule = 'arg-in-ext';
+                    s = lintConfig.getSeverity(rule, ext.name);
+                    if (s) {
+                        errors.push((0, lint_1.generateForSelf)(this, rect, rule, 'argument-in-ext', s));
                     }
                 }
                 return errors;

package/dist/src/atom.d.ts

@@ -1,6 +1,6 @@
 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", "invoke-function", "invoke-module", "template-name", "link-target"];
+declare const atomTypes: readonly ["arg-name", "attr-key", "attr-value", "ext-attr-dirty", "html-attr-dirty", "table-attr-dirty", "converter-flag", "converter-rule-variant", "invoke-function", "invoke-module", "template-name", "link-target", "param-line-key", "param-line-value"];
 declare type AtomTypes = typeof atomTypes[number];
 /**
  * plain Token that will not be parsed further

package/dist/src/atom.js

@@ -16,6 +16,8 @@ const atomTypes = [
     'invoke-module',
     'template-name',
     'link-target',
+    'param-line-key',
+    'param-line-value',
 ];
 /**
  * plain Token that will not be parsed further

package/dist/src/attribute.js

@@ -14,7 +14,7 @@ const index_2 = require("./index");
 const atom_1 = require("./atom");
 /* NOT FOR BROWSER ONLY */
 const document_1 = require("../lib/document");
-const insecureStyle = /expression|(?:accelerator|-o-link(?:-source)?|-o-replace)\s*:|(?:url|src|image(?:-set)?)\s*\(|attr\s*\([^)]+[\s,]url/u, evil = /(?:^|\s|\*\/)(?:java|vb)script(?:\W|$)/iu, complexTypes = new Set(['ext', 'arg', 'magic-word', 'template']), urlAttrs = new Set([
+const insecureStyle = /expression|(?:accelerator|-o-link(?:-source)?|-o-replace)\s*:|(?:url|src|image(?:-set)?)\s*\(|attr\s*\([^)]+[\s,]url/u, evil = /(?:^|\s|\*\/)(?:java|vb)script(?:\W|$)/iu, complexTypes = new Set(['ext', 'arg', 'magic-word', 'template']), itemAttrs = new Set(['itemtype', 'itemid', 'itemref']), urlAttrs = new Set([
     'about',
     'property',
     'resource',
@@ -88,9 +88,13 @@ class AttributeToken extends index_2.Token {
         this.#tag = tag;
         this.setAttribute('name', (0, string_1.trimLc)((0, string_1.removeComment)(key)));
     }
+    /** 获取name */
+    #getName() {
+        return (0, string_1.trimLc)(this.firstChild.text());
+    }
     /** 更新name */
     #setName() {
-        this.setAttribute('name', (0, string_1.trimLc)(this.firstChild.text()));
+        this.setAttribute('name', this.#getName());
     }
     /** @private */
     afterBuild() {
@@ -110,7 +114,9 @@ class AttributeToken extends index_2.Token {
     }
     /** @private */
     text() {
-        return this.#equal ? `${super.text(`${this.#equal.trim()}"`)}"` : this.firstChild.text();
+        // eslint-disable-next-line @typescript-eslint/no-useless-default-assignment
+        const { lastChild, name = this.#getName() } = this;
+        return this.#equal ? `${name}${this.#equal.trim()}"${lastChild.text()}"` : name;
     }
     /** @private */
     getGaps() {
@@ -138,8 +144,7 @@ class AttributeToken extends index_2.Token {
                 // 或非通用HTML属性
                 || !/^(?:xmlns:[\w:.-]+|data-(?!ooui|mw|parsoid)[^:_]*)$/u.test(name)
                     && (tag === 'meta' || tag === 'link' || !sharable_1.commonHtmlAttrs.has(name)))
-            || (name === 'itemtype' || name === 'itemid' || name === 'itemref')
-                && !parentNode?.hasAttr('itemscope')) {
+            || itemAttrs.has(name) && !parentNode?.hasAttr('itemscope')) {
             LINT: {
                 const s = lintConfig.getSeverity(rule, 'unknown');
                 if (s) {

package/dist/src/attributes.d.ts

@@ -1,3 +1,4 @@
+import { BoundingRect } from '../lib/rect';
 import { Token } from './index';
 import { AtomToken } from './atom';
 import { AttributeToken } from './attribute';

package/dist/src/attributes.js

@@ -124,10 +124,8 @@ class AttributesToken extends index_2.Token {
      * @param key attribute name / 属性名
      */
     getAttrToken(key) {
-        LINT: {
-            const tokens = this.getAttrTokens(key);
-            return tokens[tokens.length - 1];
-        }
+        const tokens = this.getAttrTokens(key);
+        return tokens[tokens.length - 1];
     }
     /**
      * Get the attribute
@@ -136,7 +134,7 @@ class AttributesToken extends index_2.Token {
      * @param key attribute name / 属性键
      */
     getAttr(key) {
-        LINT: return this.getAttrToken(key)?.getValue();
+        return this.getAttrToken(key)?.getValue();
     }
     /** 是否位于闭合标签内 */
     #lint() {
@@ -144,9 +142,24 @@ class AttributesToken extends index_2.Token {
         return parentNode?.type === 'html' && parentNode.closing && this.text().trim() !== '';
     }
     /** @private */
+    lintRef(rect, severity) {
+        LINT: {
+            const followAttr = this.getAttrToken('follow'), follow = followAttr?.getValue(), name = this.getAttr('name'), rule = 'invalid-ref';
+            if (follow && !/\D/u.test(follow)) {
+                const msg = 'int-name';
+                return rect ? (0, lint_1.generateForChild)(followAttr, rect, rule, msg, severity) : msg;
+            }
+            else if (follow && (this.hasAttr('details') || name && /\D/u.test(name))) {
+                const msg = 'ref-follow';
+                return rect ? (0, lint_1.generateForSelf)(this, rect, rule, msg, severity) : msg;
+            }
+            return '';
+        }
+    }
+    /** @private */
     lint(start = this.getAbsoluteIndex(), re) {
         LINT: {
-            const errors = super.lint(start, re), { parentNode, childNodes, type, name: tag } = this, attrs = new Map(), duplicated = new Set(), rect = new rect_1.BoundingRect(this, start), rules = ['no-ignored', 'required-attr', 'no-duplicate'], { lintConfig } = index_1.default, { computeEditInfo, fix } = lintConfig, s = ['closingTag', 'invalidAttributes', 'nonWordAttributes']
+            const errors = super.lint(start, re), { parentNode, childNodes, type, name: tag } = this, attrs = new Map(), duplicated = new Set(), rect = new rect_1.BoundingRect(this, start), rules = ['no-ignored', 'required-attr', 'invalid-ref', 'no-duplicate'], { lintConfig } = index_1.default, { computeEditInfo, fix } = lintConfig, s = ['closingTag', 'invalidAttributes', 'nonWordAttributes']
                 .map(k => lintConfig.getSeverity(rules[0], k));
             if (s[0] && this.#lint()) {
                 const e = (0, lint_1.generateForSelf)(this, rect, rules[0], 'attributes-of-closing-tag', s[0]);
@@ -192,23 +205,36 @@ class AttributesToken extends index_2.Token {
                     }
                 }
             }
-            const severity = lintConfig.getSeverity(rules[2], 'attribute');
+            if (tag === 'ref') {
+                const severity = lintConfig.getSeverity(rules[2]);
+                if (severity) {
+                    const e = this.lintRef(rect, severity);
+                    if (e) {
+                        errors.push(e);
+                    }
+                }
+            }
+            const severity = lintConfig.getSeverity(rules[3], 'attribute');
             if (severity && duplicated.size > 0) {
                 for (const key of duplicated) {
-                    const pairs = attrs.get(key).map(attr => [attr, attr.getValue()]);
-                    Array.prototype.push.apply(errors, pairs.map(([attr, value], i) => {
-                        const e = (0, lint_1.generateForChild)(attr, rect, rules[2], index_1.default.msg('duplicate-attribute', key), severity);
+                    const pairs = attrs.get(key).map(attr => [attr, attr.getValue()]), duplication = Array.from({ length: pairs.length }), values = new Set();
+                    for (let i = pairs.length - 1; i >= 0; i--) {
+                        const [attr, value] = pairs[i], e = (0, lint_1.generateForChild)(attr, rect, rules[3], index_1.default.msg('duplicate-attribute', key), severity);
                         if (computeEditInfo || fix) {
                             const remove = (0, lint_1.fixByRemove)(e);
-                            if (!value || pairs.slice(0, i).some(([, v]) => v === value)) {
+                            if (!value || values.has(value)) {
                                 e.fix = remove;
                             }
-                            else if (computeEditInfo) {
-                                e.suggestions = [remove];
+                            else {
+                                values.add(value);
+                                if (computeEditInfo) {
+                                    e.suggestions = [remove];
+                                }
                             }
                         }
-                        return e;
-                    }));
+                        duplication[i] = e;
+                    }
+                    Array.prototype.push.apply(errors, duplication);
                 }
             }
             return errors;

package/dist/src/commented.d.ts

@@ -7,6 +7,7 @@ import type { AstText, AttributesToken, ExtToken } from '../internal';
  * @classdesc `{childNodes: (AstText|CommentToken)[]}`
  */
 export declare abstract class CommentedToken extends Token {
+    readonly name: 'hiero';
     readonly childNodes: readonly (CommentToken | AstText)[];
     abstract get firstChild(): CommentToken | AstText | undefined;
     abstract get lastChild(): CommentToken | AstText | undefined;

package/dist/src/commented.js

@@ -13,9 +13,7 @@ class CommentedToken extends index_1.Token {
     }
     /** @class */
     constructor(wikitext, config, accum = []) {
-        super(undefined, config, accum, {
-            AstText: ':', CommentToken: ':',
-        });
+        super(undefined, config, accum, {});
         if (wikitext) {
             let i = wikitext.indexOf('<!--'), j = i !== -1 && wikitext.indexOf('-->', i + 4), lastIndex = 0;
             while (j !== false && j !== -1) {

package/dist/src/converterFlags.js

@@ -39,6 +39,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConverterFlagsToken = void 0;
 const lint_1 = require("../util/lint");
+const string_1 = require("../util/string");
 const rect_1 = require("../lib/rect");
 const gapped_1 = require("../mixin/gapped");
 const noEscape_1 = require("../mixin/noEscape");
@@ -76,9 +77,13 @@ let ConverterFlagsToken = (() => {
             super(undefined, config, accum, {});
             this.safeAppend(flags.map(flag => new atom_1.AtomToken(flag, 'converter-flag', config, accum)));
         }
+        /** 获取全部转换类型标记 */
+        #getFlags() {
+            return this.childNodes.map(child => child.text().trim());
+        }
         /** @private */
         afterBuild() {
-            this.#flags = this.childNodes.map(child => child.text().trim());
+            this.#flags = this.#getFlags();
             super.afterBuild();
         }
         /** @private */
@@ -87,7 +92,7 @@ let ConverterFlagsToken = (() => {
         }
         /** @private */
         text() {
-            return super.text(';');
+            return (this.#flags ?? this.#getFlags()).join(';');
         }
         /**
          * Get unknown language conversion flags
@@ -97,20 +102,24 @@ let ConverterFlagsToken = (() => {
         getUnknownFlags() {
             return new Set(this.#flags.filter(flag => /\{{3}[^{}]+\}{3}/u.test(flag)));
         }
+        /** 从解析设置中获取语言变体 */
+        #getVariants() {
+            return new Set((0, string_1.toLowerCase)(this.getAttribute('config').variants));
+        }
         /**
          * Get language coversion flags that specify a language variant
          *
          * 获取指定语言变体的转换标记
          */
         getVariantFlags() {
-            const variants = new Set(this.getAttribute('config').variants);
-            return new Set(this.#flags.filter(flag => variants.has(flag)));
+            const variants = this.#getVariants();
+            return new Set((0, string_1.toLowerCase)(this.#flags).filter(flag => variants.has(flag)));
         }
         /** @private */
         // eslint-disable-next-line @typescript-eslint/class-methods-use-this
         isInvalidFlag(flag, variant, unknown) {
             return Boolean(flag)
-                && !variant.has(flag)
+                && !variant.has(flag.toLowerCase())
                 && !unknown.has(flag)
                 && (variant.size > 0 || !definedFlags.has(flag));
         }
@@ -124,9 +133,9 @@ let ConverterFlagsToken = (() => {
                 }
                 const rule = 'no-ignored', s = lintConfig.getSeverity(rule, 'conversionFlag');
                 if (s) {
-                    const rect = new rect_1.BoundingRect(this, start);
-                    for (let i = 0; i < this.length; i++) {
-                        const child = this.childNodes[i], flag = child.text().trim();
+                    const rect = new rect_1.BoundingRect(this, start), { childNodes, length } = this;
+                    for (let i = 0; i < length; i++) {
+                        const child = childNodes[i], flag = child.text().trim();
                         if (this.isInvalidFlag(flag, variantFlags, unknownFlags)) {
                             const e = (0, lint_1.generateForChild)(child, rect, rule, 'invalid-conversion-flag', s);
                             if (computeEditInfo || fix) {

package/dist/src/converterRule.js

@@ -87,7 +87,7 @@ let ConverterRuleToken = (() => {
         constructor(rule, hasColon = true, config = index_1.default.getConfig(), accum = []) {
             super(undefined, config, accum, {});
             const i = rule.indexOf(':'), j = rule.slice(0, i).indexOf('=>'), v = j === -1 ? rule.slice(0, i) : rule.slice(j + 2, i);
-            if (hasColon && config.variants.includes(v.trim().toLowerCase())) {
+            if (hasColon && config.variants.includes(v.trim())) {
                 super.insertAt(new atom_1.AtomToken(v, 'converter-rule-variant', config, accum));
                 super.insertAt(getRuleFromTo(rule.slice(i + 1), 'to', config, accum));
                 if (j !== -1) {
@@ -109,8 +109,8 @@ let ConverterRuleToken = (() => {
         text() {
             const { childNodes, firstChild, lastChild } = this;
             return childNodes.length === 3
-                ? `${firstChild.text()}=>${childNodes[1].text()}:${lastChild.text()}`
-                : super.text(':');
+                ? `${firstChild.text().trim()}=>${childNodes[1].text().trim()}:${lastChild.text().trim()}`
+                : childNodes.map(child => child.text().trim()).join(':');
         }
         /** @private */
         getGaps(i) {

package/dist/src/funcTag.d.ts

@@ -0,0 +1,23 @@
+import { Token } from './index';
+import { ParamLineToken } from './paramLine';
+import type { Config } from '../base';
+import type { AttributesToken, ExtToken } from '../internal';
+import type { ParamLineParentBase } from '../mixin/paramLineParent';
+export interface FuncTagToken extends ParamLineParentBase {
+}
+/**
+ * `<seo>`
+ * @classdesc `{childNodes: ParamLineToken[]}`
+ */
+export declare abstract class FuncTagToken extends Token {
+    readonly name: 'seo';
+    readonly childNodes: readonly ParamLineToken[];
+    abstract get firstChild(): ParamLineToken | undefined;
+    abstract get lastChild(): ParamLineToken | undefined;
+    abstract get nextSibling(): undefined;
+    abstract get previousSibling(): AttributesToken | undefined;
+    abstract get parentNode(): ExtToken | undefined;
+    get type(): 'ext-inner';
+    /** @class */
+    constructor(wikitext: string | undefined, config: Config, accum: Token[]);
+}

package/dist/src/funcTag.js

@@ -0,0 +1,85 @@
+"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.FuncTagToken = void 0;
+const paramLineParent_1 = require("../mixin/paramLineParent");
+const index_1 = require("./index");
+const paramLine_1 = require("./paramLine");
+const gapped_1 = require("../mixin/gapped");
+/**
+ * `<seo>`
+ * @classdesc `{childNodes: ParamLineToken[]}`
+ */
+let FuncTagToken = (() => {
+    let _classDecorators = [(0, gapped_1.gapped)(), paramLineParent_1.paramLineParent];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = index_1.Token;
+    var FuncTagToken = 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);
+            FuncTagToken = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        get type() {
+            return 'ext-inner';
+        }
+        /** @class */
+        constructor(wikitext, config, accum) {
+            super(undefined, config, accum, {});
+            if (wikitext) {
+                for (const parameter of wikitext.split('|')) {
+                    // @ts-expect-error abstract class
+                    this.insertAt(new paramLine_1.ParamLineToken('seo', parameter, config, accum));
+                }
+            }
+        }
+        /** @private */
+        toString(skip) {
+            return super.toString(skip, '|');
+        }
+        /** @private */
+        text() {
+            return this.childNodes.map(child => child.text()).filter(Boolean).join('|');
+        }
+    };
+    return FuncTagToken = _classThis;
+})();
+exports.FuncTagToken = FuncTagToken;

package/dist/src/heading.js

@@ -100,7 +100,7 @@ let HeadingToken = (() => {
         /** @private */
         text() {
             const equals = this.#getEquals();
-            return equals + this.firstChild.text() + equals;
+            return equals + this.firstChild.text().trim() + equals;
         }
         /** @private */
         getAttribute(key) {
@@ -110,10 +110,15 @@ let HeadingToken = (() => {
         getGaps() {
             return this.level;
         }
+        /** 是否包含未成对的`=` */
+        #lint() {
+            const innerStr = this.firstChild.toString(), unbalancedStart = innerStr.startsWith('=');
+            return unbalancedStart ? 1 : innerStr.endsWith('=');
+        }
         /** @private */
         lint(start = this.getAbsoluteIndex(), re) {
             LINT: {
-                const errors = super.lint(start, re), { firstChild, level } = this, innerStr = firstChild.toString(), unbalancedStart = innerStr.startsWith('='), unbalanced = unbalancedStart || innerStr.endsWith('='), rect = new rect_1.BoundingRect(this, start), s = this.inHtmlAttrs(), rules = ['h1', 'unbalanced-header', 'format-leakage'], { lintConfig } = index_1.default, { computeEditInfo, fix } = lintConfig, severities = rules.map(rule => lintConfig.getSeverity(rule, 'apostrophe'));
+                const errors = super.lint(start, re), { firstChild, level } = this, innerStr = firstChild.toString(), unbalanced = this.#lint(), rect = new rect_1.BoundingRect(this, start), s = this.inHtmlAttrs(), rules = ['h1', 'unbalanced-header', 'format-leakage'], { lintConfig } = index_1.default, { computeEditInfo, fix } = lintConfig, severities = rules.map(rule => lintConfig.getSeverity(rule, 'apostrophe'));
                 if (severities[0] && this.level === 1) {
                     const e = (0, lint_1.generateForChild)(firstChild, rect, rules[0], '<h1>', severities[0]);
                     if (computeEditInfo && !unbalanced) {
@@ -126,7 +131,7 @@ let HeadingToken = (() => {
                     if (!computeEditInfo || innerStr === '=') {
                         //
                     }
-                    else if (unbalancedStart) {
+                    else if (unbalanced === 1) {
                         const extra = (0, common_1.numLeadingSpaces)(innerStr, /[^=]|$/u), newLevel = level + extra;
                         e.suggestions = [{ desc: `h${level}`, range: [e.startIndex, e.startIndex + extra], text: '' }];
                         if (newLevel < 7) {

package/dist/src/hidden.d.ts

@@ -1,8 +1,9 @@
 import { Token } from './index';
+import type { LintError } from '../base';
 /**
- * invisible token
+ * invisible token in triple braces
  *
- * 不可见的节点
+ * 三重括号内不可见的节点
  */
 export declare class HiddenToken extends Token {
     get type(): 'hidden';

package/dist/src/hidden.js

@@ -33,22 +33,27 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     return useValue ? value : void 0;
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HiddenToken = void 0;
+const lint_1 = require("../util/lint");
 const hidden_1 = require("../mixin/hidden");
 const noEscape_1 = require("../mixin/noEscape");
-const index_1 = require("./index");
+const index_1 = __importDefault(require("../index"));
+const index_2 = require("./index");
 /**
- * invisible token
+ * invisible token in triple braces
  *
- * 不可见的节点
+ * 三重括号内不可见的节点
  */
 let HiddenToken = (() => {
-    let _classDecorators = [(0, hidden_1.hiddenToken)(), noEscape_1.noEscape];
+    let _classDecorators = [(0, hidden_1.hiddenToken)(false), noEscape_1.noEscape];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    let _classSuper = index_1.Token;
+    let _classSuper = index_2.Token;
     var HiddenToken = class extends _classSuper {
         static { _classThis = this; }
         static {
@@ -61,6 +66,25 @@ let HiddenToken = (() => {
         get type() {
             return 'hidden';
         }
+        /** @private */
+        lint(start = this.getAbsoluteIndex()) {
+            LINT: {
+                const rule = 'no-ignored', { lintConfig } = index_1.default, s = lintConfig.getSeverity(rule, 'arg');
+                if (s) {
+                    const e = (0, lint_1.generateForSelf)(this, { start }, rule, 'invisible-triple-braces', s);
+                    e.startIndex--;
+                    e.startCol--;
+                    if (lintConfig.computeEditInfo) {
+                        e.suggestions = [
+                            (0, lint_1.fixByRemove)(e),
+                            (0, lint_1.fixByEscape)(e.startIndex, '{{!}}'),
+                        ];
+                    }
+                    return [e];
+                }
+                return [];
+            }
+        }
     };
     return HiddenToken = _classThis;
 })();