@absolutejs/absolute 0.19.0-beta.853 → 0.19.0-beta.855

package/dist/build.js

@@ -11489,26 +11489,7 @@ var traceAngularPhase = async (name, fn2, metadata) => {
   if (existsSync16(fromNodeModules))
     return fromNodeModules;
   return resolve17(import.meta.dir, "./dev/client");
-}, devClientDir4, hmrClientPath5, hmrRuntimePath, injectHMRRegistration = (content, sourceId) => {
-  const entityClassRegex = /(?:export\s+)?class\s+(\w+(?:Component|Service|Directive|Pipe))\s/g;
-  const entityNames = [];
-  let match;
-  while ((match = entityClassRegex.exec(content)) !== null) {
-    if (match[1])
-      entityNames.push(match[1]);
-  }
-  if (entityNames.length === 0)
-    return content;
-  const registrations = entityNames.map((name) => `  if (typeof ${name} === 'function') window.__ANGULAR_HMR__.register('${sourceId}#${name}', ${name});`).join(`
-`);
-  const hmrBlock = `
-// Angular HMR Runtime Layer (Level 3) \u2014 Auto-registration
-if (typeof window !== 'undefined' && window.__ANGULAR_HMR__) {
-${registrations}
-}
-`;
-  return content + hmrBlock;
-}, formatDiagnosticMessage = (diagnostic) => {
+}, devClientDir4, hmrClientPath5, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts2.flattenDiagnosticMessageText(diagnostic.messageText, `
 `);
@@ -12331,14 +12312,10 @@ export default ${componentClassName};
 export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
 `;
     }
-    if (hmr) {
-      rewritten = injectHMRRegistration(rewritten, resolvedEntry);
-    }
     await traceAngularPhase("wrapper/write-server-output", () => fs.writeFile(rawServerFile, rewritten, "utf-8"), { entry: resolvedEntry });
     const relativePath = relative10(indexesDir, rawServerFile).replace(/\\/g, "/");
     const normalizedImportPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
     const hmrPreamble = hmr ? `window.__HMR_FRAMEWORK__ = "angular";
-import "${hmrRuntimePath}";
 import "${hmrClientPath5}";
 ` : "";
     const hydration = hmr ? `${hmrPreamble}
@@ -12380,68 +12357,66 @@ var absoluteHttpTransferCacheOptions = {
     }
 };
 
-// Re-export the page module so HMR fast-patch (in handlers/angular.ts) can
-// dynamically import this chunk and discover the freshly-built component
-// classes without needing a separate build artifact.
-export * from '${normalizedImportPath}';
+// SURGICAL_HMR Tier 1 \u2014 Re-bootstrap hook. The dev client invokes
+// \`window.__ABS_ANGULAR_REBOOTSTRAP__()\` when it receives an
+// \`angular:rebootstrap\` WS message; the hook looks up this page's
+// freshly-built bundle URL (the rebuild already broadcast its
+// updated manifest, so window.__HMR_MANIFEST__ is current) and
+// dynamic-imports it. Re-importing the chunk re-runs the
+// destroy+bootstrap block below \u2014 no special path needed because
+// chunk eval is the bootstrap.
+window.__ABS_ANGULAR_PAGE_BUNDLE_ID__ = '${toPascal(fileBase)}Index';
+window.__ABS_ANGULAR_REBOOTSTRAP__ = async function() {
+    var id = window.__ABS_ANGULAR_PAGE_BUNDLE_ID__;
+    var manifest = window.__HMR_MANIFEST__ || {};
+    var newUrl = manifest[id];
+    if (!newUrl) {
+        console.warn('[absolutejs] no bundle URL in manifest for', id, '\u2014 full reload');
+        window.location.reload();
+        return;
+    }
+    await import(newUrl + '?t=' + Date.now());
+};
 
