@angular-eslint/eslint-plugin-template 15.2.2-alpha.24 → 15.2.2-alpha.26

package/dist/rules/no-positive-tabindex.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const get_dom_elements_1 = require("../utils/get-dom-elements");
+const to_pattern_1 = require("../utils/to-pattern");
+exports.RULE_NAME = 'no-positive-tabindex';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures that the `tabindex` attribute is not positive',
+            recommended: false,
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            noPositiveTabindex: 'The `tabindex` attribute should not be positive',
+            suggestNonNegativeTabindex: 'Use `tabindex="{{tabindex}}"`',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        const elementNamePattern = (0, to_pattern_1.toPattern)([...(0, get_dom_elements_1.getDomElements)()]);
+        return {
+            [`Element$1[name=${elementNamePattern}] > BoundAttribute[name="tabindex"][value.ast.value>0], TextAttribute[name="tabindex"][value>0]`]({ valueSpan, }) {
+                const loc = parserServices.convertNodeSourceSpanToLoc(valueSpan);
+                context.report({
+                    loc,
+                    messageId: 'noPositiveTabindex',
+                    suggest: ['-1', '0'].map((tabindex) => ({
+                        messageId: 'suggestNonNegativeTabindex',
+                        fix: (fixer) => fixer.replaceTextRange([valueSpan.start.offset, valueSpan.end.offset], tabindex),
+                        data: { tabindex },
+                    })),
+                });
+            },
+        };
+    },
+});

package/dist/rules/role-has-required-aria.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const aria_query_1 = require("aria-query");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const get_dom_elements_1 = require("../utils/get-dom-elements");
+const to_pattern_1 = require("../utils/to-pattern");
+const is_semantic_role_element_1 = require("../utils/is-semantic-role-element");
+exports.RULE_NAME = 'role-has-required-aria';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: '[Accessibility] Ensures elements with ARIA roles have all required properties for that role.',
+            recommended: false,
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            roleHasRequiredAria: 'The {{element}} with role="{{role}}" does not have required ARIA properties: {{missingProps}}',
+            suggestRemoveRole: 'Remove role `{{role}}`',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        const elementNamePattern = (0, to_pattern_1.toPattern)([...(0, get_dom_elements_1.getDomElements)()]);
+        return {
+            [`Element$1[name=${elementNamePattern}] > TextAttribute[name='role']`](node) {
+                const { value: role, sourceSpan } = node;
+                const { attributes, inputs, name: element } = node.parent;
+                const props = [...attributes, ...inputs];
+                const roleDef = aria_query_1.roles.get(role);
+                const requiredProps = Object.keys((roleDef === null || roleDef === void 0 ? void 0 : roleDef.requiredProps) || {});
+                if (!requiredProps.length)
+                    return;
+                if ((0, is_semantic_role_element_1.isSemanticRoleElement)(element, role, props))
+                    return;
+                const missingProps = requiredProps
+                    .filter((requiredProp) => !props.find((prop) => prop.name === requiredProp))
+                    .join(', ');
+                if (missingProps) {
+                    const loc = parserServices.convertNodeSourceSpanToLoc(sourceSpan);
+                    context.report({
+                        loc,
+                        messageId: 'roleHasRequiredAria',
+                        data: {
+                            element,
+                            role,
+                            missingProps,
+                        },
+                        suggest: [
+                            {
+                                messageId: 'suggestRemoveRole',
+                                data: {
+                                    element,
+                                    role,
+                                    missingProps,
+                                },
+                                fix: (fixer) => fixer.removeRange([
+                                    (sourceSpan === null || sourceSpan === void 0 ? void 0 : sourceSpan.start.offset) - 1,
+                                    sourceSpan === null || sourceSpan === void 0 ? void 0 : sourceSpan.end.offset,
+                                ]),
+                            },
+                        ],
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/table-scope.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const get_dom_elements_1 = require("../utils/get-dom-elements");
+const to_pattern_1 = require("../utils/to-pattern");
+exports.RULE_NAME = 'table-scope';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: '[Accessibility] Ensures that the `scope` attribute is only used on the `<th>` element',
+            recommended: false,
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            tableScope: 'The `scope` attribute should only be on the `<th>` element',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        const domElementsPattern = (0, to_pattern_1.toPattern)([...(0, get_dom_elements_1.getDomElements)()].filter((domElement) => domElement !== 'th'));
+        return {
+            [`Element$1[name=${domElementsPattern}] > :matches(BoundAttribute, TextAttribute)[name='scope']`]({ sourceSpan, }) {
+                const loc = parserServices.convertNodeSourceSpanToLoc(sourceSpan);
+                context.report({
+                    loc,
+                    messageId: 'tableScope',
+                    fix: (fixer) => fixer.removeRange([
+                        sourceSpan.start.offset - 1,
+                        sourceSpan.end.offset,
+                    ]),
+                });
+            },
+        };
+    },
+});

package/dist/rules/use-track-by-function.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+const utils_1 = require("@angular-eslint/utils");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+exports.RULE_NAME = 'use-track-by-function';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Ensures trackBy function is used',
+            recommended: false,
+        },
+        schema: [],
+        messages: {
+            useTrackByFunction: 'Missing trackBy function in ngFor directive',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        return {
+            'BoundAttribute.inputs[name="ngForOf"]'({ parent: { inputs }, sourceSpan, }) {
+                if (inputs.some(isNgForTrackBy)) {
+                    return;
+                }
+                const loc = parserServices.convertNodeSourceSpanToLoc(sourceSpan);
+                context.report({
+                    messageId: 'useTrackByFunction',
+                    loc,
+                });
+            },
+            'BoundAttribute.templateAttrs[name="ngForOf"]'({ parent: { templateAttrs }, }) {
+                if (templateAttrs.some(isNgForTrackBy)) {
+                    return;
+                }
+                const { start } = parserServices.convertNodeSourceSpanToLoc(templateAttrs[0].sourceSpan);
+                const { end } = parserServices.convertNodeSourceSpanToLoc(templateAttrs[templateAttrs.length - 1].sourceSpan);
+                const loc = {
+                    start: Object.assign(Object.assign({}, start), { column: start.column - 1 }),
+                    end: Object.assign(Object.assign({}, end), { column: end.column + 1 }),
+                };
+                context.report({
+                    messageId: 'useTrackByFunction',
+                    loc,
+                });
+            },
+        };
+    },
+});
+function isNgForTrackBy(attribute) {
+    return (attribute instanceof bundled_angular_compiler_1.TmplAstBoundAttribute &&
+        attribute.name === 'ngForTrackBy');
+}

