lint-suite 1.6.2 → 1.6.3

package/eslint.cjs

@@ -49,11 +49,654 @@ module.exports = __toCommonJS(eslint_exports);
 // packages/lint-suite/src/lib/angular-template.ts
 var import_angular_eslint = require("angular-eslint");
 var import_config = require("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
+var import_utils = require("@typescript-eslint/utils");
+
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/component-stylesheets.ts
+var import_node_fs2 = require("node:fs");
+var import_node_path = require("node:path");
+
+// packages/lint-suite/src/lib/rules/component-metadata.ts
+var import_node_fs = require("node:fs");
+var import_typescript = require("typescript");
+var componentArgument = (decorator) => {
+  const { expression } = decorator;
+  if (!(0, import_typescript.isCallExpression)(expression)) return null;
+  if (!(0, import_typescript.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 (!(0, import_typescript.isObjectLiteralExpression)(argument)) return null;
+  return argument;
+};
+var decoratedMetadata = (node) => {
+  if (!(0, import_typescript.canHaveDecorators)(node)) return null;
+  const decorators = (0, import_typescript.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);
+    (0, import_typescript.forEachChild)(node, visit);
+  };
+  const source = (0, import_typescript.createSourceFile)(path, text2, import_typescript.ScriptTarget.Latest, true);
+  (0, import_typescript.forEachChild)(source, visit);
+  return found;
+};
+var componentMetadata = (path) => {
+  try {
+    const text2 = (0, import_node_fs.readFileSync)(path, "utf8");
+    return parseComponentMetadata(text2, path);
+  } catch {
+    return [];
+  }
+};
+var literalText = (node) => {
+  if (!(0, import_typescript.isStringLiteralLike)(node)) return null;
+  return node.text;
+};
+var literalTexts = (node) => {
+  const single = literalText(node);
+  if (single !== null) return [single];
+  if (!(0, import_typescript.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 (!(0, import_typescript.isPropertyAssignment)(property)) continue;
+    if (!(0, import_typescript.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 = (0, import_node_path.resolve)(directory, templateUrl);
+  const linted = (0, import_node_path.resolve)(templateFilename);
+  return declared === linted;
+};
+var templateMetadata = (componentPath, templateFilename) => {
+  const components = componentMetadata(componentPath);
+  const directory = (0, import_node_path.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 = (0, import_node_path.resolve)(directory, path);
+    const isPresent = (0, import_node_fs2.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 = (0, import_node_path.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, (0, import_node_path.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
+var import_node_fs4 = require("node:fs");
+var import_node_path3 = require("node:path");
+var import_postcss_scss = require("postcss-scss");
+
+// packages/lint-suite/src/lib/rules/no-unstyled-classes/styles/stylesheet-imports.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path2 = require("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, (0, import_node_path2.join)((0, import_node_path2.dirname)(path), `_${(0, import_node_path2.basename)(path)}`)];
+  const partial = (0, import_node_path2.join)((0, import_node_path2.dirname)(path), `_${(0, import_node_path2.basename)(path)}.scss`);
+  return [
+    `${path}.scss`,
+    partial,
+    (0, import_node_path2.join)(path, "index.scss"),
+    (0, import_node_path2.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 = (0, import_node_path2.resolve)(directory, specifier);
+  const candidates = candidatesOf(path);
+  const existing = candidates.find((candidate) => (0, import_node_fs3.existsSync)(candidate));
+  return existing ?? null;
+};
+
+// packages/lint-suite/src/lib/rules/utils/selector-classes.util.ts
+var import_postcss_selector_parser = __toESM(require("postcss-selector-parser"), 1);
+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 = (0, import_postcss_selector_parser.default)().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 = (0, import_postcss_scss.parse)(source, { from: path });
+    return collectStylesheet(root, (0, import_node_path3.dirname)(path));
+  } catch {
+    return emptyEntry();
+  }
+};
+var fileEntry = (path) => {
+  try {
+    const stats = (0, import_node_fs4.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((0, import_node_fs4.readFileSync)(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
+var import_compiler2 = require("@angular/compiler");
+
+// packages/lint-suite/src/lib/rules/utils/class-expression-literals.util.ts
+var import_compiler = require("@angular/compiler");
+var WHITESPACE = /\s+/u;
+var EXPRESSION_FILE = "class-expression";
+var parser = new import_compiler.Parser(new import_compiler.Lexer());
+var spanOf = (source) => {
+  const file = new import_compiler.ParseSourceFile(source, EXPRESSION_FILE);
+  const start = new import_compiler.ParseLocation(file, 0, 0, 0);
+  const span = new import_compiler.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 import_compiler.LiteralPrimitive) {
+    addPrimitive(ast, names);
+    return;
+  }
+  if (ast instanceof import_compiler.LiteralMap) {
+    addMapKeys(ast, names);
+    return;
+  }
+  if (ast instanceof import_compiler.Interpolation) {
+    addInterpolation(ast, names);
+    return;
+  }
+  if (ast instanceof import_compiler.LiteralArray) {
+    for (const expression of ast.expressions) collect(expression, names);
+    return;
+  }
+  if (ast instanceof import_compiler.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 import_compiler2.ParseSourceSpan(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 = import_utils.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 = (0, import_config.defineConfig)([
   {
     files: ["**/*.html"],
     extends: [...import_angular_eslint.configs.templateAccessibility, ...import_angular_eslint.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",
@@ -125,33 +768,26 @@ var import_angular_eslint2 = require("angular-eslint");
 var import_config2 = require("eslint/config");
 var import_globals = __toESM(require("globals"), 1);
 
-// 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
-var import_utils10 = require("@typescript-eslint/utils");
+var import_utils11 = require("@typescript-eslint/utils");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-imports.ts
-var import_utils = require("@typescript-eslint/utils");
+var import_utils2 = require("@typescript-eslint/utils");
 var calleeRoot = (node) => {
-  if (node.type === import_utils.TSESTree.AST_NODE_TYPES.Identifier) return node;
-  if (node.type !== import_utils.TSESTree.AST_NODE_TYPES.MemberExpression || node.object.type === import_utils.TSESTree.AST_NODE_TYPES.Super) {
+  if (node.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier) return node;
+  if (node.type !== import_utils2.TSESTree.AST_NODE_TYPES.MemberExpression || node.object.type === import_utils2.TSESTree.AST_NODE_TYPES.Super) {
     return void 0;
   }
   return calleeRoot(node.object);
 };
 var angularName = (node, imports) => {
-  if (node.type === import_utils.TSESTree.AST_NODE_TYPES.Identifier) {
+  if (node.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier) {
     return imports.get(node.name);
   }
-  if (node.type !== import_utils.TSESTree.AST_NODE_TYPES.MemberExpression || node.computed || node.property.type !== import_utils.TSESTree.AST_NODE_TYPES.Identifier) {
+  if (node.type !== import_utils2.TSESTree.AST_NODE_TYPES.MemberExpression || node.computed || node.property.type !== import_utils2.TSESTree.AST_NODE_TYPES.Identifier) {
     return null;
   }
-  if (node.object.type === import_utils.TSESTree.AST_NODE_TYPES.Identifier) {
+  if (node.object.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier) {
     const namespaceAlias = imports.get(node.object.name);
     if (namespaceAlias === null) return node.property.name;
   }
@@ -171,25 +807,25 @@ var addAngularImport = (node, imports) => {
     return;
   }
   for (const specifier of node.specifiers) {
-    if (specifier.type === import_utils.TSESTree.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+    if (specifier.type === import_utils2.TSESTree.AST_NODE_TYPES.ImportNamespaceSpecifier) {
       imports.set(specifier.local.name, null);
-    } else if (specifier.type === import_utils.TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type") {
+    } else if (specifier.type === import_utils2.TSESTree.AST_NODE_TYPES.ImportSpecifier && specifier.importKind !== "type") {
       const { imported } = specifier;
-      const isIdentifier8 = imported.type === import_utils.TSESTree.AST_NODE_TYPES.Identifier;
-      const importedName = isIdentifier8 ? imported.name : imported.value;
+      const isIdentifier9 = imported.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier;
+      const importedName = isIdentifier9 ? imported.name : imported.value;
       imports.set(specifier.local.name, importedName);
     }
   }
 };
 var angularClassMetadata = (node, imports) => {
   for (const decorator of node.decorators) {
-    if (decorator.expression.type !== import_utils.TSESTree.AST_NODE_TYPES.CallExpression) {
+    if (decorator.expression.type !== import_utils2.TSESTree.AST_NODE_TYPES.CallExpression) {
       continue;
     }
     const kind = angularName(decorator.expression.callee, imports);
     const metadata = decorator.expression.arguments.at(0);
     const isComponentOrDirective = kind === "Component" || kind === "Directive";
-    if (isComponentOrDirective && metadata?.type === import_utils.TSESTree.AST_NODE_TYPES.ObjectExpression) {
+    if (isComponentOrDirective && metadata?.type === import_utils2.TSESTree.AST_NODE_TYPES.ObjectExpression) {
       const classMetadata = {
         component: kind === "Component",
         metadata
@@ -202,7 +838,7 @@ var angularClassMetadata = (node, imports) => {
 var angularClassImports = (ast) => {
   const imports = /* @__PURE__ */ new Map();
   for (const node of ast.body) {
-    if (node.type === import_utils.TSESTree.AST_NODE_TYPES.ImportDeclaration) {
+    if (node.type === import_utils2.TSESTree.AST_NODE_TYPES.ImportDeclaration) {
       addAngularImport(node, imports);
     }
   }
@@ -217,10 +853,10 @@ var angularClassImports = (ast) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-member-candidates.ts
-var import_utils3 = require("@typescript-eslint/utils");
+var import_utils4 = require("@typescript-eslint/utils");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-managed-fields.ts
-var import_utils2 = require("@typescript-eslint/utils");
+var import_utils3 = require("@typescript-eslint/utils");
 var managedApis = /* @__PURE__ */ new Set([
   "input",
   "model",
@@ -233,33 +869,33 @@ var managedApis = /* @__PURE__ */ new Set([
 var hasAutomaticEffectCleanup = (node) => {
   const options = node.arguments.at(1);
   if (options === void 0) return true;
-  if (options.type !== import_utils2.TSESTree.AST_NODE_TYPES.ObjectExpression) return false;
+  if (options.type !== import_utils3.TSESTree.AST_NODE_TYPES.ObjectExpression) return false;
   return options.properties.every((property) => {
-    if (property.type !== import_utils2.TSESTree.AST_NODE_TYPES.Property || property.computed) {
+    if (property.type !== import_utils3.TSESTree.AST_NODE_TYPES.Property || property.computed) {
       return false;
     }
-    const manualCleanup = property.key.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier && property.key.name === "manualCleanup" || property.key.type === import_utils2.TSESTree.AST_NODE_TYPES.Literal && property.key.value === "manualCleanup";
-    return !manualCleanup || property.value.type === import_utils2.TSESTree.AST_NODE_TYPES.Literal && property.value.value === false;
+    const manualCleanup = property.key.type === import_utils3.TSESTree.AST_NODE_TYPES.Identifier && property.key.name === "manualCleanup" || property.key.type === import_utils3.TSESTree.AST_NODE_TYPES.Literal && property.key.value === "manualCleanup";
+    return !manualCleanup || property.value.type === import_utils3.TSESTree.AST_NODE_TYPES.Literal && property.value.value === false;
   });
 };
 var angularCoreImportedName = (definition) => {
   if (definition?.type !== "ImportBinding") return null;
-  if (definition.node.type !== import_utils2.TSESTree.AST_NODE_TYPES.ImportSpecifier) {
+  if (definition.node.type !== import_utils3.TSESTree.AST_NODE_TYPES.ImportSpecifier) {
     return null;
   }
-  if (definition.parent.type !== import_utils2.TSESTree.AST_NODE_TYPES.ImportDeclaration) {
+  if (definition.parent.type !== import_utils3.TSESTree.AST_NODE_TYPES.ImportDeclaration) {
     return null;
   }
   if (definition.parent.source.value !== "@angular/core") return null;
   const { imported } = definition.node;
-  if (imported.type === import_utils2.TSESTree.AST_NODE_TYPES.Identifier) {
+  if (imported.type === import_utils3.TSESTree.AST_NODE_TYPES.Identifier) {
     return imported.name;
   }
   return imported.value;
 };
 var isAngularComponentRefField = (node, sourceCode) => {
   const type = node.typeAnnotation?.typeAnnotation;
-  if (type?.type !== import_utils2.TSESTree.AST_NODE_TYPES.TSTypeReference || type.typeName.type !== import_utils2.TSESTree.AST_NODE_TYPES.Identifier) {
+  if (type?.type !== import_utils3.TSESTree.AST_NODE_TYPES.TSTypeReference || type.typeName.type !== import_utils3.TSESTree.AST_NODE_TYPES.Identifier) {
     return false;
   }
   const reference = sourceCode.getScope(type.typeName).references.find(({ identifier }) => identifier === type.typeName);
@@ -267,7 +903,7 @@ var isAngularComponentRefField = (node, sourceCode) => {
   return angularCoreImportedName(definition) === "ComponentRef";
 };
 var isManagedField = (node, imports, allowEffectFields, sourceCode) => {
-  if (node.value?.type !== import_utils2.TSESTree.AST_NODE_TYPES.CallExpression) return false;
+  if (node.value?.type !== import_utils3.TSESTree.AST_NODE_TYPES.CallExpression) return false;
   const name = angularName(node.value.callee, imports);
   const isString = typeof name === "string";
   if (!isString) return false;
@@ -302,12 +938,12 @@ var formsInterfaceMethods = {
   Validator: ["validate", "registerOnValidatorChange"]
 };
 var isInstanceField = (node) => {
-  if (node.type !== import_utils3.TSESTree.AST_NODE_TYPES.PropertyDefinition) return false;
-  return node.key.type === import_utils3.TSESTree.AST_NODE_TYPES.Identifier;
+  if (node.type !== import_utils4.TSESTree.AST_NODE_TYPES.PropertyDefinition) return false;
+  return node.key.type === import_utils4.TSESTree.AST_NODE_TYPES.Identifier;
 };
 var isInstanceMethod = (node) => {
-  if (node.type !== import_utils3.TSESTree.AST_NODE_TYPES.MethodDefinition) return false;
-  return node.key.type === import_utils3.TSESTree.AST_NODE_TYPES.Identifier;
+  if (node.type !== import_utils4.TSESTree.AST_NODE_TYPES.MethodDefinition) return false;
+  return node.key.type === import_utils4.TSESTree.AST_NODE_TYPES.Identifier;
 };
 var isExcludedField = (node, localPrivateOnly, sourceCode) => {
   const isModified = node.static || node.declare || node.override;
@@ -334,7 +970,7 @@ var isExcludedMethod = (node, localPrivateOnly, implementedMethods) => {
 var implementedFormsMethods = (node) => {
   const methods = /* @__PURE__ */ new Set();
   for (const heritage of node.implements) {
-    if (heritage.expression.type !== import_utils3.TSESTree.AST_NODE_TYPES.Identifier) {
+    if (heritage.expression.type !== import_utils4.TSESTree.AST_NODE_TYPES.Identifier) {
       continue;
     }
     for (const name of formsInterfaceMethods[heritage.expression.name] ?? []) {
@@ -381,32 +1017,34 @@ var methodCandidate = (node, localPrivateOnly, implementedMethods) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-metadata-reads.ts
-var import_node_path = require("node:path");
-var import_utils5 = require("@typescript-eslint/utils");
+var import_node_path4 = require("node:path");
+var import_utils6 = require("@typescript-eslint/utils");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-metadata-literals.ts
-var import_utils4 = require("@typescript-eslint/utils");
+var import_utils5 = require("@typescript-eslint/utils");
 var text = (node) => {
-  if (node?.type === import_utils4.TSESTree.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+  if (node?.type === import_utils5.TSESTree.AST_NODE_TYPES.Literal && typeof node.value === "string") {
     return node.value;
   }
-  if (node?.type !== import_utils4.TSESTree.AST_NODE_TYPES.TemplateLiteral) return null;
+  if (node?.type !== import_utils5.TSESTree.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 !== import_utils4.TSESTree.AST_NODE_TYPES.Property || property.computed) {
+  if (property.type !== import_utils5.TSESTree.AST_NODE_TYPES.Property || property.computed) {
     return null;
   }
-  if (property.key.type === import_utils4.TSESTree.AST_NODE_TYPES.Identifier) {
+  if (property.key.type === import_utils5.TSESTree.AST_NODE_TYPES.Identifier) {
     return property.key.name;
   }
   return text(property.key);
 };
-var metadataValue = (metadata, name) => {
+var metadataValue2 = (metadata, name) => {
   for (const property of metadata.properties) {
-    if (property.type !== import_utils4.TSESTree.AST_NODE_TYPES.Property) continue;
+    if (property.type !== import_utils5.TSESTree.AST_NODE_TYPES.Property) continue;
     const propertyKey = key(property);
     if (propertyKey === name) return property.value;
   }
@@ -414,24 +1052,24 @@ var metadataValue = (metadata, name) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-template-parsing.ts
-var import_compiler3 = require("@angular/compiler");
-var import_node_fs = require("node:fs");
+var import_compiler5 = require("@angular/compiler");
+var import_node_fs5 = require("node:fs");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-expression-reads.ts
-var import_compiler2 = require("@angular/compiler");
+var import_compiler4 = require("@angular/compiler");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/utils/angular-read-target.util.ts
-var import_compiler = require("@angular/compiler");
+var import_compiler3 = require("@angular/compiler");
 var isReadTarget = (node) => {
-  const isPropertyRead = node instanceof import_compiler.PropertyRead;
-  const isSafePropertyRead = node instanceof import_compiler.SafePropertyRead;
-  const isKeyedRead = node instanceof import_compiler.KeyedRead;
-  const isSafeKeyedRead = node instanceof import_compiler.SafeKeyedRead;
+  const isPropertyRead = node instanceof import_compiler3.PropertyRead;
+  const isSafePropertyRead = node instanceof import_compiler3.SafePropertyRead;
+  const isKeyedRead = node instanceof import_compiler3.KeyedRead;
+  const isSafeKeyedRead = node instanceof import_compiler3.SafeKeyedRead;
   return isPropertyRead || isSafePropertyRead || isKeyedRead || isSafeKeyedRead;
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/angular/angular-expression-reads.ts
-var ReadCollector = class extends import_compiler2.CombinedRecursiveAstVisitor {
+var ReadCollector = class extends import_compiler4.CombinedRecursiveAstVisitor {
   reads = /* @__PURE__ */ new Set();
   boundTarget;
   action;
@@ -441,11 +1079,11 @@ var ReadCollector = class extends import_compiler2.CombinedRecursiveAstVisitor {
     this.action = action;
   }
   record(node) {
-    if (node.receiver instanceof import_compiler2.ThisReceiver) {
+    if (node.receiver instanceof import_compiler4.ThisReceiver) {
       this.reads.add(node.name);
       return;
     }
-    if (!(node.receiver instanceof import_compiler2.ImplicitReceiver)) return;
+    if (!(node.receiver instanceof import_compiler4.ImplicitReceiver)) return;
     const isBindableName = !this.action || node.name !== "$event";
     if (!isBindableName) return;
     const expressionTarget = this.boundTarget?.getExpressionTarget(node);
@@ -457,7 +1095,7 @@ var ReadCollector = class extends import_compiler2.CombinedRecursiveAstVisitor {
     if (isReadTarget(node.left)) {
       this.visit(node.left.receiver);
     }
-    if (node.left instanceof import_compiler2.KeyedRead || node.left instanceof import_compiler2.SafeKeyedRead) {
+    if (node.left instanceof import_compiler4.KeyedRead || node.left instanceof import_compiler4.SafeKeyedRead) {
       this.visit(node.left.key);
     }
     this.visit(node.right);
@@ -482,11 +1120,11 @@ 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 import_compiler3.Parser(new import_compiler3.Lexer());
-var templateBinder = new import_compiler3.R3TargetBinder(null);
+var parser2 = new import_compiler5.Parser(new import_compiler5.Lexer());
+var templateBinder = new import_compiler5.R3TargetBinder(null);
 var templateReads = (template, filename) => {
   try {
-    const result = (0, import_compiler3.parseTemplate)(template, filename);
+    const result = (0, import_compiler5.parseTemplate)(template, filename);
     if (result.errors?.length) return null;
     return collectAngularExpressionReads(
       result.nodes,
@@ -499,11 +1137,11 @@ var templateReads = (template, filename) => {
 };
 var externalTemplateReads = (filename) => {
   try {
-    const stats = (0, import_node_fs.statSync)(filename, { bigint: true });
+    const stats = (0, import_node_fs5.statSync)(filename, { bigint: true });
     const version = `${stats.mtimeNs}:${stats.size}`;
     const cached = externalTemplates.get(filename);
     if (cached?.version === version) return cached.reads;
-    const reads = templateReads((0, import_node_fs.readFileSync)(filename, "utf8"), filename);
+    const reads = templateReads((0, import_node_fs5.readFileSync)(filename, "utf8"), filename);
     externalTemplates.set(filename, { reads, version });
     return reads;
   } catch {
@@ -511,14 +1149,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 import_compiler3.ParseSourceFile(expression, filename);
-    const start = new import_compiler3.ParseLocation(file, 0, 0, 0);
-    const span = new import_compiler3.ParseSourceSpan(start, start.moveBy(expression.length));
+    const file = new import_compiler5.ParseSourceFile(expression, filename);
+    const start = new import_compiler5.ParseLocation(file, 0, 0, 0);
+    const span = new import_compiler5.ParseSourceSpan(start, start.moveBy(expression.length));
     const result = parseExpression(expression, span, action);
     if (result.errors.length > 0) return null;
     return collectAngularExpressionReads([result], void 0, action);
@@ -551,13 +1189,13 @@ var hostPropertyReads = (property, reads, filename) => {
 };
 var hostReads = (host, reads, filename) => {
   if (!host) return true;
-  if (host.type !== import_utils5.TSESTree.AST_NODE_TYPES.ObjectExpression) return false;
+  if (host.type !== import_utils6.TSESTree.AST_NODE_TYPES.ObjectExpression) return false;
   const hasUnreadableKey = host.properties.some(
     (property) => key(property) === null
   );
   if (hasUnreadableKey) return false;
   for (const property of host.properties) {
-    if (property.type !== import_utils5.TSESTree.AST_NODE_TYPES.Property) return false;
+    if (property.type !== import_utils6.TSESTree.AST_NODE_TYPES.Property) return false;
     const hasPropertyReads = hostPropertyReads(property, reads, filename);
     if (!hasPropertyReads) return false;
   }
@@ -571,11 +1209,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((0, import_node_path.resolve)((0, import_node_path.dirname)(filename), url)));
+  return url !== null && addReads(reads, externalTemplateReads((0, import_node_path4.resolve)((0, import_node_path4.dirname)(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) => {
@@ -586,7 +1224,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;
@@ -672,16 +1310,16 @@ var reportUnusedMembers = (options) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/typescript/typescript-class-read-visitor.ts
-var import_utils9 = require("@typescript-eslint/utils");
+var import_utils10 = require("@typescript-eslint/utils");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/typescript/typescript-field-reads.ts
-var import_utils6 = require("@typescript-eslint/utils");
+var import_utils7 = require("@typescript-eslint/utils");
 var expressionWrapperTypes = /* @__PURE__ */ new Set([
-  import_utils6.TSESTree.AST_NODE_TYPES.TSAsExpression,
-  import_utils6.TSESTree.AST_NODE_TYPES.TSInstantiationExpression,
-  import_utils6.TSESTree.AST_NODE_TYPES.TSNonNullExpression,
-  import_utils6.TSESTree.AST_NODE_TYPES.TSSatisfiesExpression,
-  import_utils6.TSESTree.AST_NODE_TYPES.TSTypeAssertion
+  import_utils7.TSESTree.AST_NODE_TYPES.TSAsExpression,
+  import_utils7.TSESTree.AST_NODE_TYPES.TSInstantiationExpression,
+  import_utils7.TSESTree.AST_NODE_TYPES.TSNonNullExpression,
+  import_utils7.TSESTree.AST_NODE_TYPES.TSSatisfiesExpression,
+  import_utils7.TSESTree.AST_NODE_TYPES.TSTypeAssertion
 ]);
 var isTypeScriptExpressionWrapper = (node) => {
   return expressionWrapperTypes.has(node.type);
@@ -695,10 +1333,10 @@ var unwrapTypeScriptExpression = (node) => {
 };
 var isThisExpression = (node) => {
   const unwrapped = unwrapTypeScriptExpression(node);
-  return unwrapped?.type === import_utils6.TSESTree.AST_NODE_TYPES.ThisExpression;
+  return unwrapped?.type === import_utils7.TSESTree.AST_NODE_TYPES.ThisExpression;
 };
 var destructuringParts = (node) => {
-  if (node.type === import_utils6.TSESTree.AST_NODE_TYPES.VariableDeclarator) {
+  if (node.type === import_utils7.TSESTree.AST_NODE_TYPES.VariableDeclarator) {
     const variableParts = {
       pattern: node.id,
       source: node.init
@@ -715,10 +1353,10 @@ var destructuringParts = (node) => {
   return null;
 };
 var propertyName = (property) => {
-  if (property.type !== import_utils6.TSESTree.AST_NODE_TYPES.Property || property.computed) {
+  if (property.type !== import_utils7.TSESTree.AST_NODE_TYPES.Property || property.computed) {
     return null;
   }
-  if (property.key.type === import_utils6.TSESTree.AST_NODE_TYPES.Identifier) {
+  if (property.key.type === import_utils7.TSESTree.AST_NODE_TYPES.Identifier) {
     return property.key.name;
   }
   const { value } = property.key;
@@ -728,7 +1366,7 @@ var propertyName = (property) => {
 var destructuredThisReads = (node) => {
   const parts = destructuringParts(node);
   if (!parts) return void 0;
-  if (parts.pattern.type !== import_utils6.TSESTree.AST_NODE_TYPES.ObjectPattern) {
+  if (parts.pattern.type !== import_utils7.TSESTree.AST_NODE_TYPES.ObjectPattern) {
     return void 0;
   }
   const isThisSource = isThisExpression(parts.source);
@@ -743,13 +1381,13 @@ var destructuredThisReads = (node) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/typescript/typescript-lexical-this.ts
-var import_utils7 = require("@typescript-eslint/utils");
+var import_utils8 = require("@typescript-eslint/utils");
 var componentThis = (node, thisStack) => {
-  if (node.type === import_utils7.TSESTree.AST_NODE_TYPES.ArrowFunctionExpression) {
+  if (node.type === import_utils8.TSESTree.AST_NODE_TYPES.ArrowFunctionExpression) {
     return thisStack.at(-1) ?? false;
   }
   const { parent } = node;
-  if (parent.type !== import_utils7.TSESTree.AST_NODE_TYPES.MethodDefinition) return false;
+  if (parent.type !== import_utils8.TSESTree.AST_NODE_TYPES.MethodDefinition) return false;
   return !parent.static;
 };
 var lexicalThisVisitor = (thisStack) => {
@@ -793,40 +1431,40 @@ var lexicalThisVisitor = (thisStack) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/rule/typescript/typescript-write-targets.ts
-var import_utils8 = require("@typescript-eslint/utils");
+var import_utils9 = require("@typescript-eslint/utils");
 var parentOf = (node) => {
-  if (node.type === import_utils8.TSESTree.AST_NODE_TYPES.Program) return void 0;
+  if (node.type === import_utils9.TSESTree.AST_NODE_TYPES.Program) return void 0;
   return node.parent;
 };
 var isPatternTarget = (parent, child) => {
   if (parent === void 0) return false;
-  if (parent.type === import_utils8.TSESTree.AST_NODE_TYPES.ArrayPattern) {
+  if (parent.type === import_utils9.TSESTree.AST_NODE_TYPES.ArrayPattern) {
     return parent.elements.some((element) => element === child);
   }
-  if (parent.type === import_utils8.TSESTree.AST_NODE_TYPES.AssignmentPattern) {
+  if (parent.type === import_utils9.TSESTree.AST_NODE_TYPES.AssignmentPattern) {
     return parent.left === child;
   }
-  if (parent.type === import_utils8.TSESTree.AST_NODE_TYPES.ObjectPattern) {
+  if (parent.type === import_utils9.TSESTree.AST_NODE_TYPES.ObjectPattern) {
     return parent.properties.some((property) => property === child);
   }
-  if (parent.type === import_utils8.TSESTree.AST_NODE_TYPES.Property) {
-    const isObjectPattern = parent.parent.type === import_utils8.TSESTree.AST_NODE_TYPES.ObjectPattern;
+  if (parent.type === import_utils9.TSESTree.AST_NODE_TYPES.Property) {
+    const isObjectPattern = parent.parent.type === import_utils9.TSESTree.AST_NODE_TYPES.ObjectPattern;
     return parent.value === child && isObjectPattern;
   }
-  if (parent.type === import_utils8.TSESTree.AST_NODE_TYPES.RestElement) {
+  if (parent.type === import_utils9.TSESTree.AST_NODE_TYPES.RestElement) {
     return parent.argument === child;
   }
   return false;
 };
 var isSimpleAssignmentTarget = (parent, current) => {
-  if (parent?.type !== import_utils8.TSESTree.AST_NODE_TYPES.AssignmentExpression) {
+  if (parent?.type !== import_utils9.TSESTree.AST_NODE_TYPES.AssignmentExpression) {
     return false;
   }
   return parent.left === current && parent.operator === "=";
 };
 var isLoopTarget = (parent, current) => {
-  const isForIn = parent?.type === import_utils8.TSESTree.AST_NODE_TYPES.ForInStatement;
-  const isForOf = parent?.type === import_utils8.TSESTree.AST_NODE_TYPES.ForOfStatement;
+  const isForIn = parent?.type === import_utils9.TSESTree.AST_NODE_TYPES.ForInStatement;
+  const isForOf = parent?.type === import_utils9.TSESTree.AST_NODE_TYPES.ForOfStatement;
   const isLoop = isForIn || isForOf;
   if (!isLoop) return false;
   return parent.left === current;
@@ -843,7 +1481,7 @@ var isDirectWrite = (node) => {
     current = parent;
     parent = parentOf(parent);
   }
-  const isDeleteExpression2 = parent?.type === import_utils8.TSESTree.AST_NODE_TYPES.UnaryExpression && parent.operator === "delete";
+  const isDeleteExpression2 = parent?.type === import_utils9.TSESTree.AST_NODE_TYPES.UnaryExpression && parent.operator === "delete";
   const isAssignment = isSimpleAssignmentTarget(parent, current);
   return isAssignment || isDeleteExpression2;
 };
@@ -892,7 +1530,7 @@ var trackMemberRead = (node, stack, thisStack, dynamicClasses) => {
   if (!receiverIsThis || node.computed) return;
   const isWriteOnlyTarget = isWriteOnly(node);
   if (isWriteOnlyTarget) return;
-  if (node.property.type === import_utils9.TSESTree.AST_NODE_TYPES.Identifier) {
+  if (node.property.type === import_utils10.TSESTree.AST_NODE_TYPES.Identifier) {
     current.reads.add(node.property.name);
   }
 };
@@ -942,10 +1580,10 @@ var classReadVisitor = (classes, stack, dynamicClasses) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-usage.ts
-var import_typescript17 = require("typescript");
+var import_typescript18 = require("typescript");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-directive-index.ts
-var import_compiler4 = require("@angular/compiler");
+var import_compiler6 = require("@angular/compiler");
 var classShape = ({
   component,
   declaration,
@@ -970,7 +1608,7 @@ var directiveShape = (classes) => {
 };
 var parseSelector = (selector) => {
   try {
-    return import_compiler4.CssSelector.parse(selector);
+    return import_compiler6.CssSelector.parse(selector);
   } catch {
     return null;
   }
@@ -978,7 +1616,7 @@ var parseSelector = (selector) => {
 var buildDirectiveIndex = (classes) => {
   const byDeclaration = /* @__PURE__ */ new Map();
   const byExportAs = /* @__PURE__ */ new Map();
-  const componentMatcher = new import_compiler4.SelectorMatcher();
+  const componentMatcher = new import_compiler6.SelectorMatcher();
   for (const angularClass2 of classes) {
     const { component, declaration, exportAs, selector } = angularClass2;
     byDeclaration.set(declaration, angularClass2);
@@ -1003,17 +1641,17 @@ var buildDirectiveIndex = (classes) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-reads.ts
-var import_node_fs2 = require("node:fs");
-var import_typescript3 = require("typescript");
+var import_node_fs6 = require("node:fs");
+var import_typescript4 = require("typescript");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-read-resolution.ts
-var import_compiler7 = require("@angular/compiler");
+var import_compiler9 = require("@angular/compiler");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-resolved-path.ts
-var import_typescript2 = require("typescript");
+var import_typescript3 = require("typescript");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/utils/type-property-symbols.util.ts
-var import_typescript = require("typescript");
+var import_typescript2 = require("typescript");
 var symbolsForName = (checker, type, name) => {
   const symbol = checker.getPropertyOfType(checker.getApparentType(type), name);
   if (symbol) return [symbol];
@@ -1030,7 +1668,7 @@ var symbolsForName = (checker, type, name) => {
 var stringIndexTypes = (checker, type) => {
   const indexedType = checker.getIndexTypeOfType(
     checker.getApparentType(type),
-    import_typescript.IndexKind.String
+    import_typescript2.IndexKind.String
   );
   if (indexedType) return [indexedType];
   const isUnionOrIntersection = type.isUnionOrIntersection();
@@ -1046,7 +1684,7 @@ var stringIndexTypes = (checker, type) => {
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-resolved-path.ts
 var hasAnyOrUnknownFlag = (type) => {
-  const anyOrUnknown = import_typescript2.TypeFlags.Any | import_typescript2.TypeFlags.Unknown;
+  const anyOrUnknown = import_typescript3.TypeFlags.Any | import_typescript3.TypeFlags.Unknown;
   return (type.flags & anyOrUnknown) !== 0;
 };
 var isAnyOrUnknown = (types) => {
@@ -1058,7 +1696,7 @@ var addTypes = (sink, types) => {
   }
 };
 var callReturnTypes = (checker, type) => {
-  const signatures = checker.getSignaturesOfType(type, import_typescript2.SignatureKind.Call);
+  const signatures = checker.getSignaturesOfType(type, import_typescript3.SignatureKind.Call);
   return signatures.map((signature) => signature.getReturnType());
 };
 var memberTypes = (symbols, declaration, checker, sink) => {
@@ -1108,15 +1746,15 @@ var addResolvedPath = ({
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-read-chains.ts
-var import_compiler5 = require("@angular/compiler");
+var import_compiler7 = require("@angular/compiler");
 var isPropertyReadLike = (node) => {
-  const isPlainRead = node instanceof import_compiler5.PropertyRead;
-  const isSafeRead = node instanceof import_compiler5.SafePropertyRead;
+  const isPlainRead = node instanceof import_compiler7.PropertyRead;
+  const isSafeRead = node instanceof import_compiler7.SafePropertyRead;
   return isPlainRead || isSafeRead;
 };
 var isRootRead = (read) => {
-  const isImplicitReceiver = read.receiver instanceof import_compiler5.ImplicitReceiver;
-  const isThisReceiver = read.receiver instanceof import_compiler5.ThisReceiver;
+  const isImplicitReceiver = read.receiver instanceof import_compiler7.ImplicitReceiver;
+  const isThisReceiver = read.receiver instanceof import_compiler7.ThisReceiver;
   return isImplicitReceiver || isThisReceiver;
 };
 var chainStep = (read) => {
@@ -1126,7 +1764,7 @@ var chainStep = (read) => {
     const readStep = { called: false, next: receiver };
     return readStep;
   }
-  const isCallReceiver = receiver instanceof import_compiler5.Call;
+  const isCallReceiver = receiver instanceof import_compiler7.Call;
   if (!isCallReceiver) return null;
   const target = receiver.receiver;
   const isReadLikeTarget = isPropertyReadLike(target);
@@ -1144,11 +1782,11 @@ var readChain = (node) => {
     current = step.next;
     names.unshift({ called: step.called, name: current.name });
   }
-  if (!(current instanceof import_compiler5.PropertyRead)) return null;
+  if (!(current instanceof import_compiler7.PropertyRead)) return null;
   const chain = { names, root: current };
   return chain;
 };
-var ReadCollector2 = class extends import_compiler5.CombinedRecursiveAstVisitor {
+var ReadCollector2 = class extends import_compiler7.CombinedRecursiveAstVisitor {
   reads = [];
   referenceOwners = /* @__PURE__ */ new Map();
   record(node) {
@@ -1183,7 +1821,7 @@ var ReadCollector2 = class extends import_compiler5.CombinedRecursiveAstVisitor
     if (isReadTarget(node.left)) {
       this.visit(node.left.receiver);
     }
-    if (node.left instanceof import_compiler5.KeyedRead || node.left instanceof import_compiler5.SafeKeyedRead) {
+    if (node.left instanceof import_compiler7.KeyedRead || node.left instanceof import_compiler7.SafeKeyedRead) {
       this.visit(node.left.key);
     }
     this.visit(node.right);
@@ -1200,7 +1838,7 @@ var ReadCollector2 = class extends import_compiler5.CombinedRecursiveAstVisitor
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-template-references.ts
-var import_compiler6 = require("@angular/compiler");
+var import_compiler8 = require("@angular/compiler");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/utils/read-chain-text.util.ts
 var segmentText = (segment) => {
@@ -1219,9 +1857,9 @@ var referenceTargets = (reference, owner, directives, scope) => {
   if (exportAs !== "") {
     const exportedTargets = directives.byExportAs.get(exportAs) ?? [];
     targets = [...exportedTargets];
-  } else if (owner instanceof import_compiler6.TmplAstElement) {
+  } else if (owner instanceof import_compiler8.TmplAstElement) {
     directives.componentMatcher.match(
-      (0, import_compiler6.createCssSelectorFromNode)(owner),
+      (0, import_compiler8.createCssSelectorFromNode)(owner),
       (_selector, declarations) => {
         targets.push(...declarations);
       }
@@ -1261,7 +1899,7 @@ var identifierNames = (text2) => {
   const matches = text2.match(/[A-Za-z_$][\w$]*/gu) ?? [];
   return new Set(matches);
 };
-var templateBinder2 = new import_compiler7.R3TargetBinder(null);
+var templateBinder2 = new import_compiler9.R3TargetBinder(null);
 var unparsedTemplateReads = (context, source, error) => {
   const names = identifierNames(source);
   const message = error ?? "unknown error";
@@ -1286,7 +1924,7 @@ var addComponentRead = (context, names) => {
   sink.addFallbackNames(fallbackNames, reason);
 };
 var chainEntity = (boundTarget, chain) => {
-  const isThisRead = chain.root.receiver instanceof import_compiler7.ThisReceiver;
+  const isThisRead = chain.root.receiver instanceof import_compiler9.ThisReceiver;
   if (isThisRead) return null;
   return boundTarget.getExpressionTarget(chain.root);
 };
@@ -1296,7 +1934,7 @@ var addChainRead = (context, reads, boundTarget, chain) => {
     addComponentRead(context, chain.names);
     return false;
   }
-  if (!(entity instanceof import_compiler7.TmplAstReference)) return false;
+  if (!(entity instanceof import_compiler9.TmplAstReference)) return false;
   const owner = reads.referenceOwners.get(entity);
   const names = chain.names.slice(1);
   addReferenceRead(context, entity, owner, names);
@@ -1321,7 +1959,7 @@ var addTemplateReads = ({
     scope,
     sink
   };
-  const parsed = (0, import_compiler7.parseTemplate)(source, fileName);
+  const parsed = (0, import_compiler9.parseTemplate)(source, fileName);
   if (parsed.errors?.length) {
     const error = parsed.errors[0]?.msg;
     return unparsedTemplateReads(context, source, error);
@@ -1344,8 +1982,8 @@ var addTemplateReads = ({
 var memberNameOf = (member) => {
   const name = member.name;
   if (!name) return [];
-  const isIdentifierName = (0, import_typescript3.isIdentifier)(name);
-  const isStringName = (0, import_typescript3.isStringLiteralLike)(name);
+  const isIdentifierName = (0, import_typescript4.isIdentifier)(name);
+  const isStringName = (0, import_typescript4.isStringLiteralLike)(name);
   const isTextName = isIdentifierName || isStringName;
   if (!isTextName) return [];
   const names = [name.text];
@@ -1361,13 +1999,13 @@ var unknownTemplateNames = ({ declaration, scope }, allNames) => {
   return names;
 };
 var templateFileVersion = (fileName) => {
-  const { mtimeNs, size } = (0, import_node_fs2.statSync)(fileName, { bigint: true });
+  const { mtimeNs, size } = (0, import_node_fs6.statSync)(fileName, { bigint: true });
   const version = { fileName, mtimeNs, size };
   return version;
 };
 var templateFileIsCurrent = (version) => {
   try {
-    const current = (0, import_node_fs2.statSync)(version.fileName, { bigint: true });
+    const current = (0, import_node_fs6.statSync)(version.fileName, { bigint: true });
     return current.mtimeNs === version.mtimeNs && current.size === version.size;
   } catch {
     return false;
@@ -1391,7 +2029,7 @@ var templateSourceOf = (angularClass2, allNames, sink, versions) => {
   const templateFileName = template.fileName;
   try {
     versions.push(templateFileVersion(templateFileName));
-    const source = (0, import_node_fs2.readFileSync)(templateFileName, "utf8");
+    const source = (0, import_node_fs6.readFileSync)(templateFileName, "utf8");
     const externalSource = {
       fileName: templateFileName,
       source
@@ -1439,15 +2077,15 @@ var collectAngularTemplateReads = ({
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-reads.ts
-var import_typescript10 = require("typescript");
+var import_typescript11 = require("typescript");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-angular-interface-methods.ts
-var import_typescript5 = require("typescript");
+var import_typescript6 = require("typescript");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-symbol-reads.ts
-var import_typescript4 = require("typescript");
+var import_typescript5 = require("typescript");
 var aliasTarget = (checker, symbol) => {
-  const isAlias = (symbol.flags & import_typescript4.SymbolFlags.Alias) !== 0;
+  const isAlias = (symbol.flags & import_typescript5.SymbolFlags.Alias) !== 0;
   if (!isAlias) return symbol;
   return checker.getAliasedSymbol(symbol);
 };
@@ -1499,11 +2137,11 @@ var literalPropertyNames = (type) => {
   return names;
 };
 var propertyName2 = (checker, node) => {
-  const isIdentifierName = (0, import_typescript4.isIdentifier)(node);
-  const isPrivateName = (0, import_typescript4.isPrivateIdentifier)(node);
-  const isStringName = (0, import_typescript4.isStringLiteralLike)(node);
-  const isNumericName = (0, import_typescript4.isNumericLiteral)(node);
-  const isBigIntName = (0, import_typescript4.isBigIntLiteral)(node);
+  const isIdentifierName = (0, import_typescript5.isIdentifier)(node);
+  const isPrivateName = (0, import_typescript5.isPrivateIdentifier)(node);
+  const isStringName = (0, import_typescript5.isStringLiteralLike)(node);
+  const isNumericName = (0, import_typescript5.isNumericLiteral)(node);
+  const isBigIntName = (0, import_typescript5.isBigIntLiteral)(node);
   const isLiteralName = isIdentifierName || isPrivateName || isStringName || isNumericName || isBigIntName;
   if (isLiteralName) return [node.text];
   return literalPropertyNames(checker.getTypeAtLocation(node.expression));
@@ -1511,7 +2149,7 @@ var propertyName2 = (checker, node) => {
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-angular-interface-methods.ts
 var isAngularMethodSignature = (declaration) => {
-  const isMethod = (0, import_typescript5.isMethodSignature)(declaration);
+  const isMethod = (0, import_typescript6.isMethodSignature)(declaration);
   if (!isMethod) return false;
   const fileName = declaration.getSourceFile().fileName.replaceAll("\\", "/");
   return fileName.includes("/node_modules/@angular/");
@@ -1533,7 +2171,7 @@ var addImplementations = (heritageType, classType, checker, sink) => {
 var collectAngularInterfaceMethods = (node, checker, sink) => {
   const heritageClauses = node.heritageClauses ?? [];
   const implementsClauses = heritageClauses.filter(
-    (clause) => clause.token === import_typescript5.SyntaxKind.ImplementsKeyword
+    (clause) => clause.token === import_typescript6.SyntaxKind.ImplementsKeyword
   );
   if (implementsClauses.length === 0) return;
   const classType = checker.getTypeAtLocation(node);
@@ -1547,26 +2185,26 @@ var collectAngularInterfaceMethods = (node, checker, sink) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-destructuring-reads.ts
-var import_typescript8 = require("typescript");
+var import_typescript9 = require("typescript");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-assignment-pattern-elements.ts
-var import_typescript6 = require("typescript");
+var import_typescript7 = require("typescript");
 var nestedPattern = (expression) => {
-  const isArrayLiteral = (0, import_typescript6.isArrayLiteralExpression)(expression);
-  const isObjectLiteral = (0, import_typescript6.isObjectLiteralExpression)(expression);
+  const isArrayLiteral = (0, import_typescript7.isArrayLiteralExpression)(expression);
+  const isObjectLiteral = (0, import_typescript7.isObjectLiteralExpression)(expression);
   const isNested = isArrayLiteral || isObjectLiteral;
   if (!isNested) return null;
   return expression;
 };
 var nestedPropertyPattern = (property) => {
-  const isAssignment = (0, import_typescript6.isPropertyAssignment)(property);
+  const isAssignment = (0, import_typescript7.isPropertyAssignment)(property);
   if (!isAssignment) return null;
   return nestedPattern(property.initializer);
 };
 var arrayElementRead = (element, index) => {
-  const isOmitted = (0, import_typescript6.isOmittedExpression)(element);
+  const isOmitted = (0, import_typescript7.isOmittedExpression)(element);
   if (isOmitted) return null;
-  const isRestElement = (0, import_typescript6.isSpreadElement)(element);
+  const isRestElement = (0, import_typescript7.isSpreadElement)(element);
   const indexNames = [String(index)];
   const names = isRestElement ? null : indexNames;
   const nested = nestedPattern(element);
@@ -1579,7 +2217,7 @@ var arrayElementRead = (element, index) => {
   return read;
 };
 var propertyRead = (property, checker) => {
-  const isRestProperty = (0, import_typescript6.isSpreadAssignment)(property);
+  const isRestProperty = (0, import_typescript7.isSpreadAssignment)(property);
   if (isRestProperty) {
     const restRead = {
       location: property,
@@ -1598,7 +2236,7 @@ var propertyRead = (property, checker) => {
   return read;
 };
 var assignmentPatternElements = (pattern, checker) => {
-  const isArrayPattern = (0, import_typescript6.isArrayLiteralExpression)(pattern);
+  const isArrayPattern = (0, import_typescript7.isArrayLiteralExpression)(pattern);
   if (isArrayPattern) {
     const reads = [];
     for (const [index, element] of pattern.elements.entries()) {
@@ -1613,10 +2251,10 @@ var assignmentPatternElements = (pattern, checker) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-binding-pattern-elements.ts
-var import_typescript7 = require("typescript");
+var import_typescript8 = require("typescript");
 var isBindingPattern = (node) => {
-  const isArrayPattern = (0, import_typescript7.isArrayBindingPattern)(node);
-  const isObjectPattern = (0, import_typescript7.isObjectBindingPattern)(node);
+  const isArrayPattern = (0, import_typescript8.isArrayBindingPattern)(node);
+  const isObjectPattern = (0, import_typescript8.isObjectBindingPattern)(node);
   return isArrayPattern || isObjectPattern;
 };
 var nestedPattern2 = (element) => {
@@ -1626,12 +2264,12 @@ var nestedPattern2 = (element) => {
 };
 var bindingNames = (checker, element) => {
   if (element.propertyName) return propertyName2(checker, element.propertyName);
-  const isIdentifierName = (0, import_typescript7.isIdentifier)(element.name);
+  const isIdentifierName = (0, import_typescript8.isIdentifier)(element.name);
   if (!isIdentifierName) return null;
   return [element.name.text];
 };
 var arrayElementRead2 = (element, index) => {
-  const isOmitted = (0, import_typescript7.isOmittedExpression)(element);
+  const isOmitted = (0, import_typescript8.isOmittedExpression)(element);
   if (isOmitted) return null;
   const isRestElement = Boolean(element.dotDotDotToken);
   const indexNames = [String(index)];
@@ -1665,7 +2303,7 @@ var objectElementRead = (element, checker) => {
   return read;
 };
 var bindingPatternElements = (pattern, checker) => {
-  const isArrayPattern = (0, import_typescript7.isArrayBindingPattern)(pattern);
+  const isArrayPattern = (0, import_typescript8.isArrayBindingPattern)(pattern);
   if (isArrayPattern) {
     const reads = [];
     for (const [index, element] of pattern.elements.entries()) {
@@ -1731,11 +2369,11 @@ var collectPatternReads = (pattern, type, context) => {
 var collectBindingReads = (node, context) => {
   const isBinding = isBindingPattern(node);
   if (!isBinding) return;
-  const isBindingElementParent = (0, import_typescript8.isBindingElement)(node.parent);
+  const isBindingElementParent = (0, import_typescript9.isBindingElement)(node.parent);
   const isNestedBindingName = isBindingElementParent && node.parent.name === node;
   if (isNestedBindingName) return;
   const declaration = node.parent;
-  const isDeclaration = (0, import_typescript8.isVariableDeclaration)(declaration);
+  const isDeclaration = (0, import_typescript9.isVariableDeclaration)(declaration);
   const isInitializedDeclaration = isDeclaration && declaration.initializer !== void 0;
   const source = isInitializedDeclaration ? declaration.initializer : declaration;
   const sourceTypeOf = () => context.checker.getTypeAtLocation(source);
@@ -1743,12 +2381,12 @@ var collectBindingReads = (node, context) => {
   collectPatternReads(node, sourceType, context);
 };
 var collectAssignmentReads = (node, context) => {
-  const isBinary = (0, import_typescript8.isBinaryExpression)(node);
+  const isBinary = (0, import_typescript9.isBinaryExpression)(node);
   if (!isBinary) return;
-  const isEqualsAssignment = node.operatorToken.kind === import_typescript8.SyntaxKind.EqualsToken;
+  const isEqualsAssignment = node.operatorToken.kind === import_typescript9.SyntaxKind.EqualsToken;
   if (!isEqualsAssignment) return;
-  const isArrayTarget = (0, import_typescript8.isArrayLiteralExpression)(node.left);
-  const isObjectTarget = (0, import_typescript8.isObjectLiteralExpression)(node.left);
+  const isArrayTarget = (0, import_typescript9.isArrayLiteralExpression)(node.left);
+  const isObjectTarget = (0, import_typescript9.isObjectLiteralExpression)(node.left);
   const isDestructuringAssignment = isArrayTarget || isObjectTarget;
   if (!isDestructuringAssignment) return;
   const rightTypeOf = () => context.checker.getTypeAtLocation(node.right);
@@ -1762,42 +2400,42 @@ var collectDestructuringReads = (node, checker, sink, candidateNames) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-write-targets.ts
-var import_typescript9 = require("typescript");
+var import_typescript10 = require("typescript");
 var isExpressionWrapper = (parent, child) => {
-  const isParenthesized = (0, import_typescript9.isParenthesizedExpression)(parent);
-  const isAs = (0, import_typescript9.isAsExpression)(parent);
-  const isTypeAssertion = (0, import_typescript9.isTypeAssertionExpression)(parent);
-  const isNonNull = (0, import_typescript9.isNonNullExpression)(parent);
-  const isSatisfies = (0, import_typescript9.isSatisfiesExpression)(parent);
+  const isParenthesized = (0, import_typescript10.isParenthesizedExpression)(parent);
+  const isAs = (0, import_typescript10.isAsExpression)(parent);
+  const isTypeAssertion = (0, import_typescript10.isTypeAssertionExpression)(parent);
+  const isNonNull = (0, import_typescript10.isNonNullExpression)(parent);
+  const isSatisfies = (0, import_typescript10.isSatisfiesExpression)(parent);
   const isCast = isAs || isTypeAssertion || isSatisfies;
   const isWrapper = isParenthesized || isNonNull || isCast;
   if (!isWrapper) return false;
   return parent.expression === child;
 };
 var isPatternContainer = (parent, child) => {
-  const isArrayLiteral = (0, import_typescript9.isArrayLiteralExpression)(parent);
+  const isArrayLiteral = (0, import_typescript10.isArrayLiteralExpression)(parent);
   if (isArrayLiteral) {
     return parent.elements.some((element) => element === child);
   }
-  const isObjectLiteral = (0, import_typescript9.isObjectLiteralExpression)(parent);
+  const isObjectLiteral = (0, import_typescript10.isObjectLiteralExpression)(parent);
   if (isObjectLiteral) {
     return parent.properties.some((property) => property === child);
   }
-  const isAssignment = (0, import_typescript9.isPropertyAssignment)(parent);
+  const isAssignment = (0, import_typescript10.isPropertyAssignment)(parent);
   if (isAssignment) return parent.initializer === child;
-  const isSpread = (0, import_typescript9.isSpreadAssignment)(parent);
+  const isSpread = (0, import_typescript10.isSpreadAssignment)(parent);
   if (!isSpread) return false;
   return parent.expression === child;
 };
 var isWriteTarget = (parent, current) => {
-  const isBinary = (0, import_typescript9.isBinaryExpression)(parent);
-  const isBinaryTarget = isBinary && parent.left === current && parent.operatorToken.kind === import_typescript9.SyntaxKind.EqualsToken;
+  const isBinary = (0, import_typescript10.isBinaryExpression)(parent);
+  const isBinaryTarget = isBinary && parent.left === current && parent.operatorToken.kind === import_typescript10.SyntaxKind.EqualsToken;
   if (isBinaryTarget) return true;
-  const isDelete = (0, import_typescript9.isDeleteExpression)(parent);
+  const isDelete = (0, import_typescript10.isDeleteExpression)(parent);
   const isDeleteTarget = isDelete && parent.expression === current;
   if (isDeleteTarget) return true;
-  const isForIn = (0, import_typescript9.isForInStatement)(parent);
-  const isForOf = (0, import_typescript9.isForOfStatement)(parent);
+  const isForIn = (0, import_typescript10.isForInStatement)(parent);
+  const isForOf = (0, import_typescript10.isForOfStatement)(parent);
   const isIteration = isForIn || isForOf;
   return isIteration && parent.initializer === current;
 };
@@ -1837,9 +2475,9 @@ var addElementAccessRead = (node, checker, sink, candidateNames) => {
 };
 var collectTypeScriptReads = (sourceFile, checker, sink, candidateNames) => {
   const visit = (node) => {
-    const isPropertyAccess = (0, import_typescript10.isPropertyAccessExpression)(node);
-    const isElementAccess = (0, import_typescript10.isElementAccessExpression)(node);
-    const isClass = (0, import_typescript10.isClassLike)(node);
+    const isPropertyAccess = (0, import_typescript11.isPropertyAccessExpression)(node);
+    const isElementAccess = (0, import_typescript11.isElementAccessExpression)(node);
+    const isClass = (0, import_typescript11.isClassLike)(node);
     if (isPropertyAccess) {
       addPropertyAccessRead(node, checker, sink, candidateNames);
     } else if (isElementAccess) {
@@ -1848,21 +2486,21 @@ var collectTypeScriptReads = (sourceFile, checker, sink, candidateNames) => {
       collectAngularInterfaceMethods(node, checker, sink);
     }
     collectDestructuringReads(node, checker, sink, candidateNames);
-    (0, import_typescript10.forEachChild)(node, visit);
+    (0, import_typescript11.forEachChild)(node, visit);
   };
   visit(sourceFile);
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-type-dependencies.ts
-var import_typescript11 = require("typescript");
+var import_typescript12 = require("typescript");
 var isObjectType = (type) => {
-  return (type.flags & import_typescript11.TypeFlags.Object) !== 0;
+  return (type.flags & import_typescript12.TypeFlags.Object) !== 0;
 };
 var isTypeReference = (type) => {
-  return (type.objectFlags & import_typescript11.ObjectFlags.Reference) !== 0;
+  return (type.objectFlags & import_typescript12.ObjectFlags.Reference) !== 0;
 };
 var isInterfaceType = (type) => {
-  return (type.objectFlags & import_typescript11.ObjectFlags.ClassOrInterface) !== 0;
+  return (type.objectFlags & import_typescript12.ObjectFlags.ClassOrInterface) !== 0;
 };
 var addDeclarationFiles = (type, dependencies) => {
   for (const symbol of [type.getSymbol(), type.aliasSymbol]) {
@@ -1893,7 +2531,7 @@ var addTypeDependencies = (checker, type, dependencies, seen) => {
     return;
   }
   addDeclarationFiles(type, dependencies);
-  const isTypeParameter = (type.flags & import_typescript11.TypeFlags.TypeParameter) !== 0;
+  const isTypeParameter = (type.flags & import_typescript12.TypeFlags.TypeParameter) !== 0;
   if (isTypeParameter) {
     const constraint = checker.getBaseConstraintOfType(type);
     if (constraint) {
@@ -1956,24 +2594,24 @@ 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
-var import_typescript15 = require("typescript");
+var import_typescript16 = require("typescript");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-component-scope.ts
-var import_typescript14 = require("typescript");
+var import_typescript15 = require("typescript");
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-decorator-kind.ts
-var import_typescript12 = require("typescript");
+var import_typescript13 = require("typescript");
 var decoratorKinds = [
   "Component",
   "Directive",
@@ -1993,8 +2631,8 @@ var parentOf2 = (node) => {
 var importedFromAngularCore = (declaration) => {
   let current = parentOf2(declaration);
   while (current) {
-    if ((0, import_typescript12.isImportDeclaration)(current)) {
-      return (0, import_typescript12.isStringLiteralLike)(current.moduleSpecifier) && current.moduleSpecifier.text === "@angular/core";
+    if ((0, import_typescript13.isImportDeclaration)(current)) {
+      return (0, import_typescript13.isStringLiteralLike)(current.moduleSpecifier) && current.moduleSpecifier.text === "@angular/core";
     }
     current = parentOf2(current);
   }
@@ -2006,7 +2644,7 @@ var resolveAlias = (symbol, discovery) => {
     for (const declaration of current.declarations ?? []) {
       discovery.dependencies.add(declaration.getSourceFile());
     }
-    if ((current.flags & import_typescript12.SymbolFlags.Alias) === 0) return current;
+    if ((current.flags & import_typescript13.SymbolFlags.Alias) === 0) return current;
     const next = discovery.checker.getImmediateAliasedSymbol(current);
     if (!next || next === current) return current;
     current = next;
@@ -2029,10 +2667,10 @@ var angularDecoratorKind = (expression, discovery) => {
   return name;
 };
 var classDecoratorKind = (declaration, discovery) => {
-  const hasDecorators = (0, import_typescript12.canHaveDecorators)(declaration);
+  const hasDecorators = (0, import_typescript13.canHaveDecorators)(declaration);
   if (!hasDecorators) return null;
-  for (const decorator of (0, import_typescript12.getDecorators)(declaration) ?? []) {
-    const isDecoratorCall = (0, import_typescript12.isCallExpression)(decorator.expression);
+  for (const decorator of (0, import_typescript13.getDecorators)(declaration) ?? []) {
+    const isDecoratorCall = (0, import_typescript13.isCallExpression)(decorator.expression);
     if (!isDecoratorCall) continue;
     const kind = angularDecoratorKind(
       decorator.expression.expression,
@@ -2044,17 +2682,17 @@ var classDecoratorKind = (declaration, discovery) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-metadata-values.ts
-var import_node_path2 = require("node:path");
-var import_typescript13 = require("typescript");
+var import_node_path5 = require("node:path");
+var import_typescript14 = require("typescript");
 var stringValue = (node, discovery) => {
   if (!node) return null;
-  const isStringLiteral = (0, import_typescript13.isStringLiteralLike)(node);
+  const isStringLiteral = (0, import_typescript14.isStringLiteralLike)(node);
   if (isStringLiteral) return node.text;
-  const isIdentifierNode = (0, import_typescript13.isIdentifier)(node);
-  const isPropertyAccessNode = (0, import_typescript13.isPropertyAccessExpression)(node);
+  const isIdentifierNode = (0, import_typescript14.isIdentifier)(node);
+  const isPropertyAccessNode = (0, import_typescript14.isPropertyAccessExpression)(node);
   if (isIdentifierNode || isPropertyAccessNode) {
     const symbol = discovery.checker.getSymbolAtLocation(
-      (0, import_typescript13.isIdentifier)(node) ? node : node.name
+      (0, import_typescript14.isIdentifier)(node) ? node : node.name
     );
     if (symbol) {
       resolveAlias(symbol, discovery);
@@ -2065,11 +2703,11 @@ var stringValue = (node, discovery) => {
 };
 var metadataProperty = (metadata, name) => {
   for (const property of metadata.properties) {
-    const isAssignment = (0, import_typescript13.isPropertyAssignment)(property);
+    const isAssignment = (0, import_typescript14.isPropertyAssignment)(property);
     if (!isAssignment) continue;
-    const isIdentifierName = (0, import_typescript13.isIdentifier)(property.name);
-    const isStringName = (0, import_typescript13.isStringLiteralLike)(property.name);
-    const isNumericName = (0, import_typescript13.isNumericLiteral)(property.name);
+    const isIdentifierName = (0, import_typescript14.isIdentifier)(property.name);
+    const isStringName = (0, import_typescript14.isStringLiteralLike)(property.name);
+    const isNumericName = (0, import_typescript14.isNumericLiteral)(property.name);
     const isLiteralName = isIdentifierName || isStringName || isNumericName;
     const isPropertyNamed = isLiteralName && property.name.text === name;
     if (isPropertyNamed) return property.initializer;
@@ -2088,7 +2726,7 @@ var templateOf = (metadata, fileName, discovery) => {
   if (url) {
     const text2 = stringValue(url, discovery);
     if (text2 === null) return void 0;
-    const externalFileName = (0, import_node_path2.resolve)((0, import_node_path2.dirname)(fileName), text2);
+    const externalFileName = (0, import_node_path5.resolve)((0, import_node_path5.dirname)(fileName), text2);
     const externalTemplate = {
       fileName: externalFileName,
       kind: "external"
@@ -2107,14 +2745,14 @@ var exportAsOf = (metadata, discovery) => {
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/angular/angular-component-scope.ts
 var booleanValue = (node) => {
   if (!node) return void 0;
-  if (node.kind === import_typescript14.SyntaxKind.TrueKeyword) return true;
-  if (node.kind === import_typescript14.SyntaxKind.FalseKeyword) return false;
+  if (node.kind === import_typescript15.SyntaxKind.TrueKeyword) return true;
+  if (node.kind === import_typescript15.SyntaxKind.FalseKeyword) return false;
   return void 0;
 };
 var classesOf = (symbol, discovery) => {
   const resolved = resolveAlias(symbol, discovery);
   const declarations = resolved.declarations ?? [];
-  return declarations.filter(import_typescript14.isClassLike);
+  return declarations.filter(import_typescript15.isClassLike);
 };
 var scopedClasses = (classes, discovery) => {
   const scoped = [];
@@ -2128,8 +2766,8 @@ var scopedClasses = (classes, discovery) => {
   return scoped;
 };
 var importedClasses = (element, discovery) => {
-  const isIdentifierElement = (0, import_typescript14.isIdentifier)(element);
-  const isPropertyAccessElement = (0, import_typescript14.isPropertyAccessExpression)(element);
+  const isIdentifierElement = (0, import_typescript15.isIdentifier)(element);
+  const isPropertyAccessElement = (0, import_typescript15.isPropertyAccessExpression)(element);
   if (!isIdentifierElement && !isPropertyAccessElement) return null;
   const target = isIdentifierElement ? element : element.name;
   const symbol = discovery.checker.getSymbolAtLocation(target);
@@ -2144,7 +2782,7 @@ var scopeOf = (metadata, discovery) => {
   const isModuleDeclared = standalone === void 0 && !imports;
   if (standalone === false || isModuleDeclared) return null;
   if (!imports) return [];
-  const isImportsArray = (0, import_typescript14.isArrayLiteralExpression)(imports);
+  const isImportsArray = (0, import_typescript15.isArrayLiteralExpression)(imports);
   if (!isImportsArray) return null;
   const scope = [];
   for (const element of imports.elements) {
@@ -2197,7 +2835,7 @@ var decoratedClass = (declaration, call, discovery) => {
     const bareDiscovery = { ...base2, valid: !component };
     return bareDiscovery;
   }
-  const isMetadataObject = (0, import_typescript15.isObjectLiteralExpression)(metadata);
+  const isMetadataObject = (0, import_typescript16.isObjectLiteralExpression)(metadata);
   if (!isMetadataObject) {
     const invalidDiscovery = { ...base2, valid: false };
     return invalidDiscovery;
@@ -2205,10 +2843,10 @@ var decoratedClass = (declaration, call, discovery) => {
   return describedClass(base2, metadata, discovery);
 };
 var angularClass = (declaration, discovery) => {
-  const hasDecorators = (0, import_typescript15.canHaveDecorators)(declaration);
+  const hasDecorators = (0, import_typescript16.canHaveDecorators)(declaration);
   if (!hasDecorators) return null;
-  for (const decorator of (0, import_typescript15.getDecorators)(declaration) ?? []) {
-    const isDecoratorCall = (0, import_typescript15.isCallExpression)(decorator.expression);
+  for (const decorator of (0, import_typescript16.getDecorators)(declaration) ?? []) {
+    const isDecoratorCall = (0, import_typescript16.isCallExpression)(decorator.expression);
     if (!isDecoratorCall) continue;
     const found = decoratedClass(declaration, decorator.expression, discovery);
     if (found) return found;
@@ -2219,14 +2857,14 @@ var angularClasses = (sourceFile, checker) => {
   const classes = [];
   const discovery = { checker, dependencies: /* @__PURE__ */ new Set() };
   const visit = (node) => {
-    const isClass = (0, import_typescript15.isClassLike)(node);
+    const isClass = (0, import_typescript16.isClassLike)(node);
     if (isClass) {
       const found = angularClass(node, discovery);
       if (found) {
         classes.push(found);
       }
     }
-    (0, import_typescript15.forEachChild)(node, visit);
+    (0, import_typescript16.forEachChild)(node, visit);
   };
   visit(sourceFile);
   discovery.dependencies.delete(sourceFile);
@@ -2327,23 +2965,23 @@ var dropStaleTemplateEntries = (index, force) => {
 };
 
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/typescript/typescript-candidate-names.ts
-var import_typescript16 = require("typescript");
+var import_typescript17 = require("typescript");
 var isDecoratedClass = (node) => {
-  const isDecoratable = (0, import_typescript16.canHaveDecorators)(node);
+  const isDecoratable = (0, import_typescript17.canHaveDecorators)(node);
   if (!isDecoratable) return false;
-  const decorators = (0, import_typescript16.getDecorators)(node);
+  const decorators = (0, import_typescript17.getDecorators)(node);
   const decoratorCount = decorators?.length ?? 0;
   return decoratorCount > 0;
 };
 var addMemberNames = (node, names) => {
-  const isClass = (0, import_typescript16.isClassLike)(node);
+  const isClass = (0, import_typescript17.isClassLike)(node);
   if (!isClass) return;
   const isDecorated = isDecoratedClass(node);
   if (!isDecorated) return;
   for (const member of node.members) {
     if (!member.name) continue;
-    const isIdentifierName = (0, import_typescript16.isIdentifier)(member.name);
-    const isStringName = (0, import_typescript16.isStringLiteralLike)(member.name);
+    const isIdentifierName = (0, import_typescript17.isIdentifier)(member.name);
+    const isStringName = (0, import_typescript17.isStringLiteralLike)(member.name);
     const isNamedMember = isIdentifierName || isStringName;
     if (isNamedMember) {
       names.add(member.name.text);
@@ -2354,7 +2992,7 @@ var collectCandidateNames = (sourceFile) => {
   const names = /* @__PURE__ */ new Set();
   const visit = (node) => {
     addMemberNames(node, names);
-    (0, import_typescript16.forEachChild)(node, visit);
+    (0, import_typescript17.forEachChild)(node, visit);
   };
   visit(sourceFile);
   return names;
@@ -2470,11 +3108,11 @@ var reconcile = (index, program) => {
 // packages/lint-suite/src/lib/rules/no-unused-angular-instance-fields/project-usage/project-usage.ts
 var indexes = /* @__PURE__ */ new Map();
 var memberName = (node) => {
-  const isMember = (0, import_typescript17.isClassElement)(node);
+  const isMember = (0, import_typescript18.isClassElement)(node);
   if (!isMember) return null;
   if (!node.name) return null;
-  const isIdentifierName = (0, import_typescript17.isIdentifier)(node.name);
-  const isStringName = (0, import_typescript17.isStringLiteralLike)(node.name);
+  const isIdentifierName = (0, import_typescript18.isIdentifier)(node.name);
+  const isStringName = (0, import_typescript18.isStringLiteralLike)(node.name);
   const isNamedMember = isIdentifierName || isStringName;
   if (!isNamedMember) return null;
   return node.name.text;
@@ -2538,10 +3176,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."
 };
@@ -2554,34 +3192,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 = import_utils10.ESLintUtils.RuleCreator(
+var defaultOptions2 = [ruleDefaults2];
+var createRule2 = import_utils11.ESLintUtils.RuleCreator(
   () => "https://eslint.org/docs/latest/rules/no-unused-private-class-members"
 );
 var projectParserServices = (context, analysis) => {
   if (analysis !== "project") return void 0;
   try {
-    return import_utils10.ESLintUtils.getParserServices(context);
+    return import_utils11.ESLintUtils.getParserServices(context);
   } catch {
     throw new Error(
       "Project analysis requires parser services with type information."
@@ -2599,10 +3237,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);
@@ -2642,6 +3280,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 = import_angular_eslint2.processInlineTemplates && {
+  processor: import_angular_eslint2.processInlineTemplates
+};
 var angular = (0, import_config2.defineConfig)([
   {
     files: ["**/*.ts"],
@@ -2659,7 +3300,7 @@ var angular = (0, import_config2.defineConfig)([
         projectService: true
       }
     },
-    processor: import_angular_eslint2.processInlineTemplates,
+    ...inlineTemplates,
     rules: {
       "lint-suite-angular/no-unused-instance-fields": [
         "error",
@@ -2769,6 +3410,11 @@ var baseLimits = (0, import_config3.defineConfig)([
 
 // packages/lint-suite/src/lib/base-practices.ts
 var import_config4 = require("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 = (0, import_config4.defineConfig)([
   {
     files: [
@@ -2827,7 +3473,7 @@ var basePractices = (0, import_config4.defineConfig)([
       "max-len": [
         "error",
         {
-          code: 135,
+          code: MAX_LINE_LENGTH,
           ignoreComments: true
         }
       ],
@@ -3382,7 +4028,7 @@ var typescriptRecommended = (0, import_config17.defineConfig)([
 var import_config18 = require("eslint/config");
 
 // packages/lint-suite/src/lib/rules/explicit-accessibility/explicit-accessibility.ts
-var import_utils11 = require("@typescript-eslint/utils");
+var import_utils12 = require("@typescript-eslint/utils");
 
 // packages/lint-suite/src/lib/rules/explicit-accessibility/common/explicit-accessibility.const.ts
 var accessibilities = [
@@ -3390,10 +4036,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."
 };
@@ -3402,49 +4048,49 @@ 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 = import_utils11.ESLintUtils.RuleCreator(
+var createRule3 = import_utils12.ESLintUtils.RuleCreator(
   () => "https://github.com/F0rty-Tw0/lint-suite#explicit-accessibility"
 );
 var isPrivateMember = (node) => {
-  if (node.type === import_utils11.TSESTree.AST_NODE_TYPES.TSParameterProperty) return false;
-  return node.key.type === import_utils11.TSESTree.AST_NODE_TYPES.PrivateIdentifier;
+  if (node.type === import_utils12.TSESTree.AST_NODE_TYPES.TSParameterProperty) return false;
+  return node.key.type === import_utils12.TSESTree.AST_NODE_TYPES.PrivateIdentifier;
 };
 var isConstructor = (node) => {
-  if (node.type !== import_utils11.TSESTree.AST_NODE_TYPES.MethodDefinition) return false;
+  if (node.type !== import_utils12.TSESTree.AST_NODE_TYPES.MethodDefinition) return false;
   return node.kind === "constructor";
 };
 var reportTarget = (node) => {
-  if (node.type !== import_utils11.TSESTree.AST_NODE_TYPES.TSParameterProperty) {
+  if (node.type !== import_utils12.TSESTree.AST_NODE_TYPES.TSParameterProperty) {
     return node.key;
   }
   const { parameter } = node;
-  if (parameter.type === import_utils11.TSESTree.AST_NODE_TYPES.AssignmentPattern) {
+  if (parameter.type === import_utils12.TSESTree.AST_NODE_TYPES.AssignmentPattern) {
     return parameter.left;
   }
   return parameter;
 };
 var memberName2 = (target, sourceCode) => {
-  if (target.type === import_utils11.TSESTree.AST_NODE_TYPES.Identifier) return target.name;
+  if (target.type === import_utils12.TSESTree.AST_NODE_TYPES.Identifier) return target.name;
   return sourceCode.getText(target);
 };
 var modifierToken = (node, sourceCode) => {
@@ -3488,10 +4134,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) => {
@@ -3528,40 +4174,40 @@ var explicit_accessibility_default = createRule2({
 });
 
 // packages/lint-suite/src/lib/rules/no-inline-object-types/no-inline-object-types.ts
-var import_utils12 = require("@typescript-eslint/utils");
-var docs3 = {
+var import_utils13 = require("@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 = import_utils12.ESLintUtils.RuleCreator(
+var createRule4 = import_utils13.ESLintUtils.RuleCreator(
   () => "https://github.com/F0rty-Tw0/lint-suite#no-inline-object-types"
 );
 var enclosingTypeAlias = (node) => {
   let current = node.parent;
-  while (current && current.type !== import_utils12.TSESTree.AST_NODE_TYPES.Program) {
-    if (current.type === import_utils12.TSESTree.AST_NODE_TYPES.TSTypeAliasDeclaration) {
+  while (current && current.type !== import_utils13.TSESTree.AST_NODE_TYPES.Program) {
+    if (current.type === import_utils13.TSESTree.AST_NODE_TYPES.TSTypeAliasDeclaration) {
       return current;
     }
     current = current.parent;
   }
   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 = {
       TSTypeLiteral(node) {
-        const isAliasBody = node.parent.type === import_utils12.TSESTree.AST_NODE_TYPES.TSTypeAliasDeclaration;
+        const isAliasBody = node.parent.type === import_utils13.TSESTree.AST_NODE_TYPES.TSTypeAliasDeclaration;
         if (isAliasBody) return;
         const enclosingAlias = enclosingTypeAlias(node);
         if (!enclosingAlias) return;
@@ -3576,46 +4222,138 @@ var no_inline_object_types_default = createRule3({
   }
 });
 
+// packages/lint-suite/src/lib/rules/one-line-guard/one-line-guard.ts
+var import_utils14 = require("@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 = import_utils14.ESLintUtils.RuleCreator(
+  () => "https://github.com/F0rty-Tw0/lint-suite#one-line-guard"
+);
+var GUARD_KEYWORDS = /* @__PURE__ */ new Set([
+  import_utils14.TSESTree.AST_NODE_TYPES.ReturnStatement,
+  import_utils14.TSESTree.AST_NODE_TYPES.ThrowStatement,
+  import_utils14.TSESTree.AST_NODE_TYPES.ContinueStatement,
+  import_utils14.TSESTree.AST_NODE_TYPES.BreakStatement
+]);
+var soleStatement = (body) => {
+  if (body.type !== import_utils14.TSESTree.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
-var import_utils13 = require("@typescript-eslint/utils");
-var docs4 = {
+var import_utils15 = require("@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 = import_utils13.ESLintUtils.RuleCreator(
+var createRule6 = import_utils15.ESLintUtils.RuleCreator(
   () => "https://github.com/F0rty-Tw0/lint-suite#readonly-type-properties"
 );
 var propertyName3 = (node, sourceCode) => {
-  if (node.key.type === import_utils13.TSESTree.AST_NODE_TYPES.Identifier) {
+  if (node.key.type === import_utils15.TSESTree.AST_NODE_TYPES.Identifier) {
     return node.key.name;
   }
   return sourceCode.getText(node.key);
 };
 var PRIMITIVE_KEYWORDS = /* @__PURE__ */ new Set([
-  import_utils13.TSESTree.AST_NODE_TYPES.TSStringKeyword,
-  import_utils13.TSESTree.AST_NODE_TYPES.TSNumberKeyword,
-  import_utils13.TSESTree.AST_NODE_TYPES.TSBooleanKeyword,
-  import_utils13.TSESTree.AST_NODE_TYPES.TSBigIntKeyword,
-  import_utils13.TSESTree.AST_NODE_TYPES.TSSymbolKeyword,
-  import_utils13.TSESTree.AST_NODE_TYPES.TSNullKeyword,
-  import_utils13.TSESTree.AST_NODE_TYPES.TSUndefinedKeyword
+  import_utils15.TSESTree.AST_NODE_TYPES.TSStringKeyword,
+  import_utils15.TSESTree.AST_NODE_TYPES.TSNumberKeyword,
+  import_utils15.TSESTree.AST_NODE_TYPES.TSBooleanKeyword,
+  import_utils15.TSESTree.AST_NODE_TYPES.TSBigIntKeyword,
+  import_utils15.TSESTree.AST_NODE_TYPES.TSSymbolKeyword,
+  import_utils15.TSESTree.AST_NODE_TYPES.TSNullKeyword,
+  import_utils15.TSESTree.AST_NODE_TYPES.TSUndefinedKeyword
 ]);
 var isPrimitive = (type) => {
   const isPrimitiveKeyword = PRIMITIVE_KEYWORDS.has(type.type);
   if (isPrimitiveKeyword) return true;
-  if (type.type === import_utils13.TSESTree.AST_NODE_TYPES.TSLiteralType || type.type === import_utils13.TSESTree.AST_NODE_TYPES.TSTemplateLiteralType) {
+  if (type.type === import_utils15.TSESTree.AST_NODE_TYPES.TSLiteralType || type.type === import_utils15.TSESTree.AST_NODE_TYPES.TSTemplateLiteralType) {
     return true;
   }
-  if (type.type === import_utils13.TSESTree.AST_NODE_TYPES.TSUnionType || type.type === import_utils13.TSESTree.AST_NODE_TYPES.TSIntersectionType) {
+  if (type.type === import_utils15.TSESTree.AST_NODE_TYPES.TSUnionType || type.type === import_utils15.TSESTree.AST_NODE_TYPES.TSIntersectionType) {
     return type.types.every(isPrimitive);
   }
   return false;
@@ -3627,9 +4365,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;
@@ -3658,7 +4396,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
@@ -3670,6 +4409,7 @@ var typescriptSafety = (0, import_config18.defineConfig)([
       "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",