@taiga-ui/eslint-plugin-experience-next 0.482.0 → 0.484.0

package/index.esm.js

@@ -46296,6 +46296,72 @@ const rule$M = createRule({
     },
 });
 
+function sameOrder(a, b) {
+    return a.length === b.length && a.every((value, index) => value === b[index]);
+}
+
+const config$5 = {
+    create(context) {
+        const order = context.options[0] || {};
+        return {
+            ClassDeclaration(node) {
+                const decorators = Array.from(node.decorators ?? []);
+                for (const decorator of decorators) {
+                    const { expression } = decorator;
+                    const decoratorName = expression.callee?.name ?? '';
+                    if (decoratorName in (order || {})) {
+                        const orderList = order[decoratorName];
+                        const decoratorArguments = Array.from(expression.arguments ?? []);
+                        for (const argument of decoratorArguments) {
+                            const properties = Array.from(argument.properties ?? []);
+                            const current = properties
+                                .map((prop) => prop.key?.name)
+                                .filter(Boolean);
+                            const correct = getCorrectOrderRelative(orderList, current);
+                            if (!sameOrder(correct, current.filter((item) => correct.includes(item)))) {
+                                context.report({
+                                    fix: (fixer) => {
+                                        const fileContent = context.sourceCode.text;
+                                        const forgottenProps = current.filter((key) => !orderList.includes(key));
+                                        const sortedDecoratorProperties = [
+                                            ...correct,
+                                            ...forgottenProps,
+                                        ].map((key) => properties.find((prop) => prop.key.name === key));
+                                        const newDecoratorArgument = `{${sortedDecoratorProperties
+                                            .map(({ range }) => fileContent.slice(...range))
+                                            .toString()}}`;
+                                        return fixer.replaceTextRange(argument.range, newDecoratorArgument);
+                                    },
+                                    message: `Incorrect order keys in @${decoratorName} decorator, please sort by [${correct.join(' -> ')}]`,
+                                    node: expression,
+                                });
+                            }
+                        }
+                    }
+                }
+            },
+        };
+    },
+    meta: {
+        fixable: 'code',
+        schema: [
+            {
+                additionalProperties: true,
+                description: 'Decorators names and their keys order',
+                type: 'object',
+            },
+        ],
+        type: 'problem',
+    },
+};
+function getCorrectOrderRelative(correct, current) {
+    return correct.filter((item) => current.includes(item));
+}
+const rule$L = createRule({
+    name: 'decorator-key-sort',
+    rule: config$5,
+});
+
 const INLINE_HTML_ELEMENTS = new Set([
     'a',
     'abbr',
@@ -46355,7 +46421,7 @@ function getNodeLabel(node) {
     }
     return 'text';
 }
-const rule$L = createRule({
+const rule$K = createRule({
     name: 'element-newline',
     rule: {
         create(context) {
@@ -46429,802 +46495,6 @@ const rule$L = createRule({
     },
 });
 
-const noDuplicateAttributesRule = angular.templatePlugin.rules?.['no-duplicate-attributes'];
-if (!noDuplicateAttributesRule) {
-    throw new Error('angular-eslint template rule "no-duplicate-attributes" is not available');
-}
-const rule$K = createRule({
-    name: 'no-duplicate-attrs',
-    rule: noDuplicateAttributesRule,
-});
-
-const MESSAGE_ID$f = 'duplicateId';
-const rule$J = createRule({
-    name: 'no-duplicate-id',
-    rule: {
-        create(context) {
-            const ids = new Map();
-            return {
-                Element(rawNode) {
-                    const node = rawNode;
-                    const idAttr = node.attributes.find((attr) => attr.name === 'id');
-                    if (!idAttr) {
-                        return;
-                    }
-                    ids.set(idAttr.value, [...(ids.get(idAttr.value) ?? []), idAttr]);
-                },
-                'Program:exit'() {
-                    for (const [id, attrs] of ids) {
-                        if (attrs.length <= 1) {
-                            continue;
-                        }
-                        for (const attr of attrs) {
-                            context.report({
-                                data: { id },
-                                loc: sourceSpanToLoc(attr.sourceSpan),
-                                messageId: MESSAGE_ID$f,
-                            });
-                        }
-                    }
-                },
-            };
-        },
-        meta: {
-            docs: { description: 'Disallow duplicate static id attributes' },
-            messages: { [MESSAGE_ID$f]: "The id '{{id}}' is duplicated." },
-            schema: [],
-            type: 'problem',
-        },
-    },
-});
-
-const MESSAGE_ID$e = 'duplicateTag';
-function findAttr(node, attrName) {
-    return node.attributes.find((attr) => attr.name === attrName);
-}
-function getTrackingKey(node) {
-    if (node.name === 'title' || node.name === 'base') {
-        return node.name;
-    }
-    if (node.name === 'meta') {
-        if (findAttr(node, 'charset')) {
-            return 'meta[charset]';
-        }
-        if (findAttr(node, 'name')?.value === 'viewport') {
-            return 'meta[name=viewport]';
-        }
-    }
-    if (node.name === 'link' &&
-        findAttr(node, 'rel')?.value === 'canonical' &&
-        findAttr(node, 'href')) {
-        return 'link[rel=canonical]';
-    }
-    return null;
-}
-const rule$I = createRule({
-    name: 'no-duplicate-in-head',
-    rule: {
-        create(context) {
-            const nodes = new Map();
-            let headDepth = 0;
-            return {
-                Element(rawNode) {
-                    const node = rawNode;
-                    if (node.name === 'head') {
-                        headDepth++;
-                        return;
-                    }
-                    if (headDepth === 0) {
-                        return;
-                    }
-                    const trackingKey = getTrackingKey(node);
-                    if (!trackingKey) {
-                        return;
-                    }
-                    nodes.set(trackingKey, [...(nodes.get(trackingKey) ?? []), node]);
-                },
-                'Element:exit'(rawNode) {
-                    const node = rawNode;
-                    if (node.name === 'head') {
-                        headDepth--;
-                    }
-                },
-                'Program:exit'() {
-                    for (const [tag, duplicates] of nodes) {
-                        if (duplicates.length <= 1) {
-                            continue;
-                        }
-                        for (const duplicate of duplicates.slice(1)) {
-                            context.report({
-                                data: { tag },
-                                loc: sourceSpanToLoc(duplicate.startSourceSpan),
-                                messageId: MESSAGE_ID$e,
-                            });
-                        }
-                    }
-                },
-            };
-        },
-        meta: {
-            docs: {
-                description: 'Disallow duplicate title/base/meta/link tags inside head',
-            },
-            messages: { [MESSAGE_ID$e]: 'Duplicate <{{tag}}> tag in <head>.' },
-            schema: [],
-            type: 'problem',
-        },
-    },
-});
-
-const OBSOLETE_HTML_ATTRS = {
-    abbr: [
-        {
-            elements: ['td'],
-            suggestion: "Use text that begins in an unambiguous and terse manner, and include any more elaborate text after that. The title attribute can also be useful in including more detailed text, so that the cell's contents can be made terse. If it's a heading, use th (which has an abbr attribute).",
-        },
-    ],
-    accept: [
-        {
-            elements: ['form'],
-            suggestion: 'Use the accept attribute directly on the input elements instead.',
-        },
-    ],
-    align: [
-        {
-            elements: [
-                'caption',
-                'col',
-                'div',
-                'embed',
-                'h1',
-                'h2',
-                'h3',
-                'h4',
-                'h5',
-                'h6',
-                'hr',
-                'iframe',
-                'input',
-                'img',
-                'legend',
-                'object',
-                'p',
-                'table',
-                'tbody',
-                'thead',
-                'tfoot',
-                'td',
-                'th',
-                'tr',
-            ],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    alink: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
-    allowtransparency: [{ elements: ['iframe'], suggestion: 'Use CSS instead.' }],
-    archive: [
-        {
-            elements: ['object'],
-            suggestion: 'Use the data and type attributes to invoke plugins.',
-        },
-    ],
-    axis: [
-        {
-            elements: ['td', 'th'],
-            suggestion: 'Use the scope attribute on the relevant th.',
-        },
-    ],
-    background: [
-        {
-            elements: ['body', 'table', 'thead', 'tbody', 'tfoot', 'tr', 'td', 'th'],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    bgcolor: [
-        {
-            elements: ['body', 'table', 'td', 'th', 'tr'],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    border: [
-        {
-            elements: ['input', 'img', 'object', 'table'],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    bordercolor: [{ elements: ['table'], suggestion: 'Use CSS instead.' }],
-    bottommargin: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
-    cellpadding: [{ elements: ['table'], suggestion: 'Use CSS instead.' }],
-    cellspacing: [{ elements: ['table'], suggestion: 'Use CSS instead.' }],
-    char: [
-        {
-            elements: ['col', 'tbody', 'thead', 'tfoot', 'td', 'th', 'tr'],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    charoff: [
-        {
-            elements: ['col', 'tbody', 'thead', 'tfoot', 'td', 'th', 'tr'],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    charset: [
-        {
-            elements: ['a', 'link'],
-            suggestion: 'Use an HTTP `Content-Type` header on the linked resource instead.',
-        },
-        {
-            elements: ['script'],
-            suggestion: 'It is redundant to specify it on the script element since it inherits from the document.',
-        },
-    ],
-    classid: [
-        {
-            elements: ['object'],
-            suggestion: 'Use the data and type attributes to invoke plugins.',
-        },
-    ],
-    clear: [{ elements: ['br'], suggestion: 'Use CSS instead.' }],
-    code: [
-        {
-            elements: ['object'],
-            suggestion: 'Use the data and type attributes to invoke plugins.',
-        },
-    ],
-    codebase: [
-        {
-            elements: ['object'],
-            suggestion: 'Use the data and type attributes to invoke plugins.',
-        },
-    ],
-    codetype: [
-        {
-            elements: ['object'],
-            suggestion: 'Use the data and type attributes to invoke plugins.',
-        },
-    ],
-    color: [{ elements: ['hr'], suggestion: 'Use CSS instead.' }],
-    compact: [
-        {
-            elements: ['dl', 'menu', 'ol', 'ul'],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    contextmenu: [
-        {
-            elements: ['*'],
-            suggestion: 'To implement a custom context menu, use script to handle the contextmenu event.',
-        },
-    ],
-    coords: [{ elements: ['a'], suggestion: 'Use area instead of a for image maps.' }],
-    datafld: [
-        {
-            elements: [
-                'a',
-                'button',
-                'div',
-                'fieldset',
-                'frame',
-                'iframe',
-                'img',
-                'input',
-                'label',
-                'legend',
-                'marquee',
-                'object',
-                'select',
-                'span',
-                'textarea',
-            ],
-            suggestion: 'Use script and a mechanism such as XMLHttpRequest to populate the page dynamically.',
-        },
-    ],
-    dataformatas: [
-        {
-            elements: [
-                'button',
-                'div',
-                'input',
-                'label',
-                'legend',
-                'marquee',
-                'object',
-                'option',
-                'select',
-                'span',
-                'table',
-            ],
-            suggestion: 'Use script and a mechanism such as XMLHttpRequest to populate the page dynamically.',
-        },
-    ],
-    datapagesize: [
-        {
-            elements: ['table'],
-            suggestion: 'Unnecessary. Omit it altogether.',
-        },
-    ],
-    datasrc: [
-        {
-            elements: [
-                'a',
-                'button',
-                'div',
-                'frame',
-                'iframe',
-                'img',
-                'input',
-                'label',
-                'legend',
-                'marquee',
-                'object',
-                'option',
-                'select',
-                'span',
-                'table',
-                'textarea',
-            ],
-            suggestion: 'Use script and a mechanism such as XMLHttpRequest to populate the page dynamically.',
-        },
-    ],
-    declare: [
-        {
-            elements: ['object'],
-            suggestion: 'Repeat the object element completely each time the resource is to be reused.',
-        },
-    ],
-    dropzone: [
-        {
-            elements: ['*'],
-            suggestion: 'Use script to handle the dragenter and dragover events instead.',
-        },
-    ],
-    event: [
-        {
-            elements: ['script'],
-            suggestion: 'Use DOM events mechanisms to register event listeners.',
-        },
-    ],
-    for: [
-        {
-            elements: ['script'],
-            suggestion: 'Use DOM events mechanisms to register event listeners.',
-        },
-    ],
-    frame: [{ elements: ['table'], suggestion: 'Use CSS instead.' }],
-    frameborder: [{ elements: ['iframe'], suggestion: 'Use CSS instead.' }],
-    framespacing: [{ elements: ['iframe'], suggestion: 'Use CSS instead.' }],
-    height: [
-        {
-            elements: ['table', 'thead', 'tbody', 'tfoot', 'td', 'th', 'tr'],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    hreflang: [
-        {
-            elements: ['area'],
-            suggestion: 'These attributes do not do anything useful, and for historical reasons there are no corresponding IDL attributes on area elements. Omit them altogether.',
-        },
-    ],
-    hspace: [
-        {
-            elements: ['embed', 'iframe', 'input', 'img', 'object'],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    ismap: [
-        {
-            elements: ['input'],
-            suggestion: 'Unnecessary. Omit it altogether. All input elements with a type attribute in the Image Button state are processed as server-side image maps.',
-        },
-    ],
-    label: [
-        {
-            elements: ['menu'],
-            suggestion: 'To implement a custom context menu, use script to handle the contextmenu event.',
-        },
-    ],
-    language: [
-        {
-            elements: ['script'],
-            suggestion: 'Omit the attribute for JavaScript; for data blocks, use the type attribute instead.',
-        },
-    ],
-    leftmargin: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
-    link: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
-    longdesc: [
-        {
-            elements: ['iframe', 'img'],
-            suggestion: "Use a regular a element to link to the description, or (in the case of images) use an image map to provide a link from the image to the image's description.",
-        },
-    ],
-    lowsrc: [
-        {
-            elements: ['img'],
-            suggestion: 'Use a progressive JPEG image (given in the src attribute), instead of using two separate images.',
-        },
-    ],
-    manifest: [{ elements: ['html'], suggestion: 'Use service workers instead.' }],
-    marginheight: [
-        {
-            elements: ['body', 'iframe'],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    marginwidth: [
-        {
-            elements: ['body', 'iframe'],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    methods: [
-        {
-            elements: ['a', 'link'],
-            suggestion: 'Use the HTTP OPTIONS feature instead.',
-        },
-    ],
-    name: [
-        {
-            elements: ['a', 'embed', 'img', 'option'],
-            suggestion: 'Use the id attribute instead.',
-        },
-    ],
-    nohref: [
-        {
-            elements: ['area'],
-            suggestion: 'Omitting the href attribute is sufficient; the nohref attribute is unnecessary. Omit it altogether.',
-        },
-    ],
-    noshade: [{ elements: ['hr'], suggestion: 'Use CSS instead.' }],
-    nowrap: [{ elements: ['td', 'th'], suggestion: 'Use CSS instead.' }],
-    onshow: [
-        {
-            elements: ['*'],
-            suggestion: 'To implement a custom context menu, use script to handle the contextmenu event.',
-        },
-    ],
-    profile: [{ elements: ['head'], suggestion: 'Unnecessary. Omit it altogether.' }],
-    rev: [
-        {
-            elements: ['a', 'link'],
-            suggestion: 'Use the rel attribute instead, with an opposite term. (For example, instead of rev="made", use rel="author".)',
-        },
-    ],
-    rightmargin: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
-    scheme: [
-        {
-            elements: ['meta'],
-            suggestion: 'Use only one scheme per field, or make the scheme declaration part of the value.',
-        },
-    ],
-    scope: [
-        {
-            elements: ['td'],
-            suggestion: 'Use th elements for heading cells.',
-        },
-    ],
-    scrolling: [{ elements: ['iframe'], suggestion: 'Use CSS instead.' }],
-    shape: [{ elements: ['a'], suggestion: 'Use area instead of a for image maps.' }],
-    size: [{ elements: ['hr'], suggestion: 'Use CSS instead.' }],
-    standby: [
-        {
-            elements: ['object'],
-            suggestion: 'Optimize the linked resource so that it loads quickly or, at least, incrementally.',
-        },
-    ],
-    summary: [
-        {
-            elements: ['table'],
-            suggestion: 'Use one of the techniques for describing tables given in the table section instead.',
-        },
-    ],
-    target: [{ elements: ['link'], suggestion: 'Unnecessary. Omit it altogether.' }],
-    text: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
-    topmargin: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
-    type: [
-        {
-            elements: ['area'],
-            suggestion: 'These attributes do not do anything useful, and for historical reasons there are no corresponding IDL attributes on area elements. Omit them altogether.',
-        },
-        { elements: ['li'], suggestion: 'Use CSS instead.' },
-        {
-            elements: ['menu'],
-            suggestion: 'To implement a custom context menu, use script to handle the contextmenu event. For toolbar menus, omit the attribute.',
-        },
-        {
-            elements: ['style'],
-            suggestion: 'Omit the attribute for CSS; for data blocks, use script as the container instead of style.',
-        },
-        { elements: ['ul'], suggestion: 'Use CSS instead.' },
-    ],
-    typemustmatch: [
-        {
-            elements: ['object'],
-            suggestion: 'Avoid using object elements with untrusted resources.',
-        },
-    ],
-    urn: [
-        {
-            elements: ['a', 'link'],
-            suggestion: 'Specify the preferred persistent identifier using the href attribute instead.',
-        },
-    ],
-    usemap: [
-        {
-            elements: ['input', 'object'],
-            suggestion: 'Use the img element for image maps.',
-        },
-    ],
-    valign: [
-        {
-            elements: ['col', 'tbody', 'thead', 'tfoot', 'td', 'th', 'tr'],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    version: [{ elements: ['html'], suggestion: 'Unnecessary. Omit it altogether.' }],
-    vlink: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
-    vspace: [
-        {
-            elements: ['embed', 'iframe', 'input', 'img', 'object'],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    width: [
-        {
-            elements: ['col', 'hr', 'pre', 'table', 'td', 'th'],
-            suggestion: 'Use CSS instead.',
-        },
-    ],
-    rules: [{ elements: ['table'], suggestion: 'Use CSS instead.' }],
-};
-
-const MESSAGE_ID$d = 'obsolete';
-const rule$H = createRule({
-    name: 'no-obsolete-attrs',
-    rule: {
-        create(context) {
-            return {
-                Element(rawNode) {
-                    const node = rawNode;
-                    const elementName = node.name.toLowerCase();
-                    for (const attr of node.attributes) {
-                        if (!attr.valueSpan) {
-                            continue;
-                        }
-                        const attrName = attr.name.toLowerCase();
-                        const obsoleteConfigs = OBSOLETE_HTML_ATTRS[attrName];
-                        if (!obsoleteConfigs) {
-                            continue;
-                        }
-                        const obsoleteConfig = obsoleteConfigs.find((config) => config.elements.includes('*') ||
-                            config.elements.includes(elementName));
-                        if (!obsoleteConfig) {
-                            continue;
-                        }
-                        context.report({
-                            data: {
-                                attr: attrName,
-                                element: elementName,
-                                suggestion: obsoleteConfig.suggestion,
-                            },
-                            loc: sourceSpanToLoc(attr.keySpan ?? attr.sourceSpan),
-                            messageId: MESSAGE_ID$d,
-                        });
-                    }
-                },
-            };
-        },
-        meta: {
-            docs: { description: 'Disallow obsolete HTML attributes' },
-            messages: {
-                [MESSAGE_ID$d]: 'The {{attr}} attribute on <{{element}}> is obsolete. {{suggestion}}',
-            },
-            schema: [],
-            type: 'problem',
-        },
-    },
-});
-
-const OBSOLETE_HTML_TAGS = new Set([
-    'acronym',
-    'applet',
-    'basefont',
-    'bgsound',
-    'big',
-    'blink',
-    'center',
-    'dir',
-    'font',
-    'frame',
-    'frameset',
-    'isindex',
-    'keygen',
-    'listing',
-    'marquee',
-    'menuitem',
-    'multicol',
-    'nextid',
-    'nobr',
-    'noembed',
-    'noframes',
-    'plaintext',
-    'rb',
-    'rtc',
-    'spacer',
-    'strike',
-    'tt',
-    'xmp',
-]);
-
-const MESSAGE_ID$c = 'unexpected';
-const rule$G = createRule({
-    name: 'no-obsolete-tags',
-    rule: {
-        create(context) {
-            return {
-                Element(rawNode) {
-                    const node = rawNode;
-                    if (!OBSOLETE_HTML_TAGS.has(node.name)) {
-                        return;
-                    }
-                    context.report({
-                        data: { tag: node.name },
-                        loc: sourceSpanToLoc(node.startSourceSpan),
-                        messageId: MESSAGE_ID$c,
-                    });
-                },
-            };
-        },
-        meta: {
-            docs: { description: 'Disallow obsolete HTML tags' },
-            messages: { [MESSAGE_ID$c]: 'Unexpected use of obsolete tag <{{tag}}>' },
-            schema: [],
-            type: 'problem',
-        },
-    },
-});
-
-const MESSAGE_IDS$2 = {
-    MISSING: 'missing',
-    UNEXPECTED: 'unexpected',
-};
-const EXPECTED_QUOTE = '"';
-const SINGLE_QUOTE = "'";
-const DOUBLE_QUOTE = '"';
-function isQuotableAttribute(attr) {
-    return 'sourceSpan' in attr;
-}
-const rule$F = createRule({
-    name: 'quotes',
-    rule: {
-        create(context) {
-            const sourceText = context.sourceCode.getText();
-            return {
-                Element(rawNode) {
-                    const node = rawNode;
-                    for (const attr of [
-                        ...node.attributes,
-                        ...node.inputs,
-                        ...node.outputs,
-                    ].filter(isQuotableAttribute)) {
-                        const valueSpan = getAttributeValueSpan(attr);
-                        if (!valueSpan) {
-                            continue;
-                        }
-                        const rawValue = sourceText.slice(valueSpan.start.offset, valueSpan.end.offset);
-                        if (rawValue.includes(EXPECTED_QUOTE)) {
-                            continue;
-                        }
-                        const openingQuote = sourceText[valueSpan.start.offset - 1];
-                        const closingQuote = sourceText[valueSpan.end.offset];
-                        const hasMatchingQuotes = (openingQuote === SINGLE_QUOTE ||
-                            openingQuote === DOUBLE_QUOTE) &&
-                            openingQuote === closingQuote;
-                        if (hasMatchingQuotes && openingQuote !== EXPECTED_QUOTE) {
-                            context.report({
-                                data: {
-                                    actual: `single(${openingQuote})`,
-                                    expected: `double(${EXPECTED_QUOTE})`,
-                                },
-                                fix: (fixer) => fixer.replaceTextRange([
-                                    valueSpan.start.offset - 1,
-                                    valueSpan.end.offset + 1,
-                                ], `${EXPECTED_QUOTE}${rawValue}${EXPECTED_QUOTE}`),
-                                loc: sourceSpanToLoc(attr.sourceSpan),
-                                messageId: MESSAGE_IDS$2.UNEXPECTED,
-                            });
-                            continue;
-                        }
-                        if (!hasMatchingQuotes) {
-                            context.report({
-                                data: { expected: `double(${EXPECTED_QUOTE})` },
-                                fix: (fixer) => fixer.replaceTextRange([valueSpan.start.offset, valueSpan.end.offset], `${EXPECTED_QUOTE}${rawValue}${EXPECTED_QUOTE}`),
-                                loc: sourceSpanToLoc(attr.sourceSpan),
-                                messageId: MESSAGE_IDS$2.MISSING,
-                            });
-                        }
-                    }
-                },
-            };
-        },
-        meta: {
-            docs: { description: 'Enforce double quotes around HTML attribute values' },
-            fixable: 'code',
-            messages: {
-                [MESSAGE_IDS$2.MISSING]: 'Expected {{expected}} quotes but no quotes found.',
-                [MESSAGE_IDS$2.UNEXPECTED]: 'Expected {{expected}} quotes but found {{actual}}.',
-            },
-            schema: [],
-            type: 'layout',
-        },
-    },
-});
-
-function sameOrder(a, b) {
-    return a.length === b.length && a.every((value, index) => value === b[index]);
-}
-
-const config$5 = {
-    create(context) {
-        const order = context.options[0] || {};
-        return {
-            ClassDeclaration(node) {
-                const decorators = Array.from(node.decorators ?? []);
-                for (const decorator of decorators) {
-                    const { expression } = decorator;
-                    const decoratorName = expression.callee?.name ?? '';
-                    if (decoratorName in (order || {})) {
-                        const orderList = order[decoratorName];
-                        const decoratorArguments = Array.from(expression.arguments ?? []);
-                        for (const argument of decoratorArguments) {
-                            const properties = Array.from(argument.properties ?? []);
-                            const current = properties
-                                .map((prop) => prop.key?.name)
-                                .filter(Boolean);
-                            const correct = getCorrectOrderRelative(orderList, current);
-                            if (!sameOrder(correct, current.filter((item) => correct.includes(item)))) {
-                                context.report({
-                                    fix: (fixer) => {
-                                        const fileContent = context.sourceCode.text;
-                                        const forgottenProps = current.filter((key) => !orderList.includes(key));
-                                        const sortedDecoratorProperties = [
-                                            ...correct,
-                                            ...forgottenProps,
-                                        ].map((key) => properties.find((prop) => prop.key.name === key));
-                                        const newDecoratorArgument = `{${sortedDecoratorProperties
-                                            .map(({ range }) => fileContent.slice(...range))
-                                            .toString()}}`;
-                                        return fixer.replaceTextRange(argument.range, newDecoratorArgument);
-                                    },
-                                    message: `Incorrect order keys in @${decoratorName} decorator, please sort by [${correct.join(' -> ')}]`,
-                                    node: expression,
-                                });
-                            }
-                        }
-                    }
-                }
-            },
-        };
-    },
-    meta: {
-        fixable: 'code',
-        schema: [
-            {
-                additionalProperties: true,
-                description: 'Decorators names and their keys order',
-                type: 'object',
-            },
-        ],
-        type: 'problem',
-    },
-};
-function getCorrectOrderRelative(correct, current) {
-    return correct.filter((item) => current.includes(item));
-}
-const rule$E = createRule({
-    name: 'decorator-key-sort',
-    rule: config$5,
-});
-
 function isObject(node) {
     return node?.type === dist$2.AST_NODE_TYPES.ObjectExpression;
 }
@@ -47382,7 +46652,7 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const rule$D = createRule({
+const rule$J = createRule({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -47664,7 +46934,7 @@ const DIRECTIONAL_TO_LOGICAL = {
     top: 'inset-block-start',
 };
 const STYLE_PREFIX = 'style.';
-const MESSAGE_ID$b = 'html-logical-properties';
+const MESSAGE_ID$f = 'html-logical-properties';
 const MESSAGE = `
 Use logical CSS properties instead of directional properties. Replace:
 • left → inset-inline-start
@@ -47702,7 +46972,7 @@ const config$4 = {
                 context.report({
                     fix: (fixer) => fixer.replaceTextRange([propertyStart, propertyEnd], logicalProperty),
                     loc: sourceSpanToLoc(keySpan),
-                    messageId: MESSAGE_ID$b,
+                    messageId: MESSAGE_ID$f,
                 });
             },
         };
@@ -47710,17 +46980,17 @@ const config$4 = {
     meta: {
         docs: { description: MESSAGE },
         fixable: 'code',
-        messages: { [MESSAGE_ID$b]: MESSAGE },
+        messages: { [MESSAGE_ID$f]: MESSAGE },
         schema: [],
         type: 'suggestion',
     },
 };
-const rule$C = createRule({
+const rule$I = createRule({
     name: 'html-logical-properties',
     rule: config$4,
 });
 
-const MESSAGE_ID$a = 'invalid-injection-token-description';
+const MESSAGE_ID$e = 'invalid-injection-token-description';
 const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
 const NG_DEV_MODE = 'ngDevMode';
 function getVariableName(node) {
@@ -47790,7 +47060,7 @@ function getNgDevModeDeclarationFix(program, fixer) {
     }
     return fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
 }
-const rule$B = createRule({
+const rule$H = createRule({
     create(context) {
         const { sourceCode } = context;
         const program = sourceCode.ast;
@@ -47822,7 +47092,7 @@ const rule$B = createRule({
                             }
                             return fixes;
                         },
-                        messageId: MESSAGE_ID$a,
+                        messageId: MESSAGE_ID$e,
                         node: description,
                     });
                 }
@@ -47832,7 +47102,7 @@ const rule$B = createRule({
     meta: {
         docs: { description: ERROR_MESSAGE$3 },
         fixable: 'code',
-        messages: { [MESSAGE_ID$a]: ERROR_MESSAGE$3 },
+        messages: { [MESSAGE_ID$e]: ERROR_MESSAGE$3 },
         schema: [],
         type: 'problem',
     },
@@ -47844,7 +47114,7 @@ function getResolvedVariable(sourceCode, node) {
     const reference = scope.references.find((item) => item.identifier === node);
     return reference?.resolved ?? null;
 }
-const rule$A = createRule({
+const rule$G = createRule({
     create(context) {
         const { sourceCode } = context;
         const namespaceImports = new Map();
@@ -47920,7 +47190,7 @@ const rule$A = createRule({
     name: 'no-commonjs-import-patterns',
 });
 
-const MESSAGE_ID$9 = 'no-deep-imports';
+const MESSAGE_ID$d = 'no-deep-imports';
 const ERROR_MESSAGE$2 = 'Deep imports of Taiga UI packages are prohibited';
 const CODE_EXTENSIONS = new Set([
     '.cjs',
@@ -47939,7 +47209,7 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const rule$z = createRule({
+const rule$F = createRule({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -47981,7 +47251,7 @@ const rule$z = createRule({
                         const [start, end] = node.source.range;
                         return fixer.replaceTextRange([start + 1, end - 1], importSource.replaceAll(new RegExp(deepImport, 'g'), ''));
                     },
-                    messageId: MESSAGE_ID$9,
+                    messageId: MESSAGE_ID$d,
                     node: node.source,
                 });
             },
@@ -47991,7 +47261,7 @@ const rule$z = createRule({
         defaultOptions: [DEFAULT_OPTIONS],
         docs: { description: ERROR_MESSAGE$2 },
         fixable: 'code',
-        messages: { [MESSAGE_ID$9]: ERROR_MESSAGE$2 },
+        messages: { [MESSAGE_ID$d]: ERROR_MESSAGE$2 },
         schema: [
             {
                 additionalProperties: false,
@@ -248675,7 +247945,7 @@ const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-const rule$y = createRule({
+const rule$E = createRule({
     create(context) {
         const parserServices = dist$3.ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -248868,6 +248138,133 @@ function stripKnownExtensions(filePathOrSpecifier) {
     return filePathOrSpecifier.replace(/\.(?:d\.ts|ts|tsx|js|jsx|mjs|cjs)$/, '');
 }
 
+const noDuplicateAttributesRule = angular.templatePlugin.rules?.['no-duplicate-attributes'];
+if (!noDuplicateAttributesRule) {
+    throw new Error('angular-eslint template rule "no-duplicate-attributes" is not available');
+}
+const rule$D = createRule({
+    name: 'no-duplicate-attrs',
+    rule: noDuplicateAttributesRule,
+});
+
+const MESSAGE_ID$c = 'duplicateId';
+const rule$C = createRule({
+    name: 'no-duplicate-id',
+    rule: {
+        create(context) {
+            const ids = new Map();
+            return {
+                Element(rawNode) {
+                    const node = rawNode;
+                    const idAttr = node.attributes.find((attr) => attr.name === 'id');
+                    if (!idAttr) {
+                        return;
+                    }
+                    ids.set(idAttr.value, [...(ids.get(idAttr.value) ?? []), idAttr]);
+                },
+                'Program:exit'() {
+                    for (const [id, attrs] of ids) {
+                        if (attrs.length <= 1) {
+                            continue;
+                        }
+                        for (const attr of attrs) {
+                            context.report({
+                                data: { id },
+                                loc: sourceSpanToLoc(attr.sourceSpan),
+                                messageId: MESSAGE_ID$c,
+                            });
+                        }
+                    }
+                },
+            };
+        },
+        meta: {
+            docs: { description: 'Disallow duplicate static id attributes' },
+            messages: { [MESSAGE_ID$c]: "The id '{{id}}' is duplicated." },
+            schema: [],
+            type: 'problem',
+        },
+    },
+});
+
+const MESSAGE_ID$b = 'duplicateTag';
+function findAttr(node, attrName) {
+    return node.attributes.find((attr) => attr.name === attrName);
+}
+function getTrackingKey(node) {
+    if (node.name === 'title' || node.name === 'base') {
+        return node.name;
+    }
+    if (node.name === 'meta') {
+        if (findAttr(node, 'charset')) {
+            return 'meta[charset]';
+        }
+        if (findAttr(node, 'name')?.value === 'viewport') {
+            return 'meta[name=viewport]';
+        }
+    }
+    if (node.name === 'link' &&
+        findAttr(node, 'rel')?.value === 'canonical' &&
+        findAttr(node, 'href')) {
+        return 'link[rel=canonical]';
+    }
+    return null;
+}
+const rule$B = createRule({
+    name: 'no-duplicate-in-head',
+    rule: {
+        create(context) {
+            const nodes = new Map();
+            let headDepth = 0;
+            return {
+                Element(rawNode) {
+                    const node = rawNode;
+                    if (node.name === 'head') {
+                        headDepth++;
+                        return;
+                    }
+                    if (headDepth === 0) {
+                        return;
+                    }
+                    const trackingKey = getTrackingKey(node);
+                    if (!trackingKey) {
+                        return;
+                    }
+                    nodes.set(trackingKey, [...(nodes.get(trackingKey) ?? []), node]);
+                },
+                'Element:exit'(rawNode) {
+                    const node = rawNode;
+                    if (node.name === 'head') {
+                        headDepth--;
+                    }
+                },
+                'Program:exit'() {
+                    for (const [tag, duplicates] of nodes) {
+                        if (duplicates.length <= 1) {
+                            continue;
+                        }
+                        for (const duplicate of duplicates.slice(1)) {
+                            context.report({
+                                data: { tag },
+                                loc: sourceSpanToLoc(duplicate.startSourceSpan),
+                                messageId: MESSAGE_ID$b,
+                            });
+                        }
+                    }
+                },
+            };
+        },
+        meta: {
+            docs: {
+                description: 'Disallow duplicate title/base/meta/link tags inside head',
+            },
+            messages: { [MESSAGE_ID$b]: 'Duplicate <{{tag}}> tag in <head>.' },
+            schema: [],
+            type: 'problem',
+        },
+    },
+});
+
 function isFunctionLike(node) {
     return (node.type === dist$3.AST_NODE_TYPES.ArrowFunctionExpression ||
         node.type === dist$3.AST_NODE_TYPES.FunctionDeclaration ||
@@ -249412,7 +248809,7 @@ function getTypeAwareRuleContext(context) {
     };
 }
 
-const rule$x = createUntrackedRule({
+const rule$A = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -249450,7 +248847,7 @@ const rule$x = createUntrackedRule({
     name: 'no-fully-untracked-effect',
 });
 
-const MESSAGE_ID$8 = 'no-href-with-router-link';
+const MESSAGE_ID$a = 'no-href-with-router-link';
 const ERROR_MESSAGE$1 = 'Do not use href and routerLink attributes together on the same element';
 const config$3 = {
     create(context) {
@@ -249472,7 +248869,7 @@ const config$3 = {
                         hrefAttr.sourceSpan.end.offset,
                     ]),
                     loc: sourceSpanToLoc(hrefAttr.sourceSpan),
-                    messageId: MESSAGE_ID$8,
+                    messageId: MESSAGE_ID$a,
                 });
             },
         };
@@ -249480,12 +248877,12 @@ const config$3 = {
     meta: {
         docs: { description: ERROR_MESSAGE$1 },
         fixable: 'code',
-        messages: { [MESSAGE_ID$8]: ERROR_MESSAGE$1 },
+        messages: { [MESSAGE_ID$a]: ERROR_MESSAGE$1 },
         schema: [],
         type: 'problem',
     },
 };
-const rule$w = createRule({
+const rule$z = createRule({
     name: 'no-href-with-router-link',
     rule: config$3,
 });
@@ -249546,7 +248943,7 @@ function getScopeRoot(node) {
     return (findAncestor(node, (ancestor) => ancestor.type === dist$3.AST_NODE_TYPES.Program || isFunctionLike(ancestor)) ?? node);
 }
 
-const rule$v = createRule({
+const rule$y = createRule({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getEnclosingClass(node);
@@ -249608,7 +249005,7 @@ const rule$v = createRule({
     name: 'no-implicit-public',
 });
 
-const rule$u = createRule({
+const rule$x = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -249666,7 +249063,7 @@ function isInfiniteLoopLiteral(node) {
 function isInfiniteLoopTest(test) {
     return test === null || isInfiniteLoopLiteral(test);
 }
-const rule$t = createRule({
+const rule$w = createRule({
     create(context) {
         return {
             DoWhileStatement(node) {
@@ -249711,7 +249108,7 @@ const rule$t = createRule({
 });
 
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$s = createRule({
+const rule$v = createRule({
     create(context) {
         return {
             Program(node) {
@@ -249749,7 +249146,534 @@ const rule$s = createRule({
     name: 'no-legacy-peer-deps',
 });
 
-const rule$r = createRule({
+const OBSOLETE_HTML_ATTRS = {
+    abbr: [
+        {
+            elements: ['td'],
+            suggestion: "Use text that begins in an unambiguous and terse manner, and include any more elaborate text after that. The title attribute can also be useful in including more detailed text, so that the cell's contents can be made terse. If it's a heading, use th (which has an abbr attribute).",
+        },
+    ],
+    accept: [
+        {
+            elements: ['form'],
+            suggestion: 'Use the accept attribute directly on the input elements instead.',
+        },
+    ],
+    align: [
+        {
+            elements: [
+                'caption',
+                'col',
+                'div',
+                'embed',
+                'h1',
+                'h2',
+                'h3',
+                'h4',
+                'h5',
+                'h6',
+                'hr',
+                'iframe',
+                'input',
+                'img',
+                'legend',
+                'object',
+                'p',
+                'table',
+                'tbody',
+                'thead',
+                'tfoot',
+                'td',
+                'th',
+                'tr',
+            ],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    alink: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
+    allowtransparency: [{ elements: ['iframe'], suggestion: 'Use CSS instead.' }],
+    archive: [
+        {
+            elements: ['object'],
+            suggestion: 'Use the data and type attributes to invoke plugins.',
+        },
+    ],
+    axis: [
+        {
+            elements: ['td', 'th'],
+            suggestion: 'Use the scope attribute on the relevant th.',
+        },
+    ],
+    background: [
+        {
+            elements: ['body', 'table', 'thead', 'tbody', 'tfoot', 'tr', 'td', 'th'],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    bgcolor: [
+        {
+            elements: ['body', 'table', 'td', 'th', 'tr'],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    border: [
+        {
+            elements: ['input', 'img', 'object', 'table'],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    bordercolor: [{ elements: ['table'], suggestion: 'Use CSS instead.' }],
+    bottommargin: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
+    cellpadding: [{ elements: ['table'], suggestion: 'Use CSS instead.' }],
+    cellspacing: [{ elements: ['table'], suggestion: 'Use CSS instead.' }],
+    char: [
+        {
+            elements: ['col', 'tbody', 'thead', 'tfoot', 'td', 'th', 'tr'],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    charoff: [
+        {
+            elements: ['col', 'tbody', 'thead', 'tfoot', 'td', 'th', 'tr'],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    charset: [
+        {
+            elements: ['a', 'link'],
+            suggestion: 'Use an HTTP `Content-Type` header on the linked resource instead.',
+        },
+        {
+            elements: ['script'],
+            suggestion: 'It is redundant to specify it on the script element since it inherits from the document.',
+        },
+    ],
+    classid: [
+        {
+            elements: ['object'],
+            suggestion: 'Use the data and type attributes to invoke plugins.',
+        },
+    ],
+    clear: [{ elements: ['br'], suggestion: 'Use CSS instead.' }],
+    code: [
+        {
+            elements: ['object'],
+            suggestion: 'Use the data and type attributes to invoke plugins.',
+        },
+    ],
+    codebase: [
+        {
+            elements: ['object'],
+            suggestion: 'Use the data and type attributes to invoke plugins.',
+        },
+    ],
+    codetype: [
+        {
+            elements: ['object'],
+            suggestion: 'Use the data and type attributes to invoke plugins.',
+        },
+    ],
+    color: [{ elements: ['hr'], suggestion: 'Use CSS instead.' }],
+    compact: [
+        {
+            elements: ['dl', 'menu', 'ol', 'ul'],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    contextmenu: [
+        {
+            elements: ['*'],
+            suggestion: 'To implement a custom context menu, use script to handle the contextmenu event.',
+        },
+    ],
+    coords: [{ elements: ['a'], suggestion: 'Use area instead of a for image maps.' }],
+    datafld: [
+        {
+            elements: [
+                'a',
+                'button',
+                'div',
+                'fieldset',
+                'frame',
+                'iframe',
+                'img',
+                'input',
+                'label',
+                'legend',
+                'marquee',
+                'object',
+                'select',
+                'span',
+                'textarea',
+            ],
+            suggestion: 'Use script and a mechanism such as XMLHttpRequest to populate the page dynamically.',
+        },
+    ],
+    dataformatas: [
+        {
+            elements: [
+                'button',
+                'div',
+                'input',
+                'label',
+                'legend',
+                'marquee',
+                'object',
+                'option',
+                'select',
+                'span',
+                'table',
+            ],
+            suggestion: 'Use script and a mechanism such as XMLHttpRequest to populate the page dynamically.',
+        },
+    ],
+    datapagesize: [
+        {
+            elements: ['table'],
+            suggestion: 'Unnecessary. Omit it altogether.',
+        },
+    ],
+    datasrc: [
+        {
+            elements: [
+                'a',
+                'button',
+                'div',
+                'frame',
+                'iframe',
+                'img',
+                'input',
+                'label',
+                'legend',
+                'marquee',
+                'object',
+                'option',
+                'select',
+                'span',
+                'table',
+                'textarea',
+            ],
+            suggestion: 'Use script and a mechanism such as XMLHttpRequest to populate the page dynamically.',
+        },
+    ],
+    declare: [
+        {
+            elements: ['object'],
+            suggestion: 'Repeat the object element completely each time the resource is to be reused.',
+        },
+    ],
+    dropzone: [
+        {
+            elements: ['*'],
+            suggestion: 'Use script to handle the dragenter and dragover events instead.',
+        },
+    ],
+    event: [
+        {
+            elements: ['script'],
+            suggestion: 'Use DOM events mechanisms to register event listeners.',
+        },
+    ],
+    for: [
+        {
+            elements: ['script'],
+            suggestion: 'Use DOM events mechanisms to register event listeners.',
+        },
+    ],
+    frame: [{ elements: ['table'], suggestion: 'Use CSS instead.' }],
+    frameborder: [{ elements: ['iframe'], suggestion: 'Use CSS instead.' }],
+    framespacing: [{ elements: ['iframe'], suggestion: 'Use CSS instead.' }],
+    height: [
+        {
+            elements: ['table', 'thead', 'tbody', 'tfoot', 'td', 'th', 'tr'],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    hreflang: [
+        {
+            elements: ['area'],
+            suggestion: 'These attributes do not do anything useful, and for historical reasons there are no corresponding IDL attributes on area elements. Omit them altogether.',
+        },
+    ],
+    hspace: [
+        {
+            elements: ['embed', 'iframe', 'input', 'img', 'object'],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    ismap: [
+        {
+            elements: ['input'],
+            suggestion: 'Unnecessary. Omit it altogether. All input elements with a type attribute in the Image Button state are processed as server-side image maps.',
+        },
+    ],
+    label: [
+        {
+            elements: ['menu'],
+            suggestion: 'To implement a custom context menu, use script to handle the contextmenu event.',
+        },
+    ],
+    language: [
+        {
+            elements: ['script'],
+            suggestion: 'Omit the attribute for JavaScript; for data blocks, use the type attribute instead.',
+        },
+    ],
+    leftmargin: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
+    link: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
+    longdesc: [
+        {
+            elements: ['iframe', 'img'],
+            suggestion: "Use a regular a element to link to the description, or (in the case of images) use an image map to provide a link from the image to the image's description.",
+        },
+    ],
+    lowsrc: [
+        {
+            elements: ['img'],
+            suggestion: 'Use a progressive JPEG image (given in the src attribute), instead of using two separate images.',
+        },
+    ],
+    manifest: [{ elements: ['html'], suggestion: 'Use service workers instead.' }],
+    marginheight: [
+        {
+            elements: ['body', 'iframe'],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    marginwidth: [
+        {
+            elements: ['body', 'iframe'],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    methods: [
+        {
+            elements: ['a', 'link'],
+            suggestion: 'Use the HTTP OPTIONS feature instead.',
+        },
+    ],
+    name: [
+        {
+            elements: ['a', 'embed', 'img', 'option'],
+            suggestion: 'Use the id attribute instead.',
+        },
+    ],
+    nohref: [
+        {
+            elements: ['area'],
+            suggestion: 'Omitting the href attribute is sufficient; the nohref attribute is unnecessary. Omit it altogether.',
+        },
+    ],
+    noshade: [{ elements: ['hr'], suggestion: 'Use CSS instead.' }],
+    nowrap: [{ elements: ['td', 'th'], suggestion: 'Use CSS instead.' }],
+    onshow: [
+        {
+            elements: ['*'],
+            suggestion: 'To implement a custom context menu, use script to handle the contextmenu event.',
+        },
+    ],
+    profile: [{ elements: ['head'], suggestion: 'Unnecessary. Omit it altogether.' }],
+    rev: [
+        {
+            elements: ['a', 'link'],
+            suggestion: 'Use the rel attribute instead, with an opposite term. (For example, instead of rev="made", use rel="author".)',
+        },
+    ],
+    rightmargin: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
+    scheme: [
+        {
+            elements: ['meta'],
+            suggestion: 'Use only one scheme per field, or make the scheme declaration part of the value.',
+        },
+    ],
+    scope: [
+        {
+            elements: ['td'],
+            suggestion: 'Use th elements for heading cells.',
+        },
+    ],
+    scrolling: [{ elements: ['iframe'], suggestion: 'Use CSS instead.' }],
+    shape: [{ elements: ['a'], suggestion: 'Use area instead of a for image maps.' }],
+    size: [{ elements: ['hr'], suggestion: 'Use CSS instead.' }],
+    standby: [
+        {
+            elements: ['object'],
+            suggestion: 'Optimize the linked resource so that it loads quickly or, at least, incrementally.',
+        },
+    ],
+    summary: [
+        {
+            elements: ['table'],
+            suggestion: 'Use one of the techniques for describing tables given in the table section instead.',
+        },
+    ],
+    target: [{ elements: ['link'], suggestion: 'Unnecessary. Omit it altogether.' }],
+    text: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
+    topmargin: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
+    type: [
+        {
+            elements: ['area'],
+            suggestion: 'These attributes do not do anything useful, and for historical reasons there are no corresponding IDL attributes on area elements. Omit them altogether.',
+        },
+        { elements: ['li'], suggestion: 'Use CSS instead.' },
+        {
+            elements: ['menu'],
+            suggestion: 'To implement a custom context menu, use script to handle the contextmenu event. For toolbar menus, omit the attribute.',
+        },
+        {
+            elements: ['style'],
+            suggestion: 'Omit the attribute for CSS; for data blocks, use script as the container instead of style.',
+        },
+        { elements: ['ul'], suggestion: 'Use CSS instead.' },
+    ],
+    typemustmatch: [
+        {
+            elements: ['object'],
+            suggestion: 'Avoid using object elements with untrusted resources.',
+        },
+    ],
+    urn: [
+        {
+            elements: ['a', 'link'],
+            suggestion: 'Specify the preferred persistent identifier using the href attribute instead.',
+        },
+    ],
+    usemap: [
+        {
+            elements: ['input', 'object'],
+            suggestion: 'Use the img element for image maps.',
+        },
+    ],
+    valign: [
+        {
+            elements: ['col', 'tbody', 'thead', 'tfoot', 'td', 'th', 'tr'],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    version: [{ elements: ['html'], suggestion: 'Unnecessary. Omit it altogether.' }],
+    vlink: [{ elements: ['body'], suggestion: 'Use CSS instead.' }],
+    vspace: [
+        {
+            elements: ['embed', 'iframe', 'input', 'img', 'object'],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    width: [
+        {
+            elements: ['col', 'hr', 'pre', 'table', 'td', 'th'],
+            suggestion: 'Use CSS instead.',
+        },
+    ],
+    rules: [{ elements: ['table'], suggestion: 'Use CSS instead.' }],
+};
+
+const MESSAGE_ID$9 = 'obsolete';
+const rule$u = createRule({
+    name: 'no-obsolete-attrs',
+    rule: {
+        create(context) {
+            return {
+                Element(rawNode) {
+                    const node = rawNode;
+                    const elementName = node.name.toLowerCase();
+                    for (const attr of node.attributes) {
+                        if (!attr.valueSpan) {
+                            continue;
+                        }
+                        const attrName = attr.name.toLowerCase();
+                        const obsoleteConfigs = OBSOLETE_HTML_ATTRS[attrName];
+                        if (!obsoleteConfigs) {
+                            continue;
+                        }
+                        const obsoleteConfig = obsoleteConfigs.find((config) => config.elements.includes('*') ||
+                            config.elements.includes(elementName));
+                        if (!obsoleteConfig) {
+                            continue;
+                        }
+                        context.report({
+                            data: {
+                                attr: attrName,
+                                element: elementName,
+                                suggestion: obsoleteConfig.suggestion,
+                            },
+                            loc: sourceSpanToLoc(attr.keySpan ?? attr.sourceSpan),
+                            messageId: MESSAGE_ID$9,
+                        });
+                    }
+                },
+            };
+        },
+        meta: {
+            docs: { description: 'Disallow obsolete HTML attributes' },
+            messages: {
+                [MESSAGE_ID$9]: 'The {{attr}} attribute on <{{element}}> is obsolete. {{suggestion}}',
+            },
+            schema: [],
+            type: 'problem',
+        },
+    },
+});
+
+const OBSOLETE_HTML_TAGS = new Set([
+    'acronym',
+    'applet',
+    'basefont',
+    'bgsound',
+    'big',
+    'blink',
+    'center',
+    'dir',
+    'font',
+    'frame',
+    'frameset',
+    'isindex',
+    'keygen',
+    'listing',
+    'marquee',
+    'menuitem',
+    'multicol',
+    'nextid',
+    'nobr',
+    'noembed',
+    'noframes',
+    'plaintext',
+    'rb',
+    'rtc',
+    'spacer',
+    'strike',
+    'tt',
+    'xmp',
+]);
+
+const MESSAGE_ID$8 = 'unexpected';
+const rule$t = createRule({
+    name: 'no-obsolete-tags',
+    rule: {
+        create(context) {
+            return {
+                Element(rawNode) {
+                    const node = rawNode;
+                    if (!OBSOLETE_HTML_TAGS.has(node.name)) {
+                        return;
+                    }
+                    context.report({
+                        data: { tag: node.name },
+                        loc: sourceSpanToLoc(node.startSourceSpan),
+                        messageId: MESSAGE_ID$8,
+                    });
+                },
+            };
+        },
+        meta: {
+            docs: { description: 'Disallow obsolete HTML tags' },
+            messages: { [MESSAGE_ID$8]: 'Unexpected use of obsolete tag <{{tag}}>' },
+            schema: [],
+            type: 'problem',
+        },
+    },
+});
+
+const rule$s = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
         return {
@@ -249893,7 +249817,7 @@ const config$2 = {
         type: 'problem',
     },
 };
-const rule$q = createRule({
+const rule$r = createRule({
     name: 'no-project-as-in-ng-template',
     rule: config$2,
 });
@@ -249923,7 +249847,7 @@ function collectArrayExpressions(node) {
     }
     return result;
 }
-const rule$p = createRule({
+const rule$q = createRule({
     create(context) {
         const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const ignoreTupleContextualTyping = context.options[0]?.ignoreTupleContextualTyping ?? true;
@@ -250348,7 +250272,7 @@ function inspectComputedBody(root, context, localScopes, visitedFunctions, repor
         return;
     });
 }
-const rule$o = createRule({
+const rule$p = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode, tsNodeToESTreeNodeMap, } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -250391,7 +250315,7 @@ const rule$o = createRule({
     name: 'no-side-effects-in-computed',
 });
 
-const rule$n = createUntrackedRule({
+const rule$o = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -250445,8 +250369,7 @@ function collectParts(node) {
 }
 function isRootConcat(node) {
     const { parent } = node;
-    return (parent.type !== dist$3.AST_NODE_TYPES.BinaryExpression ||
-        parent.operator !== '+');
+    return parent.type !== dist$3.AST_NODE_TYPES.BinaryExpression || parent.operator !== '+';
 }
 function isStringType(type, checker) {
     if (type.isUnion()) {
@@ -250486,7 +250409,7 @@ function templateContent(template, renderExpr) {
         : ''}`)
         .join('');
 }
-const rule$m = createRule({
+const rule$n = createRule({
     create(context) {
         const { sourceCode } = context;
         let parserServices = null;
@@ -250821,7 +250744,7 @@ function buildReactiveCallReplacement(outerUntrackedCall, reactiveCall, sourceCo
     }
     return dedent(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
 }
-const rule$l = createUntrackedRule({
+const rule$m = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -250950,7 +250873,7 @@ function hasOpaqueSynchronousCalls(root, checker, esTreeNodeToTSNodeMap, program
     });
     return found;
 }
-const rule$k = createUntrackedRule({
+const rule$l = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251032,7 +250955,7 @@ const rule$k = createUntrackedRule({
     name: 'no-useless-untracked',
 });
 
-const rule$j = createRule({
+const rule$k = createRule({
     create(context, [{ printWidth }]) {
         const sourceCode = context.sourceCode;
         const getLineEndIndex = (lineStartIndex) => {
@@ -251353,7 +251276,7 @@ function renderTest(node, sourceCode) {
     const text = sourceCode.getText(node);
     return needsParenthesesInOrChain(node) ? `(${text})` : text;
 }
-const rule$i = createRule({
+const rule$j = createRule({
     create(context) {
         const { sourceCode } = context;
         function checkBody(statements) {
@@ -251456,7 +251379,7 @@ function getPushCall(node) {
     }
     return call;
 }
-const rule$h = createRule({
+const rule$i = createRule({
     create(context) {
         const { sourceCode } = context;
         function checkBody(statements) {
@@ -251550,7 +251473,7 @@ function getModuleKeywordToken(sourceCode, node) {
     }
     return firstToken;
 }
-const rule$g = createRule({
+const rule$h = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -251820,7 +251743,7 @@ function collectSuspiciousReads(scope, checker, esTreeNodeToTSNodeMap, tsNodeToE
     });
     return [...suspicious.values()];
 }
-const rule$f = createUntrackedRule({
+const rule$g = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode, tsNodeToESTreeNodeMap, } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251908,7 +251831,7 @@ function getWrappedSignalGetter(node, checker, esTreeNodeToTSNodeMap) {
     }
     return isSignalType(getter, checker, esTreeNodeToTSNodeMap) ? body.callee : null;
 }
-const rule$e = createUntrackedRule({
+const rule$f = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251944,6 +251867,313 @@ const rule$e = createUntrackedRule({
     name: 'prefer-untracked-signal-getter',
 });
 
+const MESSAGE_IDS$2 = {
+    MISSING: 'missing',
+    UNEXPECTED: 'unexpected',
+};
+const EXPECTED_QUOTE = '"';
+const SINGLE_QUOTE = "'";
+const DOUBLE_QUOTE = '"';
+function isQuotableAttribute(attr) {
+    return 'sourceSpan' in attr;
+}
+const rule$e = createRule({
+    name: 'quotes',
+    rule: {
+        create(context) {
+            const sourceText = context.sourceCode.getText();
+            return {
+                Element(rawNode) {
+                    const node = rawNode;
+                    for (const attr of [
+                        ...node.attributes,
+                        ...node.inputs,
+                        ...node.outputs,
+                    ].filter(isQuotableAttribute)) {
+                        const valueSpan = getAttributeValueSpan(attr);
+                        if (!valueSpan) {
+                            continue;
+                        }
+                        const rawValue = sourceText.slice(valueSpan.start.offset, valueSpan.end.offset);
+                        if (rawValue.includes(EXPECTED_QUOTE)) {
+                            continue;
+                        }
+                        const openingQuote = sourceText[valueSpan.start.offset - 1];
+                        const closingQuote = sourceText[valueSpan.end.offset];
+                        const hasMatchingQuotes = (openingQuote === SINGLE_QUOTE ||
+                            openingQuote === DOUBLE_QUOTE) &&
+                            openingQuote === closingQuote;
+                        if (hasMatchingQuotes && openingQuote !== EXPECTED_QUOTE) {
+                            context.report({
+                                data: {
+                                    actual: `single(${openingQuote})`,
+                                    expected: `double(${EXPECTED_QUOTE})`,
+                                },
+                                fix: (fixer) => fixer.replaceTextRange([
+                                    valueSpan.start.offset - 1,
+                                    valueSpan.end.offset + 1,
+                                ], `${EXPECTED_QUOTE}${rawValue}${EXPECTED_QUOTE}`),
+                                loc: sourceSpanToLoc(attr.sourceSpan),
+                                messageId: MESSAGE_IDS$2.UNEXPECTED,
+                            });
+                            continue;
+                        }
+                        if (!hasMatchingQuotes) {
+                            context.report({
+                                data: { expected: `double(${EXPECTED_QUOTE})` },
+                                fix: (fixer) => fixer.replaceTextRange([valueSpan.start.offset, valueSpan.end.offset], `${EXPECTED_QUOTE}${rawValue}${EXPECTED_QUOTE}`),
+                                loc: sourceSpanToLoc(attr.sourceSpan),
+                                messageId: MESSAGE_IDS$2.MISSING,
+                            });
+                        }
+                    }
+                },
+            };
+        },
+        meta: {
+            docs: { description: 'Enforce double quotes around HTML attribute values' },
+            fixable: 'code',
+            messages: {
+                [MESSAGE_IDS$2.MISSING]: 'Expected {{expected}} quotes but no quotes found.',
+                [MESSAGE_IDS$2.UNEXPECTED]: 'Expected {{expected}} quotes but found {{actual}}.',
+            },
+            schema: [],
+            type: 'layout',
+        },
+    },
+});
+
+const MESSAGE_ID$6 = 'missing';
+const DOCTYPE_REGEXP = /^\s*<!doctype html>/i;
+const rule$d = createRule({
+    name: 'require-doctype',
+    rule: {
+        create(context) {
+            const sourceText = context.sourceCode.getText();
+            let reported = false;
+            return {
+                Element(rawNode) {
+                    const node = rawNode;
+                    if (reported ||
+                        node.name !== 'html' ||
+                        DOCTYPE_REGEXP.test(sourceText)) {
+                        return;
+                    }
+                    reported = true;
+                    context.report({
+                        fix: (fixer) => fixer.insertTextBeforeRange([0, 0], '<!DOCTYPE html>\n'),
+                        loc: sourceSpanToLoc(node.startSourceSpan),
+                        messageId: MESSAGE_ID$6,
+                    });
+                },
+            };
+        },
+        meta: {
+            docs: { description: 'Require <!DOCTYPE html> in HTML documents' },
+            fixable: 'code',
+            messages: { [MESSAGE_ID$6]: 'Missing `<!DOCTYPE html>`' },
+            schema: [],
+            type: 'problem',
+        },
+    },
+});
+
+const MESSAGE_ID$5 = 'missingAlt';
+function hasAlt(node) {
+    return (node.attributes.some((attr) => attr.name === 'alt') ||
+        node.inputs.some((input) => input.name === 'alt' || input.keySpan.details === 'attr.alt'));
+}
+const rule$c = createRule({
+    name: 'require-img-alt',
+    rule: {
+        create(context) {
+            return {
+                Element(rawNode) {
+                    const node = rawNode;
+                    if (node.name !== 'img' || hasAlt(node)) {
+                        return;
+                    }
+                    context.report({
+                        loc: sourceSpanToLoc(node.startSourceSpan),
+                        messageId: MESSAGE_ID$5,
+                    });
+                },
+            };
+        },
+        meta: {
+            docs: { description: 'Require alt or attr.alt on img elements' },
+            messages: { [MESSAGE_ID$5]: 'Missing `alt` attribute at `<img>` tag' },
+            schema: [],
+            type: 'suggestion',
+        },
+    },
+});
+
+const MESSAGE_IDS$1 = {
+    EMPTY: 'empty',
+    MISSING: 'missing',
+};
+const rule$b = createRule({
+    name: 'require-lang',
+    rule: {
+        create(context) {
+            return {
+                Element(rawNode) {
+                    const node = rawNode;
+                    if (node.name !== 'html') {
+                        return;
+                    }
+                    const langAttr = node.attributes.find((attr) => attr.name === 'lang');
+                    const hasBoundLang = node.inputs.some((input) => input.name === 'lang' ||
+                        input.keySpan.details === 'attr.lang');
+                    if (!langAttr && !hasBoundLang) {
+                        context.report({
+                            loc: sourceSpanToLoc(node.startSourceSpan),
+                            messageId: MESSAGE_IDS$1.MISSING,
+                        });
+                        return;
+                    }
+                    if (langAttr?.value.trim().length === 0) {
+                        context.report({
+                            loc: sourceSpanToLoc(langAttr.sourceSpan),
+                            messageId: MESSAGE_IDS$1.EMPTY,
+                        });
+                    }
+                },
+            };
+        },
+        meta: {
+            docs: { description: 'Require a non-empty lang attribute on the html element' },
+            messages: {
+                [MESSAGE_IDS$1.EMPTY]: 'Unexpected empty `lang` in in `<html>` tag.',
+                [MESSAGE_IDS$1.MISSING]: 'Missing `lang` attribute in `<html>` tag.',
+            },
+            schema: [],
+            type: 'problem',
+        },
+    },
+});
+
+const MESSAGE_ID$4 = 'invalid';
+const VALID_CONTAINERS = new Set(['menu', 'ol', 'ul']);
+function getClosestParentElement(node) {
+    let parent = node.parent;
+    while (parent) {
+        if (parent instanceof dist$4.TmplAstElement) {
+            return parent;
+        }
+        if (parent instanceof dist$4.TmplAstTemplate) {
+            parent = parent.parent;
+            continue;
+        }
+        break;
+    }
+    return null;
+}
+const rule$a = createRule({
+    name: 'require-li-container',
+    rule: {
+        create(context) {
+            return {
+                Element(rawNode) {
+                    const node = rawNode;
+                    if (node.name !== 'li') {
+                        return;
+                    }
+                    const parent = getClosestParentElement(node);
+                    if (parent && VALID_CONTAINERS.has(parent.name)) {
+                        return;
+                    }
+                    context.report({
+                        loc: sourceSpanToLoc(node.startSourceSpan),
+                        messageId: MESSAGE_ID$4,
+                    });
+                },
+            };
+        },
+        meta: {
+            docs: {
+                description: 'Require li elements to be placed inside ul, ol, or menu',
+            },
+            messages: {
+                [MESSAGE_ID$4]: 'Invalid container of `<li>`. <li>` should be in `<ul>`, `<ol>` or `<menu>`.',
+            },
+            schema: [],
+            type: 'problem',
+        },
+    },
+});
+
+const MESSAGE_IDS = {
+    EMPTY_TITLE: 'empty',
+    MISSING_TITLE: 'missing',
+};
+function hasMeaningfulTitleContent(node) {
+    return node.children.some((child) => {
+        if (!('value' in child)) {
+            return false;
+        }
+        const { value } = child;
+        return (typeof value === 'object' ||
+            (typeof value === 'string' && value.trim().length > 0));
+    });
+}
+const rule$9 = createRule({
+    name: 'require-title',
+    rule: {
+        create(context) {
+            let headNode;
+            let headDepth = 0;
+            let titleNode;
+            return {
+                Element(rawNode) {
+                    const node = rawNode;
+                    if (node.name === 'head') {
+                        headNode = node;
+                        headDepth++;
+                    }
+                    else if (headDepth > 0 && node.name === 'title') {
+                        titleNode = node;
+                    }
+                },
+                'Element:exit'(rawNode) {
+                    const node = rawNode;
+                    if (node.name === 'head') {
+                        headDepth--;
+                    }
+                },
+                'Program:exit'() {
+                    if (!headNode) {
+                        return;
+                    }
+                    if (!titleNode) {
+                        context.report({
+                            loc: sourceSpanToLoc(headNode.startSourceSpan),
+                            messageId: MESSAGE_IDS.MISSING_TITLE,
+                        });
+                        return;
+                    }
+                    if (!hasMeaningfulTitleContent(titleNode)) {
+                        context.report({
+                            loc: sourceSpanToLoc(titleNode.startSourceSpan),
+                            messageId: MESSAGE_IDS.EMPTY_TITLE,
+                        });
+                    }
+                },
+            };
+        },
+        meta: {
+            docs: { description: 'Require a non-empty title element inside head' },
+            messages: {
+                [MESSAGE_IDS.EMPTY_TITLE]: 'Unexpected empty text in `<title></title>`',
+                [MESSAGE_IDS.MISSING_TITLE]: 'Missing `<title></title>` in the `<head></head>`',
+            },
+            schema: [],
+            type: 'problem',
+        },
+    },
+});
+
 function isArray(node) {
     return node?.type === dist$2.AST_NODE_TYPES.ArrayExpression;
 }
@@ -251962,7 +252192,7 @@ function getImportedName(spec) {
     return spec.imported.value;
 }
 
-const MESSAGE_ID$6 = 'replaceTuiImport';
+const MESSAGE_ID$3 = 'replaceTuiImport';
 const DEFAULT_DECORATORS = ['Component', 'Directive', 'NgModule', 'Pipe'];
 const DEFAULT_EXCEPTIONS = [
     { from: 'TuiTextfieldOptionsDirective', to: 'TuiTextfield' },
@@ -251971,7 +252201,7 @@ const DEFAULT_EXCEPTIONS = [
     { from: 'TuiIslandDirective', to: 'TuiIsland' },
     { from: 'TuiTableBarsHostComponent', to: 'TuiTableBarsHost' },
 ];
-const rule$d = createRule({
+const rule$8 = createRule({
     create(context, [{ decorators = DEFAULT_DECORATORS, exceptions = DEFAULT_EXCEPTIONS }]) {
         const sourceCode = context.getSourceCode();
         const importedFromTaiga = {};
@@ -252055,7 +252285,7 @@ const rule$d = createRule({
                                 fixer.replaceText(importName, short),
                             ];
                         },
-                        messageId: MESSAGE_ID$6,
+                        messageId: MESSAGE_ID$3,
                         node: importName,
                     });
                 }
@@ -252180,7 +252410,7 @@ function getLeadingIndentation(text) {
     return text.slice(0, index);
 }
 
-const rule$c = createRule({
+const rule$7 = createRule({
     create(context) {
         const sourceCode = context.sourceCode;
         const getIndentation = (line) => getLeadingIndentation(sourceCode.lines[line - 1] ?? '');
@@ -252341,7 +252571,7 @@ function getSortedNames(elements, source) {
     return [...sortedRegular, ...sortedSpreads].map((n) => nameOf(n, source));
 }
 
-const rule$b = createRule({
+const rule$6 = createRule({
     create(context, [options]) {
         const allowed = new Set(options.decorators);
         const source = context.sourceCode;
@@ -252397,237 +252627,6 @@ const rule$b = createRule({
     name: 'standalone-imports-sort',
 });
 
-const MESSAGE_ID$5 = 'missing';
-const DOCTYPE_REGEXP = /^\s*<!doctype html>/i;
-const rule$a = createRule({
-    name: 'require-doctype',
-    rule: {
-        create(context) {
-            const sourceText = context.sourceCode.getText();
-            let reported = false;
-            return {
-                Element(rawNode) {
-                    const node = rawNode;
-                    if (reported ||
-                        node.name !== 'html' ||
-                        DOCTYPE_REGEXP.test(sourceText)) {
-                        return;
-                    }
-                    reported = true;
-                    context.report({
-                        fix: (fixer) => fixer.insertTextBeforeRange([0, 0], '<!DOCTYPE html>\n'),
-                        loc: sourceSpanToLoc(node.startSourceSpan),
-                        messageId: MESSAGE_ID$5,
-                    });
-                },
-            };
-        },
-        meta: {
-            docs: { description: 'Require <!DOCTYPE html> in HTML documents' },
-            fixable: 'code',
-            messages: { [MESSAGE_ID$5]: 'Missing `<!DOCTYPE html>`' },
-            schema: [],
-            type: 'problem',
-        },
-    },
-});
-
-const MESSAGE_ID$4 = 'missingAlt';
-function hasAlt(node) {
-    return (node.attributes.some((attr) => attr.name === 'alt') ||
-        node.inputs.some((input) => input.name === 'alt' || input.keySpan.details === 'attr.alt'));
-}
-const rule$9 = createRule({
-    name: 'require-img-alt',
-    rule: {
-        create(context) {
-            return {
-                Element(rawNode) {
-                    const node = rawNode;
-                    if (node.name !== 'img' || hasAlt(node)) {
-                        return;
-                    }
-                    context.report({
-                        loc: sourceSpanToLoc(node.startSourceSpan),
-                        messageId: MESSAGE_ID$4,
-                    });
-                },
-            };
-        },
-        meta: {
-            docs: { description: 'Require alt or attr.alt on img elements' },
-            messages: { [MESSAGE_ID$4]: 'Missing `alt` attribute at `<img>` tag' },
-            schema: [],
-            type: 'suggestion',
-        },
-    },
-});
-
-const MESSAGE_IDS$1 = {
-    EMPTY: 'empty',
-    MISSING: 'missing',
-};
-const rule$8 = createRule({
-    name: 'require-lang',
-    rule: {
-        create(context) {
-            return {
-                Element(rawNode) {
-                    const node = rawNode;
-                    if (node.name !== 'html') {
-                        return;
-                    }
-                    const langAttr = node.attributes.find((attr) => attr.name === 'lang');
-                    const hasBoundLang = node.inputs.some((input) => input.name === 'lang' ||
-                        input.keySpan.details === 'attr.lang');
-                    if (!langAttr && !hasBoundLang) {
-                        context.report({
-                            loc: sourceSpanToLoc(node.startSourceSpan),
-                            messageId: MESSAGE_IDS$1.MISSING,
-                        });
-                        return;
-                    }
-                    if (langAttr?.value.trim().length === 0) {
-                        context.report({
-                            loc: sourceSpanToLoc(langAttr.sourceSpan),
-                            messageId: MESSAGE_IDS$1.EMPTY,
-                        });
-                    }
-                },
-            };
-        },
-        meta: {
-            docs: { description: 'Require a non-empty lang attribute on the html element' },
-            messages: {
-                [MESSAGE_IDS$1.EMPTY]: 'Unexpected empty `lang` in in `<html>` tag.',
-                [MESSAGE_IDS$1.MISSING]: 'Missing `lang` attribute in `<html>` tag.',
-            },
-            schema: [],
-            type: 'problem',
-        },
-    },
-});
-
-const MESSAGE_ID$3 = 'invalid';
-const VALID_CONTAINERS = new Set(['menu', 'ol', 'ul']);
-function getClosestParentElement(node) {
-    let parent = node.parent;
-    while (parent) {
-        if (parent instanceof dist$4.TmplAstElement) {
-            return parent;
-        }
-        if (parent instanceof dist$4.TmplAstTemplate) {
-            parent = parent.parent;
-            continue;
-        }
-        break;
-    }
-    return null;
-}
-const rule$7 = createRule({
-    name: 'require-li-container',
-    rule: {
-        create(context) {
-            return {
-                Element(rawNode) {
-                    const node = rawNode;
-                    if (node.name !== 'li') {
-                        return;
-                    }
-                    const parent = getClosestParentElement(node);
-                    if (parent && VALID_CONTAINERS.has(parent.name)) {
-                        return;
-                    }
-                    context.report({
-                        loc: sourceSpanToLoc(node.startSourceSpan),
-                        messageId: MESSAGE_ID$3,
-                    });
-                },
-            };
-        },
-        meta: {
-            docs: {
-                description: 'Require li elements to be placed inside ul, ol, or menu',
-            },
-            messages: {
-                [MESSAGE_ID$3]: 'Invalid container of `<li>`. <li>` should be in `<ul>`, `<ol>` or `<menu>`.',
-            },
-            schema: [],
-            type: 'problem',
-        },
-    },
-});
-
-const MESSAGE_IDS = {
-    EMPTY_TITLE: 'empty',
-    MISSING_TITLE: 'missing',
-};
-function hasMeaningfulTitleContent(node) {
-    return node.children.some((child) => {
-        if (!('value' in child)) {
-            return false;
-        }
-        const { value } = child;
-        return (typeof value === 'object' ||
-            (typeof value === 'string' && value.trim().length > 0));
-    });
-}
-const rule$6 = createRule({
-    name: 'require-title',
-    rule: {
-        create(context) {
-            let headNode;
-            let headDepth = 0;
-            let titleNode;
-            return {
-                Element(rawNode) {
-                    const node = rawNode;
-                    if (node.name === 'head') {
-                        headNode = node;
-                        headDepth++;
-                    }
-                    else if (headDepth > 0 && node.name === 'title') {
-                        titleNode = node;
-                    }
-                },
-                'Element:exit'(rawNode) {
-                    const node = rawNode;
-                    if (node.name === 'head') {
-                        headDepth--;
-                    }
-                },
-                'Program:exit'() {
-                    if (!headNode) {
-                        return;
-                    }
-                    if (!titleNode) {
-                        context.report({
-                            loc: sourceSpanToLoc(headNode.startSourceSpan),
-                            messageId: MESSAGE_IDS.MISSING_TITLE,
-                        });
-                        return;
-                    }
-                    if (!hasMeaningfulTitleContent(titleNode)) {
-                        context.report({
-                            loc: sourceSpanToLoc(titleNode.startSourceSpan),
-                            messageId: MESSAGE_IDS.EMPTY_TITLE,
-                        });
-                    }
-                },
-            };
-        },
-        meta: {
-            docs: { description: 'Require a non-empty title element inside head' },
-            messages: {
-                [MESSAGE_IDS.EMPTY_TITLE]: 'Unexpected empty text in `<title><title/>`',
-                [MESSAGE_IDS.MISSING_TITLE]: 'Missing `<title><title/>` in the `<head><head/>`',
-            },
-            schema: [],
-            type: 'problem',
-        },
-    },
-});
-
 const config$1 = {
     create(context) {
         const classesInFile = new Map();
@@ -253495,51 +253494,51 @@ const plugin = {
         'array-as-const': rule$5,
         'attrs-newline': rule$M,
         'class-property-naming': rule$4,
-        'decorator-key-sort': rule$E,
-        'element-newline': rule$L,
+        'decorator-key-sort': rule$L,
+        'element-newline': rule$K,
         'flat-exports': rule$3,
-        'host-attributes-sort': rule$D,
-        'html-logical-properties': rule$C,
-        'injection-token-description': rule$B,
-        'no-commonjs-import-patterns': rule$A,
-        'no-deep-imports': rule$z,
-        'no-deep-imports-to-indexed-packages': rule$y,
-        'no-duplicate-attrs': rule$K,
-        'no-duplicate-id': rule$J,
-        'no-duplicate-in-head': rule$I,
-        'no-fully-untracked-effect': rule$x,
-        'no-href-with-router-link': rule$w,
-        'no-implicit-public': rule$v,
-        'no-import-assertions': rule$u,
-        'no-infinite-loop': rule$t,
-        'no-legacy-peer-deps': rule$s,
-        'no-obsolete-attrs': rule$H,
-        'no-obsolete-tags': rule$G,
-        'no-playwright-empty-fill': rule$r,
-        'no-project-as-in-ng-template': rule$q,
-        'no-redundant-type-annotation': rule$p,
+        'host-attributes-sort': rule$J,
+        'html-logical-properties': rule$I,
+        'injection-token-description': rule$H,
+        'no-commonjs-import-patterns': rule$G,
+        'no-deep-imports': rule$F,
+        'no-deep-imports-to-indexed-packages': rule$E,
+        'no-duplicate-attrs': rule$D,
+        'no-duplicate-id': rule$C,
+        'no-duplicate-in-head': rule$B,
+        'no-fully-untracked-effect': rule$A,
+        'no-href-with-router-link': rule$z,
+        'no-implicit-public': rule$y,
+        'no-import-assertions': rule$x,
+        'no-infinite-loop': rule$w,
+        'no-legacy-peer-deps': rule$v,
+        'no-obsolete-attrs': rule$u,
+        'no-obsolete-tags': rule$t,
+        'no-playwright-empty-fill': rule$s,
+        'no-project-as-in-ng-template': rule$r,
+        'no-redundant-type-annotation': rule$q,
         'no-restricted-attr-values': rule$2,
-        'no-side-effects-in-computed': rule$o,
-        'no-signal-reads-after-await-in-reactive-context': rule$n,
-        'no-string-literal-concat': rule$m,
-        'no-untracked-outside-reactive-context': rule$l,
-        'no-useless-untracked': rule$k,
-        'object-single-line': rule$j,
-        'prefer-combined-if-control-flow': rule$i,
+        'no-side-effects-in-computed': rule$p,
+        'no-signal-reads-after-await-in-reactive-context': rule$o,
+        'no-string-literal-concat': rule$n,
+        'no-untracked-outside-reactive-context': rule$m,
+        'no-useless-untracked': rule$l,
+        'object-single-line': rule$k,
+        'prefer-combined-if-control-flow': rule$j,
         'prefer-deep-imports': rule$1,
-        'prefer-multi-arg-push': rule$h,
-        'prefer-namespace-keyword': rule$g,
-        'prefer-untracked-incidental-signal-reads': rule$f,
-        'prefer-untracked-signal-getter': rule$e,
-        quotes: rule$F,
-        'require-doctype': rule$a,
-        'require-img-alt': rule$9,
-        'require-lang': rule$8,
-        'require-li-container': rule$7,
-        'require-title': rule$6,
-        'short-tui-imports': rule$d,
-        'single-line-class-property-spacing': rule$c,
-        'standalone-imports-sort': rule$b,
+        'prefer-multi-arg-push': rule$i,
+        'prefer-namespace-keyword': rule$h,
+        'prefer-untracked-incidental-signal-reads': rule$g,
+        'prefer-untracked-signal-getter': rule$f,
+        quotes: rule$e,
+        'require-doctype': rule$d,
+        'require-img-alt': rule$c,
+        'require-lang': rule$b,
+        'require-li-container': rule$a,
+        'require-title': rule$9,
+        'short-tui-imports': rule$8,
+        'single-line-class-property-spacing': rule$7,
+        'standalone-imports-sort': rule$6,
         'strict-tui-doc-example': rule,
     },
 };