wikiparser-node 1.24.1 → 1.25.1

package/dist/lib/text.js

@@ -52,13 +52,13 @@ const constants_1 = require("../util/constants");
 const readOnly_1 = require("../mixin/readOnly");
 const cached_1 = require("../mixin/cached");
 /* NOT FOR BROWSER END */
-const sp = String.raw `[${string_1.zs}\t]*`, anySp = String.raw `[^\S\n]*`, source = String.raw `<${anySp}(?:/${anySp})?([a-z]\w*)|\{+|\}+|\[{2,}|\[(?![^[]*?\])|((?:^|\])[^[]*?)\]+|(?:rfc|pmid)(?=[-:：]?${sp}\d)|isbn(?=[-:：]?${sp}(?:\d(?:${sp}|-)){6})`;
+const sp = /* #__PURE__ */ (() => String.raw `[${string_1.zs}\t]*`)(), anySp = /* #__PURE__ */ (() => String.raw `[^\S\n]*`)(), source = /* #__PURE__ */ (() => String.raw `<${anySp}(?:/${anySp})?([a-z]\w*)|\{+|\}+|\[{2,}|\[(?![^[]*?\])|((?:^|\])[^[]*?)\]+|(?:rfc|pmid)(?=[-:：]?${sp}\d)|isbn(?=[-:：]?${sp}(?:\d(?:${sp}|-)){6})`)();
 // eslint-disable-next-line @typescript-eslint/no-unused-expressions
 /<[^\S\n]*(?:\/[^\S\n]*)?([a-z]\w*)|\{+|\}+|\[{2,}|\[(?![^[]*?\])|((?:^|\])[^[]*?)\]+|https?[:/]\/+/giu;
-const errorSyntax = new RegExp(String.raw `${source}|https?[:/]/+`, 'giu');
+const errorSyntax = /* #__PURE__ */ (() => new RegExp(String.raw `${source}|https?[:/]/+`, 'giu'))();
 // eslint-disable-next-line @typescript-eslint/no-unused-expressions
 /^https?:\/\/(?:\[[\da-f:.]+\]|[^[\]<>"\t\n\p{Zs}])[^[\]<>"\t\n\p{Zs}]*\.(?:gif|png|jpg|jpeg)$/iu;
-const errorSyntaxUrl = new RegExp(source, 'giu'), noLinkTypes = new Set(['attr-value', 'ext-link-text', 'link-text']), regexes = {
+const errorSyntaxUrl = /* #__PURE__ */ new RegExp(source, 'giu'), noLinkTypes = new Set(['attr-value', 'ext-link-text', 'link-text']), regexes = {
     '[': /[[\]]/u,
     '{': /[{}]/u,
     ']': /[[\]](?=[^[\]]*$)/u,
@@ -115,14 +115,15 @@ const errorSyntaxUrl = new RegExp(source, 'giu'), noLinkTypes = new Set(['attr-v
     'param',
     'xmp',
 ]);
-let wordRegex;
-try {
-    // eslint-disable-next-line prefer-regex-literals
-    wordRegex = new RegExp(String.raw `[\p{L}\p{N}_]`, 'u');
-}
-catch /* istanbul ignore next */ {
-    wordRegex = /\w/u;
-}
+const wordRegex = /* #__PURE__ */ (() => {
+    try {
+        // eslint-disable-next-line prefer-regex-literals
+        return new RegExp(String.raw `[\p{L}\p{N}_]`, 'u');
+    }
+    catch /* istanbul ignore next */ {
+        return /\w/u;
+    }
+})();
 /**
  * text node
  *
@@ -191,184 +192,186 @@ let AstText = (() => {
         }
         /** @private */
         lint(start = this.getAbsoluteIndex(), errorRegex) {
-            if (errorRegex === false) {
-                return [];
-            }
-            const { data, parentNode, nextSibling, previousSibling } = this;
-            /* istanbul ignore if */
-            if (!parentNode) {
-                throw new Error('An isolated text node cannot be linted!');
-            }
-            const { type, name, parentNode: grandparent } = parentNode;
-            if (type === 'attr-value') {
-                const { name: grandName, tag } = grandparent;
-                if (tag === 'ref' && (grandName === 'name' || grandName === 'follow')
-                    || grandName === 'group' && (tag === 'ref' || tag === 'references')
-                    || tag === 'choose' && (grandName === 'before' || grandName === 'after')) {
+            LINT: { // eslint-disable-line no-unused-labels
+                if (errorRegex === false) {
                     return [];
                 }
-            }
-            errorRegex ??= type === 'free-ext-link'
-                || type === 'ext-link-url'
-                || type === 'ext-link-text'
-                || type === 'image-parameter' && name === 'link'
-                || type === 'attr-value'
-                ? errorSyntaxUrl
-                : errorSyntax;
-            if (data.search(errorRegex) === -1) {
-                return [];
-            }
-            errorRegex.lastIndex = 0;
-            const errors = [], nextType = nextSibling?.type, nextName = nextSibling?.name, previousType = previousSibling?.type, root = this.getRootNode(), rootStr = root.toString(), { ext, html, variants } = root.getAttribute('config'), { top, left } = root.posFromIndex(start), lintConfig = index_1.default.lintConfig['tag-like'], specified = typeof lintConfig === 'number'
-                ? new Set()
-                : new Set(Object.keys(lintConfig[1]).filter(tag => tag !== 'invalid' && tag !== 'disallowed')), tags = new Set([
-                'onlyinclude',
-                'noinclude',
-                'includeonly',
-                ...ext,
-                ...html[0],
-                ...html[1],
-                ...html[2],
-                ...specified,
-                ...disallowedTags,
-            ]);
-            for (let mt = errorRegex.exec(data); mt; mt = errorRegex.exec(data)) {
-                const [, tag, prefix] = mt;
-                let { index, 0: error } = mt;
-                if (prefix && prefix !== ']') {
-                    const { length } = prefix;
-                    index += length;
-                    error = error.slice(length);
-                }
-                error = error.toLowerCase();
-                const [char] = error, magicLink = char === 'r' || char === 'p' || char === 'i', lbrace = char === '{', rbrace = char === '}', lbrack = char === '[', rbrack = char === ']';
-                let { length } = error;
-                if (char === '<' && !tags.has(tag.toLowerCase())
-                    || lbrack && type === 'ext-link-text' && (/&(?:rbrack|#93|#x5[Dd];);/u.test(data.slice(index + 1))
-                        || nextSibling?.is('ext') && nextName === 'nowiki'
-                            && nextSibling.innerText?.includes(']'))
-                    || magicLink && (!parentNode.isPlain() || noLinkTypes.has(type))) {
-                    continue;
+                const { data, parentNode, nextSibling, previousSibling } = this;
+                /* istanbul ignore if */
+                if (!parentNode) {
+                    throw new Error('An isolated text node cannot be linted!');
                 }
-                else if (rbrack && (index || length > 1)) {
-                    errorRegex.lastIndex--;
+                const { type, name, parentNode: grandparent } = parentNode;
+                if (type === 'attr-value') {
+                    const { name: grandName, tag } = grandparent;
+                    if (tag === 'ref' && (grandName === 'name' || grandName === 'follow')
+                        || grandName === 'group' && (tag === 'ref' || tag === 'references')
+                        || tag === 'choose' && (grandName === 'before' || grandName === 'after')) {
+                        return [];
+                    }
                 }
-                // Rule & Severity
-                let startIndex = start + index, endIndex = startIndex + length, rule, severity;
-                const nextChar = rootStr[endIndex], previousChar = rootStr[startIndex - 1], leftBracket = lbrace || lbrack, lConverter = lbrace && previousChar === '-' && variants.length > 0, rConverter = rbrace && nextChar === '-' && variants.length > 0, brokenExtLink = lbrack && nextType === 'free-ext-link' && !data.slice(index + 1).trim()
-                    || rbrack && previousType === 'free-ext-link'
-                        && !data.slice(0, index).includes(']');
-                if (magicLink) {
-                    rule = 'lonely-http';
-                    error = error.toUpperCase();
-                    severity = index_1.default.lintConfig.getSeverity(rule, error);
+                errorRegex ??= type === 'free-ext-link'
+                    || type === 'ext-link-url'
+                    || type === 'ext-link-text'
+                    || type === 'image-parameter' && name === 'link'
+                    || type === 'attr-value'
+                    ? errorSyntaxUrl
+                    : errorSyntax;
+                if (data.search(errorRegex) === -1) {
+                    return [];
                 }
-                else if (char === '<') {
-                    rule = 'tag-like';
-                    let key;
-                    if (/^<\/?\s/u.test(error) || !/[\s/>]/u.test(nextChar ?? '')) {
-                        key = 'invalid';
+                errorRegex.lastIndex = 0;
+                const errors = [], nextType = nextSibling?.type, nextName = nextSibling?.name, previousType = previousSibling?.type, root = this.getRootNode(), rootStr = root.toString(), { ext, html, variants } = root.getAttribute('config'), { top, left } = root.posFromIndex(start), lintConfig = index_1.default.lintConfig['tag-like'], specified = typeof lintConfig === 'number'
+                    ? new Set()
+                    : new Set(Object.keys(lintConfig[1]).filter(tag => tag !== 'invalid' && tag !== 'disallowed')), tags = new Set([
+                    'onlyinclude',
+                    'noinclude',
+                    'includeonly',
+                    ...ext,
+                    ...html[0],
+                    ...html[1],
+                    ...html[2],
+                    ...specified,
+                    ...disallowedTags,
+                ]);
+                for (let mt = errorRegex.exec(data); mt; mt = errorRegex.exec(data)) {
+                    const [, tag, prefix] = mt;
+                    let { index, 0: error } = mt;
+                    if (prefix && prefix !== ']') {
+                        const { length } = prefix;
+                        index += length;
+                        error = error.slice(length);
                     }
-                    else if (specified.has(tag)) {
-                        key = tag;
+                    error = error.toLowerCase();
+                    const [char] = error, magicLink = char === 'r' || char === 'p' || char === 'i', lbrace = char === '{', rbrace = char === '}', lbrack = char === '[', rbrack = char === ']';
+                    let { length } = error;
+                    if (char === '<' && !tags.has(tag.toLowerCase())
+                        || lbrack && type === 'ext-link-text' && (/&(?:rbrack|#93|#x5[Dd];);/u.test(data.slice(index + 1))
+                            || nextSibling?.is('ext') && nextName === 'nowiki'
+                                && nextSibling.innerText?.includes(']'))
+                        || magicLink && (!parentNode.isPlain() || noLinkTypes.has(type))) {
+                        continue;
                     }
-                    else if (disallowedTags.has(tag) && !ext.includes(tag)) {
-                        key = 'disallowed';
+                    else if (rbrack && (index || length > 1)) {
+                        errorRegex.lastIndex--;
                     }
-                    severity = index_1.default.lintConfig.getSeverity(rule, key);
-                }
-                else if (lConverter || rConverter) {
-                    rule = 'lonely-bracket';
-                    severity = index_1.default.lintConfig.getSeverity(rule, 'converter');
-                    if (lConverter && index > 0) {
-                        error = '-{';
-                        index--;
-                        startIndex--;
-                        length = 2;
+                    // Rule & Severity
+                    let startIndex = start + index, endIndex = startIndex + length, rule, severity;
+                    const nextChar = rootStr[endIndex], previousChar = rootStr[startIndex - 1], leftBracket = lbrace || lbrack, lConverter = lbrace && previousChar === '-' && variants.length > 0, rConverter = rbrace && nextChar === '-' && variants.length > 0, brokenExtLink = lbrack && nextType === 'free-ext-link' && !data.slice(index + 1).trim()
+                        || rbrack && previousType === 'free-ext-link'
+                            && !data.slice(0, index).includes(']');
+                    if (magicLink) {
+                        rule = 'lonely-http';
+                        error = error.toUpperCase();
+                        severity = index_1.default.lintConfig.getSeverity(rule, error);
                     }
-                    else if (rConverter && index < data.length - 1) {
-                        error = '}-';
-                        endIndex++;
-                        length = 2;
+                    else if (char === '<') {
+                        rule = 'tag-like';
+                        let key;
+                        if (/^<\/?\s/u.test(error) || !/[\s/>]/u.test(nextChar ?? '')) {
+                            key = 'invalid';
+                        }
+                        else if (specified.has(tag)) {
+                            key = tag;
+                        }
+                        else if (disallowedTags.has(tag) && !ext.includes(tag)) {
+                            key = 'disallowed';
+                        }
+                        severity = index_1.default.lintConfig.getSeverity(rule, key);
                     }
-                }
-                else if (brokenExtLink) {
-                    rule = 'lonely-bracket';
-                    severity = index_1.default.lintConfig.getSeverity(rule, 'extLink');
-                }
-                else if (leftBracket || rbrace || rbrack) {
-                    rule = 'lonely-bracket';
-                    if (length > 1 || lbrace && nextChar === char || rbrace && previousChar === char) {
-                        severity = index_1.default.lintConfig.getSeverity(rule, 'double');
+                    else if (lConverter || rConverter) {
+                        rule = 'lonely-bracket';
+                        severity = index_1.default.lintConfig.getSeverity(rule, 'converter');
+                        if (lConverter && index > 0) {
+                            error = '-{';
+                            index--;
+                            startIndex--;
+                            length = 2;
+                        }
+                        else if (rConverter && index < data.length - 1) {
+                            error = '}-';
+                            endIndex++;
+                            length = 2;
+                        }
                     }
-                    else {
-                        if (!lbrack || type !== 'ext-link-text') {
-                            const regex = regexes[char], remains = leftBracket ? data.slice(index + 1) : data.slice(0, index);
-                            if (lbrace && regex.exec(remains)?.[0] === '}'
-                                || rbrace && regex.exec(remains)?.[0] === '{') {
-                                continue;
-                            }
-                            else if (!remains.includes(char)) {
-                                const sibling = leftBracket ? 'nextSibling' : 'previousSibling';
-                                let cur = this[sibling];
-                                while (cur && (cur.type !== 'text' || !regex.test(cur.data))) {
-                                    cur = cur[sibling];
-                                }
-                                if (cur && regex.exec(cur.data)[0] !== char) {
+                    else if (brokenExtLink) {
+                        rule = 'lonely-bracket';
+                        severity = index_1.default.lintConfig.getSeverity(rule, 'extLink');
+                    }
+                    else if (leftBracket || rbrace || rbrack) {
+                        rule = 'lonely-bracket';
+                        if (length > 1 || lbrace && nextChar === char || rbrace && previousChar === char) {
+                            severity = index_1.default.lintConfig.getSeverity(rule, 'double');
+                        }
+                        else {
+                            if (!lbrack || type !== 'ext-link-text') {
+                                const regex = regexes[char], remains = leftBracket ? data.slice(index + 1) : data.slice(0, index);
+                                if (lbrace && regex.exec(remains)?.[0] === '}'
+                                    || rbrace && regex.exec(remains)?.[0] === '{') {
                                     continue;
                                 }
+                                else if (!remains.includes(char)) {
+                                    const sibling = leftBracket ? 'nextSibling' : 'previousSibling';
+                                    let cur = this[sibling];
+                                    while (cur && (cur.type !== 'text' || !regex.test(cur.data))) {
+                                        cur = cur[sibling];
+                                    }
+                                    if (cur && regex.exec(cur.data)[0] !== char) {
+                                        continue;
+                                    }
+                                }
                             }
+                            severity = index_1.default.lintConfig.getSeverity(rule, 'single');
                         }
-                        severity = index_1.default.lintConfig.getSeverity(rule, 'single');
                     }
+                    else {
+                        rule = 'lonely-http';
+                        severity = index_1.default.lintConfig.getSeverity(rule);
+                    }
+                    if (!severity) {
+                        continue;
+                    }
+                    // LintError
+                    const pos = this.posFromIndex(index), { line: startLine, character: startCol } = (0, lint_1.getEndPos)(top, left, pos.top + 1, pos.left), e = {
+                        rule,
+                        message: index_1.default.msg('lonely', magicLink || char === 'h' || lConverter || rConverter ? error : char),
+                        severity,
+                        startIndex,
+                        endIndex,
+                        startLine,
+                        endLine: startLine,
+                        startCol,
+                        endCol: startCol + length,
+                    };
+                    // Suggestions
+                    if (char === '<') {
+                        e.suggestions = [(0, lint_1.fixByEscape)(startIndex, '&lt;')];
+                    }
+                    else if (char === 'h' && type !== 'link-text' && wordRegex.test(previousChar || '')) {
+                        e.suggestions = [(0, lint_1.fixBySpace)(startIndex)];
+                    }
+                    else if (lbrack && type === 'ext-link-text') {
+                        const i = parentNode.getAbsoluteIndex() + parentNode.toString().length;
+                        e.suggestions = [(0, lint_1.fixByEscape)(i, '&#93;')];
+                    }
+                    else if (rbrack && brokenExtLink) {
+                        const i = start - previousSibling.toString().length;
+                        e.suggestions = [(0, lint_1.fixByInsert)(i, 'left-bracket', '[')];
+                    }
+                    else if (magicLink) {
+                        e.suggestions = [
+                            ...mt[0] === error
+                                ? []
+                                : [(0, lint_1.fixByUpper)(e, error)],
+                            ...nextChar === ':' || nextChar === '：'
+                                ? [(0, lint_1.fixBySpace)(endIndex, 1)]
+                                : [],
+                        ];
+                    }
+                    errors.push(e);
                 }
-                else {
-                    rule = 'lonely-http';
-                    severity = index_1.default.lintConfig.getSeverity(rule);
-                }
-                if (!severity) {
-                    continue;
-                }
-                // LintError
-                const pos = this.posFromIndex(index), { line: startLine, character: startCol } = (0, lint_1.getEndPos)(top, left, pos.top + 1, pos.left), e = {
-                    rule,
-                    message: index_1.default.msg('lonely "$1"', magicLink || char === 'h' || lConverter || rConverter ? error : char),
-                    severity,
-                    startIndex,
-                    endIndex,
-                    startLine,
-                    endLine: startLine,
-                    startCol,
-                    endCol: startCol + length,
-                };
-                // Suggestions
-                if (char === '<') {
-                    e.suggestions = [(0, lint_1.fixByEscape)(startIndex, '&lt;')];
-                }
-                else if (char === 'h' && type !== 'link-text' && wordRegex.test(previousChar || '')) {
-                    e.suggestions = [(0, lint_1.fixBySpace)(startIndex)];
-                }
-                else if (lbrack && type === 'ext-link-text') {
-                    const i = parentNode.getAbsoluteIndex() + parentNode.toString().length;
-                    e.suggestions = [(0, lint_1.fixByEscape)(i, '&#93;')];
-                }
-                else if (rbrack && brokenExtLink) {
-                    const i = start - previousSibling.toString().length;
-                    e.suggestions = [(0, lint_1.fixByInsert)(i, 'left bracket', '[')];
-                }
-                else if (magicLink) {
-                    e.suggestions = [
-                        ...mt[0] === error
-                            ? []
-                            : [(0, lint_1.fixByUpper)(e, error)],
-                        ...nextChar === ':' || nextChar === '：'
-                            ? [(0, lint_1.fixBySpace)(endIndex, 1)]
-                            : [],
-                    ];
-                }
-                errors.push(e);
+                return errors;
             }
-            return errors;
         }
         /**
          * 修改内容

package/dist/mixin/hidden.js

@@ -64,7 +64,7 @@ const hiddenToken = (linter = true, html = true) => (constructor) => {
             }
             lint(start) {
                 // @ts-expect-error private argument
-                return linter ? [] : super.lint(start);
+                LINT: return linter ? [] : super.lint(start); // eslint-disable-line no-unused-labels
             }
             /* NOT FOR BROWSER */
             dispatchEvent() {

package/dist/mixin/noEscape.js

@@ -10,15 +10,17 @@ const constants_1 = require("../util/constants");
  * @ignore
  */
 const noEscape = (constructor) => {
-    /* eslint-disable jsdoc/require-jsdoc */
-    class NoEscapeToken extends constructor {
-        escape() {
-            //
+    LSP: { // eslint-disable-line no-unused-labels
+        /* eslint-disable jsdoc/require-jsdoc */
+        class NoEscapeToken extends constructor {
+            escape() {
+                //
+            }
         }
+        /* eslint-enable jsdoc/require-jsdoc */
+        (0, debug_1.mixin)(NoEscapeToken, constructor);
+        return NoEscapeToken;
     }
-    /* eslint-enable jsdoc/require-jsdoc */
-    (0, debug_1.mixin)(NoEscapeToken, constructor);
-    return NoEscapeToken;
 };
 exports.noEscape = noEscape;
 constants_1.mixins['noEscape'] = __filename;

package/dist/parser/links.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseLinks = void 0;
+const string_1 = require("../util/string");
 const index_1 = __importDefault(require("../index"));
 const quotes_1 = require("./quotes");
 const externalLinks_1 = require("./externalLinks");
@@ -24,9 +25,9 @@ const regexImg = /^((?:(?!\0\d+!\x7F)[^\n[\]{}|])+)(\||\0\d+!\x7F)([\s\S]*)$/u;
 const parseLinks = (wikitext, config, accum, tidy) => {
     /^\s*(?:ftp:\/\/|\/\/)/iu; // eslint-disable-line @typescript-eslint/no-unused-expressions
     config.regexLinks ??= new RegExp(String.raw `^\s*(?:${config.protocol}|//)`, 'iu');
-    const regex = true // eslint-disable-line no-constant-condition, @typescript-eslint/no-unnecessary-condition
+    const regex = config.inExt
         ? /^((?:(?!\0\d+!\x7F)[^\n[\]{}|])+)(?:(\||\0\d+!\x7F)([\s\S]*?[^\]]))?\]\]([\s\S]*)$/u
-        : /^((?:(?!\0\d+!\x7F)[^\n[\]{}|])+)(?:(\||\0\d+!\x7F)([\s\S]*?[^\]])?)?\]\]([\s\S]*)$/u, bits = wikitext.split('[[');
+        : /^((?:(?!\0\d+!\x7F)[^\n[\]{}|])*)(?:(\||\0\d+!\x7F)([\s\S]*?[^\]])?)?\]\]([\s\S]*)$/u, bits = wikitext.split('[[');
     let s = bits.shift();
     for (let i = 0; i < bits.length; i++) {
         let mightBeImg = false, link, delimiter, text, after;
@@ -49,14 +50,16 @@ const parseLinks = (wikitext, config, accum, tidy) => {
             s += `[[${x}`;
             continue;
         }
-        const force = link.trim().startsWith(':');
+        // eslint-disable-next-line prefer-const
+        let trimmed = (0, string_1.removeComment)(link).trim();
+        const force = trimmed.startsWith(':');
         if (force && mightBeImg) {
             s += `[[${x}`;
             continue;
         }
         const { ns, valid, 
         /* NOT FOR BROWSER */
-        interwiki, } = index_1.default.normalizeTitle(link, 0, false, config, { halfParsed: true, temporary: true, decode: true, selfLink: true });
+        interwiki, } = index_1.default.normalizeTitle(trimmed, 0, false, config, { halfParsed: true, temporary: true, decode: true, selfLink: true });
         if (!valid) {
             s += `[[${x}`;
             continue;
@@ -103,6 +106,9 @@ const parseLinks = (wikitext, config, accum, tidy) => {
                 SomeLinkToken = category_1.CategoryToken;
             }
         }
+        if (text === undefined && delimiter) {
+            text = '';
+        }
         s += `\0${accum.length}l\x7F${after}`;
         // @ts-expect-error abstract class
         new SomeLinkToken(link, text, config, accum, delimiter);

package/dist/src/arg.js

@@ -82,10 +82,12 @@ let ArgToken = (() => {
         get type() {
             return 'arg';
         }
+        /* PRINT ONLY */
         /** default value / 预设值 */
         get default() {
-            return this.childNodes[1]?.text() ?? false;
+            LSP: return this.childNodes[1]?.text() ?? false; // eslint-disable-line no-unused-labels
         }
+        /* PRINT ONLY END */
         /* NOT FOR BROWSER */
         set default(value) {
             this.setDefault(value);
@@ -147,39 +149,41 @@ let ArgToken = (() => {
         }
         /** @private */
         lint(start = this.getAbsoluteIndex(), re) {
-            const { childNodes: [argName, argDefault, ...rest] } = this;
-            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) {
-                    errors.push(...childErrors);
-                }
-            }
-            const rules = ['no-ignored', 'no-arg'], s = rules.map(rule => index_1.default.lintConfig.getSeverity(rule, 'arg'));
-            if (s[0] && rest.length > 0) {
-                const rect = new rect_1.BoundingRect(this, start);
-                errors.push(...rest.map(child => {
-                    const e = (0, lint_1.generateForChild)(child, rect, rules[0], 'invisible content inside triple braces', s[0]);
-                    e.startIndex--;
-                    e.startCol--;
-                    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, { start }, rules[1], 'unexpected template argument', s[1]);
+            LINT: { // eslint-disable-line no-unused-labels
+                const { childNodes: [argName, argDefault, ...rest] } = this;
+                argName.setAttribute('aIndex', start + 3);
+                const errors = argName.lint(start + 3, re);
                 if (argDefault) {
-                    e.suggestions = [(0, lint_1.fixBy)(e, 'expand', argDefault.text())];
+                    const index = start + 4 + argName.toString().length;
+                    argDefault.setAttribute('aIndex', index);
+                    const childErrors = argDefault.lint(index, re);
+                    if (childErrors.length > 0) {
+                        errors.push(...childErrors);
+                    }
                 }
-                errors.push(e);
+                const rules = ['no-ignored', 'no-arg'], s = rules.map(rule => index_1.default.lintConfig.getSeverity(rule, 'arg'));
+                if (s[0] && rest.length > 0) {
+                    const rect = new rect_1.BoundingRect(this, start);
+                    errors.push(...rest.map(child => {
+                        const e = (0, lint_1.generateForChild)(child, rect, rules[0], 'invisible-triple-braces', s[0]);
+                        e.startIndex--;
+                        e.startCol--;
+                        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, { start }, rules[1], 'unexpected-argument', s[1]);
+                    if (argDefault) {
+                        e.suggestions = [(0, lint_1.fixBy)(e, 'expand', argDefault.text())];
+                    }
+                    errors.push(e);
+                }
+                return errors;
             }
-            return errors;
         }
         /** @private */
         print() {
@@ -188,8 +192,10 @@ let ArgToken = (() => {
         /** @private */
         json(_, start = this.getAbsoluteIndex()) {
             const json = super.json(undefined, start);
-            json['default'] = this.default;
-            return json;
+            LSP: { // eslint-disable-line no-unused-labels
+                json['default'] = this.default;
+                return json;
+            }
         }
         /* NOT FOR BROWSER */
         cloneNode() {