@taiga-ui/eslint-plugin-experience-next 0.506.0 → 0.508.0

package/index.esm.js

@@ -1201,6 +1201,7 @@ var recommended = defineConfig([
                 },
             ],
             '@taiga-ui/experience-next/no-deep-imports-to-indexed-packages': 'error',
+            '@taiga-ui/experience-next/no-empty-style-metadata': 'error',
             '@taiga-ui/experience-next/no-fully-untracked-effect': 'error',
             '@taiga-ui/experience-next/no-implicit-public': 'error',
             '@taiga-ui/experience-next/no-import-assertions': 'error',
@@ -1213,6 +1214,7 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/no-useless-untracked': 'error',
             '@taiga-ui/experience-next/object-single-line': ['error', { printWidth: 90 }],
             '@taiga-ui/experience-next/prefer-combined-if-control-flow': 'error',
+            '@taiga-ui/experience-next/prefer-conditional-return': 'error',
             '@taiga-ui/experience-next/prefer-loose-null-check': 'error',
             '@taiga-ui/experience-next/prefer-multi-arg-push': 'error',
             '@taiga-ui/experience-next/prefer-namespace-keyword': 'error',
@@ -33201,10 +33203,7 @@ var VERSION = new Version("20.3.12");
 publishFacade(_global);
 
 function getAttributeValueSpan(attr) {
-    if (attr instanceof dist$4.TmplAstBoundEvent) {
-        return attr.handlerSpan;
-    }
-    return attr.valueSpan;
+    return attr instanceof dist$4.TmplAstBoundEvent ? attr.handlerSpan : attr.valueSpan;
 }
 function getElementAttributeLikes(element) {
     const seen = new Set();
@@ -46224,7 +46223,7 @@ function buildMultilineStartTag(node, sourceText) {
         closing,
     ].join('\n');
 }
-const rule$Q = createRule({
+const rule$S = createRule({
     name: 'attrs-newline',
     rule: {
         create(context) {
@@ -46310,54 +46309,151 @@ const rule$Q = createRule({
     },
 });
 
+function isObject(node) {
+    return node?.type === dist$2.AST_NODE_TYPES.ObjectExpression;
+}
+
+/**
+ * Extracts the metadata object from a class decorator such as
+ * `@Component()`, `@Directive()`, `@NgModule()`, or `@Pipe()`.
+ *
+ * Returns the first argument of the decorator call *if and only if*
+ * it is an `ObjectExpression`.
+ *
+ * @example
+ * // Given:
+ * @Component({
+ *   selector: 'x',
+ *   imports: [A, B],
+ * })
+ * class MyCmp {}
+ *
+ * // In the AST for @Component(...)
+ * getDecoratorMetadata(decorator, allowed) returns
+ *    ObjectExpression({ selector: ..., imports: ... })
+ *
+ * @param decorator - The decorator node attached to a class declaration.
+ * @param allowedNames - A set of decorator names to consider
+ *                       (e.g., Component, Directive, NgModule, Pipe).
+ *
+ * @returns The metadata `ObjectExpression` if present and valid,
+ *          otherwise `null`.
+ */
+function getDecoratorMetadata(decorator, allowedNames) {
+    return getDecoratorMetadataWithName(decorator, allowedNames)?.metadata ?? null;
+}
+function getDecoratorMetadataWithName(decorator, allowedNames) {
+    const expr = decorator.expression;
+    if (expr.type !== dist$2.AST_NODE_TYPES.CallExpression) {
+        return null;
+    }
+    const callee = expr.callee;
+    if (callee.type !== dist$2.AST_NODE_TYPES.Identifier || !allowedNames.has(callee.name)) {
+        return null;
+    }
+    const arg = expr.arguments[0];
+    return isObject(arg) ? { expression: expr, metadata: arg, name: callee.name } : null;
+}
+
+function isStringLiteral(node) {
+    return node?.type === dist$3.AST_NODE_TYPES.Literal && typeof node.value === 'string';
+}
+function isStaticTemplateLiteral(node) {
+    return (node?.type === dist$3.AST_NODE_TYPES.TemplateLiteral &&
+        node.expressions.length === 0 &&
+        node.quasis.length === 1);
+}
+function getStaticStringValue(node) {
+    if (isStringLiteral(node)) {
+        return node.value;
+    }
+    return isStaticTemplateLiteral(node)
+        ? (node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? '')
+        : null;
+}
+function isEmptyStaticString(node) {
+    return getStaticStringValue(node) === '';
+}
+
+function getStaticPropertyName(key) {
+    if (key.type === dist$3.AST_NODE_TYPES.Identifier) {
+        return key.name;
+    }
+    return key.type === dist$3.AST_NODE_TYPES.Literal &&
+        (typeof key.value === 'string' || typeof key.value === 'number')
+        ? String(key.value)
+        : getStaticStringValue(key);
+}
+function getObjectPropertyName(node) {
+    return node.computed ? null : getStaticPropertyName(node.key);
+}
+function getMemberExpressionPropertyName(node) {
+    if (!node.computed && node.property.type === dist$3.AST_NODE_TYPES.Identifier) {
+        return node.property.name;
+    }
+    return node.computed ? getStaticStringValue(node.property) : null;
+}
+function getClassMemberName(member) {
+    return member.key.type === dist$3.AST_NODE_TYPES.PrivateIdentifier
+        ? null
+        : getStaticPropertyName(member.key);
+}
+
 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] || {};
+const rule$R = createRule({
+    create(context, [order]) {
+        const decorators = new Set(Object.keys(order));
         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,
-                                });
-                            }
-                        }
+                for (const decorator of node?.decorators ?? []) {
+                    const metadata = getDecoratorMetadataWithName(decorator, decorators);
+                    if (!metadata) {
+                        continue;
+                    }
+                    const orderList = order[metadata.name] ?? [];
+                    const properties = getDecoratorProperties(metadata.metadata);
+                    if (!properties) {
+                        continue;
                     }
+                    const current = properties.map(({ name }) => name);
+                    const correct = getCorrectOrderRelative(orderList, current);
+                    const sortableCurrent = current.filter((item) => correct.includes(item));
+                    if (sameOrder(correct, sortableCurrent)) {
+                        continue;
+                    }
+                    context.report({
+                        data: {
+                            decorator: metadata.name,
+                            order: correct.join(' -> '),
+                        },
+                        fix: (fixer) => {
+                            const forgottenProps = properties.filter(({ name }) => !orderList.includes(name));
+                            const sortedDecoratorProperties = [
+                                ...correct.flatMap((key) => properties.filter(({ name }) => name === key)),
+                                ...forgottenProps,
+                            ];
+                            const newDecoratorArgument = `{${sortedDecoratorProperties
+                                .map(({ node }) => context.sourceCode.text.slice(...node.range))
+                                .join(',')}}`;
+                            return fixer.replaceTextRange(metadata.metadata.range, newDecoratorArgument);
+                        },
+                        messageId: 'incorrectOrder',
+                        node: metadata.expression,
+                    });
                 }
             },
         };
     },
     meta: {
+        defaultOptions: [{}],
+        docs: { description: 'Sorts keys of Angular decorator metadata.' },
         fixable: 'code',
+        messages: {
+            incorrectOrder: 'Incorrect order keys in @{{decorator}} decorator, please sort by [{{order}}]',
+        },
         schema: [
             {
                 additionalProperties: true,
@@ -46367,14 +46463,25 @@ const config$5 = {
         ],
         type: 'problem',
     },
-};
+    name: 'decorator-key-sort',
+});
 function getCorrectOrderRelative(correct, current) {
     return correct.filter((item) => current.includes(item));
 }