package/dist/rules/valid-aria.js

@@ -0,0 +1,126 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+const utils_1 = require("@angular-eslint/utils");
+const aria_query_1 = require("aria-query");
+const create_eslint_rule_1 = require("../utils/create-eslint-rule");
+const get_dom_elements_1 = require("../utils/get-dom-elements");
+const to_pattern_1 = require("../utils/to-pattern");
+exports.RULE_NAME = 'valid-aria';
+exports.default = (0, create_eslint_rule_1.createESLintRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: '[Accessibility] Ensures that correct ARIA attributes and respective values are used',
+            recommended: false,
+        },
+        hasSuggestions: true,
+        schema: [],
+        messages: {
+            validAria: 'The `{{attribute}}` is an invalid ARIA attribute',
+            validAriaValue: 'The `{{attribute}}` has an invalid value. Check the valid values at https://raw.githack.com/w3c/aria/stable/#roles',
+            suggestRemoveInvalidAria: 'Remove attribute `{{attribute}}`',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const parserServices = (0, utils_1.getTemplateParserServices)(context);
+        const elementNamePattern = (0, to_pattern_1.toPattern)([...(0, get_dom_elements_1.getDomElements)()]);
+        return {
+            [`Element$1[name=${elementNamePattern}] > :matches(BoundAttribute, TextAttribute)[name=/^aria-.+/]`](node) {
+                const { name: attribute, sourceSpan } = node;
+                const ariaPropertyDefinition = aria_query_1.aria.get(attribute);
+                const loc = parserServices.convertNodeSourceSpanToLoc(sourceSpan);
+                if (!ariaPropertyDefinition) {
+                    context.report({
+                        loc,
+                        messageId: 'validAria',
+                        data: { attribute },
+                        suggest: [
+                            {
+                                messageId: 'suggestRemoveInvalidAria',
+                                data: { attribute },
+                                fix: (fixer) => fixer.removeRange([
+                                    sourceSpan.start.offset - 1,
+                                    sourceSpan.end.offset,
+                                ]),
+                            },
+                        ],
+                    });
+                    return;
+                }
+                const ast = extractASTFrom(node);
+                if (canIgnoreNode(ast) ||
+                    isValidAriaPropertyValue(ariaPropertyDefinition, ast.value)) {
+                    return;
+                }
+                context.report({
+                    loc,
+                    messageId: 'validAriaValue',
+                    data: { attribute },
+                });
+            },
+        };
+    },
+});
+function isLiteralCollection(ast) {
+    return ast instanceof bundled_angular_compiler_1.LiteralArray || ast instanceof bundled_angular_compiler_1.LiteralMap;
+}
+function isPrimitive(ast) {
+    return ast instanceof bundled_angular_compiler_1.LiteralPrimitive || ast instanceof bundled_angular_compiler_1.TmplAstTextAttribute;
+}
+function canIgnoreNode(ast) {
+    return !isLiteralCollection(ast) && !isPrimitive(ast);
+}
+function extractASTFrom(attribute) {
+    return attribute instanceof bundled_angular_compiler_1.TmplAstBoundAttribute &&
+        attribute.value instanceof bundled_angular_compiler_1.ASTWithSource
+        ? attribute.value.ast
+        : attribute;
+}
+function isBooleanLike(value) {
+    return typeof value === 'boolean' || value === 'false' || value === 'true';
+}
+function isInteger(value) {
+    return (!Number.isNaN(value) &&
+        parseInt(Number(value)) == value &&
+        !Number.isNaN(parseInt(value, 10)));
+}
+function isNumeric(value) {
+    return (!Number.isNaN(Number.parseFloat(value)) &&
+        Number.isFinite(Number(value)));
+}
+function isNil(value) {
+    return value == null;
+}
+function isString(value) {
+    return typeof value == 'string';
+}
+function isValidAriaPropertyValue({ allowundefined, type, values }, attributeValue) {
+    if (allowundefined && isNil(attributeValue))
+        return true;
+    switch (type) {
+        case 'boolean':
+            return isBooleanLike(attributeValue);
+        case 'tristate':
+            return isBooleanLike(attributeValue) || isNil(attributeValue);
+        case 'id':
+        case 'idlist':
+            return true;
+        case 'integer':
+            return isInteger(attributeValue);
+        case 'number':
+            return isNumeric(attributeValue);
+        case 'string':
+            return isString(attributeValue);
+        case 'token':
+        case 'tokenlist': {
+            const parsedAttributeValue = isBooleanLike(attributeValue)
+                ? JSON.parse(attributeValue)
+                : attributeValue;
+            return Boolean(values === null || values === void 0 ? void 0 : values.includes(parsedAttributeValue));
+        }
+    }
+}

