lint-suite 1.6.2 → 1.6.3

package/eslint.js

@@ -1,11 +1,677 @@
 // packages/lint-suite/src/lib/angular-template.ts
 import { configs } from "angular-eslint";
 import { defineConfig } from "eslint/config";
+
+// packages/lint-suite/src/lib/rules/define-plugin.util.ts
+var definePlugin = (name, rules) => {
+  const meta7 = { name };
+  const plugin = { meta: meta7, rules };
+  return plugin;
+};
+
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/no-unstyled-classes.ts
+import { ESLintUtils } from "@typescript-eslint/utils";
+
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/component-stylesheets.ts
+import { existsSync } from "node:fs";
+import { dirname, resolve } from "node:path";
+
+// packages/lint-suite/src/lib/rules/component-metadata.ts
+import { readFileSync } from "node:fs";
+import {
+  ScriptTarget,
+  canHaveDecorators,
+  createSourceFile,
+  forEachChild,
+  getDecorators,
+  isArrayLiteralExpression,
+  isCallExpression,
+  isIdentifier,
+  isObjectLiteralExpression,
+  isPropertyAssignment,
+  isStringLiteralLike
+} from "typescript";
+var componentArgument = (decorator) => {
+  const { expression } = decorator;
+  if (!isCallExpression(expression)) return null;
+  if (!isIdentifier(expression.expression)) return null;
+  const isComponent = expression.expression.text === "Component";
+  if (!isComponent) return null;
+  const [argument] = expression.arguments;
+  if (argument === void 0) return null;
+  if (!isObjectLiteralExpression(argument)) return null;
+  return argument;
+};
+var decoratedMetadata = (node) => {
+  if (!canHaveDecorators(node)) return null;
+  const decorators = getDecorators(node) ?? [];
+  for (const decorator of decorators) {
+    const metadata = componentArgument(decorator);
+    if (metadata !== null) return metadata;
+  }
+  return null;
+};
+var parseComponentMetadata = (text2, path) => {
+  const found = [];
+  const visit = (node) => {
+    const metadata = decoratedMetadata(node);
+    if (metadata !== null) found.push(metadata);
+    forEachChild(node, visit);
+  };
+  const source = createSourceFile(path, text2, ScriptTarget.Latest, true);
+  forEachChild(source, visit);
+  return found;
+};
+var componentMetadata = (path) => {
+  try {
+    const text2 = readFileSync(path, "utf8");
+    return parseComponentMetadata(text2, path);
+  } catch {
+    return [];
+  }
+};
+var literalText = (node) => {
+  if (!isStringLiteralLike(node)) return null;
+  return node.text;
+};
+var literalTexts = (node) => {
+  const single = literalText(node);
+  if (single !== null) return [single];
+  if (!isArrayLiteralExpression(node)) return [];
+  const texts = [];
+  for (const element of node.elements) {
+    const text2 = literalText(element);
+    if (text2 !== null) texts.push(text2);
+  }
+  return texts;
+};
+var metadataValue = (metadata, name) => {
+  for (const property of metadata.properties) {
+    if (!isPropertyAssignment(property)) continue;
+    if (!isIdentifier(property.name)) continue;
+    const isMatch = property.name.text === name;
+    if (isMatch) return property.initializer;
+  }
+  return null;
+};
+var metadataTexts = (metadata, name) => {
+  const value = metadataValue(metadata, name);
+  if (value === null) return [];
+  return literalTexts(value);
+};
+
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/component-stylesheets.ts
+var SIBLING_EXTENSIONS = [".scss", ".css"];
+var HTML_EXTENSION = /\.html$/iu;
+var matchesTemplate = (metadata, directory, templateFilename) => {
+  const urls = metadataTexts(metadata, "templateUrl");
+  const [templateUrl] = urls;
+  if (templateUrl === void 0) return false;
+  const declared = resolve(directory, templateUrl);
+  const linted = resolve(templateFilename);
+  return declared === linted;
+};
+var templateMetadata = (componentPath, templateFilename) => {
+  const components = componentMetadata(componentPath);
+  const directory = dirname(componentPath);
+  const matches = (metadata) => {
+    return matchesTemplate(metadata, directory, templateFilename);
+  };
+  const matched = components.find(matches);
+  if (matched !== void 0) return matched;
+  const isOnly = components.length === 1;
+  if (!isOnly) return null;
+  const [only] = components;
+  return only ?? null;
+};
+var stylesheetFiles = (paths, directory) => {
+  const sources = [];
+  for (const path of paths) {
+    const resolved = resolve(directory, path);
+    const isPresent = existsSync(resolved);
+    if (!isPresent) continue;
+    const source = { kind: "file", path: resolved };
+    sources.push(source);
+  }
+  return sources;
+};
+var inlineSources = (styles, componentPath) => {
+  const sourceOf = (style) => {
+    const source = {
+      kind: "inline",
+      source: style,
+      path: componentPath
+    };
+    return source;
+  };
+  return styles.map(sourceOf);
+};
+var metadataSources = (componentPath, templateFilename) => {
+  const metadata = templateMetadata(componentPath, templateFilename);
+  if (metadata === null) return [];
+  const singleUrl = metadataTexts(metadata, "styleUrl");
+  const listedUrls = metadataTexts(metadata, "styleUrls");
+  const styles = metadataTexts(metadata, "styles");
+  const directory = dirname(componentPath);
+  const urls = [...singleUrl, ...listedUrls];
+  const files = stylesheetFiles(urls, directory);
+  const inline = inlineSources(styles, componentPath);
+  return [...files, ...inline];
+};
+var siblingSources = (templateFilename) => {
+  const base2 = templateFilename.replace(HTML_EXTENSION, "");
+  const candidateOf = (extension) => `${base2}${extension}`;
+  const candidates = SIBLING_EXTENSIONS.map(candidateOf);
+  return stylesheetFiles(candidates, dirname(templateFilename));
+};
+var componentStylesheets = (templateFilename) => {
+  const componentPath = templateFilename.replace(HTML_EXTENSION, ".ts");
+  const sources = metadataSources(componentPath, templateFilename);
+  if (sources.length > 0) return sources;
+  return siblingSources(templateFilename);
+};
+
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/stylesheet-classes.ts
+import { readFileSync as readFileSync2, statSync } from "node:fs";
+import { dirname as dirname3 } from "node:path";
+import { parse } from "postcss-scss";
+
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/stylesheet-imports.ts
+import { existsSync as existsSync2 } from "node:fs";
+import { basename, dirname as dirname2, join, resolve as resolve2 } from "node:path";
+var QUOTED = /'([^']*)'|"([^"]*)"/u;
+var SKIPPED_PREFIXES = ["sass:", "http", "url("];
+var specifierOf = (params) => {
+  const match = QUOTED.exec(params);
+  if (!match) return null;
+  return match[1] ?? match[2] ?? null;
+};
+var isResolvable = (specifier) => {
+  const isEmpty = specifier.length === 0;
+  if (isEmpty) return false;
+  const isSkipped = SKIPPED_PREFIXES.some(
+    (prefix) => specifier.startsWith(prefix)
+  );
+  if (isSkipped) return false;
+  return !specifier.endsWith(".css");
+};
+var candidatesOf = (path) => {
+  const isStylesheet = path.endsWith(".scss");
+  if (isStylesheet) return [path, join(dirname2(path), `_${basename(path)}`)];
+  const partial = join(dirname2(path), `_${basename(path)}.scss`);
+  return [
+    `${path}.scss`,
+    partial,
+    join(path, "index.scss"),
+    join(path, "_index.scss")
+  ];
+};
+var resolveStylesheetImport = (params, directory) => {
+  const specifier = specifierOf(params);
+  if (specifier === null) return null;
+  const isCandidate = isResolvable(specifier);
+  if (!isCandidate) return null;
+  const path = resolve2(directory, specifier);
+  const candidates = candidatesOf(path);
+  const existing = candidates.find((candidate) => existsSync2(candidate));
+  return existing ?? null;
+};
+
+// packages/lint-suite/src/lib/rules/utils/selector-classes.util.ts
+import selectorParser from "postcss-selector-parser";
+var INTERPOLATION_TOKEN = "zzinterpzz";
+var PARENT_TOKEN = "zzparentzz";
+var UNKNOWN_PARENT_SELECTOR = `.${PARENT_TOKEN}`;
+var UNKNOWN_PARTS = new RegExp(
+  `${INTERPOLATION_TOKEN}|${PARENT_TOKEN}`,
+  "gu"
+);
+var INTERPOLATION = /#\{[^}]*\}/gu;
+var REGEXP_META = /[.*+?^${}()|[\]\\]/gu;
+var escapeRegExp = (part) => {
+  return part.replaceAll(REGEXP_META, "\\$&");
+};
+var classNamePattern = (value) => {
+  const literals = value.split(UNKNOWN_PARTS).map(escapeRegExp);
+  const joined = literals.join(".*");
+  return `^${joined}$`;
+};
+var withoutParent = (selector) => {
+  return selector.replaceAll("&", UNKNOWN_PARENT_SELECTOR);
+};
+var withParent = (selector, parent) => {
+  const hasNesting = selector.includes("&");
+  if (hasNesting) return selector.replaceAll("&", parent);
+  return `${parent} ${selector}`;
+};
+var resolveSelectors = (selectors, parents) => {
+  const hasParents = parents.length > 0;
+  if (!hasParents) return selectors.map(withoutParent);
+  const resolved = [];
+  for (const parent of parents) {
+    for (const selector of selectors) {
+      resolved.push(withParent(selector, parent));
+    }
+  }
+  return resolved;
+};
+var selectorClasses = (selector) => {
+  const exact = [];
+  const patterns = [];
+  const normalized = selector.replaceAll(INTERPOLATION, INTERPOLATION_TOKEN);
+  const collect2 = (node) => {
+    const isBareParent = node.value === PARENT_TOKEN;
+    if (isBareParent) return;
+    const hasInterpolation = node.value.includes(INTERPOLATION_TOKEN);
+    const hasUnknownParent = node.value.includes(PARENT_TOKEN);
+    const isDynamic = hasInterpolation || hasUnknownParent;
+    if (isDynamic) {
+      patterns.push(classNamePattern(node.value));
+      return;
+    }
+    exact.push(node.value);
+  };
+  try {
+    const root = selectorParser().astSync(normalized);
+    root.walkClasses(collect2);
+  } catch {
+    const empty = { exact: [], patterns: [] };
+    return empty;
+  }
+  const classes = { exact, patterns };
+  return classes;
+};
+var classMatcher = (exact, patterns) => {
+  const matches = (name) => {
+    const isExact = exact.has(name);
+    if (isExact) return true;
+    return patterns.some((pattern) => pattern.test(name));
+  };
+  return matches;
+};
+
+// packages/lint-suite/src/lib/rules/utils/resolved-rules.util.ts
+var walkContainer = (container, parents, visit) => {
+  for (const node of container.nodes ?? []) {
+    if (node.type === "rule") {
+      const resolved = resolveSelectors(node.selectors, parents);
+      visit(node, resolved, parents);
+      walkContainer(node, resolved, visit);
+      continue;
+    }
+    if (node.type !== "atrule") continue;
+    walkContainer(node, parents, visit);
+  }
+};
+var walkResolvedRules = (root, visit) => {
+  walkContainer(root, [], visit);
+};
+
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/stylesheet-collection.ts
+var IMPORT_AT_RULES = /* @__PURE__ */ new Set(["use", "import", "forward"]);
+var addSelectors = (selectors, entry) => {
+  for (const selector of selectors) {
+    const { exact, patterns } = selectorClasses(selector);
+    entry.classes.push(...exact);
+    entry.patterns.push(...patterns);
+  }
+};
+var addImport = (node, entry, directory) => {
+  const isImport = IMPORT_AT_RULES.has(node.name);
+  if (!isImport) return;
+  const imported = resolveStylesheetImport(node.params, directory);
+  if (imported !== null) entry.imports.push(imported);
+};
+var collectStylesheet = (root, directory) => {
+  const entry = { classes: [], patterns: [], imports: [] };
+  const onRule = (_rule, resolved) => {
+    addSelectors(resolved, entry);
+  };
+  const onAtRule = (node) => {
+    addImport(node, entry, directory);
+  };
+  walkResolvedRules(root, onRule);
+  root.walkAtRules(onAtRule);
+  return entry;
+};
+
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/stylesheet-classes.ts
+var stylesheets = /* @__PURE__ */ new Map();
+var emptyEntry = () => {
+  const entry = { classes: [], patterns: [], imports: [] };
+  return entry;
+};
+var parseStylesheet = (source, path) => {
+  try {
+    const root = parse(source, { from: path });
+    return collectStylesheet(root, dirname3(path));
+  } catch {
+    return emptyEntry();
+  }
+};
+var fileEntry = (path) => {
+  try {
+    const stats = statSync(path, { bigint: true });
+    const version = `${stats.mtimeNs}:${stats.size}`;
+    const cached = stylesheets.get(path);
+    if (cached?.version === version) return cached.entry;
+    const entry = parseStylesheet(readFileSync2(path, "utf8"), path);
+    const fresh = { entry, version };
+    stylesheets.set(path, fresh);
+    return entry;
+  } catch {
+    return emptyEntry();
+  }
+};
+var addEntry = (entry, sink, visited) => {
+  for (const name of entry.classes) sink.exact.add(name);
+  sink.patterns.push(...entry.patterns);
+  for (const imported of entry.imports) {
+    const isVisited = visited.has(imported);
+    if (isVisited) continue;
+    visited.add(imported);
+    addEntry(fileEntry(imported), sink, visited);
+  }
+};
+var addSource = (source, sink, visited) => {
+  if (source.kind === "file") {
+    const isVisited = visited.has(source.path);
+    if (isVisited) return;
+    visited.add(source.path);
+    addEntry(fileEntry(source.path), sink, visited);
+    return;
+  }
+  addEntry(parseStylesheet(source.source, source.path), sink, visited);
+};
+var toRegExp = (pattern) => {
+  return new RegExp(pattern, "u");
+};
+var stylesheetClasses = (sources) => {
+  const exact = /* @__PURE__ */ new Set();
+  const patterns = [];
+  const sink = { exact, patterns };
+  const visited = /* @__PURE__ */ new Set();
+  for (const source of sources) addSource(source, sink, visited);
+  const compiled = patterns.map(toRegExp);
+  const has = classMatcher(exact, compiled);
+  const size = exact.size + compiled.length;
+  const classes = { has, size };
+  return classes;
+};
+
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/template-stylesheets.ts
+var templateStylesheets = (templateFilename, cwd, globalStyles) => {
+  let known = null;
+  const lookup = () => {
+    if (known !== null) return known;
+    const component = componentStylesheets(templateFilename);
+    const global = stylesheetFiles(globalStyles, cwd);
+    const sources = [...component, ...global];
+    known = stylesheetClasses(sources);
+    return known;
+  };
+  return lookup;
+};
+
+// packages/lint-suite/src/lib/rules/utils/template-classes.util.ts
+import { ParseSourceSpan as ParseSourceSpan2 } from "@angular/compiler";
+
+// packages/lint-suite/src/lib/rules/utils/class-expression-literals.util.ts
+import {
+  Conditional,
+  Interpolation,
+  Lexer,
+  LiteralArray,
+  LiteralMap,
+  LiteralPrimitive,
+  ParseLocation,
+  ParseSourceFile,
+  ParseSourceSpan,
+  Parser
+} from "@angular/compiler";
+var WHITESPACE = /\s+/u;
+var EXPRESSION_FILE = "class-expression";
+var parser = new Parser(new Lexer());
+var spanOf = (source) => {
+  const file = new ParseSourceFile(source, EXPRESSION_FILE);
+  const start = new ParseLocation(file, 0, 0, 0);
+  const span = new ParseSourceSpan(start, start.moveBy(source.length));
+  return span;
+};
+var astOf = (parsed) => {
+  const hasErrors = parsed.errors.length > 0;
+  if (hasErrors) return null;
+  return parsed.ast;
+};
+var parseClassExpression = (source) => {
+  try {
+    const span = spanOf(source);
+    const interpolation = parser.parseInterpolation(source, span, 0, null);
+    if (interpolation) return astOf(interpolation);
+    const binding = parser.parseBinding(source, span, 0);
+    return astOf(binding);
+  } catch {
+    return null;
+  }
+};
+var addNames = (value, names) => {
+  for (const token of value.split(WHITESPACE)) {
+    if (token) names.push(token);
+  }
+};
+var addPrimitive = (ast, names) => {
+  if (typeof ast.value === "string") addNames(ast.value, names);
+};
+var addMapKeys = (ast, names) => {
+  for (const key2 of ast.keys) {
+    if (key2.kind !== "spread") addNames(key2.key, names);
+  }
+};
+var addInterpolation = (ast, names) => {
+  for (const text2 of ast.strings) addNames(text2, names);
+};
+var collect = (ast, names) => {
+  if (ast instanceof LiteralPrimitive) {
+    addPrimitive(ast, names);
+    return;
+  }
+  if (ast instanceof LiteralMap) {
+    addMapKeys(ast, names);
+    return;
+  }
+  if (ast instanceof Interpolation) {
+    addInterpolation(ast, names);
+    return;
+  }
+  if (ast instanceof LiteralArray) {
+    for (const expression of ast.expressions) collect(expression, names);
+    return;
+  }
+  if (ast instanceof Conditional) {
+    collect(ast.trueExp, names);
+    collect(ast.falseExp, names);
+  }
+};
+var classExpressionLiterals = (source) => {
+  const ast = parseClassExpression(source);
+  if (ast === null) return [];
+  const names = [];
+  collect(ast, names);
+  return [...new Set(names)];
+};
+
+// packages/lint-suite/src/lib/rules/utils/template-classes.util.ts
+var CLASS_ATTRIBUTE = "class";
+var CLASS_BINDING_PREFIX = "class.";
+var TOKEN = /\S+/gu;
+var expressionSource = (value) => {
+  if (!("source" in value)) return null;
+  const { source } = value;
+  if (typeof source !== "string") return null;
+  return source;
+};
+var staticClasses = (attribute) => {
+  const classes = [];
+  const valueSpan = attribute.valueSpan ?? attribute.sourceSpan;
+  for (const token of attribute.value.matchAll(TOKEN)) {
+    const start = valueSpan.start.moveBy(token.index);
+    const end = valueSpan.start.moveBy(token.index + token[0].length);
+    const span = new ParseSourceSpan2(start, end);
+    const templateClass = { name: token[0], span };
+    classes.push(templateClass);
+  }
+  return classes;
+};
+var boundClassName = (input) => {
+  const { details } = input.keySpan;
+  if (details === null) return null;
+  const isClassBinding = details.startsWith(CLASS_BINDING_PREFIX);
+  if (!isClassBinding) return null;
+  return input.name;
+};
+var isClassExpression = (input) => {
+  const isClassName = input.name === CLASS_ATTRIBUTE;
+  if (!isClassName) return false;
+  const { details } = input.keySpan;
+  if (details === null) return true;
+  return details === CLASS_ATTRIBUTE;
+};
+var expressionClasses = (input) => {
+  const source = expressionSource(input.value);
+  if (source === null) return [];
+  const names = classExpressionLiterals(source);
+  const templateClassOf = (name) => {
+    const templateClass = { name, span: input.sourceSpan };
+    return templateClass;
+  };
+  return names.map(templateClassOf);
+};
+var inputClasses = (input) => {
+  const bound = boundClassName(input);
+  if (bound !== null) {
+    const templateClass = { name: bound, span: input.keySpan };
+    return [templateClass];
+  }
+  const isExpression = isClassExpression(input);
+  if (!isExpression) return [];
+  return expressionClasses(input);
+};
+var templateClasses = (node) => {
+  const classes = [];
+  for (const attribute of node.attributes) {
+    const isClassName = attribute.name === CLASS_ATTRIBUTE;
+    if (isClassName) classes.push(...staticClasses(attribute));
+  }
+  for (const input of node.inputs) {
+    classes.push(...inputClasses(input));
+  }
+  return classes;
+};
+
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/no-unstyled-classes.ts
+var PARSER_REQUIRED = "no-unstyled-classes requires '@angular-eslint/template-parser'.";
+var docs = {
+  description: "Disallow template class names that no stylesheet of the component selects"
+};
+var messages = {
+  unstyledClass: "Class '{{name}}' is not selected by any stylesheet of this template."
+};
+var stringItems = { type: "string" };
+var ignoreClassPatternsSchema = {
+  type: "array",
+  items: stringItems,
+  description: "Regular expressions for class names that are never reported."
+};
+var globalStylesSchema = {
+  type: "array",
+  items: stringItems,
+  description: "Stylesheets merged into the known classes of every template."
+};
+var properties = {
+  ignoreClassPatterns: ignoreClassPatternsSchema,
+  globalStyles: globalStylesSchema
+};
+var optionsSchema = {
+  type: "object",
+  properties,
+  additionalProperties: false
+};
+var schema = [optionsSchema];
+var meta = {
+  type: "problem",
+  docs,
+  schema,
+  messages
+};
+var ruleDefaults = {
+  ignoreClassPatterns: ["^(js|qa|mat|cdk|mdc)-"],
+  globalStyles: []
+};
+var defaultOptions = [ruleDefaults];
+var createRule = ESLintUtils.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#no-unstyled-classes"
+);
+var isTemplateServices = (services) => {
+  if (!("convertNodeSourceSpanToLoc" in services)) return false;
+  return typeof services.convertNodeSourceSpanToLoc === "function";
+};
+var toRegExp2 = (pattern) => new RegExp(pattern, "u");
+var no_unstyled_classes_default = createRule({
+  name: "no-unstyled-classes",
+  meta,
+  defaultOptions,
+  create(context, [options]) {
+    const { parserServices } = context.sourceCode;
+    if (parserServices === void 0) throw new Error(PARSER_REQUIRED);
+    if (!isTemplateServices(parserServices)) throw new Error(PARSER_REQUIRED);
+    const ignored = options.ignoreClassPatterns.map(toRegExp2);
+    const stylesheets2 = templateStylesheets(
+      context.filename,
+      context.cwd,
+      options.globalStyles
+    );
+    const listeners = {
+      Element(node) {
+        const isCustomElement = node.name.includes("-");
+        if (isCustomElement) return;
+        const classes = templateClasses(node);
+        if (classes.length === 0) return;
+        const known = stylesheets2();
+        if (known.size === 0) return;
+        for (const { name, span } of classes) {
+          const isIgnored = ignored.some((pattern) => pattern.test(name));
+          if (isIgnored) continue;
+          const isStyled = known.has(name);
+          if (isStyled) continue;
+          const loc = parserServices.convertNodeSourceSpanToLoc(span);
+          const data = { name };
+          const report = {
+            loc,
+            messageId: "unstyledClass",
+            data
+          };
+          context.report(report);
+        }
+      }
+    };
+    return listeners;
+  }
+});
+
+// packages/lint-suite/src/lib/angular-template.ts
+var lintSuiteAngularTemplatePlugin = definePlugin(
+  "lint-suite-angular-template",
+  { "no-unstyled-classes": no_unstyled_classes_default }
+);
 var angularTemplate = defineConfig([
   {
     files: ["**/*.html"],
     extends: [...configs.templateAccessibility, ...configs.templateRecommended],
+    plugins: {
+      "lint-suite-angular-template": lintSuiteAngularTemplatePlugin
+    },
     rules: {
+      "lint-suite-angular-template/no-unstyled-classes": "error",
       "@angular-eslint/template/prefer-template-literal": "error",
       "@angular-eslint/template/no-any": "error",
       "@angular-eslint/template/no-duplicate-attributes": "error",
@@ -77,15 +743,8 @@ import { configs as configs2, processInlineTemplates } from "angular-eslint";
 import { defineConfig as defineConfig2 } from "eslint/config";
 import globals from "globals";
 
-// packages/lint-suite/src/lib/rules/define-plugin.util.ts
-var definePlugin = (name, rules) => {
-  const meta5 = { name };
-  const plugin = { meta: meta5, rules };
-  return plugin;
-};
-
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/no-unused-angular-instance-fields.ts
-import { ESLintUtils } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils2 } from "@typescript-eslint/utils";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-imports.ts
 import { TSESTree } from "@typescript-eslint/utils";
@@ -127,8 +786,8 @@ var addAngularImport = (node, imports) => {
       imports.set(specifier.local.name, null);
     } else if (specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type") {
       const { imported } = specifier;
-      const isIdentifier8 = imported.type === TSESTree.AST_NODE_TYPES.Identifier;
-      const importedName = isIdentifier8 ? imported.name : imported.value;
+      const isIdentifier9 = imported.type === TSESTree.AST_NODE_TYPES.Identifier;
+      const importedName = isIdentifier9 ? imported.name : imported.value;
       imports.set(specifier.local.name, importedName);
     }
   }
@@ -333,7 +992,7 @@ var methodCandidate = (node, localPrivateOnly, implementedMethods) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-metadata-reads.ts
-import { dirname, resolve } from "node:path";
+import { dirname as dirname4, resolve as resolve3 } from "node:path";
 import { TSESTree as TSESTree5 } from "@typescript-eslint/utils";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-metadata-literals.ts
@@ -345,7 +1004,9 @@ var text = (node) => {
   if (node?.type !== TSESTree4.AST_NODE_TYPES.TemplateLiteral) return null;
   const hasExpressions = node.expressions.length > 0;
   if (hasExpressions) return null;
-  return node.quasis[0].value.cooked;
+  const [quasi] = node.quasis;
+  if (quasi === void 0) return null;
+  return quasi.value.cooked;
 };
 var key = (property) => {
   if (property.type !== TSESTree4.AST_NODE_TYPES.Property || property.computed) {
@@ -356,7 +1017,7 @@ var key = (property) => {
   }
   return text(property.key);
 };
-var metadataValue = (metadata, name) => {
+var metadataValue2 = (metadata, name) => {
   for (const property of metadata.properties) {
     if (property.type !== TSESTree4.AST_NODE_TYPES.Property) continue;
     const propertyKey = key(property);
@@ -367,15 +1028,15 @@ var metadataValue = (metadata, name) => {
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-template-parsing.ts
 import {
-  Lexer,
-  ParseLocation,
-  ParseSourceFile,
-  ParseSourceSpan,
-  Parser,
+  Lexer as Lexer2,
+  ParseLocation as ParseLocation2,
+  ParseSourceFile as ParseSourceFile2,
+  ParseSourceSpan as ParseSourceSpan3,
+  Parser as Parser2,
   R3TargetBinder,
   parseTemplate
 } from "@angular/compiler";
-import { readFileSync, statSync } from "node:fs";
+import { readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-expression-reads.ts
 import {
@@ -453,7 +1114,7 @@ var collectAngularExpressionReads = (nodes, boundTarget, action) => {
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-template-parsing.ts
 var externalTemplates = /* @__PURE__ */ new Map();
-var parser = new Parser(new Lexer());
+var parser2 = new Parser2(new Lexer2());
 var templateBinder = new R3TargetBinder(null);
 var templateReads = (template, filename) => {
   try {
@@ -470,11 +1131,11 @@ var templateReads = (template, filename) => {
 };
 var externalTemplateReads = (filename) => {
   try {
-    const stats = statSync(filename, { bigint: true });
+    const stats = statSync2(filename, { bigint: true });
     const version = `${stats.mtimeNs}:${stats.size}`;
     const cached = externalTemplates.get(filename);
     if (cached?.version === version) return cached.reads;
-    const reads = templateReads(readFileSync(filename, "utf8"), filename);
+    const reads = templateReads(readFileSync3(filename, "utf8"), filename);
     externalTemplates.set(filename, { reads, version });
     return reads;
   } catch {
@@ -482,14 +1143,14 @@ var externalTemplateReads = (filename) => {
   }
 };
 var parseExpression = (expression, span, action) => {
-  if (action) return parser.parseAction(expression, span, 0);
-  return parser.parseBinding(expression, span, 0);
+  if (action) return parser2.parseAction(expression, span, 0);
+  return parser2.parseBinding(expression, span, 0);
 };
 var expressionReads = (expression, filename, action) => {
   try {
-    const file = new ParseSourceFile(expression, filename);
-    const start = new ParseLocation(file, 0, 0, 0);
-    const span = new ParseSourceSpan(start, start.moveBy(expression.length));
+    const file = new ParseSourceFile2(expression, filename);
+    const start = new ParseLocation2(file, 0, 0, 0);
+    const span = new ParseSourceSpan3(start, start.moveBy(expression.length));
     const result = parseExpression(expression, span, action);
     if (result.errors.length > 0) return null;
     return collectAngularExpressionReads([result], void 0, action);
@@ -542,11 +1203,11 @@ var inlineTemplateReads = (template, reads, filename) => {
 var externalTemplatePropertyReads = (templateUrl, reads, filename) => {
   if (!templateUrl) return true;
   const url = text(templateUrl);
-  return url !== null && addReads(reads, externalTemplateReads(resolve(dirname(filename), url)));
+  return url !== null && addReads(reads, externalTemplateReads(resolve3(dirname4(filename), url)));
 };
 var componentTemplateReads = (metadata, reads, filename) => {
-  const template = metadataValue(metadata, "template");
-  const templateUrl = metadataValue(metadata, "templateUrl");
+  const template = metadataValue2(metadata, "template");
+  const templateUrl = metadataValue2(metadata, "templateUrl");
   return inlineTemplateReads(template, reads, filename) && externalTemplatePropertyReads(templateUrl, reads, filename);
 };
 var metadataReads = (options) => {
@@ -557,7 +1218,7 @@ var metadataReads = (options) => {
   const hasUnreadableKey = metadata.properties.some(isUnreadableKey);
   if (hasUnreadableKey) return null;
   const reads = /* @__PURE__ */ new Set();
-  const hostValue = metadataValue(metadata, "host");
+  const hostValue = metadataValue2(metadata, "host");
   const hasHostReads = hostReads(hostValue, reads, filename);
   if (!hasHostReads) return null;
   if (!options.component) return reads;
@@ -913,7 +1574,7 @@ var classReadVisitor = (classes, stack, dynamicClasses) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-usage.ts
-import { isClassElement, isIdentifier as isIdentifier7, isStringLiteralLike as isStringLiteralLike6 } from "typescript";
+import { isClassElement, isIdentifier as isIdentifier8, isStringLiteralLike as isStringLiteralLike7 } from "typescript";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-directive-index.ts
 import { CssSelector, SelectorMatcher } from "@angular/compiler";
@@ -974,8 +1635,8 @@ var buildDirectiveIndex = (classes) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-reads.ts
-import { readFileSync as readFileSync2, statSync as statSync2 } from "node:fs";
-import { isIdentifier, isStringLiteralLike } from "typescript";
+import { readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
+import { isIdentifier as isIdentifier2, isStringLiteralLike as isStringLiteralLike2 } from "typescript";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-read-resolution.ts
 import {
@@ -1329,8 +1990,8 @@ var addTemplateReads = ({
 var memberNameOf = (member) => {
   const name = member.name;
   if (!name) return [];
-  const isIdentifierName = isIdentifier(name);
-  const isStringName = isStringLiteralLike(name);
+  const isIdentifierName = isIdentifier2(name);
+  const isStringName = isStringLiteralLike2(name);
   const isTextName = isIdentifierName || isStringName;
   if (!isTextName) return [];
   const names = [name.text];
@@ -1346,13 +2007,13 @@ var unknownTemplateNames = ({ declaration, scope }, allNames) => {
   return names;
 };
 var templateFileVersion = (fileName) => {
-  const { mtimeNs, size } = statSync2(fileName, { bigint: true });
+  const { mtimeNs, size } = statSync3(fileName, { bigint: true });
   const version = { fileName, mtimeNs, size };
   return version;
 };
 var templateFileIsCurrent = (version) => {
   try {
-    const current = statSync2(version.fileName, { bigint: true });
+    const current = statSync3(version.fileName, { bigint: true });
     return current.mtimeNs === version.mtimeNs && current.size === version.size;
   } catch {
     return false;
@@ -1376,7 +2037,7 @@ var templateSourceOf = (angularClass2, allNames, sink, versions) => {
   const templateFileName = template.fileName;
   try {
     versions.push(templateFileVersion(templateFileName));
-    const source = readFileSync2(templateFileName, "utf8");
+    const source = readFileSync4(templateFileName, "utf8");
     const externalSource = {
       fileName: templateFileName,
       source
@@ -1425,7 +2086,7 @@ var collectAngularTemplateReads = ({
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-reads.ts
 import {
-  forEachChild,
+  forEachChild as forEachChild2,
   isClassLike,
   isElementAccessExpression,
   isPropertyAccessExpression
@@ -1438,10 +2099,10 @@ import { SyntaxKind, isMethodSignature } from "typescript";
 import {
   SymbolFlags,
   isBigIntLiteral,
-  isIdentifier as isIdentifier2,
+  isIdentifier as isIdentifier3,
   isNumericLiteral,
   isPrivateIdentifier,
-  isStringLiteralLike as isStringLiteralLike2
+  isStringLiteralLike as isStringLiteralLike3
 } from "typescript";
 var aliasTarget = (checker, symbol) => {
   const isAlias = (symbol.flags & SymbolFlags.Alias) !== 0;
@@ -1496,9 +2157,9 @@ var literalPropertyNames = (type) => {
   return names;
 };
 var propertyName2 = (checker, node) => {
-  const isIdentifierName = isIdentifier2(node);
+  const isIdentifierName = isIdentifier3(node);
   const isPrivateName = isPrivateIdentifier(node);
-  const isStringName = isStringLiteralLike2(node);
+  const isStringName = isStringLiteralLike3(node);
   const isNumericName = isNumericLiteral(node);
   const isBigIntName = isBigIntLiteral(node);
   const isLiteralName = isIdentifierName || isPrivateName || isStringName || isNumericName || isBigIntName;
@@ -1546,31 +2207,31 @@ var collectAngularInterfaceMethods = (node, checker, sink) => {
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-destructuring-reads.ts
 import {
   SyntaxKind as SyntaxKind2,
-  isArrayLiteralExpression as isArrayLiteralExpression2,
+  isArrayLiteralExpression as isArrayLiteralExpression3,
   isBinaryExpression,
   isBindingElement,
-  isObjectLiteralExpression as isObjectLiteralExpression2,
+  isObjectLiteralExpression as isObjectLiteralExpression3,
   isVariableDeclaration
 } from "typescript";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-assignment-pattern-elements.ts
 import {
-  isArrayLiteralExpression,
-  isObjectLiteralExpression,
+  isArrayLiteralExpression as isArrayLiteralExpression2,
+  isObjectLiteralExpression as isObjectLiteralExpression2,
   isOmittedExpression,
-  isPropertyAssignment,
+  isPropertyAssignment as isPropertyAssignment2,
   isSpreadAssignment,
   isSpreadElement
 } from "typescript";
 var nestedPattern = (expression) => {
-  const isArrayLiteral = isArrayLiteralExpression(expression);
-  const isObjectLiteral = isObjectLiteralExpression(expression);
+  const isArrayLiteral = isArrayLiteralExpression2(expression);
+  const isObjectLiteral = isObjectLiteralExpression2(expression);
   const isNested = isArrayLiteral || isObjectLiteral;
   if (!isNested) return null;
   return expression;
 };
 var nestedPropertyPattern = (property) => {
-  const isAssignment = isPropertyAssignment(property);
+  const isAssignment = isPropertyAssignment2(property);
   if (!isAssignment) return null;
   return nestedPattern(property.initializer);
 };
@@ -1609,7 +2270,7 @@ var propertyRead = (property, checker) => {
   return read;
 };
 var assignmentPatternElements = (pattern, checker) => {
-  const isArrayPattern = isArrayLiteralExpression(pattern);
+  const isArrayPattern = isArrayLiteralExpression2(pattern);
   if (isArrayPattern) {
     const reads = [];
     for (const [index, element] of pattern.elements.entries()) {
@@ -1626,7 +2287,7 @@ var assignmentPatternElements = (pattern, checker) => {
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-binding-pattern-elements.ts
 import {
   isArrayBindingPattern,
-  isIdentifier as isIdentifier3,
+  isIdentifier as isIdentifier4,
   isObjectBindingPattern,
   isOmittedExpression as isOmittedExpression2
 } from "typescript";
@@ -1642,7 +2303,7 @@ var nestedPattern2 = (element) => {
 };
 var bindingNames = (checker, element) => {
   if (element.propertyName) return propertyName2(checker, element.propertyName);
-  const isIdentifierName = isIdentifier3(element.name);
+  const isIdentifierName = isIdentifier4(element.name);
   if (!isIdentifierName) return null;
   return [element.name.text];
 };
@@ -1763,8 +2424,8 @@ var collectAssignmentReads = (node, context) => {
   if (!isBinary) return;
   const isEqualsAssignment = node.operatorToken.kind === SyntaxKind2.EqualsToken;
   if (!isEqualsAssignment) return;
-  const isArrayTarget = isArrayLiteralExpression2(node.left);
-  const isObjectTarget = isObjectLiteralExpression2(node.left);
+  const isArrayTarget = isArrayLiteralExpression3(node.left);
+  const isObjectTarget = isObjectLiteralExpression3(node.left);
   const isDestructuringAssignment = isArrayTarget || isObjectTarget;
   if (!isDestructuringAssignment) return;
   const rightTypeOf = () => context.checker.getTypeAtLocation(node.right);
@@ -1780,16 +2441,16 @@ var collectDestructuringReads = (node, checker, sink, candidateNames) => {
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-write-targets.ts
 import {
   SyntaxKind as SyntaxKind3,
-  isArrayLiteralExpression as isArrayLiteralExpression3,
+  isArrayLiteralExpression as isArrayLiteralExpression4,
   isAsExpression,
   isBinaryExpression as isBinaryExpression2,
   isDeleteExpression,
   isForInStatement,
   isForOfStatement,
   isNonNullExpression,
-  isObjectLiteralExpression as isObjectLiteralExpression3,
+  isObjectLiteralExpression as isObjectLiteralExpression4,
   isParenthesizedExpression,
-  isPropertyAssignment as isPropertyAssignment2,
+  isPropertyAssignment as isPropertyAssignment3,
   isSatisfiesExpression,
   isSpreadAssignment as isSpreadAssignment2,
   isTypeAssertionExpression
@@ -1806,15 +2467,15 @@ var isExpressionWrapper = (parent, child) => {
   return parent.expression === child;
 };
 var isPatternContainer = (parent, child) => {
-  const isArrayLiteral = isArrayLiteralExpression3(parent);
+  const isArrayLiteral = isArrayLiteralExpression4(parent);
   if (isArrayLiteral) {
     return parent.elements.some((element) => element === child);
   }
-  const isObjectLiteral = isObjectLiteralExpression3(parent);
+  const isObjectLiteral = isObjectLiteralExpression4(parent);
   if (isObjectLiteral) {
     return parent.properties.some((property) => property === child);
   }
-  const isAssignment = isPropertyAssignment2(parent);
+  const isAssignment = isPropertyAssignment3(parent);
   if (isAssignment) return parent.initializer === child;
   const isSpread = isSpreadAssignment2(parent);
   if (!isSpread) return false;
@@ -1879,7 +2540,7 @@ var collectTypeScriptReads = (sourceFile, checker, sink, candidateNames) => {
       collectAngularInterfaceMethods(node, checker, sink);
     }
     collectDestructuringReads(node, checker, sink, candidateNames);
-    forEachChild(node, visit);
+    forEachChild2(node, visit);
   };
   visit(sourceFile);
 };
@@ -1987,43 +2648,43 @@ var computeEntry = (index, sourceFile, checker) => {
   };
   const reads = collectFileReads(index, sourceFile, checker, sink);
   dependencies.delete(sourceFile);
-  const fileEntry = {
+  const fileEntry2 = {
     ...reads,
     declarations,
     dependencies,
     fallbackNames,
     sourceFile
   };
-  return fileEntry;
+  return fileEntry2;
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-component-discovery.ts
 import {
-  canHaveDecorators as canHaveDecorators2,
-  forEachChild as forEachChild2,
-  getDecorators as getDecorators2,
-  isCallExpression as isCallExpression2,
+  canHaveDecorators as canHaveDecorators3,
+  forEachChild as forEachChild3,
+  getDecorators as getDecorators3,
+  isCallExpression as isCallExpression3,
   isClassLike as isClassLike3,
-  isObjectLiteralExpression as isObjectLiteralExpression4
+  isObjectLiteralExpression as isObjectLiteralExpression5
 } from "typescript";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-component-scope.ts
 import {
   SyntaxKind as SyntaxKind4,
-  isArrayLiteralExpression as isArrayLiteralExpression4,
+  isArrayLiteralExpression as isArrayLiteralExpression5,
   isClassLike as isClassLike2,
-  isIdentifier as isIdentifier5,
+  isIdentifier as isIdentifier6,
   isPropertyAccessExpression as isPropertyAccessExpression3
 } from "typescript";
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-decorator-kind.ts
 import {
   SymbolFlags as SymbolFlags2,
-  canHaveDecorators,
-  getDecorators,
-  isCallExpression,
+  canHaveDecorators as canHaveDecorators2,
+  getDecorators as getDecorators2,
+  isCallExpression as isCallExpression2,
   isImportDeclaration,
-  isStringLiteralLike as isStringLiteralLike3
+  isStringLiteralLike as isStringLiteralLike4
 } from "typescript";
 var decoratorKinds = [
   "Component",
@@ -2045,7 +2706,7 @@ var importedFromAngularCore = (declaration) => {
   let current = parentOf2(declaration);
   while (current) {
     if (isImportDeclaration(current)) {
-      return isStringLiteralLike3(current.moduleSpecifier) && current.moduleSpecifier.text === "@angular/core";
+      return isStringLiteralLike4(current.moduleSpecifier) && current.moduleSpecifier.text === "@angular/core";
     }
     current = parentOf2(current);
   }
@@ -2080,10 +2741,10 @@ var angularDecoratorKind = (expression, discovery) => {
   return name;
 };
 var classDecoratorKind = (declaration, discovery) => {
-  const hasDecorators = canHaveDecorators(declaration);
+  const hasDecorators = canHaveDecorators2(declaration);
   if (!hasDecorators) return null;
-  for (const decorator of getDecorators(declaration) ?? []) {
-    const isDecoratorCall = isCallExpression(decorator.expression);
+  for (const decorator of getDecorators2(declaration) ?? []) {
+    const isDecoratorCall = isCallExpression2(decorator.expression);
     if (!isDecoratorCall) continue;
     const kind = angularDecoratorKind(
       decorator.expression.expression,
@@ -2095,23 +2756,23 @@ var classDecoratorKind = (declaration, discovery) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-metadata-values.ts
-import { dirname as dirname2, resolve as resolve2 } from "node:path";
+import { dirname as dirname5, resolve as resolve4 } from "node:path";
 import {
-  isIdentifier as isIdentifier4,
+  isIdentifier as isIdentifier5,
   isNumericLiteral as isNumericLiteral2,
   isPropertyAccessExpression as isPropertyAccessExpression2,
-  isPropertyAssignment as isPropertyAssignment3,
-  isStringLiteralLike as isStringLiteralLike4
+  isPropertyAssignment as isPropertyAssignment4,
+  isStringLiteralLike as isStringLiteralLike5
 } from "typescript";
 var stringValue = (node, discovery) => {
   if (!node) return null;
-  const isStringLiteral = isStringLiteralLike4(node);
+  const isStringLiteral = isStringLiteralLike5(node);
   if (isStringLiteral) return node.text;
-  const isIdentifierNode = isIdentifier4(node);
+  const isIdentifierNode = isIdentifier5(node);
   const isPropertyAccessNode = isPropertyAccessExpression2(node);
   if (isIdentifierNode || isPropertyAccessNode) {
     const symbol = discovery.checker.getSymbolAtLocation(
-      isIdentifier4(node) ? node : node.name
+      isIdentifier5(node) ? node : node.name
     );
     if (symbol) {
       resolveAlias(symbol, discovery);
@@ -2122,10 +2783,10 @@ var stringValue = (node, discovery) => {
 };
 var metadataProperty = (metadata, name) => {
   for (const property of metadata.properties) {
-    const isAssignment = isPropertyAssignment3(property);
+    const isAssignment = isPropertyAssignment4(property);
     if (!isAssignment) continue;
-    const isIdentifierName = isIdentifier4(property.name);
-    const isStringName = isStringLiteralLike4(property.name);
+    const isIdentifierName = isIdentifier5(property.name);
+    const isStringName = isStringLiteralLike5(property.name);
     const isNumericName = isNumericLiteral2(property.name);
     const isLiteralName = isIdentifierName || isStringName || isNumericName;
     const isPropertyNamed = isLiteralName && property.name.text === name;
@@ -2145,7 +2806,7 @@ var templateOf = (metadata, fileName, discovery) => {
   if (url) {
     const text2 = stringValue(url, discovery);
     if (text2 === null) return void 0;
-    const externalFileName = resolve2(dirname2(fileName), text2);
+    const externalFileName = resolve4(dirname5(fileName), text2);
     const externalTemplate = {
       fileName: externalFileName,
       kind: "external"
@@ -2185,7 +2846,7 @@ var scopedClasses = (classes, discovery) => {
   return scoped;
 };
 var importedClasses = (element, discovery) => {
-  const isIdentifierElement = isIdentifier5(element);
+  const isIdentifierElement = isIdentifier6(element);
   const isPropertyAccessElement = isPropertyAccessExpression3(element);
   if (!isIdentifierElement && !isPropertyAccessElement) return null;
   const target = isIdentifierElement ? element : element.name;
@@ -2201,7 +2862,7 @@ var scopeOf = (metadata, discovery) => {
   const isModuleDeclared = standalone === void 0 && !imports;
   if (standalone === false || isModuleDeclared) return null;
   if (!imports) return [];
-  const isImportsArray = isArrayLiteralExpression4(imports);
+  const isImportsArray = isArrayLiteralExpression5(imports);
   if (!isImportsArray) return null;
   const scope = [];
   for (const element of imports.elements) {
@@ -2254,7 +2915,7 @@ var decoratedClass = (declaration, call, discovery) => {
     const bareDiscovery = { ...base2, valid: !component };
     return bareDiscovery;
   }
-  const isMetadataObject = isObjectLiteralExpression4(metadata);
+  const isMetadataObject = isObjectLiteralExpression5(metadata);
   if (!isMetadataObject) {
     const invalidDiscovery = { ...base2, valid: false };
     return invalidDiscovery;
@@ -2262,10 +2923,10 @@ var decoratedClass = (declaration, call, discovery) => {
   return describedClass(base2, metadata, discovery);
 };
 var angularClass = (declaration, discovery) => {
-  const hasDecorators = canHaveDecorators2(declaration);
+  const hasDecorators = canHaveDecorators3(declaration);
   if (!hasDecorators) return null;
-  for (const decorator of getDecorators2(declaration) ?? []) {
-    const isDecoratorCall = isCallExpression2(decorator.expression);
+  for (const decorator of getDecorators3(declaration) ?? []) {
+    const isDecoratorCall = isCallExpression3(decorator.expression);
     if (!isDecoratorCall) continue;
     const found = decoratedClass(declaration, decorator.expression, discovery);
     if (found) return found;
@@ -2283,7 +2944,7 @@ var angularClasses = (sourceFile, checker) => {
         classes.push(found);
       }
     }
-    forEachChild2(node, visit);
+    forEachChild3(node, visit);
   };
   visit(sourceFile);
   discovery.dependencies.delete(sourceFile);
@@ -2385,17 +3046,17 @@ var dropStaleTemplateEntries = (index, force) => {
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-candidate-names.ts
 import {
-  canHaveDecorators as canHaveDecorators3,
-  forEachChild as forEachChild3,
-  getDecorators as getDecorators3,
+  canHaveDecorators as canHaveDecorators4,
+  forEachChild as forEachChild4,
+  getDecorators as getDecorators4,
   isClassLike as isClassLike4,
-  isIdentifier as isIdentifier6,
-  isStringLiteralLike as isStringLiteralLike5
+  isIdentifier as isIdentifier7,
+  isStringLiteralLike as isStringLiteralLike6
 } from "typescript";
 var isDecoratedClass = (node) => {
-  const isDecoratable = canHaveDecorators3(node);
+  const isDecoratable = canHaveDecorators4(node);
   if (!isDecoratable) return false;
-  const decorators = getDecorators3(node);
+  const decorators = getDecorators4(node);
   const decoratorCount = decorators?.length ?? 0;
   return decoratorCount > 0;
 };
@@ -2406,8 +3067,8 @@ var addMemberNames = (node, names) => {
   if (!isDecorated) return;
   for (const member of node.members) {
     if (!member.name) continue;
-    const isIdentifierName = isIdentifier6(member.name);
-    const isStringName = isStringLiteralLike5(member.name);
+    const isIdentifierName = isIdentifier7(member.name);
+    const isStringName = isStringLiteralLike6(member.name);
     const isNamedMember = isIdentifierName || isStringName;
     if (isNamedMember) {
       names.add(member.name.text);
@@ -2418,7 +3079,7 @@ var collectCandidateNames = (sourceFile) => {
   const names = /* @__PURE__ */ new Set();
   const visit = (node) => {
     addMemberNames(node, names);
-    forEachChild3(node, visit);
+    forEachChild4(node, visit);
   };
   visit(sourceFile);
   return names;
@@ -2537,8 +3198,8 @@ var memberName = (node) => {
   const isMember = isClassElement(node);
   if (!isMember) return null;
   if (!node.name) return null;
-  const isIdentifierName = isIdentifier7(node.name);
-  const isStringName = isStringLiteralLike6(node.name);
+  const isIdentifierName = isIdentifier8(node.name);
+  const isStringName = isStringLiteralLike7(node.name);
   const isNamedMember = isIdentifierName || isStringName;
   if (!isNamedMember) return null;
   return node.name.text;
@@ -2602,10 +3263,10 @@ var projectUsage = (program) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/no-unused-angular-instance-fields.ts
-var docs = {
+var docs2 = {
   description: "Disallow unread instance fields and methods in Angular components and directives"
 };
-var messages = {
+var messages2 = {
   unusedField: "Angular instance field '{{name}}' is never read.",
   unusedMethod: "Angular instance method '{{name}}' is never read."
 };
@@ -2618,34 +3279,34 @@ var analysisSchema = {
   enum: ["local", "project"],
   description: "Choose local-file or typed whole-project analysis."
 };
-var properties = {
+var properties2 = {
   allowEffectFields: allowEffectFieldsSchema,
   analysis: analysisSchema
 };
-var optionsSchema = {
+var optionsSchema2 = {
   type: "object",
-  properties,
+  properties: properties2,
   additionalProperties: false
 };
-var schema = [optionsSchema];
-var meta = {
+var schema2 = [optionsSchema2];
+var meta2 = {
   type: "problem",
-  docs,
-  schema,
-  messages
+  docs: docs2,
+  schema: schema2,
+  messages: messages2
 };
-var ruleDefaults = {
+var ruleDefaults2 = {
   allowEffectFields: false,
   analysis: "local"
 };
-var defaultOptions = [ruleDefaults];
-var createRule = ESLintUtils.RuleCreator(
+var defaultOptions2 = [ruleDefaults2];
+var createRule2 = ESLintUtils2.RuleCreator(
   () => "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
 );
 var projectParserServices = (context, analysis) => {
   if (analysis !== "project") return void 0;
   try {
-    return ESLintUtils.getParserServices(context);
+    return ESLintUtils2.getParserServices(context);
   } catch {
     throw new Error(
       "Project analysis requires parser services with type information."
@@ -2663,10 +3324,10 @@ var projectMemberUsedFor = (parserServices) => {
   };
   return memberUsed;
 };
-var no_unused_angular_instance_fields_default = createRule({
+var no_unused_angular_instance_fields_default = createRule2({
   name: "no-unused-instance-fields",
-  meta,
-  defaultOptions,
+  meta: meta2,
+  defaultOptions: defaultOptions2,
   create(context, [options]) {
     const analysis = options.analysis ?? "local";
     const isSpec = isSpecFile(context.filename);
@@ -2706,6 +3367,9 @@ var no_unused_angular_instance_fields_default = createRule({
 var lintSuiteAngularPlugin = definePlugin("lint-suite-angular", {
   "no-unused-instance-fields": no_unused_angular_instance_fields_default
 });
+var inlineTemplates = processInlineTemplates && {
+  processor: processInlineTemplates
+};
 var angular = defineConfig2([
   {
     files: ["**/*.ts"],
@@ -2723,7 +3387,7 @@ var angular = defineConfig2([
         projectService: true
       }
     },
-    processor: processInlineTemplates,
+    ...inlineTemplates,
     rules: {
       "lint-suite-angular/no-unused-instance-fields": [
         "error",
@@ -2833,6 +3497,11 @@ var baseLimits = defineConfig3([
 
 // packages/lint-suite/src/lib/base-practices.ts
 import { defineConfig as defineConfig4 } from "eslint/config";
+
+// packages/lint-suite/src/lib/line-length.const.ts
+var MAX_LINE_LENGTH = 135;
+
+// packages/lint-suite/src/lib/base-practices.ts
 var basePractices = defineConfig4([
   {
     files: [
@@ -2891,7 +3560,7 @@ var basePractices = defineConfig4([
       "max-len": [
         "error",
         {
-          code: 135,
+          code: MAX_LINE_LENGTH,
           ignoreComments: true
         }
       ],
@@ -3446,7 +4115,7 @@ var typescriptRecommended = defineConfig17([
 import { defineConfig as defineConfig18 } from "eslint/config";
 
 // packages/lint-suite/src/lib/rules/explicit-accessibility/explicit-accessibility.ts
-import { ESLintUtils as ESLintUtils2, TSESTree as TSESTree10 } from "@typescript-eslint/utils";
+import { ESLintUtils as ESLintUtils3, TSESTree as TSESTree10 } from "@typescript-eslint/utils";
 
 // packages/lint-suite/src/lib/rules/explicit-accessibility/common/explicit-accessibility.const.ts
 var accessibilities = [
@@ -3454,10 +4123,10 @@ var accessibilities = [
   "private",
   "protected"
 ];
-var docs2 = {
+var docs3 = {
   description: "Require explicit accessibility modifiers on class members"
 };
-var messages2 = {
+var messages3 = {
   missingAccessibility: "Class member '{{ name }}' is missing an explicit accessibility modifier (public/private/protected).",
   setAccessibility: "Add the '{{ accessibility }}' modifier."
 };
@@ -3466,27 +4135,27 @@ var defaultAccessibilitySchema = {
   enum: ["public", "private", "protected", "none"],
   description: "The accessibility modifier inserted by the auto-fix; constructors always get public. 'none' reports without an auto-fix and offers all three levels as suggestions."
 };
-var properties2 = {
+var properties3 = {
   defaultAccessibility: defaultAccessibilitySchema
 };
-var optionsSchema2 = {
+var optionsSchema3 = {
   type: "object",
-  properties: properties2,
+  properties: properties3,
   additionalProperties: false
 };
-var schema2 = [optionsSchema2];
-var meta2 = {
+var schema3 = [optionsSchema3];
+var meta3 = {
   type: "suggestion",
-  docs: docs2,
+  docs: docs3,
   fixable: "code",
   hasSuggestions: true,
-  schema: schema2,
-  messages: messages2
+  schema: schema3,
+  messages: messages3
 };
-var defaultOptions2 = [{ defaultAccessibility: "public" }];
+var defaultOptions3 = [{ defaultAccessibility: "public" }];
 
 // packages/lint-suite/src/lib/rules/explicit-accessibility/explicit-accessibility.ts
-var createRule2 = ESLintUtils2.RuleCreator(
+var createRule3 = ESLintUtils3.RuleCreator(
   () => "https://github.com/F0rty-Tw0/lint-suite#explicit-accessibility"
 );
 var isPrivateMember = (node) => {
@@ -3552,10 +4221,10 @@ var suggestionsOf = (node, fixAccessibility, sourceCode) => {
   };
   return accessibilities.filter(isOtherAccessibility).map(suggestionFor);
 };
-var explicit_accessibility_default = createRule2({
+var explicit_accessibility_default = createRule3({
   name: "explicit-accessibility",
-  meta: meta2,
-  defaultOptions: defaultOptions2,
+  meta: meta3,
+  defaultOptions: defaultOptions3,
   create(context, [{ defaultAccessibility = "public" }]) {
     const { sourceCode } = context;
     const check = (node) => {
@@ -3592,20 +4261,20 @@ var explicit_accessibility_default = createRule2({
 });
 
 // packages/lint-suite/src/lib/rules/no-inline-object-types/no-inline-object-types.ts
-import { ESLintUtils as ESLintUtils3, TSESTree as TSESTree11 } from "@typescript-eslint/utils";
-var docs3 = {
+import { ESLintUtils as ESLintUtils4, TSESTree as TSESTree11 } from "@typescript-eslint/utils";
+var docs4 = {
   description: "Require nested object types inside a type alias to be extracted to a named type alias"
 };
-var messages3 = {
+var messages4 = {
   inlineObjectType: "Inline object type must be extracted to a named type alias."
 };
-var meta3 = {
+var meta4 = {
   type: "suggestion",
-  docs: docs3,
+  docs: docs4,
   schema: [],
-  messages: messages3
+  messages: messages4
 };
-var createRule3 = ESLintUtils3.RuleCreator(
+var createRule4 = ESLintUtils4.RuleCreator(
   () => "https://github.com/F0rty-Tw0/lint-suite#no-inline-object-types"
 );
 var enclosingTypeAlias = (node) => {
@@ -3618,9 +4287,9 @@ var enclosingTypeAlias = (node) => {
   }
   return void 0;
 };
-var no_inline_object_types_default = createRule3({
+var no_inline_object_types_default = createRule4({
   name: "no-inline-object-types",
-  meta: meta3,
+  meta: meta4,
   defaultOptions: [],
   create(context) {
     const listeners = {
@@ -3640,46 +4309,138 @@ var no_inline_object_types_default = createRule3({
   }
 });
 
+// packages/lint-suite/src/lib/rules/one-line-guard/one-line-guard.ts
+import { ESLintUtils as ESLintUtils5, TSESTree as TSESTree12 } from "@typescript-eslint/utils";
+var docs5 = {
+  description: "Require a lone return/throw/continue/break guard to drop its braces when the whole if statement fits on one line"
+};
+var messages5 = {
+  oneLineGuard: "Lone {{ keyword }} guard fits within {{ max }} columns; write it on one line without braces."
+};
+var schema4 = [
+  {
+    type: "object",
+    properties: {
+      maxLineLength: { type: "integer", minimum: 1 }
+    },
+    additionalProperties: false
+  }
+];
+var meta5 = {
+  type: "suggestion",
+  docs: docs5,
+  fixable: "code",
+  schema: schema4,
+  messages: messages5
+};
+var createRule5 = ESLintUtils5.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#one-line-guard"
+);
+var GUARD_KEYWORDS = /* @__PURE__ */ new Set([
+  TSESTree12.AST_NODE_TYPES.ReturnStatement,
+  TSESTree12.AST_NODE_TYPES.ThrowStatement,
+  TSESTree12.AST_NODE_TYPES.ContinueStatement,
+  TSESTree12.AST_NODE_TYPES.BreakStatement
+]);
+var soleStatement = (body) => {
+  if (body.type !== TSESTree12.AST_NODE_TYPES.BlockStatement) return void 0;
+  if (body.body.length !== 1) return void 0;
+  return body.body[0];
+};
+var guardStatement = (node) => {
+  if (node.alternate) return void 0;
+  const statement = soleStatement(node.consequent);
+  if (!statement) return void 0;
+  const isGuardKeyword = GUARD_KEYWORDS.has(statement.type);
+  if (!isGuardKeyword) return void 0;
+  return statement;
+};
+var headText = (node, sourceCode) => {
+  return sourceCode.text.slice(node.range[0], node.consequent.range[0]).trimEnd();
+};
+var collapsedLine = (node, head, bodyText, sourceCode) => {
+  const line = sourceCode.lines[node.loc.start.line - 1] ?? "";
+  const prefix = line.slice(0, node.loc.start.column);
+  return `${prefix}${head} ${bodyText}`;
+};
+var one_line_guard_default = createRule5({
+  name: "one-line-guard",
+  meta: meta5,
+  defaultOptions: [{ maxLineLength: 80 }],
+  create(context, [{ maxLineLength }]) {
+    const { sourceCode } = context;
+    const listeners = {
+      IfStatement(node) {
+        const statement = guardStatement(node);
+        if (!statement) return;
+        const hasComments = sourceCode.getCommentsInside(node.consequent).length > 0;
+        if (hasComments) return;
+        const head = headText(node, sourceCode);
+        const isMultiLineHead = head.includes("\n");
+        if (isMultiLineHead) return;
+        const bodyText = sourceCode.getText(statement);
+        const isMultiLineBody = bodyText.includes("\n");
+        if (isMultiLineBody) return;
+        const collapsed = collapsedLine(node, head, bodyText, sourceCode);
+        if (collapsed.length > maxLineLength) return;
+        const [keywordToken] = sourceCode.getTokens(statement);
+        if (keywordToken === void 0) return;
+        const keyword = keywordToken.value;
+        const data = { keyword, max: maxLineLength };
+        const fix = (fixer) => fixer.replaceText(node.consequent, bodyText);
+        const report = {
+          node,
+          messageId: "oneLineGuard",
+          data,
+          fix
+        };
+        context.report(report);
+      }
+    };
+    return listeners;
+  }
+});
+
 // packages/lint-suite/src/lib/rules/readonly-type-properties/readonly-type-properties.ts
-import { ESLintUtils as ESLintUtils4, TSESTree as TSESTree12 } from "@typescript-eslint/utils";
-var docs4 = {
+import { ESLintUtils as ESLintUtils6, TSESTree as TSESTree13 } from "@typescript-eslint/utils";
+var docs6 = {
   description: "Require readonly on primitive-typed type and interface properties"
 };
-var messages4 = {
+var messages6 = {
   missingReadonly: "Type property '{{ name }}' should be readonly. Disable this rule on the line if mutation is required."
 };
-var meta4 = {
+var meta6 = {
   type: "suggestion",
-  docs: docs4,
+  docs: docs6,
   fixable: "code",
   schema: [],
-  messages: messages4
+  messages: messages6
 };
-var createRule4 = ESLintUtils4.RuleCreator(
+var createRule6 = ESLintUtils6.RuleCreator(
   () => "https://github.com/F0rty-Tw0/lint-suite#readonly-type-properties"
 );
 var propertyName3 = (node, sourceCode) => {
-  if (node.key.type === TSESTree12.AST_NODE_TYPES.Identifier) {
+  if (node.key.type === TSESTree13.AST_NODE_TYPES.Identifier) {
     return node.key.name;
   }
   return sourceCode.getText(node.key);
 };
 var PRIMITIVE_KEYWORDS = /* @__PURE__ */ new Set([
-  TSESTree12.AST_NODE_TYPES.TSStringKeyword,
-  TSESTree12.AST_NODE_TYPES.TSNumberKeyword,
-  TSESTree12.AST_NODE_TYPES.TSBooleanKeyword,
-  TSESTree12.AST_NODE_TYPES.TSBigIntKeyword,
-  TSESTree12.AST_NODE_TYPES.TSSymbolKeyword,
-  TSESTree12.AST_NODE_TYPES.TSNullKeyword,
-  TSESTree12.AST_NODE_TYPES.TSUndefinedKeyword
+  TSESTree13.AST_NODE_TYPES.TSStringKeyword,
+  TSESTree13.AST_NODE_TYPES.TSNumberKeyword,
+  TSESTree13.AST_NODE_TYPES.TSBooleanKeyword,
+  TSESTree13.AST_NODE_TYPES.TSBigIntKeyword,
+  TSESTree13.AST_NODE_TYPES.TSSymbolKeyword,
+  TSESTree13.AST_NODE_TYPES.TSNullKeyword,
+  TSESTree13.AST_NODE_TYPES.TSUndefinedKeyword
 ]);
 var isPrimitive = (type) => {
   const isPrimitiveKeyword = PRIMITIVE_KEYWORDS.has(type.type);
   if (isPrimitiveKeyword) return true;
-  if (type.type === TSESTree12.AST_NODE_TYPES.TSLiteralType || type.type === TSESTree12.AST_NODE_TYPES.TSTemplateLiteralType) {
+  if (type.type === TSESTree13.AST_NODE_TYPES.TSLiteralType || type.type === TSESTree13.AST_NODE_TYPES.TSTemplateLiteralType) {
     return true;
   }
-  if (type.type === TSESTree12.AST_NODE_TYPES.TSUnionType || type.type === TSESTree12.AST_NODE_TYPES.TSIntersectionType) {
+  if (type.type === TSESTree13.AST_NODE_TYPES.TSUnionType || type.type === TSESTree13.AST_NODE_TYPES.TSIntersectionType) {
     return type.types.every(isPrimitive);
   }
   return false;
@@ -3691,9 +4452,9 @@ var readonlyFix = (node, sourceCode) => {
     return fixer.insertTextBefore(firstToken, "readonly ");
   };
 };
-var readonly_type_properties_default = createRule4({
+var readonly_type_properties_default = createRule6({
   name: "readonly-type-properties",
-  meta: meta4,
+  meta: meta6,
   defaultOptions: [],
   create(context) {
     const { sourceCode } = context;
@@ -3722,7 +4483,8 @@ var readonly_type_properties_default = createRule4({
 var localPlugin = definePlugin("local", {
   "explicit-accessibility": explicit_accessibility_default,
   "readonly-type-properties": readonly_type_properties_default,
-  "no-inline-object-types": no_inline_object_types_default
+  "no-inline-object-types": no_inline_object_types_default,
+  "one-line-guard": one_line_guard_default
 });
 
 // packages/lint-suite/src/lib/typescript-safety.ts
@@ -3734,6 +4496,7 @@ var typescriptSafety = defineConfig18([
       "local/explicit-accessibility": "error",
       "local/readonly-type-properties": "error",
       "local/no-inline-object-types": "error",
+      "local/one-line-guard": ["error", { maxLineLength: MAX_LINE_LENGTH }],
       "@typescript-eslint/explicit-function-return-type": "error",
       "@typescript-eslint/no-empty-function": "error",
       "@typescript-eslint/no-unused-vars": "error",