@absolutejs/absolute 0.20.0-beta.179 → 0.20.0-beta.180

package/dist/cli/index-2wvysvjc.js

@@ -0,0 +1,40 @@
+// @bun
+// src/build/externalAssetPlugin.ts
+import { copyFileSync, existsSync, mkdirSync, statSync } from "fs";
+import { basename, dirname, join, resolve } from "path";
+var createExternalAssetPlugin = (outDir, userSourceRoots = []) => ({
+  name: "absolute-external-asset",
+  setup(bld) {
+    const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
+    const skipRoots = userSourceRoots.map((root) => resolve(root));
+    const isUserSource = (path) => skipRoots.some((root) => path.startsWith(`${root}/`));
+    bld.onLoad({ filter: /\.[mc]?[jt]sx?$/ }, async (args) => {
+      if (isUserSource(args.path))
+        return;
+      const source = await Bun.file(args.path).text();
+      if (!source.includes("import.meta.url"))
+        return;
+      urlPattern.lastIndex = 0;
+      let match;
+      const sourceDir = dirname(args.path);
+      while ((match = urlPattern.exec(source)) !== null) {
+        const relPath = match[1];
+        if (!relPath)
+          continue;
+        const assetPath = resolve(sourceDir, relPath);
+        if (!existsSync(assetPath))
+          continue;
+        if (!statSync(assetPath).isFile())
+          continue;
+        const targetPath = join(outDir, basename(assetPath));
+        if (existsSync(targetPath))
+          continue;
+        mkdirSync(dirname(targetPath), { recursive: true });
+        copyFileSync(assetPath, targetPath);
+      }
+      return;
+    });
+  }
+});
+
+export { createExternalAssetPlugin };

package/dist/cli/index-42xjh6gg.js