package/dist/utils/attributes-comparator.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.attributesComparator = void 0;
+const get_attribute_value_1 = require("./get-attribute-value");
+function attributesComparator(ariaRoleRelationConceptAttributes, node) {
+    const attributesInputs = [...node.attributes, ...node.inputs];
+    return ariaRoleRelationConceptAttributes.every((ariaRoleRelationConceptAttribute) => attributesInputs.some(({ name }) => {
+        if (node.name === 'a' && name === 'routerLink') {
+            return true;
+        }
+        if (ariaRoleRelationConceptAttribute.name !== name) {
+            return false;
+        }
+        return (!ariaRoleRelationConceptAttribute.value ||
+            ariaRoleRelationConceptAttribute.value ===
+                (0, get_attribute_value_1.getAttributeValue)(node, ariaRoleRelationConceptAttribute.name));
+    }));
+}
+exports.attributesComparator = attributesComparator;

package/dist/utils/constants.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PROPERTY_READ = void 0;
+/**
+ * A representation of a property read.
+ * @example
+ * ```html
+ * <input [disabled]="disabled">
+ * ```
+ */
+exports.PROPERTY_READ = Symbol('PROPERTY_READ');

package/dist/utils/create-eslint-rule.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createESLintRule = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * We need to patch the RuleCreator in order to preserve the defaultOptions
+ * to use as part of documentation generation.
+ */
+const patchedRuleCreator = (urlCreator) => {
+    return function createRule({ name, meta, defaultOptions, create }) {
+        return {
+            meta: Object.assign(Object.assign({}, meta), {
+                docs: Object.assign(Object.assign({}, meta.docs), {
+                    url: urlCreator(name),
+                }),
+            }),
+            defaultOptions,
+            create(context) {
+                const optionsWithDefault = utils_1.ESLintUtils.applyDefault(defaultOptions, context.options);
+                return create(context, optionsWithDefault);
+            },
+        };
+    };
+};
+patchedRuleCreator.withoutDocs = utils_1.ESLintUtils.RuleCreator.withoutDocs;
+exports.createESLintRule = patchedRuleCreator((ruleName) => `https://github.com/angular-eslint/angular-eslint/blob/main/packages/eslint-plugin-template/docs/rules/${ruleName}.md`);