-const rule$P = createRule({
-    name: 'decorator-key-sort',
-    rule: config$5,
-});
+function getDecoratorProperties(metadata) {
+    const properties = [];
+    for (const property of metadata.properties) {
+        if (property.type !== dist$3.AST_NODE_TYPES.Property) {
+            return null;
+        }
+        const name = getObjectPropertyName(property);
+        if (!name) {
+            return null;
+        }
+        properties.push({ name, node: property });
+    }
+    return properties;
+}
 
 const INLINE_HTML_ELEMENTS = new Set([
     'a',
@@ -46430,12 +46537,9 @@ function getNodeLabel(node) {
     if (node instanceof dist$4.TmplAstElement) {
         return `<${node.name}>`;
     }
-    if (node instanceof dist$4.TmplAstBoundText) {
-        return 'binding';
-    }
-    return 'text';
+    return node instanceof dist$4.TmplAstBoundText ? 'binding' : 'text';
 }
-const rule$O = createRule({
+const rule$Q = createRule({
     name: 'element-newline',
     rule: {
         create(context) {
@@ -46509,98 +46613,6 @@ const rule$O = createRule({
     },
 });
 
-function isObject(node) {
-    return node?.type === dist$2.AST_NODE_TYPES.ObjectExpression;
-}
-
-/**
- * Extracts the metadata object from a class decorator such as
- * `@Component()`, `@Directive()`, `@NgModule()`, or `@Pipe()`.
- *
- * Returns the first argument of the decorator call *if and only if*
- * it is an `ObjectExpression`.
- *
- * @example
- * // Given:
- * @Component({
- *   selector: 'x',
- *   imports: [A, B],
- * })
- * class MyCmp {}
- *
- * // In the AST for @Component(...)
- * getDecoratorMetadata(decorator, allowed) →
- *    ObjectExpression({ selector: ..., imports: ... })
- *
- * @param decorator - The decorator node attached to a class declaration.
- * @param allowedNames - A set of decorator names to consider
- *                       (e.g., Component, Directive, NgModule, Pipe).
- *
- * @returns The metadata `ObjectExpression` if present and valid,
- *          otherwise `null`.
- */
-function getDecoratorMetadata(decorator, allowedNames) {
-    const expr = decorator.expression;
-    if (expr.type !== dist$2.AST_NODE_TYPES.CallExpression) {
-        return null;
-    }
-    const callee = expr.callee;
-    if (callee.type !== dist$2.AST_NODE_TYPES.Identifier || !allowedNames.has(callee.name)) {
-        return null;
-    }
-    const arg = expr.arguments[0];
-    return isObject(arg) ? arg : null;
-}
-
-function isStringLiteral(node) {
-    return node?.type === dist$3.AST_NODE_TYPES.Literal && typeof node.value === 'string';
-}
-function isStaticTemplateLiteral(node) {
-    return (node?.type === dist$3.AST_NODE_TYPES.TemplateLiteral &&
-        node.expressions.length === 0 &&
-        node.quasis.length === 1);
-}
-function getStaticStringValue(node) {
-    if (isStringLiteral(node)) {
-        return node.value;
-    }
-    if (!isStaticTemplateLiteral(node)) {
-        return null;
-    }
-    return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? '';
-}
-function isEmptyStaticString(node) {
-    return getStaticStringValue(node) === '';
-}
-
-function getStaticPropertyName(key) {
-    if (key.type === dist$3.AST_NODE_TYPES.Identifier) {
-        return key.name;
-    }
-    if (key.type === dist$3.AST_NODE_TYPES.Literal &&
-        (typeof key.value === 'string' || typeof key.value === 'number')) {
-        return String(key.value);
-    }
-    return getStaticStringValue(key);
-}
-function getObjectPropertyName(node) {
-    if (node.computed) {
-        return null;
-    }
-    return getStaticPropertyName(node.key);
-}
-function getMemberExpressionPropertyName(node) {
-    if (!node.computed && node.property.type === dist$3.AST_NODE_TYPES.Identifier) {
-        return node.property.name;
-    }
-    return node.computed ? getStaticStringValue(node.property) : null;
-}
-function getClassMemberName(member) {
-    return member.key.type === dist$3.AST_NODE_TYPES.PrivateIdentifier
-        ? null
-        : getStaticPropertyName(member.key);
-}
-
 const DEFAULT_GROUP = '$DEFAULT';
 const DEFAULT_ATTRIBUTE_GROUPS = [
     '$ANGULAR_STRUCTURAL_DIRECTIVE',
@@ -46666,7 +46678,7 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const rule$N = createRule({
+const rule$P = createRule({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -46821,10 +46833,9 @@ function getGroup(query, ignoreCase) {
             },
         ];
     }
-    if (Array.isArray(preset)) {
-        return preset.flatMap((item) => getGroup(item, ignoreCase));
-    }
-    return [{ query, regexp: preset, values: [] }];
+    return Array.isArray(preset)
+        ? preset.flatMap((item) => getGroup(item, ignoreCase))
+        : [{ query, regexp: preset, values: [] }];
 }
 function ensureDefaultGroup(groups) {
     const existing = groups.find(({ unknown }) => unknown);
@@ -46850,10 +46861,9 @@ function getFixText(hostObject, properties, sortedProperties, sourceCode) {
             .join(', ')}}`;
     }
     const attachedComments = getAttachedComments(hostObject, properties, sourceCode, comments);
-    if (!attachedComments) {
-        return null;
-    }
-    return renderFixWithComments(hostObject, sortedProperties, sourceCode, attachedComments);
+    return attachedComments
+        ? renderFixWithComments(hostObject, sortedProperties, sourceCode, attachedComments)
+        : null;
 }
 function getAttachedComments(hostObject, properties, sourceCode, comments) {
     const attached = new Map();
@@ -46999,7 +47009,7 @@ const config$4 = {
         type: 'suggestion',
     },
 };
-const rule$M = createRule({
+const rule$O = createRule({
     name: 'html-logical-properties',
     rule: config$4,
 });
@@ -247715,12 +247725,11 @@ function getProgramResolutionCache(program) {
         return null;
     }
     const cache = getCache.call(program);
-    if (cache === null ||
+    return cache === null ||
         typeof cache !== 'object' ||
-        !('getOrCreateCacheForDirectory' in cache)) {
-        return null;
-    }
-    return cache;
+        !('getOrCreateCacheForDirectory' in cache)
+        ? null
+        : cache;
 }
 function getFallbackResolution(program) {
     const cached = fallbackResolutionByProgram.get(program);
@@ -247751,10 +247760,9 @@ function resolveModule(program, containingFile, moduleSpecifier) {
 }
 function resolveModuleFileName(program, containingFile, moduleSpecifier) {
     const resolved = resolveModule(program, containingFile, moduleSpecifier);
-    if (!resolved || resolved.isExternalLibraryImport) {
-        return null;
-    }
-    return resolved.resolvedFileName;
+    return !resolved || resolved.isExternalLibraryImport
+        ? null
+        : resolved.resolvedFileName;
 }
 function splitModuleSpecifierQuery(moduleSpecifier) {
     const queryIndex = moduleSpecifier.indexOf('?');
@@ -247849,22 +247857,20 @@ function importDeclarationHasRuntimeEdge(node) {
     if (!namedBindings) {
         return false;
     }
-    if (ts.isNamespaceImport(namedBindings)) {
-        return true;
-    }
-    return (namedBindings.elements.length === 0 ||
-        namedBindings.elements.some((specifier) => !specifier.isTypeOnly));
+    return ts.isNamespaceImport(namedBindings)
+        ? true
+        : namedBindings.elements.length === 0 ||
+            namedBindings.elements.some((specifier) => !specifier.isTypeOnly);
 }
 function exportDeclarationHasRuntimeEdge(node) {
     if (node.isTypeOnly) {
         return false;
     }
     const exportClause = node.exportClause;
-    if (!exportClause || ts.isNamespaceExport(exportClause)) {
-        return true;
-    }
-    return (exportClause.elements.length === 0 ||
-        exportClause.elements.some((specifier) => !specifier.isTypeOnly));
+    return !exportClause || ts.isNamespaceExport(exportClause)
+        ? true
+        : exportClause.elements.length === 0 ||
+            exportClause.elements.some((specifier) => !specifier.isTypeOnly);
 }
 function getRuntimeModuleSpecifier(statement) {
     if (ts.isImportDeclaration(statement)) {
@@ -247927,10 +247933,9 @@ function hasRuntimeDefaultModifier(statement) {
         !ts.isTypeAliasDeclaration(statement));
 }
 function exportsDefaultSpecifier(node) {
-    if (node.isTypeOnly || !node.exportClause || !ts.isNamedExports(node.exportClause)) {
-        return false;
-    }
-    return node.exportClause.elements.some((specifier) => !specifier.isTypeOnly && specifier.name.text === 'default');
+    return node.isTypeOnly || !node.exportClause || !ts.isNamedExports(node.exportClause)
+        ? false
+        : node.exportClause.elements.some((specifier) => !specifier.isTypeOnly && specifier.name.text === 'default');
 }
 function sourceFileHasDefaultExport(sourceFile) {
     return sourceFile.statements.some((statement) => (ts.isExportAssignment(statement) && !statement.isExportEquals) ||
@@ -247958,25 +247963,20 @@ function hasRuntimeEstreeImport(node) {
     if (node.importKind === 'type') {
         return false;
     }
-    if (node.specifiers.length === 0) {
-        return true;
-    }
-    return node.specifiers.some((specifier) => {
-        if (specifier.type !== dist$3.AST_NODE_TYPES.ImportSpecifier) {
-            return true;
-        }
-        return specifier.importKind !== 'type';
-    });
+    return node.specifiers.length === 0
+        ? true
+        : node.specifiers.some((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportSpecifier
+            ? specifier.importKind !== 'type'
+            : true);
 }
 function hasRuntimeEstreeReExport(node) {
     if (node.exportKind === 'type') {
         return false;
     }
-    if (node.type === dist$3.AST_NODE_TYPES.ExportAllDeclaration) {
-        return true;
-    }
-    return (node.specifiers.length === 0 ||
-        node.specifiers.some((specifier) => specifier.exportKind !== 'type'));
+    return node.type === dist$3.AST_NODE_TYPES.ExportAllDeclaration
+        ? true
+        : node.specifiers.length === 0 ||
+            node.specifiers.some((specifier) => specifier.exportKind !== 'type');
 }
 function getImportOrReExportModuleSpecifier(node) {
     if (node.type === dist$3.AST_NODE_TYPES.ImportDeclaration) {
@@ -248199,13 +248199,10 @@ function isInAngularSafeContext(identifier) {
     return false;
 }
 function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
-    const valueSpecifiers = node.specifiers.filter((specifier) => {
-        if (specifier.type === dist$3.AST_NODE_TYPES.ImportDefaultSpecifier ||
-            specifier.type === dist$3.AST_NODE_TYPES.ImportNamespaceSpecifier) {
-            return true;
-        }
-        return specifier.importKind !== 'type';
-    });
+    const valueSpecifiers = node.specifiers.filter((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportDefaultSpecifier ||
+        specifier.type === dist$3.AST_NODE_TYPES.ImportNamespaceSpecifier
+        ? true
+        : specifier.importKind !== 'type');
     if (valueSpecifiers.length === 0) {
         return false;
     }
@@ -248251,7 +248248,7 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
     }
     return hasSafeRuntimeUsage;
 }
-const rule$L = createRule({
+const rule$N = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode, tsProgram } = getTypeAwareRuleContext(context);
         const checkCycles = context.options[0]?.checkCycles ?? true;
@@ -248426,11 +248423,10 @@ const rule$L = createRule({
             const importSegments = moduleSpecifierPath.replace(/^\.\//, '').split('/');
             const importParentCount = countRelativeParents(importSegments);
             const expectedParentCount = countRelativeParents(expectedPath.split('/'));
-            if (importParentCount <= expectedParentCount ||
-                expectedPath === moduleSpecifierPath) {
-                return null;
-            }
-            return expectedPath;
+            return importParentCount <= expectedParentCount ||
+                expectedPath === moduleSpecifierPath
+                ? null
+                : expectedPath;
         }
         function getUselessPathSegmentsReplacement(moduleSpecifierPath) {
             const resolved = resolveModule(tsProgram, context.filename, moduleSpecifierPath);
@@ -248921,10 +248917,7 @@ function isStringLike(node) {
     return isStringLiteral(node) || node.type === dist$2.AST_NODE_TYPES.TemplateLiteral;
 }
 function getStringValue(node) {
-    if (isStringLiteral(node)) {
-        return node.value;
-    }
-    return node.quasis[0]?.value.raw || '';
+    return isStringLiteral(node) ? node.value : node.quasis[0]?.value.raw || '';
 }
 function isEmptyString(node) {
     return (isEmptyStaticString(node) &&
@@ -248942,10 +248935,7 @@ function getDescriptionValue(node) {
     if (isStringLike(node)) {
         return getStringValue(node);
     }
-    if (isNgDevModeConditional(node)) {
-        return getStringValue(node.consequent);
-    }
-    return undefined;
+    return isNgDevModeConditional(node) ? getStringValue(node.consequent) : undefined;
 }
 function getDescriptionNode(node) {
     if (isStringLike(node)) {
@@ -248972,12 +248962,11 @@ function getNgDevModeDeclarationFix(program, fixer) {
         return fixer.insertTextAfter(lastImport, '\n\ndeclare const ngDevMode: boolean;');
     }
     const [firstStatement] = program.body;
-    if (firstStatement) {
-        return fixer.insertTextBefore(firstStatement, 'declare const ngDevMode: boolean;\n\n');
-    }
-    return fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
+    return firstStatement
+        ? fixer.insertTextBefore(firstStatement, 'declare const ngDevMode: boolean;\n\n')
+        : fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
 }
-const rule$K = createRule({
+const rule$M = createRule({
     create(context) {
         const { sourceCode } = context;
         const program = sourceCode.ast;
@@ -249026,7 +249015,7 @@ const rule$K = createRule({
     name: 'injection-token-description',
 });
 
-const rule$J = createRule({
+const rule$L = createRule({
     create(context) {
         const { sourceCode } = context;
         const namespaceImports = new Map();
@@ -249121,7 +249110,7 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const rule$I = createRule({
+const rule$K = createRule({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -249213,7 +249202,7 @@ const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-const rule$H = createRule({
+const rule$J = createRule({
     create(context) {
         const parserServices = dist$3.ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -249374,10 +249363,9 @@ const rule$H = createRule({
     name: 'no-deep-imports-to-indexed-packages',
 });
 function isExternalModuleSpecifier(moduleSpecifier) {
-    if (!moduleSpecifier || moduleSpecifier.startsWith('.')) {
-        return false;
-    }
-    return !path.isAbsolute(moduleSpecifier);
+    return !moduleSpecifier || moduleSpecifier.startsWith('.')
+        ? false
+        : !path.isAbsolute(moduleSpecifier);
 }
 function isScopedPackage(importSpecifier) {
     return importSpecifier.startsWith('@');
@@ -249385,19 +249373,17 @@ function isScopedPackage(importSpecifier) {
 function getPackageRootSpecifier(importSpecifier) {
     const pathParts = importSpecifier.split('/');
     if (isScopedPackage(importSpecifier)) {
-        if (pathParts.length >= 2) {
-            return `${pathParts[0]}/${pathParts[1]}`;
-        }
-        return importSpecifier;
+        return pathParts.length >= 2
+            ? `${pathParts[0]}/${pathParts[1]}`
+            : importSpecifier;
     }
     return pathParts[0] ?? importSpecifier;
 }
 function getSubpath(importSpecifier, packageRootSpecifier) {
-    if (importSpecifier === packageRootSpecifier ||
-        !importSpecifier.startsWith(`${packageRootSpecifier}/`)) {
-        return null;
-    }
-    return importSpecifier.slice(packageRootSpecifier.length + 1);
+    return importSpecifier === packageRootSpecifier ||
+        !importSpecifier.startsWith(`${packageRootSpecifier}/`)
+        ? null
+        : importSpecifier.slice(packageRootSpecifier.length + 1);
 }
 function normalizeModuleSpecifier(moduleSpecifier) {
     return moduleSpecifier.replaceAll('\\', '/');
@@ -249410,13 +249396,13 @@ const noDuplicateAttributesRule = angular.templatePlugin.rules?.['no-duplicate-a
 if (!noDuplicateAttributesRule) {
     throw new Error('angular-eslint template rule "no-duplicate-attributes" is not available');
 }
-const rule$G = createRule({
+const rule$I = createRule({
     name: 'no-duplicate-attrs',
     rule: noDuplicateAttributesRule,
 });
 
 const MESSAGE_ID$c = 'duplicateId';
-const rule$F = createRule({
+const rule$H = createRule({
     name: 'no-duplicate-id',
     rule: {
         create(context) {
@@ -249471,14 +249457,13 @@ function getTrackingKey(node) {
             return 'meta[name=viewport]';
         }
     }
-    if (node.name === 'link' &&
+    return node.name === 'link' &&
         findAttr(node, 'rel')?.value === 'canonical' &&
-        findAttr(node, 'href')) {
-        return 'link[rel=canonical]';
-    }
-    return null;
+        findAttr(node, 'href')
+        ? 'link[rel=canonical]'
+        : null;
 }
-const rule$E = createRule({
+const rule$G = createRule({
     name: 'no-duplicate-in-head',
     rule: {
         create(context) {
@@ -249533,6 +249518,133 @@ const rule$E = createRule({
     },
 });
 
+const COMPONENT_DECORATORS = new Set(['Component']);
+const rule$F = createRule({
+    create(context) {
+        const { sourceCode } = context;
+        return {
+            ClassDeclaration(node) {
+                for (const decorator of node?.decorators ?? []) {
+                    const metadata = getDecoratorMetadata(decorator, COMPONENT_DECORATORS);
+                    if (!metadata) {
+                        continue;
+                    }
+                    const emptyProperties = metadata.properties.filter((property) => property.type === dist$3.AST_NODE_TYPES.Property &&
+                        isEmptyStyleMetadata(getObjectPropertyName(property), property, sourceCode));
+                    if (emptyProperties.length === 0) {
+                        continue;
+                    }
+                    const [firstEmptyProperty] = emptyProperties;
+                    if (!firstEmptyProperty) {
+                        continue;
+                    }
+                    context.report({
+                        fix: (fixer) => {
+                            const ranges = emptyProperties.map((property) => getPropertyRemovalRange(sourceCode, property));
+                            return ranges.some((range) => hasCommentsInRange(sourceCode, range))
+                                ? null
+                                : fixer.replaceTextRange(metadata.range, removeRanges(sourceCode.text.slice(...metadata.range), ranges.map(([start, end]) => [
+                                    start - metadata.range[0],
+                                    end - metadata.range[0],
+                                ])));
+                        },
+                        messageId: 'noEmptyStyleMetadata',
+                        node: firstEmptyProperty,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow empty `styles`, `styleUrl`, and `styleUrls` metadata in Angular components.',
+        },
+        fixable: 'code',
+        messages: {
+            noEmptyStyleMetadata: 'Empty style metadata should be removed from @Component decorator.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'no-empty-style-metadata',
+});
+function isEmptyStyleMetadata(name, property, sourceCode) {
+    return (((name === 'styles' || name === 'styleUrl') &&
+        isEmptyStringExpression(property.value)) ||
+        (name === 'styleUrls' &&
+            property.value.type === dist$3.AST_NODE_TYPES.ArrayExpression &&
+            property.value.elements.length === 0 &&
+            sourceCode.getText(property.value).replaceAll(/\s/g, '') === '[]'));
+}
+function isEmptyStringExpression(node) {
+    if (node.type === dist$3.AST_NODE_TYPES.Literal) {
+        return node.value === '';
+    }
+    if (node.type !== dist$3.AST_NODE_TYPES.TemplateLiteral || node.expressions.length > 0) {
+        return false;
+    }
+    const [quasi] = node.quasis;
+    return quasi?.value.raw === '';
+}
+function getPropertyRemovalRange(sourceCode, property) {
+    const nextToken = sourceCode.getTokenAfter(property);
+    if (nextToken?.value === ',') {
+        return getRangeWithFollowingComma(sourceCode.text, property, nextToken.range);
+    }
+    const previousToken = sourceCode.getTokenBefore(property);
+    return previousToken?.value === ','
+        ? [previousToken.range[0], property.range[1]]
+        : getSinglePropertyRange(sourceCode.text, property);
+}
+function getRangeWithFollowingComma(text, property, commaRange) {
+    const lineStart = getLineStart(text, property.range[0]);
+    const nextLineStart = getNextLineStart(text, commaRange[1]);
+    return text.slice(lineStart, property.range[0]).trim() === '' &&
+        text.slice(commaRange[1], nextLineStart).trim() === '' &&
+        nextLineStart > commaRange[1]
+        ? [lineStart, nextLineStart]
+        : [property.range[0], commaRange[1]];
+}
+function getSinglePropertyRange(text, property) {
+    const lineStart = getLineStart(text, property.range[0]);
+    const nextLineStart = getNextLineStart(text, property.range[1]);
+    return text.slice(lineStart, property.range[0]).trim() === '' &&
+        text.slice(property.range[1], nextLineStart).trim() === '' &&
+        nextLineStart > property.range[1]
+        ? [lineStart, nextLineStart]
+        : [property.range[0], property.range[1]];
+}
+function getLineStart(text, index) {
+    return text.lastIndexOf('\n', index - 1) + 1;
+}
+function getNextLineStart(text, index) {
+    const lineEnd = text.indexOf('\n', index);
+    return lineEnd === -1 ? index : lineEnd + 1;
+}
+function hasCommentsInRange(sourceCode, [start, end]) {
+    return sourceCode
+        .getAllComments()
+        .some((comment) => comment.range[0] >= start && comment.range[1] <= end);
+}
+function removeRanges(text, ranges) {
+    return mergeRanges(ranges)
+        .sort((left, right) => right[0] - left[0])
+        .reduce((result, [start, end]) => `${result.slice(0, start)}${result.slice(end)}`, text);
+}
+function mergeRanges(ranges) {
+    const sorted = [...ranges].sort((left, right) => left[0] - right[0]);
+    const merged = [];
+    for (const range of sorted) {
+        const last = merged[merged.length - 1];
+        if (!last || range[0] > last[1]) {
+            merged.push([...range]);
+            continue;
+        }
+        last[1] = Math.max(last[1], range[1]);
+    }
+    return merged;
+}
+
 function isFunctionLike(node) {
     return (node.type === dist$3.AST_NODE_TYPES.ArrowFunctionExpression ||
         node.type === dist$3.AST_NODE_TYPES.FunctionDeclaration ||
@@ -249777,12 +249889,11 @@ function getPropertyName(property) {
 }
 function isAngularCoreCall(node, program, exportedName) {
     const localName = getLocalNameForImport(program, ANGULAR_CORE, exportedName);
-    if (!localName) {
-        return false;
-    }
-    return (node.callee.type === dist$3.AST_NODE_TYPES.Identifier &&
-        node.callee.name === localName &&
-        node.arguments.length >= 1);
+    return localName
+        ? node.callee.type === dist$3.AST_NODE_TYPES.Identifier &&
+            node.callee.name === localName &&
+            node.arguments.length >= 1
+        : false;
 }
 function appendFirstArgReactiveScope(scopes, call, kind) {
     const callback = getReactiveCallbackArgument(call);
@@ -249921,13 +250032,12 @@ function isSignalType(node, checker, esTreeNodeToTSNodeMap) {
         }
         const typeSymbol = type.getSymbol();
         const aliasSymbol = type.aliasSymbol;
-        if (typeSymbol?.getName().includes('Signal') ||
-            aliasSymbol?.getName().includes('Signal')) {
-            return true;
-        }
-        return type
-            .getProperties()
-            .some((p) => p.name.startsWith('ɵ') || p.name === '__SIGNAL');
+        return typeSymbol?.getName().includes('Signal') ||
+            aliasSymbol?.getName().includes('Signal')
+            ? true
+            : type
+                .getProperties()
+                .some((p) => p.name.startsWith('ɵ') || p.name === '__SIGNAL');
     }
     catch {
         return false;
@@ -249935,22 +250045,20 @@ function isSignalType(node, checker, esTreeNodeToTSNodeMap) {
 }
 function isSignalReadCall(node, checker, esTreeNodeToTSNodeMap) {
     const { callee } = node;
-    if (callee.type !== dist$3.AST_NODE_TYPES.Identifier &&
-        callee.type !== dist$3.AST_NODE_TYPES.MemberExpression) {
-        return false;
-    }
-    return isSignalType(callee, checker, esTreeNodeToTSNodeMap);
+    return callee.type !== dist$3.AST_NODE_TYPES.Identifier &&
+        callee.type !== dist$3.AST_NODE_TYPES.MemberExpression
+        ? false
+        : isSignalType(callee, checker, esTreeNodeToTSNodeMap);
 }
 function isWritableSignalWrite(node, checker, esTreeNodeToTSNodeMap) {
     if (node.callee.type !== dist$3.AST_NODE_TYPES.MemberExpression) {
         return false;
     }
     const { object, property } = node.callee;
-    if (property.type !== dist$3.AST_NODE_TYPES.Identifier ||
-        !SIGNAL_WRITE_METHODS.has(property.name)) {
-        return false;
-    }
-    return isSignalType(object, checker, esTreeNodeToTSNodeMap);
+    return property.type !== dist$3.AST_NODE_TYPES.Identifier ||
+        !SIGNAL_WRITE_METHODS.has(property.name)
+        ? false
+        : isSignalType(object, checker, esTreeNodeToTSNodeMap);
 }
 /**
  * Returns true when `node` is a member expression `foo.bar` where `bar` is a
@@ -249964,10 +250072,7 @@ function isGetterMemberAccess(node, checker, esTreeNodeToTSNodeMap) {
             return false;
         }
         const symbol = checker.getSymbolAtLocation(tsNode);
-        if (!symbol) {
-            return false;
-        }
-        return !!(symbol.flags & ts.SymbolFlags.GetAccessor);
+        return symbol ? !!(symbol.flags & ts.SymbolFlags.GetAccessor) : false;
     }
     catch {
         return false;
@@ -250051,19 +250156,18 @@ function getReturnedReactiveOwnerCall(node, program) {
         isReactiveOwnerCall(statement.argument, program)) {
         return statement.argument;
     }
-    if (node.parent.type === dist$3.AST_NODE_TYPES.ExpressionStatement &&
+    return node.parent.type === dist$3.AST_NODE_TYPES.ExpressionStatement &&
         statement?.type === dist$3.AST_NODE_TYPES.ExpressionStatement &&
-        isReactiveOwnerCall(statement.expression, program)) {
-        return statement.expression;
-    }
-    return null;
+        isReactiveOwnerCall(statement.expression, program)
+        ? statement.expression
+        : null;
 }
 
 const ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL = 'https://angular.dev/guide/signals#reading-without-tracking-dependencies';
 const ANGULAR_SIGNALS_ASYNC_GUIDE_URL = 'https://angular.dev/guide/signals#reactive-context-and-async-operations';
 const createUntrackedRule = createRule;
 
-const rule$D = createUntrackedRule({
+const rule$E = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -250136,7 +250240,7 @@ const config$3 = {
         type: 'problem',
     },
 };
-const rule$C = createRule({
+const rule$D = createRule({
     name: 'no-href-with-router-link',
     rule: config$3,
 });
@@ -250197,7 +250301,7 @@ function getScopeRoot(node) {
     return (findAncestor(node, (ancestor) => ancestor.type === dist$3.AST_NODE_TYPES.Program || isFunctionLike(ancestor)) ?? node);
 }
 
-const rule$B = createRule({
+const rule$C = createRule({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getEnclosingClass(node);
@@ -250259,7 +250363,7 @@ const rule$B = createRule({
     name: 'no-implicit-public',
 });
 
-const rule$A = createRule({
+const rule$B = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -250292,10 +250396,9 @@ const rule$A = createRule({
 
 function getParenthesizedInner(node) {
     const maybeNode = node;
-    if (maybeNode.type === 'ParenthesizedExpression') {
-        return maybeNode.expression ?? null;
-    }
-    return null;
+    return maybeNode.type === 'ParenthesizedExpression'
+        ? (maybeNode.expression ?? null)
+        : null;
 }
 function unwrapParenthesized(node) {
     let current = node;
@@ -250309,15 +250412,14 @@ function unwrapParenthesized(node) {
 
 function isInfiniteLoopLiteral(node) {
     const unwrapped = unwrapParenthesized(node);
-    if (unwrapped.type !== dist$3.AST_NODE_TYPES.Literal) {
-        return false;
-    }
-    return unwrapped.value === true || unwrapped.value === 1;
+    return unwrapped.type === dist$3.AST_NODE_TYPES.Literal
+        ? unwrapped.value === true || unwrapped.value === 1
+        : false;
 }
 function isInfiniteLoopTest(test) {
     return test == null || isInfiniteLoopLiteral(test);
 }
-const rule$z = createRule({
+const rule$A = createRule({
     create(context) {
         return {
             DoWhileStatement(node) {
@@ -250362,7 +250464,7 @@ const rule$z = createRule({
 });
 
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$y = createRule({
+const rule$z = createRule({
     create(context) {
         return {
             Program(node) {
@@ -250822,7 +250924,7 @@ const OBSOLETE_HTML_ATTRS = {
 };
 
 const MESSAGE_ID$9 = 'obsolete';
-const rule$x = createRule({
+const rule$y = createRule({
     name: 'no-obsolete-attrs',
     rule: {
         create(context) {
@@ -250900,7 +251002,7 @@ const OBSOLETE_HTML_TAGS = new Set([
 ]);
 
 const MESSAGE_ID$8 = 'unexpected';
-const rule$w = createRule({
+const rule$x = createRule({
     name: 'no-obsolete-tags',
     rule: {
         create(context) {
@@ -250927,7 +251029,7 @@ const rule$w = createRule({
     },
 });
 
-const rule$v = createRule({
+const rule$w = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
         return {
@@ -251071,7 +251173,7 @@ const config$2 = {
         type: 'problem',
     },
 };
-const rule$u = createRule({
+const rule$v = createRule({
     name: 'no-project-as-in-ng-template',
     rule: config$2,
 });
@@ -251108,7 +251210,7 @@ function collectArrayExpressions(node) {
     }
     return result;
 }
-const rule$t = createRule({
+const rule$u = createRule({
     create(context) {
         const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const ignoreTupleContextualTyping = context.options[0]?.ignoreTupleContextualTyping ?? true;
@@ -251210,10 +251312,9 @@ function isNullableCallType(call, checker, nodeMap) {
             return false;
         }
         const type = checker.getTypeAtLocation(tsNode);
-        if (!(type.flags & ts.TypeFlags.Union)) {
-            return false;
-        }
-        return type.types.some((t) => !!(t.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)));
+        return type.flags & ts.TypeFlags.Union
+            ? type.types.some((t) => !!(t.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)))
+            : false;
     }
     catch {
         return false;
@@ -251224,13 +251325,12 @@ function getTargetNode(call) {
     if (parent.type === dist$3.AST_NODE_TYPES.TSAsExpression) {
         return parent;
     }
-    if (parent.type === dist$3.AST_NODE_TYPES.UnaryExpression &&
+    return parent.type === dist$3.AST_NODE_TYPES.UnaryExpression &&
         parent.operator === '!' &&
         parent.parent.type === dist$3.AST_NODE_TYPES.UnaryExpression &&
-        parent.parent.operator === '!') {
-        return parent.parent;
-    }
-    return call;
+        parent.parent.operator === '!'
+        ? parent.parent
+        : call;
 }
 function getCalleeName(node) {
     const { callee } = node;
@@ -251240,10 +251340,7 @@ function getCalleeName(node) {
         return callee.property.name;
     }
     // Append 'Val' to avoid shadowing the signal variable itself (e.g. const xVal = x())
-    if (callee.type === dist$3.AST_NODE_TYPES.Identifier) {
-        return `${callee.name}Val`;
-    }
-    return 'value';
+    return callee.type === dist$3.AST_NODE_TYPES.Identifier ? `${callee.name}Val` : 'value';
 }
 function findParentStatement(node) {
     for (let current = node; current.parent; current = current.parent) {
@@ -251277,13 +251374,13 @@ function getArrowBodyIndent(arrowFn, sourceText) {
     const outerIndent = /^(\s*)/.exec(textBeforeArrow)?.[1] ?? '';
     return { innerIndent: `${outerIndent}    `, outerIndent };
 }
-function getStatementIndent(statement, sourceText) {
+function getStatementIndent$1(statement, sourceText) {
     const start = statement.range[0];
     const lineStart = sourceText.lastIndexOf('\n', start - 1) + 1;
     const before = sourceText.slice(lineStart, start);
     return /^\s*$/.test(before) ? before : '';
 }
-const rule$s = createRule({
+const rule$t = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251322,7 +251419,7 @@ const rule$s = createRule({
                         const varName = getCalleeName(firstCall);
                         const parentStatement = findParentStatement(node);
                         if (parentStatement) {
-                            const indent = getStatementIndent(parentStatement, sourceCode.text);
+                            const indent = getStatementIndent$1(parentStatement, sourceCode.text);
                             const fixes = [
                                 fixer.insertTextBefore(parentStatement, `const ${varName} = ${callText};\n\n${indent}`),
                             ];
@@ -251437,12 +251534,9 @@ function collectMutationTargets(node) {
         case dist$3.AST_NODE_TYPES.MemberExpression:
             return [current];
         case dist$3.AST_NODE_TYPES.ObjectPattern:
-            return current.properties.flatMap((property) => {
-                if (property.type === dist$3.AST_NODE_TYPES.RestElement) {
-                    return collectMutationTargets(property.argument);
-                }
-                return collectMutationTargets(property.value);
-            });
+            return current.properties.flatMap((property) => property.type === dist$3.AST_NODE_TYPES.RestElement
+                ? collectMutationTargets(property.argument)
+                : collectMutationTargets(property.value));
         case dist$3.AST_NODE_TYPES.RestElement:
             return collectMutationTargets(current.argument);
         default:
@@ -251452,10 +251546,7 @@ function collectMutationTargets(node) {
 
 function getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap) {
     const tsNode = esTreeNodeToTSNodeMap.get(node);
-    if (!tsNode) {
-        return null;
-    }
-    return checker.getSymbolAtLocation(tsNode) ?? null;
+    return tsNode ? (checker.getSymbolAtLocation(tsNode) ?? null) : null;
 }
 
 function isFunctionLikeScope(node) {
@@ -251463,14 +251554,13 @@ function isFunctionLikeScope(node) {
 }
 function isLocalIdentifier(node, context, localScopes) {
     const symbol = getSymbolAtNode(node, context.checker, context.esTreeNodeToTSNodeMap);
-    if (!symbol) {
-        return false;
-    }
-    return (symbol.declarations ?? []).some((declaration) => {
-        const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
-        return (!!estreeDeclaration &&
-            isDeclaredInsideLocalScope(estreeDeclaration, localScopes));
-    });
+    return symbol
+        ? (symbol.declarations ?? []).some((declaration) => {
+            const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
+            return (!!estreeDeclaration &&
+                isDeclaredInsideLocalScope(estreeDeclaration, localScopes));
+        })
+        : false;
 }
 function isDeclaredInsideLocalScope(node, localScopes) {
     return localScopes.some((scope) => isNodeInsideFunctionScope(node, scope));
@@ -251502,12 +251592,9 @@ function isLocallyCreatedExpression(node, context, localScopes) {
     }
 }
 function hasObservableMutationTarget(node, context, localScopes) {
-    return collectMutationTargets(node).some((target) => {
-        if (target.type === dist$3.AST_NODE_TYPES.Identifier) {
-            return !isLocalIdentifier(target, context, localScopes);
-        }
-        return !isLocallyCreatedExpression(target.object, context, localScopes);
-    });
+    return collectMutationTargets(node).some((target) => target.type === dist$3.AST_NODE_TYPES.Identifier
+        ? !isLocalIdentifier(target, context, localScopes)
+        : !isLocallyCreatedExpression(target.object, context, localScopes));
 }
 function reportSideEffect(node, context, report) {
     const key = String(node.range);
@@ -251575,10 +251662,9 @@ function resolveFunctionLikeFromIdentifier(node, context, seenSymbols = new Set(
     seenSymbols.add(symbolId);
     return (symbol.declarations ?? []).flatMap((declaration) => {
         const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
-        if (!estreeDeclaration || !isInspectableFunctionContainer(estreeDeclaration)) {
-            return [];
-        }
-        return resolveFunctionLikeFromContainer(estreeDeclaration, context, seenSymbols);
+        return !estreeDeclaration || !isInspectableFunctionContainer(estreeDeclaration)
+            ? []
+            : resolveFunctionLikeFromContainer(estreeDeclaration, context, seenSymbols);
     });
 }
 function resolveCalledFunctions(node, context) {
@@ -251714,7 +251800,7 @@ function inspectComputedBody(root, context, localScopes, visitedFunctions, repor
         return;
     });
 }
-const rule$r = createRule({
+const rule$s = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode, tsNodeToESTreeNodeMap, } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251757,7 +251843,7 @@ const rule$r = createRule({
     name: 'no-side-effects-in-computed',
 });
 
-const rule$q = createUntrackedRule({
+const rule$r = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251804,20 +251890,18 @@ const rule$q = createUntrackedRule({
 });
 
 function collectParts(node) {
-    if (node.type === dist$3.AST_NODE_TYPES.BinaryExpression && node.operator === '+') {
-        return [...collectParts(node.left), ...collectParts(node.right)];
-    }
-    return [node];
+    return node.type === dist$3.AST_NODE_TYPES.BinaryExpression && node.operator === '+'
+        ? [...collectParts(node.left), ...collectParts(node.right)]
+        : [node];
 }
 function isRootConcat(node) {
     const { parent } = node;
     return parent.type !== dist$3.AST_NODE_TYPES.BinaryExpression || parent.operator !== '+';
 }
 function isStringType(type, checker) {
-    if (type.isUnion()) {
-        return type.types.every((t) => isStringType(t, checker));
-    }
-    return type.isStringLiteral() || checker.typeToString(type) === 'string';
+    return type.isUnion()
+        ? type.types.every((t) => isStringType(t, checker))
+        : type.isStringLiteral() || checker.typeToString(type) === 'string';
 }
 function buildMergedString(parts) {
     const combined = parts.map((p) => p.value).join('');
@@ -251851,7 +251935,7 @@ function templateContent(template, renderExpr) {
         : ''}`)
         .join('');
 }
-const rule$p = createRule({
+const rule$q = createRule({
     create(context) {
         const { sourceCode } = context;
         let parserServices = null;
@@ -251963,28 +252047,25 @@ function buildUntrackedImportFixes(program, fixer) {
     const coreImport = findRuntimeAngularCoreImport(program);
     if (!coreImport) {
         const firstStatement = program.body[0];
-        if (!firstStatement) {
-            return [];
-        }
-        return [
-            fixer.insertTextBefore(firstStatement, "import { untracked } from '@angular/core';\n"),
-        ];
+        return firstStatement
+            ? [
+                fixer.insertTextBefore(firstStatement, "import { untracked } from '@angular/core';\n"),
+            ]
+            : [];
     }
     const namedSpecifiers = coreImport.specifiers.filter((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportSpecifier);
     if (namedSpecifiers.length > 0) {
         const lastNamedSpecifier = namedSpecifiers[namedSpecifiers.length - 1];
-        if (!lastNamedSpecifier) {
-            return [];
-        }
-        return [fixer.insertTextAfter(lastNamedSpecifier, ', untracked')];
+        return lastNamedSpecifier
+            ? [fixer.insertTextAfter(lastNamedSpecifier, ', untracked')]
+            : [];
     }
     const defaultImport = coreImport.specifiers.find((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportDefaultSpecifier);
-    if (defaultImport) {
-        return [fixer.insertTextAfter(defaultImport, ', { untracked }')];
-    }
-    return [
-        fixer.insertTextAfter(coreImport, "\nimport { untracked } from '@angular/core';"),
-    ];
+    return defaultImport
+        ? [fixer.insertTextAfter(defaultImport, ', { untracked }')]
+        : [
+            fixer.insertTextAfter(coreImport, "\nimport { untracked } from '@angular/core';"),
+        ];
 }
 /**
  * Removes the `untracked` import specifier from `@angular/core`.
@@ -251996,7 +252077,6 @@ function buildImportRemovalFixes(program, fixer, sourceCode) {
         return [];
     }
     const { importDecl, specifier: untrackedSpec } = match;
-    const namedSpecifiers = importDecl.specifiers.filter((s) => s.type === dist$3.AST_NODE_TYPES.ImportSpecifier);
     if (importDecl.specifiers.length === 1) {
         return [fixer.remove(importDecl)];
     }
@@ -252014,24 +252094,19 @@ function buildImportRemovalFixes(program, fixer, sourceCode) {
     // Try to remove a leading comma (last specifier)
     const textBefore = importText.slice(0, specStart - importStart);
     const leadingCommaIdx = textBefore.lastIndexOf(',');
-    if (leadingCommaIdx !== -1) {
-        return [fixer.removeRange([importStart + leadingCommaIdx, specEnd])];
-    }
-    if (namedSpecifiers.length === 1) {
-        return [fixer.remove(untrackedSpec)];
-    }
-    return [fixer.remove(untrackedSpec)];
+    return leadingCommaIdx === -1
+        ? [fixer.remove(untrackedSpec)]
+        : [fixer.removeRange([importStart + leadingCommaIdx, specEnd])];
 }
 
 function hasNamedDecorator(node, name) {
     return node.decorators.some((decorator) => {
         const expression = decorator.expression;
-        if (expression.type === dist$3.AST_NODE_TYPES.Identifier) {
-            return expression.name === name;
-        }
-        return (expression.type === dist$3.AST_NODE_TYPES.CallExpression &&
-            expression.callee.type === dist$3.AST_NODE_TYPES.Identifier &&
-            expression.callee.name === name);
+        return expression.type === dist$3.AST_NODE_TYPES.Identifier
+            ? expression.name === name
+            : expression.type === dist$3.AST_NODE_TYPES.CallExpression &&
+                expression.callee.type === dist$3.AST_NODE_TYPES.Identifier &&
+                expression.callee.name === name;
     });
 }
 
@@ -252087,13 +252162,12 @@ function dedent(text, extraSpaces) {
 
 function isDirectCallOrNewArgument(node) {
     const parent = node.parent;
-    if (node.type !== dist$3.AST_NODE_TYPES.ArrowFunctionExpression &&
-        node.type !== dist$3.AST_NODE_TYPES.FunctionExpression) {
-        return false;
-    }
-    return ((parent.type === dist$3.AST_NODE_TYPES.CallExpression ||
-        parent.type === dist$3.AST_NODE_TYPES.NewExpression) &&
-        parent.arguments.includes(node));
+    return node.type !== dist$3.AST_NODE_TYPES.ArrowFunctionExpression &&
+        node.type !== dist$3.AST_NODE_TYPES.FunctionExpression
+        ? false
+        : (parent.type === dist$3.AST_NODE_TYPES.CallExpression ||
+            parent.type === dist$3.AST_NODE_TYPES.NewExpression) &&
+            parent.arguments.includes(node);
 }
 function isStoredFunctionUsedAsCallOrNewArgument(fn, checker, esTreeNodeToTSNodeMap) {
     const parent = fn.parent;
@@ -252164,29 +252238,26 @@ function isAllowedDeferredCallbackContext(node, checker, esTreeNodeToTSNodeMap)
         return false;
     }
     const fn = getEnclosingFunction(node);
-    if (!fn) {
-        return false;
-    }
-    return (isDirectCallOrNewArgument(fn) ||
-        isStoredFunctionUsedAsCallOrNewArgument(fn, checker, esTreeNodeToTSNodeMap));
+    return fn
+        ? isDirectCallOrNewArgument(fn) ||
+            isStoredFunctionUsedAsCallOrNewArgument(fn, checker, esTreeNodeToTSNodeMap)
+        : false;
 }
 function isAllowedLazyAngularFactoryContext(node, program) {
     const fn = getEnclosingFunction(node);
-    if (!fn || !getReturnedReactiveOwnerCall(node, program)) {
-        return false;
-    }
-    return (isAngularInjectionTokenFactoryFunction(fn, program) ||
-        isAngularUseFactoryFunction(fn));
+    return !fn || !getReturnedReactiveOwnerCall(node, program)
+        ? false
+        : isAngularInjectionTokenFactoryFunction(fn, program) ||
+            isAngularUseFactoryFunction(fn);
 }
 function buildReactiveCallReplacement(outerUntrackedCall, reactiveCall, sourceCode) {
     const text = sourceCode.getText(reactiveCall);
-    if (reactiveCall.parent.type !== dist$3.AST_NODE_TYPES.ExpressionStatement ||
-        outerUntrackedCall.parent.type !== dist$3.AST_NODE_TYPES.ExpressionStatement) {
-        return text;
-    }
-    return dedent(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
+    return reactiveCall.parent.type !== dist$3.AST_NODE_TYPES.ExpressionStatement ||
+        outerUntrackedCall.parent.type !== dist$3.AST_NODE_TYPES.ExpressionStatement
+        ? text
+        : dedent(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
 }
-const rule$o = createUntrackedRule({
+const rule$p = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -252315,7 +252386,7 @@ function hasOpaqueSynchronousCalls(root, checker, esTreeNodeToTSNodeMap, program
     });
     return found;
 }
-const rule$n = createUntrackedRule({
+const rule$o = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -252397,17 +252468,16 @@ const rule$n = createUntrackedRule({
     name: 'no-useless-untracked',
 });
 
-const rule$m = createRule({
+const rule$n = createRule({
     create(context, [{ printWidth }]) {
         const sourceCode = context.sourceCode;
         const getLineEndIndex = (lineStartIndex) => {
             const text = sourceCode.text;
             const newLineIndex = text.indexOf('\n', lineStartIndex);
             const rawEndIndex = newLineIndex === -1 ? text.length : newLineIndex;
-            if (rawEndIndex > lineStartIndex && text[rawEndIndex - 1] === '\r') {
-                return rawEndIndex - 1;
-            }
-            return rawEndIndex;
+            return rawEndIndex > lineStartIndex && text[rawEndIndex - 1] === '\r'
+                ? rawEndIndex - 1
+                : rawEndIndex;
         };
         const hasAnyCommentsInside = (node) => sourceCode.getCommentsInside(node).length > 0;
         const isTemplateLikeExpression = (expression) => expression.type === dist$2.AST_NODE_TYPES.TemplateLiteral ||
@@ -252479,34 +252549,28 @@ const rule$m = createRule({
             const valueExpression = property.value;
             // eslint-disable-next-line @typescript-eslint/no-use-before-define
             const valueText = renderExpressionOneLine(valueExpression);
-            if (property.computed) {
-                return `[${keyText}]: ${valueText}`;
-            }
-            return `${keyText}: ${valueText}`;
+            return property.computed
+                ? `[${keyText}]: ${valueText}`
+                : `${keyText}: ${valueText}`;
         };
         const renderObjectExpressionOneLine = (node) => {
             const [onlyProperty] = node.properties;
-            if (!onlyProperty) {
-                return '{}';
-            }
-            return `{${renderPropertyOneLine(onlyProperty)}}`;
+            return onlyProperty ? `{${renderPropertyOneLine(onlyProperty)}}` : '{}';
         };
         const renderExpressionOneLine = (expression) => {
             const innerParen = getParenthesizedInner(expression);
             if (innerParen) {
                 const inner = unwrapExpression(innerParen);
-                if (inner.type === dist$2.AST_NODE_TYPES.ObjectExpression &&
-                    canInlineObjectExpression(inner)) {
-                    return `(${renderObjectExpressionOneLine(inner)})`;
-                }
-                return sourceCode.getText(expression);
+                return inner.type === dist$2.AST_NODE_TYPES.ObjectExpression &&
+                    canInlineObjectExpression(inner)
+                    ? `(${renderObjectExpressionOneLine(inner)})`
+                    : sourceCode.getText(expression);
             }
             const unwrapped = unwrapExpression(expression);
-            if (unwrapped.type === dist$2.AST_NODE_TYPES.ObjectExpression &&
-                canInlineObjectExpression(unwrapped)) {
-                return renderObjectExpressionOneLine(unwrapped);
-            }
-            return sourceCode.getText(expression);
+            return unwrapped.type === dist$2.AST_NODE_TYPES.ObjectExpression &&
+                canInlineObjectExpression(unwrapped)
+                ? renderObjectExpressionOneLine(unwrapped)
+                : sourceCode.getText(expression);
         };
         const hasPendingInnerInlineCandidate = (node) => {
             if (node.properties.length !== 1) {
@@ -252718,7 +252782,7 @@ function renderTest(node, sourceCode) {
     const text = sourceCode.getText(node);
     return needsParenthesesInOrChain(node) ? `(${text})` : text;
 }
-const rule$l = createRule({
+const rule$m = createRule({
     create(context) {
         const { sourceCode } = context;
         function checkBody(statements) {
@@ -252807,6 +252871,169 @@ const rule$l = createRule({
     name: 'prefer-combined-if-control-flow',
 });
 
+const MAX_INLINE_CONDITIONAL_RETURN_LENGTH = 90;
+function getReturnStatement(statement) {
+    if (statement.type === dist$3.AST_NODE_TYPES.ReturnStatement) {
+        return statement;
+    }
+    if (statement.type !== dist$3.AST_NODE_TYPES.BlockStatement || statement.body.length !== 1) {
+        return null;
+    }
+    const [onlyStatement] = statement.body;
+    return onlyStatement?.type === dist$3.AST_NODE_TYPES.ReturnStatement ? onlyStatement : null;
+}
+function hasOnlyWhitespaceBetween(sourceCode, left, right) {
+    return sourceCode.text.slice(left.range[1], right.range[0]).trim() === '';
+}
+function unwrapTypeAndParentheses(node) {
+    let current = node;
+    let didUnwrap = true;
+    while (didUnwrap) {
+        didUnwrap = false;
+        const parenthesized = unwrapParenthesized(current);
+        if (parenthesized !== current) {
+            current = parenthesized;
+            didUnwrap = true;
+            continue;
+        }
+        switch (current.type) {
+            case dist$3.AST_NODE_TYPES.TSAsExpression:
+            case dist$3.AST_NODE_TYPES.TSNonNullExpression:
+            case dist$3.AST_NODE_TYPES.TSSatisfiesExpression:
+            case dist$3.AST_NODE_TYPES.TSTypeAssertion:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+        }
+    }
+    return current;
+}
+function isConditionalExpression(node) {
+    return (node !== null &&
+        unwrapTypeAndParentheses(node).type === dist$3.AST_NODE_TYPES.ConditionalExpression);
+}
+function needsParenthesesInConditionalTest(node) {
+    if (getParenthesizedInner(node)) {
+        return false;
+    }
+    switch (node.type) {
+        case dist$3.AST_NODE_TYPES.ArrowFunctionExpression:
+        case dist$3.AST_NODE_TYPES.AssignmentExpression:
+        case dist$3.AST_NODE_TYPES.ConditionalExpression:
+        case dist$3.AST_NODE_TYPES.ObjectExpression:
+        case dist$3.AST_NODE_TYPES.SequenceExpression:
+        case dist$3.AST_NODE_TYPES.TSAsExpression:
+        case dist$3.AST_NODE_TYPES.TSSatisfiesExpression:
+        case dist$3.AST_NODE_TYPES.TSTypeAssertion:
+        case dist$3.AST_NODE_TYPES.YieldExpression:
+            return true;
+        default:
+            return false;
+    }
+}
+function needsParenthesesInConditionalBranch(node) {
+    if (getParenthesizedInner(node)) {
+        return false;
+    }
+    switch (node.type) {
+        case dist$3.AST_NODE_TYPES.ArrowFunctionExpression:
+        case dist$3.AST_NODE_TYPES.AssignmentExpression:
+        case dist$3.AST_NODE_TYPES.ConditionalExpression:
+        case dist$3.AST_NODE_TYPES.SequenceExpression:
+        case dist$3.AST_NODE_TYPES.TSAsExpression:
+        case dist$3.AST_NODE_TYPES.TSSatisfiesExpression:
+        case dist$3.AST_NODE_TYPES.TSTypeAssertion:
+        case dist$3.AST_NODE_TYPES.YieldExpression:
+            return true;
+        default:
+            return false;
+    }
+}
+function renderExpression(node, sourceCode, needsParentheses) {
+    const text = sourceCode.getText(node);
+    return needsParentheses(node) ? `(${text})` : text;
+}
+function getStatementIndent(node, sourceCode) {
+    const lineStart = sourceCode.getIndexFromLoc({
+        column: 0,
+        line: node.loc.start.line,
+    });
+    return sourceCode.text.slice(lineStart, node.range[0]);
+}
+function renderConditionalReturn(ifStatement, consequentExpression, alternateExpression, sourceCode) {
+    const test = renderExpression(ifStatement.test, sourceCode, needsParenthesesInConditionalTest);
+    const consequent = renderExpression(consequentExpression, sourceCode, needsParenthesesInConditionalBranch);
+    const alternate = renderExpression(alternateExpression, sourceCode, needsParenthesesInConditionalBranch);
+    const inlineReturn = `return ${test} ? ${consequent} : ${alternate};`;
+    const indent = getStatementIndent(ifStatement, sourceCode);
+    if (indent.length + inlineReturn.length <= MAX_INLINE_CONDITIONAL_RETURN_LENGTH) {
+        return inlineReturn;
+    }
+    const branchIndent = `${indent}    `;
+    return `return ${test}\n${branchIndent}? ${consequent}\n${branchIndent}: ${alternate};`;
+}
+const rule$l = createRule({
+    create(context) {
+        const { sourceCode } = context;
+        function checkBody(statements) {
+            for (const [index, statement] of statements.entries()) {
+                if (statement.type !== dist$3.AST_NODE_TYPES.IfStatement) {
+                    continue;
+                }
+                const nextStatement = statements[index + 1];
+                if (nextStatement?.type !== dist$3.AST_NODE_TYPES.ReturnStatement) {
+                    continue;
+                }
+                const consequentReturn = getReturnStatement(statement.consequent);
+                const finalReturn = nextStatement;
+                const consequentArgument = consequentReturn?.argument ?? null;
+                const finalArgument = finalReturn.argument;
+                if (statement.alternate ||
+                    !consequentArgument ||
+                    !finalArgument ||
+                    isConditionalExpression(consequentArgument) ||
+                    isConditionalExpression(finalArgument) ||
+                    !hasOnlyWhitespaceBetween(sourceCode, statement, finalReturn) ||
+                    sourceCode.getCommentsInside(statement).length > 0 ||
+                    sourceCode.getCommentsInside(finalReturn).length > 0) {
+                    continue;
+                }
+                context.report({
+                    fix(fixer) {
+                        const replacement = renderConditionalReturn(statement, consequentArgument, finalArgument, sourceCode);
+                        return fixer.replaceTextRange([statement.range[0], finalReturn.range[1]], replacement);
+                    },
+                    messageId: 'preferConditionalReturn',
+                    node: statement,
+                });
+            }
+        }
+        return {
+            BlockStatement(node) {
+                checkBody(node.body);
+            },
+            Program(node) {
+                checkBody(node.body);
+            },
+            SwitchCase(node) {
+                checkBody(node.consequent);
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Prefer a single conditional return over an if statement followed by another return statement.',
+        },
+        fixable: 'code',
+        messages: {
+            preferConditionalReturn: 'Replace this if/return pair with a single conditional return.',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'prefer-conditional-return',
+});
+
 function parseStrictNullCheck(node, getText) {
     if (node.type !== dist$3.AST_NODE_TYPES.BinaryExpression) {
         return null;
@@ -252824,29 +253051,26 @@ function parseStrictNullCheck(node, getText) {
     if (left.type === dist$3.AST_NODE_TYPES.Literal && left.value === null) {
         return { comparedWith: 'null', operand: getText(right), strictOp: operator };
     }
-    if (left.type === dist$3.AST_NODE_TYPES.Identifier && left.name === 'undefined') {
-        return { comparedWith: 'undefined', operand: getText(right), strictOp: operator };
-    }
-    return null;
+    return left.type === dist$3.AST_NODE_TYPES.Identifier && left.name === 'undefined'
+        ? { comparedWith: 'undefined', operand: getText(right), strictOp: operator }
+        : null;
 }
 function isParsedNullCheck(value) {
     return value !== null;
 }
 function getLooseNullCheck(left, right) {
-    if (!isParsedNullCheck(left) ||
+    return !isParsedNullCheck(left) ||
         !isParsedNullCheck(right) ||
         left.strictOp !== right.strictOp ||
         left.operand !== right.operand ||
-        left.comparedWith === right.comparedWith) {
-        return null;
-    }
-    return `${left.operand} ${left.strictOp === '!==' ? '!=' : '=='} null`;
+        left.comparedWith === right.comparedWith
+        ? null
+        : `${left.operand} ${left.strictOp === '!==' ? '!=' : '=='} null`;
 }
 function collectAndLeaves(node) {
-    if (node.type === dist$3.AST_NODE_TYPES.LogicalExpression && node.operator === '&&') {
-        return [...collectAndLeaves(node.left), ...collectAndLeaves(node.right)];
-    }
-    return [node];
+    return node.type === dist$3.AST_NODE_TYPES.LogicalExpression && node.operator === '&&'
+        ? [...collectAndLeaves(node.left), ...collectAndLeaves(node.right)]
+        : [node];
 }
 function isAndChainRoot(node) {
     return (node.parent.type !== dist$3.AST_NODE_TYPES.LogicalExpression ||
@@ -252920,10 +253144,9 @@ function getPushCall(node) {
         return null;
     }
     const { property } = call.callee;
-    if (property.type !== dist$3.AST_NODE_TYPES.Identifier || property.name !== 'push') {
-        return null;
-    }
-    return call;
+    return property.type !== dist$3.AST_NODE_TYPES.Identifier || property.name !== 'push'
+        ? null
+        : call;
 }
 const rule$j = createRule({
     create(context) {
@@ -252971,10 +253194,12 @@ const rule$j = createRule({
                                             .map((arg) => sourceCode.getText(arg))
                                             .join(', ');
                                         const lastStmt = group[group.length - 1];
-                                        if (!lastStmt) {
-                                            return null;
-                                        }
-                                        return fixer.replaceTextRange([groupStmt.range[0], lastStmt.range[1]], `${arrayText}.push(${allArgs});`);
+                                        return lastStmt
+                                            ? fixer.replaceTextRange([
+                                                groupStmt.range[0],
+                                                lastStmt.range[1],
+                                            ], `${arrayText}.push(${allArgs});`)
+                                            : null;
                                     },
                                 }
                                 : {}),
@@ -253014,10 +253239,9 @@ function getModuleKeywordToken(sourceCode, node) {
     if (!firstToken) {
         return null;
     }
-    if (firstToken.value === 'declare') {
-        return sourceCode.getTokenAfter(firstToken) ?? null;
-    }
-    return firstToken;
+    return firstToken.value === 'declare'
+        ? (sourceCode.getTokenAfter(firstToken) ?? null)
+        : firstToken;
 }
 const rule$i = createRule({
     create(context) {
@@ -253114,20 +253338,18 @@ function unwrapUsageExpression(node) {
 }
 function isStatementPositionCall(node) {
     const usage = unwrapUsageExpression(node);
-    if (usage.parent?.type === dist$3.AST_NODE_TYPES.ExpressionStatement) {
-        return true;
-    }
-    return (usage.parent?.type === dist$3.AST_NODE_TYPES.AwaitExpression &&
-        usage.parent.parent.type === dist$3.AST_NODE_TYPES.ExpressionStatement);
+    return usage.parent?.type === dist$3.AST_NODE_TYPES.ExpressionStatement
+        ? true
+        : usage.parent?.type === dist$3.AST_NODE_TYPES.AwaitExpression &&
+            usage.parent.parent.type === dist$3.AST_NODE_TYPES.ExpressionStatement;
 }
 function isConsoleMethodCall(node) {
-    if (node.callee.type !== dist$3.AST_NODE_TYPES.MemberExpression ||
+    return node.callee.type !== dist$3.AST_NODE_TYPES.MemberExpression ||
         node.callee.object.type !== dist$3.AST_NODE_TYPES.Identifier ||
         node.callee.object.name !== 'console' ||
-        node.callee.property.type !== dist$3.AST_NODE_TYPES.Identifier) {
-        return false;
-    }
-    return CONSOLE_METHODS.has(node.callee.property.name);
+        node.callee.property.type !== dist$3.AST_NODE_TYPES.Identifier
+        ? false
+        : CONSOLE_METHODS.has(node.callee.property.name);
 }
 function isDomImperativeCall(node, checker, esTreeNodeToTSNodeMap) {
     if (node.callee.type === dist$3.AST_NODE_TYPES.MemberExpression &&
@@ -253149,14 +253371,13 @@ function isDomImperativeCall(node, checker, esTreeNodeToTSNodeMap) {
     return returnType === 'void' || returnType === 'Promise<void>';
 }
 function isSuspiciousDomCallArgumentConsumer(node, checker, esTreeNodeToTSNodeMap, program) {
-    if (isAngularUntrackedCall(node, program) ||
+    return isAngularUntrackedCall(node, program) ||
         isSignalReadCall(node, checker, esTreeNodeToTSNodeMap) ||
         isWritableSignalWrite(node, checker, esTreeNodeToTSNodeMap) ||
         !isStatementPositionCall(node) ||
-        isConsoleMethodCall(node)) {
-        return false;
-    }
-    return isDomImperativeCall(node, checker, esTreeNodeToTSNodeMap);
+        isConsoleMethodCall(node)
+        ? false
+        : isDomImperativeCall(node, checker, esTreeNodeToTSNodeMap);
 }
 function isAliasDeclarationIdentifier(node) {
     return (node.type === dist$3.AST_NODE_TYPES.Identifier &&
@@ -253298,13 +253519,12 @@ const rule$h = createUntrackedRule({
             const untrackedAlias = findUntrackedAlias(program);
             const alreadyHasUntracked = untrackedAlias != null;
             const wrapped = buildUntrackedWrap(read, sourceCode, untrackedAlias ?? 'untracked');
-            if (alreadyHasUntracked) {
-                return (fixer) => [fixer.replaceText(read, wrapped)];
-            }
-            return (fixer) => [
-                fixer.replaceText(read, wrapped),
-                ...buildUntrackedImportFixes(program, fixer),
-            ];
+            return alreadyHasUntracked
+                ? (fixer) => [fixer.replaceText(read, wrapped)]
+                : (fixer) => [
+                    fixer.replaceText(read, wrapped),
+                    ...buildUntrackedImportFixes(program, fixer),
+                ];
         }
         return {
             CallExpression(node) {
@@ -253353,10 +253573,9 @@ function getReturnedExpression(node) {
         return null;
     }
     const statement = node.body.body[0];
-    if (statement?.type !== dist$3.AST_NODE_TYPES.ReturnStatement || !statement.argument) {
-        return null;
-    }
-    return statement.argument;
+    return statement?.type !== dist$3.AST_NODE_TYPES.ReturnStatement || !statement.argument
+        ? null
+        : statement.argument;
 }
 
 function getWrappedSignalGetter(node, checker, esTreeNodeToTSNodeMap) {
@@ -253749,17 +253968,23 @@ function isArray(node) {
 }
 
 function isImportsArrayProperty(property) {
-    const isProperty = property?.type === dist$3.AST_NODE_TYPES.Property;
-    const hasIdentifierKey = property?.key.type === dist$3.AST_NODE_TYPES.Identifier &&
+    if (property?.type !== dist$3.AST_NODE_TYPES.Property) {
+        return false;
+    }
+    const hasIdentifierKey = property.key.type === dist$3.AST_NODE_TYPES.Identifier &&
         property.key.name === 'imports';
-    return isProperty && hasIdentifierKey && isArray(property.value);
+    return hasIdentifierKey && isArray(property.value);
+}
+
+function getImportsArray(meta) {
+    const property = meta.properties.find(isImportsArrayProperty);
+    return property?.value ?? null;
 }
 
 function getImportedName$1(spec) {
-    if (spec.imported.type === dist$3.AST_NODE_TYPES.Identifier) {
-        return spec.imported.name;
-    }
-    return spec.imported.value;
+    return spec.imported.type === dist$3.AST_NODE_TYPES.Identifier
+        ? spec.imported.name
+        : spec.imported.value;
 }
 
 const MESSAGE_ID$3 = 'replaceTuiImport';
@@ -253774,28 +253999,19 @@ const DEFAULT_EXCEPTIONS = [
 const rule$9 = createRule({
     create(context, [{ decorators = DEFAULT_DECORATORS, exceptions = DEFAULT_EXCEPTIONS }]) {
         const sourceCode = context.getSourceCode();
+        const allowedDecorators = new Set(decorators);
         const importedFromTaiga = {};
-        const decoratorSelector = `Decorator[expression.callee.name=/^(${decorators.join('|')})$/]`;
         return {
-            [decoratorSelector](decorator) {
-                const expression = decorator.expression;
-                const isInvalidExpression = expression.type !== dist$3.AST_NODE_TYPES.CallExpression ||
-                    expression.arguments.length === 0;
-                if (isInvalidExpression) {
-                    return;
-                }
-                const [arg] = expression.arguments;
-                const isNotObject = arg?.type !== dist$3.AST_NODE_TYPES.ObjectExpression;
-                if (isNotObject) {
+            Decorator(decorator) {
+                const metadata = getDecoratorMetadata(decorator, allowedDecorators);
+                if (!metadata) {
                     return;
                 }
-                const importsProperty = arg.properties
-                    .filter((literal) => literal.type === dist$3.AST_NODE_TYPES.Property)
-                    .find((literal) => isImportsArrayProperty(literal));
-                if (!importsProperty) {
+                const importsArray = getImportsArray(metadata);
+                if (!importsArray) {
                     return;
                 }
-                const imports = importsProperty.value.elements.filter((el) => {
+                const imports = importsArray.elements.filter((el) => {
                     const isIdentifier = el?.type === dist$3.AST_NODE_TYPES.Identifier;
                     return Boolean(el && isIdentifier);
                 });
@@ -253956,10 +254172,7 @@ function getLineBreak(text) {
     if (text.includes('\r\n')) {
         return '\r\n';
     }
-    if (text.includes('\r')) {
-        return '\r';
-    }
-    return '\n';
+    return text.includes('\r') ? '\r' : '\n';
 }
 function getLeadingIndentation(text) {
     let index = 0;
@@ -254073,11 +254286,10 @@ function getVariableSpacingStatement(node) {
     if (node.type === dist$3.AST_NODE_TYPES.VariableDeclaration) {
         return { declaration: node, exported: false, node };
     }
-    if (node.type !== dist$3.AST_NODE_TYPES.ExportNamedDeclaration ||
-        node.declaration?.type !== dist$3.AST_NODE_TYPES.VariableDeclaration) {
-        return null;
-    }
-    return { declaration: node.declaration, exported: true, node };
+    return node.type !== dist$3.AST_NODE_TYPES.ExportNamedDeclaration ||
+        node.declaration?.type !== dist$3.AST_NODE_TYPES.VariableDeclaration
+        ? null
+        : { declaration: node.declaration, exported: true, node };
 }
 function isRequireCall(node) {
     return (node.type === dist$3.AST_NODE_TYPES.CallExpression &&
@@ -254099,10 +254311,9 @@ function isImportLikeInitializer(node) {
     if (initializer.type === dist$3.AST_NODE_TYPES.MemberExpression) {
         return isImportLikeInitializer(initializer.object);
     }
-    if (initializer.type === dist$3.AST_NODE_TYPES.CallExpression) {
-        return isImportLikeInitializer(initializer.callee);
-    }
-    return false;
+    return initializer.type === dist$3.AST_NODE_TYPES.CallExpression
+        ? isImportLikeInitializer(initializer.callee)
+        : false;
 }
 function isImportLikeVariableDeclaration(declaration) {
     if (declaration.declarations.length !== 1) {
@@ -254110,10 +254321,7 @@ function isImportLikeVariableDeclaration(declaration) {
     }
     const [declarator] = declaration.declarations;
     const init = declarator.init;
-    if (!init) {
-        return false;
-    }
-    return isImportLikeInitializer(init);
+    return init ? isImportLikeInitializer(init) : false;
 }
 const rule$7 = createRule({
     create(context) {
@@ -254214,14 +254422,6 @@ const rule$7 = createRule({
     name: 'single-line-variable-spacing',
 });
 
-function getImportsArray(meta) {
-    const property = meta.properties.find((literal) => literal.type === dist$2.AST_NODE_TYPES.Property &&
-        literal.key.type === dist$2.AST_NODE_TYPES.Identifier &&
-        literal.key.name === 'imports' &&
-        isArray(literal.value));
-    return property ? property.value : null;
-}
-
 function isSpread(node) {
     return node.type === dist$2.AST_NODE_TYPES.SpreadElement;
 }
@@ -254261,11 +254461,12 @@ function nameOf(node, source) {
     return source.getText(node);
 }
 
+const IMPORT_NAME_COLLATOR = new Intl.Collator('en', { numeric: true });
 /**
- * Sorts Angular standalone import elements into a deterministic, alphabetical order.
+ * Sorts Angular standalone import elements into a deterministic, natural order.
  *
  * The sorting rules:
- * 1. Regular elements (Identifiers, MemberExpressions, etc.) are sorted alphabetically.
+ * 1. Regular elements (Identifiers, MemberExpressions, etc.) are sorted naturally.
  * 2. Spread elements (e.g. `...A`) are sorted separately and placed after regular ones.
  * 3. Sorting is based on the string value returned by `nameOf()`.
  *
@@ -254284,10 +254485,13 @@ function nameOf(node, source) {
 function getSortedNames(elements, source) {
     const regular = elements.filter((e) => !isSpread(e));
     const spreads = elements.filter((e) => isSpread(e));
-    const sortedRegular = [...regular].sort((a, b) => nameOf(a, source).localeCompare(nameOf(b, source)));
-    const sortedSpreads = [...spreads].sort((a, b) => nameOf(a.argument, source).localeCompare(nameOf(b.argument, source)));
+    const sortedRegular = [...regular].sort((a, b) => compareImportNames(nameOf(a, source), nameOf(b, source)));
+    const sortedSpreads = [...spreads].sort((a, b) => compareImportNames(nameOf(a.argument, source), nameOf(b.argument, source)));
     return [...sortedRegular, ...sortedSpreads].map((n) => nameOf(n, source));
 }
+function compareImportNames(x, y) {
+    return IMPORT_NAME_COLLATOR.compare(x, y);
+}
 
 const rule$6 = createRule({
     create(context, [options]) {
@@ -254522,12 +254726,11 @@ function getConstArray(node) {
 
 function isClassType(type) {
     const symbol = type.getSymbol();
-    if (!symbol) {
-        return false;
-    }
-    return (symbol
-        .getDeclarations()
-        ?.some((d) => ts.isClassDeclaration(d) || ts.isClassExpression(d)) ?? false);
+    return symbol
+        ? (symbol
+            .getDeclarations()
+            ?.some((d) => ts.isClassDeclaration(d) || ts.isClassExpression(d)) ?? false)
+        : false;
 }
 
 function isExternalPureTuple(typeChecker, type) {
@@ -254536,10 +254739,7 @@ function isExternalPureTuple(typeChecker, type) {
     }
     const typeRef = type;
     const typeArgs = typeChecker.getTypeArguments(typeRef);
-    if (typeArgs.length === 0) {
-        return false;
-    }
-    return typeArgs.every((item) => isClassType(item));
+    return typeArgs.length === 0 ? false : typeArgs.every((item) => isClassType(item));
 }
 
 const MESSAGE_ID$2 = 'spreadArrays';
@@ -254893,10 +255093,7 @@ function normalizeImportFilter(importFilter) {
 function getRootPackageName(importPath) {
     if (importPath.startsWith('@')) {
         const segments = importPath.split('/');
-        if (segments.length < 2) {
-            return null;
-        }
-        return `${segments[0]}/${segments[1]}`;
+        return segments.length < 2 ? null : `${segments[0]}/${segments[1]}`;
     }
     const parts = importPath.split('/');
     return parts[0] ?? null;
@@ -254953,14 +255150,13 @@ function findNestedEntryPointRelativePaths(rootEntryDirectory) {
     return [...new Set(directories)];
 }
 function selectCandidateEntryPointsForMode(allNestedRelativePaths, strict) {
-    if (!strict) {
-        return allNestedRelativePaths.filter((relativePath) => !relativePath.includes('/'));
-    }
-    return [...allNestedRelativePaths].sort((a, b) => {
-        const depthA = a.split('/').filter(Boolean).length;
-        const depthB = b.split('/').filter(Boolean).length;
-        return depthB - depthA;
-    });
+    return strict
+        ? [...allNestedRelativePaths].sort((a, b) => {
+            const depthA = a.split('/').filter(Boolean).length;
+            const depthB = b.split('/').filter(Boolean).length;
+            return depthB - depthA;
+        })
+        : allNestedRelativePaths.filter((relativePath) => !relativePath.includes('/'));
 }
 function mapSymbolsToEntryPointsUsingTypeChecker({ candidateEntryPoints, importedSymbols, rootEntryDirectory, state, }) {
     const symbolToEntryPoint = new Map();
@@ -255111,10 +255307,9 @@ function buildImportStatement({ importKind, importPath, specifiers, state, }) {
     if (namedSpecifiers.length > 0) {
         clauses.push(`{${namedSpecifiers.map((specifier) => state.sourceCode.getText(specifier)).join(', ')}}`);
     }
-    if (clauses.length === 0) {
-        return null;
-    }
-    return `${importKeyword} ${clauses.join(', ')} from '${importPath}';`;
+    return clauses.length === 0
+        ? null
+        : `${importKeyword} ${clauses.join(', ')} from '${importPath}';`;
 }
 
 function getTypeName(param) {
@@ -255225,41 +255420,43 @@ const plugin = {
     },
     rules: {
         'array-as-const': rule$5,
-        'attrs-newline': rule$Q,
+        'attrs-newline': rule$S,
         'class-property-naming': rule$4,
-        'decorator-key-sort': rule$P,
-        'element-newline': rule$O,
+        'decorator-key-sort': rule$R,
+        'element-newline': rule$Q,
         'flat-exports': rule$3,
-        'host-attributes-sort': rule$N,
-        'html-logical-properties': rule$M,
-        'import-integrity': rule$L,
-        'injection-token-description': rule$K,
-        'no-commonjs-import-patterns': rule$J,
-        'no-deep-imports': rule$I,
-        'no-deep-imports-to-indexed-packages': rule$H,
-        'no-duplicate-attrs': rule$G,
-        'no-duplicate-id': rule$F,
-        'no-duplicate-in-head': rule$E,
-        'no-fully-untracked-effect': rule$D,
-        'no-href-with-router-link': rule$C,
-        'no-implicit-public': rule$B,
-        'no-import-assertions': rule$A,
-        'no-infinite-loop': rule$z,
-        'no-legacy-peer-deps': rule$y,
-        'no-obsolete-attrs': rule$x,
-        'no-obsolete-tags': rule$w,
-        'no-playwright-empty-fill': rule$v,
-        'no-project-as-in-ng-template': rule$u,
-        'no-redundant-type-annotation': rule$t,
-        'no-repeated-signal-in-conditional': rule$s,
+        'host-attributes-sort': rule$P,
+        'html-logical-properties': rule$O,
+        'import-integrity': rule$N,
+        'injection-token-description': rule$M,
+        'no-commonjs-import-patterns': rule$L,
+        'no-deep-imports': rule$K,
+        'no-deep-imports-to-indexed-packages': rule$J,
+        'no-duplicate-attrs': rule$I,
+        'no-duplicate-id': rule$H,
+        'no-duplicate-in-head': rule$G,
+        'no-empty-style-metadata': rule$F,
+        'no-fully-untracked-effect': rule$E,
+        'no-href-with-router-link': rule$D,
+        'no-implicit-public': rule$C,
+        'no-import-assertions': rule$B,
+        'no-infinite-loop': rule$A,
+        'no-legacy-peer-deps': rule$z,
+        'no-obsolete-attrs': rule$y,
+        'no-obsolete-tags': rule$x,
+        'no-playwright-empty-fill': rule$w,
+        'no-project-as-in-ng-template': rule$v,
+        'no-redundant-type-annotation': rule$u,
+        'no-repeated-signal-in-conditional': rule$t,
         'no-restricted-attr-values': rule$2,
-        'no-side-effects-in-computed': rule$r,
-        'no-signal-reads-after-await-in-reactive-context': rule$q,
-        'no-string-literal-concat': rule$p,
-        'no-untracked-outside-reactive-context': rule$o,
-        'no-useless-untracked': rule$n,
-        'object-single-line': rule$m,
-        'prefer-combined-if-control-flow': rule$l,
+        'no-side-effects-in-computed': rule$s,
+        'no-signal-reads-after-await-in-reactive-context': rule$r,
+        'no-string-literal-concat': rule$q,
+        'no-untracked-outside-reactive-context': rule$p,
+        'no-useless-untracked': rule$o,
+        'object-single-line': rule$n,
+        'prefer-combined-if-control-flow': rule$m,
+        'prefer-conditional-return': rule$l,
         'prefer-deep-imports': rule$1,
         'prefer-loose-null-check': rule$k,
         'prefer-multi-arg-push': rule$j,