@@ -0,0 +1,282 @@
+// @bun
+import {
+  lazyTypescript
+} from "./index-4j1twret.js";
+
+// src/build/islandRegistryTransform.ts
+import { basename } from "path";
+var VALID_FRAMEWORKS = [
+  "react",
+  "svelte",
+  "vue",
+  "angular"
+];
+var getObjectPropertyName = (name) => lazyTypescript.isIdentifier(name) || lazyTypescript.isStringLiteral(name) ? name.text : null;
+var isIslandRegistryHelperImport = (source) => source === "@absolutejs/absolute/islands" || source.endsWith("/islands") || source.endsWith("/core/islands");
+var collectRegistryFactory = (sourceFile) => {
+  const factoryNames = new Set;
+  const namespaceNames = new Set;
+  for (const statement of sourceFile.statements) {
+    if (!lazyTypescript.isImportDeclaration(statement))
+      continue;
+    if (!lazyTypescript.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    if (!isIslandRegistryHelperImport(statement.moduleSpecifier.text))
+      continue;
+    const bindings = statement.importClause?.namedBindings;
+    if (!bindings)
+      continue;
+    if (lazyTypescript.isNamespaceImport(bindings)) {
+      namespaceNames.add(bindings.name.text);
+      continue;
+    }
+    if (!lazyTypescript.isNamedImports(bindings))
+      continue;
+    for (const element of bindings.elements) {
+      const imported = element.propertyName?.text ?? element.name.text;
+      if (imported === "defineIslandRegistry") {
+        factoryNames.add(element.name.text);
+      }
+    }
+  }
+  return { factoryNames, namespaceNames };
+};
+var isDefineIslandRegistryCall = (expression, factoryNames, namespaceNames) => {
+  if (lazyTypescript.isIdentifier(expression))
+    return factoryNames.has(expression.text);
+  return lazyTypescript.isPropertyAccessExpression(expression) && expression.name.text === "defineIslandRegistry" && lazyTypescript.isIdentifier(expression.expression) && namespaceNames.has(expression.expression.text);
+};
+var findDefineIslandRegistryCall = (sourceFile, factoryNames, namespaceNames) => {
+  let found = null;
+  const visit = (node) => {
+    if (found)
+      return;
+    const [firstArg] = lazyTypescript.isCallExpression(node) ? node.arguments : [];
+    if (lazyTypescript.isCallExpression(node) && isDefineIslandRegistryCall(node.expression, factoryNames, namespaceNames) && firstArg && lazyTypescript.isObjectLiteralExpression(firstArg)) {
+      found = node;
+      return;
+    }
+    lazyTypescript.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  return found;
+};
+var quoteKey = (key) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
+var definitionLiteral = (reference) => {
+  const exportPart = reference.export ? `, export: ${JSON.stringify(reference.export)}` : "";
+  return `{ component: null, source: ${JSON.stringify(reference.source)}${exportPart} }`;
+};
+var transformIslandRegistrySource = (source, filePath, info) => {
+  if (!source.includes("defineIslandRegistry"))
+    return null;
+  const scriptKind = filePath.endsWith(".tsx") || filePath.endsWith(".jsx") ? lazyTypescript.ScriptKind.TSX : lazyTypescript.ScriptKind.TS;
+  const sourceFile = lazyTypescript.createSourceFile(filePath, source, lazyTypescript.ScriptTarget.Latest, true, scriptKind);
+  const { factoryNames, namespaceNames } = collectRegistryFactory(sourceFile);
+  if (factoryNames.size === 0 && namespaceNames.size === 0)
+    return null;
+  const call = findDefineIslandRegistryCall(sourceFile, factoryNames, namespaceNames);
+  if (!call)
+    return null;
+  const [objectLiteral] = call.arguments;
+  if (!objectLiteral || !lazyTypescript.isObjectLiteralExpression(objectLiteral)) {
+    return null;
+  }
+  const definitionLookup = new Map;
+  for (const definition of info.definitions) {
+    if (!definition.buildReference)
+      continue;
+    definitionLookup.set(`${definition.framework}:${definition.component}`, {
+      export: definition.buildReference.export,
+      source: definition.buildReference.source
+    });
+  }
+  const edits = [];
+  const replacedLocals = new Set;
+  for (const frameworkProperty of objectLiteral.properties) {
+    if (!lazyTypescript.isPropertyAssignment(frameworkProperty))
+      continue;
+    const frameworkName = getObjectPropertyName(frameworkProperty.name);
+    const framework = VALID_FRAMEWORKS.find((f) => f === frameworkName);
+    if (!framework)
+      continue;
+    if (!lazyTypescript.isObjectLiteralExpression(frameworkProperty.initializer))
+      continue;
+    for (const componentProperty of frameworkProperty.initializer.properties) {
+      let componentKey = null;
+      let localName = null;
+      let replaceNode = null;
+      let replacementText = "";
+      if (lazyTypescript.isShorthandPropertyAssignment(componentProperty)) {
+        componentKey = componentProperty.name.text;
+        localName = componentProperty.name.text;
+        const reference = definitionLookup.get(`${framework}:${componentKey}`);
+        if (!reference)
+          continue;
+        replaceNode = componentProperty;
+        replacementText = `${quoteKey(componentKey)}: ${definitionLiteral(reference)}`;
+      } else if (lazyTypescript.isPropertyAssignment(componentProperty) && lazyTypescript.isIdentifier(componentProperty.initializer)) {
+        componentKey = getObjectPropertyName(componentProperty.name);
+        localName = componentProperty.initializer.text;
+        if (!componentKey)
+          continue;
+        const reference = definitionLookup.get(`${framework}:${componentKey}`);
+        if (!reference)
+          continue;
+        replaceNode = componentProperty.initializer;
+        replacementText = definitionLiteral(reference);
+      } else {
+        continue;
+      }
+      edits.push({
+        end: replaceNode.getEnd(),
+        start: replaceNode.getStart(sourceFile),
+        text: replacementText
+      });
+      replacedLocals.add(localName);
+    }
+  }
+  if (edits.length === 0)
+    return null;
+  for (const statement of sourceFile.statements) {
+    if (!lazyTypescript.isImportDeclaration(statement))
+      continue;
+    const clause = statement.importClause;
+    if (!clause)
+      continue;
+    const localNames = [];
+    if (clause.name)
+      localNames.push(clause.name.text);
+    const bindings = clause.namedBindings;
+    if (bindings && lazyTypescript.isNamedImports(bindings)) {
+      for (const element of bindings.elements) {
+        localNames.push(element.name.text);
+      }
+    } else if (bindings && lazyTypescript.isNamespaceImport(bindings)) {
+      localNames.push(bindings.name.text);
+    }
+    if (localNames.length === 0)
+      continue;
+    if (localNames.every((name) => replacedLocals.has(name))) {
+      edits.push({
+        end: statement.getEnd(),
+        start: statement.getStart(sourceFile),
+        text: ""
+      });
+    }
+  }
+  edits.sort((a, b) => b.start - a.start);
+  let output = source;
+  for (const edit of edits) {
+    output = output.slice(0, edit.start) + edit.text + output.slice(edit.end);
+  }
+  return output;
+};
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var loaderForPath = (filePath) => {
+  if (filePath.endsWith(".tsx"))
+    return "tsx";
+  if (filePath.endsWith(".jsx"))
+    return "jsx";
+  if (filePath.endsWith(".js") || filePath.endsWith(".mjs") || filePath.endsWith(".cjs")) {
+    return "js";
+  }
+  return "ts";
+};
+var createIslandRegistryDefinitionPlugin = (info) => {
+  const registryBase = basename(info.resolvedRegistryPath).replace(/\.[mc]?[jt]sx?$/, "");
+  const filter = new RegExp(`(^|[/\\\\])${escapeRegExp(registryBase)}\\.[mc]?[jt]sx?$`);
+  return {
+    name: "absolute-island-registry-definitions",
+    setup(build) {
+      build.onLoad({ filter }, async (args) => {
+        const source = await Bun.file(args.path).text();
+        const transformed = transformIslandRegistrySource(source, args.path, info);
+        if (transformed === null)
+          return;
+        return {
+          contents: transformed,
+          loader: loaderForPath(args.path)
+        };
+      });
+    }
+  };
+};
+
+// src/build/bunStringRawUnicodePlugin.ts
+import { extname } from "path";
+var NON_ASCII = /[^\x00-\x7f]/;
+var getScriptKind = (filePath) => {
+  if (/\.[cm]?tsx$/.test(filePath))
+    return lazyTypescript.ScriptKind.TSX;
+  if (/\.[cm]?jsx$/.test(filePath))
+    return lazyTypescript.ScriptKind.JSX;
+  if (/\.[cm]?ts$/.test(filePath))
+    return lazyTypescript.ScriptKind.TS;
+  return lazyTypescript.ScriptKind.JS;
+};
+var getLoader = (filePath) => {
+  const extension = extname(filePath);
+  if (extension === ".tsx")
+    return "tsx";
+  if (extension === ".jsx")
+    return "jsx";
+  if (extension === ".ts" || extension === ".mts" || extension === ".cts") {
+    return "ts";
+  }
+  return "js";
+};
+var isStringRawTag = (node) => lazyTypescript.isPropertyAccessExpression(node.tag) && lazyTypescript.isIdentifier(node.tag.expression) && node.tag.expression.text === "String" && node.tag.name.text === "raw";
+var getRawText = (node) => node.rawText ?? node.text;
+var rewriteBunStringRawUnicode = (source, filePath = "input.ts") => {
+  if (!source.includes("String.raw") || !NON_ASCII.test(source))
+    return source;
+  const sourceFile = lazyTypescript.createSourceFile(filePath, source, lazyTypescript.ScriptTarget.Latest, true, getScriptKind(filePath));
+  const replacements = [];
+  const visit = (node) => {
+    if (lazyTypescript.isTaggedTemplateExpression(node) && isStringRawTag(node)) {
+      const rawSegments = lazyTypescript.isNoSubstitutionTemplateLiteral(node.template) ? [getRawText(node.template)] : [
+        getRawText(node.template.head),
+        ...node.template.templateSpans.map((span) => getRawText(span.literal))
+      ];
+      if (rawSegments.some((segment) => NON_ASCII.test(segment))) {
+        const expressions = lazyTypescript.isTemplateExpression(node.template) ? node.template.templateSpans.map((span) => {
+          const expression = source.slice(span.expression.getStart(sourceFile), span.expression.end);
+          return rewriteBunStringRawUnicode(expression, filePath);
+        }) : [];
+        const args = [
+          `{ raw: [${rawSegments.map((text) => JSON.stringify(text)).join(", ")}] }`,
+          ...expressions
+        ];
+        replacements.push({
+          end: node.end,
+          start: node.getStart(sourceFile),
+          value: `String.raw(${args.join(", ")})`
+        });
+        return;
+      }
+    }
+    lazyTypescript.forEachChild(node, visit);
+  };
+  visit(sourceFile);
+  let result = source;
+  for (const replacement of replacements.sort((a, b) => b.start - a.start)) {
+    result = result.slice(0, replacement.start) + replacement.value + result.slice(replacement.end);
+  }
+  return result;
+};
+var createBunStringRawUnicodePlugin = () => ({
+  name: "absolute-bun-string-raw-unicode",
+  setup(build) {
+    build.onLoad({ filter: /\.[cm]?[jt]sx?$/ }, async (args) => {
+      if (args.path.includes("/node_modules/"))
+        return;
+      const source = await Bun.file(args.path).text();
+      const contents = rewriteBunStringRawUnicode(source, args.path);
+      if (contents === source)
+        return;
+      return { contents, loader: getLoader(args.path) };
+    });
+  }
+});
+
+export { createIslandRegistryDefinitionPlugin, createBunStringRawUnicodePlugin };

package/dist/cli/{index-qw98g1p6.js → index-47e8fwha.js}

@@ -1,4 +1,7 @@
 // @bun
+// src/utils/normalizePath.ts
+var normalizePath = (path) => path.replace(/\\/g, "/");
+
 // src/build/fileRoutes.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
 import {
@@ -266,4 +269,4 @@ var syncFileRoutes = (config) => {
   return { ...scan, output: resolved.output, written };
 };
 
-export { ensureFileRouteModule };
+export { normalizePath, scanFileRoutes, ensureFileRouteModule };

package/dist/cli/index-65kqn88a.js

@@ -0,0 +1,8 @@
+// @bun
+// src/utils/isTestSourcePath.ts
+var isTestSourcePath = (file) => {
+  const normalized = file.replace(/\\/g, "/");
+  return normalized.includes("/__tests__/") || /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(normalized);
+};
+
+export { isTestSourcePath };

package/dist/cli/{index-2bxfhs32.js → index-6f448d7m.js}

@@ -25,32 +25,6 @@ var writePartialHoles = async (htmlPath, response) => {
 
 // src/core/prerenderNonce.ts
 import { rm as rm2 } from "fs/promises";
-
-// src/utils/logger.ts
-var colors = {
-  blue: "\x1B[34m",
-  bold: "\x1B[1m",
-  cyan: "\x1B[36m",
-  dim: "\x1B[2m",
-  green: "\x1B[32m",
-  magenta: "\x1B[35m",
-  red: "\x1B[31m",
-  reset: "\x1B[0m",
-  white: "\x1B[37m",
-  yellow: "\x1B[33m"
-};
-var frameworkColors = {
-  angular: colors.magenta,
-  assets: colors.dim,
-  css: colors.cyan,
-  html: colors.white,
-  htmx: colors.white,
-  react: colors.blue,
-  svelte: colors.yellow,
-  vue: colors.green
-};
-
-// src/core/prerenderNonce.ts
 var CSP_HEADERS = [
   "content-security-policy",
   "content-security-policy-report-only"

package/dist/cli/index-972xxwgj.js

@@ -0,0 +1,16 @@
+// @bun
+// src/build/scanEntryPoints.ts
+import { existsSync } from "fs";
+var {Glob } = globalThis.Bun;
+var scanEntryPoints = async (dir, pattern) => {
+  if (!existsSync(dir))
+    return [];
+  const entryPaths = [];
+  const glob = new Glob(pattern);
+  for await (const file of glob.scan({ absolute: true, cwd: dir })) {
+    entryPaths.push(file);
+  }
+  return entryPaths;
+};
+
+export { scanEntryPoints };

package/dist/cli/index-aqe25w4h.js

@@ -0,0 +1,39 @@
+// @bun
+import {
+  isDevelopmentRuntime
+} from "./index-cba1cemz.js";
+import {
+  formatTimestamp2
+} from "./index-3ewt17wm.js";
+
+// src/utils/logger.ts
+var colors = {
+  blue: "\x1B[34m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  green: "\x1B[32m",
+  magenta: "\x1B[35m",
+  red: "\x1B[31m",
+  reset: "\x1B[0m",
+  white: "\x1B[37m",
+  yellow: "\x1B[33m"
+};
+var frameworkColors = {
+  angular: colors.magenta,
+  assets: colors.dim,
+  css: colors.cyan,
+  html: colors.white,
+  htmx: colors.white,
+  react: colors.blue,
+  svelte: colors.yellow,
+  vue: colors.green
+};
+var logTag = () => isDevelopmentRuntime() ? "[hmr]" : "[absolutejs]";
+var logWarn = (message) => {
+  const timestamp = `${colors.dim}${formatTimestamp2()}${colors.reset}`;
+  const tag = `${colors.yellow}${logTag()}${colors.reset}`;
+  console.log(`${timestamp} ${tag} ${colors.yellow}warning ${message}${colors.reset}`);
+};
+
+export { logWarn };

package/dist/cli/index-assqancr.js

@@ -0,0 +1,51 @@
+// @bun
+// src/build/scanConventions.ts
+import { basename } from "path";
+var {Glob } = globalThis.Bun;
+import { existsSync } from "fs";
+var CONVENTION_RE = /^(?:(.+)\.)?(error|loading|not-found)\.[^.]+$/;
+var classifyFile = (file, pageFiles, defaults, pages) => {
+  const fileName = basename(file);
+  const match = CONVENTION_RE.exec(fileName);
+  if (!match) {
+    pageFiles.push(file);
+    return;
+  }
+  const [, pageName, kind] = match;
+  if (!pageName) {
+    if (kind === "error")
+      defaults.error = file;
+    else if (kind === "loading")
+      defaults.loading = file;
+    else if (kind === "not-found")
+      defaults.notFound = file;
+    return;
+  }
+  if (!pages[pageName])
+    pages[pageName] = {};
+  if (kind === "error")
+    pages[pageName].error = file;
+  else if (kind === "loading")
+    pages[pageName].loading = file;
+};
+var scanConventions = async (pagesDir, pattern) => {
+  if (!existsSync(pagesDir)) {
+    const pageFiles = [];
+    return { conventions: undefined, pageFiles };
+  }
+  const pageFiles = [];
+  const defaults = {};
+  const pages = {};
+  const glob = new Glob(pattern);
+  for await (const file of glob.scan({ absolute: true, cwd: pagesDir })) {
+    classifyFile(file, pageFiles, defaults, pages);
+  }
+  const hasConventions = defaults.error !== undefined || defaults.loading !== undefined || defaults.notFound !== undefined || Object.keys(pages).length > 0;
+  const conventions = hasConventions ? {
+    ...defaults.error || defaults.loading || defaults.notFound ? { defaults } : {},
+    ...Object.keys(pages).length > 0 ? { pages } : {}
+  } : undefined;
+  return { conventions, pageFiles };
+};
+
+export { scanConventions };

package/dist/cli/{index-2shf4aya.js → index-c8rcfe5a.js}

@@ -2,11 +2,9 @@
 import {
   MILLISECONDS_IN_A_SECOND
 } from "./index-t8jmj8w1.js";
-
-// src/utils/startupTimings.ts
-var isTruthyFlag = (value) => value === "1" || value === "true";
-var devProfileEnabled = isTruthyFlag(process.env.ABSOLUTE_DEV_PROFILE);
-var startupTimingsEnabled = devProfileEnabled || isTruthyFlag(process.env.ABSOLUTE_STARTUP_TIMINGS);
+import {
+  devProfileEnabled
+} from "./index-va274tsf.js";
 
 // src/utils/bootTimeline.ts
 var ORIGIN_ENV = "ABSOLUTE_BOOT_ORIGIN_MS";
@@ -35,4 +33,4 @@ var markBootAt = (label, epochMs) => {
 };
 var processStartEpochMs = () => Date.now() - process.uptime() * MILLISECONDS_IN_A_SECOND;
 
-export { devProfileEnabled, bootTimelineChildEnv, markBoot };
+export { bootTimelineChildEnv, markBoot };

package/dist/cli/index-cba1cemz.js

@@ -0,0 +1,8 @@
+// @bun
+// src/utils/runtimeMode.ts
+var ENV_VAR = "NODE_ENV";
+var readEnv = () => typeof process === "undefined" ? undefined : process.env?.[ENV_VAR];
+var getNodeEnv = () => readEnv();
+var isDevelopmentRuntime = () => readEnv() === "development";
+
+export { getNodeEnv, isDevelopmentRuntime };

package/dist/cli/{index-3ff5ztt3.js → index-djkrb7pc.js}

@@ -1,10 +1,4 @@
 // @bun
-// src/utils/isTestSourcePath.ts
-var isTestSourcePath = (file) => {
-  const normalized = file.replace(/\\/g, "/");
-  return normalized.includes("/__tests__/") || /\.(?:test|spec)\.[cm]?[jt]sx?$/.test(normalized);
-};
-
 // src/build/workspacePackages.ts
 import { readFileSync, realpathSync } from "fs";
 import { join, sep } from "path";
@@ -51,4 +45,4 @@ var workspacePackageDirs = (projectRoot = process.cwd()) => {
   return [...dirs];
 };
 
-export { isTestSourcePath, isWorkspacePackageSpecifier, workspacePackageDirs };
+export { isWorkspacePackageSpecifier, workspacePackageDirs };

package/dist/cli/index-dkfwkpc8.js

@@ -0,0 +1,138 @@
+// @bun
+// src/svelte/staticAnalyzeSpaRoutes.ts
+import { existsSync, promises as fs } from "fs";
+import { join } from "path";
+var DYNAMIC_SEGMENT_PATTERN = /^[:*]/;
+var pathHasDynamic = (path) => path.split("/").some((seg) => DYNAMIC_SEGMENT_PATTERN.test(seg) || seg === "**");
+var joinSegments = (parent, child) => {
+  if (!child)
+    return parent;
+  if (!parent)
+    return child;
+  return `${parent.replace(/\/+$/, "")}/${child.replace(/^\/+/, "")}`;
+};
+var readAttribute = (tag, name) => {
+  const re = new RegExp(`(?:^|\\s)${name}\\s*=\\s*(?:"([^"]*)"|'([^']*)'|\\{?["']([^"']+)["']\\}?)`);
+  const match = re.exec(tag);
+  return match ? match[1] ?? match[2] ?? match[3] ?? null : null;
+};
+var findTagEnd = (source, from) => {
+  let depth = 0;
+  for (let index = from;index < source.length; index += 1) {
+    const char = source[index];
+    if (char === "{")
+      depth += 1;
+    if (char === "}")
+      depth -= 1;
+    if (char === ">" && depth <= 0)
+      return index;
+  }
+  return -1;
+};
+var findTags = (source, name) => {
+  const tags = [];
+  const opener = new RegExp(`<${name}\\b`, "g");
+  let match = opener.exec(source);
+  while (match !== null) {
+    const attrsStart = match.index + match[0].length;
+    const end = findTagEnd(source, attrsStart);
+    if (end === -1)
+      break;
+    tags.push({
+      attrs: source.slice(attrsStart, end).replace(/\/$/, ""),
+      end: end + 1,
+      start: match.index
+    });
+    opener.lastIndex = end + 1;
+    match = opener.exec(source);
+  }
+  return tags;
+};
+var findRouterBlock = (source) => {
+  const [openTag] = findTags(source, "Router");
+  if (!openTag)
+    return null;
+  const basepathRaw = readAttribute(openTag.attrs, "basepath");
+  const basepath = basepathRaw ?? "/";
+  const closeIndex = source.indexOf("</Router>", openTag.start);
+  if (closeIndex === -1)
+    return null;
+  const body = source.slice(openTag.end, closeIndex);
+  return { basepath, body };
+};
+var extractRoutesFromBody = (body) => {
+  const out = [];
+  for (const tag of findTags(body, "Route")) {
+    const path = readAttribute(tag.attrs, "path");
+    if (!path)
+      continue;
+    out.push({
+      dynamic: pathHasDynamic(path),
+      path,
+      redirected: false,
+      sitemapExcluded: false
+    });
+  }
+  return out;
+};
+var analyzeSvelteSpaRouteFile = async (filePath) => {
+  let source;
+  try {
+    source = await fs.readFile(filePath, "utf-8");
+  } catch {
+    return null;
+  }
+  if (!source.includes("<Router"))
+    return null;
+  const block = findRouterBlock(source);
+  if (!block)
+    return null;
+  const routes = extractRoutesFromBody(block.body);
+  if (routes.length === 0)
+    return null;
+  const baseHref = block.basepath.endsWith("/") ? block.basepath : `${block.basepath}/`;
+  const joinedRoutes = routes.map((r) => ({
+    ...r,
+    path: joinSegments("", r.path)
+  }));
+  return { baseHref, routes: joinedRoutes, sourceFile: filePath };
+};
+var walkSvelteFiles = async (dir, files) => {
+  let items;
+  try {
+    items = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  const directories = [];
+  for (const item of items) {
+    if (item.name === "node_modules" || item.name.startsWith("."))
+      continue;
+    const full = join(dir, item.name);
+    if (item.isDirectory()) {
+      directories.push(full);
+    } else if (item.isFile() && item.name.endsWith(".svelte")) {
+      files.push(full);
+    }
+  }
+  await Promise.all(directories.map((directory) => walkSvelteFiles(directory, files)));
+};
+var analyzeSvelteSpaRoutes2 = async (svelteDirectory) => {
+  if (!existsSync(svelteDirectory))
+    return [];
+  const files = [];
+  await walkSvelteFiles(svelteDirectory, files);
+  const hosts = [];
+  await Promise.all(files.map(async (file) => {
+    try {
+      const host = await analyzeSvelteSpaRouteFile(file);
+      if (host)
+        hosts.push(host);
+    } catch (err) {
+      console.warn(`[sitemap] Svelte SPA analysis failed for ${file}:`, err);
+    }
+  }));
+  return hosts;
+};
+
+export { analyzeSvelteSpaRoutes2 };

package/dist/cli/{index-92g14j47.js → index-dw44xa4x.js}

@@ -1,6 +1,7 @@
 // @bun
 // src/utils/stringModifiers.ts
 var normalizeSlug = (str) => str.trim().replace(/\s+/g, "-").replace(/[^A-Za-z0-9\-_]+/g, "").replace(/[-_]{2,}/g, "-");
+var toKebab = (str) => normalizeSlug(str).replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
 var toPascal = (str) => {
   if (!str.includes("-") && !str.includes("_")) {
     return str.charAt(0).toUpperCase() + str.slice(1);
@@ -8,4 +9,4 @@ var toPascal = (str) => {
   return normalizeSlug(str).split(/[-_]/).filter(Boolean).map((segment) => segment.charAt(0).toUpperCase() + segment.slice(1).toLowerCase()).join("");
 };
 
-export { toPascal };
+export { toKebab, toPascal };