@absolutejs/absolute 0.12.4 → 0.12.5

package/dist/index.js

@@ -1,22 +1,4 @@
 // @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __require = import.meta.require;
-
 // src/constants.ts
 var UNFOUND_INDEX = -1;
 var SECONDS_IN_A_MINUTE = 60;
@@ -31,638 +13,23 @@ var DEFAULT_PORT = 3000;
 var DEFAULT_CHUNK_SIZE = 16384;
 var BUN_BUILD_WARNING_SUPPRESSION = "wildcard sideEffects are not supported yet";
 var ANGULAR_BUILD_WARNING_SUPPRESSION = "@angular/common/package.json";
-// src/core/angularPatch.ts
-function getStackTrace() {
-  const stack = new Error().stack;
-  return stack ? stack.split(`
-`).slice(2, 10).join(`
-`) : "No stack trace available";
-}
-function createDocumentProxy(doc) {
-  if (!doc || typeof doc !== "object")
-    return doc;
-  if (doc.__absolutejs_proxied)
-    return doc;
-  console.log("\uD83D\uDD0D [ANGULAR PATCH] Creating document proxy:", {
-    hasHead: !!doc.head,
-    headIsNull: doc.head === null,
-    headType: typeof doc.head,
-    stack: getStackTrace()
-  });
-  if (doc.head === null || doc.head === undefined) {
-    const fakeHead = {
-      children: []
-    };
-    fakeHead.children.length = 0;
-    Object.defineProperty(fakeHead, "item", {
-      value: () => null,
-      writable: false,
-      enumerable: false,
-      configurable: false
-    });
-    try {
-      Object.defineProperty(doc, "head", {
-        value: fakeHead,
-        writable: true,
-        enumerable: true,
-        configurable: true
-      });
-    } catch (error) {}
-  } else if (doc.head && typeof doc.head === "object") {
-    if (!doc.head.children || typeof doc.head.children.length === "undefined") {
-      const elementNodes = Array.from(doc.head.childNodes || []).filter((node) => node.nodeType === 1);
-      const childrenArray = [];
-      elementNodes.forEach((node, index) => {
-        childrenArray[index] = node;
-      });
-      childrenArray.length = elementNodes.length;
-      try {
-        Object.defineProperty(doc.head, "children", {
-          value: childrenArray,
-          writable: false,
-          enumerable: true,
-          configurable: false
-        });
-      } catch (error) {}
-    }
-    if (doc.head && typeof doc.head.querySelectorAll !== "function") {
-      try {
-        Object.defineProperty(doc.head, "querySelectorAll", {
-          value: function(selector) {
-            if (doc.querySelectorAll) {
-              const all = doc.querySelectorAll(selector);
-              return Array.from(all).filter((el) => el.parentElement === doc.head || doc.head.contains(el));
-            }
-            return [];
-          },
-          writable: true,
-          enumerable: false,
-          configurable: true
-        });
-      } catch (error) {}
-    }
-    if (doc.head && typeof doc.head.querySelector !== "function") {
-      try {
-        Object.defineProperty(doc.head, "querySelector", {
-          value: function(selector) {
-            if (doc.querySelector) {
-              const el = doc.querySelector(selector);
-              if (el && (el.parentElement === doc.head || doc.head.contains(el))) {
-                return el;
-              }
-            }
-            return null;
-          },
-          writable: true,
-          enumerable: false,
-          configurable: true
-        });
-      } catch (error) {}
-    }
-  }
-  const proxy = new Proxy(doc, {
-    get(target, prop) {
-      if (prop === "head") {
-        console.log("\uD83D\uDD0D [ANGULAR PATCH] Proxy: head property accessed:", {
-          hasHead: !!target.head,
-          headIsNull: target.head === null,
-          headType: typeof target.head,
-          stack: getStackTrace()
-        });
-        const head = target.head;
-        if (!head || head === null) {
-          console.warn("\u26A0\uFE0F [ANGULAR PATCH] Proxy: head is null, returning fake head proxy");
-          return new Proxy({}, {
-            get(_target, headProp) {
-              console.log("\uD83D\uDD0D [ANGULAR PATCH] Fake head proxy: property accessed:", headProp, {
-                stack: getStackTrace()
-              });
-              if (headProp === "children") {
-                console.log("\u2705 [ANGULAR PATCH] Fake head proxy: returning empty children array");
-                const emptyChildren = [];
-                emptyChildren.length = 0;
-                Object.defineProperty(emptyChildren, "item", {
-                  value: () => null,
-                  writable: false,
-                  enumerable: false,
-                  configurable: false
-                });
-                return emptyChildren;
-              }
-              if (headProp === "querySelectorAll") {
-                return function(selector) {
-                  const emptyNodeList = [];
-                  emptyNodeList.length = 0;
-                  return emptyNodeList;
-                };
-              }
-              if (headProp === "querySelector") {
-                return function(selector) {
-                  return null;
-                };
-              }
-              return;
-            },
-            has() {
-              return true;
-            },
-            ownKeys() {
-              return ["children"];
-            },
-            getOwnPropertyDescriptor() {
-              return {
-                enumerable: true,
-                configurable: false,
-                writable: false,
-                value: []
-              };
-            }
-          });
-        }
-        if (head && typeof head === "object") {
-          return createHeadProxy(head);
-        }
-        return head;
-      }
-      const value = target[prop];
-      if (typeof value === "function") {
-        return value.bind(target);
-      }
-      return value;
-    },
-    set(target, prop, value) {
-      target[prop] = value;
-      return true;
-    },
-    has(target, prop) {
-      return prop in target;
-    },
-    ownKeys(target) {
-      return Reflect.ownKeys(target);
-    }
-  });
-  Object.defineProperty(doc, "__absolutejs_proxied", {
-    value: true,
-    writable: false,
-    configurable: false,
-    enumerable: false
-  });
-  return proxy;
-}
-function createHeadProxy(head) {
-  if (head && typeof head === "object") {
-    if (typeof head.querySelectorAll !== "function") {
-      try {
-        Object.defineProperty(head, "querySelectorAll", {
-          value: function(selector) {
-            if (head.ownerDocument && head.ownerDocument.querySelectorAll) {
-              const all = head.ownerDocument.querySelectorAll(selector);
-              return Array.from(all).filter((el) => el.parentElement === head || head.contains(el));
-            }
-            return [];
-          },
-          writable: true,
-          enumerable: false,
-          configurable: true
-        });
-      } catch (e) {}
-    }
-    if (typeof head.querySelector !== "function") {
-      try {
-        Object.defineProperty(head, "querySelector", {
-          value: function(selector) {
-            if (head.ownerDocument && head.ownerDocument.querySelector) {
-              const el = head.ownerDocument.querySelector(selector);
-              if (el && (el.parentElement === head || head.contains(el))) {
-                return el;
-              }
-            }
-            return null;
-          },
-          writable: true,
-          enumerable: false,
-          configurable: true
-        });
-      } catch (e) {}
-    }
-  }
-  if (!head || typeof head !== "object")
-    return head;
-  if (head.__absolutejs_head_proxied)
-    return head;
-  const proxy = new Proxy(head, {
-    get(target, prop) {
-      if (prop === "children") {
-        const children = target.children;
-        if (!children || typeof children.length === "undefined") {
-          const elementNodes = Array.from(target.childNodes || []).filter((node) => node.nodeType === 1);
-          const childrenArray = [];
-          elementNodes.forEach((node, index) => {
-            childrenArray[index] = node;
-          });
-          childrenArray.length = elementNodes.length;
-          return childrenArray;
-        }
-        return children;
-      }
-      if (prop === "querySelectorAll" && typeof target.querySelectorAll !== "function") {
-        return function(selector) {
-          if (target.ownerDocument && target.ownerDocument.querySelectorAll) {
-            const all = target.ownerDocument.querySelectorAll(selector);
-            return Array.from(all).filter((el) => el.parentElement === target || target.contains(el));
-          }
-          return [];
-        };
-      }
-      if (prop === "querySelector" && typeof target.querySelector !== "function") {
-        return function(selector) {
-          if (target.ownerDocument && target.ownerDocument.querySelector) {
-            const el = target.ownerDocument.querySelector(selector);
-            if (el && (el.parentElement === target || target.contains(el))) {
-              return el;
-            }
-          }
-          return null;
-        };
-      }
-      const value = target[prop];
-      if (typeof value === "function") {
-        return value.bind(target);
-      }
-      return value;
-    }
-  });
-  Object.defineProperty(head, "__absolutejs_head_proxied", {
-    value: true,
-    writable: false,
-    configurable: false,
-    enumerable: false
-  });
-  return proxy;
-}
-var patchesApplied = (async () => {
-  try {
-    try {
-      const originalErrorHandler = globalThis.onerror;
-      globalThis.onerror = function(message, source, lineno, colno, error) {
-        if (typeof message === "string" && message.includes("doc.head.children")) {
-          console.error("\uD83D\uDEA8 [ANGULAR PATCH] Caught doc.head.children error:", {
-            message,
-            source,
-            lineno,
-            colno,
-            error,
-            stack: error?.stack || "No stack trace"
-          });
-        }
-        if (originalErrorHandler) {
-          return originalErrorHandler.call(this, message, source, lineno, colno, error);
-        }
-        return false;
-      };
-    } catch (error) {
-      console.warn("\u26A0\uFE0F [ANGULAR PATCH] Failed to set global error handler:", error);
-    }
-    try {
-      const originalUnhandledRejection = globalThis.onunhandledrejection;
-      globalThis.onunhandledrejection = function(event) {
-        if (event.reason && typeof event.reason === "object" && event.reason.message && event.reason.message.includes("doc.head.children")) {
-          console.error("\uD83D\uDEA8 [ANGULAR PATCH] Unhandled rejection with doc.head.children error:", {
-            reason: event.reason,
-            stack: event.reason?.stack || "No stack trace"
-          });
-        }
-        if (originalUnhandledRejection) {
-          return originalUnhandledRejection.call(this, event);
-        }
-      };
-    } catch (error) {
-      console.warn("\u26A0\uFE0F [ANGULAR PATCH] Failed to set unhandled rejection handler:", error);
-    }
-    const [common, platformServer] = await Promise.all([
-      import("@angular/common"),
-      import("@angular/platform-server")
-    ]);
-    console.log("\u2705 [ANGULAR PATCH] Angular modules imported, starting patches...");
-    const _getDOM = common.\u{275}getDOM;
-    if (_getDOM) {
-      const originalGetDOM = _getDOM;
-      try {
-        Object.defineProperty(common, "\u0275getDOM", {
-          value: function() {
-            const domAdapter = originalGetDOM();
-            if (domAdapter && typeof domAdapter.getBaseHref === "function") {
-              const adapter = domAdapter;
-              if (!adapter.__absolutejs_originalGetBaseHref) {
-                adapter.__absolutejs_originalGetBaseHref = domAdapter.getBaseHref.bind(domAdapter);
-              }
-              Object.defineProperty(domAdapter, "getBaseHref", {
-                value: function(doc) {
-                  console.log("\uD83D\uDD0D [ANGULAR PATCH] getBaseHref called via _getDOM():", {
-                    hasDoc: !!doc,
-                    hasHead: !!doc?.head,
-                    headIsNull: doc?.head === null,
-                    headType: typeof doc?.head,
-                    hasChildren: !!doc?.head?.children,
-                    childrenType: typeof doc?.head?.children,
-                    stack: getStackTrace()
-                  });
-                  if (!doc || !doc.head || typeof doc.head.children === "undefined") {
-                    console.warn("\u26A0\uFE0F [ANGULAR PATCH] getBaseHref (_getDOM): Returning empty string due to null/undefined head or children");
-                    return "";
-                  }
-                  const result = adapter.__absolutejs_originalGetBaseHref.call(this, doc);
-                  console.log("\u2705 [ANGULAR PATCH] getBaseHref (_getDOM) result:", result);
-                  return result;
-                },
-                writable: false,
-                configurable: false,
-                enumerable: true
-              });
-            }
-            return domAdapter;
-          },
-          writable: true,
-          configurable: true,
-          enumerable: true
-        });
-      } catch (error) {
-        console.warn("\u26A0\uFE0F [ANGULAR PATCH] Failed to patch _getDOM via defineProperty, trying direct assignment:", error);
-        try {
-          common.\u{275}getDOM = function() {
-            const domAdapter = originalGetDOM();
-            if (domAdapter && typeof domAdapter.getBaseHref === "function") {
-              const adapter = domAdapter;
-              if (!adapter.__absolutejs_originalGetBaseHref) {
-                adapter.__absolutejs_originalGetBaseHref = domAdapter.getBaseHref.bind(domAdapter);
-              }
-              Object.defineProperty(domAdapter, "getBaseHref", {
-                value: function(doc) {
-                  if (!doc || !doc.head || typeof doc.head.children === "undefined") {
-                    return "";
-                  }
-                  return adapter.__absolutejs_originalGetBaseHref.call(this, doc);
-                },
-                writable: false,
-                configurable: false,
-                enumerable: true
-              });
-            }
-            return domAdapter;
-          };
-        } catch (assignError) {
-          console.warn("\u26A0\uFE0F [ANGULAR PATCH] Failed to patch _getDOM via direct assignment:", assignError);
-        }
-      }
-    }
-    const DominoAdapter = platformServer.DominoAdapter;
-    if (DominoAdapter && DominoAdapter.prototype) {
-      const prototype = DominoAdapter.prototype;
-      if (prototype.getBaseHref && !prototype.__absolutejs_originalGetBaseHref) {
-        prototype.__absolutejs_originalGetBaseHref = prototype.getBaseHref;
-        prototype.getBaseHref = function(doc) {
-          console.log("\uD83D\uDD0D [ANGULAR PATCH] getBaseHref called on DominoAdapter.prototype:", {
-            hasDoc: !!doc,
-            hasHead: !!doc?.head,
-            headIsNull: doc?.head === null,
-            headType: typeof doc?.head,
-            hasChildren: !!doc?.head?.children,
-            childrenType: typeof doc?.head?.children,
-            stack: getStackTrace()
-          });
-          if (!doc || !doc.head || typeof doc.head.children === "undefined") {
-            console.warn("\u26A0\uFE0F [ANGULAR PATCH] getBaseHref: Returning empty string due to null/undefined head or children");
-            return "";
-          }
-          const result = prototype.__absolutejs_originalGetBaseHref.call(this, doc);
-          console.log("\u2705 [ANGULAR PATCH] getBaseHref result:", result);
-          return result;
-        };
-      }
-      if (prototype.createHtmlDocument && !prototype.__absolutejs_originalCreateHtmlDocument) {
-        prototype.__absolutejs_originalCreateHtmlDocument = prototype.createHtmlDocument;
-        prototype.createHtmlDocument = function() {
-          console.log("\uD83D\uDD0D [ANGULAR PATCH] createHtmlDocument called");
-          const doc = prototype.__absolutejs_originalCreateHtmlDocument.call(this);
-          console.log("\uD83D\uDD0D [ANGULAR PATCH] createHtmlDocument result:", {
-            hasDoc: !!doc,
-            hasHead: !!doc?.head,
-            headIsNull: doc?.head === null,
-            stack: getStackTrace()
-          });
-          return createDocumentProxy(doc);
-        };
-      }
-      if (prototype.getDefaultDocument && !prototype.__absolutejs_originalGetDefaultDocument) {
-        prototype.__absolutejs_originalGetDefaultDocument = prototype.getDefaultDocument;
-        prototype.getDefaultDocument = function() {
-          const doc = prototype.__absolutejs_originalGetDefaultDocument.call(this);
-          return createDocumentProxy(doc);
-        };
-      }
-    }
-    try {
-      const domino = await import("domino").catch(() => null);
-      if (domino) {
-        if (domino.createWindow && !domino.__absolutejs_originalCreateWindow) {
-          domino.__absolutejs_originalCreateWindow = domino.createWindow;
-          domino.createWindow = function(html, url) {
-            const window = domino.__absolutejs_originalCreateWindow(html, url);
-            if (window && window.document) {
-              window.document = createDocumentProxy(window.document);
-            }
-            return window;
-          };
-        }
-        if (domino.createDocument && !domino.__absolutejs_originalCreateDocument) {
-          domino.__absolutejs_originalCreateDocument = domino.createDocument;
-          domino.createDocument = function(html) {
-            const doc = domino.__absolutejs_originalCreateDocument(html);
-            return createDocumentProxy(doc);
-          };
-        }
-      }
-    } catch (error) {}
-    try {
-      const serverModule = platformServer;
-      if (serverModule._document || platformServer.\u{275}_document) {
-        const originalDocument = serverModule._document || platformServer.\u{275}_document;
-        if (typeof originalDocument === "function") {
-          platformServer._document = function(injector) {
-            const doc = originalDocument(injector);
-            return createDocumentProxy(doc);
-          };
-        }
-      }
-    } catch (error) {}
-    console.log("\u2705 Angular SSR patches applied at module resolution time");
-    return true;
-  } catch (error) {
-    console.warn("\u26A0\uFE0F Failed to apply Angular SSR patches at module resolution time:", error);
-    return false;
-  }
-})();
-var angularPatch_default = patchesApplied;
-
 // src/core/build.ts
 import { copyFileSync, cpSync, mkdirSync } from "fs";
 import { rm as rm3 } from "fs/promises";