package/dist/utils/get-attribute-value.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAttributeValue = void 0;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+const constants_1 = require("./constants");
+const get_original_attribute_name_1 = require("./get-original-attribute-name");
+/**
+ * Extracts the attribute value.
+ * @example
+ * ```ts
+ * getAttributeValue(Element(`<div property="test"></div>`), 'nonExistent'); // null
+ * getAttributeValue(Element(`<div aria-role="none"></div>`), 'role'); // 'none'
+ * getAttributeValue(Element(`<div [attr.aria-checked]="true"></div>`), 'aria-checked'); // true
+ * getAttributeValue(Element(`<button [variant]="variant"></button>`), 'variant'); // PROPERTY
+ * ```
+ */
+function getAttributeValue({ attributes, inputs }, attributeName) {
+    const attributeOrInput = [...attributes, ...inputs].find((attrOrInput) => (0, get_original_attribute_name_1.getOriginalAttributeName)(attrOrInput) === attributeName);
+    if (typeof (attributeOrInput === null || attributeOrInput === void 0 ? void 0 : attributeOrInput.value) === 'string') {
+        return attributeOrInput.value;
+    }
+    if (!((attributeOrInput === null || attributeOrInput === void 0 ? void 0 : attributeOrInput.value) instanceof bundled_angular_compiler_1.ASTWithSource)) {
+        return null;
+    }
+    if (attributeOrInput.value.ast instanceof bundled_angular_compiler_1.LiteralArray) {
+        return attributeOrInput.value.ast.expressions;
+    }
+    if (attributeOrInput.value.ast instanceof bundled_angular_compiler_1.LiteralMap) {
+        const { keys, values } = attributeOrInput.value.ast;
+        return keys.reduce((current, next, index) => {
+            return current.set(next.key, values[index]);
+        }, new Map());
+    }
+    if (attributeOrInput.value.ast instanceof bundled_angular_compiler_1.LiteralPrimitive) {
+        return attributeOrInput.value.ast.value;
+    }
+    return constants_1.PROPERTY_READ;
+}
+exports.getAttributeValue = getAttributeValue;

package/dist/utils/get-dom-elements.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDomElements = void 0;
+const aria_query_1 = require("aria-query");
+let domElements = null;
+function getDomElements() {
+    return domElements !== null && domElements !== void 0 ? domElements : (domElements = new Set(aria_query_1.dom.keys()));
+}
+exports.getDomElements = getDomElements;

package/dist/utils/get-nearest-node-from.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNearestNodeFrom = void 0;
+const types_1 = require("@typescript-eslint/types");
+function isProgram(node) {
+    return node.type === types_1.AST_NODE_TYPES.Program;
+}
+function getNearestNodeFrom({ parent }, predicate) {
+    while (parent && !isProgram(parent)) {
+        if (predicate(parent)) {
+            return parent;
+        }
+        parent = parent.parent;
+    }
+    return null;
+}
+exports.getNearestNodeFrom = getNearestNodeFrom;

