@taiga-ui/eslint-plugin-experience-next 0.498.0 → 0.500.0

package/index.esm.js

@@ -875,6 +875,7 @@ var recommended = defineConfig([
             'func-style': ['error', 'declaration', { allowArrowFunctions: true }],
             'guard-for-in': 'error',
             'import/consistent-type-specifier-style': ['error', 'prefer-inline'],
+            'import/default': 'off',
             'import/enforce-node-protocol-usage': ['error', 'always'],
             'import/export': 'off',
             'import/first': 'error',
@@ -885,7 +886,7 @@ var recommended = defineConfig([
             'import/no-duplicates': ['error', { 'prefer-inline': true }],
             'import/no-extraneous-dependencies': 'off',
             'import/no-mutable-exports': 'error',
-            'import/no-named-as-default': 'error',
+            'import/no-named-as-default': 'off',
             'import/no-self-import': 'error',
             'import/no-unresolved': 'off',
             'import/no-useless-path-segments': ['error', { noUselessIndex: true }],
@@ -1188,6 +1189,7 @@ var recommended = defineConfig([
                 },
             ],
             '@taiga-ui/experience-next/host-attributes-sort': 'error',
+            '@taiga-ui/experience-next/import-integrity': 'error',
             '@taiga-ui/experience-next/injection-token-description': 'error',
             '@taiga-ui/experience-next/no-commonjs-import-patterns': 'error',
             '@taiga-ui/experience-next/no-deep-imports': [
@@ -1203,6 +1205,7 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/no-import-assertions': 'error',
             '@taiga-ui/experience-next/no-infinite-loop': 'error',
             '@taiga-ui/experience-next/no-redundant-type-annotation': 'error',
+            '@taiga-ui/experience-next/no-repeated-signal-in-conditional': 'error',
             '@taiga-ui/experience-next/no-side-effects-in-computed': 'error',
             '@taiga-ui/experience-next/no-signal-reads-after-await-in-reactive-context': 'error',
             '@taiga-ui/experience-next/no-untracked-outside-reactive-context': 'error',
@@ -1215,6 +1218,7 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/prefer-untracked-signal-getter': 'error',
             '@taiga-ui/experience-next/short-tui-imports': 'error',
             '@taiga-ui/experience-next/single-line-class-property-spacing': 'error',
+            '@taiga-ui/experience-next/single-line-variable-spacing': 'error',
             '@taiga-ui/experience-next/standalone-imports-sort': [
                 'error',
                 { decorators: ['Component', 'Directive', 'NgModule', 'Pipe'] },
@@ -46217,7 +46221,7 @@ function buildMultilineStartTag(node, sourceText) {
         closing,
     ].join('\n');
 }
-const rule$M = createRule({
+const rule$P = createRule({
     name: 'attrs-newline',
     rule: {
         create(context) {
@@ -46364,7 +46368,7 @@ const config$5 = {
 function getCorrectOrderRelative(correct, current) {
     return correct.filter((item) => current.includes(item));
 }
-const rule$L = createRule({
+const rule$O = createRule({
     name: 'decorator-key-sort',
     rule: config$5,
 });
@@ -46428,7 +46432,7 @@ function getNodeLabel(node) {
     }
     return 'text';
 }
-const rule$K = createRule({
+const rule$N = createRule({
     name: 'element-newline',
     rule: {
         create(context) {
@@ -46659,7 +46663,7 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const rule$J = createRule({
+const rule$M = createRule({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -46992,317 +46996,11 @@ const config$4 = {
         type: 'suggestion',
     },
 };
-const rule$I = createRule({
+const rule$L = createRule({
     name: 'html-logical-properties',
     rule: config$4,
 });
 
-const MESSAGE_ID$e = 'invalid-injection-token-description';
-const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
-const NG_DEV_MODE = 'ngDevMode';
-function getVariableName(node) {
-    if (node.parent.type !== dist$2.AST_NODE_TYPES.VariableDeclarator) {
-        return undefined;
-    }
-    const { id } = node.parent;
-    return id.type === dist$2.AST_NODE_TYPES.Identifier ? id.name : undefined;
-}
-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 || '';
-}
-function isEmptyString(node) {
-    return (isEmptyStaticString(node) &&
-        (!('expressions' in node) || node.expressions.length === 0));
-}
-function isNgDevModeConditional(node) {
-    return (node.type === dist$2.AST_NODE_TYPES.ConditionalExpression &&
-        node.test.type === dist$2.AST_NODE_TYPES.Identifier &&
-        node.test.name === NG_DEV_MODE &&
-        isStringLike(node.consequent) &&
-        isStringLike(node.alternate) &&
-        isEmptyString(node.alternate));
-}
-function getDescriptionValue(node) {
-    if (isStringLike(node)) {
-        return getStringValue(node);
-    }
-    if (isNgDevModeConditional(node)) {
-        return getStringValue(node.consequent);
-    }
-    return undefined;
-}
-function getDescriptionNode(node) {
-    if (isStringLike(node)) {
-        return node;
-    }
-    return isNgDevModeConditional(node) ? node.consequent : undefined;
-}
-function prependTokenName(text, name) {
-    return `${text.slice(0, 1)}[${name}]: ${text.slice(1)}`;
-}
-function isNgDevModeVisible(sourceCode, node) {
-    for (let scope = sourceCode.getScope(node); scope !== null; scope = scope.upper) {
-        if (scope.variables.some((variable) => variable.name === NG_DEV_MODE)) {
-            return true;
-        }
-    }
-    return false;
-}
-function getNgDevModeDeclarationFix(program, fixer) {
-    const lastImport = [...program.body]
-        .reverse()
-        .find((statement) => statement.type === dist$2.AST_NODE_TYPES.ImportDeclaration);
-    if (lastImport) {
-        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');
-}
-const rule$H = createRule({
-    create(context) {
-        const { sourceCode } = context;
-        const program = sourceCode.ast;
-        let shouldAddNgDevModeDeclaration = true;
-        return {
-            'NewExpression[callee.name="InjectionToken"]'(node) {
-                const [description] = node.arguments;
-                if (!description || description.type === dist$2.AST_NODE_TYPES.SpreadElement) {
-                    return;
-                }
-                const name = getVariableName(node);
-                const token = getDescriptionValue(description);
-                const fixedDescription = getDescriptionNode(description);
-                const report = name && token && !token.includes(name);
-                if (report && fixedDescription) {
-                    context.report({
-                        fix: (fixer) => {
-                            const isNgDevModeGuarded = isNgDevModeConditional(description);
-                            const fixes = [
-                                fixer.replaceText(isNgDevModeGuarded ? fixedDescription : description, isNgDevModeGuarded
-                                    ? prependTokenName(sourceCode.getText(fixedDescription), name)
-                                    : `${NG_DEV_MODE} ? ${prependTokenName(sourceCode.getText(fixedDescription), name)} : ''`),
-                            ];
-                            if (!isNgDevModeGuarded &&
-                                shouldAddNgDevModeDeclaration &&
-                                !isNgDevModeVisible(sourceCode, description)) {
-                                shouldAddNgDevModeDeclaration = false;
-                                fixes.unshift(getNgDevModeDeclarationFix(program, fixer));
-                            }
-                            return fixes;
-                        },
-                        messageId: MESSAGE_ID$e,
-                        node: description,
-                    });
-                }
-            },
-        };
-    },
-    meta: {
-        docs: { description: ERROR_MESSAGE$3 },
-        fixable: 'code',
-        messages: { [MESSAGE_ID$e]: ERROR_MESSAGE$3 },
-        schema: [],
-        type: 'problem',
-    },
-    name: 'injection-token-description',
-});
-
-function getResolvedVariable(sourceCode, node) {
-    const scope = sourceCode.getScope(node);
-    const reference = scope.references.find((item) => item.identifier === node);
-    return reference?.resolved ?? null;
-}
-const rule$G = createRule({
-    create(context) {
-        const { sourceCode } = context;
-        const namespaceImports = new Map();
-        const markNamespaceImportAsUsedLikeValue = (identifier) => {
-            const usage = namespaceImports.get(identifier.name);
-            if (!usage ||
-                usage.usedLikeValue ||
-                getResolvedVariable(sourceCode, identifier) !== usage.variable) {
-                return;
-            }
-            usage.usedLikeValue = true;
-        };
-        return {
-            'CallExpression > Identifier.callee'(node) {
-                markNamespaceImportAsUsedLikeValue(node);
-            },
-            ImportDeclaration(node) {
-                const namespaceImport = node.specifiers.find((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportNamespaceSpecifier);
-                if (!namespaceImport) {
-                    return;
-                }
-                const [variable] = sourceCode.getDeclaredVariables(namespaceImport);
-                if (!variable) {
-                    return;
-                }
-                namespaceImports.set(namespaceImport.local.name, {
-                    node: namespaceImport,
-                    usedLikeValue: false,
-                    variable,
-                });
-            },
-            'NewExpression > Identifier.callee'(node) {
-                markNamespaceImportAsUsedLikeValue(node);
-            },
-            'Program:exit'() {
-                for (const usage of namespaceImports.values()) {
-                    if (!usage.usedLikeValue) {
-                        continue;
-                    }
-                    context.report({
-                        data: { name: usage.node.local.name },
-                        messageId: 'avoidCallableNamespaceImport',
-                        node: usage.node,
-                    });
-                }
-            },
-            'TaggedTemplateExpression > Identifier.tag'(node) {
-                markNamespaceImportAsUsedLikeValue(node);
-            },
-            TSImportEqualsDeclaration(node) {
-                if (node.moduleReference.type !== dist$3.AST_NODE_TYPES.TSExternalModuleReference) {
-                    return;
-                }
-                context.report({
-                    data: { name: node.id.name },
-                    messageId: 'avoidImportEquals',
-                    node,
-                });
-            },
-        };
-    },
-    meta: {
-        docs: {
-            description: 'Disallow legacy CommonJS interop import patterns such as `import = require(...)` and namespace imports used like callable values.',
-        },
-        messages: {
-            avoidCallableNamespaceImport: 'Namespace import "{{name}}" is used like a value instead of a namespace. This is a brittle interop pattern and often should become a default import.',
-            avoidImportEquals: '`import {{name}} = require(...)` is a legacy CommonJS import pattern.',
-        },
-        schema: [],
-        type: 'problem',
-    },
-    name: 'no-commonjs-import-patterns',
-});
-
-const MESSAGE_ID$d = 'no-deep-imports';
-const ERROR_MESSAGE$2 = 'Deep imports of Taiga UI packages are prohibited';
-const CODE_EXTENSIONS = new Set([
-    '.cjs',
-    '.cts',
-    '.js',
-    '.jsx',
-    '.mjs',
-    '.mts',
-    '.ts',
-    '.tsx',
-]);
-const DEFAULT_OPTIONS = {
-    currentProject: '',
-    deepImport: String.raw `(?<=^@taiga-ui/[\w-]+)(/.+)$`,
-    ignoreImports: [],
-    importDeclaration: '^@taiga-ui*',
-    projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
-};
-const rule$F = createRule({
-    create(context) {
-        const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
-        const hasNonCodeExtension = (source) => {
-            if (!source) {
-                return false;
-            }
-            const cleanSource = source.split(/[?#]/, 1)[0] ?? '';
-            const extension = path.posix.extname(cleanSource).toLowerCase();
-            return !!extension && !CODE_EXTENSIONS.has(extension);
-        };
-        const isDeepImport = (source) => !!source && new RegExp(deepImport, 'g').test(source);
-        const isSideEffectImport = (node) => node.specifiers.length === 0;
-        const isInsideTheSameEntryPoint = (source) => {
-            const filePath = path
-                .relative(context.cwd, context.filename)
-                .replaceAll(/\\+/g, '/');
-            const [currentFileProjectName] = (currentProject && new RegExp(currentProject, 'g').exec(filePath)) ?? [];
-            const [importSourceProjectName] = source?.match(new RegExp(projectName, 'g')) ?? [];
-            return Boolean(currentFileProjectName &&
-                importSourceProjectName &&
-                currentFileProjectName === importSourceProjectName);
-        };
-        const shouldIgnore = (source) => !!source && ignoreImports.some((p) => new RegExp(p, 'g').test(source));
-        return {
-            [`ImportDeclaration[source.value=/${importDeclaration}/]`](node) {
-                if (!node || isSideEffectImport(node)) {
-                    return;
-                }
-                const importSource = node.source.value;
-                if (!importSource ||
-                    !isDeepImport(importSource) ||
-                    isInsideTheSameEntryPoint(importSource) ||
-                    shouldIgnore(importSource) ||
-                    hasNonCodeExtension(importSource)) {
-                    return;
-                }
-                context.report({
-                    fix: (fixer) => {
-                        const [start, end] = node.source.range;
-                        return fixer.replaceTextRange([start + 1, end - 1], importSource.replaceAll(new RegExp(deepImport, 'g'), ''));
-                    },
-                    messageId: MESSAGE_ID$d,
-                    node: node.source,
-                });
-            },
-        };
-    },
-    meta: {
-        defaultOptions: [DEFAULT_OPTIONS],
-        docs: { description: ERROR_MESSAGE$2 },
-        fixable: 'code',
-        messages: { [MESSAGE_ID$d]: ERROR_MESSAGE$2 },
-        schema: [
-            {
-                additionalProperties: false,
-                properties: {
-                    currentProject: {
-                        description: 'RegExp string to pick out current project name of processed file',
-                        type: 'string',
-                    },
-                    deepImport: {
-                        description: 'RegExp string to pick out deep import part',
-                        type: 'string',
-                    },
-                    ignoreImports: {
-                        description: 'RegExp string to exclude import declarations which is selected by importDeclaration-option',
-                        items: { type: 'string' },
-                        type: 'array',
-                    },
-                    importDeclaration: {
-                        description: 'RegExp string to detect import declarations for which this rule should be applied',
-                        type: 'string',
-                    },
-                    projectName: {
-                        description: 'RegExp string to extract project name from import',
-                        type: 'string',
-                    },
-                },
-                type: 'object',
-            },
-        ],
-        type: 'problem',
-    },
-    name: 'no-deep-imports',
-});
-
 function commonjsRequire(path) {
 	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
 }
@@ -247947,12 +247645,1056 @@ Additional information: BADCLIENT: Bad error code, ${badCode} not found in range
 var typescriptExports = typescript.exports;
 var ts = /*@__PURE__*/getDefaultExportFromCjs(typescriptExports);
 
+function getResolvedVariable(sourceCode, node) {
+    const scope = sourceCode.getScope(node);
+    const reference = scope.references.find((item) => item.identifier === node);
+    return reference?.resolved ?? null;
+}
+
+function getTypeAwareRuleContext(context) {
+    const parserServices = dist$3.ESLintUtils.getParserServices(context);
+    const { sourceCode } = context;
+    return {
+        checker: parserServices.program.getTypeChecker(),
+        esTreeNodeToTSNodeMap: parserServices.esTreeNodeToTSNodeMap,
+        parserServices,
+        program: sourceCode.ast,
+        sourceCode,
+        tsNodeToESTreeNodeMap: parserServices.tsNodeToESTreeNodeMap,
+        tsProgram: parserServices.program,
+    };
+}
+
+const importGraphCacheByProgram = new WeakMap();
+const defaultExportCacheByProgram = new WeakMap();
+const moduleExportNamesCache = new WeakMap();
+const resolutionStateByProgram = new WeakMap();
+const sourceFileCacheByProgram = new WeakMap();
+const codeFileExtensionRegExp = /\.[cm]?[jt]sx?$/;
+// Angular DI functions resolve tokens at instantiation time, not at module load time,
+// so cycles where all usages are DI-only are safe and should not be reported.
+const ANGULAR_DI_FIRST_ARG_FUNCTIONS = new Set([
+    'contentChild',
+    'contentChildren',
+    'inject',
+    'viewChild',
+    'viewChildren',
+]);
+function createCanonicalFileName() {
+    const useCaseSensitiveFileNames = ts.sys.useCaseSensitiveFileNames;
+    return (fileName) => {
+        const resolvedFileName = path.resolve(fileName).replaceAll('\\', '/');
+        return useCaseSensitiveFileNames
+            ? resolvedFileName
+            : resolvedFileName.toLowerCase();
+    };
+}
+function getResolutionState(program) {
+    const cached = resolutionStateByProgram.get(program);
+    if (cached) {
+        return cached;
+    }
+    const compilerOptions = program.getCompilerOptions();
+    const state = {
+        compilerHost: ts.createCompilerHost(compilerOptions, true),
+        resolutionCache: ts.createModuleResolutionCache(program.getCurrentDirectory(), (fileName) => fileName, compilerOptions),
+    };
+    resolutionStateByProgram.set(program, state);
+    return state;
+}
+function normalizeSlashes(fileName) {
+    return fileName.replaceAll('\\', '/');
+}
+function isProjectCodeFile(sourceFile) {
+    const normalizedFileName = normalizeSlashes(sourceFile.fileName);
+    return (!sourceFile.isDeclarationFile &&
+        codeFileExtensionRegExp.test(normalizedFileName) &&
+        !normalizedFileName.includes('/node_modules/'));
+}
+function resolveModule(program, containingFile, moduleSpecifier) {
+    const compilerOptions = program.getCompilerOptions();
+    const { compilerHost, resolutionCache } = getResolutionState(program);
+    const resolved = ts.resolveModuleName(moduleSpecifier, containingFile, compilerOptions, compilerHost, resolutionCache).resolvedModule ?? null;
+    return resolved;
+}
+function resolveModuleFileName(program, containingFile, moduleSpecifier) {
+    const resolved = resolveModule(program, containingFile, moduleSpecifier);
+    if (!resolved || resolved.isExternalLibraryImport) {
+        return null;
+    }
+    return resolved.resolvedFileName;
+}
+function importDeclarationHasRuntimeEdge(node) {
+    const importClause = node.importClause;
+    if (!importClause) {
+        return true;
+    }
+    if (importClause.isTypeOnly) {
+        return false;
+    }
+    if (importClause.name) {
+        return true;
+    }
+    const namedBindings = importClause.namedBindings;
+    if (!namedBindings) {
+        return false;
+    }
+    if (ts.isNamespaceImport(namedBindings)) {
+        return true;
+    }
+    return (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));
+}
+function getRuntimeModuleSpecifier(statement) {
+    if (ts.isImportDeclaration(statement)) {
+        const { moduleSpecifier } = statement;
+        return ts.isStringLiteralLike(moduleSpecifier) &&
+            importDeclarationHasRuntimeEdge(statement)
+            ? moduleSpecifier.text
+            : null;
+    }
+    if (ts.isExportDeclaration(statement)) {
+        const { moduleSpecifier } = statement;
+        return moduleSpecifier &&
+            ts.isStringLiteralLike(moduleSpecifier) &&
+            exportDeclarationHasRuntimeEdge(statement)
+            ? moduleSpecifier.text
+            : null;
+    }
+    if (ts.isImportEqualsDeclaration(statement) &&
+        !statement.isTypeOnly &&
+        ts.isExternalModuleReference(statement.moduleReference)) {
+        const expression = statement.moduleReference.expression;
+        return ts.isStringLiteralLike(expression) ? expression.text : null;
+    }
+    return null;
+}
+function buildDependenciesByFileName(program, canonicalFileName) {
+    const sourceFiles = program.getSourceFiles().filter(isProjectCodeFile);
+    const projectFileNames = new Set(sourceFiles.map((sourceFile) => canonicalFileName(sourceFile.fileName)));
+    const dependenciesByFileName = new Map();
+    const displayFileNameByFileName = new Map();
+    for (const sourceFile of sourceFiles) {
+        const fileName = canonicalFileName(sourceFile.fileName);
+        const edges = [];
+        displayFileNameByFileName.set(fileName, sourceFile.fileName);
+        for (const statement of sourceFile.statements) {
+            const moduleSpecifier = getRuntimeModuleSpecifier(statement);
+            if (!moduleSpecifier) {
+                continue;
+            }
+            const resolvedFileName = resolveModuleFileName(program, sourceFile.fileName, moduleSpecifier);
+            if (!resolvedFileName) {
+                continue;
+            }
+            const targetFileName = canonicalFileName(resolvedFileName);
+            if (!projectFileNames.has(targetFileName)) {
+                continue;
+            }
+            edges.push({ moduleSpecifier, targetFileName });
+        }
+        dependenciesByFileName.set(fileName, edges);
+    }
+    return { dependenciesByFileName, displayFileNameByFileName };
+}
+function findStronglyConnectedComponents(dependenciesByFileName) {
+    let nextComponentId = 0;
+    let nextIndex = 0;
+    const componentIdByFileName = new Map();
+    const componentSizeById = new Map();
+    const nodeStateByFileName = new Map();
+    const stack = [];
+    function visit(fileName) {
+        const state = {
+            index: nextIndex,
+            lowLink: nextIndex,
+            onStack: true,
+        };
+        nextIndex += 1;
+        nodeStateByFileName.set(fileName, state);
+        stack.push(fileName);
+        for (const edge of dependenciesByFileName.get(fileName) ?? []) {
+            const targetState = nodeStateByFileName.get(edge.targetFileName);
+            if (!targetState) {
+                visit(edge.targetFileName);
+                const visitedTargetState = nodeStateByFileName.get(edge.targetFileName);
+                if (visitedTargetState) {
+                    state.lowLink = Math.min(state.lowLink, visitedTargetState.lowLink);
+                }
+                continue;
+            }
+            if (targetState.onStack) {
+                state.lowLink = Math.min(state.lowLink, targetState.index);
+            }
+        }
+        if (state.lowLink !== state.index) {
+            return;
+        }
+        const componentId = nextComponentId;
+        let componentSize = 0;
+        let shouldPop = stack.length > 0;
+        nextComponentId += 1;
+        while (shouldPop) {
+            const memberFileName = stack.pop();
+            if (!memberFileName) {
+                shouldPop = false;
+                continue;
+            }
+            const memberState = nodeStateByFileName.get(memberFileName);
+            if (memberState) {
+                memberState.onStack = false;
+            }
+            componentSize += 1;
+            componentIdByFileName.set(memberFileName, componentId);
+            shouldPop = stack.length > 0 && memberFileName !== fileName;
+        }
+        componentSizeById.set(componentId, componentSize);
+    }
+    for (const fileName of dependenciesByFileName.keys()) {
+        if (!nodeStateByFileName.has(fileName)) {
+            visit(fileName);
+        }
+    }
+    return { componentIdByFileName, componentSizeById };
+}
+function collectSelfCycles(dependenciesByFileName) {
+    const selfCycleFileNames = new Set();
+    for (const [fileName, edges] of dependenciesByFileName) {
+        if (edges.some((edge) => edge.targetFileName === fileName)) {
+            selfCycleFileNames.add(fileName);
+        }
+    }
+    return selfCycleFileNames;
+}
+function getImportGraph(program) {
+    const cached = importGraphCacheByProgram.get(program);
+    if (cached) {
+        return cached;
+    }
+    const canonicalFileName = createCanonicalFileName();
+    const { dependenciesByFileName, displayFileNameByFileName } = buildDependenciesByFileName(program, canonicalFileName);
+    const { componentIdByFileName, componentSizeById } = findStronglyConnectedComponents(dependenciesByFileName);
+    const cache = {
+        componentIdByFileName,
+        componentSizeById,
+        dependenciesByFileName,
+        displayFileNameByFileName,
+        selfCycleFileNames: collectSelfCycles(dependenciesByFileName),
+    };
+    importGraphCacheByProgram.set(program, cache);
+    return cache;
+}
+function getSourceFileByFileName(program, fileName) {
+    const cached = sourceFileCacheByProgram.get(program);
+    const canonicalFileName = createCanonicalFileName();
+    const normalizedFileName = canonicalFileName(fileName);
+    if (cached) {
+        return cached.get(normalizedFileName) ?? null;
+    }
+    const sourceFileByFileName = new Map();
+    for (const sourceFile of program.getSourceFiles()) {
+        sourceFileByFileName.set(canonicalFileName(sourceFile.fileName), sourceFile);
+    }
+    sourceFileCacheByProgram.set(program, sourceFileByFileName);
+    return sourceFileByFileName.get(normalizedFileName) ?? null;
+}
+function hasModifier(node, kind) {
+    return (ts.canHaveModifiers(node) &&
+        (ts.getModifiers(node)?.some((modifier) => modifier.kind === kind) ?? false));
+}
+function hasRuntimeDefaultModifier(statement) {
+    return (hasModifier(statement, ts.SyntaxKind.ExportKeyword) &&
+        hasModifier(statement, ts.SyntaxKind.DefaultKeyword) &&
+        !ts.isInterfaceDeclaration(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');
+}
+function sourceFileHasDefaultExport(sourceFile) {
+    return sourceFile.statements.some((statement) => (ts.isExportAssignment(statement) && !statement.isExportEquals) ||
+        hasRuntimeDefaultModifier(statement) ||
+        (ts.isExportDeclaration(statement) && exportsDefaultSpecifier(statement)));
+}
+function hasDefaultExport(program, fileName) {
+    const canonicalFileName = createCanonicalFileName();
+    const normalizedFileName = canonicalFileName(fileName);
+    let cache = defaultExportCacheByProgram.get(program);
+    if (!cache) {
+        cache = new Map();
+        defaultExportCacheByProgram.set(program, cache);
+    }
+    const cached = cache.get(normalizedFileName);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const sourceFile = getSourceFileByFileName(program, fileName);
+    const hasExport = sourceFile ? sourceFileHasDefaultExport(sourceFile) : false;
+    cache.set(normalizedFileName, hasExport);
+    return hasExport;
+}
+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';
+    });
+}
+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'));
+}
+function getImportOrReExportModuleSpecifier(node) {
+    if (node.type === dist$3.AST_NODE_TYPES.ImportDeclaration) {
+        return hasRuntimeEstreeImport(node) ? node.source.value : null;
+    }
+    if (!node.source || !hasRuntimeEstreeReExport(node)) {
+        return null;
+    }
+    return typeof node.source.value === 'string' ? node.source.value : null;
+}
+function findCyclicTargetFileName(graph, currentFileName, moduleSpecifier) {
+    const currentComponentId = graph.componentIdByFileName.get(currentFileName);
+    if (currentComponentId === undefined) {
+        return null;
+    }
+    const currentComponentSize = graph.componentSizeById.get(currentComponentId) ?? 0;
+    for (const edge of graph.dependenciesByFileName.get(currentFileName) ?? []) {
+        if (edge.moduleSpecifier !== moduleSpecifier) {
+            continue;
+        }
+        const isSelfCycle = edge.targetFileName === currentFileName &&
+            graph.selfCycleFileNames.has(currentFileName);
+        const isSameComponentCycle = currentComponentSize > 1 &&
+            graph.componentIdByFileName.get(edge.targetFileName) === currentComponentId;
+        if (isSelfCycle || isSameComponentCycle) {
+            return edge.targetFileName;
+        }
+    }
+    return null;
+}
+function findPathWithinComponent(graph, startFileName, endFileName, componentId) {
+    const queue = [startFileName];
+    const previousFileName = new Map([[startFileName, null]]);
+    for (let index = 0; index < queue.length && !previousFileName.has(endFileName); index += 1) {
+        const currentFileName = queue[index];
+        if (!currentFileName) {
+            continue;
+        }
+        for (const edge of graph.dependenciesByFileName.get(currentFileName) ?? []) {
+            if (graph.componentIdByFileName.get(edge.targetFileName) !== componentId ||
+                previousFileName.has(edge.targetFileName)) {
+                continue;
+            }
+            previousFileName.set(edge.targetFileName, currentFileName);
+            queue.push(edge.targetFileName);
+        }
+    }
+    if (!previousFileName.has(endFileName)) {
+        return [startFileName, endFileName];
+    }
+    const pathSegments = [];
+    let currentFileName = endFileName;
+    while (currentFileName !== null) {
+        pathSegments.push(currentFileName);
+        const nextFileName = previousFileName.get(currentFileName);
+        if (nextFileName === undefined) {
+            return [startFileName, endFileName];
+        }
+        currentFileName = nextFileName;
+    }
+    return pathSegments.reverse();
+}
+function formatFileName(graph, fileName, cwd) {
+    const displayFileName = graph.displayFileNameByFileName.get(fileName) ?? fileName;
+    const relativeFileName = normalizeSlashes(path.relative(cwd, displayFileName));
+    return relativeFileName || normalizeSlashes(path.basename(displayFileName));
+}
+function formatCyclePath(graph, currentFileName, targetFileName, cwd) {
+    const componentId = graph.componentIdByFileName.get(currentFileName);
+    if (componentId === undefined || currentFileName === targetFileName) {
+        return [currentFileName, targetFileName]
+            .map((fileName) => formatFileName(graph, fileName, cwd))
+            .join(' -> ');
+    }
+    return [
+        currentFileName,
+        ...findPathWithinComponent(graph, targetFileName, currentFileName, componentId),
+    ]
+        .map((fileName) => formatFileName(graph, fileName, cwd))
+        .join(' -> ');
+}
+function getAliasedSymbolIfNeeded(checker, symbol) {
+    return (symbol.flags & ts.SymbolFlags.Alias) === 0
+        ? symbol
+        : checker.getAliasedSymbol(symbol);
+}
+function isValueExport(checker, symbol) {
+    const exportSymbol = getAliasedSymbolIfNeeded(checker, symbol);
+    return (exportSymbol.flags & ts.SymbolFlags.Value) !== 0;
+}
+function getModuleExportNames(checker, moduleSymbol) {
+    const symbol = getAliasedSymbolIfNeeded(checker, moduleSymbol);
+    const cached = moduleExportNamesCache.get(symbol);
+    if (cached) {
+        return cached;
+    }
+    const exportNames = new Set(checker
+        .getExportsOfModule(symbol)
+        .filter((exportSymbol) => isValueExport(checker, exportSymbol))
+        .map((exportSymbol) => exportSymbol.escapedName.toString()));
+    moduleExportNamesCache.set(symbol, exportNames);
+    return exportNames;
+}
+function getNamespaceImportExportNames(checker, esTreeNodeToTSNodeMap, node) {
+    if (node.importKind === 'type') {
+        return null;
+    }
+    const tsNode = esTreeNodeToTSNodeMap.get(node);
+    if (!ts.isImportDeclaration(tsNode)) {
+        return null;
+    }
+    const moduleSymbol = checker.getSymbolAtLocation(tsNode.moduleSpecifier);
+    return moduleSymbol ? getModuleExportNames(checker, moduleSymbol) : null;
+}
+function getExportDeclarationModuleExportNames(checker, esTreeNodeToTSNodeMap, node) {
+    const tsNode = esTreeNodeToTSNodeMap.get(node);
+    if (!ts.isExportDeclaration(tsNode) ||
+        !tsNode.moduleSpecifier ||
+        !ts.isStringLiteralLike(tsNode.moduleSpecifier)) {
+        return null;
+    }
+    const moduleSymbol = checker.getSymbolAtLocation(tsNode.moduleSpecifier);
+    return moduleSymbol ? getModuleExportNames(checker, moduleSymbol) : null;
+}
+function getExportSpecifierName(name) {
+    if (name.type === dist$3.AST_NODE_TYPES.Identifier) {
+        return name.name;
+    }
+    return typeof name.value === 'string' ? name.value : null;
+}
+function hasNamedValueExport(exportNames, exportedName) {
+    return exportedName !== 'default' && (exportNames?.has(exportedName) ?? 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';
+    });
+    if (valueSpecifiers.length === 0) {
+        return false;
+    }
+    for (const specifier of valueSpecifiers) {
+        const [variable] = sourceCode.getDeclaredVariables(specifier);
+        if (!variable || variable.references.length === 0) {
+            return false;
+        }
+        for (const ref of variable.references) {
+            const { identifier } = ref;
+            const parent = identifier.parent;
+            const callee = parent.type === dist$3.AST_NODE_TYPES.CallExpression ? parent.callee : null;
+            const isDirectCall = callee?.type === dist$3.AST_NODE_TYPES.Identifier &&
+                ANGULAR_DI_FIRST_ARG_FUNCTIONS.has(callee.name);
+            const isRequiredCall = callee?.type === dist$3.AST_NODE_TYPES.MemberExpression &&
+                !callee.computed &&
+                callee.object.type === dist$3.AST_NODE_TYPES.Identifier &&
+                ANGULAR_DI_FIRST_ARG_FUNCTIONS.has(callee.object.name) &&
+                callee.property.type === dist$3.AST_NODE_TYPES.Identifier &&
+                callee.property.name === 'required';
+            if (parent.type !== dist$3.AST_NODE_TYPES.CallExpression ||
+                (!isDirectCall && !isRequiredCall) ||
+                parent.arguments[0] !== identifier) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+const rule$K = createRule({
+    create(context) {
+        const { checker, esTreeNodeToTSNodeMap, sourceCode, tsProgram } = getTypeAwareRuleContext(context);
+        const checkCycles = context.options[0]?.checkCycles ?? true;
+        const checkDefaultImports = context.options[0]?.checkDefaultImports ?? true;
+        const checkNamedAsDefault = context.options[0]?.checkNamedAsDefault ?? true;
+        const checkNamespaceMembers = context.options[0]?.checkNamespaceMembers ?? true;
+        const ignoreExternalDefaultImports = context.options[0]?.ignoreExternalDefaultImports ?? true;
+        const canonicalFileName = createCanonicalFileName();
+        const currentFileName = canonicalFileName(context.filename);
+        const namespaceImports = new Map();
+        function checkImportCycle(node) {
+            if (!checkCycles) {
+                return;
+            }
+            const moduleSpecifier = getImportOrReExportModuleSpecifier(node);
+            if (!moduleSpecifier) {
+                return;
+            }
+            const sourceNode = node.source;
+            if (!sourceNode) {
+                return;
+            }
+            const graph = getImportGraph(tsProgram);
+            const targetFileName = findCyclicTargetFileName(graph, currentFileName, moduleSpecifier);
+            if (!targetFileName ||
+                (node.type === dist$3.AST_NODE_TYPES.ImportDeclaration &&
+                    isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode))) {
+                return;
+            }
+            context.report({
+                data: {
+                    cyclePath: formatCyclePath(graph, currentFileName, targetFileName, context.cwd),
+                },
+                messageId: 'importCycle',
+                node: sourceNode,
+            });
+        }
+        function checkDefaultImport(node) {
+            if ((!checkDefaultImports && !checkNamedAsDefault) ||
+                node.importKind === 'type') {
+                return;
+            }
+            const defaultImport = node.specifiers.find((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportDefaultSpecifier);
+            if (!defaultImport) {
+                return;
+            }
+            const moduleSpecifier = node.source.value;
+            const resolved = resolveModule(tsProgram, context.filename, moduleSpecifier);
+            if (!resolved ||
+                (resolved.isExternalLibraryImport && ignoreExternalDefaultImports)) {
+                return;
+            }
+            const hasResolvedDefaultExport = hasDefaultExport(tsProgram, resolved.resolvedFileName);
+            if (!hasResolvedDefaultExport) {
+                if (!checkDefaultImports) {
+                    return;
+                }
+                context.report({
+                    data: { moduleSpecifier },
+                    messageId: 'missingDefaultExport',
+                    node: defaultImport,
+                });
+                return;
+            }
+            const exportNames = getNamespaceImportExportNames(checker, esTreeNodeToTSNodeMap, node);
+            if (!checkNamedAsDefault ||
+                !hasNamedValueExport(exportNames, defaultImport.local.name)) {
+                return;
+            }
+            context.report({
+                data: { name: defaultImport.local.name },
+                messageId: 'namedAsDefault',
+                node: defaultImport,
+            });
+        }
+        function checkNamedAsDefaultExport(node) {
+            if (!checkNamedAsDefault ||
+                node.exportKind === 'type' ||
+                !node.source ||
+                typeof node.source.value !== 'string') {
+                return;
+            }
+            const moduleSpecifier = node.source.value;
+            const resolved = resolveModule(tsProgram, context.filename, moduleSpecifier);
+            if (!resolved ||
+                (resolved.isExternalLibraryImport && ignoreExternalDefaultImports) ||
+                !hasDefaultExport(tsProgram, resolved.resolvedFileName)) {
+                return;
+            }
+            const exportNames = getExportDeclarationModuleExportNames(checker, esTreeNodeToTSNodeMap, node);
+            for (const specifier of node.specifiers) {
+                if (specifier.exportKind === 'type' ||
+                    getExportSpecifierName(specifier.local) !== 'default') {
+                    continue;
+                }
+                const exportedName = getExportSpecifierName(specifier.exported);
+                if (!exportedName || !hasNamedValueExport(exportNames, exportedName)) {
+                    continue;
+                }
+                context.report({
+                    data: { name: exportedName },
+                    messageId: 'namedAsDefault',
+                    node: specifier.exported,
+                });
+            }
+        }
+        function collectNamespaceImport(node) {
+            if (!checkNamespaceMembers) {
+                return;
+            }
+            const namespaceImport = node.specifiers.find((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportNamespaceSpecifier);
+            if (!namespaceImport) {
+                return;
+            }
+            const exportNames = getNamespaceImportExportNames(checker, esTreeNodeToTSNodeMap, node);
+            if (!exportNames) {
+                return;
+            }
+            const [variable] = sourceCode.getDeclaredVariables(namespaceImport);
+            if (!variable) {
+                return;
+            }
+            namespaceImports.set(namespaceImport.local.name, {
+                exportNames,
+                moduleSpecifier: node.source.value,
+                node: namespaceImport,
+                variable,
+            });
+        }
+        function buildNamespaceToNamedFix(fixer, usage) {
+            const importDecl = usage.node.parent;
+            if (importDecl.specifiers.length !== 1) {
+                return null;
+            }
+            const memberNames = new Set();
+            const memberNodes = [];
+            for (const ref of usage.variable.references) {
+                const parent = ref.identifier.parent;
+                if (parent.type !== dist$3.AST_NODE_TYPES.MemberExpression ||
+                    parent.object !== ref.identifier ||
+                    parent.computed) {
+                    return null;
+                }
+                const memberName = getMemberExpressionPropertyName(parent);
+                if (!memberName || memberName === 'default') {
+                    return null;
+                }
+                memberNames.add(memberName);
+                memberNodes.push(parent);
+            }
+            if (memberNames.size === 0) {
+                return null;
+            }
+            const sourceText = sourceCode.getText(importDecl.source);
+            const hasSemi = sourceCode.getText(importDecl).endsWith(';');
+            const sortedMembers = [...memberNames].sort();
+            const newImportText = `import {${sortedMembers.join(', ')}} from ${sourceText}${hasSemi ? ';' : ''}`;
+            return [
+                fixer.replaceText(importDecl, newImportText),
+                ...memberNodes.flatMap((memberNode) => {
+                    const name = getMemberExpressionPropertyName(memberNode);
+                    return name ? [fixer.replaceText(memberNode, name)] : [];
+                }),
+            ];
+        }
+        function checkNamespaceMember(node) {
+            if (!checkNamespaceMembers ||
+                node.object.type !== dist$3.AST_NODE_TYPES.Identifier) {
+                return;
+            }
+            const usage = namespaceImports.get(node.object.name);
+            const memberName = getMemberExpressionPropertyName(node);
+            if (!usage ||
+                !memberName ||
+                usage.exportNames.has(memberName) ||
+                getResolvedVariable(sourceCode, node.object) !== usage.variable) {
+                return;
+            }
+            context.report({
+                data: {
+                    memberName,
+                    moduleSpecifier: usage.moduleSpecifier,
+                    namespaceName: usage.node.local.name,
+                },
+                fix: (fixer) => buildNamespaceToNamedFix(fixer, usage),
+                messageId: 'unknownNamespaceMember',
+                node: node.property,
+            });
+        }
+        return {
+            ExportAllDeclaration: checkImportCycle,
+            ExportNamedDeclaration(node) {
+                checkImportCycle(node);
+                checkNamedAsDefaultExport(node);
+            },
+            ImportDeclaration(node) {
+                checkImportCycle(node);
+                checkDefaultImport(node);
+                collectNamespaceImport(node);
+            },
+            MemberExpression: checkNamespaceMember,
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Fast replacement for import/default, import/namespace, import/no-cycle, and import/no-named-as-default checks',
+        },
+        fixable: 'code',
+        messages: {
+            importCycle: 'Import cycle detected: {{cyclePath}}.',
+            missingDefaultExport: 'No default export found in "{{moduleSpecifier}}".',
+            namedAsDefault: 'Using exported name "{{name}}" as identifier for default export.',
+            unknownNamespaceMember: 'Namespace import "{{namespaceName}}" from "{{moduleSpecifier}}" has no exported member "{{memberName}}".',
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    checkCycles: {
+                        description: 'Report static project-local import and re-export cycles. Defaults to true.',
+                        type: 'boolean',
+                    },
+                    checkDefaultImports: {
+                        description: 'Report default imports from modules without a default export. Defaults to true.',
+                        type: 'boolean',
+                    },
+                    checkNamedAsDefault: {
+                        description: 'Report default imports and default re-exports named after a named export from the same module. Defaults to true.',
+                        type: 'boolean',
+                    },
+                    checkNamespaceMembers: {
+                        description: 'Report static namespace import member accesses that are not exported by the imported module. Defaults to true.',
+                        type: 'boolean',
+                    },
+                    ignoreExternalDefaultImports: {
+                        description: 'Skip default import checks for modules resolved from external libraries. Defaults to true.',
+                        type: 'boolean',
+                    },
+                },
+                type: 'object',
+            },
+        ],
+        type: 'problem',
+    },
+    name: 'import-integrity',
+});
+
+const MESSAGE_ID$e = 'invalid-injection-token-description';
+const ERROR_MESSAGE$3 = "InjectionToken's description should contain token's name";
+const NG_DEV_MODE = 'ngDevMode';
+function getVariableName(node) {
+    if (node.parent.type !== dist$2.AST_NODE_TYPES.VariableDeclarator) {
+        return undefined;
+    }
+    const { id } = node.parent;
+    return id.type === dist$2.AST_NODE_TYPES.Identifier ? id.name : undefined;
+}
+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 || '';
+}
+function isEmptyString(node) {
+    return (isEmptyStaticString(node) &&
+        (!('expressions' in node) || node.expressions.length === 0));
+}
+function isNgDevModeConditional(node) {
+    return (node.type === dist$2.AST_NODE_TYPES.ConditionalExpression &&
+        node.test.type === dist$2.AST_NODE_TYPES.Identifier &&
+        node.test.name === NG_DEV_MODE &&
+        isStringLike(node.consequent) &&
+        isStringLike(node.alternate) &&
+        isEmptyString(node.alternate));
+}
+function getDescriptionValue(node) {
+    if (isStringLike(node)) {
+        return getStringValue(node);
+    }
+    if (isNgDevModeConditional(node)) {
+        return getStringValue(node.consequent);
+    }
+    return undefined;
+}
+function getDescriptionNode(node) {
+    if (isStringLike(node)) {
+        return node;
+    }
+    return isNgDevModeConditional(node) ? node.consequent : undefined;
+}
+function prependTokenName(text, name) {
+    return `${text.slice(0, 1)}[${name}]: ${text.slice(1)}`;
+}
+function isNgDevModeVisible(sourceCode, node) {
+    for (let scope = sourceCode.getScope(node); scope !== null; scope = scope.upper) {
+        if (scope.variables.some((variable) => variable.name === NG_DEV_MODE)) {
+            return true;
+        }
+    }
+    return false;
+}
+function getNgDevModeDeclarationFix(program, fixer) {
+    const lastImport = [...program.body]
+        .reverse()
+        .find((statement) => statement.type === dist$2.AST_NODE_TYPES.ImportDeclaration);
+    if (lastImport) {
+        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');
+}
+const rule$J = createRule({
+    create(context) {
+        const { sourceCode } = context;
+        const program = sourceCode.ast;
+        let shouldAddNgDevModeDeclaration = true;
+        return {
+            'NewExpression[callee.name="InjectionToken"]'(node) {
+                const [description] = node.arguments;
+                if (!description || description.type === dist$2.AST_NODE_TYPES.SpreadElement) {
+                    return;
+                }
+                const name = getVariableName(node);
+                const token = getDescriptionValue(description);
+                const fixedDescription = getDescriptionNode(description);
+                const report = name && token && !token.includes(name);
+                if (report && fixedDescription) {
+                    context.report({
+                        fix: (fixer) => {
+                            const isNgDevModeGuarded = isNgDevModeConditional(description);
+                            const fixes = [
+                                fixer.replaceText(isNgDevModeGuarded ? fixedDescription : description, isNgDevModeGuarded
+                                    ? prependTokenName(sourceCode.getText(fixedDescription), name)
+                                    : `${NG_DEV_MODE} ? ${prependTokenName(sourceCode.getText(fixedDescription), name)} : ''`),
+                            ];
+                            if (!isNgDevModeGuarded &&
+                                shouldAddNgDevModeDeclaration &&
+                                !isNgDevModeVisible(sourceCode, description)) {
+                                shouldAddNgDevModeDeclaration = false;
+                                fixes.unshift(getNgDevModeDeclarationFix(program, fixer));
+                            }
+                            return fixes;
+                        },
+                        messageId: MESSAGE_ID$e,
+                        node: description,
+                    });
+                }
+            },
+        };
+    },
+    meta: {
+        docs: { description: ERROR_MESSAGE$3 },
+        fixable: 'code',
+        messages: { [MESSAGE_ID$e]: ERROR_MESSAGE$3 },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'injection-token-description',
+});
+
+const rule$I = createRule({
+    create(context) {
+        const { sourceCode } = context;
+        const namespaceImports = new Map();
+        const markNamespaceImportAsUsedLikeValue = (identifier) => {
+            const usage = namespaceImports.get(identifier.name);
+            if (!usage ||
+                usage.usedLikeValue ||
+                getResolvedVariable(sourceCode, identifier) !== usage.variable) {
+                return;
+            }
+            usage.usedLikeValue = true;
+        };
+        return {
+            'CallExpression > Identifier.callee'(node) {
+                markNamespaceImportAsUsedLikeValue(node);
+            },
+            ImportDeclaration(node) {
+                const namespaceImport = node.specifiers.find((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportNamespaceSpecifier);
+                if (!namespaceImport) {
+                    return;
+                }
+                const [variable] = sourceCode.getDeclaredVariables(namespaceImport);
+                if (!variable) {
+                    return;
+                }
+                namespaceImports.set(namespaceImport.local.name, {
+                    node: namespaceImport,
+                    usedLikeValue: false,
+                    variable,
+                });
+            },
+            'NewExpression > Identifier.callee'(node) {
+                markNamespaceImportAsUsedLikeValue(node);
+            },
+            'Program:exit'() {
+                for (const usage of namespaceImports.values()) {
+                    if (!usage.usedLikeValue) {
+                        continue;
+                    }
+                    context.report({
+                        data: { name: usage.node.local.name },
+                        messageId: 'avoidCallableNamespaceImport',
+                        node: usage.node,
+                    });
+                }
+            },
+            'TaggedTemplateExpression > Identifier.tag'(node) {
+                markNamespaceImportAsUsedLikeValue(node);
+            },
+            TSImportEqualsDeclaration(node) {
+                if (node.moduleReference.type !== dist$3.AST_NODE_TYPES.TSExternalModuleReference) {
+                    return;
+                }
+                context.report({
+                    data: { name: node.id.name },
+                    messageId: 'avoidImportEquals',
+                    node,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow legacy CommonJS interop import patterns such as `import = require(...)` and namespace imports used like callable values.',
+        },
+        messages: {
+            avoidCallableNamespaceImport: 'Namespace import "{{name}}" is used like a value instead of a namespace. This is a brittle interop pattern and often should become a default import.',
+            avoidImportEquals: '`import {{name}} = require(...)` is a legacy CommonJS import pattern.',
+        },
+        schema: [],
+        type: 'problem',
+    },
+    name: 'no-commonjs-import-patterns',
+});
+
+const MESSAGE_ID$d = 'no-deep-imports';
+const ERROR_MESSAGE$2 = 'Deep imports of Taiga UI packages are prohibited';
+const CODE_EXTENSIONS = new Set([
+    '.cjs',
+    '.cts',
+    '.js',
+    '.jsx',
+    '.mjs',
+    '.mts',
+    '.ts',
+    '.tsx',
+]);
+const DEFAULT_OPTIONS = {
+    currentProject: '',
+    deepImport: String.raw `(?<=^@taiga-ui/[\w-]+)(/.+)$`,
+    ignoreImports: [],
+    importDeclaration: '^@taiga-ui*',
+    projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
+};
+const rule$H = createRule({
+    create(context) {
+        const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
+        const hasNonCodeExtension = (source) => {
+            if (!source) {
+                return false;
+            }
+            const cleanSource = source.split(/[?#]/, 1)[0] ?? '';
+            const extension = path.posix.extname(cleanSource).toLowerCase();
+            return !!extension && !CODE_EXTENSIONS.has(extension);
+        };
+        const isDeepImport = (source) => !!source && new RegExp(deepImport, 'g').test(source);
+        const isSideEffectImport = (node) => node.specifiers.length === 0;
+        const isInsideTheSameEntryPoint = (source) => {
+            const filePath = path
+                .relative(context.cwd, context.filename)
+                .replaceAll(/\\+/g, '/');
+            const [currentFileProjectName] = (currentProject && new RegExp(currentProject, 'g').exec(filePath)) ?? [];
+            const [importSourceProjectName] = source?.match(new RegExp(projectName, 'g')) ?? [];
+            return Boolean(currentFileProjectName &&
+                importSourceProjectName &&
+                currentFileProjectName === importSourceProjectName);
+        };
+        const shouldIgnore = (source) => !!source && ignoreImports.some((p) => new RegExp(p, 'g').test(source));
+        return {
+            [`ImportDeclaration[source.value=/${importDeclaration}/]`](node) {
+                if (!node || isSideEffectImport(node)) {
+                    return;
+                }
+                const importSource = node.source.value;
+                if (!importSource ||
+                    !isDeepImport(importSource) ||
+                    isInsideTheSameEntryPoint(importSource) ||
+                    shouldIgnore(importSource) ||
+                    hasNonCodeExtension(importSource)) {
+                    return;
+                }
+                context.report({
+                    fix: (fixer) => {
+                        const [start, end] = node.source.range;
+                        return fixer.replaceTextRange([start + 1, end - 1], importSource.replaceAll(new RegExp(deepImport, 'g'), ''));
+                    },
+                    messageId: MESSAGE_ID$d,
+                    node: node.source,
+                });
+            },
+        };
+    },
+    meta: {
+        defaultOptions: [DEFAULT_OPTIONS],
+        docs: { description: ERROR_MESSAGE$2 },
+        fixable: 'code',
+        messages: { [MESSAGE_ID$d]: ERROR_MESSAGE$2 },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    currentProject: {
+                        description: 'RegExp string to pick out current project name of processed file',
+                        type: 'string',
+                    },
+                    deepImport: {
+                        description: 'RegExp string to pick out deep import part',
+                        type: 'string',
+                    },
+                    ignoreImports: {
+                        description: 'RegExp string to exclude import declarations which is selected by importDeclaration-option',
+                        items: { type: 'string' },
+                        type: 'array',
+                    },
+                    importDeclaration: {
+                        description: 'RegExp string to detect import declarations for which this rule should be applied',
+                        type: 'string',
+                    },
+                    projectName: {
+                        description: 'RegExp string to extract project name from import',
+                        type: 'string',
+                    },
+                },
+                type: 'object',
+            },
+        ],
+        type: 'problem',
+    },
+    name: 'no-deep-imports',
+});
+
 const resolveCacheByOptions = new WeakMap();
 const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-const rule$E = createRule({
+const rule$G = createRule({
     create(context) {
         const parserServices = dist$3.ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -248149,13 +248891,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$D = createRule({
+const rule$F = createRule({
     name: 'no-duplicate-attrs',
     rule: noDuplicateAttributesRule,
 });
 
 const MESSAGE_ID$c = 'duplicateId';
-const rule$C = createRule({
+const rule$E = createRule({
     name: 'no-duplicate-id',
     rule: {
         create(context) {
@@ -248217,7 +248959,7 @@ function getTrackingKey(node) {
     }
     return null;
 }
-const rule$B = createRule({
+const rule$D = createRule({
     name: 'no-duplicate-in-head',
     rule: {
         create(context) {
@@ -248802,21 +249544,7 @@ const ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL = 'https://angular.dev/guide/signals#r
 const ANGULAR_SIGNALS_ASYNC_GUIDE_URL = 'https://angular.dev/guide/signals#reactive-context-and-async-operations';
 const createUntrackedRule = createRule;
 
-function getTypeAwareRuleContext(context) {
-    const parserServices = dist$3.ESLintUtils.getParserServices(context);
-    const { sourceCode } = context;
-    return {
-        checker: parserServices.program.getTypeChecker(),
-        esTreeNodeToTSNodeMap: parserServices.esTreeNodeToTSNodeMap,
-        parserServices,
-        program: sourceCode.ast,
-        sourceCode,
-        tsNodeToESTreeNodeMap: parserServices.tsNodeToESTreeNodeMap,
-        tsProgram: parserServices.program,
-    };
-}
-
-const rule$A = createUntrackedRule({
+const rule$C = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -248889,7 +249617,7 @@ const config$3 = {
         type: 'problem',
     },
 };
-const rule$z = createRule({
+const rule$B = createRule({
     name: 'no-href-with-router-link',
     rule: config$3,
 });
@@ -248950,7 +249678,7 @@ function getScopeRoot(node) {
     return (findAncestor(node, (ancestor) => ancestor.type === dist$3.AST_NODE_TYPES.Program || isFunctionLike(ancestor)) ?? node);
 }
 
-const rule$y = createRule({
+const rule$A = createRule({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getEnclosingClass(node);
@@ -249012,7 +249740,7 @@ const rule$y = createRule({
     name: 'no-implicit-public',
 });
 
-const rule$x = createRule({
+const rule$z = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -249070,7 +249798,7 @@ function isInfiniteLoopLiteral(node) {
 function isInfiniteLoopTest(test) {
     return test === null || isInfiniteLoopLiteral(test);
 }
-const rule$w = createRule({
+const rule$y = createRule({
     create(context) {
         return {
             DoWhileStatement(node) {
@@ -249115,7 +249843,7 @@ const rule$w = createRule({
 });
 
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$v = createRule({
+const rule$x = createRule({
     create(context) {
         return {
             Program(node) {
@@ -249575,7 +250303,7 @@ const OBSOLETE_HTML_ATTRS = {
 };
 
 const MESSAGE_ID$9 = 'obsolete';
-const rule$u = createRule({
+const rule$w = createRule({
     name: 'no-obsolete-attrs',
     rule: {
         create(context) {
@@ -249653,7 +250381,7 @@ const OBSOLETE_HTML_TAGS = new Set([
 ]);
 
 const MESSAGE_ID$8 = 'unexpected';
-const rule$t = createRule({
+const rule$v = createRule({
     name: 'no-obsolete-tags',
     rule: {
         create(context) {
@@ -249680,7 +250408,7 @@ const rule$t = createRule({
     },
 });
 
-const rule$s = createRule({
+const rule$u = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
         return {
@@ -249824,7 +250552,7 @@ const config$2 = {
         type: 'problem',
     },
 };
-const rule$r = createRule({
+const rule$t = createRule({
     name: 'no-project-as-in-ng-template',
     rule: config$2,
 });
@@ -249861,7 +250589,7 @@ function collectArrayExpressions(node) {
     }
     return result;
 }
-const rule$q = createRule({
+const rule$s = createRule({
     create(context) {
         const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const ignoreTupleContextualTyping = context.options[0]?.ignoreTupleContextualTyping ?? true;
@@ -249956,6 +250684,177 @@ const rule$q = createRule({
     name: 'no-redundant-type-annotation',
 });
 
+function isNullableCallType(call, checker, nodeMap) {
+    try {
+        const tsNode = nodeMap.get(call);
+        if (!tsNode) {
+            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)));
+    }
+    catch {
+        return false;
+    }
+}
+function getCalleeName(node) {
+    const { callee } = node;
+    if (callee.type === dist$3.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === dist$3.AST_NODE_TYPES.Identifier) {
+        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';
+}
+function findParentStatement(node) {
+    for (let current = node; current.parent; current = current.parent) {
+        if (isFunctionLike(current)) {
+            return null;
+        }
+        if (current.parent.type === dist$3.AST_NODE_TYPES.BlockStatement ||
+            current.parent.type === dist$3.AST_NODE_TYPES.Program) {
+            return current;
+        }
+    }
+    return null;
+}
+function findConciseArrowAncestor(node) {
+    for (let current = node; current.parent; current = current.parent) {
+        const { parent } = current;
+        if (parent.type === dist$3.AST_NODE_TYPES.ArrowFunctionExpression &&
+            parent.body.type !== dist$3.AST_NODE_TYPES.BlockStatement) {
+            return parent;
+        }
+        if (isFunctionLike(parent)) {
+            return null;
+        }
+    }
+    return null;
+}
+function getArrowBodyIndent(arrowFn, sourceText) {
+    const arrowStart = arrowFn.range[0];
+    const lineStart = sourceText.lastIndexOf('\n', arrowStart - 1) + 1;
+    const textBeforeArrow = sourceText.slice(lineStart, arrowStart);
+    const outerIndent = /^(\s*)/.exec(textBeforeArrow)?.[1] ?? '';
+    return { innerIndent: `${outerIndent}    `, outerIndent };
+}
+function getStatementIndent(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$r = createRule({
+    create(context) {
+        const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
+        const signalNodeMap = esTreeNodeToTSNodeMap;
+        function checkNode(node) {
+            const callsByText = new Map();
+            walkAst(node, (child) => {
+                if (child === node) {
+                    return;
+                }
+                if (child.type === dist$3.AST_NODE_TYPES.ConditionalExpression ||
+                    child.type === dist$3.AST_NODE_TYPES.IfStatement ||
+                    isFunctionLike(child)) {
+                    return false;
+                }
+                if (child.type === dist$3.AST_NODE_TYPES.CallExpression &&
+                    isSignalReadCall(child, checker, signalNodeMap) &&
+                    isNullableCallType(child, checker, signalNodeMap)) {
+                    const text = sourceCode.getText(child);
+                    const list = callsByText.get(text) ?? [];
+                    list.push(child);
+                    callsByText.set(text, list);
+                }
+                return;
+            });
+            for (const [callText, calls] of callsByText) {
+                if (calls.length < 2) {
+                    continue;
+                }
+                const firstCall = calls[0];
+                if (!firstCall) {
+                    continue;
+                }
+                context.report({
+                    data: { call: callText },
+                    fix(fixer) {
+                        const varName = getCalleeName(firstCall);
+                        const parentStatement = findParentStatement(node);
+                        if (parentStatement) {
+                            const indent = getStatementIndent(parentStatement, sourceCode.text);
+                            const fixes = [
+                                fixer.insertTextBefore(parentStatement, `const ${varName} = ${callText};\n\n${indent}`),
+                            ];
+                            for (const call of calls) {
+                                const { parent } = call;
+                                const target = parent.type === dist$3.AST_NODE_TYPES.TSAsExpression
+                                    ? parent
+                                    : call;
+                                fixes.push(fixer.replaceText(target, varName));
+                            }
+                            return fixes;
+                        }
+                        const arrowFn = findConciseArrowAncestor(node);
+                        if (!arrowFn) {
+                            return null;
+                        }
+                        const arrowBody = arrowFn.body;
+                        const { innerIndent, outerIndent } = getArrowBodyIndent(arrowFn, sourceCode.text);
+                        const bodyText = sourceCode.getText(arrowBody);
+                        const bodyStart = arrowBody.range[0];
+                        const targets = calls
+                            .map((call) => {
+                            const { parent } = call;
+                            return parent.type === dist$3.AST_NODE_TYPES.TSAsExpression
+                                ? parent
+                                : call;
+                        })
+                            .sort((a, b) => a.range[0] - b.range[0]);
+                        let replacedBody = '';
+                        let lastIndex = 0;
+                        for (const target of targets) {
+                            const start = target.range[0] - bodyStart;
+                            const end = target.range[1] - bodyStart;
+                            replacedBody += `${bodyText.slice(lastIndex, start)}${varName}`;
+                            lastIndex = end;
+                        }
+                        replacedBody += bodyText.slice(lastIndex);
+                        const newBody = `{\n${innerIndent}const ${varName} = ${callText};\n\n${innerIndent}return ${replacedBody};\n${outerIndent}}`;
+                        return [fixer.replaceText(arrowBody, newBody)];
+                    },
+                    messageId: 'noRepeatedSignalInConditional',
+                    node: firstCall,
+                });
+            }
+        }
+        return {
+            ConditionalExpression: checkNode,
+            IfStatement: checkNode,
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Disallow reading the same nullable Angular signal more than once in a conditional (ternary or if) expression; extract it to a const variable instead',
+        },
+        fixable: 'code',
+        messages: {
+            noRepeatedSignalInConditional: 'Signal `{{call}}` is read multiple times in this conditional; extract it to a const variable',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'no-repeated-signal-in-conditional',
+});
+
 /**
  * Strips TypeScript-only wrapper nodes that have no runtime meaning:
  * `as` casts, non-null assertions (`!`), type assertions (`<T>expr`), and
@@ -250286,7 +251185,7 @@ function inspectComputedBody(root, context, localScopes, visitedFunctions, repor
         return;
     });
 }
-const rule$p = createRule({
+const rule$q = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode, tsNodeToESTreeNodeMap, } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -250329,7 +251228,7 @@ const rule$p = createRule({
     name: 'no-side-effects-in-computed',
 });
 
-const rule$o = createUntrackedRule({
+const rule$p = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -250423,7 +251322,7 @@ function templateContent(template, renderExpr) {
         : ''}`)
         .join('');
 }
-const rule$n = createRule({
+const rule$o = createRule({
     create(context) {
         const { sourceCode } = context;
         let parserServices = null;
@@ -250758,7 +251657,7 @@ function buildReactiveCallReplacement(outerUntrackedCall, reactiveCall, sourceCo
     }
     return dedent(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
 }
-const rule$m = createUntrackedRule({
+const rule$n = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -250887,7 +251786,7 @@ function hasOpaqueSynchronousCalls(root, checker, esTreeNodeToTSNodeMap, program
     });
     return found;
 }
-const rule$l = createUntrackedRule({
+const rule$m = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -250969,7 +251868,7 @@ const rule$l = createUntrackedRule({
     name: 'no-useless-untracked',
 });
 
-const rule$k = createRule({
+const rule$l = createRule({
     create(context, [{ printWidth }]) {
         const sourceCode = context.sourceCode;
         const getLineEndIndex = (lineStartIndex) => {
@@ -251290,7 +252189,7 @@ function renderTest(node, sourceCode) {
     const text = sourceCode.getText(node);
     return needsParenthesesInOrChain(node) ? `(${text})` : text;
 }
-const rule$j = createRule({
+const rule$k = createRule({
     create(context) {
         const { sourceCode } = context;
         function checkBody(statements) {
@@ -251393,7 +252292,7 @@ function getPushCall(node) {
     }
     return call;
 }
-const rule$i = createRule({
+const rule$j = createRule({
     create(context) {
         const { sourceCode } = context;
         function checkBody(statements) {
@@ -251487,7 +252386,7 @@ function getModuleKeywordToken(sourceCode, node) {
     }
     return firstToken;
 }
-const rule$h = createRule({
+const rule$i = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -251757,7 +252656,7 @@ function collectSuspiciousReads(scope, checker, esTreeNodeToTSNodeMap, tsNodeToE
     });
     return [...suspicious.values()];
 }
-const rule$g = createUntrackedRule({
+const rule$h = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode, tsNodeToESTreeNodeMap, } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251845,7 +252744,7 @@ function getWrappedSignalGetter(node, checker, esTreeNodeToTSNodeMap) {
     }
     return isSignalType(getter, checker, esTreeNodeToTSNodeMap) ? body.callee : null;
 }
-const rule$f = createUntrackedRule({
+const rule$g = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251891,7 +252790,7 @@ const DOUBLE_QUOTE = '"';
 function isQuotableAttribute(attr) {
     return 'sourceSpan' in attr;
 }
-const rule$e = createRule({
+const rule$f = createRule({
     name: 'quotes',
     rule: {
         create(context) {
@@ -251976,7 +252875,7 @@ const rule$e = createRule({
 
 const MESSAGE_ID$6 = 'missing';
 const DOCTYPE_REGEXP = /^\s*<!doctype html>/i;
-const rule$d = createRule({
+const rule$e = createRule({
     name: 'require-doctype',
     rule: {
         create(context) {
@@ -252014,7 +252913,7 @@ function hasAlt(node) {
     return (node.attributes.some((attr) => attr.name === 'alt') ||
         node.inputs.some((input) => input.name === 'alt' || input.keySpan.details === 'attr.alt'));
 }
-const rule$c = createRule({
+const rule$d = createRule({
     name: 'require-img-alt',
     rule: {
         create(context) {
@@ -252044,7 +252943,7 @@ const MESSAGE_IDS$1 = {
     EMPTY: 'empty',
     MISSING: 'missing',
 };
-const rule$b = createRule({
+const rule$c = createRule({
     name: 'require-lang',
     rule: {
         create(context) {
@@ -252108,7 +253007,7 @@ function getClosestParentElement(node) {
     }
     return null;
 }
-const rule$a = createRule({
+const rule$b = createRule({
     name: 'require-li-container',
     rule: {
         create(context) {
@@ -252156,7 +253055,7 @@ function hasMeaningfulTitleContent(node) {
             (typeof value === 'string' && value.trim().length > 0));
     });
 }
-const rule$9 = createRule({
+const rule$a = createRule({
     name: 'require-title',
     rule: {
         create(context) {
@@ -252239,7 +253138,7 @@ const DEFAULT_EXCEPTIONS = [
     { from: 'TuiIslandDirective', to: 'TuiIsland' },
     { from: 'TuiTableBarsHostComponent', to: 'TuiTableBarsHost' },
 ];
-const rule$8 = createRule({
+const rule$9 = createRule({
     create(context, [{ decorators = DEFAULT_DECORATORS, exceptions = DEFAULT_EXCEPTIONS }]) {
         const sourceCode = context.getSourceCode();
         const importedFromTaiga = {};
@@ -252395,17 +253294,6 @@ const rule$8 = createRule({
     name: 'short-tui-imports',
 });
 
-function isFieldLikeMember(member) {
-    return (member.type === dist$3.AST_NODE_TYPES.PropertyDefinition ||
-        member.type === dist$3.AST_NODE_TYPES.TSAbstractPropertyDefinition);
-}
-function isAccessorMember(member) {
-    return (member.type === dist$3.AST_NODE_TYPES.MethodDefinition &&
-        (member.kind === 'get' || member.kind === 'set'));
-}
-function isRelevantSpacingClassMember(member) {
-    return isFieldLikeMember(member) || isAccessorMember(member);
-}
 function isSingleLineNode(node) {
     return node.loc.start.line === node.loc.end.line;
 }
@@ -252447,12 +253335,26 @@ function getLeadingIndentation(text) {
     }
     return text.slice(0, index);
 }
+function getSpacingReplacement(sourceCode, betweenText, nextLine, blankLineCount) {
+    const indentation = getLeadingIndentation(sourceCode.lines[nextLine - 1] ?? '');
+    return `${getLineBreak(betweenText).repeat(blankLineCount + 1)}${indentation}`;
+}
 
-const rule$7 = createRule({
+function isFieldLikeMember(member) {
+    return (member.type === dist$3.AST_NODE_TYPES.PropertyDefinition ||
+        member.type === dist$3.AST_NODE_TYPES.TSAbstractPropertyDefinition);
+}
+function isAccessorMember(member) {
+    return (member.type === dist$3.AST_NODE_TYPES.MethodDefinition &&
+        (member.kind === 'get' || member.kind === 'set'));
+}
+function isRelevantSpacingClassMember(member) {
+    return isFieldLikeMember(member) || isAccessorMember(member);
+}
+
+const rule$8 = createRule({
     create(context) {
         const sourceCode = context.sourceCode;
-        const getIndentation = (line) => getLeadingIndentation(sourceCode.lines[line - 1] ?? '');
-        const getSpacingReplacement = (betweenText, nextLine, blankLineCount) => `${getLineBreak(betweenText).repeat(blankLineCount + 1)}${getIndentation(nextLine)}`;
         return {
             ClassBody(node) {
                 for (let index = 0; index < node.body.length - 1; index++) {
@@ -252477,7 +253379,7 @@ const rule$7 = createRule({
                         isSingleLineNode(next) &&
                         blankLineBetween) {
                         context.report({
-                            fix: (fixer) => fixer.replaceTextRange([current.range[1], next.range[0]], getSpacingReplacement(betweenText, next.loc.start.line, 0)),
+                            fix: (fixer) => fixer.replaceTextRange([current.range[1], next.range[0]], getSpacingReplacement(sourceCode, betweenText, next.loc.start.line, 0)),
                             messageId: 'unexpectedBlankLineBeforeNextSingleLineField',
                             node: next,
                         });
@@ -252485,7 +253387,7 @@ const rule$7 = createRule({
                     }
                     if (needsSeparatedLine && !blankLineBetween) {
                         context.report({
-                            fix: (fixer) => fixer.replaceTextRange([current.range[1], next.range[0]], getSpacingReplacement(betweenText, next.loc.start.line, 1)),
+                            fix: (fixer) => fixer.replaceTextRange([current.range[1], next.range[0]], getSpacingReplacement(sourceCode, betweenText, next.loc.start.line, 1)),
                             messageId: 'missingBlankLineAroundAccessor',
                             node: next,
                         });
@@ -252497,7 +253399,7 @@ const rule$7 = createRule({
                         !isSingleLineNode(next) &&
                         !blankLineBetween) {
                         context.report({
-                            fix: (fixer) => fixer.replaceTextRange([current.range[1], next.range[0]], getSpacingReplacement(betweenText, next.loc.start.line, 1)),
+                            fix: (fixer) => fixer.replaceTextRange([current.range[1], next.range[0]], getSpacingReplacement(sourceCode, betweenText, next.loc.start.line, 1)),
                             messageId: 'missingBlankLineBeforeMultilineProperty',
                             node: next,
                         });
@@ -252508,7 +253410,7 @@ const rule$7 = createRule({
                         !currentIsSingleLine &&
                         !blankLineBetween) {
                         context.report({
-                            fix: (fixer) => fixer.replaceTextRange([current.range[1], next.range[0]], getSpacingReplacement(betweenText, next.loc.start.line, 1)),
+                            fix: (fixer) => fixer.replaceTextRange([current.range[1], next.range[0]], getSpacingReplacement(sourceCode, betweenText, next.loc.start.line, 1)),
                             messageId: 'missingBlankLineAfterMultilineProperty',
                             node: next,
                         });
@@ -252534,6 +253436,151 @@ const rule$7 = createRule({
     name: 'single-line-class-property-spacing',
 });
 
+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 };
+}
+function isRequireCall(node) {
+    return (node.type === dist$3.AST_NODE_TYPES.CallExpression &&
+        node.callee.type === dist$3.AST_NODE_TYPES.Identifier &&
+        node.callee.name === 'require');
+}
+function isImportLikeInitializer(node) {
+    const initializer = unwrapParenthesized(node);
+    if (initializer.type === dist$3.AST_NODE_TYPES.ImportExpression ||
+        isRequireCall(initializer)) {
+        return true;
+    }
+    if (initializer.type === dist$3.AST_NODE_TYPES.AwaitExpression) {
+        return isImportLikeInitializer(initializer.argument);
+    }
+    if (initializer.type === dist$3.AST_NODE_TYPES.ChainExpression) {
+        return isImportLikeInitializer(initializer.expression);
+    }
+    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;
+}
+function isImportLikeVariableDeclaration(declaration) {
+    if (declaration.declarations.length !== 1) {
+        return false;
+    }
+    const [declarator] = declaration.declarations;
+    const init = declarator.init;
+    if (!init) {
+        return false;
+    }
+    return isImportLikeInitializer(init);
+}
+const rule$7 = createRule({
+    create(context) {
+        const sourceCode = context.sourceCode;
+        const checkStatements = (statements) => {
+            for (let index = 0; index < statements.length - 1; index++) {
+                const currentStatement = statements[index];
+                const nextStatement = statements[index + 1];
+                if (!currentStatement || !nextStatement) {
+                    continue;
+                }
+                const current = getVariableSpacingStatement(currentStatement);
+                const next = getVariableSpacingStatement(nextStatement);
+                if (!current ||
+                    !next ||
+                    isImportLikeVariableDeclaration(current.declaration) ||
+                    isImportLikeVariableDeclaration(next.declaration)) {
+                    continue;
+                }
+                const betweenText = sourceCode.text.slice(current.node.range[1], next.node.range[0]);
+                if (hasCommentLikeText(betweenText)) {
+                    continue;
+                }
+                const currentIsSingleLine = isSingleLineNode(current.node);
+                const nextIsSingleLine = isSingleLineNode(next.node);
+                const blankLineBetween = hasBlankLine(betweenText);
+                const sameExportGroup = current.exported === next.exported;
+                if (currentIsSingleLine &&
+                    nextIsSingleLine &&
+                    sameExportGroup &&
+                    blankLineBetween) {
+                    context.report({
+                        fix: (fixer) => fixer.replaceTextRange([current.node.range[1], next.node.range[0]], getSpacingReplacement(sourceCode, betweenText, next.node.loc.start.line, 0)),
+                        messageId: 'unexpectedBlankLineBeforeNextSingleLineVariable',
+                        node: next.node,
+                    });
+                    continue;
+                }
+                if (currentIsSingleLine &&
+                    nextIsSingleLine &&
+                    !sameExportGroup &&
+                    !blankLineBetween) {
+                    context.report({
+                        fix: (fixer) => fixer.replaceTextRange([current.node.range[1], next.node.range[0]], getSpacingReplacement(sourceCode, betweenText, next.node.loc.start.line, 1)),
+                        messageId: 'missingBlankLineBetweenVariableGroups',
+                        node: next.node,
+                    });
+                }
+                if (currentIsSingleLine && !nextIsSingleLine && !blankLineBetween) {
+                    context.report({
+                        fix: (fixer) => fixer.replaceTextRange([current.node.range[1], next.node.range[0]], getSpacingReplacement(sourceCode, betweenText, next.node.loc.start.line, 1)),
+                        messageId: 'missingBlankLineBeforeMultilineVariable',
+                        node: next.node,
+                    });
+                    continue;
+                }
+                if (!currentIsSingleLine && !blankLineBetween) {
+                    context.report({
+                        fix: (fixer) => fixer.replaceTextRange([current.node.range[1], next.node.range[0]], getSpacingReplacement(sourceCode, betweenText, next.node.loc.start.line, 1)),
+                        messageId: 'missingBlankLineAfterMultilineVariable',
+                        node: next.node,
+                    });
+                }
+            }
+        };
+        return {
+            BlockStatement(node) {
+                checkStatements(node.body);
+            },
+            Program(node) {
+                checkStatements(node.body);
+            },
+            StaticBlock(node) {
+                checkStatements(node.body);
+            },
+            SwitchCase(node) {
+                checkStatements(node.consequent);
+            },
+            TSModuleBlock(node) {
+                checkStatements(node.body);
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Group consecutive single-line variable declarations together, while separating multiline variable declarations with blank lines',
+        },
+        fixable: 'code',
+        messages: {
+            missingBlankLineAfterMultilineVariable: 'Multiline variable declarations should be followed by a blank line before the next variable declaration',
+            missingBlankLineBeforeMultilineVariable: 'Multiline variable declarations should be preceded by a blank line after single-line variable declarations',
+            missingBlankLineBetweenVariableGroups: 'Exported and non-exported variable declarations should be separated by a blank line',
+            unexpectedBlankLineBeforeNextSingleLineVariable: 'Single-line variable declarations should not be separated by a blank line before the next single-line variable declaration',
+        },
+        schema: [],
+        type: 'layout',
+    },
+    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 &&
@@ -253545,52 +254592,55 @@ const plugin = {
     },
     rules: {
         'array-as-const': rule$5,
-        'attrs-newline': rule$M,
+        'attrs-newline': rule$P,
         'class-property-naming': rule$4,
-        'decorator-key-sort': rule$L,
-        'element-newline': rule$K,
+        'decorator-key-sort': rule$O,
+        'element-newline': rule$N,
         'flat-exports': rule$3,
-        'host-attributes-sort': rule$J,
-        'html-logical-properties': rule$I,
-        'injection-token-description': rule$H,
-        'no-commonjs-import-patterns': rule$G,
-        'no-deep-imports': rule$F,
-        'no-deep-imports-to-indexed-packages': rule$E,
-        'no-duplicate-attrs': rule$D,
-        'no-duplicate-id': rule$C,
-        'no-duplicate-in-head': rule$B,
-        'no-fully-untracked-effect': rule$A,
-        'no-href-with-router-link': rule$z,
-        'no-implicit-public': rule$y,
-        'no-import-assertions': rule$x,
-        'no-infinite-loop': rule$w,
-        'no-legacy-peer-deps': rule$v,
-        'no-obsolete-attrs': rule$u,
-        'no-obsolete-tags': rule$t,
-        'no-playwright-empty-fill': rule$s,
-        'no-project-as-in-ng-template': rule$r,
-        'no-redundant-type-annotation': rule$q,
+        'host-attributes-sort': rule$M,
+        'html-logical-properties': rule$L,
+        'import-integrity': rule$K,
+        'injection-token-description': rule$J,
+        'no-commonjs-import-patterns': rule$I,
+        'no-deep-imports': rule$H,
+        'no-deep-imports-to-indexed-packages': rule$G,
+        'no-duplicate-attrs': rule$F,
+        'no-duplicate-id': rule$E,
+        'no-duplicate-in-head': rule$D,
+        'no-fully-untracked-effect': rule$C,
+        'no-href-with-router-link': rule$B,
+        'no-implicit-public': rule$A,
+        'no-import-assertions': rule$z,
+        'no-infinite-loop': rule$y,
+        'no-legacy-peer-deps': rule$x,
+        'no-obsolete-attrs': rule$w,
+        'no-obsolete-tags': rule$v,
+        'no-playwright-empty-fill': rule$u,
+        'no-project-as-in-ng-template': rule$t,
+        'no-redundant-type-annotation': rule$s,
+        'no-repeated-signal-in-conditional': rule$r,
         'no-restricted-attr-values': rule$2,
-        'no-side-effects-in-computed': rule$p,
-        'no-signal-reads-after-await-in-reactive-context': rule$o,
-        'no-string-literal-concat': rule$n,
-        'no-untracked-outside-reactive-context': rule$m,
-        'no-useless-untracked': rule$l,
-        'object-single-line': rule$k,
-        'prefer-combined-if-control-flow': rule$j,
+        'no-side-effects-in-computed': rule$q,
+        'no-signal-reads-after-await-in-reactive-context': rule$p,
+        'no-string-literal-concat': rule$o,
+        'no-untracked-outside-reactive-context': rule$n,
+        'no-useless-untracked': rule$m,
+        'object-single-line': rule$l,
+        'prefer-combined-if-control-flow': rule$k,
         'prefer-deep-imports': rule$1,
-        'prefer-multi-arg-push': rule$i,
-        'prefer-namespace-keyword': rule$h,
-        'prefer-untracked-incidental-signal-reads': rule$g,
-        'prefer-untracked-signal-getter': rule$f,
-        quotes: rule$e,
-        'require-doctype': rule$d,
-        'require-img-alt': rule$c,
-        'require-lang': rule$b,
-        'require-li-container': rule$a,
-        'require-title': rule$9,
-        'short-tui-imports': rule$8,
-        'single-line-class-property-spacing': rule$7,
+        'prefer-multi-arg-push': rule$j,
+        'prefer-namespace-keyword': rule$i,
+        'prefer-untracked-incidental-signal-reads': rule$h,
+        'prefer-untracked-signal-getter': rule$g,
+        quotes: rule$f,
+        'require-doctype': rule$e,
+        'require-img-alt': rule$d,
+        'require-lang': rule$c,
+        'require-li-container': rule$b,
+        'require-title': rule$a,
+        'short-tui-imports': rule$9,
+        'single-line-class-property-spacing': rule$8,
+        'single-line-variable-spacing': rule$7,
         'standalone-imports-sort': rule$6,
         'strict-tui-doc-example': rule,
     },