@absolutejs/absolute 0.19.0-beta.1092 → 0.19.0-beta.1093

package/dist/build.js

@@ -13883,23 +13883,55 @@ var init_compileSvelte = __esm(() => {
 });
 
 // src/build/parseVueSpaRoutes.ts
-var ROUTES_BLOCK_RE, ROUTE_ENTRY_RE, parseVueSpaRoutes = (source) => {
-  const blockMatch = source.match(ROUTES_BLOCK_RE);
-  if (!blockMatch?.[1])
-    return [];
-  const block = blockMatch[1];
-  const entries = [];
-  for (const match of block.matchAll(ROUTE_ENTRY_RE)) {
-    const [, path, importPath] = match;
-    if (path && importPath)
-      entries.push({ importPath, path });
+import ts11 from "typescript";
+var propertyName = (node) => ts11.isIdentifier(node) || ts11.isStringLiteralLike(node) ? node.text : null, stringValue = (node) => ts11.isStringLiteralLike(node) ? node.text : null, findVueImport = (node) => {
+  if (ts11.isCallExpression(node) && node.expression.kind === ts11.SyntaxKind.ImportKeyword) {
+    const [specifier] = node.arguments;
+    if (specifier && ts11.isStringLiteralLike(specifier)) {
+      return specifier.text.endsWith(".vue") ? specifier.text : null;
+    }
   }
+  let found = null;
+  ts11.forEachChild(node, (child) => {
+    if (found === null)
+      found = findVueImport(child);
+  });
+  return found;
+}, parseRoute = (node) => {
+  if (!ts11.isObjectLiteralExpression(node))
+    return null;
+  let path = null;
+  let importPath = null;
+  for (const property of node.properties) {
+    if (!ts11.isPropertyAssignment(property))
+      continue;
+    const name = propertyName(property.name);
+    if (name === "path")
+      path = stringValue(property.initializer);
+    if (name === "component")
+      importPath = findVueImport(property.initializer);
+  }
+  return path && importPath ? { importPath, path } : null;
+}, parseVueSpaRoutes = (source) => {
+  const sourceFile = ts11.createSourceFile("absolute-vue-routes.ts", source, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TS);
+  const entries = [];
+  const visit = (node) => {
+    if (ts11.isCallExpression(node) && ts11.isIdentifier(node.expression) && node.expression.text === "defineRoutes") {
+      const [routes] = node.arguments;
+      if (routes && ts11.isArrayLiteralExpression(routes)) {
+        for (const element of routes.elements) {
+          const route = parseRoute(element);
+          if (route)
+            entries.push(route);
+        }
+      }
+    }
+    ts11.forEachChild(node, visit);
+  };
+  ts11.forEachChild(sourceFile, visit);
   return entries;
 };
-var init_parseVueSpaRoutes = __esm(() => {
-  ROUTES_BLOCK_RE = /export\s+const\s+routes\s*=\s*defineRoutes\s*\(\s*\[([\s\S]*?)\]\s*\)\s*;?/;
-  ROUTE_ENTRY_RE = /path:\s*['"`]([^'"`]+)['"`][\s\S]*?import\(\s*['"`]([^'"`]+\.vue)['"`]\s*\)/g;
-});
+var init_parseVueSpaRoutes = () => {};
 
 // src/build/chainInlineSourcemaps.ts
 var exports_chainInlineSourcemaps = {};
@@ -15342,14 +15374,14 @@ __export(exports_compileAngular, {
 import { existsSync as existsSync23, readFileSync as readFileSync19, promises as fs5 } from "fs";
 import { join as join30, basename as basename9, sep as sep3, dirname as dirname15, resolve as resolve21, relative as relative12 } from "path";
 var {Glob: Glob6 } = globalThis.Bun;
-import ts11 from "typescript";
+import ts12 from "typescript";
 var traceAngularPhase = async (name, fn2, metadata) => {
   const tracePhase = globalThis.__absoluteBuildTracePhase;
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn2, metadata) : await fn2();
 }, readTsconfigPathAliases = () => {
   try {
     const configPath2 = resolve21(process.cwd(), "tsconfig.json");
-    const config = ts11.readConfigFile(configPath2, ts11.sys.readFile).config;
+    const config = ts12.readConfigFile(configPath2, ts12.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
     const baseUrl = resolve21(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
@@ -15478,7 +15510,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   return resolve21(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, formatDiagnosticMessage = (diagnostic) => {
   try {
-    return ts11.flattenDiagnosticMessageText(diagnostic.messageText, `
+    return ts12.flattenDiagnosticMessageText(diagnostic.messageText, `
 `);
   } catch {
     return String(diagnostic.messageText || "Unknown error");
@@ -15486,7 +15518,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
 }, throwOnCompilationErrors = (diagnostics) => {
   if (!diagnostics?.length)
     return;
-  const errors = diagnostics.filter((diag) => diag.category === ts11.DiagnosticCategory.Error);
+  const errors = diagnostics.filter((diag) => diag.category === ts12.DiagnosticCategory.Error);
   if (!errors.length)
     return;
   const fullMessage = errors.map(formatDiagnosticMessage).join(`
@@ -15528,22 +15560,22 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   }
   return `${path}.js${query}`;
 }, isRelativeModuleSpecifier = (specifier) => specifier.startsWith("./") || specifier.startsWith("../"), extractLocalImportSpecifiers = (source, fileName) => {
-  const sourceFile = ts11.createSourceFile(fileName, source, ts11.ScriptTarget.Latest, true, ts11.ScriptKind.TS);
+  const sourceFile = ts12.createSourceFile(fileName, source, ts12.ScriptTarget.Latest, true, ts12.ScriptKind.TS);
   const specifiers = [];
   const addSpecifier = (node) => {
-    if (!node || !ts11.isStringLiteralLike(node))
+    if (!node || !ts12.isStringLiteralLike(node))
       return;
     const specifier = node.text;
     if (isRelativeModuleSpecifier(specifier))
       specifiers.push(specifier);
   };
   const visit = (node) => {
-    if (ts11.isImportDeclaration(node) || ts11.isExportDeclaration(node)) {
+    if (ts12.isImportDeclaration(node) || ts12.isExportDeclaration(node)) {
       addSpecifier(node.moduleSpecifier);
-    } else if (ts11.isCallExpression(node) && node.expression.kind === ts11.SyntaxKind.ImportKeyword) {
+    } else if (ts12.isCallExpression(node) && node.expression.kind === ts12.SyntaxKind.ImportKeyword) {
       addSpecifier(node.arguments[0]);
     }
-    ts11.forEachChild(node, visit);
+    ts12.forEachChild(node, visit);
   };
   visit(sourceFile);
   return specifiers;
@@ -15691,25 +15723,25 @@ var traceAngularPhase = async (name, fn2, metadata) => {
     emitDecoratorMetadata: true,
     esModuleInterop: true,
     experimentalDecorators: true,
-    module: ts11.ModuleKind.ESNext,
-    moduleResolution: ts11.ModuleResolutionKind.Bundler,
-    newLine: ts11.NewLineKind.LineFeed,
+    module: ts12.ModuleKind.ESNext,
+    moduleResolution: ts12.ModuleResolutionKind.Bundler,
+    newLine: ts12.NewLineKind.LineFeed,
     noLib: false,
     outDir,
     skipLibCheck: true,
-    target: ts11.ScriptTarget.ES2022,
+    target: ts12.ScriptTarget.ES2022,
     ...config.options
   };
-  options.target = ts11.ScriptTarget.ES2022;
+  options.target = ts12.ScriptTarget.ES2022;
   options.experimentalDecorators = true;
   options.emitDecoratorMetadata = true;
-  options.newLine = ts11.NewLineKind.LineFeed;
+  options.newLine = ts12.NewLineKind.LineFeed;
   options.outDir = outDir;
   options.noEmit = false;
   options.incremental = false;
   options.tsBuildInfoFile = undefined;
   options.rootDir = process.cwd();
-  const host = await traceAngularPhase("aot/create-compiler-host", () => ts11.createCompilerHost(options));
+  const host = await traceAngularPhase("aot/create-compiler-host", () => ts12.createCompilerHost(options));
   const originalGetDefaultLibLocation = host.getDefaultLibLocation;
   host.getDefaultLibLocation = () => tsLibDir || (originalGetDefaultLibLocation ? originalGetDefaultLibLocation() : "");
   const originalGetDefaultLibFileName = host.getDefaultLibFileName;
@@ -15755,7 +15787,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   host.getSourceFile = (fileName, languageVersion, onError) => {
     const source = transformedSources.get(resolve21(fileName));
     if (source) {
-      return ts11.createSourceFile(fileName, source, languageVersion, true);
+      return ts12.createSourceFile(fileName, source, languageVersion, true);
     }
     return originalGetSourceFileForCompile?.call(host, fileName, languageVersion, onError);
   };
@@ -16644,18 +16676,18 @@ var init_compileAngular = __esm(() => {
 });
 
 // src/dev/angular/hmrImportGenerator.ts
-import ts12 from "typescript";
+import ts13 from "typescript";
 var createHmrImportGenerator = (namespaceMap) => ({
   addImport(request) {
     const ns = namespaceMap.get(request.exportModuleSpecifier);
     if (!ns) {
       throw new Error(`HMR import generator has no namespace mapping for ${request.exportModuleSpecifier}. ` + `Add it to namespaceDependencies before calling compileHmrUpdateCallback.`);
     }
-    const namespaceId = ts12.factory.createIdentifier(ns);
+    const namespaceId = ts13.factory.createIdentifier(ns);
     if (request.exportSymbolName === null) {
       return namespaceId;
     }
-    return ts12.factory.createPropertyAccessExpression(namespaceId, ts12.factory.createIdentifier(request.exportSymbolName));
+    return ts13.factory.createPropertyAccessExpression(namespaceId, ts13.factory.createIdentifier(request.exportSymbolName));
   }
 });
 var init_hmrImportGenerator = () => {};
@@ -17028,13 +17060,13 @@ var init_translator = __esm(() => {
 });
 
 // src/dev/angular/vendor/translator/ts_util.ts
-import ts13 from "typescript";
+import ts14 from "typescript";
 function tsNumericExpression(value) {
   if (value < 0) {
-    const operand = ts13.factory.createNumericLiteral(Math.abs(value));
-    return ts13.factory.createPrefixUnaryExpression(ts13.SyntaxKind.MinusToken, operand);
+    const operand = ts14.factory.createNumericLiteral(Math.abs(value));
+    return ts14.factory.createPrefixUnaryExpression(ts14.SyntaxKind.MinusToken, operand);
   }
-  return ts13.factory.createNumericLiteral(value);
+  return ts14.factory.createNumericLiteral(value);
 }
 var init_ts_util = __esm(() => {
   /*!
@@ -17047,142 +17079,142 @@ var init_ts_util = __esm(() => {
 });
 
 // src/dev/angular/vendor/translator/typescript_ast_factory.ts
-import ts14 from "typescript";
+import ts15 from "typescript";
 
 class TypeScriptAstFactory {
   annotateForClosureCompiler;
   externalSourceFiles = new Map;
   UNARY_OPERATORS = /* @__PURE__ */ (() => ({
-    "+": ts14.SyntaxKind.PlusToken,
-    "-": ts14.SyntaxKind.MinusToken,
-    "!": ts14.SyntaxKind.ExclamationToken
+    "+": ts15.SyntaxKind.PlusToken,
+    "-": ts15.SyntaxKind.MinusToken,
+    "!": ts15.SyntaxKind.ExclamationToken
   }))();
   BINARY_OPERATORS = /* @__PURE__ */ (() => ({
-    "&&": ts14.SyntaxKind.AmpersandAmpersandToken,
-    ">": ts14.SyntaxKind.GreaterThanToken,
-    ">=": ts14.SyntaxKind.GreaterThanEqualsToken,
-    "&": ts14.SyntaxKind.AmpersandToken,
-    "|": ts14.SyntaxKind.BarToken,
-    "/": ts14.SyntaxKind.SlashToken,
-    "==": ts14.SyntaxKind.EqualsEqualsToken,
-    "===": ts14.SyntaxKind.EqualsEqualsEqualsToken,
-    "<": ts14.SyntaxKind.LessThanToken,
-    "<=": ts14.SyntaxKind.LessThanEqualsToken,
-    "-": ts14.SyntaxKind.MinusToken,
-    "%": ts14.SyntaxKind.PercentToken,
-    "*": ts14.SyntaxKind.AsteriskToken,
-    "**": ts14.SyntaxKind.AsteriskAsteriskToken,
-    "!=": ts14.SyntaxKind.ExclamationEqualsToken,
-    "!==": ts14.SyntaxKind.ExclamationEqualsEqualsToken,
-    "||": ts14.SyntaxKind.BarBarToken,
-    "+": ts14.SyntaxKind.PlusToken,
-    "??": ts14.SyntaxKind.QuestionQuestionToken,
-    "=": ts14.SyntaxKind.EqualsToken,
-    "+=": ts14.SyntaxKind.PlusEqualsToken,
-    "-=": ts14.SyntaxKind.MinusEqualsToken,
-    "*=": ts14.SyntaxKind.AsteriskEqualsToken,
-    "/=": ts14.SyntaxKind.SlashEqualsToken,
-    "%=": ts14.SyntaxKind.PercentEqualsToken,
-    "**=": ts14.SyntaxKind.AsteriskAsteriskEqualsToken,
-    "&&=": ts14.SyntaxKind.AmpersandAmpersandEqualsToken,
-    "||=": ts14.SyntaxKind.BarBarEqualsToken,
-    "??=": ts14.SyntaxKind.QuestionQuestionEqualsToken,
-    in: ts14.SyntaxKind.InKeyword,
-    instanceof: ts14.SyntaxKind.InstanceOfKeyword
+    "&&": ts15.SyntaxKind.AmpersandAmpersandToken,
+    ">": ts15.SyntaxKind.GreaterThanToken,
+    ">=": ts15.SyntaxKind.GreaterThanEqualsToken,
+    "&": ts15.SyntaxKind.AmpersandToken,
+    "|": ts15.SyntaxKind.BarToken,
+    "/": ts15.SyntaxKind.SlashToken,
+    "==": ts15.SyntaxKind.EqualsEqualsToken,
+    "===": ts15.SyntaxKind.EqualsEqualsEqualsToken,
+    "<": ts15.SyntaxKind.LessThanToken,
+    "<=": ts15.SyntaxKind.LessThanEqualsToken,
+    "-": ts15.SyntaxKind.MinusToken,
+    "%": ts15.SyntaxKind.PercentToken,
+    "*": ts15.SyntaxKind.AsteriskToken,
+    "**": ts15.SyntaxKind.AsteriskAsteriskToken,
+    "!=": ts15.SyntaxKind.ExclamationEqualsToken,
+    "!==": ts15.SyntaxKind.ExclamationEqualsEqualsToken,
+    "||": ts15.SyntaxKind.BarBarToken,
+    "+": ts15.SyntaxKind.PlusToken,
+    "??": ts15.SyntaxKind.QuestionQuestionToken,
+    "=": ts15.SyntaxKind.EqualsToken,
+    "+=": ts15.SyntaxKind.PlusEqualsToken,
+    "-=": ts15.SyntaxKind.MinusEqualsToken,
+    "*=": ts15.SyntaxKind.AsteriskEqualsToken,
+    "/=": ts15.SyntaxKind.SlashEqualsToken,
+    "%=": ts15.SyntaxKind.PercentEqualsToken,
+    "**=": ts15.SyntaxKind.AsteriskAsteriskEqualsToken,
+    "&&=": ts15.SyntaxKind.AmpersandAmpersandEqualsToken,
+    "||=": ts15.SyntaxKind.BarBarEqualsToken,
+    "??=": ts15.SyntaxKind.QuestionQuestionEqualsToken,
+    in: ts15.SyntaxKind.InKeyword,
+    instanceof: ts15.SyntaxKind.InstanceOfKeyword
   }))();
   VAR_TYPES = /* @__PURE__ */ (() => ({
-    const: ts14.NodeFlags.Const,
-    let: ts14.NodeFlags.Let,
-    var: ts14.NodeFlags.None
+    const: ts15.NodeFlags.Const,
+    let: ts15.NodeFlags.Let,
+    var: ts15.NodeFlags.None
   }))();
   constructor(annotateForClosureCompiler) {
     this.annotateForClosureCompiler = annotateForClosureCompiler;
   }
   attachComments = attachComments;
-  createArrayLiteral = ts14.factory.createArrayLiteralExpression;
+  createArrayLiteral = ts15.factory.createArrayLiteralExpression;
   createAssignment(target, operator, value) {
-    return ts14.factory.createBinaryExpression(target, this.BINARY_OPERATORS[operator], value);
+    return ts15.factory.createBinaryExpression(target, this.BINARY_OPERATORS[operator], value);
   }
   createBinaryExpression(leftOperand, operator, rightOperand) {
-    return ts14.factory.createBinaryExpression(leftOperand, this.BINARY_OPERATORS[operator], rightOperand);
+    return ts15.factory.createBinaryExpression(leftOperand, this.BINARY_OPERATORS[operator], rightOperand);
   }
   createBlock(body) {
-    return ts14.factory.createBlock(body);
+    return ts15.factory.createBlock(body);
   }
   createCallExpression(callee, args, pure) {
-    const call = ts14.factory.createCallExpression(callee, undefined, args);
+    const call = ts15.factory.createCallExpression(callee, undefined, args);
     if (pure) {
-      ts14.addSyntheticLeadingComment(call, ts14.SyntaxKind.MultiLineCommentTrivia, this.annotateForClosureCompiler ? "* @pureOrBreakMyCode " /* CLOSURE */ : "@__PURE__" /* TERSER */, false);
+      ts15.addSyntheticLeadingComment(call, ts15.SyntaxKind.MultiLineCommentTrivia, this.annotateForClosureCompiler ? "* @pureOrBreakMyCode " /* CLOSURE */ : "@__PURE__" /* TERSER */, false);
     }
     return call;
   }
   createConditional(condition, whenTrue, whenFalse) {
-    return ts14.factory.createConditionalExpression(condition, undefined, whenTrue, undefined, whenFalse);
+    return ts15.factory.createConditionalExpression(condition, undefined, whenTrue, undefined, whenFalse);
   }
-  createElementAccess = ts14.factory.createElementAccessExpression;
-  createExpressionStatement = ts14.factory.createExpressionStatement;
+  createElementAccess = ts15.factory.createElementAccessExpression;
+  createExpressionStatement = ts15.factory.createExpressionStatement;
   createDynamicImport(url) {
-    return ts14.factory.createCallExpression(ts14.factory.createToken(ts14.SyntaxKind.ImportKeyword), undefined, [
-      typeof url === "string" ? ts14.factory.createStringLiteral(url) : url
+    return ts15.factory.createCallExpression(ts15.factory.createToken(ts15.SyntaxKind.ImportKeyword), undefined, [
+      typeof url === "string" ? ts15.factory.createStringLiteral(url) : url
     ]);
   }
   createFunctionDeclaration(functionName, parameters, body) {
-    if (!ts14.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${ts14.SyntaxKind[body.kind]}.`);
+    if (!ts15.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts15.SyntaxKind[body.kind]}.`);
     }
-    return ts14.factory.createFunctionDeclaration(undefined, undefined, functionName, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
+    return ts15.factory.createFunctionDeclaration(undefined, undefined, functionName, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
   }
   createFunctionExpression(functionName, parameters, body) {
-    if (!ts14.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${ts14.SyntaxKind[body.kind]}.`);
+    if (!ts15.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts15.SyntaxKind[body.kind]}.`);
     }
-    return ts14.factory.createFunctionExpression(undefined, undefined, functionName ?? undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
+    return ts15.factory.createFunctionExpression(undefined, undefined, functionName ?? undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
   }
   createArrowFunctionExpression(parameters, body) {
-    if (ts14.isStatement(body) && !ts14.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${ts14.SyntaxKind[body.kind]}.`);
+    if (ts15.isStatement(body) && !ts15.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts15.SyntaxKind[body.kind]}.`);
     }
-    return ts14.factory.createArrowFunction(undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, undefined, body);
+    return ts15.factory.createArrowFunction(undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, undefined, body);
   }
   createParameter(param) {
-    return ts14.factory.createParameterDeclaration(undefined, undefined, param.name, undefined, param.type ?? undefined);
+    return ts15.factory.createParameterDeclaration(undefined, undefined, param.name, undefined, param.type ?? undefined);
   }
-  createIdentifier = ts14.factory.createIdentifier;
+  createIdentifier = ts15.factory.createIdentifier;
   createIfStatement(condition, thenStatement, elseStatement) {
-    return ts14.factory.createIfStatement(condition, thenStatement, elseStatement ?? undefined);
+    return ts15.factory.createIfStatement(condition, thenStatement, elseStatement ?? undefined);
   }
   createLiteral(value) {
     if (value === undefined) {
-      return ts14.factory.createIdentifier("undefined");
+      return ts15.factory.createIdentifier("undefined");
     } else if (value === null) {
-      return ts14.factory.createNull();
+      return ts15.factory.createNull();
     } else if (typeof value === "boolean") {
-      return value ? ts14.factory.createTrue() : ts14.factory.createFalse();
+      return value ? ts15.factory.createTrue() : ts15.factory.createFalse();
     } else if (typeof value === "number") {
       return tsNumericExpression(value);
     } else {
-      return ts14.factory.createStringLiteral(value);
+      return ts15.factory.createStringLiteral(value);
     }
   }
   createNewExpression(expression, args) {
-    return ts14.factory.createNewExpression(expression, undefined, args);
+    return ts15.factory.createNewExpression(expression, undefined, args);
   }
   createObjectLiteral(properties) {
-    return ts14.factory.createObjectLiteralExpression(properties.map((prop) => {
+    return ts15.factory.createObjectLiteralExpression(properties.map((prop) => {
       if (prop.kind === "spread") {
-        return ts14.factory.createSpreadAssignment(prop.expression);
+        return ts15.factory.createSpreadAssignment(prop.expression);
       }
-      return ts14.factory.createPropertyAssignment(prop.quoted ? ts14.factory.createStringLiteral(prop.propertyName) : ts14.factory.createIdentifier(prop.propertyName), prop.value);
+      return ts15.factory.createPropertyAssignment(prop.quoted ? ts15.factory.createStringLiteral(prop.propertyName) : ts15.factory.createIdentifier(prop.propertyName), prop.value);
     }));
   }
-  createParenthesizedExpression = ts14.factory.createParenthesizedExpression;
-  createPropertyAccess = ts14.factory.createPropertyAccessExpression;
-  createSpreadElement = ts14.factory.createSpreadElement;
+  createParenthesizedExpression = ts15.factory.createParenthesizedExpression;
+  createPropertyAccess = ts15.factory.createPropertyAccessExpression;
+  createSpreadElement = ts15.factory.createSpreadElement;
   createReturnStatement(expression) {
-    return ts14.factory.createReturnStatement(expression ?? undefined);
+    return ts15.factory.createReturnStatement(expression ?? undefined);
   }
   createTaggedTemplate(tag, template) {
-    return ts14.factory.createTaggedTemplateExpression(tag, undefined, this.createTemplateLiteral(template));
+    return ts15.factory.createTaggedTemplateExpression(tag, undefined, this.createTemplateLiteral(template));
   }
   createTemplateLiteral(template) {
     let templateLiteral;
@@ -17192,7 +17224,7 @@ class TypeScriptAstFactory {
       throw new Error("createTemplateLiteral: template has no elements");
     }
     if (length === 1) {
-      templateLiteral = ts14.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
+      templateLiteral = ts15.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
     } else {
       const spans = [];
       for (let i = 1;i < length - 1; i++) {
@@ -17206,7 +17238,7 @@ class TypeScriptAstFactory {
         if (range !== null) {
           this.setSourceMapRange(middle, range);
         }
-        spans.push(ts14.factory.createTemplateSpan(expression, middle));
+        spans.push(ts15.factory.createTemplateSpan(expression, middle));
       }
       const resolvedExpression = template.expressions[length - 2];
       const templatePart = template.elements[length - 1];
@@ -17217,27 +17249,27 @@ class TypeScriptAstFactory {
       if (templatePart.range !== null) {
         this.setSourceMapRange(templateTail, templatePart.range);
       }
-      spans.push(ts14.factory.createTemplateSpan(resolvedExpression, templateTail));
-      templateLiteral = ts14.factory.createTemplateExpression(ts14.factory.createTemplateHead(head.cooked, head.raw), spans);
+      spans.push(ts15.factory.createTemplateSpan(resolvedExpression, templateTail));
+      templateLiteral = ts15.factory.createTemplateExpression(ts15.factory.createTemplateHead(head.cooked, head.raw), spans);
     }
     if (head.range !== null) {
       this.setSourceMapRange(templateLiteral, head.range);
     }
     return templateLiteral;
   }
-  createThrowStatement = ts14.factory.createThrowStatement;
-  createTypeOfExpression = ts14.factory.createTypeOfExpression;
-  createVoidExpression = ts14.factory.createVoidExpression;
+  createThrowStatement = ts15.factory.createThrowStatement;
+  createTypeOfExpression = ts15.factory.createTypeOfExpression;
+  createVoidExpression = ts15.factory.createVoidExpression;
   createUnaryExpression(operator, operand) {
-    return ts14.factory.createPrefixUnaryExpression(this.UNARY_OPERATORS[operator], operand);
+    return ts15.factory.createPrefixUnaryExpression(this.UNARY_OPERATORS[operator], operand);
   }
   createVariableDeclaration(variableName, initializer, variableType, type) {
-    return ts14.factory.createVariableStatement(undefined, ts14.factory.createVariableDeclarationList([
-      ts14.factory.createVariableDeclaration(variableName, undefined, type ?? undefined, initializer ?? undefined)
+    return ts15.factory.createVariableStatement(undefined, ts15.factory.createVariableDeclarationList([
+      ts15.factory.createVariableDeclaration(variableName, undefined, type ?? undefined, initializer ?? undefined)
     ], this.VAR_TYPES[variableType]));
   }
   createRegularExpressionLiteral(body, flags) {
-    return ts14.factory.createRegularExpressionLiteral(`/${body}/${flags ?? ""}`);
+    return ts15.factory.createRegularExpressionLiteral(`/${body}/${flags ?? ""}`);
   }
   setSourceMapRange(node, sourceMapRange) {
     if (sourceMapRange === null) {
@@ -17245,10 +17277,10 @@ class TypeScriptAstFactory {
     }
     const url = sourceMapRange.url;
     if (!this.externalSourceFiles.has(url)) {
-      this.externalSourceFiles.set(url, ts14.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
+      this.externalSourceFiles.set(url, ts15.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
     }
     const source = this.externalSourceFiles.get(url);
-    ts14.setSourceMapRange(node, {
+    ts15.setSourceMapRange(node, {
       pos: sourceMapRange.start.offset,
       end: sourceMapRange.end.offset,
       source
@@ -17258,77 +17290,77 @@ class TypeScriptAstFactory {
   createBuiltInType(type) {
     switch (type) {
       case "any":
-        return ts14.factory.createKeywordTypeNode(ts14.SyntaxKind.AnyKeyword);
+        return ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.AnyKeyword);
       case "boolean":
-        return ts14.factory.createKeywordTypeNode(ts14.SyntaxKind.BooleanKeyword);
+        return ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.BooleanKeyword);
       case "number":
-        return ts14.factory.createKeywordTypeNode(ts14.SyntaxKind.NumberKeyword);
+        return ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.NumberKeyword);
       case "string":
-        return ts14.factory.createKeywordTypeNode(ts14.SyntaxKind.StringKeyword);
+        return ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.StringKeyword);
       case "function":
-        return ts14.factory.createTypeReferenceNode(ts14.factory.createIdentifier("Function"));
+        return ts15.factory.createTypeReferenceNode(ts15.factory.createIdentifier("Function"));
       case "never":
-        return ts14.factory.createKeywordTypeNode(ts14.SyntaxKind.NeverKeyword);
+        return ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.NeverKeyword);
       case "unknown":
-        return ts14.factory.createKeywordTypeNode(ts14.SyntaxKind.UnknownKeyword);
+        return ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.UnknownKeyword);
     }
   }
   createExpressionType(expression, typeParams) {
     const typeName = getEntityTypeFromExpression(expression);
-    return ts14.factory.createTypeReferenceNode(typeName, typeParams ?? undefined);
+    return ts15.factory.createTypeReferenceNode(typeName, typeParams ?? undefined);
   }
   createArrayType(elementType) {
-    return ts14.factory.createArrayTypeNode(elementType);
+    return ts15.factory.createArrayTypeNode(elementType);
   }
   createMapType(valueType) {
-    return ts14.factory.createTypeLiteralNode([
-      ts14.factory.createIndexSignature(undefined, [
-        ts14.factory.createParameterDeclaration(undefined, undefined, "key", undefined, ts14.factory.createKeywordTypeNode(ts14.SyntaxKind.StringKeyword))
+    return ts15.factory.createTypeLiteralNode([
+      ts15.factory.createIndexSignature(undefined, [
+        ts15.factory.createParameterDeclaration(undefined, undefined, "key", undefined, ts15.factory.createKeywordTypeNode(ts15.SyntaxKind.StringKeyword))
       ], valueType)
     ]);
   }
   transplantType(type) {
-    if (typeof type.kind === "number" && typeof type.getSourceFile === "function" && ts14.isTypeNode(type)) {
+    if (typeof type.kind === "number" && typeof type.getSourceFile === "function" && ts15.isTypeNode(type)) {
       return type;
     }
     throw new Error("Attempting to transplant a type node from a non-TypeScript AST: " + type);
   }
 }
 function createTemplateMiddle(cooked, raw) {
-  const node = ts14.factory.createTemplateHead(cooked, raw);
-  node.kind = ts14.SyntaxKind.TemplateMiddle;
+  const node = ts15.factory.createTemplateHead(cooked, raw);
+  node.kind = ts15.SyntaxKind.TemplateMiddle;
   return node;
 }
 function createTemplateTail(cooked, raw) {
-  const node = ts14.factory.createTemplateHead(cooked, raw);
-  node.kind = ts14.SyntaxKind.TemplateTail;
+  const node = ts15.factory.createTemplateHead(cooked, raw);
+  node.kind = ts15.SyntaxKind.TemplateTail;
   return node;
 }
 function attachComments(statement, leadingComments) {
   for (const comment of leadingComments) {
-    const commentKind = comment.multiline ? ts14.SyntaxKind.MultiLineCommentTrivia : ts14.SyntaxKind.SingleLineCommentTrivia;
+    const commentKind = comment.multiline ? ts15.SyntaxKind.MultiLineCommentTrivia : ts15.SyntaxKind.SingleLineCommentTrivia;
     if (comment.multiline) {
-      ts14.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
+      ts15.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
     } else {
       for (const line of comment.toString().split(`
 `)) {
-        ts14.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
+        ts15.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
       }
     }
   }
 }
 function getEntityTypeFromExpression(expression) {
-  if (ts14.isIdentifier(expression)) {
+  if (ts15.isIdentifier(expression)) {
     return expression;
   }
-  if (ts14.isPropertyAccessExpression(expression)) {
+  if (ts15.isPropertyAccessExpression(expression)) {
     const left = getEntityTypeFromExpression(expression.expression);
-    if (!ts14.isIdentifier(expression.name)) {
+    if (!ts15.isIdentifier(expression.name)) {
       throw new Error(`Unsupported property access for type reference: ${expression.name.text}`);
     }
-    return ts14.factory.createQualifiedName(left, expression.name);
+    return ts15.factory.createQualifiedName(left, expression.name);
   }
-  throw new Error(`Unsupported expression for type reference: ${ts14.SyntaxKind[expression.kind]}`);
+  throw new Error(`Unsupported expression for type reference: ${ts15.SyntaxKind[expression.kind]}`);
 }
 var init_typescript_ast_factory = __esm(() => {
   init_ts_util();
@@ -17363,7 +17395,7 @@ __export(exports_fastHmrCompiler, {
 });
 import { existsSync as existsSync24, readFileSync as readFileSync20, statSync as statSync2 } from "fs";
 import { dirname as dirname16, extname as extname7, relative as relative13, resolve as resolve22 } from "path";
-import ts15 from "typescript";
+import ts16 from "typescript";
 var fail = (reason, detail, location) => ({
   ok: false,
   reason,
@@ -17448,23 +17480,23 @@ var fail = (reason, detail, location) => ({
   }
   let sourceFile;
   try {
-    sourceFile = ts15.createSourceFile(componentFilePath, source, ts15.ScriptTarget.Latest, true, ts15.ScriptKind.TS);
+    sourceFile = ts16.createSourceFile(componentFilePath, source, ts16.ScriptTarget.Latest, true, ts16.ScriptKind.TS);
   } catch {
     return;
   }
   for (const stmt of sourceFile.statements) {
-    if (!ts15.isClassDeclaration(stmt))
+    if (!ts16.isClassDeclaration(stmt))
       continue;
     const className = stmt.name?.text;
     if (!className)
       continue;
-    const decorators = ts15.getDecorators(stmt) ?? [];
+    const decorators = ts16.getDecorators(stmt) ?? [];
     const decoratorName = (() => {
       for (const d2 of decorators) {
-        if (!ts15.isCallExpression(d2.expression))
+        if (!ts16.isCallExpression(d2.expression))
           continue;
         const expr = d2.expression.expression;
-        if (!ts15.isIdentifier(expr))
+        if (!ts16.isIdentifier(expr))
           continue;
         if (expr.text === "Component" || expr.text === "Directive" || expr.text === "Pipe" || expr.text === "Injectable") {
           return expr.text;
@@ -17478,16 +17510,16 @@ var fail = (reason, detail, location) => ({
     const id = encodeURIComponent(`${projectRel}@${className}`);
     if (decoratorName === "Component") {
       const componentDecorator = decorators.find((d2) => {
-        if (!ts15.isCallExpression(d2.expression))
+        if (!ts16.isCallExpression(d2.expression))
           return false;
         const expr = d2.expression.expression;
-        return ts15.isIdentifier(expr) && expr.text === "Component";
+        return ts16.isIdentifier(expr) && expr.text === "Component";
       });
       if (!componentDecorator)
         continue;
       const decoratorCall = componentDecorator.expression;
       const args = decoratorCall.arguments[0];
-      if (!args || !ts15.isObjectLiteralExpression(args))
+      if (!args || !ts16.isObjectLiteralExpression(args))
         continue;
       const decoratorMeta = readDecoratorMeta(args);
       const { inputs, outputs } = extractInputsAndOutputs(stmt, null);
@@ -17520,11 +17552,11 @@ var fail = (reason, detail, location) => ({
     return false;
   return true;
 }, ENTITY_DECORATOR_NAMES, findEntityDecorator = (cls) => {
-  for (const dec of ts15.getDecorators(cls) ?? []) {
+  for (const dec of ts16.getDecorators(cls) ?? []) {
     const expr = dec.expression;
-    if (!ts15.isCallExpression(expr))
+    if (!ts16.isCallExpression(expr))
       continue;
-    if (!ts15.isIdentifier(expr.expression))
+    if (!ts16.isIdentifier(expr.expression))
       continue;
     if (ENTITY_DECORATOR_NAMES.has(expr.expression.text))
       return dec;
@@ -17542,18 +17574,18 @@ var fail = (reason, detail, location) => ({
   }
   const ctorParamTypes = [];
   for (const member of cls.members) {
-    if (!ts15.isConstructorDeclaration(member))
+    if (!ts16.isConstructorDeclaration(member))
       continue;
     for (const param of member.parameters) {
       const typeText = param.type ? param.type.getText() : "";
-      const decorators = ts15.getDecorators(param) ?? [];
+      const decorators = ts16.getDecorators(param) ?? [];
       const decoratorSig = decorators.length === 0 ? "" : decorators.map((d2) => {
         const e = d2.expression;
-        if (ts15.isCallExpression(e) && ts15.isIdentifier(e.expression)) {
+        if (ts16.isCallExpression(e) && ts16.isIdentifier(e.expression)) {
           const args = e.arguments.map((a) => a.getText()).join(",");
           return `@${e.expression.text}(${args})`;
         }
-        if (ts15.isIdentifier(e))
+        if (ts16.isIdentifier(e))
           return `@${e.text}`;
         return "@<unknown>";
       }).join("");
@@ -17575,23 +17607,23 @@ var fail = (reason, detail, location) => ({
   const walk = (node) => {
     if (found)
       return;
-    if (ts15.isClassDeclaration(node) && node.name?.text === className) {
+    if (ts16.isClassDeclaration(node) && node.name?.text === className) {
       found = node;
       return;
     }
-    ts15.forEachChild(node, walk);
+    ts16.forEachChild(node, walk);
   };
   walk(sourceFile);
   return found;
 }, getClassDecorators = (cls) => {
-  const modifiers = ts15.getDecorators(cls) ?? [];
+  const modifiers = ts16.getDecorators(cls) ?? [];
   return [...modifiers];
 }, findComponentDecorator = (cls) => {
   for (const decorator of getClassDecorators(cls)) {
     const expr = decorator.expression;
-    if (ts15.isCallExpression(expr)) {
+    if (ts16.isCallExpression(expr)) {
       const fn2 = expr.expression;
-      if (ts15.isIdentifier(fn2) && fn2.text === "Component") {
+      if (ts16.isIdentifier(fn2) && fn2.text === "Component") {
         return decorator;
       }
     }
@@ -17599,15 +17631,15 @@ var fail = (reason, detail, location) => ({
   return null;
 }, getDecoratorArgsObject = (decorator) => {
   const call = decorator.expression;
-  if (!ts15.isCallExpression(call))
+  if (!ts16.isCallExpression(call))
     return null;
   const arg = call.arguments[0];
-  if (!arg || !ts15.isObjectLiteralExpression(arg))
+  if (!arg || !ts16.isObjectLiteralExpression(arg))
     return null;
   return arg;
 }, getProperty = (obj, name) => {
   for (const prop of obj.properties) {
-    if (ts15.isPropertyAssignment(prop) && (ts15.isIdentifier(prop.name) && prop.name.text === name || ts15.isStringLiteral(prop.name) && prop.name.text === name)) {
+    if (ts16.isPropertyAssignment(prop) && (ts16.isIdentifier(prop.name) && prop.name.text === name || ts16.isStringLiteral(prop.name) && prop.name.text === name)) {
       return prop.initializer;
     }
   }
@@ -17616,7 +17648,7 @@ var fail = (reason, detail, location) => ({
   const expr = getProperty(obj, name);
   if (!expr)
     return null;
-  if (ts15.isStringLiteral(expr) || ts15.isNoSubstitutionTemplateLiteral(expr)) {
+  if (ts16.isStringLiteral(expr) || ts16.isNoSubstitutionTemplateLiteral(expr)) {
     return expr.text;
   }
   return null;
@@ -17624,22 +17656,22 @@ var fail = (reason, detail, location) => ({
   const expr = getProperty(obj, name);
   if (!expr)
     return null;
-  if (expr.kind === ts15.SyntaxKind.TrueKeyword)
+  if (expr.kind === ts16.SyntaxKind.TrueKeyword)
     return true;
-  if (expr.kind === ts15.SyntaxKind.FalseKeyword)
+  if (expr.kind === ts16.SyntaxKind.FalseKeyword)
     return false;
   return null;
 }, isAngularDecoratorIdentifier = (name) => name === "Component" || name === "Directive" || name === "Pipe" || name === "Injectable", classHasAngularDecorator = (cls) => {
-  for (const dec of ts15.getDecorators(cls) ?? []) {
+  for (const dec of ts16.getDecorators(cls) ?? []) {
     const expr = dec.expression;
-    if (ts15.isCallExpression(expr) && ts15.isIdentifier(expr.expression) && isAngularDecoratorIdentifier(expr.expression.text)) {
+    if (ts16.isCallExpression(expr) && ts16.isIdentifier(expr.expression) && isAngularDecoratorIdentifier(expr.expression.text)) {
       return true;
     }
   }
   return false;
 }, findClassInSourceFile = (sf, className) => {
   for (const stmt of sf.statements) {
-    if (ts15.isClassDeclaration(stmt) && stmt.name?.text === className) {
+    if (ts16.isClassDeclaration(stmt) && stmt.name?.text === className) {
       return stmt;
     }
   }
@@ -17649,15 +17681,15 @@ var fail = (reason, detail, location) => ({
   if (sameFile)
     return classHasAngularDecorator(sameFile);
   for (const stmt of sourceFile.statements) {
-    if (!ts15.isImportDeclaration(stmt))
+    if (!ts16.isImportDeclaration(stmt))
       continue;
-    if (!ts15.isStringLiteral(stmt.moduleSpecifier))
+    if (!ts16.isStringLiteral(stmt.moduleSpecifier))
       continue;
     const clause = stmt.importClause;
     if (!clause || clause.isTypeOnly)
       continue;
     const named = clause.namedBindings;
-    if (!named || !ts15.isNamedImports(named))
+    if (!named || !ts16.isNamedImports(named))
       continue;
     const found = named.elements.find((el) => el.name.text === parentClassName);
     if (!found)
@@ -17682,7 +17714,7 @@ var fail = (reason, detail, location) => ({
       } catch {
         continue;
       }
-      const parentSf = ts15.createSourceFile(candidate, content, ts15.ScriptTarget.Latest, true);
+      const parentSf = ts16.createSourceFile(candidate, content, ts16.ScriptTarget.Latest, true);
       const parentCls = findClassInSourceFile(parentSf, parentClassName);
       if (!parentCls)
         continue;
@@ -17694,11 +17726,11 @@ var fail = (reason, detail, location) => ({
 }, inheritsDecoratedClass = (cls, sourceFile, componentDir, projectRoot) => {
   const heritage = cls.heritageClauses ?? [];
   for (const clause of heritage) {
-    if (clause.token !== ts15.SyntaxKind.ExtendsKeyword)
+    if (clause.token !== ts16.SyntaxKind.ExtendsKeyword)
       continue;
     for (const typeNode of clause.types) {
       const expr = typeNode.expression;
-      if (!ts15.isIdentifier(expr)) {
+      if (!ts16.isIdentifier(expr)) {
         return true;
       }
       if (parentHasAngularDecoratorAcrossFiles(expr.text, sourceFile, componentDir, projectRoot)) {
@@ -17709,18 +17741,18 @@ var fail = (reason, detail, location) => ({
   return false;
 }, CONTROL_CREATE_METHOD_NAME = "\u0275ngControlCreate", extractControlCreate = (cls) => {
   for (const member of cls.members) {
-    if (!ts15.isMethodDeclaration(member))
+    if (!ts16.isMethodDeclaration(member))
       continue;
-    if (member.modifiers?.some((m) => m.kind === ts15.SyntaxKind.StaticKeyword))
+    if (member.modifiers?.some((m) => m.kind === ts16.SyntaxKind.StaticKeyword))
       continue;
     const { name } = member;
     if (name === undefined)
       continue;
-    const nameText = ts15.isIdentifier(name) ? name.text : name.getText();
+    const nameText = ts16.isIdentifier(name) ? name.text : name.getText();
     if (nameText !== CONTROL_CREATE_METHOD_NAME)
       continue;
     const firstParam = member.parameters[0];
-    if (firstParam === undefined || firstParam.type === undefined || !ts15.isTypeReferenceNode(firstParam.type)) {
+    if (firstParam === undefined || firstParam.type === undefined || !ts16.isTypeReferenceNode(firstParam.type)) {
       return { passThroughInput: null };
     }
     const typeArgs = firstParam.type.typeArguments;
@@ -17728,16 +17760,16 @@ var fail = (reason, detail, location) => ({
       return { passThroughInput: null };
     }
     const arg = typeArgs[0];
-    if (arg === undefined || !ts15.isLiteralTypeNode(arg) || !ts15.isStringLiteral(arg.literal)) {
+    if (arg === undefined || !ts16.isLiteralTypeNode(arg) || !ts16.isStringLiteral(arg.literal)) {
       return { passThroughInput: null };
     }
     return { passThroughInput: arg.literal.text };
   }
   return null;
 }, resolveEnumPropertyAccess = (expr, enumName, values) => {
-  if (!ts15.isPropertyAccessExpression(expr))
+  if (!ts16.isPropertyAccessExpression(expr))
     return null;
-  if (!ts15.isIdentifier(expr.expression))
+  if (!ts16.isIdentifier(expr.expression))
     return null;
   if (expr.expression.text !== enumName)
     return null;
@@ -17756,21 +17788,21 @@ var fail = (reason, detail, location) => ({
   const hostExpr = getProperty(args, "host");
   const schemasExpr = getProperty(args, "schemas");
   const styleUrls = [];
-  if (styleUrlsExpr && ts15.isArrayLiteralExpression(styleUrlsExpr)) {
+  if (styleUrlsExpr && ts16.isArrayLiteralExpression(styleUrlsExpr)) {
     for (const el of styleUrlsExpr.elements) {
-      if (ts15.isStringLiteral(el))
+      if (ts16.isStringLiteral(el))
         styleUrls.push(el.text);
     }
   }
   const styles = [];
   if (stylesExpr) {
-    if (ts15.isArrayLiteralExpression(stylesExpr)) {
+    if (ts16.isArrayLiteralExpression(stylesExpr)) {
       for (const el of stylesExpr.elements) {
-        if (ts15.isStringLiteral(el) || ts15.isNoSubstitutionTemplateLiteral(el)) {
+        if (ts16.isStringLiteral(el) || ts16.isNoSubstitutionTemplateLiteral(el)) {
           styles.push(el.text);
         }
       }
-    } else if (ts15.isStringLiteral(stylesExpr) || ts15.isNoSubstitutionTemplateLiteral(stylesExpr)) {
+    } else if (ts16.isStringLiteral(stylesExpr) || ts16.isNoSubstitutionTemplateLiteral(stylesExpr)) {
       styles.push(stylesExpr.text);
     }
   }
@@ -17783,15 +17815,15 @@ var fail = (reason, detail, location) => ({
     encapsulation,
     hasProviders: getProperty(args, "providers") !== null,
     hasViewProviders: getProperty(args, "viewProviders") !== null,
-    importsExpr: importsExpr && ts15.isArrayLiteralExpression(importsExpr) ? importsExpr : null,
-    hostDirectivesExpr: hostDirectivesExpr && ts15.isArrayLiteralExpression(hostDirectivesExpr) ? hostDirectivesExpr : null,
-    animationsExpr: animationsExpr && ts15.isArrayLiteralExpression(animationsExpr) ? animationsExpr : null,
-    providersExpr: providersExpr && ts15.isArrayLiteralExpression(providersExpr) ? providersExpr : null,
-    viewProvidersExpr: viewProvidersExpr && ts15.isArrayLiteralExpression(viewProvidersExpr) ? viewProvidersExpr : null,
-    inputsArrayExpr: inputsArrayExpr && ts15.isArrayLiteralExpression(inputsArrayExpr) ? inputsArrayExpr : null,
-    outputsArrayExpr: outputsArrayExpr && ts15.isArrayLiteralExpression(outputsArrayExpr) ? outputsArrayExpr : null,
-    hostExpr: hostExpr && ts15.isObjectLiteralExpression(hostExpr) ? hostExpr : null,
-    schemasExpr: schemasExpr && ts15.isArrayLiteralExpression(schemasExpr) ? schemasExpr : null,
+    importsExpr: importsExpr && ts16.isArrayLiteralExpression(importsExpr) ? importsExpr : null,
+    hostDirectivesExpr: hostDirectivesExpr && ts16.isArrayLiteralExpression(hostDirectivesExpr) ? hostDirectivesExpr : null,
+    animationsExpr: animationsExpr && ts16.isArrayLiteralExpression(animationsExpr) ? animationsExpr : null,
+    providersExpr: providersExpr && ts16.isArrayLiteralExpression(providersExpr) ? providersExpr : null,
+    viewProvidersExpr: viewProvidersExpr && ts16.isArrayLiteralExpression(viewProvidersExpr) ? viewProvidersExpr : null,
+    inputsArrayExpr: inputsArrayExpr && ts16.isArrayLiteralExpression(inputsArrayExpr) ? inputsArrayExpr : null,
+    outputsArrayExpr: outputsArrayExpr && ts16.isArrayLiteralExpression(outputsArrayExpr) ? outputsArrayExpr : null,
+    hostExpr: hostExpr && ts16.isObjectLiteralExpression(hostExpr) ? hostExpr : null,
+    schemasExpr: schemasExpr && ts16.isArrayLiteralExpression(schemasExpr) ? schemasExpr : null,
     preserveWhitespaces: getBooleanProperty(args, "preserveWhitespaces") ?? projectDefaults.preserveWhitespaces ?? false,
     selector: getStringProperty(args, "selector"),
     standalone: getBooleanProperty(args, "standalone") ?? true,
@@ -17802,13 +17834,13 @@ var fail = (reason, detail, location) => ({
     templateUrl: getStringProperty(args, "templateUrl")
   };
 }, extractDecoratorInput = (prop, compiler) => {
-  const decorators = ts15.getDecorators(prop) ?? [];
+  const decorators = ts16.getDecorators(prop) ?? [];
   for (const decorator of decorators) {
     const expr = decorator.expression;
-    if (!ts15.isCallExpression(expr))
+    if (!ts16.isCallExpression(expr))
       continue;
     const fn2 = expr.expression;
-    if (!ts15.isIdentifier(fn2) || fn2.text !== "Input")
+    if (!ts16.isIdentifier(fn2) || fn2.text !== "Input")
       continue;
     const classPropertyName = prop.name.getText();
     let bindingPropertyName = classPropertyName;
@@ -17816,9 +17848,9 @@ var fail = (reason, detail, location) => ({
     let transformFunction = null;
     const arg = expr.arguments[0];
     if (arg) {
-      if (ts15.isStringLiteral(arg)) {
+      if (ts16.isStringLiteral(arg)) {
         bindingPropertyName = arg.text;
-      } else if (ts15.isObjectLiteralExpression(arg)) {
+      } else if (ts16.isObjectLiteralExpression(arg)) {
         const aliasNode = getStringProperty(arg, "alias");
         if (aliasNode !== null)
           bindingPropertyName = aliasNode;
@@ -17842,11 +17874,11 @@ var fail = (reason, detail, location) => ({
   }
   return null;
 }, isInputSignalCall = (init) => {
-  if (ts15.isCallExpression(init)) {
+  if (ts16.isCallExpression(init)) {
     const fn2 = init.expression;
-    if (ts15.isIdentifier(fn2) && fn2.text === "input")
+    if (ts16.isIdentifier(fn2) && fn2.text === "input")
       return true;
-    if (ts15.isPropertyAccessExpression(fn2) && ts15.isIdentifier(fn2.expression) && fn2.expression.text === "input") {
+    if (ts16.isPropertyAccessExpression(fn2) && ts16.isIdentifier(fn2.expression) && fn2.expression.text === "input") {
       return true;
     }
   }
@@ -17857,13 +17889,13 @@ var fail = (reason, detail, location) => ({
   const classPropertyName = prop.name.getText();
   const call = prop.initializer;
   let required = false;
-  if (ts15.isPropertyAccessExpression(call.expression) && ts15.isIdentifier(call.expression.name) && call.expression.name.text === "required") {
+  if (ts16.isPropertyAccessExpression(call.expression) && ts16.isIdentifier(call.expression.name) && call.expression.name.text === "required") {
     required = true;
   }
   let bindingPropertyName = classPropertyName;
   let transformFunction = null;
   const optsArg = call.arguments[required ? 0 : 1];
-  if (optsArg && ts15.isObjectLiteralExpression(optsArg)) {
+  if (optsArg && ts16.isObjectLiteralExpression(optsArg)) {
     const aliasNode = getStringProperty(optsArg, "alias");
     if (aliasNode !== null)
       bindingPropertyName = aliasNode;
@@ -17883,28 +17915,28 @@ var fail = (reason, detail, location) => ({
     }
   };
 }, extractDecoratorOutput = (prop) => {
-  const decorators = ts15.getDecorators(prop) ?? [];
+  const decorators = ts16.getDecorators(prop) ?? [];
   for (const decorator of decorators) {
     const expr = decorator.expression;
-    if (!ts15.isCallExpression(expr))
+    if (!ts16.isCallExpression(expr))
       continue;
     const fn2 = expr.expression;
-    if (!ts15.isIdentifier(fn2) || fn2.text !== "Output")
+    if (!ts16.isIdentifier(fn2) || fn2.text !== "Output")
       continue;
     const classPropertyName = prop.name.getText();
     let bindingName = classPropertyName;
     const arg = expr.arguments[0];
-    if (arg && ts15.isStringLiteral(arg))
+    if (arg && ts16.isStringLiteral(arg))
       bindingName = arg.text;
     return { bindingName, classPropertyName };
   }
   return null;
 }, isOutputSignalCall = (init) => {
-  if (ts15.isCallExpression(init)) {
+  if (ts16.isCallExpression(init)) {
     const fn2 = init.expression;
-    if (ts15.isIdentifier(fn2) && fn2.text === "output")
+    if (ts16.isIdentifier(fn2) && fn2.text === "output")
       return true;
-    if (ts15.isPropertyAccessExpression(fn2) && ts15.isIdentifier(fn2.expression) && fn2.expression.text === "output") {
+    if (ts16.isPropertyAccessExpression(fn2) && ts16.isIdentifier(fn2.expression) && fn2.expression.text === "output") {
       return true;
     }
   }
@@ -17916,7 +17948,7 @@ var fail = (reason, detail, location) => ({
   const call = prop.initializer;
   let bindingName = classPropertyName;
   const optsArg = call.arguments[0];
-  if (optsArg && ts15.isObjectLiteralExpression(optsArg)) {
+  if (optsArg && ts16.isObjectLiteralExpression(optsArg)) {
     const aliasNode = getStringProperty(optsArg, "alias");
     if (aliasNode !== null)
       bindingName = aliasNode;
@@ -17928,7 +17960,7 @@ var fail = (reason, detail, location) => ({
   let hasDecoratorIO = false;
   let hasSignalIO = false;
   for (const member of cls.members) {
-    if (!ts15.isPropertyDeclaration(member))
+    if (!ts16.isPropertyDeclaration(member))
       continue;
     const decoratorIn = extractDecoratorInput(member, compiler);
     if (decoratorIn) {
@@ -17962,21 +17994,21 @@ var fail = (reason, detail, location) => ({
   specialAttributes: {}
 }), parseHostObjectInto = (host, args, hostExprNode, compiler) => {
   const hostNode = getProperty(args, "host");
-  if (!hostNode || !ts15.isObjectLiteralExpression(hostNode)) {
+  if (!hostNode || !ts16.isObjectLiteralExpression(hostNode)) {
     if (!hostExprNode)
       return;
   }
-  const obj = hostNode && ts15.isObjectLiteralExpression(hostNode) ? hostNode : hostExprNode;
+  const obj = hostNode && ts16.isObjectLiteralExpression(hostNode) ? hostNode : hostExprNode;
   if (!obj)
     return;
   for (const prop of obj.properties) {
-    if (!ts15.isPropertyAssignment(prop))
+    if (!ts16.isPropertyAssignment(prop))
       continue;
     const keyNode = prop.name;
     let key;
-    if (ts15.isStringLiteral(keyNode) || ts15.isNoSubstitutionTemplateLiteral(keyNode)) {
+    if (ts16.isStringLiteral(keyNode) || ts16.isNoSubstitutionTemplateLiteral(keyNode)) {
       key = keyNode.text;
-    } else if (ts15.isIdentifier(keyNode)) {
+    } else if (ts16.isIdentifier(keyNode)) {
       key = keyNode.text;
     } else {
       continue;
@@ -17993,36 +18025,36 @@ var fail = (reason, detail, location) => ({
   }
 }, mergeMemberHostDecorators = (host, cls) => {
   for (const member of cls.members) {
-    if (!ts15.canHaveDecorators(member))
+    if (!ts16.canHaveDecorators(member))
       continue;
-    const decorators = ts15.getDecorators(member) ?? [];
+    const decorators = ts16.getDecorators(member) ?? [];
     for (const dec of decorators) {
       const expr = dec.expression;
-      if (!ts15.isCallExpression(expr))
+      if (!ts16.isCallExpression(expr))
         continue;
       const fn2 = expr.expression;
-      if (!ts15.isIdentifier(fn2))
+      if (!ts16.isIdentifier(fn2))
         continue;
       if (fn2.text === "HostBinding") {
-        if (!ts15.isPropertyDeclaration(member) && !ts15.isGetAccessor(member))
+        if (!ts16.isPropertyDeclaration(member) && !ts16.isGetAccessor(member))
           continue;
-        const propertyName = member.name.text;
+        const propertyName2 = member.name.text;
         const target = expr.arguments[0];
-        const key = target && ts15.isStringLiteral(target) ? target.text : propertyName;
-        host.properties[key] = propertyName;
+        const key = target && ts16.isStringLiteral(target) ? target.text : propertyName2;
+        host.properties[key] = propertyName2;
       } else if (fn2.text === "HostListener") {
-        if (!ts15.isMethodDeclaration(member))
+        if (!ts16.isMethodDeclaration(member))
           continue;
         const methodName = member.name.text;
         const eventArg = expr.arguments[0];
-        if (!eventArg || !ts15.isStringLiteral(eventArg))
+        if (!eventArg || !ts16.isStringLiteral(eventArg))
           continue;
         const event = eventArg.text;
         const argsArg = expr.arguments[1];
         const argsList = [];
-        if (argsArg && ts15.isArrayLiteralExpression(argsArg)) {
+        if (argsArg && ts16.isArrayLiteralExpression(argsArg)) {
           for (const el of argsArg.elements) {
-            if (ts15.isStringLiteral(el))
+            if (ts16.isStringLiteral(el))
               argsList.push(el.text);
           }
         }
@@ -18035,14 +18067,14 @@ var fail = (reason, detail, location) => ({
   let descendants = true;
   let emitDistinctChangesOnly = true;
   const opts = args[1];
-  if (opts && ts15.isObjectLiteralExpression(opts)) {
+  if (opts && ts16.isObjectLiteralExpression(opts)) {
     static_ = getBooleanProperty(opts, "static") ?? false;
     descendants = getBooleanProperty(opts, "descendants") ?? true;
     emitDistinctChangesOnly = getBooleanProperty(opts, "emitDistinctChangesOnly") ?? true;
   }
   return { descendants, emitDistinctChangesOnly, static_ };
 }, queryPredicateFromArg = (arg, compiler) => {
-  if (ts15.isStringLiteral(arg)) {
+  if (ts16.isStringLiteral(arg)) {
     return arg.text.split(",").map((s2) => s2.trim()).filter(Boolean);
   }
   return {
@@ -18053,17 +18085,17 @@ var fail = (reason, detail, location) => ({
   const contentQueries = [];
   const viewQueries = [];
   for (const member of cls.members) {
-    if (!ts15.isPropertyDeclaration(member))
+    if (!ts16.isPropertyDeclaration(member))
       continue;
-    const decorators = ts15.getDecorators(member) ?? [];
+    const decorators = ts16.getDecorators(member) ?? [];
     for (const dec of decorators) {
       const expr = dec.expression;
-      if (!ts15.isCallExpression(expr))
+      if (!ts16.isCallExpression(expr))
         continue;
       const fn2 = expr.expression;
-      if (!ts15.isIdentifier(fn2) || !QUERY_DECORATORS.has(fn2.text))
+      if (!ts16.isIdentifier(fn2) || !QUERY_DECORATORS.has(fn2.text))
         continue;
-      const propertyName = member.name.text;
+      const propertyName2 = member.name.text;
       const tokenArg = expr.arguments[0];
       if (!tokenArg)
         continue;
@@ -18073,7 +18105,7 @@ var fail = (reason, detail, location) => ({
       const { static_, descendants, emitDistinctChangesOnly } = parseQueryDecoratorOptions(expr.arguments);
       const opts = expr.arguments[1];
       let read = null;
-      if (opts && ts15.isObjectLiteralExpression(opts)) {
+      if (opts && ts16.isObjectLiteralExpression(opts)) {
         const readNode = getProperty(opts, "read");
         if (readNode) {
           read = new compiler.WrappedNodeExpr(readNode);
@@ -18085,7 +18117,7 @@ var fail = (reason, detail, location) => ({
         first: fn2.text === "ViewChild" || fn2.text === "ContentChild",
         isSignal: false,
         predicate,
-        propertyName,
+        propertyName: propertyName2,
         read,
         static: static_
       };
@@ -18101,15 +18133,15 @@ var fail = (reason, detail, location) => ({
   const contentQueries = [];
   const viewQueries = [];
   for (const member of cls.members) {
-    if (!ts15.isPropertyDeclaration(member) || !member.initializer)
+    if (!ts16.isPropertyDeclaration(member) || !member.initializer)
       continue;
     const init = member.initializer;
-    if (!ts15.isCallExpression(init))
+    if (!ts16.isCallExpression(init))
       continue;
     let queryName;
-    if (ts15.isIdentifier(init.expression)) {
+    if (ts16.isIdentifier(init.expression)) {
       queryName = init.expression.text;
-    } else if (ts15.isPropertyAccessExpression(init.expression) && ts15.isIdentifier(init.expression.expression) && init.expression.name.text === "required") {
+    } else if (ts16.isPropertyAccessExpression(init.expression) && ts16.isIdentifier(init.expression.expression) && init.expression.name.text === "required") {
       queryName = init.expression.expression.text;
     } else {
       continue;
@@ -18117,7 +18149,7 @@ var fail = (reason, detail, location) => ({
     const runtime = SIGNAL_QUERY_TO_RUNTIME[queryName];
     if (!runtime)
       continue;
-    const propertyName = member.name.text;
+    const propertyName2 = member.name.text;
     const tokenArg = init.arguments[0];
     if (!tokenArg)
       continue;
@@ -18127,7 +18159,7 @@ var fail = (reason, detail, location) => ({
     let descendants = true;
     let read = null;
     const opts = init.arguments[1];
-    if (opts && ts15.isObjectLiteralExpression(opts)) {
+    if (opts && ts16.isObjectLiteralExpression(opts)) {
       descendants = getBooleanProperty(opts, "descendants") ?? true;
       const readNode = getProperty(opts, "read");
       if (readNode)
@@ -18139,7 +18171,7 @@ var fail = (reason, detail, location) => ({
       first: runtime.first,
       isSignal: true,
       predicate,
-      propertyName,
+      propertyName: propertyName2,
       read,
       static: false
     };
@@ -18153,13 +18185,13 @@ var fail = (reason, detail, location) => ({
   const node = getProperty(args, "exportAs");
   if (!node)
     return null;
-  if (ts15.isStringLiteral(node)) {
+  if (ts16.isStringLiteral(node)) {
     return node.text.split(",").map((s2) => s2.trim()).filter(Boolean);
   }
-  if (ts15.isArrayLiteralExpression(node)) {
+  if (ts16.isArrayLiteralExpression(node)) {
     const out = [];
     for (const el of node.elements) {
-      if (ts15.isStringLiteral(el))
+      if (ts16.isStringLiteral(el))
         out.push(el.text);
     }
     return out.length > 0 ? out : null;
@@ -18167,11 +18199,11 @@ var fail = (reason, detail, location) => ({
   return null;
 }, extractHostDirectives = (args, compiler) => {
   const node = getProperty(args, "hostDirectives");
-  if (!node || !ts15.isArrayLiteralExpression(node))
+  if (!node || !ts16.isArrayLiteralExpression(node))
     return null;
   const out = [];
   for (const el of node.elements) {
-    if (ts15.isIdentifier(el)) {
+    if (ts16.isIdentifier(el)) {
       out.push({
         directive: {
           type: new compiler.WrappedNodeExpr(el),
@@ -18183,7 +18215,7 @@ var fail = (reason, detail, location) => ({
       });
       continue;
     }
-    if (!ts15.isObjectLiteralExpression(el))
+    if (!ts16.isObjectLiteralExpression(el))
       continue;
     const directiveNode = getProperty(el, "directive");
     if (!directiveNode)
@@ -18191,11 +18223,11 @@ var fail = (reason, detail, location) => ({
     const inputsNode = getProperty(el, "inputs");
     const outputsNode = getProperty(el, "outputs");
     const collectMap = (n) => {
-      if (!n || !ts15.isArrayLiteralExpression(n))
+      if (!n || !ts16.isArrayLiteralExpression(n))
         return null;
       const map = {};
       for (const item of n.elements) {
-        if (!ts15.isStringLiteral(item))
+        if (!ts16.isStringLiteral(item))
           continue;
         const [name, alias] = item.text.split(":").map((s2) => s2.trim());
         if (name)
@@ -18265,10 +18297,10 @@ var fail = (reason, detail, location) => ({
     });
     return null;
   }
-  const sf = ts15.createSourceFile(filePath, source, ts15.ScriptTarget.Latest, true);
+  const sf = ts16.createSourceFile(filePath, source, ts16.ScriptTarget.Latest, true);
   let info = null;
   for (const stmt of sf.statements) {
-    if (!ts15.isClassDeclaration(stmt))
+    if (!ts16.isClassDeclaration(stmt))
       continue;
     if (!stmt.name || stmt.name.text !== className)
       continue;
@@ -18403,9 +18435,9 @@ var fail = (reason, detail, location) => ({
 }, buildClassToSpecMap = (sourceFile) => {
   const result = new Map;
   for (const stmt of sourceFile.statements) {
-    if (!ts15.isImportDeclaration(stmt))
+    if (!ts16.isImportDeclaration(stmt))
       continue;
-    if (!ts15.isStringLiteral(stmt.moduleSpecifier))
+    if (!ts16.isStringLiteral(stmt.moduleSpecifier))
       continue;
     const spec = stmt.moduleSpecifier.text;
     const clause = stmt.importClause;
@@ -18414,7 +18446,7 @@ var fail = (reason, detail, location) => ({
     if (clause.name)
       result.set(clause.name.text, spec);
     const named = clause.namedBindings;
-    if (named && ts15.isNamedImports(named)) {
+    if (named && ts16.isNamedImports(named)) {
       for (const el of named.elements) {
         if (el.isTypeOnly)
           continue;
@@ -18527,7 +18559,7 @@ var fail = (reason, detail, location) => ({
     return result;
   const classToSpec = buildClassToSpecMap(sourceFile);
   for (const el of importsExpr.elements) {
-    if (!ts15.isIdentifier(el))
+    if (!ts16.isIdentifier(el))
       continue;
     const className = el.text;
     const spec = classToSpec.get(className);
@@ -18546,35 +18578,35 @@ var fail = (reason, detail, location) => ({
   }
   return (h2 >>> 0).toString(36);
 }, initializerShapeIsStructural = (node) => {
-  if (ts15.isArrowFunction(node) || ts15.isFunctionExpression(node) || ts15.isCallExpression(node) || ts15.isNewExpression(node)) {
+  if (ts16.isArrowFunction(node) || ts16.isFunctionExpression(node) || ts16.isCallExpression(node) || ts16.isNewExpression(node)) {
     return true;
   }
-  if (ts15.isConditionalExpression(node)) {
+  if (ts16.isConditionalExpression(node)) {
     return initializerShapeIsStructural(node.whenTrue) || initializerShapeIsStructural(node.whenFalse);
   }
-  if (ts15.isParenthesizedExpression(node)) {
+  if (ts16.isParenthesizedExpression(node)) {
     return initializerShapeIsStructural(node.expression);
   }
-  if (ts15.isAsExpression(node) || ts15.isTypeAssertionExpression(node)) {
+  if (ts16.isAsExpression(node) || ts16.isTypeAssertionExpression(node)) {
     return initializerShapeIsStructural(node.expression);
   }
-  if (ts15.isNonNullExpression(node)) {
+  if (ts16.isNonNullExpression(node)) {
     return initializerShapeIsStructural(node.expression);
   }
-  if (ts15.isObjectLiteralExpression(node)) {
+  if (ts16.isObjectLiteralExpression(node)) {
     for (const prop of node.properties) {
-      if (ts15.isPropertyAssignment(prop) && initializerShapeIsStructural(prop.initializer)) {
+      if (ts16.isPropertyAssignment(prop) && initializerShapeIsStructural(prop.initializer)) {
         return true;
       }
-      if (ts15.isShorthandPropertyAssignment(prop))
+      if (ts16.isShorthandPropertyAssignment(prop))
         continue;
-      if (ts15.isSpreadAssignment(prop) && initializerShapeIsStructural(prop.expression)) {
+      if (ts16.isSpreadAssignment(prop) && initializerShapeIsStructural(prop.expression)) {
         return true;
       }
     }
     return false;
   }
-  if (ts15.isArrayLiteralExpression(node)) {
+  if (ts16.isArrayLiteralExpression(node)) {
     for (const el of node.elements) {
       if (initializerShapeIsStructural(el))
         return true;
@@ -18585,7 +18617,7 @@ var fail = (reason, detail, location) => ({
 }, extractArrowFieldSig = (cls) => {
   const entries = [];
   for (const member of cls.members) {
-    if (!ts15.isPropertyDeclaration(member))
+    if (!ts16.isPropertyDeclaration(member))
       continue;
     const init = member.initializer;
     if (!init)
@@ -18595,12 +18627,12 @@ var fail = (reason, detail, location) => ({
     const name = member.name.getText();
     let bodyText;
     try {
-      const printer = ts15.createPrinter({
-        newLine: ts15.NewLineKind.LineFeed,
+      const printer = ts16.createPrinter({
+        newLine: ts16.NewLineKind.LineFeed,
         omitTrailingSemicolon: true,
         removeComments: true
       });
-      bodyText = printer.printNode(ts15.EmitHint.Unspecified, init, cls.getSourceFile());
+      bodyText = printer.printNode(ts16.EmitHint.Unspecified, init, cls.getSourceFile());
     } catch {
       bodyText = init.getText();
     }
@@ -18611,9 +18643,9 @@ var fail = (reason, detail, location) => ({
 }, INPUT_OUTPUT_DECORATORS, extractMemberDecoratorSig = (cls) => {
   const entries = [];
   for (const member of cls.members) {
-    if (!ts15.canHaveDecorators(member))
+    if (!ts16.canHaveDecorators(member))
       continue;
-    const decorators = ts15.getDecorators(member) ?? [];
+    const decorators = ts16.getDecorators(member) ?? [];
     if (decorators.length === 0)
       continue;
     const memberName = member.name?.getText() ?? "<anon>";
@@ -18621,14 +18653,14 @@ var fail = (reason, detail, location) => ({
       const expr = decorator.expression;
       let decName = "<unknown>";
       let argText = "";
-      if (ts15.isCallExpression(expr)) {
-        if (ts15.isIdentifier(expr.expression)) {
+      if (ts16.isCallExpression(expr)) {
+        if (ts16.isIdentifier(expr.expression)) {
           decName = expr.expression.text;
         }
         if (expr.arguments.length > 0) {
           argText = expr.arguments.map((a) => a.getText()).join(",");
         }
-      } else if (ts15.isIdentifier(expr)) {
+      } else if (ts16.isIdentifier(expr)) {
         decName = expr.text;
       }
       if (INPUT_OUTPUT_DECORATORS.has(decName))
@@ -18653,18 +18685,18 @@ var fail = (reason, detail, location) => ({
   } catch {
     return true;
   }
-  const sf = ts15.createSourceFile(filePath, source, ts15.ScriptTarget.ES2022, true, ts15.ScriptKind.TS);
+  const sf = ts16.createSourceFile(filePath, source, ts16.ScriptTarget.ES2022, true, ts16.ScriptKind.TS);
   let hasProviders = false;
   const visit = (node) => {
     if (hasProviders)
       return;
-    if (ts15.isClassDeclaration(node)) {
-      for (const decorator of ts15.getDecorators(node) ?? []) {
+    if (ts16.isClassDeclaration(node)) {
+      for (const decorator of ts16.getDecorators(node) ?? []) {
         const expr = decorator.expression;
-        if (!ts15.isCallExpression(expr))
+        if (!ts16.isCallExpression(expr))
           continue;
         const arg = expr.arguments[0];
-        if (!arg || !ts15.isObjectLiteralExpression(arg))
+        if (!arg || !ts16.isObjectLiteralExpression(arg))
           continue;
         if (getProperty(arg, "providers") !== null) {
           hasProviders = true;
@@ -18672,7 +18704,7 @@ var fail = (reason, detail, location) => ({
         }
       }
     }
-    ts15.forEachChild(node, visit);
+    ts16.forEachChild(node, visit);
   };
   visit(sf);
   providerProbeCache.set(filePath, {
@@ -18682,10 +18714,10 @@ var fail = (reason, detail, location) => ({
   return hasProviders;
 }, TS_EXTENSIONS, resolveImportSource = (identifierName, sourceFile, componentDir) => {
   for (const stmt of sourceFile.statements) {
-    if (!ts15.isImportDeclaration(stmt))
+    if (!ts16.isImportDeclaration(stmt))
       continue;
     const moduleSpec = stmt.moduleSpecifier;
-    if (!ts15.isStringLiteral(moduleSpec))
+    if (!ts16.isStringLiteral(moduleSpec))
       continue;
     const spec = moduleSpec.text;
     if (!spec.startsWith(".") && !spec.startsWith("/"))
@@ -18699,7 +18731,7 @@ var fail = (reason, detail, location) => ({
     }
     if (importClause.namedBindings) {
       const nb = importClause.namedBindings;
-      if (ts15.isNamespaceImport(nb)) {
+      if (ts16.isNamespaceImport(nb)) {
         if (nb.name.text === identifierName)
           matches = true;
       } else {
@@ -18729,7 +18761,7 @@ var fail = (reason, detail, location) => ({
     return [];
   const sig = [];
   for (const entry of importsExpr.elements) {
-    if (ts15.isIdentifier(entry)) {
+    if (ts16.isIdentifier(entry)) {
       const importPath = resolveImportSource(entry.text, sourceFile, componentDir);
       if (importPath) {
         if (fileHasModuleProviders(importPath)) {
@@ -18748,13 +18780,13 @@ var fail = (reason, detail, location) => ({
 }, extractPropertyFieldNames = (cls) => {
   const names = [];
   for (const member of cls.members) {
-    if (!ts15.isPropertyDeclaration(member) && !ts15.isMethodDeclaration(member) && !ts15.isGetAccessorDeclaration(member) && !ts15.isSetAccessorDeclaration(member)) {
+    if (!ts16.isPropertyDeclaration(member) && !ts16.isMethodDeclaration(member) && !ts16.isGetAccessorDeclaration(member) && !ts16.isSetAccessorDeclaration(member)) {
       continue;
     }
     const { name } = member;
     if (name === undefined)
       continue;
-    const text = ts15.isIdentifier(name) ? name.text : ts15.isStringLiteral(name) || ts15.isNoSubstitutionTemplateLiteral(name) ? name.text : name.getText();
+    const text = ts16.isIdentifier(name) ? name.text : ts16.isStringLiteral(name) || ts16.isNoSubstitutionTemplateLiteral(name) ? name.text : name.getText();
     if (text.length > 0)
       names.push(text);
   }
@@ -18762,7 +18794,7 @@ var fail = (reason, detail, location) => ({
 }, extractTopLevelImports = (sourceFile) => {
   const names = new Set;
   for (const stmt of sourceFile.statements) {
-    if (!ts15.isImportDeclaration(stmt))
+    if (!ts16.isImportDeclaration(stmt))
       continue;
     const clause = stmt.importClause;
     if (!clause)
@@ -18774,9 +18806,9 @@ var fail = (reason, detail, location) => ({
     const bindings = clause.namedBindings;
     if (!bindings)
       continue;
-    if (ts15.isNamespaceImport(bindings)) {
+    if (ts16.isNamespaceImport(bindings)) {
       names.add(bindings.name.text);
-    } else if (ts15.isNamedImports(bindings)) {
+    } else if (ts16.isNamedImports(bindings)) {
       for (const el of bindings.elements) {
         if (el.isTypeOnly)
           continue;
@@ -18788,18 +18820,18 @@ var fail = (reason, detail, location) => ({
 }, extractFingerprint = (cls, className, decoratorMeta, inputs, outputs, sourceFile, componentDir) => {
   const ctorParamTypes = [];
   for (const member of cls.members) {
-    if (!ts15.isConstructorDeclaration(member))
+    if (!ts16.isConstructorDeclaration(member))
       continue;
     for (const param of member.parameters) {
       const typeText = param.type ? param.type.getText() : "";
-      const decorators = ts15.getDecorators(param) ?? [];
+      const decorators = ts16.getDecorators(param) ?? [];
       const decoratorSig = decorators.length === 0 ? "" : decorators.map((d2) => {
         const expr = d2.expression;
-        if (ts15.isCallExpression(expr) && ts15.isIdentifier(expr.expression)) {
+        if (ts16.isCallExpression(expr) && ts16.isIdentifier(expr.expression)) {
           const args = expr.arguments.map((a) => a.getText()).join(",");
           return `@${expr.expression.text}(${args})`;
         }
-        if (ts15.isIdentifier(expr)) {
+        if (ts16.isIdentifier(expr)) {
           return `@${expr.text}`;
         }
         return "@<unknown>";
@@ -18815,12 +18847,12 @@ var fail = (reason, detail, location) => ({
   const providerImportSig = extractProviderImportSig(decoratorMeta.importsExpr, sourceFile, componentDir);
   const topLevelImports = extractTopLevelImports(sourceFile);
   const propertyFieldNames = extractPropertyFieldNames(cls);
-  const printer = ts15.createPrinter({
-    newLine: ts15.NewLineKind.LineFeed,
+  const printer = ts16.createPrinter({
+    newLine: ts16.NewLineKind.LineFeed,
     omitTrailingSemicolon: true,
     removeComments: true
   });
-  const canonicalText = (node) => printer.printNode(ts15.EmitHint.Unspecified, node, sourceFile);
+  const canonicalText = (node) => printer.printNode(ts16.EmitHint.Unspecified, node, sourceFile);
   const importsArraySig = decoratorMeta.importsExpr ? djb2Hash(canonicalText(decoratorMeta.importsExpr)) : "";
   const hostDirectivesSig = decoratorMeta.hostDirectivesExpr ? djb2Hash(canonicalText(decoratorMeta.hostDirectivesExpr)) : "";
   const animationsArraySig = decoratorMeta.animationsExpr ? djb2Hash(canonicalText(decoratorMeta.animationsExpr)) : "";
@@ -18833,13 +18865,13 @@ var fail = (reason, detail, location) => ({
   const PAGE_EXPORT_NAMES = new Set(["providers", "routes"]);
   const pageExportEntries = [];
   for (const stmt of sourceFile.statements) {
-    if (!ts15.isVariableStatement(stmt))
+    if (!ts16.isVariableStatement(stmt))
       continue;
-    const isExported = stmt.modifiers?.some((m) => m.kind === ts15.SyntaxKind.ExportKeyword);
+    const isExported = stmt.modifiers?.some((m) => m.kind === ts16.SyntaxKind.ExportKeyword);
     if (!isExported)
       continue;
     for (const decl of stmt.declarationList.declarations) {
-      if (!ts15.isIdentifier(decl.name))
+      if (!ts16.isIdentifier(decl.name))
         continue;
       if (!PAGE_EXPORT_NAMES.has(decl.name.text))
         continue;
@@ -18880,35 +18912,35 @@ var fail = (reason, detail, location) => ({
 }, buildFreshClassMethodsBlock = (classNode, className) => {
   const memberSources = [];
   let hasStatic = false;
-  const printer = ts15.createPrinter({ removeComments: true });
+  const printer = ts16.createPrinter({ removeComments: true });
   for (const member of classNode.members) {
-    if (ts15.isPropertyDeclaration(member)) {
-      const modifiers = (ts15.getModifiers(member) ?? []).filter((m) => m.kind !== ts15.SyntaxKind.PrivateKeyword && m.kind !== ts15.SyntaxKind.PublicKeyword && m.kind !== ts15.SyntaxKind.ProtectedKeyword && m.kind !== ts15.SyntaxKind.ReadonlyKeyword && m.kind !== ts15.SyntaxKind.OverrideKeyword);
-      const cleaned = ts15.factory.createPropertyDeclaration(modifiers, member.name, undefined, undefined, member.initializer);
-      memberSources.push(printer.printNode(ts15.EmitHint.Unspecified, cleaned, classNode.getSourceFile()));
+    if (ts16.isPropertyDeclaration(member)) {
+      const modifiers = (ts16.getModifiers(member) ?? []).filter((m) => m.kind !== ts16.SyntaxKind.PrivateKeyword && m.kind !== ts16.SyntaxKind.PublicKeyword && m.kind !== ts16.SyntaxKind.ProtectedKeyword && m.kind !== ts16.SyntaxKind.ReadonlyKeyword && m.kind !== ts16.SyntaxKind.OverrideKeyword);
+      const cleaned = ts16.factory.createPropertyDeclaration(modifiers, member.name, undefined, undefined, member.initializer);
+      memberSources.push(printer.printNode(ts16.EmitHint.Unspecified, cleaned, classNode.getSourceFile()));
       continue;
     }
-    if (ts15.isConstructorDeclaration(member)) {
-      const cleanedParams = member.parameters.map((param) => ts15.factory.updateParameterDeclaration(param, (ts15.getModifiers(param) ?? []).filter((m) => m.kind !== ts15.SyntaxKind.PrivateKeyword && m.kind !== ts15.SyntaxKind.PublicKeyword && m.kind !== ts15.SyntaxKind.ProtectedKeyword && m.kind !== ts15.SyntaxKind.ReadonlyKeyword && m.kind !== ts15.SyntaxKind.OverrideKeyword), param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer));
-      const cleaned = ts15.factory.createConstructorDeclaration([], cleanedParams, member.body);
-      memberSources.push(printer.printNode(ts15.EmitHint.Unspecified, cleaned, classNode.getSourceFile()));
+    if (ts16.isConstructorDeclaration(member)) {
+      const cleanedParams = member.parameters.map((param) => ts16.factory.updateParameterDeclaration(param, (ts16.getModifiers(param) ?? []).filter((m) => m.kind !== ts16.SyntaxKind.PrivateKeyword && m.kind !== ts16.SyntaxKind.PublicKeyword && m.kind !== ts16.SyntaxKind.ProtectedKeyword && m.kind !== ts16.SyntaxKind.ReadonlyKeyword && m.kind !== ts16.SyntaxKind.OverrideKeyword), param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer));
+      const cleaned = ts16.factory.createConstructorDeclaration([], cleanedParams, member.body);
+      memberSources.push(printer.printNode(ts16.EmitHint.Unspecified, cleaned, classNode.getSourceFile()));
       continue;
     }
-    if (ts15.isMethodDeclaration(member) || ts15.isGetAccessorDeclaration(member) || ts15.isSetAccessorDeclaration(member)) {
-      const modifiers = ts15.getModifiers(member) ?? [];
-      const isStatic = modifiers.some((m) => m.kind === ts15.SyntaxKind.StaticKeyword);
+    if (ts16.isMethodDeclaration(member) || ts16.isGetAccessorDeclaration(member) || ts16.isSetAccessorDeclaration(member)) {
+      const modifiers = ts16.getModifiers(member) ?? [];
+      const isStatic = modifiers.some((m) => m.kind === ts16.SyntaxKind.StaticKeyword);
       if (isStatic)
         hasStatic = true;
-      const cleanedParams = member.parameters.map((param) => ts15.factory.updateParameterDeclaration(param, ts15.getModifiers(param) ?? [], param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer));
+      const cleanedParams = member.parameters.map((param) => ts16.factory.updateParameterDeclaration(param, ts16.getModifiers(param) ?? [], param.dotDotDotToken, param.name, param.questionToken, param.type, param.initializer));
       let cleaned;
-      if (ts15.isMethodDeclaration(member)) {
-        cleaned = ts15.factory.createMethodDeclaration(modifiers, member.asteriskToken, member.name, member.questionToken, member.typeParameters, cleanedParams, member.type, member.body);
-      } else if (ts15.isGetAccessorDeclaration(member)) {
-        cleaned = ts15.factory.createGetAccessorDeclaration(modifiers, member.name, cleanedParams, member.type, member.body);
+      if (ts16.isMethodDeclaration(member)) {
+        cleaned = ts16.factory.createMethodDeclaration(modifiers, member.asteriskToken, member.name, member.questionToken, member.typeParameters, cleanedParams, member.type, member.body);
+      } else if (ts16.isGetAccessorDeclaration(member)) {
+        cleaned = ts16.factory.createGetAccessorDeclaration(modifiers, member.name, cleanedParams, member.type, member.body);
       } else {
-        cleaned = ts15.factory.createSetAccessorDeclaration(modifiers, member.name, cleanedParams, member.body);
+        cleaned = ts16.factory.createSetAccessorDeclaration(modifiers, member.name, cleanedParams, member.body);
       }
-      const printed = printer.printNode(ts15.EmitHint.Unspecified, cleaned, classNode.getSourceFile());
+      const printed = printer.printNode(ts16.EmitHint.Unspecified, cleaned, classNode.getSourceFile());
       memberSources.push(printed);
     }
   }
@@ -18920,10 +18952,10 @@ ${memberSources.join(`
 }`;
   let transpiled;
   try {
-    transpiled = ts15.transpileModule(wrappedSource, {
+    transpiled = ts16.transpileModule(wrappedSource, {
       compilerOptions: {
-        module: ts15.ModuleKind.ES2022,
-        target: ts15.ScriptTarget.ES2022
+        module: ts16.ModuleKind.ES2022,
+        target: ts16.ScriptTarget.ES2022
       },
       reportDiagnostics: false
     }).outputText;
@@ -18997,7 +19029,7 @@ ${block}
   if (existsSync24(tsconfigPath)) {
     try {
       const text = readFileSync20(tsconfigPath, "utf8");
-      const parsed = ts15.parseConfigFileTextToJson(tsconfigPath, text);
+      const parsed = ts16.parseConfigFileTextToJson(tsconfigPath, text);
       if (!parsed.error && parsed.config) {
         const cfg = parsed.config;
         const ang = cfg.angularCompilerOptions ?? {};
@@ -19031,7 +19063,7 @@ ${block}
     return fail("unexpected-error", `import @angular/compiler: ${err}`);
   }
   const tsSource = readFileSync20(componentFilePath, "utf8");
-  const sourceFile = ts15.createSourceFile(componentFilePath, tsSource, ts15.ScriptTarget.ES2022, true, ts15.ScriptKind.TS);
+  const sourceFile = ts16.createSourceFile(componentFilePath, tsSource, ts16.ScriptTarget.ES2022, true, ts16.ScriptKind.TS);
   const classNode = findClassDeclaration(sourceFile, className);
   if (!classNode) {
     return fail("class-not-found", `${className} in ${componentFilePath}`);
@@ -19158,7 +19190,7 @@ ${block}
     isSignal: (hasSignalIO || advancedMetadata.contentQueries.some((q2) => q2.isSignal) || advancedMetadata.viewQueries.some((q2) => q2.isSignal)) && !hasDecoratorIO && !advancedMetadata.contentQueries.some((q2) => !q2.isSignal) && !advancedMetadata.viewQueries.some((q2) => !q2.isSignal),
     isStandalone: decoratorMeta.standalone,
     lifecycle: {
-      usesOnChanges: classNode.members.some((m) => ts15.isMethodDeclaration(m) && m.name !== undefined && ts15.isIdentifier(m.name) && m.name.text === "ngOnChanges")
+      usesOnChanges: classNode.members.some((m) => ts16.isMethodDeclaration(m) && m.name !== undefined && ts16.isIdentifier(m.name) && m.name.text === "ngOnChanges")
     },
     name: className,
     outputs,
@@ -19207,15 +19239,15 @@ ${block}
     }
     const importGenerator = createHmrImportGenerator(namespaceMap);
     const tsFunctionDecl = translateStatement(sourceFile, callback, importGenerator);
-    const exportedDecl = ts15.factory.updateFunctionDeclaration(tsFunctionDecl, [
-      ts15.factory.createToken(ts15.SyntaxKind.ExportKeyword),
-      ts15.factory.createToken(ts15.SyntaxKind.DefaultKeyword)
+    const exportedDecl = ts16.factory.updateFunctionDeclaration(tsFunctionDecl, [
+      ts16.factory.createToken(ts16.SyntaxKind.ExportKeyword),
+      ts16.factory.createToken(ts16.SyntaxKind.DefaultKeyword)
     ], tsFunctionDecl.asteriskToken, tsFunctionDecl.name, tsFunctionDecl.typeParameters, tsFunctionDecl.parameters, tsFunctionDecl.type, tsFunctionDecl.body);
-    const printer = ts15.createPrinter({
-      newLine: ts15.NewLineKind.LineFeed,
+    const printer = ts16.createPrinter({
+      newLine: ts16.NewLineKind.LineFeed,
       removeComments: false
     });
-    const fnText = printer.printNode(ts15.EmitHint.Unspecified, exportedDecl, sourceFile);
+    const fnText = printer.printNode(ts16.EmitHint.Unspecified, exportedDecl, sourceFile);
     const provisionalMethodsBlock = buildFreshClassMethodsBlock(classNode, className) ?? "";
     const referencedNames = new Set;
     const identRe = /[A-Za-z_$][A-Za-z0-9_$]*/g;
@@ -19225,33 +19257,33 @@ ${block}
     }
     const sourceScopeNames = new Set;
     for (const stmt of sourceFile.statements) {
-      if (ts15.isImportDeclaration(stmt)) {
-        if (!ts15.isStringLiteral(stmt.moduleSpecifier))
+      if (ts16.isImportDeclaration(stmt)) {
+        if (!ts16.isStringLiteral(stmt.moduleSpecifier))
           continue;
         const clause = stmt.importClause;
         if (clause?.name)
           sourceScopeNames.add(clause.name.text);
-        if (clause?.namedBindings && ts15.isNamedImports(clause.namedBindings)) {
+        if (clause?.namedBindings && ts16.isNamedImports(clause.namedBindings)) {
           for (const el of clause.namedBindings.elements) {
             if (el.isTypeOnly)
               continue;
             sourceScopeNames.add(el.name.text);
           }
-        } else if (clause?.namedBindings && ts15.isNamespaceImport(clause.namedBindings)) {
+        } else if (clause?.namedBindings && ts16.isNamespaceImport(clause.namedBindings)) {
           sourceScopeNames.add(clause.namedBindings.name.text);
         }
         continue;
       }
-      if (ts15.isVariableStatement(stmt) || stmt.kind === ts15.SyntaxKind.VariableStatement) {
+      if (ts16.isVariableStatement(stmt) || stmt.kind === ts16.SyntaxKind.VariableStatement) {
         const varStmt = stmt;
         for (const decl of varStmt.declarationList.declarations) {
-          if (ts15.isIdentifier(decl.name)) {
+          if (ts16.isIdentifier(decl.name)) {
             sourceScopeNames.add(decl.name.text);
           }
         }
         continue;
       }
-      if (ts15.isFunctionDeclaration(stmt) || ts15.isClassDeclaration(stmt)) {
+      if (ts16.isFunctionDeclaration(stmt) || ts16.isClassDeclaration(stmt)) {
         if (stmt.name)
           sourceScopeNames.add(stmt.name.text);
       }
@@ -19262,7 +19294,7 @@ ${block}
     }
     const allImportedNames = new Set;
     for (const stmt of sourceFile.statements) {
-      if (!ts15.isImportDeclaration(stmt))
+      if (!ts16.isImportDeclaration(stmt))
         continue;
       const clause = stmt.importClause;
       if (!clause || clause.isTypeOnly)
@@ -19272,7 +19304,7 @@ ${block}
       const bindings = clause.namedBindings;
       if (!bindings)
         continue;
-      if (ts15.isNamespaceImport(bindings)) {
+      if (ts16.isNamespaceImport(bindings)) {
         allImportedNames.add(bindings.name.text);
       } else {
         for (const el of bindings.elements) {
@@ -19284,10 +19316,10 @@ ${block}
     }
     const depsToDestructure = [...sourceScopeNames].filter((n) => referencedNames.has(n) || allImportedNames.has(n));
     const tsSourceText = fnText;
-    const transpiled = ts15.transpileModule(tsSourceText, {
+    const transpiled = ts16.transpileModule(tsSourceText, {
       compilerOptions: {
-        module: ts15.ModuleKind.ES2022,
-        target: ts15.ScriptTarget.ES2022
+        module: ts16.ModuleKind.ES2022,
+        target: ts16.ScriptTarget.ES2022
       },
       fileName: componentFilePath,
       reportDiagnostics: false
@@ -23714,7 +23746,7 @@ __export(exports_resolveOwningComponents, {
 });
 import { readdirSync as readdirSync8, readFileSync as readFileSync26, statSync as statSync5 } from "fs";
 import { dirname as dirname22, extname as extname10, join as join39, resolve as resolve34 } from "path";
-import ts16 from "typescript";
+import ts17 from "typescript";
 var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") || file4.endsWith(".tsx"), walkAngularSourceFiles = (root) => {
   const out = [];
   const visit = (dir) => {
@@ -23740,13 +23772,13 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   return out;
 }, getStringPropertyValue = (obj, name) => {
   for (const prop of obj.properties) {
-    if (!ts16.isPropertyAssignment(prop))
+    if (!ts17.isPropertyAssignment(prop))
       continue;
-    const propName = ts16.isIdentifier(prop.name) || ts16.isStringLiteral(prop.name) ? prop.name.text : null;
+    const propName = ts17.isIdentifier(prop.name) || ts17.isStringLiteral(prop.name) ? prop.name.text : null;
     if (propName !== name)
       continue;
     const init = prop.initializer;
-    if (ts16.isStringLiteral(init) || ts16.isNoSubstitutionTemplateLiteral(init)) {
+    if (ts17.isStringLiteral(init) || ts17.isNoSubstitutionTemplateLiteral(init)) {
       return init.text;
     }
   }
@@ -23754,16 +23786,16 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
 }, getStringArrayProperty = (obj, name) => {
   const out = [];
   for (const prop of obj.properties) {
-    if (!ts16.isPropertyAssignment(prop))
+    if (!ts17.isPropertyAssignment(prop))
       continue;
-    const propName = ts16.isIdentifier(prop.name) || ts16.isStringLiteral(prop.name) ? prop.name.text : null;
+    const propName = ts17.isIdentifier(prop.name) || ts17.isStringLiteral(prop.name) ? prop.name.text : null;
     if (propName !== name)
       continue;
     const init = prop.initializer;
-    if (!ts16.isArrayLiteralExpression(init))
+    if (!ts17.isArrayLiteralExpression(init))
       continue;
     for (const element of init.elements) {
-      if (ts16.isStringLiteral(element) || ts16.isNoSubstitutionTemplateLiteral(element)) {
+      if (ts17.isStringLiteral(element) || ts17.isNoSubstitutionTemplateLiteral(element)) {
         out.push(element.text);
       }
     }
@@ -23776,27 +23808,27 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   } catch {
     return [];
   }
-  const sourceFile = ts16.createSourceFile(filePath, source, ts16.ScriptTarget.ES2022, true, ts16.ScriptKind.TS);
+  const sourceFile = ts17.createSourceFile(filePath, source, ts17.ScriptTarget.ES2022, true, ts17.ScriptKind.TS);
   const out = [];
   const visit = (node) => {
-    if (ts16.isClassDeclaration(node) && node.name) {
-      for (const decorator of ts16.getDecorators(node) ?? []) {
+    if (ts17.isClassDeclaration(node) && node.name) {
+      for (const decorator of ts17.getDecorators(node) ?? []) {
         const expr = decorator.expression;
-        if (!ts16.isCallExpression(expr))
+        if (!ts17.isCallExpression(expr))
           continue;
         const fn2 = expr.expression;
-        if (!ts16.isIdentifier(fn2))
+        if (!ts17.isIdentifier(fn2))
           continue;
         const kind = ENTITY_DECORATORS[fn2.text];
         if (!kind)
           continue;
         let extendsName = null;
         for (const heritage of node.heritageClauses ?? []) {
-          if (heritage.token !== ts16.SyntaxKind.ExtendsKeyword) {
+          if (heritage.token !== ts17.SyntaxKind.ExtendsKeyword) {
             continue;
           }
           const first = heritage.types[0];
-          if (first && ts16.isIdentifier(first.expression)) {
+          if (first && ts17.isIdentifier(first.expression)) {
             extendsName = first.expression.text;
           }
           break;
@@ -23809,7 +23841,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
           templateUrls: []
         };
         const arg = expr.arguments[0];
-        if (arg && ts16.isObjectLiteralExpression(arg) && kind === "component") {
+        if (arg && ts17.isObjectLiteralExpression(arg) && kind === "component") {
           const tplUrl = getStringPropertyValue(arg, "templateUrl");
           if (tplUrl)
             entry.templateUrls.push(tplUrl);
@@ -23822,7 +23854,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
         break;
       }
     }
-    ts16.forEachChild(node, visit);
+    ts17.forEachChild(node, visit);
   };
   visit(sourceFile);
   return out;
@@ -23866,12 +23898,12 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
   } catch {
     return null;
   }
-  const sf = ts16.createSourceFile(childFilePath, source, ts16.ScriptTarget.ES2022, true, ts16.ScriptKind.TS);
+  const sf = ts17.createSourceFile(childFilePath, source, ts17.ScriptTarget.ES2022, true, ts17.ScriptKind.TS);
   const childDir = dirname22(childFilePath);
   for (const stmt of sf.statements) {
-    if (!ts16.isImportDeclaration(stmt))
+    if (!ts17.isImportDeclaration(stmt))
       continue;
-    if (!ts16.isStringLiteral(stmt.moduleSpecifier))
+    if (!ts17.isStringLiteral(stmt.moduleSpecifier))
       continue;
     const clause = stmt.importClause;
     if (!clause || clause.isTypeOnly)
@@ -23879,7 +23911,7 @@ var ENTITY_DECORATORS, isAngularSourceFile = (file4) => file4.endsWith(".ts") ||
     let matchesName = false;
     if (clause.name && clause.name.text === parentName)
       matchesName = true;
-    if (!matchesName && clause.namedBindings && ts16.isNamedImports(clause.namedBindings)) {
+    if (!matchesName && clause.namedBindings && ts17.isNamedImports(clause.namedBindings)) {
       for (const el of clause.namedBindings.elements) {
         if (el.isTypeOnly)
           continue;
@@ -28649,5 +28681,5 @@ export {
   build
 };
 
-//# debugId=859150DBEA0DAF0064756E2164756E21
+//# debugId=2419EDD21F53931564756E2164756E21
 //# sourceMappingURL=build.js.map