@absolutejs/absolute 0.19.0-beta.807 → 0.19.0-beta.809

package/dist/chunk-92fsjfpp.js

@@ -1,1731 +0,0 @@
-// @bun
-import {
-  buildIslandMetadataExports
-} from "./chunk-a9mvyp04.js";
-import {
-  toPascal
-} from "./chunk-p5504p14.js";
-import {
-  compileStyleFileIfNeeded
-} from "./chunk-xnt8c6h2.js";
-import {
-  BASE_36_RADIX,
-  MILLISECONDS_IN_A_SECOND
-} from "./chunk-qh75agse.js";
-import {
-  __require
-} from "./chunk-bmgqm774.js";
-
-// src/build/compileAngular.ts
-import { existsSync, readFileSync, promises as fs } from "fs";
-import { join, basename, sep, dirname, resolve, relative } from "path";
-import ts from "typescript";
-
-// src/angular/lowerDeferSyntax.ts
-var isInterpolatedExpressionStart = (value, index) => value[index] === "{" && value[index + 1] === "{";
-var skipInterpolatedExpression = (value, start) => {
-  const cursor = start + 2;
-  while (cursor < value.length - 1) {
-    const end = value.indexOf("}}", cursor);
-    if (end < 0) {
-      return value.length;
-    }
-    return end + 2;
-  }
-  return value.length;
-};
-var updateBlockDepth = (char, depth) => {
-  if (char === "{") {
-    return depth + 1;
-  }
-  if (char === "}") {
-    return depth - 1;
-  }
-  return depth;
-};
-var updateParenthesisDepth = (char, depth) => {
-  if (char === "(") {
-    return depth + 1;
-  }
-  if (char === ")") {
-    return depth - 1;
-  }
-  return depth;
-};
-var appendResolvedChunk = (value, template, cursor, interpolationStart) => {
-  const nextTemplate = template + value.slice(cursor, interpolationStart);
-  const nextCursor = skipInterpolatedExpression(value, interpolationStart);
-  if (nextCursor > value.length) {
-    return {
-      bindings: undefined,
-      cursor: value.length,
-      done: true,
-      template: nextTemplate + value.slice(interpolationStart)
-    };
-  }
-  const expression = value.slice(interpolationStart + 2, nextCursor - 2).trim();
-  return {
-    bindings: expression,
-    cursor: nextCursor,
-    done: false,
-    template: nextTemplate
-  };
-};
-var appendTrailingTemplate = (value, template, cursor) => template + value.slice(cursor);
-var consumeDeferredAuxiliaryBlock = (input) => {
-  const parsedBlock = parseDeferredAuxiliaryBlock(input.template, input.cursorAfterResolved, input.keyword);
-  if (!parsedBlock) {
-    return null;
-  }
-  return {
-    content: parsedBlock.content.trim(),
-    nextIndex: input.keyword === "@placeholder" ? skipWhitespace(input.template, parsedBlock.nextIndex) : parsedBlock.nextIndex
-  };
-};
-var resolveDeferSlotStart = (template, deferIndex, markerCursor) => {
-  const nextMarkerCursor = skipWhitespace(template, markerCursor);
-  if (template[nextMarkerCursor] === "{") {
-    return {
-      changed: false,
-      cursor: deferIndex,
-      markerCursor: nextMarkerCursor,
-      templatePrefix: ""
-    };
-  }
-  return {
-    changed: true,
-    cursor: deferIndex + "@defer".length,
-    markerCursor: nextMarkerCursor,
-    templatePrefix: "&#64;defer"
-  };
-};
-var consumeBlockCursor = (value, start, cursor, depth) => {
-  if (isInterpolatedExpressionStart(value, cursor)) {
-    return {
-      cursor: skipInterpolatedExpression(value, cursor),
-      depth,
-      result: null
-    };
-  }
-  const char = value[cursor] ?? "";
-  const nextDepth = updateBlockDepth(char, depth);
-  if (char === "}" && nextDepth === 0) {
-    return {
-      cursor,
-      depth,
-      result: {
-        content: value.slice(start + 1, cursor),
-        nextIndex: cursor + 1
-      }
-    };
-  }
-  return {
-    cursor: cursor + 1,
-    depth: nextDepth,
-    result: null
-  };
-};
-var consumeResolvedTemplateChunk = (value, template, cursor, bindingsLength) => {
-  const interpolationStart = value.indexOf("{{", cursor);
-  if (interpolationStart < 0) {
-    return {
-      binding: null,
-      cursor,
-      done: true,
-      template: appendTrailingTemplate(value, template, cursor)
-    };
-  }
-  const nextChunk = appendResolvedChunk(value, template, cursor, interpolationStart);
-  if (nextChunk.done || nextChunk.bindings === undefined) {
-    return {
-      binding: null,
-      cursor,
-      done: true,
-      template: nextChunk.template
-    };
-  }
-  const key = `e${bindingsLength.toString(BASE_36_RADIX)}`;
-  return {
-    binding: {
-      expression: nextChunk.bindings,
-      key
-    },
-    cursor: nextChunk.cursor,
-    done: false,
-    template: `${nextChunk.template}{{ slotData["${key}"] }}`
-  };
-};
-var readNextDeferBlock = (template, cursor) => {
-  const deferIndex = template.indexOf("@defer", cursor);
-  if (deferIndex < 0) {
-    return null;
-  }
-  return {
-    deferIndex,
-    prefix: template.slice(cursor, deferIndex)
-  };
-};
-var buildDeferredSlot = (input) => {
-  const {
-    cursorAfterResolved,
-    errorHtml,
-    placeholderHtml,
-    resolvedBlock,
-    slotIndex,
-    triggerExpression
-  } = input;
-  const resolvedHtml = resolvedBlock.content.trim();
-  const transformedResolved = transformResolvedTemplate(resolvedHtml);
-  const id = `absolute-angular-defer-${slotIndex.toString(BASE_36_RADIX)}`;
-  const slot = {
-    delayMs: parseDelayMs(triggerExpression),
-    errorHtml,
-    fallbackHtml: placeholderHtml,
-    id,
-    resolvedBindings: transformedResolved.bindings,
-    resolvedHtml,
-    resolvedTemplate: transformedResolved.template
-  };
-  return {
-    cursorAfterResolved,
-    markup: `<abs-defer-slot [id]="'${id}'" [resolve]="__absoluteDeferResolvePayload${slotIndex}">${buildSlotTemplates(slot)}</abs-defer-slot>`,
-    slot
-  };
-};
-var applyConsumedResolvedTemplateChunk = (bindings, nextChunk) => {
-  if (nextChunk.binding) {
-    bindings.push(nextChunk.binding);
-  }
-  return {
-    cursor: nextChunk.done ? Number.POSITIVE_INFINITY : nextChunk.cursor,
-    done: nextChunk.done,
-    template: nextChunk.template
-  };
-};
-var applyConsumedDeferredBlock = (content, parsedBlock, cursorAfterResolved) => {
-  if (!parsedBlock) {
-    return {
-      content,
-      cursorAfterResolved
-    };
-  }
-  return {
-    content: parsedBlock.content || null,
-    cursorAfterResolved: parsedBlock.nextIndex
-  };
-};
-var applyConsumedPlaceholderBlock = (placeholderHtml, parsedBlock, cursorAfterResolved) => {
-  const nextState = applyConsumedDeferredBlock(placeholderHtml, parsedBlock, cursorAfterResolved);
-  return {
-    cursorAfterResolved: nextState.cursorAfterResolved,
-    placeholderHtml: nextState.content ?? ""
-  };
-};
-var applyConsumedErrorBlock = (errorHtml, parsedBlock, cursorAfterResolved) => {
-  const nextState = applyConsumedDeferredBlock(errorHtml, parsedBlock, cursorAfterResolved);
-  return {
-    cursorAfterResolved: nextState.cursorAfterResolved,
-    errorHtml: nextState.content
-  };
-};
-var resolveNextLoweredTemplateChunk = (template, cursor) => {
-  const nextDeferBlock = readNextDeferBlock(template, cursor);
-  if (nextDeferBlock) {
-    return nextDeferBlock;
-  }
-  return {
-    deferIndex: -1,
-    prefix: template.slice(cursor)
-  };
-};
-var applyInvalidDeferSlotStart = (loweredTemplate, slotStart) => {
-  if (!slotStart.changed) {
-    return null;
-  }
-  return {
-    changed: true,
-    cursor: slotStart.cursor,
-    template: loweredTemplate + slotStart.templatePrefix
-  };
-};
-var applyEmptyResolvedBlock = (loweredTemplate, template, deferIndex, resolvedBlock) => {
-  if (resolvedBlock.content.trim()) {
-    return null;
-  }
-  return {
-    cursor: resolvedBlock.nextIndex,
-    template: loweredTemplate + template.slice(deferIndex, resolvedBlock.nextIndex)
-  };
-};
-var applyNextLoweredTemplateChunk = (loweredTemplate, nextDeferBlock) => ({
-  deferIndex: nextDeferBlock.deferIndex,
-  done: nextDeferBlock.deferIndex < 0,
-  template: loweredTemplate + nextDeferBlock.prefix
-});
-var applyParsedSlotStart = (changed, cursor, loweredTemplate, slotStart) => {
-  const invalidSlotStart = applyInvalidDeferSlotStart(loweredTemplate, slotStart);
-  if (!invalidSlotStart) {
-    return {
-      changed,
-      cursor,
-      template: loweredTemplate
-    };
-  }
-  return {
-    changed: true,
-    cursor: invalidSlotStart.cursor,
-    template: invalidSlotStart.template
-  };
-};
-var applyResolvedBlockState = (cursor, loweredTemplate, template, deferIndex, resolvedBlock) => {
-  const emptyResolvedBlock = applyEmptyResolvedBlock(loweredTemplate, template, deferIndex, resolvedBlock);
-  if (!emptyResolvedBlock) {
-    return {
-      cursor,
-      template: loweredTemplate
-    };
-  }
-  return emptyResolvedBlock;
-};
-var consumeResolvedTemplateStep = (value, template, cursor, bindings) => {
-  const nextChunk = consumeResolvedTemplateChunk(value, template, cursor, bindings.length);
-  return applyConsumedResolvedTemplateChunk(bindings, nextChunk);
-};
-var consumeLoweredDeferStep = (input) => {
-  const { changed, cursor, loweredTemplate, slotIndex, slots, template } = input;
-  const nextDeferBlock = resolveNextLoweredTemplateChunk(template, cursor);
-  const nextLoweredChunk = applyNextLoweredTemplateChunk(loweredTemplate, nextDeferBlock);
-  if (nextLoweredChunk.done) {
-    return null;
-  }
-  const { deferIndex } = nextLoweredChunk;
-  let markerCursor = deferIndex + "@defer".length;
-  const triggerInfo = parseOptionalTriggerExpression(template, markerCursor);
-  const { triggerExpression } = triggerInfo;
-  ({ markerCursor } = triggerInfo);
-  const slotStart = resolveDeferSlotStart(template, deferIndex, markerCursor);
-  ({ markerCursor } = slotStart);
-  const slotStartState = applyParsedSlotStart(changed, cursor, nextLoweredChunk.template, slotStart);
-  if (slotStartState.changed !== changed) {
-    return {
-      changed: slotStartState.changed,
-      cursor: slotStartState.cursor,
-      slotIndex,
-      template: slotStartState.template
-    };
-  }
-  const resolvedBlock = skipMatchingBlock(template, markerCursor);
-  const resolvedBlockState = applyResolvedBlockState(cursor, nextLoweredChunk.template, template, deferIndex, resolvedBlock);
-  if (resolvedBlockState.cursor !== cursor) {
-    return {
-      changed,
-      cursor: resolvedBlockState.cursor,
-      slotIndex,
-      template: resolvedBlockState.template
-    };
-  }
-  const blockContent = parsePlaceholderAndErrorBlocks(template, skipWhitespace(template, resolvedBlock.nextIndex));
-  const builtSlot = buildDeferredSlot({
-    cursorAfterResolved: blockContent.cursorAfterResolved,
-    errorHtml: blockContent.errorHtml,
-    placeholderHtml: blockContent.placeholderHtml,
-    resolvedBlock,
-    slotIndex,
-    triggerExpression
-  });
-  slots.push(builtSlot.slot);
-  return {
-    changed: true,
-    cursor: builtSlot.cursorAfterResolved,
-    slotIndex: slotIndex + 1,
-    template: nextLoweredChunk.template + builtSlot.markup
-  };
-};
-var skipMatchingBlock = (value, start) => {
-  if (value[start] !== "{") {
-    return { content: "", nextIndex: start };
-  }
-  let cursor = start + 1;
-  let depth = 1;
-  while (cursor < value.length) {
-    const consumed = consumeBlockCursor(value, start, cursor, depth);
-    if (consumed.result) {
-      return consumed.result;
-    }
-    ({ cursor, depth } = consumed);
-  }
-  return { content: value.slice(start + 1), nextIndex: value.length };
-};
-var skipWhitespace = (value, index) => {
-  let cursor = index;
-  while (cursor < value.length && /\s/.test(value[cursor] ?? "")) {
-    cursor += 1;
-  }
-  return cursor;
-};
-var parseOptionalParenthesizedBlock = (value, index) => {
-  let cursor = skipWhitespace(value, index);
-  if (value[cursor] !== "(") {
-    return null;
-  }
-  cursor += 1;
-  let depth = 1;
-  const start = cursor;
-  while (cursor < value.length) {
-    const char = value[cursor] ?? "";
-    const nextDepth = updateParenthesisDepth(char, depth);
-    if (char === ")" && nextDepth === 0) {
-      return {
-        expression: value.slice(start, cursor),
-        nextIndex: cursor + 1
-      };
-    }
-    depth = nextDepth;
-    cursor += 1;
-  }
-  return { expression: value.slice(start), nextIndex: value.length };
-};
-var parseDelayMs = (triggerExpression) => {
-  if (!triggerExpression)
-    return 0;
-  const timerMsMatch = triggerExpression.match(/timer\(\s*(\d+)\s*ms\s*\)/i);
-  if (timerMsMatch?.[1])
-    return Number.parseInt(timerMsMatch[1], 10);
-  const timerSecondsMatch = triggerExpression.match(/timer\(\s*(\d+)\s*s\s*\)/i);
-  if (timerSecondsMatch?.[1]) {
-    return Number.parseInt(timerSecondsMatch[1], 10) * MILLISECONDS_IN_A_SECOND;
-  }
-  if (/\bon\s+immediate\b/i.test(triggerExpression))
-    return 0;
-  if (/\bon\s+idle\b/i.test(triggerExpression))
-    return 1;
-  return 0;
-};
-var transformResolvedTemplate = (value) => {
-  const bindings = [];
-  let template = "";
-  let cursor = 0;
-  while (cursor < value.length) {
-    const appliedChunk = consumeResolvedTemplateStep(value, template, cursor, bindings);
-    ({ cursor, template } = appliedChunk);
-  }
-  return {
-    bindings,
-    template
-  };
-};
-var parseOptionalTriggerExpression = (template, markerCursor) => {
-  const parsedTrigger = parseOptionalParenthesizedBlock(template, markerCursor);
-  if (!parsedTrigger) {
-    return {
-      markerCursor,
-      triggerExpression: undefined
-    };
-  }
-  return {
-    markerCursor: parsedTrigger.nextIndex,
-    triggerExpression: parsedTrigger.expression.trim()
-  };
-};
-var parseDeferredAuxiliaryBlock = (template, cursorAfterResolved, keyword) => {
-  if (!template.startsWith(keyword, cursorAfterResolved)) {
-    return null;
-  }
-  const blockKeywordCursor = cursorAfterResolved + keyword.length;
-  const blockStart = skipWhitespace(template, blockKeywordCursor);
-  if (template[blockStart] !== "{") {
-    return null;
-  }
-  return skipMatchingBlock(template, blockStart);
-};
-var parsePlaceholderAndErrorBlocks = (template, startCursor) => {
-  let cursorAfterResolved = startCursor;
-  let placeholderHtml = "";
-  let errorHtml = null;
-  const parsedPlaceholder = consumeDeferredAuxiliaryBlock({
-    cursorAfterResolved,
-    keyword: "@placeholder",
-    template
-  });
-  ({ placeholderHtml, cursorAfterResolved } = applyConsumedPlaceholderBlock(placeholderHtml, parsedPlaceholder, cursorAfterResolved));
-  const parsedError = consumeDeferredAuxiliaryBlock({
-    cursorAfterResolved,
-    keyword: "@error",
-    template
-  });
-  ({ errorHtml, cursorAfterResolved } = applyConsumedErrorBlock(errorHtml, parsedError, cursorAfterResolved));
-  return {
-    cursorAfterResolved,
-    errorHtml,
-    placeholderHtml
-  };
-};
-var buildSlotTemplates = (slot) => {
-  const templates = [
-    `<ng-template absDeferResolved let-slotData>${slot.resolvedTemplate}</ng-template>`
-  ];
-  if (slot.fallbackHtml.length > 0) {
-    templates.push(`<ng-template absDeferFallback>${slot.fallbackHtml}</ng-template>`);
-  }
-  if (slot.errorHtml) {
-    templates.push(`<ng-template absDeferError>${slot.errorHtml}</ng-template>`);
-  }
-  return templates.join("");
-};
-var lowerAngularDeferSyntax = (template) => {
-  if (!template.includes("@defer")) {
-    return {
-      slots: [],
-      template,
-      transformed: false
-    };
-  }
-  let cursor = 0;
-  let slotIndex = 0;
-  const slots = [];
-  let loweredTemplate = "";
-  let changed = false;
-  let nextState = consumeLoweredDeferStep({
-    changed,
-    cursor,
-    loweredTemplate,
-    slotIndex,
-    slots,
-    template
-  });
-  while (nextState) {
-    ({ changed, cursor, slotIndex, template: loweredTemplate } = nextState);
-    nextState = consumeLoweredDeferStep({
-      changed,
-      cursor,
-      loweredTemplate,
-      slotIndex,
-      slots,
-      template
-    });
-  }
-  const transformedTemplate = slots.length > 0 ? loweredTemplate + template.slice(cursor) : template.replaceAll("@defer", "&#64;defer");
-  return {
-    slots,
-    template: transformedTemplate,
-    transformed: slots.length > 0
-  };
-};
-
-// src/build/compileAngular.ts
-var traceAngularPhase = async (name, fn, metadata) => {
-  const tracePhase = globalThis.__absoluteBuildTracePhase;
-  return tracePhase ? tracePhase(`compile/angular/${name}`, fn, metadata) : await fn();
-};
-var readTsconfigPathAliases = () => {
-  try {
-    const configPath = resolve(process.cwd(), "tsconfig.json");
-    const config = ts.readConfigFile(configPath, ts.sys.readFile).config;
-    const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve(process.cwd(), compilerOptions.baseUrl ?? ".");
-    const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
-    return { aliases, baseUrl };
-  } catch {
-    return { aliases: [], baseUrl: process.cwd() };
-  }
-};
-var matchTsconfigAlias = (specifier, aliases, baseUrl, resolveSourceFile) => {
-  for (const alias of aliases) {
-    const wildcardIndex = alias.pattern.indexOf("*");
-    const exactMatch = wildcardIndex === -1;
-    if (exactMatch && specifier !== alias.pattern)
-      continue;
-    const prefix = exactMatch ? alias.pattern : alias.pattern.slice(0, wildcardIndex);
-    const suffix = exactMatch ? "" : alias.pattern.slice(wildcardIndex + 1);
-    if (!exactMatch && (!specifier.startsWith(prefix) || !specifier.endsWith(suffix))) {
-      continue;
-    }
-    const wildcardValue = exactMatch ? "" : specifier.slice(prefix.length, specifier.length - suffix.length);
-    for (const replacement of alias.replacements) {
-      const candidate = replacement.replace("*", wildcardValue);
-      const resolved = resolveSourceFile(resolve(baseUrl, candidate));
-      if (resolved)
-        return resolved;
-    }
-  }
-  return;
-};
-var resolveSourceFile = (candidate) => {
-  const candidates = candidate.match(/\.[cm]?[tj]sx?$/) ? [candidate] : [
-    `${candidate}.ts`,
-    `${candidate}.tsx`,
-    `${candidate}.js`,
-    `${candidate}.jsx`,
-    join(candidate, "index.ts"),
-    join(candidate, "index.tsx"),
-    join(candidate, "index.js"),
-    join(candidate, "index.jsx")
-  ];
-  return candidates.find((file) => existsSync(file));
-};
-var createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve(rootDir);
-  const tsconfigAliases = readTsconfigPathAliases();
-  const transpiler = new Bun.Transpiler({ loader: "tsx" });
-  const scanCache = new Map;
-  const resolveLocalImport = (specifier, fromDir) => {
-    if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile(resolve(fromDir, specifier));
-    }
-    const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
-    if (aliased)
-      return aliased;
-    try {
-      const resolved = Bun.resolveSync(specifier, fromDir);
-      if (resolved.includes("/node_modules/"))
-        return;
-      const absolute = resolve(resolved);
-      if (!absolute.startsWith(baseDir))
-        return;
-      return resolveSourceFile(absolute);
-    } catch {
-      return;
-    }
-  };
-  const scanFile = (filePath) => {
-    const actualPath = resolveSourceFile(filePath);
-    if (!actualPath) {
-      return Promise.resolve({
-        imports: [],
-        usesLegacyAnimations: false
-      });
-    }
-    const resolved = resolve(actualPath);
-    const cached = scanCache.get(resolved);
-    if (cached)
-      return cached;
-    const promise = (async () => {
-      let sourceCode;
-      try {
-        sourceCode = await fs.readFile(resolved, "utf-8");
-      } catch {
-        return { imports: [], usesLegacyAnimations: false };
-      }
-      let imports;
-      try {
-        imports = transpiler.scanImports(sourceCode);
-      } catch {
-        return { imports: [], usesLegacyAnimations: false };
-      }
-      return {
-        imports: imports.map((imp) => imp.path),
-        usesLegacyAnimations: imports.some((imp) => imp.path === "@angular/animations")
-      };
-    })();
-    scanCache.set(resolved, promise);
-    return promise;
-  };
-  const visit = async (filePath, visited = new Set) => {
-    const actualPath = resolveSourceFile(filePath);
-    if (!actualPath)
-      return false;
-    const resolved = resolve(actualPath);
-    if (visited.has(resolved))
-      return false;
-    visited.add(resolved);
-    const scan = await scanFile(resolved);
-    if (scan.usesLegacyAnimations)
-      return true;
-    for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname(resolved));
-      if (importedPath && await visit(importedPath, visited)) {
-        return true;
-      }
-    }
-    return false;
-  };
-  return (entryPath) => visit(entryPath);
-};
-var resolveDevClientDir = () => {
-  const projectRoot = process.cwd();
-  const fromSource = resolve(import.meta.dir, "../dev/client");
-  if (existsSync(fromSource) && fromSource.startsWith(projectRoot)) {
-    return fromSource;
-  }
-  const fromNodeModules = resolve(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync(fromNodeModules))
-    return fromNodeModules;
-  return resolve(import.meta.dir, "./dev/client");
-};
-var devClientDir = resolveDevClientDir();
-var hmrClientPath = join(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
-var hmrRuntimePath = join(devClientDir, "handlers", "angularRuntime.ts").replace(/\\/g, "/");
-var injectHMRRegistration = (content, sourceId) => {
-  const componentClassRegex = /(?:export\s+)?class\s+(\w+Component)\s/g;
-  const componentNames = [];
-  let match;
-  while ((match = componentClassRegex.exec(content)) !== null) {
-    if (match[1])
-      componentNames.push(match[1]);
-  }
-  if (componentNames.length === 0)
-    return content;
-  const registrations = componentNames.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;
-};
-var formatDiagnosticMessage = (diagnostic) => {
-  try {
-    return ts.flattenDiagnosticMessageText(diagnostic.messageText, `
-`);
-  } catch {
-    return String(diagnostic.messageText || "Unknown error");
-  }
-};
-var throwOnCompilationErrors = (diagnostics) => {
-  if (!diagnostics?.length)
-    return;
-  const errors = diagnostics.filter((diag) => diag.category === ts.DiagnosticCategory.Error);
-  if (!errors.length)
-    return;
-  const fullMessage = errors.map(formatDiagnosticMessage).join(`
-`);
-  console.error("Angular compilation errors:", fullMessage);
-  throw new Error(fullMessage);
-};
-var resolveRelativePath = (fileName, resolvedOutDir, outDir) => {
-  if (fileName.startsWith(resolvedOutDir))
-    return fileName.substring(resolvedOutDir.length + 1);
-  if (fileName.startsWith(outDir))
-    return fileName.substring(outDir.length + 1);
-  return fileName;
-};
-var hasJsLikeExtension = (path) => /\.(js|ts|mjs|cjs)$/.test(path);
-var rewriteRelativeJsSpecifier = (importerOutputPath, specifier, outputFiles) => {
-  if (specifier.endsWith(".ts"))
-    return specifier.replace(/\.ts$/, ".js");
-  if (hasJsLikeExtension(specifier))
-    return specifier;
-  const importerDir = dirname(importerOutputPath);
-  const fileCandidate = resolve(importerDir, `${specifier}.js`);
-  if (outputFiles?.has(fileCandidate) || existsSync(fileCandidate)) {
-    return `${specifier}.js`;
-  }
-  const indexCandidate = resolve(importerDir, specifier, "index.js");
-  if (outputFiles?.has(indexCandidate) || existsSync(indexCandidate)) {
-    return `${specifier}/index.js`;
-  }
-  return `${specifier}.js`;
-};
-var isRelativeModuleSpecifier = (specifier) => specifier.startsWith("./") || specifier.startsWith("../");
-var extractLocalImportSpecifiers = (source, fileName) => {
-  const sourceFile = ts.createSourceFile(fileName, source, ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
-  const specifiers = [];
-  const addSpecifier = (node) => {
-    if (!node || !ts.isStringLiteralLike(node))
-      return;
-    const specifier = node.text;
-    if (isRelativeModuleSpecifier(specifier))
-      specifiers.push(specifier);
-  };
-  const visit = (node) => {
-    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
-      addSpecifier(node.moduleSpecifier);
-    } else if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword) {
-      addSpecifier(node.arguments[0]);
-    }
-    ts.forEachChild(node, visit);
-  };
-  visit(sourceFile);
-  return specifiers;
-};
-var resolveLocalTsImport = (fromFile, specifier) => {
-  if (!isRelativeModuleSpecifier(specifier))
-    return null;
-  const basePath = resolve(dirname(fromFile), specifier);
-  const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
-    `${basePath}.ts`,
-    `${basePath}.tsx`,
-    `${basePath}.mts`,
-    `${basePath}.cts`,
-    join(basePath, "index.ts"),
-    join(basePath, "index.tsx"),
-    join(basePath, "index.mts"),
-    join(basePath, "index.cts")
-  ];
-  return candidates.map((candidate) => resolve(candidate)).find((candidate) => existsSync(candidate) && !candidate.endsWith(".d.ts")) ?? null;
-};
-var readFileForAotTransform = async (fileName, readFile) => {
-  const hostSource = readFile?.(fileName);
-  if (typeof hostSource === "string")
-    return hostSource;
-  return fs.readFile(fileName, "utf-8");
-};
-var safeStableStringify = (value) => {
-  const seen = new WeakSet;
-  return JSON.stringify(value, (_key, entry) => {
-    if (typeof entry === "function")
-      return `[Function:${entry.name}]`;
-    if (!entry || typeof entry !== "object")
-      return entry;
-    if (seen.has(entry))
-      return "[Circular]";
-    seen.add(entry);
-    if (Array.isArray(entry))
-      return entry;
-    return Object.fromEntries(Object.entries(entry).sort(([left], [right]) => left.localeCompare(right)));
-  });
-};
-var collectAngularResourcePaths = (source, fileDir) => {
-  const paths = [];
-  const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
-  if (templateUrlMatch?.[1])
-    paths.push(join(fileDir, templateUrlMatch[1]));
-  const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
-  if (styleUrlMatch?.[1])
-    paths.push(join(fileDir, styleUrlMatch[1]));
-  const styleUrlsMatch = findUncommentedMatch(source, /styleUrls\s*:\s*\[([^\]]+)\]/);
-  const urlMatches = styleUrlsMatch?.[1]?.match(/['"]([^'"]+)['"]/g);
-  if (urlMatches) {
-    for (const urlMatch of urlMatches) {
-      paths.push(join(fileDir, urlMatch.replace(/['"]/g, "")));
-    }
-  }
-  return paths.map((path) => resolve(path));
-};
-var readResourceCacheFile = async (cachePath) => {
-  try {
-    const entry = JSON.parse(await fs.readFile(cachePath, "utf-8"));
-    if (entry.version !== 1 || typeof entry.source !== "string") {
-      return null;
-    }
-    return entry;
-  } catch {
-    return null;
-  }
-};
-var writeResourceCacheFile = async (cachePath, source) => {
-  await fs.mkdir(dirname(cachePath), { recursive: true });
-  await fs.writeFile(cachePath, JSON.stringify({
-    source,
-    version: 1
-  }), "utf-8");
-};
-var resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname(filePath));
-  const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
-    const content = await fs.readFile(resourcePath, "utf-8");
-    return `${resourcePath}\x00${content}`;
-  }));
-  const cacheInput = [
-    "v1",
-    filePath,
-    source,
-    ...resourceContents,
-    safeStableStringify(stylePreprocessors ?? null)
-  ].join("\x00");
-  const cacheKey = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey}.json`);
-};
-var precomputeAotResourceTransforms = async (inputPaths, readFile, stylePreprocessors) => {
-  const transformedSources = new Map;
-  const visited = new Set;
-  const stats = {
-    cacheHits: 0,
-    cacheMisses: 0,
-    filesVisited: 0,
-    transformedFiles: 0
-  };
-  const transformFile = async (filePath) => {
-    const resolvedPath = resolve(filePath);
-    if (visited.has(resolvedPath))
-      return;
-    visited.add(resolvedPath);
-    if (!existsSync(resolvedPath) || resolvedPath.endsWith(".d.ts"))
-      return;
-    stats.filesVisited += 1;
-    const source = await readFileForAotTransform(resolvedPath, readFile);
-    const cachePath = await resolveResourceTransformCachePath(resolvedPath, source, stylePreprocessors);
-    const cached = await readResourceCacheFile(cachePath);
-    let transformedSource;
-    if (cached) {
-      stats.cacheHits += 1;
-      transformedSource = cached.source;
-    } else {
-      stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname(resolvedPath), stylePreprocessors);
-      transformedSource = transformed.source;
-      await writeResourceCacheFile(cachePath, transformedSource);
-    }
-    if (transformedSource !== source) {
-      stats.transformedFiles += 1;
-      transformedSources.set(resolvedPath, transformedSource);
-    }
-    const imports = extractLocalImportSpecifiers(source, resolvedPath);
-    await Promise.all(imports.map(async (specifier) => {
-      const resolvedImport = resolveLocalTsImport(resolvedPath, specifier);
-      if (resolvedImport)
-        await transformFile(resolvedImport);
-    }));
-  };
-  await Promise.all(inputPaths.map((inputPath) => transformFile(inputPath)));
-  return { stats, transformedSources };
-};
-var compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
-  const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve(join(outDir, relative(process.cwd(), resolve(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
-    return [
-      outputPath,
-      buildIslandMetadataExports(readFileSync(inputPath, "utf-8"))
-    ];
-  })), { entries: inputPaths.length });
-  await traceAngularPhase("aot/preload-compiler", () => import("@angular/compiler"));
-  const { readConfiguration, performCompilation, EmitFlags } = await traceAngularPhase("aot/import-compiler-cli", () => import("@angular/compiler-cli"));
-  const tsLibDir = await traceAngularPhase("aot/resolve-typescript-lib", () => {
-    const tsPath = __require.resolve("typescript");
-    const tsRootDir = dirname(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve(tsRootDir, "lib");
-  });
-  const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
-  const options = {
-    emitDecoratorMetadata: true,
-    esModuleInterop: true,
-    experimentalDecorators: true,
-    module: ts.ModuleKind.ESNext,
-    moduleResolution: ts.ModuleResolutionKind.Bundler,
-    newLine: ts.NewLineKind.LineFeed,
-    noLib: false,
-    outDir,
-    skipLibCheck: true,
-    target: ts.ScriptTarget.ES2022,
-    ...config.options
-  };
-  options.target = ts.ScriptTarget.ES2022;
-  options.experimentalDecorators = true;
-  options.emitDecoratorMetadata = true;
-  options.newLine = ts.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", () => ts.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 basename(fileName);
-  };
-  const originalGetSourceFile = host.getSourceFile;
-  host.getSourceFile = (fileName, languageVersion, onError) => {
-    if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-      const resolvedPath = join(tsLibDir, fileName);
-      return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
-    }
-    return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
-  };
-  const emitted = {};
-  const resolvedOutDir = resolve(outDir);
-  host.writeFile = (fileName, text) => {
-    const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
-    emitted[relativePath] = text;
-  };
-  const originalReadFile = host.readFile;
-  const { stats: aotResourceTransformStats, transformedSources } = await traceAngularPhase("aot/precompute-resources", () => precomputeAotResourceTransforms(inputPaths, originalReadFile?.bind(host), stylePreprocessors), { entries: inputPaths.length });
-  await traceAngularPhase("aot/resource-cache-summary", () => {
-    return;
-  }, {
-    cacheHits: aotResourceTransformStats.cacheHits,
-    cacheMisses: aotResourceTransformStats.cacheMisses,
-    filesVisited: aotResourceTransformStats.filesVisited,
-    transformedFiles: aotResourceTransformStats.transformedFiles
-  });
-  host.readFile = (fileName) => {
-    const source = originalReadFile ? originalReadFile.call(host, fileName) : undefined;
-    if (typeof source !== "string")
-      return source;
-    if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
-      return source;
-    }
-    const resolvedPath = resolve(fileName);
-    return transformedSources.get(resolvedPath) ?? source;
-  };
-  const originalGetSourceFileForCompile = host.getSourceFile;
-  host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve(fileName));
-    if (source) {
-      return ts.createSourceFile(fileName, source, languageVersion, true);
-    }
-    return originalGetSourceFileForCompile?.call(host, fileName, languageVersion, onError);
-  };
-  let diagnostics;
-  try {
-    ({ diagnostics } = await traceAngularPhase("aot/perform-compilation", () => performCompilation({
-      emitFlags: EmitFlags.Default,
-      host,
-      options,
-      rootNames: inputPaths
-    }), { entries: inputPaths.length }));
-  } finally {
-    host.readFile = originalReadFile;
-    host.getSourceFile = originalGetSourceFileForCompile;
-  }
-  await traceAngularPhase("aot/check-diagnostics", () => throwOnCompilationErrors(diagnostics));
-  const entries = await traceAngularPhase("aot/postprocess-emitted-js", () => {
-    const rawEntries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => ({
-      content,
-      target: join(outDir, fileName)
-    }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve(target)));
-    return rawEntries.map(({ content, target }) => {
-      let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
-        const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
-        if (rewritten !== path) {
-          return `from ${quote}${rewritten}${quote}`;
-        }
-        return match;
-      });
-      processedContent = processedContent.replace(/\u0275\u0275domElementStart/g, "\u0275\u0275elementStart").replace(/\u0275\u0275domElementEnd/g, "\u0275\u0275elementEnd").replace(/\u0275\u0275domElement\(/g, "\u0275\u0275element(").replace(/\u0275\u0275domProperty/g, "\u0275\u0275property").replace(/\u0275\u0275domListener/g, "\u0275\u0275listener");
-      processedContent = processedContent.replace(/import\s*{\s*([^}]*)\bInjectFlags\b([^}]*)\s*}\s*from\s*['"]@angular\/core['"]/g, (match, before, after) => {
-        const cleaned = (before + after).replace(/,\s*,/g, ",").replace(/^\s*,\s*/, "").replace(/,\s*$/, "");
-        return cleaned ? `import { ${cleaned}, InternalInjectFlags } from '@angular/core'` : `import { InternalInjectFlags } from '@angular/core'`;
-      });
-      processedContent = processedContent.replace(/\b(?<!Internal)InjectFlags\b/g, "InternalInjectFlags");
-      processedContent += islandMetadataByOutputPath.get(resolve(target)) ?? "";
-      return { content: processedContent, target };
-    });
-  });
-  await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs.mkdir(dirname(target), { recursive: true });
-    await fs.writeFile(target, content, "utf-8");
-  })), { outputs: entries.length });
-  return await traceAngularPhase("aot/collect-output-paths", () => entries.map(({ target }) => target), { outputs: entries.length });
-};
-var compileAngularFile = async (inputPath, outDir, stylePreprocessors) => compileAngularFiles([inputPath], outDir, stylePreprocessors);
-var jitContentCache = new Map;
-var wrapperOutputCache = new Map;
-var escapeTemplateContent = (content) => content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
-var findUncommentedMatch = (source, pattern) => {
-  const re = new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : pattern.flags + "g");
-  let match;
-  while ((match = re.exec(source)) !== null) {
-    const lineStart = source.lastIndexOf(`
-`, match.index - 1) + 1;
-    const beforeMatch = source.slice(lineStart, match.index);
-    if (!/^\s*\/\//.test(beforeMatch))
-      return match;
-  }
-  return null;
-};
-var resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve(import.meta.dir, "../angular/components/index.ts");
-  if (existsSync(sourceEntry)) {
-    return sourceEntry.replace(/\\/g, "/");
-  }
-  return "@absolutejs/absolute/angular/components";
-};
-var ensureDeferSlotImport = (source, importSpecifier = "@absolutejs/absolute/angular/components") => {
-  if (source.includes("DeferSlotComponent"))
-    return source;
-  const resolvedImportSpecifier = JSON.stringify(importSpecifier);
-  const importLine = `import { DeferErrorTemplateDirective, DeferFallbackTemplateDirective, DeferResolvedTemplateDirective, DeferSlotComponent } from ${resolvedImportSpecifier};
-`;
-  const lastImportMatch = [...source.matchAll(/^import[\s\S]*?;$/gm)].pop();
-  if (!lastImportMatch || lastImportMatch.index === undefined) {
-    return importLine + source;
-  }
-  const insertAt = lastImportMatch.index + lastImportMatch[0].length;
-  return `${source.slice(0, insertAt)}
-${importLine}${source.slice(insertAt)}`;
-};
-var ensureComponentImportsHasDeferSlot = (source) => {
-  const importListMatch = source.match(/imports\s*:\s*\[([\s\S]*?)\]/);
-  if (importListMatch) {
-    if (/\bDeferSlotComponent\b/.test(importListMatch[1] ?? "") && /\bDeferResolvedTemplateDirective\b/.test(importListMatch[1] ?? "") && /\bDeferFallbackTemplateDirective\b/.test(importListMatch[1] ?? "") && /\bDeferErrorTemplateDirective\b/.test(importListMatch[1] ?? "")) {
-      return source;
-    }
-    return source.replace(/imports\s*:\s*\[([\s\S]*?)\]/, (match, importsContent) => {
-      const trimmed = importsContent.trim();
-      const entries = trimmed.split(",").map((entry) => entry.trim()).filter(Boolean);
-      for (const requiredImport of [
-        "DeferSlotComponent",
-        "DeferResolvedTemplateDirective",
-        "DeferFallbackTemplateDirective",
-        "DeferErrorTemplateDirective"
-      ]) {
-        if (!entries.includes(requiredImport)) {
-          entries.push(requiredImport);
-        }
-      }
-      const nextContent = entries.join(", ");
-      return `imports: [${nextContent}]`;
-    });
-  }
-  return source.replace(/@Component\(\s*{/, `@Component({
-	imports: [DeferSlotComponent, DeferResolvedTemplateDirective, DeferFallbackTemplateDirective, DeferErrorTemplateDirective],`);
-};
-var escapeTemplateLiteralValue = (value) => value.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
-var skipInterpolatedExpression2 = (value, start) => {
-  const cursor = start + 2;
-  while (cursor < value.length - 1) {
-    const end = value.indexOf("}}", cursor);
-    if (end < 0) {
-      return value.length;
-    }
-    return end + 2;
-  }
-  return value.length;
-};
-var buildResolverTemplateLiteral = (value) => {
-  const parts = [];
-  let cursor = 0;
-  while (cursor < value.length) {
-    const interpolationStart = value.indexOf("{{", cursor);
-    if (interpolationStart < 0) {
-      parts.push(escapeTemplateLiteralValue(value.slice(cursor)));
-      break;
-    }
-    parts.push(escapeTemplateLiteralValue(value.slice(cursor, interpolationStart)));
-    const nextCursor = skipInterpolatedExpression2(value, interpolationStart);
-    if (nextCursor >= value.length) {
-      parts.push(escapeTemplateLiteralValue(value.slice(interpolationStart)));
-      break;
-    }
-    const rawExpression = value.slice(interpolationStart + 2, nextCursor - 2).trim();
-    const expression = rawExpression.length === 0 ? "''" : rawExpression;
-    const expressionLiteral = JSON.stringify(expression);
-    parts.push(`\${this.__absoluteDeferResolveTemplateExpression(${expressionLiteral})}`);
-    cursor = nextCursor;
-  }
-  return parts.join("");
-};
-var buildDeferSlotTemplateResolver = () => `	__absoluteDeferTemplateExpressionCache = new Map<string, string>();
-` + `	__absoluteDeferResolveTemplateExpression(expression: string) {
-` + `		const cached = this.__absoluteDeferTemplateExpressionCache.get(expression);
-` + `		if (cached !== undefined) return cached;
-` + `
-` + `		const scope = new Proxy(this, {
-` + `			get: (_target, property) => {
-` + `				const value = (this as Record<PropertyKey, unknown>)[property];
-` + `				return typeof value === "function" ? value.bind(this) : value;
-` + `			}
-` + `		});
-` + `		let value = '';
-` + `		try {
-` + `			const evaluate = new Function(
-` + `				'scope',
-` + `				"with (scope) { return (" + expression + "); }"
-` + `			);
-` + `
-` + `			const resolvedValue = evaluate(scope);
-` + `			value = resolvedValue == null ? '' : String(resolvedValue);
-` + `		} catch (_error) {
-` + `			value = '';
-` + `		}
-` + `		this.__absoluteDeferTemplateExpressionCache.set(expression, value);
-` + `		return value;
-` + `	}
-
-`;
-var buildDeferSlotFields = (slots) => [
-  buildDeferSlotTemplateResolver(),
-  ...slots.map((slot, index) => {
-    const htmlField = `	__absoluteDeferHtml${index} = () => \`${buildResolverTemplateLiteral(slot.resolvedHtml)}\`;
-`;
-    const dataField = slot.resolvedBindings.length > 0 ? `	__absoluteDeferData${index} = () => ({
-${slot.resolvedBindings.map((binding) => `		"${binding.key}": this.__absoluteDeferResolveTemplateExpression(${JSON.stringify(binding.expression)})`).join(`,
-`)}
-	});
-` : `	__absoluteDeferData${index} = () => ({});
-`;
-    return `${htmlField + dataField}	__absoluteDeferResolvePayload${index} = () => new Promise<any>((resolve) => {
-` + `		setTimeout(() => resolve({ kind: 'angular-defer', state: 'resolved', html: this.__absoluteDeferHtml${index}(), data: this.__absoluteDeferData${index}() }), ${slot.delayMs});
-` + `	});
-`;
-  })
-].join(`
-`);
-var injectDeferSlotFields = (source, slots, importSpecifier = "@absolutejs/absolute/angular") => {
-  if (slots.length === 0)
-    return source;
-  let rewritten = ensureDeferSlotImport(source, importSpecifier);
-  rewritten = ensureComponentImportsHasDeferSlot(rewritten);
-  const fields = buildDeferSlotFields(slots);
-  return rewritten.replace(/export(?:\s+default)?\s+class\s+([A-Za-z_$][\w$]*)\s*{/, (match) => `${match}
-${fields}
-`);
-};
-var readAndEscapeFile = async (filePath, stylePreprocessors) => {
-  if (!existsSync(filePath)) {
-    throw new Error(`Unable to inline Angular style resource: file not found at ${filePath}`);
-  }
-  const content = await compileStyleFileIfNeeded(filePath, stylePreprocessors);
-  return escapeTemplateContent(content);
-};
-var inlineTemplateAndLowerDefer = async (source, fileDir) => {
-  const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
-  if (templateUrlMatch?.[1]) {
-    const templatePath = join(fileDir, templateUrlMatch[1]);
-    if (!existsSync(templatePath)) {
-      throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
-    }
-    const templateRaw2 = await fs.readFile(templatePath, "utf-8");
-    const lowered2 = lowerAngularDeferSyntax(templateRaw2);
-    const escaped2 = escapeTemplateContent(lowered2.template);
-    const replacedSource2 = source.slice(0, templateUrlMatch.index) + `template: \`${escaped2}\`` + source.slice(templateUrlMatch.index + templateUrlMatch[0].length);
-    return {
-      deferSlots: lowered2.slots,
-      source: injectDeferSlotFields(replacedSource2, lowered2.slots, resolveAngularDeferImportSpecifier())
-    };
-  }
-  const inlineTemplateMatch = findUncommentedMatch(source, /template\s*:\s*(`([\s\S]*?)`|'([^']*)'|"([^"]*)")/);
-  if (!inlineTemplateMatch) {
-    return { deferSlots: [], source };
-  }
-  const templateRaw = inlineTemplateMatch[2] ?? inlineTemplateMatch[3] ?? inlineTemplateMatch[4] ?? "";
-  const lowered = lowerAngularDeferSyntax(templateRaw);
-  if (lowered.slots.length === 0 && lowered.template === templateRaw) {
-    return { deferSlots: lowered.slots, source };
-  }
-  const escaped = escapeTemplateContent(lowered.template);
-  const replacedSource = source.slice(0, inlineTemplateMatch.index) + `template: \`${escaped}\`` + source.slice(inlineTemplateMatch.index + inlineTemplateMatch[0].length);
-  return {
-    deferSlots: lowered.slots,
-    source: injectDeferSlotFields(replacedSource, lowered.slots, resolveAngularDeferImportSpecifier())
-  };
-};
-var inlineTemplateAndLowerDeferSync = (source, fileDir) => {
-  const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
-  if (templateUrlMatch?.[1]) {
-    const templatePath = join(fileDir, templateUrlMatch[1]);
-    if (!existsSync(templatePath)) {
-      throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
-    }
-    const templateRaw2 = readFileSync(templatePath, "utf-8");
-    const lowered2 = lowerAngularDeferSyntax(templateRaw2);
-    const escaped2 = escapeTemplateContent(lowered2.template);
-    const replacedSource2 = source.slice(0, templateUrlMatch.index) + `template: \`${escaped2}\`` + source.slice(templateUrlMatch.index + templateUrlMatch[0].length);
-    return {
-      deferSlots: lowered2.slots,
-      source: injectDeferSlotFields(replacedSource2, lowered2.slots, resolveAngularDeferImportSpecifier())
-    };
-  }
-  const inlineTemplateMatch = findUncommentedMatch(source, /template\s*:\s*(`([\s\S]*?)`|'([^']*)'|"([^"]*)")/);
-  if (!inlineTemplateMatch) {
-    return { deferSlots: [], source };
-  }
-  const templateRaw = inlineTemplateMatch[2] ?? inlineTemplateMatch[3] ?? inlineTemplateMatch[4] ?? "";
-  const lowered = lowerAngularDeferSyntax(templateRaw);
-  if (lowered.slots.length === 0 && lowered.template === templateRaw) {
-    return { deferSlots: lowered.slots, source };
-  }
-  const escaped = escapeTemplateContent(lowered.template);
-  const replacedSource = source.slice(0, inlineTemplateMatch.index) + `template: \`${escaped}\`` + source.slice(inlineTemplateMatch.index + inlineTemplateMatch[0].length);
-  return {
-    deferSlots: lowered.slots,
-    source: injectDeferSlotFields(replacedSource, lowered.slots, resolveAngularDeferImportSpecifier())
-  };
-};
-var inlineStyleUrls = async (source, fileDir, stylePreprocessors) => {
-  const styleUrlsMatch = findUncommentedMatch(source, /styleUrls\s*:\s*\[([^\]]+)\]/);
-  if (!styleUrlsMatch?.[1])
-    return source;
-  const urlMatches = styleUrlsMatch[1].match(/['"]([^'"]+)['"]/g);
-  if (!urlMatches)
-    return source;
-  const stylePromises = urlMatches.map((urlMatch) => {
-    const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join(fileDir, styleUrl), stylePreprocessors);
-  });
-  const results = await Promise.all(stylePromises);
-  const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
-  if (inlinedStyles.length === 0)
-    return source;
-  return source.slice(0, styleUrlsMatch.index) + `styles: [${inlinedStyles.join(", ")}]` + source.slice(styleUrlsMatch.index + styleUrlsMatch[0].length);
-};
-var inlineSingleStyleUrl = async (source, fileDir, stylePreprocessors) => {
-  const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
-  if (!styleUrlMatch?.[1])
-    return source;
-  const escaped = await readAndEscapeFile(join(fileDir, styleUrlMatch[1]), stylePreprocessors);
-  if (!escaped)
-    return source;
-  return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
-};
-var inlineResources = async (source, fileDir, stylePreprocessors) => {
-  const inlinedTemplate = await inlineTemplateAndLowerDefer(source, fileDir);
-  let result = inlinedTemplate.source;
-  result = await inlineStyleUrls(result, fileDir, stylePreprocessors);
-  result = await inlineSingleStyleUrl(result, fileDir, stylePreprocessors);
-  return {
-    deferSlots: inlinedTemplate.deferSlots,
-    source: result
-  };
-};
-var compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors) => {
-  const entryPath = resolve(inputPath);
-  const allOutputs = [];
-  const visited = new Set;
-  const baseDir = resolve(rootDir ?? process.cwd());
-  let usesLegacyAnimations = false;
-  const angularTranspiler = new Bun.Transpiler({
-    loader: "ts",
-    tsconfig: JSON.stringify({
-      compilerOptions: {
-        emitDecoratorMetadata: true,
-        experimentalDecorators: true
-      }
-    })
-  });
-  const tsconfigAliases = readTsconfigPathAliases();
-  const resolveSourceFile2 = (candidate) => {
-    const candidates = candidate.match(/\.[cm]?[tj]sx?$/) ? [candidate] : [
-      `${candidate}.ts`,
-      `${candidate}.tsx`,
-      `${candidate}.js`,
-      `${candidate}.jsx`,
-      join(candidate, "index.ts"),
-      join(candidate, "index.tsx"),
-      join(candidate, "index.js"),
-      join(candidate, "index.jsx")
-    ];
-    return candidates.find((file) => existsSync(file));
-  };
-  const resolveLocalImport = (specifier, fromDir) => {
-    if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve(fromDir, specifier));
-    }
-    const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
-    if (aliased)
-      return aliased;
-    try {
-      const resolved = Bun.resolveSync(specifier, fromDir);
-      if (resolved.includes("/node_modules/"))
-        return;
-      const absolute = resolve(resolved);
-      if (!absolute.startsWith(baseDir))
-        return;
-      return resolveSourceFile2(absolute);
-    } catch {
-      return;
-    }
-  };
-  const toOutputPath = (sourcePath) => {
-    const inputDir = dirname(sourcePath);
-    const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
-    const fileBase = basename(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    return join(outDir, relativeDir, fileBase);
-  };
-  const transpileAndRewrite = (sourceCode, relativeDir, actualPath, importRewrites) => {
-    let processedContent = angularTranspiler.transformSync(sourceCode);
-    const outputPath = toOutputPath(actualPath);
-    const rewriteBareImport = (prefix, specifier, suffix) => {
-      const rewritten = importRewrites.get(specifier);
-      if (rewritten) {
-        return `${prefix}${rewritten}${suffix}`;
-      }
-      if (specifier.startsWith(".") || specifier.startsWith("/")) {
-        return `${prefix}${specifier}${suffix}`;
-      }
-      return `${prefix}${specifier}${suffix}`;
-    };
-    processedContent = processedContent.replace(/(from\s+['"])([^'"]+)(['"])/g, (_, prefix, specifier, suffix) => rewriteBareImport(prefix, specifier, suffix));
-    processedContent = processedContent.replace(/(import\s+['"])([^'"]+)(['"])/g, (_, prefix, specifier, suffix) => rewriteBareImport(prefix, specifier, suffix));
-    processedContent = processedContent.replace(/(import\(\s*['"])([^'"]+)(['"]\s*\))/g, (_, prefix, specifier, suffix) => rewriteBareImport(prefix, specifier, suffix));
-    processedContent = processedContent.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
-      const rewritten = rewriteRelativeJsSpecifier(outputPath, path);
-      if (rewritten !== path) {
-        return `from ${quote}${rewritten}${quote}`;
-      }
-      return match;
-    });
-    const relDepth = relativeDir === "" || relativeDir === "." ? 0 : relativeDir.split("/").length;
-    processedContent = processedContent.replace(/(from\s+['"])(\.\.\/(?:\.\.\/)*)/g, (_, prefix, dots) => {
-      const upCount = dots.split("/").length - 1;
-      if (upCount <= relDepth)
-        return `${prefix}${dots}`;
-      return `${prefix}../${dots}`;
-    });
-    if (resolve(actualPath) === entryPath) {
-      processedContent += buildIslandMetadataExports(sourceCode);
-    }
-    return processedContent;
-  };
-  const transpileFile = async (filePath) => {
-    const resolved = resolve(filePath);
-    if (visited.has(resolved))
-      return;
-    visited.add(resolved);
-    let actualPath = resolved;
-    if (!actualPath.endsWith(".ts"))
-      actualPath += ".ts";
-    if (!existsSync(actualPath))
-      return;
-    let sourceCode = await fs.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname(actualPath)).source;
-    const inputDir = dirname(actualPath);
-    const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
-    const fileBase = basename(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    const targetDir = join(outDir, relativeDir);
-    const targetPath = toOutputPath(actualPath);
-    const localImports = [];
-    const importRewrites = new Map;
-    const fromRegex = /(?:from|import)\s+['"]([^'".][^'"]*|\.\.?\/[^'"]+)['"]/g;
-    const dynamicImportRegex = /import\(\s*['"]([^'".][^'"]*|\.\.?\/[^'"]+)['"]\s*\)/g;
-    let importMatch;
-    while ((importMatch = fromRegex.exec(sourceCode)) !== null) {
-      if (importMatch[1])
-        localImports.push(importMatch[1]);
-    }
-    while ((importMatch = dynamicImportRegex.exec(sourceCode)) !== null) {
-      if (importMatch[1])
-        localImports.push(importMatch[1]);
-    }
-    if (localImports.includes("@angular/animations")) {
-      usesLegacyAnimations = true;
-    }
-    const localImportPaths = localImports.map((specifier) => {
-      const resolved2 = resolveLocalImport(specifier, inputDir);
-      if (!resolved2)
-        return null;
-      const relativeImport = relative(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
-      importRewrites.set(specifier, relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`);
-      return resolved2;
-    }).filter((path) => Boolean(path));
-    const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
-    const cacheKey = actualPath;
-    if (jitContentCache.get(cacheKey) === contentHash && existsSync(targetPath)) {
-      allOutputs.push(targetPath);
-    } else {
-      const processedContent = transpileAndRewrite(sourceCode, relativeDir, actualPath, importRewrites);
-      await fs.mkdir(targetDir, { recursive: true });
-      await fs.writeFile(targetPath, processedContent, "utf-8");
-      allOutputs.push(targetPath);
-      jitContentCache.set(cacheKey, contentHash);
-    }
-    await Promise.all(localImportPaths.map((importPath) => transpileFile(importPath)));
-  };
-  await transpileFile(inputPath);
-  const entryOutputPath = toOutputPath(entryPath);
-  if (existsSync(entryOutputPath)) {
-    const entryOutput = await fs.readFile(entryOutputPath, "utf-8");
-    const withoutLegacyFlag = entryOutput.replace(/\nexport const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;\n?/g, `
-`);
-    const nextEntryOutput = usesLegacyAnimations ? `${withoutLegacyFlag}
-export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
-` : withoutLegacyFlag;
-    if (nextEntryOutput !== entryOutput) {
-      await fs.writeFile(entryOutputPath, nextEntryOutput, "utf-8");
-    }
-  }
-  return allOutputs;
-};
-var compileAngular = async (entryPoints, outRoot, hmr = false, stylePreprocessors) => {
-  const compiledParent = join(outRoot, "generated");
-  if (entryPoints.length === 0) {
-    const emptyPaths = [];
-    return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
-  }
-  const compiledRoot = compiledParent;
-  const indexesDir = join(compiledParent, "indexes");
-  await traceAngularPhase("setup/create-indexes-dir", () => fs.mkdir(indexesDir, { recursive: true }));
-  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
-  const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
-  const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve(entry);
-    const relativeEntry = relative(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
-    const compileEntry = () => compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors);
-    let outputs = hmr ? await traceAngularPhase("jit/compile-entry", compileEntry, {
-      entry: resolvedEntry
-    }) : aotOutputs;
-    const fileBase = basename(resolvedEntry).replace(/\.[tj]s$/, "");
-    const jsName = `${fileBase}.js`;
-    const compiledFallbackPaths = [
-      join(compiledRoot, relativeEntry),
-      join(compiledRoot, "pages", jsName),
-      join(compiledRoot, jsName)
-    ].map((file) => resolve(file));
-    const resolveRawServerFile = (candidatePaths) => {
-      const normalizedCandidates = [
-        ...candidatePaths.map((file) => resolve(file)),
-        ...compiledFallbackPaths
-      ];
-      let candidate = normalizedCandidates.find((file) => existsSync(file) && file.endsWith(`${sep}pages${sep}${jsName}`));
-      if (!candidate) {
-        candidate = normalizedCandidates.find((file) => existsSync(file) && file.endsWith(`${sep}${jsName}`));
-      }
-      if (!candidate) {
-        candidate = normalizedCandidates.find((file) => existsSync(file));
-      }
-      return candidate;
-    };
-    let rawServerFile = await traceAngularPhase("wrapper/resolve-server-output", () => resolveRawServerFile(outputs), { entry: resolvedEntry });
-    if (!rawServerFile) {
-      rawServerFile = await traceAngularPhase("wrapper/resolve-server-output-fallback", () => resolveRawServerFile([]), { entry: resolvedEntry });
-    }
-    if (rawServerFile && !existsSync(rawServerFile)) {
-      outputs = hmr ? await compileEntry() : aotOutputs;
-      rawServerFile = await traceAngularPhase("wrapper/resolve-server-output-retry", () => resolveRawServerFile(outputs), { entry: resolvedEntry });
-    }
-    if (!rawServerFile || !existsSync(rawServerFile)) {
-      throw new Error(`Compiled output not found for ${entry}. Looking for: ${jsName}. Available: ${[
-        ...outputs,
-        ...compiledFallbackPaths
-      ].join(", ")}`);
-    }
-    const original = await traceAngularPhase("wrapper/read-server-output", () => fs.readFile(rawServerFile, "utf-8"), { entry: resolvedEntry });
-    const detectExportedComponentClass = (source, fallback) => {
-      const defaultMatch = source.match(/export\s+default\s+([A-Za-z_$][\w$]*)\s*;/);
-      if (defaultMatch)
-        return defaultMatch[1];
-      const exportClassMatch = source.match(/export\s+(?:default\s+)?class\s+([A-Za-z_$][\w$]*)/);
-      if (exportClassMatch)
-        return exportClassMatch[1];
-      return fallback;
-    };
-    const componentClassName = await traceAngularPhase("wrapper/detect-component-class", () => detectExportedComponentClass(original, `${toPascal(fileBase)}Component`), { entry: resolvedEntry });
-    const usesLegacyAnimations = await traceAngularPhase("wrapper/detect-legacy-animations", () => usesLegacyAngularAnimations(resolvedEntry), { entry: resolvedEntry });
-    const serverContentHash = Bun.hash(original).toString(BASE_36_RADIX);
-    const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
-    const clientFile = join(indexesDir, jsName);
-    if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
-      return {
-        clientPath: clientFile,
-        indexUnchanged: true,
-        serverPath: rawServerFile
-      };
-    }
-    let rewritten = original;
-    rewritten = rewritten.replace(/\nexport const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;\n?/g, `
-`);
-    if (!rewritten.includes(`import '@angular/compiler';`)) {
-      rewritten = `import '@angular/compiler';
-${rewritten}`;
-    }
-    rewritten = rewritten.replace(new RegExp(`templateUrl:\\s*['"]\\.\\/${fileBase}\\.html['"]`), `templateUrl: '../../pages/${fileBase}.html'`);
-    if (!rewritten.includes("export default")) {
-      rewritten += `
-export default ${componentClassName};
-`;
-    }
-    if (usesLegacyAnimations) {
-      rewritten += `
-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 = relative(indexesDir, rawServerFile).replace(/\\/g, "/");
-    const normalizedImportPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
-    const hmrPreamble = hmr ? `window.__HMR_FRAMEWORK__ = "angular";
-import "${hmrRuntimePath}";
-import "${hmrClientPath}";
-` : "";
-    const hydration = hmr ? `${hmrPreamble}
-import '@angular/compiler';
-import { bootstrapApplication } from '@angular/platform-browser';
-import { provideClientHydration } from '@angular/platform-browser';
-import { withHttpTransferCacheOptions } from '@angular/platform-browser';
-import { provideZonelessChangeDetection } from '@angular/core';
-import * as pageModule from '${normalizedImportPath}';
-
-var ${componentClassName} = pageModule.default;
-var toScreamingSnake = function(str) {
-    return str.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
-};
-var isInjectionToken = function(value) {
-    return Boolean(value) && typeof value === 'object' && value.ngMetadataName === 'InjectionToken';
-};
-var pageProps = window.__ABS_ANGULAR_PAGE_PROPS__ || {};
-var pageHasIslands = Boolean(pageModule.__ABSOLUTE_PAGE_HAS_ISLANDS__) || Boolean(document.querySelector('[data-island="true"]'));
-var pageHasRawStreamingSlots = Boolean(document.querySelector('[data-absolute-raw-slot="true"]'));
-var pageHasStreamingSlots = Boolean(document.querySelector('[data-absolute-slot="true"]'));
-var propProviders = Object.entries(pageProps).map(function(entry) {
-    var propName = entry[0];
-    var propValue = entry[1];
-    var token = pageModule[toScreamingSnake(propName)];
-    return isInjectionToken(token) ? { provide: token, useValue: propValue } : null;
-}).filter(Boolean);
-// Page-level providers, opt-in via \`export const providers = [...]\` in the
-// page module. Required so DI tokens that the component (or any service it
-// injects) needs are available client-side too \u2014 without these, services
-// that worked in SSR fail with NG0201 after hydration.
-var maybePageProviders = Reflect.get(pageModule, 'providers');
-var pageProviders = Array.isArray(maybePageProviders) ? maybePageProviders : [];
-var absoluteHttpTransferCacheOptions = {
-    includePostRequests: false,
-    includeRequestsWithAuthHeaders: false,
-    filter: function(request) {
-        return !request.headers.has('x-skip-transfer-cache');
-    }
-};
-
-// 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}';
-
-// 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);
-}
-
-// 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));
-    }
-
-    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) {
-        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';
-import { bootstrapApplication } from '@angular/platform-browser';
-import { provideClientHydration } from '@angular/platform-browser';
-import { withHttpTransferCacheOptions } from '@angular/platform-browser';
-import { enableProdMode, provideZonelessChangeDetection } from '@angular/core';
-import * as pageModule from '${normalizedImportPath}';
-
-var ${componentClassName} = pageModule.default;
-var toScreamingSnake = function(str) {
-    return str.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toUpperCase();
-};
-var isInjectionToken = function(value) {
-    return Boolean(value) && typeof value === 'object' && value.ngMetadataName === 'InjectionToken';
-};
-var pageProps = window.__ABS_ANGULAR_PAGE_PROPS__ || {};
-var pageHasIslands = Boolean(pageModule.__ABSOLUTE_PAGE_HAS_ISLANDS__) || Boolean(document.querySelector('[data-island="true"]'));
-var pageHasRawStreamingSlots = Boolean(document.querySelector('[data-absolute-raw-slot="true"]'));
-var pageHasStreamingSlots = Boolean(document.querySelector('[data-absolute-slot="true"]'));
-var propProviders = Object.entries(pageProps).map(function(entry) {
-    var propName = entry[0];
-    var propValue = entry[1];
-    var token = pageModule[toScreamingSnake(propName)];
-    return isInjectionToken(token) ? { provide: token, useValue: propValue } : null;
-}).filter(Boolean);
-// Page-level providers, opt-in via \`export const providers = [...]\` in the
-// page module. Required so DI tokens that the component (or any service it
-// injects) needs are available client-side too \u2014 without these, services
-// that worked in SSR fail with NG0201 after hydration.
-var maybePageProviders = Reflect.get(pageModule, 'providers');
-var pageProviders = Array.isArray(maybePageProviders) ? maybePageProviders : [];
-var absoluteHttpTransferCacheOptions = {
-    includePostRequests: false,
-    includeRequestsWithAuthHeaders: false,
-    filter: function(request) {
-        return !request.headers.has('x-skip-transfer-cache');
-    }
-};
-
-enableProdMode();
-
-var providers = [provideZonelessChangeDetection()].concat(pageProviders).concat(propProviders);
-if (!pageHasIslands) {
-    providers.unshift(provideClientHydration(withHttpTransferCacheOptions(absoluteHttpTransferCacheOptions)));
-}
-window.__ABS_SLOT_HYDRATION_PENDING__ = 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__();
-            });
-        }
-    });
-}
-`.trim();
-    const indexHash = Bun.hash(hydration).toString(BASE_36_RADIX);
-    const indexUnchanged = cachedWrapper?.indexHash === indexHash;
-    await traceAngularPhase("wrapper/write-client-index", () => fs.writeFile(clientFile, hydration, "utf-8"), { entry: resolvedEntry });
-    wrapperOutputCache.set(resolvedEntry, {
-      indexHash,
-      serverHash: serverContentHash
-    });
-    return {
-      clientPath: clientFile,
-      indexUnchanged,
-      serverPath: rawServerFile
-    };
-  });
-  const results = await traceAngularPhase("wrapper/process-entries", () => Promise.all(compileTasks), { entries: entryPoints.length });
-  const { clientPaths, serverPaths } = await traceAngularPhase("wrapper/collect-paths", () => ({
-    clientPaths: results.map((r) => r.clientPath),
-    serverPaths: results.map((r) => r.serverPath)
-  }), { entries: results.length });
-  return {
-    allIndexesUnchanged: hmr && results.every((r) => r.indexUnchanged),
-    clientPaths,
-    serverPaths
-  };
-};
-export {
-  compileAngularFiles,
-  compileAngularFileJIT,
-  compileAngularFile,
-  compileAngular
-};
-
-//# debugId=F70C8C2EEC6A3A1764756E2164756E21
-//# sourceMappingURL=chunk-92fsjfpp.js.map