-// Record this evaluation's \`routes\` and \`providers\` exports for the
-// HMR fast-patch to compare against on the next reload. If they change
-// (a new route was added, a provider was edited), fast-patch falls back
-// to a full re-bootstrap because those values are consumed once at
-// bootstrap and won't propagate to the running router/injector via an
-// in-place component patch.
-if (typeof window !== 'undefined' && window.__ANGULAR_HMR__ && typeof window.__ANGULAR_HMR__.recordPageExports === 'function') {
-    var __abs_hmr_routes = Reflect.get(pageModule, 'routes');
-    window.__ANGULAR_HMR__.recordPageExports('${resolvedEntry}', __abs_hmr_routes, maybePageProviders);
+if (window.__ANGULAR_APP__) {
+    try { window.__ANGULAR_APP__.destroy(); } catch (_err) { /* ignore */ }
+    window.__ANGULAR_APP__ = null;
 }
 
-// Re-Bootstrap HMR with View Transitions API.
-// Skipped during fast-patch: the HMR client sets
-// window.__ANGULAR_HMR_FAST_PATCH__ = true before \`import()\`-ing this
-// chunk so it can read the new component classes via \`export *\` above
-// without destroying the running app.
-if (!window.__ANGULAR_HMR_FAST_PATCH__) {
-    if (window.__ANGULAR_APP__) {
-        try { window.__ANGULAR_APP__.destroy(); } catch (_err) { /* ignore */ }
-        window.__ANGULAR_APP__ = null;
-    }
-
-    // Ensure root element exists after destroy (Angular removes it)
-    var _sel = ${componentClassName}.\u0275cmp?.selectors?.[0]?.[0] || 'ng-app';
-    if (!document.querySelector(_sel)) {
-        (document.getElementById('root') || document.body).appendChild(document.createElement(_sel));
-    }
+// Ensure root element exists after destroy (Angular removes it)
+var _sel = ${componentClassName}.\u0275cmp?.selectors?.[0]?.[0] || 'ng-app';
+if (!document.querySelector(_sel)) {
+    (document.getElementById('root') || document.body).appendChild(document.createElement(_sel));
+}
 
-    var providers = [provideZonelessChangeDetection()];
-    if (!window.__HMR_SKIP_HYDRATION__ && !pageHasIslands) {
-        providers.push(provideClientHydration(withHttpTransferCacheOptions(absoluteHttpTransferCacheOptions)));
-    }
-    delete window.__HMR_SKIP_HYDRATION__;
-    providers.push.apply(providers, pageProviders);
-    providers.push.apply(providers, propProviders);
-    window.__ABS_SLOT_HYDRATION_PENDING__ = pageHasRawStreamingSlots;
+var providers = [provideZonelessChangeDetection()];
+if (!window.__HMR_SKIP_HYDRATION__ && !pageHasIslands) {
+    providers.push(provideClientHydration(withHttpTransferCacheOptions(absoluteHttpTransferCacheOptions)));
+}
+delete window.__HMR_SKIP_HYDRATION__;
+providers.push.apply(providers, pageProviders);
+providers.push.apply(providers, propProviders);
+window.__ABS_SLOT_HYDRATION_PENDING__ = pageHasRawStreamingSlots;
 
-    if (pageHasRawStreamingSlots) {
+if (pageHasRawStreamingSlots) {
+    window.__ABS_SLOT_HYDRATION_PENDING__ = false;
+    if (typeof window.__ABS_SLOT_FLUSH__ === 'function') {
+        requestAnimationFrame(function() {
+            window.__ABS_SLOT_FLUSH__();
+        });
+    }
+} else {
+    bootstrapApplication(${componentClassName}, {
+        providers: providers
+    }).then(function (appRef) {
+        window.__ANGULAR_APP__ = appRef;
         window.__ABS_SLOT_HYDRATION_PENDING__ = false;
         if (typeof window.__ABS_SLOT_FLUSH__ === 'function') {
             requestAnimationFrame(function() {
                 window.__ABS_SLOT_FLUSH__();
             });
         }
-    } else {
-        bootstrapApplication(${componentClassName}, {
-            providers: providers
-        }).then(function (appRef) {
-            window.__ANGULAR_APP__ = appRef;
-            window.__ABS_SLOT_HYDRATION_PENDING__ = false;
-            if (typeof window.__ABS_SLOT_FLUSH__ === 'function') {
-                requestAnimationFrame(function() {
-                    window.__ABS_SLOT_FLUSH__();
-                });
-            }
-        });
-    }
+    });
 }
 `.trim() : `
 import '@angular/compiler';
@@ -12543,7 +12518,6 @@ var init_compileAngular = __esm(() => {
   init_generatedDir();
   devClientDir4 = resolveDevClientDir4();
   hmrClientPath5 = join17(devClientDir4, "hmrClient.ts").replace(/\\/g, "/");
-  hmrRuntimePath = join17(devClientDir4, "handlers", "angularRuntime.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
@@ -16607,247 +16581,6 @@ var init_ssrCache = __esm(() => {
   dirtyFrameworks = new Set;
 });
 
-// src/dev/angular/editTypeDetection.ts
-import { readFileSync as readFileSync17 } from "fs";
-import { basename as basename10 } from "path";
-import * as ts3 from "typescript";
-var TYPE_PRIORITY, STYLE_EXT_RE, COMPONENT_STYLE_RE, TEMPLATE_RE, COMPONENT_CLASS_RE, SERVICE_RE, ROUTES_RE, PAGE_TS_RE, SIDE_EFFECT_CALL_NAMES, SIDE_EFFECT_NEW_NAMES, getCalleeName = (node) => {
-  const callee = node.expression;
-  if (ts3.isIdentifier(callee))
-    return callee.text;
-  if (ts3.isPropertyAccessExpression(callee))
-    return callee.name.text;
-  return null;
-}, getNewExprName = (node) => {
-  const callee = node.expression;
-  if (ts3.isIdentifier(callee))
-    return callee.text;
-  if (ts3.isPropertyAccessExpression(callee))
-    return callee.name.text;
-  return null;
-}, collectMethodBodies = (cls) => {
-  const methods = new Map;
-  cls.members.forEach((member) => {
-    if (!member.name || !ts3.isIdentifier(member.name))
-      return;
-    if (ts3.isMethodDeclaration(member) && member.body) {
-      methods.set(member.name.text, member.body);
-      return;
-    }
-    if (ts3.isPropertyDeclaration(member) && member.initializer) {
-      const init = member.initializer;
-      if (ts3.isArrowFunction(init) || ts3.isFunctionExpression(init)) {
-        methods.set(member.name.text, init.body);
-      }
-    }
-  });
-  return methods;
-}, findSideEffectInBody = (body, methods, visited) => {
-  let hit = { found: false };
-  const walk = (node) => {
-    if (hit.found)
-      return;
-    if (ts3.isCallExpression(node)) {
-      const name = getCalleeName(node);
-      if (name && SIDE_EFFECT_CALL_NAMES.has(name)) {
-        hit = {
-          found: true,
-          reason: `constructor invokes ${name}(...)`
-        };
-        return;
-      }
-      if (name && methods.has(name) && !visited.has(name)) {
-        visited.add(name);
-        const target = methods.get(name);
-        if (target) {
-          const inner = findSideEffectInBody(target, methods, visited);
-          if (inner.found) {
-            hit = {
-              found: true,
-              reason: `${inner.reason} (via this.${name}())`
-            };
-            return;
-          }
-        }
-      }
-    }
-    if (ts3.isNewExpression(node)) {
-      const name = getNewExprName(node);
-      if (name && SIDE_EFFECT_NEW_NAMES.has(name)) {
-        hit = {
-          found: true,
-          reason: `constructor instantiates new ${name}(...)`
-        };
-        return;
-      }
-    }
-    ts3.forEachChild(node, walk);
-  };
-  walk(body);
-  return hit;
-}, analyzeServiceFile = (file4) => {
-  let source;
-  try {
-    source = readFileSync17(file4, "utf8");
-  } catch {
-    return {
-      hasSideEffectCtor: true,
-      reason: "service file unreadable \u2014 defaulting to reboot"
-    };
-  }
-  const sf = ts3.createSourceFile(file4, source, ts3.ScriptTarget.Latest, true);
-  let result = {
-    hasSideEffectCtor: false,
-    reason: "constructor has no side-effecting calls"
-  };
-  const visit = (node) => {
-    if (result.hasSideEffectCtor)
-      return;
-    if (!ts3.isClassDeclaration(node)) {
-      ts3.forEachChild(node, visit);
-      return;
-    }
-    const methods = collectMethodBodies(node);
-    const ctor = node.members.find(ts3.isConstructorDeclaration);
-    const targets = [];
-    if (ctor?.body)
-      targets.push(ctor.body);
-    node.members.forEach((member) => {
-      if (ts3.isPropertyDeclaration(member) && member.initializer) {
-        targets.push(member.initializer);
-      }
-    });
-    for (const target of targets) {
-      const r = findSideEffectInBody(target, methods, new Set);
-      if (r.found) {
-        result = { hasSideEffectCtor: true, reason: r.reason };
-        break;
-      }
-    }
-    if (!result.hasSideEffectCtor)
-      ts3.forEachChild(node, visit);
-  };
-  visit(sf);
-  return result;
-}, classifyAngularEdit = (file4) => {
-  const base = basename10(file4);
-  if (TEMPLATE_RE.test(file4)) {
-    return {
-      type: "template",
-      reason: `${base} \u2014 template edit`,
-      sourceFile: file4
-    };
-  }
-  if (COMPONENT_STYLE_RE.test(file4)) {
-    return {
-      type: "style-component",
-      reason: `${base} \u2014 component-scoped stylesheet edit`,
-      sourceFile: file4
-    };
-  }
-  if (STYLE_EXT_RE.test(file4)) {
-    return {
-      type: "reboot",
-      reason: `${base} \u2014 non-component-named stylesheet, falling back to reboot until scoping is verified`,
-      sourceFile: file4
-    };
-  }
-  if (ROUTES_RE.test(file4)) {
-    return {
-      type: "route",
-      reason: `${base} \u2014 router config, requires reboot`,
-      sourceFile: file4
-    };
-  }
-  if (SERVICE_RE.test(file4)) {
-    const a = analyzeServiceFile(file4);
-    if (a.hasSideEffectCtor) {
-      return {
-        type: "service-with-side-effects",
-        reason: `${base} \u2014 ${a.reason}`,
-        sourceFile: file4
-      };
-    }
-    return {
-      type: "service-method-only",
-      reason: `${base} \u2014 ${a.reason}`,
-      sourceFile: file4
-    };
-  }
-  if (COMPONENT_CLASS_RE.test(file4)) {
-    return {
-      type: "class-component",
-      reason: `${base} \u2014 component class edit`,
-      sourceFile: file4
-    };
-  }
-  if (PAGE_TS_RE.test(file4)) {
-    return {
-      type: "class-component",
-      reason: `${base} \u2014 page component edit`,
-      sourceFile: file4
-    };
-  }
-  return {
-    type: "reboot",
-    reason: `${base} \u2014 unrecognized angular file type, falling back to reboot`,
-    sourceFile: file4
-  };
-}, collapseClassifications = (classifications) => {
-  if (classifications.length === 0) {
-    return {
-      type: "reboot",
-      reason: "no classifiable files in batch",
-      sourceFile: ""
-    };
-  }
-  let winner = classifications[0];
-  for (let i = 1;i < classifications.length; i++) {
-    const candidate = classifications[i];
-    if (TYPE_PRIORITY[candidate.type] > TYPE_PRIORITY[winner.type]) {
-      winner = candidate;
-    }
-  }
-  return winner;
-};
-var init_editTypeDetection = __esm(() => {
-  TYPE_PRIORITY = {
-    template: 0,
-    "style-component": 1,
-    "service-method-only": 2,
-    "class-component": 3,
-    "service-with-side-effects": 4,
-    route: 5,
-    reboot: 6
-  };
-  STYLE_EXT_RE = /\.(css|scss|sass|less|styl|stylus|pcss|postcss)$/i;
-  COMPONENT_STYLE_RE = /\.component\.(css|scss|sass|less|styl|stylus|pcss|postcss)$/i;
-  TEMPLATE_RE = /\.html$/i;
-  COMPONENT_CLASS_RE = /\.component\.ts$/i;
-  SERVICE_RE = /\.service\.ts$/i;
-  ROUTES_RE = /(?:^|[\\/])(?:app\.)?routes\.ts$/i;
-  PAGE_TS_RE = /(?:^|[\\/])pages[\\/][^\\/]+\.ts$/i;
-  SIDE_EFFECT_CALL_NAMES = new Set([
-    "subscribe",
-    "setInterval",
-    "setTimeout",
-    "addEventListener",
-    "effect",
-    "afterNextRender",
-    "afterRender",
-    "afterEveryRender",
-    "requestAnimationFrame",
-    "requestIdleCallback"
-  ]);
-  SIDE_EFFECT_NEW_NAMES = new Set([
-    "Worker",
-    "SharedWorker",
-    "EventSource",
-    "WebSocket",
-    "BroadcastChannel"
-  ]);
-});
-
 // src/dev/moduleServer.ts
 var exports_moduleServer = {};
 __export(exports_moduleServer, {
@@ -16859,8 +16592,8 @@ __export(exports_moduleServer, {
   createModuleServer: () => createModuleServer,
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
-import { existsSync as existsSync24, readFileSync as readFileSync18, statSync as statSync2 } from "fs";
-import { basename as basename11, dirname as dirname16, extname as extname8, join as join27, resolve as resolve29, relative as relative12 } from "path";
+import { existsSync as existsSync24, readFileSync as readFileSync17, statSync as statSync2 } from "fs";
+import { basename as basename10, dirname as dirname16, extname as extname8, join as join27, resolve as resolve29, relative as relative12 } from "path";
 var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPILABLE, ALL_EXPORTS_RE, STRING_CONTENTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
   const codeOnly = originalSource.replace(STRING_CONTENTS_RE, '""');
   const allExports = [];
@@ -16932,7 +16665,7 @@ ${stubs}
         const pkgDir = resolve29(projectRoot, "node_modules", packageName ?? "");
         const pkgJsonPath = join27(pkgDir, "package.json");
         if (existsSync24(pkgJsonPath)) {
-          const pkg = JSON.parse(readFileSync18(pkgJsonPath, "utf-8"));
+          const pkg = JSON.parse(readFileSync17(pkgJsonPath, "utf-8"));
           const esmEntry = typeof pkg.module === "string" && pkg.module || typeof pkg.browser === "string" && pkg.browser;
           if (esmEntry) {
             const resolved = resolve29(pkgDir, esmEntry);
@@ -17031,7 +16764,7 @@ ${code}`;
   reactFastRefreshWarningEmitted = true;
   logWarn("React HMR is blocked: this Bun build ignores " + "`reactFastRefresh` on Bun.Transpiler, so component state " + "cannot be preserved across edits. Tracking " + "https://github.com/oven-sh/bun/pull/28312 \u2014 if it still has " + "not merged, leave a \uD83D\uDC4D on the PR so the Bun team knows it " + "is blocking you. Until then, React edits trigger a full " + "reload instead of a fast refresh.");
 }, transformReactFile = (filePath, projectRoot, rewriter) => {
-  const raw = readFileSync18(filePath, "utf-8");
+  const raw = readFileSync17(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
   transpiled = preserveTypeExports(raw, transpiled, valueExports);
@@ -17047,7 +16780,7 @@ ${transpiled}`;
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports(transpiled, filePath, projectRoot, rewriter);
 }, transformPlainFile = (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync18(filePath, "utf-8");
+  const raw = readFileSync17(filePath, "utf-8");
   const ext = extname8(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
@@ -17213,7 +16946,7 @@ ${code}`;
 ` + `  var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleUrl)}] = cb; };`);
   return code.replace(/import\.meta\.hot\.accept\(/g, "__hmr_accept(");
 }, transformSvelteFile = async (filePath, projectRoot, rewriter, stylePreprocessors) => {
-  const raw = readFileSync18(filePath, "utf-8");
+  const raw = readFileSync17(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
@@ -17273,12 +17006,12 @@ export default __script__;`;
   return `${cssInjection}
 ${code}`;
 }, transformVueFile = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const rawSource = readFileSync18(filePath, "utf-8");
+  const rawSource = readFileSync17(filePath, "utf-8");
   const raw = addAutoRouterSetupApp(rawSource);
   if (!vueCompiler) {
     vueCompiler = await import("@vue/compiler-sfc");
   }
-  const fileName = basename11(filePath, ".vue");
+  const fileName = basename10(filePath, ".vue");
   const componentId = fileName.toLowerCase();
   const { descriptor } = vueCompiler.parse(raw, { filename: filePath });
   const hasScript = descriptor.script || descriptor.scriptSetup;
@@ -17328,7 +17061,7 @@ ${code}`;
     }
   });
 }, handleCssRequest = (filePath) => {
-  const raw = readFileSync18(filePath, "utf-8");
+  const raw = readFileSync17(filePath, "utf-8");
   const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return [
     `const style = document.createElement('style');`,
@@ -17653,9 +17386,9 @@ var exports_resolveOwningComponents = {};
 __export(exports_resolveOwningComponents, {
   resolveOwningComponents: () => resolveOwningComponents
 });
-import { readdirSync as readdirSync2, readFileSync as readFileSync19, statSync as statSync3 } from "fs";
+import { readdirSync as readdirSync2, readFileSync as readFileSync18, statSync as statSync3 } from "fs";
 import { dirname as dirname17, extname as extname9, join as join28, resolve as resolve30 } from "path";
-import ts4 from "typescript";
+import ts3 from "typescript";
 var isComponentTsFile = (file4) => file4.endsWith(".component.ts") || file4.endsWith(".component.tsx"), walkComponentTsFiles = (root) => {
   const out = [];
   const visit = (dir) => {
@@ -17681,13 +17414,13 @@ var isComponentTsFile = (file4) => file4.endsWith(".component.ts") || file4.ends
   return out;
 }, getStringPropertyValue = (obj, name) => {
   for (const prop of obj.properties) {
-    if (!ts4.isPropertyAssignment(prop))
+    if (!ts3.isPropertyAssignment(prop))
       continue;
-    const propName = ts4.isIdentifier(prop.name) ? prop.name.text : ts4.isStringLiteral(prop.name) ? prop.name.text : null;
+    const propName = ts3.isIdentifier(prop.name) ? prop.name.text : ts3.isStringLiteral(prop.name) ? prop.name.text : null;
     if (propName !== name)
       continue;
     const init = prop.initializer;
-    if (ts4.isStringLiteral(init) || ts4.isNoSubstitutionTemplateLiteral(init)) {
+    if (ts3.isStringLiteral(init) || ts3.isNoSubstitutionTemplateLiteral(init)) {
       return init.text;
     }
   }
@@ -17695,16 +17428,16 @@ var isComponentTsFile = (file4) => file4.endsWith(".component.ts") || file4.ends
 }, getStringArrayProperty = (obj, name) => {
   const out = [];
   for (const prop of obj.properties) {
-    if (!ts4.isPropertyAssignment(prop))
+    if (!ts3.isPropertyAssignment(prop))
       continue;
-    const propName = ts4.isIdentifier(prop.name) ? prop.name.text : ts4.isStringLiteral(prop.name) ? prop.name.text : null;
+    const propName = ts3.isIdentifier(prop.name) ? prop.name.text : ts3.isStringLiteral(prop.name) ? prop.name.text : null;
     if (propName !== name)
       continue;
     const init = prop.initializer;
-    if (!ts4.isArrayLiteralExpression(init))
+    if (!ts3.isArrayLiteralExpression(init))
       continue;
     for (const element of init.elements) {
-      if (ts4.isStringLiteral(element) || ts4.isNoSubstitutionTemplateLiteral(element)) {
+      if (ts3.isStringLiteral(element) || ts3.isNoSubstitutionTemplateLiteral(element)) {
         out.push(element.text);
       }
     }
@@ -17718,24 +17451,24 @@ var isComponentTsFile = (file4) => file4.endsWith(".component.ts") || file4.ends
   };
   let source;
   try {
-    source = readFileSync19(filePath, "utf8");
+    source = readFileSync18(filePath, "utf8");
   } catch {
     return refs;
   }
-  const sourceFile = ts4.createSourceFile(filePath, source, ts4.ScriptTarget.ES2022, true, ts4.ScriptKind.TS);
+  const sourceFile = ts3.createSourceFile(filePath, source, ts3.ScriptTarget.ES2022, true, ts3.ScriptKind.TS);
   const visit = (node) => {
-    if (ts4.isClassDeclaration(node) && node.name) {
-      const decorators = ts4.getDecorators(node) ?? [];
+    if (ts3.isClassDeclaration(node) && node.name) {
+      const decorators = ts3.getDecorators(node) ?? [];
       for (const decorator of decorators) {
         const expr = decorator.expression;
-        if (!ts4.isCallExpression(expr))
+        if (!ts3.isCallExpression(expr))
           continue;
         const fn2 = expr.expression;
-        if (!ts4.isIdentifier(fn2) || fn2.text !== "Component")
+        if (!ts3.isIdentifier(fn2) || fn2.text !== "Component")
           continue;
         refs.classNames.push(node.name.text);
         const arg = expr.arguments[0];
-        if (!arg || !ts4.isObjectLiteralExpression(arg))
+        if (!arg || !ts3.isObjectLiteralExpression(arg))
           continue;
         const tplUrl = getStringPropertyValue(arg, "templateUrl");
         if (tplUrl)
@@ -17746,7 +17479,7 @@ var isComponentTsFile = (file4) => file4.endsWith(".component.ts") || file4.ends
         refs.styleUrls.push(...getStringArrayProperty(arg, "styleUrls"));
       }
     }
-    ts4.forEachChild(node, visit);
+    ts3.forEachChild(node, visit);
   };
   visit(sourceFile);
   return refs;
@@ -17795,18 +17528,18 @@ var isComponentTsFile = (file4) => file4.endsWith(".component.ts") || file4.ends
 var init_resolveOwningComponents = () => {};
 
 // src/dev/angular/hmrImportGenerator.ts
-import ts5 from "typescript";
+import ts4 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 = ts5.factory.createIdentifier(ns);
+    const namespaceId = ts4.factory.createIdentifier(ns);
     if (request.exportSymbolName === null) {
       return namespaceId;
     }
-    return ts5.factory.createPropertyAccessExpression(namespaceId, ts5.factory.createIdentifier(request.exportSymbolName));
+    return ts4.factory.createPropertyAccessExpression(namespaceId, ts4.factory.createIdentifier(request.exportSymbolName));
   }
 });
 var init_hmrImportGenerator = () => {};
@@ -18148,13 +17881,13 @@ var init_translator = __esm(() => {
 });
 
 // src/dev/angular/vendor/translator/ts_util.ts
-import ts6 from "typescript";
+import ts5 from "typescript";
 function tsNumericExpression(value) {
   if (value < 0) {
-    const operand = ts6.factory.createNumericLiteral(Math.abs(value));
-    return ts6.factory.createPrefixUnaryExpression(ts6.SyntaxKind.MinusToken, operand);
+    const operand = ts5.factory.createNumericLiteral(Math.abs(value));
+    return ts5.factory.createPrefixUnaryExpression(ts5.SyntaxKind.MinusToken, operand);
   }
-  return ts6.factory.createNumericLiteral(value);
+  return ts5.factory.createNumericLiteral(value);
 }
 var init_ts_util = __esm(() => {
   /*!
@@ -18167,147 +17900,147 @@ var init_ts_util = __esm(() => {
 });
 
 // src/dev/angular/vendor/translator/typescript_ast_factory.ts
-import ts7 from "typescript";
+import ts6 from "typescript";
 
 class TypeScriptAstFactory {
   annotateForClosureCompiler;
   externalSourceFiles = new Map;
   UNARY_OPERATORS = /* @__PURE__ */ (() => ({
-    "+": ts7.SyntaxKind.PlusToken,
-    "-": ts7.SyntaxKind.MinusToken,
-    "!": ts7.SyntaxKind.ExclamationToken
+    "+": ts6.SyntaxKind.PlusToken,
+    "-": ts6.SyntaxKind.MinusToken,
+    "!": ts6.SyntaxKind.ExclamationToken
   }))();
   BINARY_OPERATORS = /* @__PURE__ */ (() => ({
-    "&&": ts7.SyntaxKind.AmpersandAmpersandToken,
-    ">": ts7.SyntaxKind.GreaterThanToken,
-    ">=": ts7.SyntaxKind.GreaterThanEqualsToken,
-    "&": ts7.SyntaxKind.AmpersandToken,
-    "|": ts7.SyntaxKind.BarToken,
-    "/": ts7.SyntaxKind.SlashToken,
-    "==": ts7.SyntaxKind.EqualsEqualsToken,
-    "===": ts7.SyntaxKind.EqualsEqualsEqualsToken,
-    "<": ts7.SyntaxKind.LessThanToken,
-    "<=": ts7.SyntaxKind.LessThanEqualsToken,
-    "-": ts7.SyntaxKind.MinusToken,
-    "%": ts7.SyntaxKind.PercentToken,
-    "*": ts7.SyntaxKind.AsteriskToken,
-    "**": ts7.SyntaxKind.AsteriskAsteriskToken,
-    "!=": ts7.SyntaxKind.ExclamationEqualsToken,
-    "!==": ts7.SyntaxKind.ExclamationEqualsEqualsToken,
-    "||": ts7.SyntaxKind.BarBarToken,
-    "+": ts7.SyntaxKind.PlusToken,
-    "??": ts7.SyntaxKind.QuestionQuestionToken,
-    "=": ts7.SyntaxKind.EqualsToken,
-    "+=": ts7.SyntaxKind.PlusEqualsToken,
-    "-=": ts7.SyntaxKind.MinusEqualsToken,
-    "*=": ts7.SyntaxKind.AsteriskEqualsToken,
-    "/=": ts7.SyntaxKind.SlashEqualsToken,
-    "%=": ts7.SyntaxKind.PercentEqualsToken,
-    "**=": ts7.SyntaxKind.AsteriskAsteriskEqualsToken,
-    "&&=": ts7.SyntaxKind.AmpersandAmpersandEqualsToken,
-    "||=": ts7.SyntaxKind.BarBarEqualsToken,
-    "??=": ts7.SyntaxKind.QuestionQuestionEqualsToken,
-    in: ts7.SyntaxKind.InKeyword,
-    instanceof: ts7.SyntaxKind.InstanceOfKeyword
+    "&&": ts6.SyntaxKind.AmpersandAmpersandToken,
+    ">": ts6.SyntaxKind.GreaterThanToken,
+    ">=": ts6.SyntaxKind.GreaterThanEqualsToken,
+    "&": ts6.SyntaxKind.AmpersandToken,
+    "|": ts6.SyntaxKind.BarToken,
+    "/": ts6.SyntaxKind.SlashToken,
+    "==": ts6.SyntaxKind.EqualsEqualsToken,
+    "===": ts6.SyntaxKind.EqualsEqualsEqualsToken,
+    "<": ts6.SyntaxKind.LessThanToken,
+    "<=": ts6.SyntaxKind.LessThanEqualsToken,
+    "-": ts6.SyntaxKind.MinusToken,
+    "%": ts6.SyntaxKind.PercentToken,
+    "*": ts6.SyntaxKind.AsteriskToken,
+    "**": ts6.SyntaxKind.AsteriskAsteriskToken,
+    "!=": ts6.SyntaxKind.ExclamationEqualsToken,
+    "!==": ts6.SyntaxKind.ExclamationEqualsEqualsToken,
+    "||": ts6.SyntaxKind.BarBarToken,
+    "+": ts6.SyntaxKind.PlusToken,
+    "??": ts6.SyntaxKind.QuestionQuestionToken,
+    "=": ts6.SyntaxKind.EqualsToken,
+    "+=": ts6.SyntaxKind.PlusEqualsToken,
+    "-=": ts6.SyntaxKind.MinusEqualsToken,
+    "*=": ts6.SyntaxKind.AsteriskEqualsToken,
+    "/=": ts6.SyntaxKind.SlashEqualsToken,
+    "%=": ts6.SyntaxKind.PercentEqualsToken,
+    "**=": ts6.SyntaxKind.AsteriskAsteriskEqualsToken,
+    "&&=": ts6.SyntaxKind.AmpersandAmpersandEqualsToken,
+    "||=": ts6.SyntaxKind.BarBarEqualsToken,
+    "??=": ts6.SyntaxKind.QuestionQuestionEqualsToken,
+    in: ts6.SyntaxKind.InKeyword,
+    instanceof: ts6.SyntaxKind.InstanceOfKeyword
   }))();
   VAR_TYPES = /* @__PURE__ */ (() => ({
-    const: ts7.NodeFlags.Const,
-    let: ts7.NodeFlags.Let,
-    var: ts7.NodeFlags.None
+    const: ts6.NodeFlags.Const,
+    let: ts6.NodeFlags.Let,
+    var: ts6.NodeFlags.None
   }))();
   constructor(annotateForClosureCompiler) {
     this.annotateForClosureCompiler = annotateForClosureCompiler;
   }
   attachComments = attachComments;
-  createArrayLiteral = ts7.factory.createArrayLiteralExpression;
+  createArrayLiteral = ts6.factory.createArrayLiteralExpression;
   createAssignment(target, operator, value) {
-    return ts7.factory.createBinaryExpression(target, this.BINARY_OPERATORS[operator], value);
+    return ts6.factory.createBinaryExpression(target, this.BINARY_OPERATORS[operator], value);
   }
   createBinaryExpression(leftOperand, operator, rightOperand) {
-    return ts7.factory.createBinaryExpression(leftOperand, this.BINARY_OPERATORS[operator], rightOperand);
+    return ts6.factory.createBinaryExpression(leftOperand, this.BINARY_OPERATORS[operator], rightOperand);
   }
   createBlock(body) {
-    return ts7.factory.createBlock(body);
+    return ts6.factory.createBlock(body);
   }
   createCallExpression(callee, args, pure) {
-    const call = ts7.factory.createCallExpression(callee, undefined, args);
+    const call = ts6.factory.createCallExpression(callee, undefined, args);
     if (pure) {
-      ts7.addSyntheticLeadingComment(call, ts7.SyntaxKind.MultiLineCommentTrivia, this.annotateForClosureCompiler ? "* @pureOrBreakMyCode " /* CLOSURE */ : "@__PURE__" /* TERSER */, false);
+      ts6.addSyntheticLeadingComment(call, ts6.SyntaxKind.MultiLineCommentTrivia, this.annotateForClosureCompiler ? "* @pureOrBreakMyCode " /* CLOSURE */ : "@__PURE__" /* TERSER */, false);
     }
     return call;
   }
   createConditional(condition, whenTrue, whenFalse) {
-    return ts7.factory.createConditionalExpression(condition, undefined, whenTrue, undefined, whenFalse);
+    return ts6.factory.createConditionalExpression(condition, undefined, whenTrue, undefined, whenFalse);
   }
-  createElementAccess = ts7.factory.createElementAccessExpression;
-  createExpressionStatement = ts7.factory.createExpressionStatement;
+  createElementAccess = ts6.factory.createElementAccessExpression;
+  createExpressionStatement = ts6.factory.createExpressionStatement;
   createDynamicImport(url) {
-    return ts7.factory.createCallExpression(ts7.factory.createToken(ts7.SyntaxKind.ImportKeyword), undefined, [typeof url === "string" ? ts7.factory.createStringLiteral(url) : url]);
+    return ts6.factory.createCallExpression(ts6.factory.createToken(ts6.SyntaxKind.ImportKeyword), undefined, [typeof url === "string" ? ts6.factory.createStringLiteral(url) : url]);
   }
   createFunctionDeclaration(functionName, parameters, body) {
-    if (!ts7.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${ts7.SyntaxKind[body.kind]}.`);
+    if (!ts6.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts6.SyntaxKind[body.kind]}.`);
     }
-    return ts7.factory.createFunctionDeclaration(undefined, undefined, functionName, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
+    return ts6.factory.createFunctionDeclaration(undefined, undefined, functionName, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
   }
   createFunctionExpression(functionName, parameters, body) {
-    if (!ts7.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${ts7.SyntaxKind[body.kind]}.`);
+    if (!ts6.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts6.SyntaxKind[body.kind]}.`);
     }
-    return ts7.factory.createFunctionExpression(undefined, undefined, functionName ?? undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
+    return ts6.factory.createFunctionExpression(undefined, undefined, functionName ?? undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, body);
   }
   createArrowFunctionExpression(parameters, body) {
-    if (ts7.isStatement(body) && !ts7.isBlock(body)) {
-      throw new Error(`Invalid syntax, expected a block, but got ${ts7.SyntaxKind[body.kind]}.`);
+    if (ts6.isStatement(body) && !ts6.isBlock(body)) {
+      throw new Error(`Invalid syntax, expected a block, but got ${ts6.SyntaxKind[body.kind]}.`);
     }
-    return ts7.factory.createArrowFunction(undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, undefined, body);
+    return ts6.factory.createArrowFunction(undefined, undefined, parameters.map((param) => this.createParameter(param)), undefined, undefined, body);
   }
   createParameter(param) {
-    return ts7.factory.createParameterDeclaration(undefined, undefined, param.name, undefined, param.type ?? undefined);
+    return ts6.factory.createParameterDeclaration(undefined, undefined, param.name, undefined, param.type ?? undefined);
   }
-  createIdentifier = ts7.factory.createIdentifier;
+  createIdentifier = ts6.factory.createIdentifier;
   createIfStatement(condition, thenStatement, elseStatement) {
-    return ts7.factory.createIfStatement(condition, thenStatement, elseStatement ?? undefined);
+    return ts6.factory.createIfStatement(condition, thenStatement, elseStatement ?? undefined);
   }
   createLiteral(value) {
     if (value === undefined) {
-      return ts7.factory.createIdentifier("undefined");
+      return ts6.factory.createIdentifier("undefined");
     } else if (value === null) {
-      return ts7.factory.createNull();
+      return ts6.factory.createNull();
     } else if (typeof value === "boolean") {
-      return value ? ts7.factory.createTrue() : ts7.factory.createFalse();
+      return value ? ts6.factory.createTrue() : ts6.factory.createFalse();
     } else if (typeof value === "number") {
       return tsNumericExpression(value);
     } else {
-      return ts7.factory.createStringLiteral(value);
+      return ts6.factory.createStringLiteral(value);
     }
   }
   createNewExpression(expression, args) {
-    return ts7.factory.createNewExpression(expression, undefined, args);
+    return ts6.factory.createNewExpression(expression, undefined, args);
   }
   createObjectLiteral(properties) {
-    return ts7.factory.createObjectLiteralExpression(properties.map((prop) => {
+    return ts6.factory.createObjectLiteralExpression(properties.map((prop) => {
       if (prop.kind === "spread") {
-        return ts7.factory.createSpreadAssignment(prop.expression);
+        return ts6.factory.createSpreadAssignment(prop.expression);
       }
-      return ts7.factory.createPropertyAssignment(prop.quoted ? ts7.factory.createStringLiteral(prop.propertyName) : ts7.factory.createIdentifier(prop.propertyName), prop.value);
+      return ts6.factory.createPropertyAssignment(prop.quoted ? ts6.factory.createStringLiteral(prop.propertyName) : ts6.factory.createIdentifier(prop.propertyName), prop.value);
     }));
   }
-  createParenthesizedExpression = ts7.factory.createParenthesizedExpression;
-  createPropertyAccess = ts7.factory.createPropertyAccessExpression;
-  createSpreadElement = ts7.factory.createSpreadElement;
+  createParenthesizedExpression = ts6.factory.createParenthesizedExpression;
+  createPropertyAccess = ts6.factory.createPropertyAccessExpression;
+  createSpreadElement = ts6.factory.createSpreadElement;
   createReturnStatement(expression) {
-    return ts7.factory.createReturnStatement(expression ?? undefined);
+    return ts6.factory.createReturnStatement(expression ?? undefined);
   }
   createTaggedTemplate(tag, template) {
-    return ts7.factory.createTaggedTemplateExpression(tag, undefined, this.createTemplateLiteral(template));
+    return ts6.factory.createTaggedTemplateExpression(tag, undefined, this.createTemplateLiteral(template));
   }
   createTemplateLiteral(template) {
     let templateLiteral;
     const length = template.elements.length;
     const head = template.elements[0];
     if (length === 1) {
-      templateLiteral = ts7.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
+      templateLiteral = ts6.factory.createNoSubstitutionTemplateLiteral(head.cooked, head.raw);
     } else {
       const spans = [];
       for (let i = 1;i < length - 1; i++) {
@@ -18316,7 +18049,7 @@ class TypeScriptAstFactory {
         if (range !== null) {
           this.setSourceMapRange(middle, range);
         }
-        spans.push(ts7.factory.createTemplateSpan(template.expressions[i - 1], middle));
+        spans.push(ts6.factory.createTemplateSpan(template.expressions[i - 1], middle));
       }
       const resolvedExpression = template.expressions[length - 2];
       const templatePart = template.elements[length - 1];
@@ -18324,27 +18057,27 @@ class TypeScriptAstFactory {
       if (templatePart.range !== null) {
         this.setSourceMapRange(templateTail, templatePart.range);
       }
-      spans.push(ts7.factory.createTemplateSpan(resolvedExpression, templateTail));
-      templateLiteral = ts7.factory.createTemplateExpression(ts7.factory.createTemplateHead(head.cooked, head.raw), spans);
+      spans.push(ts6.factory.createTemplateSpan(resolvedExpression, templateTail));
+      templateLiteral = ts6.factory.createTemplateExpression(ts6.factory.createTemplateHead(head.cooked, head.raw), spans);
     }
     if (head.range !== null) {
       this.setSourceMapRange(templateLiteral, head.range);
     }
     return templateLiteral;
   }
-  createThrowStatement = ts7.factory.createThrowStatement;
-  createTypeOfExpression = ts7.factory.createTypeOfExpression;
-  createVoidExpression = ts7.factory.createVoidExpression;
+  createThrowStatement = ts6.factory.createThrowStatement;
+  createTypeOfExpression = ts6.factory.createTypeOfExpression;
+  createVoidExpression = ts6.factory.createVoidExpression;
   createUnaryExpression(operator, operand) {
-    return ts7.factory.createPrefixUnaryExpression(this.UNARY_OPERATORS[operator], operand);
+    return ts6.factory.createPrefixUnaryExpression(this.UNARY_OPERATORS[operator], operand);
   }
   createVariableDeclaration(variableName, initializer, variableType, type) {
-    return ts7.factory.createVariableStatement(undefined, ts7.factory.createVariableDeclarationList([
-      ts7.factory.createVariableDeclaration(variableName, undefined, type ?? undefined, initializer ?? undefined)
+    return ts6.factory.createVariableStatement(undefined, ts6.factory.createVariableDeclarationList([
+      ts6.factory.createVariableDeclaration(variableName, undefined, type ?? undefined, initializer ?? undefined)
     ], this.VAR_TYPES[variableType]));
   }
   createRegularExpressionLiteral(body, flags) {
-    return ts7.factory.createRegularExpressionLiteral(`/${body}/${flags ?? ""}`);
+    return ts6.factory.createRegularExpressionLiteral(`/${body}/${flags ?? ""}`);
   }
   setSourceMapRange(node, sourceMapRange) {
     if (sourceMapRange === null) {
@@ -18352,10 +18085,10 @@ class TypeScriptAstFactory {
     }
     const url = sourceMapRange.url;
     if (!this.externalSourceFiles.has(url)) {
-      this.externalSourceFiles.set(url, ts7.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
+      this.externalSourceFiles.set(url, ts6.createSourceMapSource(url, sourceMapRange.content, (pos) => pos));
     }
     const source = this.externalSourceFiles.get(url);
-    ts7.setSourceMapRange(node, {
+    ts6.setSourceMapRange(node, {
       pos: sourceMapRange.start.offset,
       end: sourceMapRange.end.offset,
       source
@@ -18365,77 +18098,77 @@ class TypeScriptAstFactory {
   createBuiltInType(type) {
     switch (type) {
       case "any":
-        return ts7.factory.createKeywordTypeNode(ts7.SyntaxKind.AnyKeyword);
+        return ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.AnyKeyword);
       case "boolean":
-        return ts7.factory.createKeywordTypeNode(ts7.SyntaxKind.BooleanKeyword);
+        return ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.BooleanKeyword);
       case "number":
-        return ts7.factory.createKeywordTypeNode(ts7.SyntaxKind.NumberKeyword);
+        return ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.NumberKeyword);
       case "string":
-        return ts7.factory.createKeywordTypeNode(ts7.SyntaxKind.StringKeyword);
+        return ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.StringKeyword);
       case "function":
-        return ts7.factory.createTypeReferenceNode(ts7.factory.createIdentifier("Function"));
+        return ts6.factory.createTypeReferenceNode(ts6.factory.createIdentifier("Function"));
       case "never":
-        return ts7.factory.createKeywordTypeNode(ts7.SyntaxKind.NeverKeyword);
+        return ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.NeverKeyword);
       case "unknown":
-        return ts7.factory.createKeywordTypeNode(ts7.SyntaxKind.UnknownKeyword);
+        return ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.UnknownKeyword);
     }
   }
   createExpressionType(expression, typeParams) {
     const typeName = getEntityTypeFromExpression(expression);
-    return ts7.factory.createTypeReferenceNode(typeName, typeParams ?? undefined);
+    return ts6.factory.createTypeReferenceNode(typeName, typeParams ?? undefined);
   }
   createArrayType(elementType) {
-    return ts7.factory.createArrayTypeNode(elementType);
+    return ts6.factory.createArrayTypeNode(elementType);
   }
   createMapType(valueType) {
-    return ts7.factory.createTypeLiteralNode([
-      ts7.factory.createIndexSignature(undefined, [
-        ts7.factory.createParameterDeclaration(undefined, undefined, "key", undefined, ts7.factory.createKeywordTypeNode(ts7.SyntaxKind.StringKeyword))
+    return ts6.factory.createTypeLiteralNode([
+      ts6.factory.createIndexSignature(undefined, [
+        ts6.factory.createParameterDeclaration(undefined, undefined, "key", undefined, ts6.factory.createKeywordTypeNode(ts6.SyntaxKind.StringKeyword))
       ], valueType)
     ]);
   }
   transplantType(type) {
-    if (typeof type.kind === "number" && typeof type.getSourceFile === "function" && ts7.isTypeNode(type)) {
+    if (typeof type.kind === "number" && typeof type.getSourceFile === "function" && ts6.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 = ts7.factory.createTemplateHead(cooked, raw);
-  node.kind = ts7.SyntaxKind.TemplateMiddle;
+  const node = ts6.factory.createTemplateHead(cooked, raw);
+  node.kind = ts6.SyntaxKind.TemplateMiddle;
   return node;
 }
 function createTemplateTail(cooked, raw) {
-  const node = ts7.factory.createTemplateHead(cooked, raw);
-  node.kind = ts7.SyntaxKind.TemplateTail;
+  const node = ts6.factory.createTemplateHead(cooked, raw);
+  node.kind = ts6.SyntaxKind.TemplateTail;
   return node;
 }
 function attachComments(statement, leadingComments) {
   for (const comment of leadingComments) {
-    const commentKind = comment.multiline ? ts7.SyntaxKind.MultiLineCommentTrivia : ts7.SyntaxKind.SingleLineCommentTrivia;
+    const commentKind = comment.multiline ? ts6.SyntaxKind.MultiLineCommentTrivia : ts6.SyntaxKind.SingleLineCommentTrivia;
     if (comment.multiline) {
-      ts7.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
+      ts6.addSyntheticLeadingComment(statement, commentKind, comment.toString(), comment.trailingNewline);
     } else {
       for (const line of comment.toString().split(`
 `)) {
-        ts7.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
+        ts6.addSyntheticLeadingComment(statement, commentKind, line, comment.trailingNewline);
       }
     }
   }
 }
 function getEntityTypeFromExpression(expression) {
-  if (ts7.isIdentifier(expression)) {
+  if (ts6.isIdentifier(expression)) {
     return expression;
   }
-  if (ts7.isPropertyAccessExpression(expression)) {
+  if (ts6.isPropertyAccessExpression(expression)) {
     const left = getEntityTypeFromExpression(expression.expression);
-    if (!ts7.isIdentifier(expression.name)) {
+    if (!ts6.isIdentifier(expression.name)) {
       throw new Error(`Unsupported property access for type reference: ${expression.name.text}`);
     }
-    return ts7.factory.createQualifiedName(left, expression.name);
+    return ts6.factory.createQualifiedName(left, expression.name);
   }
-  throw new Error(`Unsupported expression for type reference: ${ts7.SyntaxKind[expression.kind]}`);
+  throw new Error(`Unsupported expression for type reference: ${ts6.SyntaxKind[expression.kind]}`);
 }
 var init_typescript_ast_factory = __esm(() => {
   init_ts_util();
@@ -18451,31 +18184,73 @@ var init_typescript_translator = __esm(() => {
 });
 
 // src/dev/angular/fastHmrCompiler.ts
-import { existsSync as existsSync25, readFileSync as readFileSync20 } from "fs";
+var exports_fastHmrCompiler = {};
+__export(exports_fastHmrCompiler, {
+  tryFastHmr: () => tryFastHmr,
+  recordFingerprint: () => recordFingerprint,
+  invalidateFingerprintCache: () => invalidateFingerprintCache
+});
+import { existsSync as existsSync25, readFileSync as readFileSync19 } from "fs";
 import { dirname as dirname18, relative as relative13, resolve as resolve31 } from "path";
-import ts8 from "typescript";
-var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclaration = (sourceFile, className) => {
+import ts7 from "typescript";
+var fail = (reason, detail) => ({ ok: false, reason, detail }), fingerprintCache, fingerprintsEqual = (a, b2) => {
+  if (a.className !== b2.className)
+    return false;
+  if (a.selector !== b2.selector)
+    return false;
+  if (a.standalone !== b2.standalone)
+    return false;
+  if (a.importsArity !== b2.importsArity)
+    return false;
+  if (a.hasProviders !== b2.hasProviders)
+    return false;
+  if (a.hasViewProviders !== b2.hasViewProviders)
+    return false;
+  if (a.ctorParamTypes.length !== b2.ctorParamTypes.length)
+    return false;
+  for (let i = 0;i < a.ctorParamTypes.length; i++) {
+    if (a.ctorParamTypes[i] !== b2.ctorParamTypes[i])
+      return false;
+  }
+  if (a.inputs.length !== b2.inputs.length)
+    return false;
+  for (let i = 0;i < a.inputs.length; i++) {
+    if (a.inputs[i] !== b2.inputs[i])
+      return false;
+  }
+  if (a.outputs.length !== b2.outputs.length)
+    return false;
+  for (let i = 0;i < a.outputs.length; i++) {
+    if (a.outputs[i] !== b2.outputs[i])
+      return false;
+  }
+  return true;
+}, recordFingerprint = (id, fp) => {
+  fingerprintCache.set(id, fp);
+}, invalidateFingerprintCache = () => {
+  fingerprintCache.clear();
+}, findClassDeclaration = (sourceFile, className) => {
   let found = null;
   const walk = (node) => {
     if (found)
       return;
-    if (ts8.isClassDeclaration(node) && node.name?.text === className) {
+    if (ts7.isClassDeclaration(node) && node.name?.text === className) {
       found = node;
       return;
     }
-    ts8.forEachChild(node, walk);
+    ts7.forEachChild(node, walk);
   };
   walk(sourceFile);
   return found;
 }, getClassDecorators = (cls) => {
-  const modifiers = ts8.getDecorators(cls) ?? [];
+  const modifiers = ts7.getDecorators(cls) ?? [];
   return [...modifiers];
 }, findComponentDecorator = (cls) => {
   for (const decorator of getClassDecorators(cls)) {
     const expr = decorator.expression;
-    if (ts8.isCallExpression(expr)) {
+    if (ts7.isCallExpression(expr)) {
       const fn2 = expr.expression;
-      if (ts8.isIdentifier(fn2) && fn2.text === "Component") {
+      if (ts7.isIdentifier(fn2) && fn2.text === "Component") {
         return decorator;
       }
     }
@@ -18483,15 +18258,15 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
   return null;
 }, getDecoratorArgsObject = (decorator) => {
   const call = decorator.expression;
-  if (!ts8.isCallExpression(call))
+  if (!ts7.isCallExpression(call))
     return null;
   const arg = call.arguments[0];
-  if (!arg || !ts8.isObjectLiteralExpression(arg))
+  if (!arg || !ts7.isObjectLiteralExpression(arg))
     return null;
   return arg;
 }, getProperty = (obj, name) => {
   for (const prop of obj.properties) {
-    if (ts8.isPropertyAssignment(prop) && (ts8.isIdentifier(prop.name) && prop.name.text === name || ts8.isStringLiteral(prop.name) && prop.name.text === name)) {
+    if (ts7.isPropertyAssignment(prop) && (ts7.isIdentifier(prop.name) && prop.name.text === name || ts7.isStringLiteral(prop.name) && prop.name.text === name)) {
       return prop.initializer;
     }
   }
@@ -18500,7 +18275,7 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
   const expr = getProperty(obj, name);
   if (!expr)
     return null;
-  if (ts8.isStringLiteral(expr) || ts8.isNoSubstitutionTemplateLiteral(expr)) {
+  if (ts7.isStringLiteral(expr) || ts7.isNoSubstitutionTemplateLiteral(expr)) {
     return expr.text;
   }
   return null;
@@ -18508,15 +18283,15 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
   const expr = getProperty(obj, name);
   if (!expr)
     return null;
-  if (expr.kind === ts8.SyntaxKind.TrueKeyword)
+  if (expr.kind === ts7.SyntaxKind.TrueKeyword)
     return true;
-  if (expr.kind === ts8.SyntaxKind.FalseKeyword)
+  if (expr.kind === ts7.SyntaxKind.FalseKeyword)
     return false;
   return null;
 }, inheritsDecoratedClass = (cls) => {
   const heritage = cls.heritageClauses ?? [];
   for (const clause of heritage) {
-    if (clause.token !== ts8.SyntaxKind.ExtendsKeyword)
+    if (clause.token !== ts7.SyntaxKind.ExtendsKeyword)
       continue;
     if (clause.types.length > 0)
       return true;
@@ -18527,52 +18302,54 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
   const stylesExpr = getProperty(args, "styles");
   const importsExpr = getProperty(args, "imports");
   const styleUrls = [];
-  if (styleUrlsExpr && ts8.isArrayLiteralExpression(styleUrlsExpr)) {
+  if (styleUrlsExpr && ts7.isArrayLiteralExpression(styleUrlsExpr)) {
     for (const el of styleUrlsExpr.elements) {
-      if (ts8.isStringLiteral(el))
+      if (ts7.isStringLiteral(el))
         styleUrls.push(el.text);
     }
   }
   const styles = [];
   if (stylesExpr) {
-    if (ts8.isArrayLiteralExpression(stylesExpr)) {
+    if (ts7.isArrayLiteralExpression(stylesExpr)) {
       for (const el of stylesExpr.elements) {
-        if (ts8.isStringLiteral(el) || ts8.isNoSubstitutionTemplateLiteral(el)) {
+        if (ts7.isStringLiteral(el) || ts7.isNoSubstitutionTemplateLiteral(el)) {
           styles.push(el.text);
         }
       }
-    } else if (ts8.isStringLiteral(stylesExpr) || ts8.isNoSubstitutionTemplateLiteral(stylesExpr)) {
+    } else if (ts7.isStringLiteral(stylesExpr) || ts7.isNoSubstitutionTemplateLiteral(stylesExpr)) {
       styles.push(stylesExpr.text);
     }
   }
   return {
+    hasProviders: getProperty(args, "providers") !== null,
+    hasViewProviders: getProperty(args, "viewProviders") !== null,
+    importsExpr: importsExpr && ts7.isArrayLiteralExpression(importsExpr) ? importsExpr : null,
+    preserveWhitespaces: getBooleanProperty(args, "preserveWhitespaces") ?? false,
     selector: getStringProperty(args, "selector"),
-    templateUrl: getStringProperty(args, "templateUrl"),
-    template: getStringProperty(args, "template"),
+    standalone: getBooleanProperty(args, "standalone") ?? true,
     styleUrl: getStringProperty(args, "styleUrl"),
     styleUrls,
     styles,
-    standalone: getBooleanProperty(args, "standalone") ?? true,
-    preserveWhitespaces: getBooleanProperty(args, "preserveWhitespaces") ?? false,
-    importsExpr: importsExpr && ts8.isArrayLiteralExpression(importsExpr) ? importsExpr : null
+    template: getStringProperty(args, "template"),
+    templateUrl: getStringProperty(args, "templateUrl")
   };
 }, extractDecoratorInput = (prop) => {
-  const decorators = ts8.getDecorators(prop) ?? [];
+  const decorators = ts7.getDecorators(prop) ?? [];
   for (const decorator of decorators) {
     const expr = decorator.expression;
-    if (!ts8.isCallExpression(expr))
+    if (!ts7.isCallExpression(expr))
       continue;
     const fn2 = expr.expression;
-    if (!ts8.isIdentifier(fn2) || fn2.text !== "Input")
+    if (!ts7.isIdentifier(fn2) || fn2.text !== "Input")
       continue;
     const classPropertyName = prop.name.getText();
     let bindingPropertyName = classPropertyName;
     let required = false;
     const arg = expr.arguments[0];
     if (arg) {
-      if (ts8.isStringLiteral(arg)) {
+      if (ts7.isStringLiteral(arg)) {
         bindingPropertyName = arg.text;
-      } else if (ts8.isObjectLiteralExpression(arg)) {
+      } else if (ts7.isObjectLiteralExpression(arg)) {
         const aliasNode = getStringProperty(arg, "alias");
         if (aliasNode !== null)
           bindingPropertyName = aliasNode;
@@ -18592,11 +18369,11 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
   }
   return null;
 }, isInputSignalCall = (init) => {
-  if (ts8.isCallExpression(init)) {
+  if (ts7.isCallExpression(init)) {
     const fn2 = init.expression;
-    if (ts8.isIdentifier(fn2) && fn2.text === "input")
+    if (ts7.isIdentifier(fn2) && fn2.text === "input")
       return true;
-    if (ts8.isPropertyAccessExpression(fn2) && ts8.isIdentifier(fn2.expression) && fn2.expression.text === "input") {
+    if (ts7.isPropertyAccessExpression(fn2) && ts7.isIdentifier(fn2.expression) && fn2.expression.text === "input") {
       return true;
     }
   }
@@ -18607,12 +18384,12 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
   const classPropertyName = prop.name.getText();
   const call = prop.initializer;
   let required = false;
-  if (ts8.isPropertyAccessExpression(call.expression) && ts8.isIdentifier(call.expression.name) && call.expression.name.text === "required") {
+  if (ts7.isPropertyAccessExpression(call.expression) && ts7.isIdentifier(call.expression.name) && call.expression.name.text === "required") {
     required = true;
   }
   let bindingPropertyName = classPropertyName;
   const optsArg = call.arguments[required ? 0 : 1];
-  if (optsArg && ts8.isObjectLiteralExpression(optsArg)) {
+  if (optsArg && ts7.isObjectLiteralExpression(optsArg)) {
     const aliasNode = getStringProperty(optsArg, "alias");
     if (aliasNode !== null)
       bindingPropertyName = aliasNode;
@@ -18628,28 +18405,28 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
     }
   };
 }, extractDecoratorOutput = (prop) => {
-  const decorators = ts8.getDecorators(prop) ?? [];
+  const decorators = ts7.getDecorators(prop) ?? [];
   for (const decorator of decorators) {
     const expr = decorator.expression;
-    if (!ts8.isCallExpression(expr))
+    if (!ts7.isCallExpression(expr))
       continue;
     const fn2 = expr.expression;
-    if (!ts8.isIdentifier(fn2) || fn2.text !== "Output")
+    if (!ts7.isIdentifier(fn2) || fn2.text !== "Output")
       continue;
     const classPropertyName = prop.name.getText();
     let bindingName = classPropertyName;
     const arg = expr.arguments[0];
-    if (arg && ts8.isStringLiteral(arg))
+    if (arg && ts7.isStringLiteral(arg))
       bindingName = arg.text;
     return { classPropertyName, bindingName };
   }
   return null;
 }, isOutputSignalCall = (init) => {
-  if (ts8.isCallExpression(init)) {
+  if (ts7.isCallExpression(init)) {
     const fn2 = init.expression;
-    if (ts8.isIdentifier(fn2) && fn2.text === "output")
+    if (ts7.isIdentifier(fn2) && fn2.text === "output")
       return true;
-    if (ts8.isPropertyAccessExpression(fn2) && ts8.isIdentifier(fn2.expression) && fn2.expression.text === "output") {
+    if (ts7.isPropertyAccessExpression(fn2) && ts7.isIdentifier(fn2.expression) && fn2.expression.text === "output") {
       return true;
     }
   }
@@ -18661,7 +18438,7 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
   const call = prop.initializer;
   let bindingName = classPropertyName;
   const optsArg = call.arguments[0];
-  if (optsArg && ts8.isObjectLiteralExpression(optsArg)) {
+  if (optsArg && ts7.isObjectLiteralExpression(optsArg)) {
     const aliasNode = getStringProperty(optsArg, "alias");
     if (aliasNode !== null)
       bindingName = aliasNode;
@@ -18671,7 +18448,7 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
   const inputs = {};
   const outputs = {};
   for (const member of cls.members) {
-    if (!ts8.isPropertyDeclaration(member))
+    if (!ts7.isPropertyDeclaration(member))
       continue;
     const decoratorIn = extractDecoratorInput(member);
     if (decoratorIn) {
@@ -18694,11 +18471,78 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
     }
   }
   return { inputs, outputs };
+}, extractFingerprint = (cls, className, decoratorMeta, inputs, outputs) => {
+  const ctorParamTypes = [];
+  for (const member of cls.members) {
+    if (!ts7.isConstructorDeclaration(member))
+      continue;
+    for (const param of member.parameters) {
+      ctorParamTypes.push(param.type ? param.type.getText() : "");
+    }
+    break;
+  }
+  const inputNames = Object.keys(inputs).sort();
+  const outputNames = Object.keys(outputs).sort();
+  const importsArity = decoratorMeta.importsExpr ? decoratorMeta.importsExpr.elements.length : 0;
+  const hasProviders = decoratorMeta.hasProviders;
+  const hasViewProviders = decoratorMeta.hasViewProviders;
+  return {
+    className,
+    ctorParamTypes,
+    hasProviders,
+    hasViewProviders,
+    importsArity,
+    inputs: inputNames,
+    outputs: outputNames,
+    selector: decoratorMeta.selector,
+    standalone: decoratorMeta.standalone
+  };
+}, buildFreshClassMethodsBlock = (classNode, className) => {
+  const methodSources = [];
+  for (const member of classNode.members) {
+    if (ts7.isMethodDeclaration(member) || ts7.isGetAccessorDeclaration(member) || ts7.isSetAccessorDeclaration(member)) {
+      const modifiers = ts7.getModifiers(member) ?? [];
+      const isStatic = modifiers.some((m) => m.kind === ts7.SyntaxKind.StaticKeyword);
+      if (isStatic)
+        continue;
+      methodSources.push(member.getText());
+    }
+  }
+  if (methodSources.length === 0)
+    return null;
+  const wrappedSource = `class _Fresh {
+${methodSources.join(`
+`)}
+}`;
+  let transpiled;
+  try {
+    transpiled = ts7.transpileModule(wrappedSource, {
+      compilerOptions: {
+        module: ts7.ModuleKind.ES2022,
+        target: ts7.ScriptTarget.ES2022
+      },
+      reportDiagnostics: false
+    }).outputText;
+  } catch {
+    return null;
+  }
+  return `// SURGICAL_HMR \u2014 patch prototype methods so existing instances
+// pick up new method bodies (\`compileComponentFromMetadata\` only
+// updates \`\u0275cmp\`, never the prototype).
+${transpiled}
+{
+    const __fresh_proto = _Fresh.prototype;
+    for (const __name of Object.getOwnPropertyNames(__fresh_proto)) {
+        if (__name === 'constructor') continue;
+        const __desc = Object.getOwnPropertyDescriptor(__fresh_proto, __name);
+        if (__desc) Object.defineProperty(${className}.prototype, __name, __desc);
+    }
+}`;
 }, resolveAndReadResource = (componentDir, url) => {
   const abs = resolve31(componentDir, url);
   if (!existsSync25(abs))
     return null;
-  return readFileSync20(abs, "utf8");
+  return readFileSync19(abs, "utf8");
 }, collectStyles = (decoratorMeta, componentDir) => {
   const styles = [...decoratorMeta.styles];
   const urls = [];
@@ -18724,8 +18568,8 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
   } catch (err) {
     return fail("unexpected-error", `import @angular/compiler: ${err}`);
   }
-  const tsSource = readFileSync20(componentFilePath, "utf8");
-  const sourceFile = ts8.createSourceFile(componentFilePath, tsSource, ts8.ScriptTarget.ES2022, true, ts8.ScriptKind.TS);
+  const tsSource = readFileSync19(componentFilePath, "utf8");
+  const sourceFile = ts7.createSourceFile(componentFilePath, tsSource, ts7.ScriptTarget.ES2022, true, ts7.ScriptKind.TS);
   const classNode = findClassDeclaration(sourceFile, className);
   if (!classNode) {
     return fail("class-not-found", `${className} in ${componentFilePath}`);
@@ -18753,7 +18597,7 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
     if (!existsSync25(tplAbs)) {
       return fail("template-resource-not-found", tplAbs);
     }
-    templateText = readFileSync20(tplAbs, "utf8");
+    templateText = readFileSync19(tplAbs, "utf8");
     templatePath = tplAbs;
   } else {
     return fail("unsupported-decorator-args", "missing template/templateUrl");
@@ -18780,6 +18624,12 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
   const wrappedClass = new compiler.WrappedNodeExpr(className_);
   const { inputs, outputs } = extractInputsAndOutputs(classNode);
   const projectRelPath = relative13(projectRoot, componentFilePath).replace(/\\/g, "/");
+  const fingerprintId = encodeURIComponent(`${projectRelPath}@${className}`);
+  const currentFingerprint = extractFingerprint(classNode, className, decoratorMeta, inputs, outputs);
+  const cachedFingerprint = fingerprintCache.get(fingerprintId);
+  if (cachedFingerprint && !fingerprintsEqual(cachedFingerprint, currentFingerprint)) {
+    return fail("structural-change", `fingerprint changed for ${className}; escalate to Tier 1`);
+  }
   const sourceFileObj = new compiler.ParseSourceFile(tsSource, componentFilePath);
   const zeroLoc = new compiler.ParseLocation(sourceFileObj, 0, 0, 0);
   const typeSourceSpan = new compiler.ParseSourceSpan(zeroLoc, zeroLoc);
@@ -18868,23 +18718,36 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
     }
     const importGenerator = createHmrImportGenerator(namespaceMap);
     const tsFunctionDecl = translateStatement(sourceFile, callback, importGenerator);
-    const exportedDecl = ts8.factory.updateFunctionDeclaration(tsFunctionDecl, [
-      ts8.factory.createToken(ts8.SyntaxKind.ExportKeyword),
-      ts8.factory.createToken(ts8.SyntaxKind.DefaultKeyword)
+    const exportedDecl = ts7.factory.updateFunctionDeclaration(tsFunctionDecl, [
+      ts7.factory.createToken(ts7.SyntaxKind.ExportKeyword),
+      ts7.factory.createToken(ts7.SyntaxKind.DefaultKeyword)
     ], tsFunctionDecl.asteriskToken, tsFunctionDecl.name, tsFunctionDecl.typeParameters, tsFunctionDecl.parameters, tsFunctionDecl.type, tsFunctionDecl.body);
-    const printer = ts8.createPrinter({
-      newLine: ts8.NewLineKind.LineFeed,
+    const printer = ts7.createPrinter({
+      newLine: ts7.NewLineKind.LineFeed,
       removeComments: false
     });
-    const tsSourceText = printer.printNode(ts8.EmitHint.Unspecified, exportedDecl, sourceFile);
-    const moduleText = ts8.transpileModule(tsSourceText, {
+    const tsSourceText = printer.printNode(ts7.EmitHint.Unspecified, exportedDecl, sourceFile);
+    const transpiled = ts7.transpileModule(tsSourceText, {
       compilerOptions: {
-        module: ts8.ModuleKind.ES2022,
-        target: ts8.ScriptTarget.ES2022
+        module: ts7.ModuleKind.ES2022,
+        target: ts7.ScriptTarget.ES2022
       },
       fileName: componentFilePath,
       reportDiagnostics: false
     }).outputText;
+    const methodsBlock = buildFreshClassMethodsBlock(classNode, className);
+    let moduleText = transpiled;
+    if (methodsBlock) {
+      const fnOpening = `function ${className}_UpdateMetadata(${className}, \u0275\u0275namespaces) {`;
+      const idx = moduleText.indexOf(fnOpening);
+      if (idx >= 0) {
+        const insertAt = idx + fnOpening.length;
+        moduleText = moduleText.slice(0, insertAt) + `
+` + methodsBlock + `
+` + moduleText.slice(insertAt);
+      }
+    }
+    fingerprintCache.set(fingerprintId, currentFingerprint);
     return { ok: true, moduleText, componentSource: sourceFile };
   } catch (err) {
     return fail("unexpected-error", String(err));
@@ -18893,6 +18756,7 @@ var fail = (reason, detail) => ({ ok: false, reason, detail }), findClassDeclara
 var init_fastHmrCompiler = __esm(() => {
   init_hmrImportGenerator();
   init_typescript_translator();
+  fingerprintCache = new Map;
 });
 
 // src/dev/angular/hmrCompiler.ts
@@ -18905,9 +18769,9 @@ __export(exports_hmrCompiler, {
   compileAngularForHmr: () => compileAngularForHmr
 });
 import { existsSync as existsSync26 } from "fs";
-import { basename as basename12, dirname as dirname19, join as join29, relative as relative14, resolve as resolve32 } from "path";
+import { basename as basename11, dirname as dirname19, join as join29, relative as relative14, resolve as resolve32 } from "path";
 import { performance as performance2 } from "perf_hooks";
-import ts9 from "typescript";
+import ts8 from "typescript";
 var globalCache, getCachedHmrProgram = () => globalCache.__ABSOLUTE_ANGULAR_HMR_PROGRAM__ ?? null, setCachedHmrProgram = (program) => {
   globalCache.__ABSOLUTE_ANGULAR_HMR_PROGRAM__ = program;
 }, resolveTypescriptLibDirCached = null, resolveTypescriptLibDir = () => {
@@ -18922,14 +18786,14 @@ var globalCache, getCachedHmrProgram = () => globalCache.__ABSOLUTE_ANGULAR_HMR_
   emitDecoratorMetadata: true,
   esModuleInterop: true,
   experimentalDecorators: true,
-  module: ts9.ModuleKind.ESNext,
-  moduleResolution: ts9.ModuleResolutionKind.Bundler,
-  newLine: ts9.NewLineKind.LineFeed,
+  module: ts8.ModuleKind.ESNext,
+  moduleResolution: ts8.ModuleResolutionKind.Bundler,
+  newLine: ts8.NewLineKind.LineFeed,
   noEmit: false,
   noLib: false,
   rootDir: process.cwd(),
   skipLibCheck: true,
-  target: ts9.ScriptTarget.ES2022,
+  target: ts8.ScriptTarget.ES2022,
   _enableHmr: true,
   enableHmr: true
 }), ANGULAR_COMPILER_OPTIONS_CACHE, loadAngularCompilerOptions = async () => {
@@ -18956,20 +18820,20 @@ var globalCache, getCachedHmrProgram = () => globalCache.__ABSOLUTE_ANGULAR_HMR_
   const baseOptions = await loadAngularCompilerOptions();
   const options = buildHmrCompilerOptions(baseOptions);
   options.outDir = outDir;
-  options.target = ts9.ScriptTarget.ES2022;
+  options.target = ts8.ScriptTarget.ES2022;
   options.experimentalDecorators = true;
   options.emitDecoratorMetadata = true;
-  options.newLine = ts9.NewLineKind.LineFeed;
+  options.newLine = ts8.NewLineKind.LineFeed;
   options.incremental = false;
   options.tsBuildInfoFile = undefined;
   const tsLibDir = resolveTypescriptLibDir();
-  const host = ts9.createCompilerHost(options);
+  const host = ts8.createCompilerHost(options);
   const originalGetDefaultLibLocation = host.getDefaultLibLocation;
   host.getDefaultLibLocation = () => tsLibDir || (originalGetDefaultLibLocation ? originalGetDefaultLibLocation() : "");
   const originalGetDefaultLibFileName = host.getDefaultLibFileName;
   host.getDefaultLibFileName = (opts) => {
     const fileName = originalGetDefaultLibFileName ? originalGetDefaultLibFileName(opts) : "lib.d.ts";
-    return basename12(fileName);
+    return basename11(fileName);
   };
   const originalGetSourceFile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
@@ -19040,11 +18904,11 @@ var globalCache, getCachedHmrProgram = () => globalCache.__ABSOLUTE_ANGULAR_HMR_
   const walk = (node) => {
     if (found)
       return;
-    if (ts9.isClassDeclaration(node) && node.name?.text === className) {
+    if (ts8.isClassDeclaration(node) && node.name?.text === className) {
       found = node;
       return;
     }
-    ts9.forEachChild(node, walk);
+    ts8.forEachChild(node, walk);
   };
   walk(sourceFile);
   return found;
@@ -19271,7 +19135,7 @@ var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
 import { existsSync as existsSync27 } from "fs";
-import { basename as basename13, dirname as dirname20, relative as relative15, resolve as resolve35 } from "path";
+import { basename as basename12, dirname as dirname20, relative as relative15, resolve as resolve35 } from "path";
 var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequentially = (items, action) => items.reduce((chain, item) => chain.then(() => action(item)), Promise.resolve()), getStyleTransformConfig = (config) => createStyleTransformConfig(config.stylePreprocessors, config.postcss), recompileTailwindForFastPath = async (state, config, files) => {
   if (!config.tailwind)
     return;
@@ -19604,7 +19468,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { commonAncestor: commonAncestor2 } = await Promise.resolve().then(() => (init_commonAncestor(), exports_commonAncestor));
   return clientRoots.length === 1 ? clientRoots[0] ?? projectRoot : commonAncestor2(clientRoots, projectRoot);
 }, updateServerManifestEntry = (state, artifact) => {
-  const fileWithHash = basename13(artifact.path);
+  const fileWithHash = basename12(artifact.path);
   const [baseName] = fileWithHash.split(`.${artifact.hash}.`);
   if (!baseName) {
     return;
@@ -19665,59 +19529,63 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const clientManifest = generateManifest2(clientResult.outputs, buildDir);
   Object.assign(state.manifest, clientManifest);
   await populateAssetStore(state.assetStore, clientManifest, buildDir);
-}, filterToUserEdits = (candidates, userEditedFiles) => {
-  if (!userEditedFiles || userEditedFiles.size === 0)
-    return candidates;
-  const filtered = candidates.filter((file4) => userEditedFiles.has(resolve35(file4)));
-  return filtered.length > 0 ? filtered : candidates;
-}, broadcastAngularComponentUpdates = async (state, angularDir) => {
+}, decideAngularTier = async (state, angularDir) => {
   const userEdited = state.lastUserEditedFiles ?? new Set;
   if (userEdited.size === 0)
-    return;
+    return { queue: [], tier: 0 };
   const { resolveOwningComponents: resolveOwningComponents2 } = await Promise.resolve().then(() => (init_resolveOwningComponents(), exports_resolveOwningComponents));
   const { encodeHmrComponentId: encodeHmrComponentId2 } = await Promise.resolve().then(() => (init_hmrCompiler(), exports_hmrCompiler));
-  const broadcastedIds = new Set;
-  const broadcastTimestamp = Date.now();
+  const { tryFastHmr: tryFastHmr2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
+  const queue = [];
+  const queueIds = new Set;
   for (const editedFile of userEdited) {
     const owners = resolveOwningComponents2({
       changedFilePath: editedFile,
       userAngularRoot: angularDir
     });
+    if (owners.length === 0 && editedFile.endsWith(".component.ts")) {
+      return {
+        reason: `no @Component class found in ${editedFile}`,
+        tier: 1
+      };
+    }
     for (const { componentFilePath, className } of owners) {
       const id = encodeHmrComponentId2(componentFilePath, className);
-      if (broadcastedIds.has(id))
+      if (queueIds.has(id))
         continue;
-      broadcastedIds.add(id);
-      broadcastToClients(state, {
-        data: { id, timestamp: broadcastTimestamp },
-        type: "angular:component-update"
-      });
-      logInfo(`[ng-hmr broadcast] ${className}`);
+      const result = await tryFastHmr2({ className, componentFilePath });
+      if (!result.ok) {
+        return {
+          reason: `${className}: ${result.reason}${result.detail ? ` (${result.detail})` : ""}`,
+          tier: 1
+        };
+      }
+      queueIds.add(id);
+      queue.push({ className, id });
     }
   }
-}, broadcastAngularPageUpdates = (state, pagesToUpdate, manifest, startTime, classification) => {
-  pagesToUpdate.forEach((angularPagePath) => {
-    const fileName = basename13(angularPagePath);
-    const baseName = fileName.replace(/\.[tj]s$/, "");
-    const pascalName = toPascal(baseName);
-    const cssKey = `${pascalName}CSS`;
-    const cssUrl = manifest[cssKey] || null;
-    const duration = Date.now() - startTime;
-    logHmrUpdate(angularPagePath, "angular", duration);
+  return { queue, tier: 0 };
+}, broadcastSurgical = (state, queue) => {
+  const timestamp = Date.now();
+  for (const { id, className } of queue) {
     broadcastToClients(state, {
-      data: {
-        cssBaseName: baseName,
-        cssUrl,
-        editSourceFile: classification.sourceFile,
-        framework: "angular",
-        manifest,
-        reason: classification.reason,
-        sourceFile: angularPagePath,
-        updateType: classification.type
-      },
-      type: "angular-update"
+      data: { id, timestamp },
+      type: "angular:component-update"
     });
+    logInfo(`[ng-hmr broadcast] ${className}`);
+  }
+}, broadcastRebootstrap = async (state, reason) => {
+  logInfo(`[ng-hmr tier-1 rebootstrap] ${reason}`);
+  broadcastToClients(state, {
+    data: {
+      manifest: state.manifest,
+      reason,
+      timestamp: Date.now()
+    },
+    type: "angular:rebootstrap"
   });
+  const { invalidateFingerprintCache: invalidateFingerprintCache2 } = await Promise.resolve().then(() => (init_fastHmrCompiler(), exports_fastHmrCompiler));
+  invalidateFingerprintCache2();
 }, compileAndBundleAngular = async (state, pageEntries, angularDir) => {
   const { compileAngular: compileAngular2 } = await Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular));
   const { clientPaths, serverPaths } = await compileAngular2(pageEntries, angularDir, true, getStyleTransformConfig(state.config));
@@ -19742,7 +19610,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     await rewriteImports3(ssrPaths, angServerVendorPaths);
   }
   serverPaths.forEach((serverPath, idx) => {
-    const fileBase = basename13(serverPath, ".js");
+    const fileBase = basename12(serverPath, ".js");
     const ssrPath = ssrPaths[idx] ?? serverPath;
     state.manifest[toPascal(fileBase)] = resolve35(ssrPath);
   });
@@ -19757,18 +19625,23 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   }
   const angularPagesPath = resolve35(angularDir, "pages");
   const pageEntries = resolveAngularPageEntries(state, angularFiles, angularPagesPath);
-  if (pageEntries.length > 0) {
+  const verdict = await decideAngularTier(state, angularDir);
+  const runBundle = async () => {
+    if (pageEntries.length === 0)
+      return;
     await compileAndBundleAngular(state, pageEntries, angularDir);
     markSsrCacheDirty("angular");
+  };
+  if (verdict.tier === 0) {
+    broadcastSurgical(state, verdict.queue);
+    runBundle().catch((err) => {
+      logWarn(`[ng-hmr async bundle] rebuild failed: ${err instanceof Error ? err.message : String(err)}`);
+    });
+  } else {
+    await runBundle();
+    await broadcastRebootstrap(state, verdict.reason);
   }
   const { manifest } = state;
-  const angularHmrFiles = angularFiles.filter((file4) => file4.endsWith(".ts") || file4.endsWith(".html"));
-  const angularPageFiles = angularHmrFiles.filter((file4) => file4.replace(/\\/g, "/").includes("/pages/"));
-  const pagesToUpdate = angularPageFiles.length > 0 ? angularPageFiles : pageEntries;
-  const filesToClassify = filterToUserEdits(angularFiles, state.lastUserEditedFiles);
-  const classification = collapseClassifications(filesToClassify.map(classifyAngularEdit));
-  broadcastAngularPageUpdates(state, pagesToUpdate, manifest, startTime, classification);
-  await broadcastAngularComponentUpdates(state, angularDir);
   onRebuildComplete({ hmrState: state, manifest });
   return manifest;
 }, getModuleUrl = async (pageFile) => {
@@ -19895,7 +19768,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     const clientEntries = [...svelteIndexPaths, ...svelteClientPaths];
     const { getFrameworkGeneratedDir: getFrameworkGeneratedDir2 } = await Promise.resolve().then(() => (init_generatedDir(), exports_generatedDir));
     const serverRoot = resolve35(getFrameworkGeneratedDir2("svelte"), "server");
-    const serverOutDir = resolve35(buildDir, basename13(svelteDir));
+    const serverOutDir = resolve35(buildDir, basename12(svelteDir));
     const [serverResult, clientResult] = await Promise.all([
       serverEntries.length > 0 ? bunBuild9({
         entrypoints: serverEntries,
@@ -19937,7 +19810,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const duration = Date.now() - startTime;
   const broadcastFiles = svelteFiles.length > 0 ? svelteFiles : filesToRebuild;
   broadcastFiles.forEach((sveltePagePath) => {
-    const fileName = basename13(sveltePagePath);
+    const fileName = basename12(sveltePagePath);
     const baseName = fileName.replace(/\.svelte$/, "");
     const pascalName = toPascal(baseName);
     const cssKey = `${pascalName}CSS`;
@@ -20044,7 +19917,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const { compileEmber: compileEmber2 } = await Promise.resolve().then(() => (init_compileEmber(), exports_compileEmber));
   const { serverPaths } = await compileEmber2(allPageEntries, emberDir, process.cwd(), true);
   for (const serverPath of serverPaths) {
-    const fileBase = basename13(serverPath, ".js");
+    const fileBase = basename12(serverPath, ".js");
     state.manifest[toPascal(fileBase)] = resolve35(serverPath);
   }
   const { invalidateEmberSsrCache: invalidateEmberSsrCache2 } = await Promise.resolve().then(() => (init_ember(), exports_ember));
@@ -20115,7 +19988,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     });
   }
 }, handleScriptUpdate = (state, scriptFile, manifest, framework, duration) => {
-  const scriptBaseName = basename13(scriptFile).replace(/\.(ts|js|tsx|jsx)$/, "");
+  const scriptBaseName = basename12(scriptFile).replace(/\.(ts|js|tsx|jsx)$/, "");
   const pascalName = toPascal(scriptBaseName);
   const scriptPath = manifest[pascalName] || null;
   if (!scriptPath) {
@@ -20194,7 +20067,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (isSingle) {
     return resolve35(state.resolvedPaths.buildDir, "pages");
   }
-  const dirName = framework === "html" ? basename13(config.htmlDirectory ?? "html") : basename13(config.htmxDirectory ?? "htmx");
+  const dirName = framework === "html" ? basename12(config.htmlDirectory ?? "html") : basename12(config.htmxDirectory ?? "htmx");
   return resolve35(state.resolvedPaths.buildDir, dirName, "pages");
 }, processHtmlPageUpdate = async (state, pageFile, builtHtmlPagePath, manifest, duration) => {
   try {
@@ -20233,7 +20106,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const shouldRefreshAllPages = htmlPageFiles.length === 0 && shouldRefreshFromIslandChange;
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmlPages, "*.html") : htmlPageFiles;
   await runSequentially(pageFilesToUpdate, async (pageFile) => {
-    const htmlPageName = basename13(pageFile);
+    const htmlPageName = basename12(pageFile);
     const builtHtmlPagePath = resolve35(outputHtmlPages, htmlPageName);
     await processHtmlPageUpdate(state, pageFile, builtHtmlPagePath, manifest, duration);
   });
@@ -20242,7 +20115,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!cssFile) {
     return;
   }
-  const cssBaseName = basename13(getStyleBaseName(cssFile));
+  const cssBaseName = basename12(getStyleBaseName(cssFile));
   const cssPascalName = toPascal(cssBaseName);
   const cssKey = `${cssPascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
@@ -20291,7 +20164,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     type: "vue-update"
   });
 }, broadcastVuePageChange = async (state, config, vuePagePath, manifest, duration) => {
-  const fileName = basename13(vuePagePath);
+  const fileName = basename12(vuePagePath);
   const baseName = fileName.replace(/\.vue$/, "");
   const pascalName = toPascal(baseName);
   const vueRoot = config.vueDirectory;
@@ -20337,7 +20210,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   if (!cssFile) {
     return;
   }
-  const cssBaseName = basename13(getStyleBaseName(cssFile));
+  const cssBaseName = basename12(getStyleBaseName(cssFile));
   const cssPascalName = toPascal(cssBaseName);
   const cssKey = `${cssPascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
@@ -20355,7 +20228,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   });
 }, broadcastSveltePageUpdate = (state, sveltePagePath, manifest, duration) => {
   try {
-    const fileName = basename13(sveltePagePath);
+    const fileName = basename12(sveltePagePath);
     const baseName = fileName.replace(/\.svelte$/, "");
     const pascalName = toPascal(baseName);
     const cssKey = `${pascalName}CSS`;
@@ -20398,26 +20271,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   pagesToUpdate.forEach((sveltePagePath) => {
     broadcastSveltePageUpdate(state, sveltePagePath, manifest, duration);
   });
-}, collectAngularAffectedPages = (affected, resolvedPages) => {
-  affected.forEach((file4) => {
-    if (file4.replace(/\\/g, "/").includes("/pages/") && file4.endsWith(".ts")) {
-      resolvedPages.add(file4);
-    }
-  });
-}, resolveAngularPagesFromDependencyGraph = (state, angularFiles) => {
-  const resolvedPages = new Set;
-  angularFiles.forEach((componentFile) => {
-    const lookupFile = resolveComponentLookupFile(componentFile, state.dependencyGraph);
-    const affected = getAffectedFiles(state.dependencyGraph, lookupFile);
-    collectAngularAffectedPages(affected, resolvedPages);
-  });
-  return Array.from(resolvedPages);
 }, handleAngularCssOnlyUpdate = (state, angularCssFiles, manifest, duration) => {
   const [cssFile] = angularCssFiles;
   if (!cssFile) {
     return;
   }
-  const cssBaseName = basename13(getStyleBaseName(cssFile));
+  const cssBaseName = basename12(getStyleBaseName(cssFile));
   const cssPascalName = toPascal(cssBaseName);
   const cssKey = `${cssPascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
@@ -20433,58 +20292,17 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
     },
     type: "angular-update"
   });
-}, broadcastAngularPageHmrUpdate = (state, angularPagePath, manifest, duration, classification) => {
-  try {
-    const fileName = basename13(angularPagePath);
-    const baseName = fileName.replace(/\.[tj]s$/, "");
-    const pascalName = toPascal(baseName);
-    const cssKey = `${pascalName}CSS`;
-    const cssUrl = manifest[cssKey] || null;
-    logHmrUpdate(angularPagePath, "angular", duration);
-    broadcastToClients(state, {
-      data: {
-        cssBaseName: baseName,
-        cssUrl,
-        editSourceFile: classification.sourceFile,
-        framework: "angular",
-        manifest,
-        reason: classification.reason,
-        sourceFile: angularPagePath,
-        updateType: classification.type
-      },
-      type: "angular-update"
-    });
-  } catch (err) {
-    sendTelemetryEvent("hmr:error", {
-      framework: "angular",
-      message: err instanceof Error ? err.message : String(err)
-    });
-  }
 }, handleAngularHMR = (state, config, filesToRebuild, manifest, duration) => {
-  if (!config.angularDirectory) {
+  if (!config.angularDirectory)
     return;
-  }
   const angularFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "angular");
-  if (angularFiles.length === 0) {
+  if (angularFiles.length === 0)
     return;
-  }
-  broadcastAngularComponentUpdates(state, config.angularDirectory);
   const angularCssFiles = angularFiles.filter(isStylePath);
   const isCssOnlyChange = angularFiles.every(isStylePath) && angularCssFiles.length > 0;
-  const angularPageFiles = angularFiles.filter((file4) => file4.replace(/\\/g, "/").includes("/pages/"));
-  let pagesToUpdate = angularPageFiles;
-  if (pagesToUpdate.length === 0 && state.dependencyGraph) {
-    pagesToUpdate = resolveAngularPagesFromDependencyGraph(state, angularFiles);
-  }
-  if (isCssOnlyChange && angularCssFiles.length > 0) {
+  if (isCssOnlyChange) {
     handleAngularCssOnlyUpdate(state, angularCssFiles, manifest, duration);
-    return;
   }
-  const filesToClassifySlow = filterToUserEdits(angularFiles, state.lastUserEditedFiles);
-  const classification = collapseClassifications(filesToClassifySlow.map(classifyAngularEdit));
-  pagesToUpdate.forEach((angularPagePath) => {
-    broadcastAngularPageHmrUpdate(state, angularPagePath, manifest, duration, classification);
-  });
 }, handleHTMXScriptHMR = (state, filesToRebuild, manifest, duration) => {
   if (!state.resolvedPaths.htmxDir) {
     return;
@@ -20538,7 +20356,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   const shouldRefreshAllPages = htmxPageFiles.length === 0 && shouldRefreshFromIslandChange;
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmxPages, "*.html") : htmxPageFiles;
   await runSequentially(pageFilesToUpdate, async (htmxPageFile) => {
-    const htmxPageName = basename13(htmxPageFile);
+    const htmxPageName = basename12(htmxPageFile);
     const builtHtmxPagePath = resolve35(outputHtmxPages, htmxPageName);
     await processHtmxPageUpdate(state, htmxPageFile, builtHtmxPagePath, manifest, duration);
   });
@@ -20648,7 +20466,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, runSequent
   html = html.slice(0, bodyClose.index) + hmrScript + html.slice(bodyClose.index);
   writeFs(destPath, html);
 }, processMarkupFileFastPath = async (state, sourceFile, outputDir, framework, startTime, updateAssetPaths2, handleUpdate, readFs, writeFs) => {
-  const destPath = resolve35(outputDir, basename13(sourceFile));
+  const destPath = resolve35(outputDir, basename12(sourceFile));
   const hmrScript = extractHmrScript(destPath, readFs);
   const source = await Bun.file(sourceFile).text();
   await Bun.write(destPath, source);
@@ -20894,7 +20712,6 @@ var init_rebuildTrigger = __esm(() => {
   init_compileTailwind();
   init_tailwindCompiler();
   init_ssrCache();
-  init_editTypeDetection();
   moduleServerPromise = Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
   getReactModuleUrl = getModuleUrl;
   EMBER_PAGE_EXTENSIONS = [".gts", ".gjs", ".ts", ".js"];
@@ -20982,7 +20799,7 @@ var toSafeFileName6 = (specifier) => {
     framework: Array.from(framework).filter(isResolvable4)
   };
 }, collectTransitiveImports = async (specs, alreadyVendored, alreadyScanned) => {
-  const { readFileSync: readFileSync21 } = await import("fs");
+  const { readFileSync: readFileSync20 } = await import("fs");
   const transpiler5 = new Bun.Transpiler({ loader: "js" });
   const newSpecs = new Set;
   for (const spec of specs) {
@@ -20997,7 +20814,7 @@ var toSafeFileName6 = (specifier) => {
     }
     let content;
     try {
-      content = readFileSync21(resolved, "utf-8");
+      content = readFileSync20(resolved, "utf-8");
     } catch {
       continue;
     }
@@ -21544,5 +21361,5 @@ export {
   build
 };
 
-//# debugId=694BCF01757C9B7164756E2164756E21
+//# debugId=3DF8C37F7F59DD5A64756E2164756E21
 //# sourceMappingURL=build.js.map