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

package/dist/cli/index-x1vvn549.js

@@ -0,0 +1,835 @@
+// @bun
+import {
+  UNFOUND_INDEX
+} from "./index-t8jmj8w1.js";
+import {
+  normalizePath,
+  scanFileRoutes
+} from "./index-47e8fwha.js";
+import {
+  scanEntryPoints
+} from "./index-972xxwgj.js";
+import {
+  scanConventions
+} from "./index-assqancr.js";
+import {
+  ISLAND_BOOTSTRAP_MANIFEST_KEY,
+  getIslandManifestKey,
+  getIslandStyleManifestKey,
+  loadIslandRegistryBuildInfo
+} from "./index-w6xsk8cv.js";
+import {
+  toKebab,
+  toPascal
+} from "./index-dw44xa4x.js";
+import {
+  getNodeEnv
+} from "./index-cba1cemz.js";
+
+// src/react/serverComponents/constants.ts
+var REACT_SERVER_CLIENT_MANIFEST_KEY = "ReactServerClient";
+var REACT_SERVER_PAGE_MANIFEST_SUFFIX = "RSC";
+var REACT_SERVER_PAYLOAD_GLOBAL = "__absoluteReactServerPayload";
+var REACT_SERVER_RENDERER_MANIFEST_KEY = "ReactServerRenderer";
+var REACT_SERVER_RUNTIME_FILE = "react-server-runtime.json";
+
+// src/utils/fontAssets.ts
+var FONT_PRELOAD_MANIFEST_PREFIX = "AbsoluteFontPreload";
+var FONTS_REMOTE_CSS_MANIFEST_PREFIX = "AbsoluteFontsRemoteCSS";
+
+// src/build/generateManifest.ts
+import { extname } from "path";
+var getManifestKey = (folder, pascalName, isClientComponent, isReact, isVue, isSvelte, isAngular) => {
+  if (folder === "indexes")
+    return `${pascalName}Index`;
+  if (isClientComponent)
+    return `${pascalName}Client`;
+  if (folder !== "pages")
+    return pascalName;
+  if (isReact)
+    return `${pascalName}Page`;
+  if (isVue || isSvelte || isAngular)
+    return pascalName;
+  return `${pascalName}Page`;
+};
+var getCssKey = (pascalName, segments) => {
+  const isFromVue = segments.some((seg) => seg === "vue");
+  if (isFromVue && segments.includes("css"))
+    return `${pascalName}CompiledCSS`;
+  const isFromReact = segments.some((seg) => seg === "react");
+  const isFromSvelte = segments.some((seg) => seg === "svelte");
+  const isFromAngular = segments.some((seg) => seg === "angular");
+  if (isFromReact || isFromVue || isFromSvelte || isFromAngular)
+    return `${pascalName}BundledCSS`;
+  return `${pascalName}CSS`;
+};
+var getArtifactBaseName = (fileName, hash) => {
+  const ext = extname(fileName);
+  const stem = ext ? fileName.slice(0, -ext.length) : fileName;
+  if (!hash)
+    return stem;
+  const hashSuffix = `.${hash}`;
+  if (stem.endsWith(hashSuffix))
+    return stem.slice(0, -hashSuffix.length);
+  return stem;
+};
+var islandFrameworkOf = (segment) => segment === "react" || segment === "svelte" || segment === "vue" || segment === "angular" ? segment : undefined;
+var manifestKeyForOutput = (relativePath, hash = null) => {
+  const segments = relativePath.replace(/^\/+/, "").split("/");
+  const fileWithHash = segments.pop();
+  if (!fileWithHash)
+    return null;
+  const baseName = getArtifactBaseName(fileWithHash, hash);
+  if (!baseName)
+    return null;
+  const pascalName = toPascal(baseName);
+  const ext = extname(fileWithHash);
+  const islandIndex = segments.findIndex((seg) => seg === "islands");
+  const islandFramework = islandFrameworkOf(islandIndex > UNFOUND_INDEX ? segments[islandIndex + 1] : undefined);
+  if (ext === ".css") {
+    if (segments.includes("server"))
+      return null;
+    if (islandFramework)
+      return {
+        key: getIslandStyleManifestKey(islandFramework, pascalName),
+        warnOnDuplicate: false
+      };
+    return { key: getCssKey(pascalName, segments), warnOnDuplicate: true };
+  }
+  if (islandFramework)
+    return {
+      key: getIslandManifestKey(islandFramework, pascalName),
+      warnOnDuplicate: false
+    };
+  const idx = segments.findIndex((seg) => seg === "indexes" || seg === "pages" || seg === "client");
+  const folder = idx > UNFOUND_INDEX ? segments[idx] : segments[0];
+  const isReact = segments.some((seg) => seg === "react");
+  const isVue = segments.some((seg) => seg === "vue");
+  const isSvelte = segments.some((seg) => seg === "svelte");
+  const isAngular = segments.some((seg) => seg === "angular");
+  const isClientComponent = segments.includes("client");
+  return {
+    key: getManifestKey(folder, pascalName, isClientComponent, isReact, isVue, isSvelte, isAngular),
+    warnOnDuplicate: true
+  };
+};
+
+// src/build/islandBootstrap.ts
+var DEFAULT_ISLAND_BOOTSTRAP_NAME = "absoluteIslandBootstrap";
+
+// src/build/stylePreprocessor.ts
+import { existsSync, readFileSync } from "fs";
+import { readFile } from "fs/promises";
+import { createRequire } from "module";
+import {
+  dirname,
+  extname as extname2,
+  isAbsolute,
+  join,
+  relative,
+  resolve
+} from "path";
+import { fileURLToPath, pathToFileURL } from "url";
+var CSS_EXTENSION_PATTERN = /\.css$/i;
+var STYLE_EXTENSION_PATTERN = /\.(s[ac]ss|less|styl(?:us)?)$/i;
+var STYLE_MODULE_EXTENSION_PATTERN = /\.module\.(s[ac]ss|less|styl(?:us)?)$/i;
+var importOptionalPeer = new Function("specifier", "return import(specifier)");
+var requireOptionalPeer = new Function("specifier", "return require(specifier)");
+var requireFromCwd = createRequire(join(process.cwd(), "package.json"));
+var isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath);
+var getStyleLanguage = (filePathOrLanguage) => {
+  const normalized = filePathOrLanguage.toLowerCase();
+  if (normalized === "scss" || normalized.endsWith(".scss"))
+    return "scss";
+  if (normalized === "sass" || normalized.endsWith(".sass"))
+    return "sass";
+  if (normalized === "less" || normalized.endsWith(".less"))
+    return "less";
+  if (normalized === "styl" || normalized === "stylus" || normalized.endsWith(".styl") || normalized.endsWith(".stylus"))
+    return "stylus";
+  return null;
+};
+var missingDependencyError = (name, filePath) => new Error(`Unable to compile ${filePath}: install optional dependency "${name}" to use this stylesheet preprocessor.`);
+var throwPreprocessorError = (error, filePath, language) => {
+  if (!(error instanceof Error)) {
+    throw new Error(`${language} compile failed in ${filePath}: ${String(error)}`);
+  }
+  const detail = error;
+  const sassLine = detail.span?.start?.line;
+  const sassCol = detail.span?.start?.column;
+  const line = detail.line ?? sassLine;
+  const column = detail.column ?? sassCol;
+  const location = typeof line === "number" ? `:${line}${typeof column === "number" ? `:${column}` : ""}` : "";
+  const message = detail.formatted ?? detail.message;
+  const wrapped = new Error(`${language} compile failed in ${filePath}${location}
+${message}`);
+  wrapped.cause = error;
+  throw wrapped;
+};
+var requireOptionalPeerSync = (specifier) => {
+  try {
+    return requireFromCwd(specifier);
+  } catch {
+    return requireOptionalPeer(specifier);
+  }
+};
+var normalizeLoadPaths = (filePath, paths = []) => [
+  dirname(filePath),
+  process.cwd(),
+  ...paths.map((path) => resolve(process.cwd(), path))
+];
+var tsconfigAliasCache;
+var stripJsonComments = (source) => source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
+var normalizeAliasEntries = (aliases) => Object.entries(aliases ?? {}).map(([pattern, value]) => ({
+  pattern,
+  replacements: Array.isArray(value) ? value : [value]
+}));
+var readTsconfigAliases = () => {
+  const cwd = process.cwd();
+  if (tsconfigAliasCache?.cwd === cwd)
+    return tsconfigAliasCache;
+  const tsconfigPath = resolve(cwd, "tsconfig.json");
+  const empty = { aliases: [], baseUrl: cwd, cwd };
+  if (!existsSync(tsconfigPath)) {
+    tsconfigAliasCache = empty;
+    return empty;
+  }
+  try {
+    const parsed = JSON.parse(stripJsonComments(readFileSync(tsconfigPath, "utf-8")));
+    const compilerOptions = parsed.compilerOptions ?? {};
+    const baseUrl = resolve(cwd, compilerOptions.baseUrl ?? ".");
+    tsconfigAliasCache = {
+      aliases: normalizeAliasEntries(compilerOptions.paths),
+      baseUrl,
+      cwd
+    };
+  } catch {
+    tsconfigAliasCache = empty;
+  }
+  return tsconfigAliasCache;
+};
+var getAliasEntries = (config) => {
+  const tsconfig = readTsconfigAliases();
+  return {
+    aliases: [
+      ...normalizeAliasEntries(config?.aliases),
+      ...tsconfig.aliases
+    ],
+    baseUrl: tsconfig.baseUrl
+  };
+};
+var aliasPatternToRegExp = (pattern) => new RegExp(`^${pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("(.+)")}$`);
+var resolveAliasTargets = (specifier, config) => {
+  const { aliases, baseUrl } = getAliasEntries(config);
+  const targets = [];
+  for (const alias of aliases) {
+    const match = specifier.match(aliasPatternToRegExp(alias.pattern));
+    if (!match)
+      continue;
+    const wildcard = match[1] ?? "";
+    for (const replacement of alias.replacements) {
+      targets.push(resolve(baseUrl, replacement.replace("*", wildcard)));
+    }
+  }
+  return targets;
+};
+var getLanguageExtensions = (language) => {
+  if (language === "less")
+    return [".less", ".css"];
+  if (language === "stylus")
+    return [".styl", ".stylus", ".css"];
+  return [".scss", ".sass", ".css"];
+};
+var getCandidatePaths = (basePath, language) => {
+  const ext = extname2(basePath);
+  const paths = ext ? [basePath] : getLanguageExtensions(language).flatMap((extension) => [
+    `${basePath}${extension}`,
+    join(basePath, `index${extension}`)
+  ]);
+  if (language === "scss" || language === "sass") {
+    return paths.flatMap((path) => {
+      const dir = dirname(path);
+      const base = path.slice(dir.length + 1);
+      return [path, join(dir, `_${base}`)];
+    });
+  }
+  return paths;
+};
+var resolveImportPath = (specifier, fromDirectory, loadPaths, language, config) => {
+  const rawCandidates = [
+    ...resolveAliasTargets(specifier, config),
+    isAbsolute(specifier) ? specifier : resolve(fromDirectory, specifier),
+    ...loadPaths.map((path) => resolve(path, specifier))
+  ];
+  for (const candidate of rawCandidates.flatMap((path) => getCandidatePaths(path, language))) {
+    if (existsSync(candidate))
+      return candidate;
+  }
+  return null;
+};
+var isExternalCssUrl = (url) => /^(?:[a-z][a-z0-9+.-]*:|\/\/|#|\/)/i.test(url);
+var splitCssUrl = (url) => {
+  const markerIndex = url.search(/[?#]/);
+  if (markerIndex === -1)
+    return { marker: "", path: url };
+  return {
+    marker: url.slice(markerIndex),
+    path: url.slice(0, markerIndex)
+  };
+};
+var rebaseCssUrls = (contents, sourceFile, entryFile) => {
+  const sourceDir = dirname(sourceFile);
+  const entryDir = dirname(entryFile);
+  if (sourceDir === entryDir)
+    return contents;
+  return contents.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (match, quote, rawUrl) => {
+    const trimmedUrl = rawUrl.trim();
+    if (!trimmedUrl || isExternalCssUrl(trimmedUrl))
+      return match;
+    const { marker, path } = splitCssUrl(trimmedUrl);
+    const rebased = relative(entryDir, resolve(sourceDir, path)).replace(/\\/g, "/");
+    const normalized = rebased.startsWith(".") ? rebased : `./${rebased}`;
+    const nextQuote = quote || '"';
+    return `url(${nextQuote}${normalized}${marker}${nextQuote})`;
+  });
+};
+var rewriteAliasedStyleImports = (contents, sourceFile, loadPaths, language, config) => contents.replace(/(@(?:use|forward|import|require)\s+)(["'])([^"']+)\2/g, (match, prefix, quote, specifier) => {
+  if (specifier.startsWith(".") || isAbsolute(specifier) || isExternalCssUrl(specifier))
+    return match;
+  const resolved = resolveImportPath(specifier, dirname(sourceFile), loadPaths, language, config);
+  return resolved ? `${prefix}${quote}${resolved}${quote}` : match;
+});
+var preprocessLoadedStyle = (contents, sourceFile, entryFile, loadPaths = [], language, config) => {
+  const rebased = rebaseCssUrls(contents, sourceFile, entryFile);
+  return language ? rewriteAliasedStyleImports(rebased, sourceFile, loadPaths, language, config) : rebased;
+};
+var extractCssModuleExports = (css) => {
+  const exports = {};
+  const nextCss = css.replace(/:export\s*\{([^}]*)\}/g, (_, body) => {
+    for (const declaration of body.split(";")) {
+      const separator = declaration.indexOf(":");
+      if (separator === -1)
+        continue;
+      const key = declaration.slice(0, separator).trim();
+      const value = declaration.slice(separator + 1).trim();
+      if (key && value)
+        exports[key] = value;
+    }
+    return "";
+  });
+  return { css: nextCss, exports };
+};
+var getSassOptions = (config, language) => ({
+  ...config?.sass ?? {},
+  ...language === "scss" ? config?.scss ?? {} : {}
+});
+var getLessOptions = (config) => config?.less ?? {};
+var getStylusOptions = (config) => config?.stylus ?? {};
+var withAdditionalData = (contents, additionalData) => additionalData ? `${additionalData}
+${contents}` : contents;
+var normalizePostcssModule = (mod) => {
+  if (mod && typeof mod === "object" && "default" in mod) {
+    return mod.default ?? mod;
+  }
+  return mod;
+};
+var loadPostcssConfigFile = async (configPath) => {
+  const resolved = resolve(process.cwd(), configPath);
+  const loaded = resolved.endsWith(".cjs") || resolved.endsWith(".cts") ? requireOptionalPeerSync(resolved) : await importOptionalPeer(`${new URL(`file://${resolved}`).href}?t=${Date.now()}`);
+  const config = normalizePostcssModule(loaded);
+  const value = typeof config === "function" ? await config({
+    cwd: process.cwd(),
+    env: getNodeEnv()
+  }) : config;
+  return normalizePostcssModule(value) ?? {};
+};
+var normalizePostcssPlugins = (plugins) => {
+  if (!plugins)
+    return [];
+  if (Array.isArray(plugins))
+    return plugins.filter(Boolean);
+  const resolved = [];
+  for (const [specifier, options] of Object.entries(plugins)) {
+    if (options === false)
+      continue;
+    const mod = normalizePostcssModule(requireOptionalPeerSync(specifier));
+    const plugin = typeof mod === "function" ? mod(options === true ? undefined : options) : mod;
+    if (plugin)
+      resolved.push(plugin);
+  }
+  return resolved;
+};
+var resolvePostcssConfig = async (config) => {
+  const inlineConfig = config?.postcss;
+  if (!inlineConfig)
+    return null;
+  const fileConfig = inlineConfig.config ? await loadPostcssConfigFile(inlineConfig.config) : {};
+  const plugins = [
+    ...normalizePostcssPlugins(fileConfig.plugins),
+    ...normalizePostcssPlugins(inlineConfig.plugins)
+  ];
+  if (plugins.length === 0)
+    return null;
+  return {
+    options: {
+      ...fileConfig.options ?? {},
+      ...inlineConfig.options ?? {}
+    },
+    plugins
+  };
+};
+var runPostcss = async (css, filePath, config) => {
+  const postcssConfig = await resolvePostcssConfig(config);
+  if (!postcssConfig)
+    return css;
+  let postcssModule;
+  try {
+    postcssModule = await importOptionalPeer("postcss");
+  } catch {
+    throw missingDependencyError("postcss", filePath);
+  }
+  const postcss = postcssModule.default ?? postcssModule;
+  const result = await postcss(postcssConfig.plugins).process(css, {
+    from: filePath,
+    map: false,
+    ...postcssConfig.options
+  });
+  return result.css;
+};
+var createSassImporter = (entryFile, loadPaths, language, config, deps) => ({
+  canonicalize(specifier, options) {
+    const fromDirectory = options.containingUrl ? dirname(fileURLToPath(options.containingUrl)) : dirname(entryFile);
+    const resolved = resolveImportPath(specifier, fromDirectory, loadPaths, language, config);
+    return resolved ? new URL(pathToFileURL(resolve(resolved)).href) : null;
+  },
+  load(canonicalUrl) {
+    const filePath = fileURLToPath(canonicalUrl);
+    deps?.add(filePath);
+    const fileLanguage = getStyleLanguage(filePath);
+    if (fileLanguage !== "scss" && fileLanguage !== "sass" && fileLanguage !== null)
+      return null;
+    return {
+      contents: preprocessLoadedStyle(readFileSync(filePath, "utf-8"), filePath, entryFile, loadPaths, language, config),
+      syntax: filePath.endsWith(".sass") ? "indented" : "scss"
+    };
+  }
+});
+var createLessFileManager = (entryFile, loadPaths, config, deps) => ({
+  install(less, pluginManager) {
+    const baseManager = new less.FileManager;
+    const manager = Object.create(baseManager);
+    manager.supports = (filename, currentDirectory) => Boolean(resolveImportPath(filename, resolve(currentDirectory), loadPaths, "less", config));
+    manager.loadFile = async (filename, currentDirectory) => {
+      const resolved = resolveImportPath(filename, resolve(currentDirectory), loadPaths, "less", config);
+      if (!resolved) {
+        throw new Error(`Unable to resolve Less import "${filename}"`);
+      }
+      deps?.add(resolved);
+      return {
+        contents: preprocessLoadedStyle(await readFile(resolved, "utf-8"), resolved, entryFile, loadPaths, "less", config),
+        filename: resolved
+      };
+    };
+    pluginManager.addFileManager(manager);
+  }
+});
+var renderStylus = async (contents, filePath, loadPaths, options, deps) => {
+  let stylus;
+  try {
+    const stylusModule = await importOptionalPeer("stylus");
+    stylus = stylusModule.default ?? stylusModule;
+  } catch {
+    throw missingDependencyError("stylus", filePath);
+  }
+  return new Promise((resolveCss, reject) => {
+    const renderer = stylus(contents);
+    renderer.set("filename", filePath);
+    for (const [key, value] of Object.entries(options.options ?? {})) {
+      renderer.set(key, value);
+    }
+    for (const path of loadPaths)
+      renderer.include(path);
+    renderer.render((error, css) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      if (deps) {
+        const stylusDeps = renderer.deps?.();
+        if (Array.isArray(stylusDeps)) {
+          for (const dep of stylusDeps)
+            deps.add(resolve(dep));
+        }
+      }
+      resolveCss(css ?? "");
+    });
+  });
+};
+var styleDependencyGraph = new Map;
+var styleOutputHashes = new Map;
+var recordStyleDeps = (entry, deps) => {
+  const key = resolve(entry);
+  const stripped = new Set;
+  for (const dep of deps) {
+    const resolved = resolve(dep);
+    if (resolved !== key)
+      stripped.add(resolved);
+  }
+  styleDependencyGraph.set(key, stripped);
+};
+var compileStyleSource = async (filePath, source, languageHint, config) => {
+  const language = getStyleLanguage(languageHint ?? filePath);
+  const rawContents = source ?? await readFile(filePath, "utf-8");
+  const deps = new Set;
+  if (language === "scss" || language === "sass") {
+    const options = getSassOptions(config, language);
+    const packageName = options.implementation ?? "sass";
+    let sass;
+    try {
+      sass = await importOptionalPeer(packageName);
+    } catch {
+      throw missingDependencyError(packageName, filePath);
+    }
+    const contents = withAdditionalData(rawContents, options.additionalData);
+    const loadPaths = normalizeLoadPaths(filePath, options.loadPaths);
+    try {
+      const result = sass.compileString(contents, {
+        importers: [
+          createSassImporter(filePath, loadPaths, language, config, deps)
+        ],
+        loadPaths,
+        style: "expanded",
+        syntax: language === "sass" ? "indented" : "scss",
+        url: new URL(pathToFileURL(resolve(filePath)).href)
+      });
+      const css = await runPostcss(result.css, filePath, config);
+      const loadedUrls = result.loadedUrls ?? [];
+      for (const url of loadedUrls) {
+        if (url.protocol !== "file:")
+          continue;
+        const dep = fileURLToPath(url);
+        if (resolve(dep) === resolve(filePath))
+          continue;
+        deps.add(dep);
+      }
+      recordStyleDeps(filePath, deps);
+      return css;
+    } catch (error) {
+      throwPreprocessorError(error, filePath, language);
+    }
+  }
+  if (language === "less") {
+    const options = getLessOptions(config);
+    let lessModule;
+    try {
+      lessModule = await importOptionalPeer("less");
+    } catch {
+      throw missingDependencyError("less", filePath);
+    }
+    const less = lessModule.render ? lessModule : lessModule.default;
+    const render = less?.render;
+    if (!render)
+      throw missingDependencyError("less", filePath);
+    const contents = withAdditionalData(rawContents, options.additionalData);
+    const loadPaths = normalizeLoadPaths(filePath, options.paths);
+    try {
+      const result = await render(contents, {
+        ...options.options ?? {},
+        filename: filePath,
+        paths: loadPaths,
+        plugins: [
+          ...options.options?.plugins ?? [],
+          createLessFileManager(filePath, loadPaths, config, deps)
+        ]
+      });
+      const css = await runPostcss(result.css, filePath, config);
+      recordStyleDeps(filePath, deps);
+      return css;
+    } catch (error) {
+      throwPreprocessorError(error, filePath, "less");
+    }
+  }
+  if (language === "stylus") {
+    const options = getStylusOptions(config);
+    const loadPaths = normalizeLoadPaths(filePath, options.paths);
+    const contents = withAdditionalData(preprocessLoadedStyle(rawContents, filePath, filePath, loadPaths, "stylus", config), options.additionalData);
+    try {
+      const css = await runPostcss(await renderStylus(contents, filePath, loadPaths, options, deps), filePath, config);
+      recordStyleDeps(filePath, deps);
+      return css;
+    } catch (error) {
+      throwPreprocessorError(error, filePath, "stylus");
+    }
+  }
+  return runPostcss(rawContents, filePath, config);
+};
+var createStylePreprocessorPlugin = (config) => ({
+  name: "absolute-style-preprocessor",
+  setup(build) {
+    const cssModuleSources = new Map;
+    build.onResolve({ filter: /^absolute-style-module:/ }, ({ path }) => ({
+      namespace: "absolute-style-module",
+      path: path.slice("absolute-style-module:".length)
+    }));
+    build.onLoad({ filter: /\.module\.css$/i, namespace: "absolute-style-module" }, async ({ path }) => {
+      const source = cssModuleSources.get(path);
+      if (!source) {
+        throw new Error(`Unable to resolve CSS module source for ${path}`);
+      }
+      return {
+        contents: source.css,
+        loader: "css"
+      };
+    });
+    build.onLoad({ filter: STYLE_EXTENSION_PATTERN }, async ({ path }) => {
+      if (isStyleModulePath(path)) {
+        const cssModulePath = path.replace(STYLE_EXTENSION_PATTERN, ".css");
+        const compiled = await compileStyleSource(path, undefined, undefined, config);
+        const { css, exports } = extractCssModuleExports(compiled);
+        cssModuleSources.set(cssModulePath, { css, exports });
+        const exportSource = Object.keys(exports).length > 0 ? `import styles from ${JSON.stringify(`absolute-style-module:${cssModulePath}`)}; export default Object.assign({}, styles, ${JSON.stringify(exports)});` : `export { default } from ${JSON.stringify(`absolute-style-module:${cssModulePath}`)};`;
+        return {
+          contents: exportSource,
+          loader: "js"
+        };
+      }
+      return {
+        contents: await compileStyleSource(path, undefined, undefined, config),
+        loader: "css"
+      };
+    });
+    build.onLoad({ filter: CSS_EXTENSION_PATTERN }, async ({ path }) => ({
+      contents: await compileStyleSource(path, undefined, undefined, config),
+      loader: "css"
+    }));
+  }
+});
+var stylePreprocessorPlugin = createStylePreprocessorPlugin();
+
+// src/build/scanCssEntryPoints.ts
+import { existsSync as existsSync2 } from "fs";
+var {Glob } = globalThis.Bun;
+var scanCssEntryPoints = async (dir, ignore) => {
+  if (!existsSync2(dir))
+    return [];
+  const entryPaths = [];
+  const glob = new Glob("**/*.{css,scss,sass,less,styl,stylus}");
+  for await (const file of glob.scan({ absolute: true, cwd: dir })) {
+    const normalized = normalizePath(file);
+    if (isStyleModulePath(normalized) || ignore?.some((pattern) => normalized.includes(pattern)))
+      continue;
+    entryPaths.push(file);
+  }
+  return entryPaths;
+};
+
+// src/build/manifestKeys.ts
+import { existsSync as existsSync3, readFileSync as readFileSync2 } from "fs";
+import { mkdir, readFile as readFile2, rename, rm, writeFile } from "fs/promises";
+import { basename, dirname as dirname2, extname as extname3, join as join2, relative as relative2, resolve as resolve2 } from "path";
+var GENERATED = ".absolutejs/generated";
+var STYLE_EXTENSION = /\.(?:css|scss|sass|less|styl|stylus)$/;
+var stemOf = (path) => basename(path, extname3(path));
+var toPosix = (path) => normalizePath(path);
+var asJs = (path) => toPosix(path).replace(/\.(?:vue|svelte|ts|tsx|jsx|js|mjs)$/, ".js");
+var deriveManifestKeys = async (config, projectRoot = process.cwd()) => {
+  const definite = new Set;
+  const possible = new Set;
+  const patterns = ["Chunk${string}"];
+  const at = (dir) => dir === undefined ? undefined : resolve2(projectRoot, dir);
+  const fromRoot = (path) => toPosix(relative2(projectRoot, path));
+  const add = (target, outputPath) => {
+    const output = manifestKeyForOutput(outputPath);
+    if (output)
+      target.add(output.key);
+  };
+  const reactDir = at(config.reactDirectory);
+  const svelteDir = at(config.svelteDirectory);
+  const vueDir = at(config.vueDirectory);
+  const angularDir = at(config.angularDirectory);
+  const emberDir = at(config.emberDirectory);
+  const htmlDir = at(config.htmlDirectory);
+  const htmxDir = at(config.htmxDirectory);
+  const assetsDir = at(config.assetsDirectory);
+  const fileRoutes = scanFileRoutes(config).routes;
+  if (reactDir) {
+    const pagesDir = join2(reactDir, "pages");
+    const pages = existsSync3(pagesDir) ? (await scanConventions(pagesDir, "*.{jsx,tsx}")).pageFiles : [];
+    const names = [
+      ...pages.map((page) => basename(page).split(".")[0] ?? ""),
+      ...fileRoutes.filter((route) => route.framework === "react").map((route) => route.name)
+    ].filter(Boolean);
+    for (const name of names) {
+      add(definite, `${GENERATED}/react/indexes/${name}.js`);
+      add(possible, `${GENERATED}/react/indexes/${name}.css`);
+    }
+  }
+  const rscDir = at(config.reactServerComponentsDirectory);
+  if (rscDir && existsSync3(join2(rscDir, "pages"))) {
+    const { reactServerPageManifestKeys } = await import("./buildReactServerComponents-fq6mw10d.js");
+    const names = (await scanEntryPoints(join2(rscDir, "pages"), "*.{tsx,jsx,ts,js}")).map((page) => toPascal(stemOf(page)));
+    if (names.length > 0) {
+      definite.add(REACT_SERVER_CLIENT_MANIFEST_KEY);
+      definite.add(REACT_SERVER_RENDERER_MANIFEST_KEY);
+    }
+    for (const keys of reactServerPageManifestKeys(names).keys.values())
+      for (const key of keys)
+        definite.add(key);
+  }
+  if (svelteDir) {
+    const { pageFiles } = await scanConventions(join2(svelteDir, "pages"), "*.svelte");
+    for (const page of pageFiles) {
+      const name = stemOf(page);
+      definite.add(toPascal(name));
+      add(definite, `svelte/server/pages/${name}.js`);
+      add(definite, `${GENERATED}/svelte/indexes/pages/${name}.js`);
+      add(definite, `${GENERATED}/svelte/client/pages/${name}.js`);
+      add(possible, `${GENERATED}/svelte/indexes/pages/${name}.css`);
+    }
+    for (const route of fileRoutes.filter((entry) => entry.framework === "svelte")) {
+      for (const key of [
+        route.name,
+        `${route.name}Index`,
+        `${route.name}Client`
+      ])
+        possible.add(key);
+    }
+  }
+  if (vueDir) {
+    const { pageFiles } = await scanConventions(join2(vueDir, "pages"), "*.vue");
+    const cssDir = assetsDir ? basename(assetsDir) : "assets";
+    for (const page of pageFiles) {
+      const name = stemOf(page);
+      const mirrored = asJs(fromRoot(page));
+      definite.add(toPascal(name));
+      add(definite, `vue/server/sources/${mirrored}`);
+      add(definite, `${GENERATED}/vue/indexes/${name}.js`);
+      add(definite, `${GENERATED}/vue/client/sources/${mirrored}`);
+      add(possible, `${cssDir}/css/${toKebab(name)}-compiled.css`);
+      possible.add(`${name}Css`);
+      if (readFileSync2(page, "utf-8").includes("defineRoutes"))
+        possible.add(`${name}SpaManifest`);
+    }
+  }
+  if (angularDir) {
+    const { pageFiles } = await scanConventions(join2(angularDir, "pages"), "**/*.ts");
+    for (const page of pageFiles) {
+      const name = stemOf(page);
+      definite.add(toPascal(name));
+      add(definite, `angular/${asJs(fromRoot(page))}`);
+      add(definite, `${GENERATED}/angular/indexes/${name}.js`);
+      add(possible, `${GENERATED}/angular/indexes/${name}.css`);
+    }
+  }
+  if (emberDir) {
+    const { pageFiles } = await scanConventions(join2(emberDir, "pages"), "*.{gjs,gts,ts}");
+    for (const page of pageFiles) {
+      definite.add(toPascal(stemOf(page)));
+      possible.add(`${toPascal(stemOf(page))}Index`);
+    }
+  }
+  for (const dir of [htmlDir, htmxDir]) {
+    if (!dir)
+      continue;
+    for (const page of await scanEntryPoints(join2(dir, "pages"), "*.html"))
+      definite.add(basename(page, ".html"));
+    for (const script of await scanEntryPoints(join2(dir, "scripts"), "*.{js,ts}"))
+      add(definite, asJs(fromRoot(script)));
+  }
+  const stylesPath = typeof config.stylesConfig === "string" ? config.stylesConfig : config.stylesConfig?.path;
+  const stylesDir = at(stylesPath);
+  if (stylesDir) {
+    const ignore = typeof config.stylesConfig === "object" ? config.stylesConfig.ignore : undefined;
+    for (const sheet of await scanCssEntryPoints(stylesDir, ignore)) {
+      const path = toPosix(relative2(stylesDir, sheet)).replace(STYLE_EXTENSION, ".css");
+      add(definite, `${basename(stylesDir)}/${path}`);
+    }
+  }
+  const registryPath = at(config.islands?.registry);
+  const bootstrapPath = at(config.islands?.bootstrap);
+  if (registryPath && existsSync3(registryPath)) {
+    const { definitions } = await loadIslandRegistryBuildInfo(registryPath);
+    for (const { component, framework } of definitions) {
+      add(definite, `islands/${framework}/${component}.js`);
+      add(possible, `islands/${framework}/${component}.css`);
+    }
+    if (!bootstrapPath && definitions.length > 0)
+      add(definite, `islands/${DEFAULT_ISLAND_BOOTSTRAP_NAME}.js`);
+  }
+  if (bootstrapPath && existsSync3(bootstrapPath)) {
+    definite.add(ISLAND_BOOTSTRAP_MANIFEST_KEY);
+    add(definite, asJs(fromRoot(bootstrapPath)));
+  }
+  const frameworkDirs = [
+    reactDir,
+    svelteDir,
+    vueDir,
+    angularDir,
+    htmlDir,
+    htmxDir
+  ].filter((dir) => dir !== undefined && existsSync3(dir));
+  if (frameworkDirs.length > 0) {
+    const { scanWorkerReferences } = await import("./build-fntmf42w.js");
+    for (const worker of await scanWorkerReferences(frameworkDirs))
+      possible.add(toPascal(stemOf(worker)));
+  }
+  if (config.fonts) {
+    patterns.push(`${FONT_PRELOAD_MANIFEST_PREFIX}\${number}`, `${FONTS_REMOTE_CSS_MANIFEST_PREFIX}\${number}`);
+  }
+  for (const key of definite)
+    possible.delete(key);
+  return { definite, patterns, possible };
+};
+var MANIFEST_KEYS_DECLARATION = ".absolutejs/types/manifest.d.ts";
+var PACKAGE = "@absolutejs/absolute";
+var manifestKeysDeclarationSource = ({
+  definite,
+  patterns,
+  possible
+}) => {
+  const keys = [...new Set([...definite, ...possible])].sort();
+  const members = [
+    ...keys.map((key) => `		${JSON.stringify(key)}: true;`),
+    ...patterns.map((pattern) => `		[key: \`${pattern}\`]: true;`)
+  ];
+  return `// Generated by AbsoluteJS from the project's pages, styles and islands
+// (absolute dev, absolute build, absolute typecheck). Do not edit.
+export {};
+
+declare module '${PACKAGE}' {
+	interface AbsoluteManifestKeys {
+${members.join(`
+`)}
+	}
+}
+`;
+};
+var mergeKeys = (all) => {
+  const definite = new Set(all.flatMap((keys) => [...keys.definite]));
+  const possible = new Set(all.flatMap((keys) => [...keys.possible]).filter((key) => !definite.has(key)));
+  const patterns = [...new Set(all.flatMap((keys) => keys.patterns))];
+  return { definite, patterns, possible };
+};
+var writeManifestKeysDeclaration = async (configs, projectRoot = process.cwd()) => {
+  const path = join2(projectRoot, MANIFEST_KEYS_DECLARATION);
+  try {
+    const derived = mergeKeys(await Promise.all((Array.isArray(configs) ? configs : [configs]).map((config) => deriveManifestKeys(config, projectRoot))));
+    if (derived.definite.size === 0 && derived.possible.size === 0) {
+      await rm(path, { force: true });
+      return null;
+    }
+    const source = manifestKeysDeclarationSource(derived);
+    const current = existsSync3(path) ? await readFile2(path, "utf-8") : undefined;
+    if (current === source)
+      return path;
+    await mkdir(dirname2(path), { recursive: true });
+    const staging = `${path}.${process.pid}.tmp`;
+    await writeFile(staging, source);
+    await rename(staging, path);
+    return path;
+  } catch {
+    return existsSync3(path) ? path : null;
+  }
+};
+
+export { REACT_SERVER_CLIENT_MANIFEST_KEY, REACT_SERVER_PAGE_MANIFEST_SUFFIX, REACT_SERVER_PAYLOAD_GLOBAL, REACT_SERVER_RENDERER_MANIFEST_KEY, REACT_SERVER_RUNTIME_FILE, MANIFEST_KEYS_DECLARATION, writeManifestKeysDeclaration };