@taiga-ui/eslint-plugin-experience-next 0.497.0 → 0.499.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,970 @@ 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?$/;
+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);
+}
+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) {
+                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 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,
+                },
+                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',
+        },
+        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 +248805,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 +248873,7 @@ function getTrackingKey(node) {
     }
     return null;
 }
-const rule$B = createRule({
+const rule$D = createRule({
     name: 'no-duplicate-in-head',
     rule: {
         create(context) {
@@ -248802,21 +249458,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 +249531,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 +249592,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 +249654,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 +249712,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 +249757,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 +250217,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 +250295,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 +250322,7 @@ const rule$t = createRule({
     },
 });
 
-const rule$s = createRule({
+const rule$u = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
         return {
@@ -249824,7 +250466,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 +250503,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 +250598,128 @@ 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 (current.parent.type === dist$3.AST_NODE_TYPES.BlockStatement ||
+            current.parent.type === dist$3.AST_NODE_TYPES.Program) {
+            return current;
+        }
+    }
+    return null;
+}
+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 parentStatement = findParentStatement(node);
+                        if (!parentStatement) {
+                            return null;
+                        }
+                        const varName = getCalleeName(firstCall);
+                        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;
+                    },
+                    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 +251050,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 +251093,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 +251187,7 @@ function templateContent(template, renderExpr) {
         : ''}`)
         .join('');
 }
-const rule$n = createRule({
+const rule$o = createRule({
     create(context) {
         const { sourceCode } = context;
         let parserServices = null;
@@ -250758,7 +251522,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 +251651,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 +251733,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 +252054,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 +252157,7 @@ function getPushCall(node) {
     }
     return call;
 }
-const rule$i = createRule({
+const rule$j = createRule({
     create(context) {
         const { sourceCode } = context;
         function checkBody(statements) {
@@ -251487,7 +252251,7 @@ function getModuleKeywordToken(sourceCode, node) {
     }
     return firstToken;
 }
-const rule$h = createRule({
+const rule$i = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -251757,7 +252521,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 +252609,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 +252655,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 +252740,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 +252778,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 +252808,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 +252872,7 @@ function getClosestParentElement(node) {
     }
     return null;
 }
-const rule$a = createRule({
+const rule$b = createRule({
     name: 'require-li-container',
     rule: {
         create(context) {
@@ -252156,7 +252920,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) {
@@ -252223,7 +252987,7 @@ function isImportsArrayProperty(property) {
     return isProperty && hasIdentifierKey && isArray(property.value);
 }
 
-function getImportedName(spec) {
+function getImportedName$1(spec) {
     if (spec.imported.type === dist$3.AST_NODE_TYPES.Identifier) {
         return spec.imported.name;
     }
@@ -252239,7 +253003,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 = {};
@@ -252297,7 +253061,7 @@ const rule$8 = createRule({
                             const specifierNames = importDeclaration.specifiers
                                 .filter((clause) => clause.type === dist$3.AST_NODE_TYPES.ImportSpecifier &&
                                 clause.importKind !== 'type')
-                                .map((specifier) => getImportedName(specifier));
+                                .map((specifier) => getImportedName$1(specifier));
                             const nextNames = new Set(specifierNames);
                             nextNames.add(short);
                             if (shouldDeleteImport) {
@@ -252307,7 +253071,7 @@ const rule$8 = createRule({
                                 .filter((clause) => clause.type === dist$3.AST_NODE_TYPES.ImportSpecifier &&
                                 (clause.importKind === 'type' ||
                                     importDeclaration.importKind === 'type'))
-                                .map((specifier) => `type ${getImportedName(specifier)}`);
+                                .map((specifier) => `type ${getImportedName$1(specifier)}`);
                             const allNames = [...typeImports, ...[...nextNames].sort()];
                             const newImport = `import { ${allNames.join(', ')} } from '${module}';`;
                             const alreadyHasShort = imports.some((id) => id.name === short);
@@ -252338,7 +253102,7 @@ const rule$8 = createRule({
                     if (spec.type !== dist$3.AST_NODE_TYPES.ImportSpecifier) {
                         continue;
                     }
-                    const importedClass = getImportedName(spec);
+                    const importedClass = getImportedName$1(spec);
                     const matchesPattern = /^Tui[A-Z].*(?:Component|Directive)$/.test(importedClass) ||
                         exceptions.some((exception) => exception.from === importedClass);
                     if (matchesPattern) {
@@ -252395,17 +253159,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 +253200,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 +253244,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 +253252,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 +253264,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 +253275,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 +253301,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 &&
@@ -253078,13 +253990,31 @@ const rule$2 = createRule({
 
 const MESSAGE_ID = 'prefer-deep-imports';
 const ERROR_MESSAGE = 'Import via root entry point is prohibited when nested entry points exist';
+const sharedStateByProgram = new WeakMap();
 const rule$1 = createRule({
     create(context, [options]) {
-        const allowedPackages = normalizeImportFilter(options.importFilter);
+        const allowedPackages = new Set(normalizeImportFilter(options.importFilter));
+        if (allowedPackages.size === 0) {
+            return {};
+        }
         const isStrictMode = options.strict ?? false;
-        const parserServices = dist$3.ESLintUtils.getParserServices(context);
-        const program = parserServices.program;
-        const typeChecker = program.getTypeChecker();
+        let state = null;
+        function getState() {
+            if (state) {
+                return state;
+            }
+            const parserServices = dist$3.ESLintUtils.getParserServices(context);
+            const program = parserServices.program;
+            state = {
+                allowedPackages,
+                isStrictMode,
+                program,
+                shared: getSharedState(program),
+                sourceCode: context.sourceCode,
+                typeChecker: program.getTypeChecker(),
+            };
+            return state;
+        }
         return {
             ImportDeclaration(node) {
                 const rawImportPath = node.source.value;
@@ -253093,7 +254023,7 @@ const rule$1 = createRule({
                 }
                 const rootPackageName = getRootPackageName(rawImportPath);
                 if (!rootPackageName ||
-                    !allowedPackages.includes(rootPackageName) ||
+                    !allowedPackages.has(rootPackageName) ||
                     (!isStrictMode &&
                         isAlreadyNestedImport(rawImportPath, rootPackageName))) {
                     return;
@@ -253102,32 +254032,38 @@ const rule$1 = createRule({
                 if (importedSymbols.length === 0) {
                     return;
                 }
-                const currentFileName = context.getFilename();
-                const rootEntryDirectory = resolveRootEntryDirectory(rawImportPath, currentFileName, program);
+                const currentState = getState();
+                const rootEntryDirectory = getCachedRootEntryDirectory({
+                    fromFile: context.getFilename(),
+                    importPath: rawImportPath,
+                    state: currentState,
+                });
                 if (!rootEntryDirectory) {
-                    context.report({
-                        messageId: MESSAGE_ID,
-                        node,
-                    });
                     return;
                 }
-                const nestedEntryPointRelativePaths = findNestedEntryPointRelativePaths(rootEntryDirectory);
+                const nestedEntryPointRelativePaths = getCachedNestedEntryPointRelativePaths(rootEntryDirectory, currentState.shared.nestedEntryPointPathsByRoot);
                 if (nestedEntryPointRelativePaths.length === 0) {
-                    context.report({
-                        messageId: MESSAGE_ID,
-                        node,
-                    });
                     return;
                 }
-                const candidateEntryPointPaths = selectCandidateEntryPointsForMode(nestedEntryPointRelativePaths, isStrictMode);
+                const candidateEntryPointPaths = selectCandidateEntryPointsForMode(nestedEntryPointRelativePaths, currentState.isStrictMode);
                 if (candidateEntryPointPaths.length === 0) {
                     return;
                 }
-                const symbolToEntryPoint = mapSymbolsToEntryPointsUsingTypeChecker(importedSymbols, candidateEntryPointPaths, rootEntryDirectory, program, typeChecker);
+                const symbolToEntryPoint = mapSymbolsToEntryPointsUsingTypeChecker({
+                    candidateEntryPoints: candidateEntryPointPaths,
+                    importedSymbols,
+                    rootEntryDirectory,
+                    state: currentState,
+                });
                 if (symbolToEntryPoint.size === 0) {
                     return;
                 }
-                const newImportBlock = buildRewrittenImports(node, rawImportPath, symbolToEntryPoint);
+                const newImportBlock = buildRewrittenImports({
+                    baseImportPath: rawImportPath,
+                    node,
+                    state: currentState,
+                    symbolToEntryPoint,
+                });
                 context.report({
                     fix(fixer) {
                         return fixer.replaceTextRange(node.range, newImportBlock);
@@ -253152,7 +254088,15 @@ const rule$1 = createRule({
             {
                 additionalProperties: false,
                 properties: {
-                    importFilter: { type: ['string', 'array'] },
+                    importFilter: {
+                        oneOf: [
+                            { type: 'string' },
+                            {
+                                items: { type: 'string' },
+                                type: 'array',
+                            },
+                        ],
+                    },
                     strict: { type: 'boolean' },
                 },
                 type: 'object',
@@ -253162,22 +254106,22 @@ const rule$1 = createRule({
     },
     name: 'prefer-deep-imports',
 });
-/**
- * Normalize "importFilter" option to a flat array of package names.
- * The rule expects concrete package names, not regular expression strings.
- */
+function getSharedState(program) {
+    const cached = sharedStateByProgram.get(program);
+    if (cached) {
+        return cached;
+    }
+    const state = {
+        entryPointBySymbolCache: new Map(),
+        nestedEntryPointPathsByRoot: new Map(),
+        rootEntryDirectoryByImport: new Map(),
+    };
+    sharedStateByProgram.set(program, state);
+    return state;
+}
 function normalizeImportFilter(importFilter) {
-    return Array.isArray(importFilter) ? importFilter : [importFilter];
+    return (Array.isArray(importFilter) ? importFilter : [importFilter]).filter(Boolean);
 }
-/**
- * Extract the package root name from an import specifier.
- *
- * Examples:
- *  "@taiga-ui/core"               → "@taiga-ui/core"
- *  "@taiga-ui/core/components"   → "@taiga-ui/core"
- *  "some-lib"                    → "some-lib"
- *  "some-lib/utils"              → "some-lib"
- */
 function getRootPackageName(importPath) {
     if (importPath.startsWith('@')) {
         const segments = importPath.split('/');
@@ -253189,15 +254133,6 @@ function getRootPackageName(importPath) {
     const parts = importPath.split('/');
     return parts[0] ?? null;
 }
-/**
- * Check whether the current import path is already nested below the root package.
- *
- * Example:
- *   root = "@taiga-ui/core"
- *   "@taiga-ui/core"               → false (root import)
- *   "@taiga-ui/core/components"    → true
- *   "@taiga-ui/core/components/x"  → true
- */
 function isAlreadyNestedImport(importPath, rootPackageName) {
     if (!importPath.startsWith(rootPackageName)) {
         return false;
@@ -253206,63 +254141,49 @@ function isAlreadyNestedImport(importPath, rootPackageName) {
     const rootSegments = rootPackageName.split('/');
     return importSegments.length > rootSegments.length;
 }
-/**
- * Extract only named imported symbols:
- *
- * Examples:
- *   import {A, B as C} from 'x';  → ['A', 'B']
- *
- * Namespace imports and default imports are ignored for this rule.
- */
 function extractNamedImportedSymbols(node) {
     return node.specifiers
         .filter((specifier) => specifier.type === dist$2.AST_NODE_TYPES.ImportSpecifier)
-        .map((specifier) => specifier.imported.type === dist$2.AST_NODE_TYPES.Identifier
+        .map(getImportedName);
+}
+function getImportedName(specifier) {
+    return specifier.imported.type === dist$2.AST_NODE_TYPES.Identifier
         ? specifier.imported.name
-        : specifier.imported.value);
+        : specifier.imported.value;
+}
+function getCachedRootEntryDirectory({ fromFile, importPath, state, }) {
+    const cacheKey = `${path.dirname(fromFile)}\0${importPath}`;
+    const cache = state.shared.rootEntryDirectoryByImport;
+    if (cache.has(cacheKey)) {
+        return cache.get(cacheKey) ?? null;
+    }
+    const rootEntryDirectory = resolveRootEntryDirectory({
+        fromFile,
+        importPath,
+        program: state.program,
+    });
+    cache.set(cacheKey, rootEntryDirectory);
+    return rootEntryDirectory;
 }
-/**
- * Resolve the physical directory of the module being imported.
- * We rely on the same module resolution that TypeScript uses for the program.
- */
-function resolveRootEntryDirectory(importPath, fromFile, program) {
-    const compilerOptions = program.getCompilerOptions();
-    const resolution = ts.resolveModuleName(importPath, fromFile, compilerOptions, ts.sys).resolvedModule;
-    if (!resolution) {
-        return null;
+function resolveRootEntryDirectory({ fromFile, importPath, program, }) {
+    const resolution = ts.resolveModuleName(importPath, fromFile, program.getCompilerOptions(), ts.sys).resolvedModule;
+    return resolution ? path.dirname(resolution.resolvedFileName) : null;
+}
+function getCachedNestedEntryPointRelativePaths(rootEntryDirectory, cache) {
+    if (cache.has(rootEntryDirectory)) {
+        return cache.get(rootEntryDirectory) ?? [];
     }
-    return path.dirname(resolution.resolvedFileName);
+    const entryPoints = findNestedEntryPointRelativePaths(rootEntryDirectory);
+    cache.set(rootEntryDirectory, entryPoints);
+    return entryPoints;
 }
-/**
- * Find all nested entry points relative to the given root directory.
- *
- * A directory is considered a nested entry point if it contains either:
- *   - "ng-package.json"  (Angular library entry)
- *   - "collection.json"  (Angular schematics collection)
- *
- * Returned paths are relative to "rootEntryDirectory".
- *
- * Example:
- *   rootEntryDirectory = ".../core/src"
- *   found:
- *     "utils/ng-package.json"          → "utils"
- *     "utils/dom/ng-package.json"      → "utils/dom"
- *     "schematics/collection.json"     → "schematics"
- */
 function findNestedEntryPointRelativePaths(rootEntryDirectory) {
     const files = ['**/ng-package.json', '**/collection.json'].flatMap((pattern) => globSync(pattern, { cwd: rootEntryDirectory }));
-    return files
-        .map((file) => path.dirname(file).replaceAll('\\', '/'))
+    const directories = files
+        .map((file) => path.posix.dirname(file.replaceAll('\\', '/')))
         .filter((directory) => directory && directory !== '.');
+    return [...new Set(directories)];
 }
-/**
- * For strict = false:
- *   Only first-level nested directories are candidates.
- *
- * For strict = true:
- *   All nested directories are candidates, sorted from deepest to shallowest
- *   so that the deepest match wins.
- */
 function selectCandidateEntryPointsForMode(allNestedRelativePaths, strict) {
     if (!strict) {
         return allNestedRelativePaths.filter((relativePath) => !relativePath.includes('/'));
@@ -253273,62 +254194,70 @@ function selectCandidateEntryPointsForMode(allNestedRelativePaths, strict) {
         return depthB - depthA;
     });
 }
-/**
- * Build a map from exported symbol name to nested entry point relative path.
- *
- * Implementation strategy:
- *   1. For each candidate nested entry point:
- *      - Determine its entry file (using ng-package.json or collection.json).
- *      - Ask TypeScript for the module symbol and its exports.
- *   2. For each imported symbol:
- *      - Find the first entry point whose export table contains that symbol.
- *      - strict = true: candidates were sorted deepest-first.
- *      - strict = false: candidates contain only first-level nested entry points.
- */
-function mapSymbolsToEntryPointsUsingTypeChecker(importedSymbols, candidateEntryPoints, rootEntryDirectory, program, typeChecker) {
+function mapSymbolsToEntryPointsUsingTypeChecker({ candidateEntryPoints, importedSymbols, rootEntryDirectory, state, }) {
     const symbolToEntryPoint = new Map();
-    const exportTableByEntryPoint = new Map();
-    for (const relativeEntryDir of candidateEntryPoints) {
-        const entryFile = getEntryFileForNestedEntryPoint(rootEntryDirectory, relativeEntryDir);
-        if (!entryFile) {
-            continue;
-        }
-        const sourceFile = program.getSourceFile(entryFile);
-        if (!sourceFile) {
-            continue;
+    const entryPointBySymbol = getCachedEntryPointBySymbol({
+        candidateEntryPoints,
+        rootEntryDirectory,
+        state,
+    });
+    for (const importedSymbol of importedSymbols) {
+        const entryPoint = entryPointBySymbol.get(importedSymbol);
+        if (entryPoint) {
+            symbolToEntryPoint.set(importedSymbol, entryPoint);
         }
-        const moduleSymbol = typeChecker.getSymbolAtLocation(sourceFile);
-        if (!moduleSymbol) {
+    }
+    return symbolToEntryPoint;
+}
+function getCachedEntryPointBySymbol({ candidateEntryPoints, rootEntryDirectory, state, }) {
+    const cacheKey = `${rootEntryDirectory}\0${candidateEntryPoints.join('\0')}`;
+    const cache = state.shared.entryPointBySymbolCache;
+    if (cache.has(cacheKey)) {
+        return cache.get(cacheKey) ?? new Map();
+    }
+    const entryPointBySymbol = buildEntryPointBySymbolIndex({
+        candidateEntryPoints,
+        rootEntryDirectory,
+        state,
+    });
+    cache.set(cacheKey, entryPointBySymbol);
+    return entryPointBySymbol;
+}
+function buildEntryPointBySymbolIndex({ candidateEntryPoints, rootEntryDirectory, state, }) {
+    const entryPointBySymbol = new Map();
+    for (const relativeEntryDir of candidateEntryPoints) {
+        const exportedNames = getExportedNamesForEntryPoint({
+            relativeEntryDirectory: relativeEntryDir,
+            rootEntryDirectory,
+            state,
+        });
+        if (!exportedNames) {
             continue;
         }
-        const exports$1 = typeChecker.getExportsOfModule(moduleSymbol);
-        const exportedNames = new Set(exports$1.map((symbol) => symbol.getName()));
-        exportTableByEntryPoint.set(relativeEntryDir, exportedNames);
-    }
-    for (const importedSymbol of importedSymbols) {
-        for (const relativeEntryDir of candidateEntryPoints) {
-            const exportedNames = exportTableByEntryPoint.get(relativeEntryDir);
-            if (!exportedNames?.has(importedSymbol)) {
-                continue;
+        for (const exportedName of exportedNames) {
+            if (!entryPointBySymbol.has(exportedName)) {
+                entryPointBySymbol.set(exportedName, relativeEntryDir);
             }
-            symbolToEntryPoint.set(importedSymbol, relativeEntryDir);
-            break;
         }
     }
-    return symbolToEntryPoint;
+    return entryPointBySymbol;
+}
+function getExportedNamesForEntryPoint({ relativeEntryDirectory, rootEntryDirectory, state, }) {
+    const entryFile = getEntryFileForNestedEntryPoint(rootEntryDirectory, relativeEntryDirectory);
+    if (!entryFile) {
+        return null;
+    }
+    const sourceFile = state.program.getSourceFile(entryFile);
+    if (!sourceFile) {
+        return null;
+    }
+    const moduleSymbol = state.typeChecker.getSymbolAtLocation(sourceFile);
+    if (!moduleSymbol) {
+        return null;
+    }
+    const exports$1 = state.typeChecker.getExportsOfModule(moduleSymbol);
+    return new Set(exports$1.map((symbol) => symbol.getName()));
 }
-/**
- * Determine the physical entry file for a nested entry point.
- *
- * Priority:
- *   1. If "ng-package.json" exists:
- *        - use lib.entryFile if present
- *        - otherwise fall back to "index.ts"
- *   2. Else if "collection.json" exists:
- *        - treat this directory as a schematic collection package
- *        - entry file is "index.ts" if it exists
- *   3. Otherwise: no entry file can be determined → return null
- */
 function getEntryFileForNestedEntryPoint(rootEntryDirectory, relativeEntryDirectory) {
     const absoluteDirectory = path.join(rootEntryDirectory, relativeEntryDirectory);
     const ngPackageJsonPath = path.join(absoluteDirectory, 'ng-package.json');
@@ -253351,58 +254280,74 @@ function getEntryFileForNestedEntryPoint(rootEntryDirectory, relativeEntryDirect
     }
     return null;
 }
-/**
- * Build the final text block with rewritten import declarations.
- *
- * Example:
- *   original:
- *     import {A, B as C, D} from '@taiga-ui/core';
- *
- *   symbolMap (strict = true):
- *     A -> "components/button"
- *     B -> "components/button"
- *     D -> "components/other"
- *
- *   result:
- *     import {A, B as C} from '@taiga-ui/core/components/button';
- *     import {D} from '@taiga-ui/core/components/other';
- */
-function buildRewrittenImports(node, baseImportPath, symbolToEntryPoint) {
-    const isTypeOnlyImport = node.importKind === 'type';
+function buildRewrittenImports({ baseImportPath, node, state, symbolToEntryPoint, }) {
     const groupedByTarget = new Map();
-    for (const [symbolName, relativeEntryPath] of symbolToEntryPoint.entries()) {
+    const remainingSpecifiers = [];
+    for (const specifier of node.specifiers) {
+        if (specifier.type !== dist$2.AST_NODE_TYPES.ImportSpecifier) {
+            remainingSpecifiers.push(specifier);
+            continue;
+        }
+        const importedName = getImportedName(specifier);
+        const relativeEntryPath = symbolToEntryPoint.get(importedName);
+        if (!relativeEntryPath) {
+            remainingSpecifiers.push(specifier);
+            continue;
+        }
         const targetSpecifier = `${baseImportPath}/${relativeEntryPath}`;
         if (!groupedByTarget.has(targetSpecifier)) {
             groupedByTarget.set(targetSpecifier, []);
         }
-        const targetGroup = groupedByTarget.get(targetSpecifier);
-        if (targetGroup) {
-            targetGroup.push(symbolName);
-        }
+        groupedByTarget.get(targetSpecifier)?.push(specifier);
     }
     const importStatements = [];
-    for (const [targetSpecifier, symbols] of groupedByTarget.entries()) {
-        const parts = symbols.map((symbolName) => {
-            const matchingSpecifier = node.specifiers.find((specifier) => specifier.type === dist$2.AST_NODE_TYPES.ImportSpecifier &&
-                (specifier.imported.type === dist$2.AST_NODE_TYPES.Identifier
-                    ? specifier.imported.name === symbolName
-                    : specifier.imported.value === symbolName));
-            if (!matchingSpecifier) {
-                return symbolName;
-            }
-            const importedName = matchingSpecifier.imported.type === dist$2.AST_NODE_TYPES.Identifier
-                ? matchingSpecifier.imported.name
-                : matchingSpecifier.imported.value;
-            const localName = matchingSpecifier.local.name;
-            return importedName === localName
-                ? importedName
-                : `${importedName} as ${localName}`;
-        });
-        const statement = `import ${isTypeOnlyImport ? 'type ' : ''}{${parts.join(', ')}} from '${targetSpecifier}';`;
-        importStatements.push(statement);
+    for (const [targetSpecifier, specifiers] of groupedByTarget.entries()) {
+        importStatements.push(buildNamedImportStatement({
+            importKind: node.importKind,
+            importPath: targetSpecifier,
+            specifiers,
+            state,
+        }));
+    }
+    const remainingImportStatement = buildImportStatement({
+        importKind: node.importKind,
+        importPath: baseImportPath,
+        specifiers: remainingSpecifiers,
+        state,
+    });
+    if (remainingImportStatement) {
+        importStatements.push(remainingImportStatement);
     }
     return importStatements.join('\n');
 }
+function buildNamedImportStatement({ importKind, importPath, specifiers, state, }) {
+    const importKeyword = importKind === 'type' ? 'import type' : 'import';
+    const parts = specifiers.map((specifier) => state.sourceCode.getText(specifier));
+    return `${importKeyword} {${parts.join(', ')}} from '${importPath}';`;
+}
+function buildImportStatement({ importKind, importPath, specifiers, state, }) {
+    if (specifiers.length === 0) {
+        return null;
+    }
+    const importKeyword = importKind === 'type' ? 'import type' : 'import';
+    const defaultSpecifier = specifiers.find((specifier) => specifier.type === dist$2.AST_NODE_TYPES.ImportDefaultSpecifier);
+    const namespaceSpecifier = specifiers.find((specifier) => specifier.type === dist$2.AST_NODE_TYPES.ImportNamespaceSpecifier);
+    const namedSpecifiers = specifiers.filter((specifier) => specifier.type === dist$2.AST_NODE_TYPES.ImportSpecifier);
+    const clauses = [];
+    if (defaultSpecifier) {
+        clauses.push(state.sourceCode.getText(defaultSpecifier));
+    }
+    if (namespaceSpecifier) {
+        clauses.push(state.sourceCode.getText(namespaceSpecifier));
+    }
+    if (namedSpecifiers.length > 0) {
+        clauses.push(`{${namedSpecifiers.map((specifier) => state.sourceCode.getText(specifier)).join(', ')}}`);
+    }
+    if (clauses.length === 0) {
+        return null;
+    }
+    return `${importKeyword} ${clauses.join(', ')} from '${importPath}';`;
+}
 
 function getTypeName(param) {
     const typeAnnotation = param?.parameter?.typeAnnotation ?? param?.typeAnnotation;
@@ -253512,52 +254457,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,
     },