package/dist/utils/get-original-attribute-name.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOriginalAttributeName = void 0;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+/**
+ * Returns the original attribute name.
+ * @example
+ * ```html
+ * <div [style.display.none]="test"></div> <!-- Instead of "display", "style.display.none" -->
+ * <div [attr.role]="'none'"></div> <!-- Instead of "attr.role", "role" -->
+ * <div ([ngModel])="test"></div> <!-- Instead of "ngModel", "ngModelChange" -->
+ * <div (@fade.start)="handle()"></div> <!-- Instead of "fade", "@fade.start" -->
+ * ```
+ */
+function getOriginalAttributeName(attribute) {
+    var _a;
+    const { details } = (_a = attribute.keySpan) !== null && _a !== void 0 ? _a : {};
+    if (!details) {
+        return attribute.name;
+    }
+    if (attribute instanceof bundled_angular_compiler_1.TmplAstBoundEvent) {
+        return isTwoWayDataBinding(attribute) ? attribute.name : details;
+    }
+    return details.replace('attr.', '');
+}
+exports.getOriginalAttributeName = getOriginalAttributeName;
+function isTwoWayDataBinding({ keySpan: { details }, name, }) {
+    return name === `${details}Change`;
+}

package/dist/utils/is-child-node-of.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isChildNodeOf = void 0;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+function isChildNodeOf(ast, childNodeName) {
+    function traverseChildNodes({ children }) {
+        return children.some((child) => child instanceof bundled_angular_compiler_1.TmplAstElement &&
+            (child.name === childNodeName || traverseChildNodes(child)));
+    }
+    return traverseChildNodes(ast);
+}
+exports.isChildNodeOf = isChildNodeOf;

package/dist/utils/is-content-editable.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isContentEditable = void 0;
+const get_original_attribute_name_1 = require("./get-original-attribute-name");
+const get_attribute_value_1 = require("./get-attribute-value");
+function isContentEditable(node) {
+    const attributesInputs = [...node.attributes, ...node.inputs];
+    const contentEditableAttr = attributesInputs.find((attr) => (0, get_original_attribute_name_1.getOriginalAttributeName)(attr) === 'contenteditable');
+    const contentEditableValue = (0, get_attribute_value_1.getAttributeValue)(node, 'contenteditable');
+    return (!!contentEditableAttr &&
+        (contentEditableValue === '' ||
+            String(contentEditableValue).toLowerCase() === 'true'));
+}
+exports.isContentEditable = isContentEditable;

package/dist/utils/is-disabled-element.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDisabledElement = void 0;
+const get_original_attribute_name_1 = require("./get-original-attribute-name");
+const get_attribute_value_1 = require("./get-attribute-value");
+function isDisabledElement(node) {
+    const attributesInputs = [...node.attributes, ...node.inputs];
+    const disabledAttr = attributesInputs.find((attr) => (0, get_original_attribute_name_1.getOriginalAttributeName)(attr) === 'disabled');
+    const disabledValue = (0, get_attribute_value_1.getAttributeValue)(node, 'disabled');
+    const isHTML5Disabled = disabledAttr && disabledValue !== undefined;
+    if (isHTML5Disabled) {
+        return true;
+    }
+    const isAriaDisabled = String((0, get_attribute_value_1.getAttributeValue)(node, 'aria-disabled')).toLowerCase() === 'true';
+    if (isAriaDisabled) {
+        return true;
+    }
+    return false;
+}
+exports.isDisabledElement = isDisabledElement;

