@absolutejs/absolute 0.19.0-beta.930 → 0.19.0-beta.931

package/dist/angular/server.js

@@ -1725,100 +1725,6 @@ var init_svelteServerModule = __esm(() => {
   });
 });
 
-// src/core/vueServerModule.ts
-import { mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname3, join as join5, relative as relative3, resolve as resolve5 } from "path";
-var {Transpiler } = globalThis.Bun;
-var ISLAND_COMPONENT_ID_LENGTH = 8, serverCacheRoot2, compiledModuleCache2, transpiler2, ensureRelativeImportPath2 = (from, target) => {
-  const importPath = relative3(dirname3(from), target).replace(/\\/g, "/");
-  return importPath.startsWith(".") ? importPath : `./${importPath}`;
-}, getCachedModulePath2 = (sourcePath) => {
-  const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
-  const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
-  return join5(serverCacheRoot2, `${normalizedSourcePath}.server.js`);
-}, writeIfChanged2 = async (path, content) => {
-  const targetFile = Bun.file(path);
-  if (await targetFile.exists()) {
-    const currentContent = await targetFile.text();
-    if (currentContent === content)
-      return;
-  }
-  await Bun.write(path, content);
-}, stripExports = (code) => code.replace(/export\s+default/, "const script ="), mergeVueImports = (code) => {
-  const lines = code.split(`
-`);
-  const specifierSet = new Set;
-  const vueImportRegex = /^import\s+{([^}]+)}\s+from\s+['"]vue['"];?$/;
-  lines.forEach((line) => {
-    const match = line.match(vueImportRegex);
-    if (match?.[1])
-      match[1].split(",").forEach((importSpecifier) => specifierSet.add(importSpecifier.trim()));
-  });
-  const nonVueLines = lines.filter((line) => !vueImportRegex.test(line));
-  return specifierSet.size ? [
-    `import { ${[...specifierSet].join(", ")} } from "vue";`,
-    ...nonVueLines
-  ].join(`
-`) : nonVueLines.join(`
-`);
-}, extractRelativeVueImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => typeof importPath === "string" && importPath.startsWith(".") && importPath.endsWith(".vue")), compileVueServerModule = async (sourcePath) => {
-  const cachedModulePath = compiledModuleCache2.get(sourcePath);
-  if (cachedModulePath)
-    return cachedModulePath;
-  const compiler = await import("@vue/compiler-sfc");
-  const source = await Bun.file(sourcePath).text();
-  const { descriptor } = compiler.parse(source, { filename: sourcePath });
-  const componentId = Bun.hash(sourcePath).toString(BASE_36_RADIX).slice(0, ISLAND_COMPONENT_ID_LENGTH);
-  const hasScript = descriptor.script || descriptor.scriptSetup;
-  const compiledScript = hasScript ? compiler.compileScript(descriptor, {
-    id: componentId,
-    inlineTemplate: false
-  }) : { bindings: {}, content: "export default {};" };
-  const renderCode = descriptor.template ? compiler.compileTemplate({
-    compilerOptions: {
-      bindingMetadata: compiledScript.bindings,
-      expressionPlugins: ["typescript"],
-      prefixIdentifiers: true,
-      isCustomElement: (tag) => tag === "absolute-island"
-    },
-    filename: sourcePath,
-    id: componentId,
-    scoped: descriptor.styles.some((styleBlock) => styleBlock.scoped),
-    source: descriptor.template.content,
-    ssr: true,
-    ssrCssVars: descriptor.cssVars
-  }).code : "const ssrRender = () => {};";
-  const childImportPaths = extractRelativeVueImports(compiledScript.content);
-  const compiledChildren = await Promise.all(childImportPaths.map(async (relativeImport) => ({
-    compiledPath: await compileVueServerModule(resolve5(dirname3(sourcePath), relativeImport)),
-    spec: relativeImport
-  })));
-  const strippedScript = stripExports(compiledScript.content);
-  const transpiledScript = transpiler2.transformSync(strippedScript);
-  const assembled = mergeVueImports([
-    transpiledScript,
-    renderCode,
-    "script.ssrRender = ssrRender;",
-    "export default script;"
-  ].join(`
-`));
-  const compiledModulePath = getCachedModulePath2(sourcePath);
-  let rewritten = assembled;
-  for (const child of compiledChildren) {
-    rewritten = rewritten.replaceAll(child.spec, ensureRelativeImportPath2(compiledModulePath, child.compiledPath));
-  }
-  await mkdir2(dirname3(compiledModulePath), { recursive: true });
-  await writeIfChanged2(compiledModulePath, rewritten);
-  compiledModuleCache2.set(sourcePath, compiledModulePath);
-  return compiledModulePath;
-};
-var init_vueServerModule = __esm(() => {
-  init_constants();
-  serverCacheRoot2 = join5(process.cwd(), ".absolutejs", "islands", "vue");
-  compiledModuleCache2 = new Map;
-  transpiler2 = new Transpiler({ loader: "ts", target: "browser" });
-});
-
 // src/core/islandManifest.ts
 var toIslandFrameworkSegment = (framework) => framework[0]?.toUpperCase() + framework.slice(1), collectFrameworkIslands = (manifest, prefix) => {
   const entries = {};
@@ -1905,17 +1811,9 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
   const loadPromise = loadAndCompileServerBuildComponent(buildReferencePath);
   resolvedServerBuildComponentCache.set(buildReferencePath, loadPromise);
   return loadPromise;
-}, resolveRuntimeImportTarget = async (resolvedModulePath) => {
-  if (resolvedModulePath.endsWith(".svelte")) {
-    return compileSvelteServerModule(resolvedModulePath);
-  }
-  if (resolvedModulePath.endsWith(".vue")) {
-    return compileVueServerModule(resolvedModulePath);
-  }
-  return resolvedModulePath;
 }, loadServerImportComponent = async (resolvedComponent, exportName) => {
   const resolvedModulePath = resolvedComponent.startsWith(".") ? new URL(resolvedComponent, import.meta.url).pathname : resolvedComponent;
-  const importTarget = await resolveRuntimeImportTarget(resolvedModulePath);
+  const importTarget = resolvedModulePath.endsWith(".svelte") ? await compileSvelteServerModule(resolvedModulePath) : resolvedModulePath;
   const loadedModule = await import(importTarget);
   if (exportName && exportName !== "default" && exportName in loadedModule) {
     return loadedModule[exportName];
@@ -2019,7 +1917,6 @@ var islandSequence = 0, resolvedServerComponentCache, resolvedServerBuildCompone
 var init_renderIslandMarkup = __esm(() => {
   init_islandSsr();
   init_svelteServerModule();
-  init_vueServerModule();
   init_islandMarkupAttributes();
   init_islands2();
   resolvedServerComponentCache = new Map;
@@ -2862,12 +2759,12 @@ var init_startupBanner = __esm(() => {
 // src/utils/logger.ts
 var colors2, frameworkColors, formatPath = (filePath) => {
   const cwd = process.cwd();
-  let relative4 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
-  relative4 = relative4.replace(/\\/g, "/");
-  if (!relative4.startsWith("/")) {
-    relative4 = `/${relative4}`;
+  let relative3 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+  relative3 = relative3.replace(/\\/g, "/");
+  if (!relative3.startsWith("/")) {
+    relative3 = `/${relative3}`;
   }
-  return relative4;
+  return relative3;
 }, getFrameworkColor = (framework) => frameworkColors[framework] || colors2.white, log = (action, options) => {
   const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
   const tag = `${colors2.cyan}[hmr]${colors2.reset}`;
@@ -3479,8 +3376,8 @@ __export(exports_generatedDir, {
   getGeneratedRoot: () => getGeneratedRoot,
   getFrameworkGeneratedDir: () => getFrameworkGeneratedDir
 });
-import { join as join6 } from "path";
-var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join6(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join6(getGeneratedRoot(projectRoot), framework);
+import { join as join5 } from "path";
+var GENERATED_DIR_NAME = "generated", ABSOLUTE_CACHE_DIR_NAME = ".absolutejs", getGeneratedRoot = (projectRoot = process.cwd()) => join5(projectRoot, ABSOLUTE_CACHE_DIR_NAME, GENERATED_DIR_NAME), getFrameworkGeneratedDir = (framework, projectRoot = process.cwd()) => join5(getGeneratedRoot(projectRoot), framework);
 var init_generatedDir = () => {};
 
 // src/build/compileAngular.ts
@@ -3492,17 +3389,17 @@ __export(exports_compileAngular, {
   compileAngular: () => compileAngular
 });
 import { existsSync as existsSync4, readFileSync as readFileSync4, promises as fs } from "fs";
-import { join as join7, basename as basename3, sep, dirname as dirname4, resolve as resolve6, relative as relative4 } from "path";
+import { join as join6, basename as basename3, sep, dirname as dirname3, resolve as resolve5, relative as relative3 } from "path";
 import ts from "typescript";
 var traceAngularPhase = async (name, fn, metadata) => {
   const tracePhase = globalThis.__absoluteBuildTracePhase;
   return tracePhase ? tracePhase(`compile/angular/${name}`, fn, metadata) : await fn();
 }, readTsconfigPathAliases = () => {
   try {
-    const configPath = resolve6(process.cwd(), "tsconfig.json");
+    const configPath = resolve5(process.cwd(), "tsconfig.json");
     const config = ts.readConfigFile(configPath, ts.sys.readFile).config;
     const compilerOptions = config?.compilerOptions ?? {};
-    const baseUrl = resolve6(process.cwd(), compilerOptions.baseUrl ?? ".");
+    const baseUrl = resolve5(process.cwd(), compilerOptions.baseUrl ?? ".");
     const aliases = Object.entries(compilerOptions.paths ?? {}).map(([pattern, replacements]) => ({ pattern, replacements }));
     return { aliases, baseUrl };
   } catch {
@@ -3522,7 +3419,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     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(resolve6(baseUrl, candidate));
+      const resolved = resolveSourceFile(resolve5(baseUrl, candidate));
       if (resolved)
         return resolved;
     }
@@ -3534,20 +3431,20 @@ var traceAngularPhase = async (name, fn, metadata) => {
     `${candidate}.tsx`,
     `${candidate}.js`,
     `${candidate}.jsx`,
-    join7(candidate, "index.ts"),
-    join7(candidate, "index.tsx"),
-    join7(candidate, "index.js"),
-    join7(candidate, "index.jsx")
+    join6(candidate, "index.ts"),
+    join6(candidate, "index.tsx"),
+    join6(candidate, "index.js"),
+    join6(candidate, "index.jsx")
   ];
   return candidates.find((file) => existsSync4(file));
 }, createLegacyAngularAnimationUsageResolver = (rootDir) => {
-  const baseDir = resolve6(rootDir);
+  const baseDir = resolve5(rootDir);
   const tsconfigAliases = readTsconfigPathAliases();
-  const transpiler3 = new Bun.Transpiler({ loader: "tsx" });
+  const transpiler2 = new Bun.Transpiler({ loader: "tsx" });
   const scanCache = new Map;
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile(resolve6(fromDir, specifier));
+      return resolveSourceFile(resolve5(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile);
     if (aliased)
@@ -3556,7 +3453,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve6(resolved);
+      const absolute = resolve5(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile(absolute);
@@ -3572,7 +3469,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
         usesLegacyAnimations: false
       });
     }
-    const resolved = resolve6(actualPath);
+    const resolved = resolve5(actualPath);
     const cached = scanCache.get(resolved);
     if (cached)
       return cached;
@@ -3585,7 +3482,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
       }
       let imports;
       try {
-        imports = transpiler3.scanImports(sourceCode);
+        imports = transpiler2.scanImports(sourceCode);
       } catch {
         return { imports: [], usesLegacyAnimations: false };
       }
@@ -3601,7 +3498,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     const actualPath = resolveSourceFile(filePath);
     if (!actualPath)
       return false;
-    const resolved = resolve6(actualPath);
+    const resolved = resolve5(actualPath);
     if (visited.has(resolved))
       return false;
     visited.add(resolved);
@@ -3609,7 +3506,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     if (scan.usesLegacyAnimations)
       return true;
     for (const specifier of scan.imports) {
-      const importedPath = resolveLocalImport(specifier, dirname4(resolved));
+      const importedPath = resolveLocalImport(specifier, dirname3(resolved));
       if (importedPath && await visit(importedPath, visited)) {
         return true;
       }
@@ -3619,14 +3516,14 @@ var traceAngularPhase = async (name, fn, metadata) => {
   return (entryPath) => visit(entryPath);
 }, resolveDevClientDir = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve6(import.meta.dir, "../dev/client");
+  const fromSource = resolve5(import.meta.dir, "../dev/client");
   if (existsSync4(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve6(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  const fromNodeModules = resolve5(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
   if (existsSync4(fromNodeModules))
     return fromNodeModules;
-  return resolve6(import.meta.dir, "./dev/client");
+  return resolve5(import.meta.dir, "./dev/client");
 }, devClientDir, hmrClientPath, formatDiagnosticMessage = (diagnostic) => {
   try {
     return ts.flattenDiagnosticMessageText(diagnostic.messageText, `
@@ -3668,12 +3565,12 @@ var traceAngularPhase = async (name, fn, metadata) => {
     return `${path.replace(/\.ts$/, ".js")}${query}`;
   if (hasJsLikeExtension(path))
     return `${path}${query}`;
-  const importerDir = dirname4(importerOutputPath);
-  const fileCandidate = resolve6(importerDir, `${path}.js`);
+  const importerDir = dirname3(importerOutputPath);
+  const fileCandidate = resolve5(importerDir, `${path}.js`);
   if (outputFiles?.has(fileCandidate) || existsSync4(fileCandidate)) {
     return `${path}.js${query}`;
   }
-  const indexCandidate = resolve6(importerDir, path, "index.js");
+  const indexCandidate = resolve5(importerDir, path, "index.js");
   if (outputFiles?.has(indexCandidate) || existsSync4(indexCandidate)) {
     return `${path}/index.js${query}`;
   }
@@ -3701,18 +3598,18 @@ var traceAngularPhase = async (name, fn, metadata) => {
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve6(dirname4(fromFile), specifier);
+  const basePath = resolve5(dirname3(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
     `${basePath}.mts`,
     `${basePath}.cts`,
-    join7(basePath, "index.ts"),
-    join7(basePath, "index.tsx"),
-    join7(basePath, "index.mts"),
-    join7(basePath, "index.cts")
+    join6(basePath, "index.ts"),
+    join6(basePath, "index.tsx"),
+    join6(basePath, "index.mts"),
+    join6(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve6(candidate)).find((candidate) => existsSync4(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve5(candidate)).find((candidate) => existsSync4(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile2) => {
   const hostSource = readFile2?.(fileName);
   if (typeof hostSource === "string")
@@ -3736,18 +3633,18 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const paths = [];
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1])
-    paths.push(join7(fileDir, templateUrlMatch[1]));
+    paths.push(join6(fileDir, templateUrlMatch[1]));
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (styleUrlMatch?.[1])
-    paths.push(join7(fileDir, styleUrlMatch[1]));
+    paths.push(join6(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(join7(fileDir, urlMatch.replace(/['"]/g, "")));
+      paths.push(join6(fileDir, urlMatch.replace(/['"]/g, "")));
     }
   }
-  return paths.map((path) => resolve6(path));
+  return paths.map((path) => resolve5(path));
 }, readResourceCacheFile = async (cachePath) => {
   try {
     const entry = JSON.parse(await fs.readFile(cachePath, "utf-8"));
@@ -3759,13 +3656,13 @@ var traceAngularPhase = async (name, fn, metadata) => {
     return null;
   }
 }, writeResourceCacheFile = async (cachePath, source) => {
-  await fs.mkdir(dirname4(cachePath), { recursive: true });
+  await fs.mkdir(dirname3(cachePath), { recursive: true });
   await fs.writeFile(cachePath, JSON.stringify({
     source,
     version: 1
   }), "utf-8");
 }, resolveResourceTransformCachePath = async (filePath, source, stylePreprocessors) => {
-  const resourcePaths = collectAngularResourcePaths(source, dirname4(filePath));
+  const resourcePaths = collectAngularResourcePaths(source, dirname3(filePath));
   const resourceContents = await Promise.all(resourcePaths.map(async (resourcePath) => {
     const content = await fs.readFile(resourcePath, "utf-8");
     return `${resourcePath}\x00${content}`;
@@ -3778,7 +3675,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     safeStableStringify(stylePreprocessors ?? null)
   ].join("\x00");
   const cacheKey = Bun.hash(cacheInput).toString(BASE_36_RADIX);
-  return join7(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey}.json`);
+  return join6(process.cwd(), ".absolutejs", "cache", "angular-resources", `${cacheKey}.json`);
 }, precomputeAotResourceTransforms = async (inputPaths, readFile2, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
@@ -3789,7 +3686,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
     transformedFiles: 0
   };
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve6(filePath);
+    const resolvedPath = resolve5(filePath);
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
@@ -3805,7 +3702,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
       transformedSource = cached.source;
     } else {
       stats.cacheMisses += 1;
-      const transformed = await inlineResources(source, dirname4(resolvedPath), stylePreprocessors);
+      const transformed = await inlineResources(source, dirname3(resolvedPath), stylePreprocessors);
       transformedSource = transformed.source;
       await writeResourceCacheFile(cachePath, transformedSource);
     }
@@ -3824,7 +3721,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
   return { stats, transformedSources };
 }, compileAngularFiles = async (inputPaths, outDir, stylePreprocessors) => {
   const islandMetadataByOutputPath = await traceAngularPhase("aot/island-metadata", () => new Map(inputPaths.map((inputPath) => {
-    const outputPath = resolve6(join7(outDir, relative4(process.cwd(), resolve6(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
+    const outputPath = resolve5(join6(outDir, relative3(process.cwd(), resolve5(inputPath)).replace(/\.[cm]?[tj]sx?$/, ".js")));
     return [
       outputPath,
       buildIslandMetadataExports(readFileSync4(inputPath, "utf-8"))
@@ -3834,8 +3731,8 @@ var traceAngularPhase = async (name, fn, metadata) => {
   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 = dirname4(tsPath);
-    return tsRootDir.endsWith("lib") ? tsRootDir : resolve6(tsRootDir, "lib");
+    const tsRootDir = dirname3(tsPath);
+    return tsRootDir.endsWith("lib") ? tsRootDir : resolve5(tsRootDir, "lib");
   });
   const config = await traceAngularPhase("aot/read-configuration", () => readConfiguration("./tsconfig.json"));
   const options = {
@@ -3871,13 +3768,13 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const originalGetSourceFile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
     if (fileName.startsWith("lib.") && fileName.endsWith(".d.ts") && tsLibDir) {
-      const resolvedPath = join7(tsLibDir, fileName);
+      const resolvedPath = join6(tsLibDir, fileName);
       return originalGetSourceFile?.call(host, resolvedPath, languageVersion, onError);
     }
     return originalGetSourceFile?.call(host, fileName, languageVersion, onError);
   };
   const emitted = {};
-  const resolvedOutDir = resolve6(outDir);
+  const resolvedOutDir = resolve5(outDir);
   host.writeFile = (fileName, text) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text;
@@ -3899,12 +3796,12 @@ var traceAngularPhase = async (name, fn, metadata) => {
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve6(fileName);
+    const resolvedPath = resolve5(fileName);
     return transformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
   host.getSourceFile = (fileName, languageVersion, onError) => {
-    const source = transformedSources.get(resolve6(fileName));
+    const source = transformedSources.get(resolve5(fileName));
     if (source) {
       return ts.createSourceFile(fileName, source, languageVersion, true);
     }
@@ -3926,9 +3823,9 @@ var traceAngularPhase = async (name, fn, metadata) => {
   const entries = await traceAngularPhase("aot/postprocess-emitted-js", () => {
     const rawEntries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => ({
       content,
-      target: join7(outDir, fileName)
+      target: join6(outDir, fileName)
     }));
-    const outputFiles = new Set(rawEntries.map(({ target }) => resolve6(target)));
+    const outputFiles = new Set(rawEntries.map(({ target }) => resolve5(target)));
     return rawEntries.map(({ content, target }) => {
       let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
         const rewritten = rewriteRelativeJsSpecifier(target, path, outputFiles);
@@ -3943,12 +3840,12 @@ var traceAngularPhase = async (name, fn, metadata) => {
         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(resolve6(target)) ?? "";
+      processedContent += islandMetadataByOutputPath.get(resolve5(target)) ?? "";
       return { content: processedContent, target };
     });
   });
   await traceAngularPhase("aot/write-output", () => Promise.all(entries.map(async ({ target, content }) => {
-    await fs.mkdir(dirname4(target), { recursive: true });
+    await fs.mkdir(dirname3(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 });
@@ -3964,7 +3861,7 @@ var traceAngularPhase = async (name, fn, metadata) => {
   }
   return null;
 }, resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve6(import.meta.dir, "../angular/components/index.ts");
+  const sourceEntry = resolve5(import.meta.dir, "../angular/components/index.ts");
   if (existsSync4(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
@@ -4101,7 +3998,7 @@ ${fields}
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join7(fileDir, templateUrlMatch[1]);
+    const templatePath = join6(fileDir, templateUrlMatch[1]);
     if (!existsSync4(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -4132,7 +4029,7 @@ ${fields}
 }, inlineTemplateAndLowerDeferSync = (source, fileDir) => {
   const templateUrlMatch = findUncommentedMatch(source, /templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
-    const templatePath = join7(fileDir, templateUrlMatch[1]);
+    const templatePath = join6(fileDir, templateUrlMatch[1]);
     if (!existsSync4(templatePath)) {
       throw new Error(`Unable to inline Angular templateUrl "${templateUrlMatch[1]}": file not found at ${templatePath}`);
     }
@@ -4169,7 +4066,7 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join7(fileDir, styleUrl), stylePreprocessors);
+    return readAndEscapeFile(join6(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
@@ -4180,7 +4077,7 @@ ${fields}
   const styleUrlMatch = findUncommentedMatch(source, /styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join7(fileDir, styleUrlMatch[1]), stylePreprocessors);
+  const escaped = await readAndEscapeFile(join6(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.slice(0, styleUrlMatch.index) + `styles: [\`${escaped}\`]` + source.slice(styleUrlMatch.index + styleUrlMatch[0].length);
@@ -4194,10 +4091,10 @@ ${fields}
     source: result
   };
 }, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors, cacheBuster) => {
-  const entryPath = resolve6(inputPath);
+  const entryPath = resolve5(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve6(rootDir ?? process.cwd());
+  const baseDir = resolve5(rootDir ?? process.cwd());
   let usesLegacyAnimations = false;
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
@@ -4215,16 +4112,16 @@ ${fields}
       `${candidate}.tsx`,
       `${candidate}.js`,
       `${candidate}.jsx`,
-      join7(candidate, "index.ts"),
-      join7(candidate, "index.tsx"),
-      join7(candidate, "index.js"),
-      join7(candidate, "index.jsx")
+      join6(candidate, "index.ts"),
+      join6(candidate, "index.tsx"),
+      join6(candidate, "index.js"),
+      join6(candidate, "index.jsx")
     ];
     return candidates.find((file) => existsSync4(file));
   };
   const resolveLocalImport = (specifier, fromDir) => {
     if (specifier.startsWith(".") || specifier.startsWith("/")) {
-      return resolveSourceFile2(resolve6(fromDir, specifier));
+      return resolveSourceFile2(resolve5(fromDir, specifier));
     }
     const aliased = matchTsconfigAlias(specifier, tsconfigAliases.aliases, tsconfigAliases.baseUrl, resolveSourceFile2);
     if (aliased)
@@ -4233,7 +4130,7 @@ ${fields}
       const resolved = Bun.resolveSync(specifier, fromDir);
       if (resolved.includes("/node_modules/"))
         return;
-      const absolute = resolve6(resolved);
+      const absolute = resolve5(resolved);
       if (!absolute.startsWith(baseDir))
         return;
       return resolveSourceFile2(absolute);
@@ -4242,10 +4139,10 @@ ${fields}
     }
   };
   const toOutputPath = (sourcePath) => {
-    const inputDir = dirname4(sourcePath);
+    const inputDir = dirname3(sourcePath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename3(sourcePath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    return join7(outDir, relativeDir, fileBase);
+    return join6(outDir, relativeDir, fileBase);
   };
   const withCacheBuster = (specifier) => {
     if (!cacheBuster)
@@ -4282,13 +4179,13 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve6(actualPath) === entryPath) {
+    if (resolve5(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve6(filePath);
+    const resolved = resolve5(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
@@ -4298,12 +4195,12 @@ ${fields}
     if (!existsSync4(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
-    const inlined = await inlineResources(sourceCode, dirname4(actualPath), stylePreprocessors);
-    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname4(actualPath)).source;
-    const inputDir = dirname4(actualPath);
+    const inlined = await inlineResources(sourceCode, dirname3(actualPath), stylePreprocessors);
+    sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname3(actualPath)).source;
+    const inputDir = dirname3(actualPath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
     const fileBase = basename3(actualPath).replace(/\.[cm]?[tj]sx?$/, ".js");
-    const targetDir = join7(outDir, relativeDir);
+    const targetDir = join6(outDir, relativeDir);
     const targetPath = toOutputPath(actualPath);
     const localImports = [];
     const importRewrites = new Map;
@@ -4325,12 +4222,12 @@ ${fields}
       const resolved2 = resolveLocalImport(specifier, inputDir);
       if (!resolved2)
         return null;
-      const relativeImport = relative4(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
+      const relativeImport = relative3(targetDir, toOutputPath(resolved2)).replace(/\\/g, "/").replace(/\.js$/, "");
       const relativeRewrite = relativeImport.startsWith(".") ? relativeImport : `./${relativeImport}`;
       importRewrites.set(specifier, relativeRewrite);
       return resolved2;
     }).filter((path) => Boolean(path));
-    const isEntry = resolve6(actualPath) === resolve6(entryPath);
+    const isEntry = resolve5(actualPath) === resolve5(entryPath);
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey = actualPath;
     const shouldWriteFile = cacheBuster && isEntry ? true : jitContentCache.get(cacheKey) !== contentHash || !existsSync4(targetPath);
@@ -4364,13 +4261,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     return { clientPaths: [...emptyPaths], serverPaths: [...emptyPaths] };
   }
   const compiledRoot = compiledParent;
-  const indexesDir = join7(compiledParent, "indexes");
+  const indexesDir = join6(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) => resolve6(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
+  const aotOutputs = hmr ? [] : await traceAngularPhase("aot/compile-files", () => compileAngularFiles(entryPoints.map((entry) => resolve5(entry)), compiledRoot, stylePreprocessors), { entries: entryPoints.length });
   const usesLegacyAngularAnimations = await traceAngularPhase("setup/legacy-animation-resolver", () => createLegacyAngularAnimationUsageResolver(outRoot));
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve6(entry);
-    const relativeEntry = relative4(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
+    const resolvedEntry = resolve5(entry);
+    const relativeEntry = relative3(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
     const compileEntry = () => compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors);
     let outputs = hmr ? await traceAngularPhase("jit/compile-entry", compileEntry, {
       entry: resolvedEntry
@@ -4378,13 +4275,13 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     const fileBase = basename3(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
     const compiledFallbackPaths = [
-      join7(compiledRoot, relativeEntry),
-      join7(compiledRoot, "pages", jsName),
-      join7(compiledRoot, jsName)
-    ].map((file) => resolve6(file));
+      join6(compiledRoot, relativeEntry),
+      join6(compiledRoot, "pages", jsName),
+      join6(compiledRoot, jsName)
+    ].map((file) => resolve5(file));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file) => resolve6(file)),
+        ...candidatePaths.map((file) => resolve5(file)),
         ...compiledFallbackPaths
       ];
       let candidate = normalizedCandidates.find((file) => existsSync4(file) && file.endsWith(`${sep}pages${sep}${jsName}`));
@@ -4425,7 +4322,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
     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 = join7(indexesDir, jsName);
+    const clientFile = join6(indexesDir, jsName);
     if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync4(clientFile) && (usesLegacyAnimations || !original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__")) && (!usesLegacyAnimations || original.includes("__ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__"))) {
       return {
         clientPath: clientFile,
@@ -4452,7 +4349,7 @@ export const __ABSOLUTE_PAGE_USES_LEGACY_ANIMATIONS__ = true;
 `;
     }
     await traceAngularPhase("wrapper/write-server-output", () => fs.writeFile(rawServerFile, rewritten, "utf-8"), { entry: resolvedEntry });
-    const relativePath = relative4(indexesDir, rawServerFile).replace(/\\/g, "/");
+    const relativePath = relative3(indexesDir, rawServerFile).replace(/\\/g, "/");
     const normalizedImportPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
     const hmrPreamble = hmr ? `window.__HMR_FRAMEWORK__ = "angular";
 import "${hmrClientPath}";
@@ -4656,7 +4553,7 @@ var init_compileAngular = __esm(() => {
   init_stylePreprocessor();
   init_generatedDir();
   devClientDir = resolveDevClientDir();
-  hmrClientPath = join7(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
+  hmrClientPath = join6(devClientDir, "hmrClient.ts").replace(/\\/g, "/");
   jitContentCache = new Map;
   wrapperOutputCache = new Map;
 });
@@ -4824,9 +4721,9 @@ var provideDeterministicEnv = (options = {}) => {
 // src/angular/pageHandler.ts
 init_constants();
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
-import { mkdir as mkdir3, symlink } from "fs/promises";
+import { mkdir as mkdir2, symlink } from "fs/promises";
 import { tmpdir } from "os";
-import { basename as basename4, dirname as dirname5, join as join8, resolve as resolve7 } from "path";
+import { basename as basename4, dirname as dirname4, join as join7, resolve as resolve6 } from "path";
 import { pathToFileURL } from "url";
 
 // src/core/islandPageContext.ts
@@ -5646,23 +5543,23 @@ var ensureAngularCompiler = () => {
   return compilerImportPromise;
 };
 var readAngularPageModule = (value) => isRecord5(value) ? value : null;
-var resolveAngularSsrOutDir = () => process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR ?? join8(tmpdir(), "absolutejs", "generated", "angular-ssr");
+var resolveAngularSsrOutDir = () => process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR ?? join7(tmpdir(), "absolutejs", "generated", "angular-ssr");
 var createAngularRuntimeCacheBuster = () => `${Date.now().toString(BASE_36_RADIX)}.${Math.random().toString(BASE_36_RADIX).substring(2, RANDOM_ID_END_INDEX)}`;
 var ensureAngularSsrNodeModules = async (outDir) => {
-  const outRoot = resolve7(dirname5(dirname5(outDir)));
-  const nodeModulesLink = join8(outRoot, "node_modules");
+  const outRoot = resolve6(dirname4(dirname4(outDir)));
+  const nodeModulesLink = join7(outRoot, "node_modules");
   if (process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR) {
     return;
   }
-  if (nodeModulesLink === resolve7(process.cwd(), "node_modules")) {
+  if (nodeModulesLink === resolve6(process.cwd(), "node_modules")) {
     return;
   }
   if (await Bun.file(nodeModulesLink).exists()) {
     return;
   }
-  await mkdir3(outRoot, { recursive: true });
+  await mkdir2(outRoot, { recursive: true });
   try {
-    await symlink(resolve7(process.cwd(), "node_modules"), nodeModulesLink, "dir");
+    await symlink(resolve6(process.cwd(), "node_modules"), nodeModulesLink, "dir");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") {
       throw error;
@@ -5820,5 +5717,5 @@ export {
   ABSOLUTE_HTTP_TRANSFER_CACHE_SKIP_HEADER
 };
 
-//# debugId=9DA443ABFADD607864756E2164756E21
+//# debugId=3FD817D68DD9BDA264756E2164756E21
 //# sourceMappingURL=server.js.map