-import { basename as basename5, join as join6 } from "path";
+import { basename as basename4, join as join5 } from "path";
 import { cwd, env as env2, exit } from "process";
 var {$, build: bunBuild, Glob: Glob3 } = globalThis.Bun;
 
-// src/build/compileAngular.ts
-import { promises as fs } from "fs";
-import { join, basename, sep, dirname, resolve, relative } from "path";
-import {
-  readConfiguration,
-  performCompilation,
-  EmitFlags
-} from "@angular/compiler-cli";
-import ts from "typescript";
-
-// src/utils/stringModifiers.ts
-var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_]+/g, "").replace(/[-_]{2,}/g, "-");
-var toPascal = (str) => {
-  if (!str.includes("-") && !str.includes("_")) {
-    return str.charAt(0).toUpperCase() + str.slice(1);
-  }
-  return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
-};
-var toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
-
-// src/build/compileAngular.ts
-var compileAngularFile = async (inputPath, outDir) => {
-  const tsPath = __require.resolve("typescript");
-  const tsRootDir = dirname(tsPath);
-  const tsLibDir = tsRootDir.endsWith("lib") ? tsRootDir : resolve(tsRootDir, "lib");
-  const config = readConfiguration("./tsconfig.json");
-  const options = {
-    newLine: ts.NewLineKind.LineFeed,
-    target: ts.ScriptTarget.ES2022,
-    module: ts.ModuleKind.ESNext,
-    outDir,
-    experimentalDecorators: false,
-    emitDecoratorMetadata: false,
-    moduleResolution: ts.ModuleResolutionKind.Bundler,
-    esModuleInterop: true,
-    skipLibCheck: true,
-    noLib: false,
-    ...config.options
-  };
-  options.target = ts.ScriptTarget.ES2022;
-  options.newLine = ts.NewLineKind.LineFeed;
-  const host = ts.createCompilerHost(options);
-  const originalGetDefaultLibLocation = host.getDefaultLibLocation;
-  host.getDefaultLibLocation = () => {
-    return 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 = {};
-  host.writeFile = (fileName, text) => {
-    const relativePath = fileName.startsWith(outDir) ? fileName.substring(outDir.length + 1) : fileName;
-    emitted[relativePath] = text;
-  };
-  const { diagnostics } = performCompilation({
-    emitFlags: EmitFlags.Default,
-    host,
-    options,
-    rootNames: [inputPath]
-  });
-  if (diagnostics?.length) {
-    const errors = diagnostics.filter((d) => d.category === ts.DiagnosticCategory.Error);
-    if (errors.length) {
-      throw new Error(errors.map((diagnostic) => ts.flattenDiagnosticMessageText(diagnostic.messageText, `
-`)).join(`
-`));
-    }
-  }
-  const entries = Object.entries(emitted).filter(([fileName]) => fileName.endsWith(".js")).map(([fileName, content]) => {
-    const target = join(outDir, fileName);
-    let processedContent = content.replace(/from\s+(['"])(\.\.?\/[^'"]+)(\1)/g, (match, quote, path) => {
-      if (!path.match(/\.(js|ts|mjs|cjs)$/)) {
-        return `from ${quote}${path}.js${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(/\bInjectFlags\b/g, "InternalInjectFlags");
-    return { content: processedContent, target };
-  });
-  await Promise.all(entries.map(({ target }) => fs.mkdir(dirname(target), { recursive: true })));
-  await Promise.all(entries.map(({ target, content }) => fs.writeFile(target, content, "utf-8")));
-  return entries.map(({ target }) => target);
-};
-var compileAngular = async (entryPoints, outRoot) => {
-  const compiledRoot = join(outRoot, "compiled");
-  const indexesDir = join(compiledRoot, "indexes");
-  await fs.rm(compiledRoot, { force: true, recursive: true });
-  await fs.mkdir(indexesDir, { recursive: true });
-  const compileTasks = entryPoints.map(async (entry) => {
-    const outputs = await compileAngularFile(entry, compiledRoot);
-    const fileBase = basename(entry).replace(/\.[tj]s$/, "");
-    const jsName = `${fileBase}.js`;
-    let rawServerFile = outputs.find((f) => f.endsWith(`${sep}pages${sep}${jsName}`));
-    if (!rawServerFile) {
-      rawServerFile = outputs.find((f) => f.endsWith(`${sep}${jsName}`));
-    }
-    if (!rawServerFile) {
-      throw new Error(`Compiled output not found for ${entry}. Looking for: ${jsName}. Available: ${outputs.join(", ")}`);
-    }
-    const original = await fs.readFile(rawServerFile, "utf-8");
-    const componentClassName = `${toPascal(fileBase)}Component`;
-    let rewritten = original.replace(new RegExp(`templateUrl:\\s*['"]\\.\\/${fileBase}\\.html['"]`), `templateUrl: '../../pages/${fileBase}.html'`);
-    if (!rewritten.includes("export default")) {
-      rewritten += `
-export default ${componentClassName};
-`;
-    }
-    await fs.writeFile(rawServerFile, rewritten, "utf-8");
-    const relativePath = relative(indexesDir, rawServerFile).replace(/\\/g, "/");
-    const normalizedImportPath = relativePath.startsWith(".") ? relativePath : "./" + relativePath;
-    const clientFile = join(indexesDir, jsName);
-    const hydration = `
-import { bootstrapApplication } from '@angular/platform-browser';
-import { provideClientHydration } from '@angular/platform-browser';
-import ${componentClassName} from '${normalizedImportPath}';
-
-bootstrapApplication(${componentClassName}, { providers: [provideClientHydration()] });
-`.trim();
-    await fs.writeFile(clientFile, hydration, "utf-8");
-    return { clientPath: clientFile, serverPath: rawServerFile };
-  });
-  const results = await Promise.all(compileTasks);
-  const serverPaths = results.map((r) => r.serverPath);
-  const clientPaths = results.map((r) => r.clientPath);
-  return { clientPaths, serverPaths };
-};
-
 // src/build/compileSvelte.ts
 import { mkdir, stat } from "fs/promises";
 import {
-  dirname as dirname2,
-  join as join2,
-  basename as basename2,
+  dirname,
+  join,
+  basename,
   extname,
-  resolve as resolve2,
-  relative as relative2,
-  sep as sep2
+  resolve,
+  relative,
+  sep
 } from "path";
 import { env } from "process";
 var {write, file, Transpiler } = globalThis.Bun;
@@ -677,7 +44,7 @@ var exists = async (path) => {
   }
 };
 var resolveSvelte = async (spec, from) => {
-  const basePath = resolve2(dirname2(from), spec);
+  const basePath = resolve(dirname(from), spec);
   const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
   if (!explicit) {
     const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
@@ -699,10 +66,10 @@ var resolveSvelte = async (spec, from) => {
   return null;
 };
 var compileSvelte = async (entryPoints, svelteRoot, cache = new Map) => {
-  const compiledRoot = join2(svelteRoot, "compiled");
-  const clientDir = join2(compiledRoot, "client");
-  const indexDir = join2(compiledRoot, "indexes");
-  const pagesDir = join2(compiledRoot, "pages");
+  const compiledRoot = join(svelteRoot, "compiled");
+  const clientDir = join(compiledRoot, "client");
+  const indexDir = join(compiledRoot, "indexes");
+  const pagesDir = join(compiledRoot, "pages");
   await Promise.all([clientDir, indexDir, pagesDir].map((dir) => mkdir(dir, { recursive: true })));
   const dev = env.NODE_ENV === "development";
   const build = async (src) => {
@@ -713,8 +80,8 @@ var compileSvelte = async (entryPoints, svelteRoot, cache = new Map) => {
     const isModule = src.endsWith(".svelte.ts") || src.endsWith(".svelte.js");
     const preprocessed = isModule ? raw : (await preprocess(raw, {})).code;
     const transpiled = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler.transformSync(preprocessed) : preprocessed;
-    const relDir = dirname2(relative2(svelteRoot, src)).replace(/\\/g, "/");
-    const baseName = basename2(src).replace(/\.svelte(\.(ts|js))?$/, "");
+    const relDir = dirname(relative(svelteRoot, src)).replace(/\\/g, "/");
+    const baseName = basename(src).replace(/\.svelte(\.(ts|js))?$/, "");
     const importPaths = Array.from(transpiled.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((path) => path !== undefined);
     const resolvedImports = await Promise.all(importPaths.map((importPath) => resolveSvelte(importPath, src)));
     const childSources = resolvedImports.filter((path) => path !== null);
@@ -725,11 +92,11 @@ var compileSvelte = async (entryPoints, svelteRoot, cache = new Map) => {
       filename: src,
       generate: mode
     }).js.code).replace(/\.svelte(?:\.(?:ts|js))?(['"])/g, ".js$1");
-    const ssrPath = join2(pagesDir, relDir, `${baseName}.js`);
-    const clientPath = join2(clientDir, relDir, `${baseName}.js`);
+    const ssrPath = join(pagesDir, relDir, `${baseName}.js`);
+    const clientPath = join(clientDir, relDir, `${baseName}.js`);
     await Promise.all([
-      mkdir(dirname2(ssrPath), { recursive: true }),
-      mkdir(dirname2(clientPath), { recursive: true })
+      mkdir(dirname(ssrPath), { recursive: true }),
+      mkdir(dirname(clientPath), { recursive: true })
     ]);
     if (isModule) {
       const bundle = generate("client");
@@ -751,21 +118,21 @@ var compileSvelte = async (entryPoints, svelteRoot, cache = new Map) => {
   };
   const roots = await Promise.all(entryPoints.map(build));
   await Promise.all(roots.map(async ({ client }) => {
-    const relClientDir = dirname2(relative2(clientDir, client));
-    const name = basename2(client, extname(client));
-    const indexPath = join2(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative2(dirname2(indexPath), client).split(sep2).join("/");
+    const relClientDir = dirname(relative(clientDir, client));
+    const name = basename(client, extname(client));
+    const indexPath = join(indexDir, relClientDir, `${name}.js`);
+    const importRaw = relative(dirname(indexPath), client).split(sep).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const bootstrap = `import C from "${importPath}";
 import { hydrate } from "svelte";
 hydrate(C,{target:document.body,props:window.__INITIAL_PROPS__??{}});`;
-    await mkdir(dirname2(indexPath), { recursive: true });
+    await mkdir(dirname(indexPath), { recursive: true });
     return write(indexPath, bootstrap);
   }));
   return {
     svelteClientPaths: roots.map(({ client }) => {
-      const rel = dirname2(relative2(clientDir, client));
-      return join2(indexDir, rel, basename2(client));
+      const rel = dirname(relative(clientDir, client));
+      return join(indexDir, rel, basename(client));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
   };
@@ -773,7 +140,7 @@ hydrate(C,{target:document.body,props:window.__INITIAL_PROPS__??{}});`;
 
 // src/build/compileVue.ts
 import { mkdir as mkdir2 } from "fs/promises";
-import { basename as basename3, dirname as dirname3, join as join3, relative as relative3, resolve as resolve3 } from "path";
+import { basename as basename2, dirname as dirname2, join as join2, relative as relative2, resolve as resolve2 } from "path";
 import {
   parse,
   compileScript,
@@ -781,6 +148,18 @@ import {
   compileStyle
 } from "@vue/compiler-sfc";
 var {file: file2, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
+
+// src/utils/stringModifiers.ts
+var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_]+/g, "").replace(/[-_]{2,}/g, "-");
+var toPascal = (str) => {
+  if (!str.includes("-") && !str.includes("_")) {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  }
+  return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
+};
+var toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+
+// src/build/compileVue.ts
 var transpiler2 = new Transpiler2({ loader: "ts", target: "browser" });
 var extractImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => importPath !== undefined);
 var toJs = (filePath) => {
@@ -813,9 +192,9 @@ var compileVueFile = async (sourceFilePath, outputDirs, cacheMap, isEntryPoint,
   const cachedResult = cacheMap.get(sourceFilePath);
   if (cachedResult)
     return cachedResult;
-  const relativeFilePath = relative3(vueRootDir, sourceFilePath).replace(/\\/g, "/");
+  const relativeFilePath = relative2(vueRootDir, sourceFilePath).replace(/\\/g, "/");
   const relativeWithoutExtension = relativeFilePath.replace(/\.vue$/, "");
-  const fileBaseName = basename3(sourceFilePath, ".vue");
+  const fileBaseName = basename2(sourceFilePath, ".vue");
   const componentId = toKebab(fileBaseName);
   const sourceContent = await file2(sourceFilePath).text();
   const { descriptor } = parse(sourceContent, { filename: sourceFilePath });
@@ -823,7 +202,7 @@ var compileVueFile = async (sourceFilePath, outputDirs, cacheMap, isEntryPoint,
   const importPaths = extractImports(scriptSource);
   const childComponentPaths = importPaths.filter((path) => path.startsWith(".") && path.endsWith(".vue"));
   const helperModulePaths = importPaths.filter((path) => path.startsWith(".") && !path.endsWith(".vue"));
-  const childBuildResults = await Promise.all(childComponentPaths.map((relativeChildPath) => compileVueFile(resolve3(dirname3(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir)));
+  const childBuildResults = await Promise.all(childComponentPaths.map((relativeChildPath) => compileVueFile(resolve2(dirname2(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir)));
   const compiledScript = compileScript(descriptor, {
     id: componentId,
     inlineTemplate: false
@@ -855,8 +234,8 @@ var compileVueFile = async (sourceFilePath, outputDirs, cacheMap, isEntryPoint,
   ];
   let cssOutputPaths = [];
   if (isEntryPoint && allCss.length) {
-    const cssOutputFile = join3(outputDirs.css, `${toKebab(fileBaseName)}.css`);
-    await mkdir2(dirname3(cssOutputFile), { recursive: true });
+    const cssOutputFile = join2(outputDirs.css, `${toKebab(fileBaseName)}.css`);
+    await mkdir2(dirname2(cssOutputFile), { recursive: true });
     await write2(cssOutputFile, allCss.join(`
 `));
     cssOutputPaths = [cssOutputFile];
@@ -870,10 +249,10 @@ var compileVueFile = async (sourceFilePath, outputDirs, cacheMap, isEntryPoint,
 `));
   const clientCode = assembleModule(generateRenderFunction(false), "render");
   const serverCode = assembleModule(generateRenderFunction(true), "ssrRender");
-  const clientOutputPath = join3(outputDirs.client, `${relativeWithoutExtension}.js`);
-  const serverOutputPath = join3(outputDirs.server, `${relativeWithoutExtension}.js`);
-  await mkdir2(dirname3(clientOutputPath), { recursive: true });
-  await mkdir2(dirname3(serverOutputPath), { recursive: true });
+  const clientOutputPath = join2(outputDirs.client, `${relativeWithoutExtension}.js`);
+  const serverOutputPath = join2(outputDirs.server, `${relativeWithoutExtension}.js`);
+  await mkdir2(dirname2(clientOutputPath), { recursive: true });
+  await mkdir2(dirname2(serverOutputPath), { recursive: true });
   await write2(clientOutputPath, clientCode);
   await write2(serverOutputPath, serverCode);
   const result = {
@@ -882,7 +261,7 @@ var compileVueFile = async (sourceFilePath, outputDirs, cacheMap, isEntryPoint,
     cssPaths: cssOutputPaths,
     serverPath: serverOutputPath,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolve3(dirname3(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
+      ...helperModulePaths.map((helper) => resolve2(dirname2(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
@@ -890,11 +269,11 @@ var compileVueFile = async (sourceFilePath, outputDirs, cacheMap, isEntryPoint,
   return result;
 };
 var compileVue = async (entryPoints, vueRootDir) => {
-  const compiledOutputRoot = join3(vueRootDir, "compiled");
-  const clientOutputDir = join3(compiledOutputRoot, "client");
-  const indexOutputDir = join3(compiledOutputRoot, "indexes");
-  const serverOutputDir = join3(compiledOutputRoot, "pages");
-  const cssOutputDir = join3(compiledOutputRoot, "styles");
+  const compiledOutputRoot = join2(vueRootDir, "compiled");
+  const clientOutputDir = join2(compiledOutputRoot, "client");
+  const indexOutputDir = join2(compiledOutputRoot, "indexes");
+  const serverOutputDir = join2(compiledOutputRoot, "pages");
+  const cssOutputDir = join2(compiledOutputRoot, "styles");
   await Promise.all([
     mkdir2(clientOutputDir, { recursive: true }),
     mkdir2(indexOutputDir, { recursive: true }),
@@ -904,18 +283,18 @@ var compileVue = async (entryPoints, vueRootDir) => {
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
   const compiledPages = await Promise.all(entryPoints.map(async (entryPath) => {
-    const result = await compileVueFile(resolve3(entryPath), {
+    const result = await compileVueFile(resolve2(entryPath), {
       client: clientOutputDir,
       css: cssOutputDir,
       server: serverOutputDir
     }, buildCache, true, vueRootDir);
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
-    const entryBaseName = basename3(entryPath, ".vue");
-    const indexOutputFile = join3(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join3(clientOutputDir, relative3(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
-    await mkdir2(dirname3(indexOutputFile), { recursive: true });
+    const entryBaseName = basename2(entryPath, ".vue");
+    const indexOutputFile = join2(indexOutputDir, `${entryBaseName}.js`);
+    const clientOutputFile = join2(clientOutputDir, relative2(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    await mkdir2(dirname2(indexOutputFile), { recursive: true });
     await write2(indexOutputFile, [
-      `import Comp from "${relative3(dirname3(indexOutputFile), clientOutputFile)}";`,
+      `import Comp from "${relative2(dirname2(indexOutputFile), clientOutputFile)}";`,
       'import { createSSRApp } from "vue";',
       "const props = window.__INITIAL_PROPS__ ?? {};",
       'createSSRApp(Comp, props).mount("#root");'
@@ -930,11 +309,11 @@ var compileVue = async (entryPoints, vueRootDir) => {
   await Promise.all(Array.from(allTsHelperPaths).map(async (tsPath) => {
     const sourceCode = await file2(tsPath).text();
     const transpiledCode = transpiler2.transformSync(sourceCode);
-    const relativeJsPath = relative3(vueRootDir, tsPath).replace(/\.ts$/, ".js");
-    const outClientPath = join3(clientOutputDir, relativeJsPath);
-    const outServerPath = join3(serverOutputDir, relativeJsPath);
-    await mkdir2(dirname3(outClientPath), { recursive: true });
-    await mkdir2(dirname3(outServerPath), { recursive: true });
+    const relativeJsPath = relative2(vueRootDir, tsPath).replace(/\.ts$/, ".js");
+    const outClientPath = join2(clientOutputDir, relativeJsPath);
+    const outServerPath = join2(serverOutputDir, relativeJsPath);
+    await mkdir2(dirname2(outClientPath), { recursive: true });
+    await mkdir2(dirname2(outServerPath), { recursive: true });
     await write2(outClientPath, transpiledCode);
     await write2(outServerPath, transpiledCode);
   }));
@@ -948,9 +327,9 @@ var compileVue = async (entryPoints, vueRootDir) => {
 // src/build/generateManifest.ts
 import { extname as extname2 } from "path";
 var generateManifest = (outputs, buildPath) => outputs.reduce((manifest, artifact) => {
-  let relative4 = artifact.path.startsWith(buildPath) ? artifact.path.slice(buildPath.length) : artifact.path;
-  relative4 = relative4.replace(/^\/+/, "");
-  const segments = relative4.split("/");
+  let relative3 = artifact.path.startsWith(buildPath) ? artifact.path.slice(buildPath.length) : artifact.path;
+  relative3 = relative3.replace(/^\/+/, "");
+  const segments = relative3.split("/");
   const fileWithHash = segments.pop();
   if (!fileWithHash)
     return manifest;
@@ -960,24 +339,24 @@ var generateManifest = (outputs, buildPath) => outputs.reduce((manifest, artifac
   const pascalName = toPascal(baseName);
   const ext = extname2(fileWithHash);
   if (ext === ".css") {
-    manifest[`${pascalName}CSS`] = `/${relative4}`;
+    manifest[`${pascalName}CSS`] = `/${relative3}`;
     return manifest;
   }
   const idx = segments.findIndex((seg) => seg === "indexes" || seg === "pages");
   const folder = idx > UNFOUND_INDEX ? segments[idx] : segments[0];
   if (folder === "indexes") {
-    manifest[`${pascalName}Index`] = `/${relative4}`;
+    manifest[`${pascalName}Index`] = `/${relative3}`;
   } else if (folder === "pages") {
     manifest[pascalName] = artifact.path;
   } else {
-    manifest[pascalName] = `/${relative4}`;
+    manifest[pascalName] = `/${relative3}`;
   }
   return manifest;
 }, {});
 
 // src/build/generateReactIndexes.ts
 import { mkdir as mkdir3, rm, writeFile } from "fs/promises";
-import { basename as basename4, join as join4 } from "path";
+import { basename as basename3, join as join3 } from "path";
 var {Glob } = globalThis.Bun;
 var generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory) => {
   await rm(reactIndexesDirectory, { force: true, recursive: true });
@@ -988,7 +367,7 @@ var generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory)
     files.push(file3);
   }
   const promises = files.map(async (file3) => {
-    const fileName = basename4(file3);
+    const fileName = basename3(file3);
     const [componentName] = fileName.split(".");
     const content = [
       `import { hydrateRoot } from 'react-dom/client';`,
@@ -1006,7 +385,7 @@ var generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory)
       `hydrateRoot(document, <${componentName} {...window.__INITIAL_PROPS__} />);`
     ].join(`
 `);
-    return writeFile(join4(reactIndexesDirectory, `${componentName}.tsx`), content);
+    return writeFile(join3(reactIndexesDirectory, `${componentName}.tsx`), content);
   });
   await Promise.all(promises);
 };
@@ -1067,33 +446,33 @@ var updateAssetPaths = async (manifest, directory) => {
 
 // src/utils/cleanup.ts
 import { rm as rm2 } from "fs/promises";
-import { join as join5 } from "path";
+import { join as join4 } from "path";
 var cleanup = async ({
   svelteDir,
   vueDir,
   reactIndexesPath
 }) => {
   if (svelteDir) {
-    await rm2(join5(svelteDir, "compiled"), { force: true, recursive: true });
+    await rm2(join4(svelteDir, "compiled"), { force: true, recursive: true });
   }
   if (vueDir) {
-    await rm2(join5(vueDir, "compiled"), { force: true, recursive: true });
+    await rm2(join4(vueDir, "compiled"), { force: true, recursive: true });
   }
   if (reactIndexesPath)
     await rm2(reactIndexesPath, { force: true, recursive: true });
 };
 
 // src/utils/commonAncestor.ts
-import { sep as sep3 } from "path";
+import { sep as sep2 } from "path";
 var commonAncestor = (paths, fallback) => {
   if (paths.length === 0)
     return fallback;
-  const segmentsList = paths.map((p) => p.split(sep3));
+  const segmentsList = paths.map((p) => p.split(sep2));
   const [first] = segmentsList;
   if (!first)
     return fallback;
   const commonSegments = first.filter((segment, index) => segmentsList.every((pathSegs) => pathSegs[index] === segment));
-  return commonSegments.length ? commonSegments.join(sep3) : fallback;
+  return commonSegments.length ? commonSegments.join(sep2) : fallback;
 };
 
 // src/utils/getDurationString.ts
@@ -1110,11 +489,11 @@ var getDurationString = (duration) => {
 };
 
 // src/utils/validateSafePath.ts
-import { resolve as resolve4, relative as relative4, sep as sep4 } from "path";
+import { resolve as resolve3, relative as relative3, sep as sep3 } from "path";
 var validateSafePath = (targetPath, baseDirectory) => {
-  const absoluteBase = resolve4(baseDirectory);
-  const absoluteTarget = resolve4(baseDirectory, targetPath);
-  if (relative4(absoluteBase, absoluteTarget).startsWith(`..${sep4}`)) {
+  const absoluteBase = resolve3(baseDirectory);
+  const absoluteTarget = resolve3(baseDirectory, targetPath);
+  if (relative3(absoluteBase, absoluteTarget).startsWith(`..${sep3}`)) {
     throw new Error(`Unsafe path: ${targetPath}`);
   }
   return absoluteTarget;
@@ -1149,14 +528,14 @@ var build = async ({
   const svelteDir = svelteDirectory && validateSafePath(svelteDirectory, projectRoot);
   const vueDir = vueDirectory && validateSafePath(vueDirectory, projectRoot);
   const angularDir = angularDirectory && validateSafePath(angularDirectory, projectRoot);
-  const reactIndexesPath = reactDir && join6(reactDir, "indexes");
-  const reactPagesPath = reactDir && join6(reactDir, "pages");
-  const htmlPagesPath = htmlDir && join6(htmlDir, "pages");
-  const htmlScriptsPath = htmlDir && join6(htmlDir, "scripts");
-  const sveltePagesPath = svelteDir && join6(svelteDir, "pages");
-  const vuePagesPath = vueDir && join6(vueDir, "pages");
-  const htmxPagesPath = htmxDir && join6(htmxDir, "pages");
-  const angularPagesPath = angularDir && join6(angularDir, "pages");
+  const reactIndexesPath = reactDir && join5(reactDir, "indexes");
+  const reactPagesPath = reactDir && join5(reactDir, "pages");
+  const htmlPagesPath = htmlDir && join5(htmlDir, "pages");
+  const htmlScriptsPath = htmlDir && join5(htmlDir, "scripts");
+  const sveltePagesPath = svelteDir && join5(svelteDir, "pages");
+  const vuePagesPath = vueDir && join5(vueDir, "pages");
+  const htmxPagesPath = htmxDir && join5(htmxDir, "pages");
+  const angularPagesPath = angularDir && join5(angularDir, "pages");
   const frontends = [
     reactDir,
     htmlDir,
@@ -1168,9 +547,9 @@ var build = async ({
   const isSingle = frontends.length === 1;
   let serverOutDir;
   if (svelteDir)
-    serverOutDir = join6(buildPath, basename5(svelteDir), "pages");
+    serverOutDir = join5(buildPath, basename4(svelteDir), "pages");
   else if (vueDir)
-    serverOutDir = join6(buildPath, basename5(vueDir), "pages");
+    serverOutDir = join5(buildPath, basename4(vueDir), "pages");
   let serverRoot;
   if (sveltePagesPath)
     serverRoot = sveltePagesPath;
@@ -1181,36 +560,30 @@ var build = async ({
   if (reactIndexesPath && reactPagesPath)
     await generateReactIndexFiles(reactPagesPath, reactIndexesPath);
   if (assetsPath)
-    cpSync(assetsPath, join6(buildPath, "assets"), {
+    cpSync(assetsPath, join5(buildPath, "assets"), {
       force: true,
       recursive: true
     });
   if (tailwind)
-    await $`bunx @tailwindcss/cli -i ${tailwind.input} -o ${join6(buildPath, tailwind.output)}`;
+    await $`bunx @tailwindcss/cli -i ${tailwind.input} -o ${join5(buildPath, tailwind.output)}`;
   const reactEntries = reactIndexesPath ? await scanEntryPoints(reactIndexesPath, "*.tsx") : [];
   const htmlEntries = htmlScriptsPath ? await scanEntryPoints(htmlScriptsPath, "*.{js,ts}") : [];
   const svelteEntries = sveltePagesPath ? await scanEntryPoints(sveltePagesPath, "*.svelte") : [];
   const vueEntries = vuePagesPath ? await scanEntryPoints(vuePagesPath, "*.vue") : [];
   const angularEntries = angularPagesPath ? await scanEntryPoints(angularPagesPath, "*.ts") : [];
-  const htmlCssEntries = htmlDir ? await scanEntryPoints(join6(htmlDir, "styles"), "*.css") : [];
-  const htmxCssEntries = htmxDir ? await scanEntryPoints(join6(htmxDir, "styles"), "*.css") : [];
-  const reactCssEntries = reactDir ? await scanEntryPoints(join6(reactDir, "styles"), "*.css") : [];
-  const svelteCssEntries = svelteDir ? await scanEntryPoints(join6(svelteDir, "styles"), "*.css") : [];
-  const angularCssEntries = angularDir ? await scanEntryPoints(join6(angularDir, "styles"), "*.css") : [];
+  const htmlCssEntries = htmlDir ? await scanEntryPoints(join5(htmlDir, "styles"), "*.css") : [];
+  const htmxCssEntries = htmxDir ? await scanEntryPoints(join5(htmxDir, "styles"), "*.css") : [];
+  const reactCssEntries = reactDir ? await scanEntryPoints(join5(reactDir, "styles"), "*.css") : [];
+  const svelteCssEntries = svelteDir ? await scanEntryPoints(join5(svelteDir, "styles"), "*.css") : [];
+  const angularCssEntries = angularDir ? await scanEntryPoints(join5(angularDir, "styles"), "*.css") : [];
   const { svelteServerPaths, svelteClientPaths } = svelteDir ? await compileSvelte(svelteEntries, svelteDir) : { svelteClientPaths: [], svelteServerPaths: [] };
   const { vueServerPaths, vueIndexPaths, vueCssPaths } = vueDir ? await compileVue(vueEntries, vueDir) : { vueCssPaths: [], vueIndexPaths: [], vueServerPaths: [] };
-  const { serverPaths: angularServerPaths, clientPaths: angularClientPaths } = angularDir ? await compileAngular(angularEntries, angularDir) : { clientPaths: [], serverPaths: [] };
-  const serverEntryPoints = [
-    ...svelteServerPaths,
-    ...vueServerPaths,
-    ...angularServerPaths
-  ];
+  const serverEntryPoints = [...svelteServerPaths, ...vueServerPaths];
   const clientEntryPoints = [
     ...reactEntries,
     ...svelteClientPaths,
     ...htmlEntries,
-    ...vueIndexPaths,
-    ...angularClientPaths
+    ...vueIndexPaths
   ];
   const cssEntryPoints = [
     ...vueCssPaths,
@@ -1274,7 +647,7 @@ var build = async ({
     const { logs, outputs } = await bunBuild({
       entrypoints: cssEntryPoints,
       naming: `[name].[hash].[ext]`,
-      outdir: join6(buildPath, basename5(assetsPath), "css"),
+      outdir: join5(buildPath, basename4(assetsPath), "css"),
       target: "browser"
     }).catch((err) => {
       console.error("CSS build failed:", err);
@@ -1287,7 +660,7 @@ var build = async ({
   outputLogs(allLogs);
   const manifest = generateManifest([...serverOutputs, ...clientOutputs, ...cssOutputs], buildPath);
   if (htmlDir && htmlPagesPath) {
-    const outputHtmlPages = isSingle ? join6(buildPath, "pages") : join6(buildPath, basename5(htmlDir), "pages");
+    const outputHtmlPages = isSingle ? join5(buildPath, "pages") : join5(buildPath, basename4(htmlDir), "pages");
     mkdirSync(outputHtmlPages, { recursive: true });
     cpSync(htmlPagesPath, outputHtmlPages, {
       force: true,
@@ -1296,18 +669,18 @@ var build = async ({
     await updateAssetPaths(manifest, outputHtmlPages);
   }
   if (htmxDir && htmxPagesPath) {
-    const outputHtmxPages = isSingle ? join6(buildPath, "pages") : join6(buildPath, basename5(htmxDir), "pages");
+    const outputHtmxPages = isSingle ? join5(buildPath, "pages") : join5(buildPath, basename4(htmxDir), "pages");
     mkdirSync(outputHtmxPages, { recursive: true });
     cpSync(htmxPagesPath, outputHtmxPages, {
       force: true,
       recursive: true
     });
-    const htmxDestDir = isSingle ? buildPath : join6(buildPath, basename5(htmxDir));
+    const htmxDestDir = isSingle ? buildPath : join5(buildPath, basename4(htmxDir));
     mkdirSync(htmxDestDir, { recursive: true });
     const glob = new Glob3("htmx*.min.js");
     for (const relativePath of glob.scanSync({ cwd: htmxDir })) {
-      const src = join6(htmxDir, relativePath);
-      const dest = join6(htmxDestDir, "htmx.min.js");
+      const src = join5(htmxDir, relativePath);
+      const dest = join5(htmxDestDir, "htmx.min.js");
       copyFileSync(src, dest);
       break;
     }
@@ -1323,12 +696,6 @@ var build = async ({
   return manifest;
 };
 // src/core/pageHandlers.ts
-import { bootstrapApplication } from "@angular/platform-browser";
-import {
-  renderApplication,
-  provideServerRendering
-} from "@angular/platform-server";
-import { APP_BASE_HREF } from "@angular/common";
 var {file: file3 } = globalThis.Bun;
 import { createElement } from "react";
 import { renderToReadableStream as renderReactToReadableStream } from "react-dom/server";
@@ -1419,7 +786,6 @@ var renderToString = (component, props, {
 };
 
 // src/core/pageHandlers.ts
-var originalAsyncFunction = (async () => {}).constructor;
 var handleReactPageRequest = async (pageComponent, index, ...props) => {
   const [maybeProps] = props;
   const element = maybeProps !== undefined ? createElement(pageComponent, maybeProps) : createElement(pageComponent);
@@ -1475,170 +841,6 @@ var handleVuePageRequest = async (_PageComponent, pagePath, indexPath, headTag =
     headers: { "Content-Type": "text/html" }
   });
 };
-var handleAngularPageRequest = async (PageComponent, indexPath, props, template, tokens) => {
-  await angularPatch_default;
-  const CSS_PATH_TOKEN = tokens?.CSS_PATH;
-  const INITIAL_COUNT_TOKEN = tokens?.INITIAL_COUNT;
-  if (!("Zone" in globalThis))
-    await import("zone.js/node");
-  try {
-    const platformServer = await import("@angular/platform-server");
-    const DominoAdapter = platformServer.DominoAdapter;
-    if (DominoAdapter?.makeCurrent) {
-      DominoAdapter.makeCurrent();
-      console.log("\u2705 DominoAdapter initialized (patches already applied at module load)");
-    } else {
-      console.warn("\u26A0\uFE0F DominoAdapter.makeCurrent not available");
-    }
-  } catch (error) {
-    console.warn("Failed to initialize DominoAdapter:", error);
-  }
-  const htmlString = template || "<!DOCTYPE html><html><head></head><body></body></html>";
-  let document = htmlString;
-  if (typeof htmlString === "string") {
-    try {
-      const domino = await import("domino").catch(() => null);
-      if (domino?.createWindow) {
-        const window = domino.createWindow(htmlString, "/");
-        const doc = window.document;
-        if (!doc.head) {
-          const head = doc.createElement("head");
-          if (doc.documentElement) {
-            doc.documentElement.insertBefore(head, doc.documentElement.firstChild);
-          }
-        }
-        if (doc.head && typeof doc.head.querySelectorAll !== "function") {
-          try {
-            Object.defineProperty(doc.head, "querySelectorAll", {
-              value: function(selector) {
-                if (doc.querySelectorAll) {
-                  const all = doc.querySelectorAll(selector);
-                  return Array.from(all).filter((el) => el.parentElement === doc.head || doc.head.contains(el));
-                }
-                return [];
-              },
-              writable: true,
-              enumerable: false,
-              configurable: true
-            });
-          } catch (e) {
-            console.warn("Failed to add querySelectorAll to head:", e);
-          }
-        }
-        if (doc.head && typeof doc.head.querySelector !== "function") {
-          try {
-            Object.defineProperty(doc.head, "querySelector", {
-              value: function(selector) {
-                if (doc.querySelector) {
-                  const el = doc.querySelector(selector);
-                  if (el && (el.parentElement === doc.head || doc.head.contains(el))) {
-                    return el;
-                  }
-                }
-                return null;
-              },
-              writable: true,
-              enumerable: false,
-              configurable: true
-            });
-          } catch (e) {
-            console.warn("Failed to add querySelector to head:", e);
-          }
-        }
-        if (!doc.head.children) {
-          const elementNodes = Array.from(doc.head.childNodes).filter((node) => node.nodeType === 1);
-          const childrenArray = [];
-          elementNodes.forEach((node, index) => {
-            childrenArray[index] = node;
-          });
-          childrenArray.length = elementNodes.length;
-          Object.defineProperty(doc.head, "children", {
-            value: childrenArray,
-            writable: false,
-            enumerable: true,
-            configurable: false
-          });
-        } else {
-          const children = doc.head.children;
-          if (typeof children.length === "undefined" || children[0] === undefined && children.length > 0) {
-            const elementNodes = Array.from(doc.head.childNodes).filter((node) => node.nodeType === 1);
-            const childrenArray = [];
-            elementNodes.forEach((node, index) => {
-              childrenArray[index] = node;
-            });
-            childrenArray.length = elementNodes.length;
-            Object.defineProperty(doc.head, "children", {
-              value: childrenArray,
-              writable: false,
-              enumerable: true,
-              configurable: false
-            });
-          }
-        }
-        document = createDocumentProxy(doc);
-      }
-    } catch (error) {
-      console.warn("Failed to parse document with domino, using string:", error);
-      document = htmlString;
-    }
-  }
-  const providers = [
-    provideServerRendering(),
-    { provide: APP_BASE_HREF, useValue: "/" }
-  ];
-  if (props) {
-    console.log("\uD83D\uDD0D [DEBUG] handleAngularPageRequest props:", props);
-    if (props.cssPath !== undefined && CSS_PATH_TOKEN) {
-      providers.push({
-        provide: CSS_PATH_TOKEN,
-        useValue: props.cssPath
-      });
-      console.log("\uD83D\uDD0D [DEBUG] Providing cssPath via DI token:", props.cssPath, "Token:", CSS_PATH_TOKEN);
-    } else if (props.cssPath !== undefined) {
-      console.warn("\u26A0\uFE0F [DEBUG] cssPath provided but CSS_PATH_TOKEN not available");
-    }
-    if (props.initialCount !== undefined && INITIAL_COUNT_TOKEN) {
-      providers.push({
-        provide: INITIAL_COUNT_TOKEN,
-        useValue: props.initialCount
-      });
-    }
-  }
-  const bootstrap = (context) => {
-    return bootstrapApplication(PageComponent, {
-      providers
-    }, context);
-  };
-  try {
-    let finalDocument = document;
-    if (typeof document !== "string" && document) {
-      finalDocument = createDocumentProxy(document);
-    }
-    const html = await renderApplication(bootstrap, {
-      document: finalDocument,
-      url: "/",
-      platformProviders: []
-    });
-    return new Response(html, {
-      headers: { "Content-Type": "text/html" }
-    });
-  } catch (error) {
-    console.error("\uD83D\uDEA8 [ANGULAR SSR] Error caught in handleAngularPageRequest:", {
-      message: error.message,
-      stack: error.stack,
-      name: error.name,
-      error
-    });
-    if (error.message && error.message.includes("doc.head.children")) {
-      console.error("\uD83D\uDEA8 [ANGULAR SSR] doc.head.children error detected!", {
-        fullError: error,
-        stack: error.stack,
-        message: error.message
-      });
-    }
-    throw error;
-  }
-};
 var handleHTMLPageRequest = (html) => file3(html);
 var handleHTMXPageRequest = (htmx) => file3(htmx);
 var handlePageRequest = (PageComponent, ...props) => {
@@ -1730,7 +932,6 @@ export {
   handlePageRequest,
   handleHTMXPageRequest,
   handleHTMLPageRequest,
-  handleAngularPageRequest,
   getLocalIPAddress,
   getEnv,
   generateHeadElement,
@@ -1751,5 +952,5 @@ export {
   ANGULAR_BUILD_WARNING_SUPPRESSION
 };
 
-//# debugId=FFDC673FD1CEB27164756E2164756E21
+//# debugId=898E0366299327F164756E2164756E21
 //# sourceMappingURL=index.js.map