package/dist/utils/is-hidden-from-screen-reader.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHiddenFromScreenReader = void 0;
+const bundled_angular_compiler_1 = require("@angular-eslint/bundled-angular-compiler");
+const get_attribute_value_1 = require("./get-attribute-value");
+const get_nearest_node_from_1 = require("./get-nearest-node-from");
+/**
+ * Whether an element content cannot be read by a screen reader. It can happen in the following situations:
+ * - It has `display: none` or `visibility: hidden` style;
+ * - It has `aria-hidden` or `hidden` attribute;
+ * - It's an `<input type="hidden">`;
+ * - One of its ancestors met one of the following situations above.
+ */
+function isHiddenFromScreenReader(node) {
+    if ((0, get_nearest_node_from_1.getNearestNodeFrom)(node, isElementHiddenFromScreenReader) ||
+        hasHiddenStaticStyles(node) ||
+        hasHiddenStaticNgStyles(node) ||
+        hasHiddenDynamicStylesWithLiteralValues(node) ||
+        /**
+         * We can't know if the element is hidden from screen reader if the value of `aria-hidden` or `hidden`
+         * is set dynamically via an Angular property binding, so we just check for raw HTML truthiness here.
+         */
+        isHtmlTruthy(node, 'aria-hidden') ||
+        isHtmlTruthy(node, 'hidden')) {
+        return true;
+    }
+    if (node.name.toUpperCase() !== 'INPUT') {
+        return false;
+    }
+    const typeAttributeValue = (0, get_attribute_value_1.getAttributeValue)(node, 'type');
+    return (typeof typeAttributeValue === 'string' &&
+        typeAttributeValue.toUpperCase() === 'HIDDEN');
+}
+exports.isHiddenFromScreenReader = isHiddenFromScreenReader;
+/**
+ * Whether an element has hidden static styles.
+ * @example
+ * ```html
+ * <div style="display: none;"></div>
+ * <div [style]="'visibility: hidden; color: red'"></div>
+ * <div ngStyle="{ 'display': 'none' }"></div>
+ * ```
+ */
+function hasHiddenStaticStyles(node) {
+    const styleAttributeValue = (0, get_attribute_value_1.getAttributeValue)(node, 'style');
+    if (typeof styleAttributeValue !== 'string') {
+        return false;
+    }
+    const rawStyleAttributeValue = styleAttributeValue.replace(/[\s'"]/g, '');
+    return (rawStyleAttributeValue.includes('display:none') ||
+        rawStyleAttributeValue.includes('visibility:hidden'));
+}
+/**
+ * Whether an element has hidden dynamic styles with literal values.
+ * @example
+ * ```html
+ * <div [style.display]="'none'"></div>
+ * <div [visibility.hidden]="true"></div>
+ * ```
+ */
+function hasHiddenDynamicStylesWithLiteralValues(node) {
+    return ((0, get_attribute_value_1.getAttributeValue)(node, 'style.display') === 'none' ||
+        String((0, get_attribute_value_1.getAttributeValue)(node, 'style.display.none')) === 'true' ||
+        (0, get_attribute_value_1.getAttributeValue)(node, 'style.visibility') === 'hidden' ||
+        String((0, get_attribute_value_1.getAttributeValue)(node, 'style.visibility.hidden')) === 'true');
+}
+/**
+ * Whether an element has `ngStyle` attribute containing `display: none` or `visibility: hidden`.
+ * @example
+ * ```html
+ * <div [ngStyle]="{ 'display': 'none' }"></div>
+ * <div [ngStyle]="{ 'visibility': 'hidden' }"></div>
+ * ```
+ */
+function hasHiddenStaticNgStyles(node) {
+    const ngStyleAttributeValue = (0, get_attribute_value_1.getAttributeValue)(node, 'ngStyle');
+    return (ngStyleAttributeValue instanceof Map &&
+        (ngStyleAttributeValue.get('display') === 'none' ||
+            ngStyleAttributeValue.get('visibility') === 'hidden'));
+}
+/**
+ * Whether an attribute is equals to empty string, `'true'` or `true`.
+ * @example
+ * ```html
+ * <div hidden></div>
+ * <div [hidden]="true"></div>
+ * <div aria-hidden=""></div>
+ * <div aria-hidden="true"></div>
+ * ```
+ */
+function isHtmlTruthy(node, attributeName) {
+    const attributeValue = (0, get_attribute_value_1.getAttributeValue)(node, attributeName);
+    return attributeValue === '' || String(attributeValue) === 'true';
+}
+function isElementHiddenFromScreenReader(node) {
+    return node instanceof bundled_angular_compiler_1.TmplAstElement && isHiddenFromScreenReader(node);
+}