@taiga-ui/eslint-plugin-experience-next 0.505.0 → 0.507.0

package/index.esm.js

@@ -1213,6 +1213,8 @@ var recommended = defineConfig([
             '@taiga-ui/experience-next/no-useless-untracked': 'error',
             '@taiga-ui/experience-next/object-single-line': ['error', { printWidth: 90 }],
             '@taiga-ui/experience-next/prefer-combined-if-control-flow': 'error',
+            '@taiga-ui/experience-next/prefer-conditional-return': 'error',
+            '@taiga-ui/experience-next/prefer-loose-null-check': 'error',
             '@taiga-ui/experience-next/prefer-multi-arg-push': 'error',
             '@taiga-ui/experience-next/prefer-namespace-keyword': 'error',
             '@taiga-ui/experience-next/prefer-untracked-incidental-signal-reads': 'error',
@@ -33200,10 +33202,7 @@ var VERSION = new Version("20.3.12");
 publishFacade(_global);
 
 function getAttributeValueSpan(attr) {
-    if (attr instanceof dist$4.TmplAstBoundEvent) {
-        return attr.handlerSpan;
-    }
-    return attr.valueSpan;
+    return attr instanceof dist$4.TmplAstBoundEvent ? attr.handlerSpan : attr.valueSpan;
 }
 function getElementAttributeLikes(element) {
     const seen = new Set();
@@ -46223,7 +46222,7 @@ function buildMultilineStartTag(node, sourceText) {
         closing,
     ].join('\n');
 }
-const rule$P = createRule({
+const rule$R = createRule({
     name: 'attrs-newline',
     rule: {
         create(context) {
@@ -46370,7 +46369,7 @@ const config$5 = {
 function getCorrectOrderRelative(correct, current) {
     return correct.filter((item) => current.includes(item));
 }
-const rule$O = createRule({
+const rule$Q = createRule({
     name: 'decorator-key-sort',
     rule: config$5,
 });
@@ -46429,12 +46428,9 @@ function getNodeLabel(node) {
     if (node instanceof dist$4.TmplAstElement) {
         return `<${node.name}>`;
     }
-    if (node instanceof dist$4.TmplAstBoundText) {
-        return 'binding';
-    }
-    return 'text';
+    return node instanceof dist$4.TmplAstBoundText ? 'binding' : 'text';
 }
-const rule$N = createRule({
+const rule$P = createRule({
     name: 'element-newline',
     rule: {
         create(context) {
@@ -46563,10 +46559,9 @@ function getStaticStringValue(node) {
     if (isStringLiteral(node)) {
         return node.value;
     }
-    if (!isStaticTemplateLiteral(node)) {
-        return null;
-    }
-    return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? '';
+    return isStaticTemplateLiteral(node)
+        ? (node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw ?? '')
+        : null;
 }
 function isEmptyStaticString(node) {
     return getStaticStringValue(node) === '';
@@ -46576,17 +46571,13 @@ function getStaticPropertyName(key) {
     if (key.type === dist$3.AST_NODE_TYPES.Identifier) {
         return key.name;
     }
-    if (key.type === dist$3.AST_NODE_TYPES.Literal &&
-        (typeof key.value === 'string' || typeof key.value === 'number')) {
-        return String(key.value);
-    }
-    return getStaticStringValue(key);
+    return key.type === dist$3.AST_NODE_TYPES.Literal &&
+        (typeof key.value === 'string' || typeof key.value === 'number')
+        ? String(key.value)
+        : getStaticStringValue(key);
 }
 function getObjectPropertyName(node) {
-    if (node.computed) {
-        return null;
-    }
-    return getStaticPropertyName(node.key);
+    return node.computed ? null : getStaticPropertyName(node.key);
 }
 function getMemberExpressionPropertyName(node) {
     if (!node.computed && node.property.type === dist$3.AST_NODE_TYPES.Identifier) {
@@ -46665,7 +46656,7 @@ const PRESETS = {
     $VUE: ['$CLASS', '$ID', '$VUE_ATTRIBUTE'],
     $VUE_ATTRIBUTE: /^v-/,
 };
-const rule$M = createRule({
+const rule$O = createRule({
     create(context, [options]) {
         const sourceCode = context.sourceCode;
         const settings = {
@@ -46779,7 +46770,7 @@ function getHostAttributeProperties(hostObject) {
             return null;
         }
         const name = getStaticPropertyName(property.key);
-        if (name === null) {
+        if (name == null) {
             return null;
         }
         properties.push({ name, node: property });
@@ -46820,10 +46811,9 @@ function getGroup(query, ignoreCase) {
             },
         ];
     }
-    if (Array.isArray(preset)) {
-        return preset.flatMap((item) => getGroup(item, ignoreCase));
-    }
-    return [{ query, regexp: preset, values: [] }];
+    return Array.isArray(preset)
+        ? preset.flatMap((item) => getGroup(item, ignoreCase))
+        : [{ query, regexp: preset, values: [] }];
 }
 function ensureDefaultGroup(groups) {
     const existing = groups.find(({ unknown }) => unknown);
@@ -46849,10 +46839,9 @@ function getFixText(hostObject, properties, sortedProperties, sourceCode) {
             .join(', ')}}`;
     }
     const attachedComments = getAttachedComments(hostObject, properties, sourceCode, comments);
-    if (!attachedComments) {
-        return null;
-    }
-    return renderFixWithComments(hostObject, sortedProperties, sourceCode, attachedComments);
+    return attachedComments
+        ? renderFixWithComments(hostObject, sortedProperties, sourceCode, attachedComments)
+        : null;
 }
 function getAttachedComments(hostObject, properties, sourceCode, comments) {
     const attached = new Map();
@@ -46998,7 +46987,7 @@ const config$4 = {
         type: 'suggestion',
     },
 };
-const rule$L = createRule({
+const rule$N = createRule({
     name: 'html-logical-properties',
     rule: config$4,
 });
@@ -247714,12 +247703,11 @@ function getProgramResolutionCache(program) {
         return null;
     }
     const cache = getCache.call(program);
-    if (cache === null ||
+    return cache === null ||
         typeof cache !== 'object' ||
-        !('getOrCreateCacheForDirectory' in cache)) {
-        return null;
-    }
-    return cache;
+        !('getOrCreateCacheForDirectory' in cache)
+        ? null
+        : cache;
 }
 function getFallbackResolution(program) {
     const cached = fallbackResolutionByProgram.get(program);
@@ -247750,10 +247738,9 @@ function resolveModule(program, containingFile, moduleSpecifier) {
 }
 function resolveModuleFileName(program, containingFile, moduleSpecifier) {
     const resolved = resolveModule(program, containingFile, moduleSpecifier);
-    if (!resolved || resolved.isExternalLibraryImport) {
-        return null;
-    }
-    return resolved.resolvedFileName;
+    return !resolved || resolved.isExternalLibraryImport
+        ? null
+        : resolved.resolvedFileName;
 }
 function splitModuleSpecifierQuery(moduleSpecifier) {
     const queryIndex = moduleSpecifier.indexOf('?');
@@ -247848,22 +247835,20 @@ function importDeclarationHasRuntimeEdge(node) {
     if (!namedBindings) {
         return false;
     }
-    if (ts.isNamespaceImport(namedBindings)) {
-        return true;
-    }
-    return (namedBindings.elements.length === 0 ||
-        namedBindings.elements.some((specifier) => !specifier.isTypeOnly));
+    return ts.isNamespaceImport(namedBindings)
+        ? true
+        : namedBindings.elements.length === 0 ||
+            namedBindings.elements.some((specifier) => !specifier.isTypeOnly);
 }
 function exportDeclarationHasRuntimeEdge(node) {
     if (node.isTypeOnly) {
         return false;
     }
     const exportClause = node.exportClause;
-    if (!exportClause || ts.isNamespaceExport(exportClause)) {
-        return true;
-    }
-    return (exportClause.elements.length === 0 ||
-        exportClause.elements.some((specifier) => !specifier.isTypeOnly));
+    return !exportClause || ts.isNamespaceExport(exportClause)
+        ? true
+        : exportClause.elements.length === 0 ||
+            exportClause.elements.some((specifier) => !specifier.isTypeOnly);
 }
 function getRuntimeModuleSpecifier(statement) {
     if (ts.isImportDeclaration(statement)) {
@@ -247926,10 +247911,9 @@ function hasRuntimeDefaultModifier(statement) {
         !ts.isTypeAliasDeclaration(statement));
 }
 function exportsDefaultSpecifier(node) {
-    if (node.isTypeOnly || !node.exportClause || !ts.isNamedExports(node.exportClause)) {
-        return false;
-    }
-    return node.exportClause.elements.some((specifier) => !specifier.isTypeOnly && specifier.name.text === 'default');
+    return node.isTypeOnly || !node.exportClause || !ts.isNamedExports(node.exportClause)
+        ? false
+        : node.exportClause.elements.some((specifier) => !specifier.isTypeOnly && specifier.name.text === 'default');
 }
 function sourceFileHasDefaultExport(sourceFile) {
     return sourceFile.statements.some((statement) => (ts.isExportAssignment(statement) && !statement.isExportEquals) ||
@@ -247957,25 +247941,20 @@ function hasRuntimeEstreeImport(node) {
     if (node.importKind === 'type') {
         return false;
     }
-    if (node.specifiers.length === 0) {
-        return true;
-    }
-    return node.specifiers.some((specifier) => {
-        if (specifier.type !== dist$3.AST_NODE_TYPES.ImportSpecifier) {
-            return true;
-        }
-        return specifier.importKind !== 'type';
-    });
+    return node.specifiers.length === 0
+        ? true
+        : node.specifiers.some((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportSpecifier
+            ? specifier.importKind !== 'type'
+            : true);
 }
 function hasRuntimeEstreeReExport(node) {
     if (node.exportKind === 'type') {
         return false;
     }
-    if (node.type === dist$3.AST_NODE_TYPES.ExportAllDeclaration) {
-        return true;
-    }
-    return (node.specifiers.length === 0 ||
-        node.specifiers.some((specifier) => specifier.exportKind !== 'type'));
+    return node.type === dist$3.AST_NODE_TYPES.ExportAllDeclaration
+        ? true
+        : node.specifiers.length === 0 ||
+            node.specifiers.some((specifier) => specifier.exportKind !== 'type');
 }
 function getImportOrReExportModuleSpecifier(node) {
     if (node.type === dist$3.AST_NODE_TYPES.ImportDeclaration) {
@@ -248198,13 +248177,10 @@ function isInAngularSafeContext(identifier) {
     return false;
 }
 function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
-    const valueSpecifiers = node.specifiers.filter((specifier) => {
-        if (specifier.type === dist$3.AST_NODE_TYPES.ImportDefaultSpecifier ||
-            specifier.type === dist$3.AST_NODE_TYPES.ImportNamespaceSpecifier) {
-            return true;
-        }
-        return specifier.importKind !== 'type';
-    });
+    const valueSpecifiers = node.specifiers.filter((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportDefaultSpecifier ||
+        specifier.type === dist$3.AST_NODE_TYPES.ImportNamespaceSpecifier
+        ? true
+        : specifier.importKind !== 'type');
     if (valueSpecifiers.length === 0) {
         return false;
     }
@@ -248250,7 +248226,7 @@ function isImportUsedOnlyAsAngularDiFirstArg(node, sourceCode) {
     }
     return hasSafeRuntimeUsage;
 }
-const rule$K = createRule({
+const rule$M = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode, tsProgram } = getTypeAwareRuleContext(context);
         const checkCycles = context.options[0]?.checkCycles ?? true;
@@ -248425,11 +248401,10 @@ const rule$K = createRule({
             const importSegments = moduleSpecifierPath.replace(/^\.\//, '').split('/');
             const importParentCount = countRelativeParents(importSegments);
             const expectedParentCount = countRelativeParents(expectedPath.split('/'));
-            if (importParentCount <= expectedParentCount ||
-                expectedPath === moduleSpecifierPath) {
-                return null;
-            }
-            return expectedPath;
+            return importParentCount <= expectedParentCount ||
+                expectedPath === moduleSpecifierPath
+                ? null
+                : expectedPath;
         }
         function getUselessPathSegmentsReplacement(moduleSpecifierPath) {
             const resolved = resolveModule(tsProgram, context.filename, moduleSpecifierPath);
@@ -248920,10 +248895,7 @@ function isStringLike(node) {
     return isStringLiteral(node) || node.type === dist$2.AST_NODE_TYPES.TemplateLiteral;
 }
 function getStringValue(node) {
-    if (isStringLiteral(node)) {
-        return node.value;
-    }
-    return node.quasis[0]?.value.raw || '';
+    return isStringLiteral(node) ? node.value : node.quasis[0]?.value.raw || '';
 }
 function isEmptyString(node) {
     return (isEmptyStaticString(node) &&
@@ -248941,10 +248913,7 @@ function getDescriptionValue(node) {
     if (isStringLike(node)) {
         return getStringValue(node);
     }
-    if (isNgDevModeConditional(node)) {
-        return getStringValue(node.consequent);
-    }
-    return undefined;
+    return isNgDevModeConditional(node) ? getStringValue(node.consequent) : undefined;
 }
 function getDescriptionNode(node) {
     if (isStringLike(node)) {
@@ -248956,7 +248925,7 @@ 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) {
+    for (let scope = sourceCode.getScope(node); scope != null; scope = scope.upper) {
         if (scope.variables.some((variable) => variable.name === NG_DEV_MODE)) {
             return true;
         }
@@ -248971,12 +248940,11 @@ function getNgDevModeDeclarationFix(program, fixer) {
         return fixer.insertTextAfter(lastImport, '\n\ndeclare const ngDevMode: boolean;');
     }
     const [firstStatement] = program.body;
-    if (firstStatement) {
-        return fixer.insertTextBefore(firstStatement, 'declare const ngDevMode: boolean;\n\n');
-    }
-    return fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
+    return firstStatement
+        ? fixer.insertTextBefore(firstStatement, 'declare const ngDevMode: boolean;\n\n')
+        : fixer.insertTextBeforeRange([0, 0], 'declare const ngDevMode: boolean;\n');
 }
-const rule$J = createRule({
+const rule$L = createRule({
     create(context) {
         const { sourceCode } = context;
         const program = sourceCode.ast;
@@ -249025,7 +248993,7 @@ const rule$J = createRule({
     name: 'injection-token-description',
 });
 
-const rule$I = createRule({
+const rule$K = createRule({
     create(context) {
         const { sourceCode } = context;
         const namespaceImports = new Map();
@@ -249120,7 +249088,7 @@ const DEFAULT_OPTIONS = {
     importDeclaration: '^@taiga-ui*',
     projectName: String.raw `(?<=^@taiga-ui/)([-\w]+)`,
 };
-const rule$H = createRule({
+const rule$J = createRule({
     create(context) {
         const { currentProject, deepImport, ignoreImports, importDeclaration, projectName, } = { ...DEFAULT_OPTIONS, ...context.options[0] };
         const hasNonCodeExtension = (source) => {
@@ -249212,7 +249180,7 @@ const nearestFileUpCache = new Map();
 const markerCache = new Map();
 const indexFileCache = new Map();
 const indexExportsCache = new Map();
-const rule$G = createRule({
+const rule$I = createRule({
     create(context) {
         const parserServices = dist$3.ESLintUtils.getParserServices(context);
         const program = parserServices.program;
@@ -249227,7 +249195,7 @@ const rule$G = createRule({
             }
             const key = `${containingDir}\0${moduleSpecifier}`;
             const cachedFile = cache.get(key);
-            if (cachedFile !== undefined) {
+            if (cachedFile != null) {
                 return cachedFile;
             }
             const resolved = ts.resolveModuleName(moduleSpecifier, context.filename, compilerOptions, compilerHost);
@@ -249238,7 +249206,7 @@ const rule$G = createRule({
         function findNearestFileUpwardsCached(startDirectory, fileName) {
             const key = `${startDirectory}\0${fileName}`;
             const cachedPath = nearestFileUpCache.get(key);
-            if (cachedPath !== undefined) {
+            if (cachedPath != null) {
                 return cachedPath;
             }
             let currentDirectory = startDirectory;
@@ -249259,7 +249227,7 @@ const rule$G = createRule({
         }
         function pickPackageMarkerFileCached(resolvedRootFilePath) {
             const cachedMarker = markerCache.get(resolvedRootFilePath);
-            if (cachedMarker !== undefined) {
+            if (cachedMarker != null) {
                 return cachedMarker;
             }
             const resolvedRootDirectory = path.dirname(resolvedRootFilePath);
@@ -249271,7 +249239,7 @@ const rule$G = createRule({
         }
         function pickIndexFileInDirectoryCached(packageDirectory) {
             const cachedIndexFile = indexFileCache.get(packageDirectory);
-            if (cachedIndexFile !== undefined) {
+            if (cachedIndexFile != null) {
                 return cachedIndexFile;
             }
             const indexTypescriptPath = path.join(packageDirectory, 'index.ts');
@@ -249373,10 +249341,9 @@ const rule$G = createRule({
     name: 'no-deep-imports-to-indexed-packages',
 });
 function isExternalModuleSpecifier(moduleSpecifier) {
-    if (!moduleSpecifier || moduleSpecifier.startsWith('.')) {
-        return false;
-    }
-    return !path.isAbsolute(moduleSpecifier);
+    return !moduleSpecifier || moduleSpecifier.startsWith('.')
+        ? false
+        : !path.isAbsolute(moduleSpecifier);
 }
 function isScopedPackage(importSpecifier) {
     return importSpecifier.startsWith('@');
@@ -249384,19 +249351,17 @@ function isScopedPackage(importSpecifier) {
 function getPackageRootSpecifier(importSpecifier) {
     const pathParts = importSpecifier.split('/');
     if (isScopedPackage(importSpecifier)) {
-        if (pathParts.length >= 2) {
-            return `${pathParts[0]}/${pathParts[1]}`;
-        }
-        return importSpecifier;
+        return pathParts.length >= 2
+            ? `${pathParts[0]}/${pathParts[1]}`
+            : importSpecifier;
     }
     return pathParts[0] ?? importSpecifier;
 }
 function getSubpath(importSpecifier, packageRootSpecifier) {
-    if (importSpecifier === packageRootSpecifier ||
-        !importSpecifier.startsWith(`${packageRootSpecifier}/`)) {
-        return null;
-    }
-    return importSpecifier.slice(packageRootSpecifier.length + 1);
+    return importSpecifier === packageRootSpecifier ||
+        !importSpecifier.startsWith(`${packageRootSpecifier}/`)
+        ? null
+        : importSpecifier.slice(packageRootSpecifier.length + 1);
 }
 function normalizeModuleSpecifier(moduleSpecifier) {
     return moduleSpecifier.replaceAll('\\', '/');
@@ -249409,13 +249374,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$F = createRule({
+const rule$H = createRule({
     name: 'no-duplicate-attrs',
     rule: noDuplicateAttributesRule,
 });
 
 const MESSAGE_ID$c = 'duplicateId';
-const rule$E = createRule({
+const rule$G = createRule({
     name: 'no-duplicate-id',
     rule: {
         create(context) {
@@ -249470,14 +249435,13 @@ function getTrackingKey(node) {
             return 'meta[name=viewport]';
         }
     }
-    if (node.name === 'link' &&
+    return node.name === 'link' &&
         findAttr(node, 'rel')?.value === 'canonical' &&
-        findAttr(node, 'href')) {
-        return 'link[rel=canonical]';
-    }
-    return null;
+        findAttr(node, 'href')
+        ? 'link[rel=canonical]'
+        : null;
 }
-const rule$D = createRule({
+const rule$F = createRule({
     name: 'no-duplicate-in-head',
     rule: {
         create(context) {
@@ -249543,7 +249507,7 @@ function getOrderedChildren(node) {
             ...node.params,
             node.body,
         ];
-        return children.filter((child) => child !== undefined && child !== null);
+        return children.filter((child) => child != null);
     }
     if (node.type === dist$3.AST_NODE_TYPES.BlockStatement ||
         node.type === dist$3.AST_NODE_TYPES.Program) {
@@ -249570,7 +249534,7 @@ function getOrderedChildren(node) {
             node.update,
             node.body,
         ];
-        return children.filter((child) => child !== null);
+        return children.filter((child) => child != null);
     }
     if (node.type === dist$3.AST_NODE_TYPES.ForInStatement ||
         node.type === dist$3.AST_NODE_TYPES.ForOfStatement) {
@@ -249776,12 +249740,11 @@ function getPropertyName(property) {
 }
 function isAngularCoreCall(node, program, exportedName) {
     const localName = getLocalNameForImport(program, ANGULAR_CORE, exportedName);
-    if (!localName) {
-        return false;
-    }
-    return (node.callee.type === dist$3.AST_NODE_TYPES.Identifier &&
-        node.callee.name === localName &&
-        node.arguments.length >= 1);
+    return localName
+        ? node.callee.type === dist$3.AST_NODE_TYPES.Identifier &&
+            node.callee.name === localName &&
+            node.arguments.length >= 1
+        : false;
 }
 function appendFirstArgReactiveScope(scopes, call, kind) {
     const callback = getReactiveCallbackArgument(call);
@@ -249920,13 +249883,12 @@ function isSignalType(node, checker, esTreeNodeToTSNodeMap) {
         }
         const typeSymbol = type.getSymbol();
         const aliasSymbol = type.aliasSymbol;
-        if (typeSymbol?.getName().includes('Signal') ||
-            aliasSymbol?.getName().includes('Signal')) {
-            return true;
-        }
-        return type
-            .getProperties()
-            .some((p) => p.name.startsWith('ɵ') || p.name === '__SIGNAL');
+        return typeSymbol?.getName().includes('Signal') ||
+            aliasSymbol?.getName().includes('Signal')
+            ? true
+            : type
+                .getProperties()
+                .some((p) => p.name.startsWith('ɵ') || p.name === '__SIGNAL');
     }
     catch {
         return false;
@@ -249934,22 +249896,20 @@ function isSignalType(node, checker, esTreeNodeToTSNodeMap) {
 }
 function isSignalReadCall(node, checker, esTreeNodeToTSNodeMap) {
     const { callee } = node;
-    if (callee.type !== dist$3.AST_NODE_TYPES.Identifier &&
-        callee.type !== dist$3.AST_NODE_TYPES.MemberExpression) {
-        return false;
-    }
-    return isSignalType(callee, checker, esTreeNodeToTSNodeMap);
+    return callee.type !== dist$3.AST_NODE_TYPES.Identifier &&
+        callee.type !== dist$3.AST_NODE_TYPES.MemberExpression
+        ? false
+        : isSignalType(callee, checker, esTreeNodeToTSNodeMap);
 }
 function isWritableSignalWrite(node, checker, esTreeNodeToTSNodeMap) {
     if (node.callee.type !== dist$3.AST_NODE_TYPES.MemberExpression) {
         return false;
     }
     const { object, property } = node.callee;
-    if (property.type !== dist$3.AST_NODE_TYPES.Identifier ||
-        !SIGNAL_WRITE_METHODS.has(property.name)) {
-        return false;
-    }
-    return isSignalType(object, checker, esTreeNodeToTSNodeMap);
+    return property.type !== dist$3.AST_NODE_TYPES.Identifier ||
+        !SIGNAL_WRITE_METHODS.has(property.name)
+        ? false
+        : isSignalType(object, checker, esTreeNodeToTSNodeMap);
 }
 /**
  * Returns true when `node` is a member expression `foo.bar` where `bar` is a
@@ -249963,10 +249923,7 @@ function isGetterMemberAccess(node, checker, esTreeNodeToTSNodeMap) {
             return false;
         }
         const symbol = checker.getSymbolAtLocation(tsNode);
-        if (!symbol) {
-            return false;
-        }
-        return !!(symbol.flags & ts.SymbolFlags.GetAccessor);
+        return symbol ? !!(symbol.flags & ts.SymbolFlags.GetAccessor) : false;
     }
     catch {
         return false;
@@ -250050,19 +250007,18 @@ function getReturnedReactiveOwnerCall(node, program) {
         isReactiveOwnerCall(statement.argument, program)) {
         return statement.argument;
     }
-    if (node.parent.type === dist$3.AST_NODE_TYPES.ExpressionStatement &&
+    return node.parent.type === dist$3.AST_NODE_TYPES.ExpressionStatement &&
         statement?.type === dist$3.AST_NODE_TYPES.ExpressionStatement &&
-        isReactiveOwnerCall(statement.expression, program)) {
-        return statement.expression;
-    }
-    return null;
+        isReactiveOwnerCall(statement.expression, program)
+        ? statement.expression
+        : null;
 }
 
 const ANGULAR_SIGNALS_UNTRACKED_GUIDE_URL = 'https://angular.dev/guide/signals#reading-without-tracking-dependencies';
 const ANGULAR_SIGNALS_ASYNC_GUIDE_URL = 'https://angular.dev/guide/signals#reactive-context-and-async-operations';
 const createUntrackedRule = createRule;
 
-const rule$C = createUntrackedRule({
+const rule$E = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -250135,7 +250091,7 @@ const config$3 = {
         type: 'problem',
     },
 };
-const rule$B = createRule({
+const rule$D = createRule({
     name: 'no-href-with-router-link',
     rule: config$3,
 });
@@ -250196,7 +250152,7 @@ function getScopeRoot(node) {
     return (findAncestor(node, (ancestor) => ancestor.type === dist$3.AST_NODE_TYPES.Program || isFunctionLike(ancestor)) ?? node);
 }
 
-const rule$A = createRule({
+const rule$C = createRule({
     create(context) {
         const checkImplicitPublic = (node) => {
             const classRef = getEnclosingClass(node);
@@ -250258,7 +250214,7 @@ const rule$A = createRule({
     name: 'no-implicit-public',
 });
 
-const rule$z = createRule({
+const rule$B = createRule({
     create(context) {
         const { sourceCode } = context;
         return {
@@ -250291,10 +250247,9 @@ const rule$z = createRule({
 
 function getParenthesizedInner(node) {
     const maybeNode = node;
-    if (maybeNode.type === 'ParenthesizedExpression') {
-        return maybeNode.expression ?? null;
-    }
-    return null;
+    return maybeNode.type === 'ParenthesizedExpression'
+        ? (maybeNode.expression ?? null)
+        : null;
 }
 function unwrapParenthesized(node) {
     let current = node;
@@ -250308,15 +250263,14 @@ function unwrapParenthesized(node) {
 
 function isInfiniteLoopLiteral(node) {
     const unwrapped = unwrapParenthesized(node);
-    if (unwrapped.type !== dist$3.AST_NODE_TYPES.Literal) {
-        return false;
-    }
-    return unwrapped.value === true || unwrapped.value === 1;
+    return unwrapped.type === dist$3.AST_NODE_TYPES.Literal
+        ? unwrapped.value === true || unwrapped.value === 1
+        : false;
 }
 function isInfiniteLoopTest(test) {
-    return test === null || isInfiniteLoopLiteral(test);
+    return test == null || isInfiniteLoopLiteral(test);
 }
-const rule$y = createRule({
+const rule$A = createRule({
     create(context) {
         return {
             DoWhileStatement(node) {
@@ -250361,7 +250315,7 @@ const rule$y = createRule({
 });
 
 const LEGACY_PEER_DEPS_PATTERN = /^legacy-peer-deps\s*=\s*true$/i;
-const rule$x = createRule({
+const rule$z = createRule({
     create(context) {
         return {
             Program(node) {
@@ -250821,7 +250775,7 @@ const OBSOLETE_HTML_ATTRS = {
 };
 
 const MESSAGE_ID$9 = 'obsolete';
-const rule$w = createRule({
+const rule$y = createRule({
     name: 'no-obsolete-attrs',
     rule: {
         create(context) {
@@ -250899,7 +250853,7 @@ const OBSOLETE_HTML_TAGS = new Set([
 ]);
 
 const MESSAGE_ID$8 = 'unexpected';
-const rule$v = createRule({
+const rule$x = createRule({
     name: 'no-obsolete-tags',
     rule: {
         create(context) {
@@ -250926,7 +250880,7 @@ const rule$v = createRule({
     },
 });
 
-const rule$u = createRule({
+const rule$w = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
         return {
@@ -251070,7 +251024,7 @@ const config$2 = {
         type: 'problem',
     },
 };
-const rule$t = createRule({
+const rule$v = createRule({
     name: 'no-project-as-in-ng-template',
     rule: config$2,
 });
@@ -251107,7 +251061,7 @@ function collectArrayExpressions(node) {
     }
     return result;
 }
-const rule$s = createRule({
+const rule$u = createRule({
     create(context) {
         const { checker: typeChecker, esTreeNodeToTSNodeMap } = getTypeAwareRuleContext(context);
         const ignoreTupleContextualTyping = context.options[0]?.ignoreTupleContextualTyping ?? true;
@@ -251209,10 +251163,9 @@ function isNullableCallType(call, checker, nodeMap) {
             return false;
         }
         const type = checker.getTypeAtLocation(tsNode);
-        if (!(type.flags & ts.TypeFlags.Union)) {
-            return false;
-        }
-        return type.types.some((t) => !!(t.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)));
+        return type.flags & ts.TypeFlags.Union
+            ? type.types.some((t) => !!(t.flags & (ts.TypeFlags.Null | ts.TypeFlags.Undefined)))
+            : false;
     }
     catch {
         return false;
@@ -251223,13 +251176,12 @@ function getTargetNode(call) {
     if (parent.type === dist$3.AST_NODE_TYPES.TSAsExpression) {
         return parent;
     }
-    if (parent.type === dist$3.AST_NODE_TYPES.UnaryExpression &&
+    return parent.type === dist$3.AST_NODE_TYPES.UnaryExpression &&
         parent.operator === '!' &&
         parent.parent.type === dist$3.AST_NODE_TYPES.UnaryExpression &&
-        parent.parent.operator === '!') {
-        return parent.parent;
-    }
-    return call;
+        parent.parent.operator === '!'
+        ? parent.parent
+        : call;
 }
 function getCalleeName(node) {
     const { callee } = node;
@@ -251239,10 +251191,7 @@ function getCalleeName(node) {
         return callee.property.name;
     }
     // Append 'Val' to avoid shadowing the signal variable itself (e.g. const xVal = x())
-    if (callee.type === dist$3.AST_NODE_TYPES.Identifier) {
-        return `${callee.name}Val`;
-    }
-    return 'value';
+    return callee.type === dist$3.AST_NODE_TYPES.Identifier ? `${callee.name}Val` : 'value';
 }
 function findParentStatement(node) {
     for (let current = node; current.parent; current = current.parent) {
@@ -251276,13 +251225,13 @@ function getArrowBodyIndent(arrowFn, sourceText) {
     const outerIndent = /^(\s*)/.exec(textBeforeArrow)?.[1] ?? '';
     return { innerIndent: `${outerIndent}    `, outerIndent };
 }
-function getStatementIndent(statement, sourceText) {
+function getStatementIndent$1(statement, sourceText) {
     const start = statement.range[0];
     const lineStart = sourceText.lastIndexOf('\n', start - 1) + 1;
     const before = sourceText.slice(lineStart, start);
     return /^\s*$/.test(before) ? before : '';
 }
-const rule$r = createRule({
+const rule$t = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251321,7 +251270,7 @@ const rule$r = createRule({
                         const varName = getCalleeName(firstCall);
                         const parentStatement = findParentStatement(node);
                         if (parentStatement) {
-                            const indent = getStatementIndent(parentStatement, sourceCode.text);
+                            const indent = getStatementIndent$1(parentStatement, sourceCode.text);
                             const fixes = [
                                 fixer.insertTextBefore(parentStatement, `const ${varName} = ${callText};\n\n${indent}`),
                             ];
@@ -251436,12 +251385,9 @@ function collectMutationTargets(node) {
         case dist$3.AST_NODE_TYPES.MemberExpression:
             return [current];
         case dist$3.AST_NODE_TYPES.ObjectPattern:
-            return current.properties.flatMap((property) => {
-                if (property.type === dist$3.AST_NODE_TYPES.RestElement) {
-                    return collectMutationTargets(property.argument);
-                }
-                return collectMutationTargets(property.value);
-            });
+            return current.properties.flatMap((property) => property.type === dist$3.AST_NODE_TYPES.RestElement
+                ? collectMutationTargets(property.argument)
+                : collectMutationTargets(property.value));
         case dist$3.AST_NODE_TYPES.RestElement:
             return collectMutationTargets(current.argument);
         default:
@@ -251451,10 +251397,7 @@ function collectMutationTargets(node) {
 
 function getSymbolAtNode(node, checker, esTreeNodeToTSNodeMap) {
     const tsNode = esTreeNodeToTSNodeMap.get(node);
-    if (!tsNode) {
-        return null;
-    }
-    return checker.getSymbolAtLocation(tsNode) ?? null;
+    return tsNode ? (checker.getSymbolAtLocation(tsNode) ?? null) : null;
 }
 
 function isFunctionLikeScope(node) {
@@ -251462,14 +251405,13 @@ function isFunctionLikeScope(node) {
 }
 function isLocalIdentifier(node, context, localScopes) {
     const symbol = getSymbolAtNode(node, context.checker, context.esTreeNodeToTSNodeMap);
-    if (!symbol) {
-        return false;
-    }
-    return (symbol.declarations ?? []).some((declaration) => {
-        const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
-        return (!!estreeDeclaration &&
-            isDeclaredInsideLocalScope(estreeDeclaration, localScopes));
-    });
+    return symbol
+        ? (symbol.declarations ?? []).some((declaration) => {
+            const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
+            return (!!estreeDeclaration &&
+                isDeclaredInsideLocalScope(estreeDeclaration, localScopes));
+        })
+        : false;
 }
 function isDeclaredInsideLocalScope(node, localScopes) {
     return localScopes.some((scope) => isNodeInsideFunctionScope(node, scope));
@@ -251501,12 +251443,9 @@ function isLocallyCreatedExpression(node, context, localScopes) {
     }
 }
 function hasObservableMutationTarget(node, context, localScopes) {
-    return collectMutationTargets(node).some((target) => {
-        if (target.type === dist$3.AST_NODE_TYPES.Identifier) {
-            return !isLocalIdentifier(target, context, localScopes);
-        }
-        return !isLocallyCreatedExpression(target.object, context, localScopes);
-    });
+    return collectMutationTargets(node).some((target) => target.type === dist$3.AST_NODE_TYPES.Identifier
+        ? !isLocalIdentifier(target, context, localScopes)
+        : !isLocallyCreatedExpression(target.object, context, localScopes));
 }
 function reportSideEffect(node, context, report) {
     const key = String(node.range);
@@ -251574,10 +251513,9 @@ function resolveFunctionLikeFromIdentifier(node, context, seenSymbols = new Set(
     seenSymbols.add(symbolId);
     return (symbol.declarations ?? []).flatMap((declaration) => {
         const estreeDeclaration = context.tsNodeToESTreeNodeMap.get(declaration);
-        if (!estreeDeclaration || !isInspectableFunctionContainer(estreeDeclaration)) {
-            return [];
-        }
-        return resolveFunctionLikeFromContainer(estreeDeclaration, context, seenSymbols);
+        return !estreeDeclaration || !isInspectableFunctionContainer(estreeDeclaration)
+            ? []
+            : resolveFunctionLikeFromContainer(estreeDeclaration, context, seenSymbols);
     });
 }
 function resolveCalledFunctions(node, context) {
@@ -251713,7 +251651,7 @@ function inspectComputedBody(root, context, localScopes, visitedFunctions, repor
         return;
     });
 }
-const rule$q = createRule({
+const rule$s = createRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode, tsNodeToESTreeNodeMap, } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251756,7 +251694,7 @@ const rule$q = createRule({
     name: 'no-side-effects-in-computed',
 });
 
-const rule$p = createUntrackedRule({
+const rule$r = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -251803,20 +251741,18 @@ const rule$p = createUntrackedRule({
 });
 
 function collectParts(node) {
-    if (node.type === dist$3.AST_NODE_TYPES.BinaryExpression && node.operator === '+') {
-        return [...collectParts(node.left), ...collectParts(node.right)];
-    }
-    return [node];
+    return node.type === dist$3.AST_NODE_TYPES.BinaryExpression && node.operator === '+'
+        ? [...collectParts(node.left), ...collectParts(node.right)]
+        : [node];
 }
 function isRootConcat(node) {
     const { parent } = node;
     return parent.type !== dist$3.AST_NODE_TYPES.BinaryExpression || parent.operator !== '+';
 }
 function isStringType(type, checker) {
-    if (type.isUnion()) {
-        return type.types.every((t) => isStringType(t, checker));
-    }
-    return type.isStringLiteral() || checker.typeToString(type) === 'string';
+    return type.isUnion()
+        ? type.types.every((t) => isStringType(t, checker))
+        : type.isStringLiteral() || checker.typeToString(type) === 'string';
 }
 function buildMergedString(parts) {
     const combined = parts.map((p) => p.value).join('');
@@ -251850,7 +251786,7 @@ function templateContent(template, renderExpr) {
         : ''}`)
         .join('');
 }
-const rule$o = createRule({
+const rule$q = createRule({
     create(context) {
         const { sourceCode } = context;
         let parserServices = null;
@@ -251962,28 +251898,25 @@ function buildUntrackedImportFixes(program, fixer) {
     const coreImport = findRuntimeAngularCoreImport(program);
     if (!coreImport) {
         const firstStatement = program.body[0];
-        if (!firstStatement) {
-            return [];
-        }
-        return [
-            fixer.insertTextBefore(firstStatement, "import { untracked } from '@angular/core';\n"),
-        ];
+        return firstStatement
+            ? [
+                fixer.insertTextBefore(firstStatement, "import { untracked } from '@angular/core';\n"),
+            ]
+            : [];
     }
     const namedSpecifiers = coreImport.specifiers.filter((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportSpecifier);
     if (namedSpecifiers.length > 0) {
         const lastNamedSpecifier = namedSpecifiers[namedSpecifiers.length - 1];
-        if (!lastNamedSpecifier) {
-            return [];
-        }
-        return [fixer.insertTextAfter(lastNamedSpecifier, ', untracked')];
+        return lastNamedSpecifier
+            ? [fixer.insertTextAfter(lastNamedSpecifier, ', untracked')]
+            : [];
     }
     const defaultImport = coreImport.specifiers.find((specifier) => specifier.type === dist$3.AST_NODE_TYPES.ImportDefaultSpecifier);
-    if (defaultImport) {
-        return [fixer.insertTextAfter(defaultImport, ', { untracked }')];
-    }
-    return [
-        fixer.insertTextAfter(coreImport, "\nimport { untracked } from '@angular/core';"),
-    ];
+    return defaultImport
+        ? [fixer.insertTextAfter(defaultImport, ', { untracked }')]
+        : [
+            fixer.insertTextAfter(coreImport, "\nimport { untracked } from '@angular/core';"),
+        ];
 }
 /**
  * Removes the `untracked` import specifier from `@angular/core`.
@@ -251995,7 +251928,6 @@ function buildImportRemovalFixes(program, fixer, sourceCode) {
         return [];
     }
     const { importDecl, specifier: untrackedSpec } = match;
-    const namedSpecifiers = importDecl.specifiers.filter((s) => s.type === dist$3.AST_NODE_TYPES.ImportSpecifier);
     if (importDecl.specifiers.length === 1) {
         return [fixer.remove(importDecl)];
     }
@@ -252013,24 +251945,19 @@ function buildImportRemovalFixes(program, fixer, sourceCode) {
     // Try to remove a leading comma (last specifier)
     const textBefore = importText.slice(0, specStart - importStart);
     const leadingCommaIdx = textBefore.lastIndexOf(',');
-    if (leadingCommaIdx !== -1) {
-        return [fixer.removeRange([importStart + leadingCommaIdx, specEnd])];
-    }
-    if (namedSpecifiers.length === 1) {
-        return [fixer.remove(untrackedSpec)];
-    }
-    return [fixer.remove(untrackedSpec)];
+    return leadingCommaIdx === -1
+        ? [fixer.remove(untrackedSpec)]
+        : [fixer.removeRange([importStart + leadingCommaIdx, specEnd])];
 }
 
 function hasNamedDecorator(node, name) {
     return node.decorators.some((decorator) => {
         const expression = decorator.expression;
-        if (expression.type === dist$3.AST_NODE_TYPES.Identifier) {
-            return expression.name === name;
-        }
-        return (expression.type === dist$3.AST_NODE_TYPES.CallExpression &&
-            expression.callee.type === dist$3.AST_NODE_TYPES.Identifier &&
-            expression.callee.name === name);
+        return expression.type === dist$3.AST_NODE_TYPES.Identifier
+            ? expression.name === name
+            : expression.type === dist$3.AST_NODE_TYPES.CallExpression &&
+                expression.callee.type === dist$3.AST_NODE_TYPES.Identifier &&
+                expression.callee.name === name;
     });
 }
 
@@ -252086,13 +252013,12 @@ function dedent(text, extraSpaces) {
 
 function isDirectCallOrNewArgument(node) {
     const parent = node.parent;
-    if (node.type !== dist$3.AST_NODE_TYPES.ArrowFunctionExpression &&
-        node.type !== dist$3.AST_NODE_TYPES.FunctionExpression) {
-        return false;
-    }
-    return ((parent.type === dist$3.AST_NODE_TYPES.CallExpression ||
-        parent.type === dist$3.AST_NODE_TYPES.NewExpression) &&
-        parent.arguments.includes(node));
+    return node.type !== dist$3.AST_NODE_TYPES.ArrowFunctionExpression &&
+        node.type !== dist$3.AST_NODE_TYPES.FunctionExpression
+        ? false
+        : (parent.type === dist$3.AST_NODE_TYPES.CallExpression ||
+            parent.type === dist$3.AST_NODE_TYPES.NewExpression) &&
+            parent.arguments.includes(node);
 }
 function isStoredFunctionUsedAsCallOrNewArgument(fn, checker, esTreeNodeToTSNodeMap) {
     const parent = fn.parent;
@@ -252163,29 +252089,26 @@ function isAllowedDeferredCallbackContext(node, checker, esTreeNodeToTSNodeMap)
         return false;
     }
     const fn = getEnclosingFunction(node);
-    if (!fn) {
-        return false;
-    }
-    return (isDirectCallOrNewArgument(fn) ||
-        isStoredFunctionUsedAsCallOrNewArgument(fn, checker, esTreeNodeToTSNodeMap));
+    return fn
+        ? isDirectCallOrNewArgument(fn) ||
+            isStoredFunctionUsedAsCallOrNewArgument(fn, checker, esTreeNodeToTSNodeMap)
+        : false;
 }
 function isAllowedLazyAngularFactoryContext(node, program) {
     const fn = getEnclosingFunction(node);
-    if (!fn || !getReturnedReactiveOwnerCall(node, program)) {
-        return false;
-    }
-    return (isAngularInjectionTokenFactoryFunction(fn, program) ||
-        isAngularUseFactoryFunction(fn));
+    return !fn || !getReturnedReactiveOwnerCall(node, program)
+        ? false
+        : isAngularInjectionTokenFactoryFunction(fn, program) ||
+            isAngularUseFactoryFunction(fn);
 }
 function buildReactiveCallReplacement(outerUntrackedCall, reactiveCall, sourceCode) {
     const text = sourceCode.getText(reactiveCall);
-    if (reactiveCall.parent.type !== dist$3.AST_NODE_TYPES.ExpressionStatement ||
-        outerUntrackedCall.parent.type !== dist$3.AST_NODE_TYPES.ExpressionStatement) {
-        return text;
-    }
-    return dedent(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
+    return reactiveCall.parent.type !== dist$3.AST_NODE_TYPES.ExpressionStatement ||
+        outerUntrackedCall.parent.type !== dist$3.AST_NODE_TYPES.ExpressionStatement
+        ? text
+        : dedent(text, reactiveCall.loc.start.column - outerUntrackedCall.parent.loc.start.column);
 }
-const rule$n = createUntrackedRule({
+const rule$p = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -252221,7 +252144,7 @@ const rule$n = createUntrackedRule({
                                 fixer.replaceText(node, buildReactiveCallReplacement(node, reactiveCall, sourceCode)),
                             ];
                             const untrackedLocalName = findUntrackedAlias(program);
-                            const stillUsed = untrackedLocalName !== null &&
+                            const stillUsed = untrackedLocalName != null &&
                                 isUntrackedUsedElsewhere(untrackedLocalName, node);
                             if (!stillUsed) {
                                 fixes.push(...buildImportRemovalFixes(program, fixer, sourceCode));
@@ -252314,7 +252237,7 @@ function hasOpaqueSynchronousCalls(root, checker, esTreeNodeToTSNodeMap, program
     });
     return found;
 }
-const rule$m = createUntrackedRule({
+const rule$o = createUntrackedRule({
     create(context) {
         const { checker, esTreeNodeToTSNodeMap, program, sourceCode } = getTypeAwareRuleContext(context);
         const signalNodeMap = esTreeNodeToTSNodeMap;
@@ -252345,11 +252268,11 @@ const rule$m = createUntrackedRule({
                     ? (fixer) => {
                         const parentStmt = parent;
                         const replacement = buildReplacement(untrackedCall, parentStmt, sourceCode);
-                        if (replacement === null) {
+                        if (replacement == null) {
                             return null;
                         }
                         const untrackedLocalName = findUntrackedAlias(program);
-                        const stillUsed = untrackedLocalName !== null &&
+                        const stillUsed = untrackedLocalName != null &&
                             isUntrackedUsedElsewhere(untrackedLocalName, untrackedCall);
                         const fixes = [fixer.replaceText(parentStmt, replacement)];
                         if (!stillUsed) {
@@ -252396,17 +252319,16 @@ const rule$m = createUntrackedRule({
     name: 'no-useless-untracked',
 });
 
-const rule$l = createRule({
+const rule$n = createRule({
     create(context, [{ printWidth }]) {
         const sourceCode = context.sourceCode;
         const getLineEndIndex = (lineStartIndex) => {
             const text = sourceCode.text;
             const newLineIndex = text.indexOf('\n', lineStartIndex);
             const rawEndIndex = newLineIndex === -1 ? text.length : newLineIndex;
-            if (rawEndIndex > lineStartIndex && text[rawEndIndex - 1] === '\r') {
-                return rawEndIndex - 1;
-            }
-            return rawEndIndex;
+            return rawEndIndex > lineStartIndex && text[rawEndIndex - 1] === '\r'
+                ? rawEndIndex - 1
+                : rawEndIndex;
         };
         const hasAnyCommentsInside = (node) => sourceCode.getCommentsInside(node).length > 0;
         const isTemplateLikeExpression = (expression) => expression.type === dist$2.AST_NODE_TYPES.TemplateLiteral ||
@@ -252478,34 +252400,28 @@ const rule$l = createRule({
             const valueExpression = property.value;
             // eslint-disable-next-line @typescript-eslint/no-use-before-define
             const valueText = renderExpressionOneLine(valueExpression);
-            if (property.computed) {
-                return `[${keyText}]: ${valueText}`;
-            }
-            return `${keyText}: ${valueText}`;
+            return property.computed
+                ? `[${keyText}]: ${valueText}`
+                : `${keyText}: ${valueText}`;
         };
         const renderObjectExpressionOneLine = (node) => {
             const [onlyProperty] = node.properties;
-            if (!onlyProperty) {
-                return '{}';
-            }
-            return `{${renderPropertyOneLine(onlyProperty)}}`;
+            return onlyProperty ? `{${renderPropertyOneLine(onlyProperty)}}` : '{}';
         };
         const renderExpressionOneLine = (expression) => {
             const innerParen = getParenthesizedInner(expression);
             if (innerParen) {
                 const inner = unwrapExpression(innerParen);
-                if (inner.type === dist$2.AST_NODE_TYPES.ObjectExpression &&
-                    canInlineObjectExpression(inner)) {
-                    return `(${renderObjectExpressionOneLine(inner)})`;
-                }
-                return sourceCode.getText(expression);
+                return inner.type === dist$2.AST_NODE_TYPES.ObjectExpression &&
+                    canInlineObjectExpression(inner)
+                    ? `(${renderObjectExpressionOneLine(inner)})`
+                    : sourceCode.getText(expression);
             }
             const unwrapped = unwrapExpression(expression);
-            if (unwrapped.type === dist$2.AST_NODE_TYPES.ObjectExpression &&
-                canInlineObjectExpression(unwrapped)) {
-                return renderObjectExpressionOneLine(unwrapped);
-            }
-            return sourceCode.getText(expression);
+            return unwrapped.type === dist$2.AST_NODE_TYPES.ObjectExpression &&
+                canInlineObjectExpression(unwrapped)
+                ? renderObjectExpressionOneLine(unwrapped)
+                : sourceCode.getText(expression);
         };
         const hasPendingInnerInlineCandidate = (node) => {
             if (node.properties.length !== 1) {
@@ -252717,7 +252633,7 @@ function renderTest(node, sourceCode) {
     const text = sourceCode.getText(node);
     return needsParenthesesInOrChain(node) ? `(${text})` : text;
 }
-const rule$k = createRule({
+const rule$m = createRule({
     create(context) {
         const { sourceCode } = context;
         function checkBody(statements) {
@@ -252806,6 +252722,270 @@ const rule$k = createRule({
     name: 'prefer-combined-if-control-flow',
 });
 
+const MAX_INLINE_CONDITIONAL_RETURN_LENGTH = 90;
+function getReturnStatement(statement) {
+    if (statement.type === dist$3.AST_NODE_TYPES.ReturnStatement) {
+        return statement;
+    }
+    if (statement.type !== dist$3.AST_NODE_TYPES.BlockStatement || statement.body.length !== 1) {
+        return null;
+    }
+    const [onlyStatement] = statement.body;
+    return onlyStatement?.type === dist$3.AST_NODE_TYPES.ReturnStatement ? onlyStatement : null;
+}
+function hasOnlyWhitespaceBetween(sourceCode, left, right) {
+    return sourceCode.text.slice(left.range[1], right.range[0]).trim() === '';
+}
+function unwrapTypeAndParentheses(node) {
+    let current = node;
+    let didUnwrap = true;
+    while (didUnwrap) {
+        didUnwrap = false;
+        const parenthesized = unwrapParenthesized(current);
+        if (parenthesized !== current) {
+            current = parenthesized;
+            didUnwrap = true;
+            continue;
+        }
+        switch (current.type) {
+            case dist$3.AST_NODE_TYPES.TSAsExpression:
+            case dist$3.AST_NODE_TYPES.TSNonNullExpression:
+            case dist$3.AST_NODE_TYPES.TSSatisfiesExpression:
+            case dist$3.AST_NODE_TYPES.TSTypeAssertion:
+                current = current.expression;
+                didUnwrap = true;
+                break;
+        }
+    }
+    return current;
+}
+function isConditionalExpression(node) {
+    return (node !== null &&
+        unwrapTypeAndParentheses(node).type === dist$3.AST_NODE_TYPES.ConditionalExpression);
+}
+function needsParenthesesInConditionalTest(node) {
+    if (getParenthesizedInner(node)) {
+        return false;
+    }
+    switch (node.type) {
+        case dist$3.AST_NODE_TYPES.ArrowFunctionExpression:
+        case dist$3.AST_NODE_TYPES.AssignmentExpression:
+        case dist$3.AST_NODE_TYPES.ConditionalExpression:
+        case dist$3.AST_NODE_TYPES.ObjectExpression:
+        case dist$3.AST_NODE_TYPES.SequenceExpression:
+        case dist$3.AST_NODE_TYPES.TSAsExpression:
+        case dist$3.AST_NODE_TYPES.TSSatisfiesExpression:
+        case dist$3.AST_NODE_TYPES.TSTypeAssertion:
+        case dist$3.AST_NODE_TYPES.YieldExpression:
+            return true;
+        default:
+            return false;
+    }
+}
+function needsParenthesesInConditionalBranch(node) {
+    if (getParenthesizedInner(node)) {
+        return false;
+    }
+    switch (node.type) {
+        case dist$3.AST_NODE_TYPES.ArrowFunctionExpression:
+        case dist$3.AST_NODE_TYPES.AssignmentExpression:
+        case dist$3.AST_NODE_TYPES.ConditionalExpression:
+        case dist$3.AST_NODE_TYPES.SequenceExpression:
+        case dist$3.AST_NODE_TYPES.TSAsExpression:
+        case dist$3.AST_NODE_TYPES.TSSatisfiesExpression:
+        case dist$3.AST_NODE_TYPES.TSTypeAssertion:
+        case dist$3.AST_NODE_TYPES.YieldExpression:
+            return true;
+        default:
+            return false;
+    }
+}
+function renderExpression(node, sourceCode, needsParentheses) {
+    const text = sourceCode.getText(node);
+    return needsParentheses(node) ? `(${text})` : text;
+}
+function getStatementIndent(node, sourceCode) {
+    const lineStart = sourceCode.getIndexFromLoc({
+        column: 0,
+        line: node.loc.start.line,
+    });
+    return sourceCode.text.slice(lineStart, node.range[0]);
+}
+function renderConditionalReturn(ifStatement, consequentExpression, alternateExpression, sourceCode) {
+    const test = renderExpression(ifStatement.test, sourceCode, needsParenthesesInConditionalTest);
+    const consequent = renderExpression(consequentExpression, sourceCode, needsParenthesesInConditionalBranch);
+    const alternate = renderExpression(alternateExpression, sourceCode, needsParenthesesInConditionalBranch);
+    const inlineReturn = `return ${test} ? ${consequent} : ${alternate};`;
+    const indent = getStatementIndent(ifStatement, sourceCode);
+    if (indent.length + inlineReturn.length <= MAX_INLINE_CONDITIONAL_RETURN_LENGTH) {
+        return inlineReturn;
+    }
+    const branchIndent = `${indent}    `;
+    return `return ${test}\n${branchIndent}? ${consequent}\n${branchIndent}: ${alternate};`;
+}
+const rule$l = createRule({
+    create(context) {
+        const { sourceCode } = context;
+        function checkBody(statements) {
+            for (const [index, statement] of statements.entries()) {
+                if (statement.type !== dist$3.AST_NODE_TYPES.IfStatement) {
+                    continue;
+                }
+                const nextStatement = statements[index + 1];
+                if (nextStatement?.type !== dist$3.AST_NODE_TYPES.ReturnStatement) {
+                    continue;
+                }
+                const consequentReturn = getReturnStatement(statement.consequent);
+                const finalReturn = nextStatement;
+                const consequentArgument = consequentReturn?.argument ?? null;
+                const finalArgument = finalReturn.argument;
+                if (statement.alternate ||
+                    !consequentArgument ||
+                    !finalArgument ||
+                    isConditionalExpression(consequentArgument) ||
+                    isConditionalExpression(finalArgument) ||
+                    !hasOnlyWhitespaceBetween(sourceCode, statement, finalReturn) ||
+                    sourceCode.getCommentsInside(statement).length > 0 ||
+                    sourceCode.getCommentsInside(finalReturn).length > 0) {
+                    continue;
+                }
+                context.report({
+                    fix(fixer) {
+                        const replacement = renderConditionalReturn(statement, consequentArgument, finalArgument, sourceCode);
+                        return fixer.replaceTextRange([statement.range[0], finalReturn.range[1]], replacement);
+                    },
+                    messageId: 'preferConditionalReturn',
+                    node: statement,
+                });
+            }
+        }
+        return {
+            BlockStatement(node) {
+                checkBody(node.body);
+            },
+            Program(node) {
+                checkBody(node.body);
+            },
+            SwitchCase(node) {
+                checkBody(node.consequent);
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Prefer a single conditional return over an if statement followed by another return statement.',
+        },
+        fixable: 'code',
+        messages: {
+            preferConditionalReturn: 'Replace this if/return pair with a single conditional return.',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'prefer-conditional-return',
+});
+
+function parseStrictNullCheck(node, getText) {
+    if (node.type !== dist$3.AST_NODE_TYPES.BinaryExpression) {
+        return null;
+    }
+    const { left, operator, right } = node;
+    if (operator !== '!==' && operator !== '===') {
+        return null;
+    }
+    if (right.type === dist$3.AST_NODE_TYPES.Literal && right.value === null) {
+        return { comparedWith: 'null', operand: getText(left), strictOp: operator };
+    }
+    if (right.type === dist$3.AST_NODE_TYPES.Identifier && right.name === 'undefined') {
+        return { comparedWith: 'undefined', operand: getText(left), strictOp: operator };
+    }
+    if (left.type === dist$3.AST_NODE_TYPES.Literal && left.value === null) {
+        return { comparedWith: 'null', operand: getText(right), strictOp: operator };
+    }
+    return left.type === dist$3.AST_NODE_TYPES.Identifier && left.name === 'undefined'
+        ? { comparedWith: 'undefined', operand: getText(right), strictOp: operator }
+        : null;
+}
+function isParsedNullCheck(value) {
+    return value !== null;
+}
+function getLooseNullCheck(left, right) {
+    return !isParsedNullCheck(left) ||
+        !isParsedNullCheck(right) ||
+        left.strictOp !== right.strictOp ||
+        left.operand !== right.operand ||
+        left.comparedWith === right.comparedWith
+        ? null
+        : `${left.operand} ${left.strictOp === '!==' ? '!=' : '=='} null`;
+}
+function collectAndLeaves(node) {
+    return node.type === dist$3.AST_NODE_TYPES.LogicalExpression && node.operator === '&&'
+        ? [...collectAndLeaves(node.left), ...collectAndLeaves(node.right)]
+        : [node];
+}
+function isAndChainRoot(node) {
+    return (node.parent.type !== dist$3.AST_NODE_TYPES.LogicalExpression ||
+        node.parent.operator !== '&&');
+}
+function findLooseNullCheckMatch(parsedChecks) {
+    for (const [firstCheckIndex, firstCheck] of parsedChecks.entries()) {
+        if (!isParsedNullCheck(firstCheck)) {
+            continue;
+        }
+        for (let secondCheckIndex = firstCheckIndex + 1; secondCheckIndex < parsedChecks.length; secondCheckIndex++) {
+            const replacement = getLooseNullCheck(firstCheck, parsedChecks[secondCheckIndex] ?? null);
+            if (replacement !== null) {
+                return { firstCheckIndex, replacement, secondCheckIndex };
+            }
+        }
+    }
+    return null;
+}
+const rule$k = createRule({
+    create(context) {
+        const getText = (n) => context.sourceCode.getText(n);
+        return {
+            /**
+             * Handles only paired null/undefined checks in the same `&&` chain.
+             */
+            LogicalExpression(node) {
+                if (node.operator !== '&&' || !isAndChainRoot(node)) {
+                    return;
+                }
+                const leaves = collectAndLeaves(node);
+                const parsedChecks = leaves.map((leaf) => parseStrictNullCheck(leaf, getText));
+                const match = findLooseNullCheckMatch(parsedChecks);
+                if (match === null) {
+                    return;
+                }
+                const replacement = leaves
+                    .filter((_, index) => index !== match.secondCheckIndex)
+                    .map((leaf, index) => index === match.firstCheckIndex
+                    ? match.replacement
+                    : getText(leaf))
+                    .join(' && ');
+                context.report({
+                    fix: (fixer) => fixer.replaceText(node, replacement),
+                    messageId: 'preferLooseNullCheck',
+                    node,
+                });
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Prefer loose null checks over paired strict comparisons against `null` and `undefined`.',
+        },
+        fixable: 'code',
+        messages: {
+            preferLooseNullCheck: 'Prefer loose null check over paired strict comparisons against `null` and `undefined`.',
+        },
+        schema: [],
+        type: 'suggestion',
+    },
+    name: 'prefer-loose-null-check',
+});
+
 function getPushCall(node) {
     if (node.expression.type !== dist$3.AST_NODE_TYPES.CallExpression) {
         return null;
@@ -252815,10 +252995,9 @@ function getPushCall(node) {
         return null;
     }
     const { property } = call.callee;
-    if (property.type !== dist$3.AST_NODE_TYPES.Identifier || property.name !== 'push') {
-        return null;
-    }
-    return call;
+    return property.type !== dist$3.AST_NODE_TYPES.Identifier || property.name !== 'push'
+        ? null
+        : call;
 }
 const rule$j = createRule({
     create(context) {
@@ -252866,10 +253045,12 @@ const rule$j = createRule({
                                             .map((arg) => sourceCode.getText(arg))
                                             .join(', ');
                                         const lastStmt = group[group.length - 1];
-                                        if (!lastStmt) {
-                                            return null;
-                                        }
-                                        return fixer.replaceTextRange([groupStmt.range[0], lastStmt.range[1]], `${arrayText}.push(${allArgs});`);
+                                        return lastStmt
+                                            ? fixer.replaceTextRange([
+                                                groupStmt.range[0],
+                                                lastStmt.range[1],
+                                            ], `${arrayText}.push(${allArgs});`)
+                                            : null;
                                     },
                                 }
                                 : {}),
@@ -252909,10 +253090,9 @@ function getModuleKeywordToken(sourceCode, node) {
     if (!firstToken) {
         return null;
     }
-    if (firstToken.value === 'declare') {
-        return sourceCode.getTokenAfter(firstToken) ?? null;
-    }
-    return firstToken;
+    return firstToken.value === 'declare'
+        ? (sourceCode.getTokenAfter(firstToken) ?? null)
+        : firstToken;
 }
 const rule$i = createRule({
     create(context) {
@@ -253009,20 +253189,18 @@ function unwrapUsageExpression(node) {
 }
 function isStatementPositionCall(node) {
     const usage = unwrapUsageExpression(node);
-    if (usage.parent?.type === dist$3.AST_NODE_TYPES.ExpressionStatement) {
-        return true;
-    }
-    return (usage.parent?.type === dist$3.AST_NODE_TYPES.AwaitExpression &&
-        usage.parent.parent.type === dist$3.AST_NODE_TYPES.ExpressionStatement);
+    return usage.parent?.type === dist$3.AST_NODE_TYPES.ExpressionStatement
+        ? true
+        : usage.parent?.type === dist$3.AST_NODE_TYPES.AwaitExpression &&
+            usage.parent.parent.type === dist$3.AST_NODE_TYPES.ExpressionStatement;
 }
 function isConsoleMethodCall(node) {
-    if (node.callee.type !== dist$3.AST_NODE_TYPES.MemberExpression ||
+    return node.callee.type !== dist$3.AST_NODE_TYPES.MemberExpression ||
         node.callee.object.type !== dist$3.AST_NODE_TYPES.Identifier ||
         node.callee.object.name !== 'console' ||
-        node.callee.property.type !== dist$3.AST_NODE_TYPES.Identifier) {
-        return false;
-    }
-    return CONSOLE_METHODS.has(node.callee.property.name);
+        node.callee.property.type !== dist$3.AST_NODE_TYPES.Identifier
+        ? false
+        : CONSOLE_METHODS.has(node.callee.property.name);
 }
 function isDomImperativeCall(node, checker, esTreeNodeToTSNodeMap) {
     if (node.callee.type === dist$3.AST_NODE_TYPES.MemberExpression &&
@@ -253044,14 +253222,13 @@ function isDomImperativeCall(node, checker, esTreeNodeToTSNodeMap) {
     return returnType === 'void' || returnType === 'Promise<void>';
 }
 function isSuspiciousDomCallArgumentConsumer(node, checker, esTreeNodeToTSNodeMap, program) {
-    if (isAngularUntrackedCall(node, program) ||
+    return isAngularUntrackedCall(node, program) ||
         isSignalReadCall(node, checker, esTreeNodeToTSNodeMap) ||
         isWritableSignalWrite(node, checker, esTreeNodeToTSNodeMap) ||
         !isStatementPositionCall(node) ||
-        isConsoleMethodCall(node)) {
-        return false;
-    }
-    return isDomImperativeCall(node, checker, esTreeNodeToTSNodeMap);
+        isConsoleMethodCall(node)
+        ? false
+        : isDomImperativeCall(node, checker, esTreeNodeToTSNodeMap);
 }
 function isAliasDeclarationIdentifier(node) {
     return (node.type === dist$3.AST_NODE_TYPES.Identifier &&
@@ -253191,15 +253368,14 @@ const rule$h = createUntrackedRule({
         const estreeNodeMap = tsNodeToESTreeNodeMap;
         function buildFix(read) {
             const untrackedAlias = findUntrackedAlias(program);
-            const alreadyHasUntracked = untrackedAlias !== null;
+            const alreadyHasUntracked = untrackedAlias != null;
             const wrapped = buildUntrackedWrap(read, sourceCode, untrackedAlias ?? 'untracked');
-            if (alreadyHasUntracked) {
-                return (fixer) => [fixer.replaceText(read, wrapped)];
-            }
-            return (fixer) => [
-                fixer.replaceText(read, wrapped),
-                ...buildUntrackedImportFixes(program, fixer),
-            ];
+            return alreadyHasUntracked
+                ? (fixer) => [fixer.replaceText(read, wrapped)]
+                : (fixer) => [
+                    fixer.replaceText(read, wrapped),
+                    ...buildUntrackedImportFixes(program, fixer),
+                ];
         }
         return {
             CallExpression(node) {
@@ -253248,10 +253424,9 @@ function getReturnedExpression(node) {
         return null;
     }
     const statement = node.body.body[0];
-    if (statement?.type !== dist$3.AST_NODE_TYPES.ReturnStatement || !statement.argument) {
-        return null;
-    }
-    return statement.argument;
+    return statement?.type !== dist$3.AST_NODE_TYPES.ReturnStatement || !statement.argument
+        ? null
+        : statement.argument;
 }
 
 function getWrappedSignalGetter(node, checker, esTreeNodeToTSNodeMap) {
@@ -253521,13 +253696,13 @@ const VALID_CONTAINERS = new Set(['menu', 'ol', 'ul']);
  */
 function isElement(node) {
     return (typeof node === 'object' &&
-        node !== null &&
+        node != null &&
         typeof node['name'] === 'string' &&
         Array.isArray(node['children']));
 }
 function getClosestParentElement(node) {
     let current = node['parent'];
-    while (current !== null && current !== undefined) {
+    while (current != null) {
         if (isElement(current)) {
             return current;
         }
@@ -253651,10 +253826,9 @@ function isImportsArrayProperty(property) {
 }
 
 function getImportedName$1(spec) {
-    if (spec.imported.type === dist$3.AST_NODE_TYPES.Identifier) {
-        return spec.imported.name;
-    }
-    return spec.imported.value;
+    return spec.imported.type === dist$3.AST_NODE_TYPES.Identifier
+        ? spec.imported.name
+        : spec.imported.value;
 }
 
 const MESSAGE_ID$3 = 'replaceTuiImport';
@@ -253851,10 +254025,7 @@ function getLineBreak(text) {
     if (text.includes('\r\n')) {
         return '\r\n';
     }
-    if (text.includes('\r')) {
-        return '\r';
-    }
-    return '\n';
+    return text.includes('\r') ? '\r' : '\n';
 }
 function getLeadingIndentation(text) {
     let index = 0;
@@ -253968,11 +254139,10 @@ function getVariableSpacingStatement(node) {
     if (node.type === dist$3.AST_NODE_TYPES.VariableDeclaration) {
         return { declaration: node, exported: false, node };
     }
-    if (node.type !== dist$3.AST_NODE_TYPES.ExportNamedDeclaration ||
-        node.declaration?.type !== dist$3.AST_NODE_TYPES.VariableDeclaration) {
-        return null;
-    }
-    return { declaration: node.declaration, exported: true, node };
+    return node.type !== dist$3.AST_NODE_TYPES.ExportNamedDeclaration ||
+        node.declaration?.type !== dist$3.AST_NODE_TYPES.VariableDeclaration
+        ? null
+        : { declaration: node.declaration, exported: true, node };
 }
 function isRequireCall(node) {
     return (node.type === dist$3.AST_NODE_TYPES.CallExpression &&
@@ -253994,10 +254164,9 @@ function isImportLikeInitializer(node) {
     if (initializer.type === dist$3.AST_NODE_TYPES.MemberExpression) {
         return isImportLikeInitializer(initializer.object);
     }
-    if (initializer.type === dist$3.AST_NODE_TYPES.CallExpression) {
-        return isImportLikeInitializer(initializer.callee);
-    }
-    return false;
+    return initializer.type === dist$3.AST_NODE_TYPES.CallExpression
+        ? isImportLikeInitializer(initializer.callee)
+        : false;
 }
 function isImportLikeVariableDeclaration(declaration) {
     if (declaration.declarations.length !== 1) {
@@ -254005,10 +254174,7 @@ function isImportLikeVariableDeclaration(declaration) {
     }
     const [declarator] = declaration.declarations;
     const init = declarator.init;
-    if (!init) {
-        return false;
-    }
-    return isImportLikeInitializer(init);
+    return init ? isImportLikeInitializer(init) : false;
 }
 const rule$7 = createRule({
     create(context) {
@@ -254199,7 +254365,7 @@ const rule$6 = createRule({
                     if (!arr) {
                         continue;
                     }
-                    const elements = arr.elements.filter((el) => el !== null);
+                    const elements = arr.elements.filter((el) => el != null);
                     if (elements.length <= 1) {
                         continue;
                     }
@@ -254417,12 +254583,11 @@ function getConstArray(node) {
 
 function isClassType(type) {
     const symbol = type.getSymbol();
-    if (!symbol) {
-        return false;
-    }
-    return (symbol
-        .getDeclarations()
-        ?.some((d) => ts.isClassDeclaration(d) || ts.isClassExpression(d)) ?? false);
+    return symbol
+        ? (symbol
+            .getDeclarations()
+            ?.some((d) => ts.isClassDeclaration(d) || ts.isClassExpression(d)) ?? false)
+        : false;
 }
 
 function isExternalPureTuple(typeChecker, type) {
@@ -254431,10 +254596,7 @@ function isExternalPureTuple(typeChecker, type) {
     }
     const typeRef = type;
     const typeArgs = typeChecker.getTypeArguments(typeRef);
-    if (typeArgs.length === 0) {
-        return false;
-    }
-    return typeArgs.every((item) => isClassType(item));
+    return typeArgs.length === 0 ? false : typeArgs.every((item) => isClassType(item));
 }
 
 const MESSAGE_ID$2 = 'spreadArrays';
@@ -254445,7 +254607,7 @@ const rule$3 = createRule({
         const purityCache = new WeakMap();
         const isPureArray = (arr) => {
             const cachedPurity = purityCache.get(arr);
-            if (cachedPurity !== undefined) {
+            if (cachedPurity != null) {
                 return cachedPurity;
             }
             if (arr.isDirty) {
@@ -254614,7 +254776,7 @@ const config = {
                 }
                 for (const attr of node.inputs) {
                     const attrValue = getLiteralStringValue(attr);
-                    if (attrValue !== null) {
+                    if (attrValue != null) {
                         checkAttribute(context, attr, attrValue, checkers);
                     }
                 }
@@ -254788,10 +254950,7 @@ function normalizeImportFilter(importFilter) {
 function getRootPackageName(importPath) {
     if (importPath.startsWith('@')) {
         const segments = importPath.split('/');
-        if (segments.length < 2) {
-            return null;
-        }
-        return `${segments[0]}/${segments[1]}`;
+        return segments.length < 2 ? null : `${segments[0]}/${segments[1]}`;
     }
     const parts = importPath.split('/');
     return parts[0] ?? null;
@@ -254848,14 +255007,13 @@ function findNestedEntryPointRelativePaths(rootEntryDirectory) {
     return [...new Set(directories)];
 }
 function selectCandidateEntryPointsForMode(allNestedRelativePaths, strict) {
-    if (!strict) {
-        return allNestedRelativePaths.filter((relativePath) => !relativePath.includes('/'));
-    }
-    return [...allNestedRelativePaths].sort((a, b) => {
-        const depthA = a.split('/').filter(Boolean).length;
-        const depthB = b.split('/').filter(Boolean).length;
-        return depthB - depthA;
-    });
+    return strict
+        ? [...allNestedRelativePaths].sort((a, b) => {
+            const depthA = a.split('/').filter(Boolean).length;
+            const depthB = b.split('/').filter(Boolean).length;
+            return depthB - depthA;
+        })
+        : allNestedRelativePaths.filter((relativePath) => !relativePath.includes('/'));
 }
 function mapSymbolsToEntryPointsUsingTypeChecker({ candidateEntryPoints, importedSymbols, rootEntryDirectory, state, }) {
     const symbolToEntryPoint = new Map();
@@ -255006,10 +255164,9 @@ function buildImportStatement({ importKind, importPath, specifiers, state, }) {
     if (namedSpecifiers.length > 0) {
         clauses.push(`{${namedSpecifiers.map((specifier) => state.sourceCode.getText(specifier)).join(', ')}}`);
     }
-    if (clauses.length === 0) {
-        return null;
-    }
-    return `${importKeyword} ${clauses.join(', ')} from '${importPath}';`;
+    return clauses.length === 0
+        ? null
+        : `${importKeyword} ${clauses.join(', ')} from '${importPath}';`;
 }
 
 function getTypeName(param) {
@@ -255120,42 +255277,44 @@ const plugin = {
     },
     rules: {
         'array-as-const': rule$5,
-        'attrs-newline': rule$P,
+        'attrs-newline': rule$R,
         'class-property-naming': rule$4,
-        'decorator-key-sort': rule$O,
-        'element-newline': rule$N,
+        'decorator-key-sort': rule$Q,
+        'element-newline': rule$P,
         'flat-exports': rule$3,
-        '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,
+        'host-attributes-sort': rule$O,
+        'html-logical-properties': rule$N,
+        'import-integrity': rule$M,
+        'injection-token-description': rule$L,
+        'no-commonjs-import-patterns': rule$K,
+        'no-deep-imports': rule$J,
+        'no-deep-imports-to-indexed-packages': rule$I,
+        'no-duplicate-attrs': rule$H,
+        'no-duplicate-id': rule$G,
+        'no-duplicate-in-head': rule$F,
+        'no-fully-untracked-effect': rule$E,
+        'no-href-with-router-link': rule$D,
+        'no-implicit-public': rule$C,
+        'no-import-assertions': rule$B,
+        'no-infinite-loop': rule$A,
+        'no-legacy-peer-deps': rule$z,
+        'no-obsolete-attrs': rule$y,
+        'no-obsolete-tags': rule$x,
+        'no-playwright-empty-fill': rule$w,
+        'no-project-as-in-ng-template': rule$v,
+        'no-redundant-type-annotation': rule$u,
+        'no-repeated-signal-in-conditional': rule$t,
         'no-restricted-attr-values': rule$2,
-        'no-side-effects-in-computed': rule$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,
+        'no-side-effects-in-computed': rule$s,
+        'no-signal-reads-after-await-in-reactive-context': rule$r,
+        'no-string-literal-concat': rule$q,
+        'no-untracked-outside-reactive-context': rule$p,
+        'no-useless-untracked': rule$o,
+        'object-single-line': rule$n,
+        'prefer-combined-if-control-flow': rule$m,
+        'prefer-conditional-return': rule$l,
         'prefer-deep-imports': rule$1,
+        'prefer-loose-null-check': rule$k,
         'prefer-multi-arg-push': rule$j,
         'prefer-namespace-keyword': rule$i,
         'prefer-untracked-incidental-signal-reads': rule$h,