@absolutejs/absolute 0.19.0-beta.693 → 0.19.0-beta.695

package/dist/build.js

@@ -2448,10 +2448,27 @@ var init_lowerAwaitSlotSyntax = __esm(() => {
 });
 
 // src/build/stylePreprocessor.ts
+var exports_stylePreprocessor = {};
+__export(exports_stylePreprocessor, {
+  stylePreprocessorPlugin: () => stylePreprocessorPlugin,
+  isStylePath: () => isStylePath,
+  isStyleModulePath: () => isStyleModulePath,
+  isPreprocessableStylePath: () => isPreprocessableStylePath,
+  getStyleBaseName: () => getStyleBaseName,
+  getCssOutputExtension: () => getCssOutputExtension,
+  createSvelteStylePreprocessor: () => createSvelteStylePreprocessor,
+  createStyleTransformConfig: () => createStyleTransformConfig,
+  createStylePreprocessorPlugin: () => createStylePreprocessorPlugin,
+  compileStyleSource: () => compileStyleSource,
+  compileStyleFileIfNeededSync: () => compileStyleFileIfNeededSync,
+  compileStyleFileIfNeeded: () => compileStyleFileIfNeeded
+});
+import { existsSync as existsSync5, readFileSync as readFileSync3 } from "fs";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
-import { dirname as dirname3, extname as extname3, join as join5, resolve as resolve6 } from "path";
-var STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATTERN, importOptionalPeer, requireOptionalPeer, requireFromCwd, isPreprocessableStylePath = (filePath) => STYLE_EXTENSION_PATTERN.test(filePath), isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath), isStylePath = (filePath) => /\.(css|s[ac]ss|less)$/i.test(filePath), getStyleBaseName = (filePath) => filePath.replace(/\.(css|s[ac]ss|less)$/i, ""), getStyleLanguage = (filePathOrLanguage) => {
+import { dirname as dirname3, extname as extname3, isAbsolute, join as join5, relative as relative3, resolve as resolve6 } from "path";
+import { fileURLToPath } from "url";
+var CSS_EXTENSION_PATTERN, STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATTERN, importOptionalPeer, requireOptionalPeer, requireFromCwd, isPreprocessableStylePath = (filePath) => STYLE_EXTENSION_PATTERN.test(filePath), isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath), isStylePath = (filePath) => /\.(css|s[ac]ss|less|styl(?:us)?)$/i.test(filePath), getStyleBaseName = (filePath) => filePath.replace(/\.(css|s[ac]ss|less|styl(?:us)?)$/i, ""), getStyleLanguage = (filePathOrLanguage) => {
   const normalized = filePathOrLanguage.toLowerCase();
   if (normalized === "scss" || normalized.endsWith(".scss"))
     return "scss";
@@ -2459,16 +2476,266 @@ var STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATT
     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;
-}, missingDependencyError = (name, filePath) => new Error(`Unable to compile ${filePath}: install optional dependency "${name}" to use this stylesheet preprocessor.`), normalizeLoadPaths = (filePath, paths = []) => [
+}, missingDependencyError = (name, filePath) => new Error(`Unable to compile ${filePath}: install optional dependency "${name}" to use this stylesheet preprocessor.`), requireOptionalPeerSync = (specifier) => {
+  try {
+    return requireFromCwd(specifier);
+  } catch {
+    return requireOptionalPeer(specifier);
+  }
+}, normalizeLoadPaths = (filePath, paths = []) => [
   dirname3(filePath),
   process.cwd(),
   ...paths.map((path) => resolve6(process.cwd(), path))
-], getSassOptions = (config, language) => ({
+], tsconfigAliasCache, stripJsonComments = (source) => source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1"), normalizeAliasEntries = (aliases) => Object.entries(aliases ?? {}).map(([pattern, value]) => ({
+  pattern,
+  replacements: Array.isArray(value) ? value : [value]
+})), readTsconfigAliases = () => {
+  const cwd = process.cwd();
+  if (tsconfigAliasCache?.cwd === cwd)
+    return tsconfigAliasCache;
+  const tsconfigPath = resolve6(cwd, "tsconfig.json");
+  const empty = { aliases: [], baseUrl: cwd, cwd };
+  if (!existsSync5(tsconfigPath)) {
+    tsconfigAliasCache = empty;
+    return empty;
+  }
+  try {
+    const parsed = JSON.parse(stripJsonComments(readFileSync3(tsconfigPath, "utf-8")));
+    const compilerOptions = parsed.compilerOptions ?? {};
+    const baseUrl = resolve6(cwd, compilerOptions.baseUrl ?? ".");
+    tsconfigAliasCache = {
+      aliases: normalizeAliasEntries(compilerOptions.paths),
+      baseUrl,
+      cwd
+    };
+  } catch {
+    tsconfigAliasCache = empty;
+  }
+  return tsconfigAliasCache;
+}, getAliasEntries = (config) => {
+  const tsconfig = readTsconfigAliases();
+  return {
+    aliases: [...normalizeAliasEntries(config?.aliases), ...tsconfig.aliases],
+    baseUrl: tsconfig.baseUrl
+  };
+}, aliasPatternToRegExp = (pattern) => new RegExp(`^${pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("(.+)")}$`), 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(resolve6(baseUrl, replacement.replace("*", wildcard)));
+    }
+  }
+  return targets;
+}, getLanguageExtensions = (language) => {
+  if (language === "less")
+    return [".less", ".css"];
+  if (language === "stylus")
+    return [".styl", ".stylus", ".css"];
+  return [".scss", ".sass", ".css"];
+}, getCandidatePaths = (basePath, language) => {
+  const ext = extname3(basePath);
+  const paths = ext ? [basePath] : getLanguageExtensions(language).flatMap((extension) => [
+    `${basePath}${extension}`,
+    join5(basePath, `index${extension}`)
+  ]);
+  if (language === "scss" || language === "sass") {
+    return paths.flatMap((path) => {
+      const dir = dirname3(path);
+      const base = path.slice(dir.length + 1);
+      return [path, join5(dir, `_${base}`)];
+    });
+  }
+  return paths;
+}, resolveImportPath = (specifier, fromDirectory, loadPaths, language, config) => {
+  const rawCandidates = [
+    ...resolveAliasTargets(specifier, config),
+    isAbsolute(specifier) ? specifier : resolve6(fromDirectory, specifier),
+    ...loadPaths.map((path) => resolve6(path, specifier))
+  ];
+  for (const candidate of rawCandidates.flatMap((path) => getCandidatePaths(path, language))) {
+    if (existsSync5(candidate))
+      return candidate;
+  }
+  return null;
+}, isExternalCssUrl = (url) => /^(?:[a-z][a-z0-9+.-]*:|\/\/|#|\/)/i.test(url), splitCssUrl = (url) => {
+  const markerIndex = url.search(/[?#]/);
+  if (markerIndex === -1)
+    return { marker: "", path: url };
+  return {
+    marker: url.slice(markerIndex),
+    path: url.slice(0, markerIndex)
+  };
+}, rebaseCssUrls = (contents, sourceFile, entryFile) => {
+  const sourceDir = dirname3(sourceFile);
+  const entryDir = dirname3(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 = relative3(entryDir, resolve6(sourceDir, path)).replace(/\\/g, "/");
+    const normalized = rebased.startsWith(".") ? rebased : `./${rebased}`;
+    const nextQuote = quote || '"';
+    return `url(${nextQuote}${normalized}${marker}${nextQuote})`;
+  });
+}, 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, dirname3(sourceFile), loadPaths, language, config);
+  return resolved ? `${prefix}${quote}${resolved}${quote}` : match;
+}), preprocessLoadedStyle = (contents, sourceFile, entryFile, loadPaths = [], language, config) => {
+  const rebased = rebaseCssUrls(contents, sourceFile, entryFile);
+  return language ? rewriteAliasedStyleImports(rebased, sourceFile, loadPaths, language, config) : rebased;
+}, 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 };
+}, getSassOptions = (config, language) => ({
   ...config?.sass ?? {},
   ...language === "scss" ? config?.scss ?? {} : {}
-}), getLessOptions = (config) => config?.less ?? {}, withAdditionalData = (contents, additionalData) => additionalData ? `${additionalData}
-${contents}` : contents, compileStyleSource = async (filePath, source, languageHint, config) => {
+}), getLessOptions = (config) => config?.less ?? {}, getStylusOptions = (config) => config?.stylus ?? {}, createStyleTransformConfig = (stylePreprocessors, postcss) => postcss === undefined ? stylePreprocessors : { ...stylePreprocessors ?? {}, postcss }, withAdditionalData = (contents, additionalData) => additionalData ? `${additionalData}
+${contents}` : contents, normalizePostcssModule = (mod) => {
+  if (mod && typeof mod === "object" && "default" in mod) {
+    return mod.default ?? mod;
+  }
+  return mod;
+}, loadPostcssConfigFile = async (configPath) => {
+  const resolved = resolve6(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: "development"
+  }) : config;
+  return normalizePostcssModule(value) ?? {};
+}, 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;
+}, 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
+  };
+}, 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;
+}, createSassImporter = (entryFile, loadPaths, language, config) => ({
+  canonicalize(specifier, options) {
+    const fromDirectory = options.containingUrl ? dirname3(fileURLToPath(options.containingUrl)) : dirname3(entryFile);
+    const resolved = resolveImportPath(specifier, fromDirectory, loadPaths, language, config);
+    return resolved ? new URL(`file://${resolved}`) : null;
+  },
+  load(canonicalUrl) {
+    const filePath = fileURLToPath(canonicalUrl);
+    const fileLanguage = getStyleLanguage(filePath);
+    if (fileLanguage !== "scss" && fileLanguage !== "sass" && fileLanguage !== null)
+      return null;
+    return {
+      contents: preprocessLoadedStyle(readFileSync3(filePath, "utf-8"), filePath, entryFile, loadPaths, language, config),
+      syntax: filePath.endsWith(".sass") ? "indented" : "scss"
+    };
+  }
+}), createLessFileManager = (entryFile, loadPaths, config) => ({
+  install(less, pluginManager) {
+    const baseManager = new less.FileManager;
+    const manager = Object.create(baseManager);
+    manager.supports = (filename, currentDirectory) => Boolean(resolveImportPath(filename, resolve6(currentDirectory), loadPaths, "less", config));
+    manager.loadFile = async (filename, currentDirectory) => {
+      const resolved = resolveImportPath(filename, resolve6(currentDirectory), loadPaths, "less", config);
+      if (!resolved) {
+        throw new Error(`Unable to resolve Less import "${filename}"`);
+      }
+      return {
+        contents: preprocessLoadedStyle(await readFile(resolved, "utf-8"), resolved, entryFile, loadPaths, "less", config),
+        filename: resolved
+      };
+    };
+    pluginManager.addFileManager(manager);
+  }
+}), renderStylus = async (contents, filePath, loadPaths, options) => {
+  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);
+      else
+        resolveCss(css ?? "");
+    });
+  });
+}, compileStyleSource = async (filePath, source, languageHint, config) => {
   const language = getStyleLanguage(languageHint ?? filePath);
   const rawContents = source ?? await readFile(filePath, "utf-8");
   if (language === "scss" || language === "sass") {
@@ -2481,13 +2748,17 @@ ${contents}` : contents, compileStyleSource = async (filePath, source, languageH
       throw missingDependencyError(packageName, filePath);
     }
     const contents = withAdditionalData(rawContents, options.additionalData);
+    const loadPaths = normalizeLoadPaths(filePath, options.loadPaths);
     const result = sass.compileString(contents, {
-      loadPaths: normalizeLoadPaths(filePath, options.loadPaths),
+      importers: [
+        createSassImporter(filePath, loadPaths, language, config)
+      ],
+      loadPaths,
       style: "expanded",
       syntax: language === "sass" ? "indented" : "scss",
       url: new URL(`file://${filePath}`)
     });
-    return result.css;
+    return runPostcss(result.css, filePath, config);
   }
   if (language === "less") {
     const options = getLessOptions(config);
@@ -2502,14 +2773,25 @@ ${contents}` : contents, compileStyleSource = async (filePath, source, languageH
     if (!render)
       throw missingDependencyError("less", filePath);
     const contents = withAdditionalData(rawContents, options.additionalData);
+    const loadPaths = normalizeLoadPaths(filePath, options.paths);
     const result = await render(contents, {
       ...options.options ?? {},
       filename: filePath,
-      paths: normalizeLoadPaths(filePath, options.paths)
+      paths: loadPaths,
+      plugins: [
+        ...options.options?.plugins ?? [],
+        createLessFileManager(filePath, loadPaths, config)
+      ]
     });
-    return result.css;
+    return runPostcss(result.css, filePath, config);
   }
-  return rawContents;
+  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);
+    return runPostcss(await renderStylus(contents, filePath, loadPaths, options), filePath, config);
+  }
+  return runPostcss(rawContents, filePath, config);
 }, createStylePreprocessorPlugin = (config) => ({
   name: "absolute-style-preprocessor",
   setup(build) {
@@ -2519,21 +2801,24 @@ ${contents}` : contents, compileStyleSource = async (filePath, source, languageH
       path: path.slice("absolute-style-module:".length)
     }));
     build.onLoad({ filter: /\.module\.css$/i, namespace: "absolute-style-module" }, async ({ path }) => {
-      const sourcePath = cssModuleSources.get(path);
-      if (!sourcePath) {
+      const source = cssModuleSources.get(path);
+      if (!source) {
         throw new Error(`Unable to resolve CSS module source for ${path}`);
       }
       return {
-        contents: await compileStyleSource(sourcePath, undefined, undefined, config),
+        contents: source.css,
         loader: "css"
       };
     });
     build.onLoad({ filter: STYLE_EXTENSION_PATTERN }, async ({ path }) => {
       if (isStyleModulePath(path)) {
         const cssModulePath = path.replace(STYLE_EXTENSION_PATTERN, ".css");
-        cssModuleSources.set(cssModulePath, path);
+        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: `export { default } from ${JSON.stringify(`absolute-style-module:${cssModulePath}`)};`,
+          contents: exportSource,
           loader: "js"
         };
       }
@@ -2542,6 +2827,10 @@ ${contents}` : contents, compileStyleSource = async (filePath, source, languageH
         loader: "css"
       };
     });
+    build.onLoad({ filter: CSS_EXTENSION_PATTERN }, async ({ path }) => ({
+      contents: await compileStyleSource(path, undefined, undefined, config),
+      loader: "css"
+    }));
   }
 }), stylePreprocessorPlugin, createSvelteStylePreprocessor = (config) => ({
   style: async ({
@@ -2559,14 +2848,49 @@ ${contents}` : contents, compileStyleSource = async (filePath, source, languageH
   }
 }), compileStyleFileIfNeeded = async (filePath, config) => {
   if (!isPreprocessableStylePath(filePath)) {
-    return readFile(filePath, "utf-8");
+    return runPostcss(await readFile(filePath, "utf-8"), filePath, config);
   }
   return compileStyleSource(filePath, undefined, undefined, config);
-};
+}, compileStyleFileIfNeededSync = (filePath, config) => {
+  const rawContents = readFileSync3(filePath, "utf-8");
+  const language = getStyleLanguage(filePath);
+  if (config?.postcss) {
+    throw new Error(`Unable to compile ${filePath}: PostCSS preprocessing is async-only.`);
+  }
+  if (language === "scss" || language === "sass") {
+    const options = getSassOptions(config, language);
+    const packageName = options.implementation ?? "sass";
+    let sass;
+    try {
+      sass = requireOptionalPeerSync(packageName);
+    } catch {
+      throw missingDependencyError(packageName, filePath);
+    }
+    const contents = withAdditionalData(rawContents, options.additionalData);
+    const loadPaths = normalizeLoadPaths(filePath, options.loadPaths);
+    return sass.compileString(contents, {
+      importers: [
+        createSassImporter(filePath, loadPaths, language, config)
+      ],
+      loadPaths,
+      style: "expanded",
+      syntax: language === "sass" ? "indented" : "scss",
+      url: new URL(`file://${filePath}`)
+    }).css;
+  }
+  if (language === "less") {
+    throw new Error(`Unable to compile ${filePath}: Less styleUrl preprocessing is async-only. Import the Less file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
+  }
+  if (language === "stylus") {
+    throw new Error(`Unable to compile ${filePath}: Stylus styleUrl preprocessing is async-only. Import the Stylus file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
+  }
+  return rawContents;
+}, getCssOutputExtension = (filePath) => isPreprocessableStylePath(filePath) ? ".css" : extname3(filePath);
 var init_stylePreprocessor = __esm(() => {
-  STYLE_EXTENSION_PATTERN = /\.(s[ac]ss|less)$/i;
-  STYLE_MODULE_EXTENSION_PATTERN = /\.module\.(s[ac]ss|less)$/i;
-  STYLE_LANGUAGE_PATTERN = /^(s[ac]ss|less)$/i;
+  CSS_EXTENSION_PATTERN = /\.css$/i;
+  STYLE_EXTENSION_PATTERN = /\.(s[ac]ss|less|styl(?:us)?)$/i;
+  STYLE_MODULE_EXTENSION_PATTERN = /\.module\.(s[ac]ss|less|styl(?:us)?)$/i;
+  STYLE_LANGUAGE_PATTERN = /^(s[ac]ss|less|styl(?:us)?)$/i;
   importOptionalPeer = new Function("specifier", "return import(specifier)");
   requireOptionalPeer = new Function("specifier", "return require(specifier)");
   requireFromCwd = createRequire(join5(process.cwd(), "package.json"));
@@ -2575,9 +2899,9 @@ var init_stylePreprocessor = __esm(() => {
 
 // src/core/svelteServerModule.ts
 import { mkdir, readdir as readdir2 } from "fs/promises";
-import { basename as basename2, dirname as dirname4, extname as extname4, join as join6, relative as relative3, resolve as resolve7 } from "path";
+import { basename as basename2, dirname as dirname4, extname as extname4, join as join6, relative as relative4, resolve as resolve7 } from "path";
 var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
-  const importPath = relative3(dirname4(from), target).replace(/\\/g, "/");
+  const importPath = relative4(dirname4(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, processDirectoryEntries = (entries, dir, targetFileName, stack) => {
   for (const entry of entries) {
@@ -2641,7 +2965,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   const foundIndex = existResults.indexOf(true);
   return foundIndex >= 0 ? candidates[foundIndex] ?? null : null;
 }, getCachedModulePath = (sourcePath) => {
-  const relativeSourcePath = relative3(process.cwd(), sourcePath).replace(/\\/g, "/");
+  const relativeSourcePath = relative4(process.cwd(), sourcePath).replace(/\\/g, "/");
   const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
   return join6(serverCacheRoot, `${normalizedSourcePath}.server.js`);
 }, resolveSvelteImport = async (spec, from) => {
@@ -2961,7 +3285,7 @@ var init_staticStreaming = __esm(() => {
 });
 
 // src/build/staticIslandPages.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync3 } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
 var ISLAND_TAG_RE_SOURCE = "<(?:absolute-island|island)\\b([^>]*?)(?:\\/\\>|>(?:[\\s\\S]*?)<\\/(?:absolute-island|island)>)", ATTRIBUTE_RE_SOURCE = `([A-Za-z_:][-A-Za-z0-9_:.]*)\\s*=\\s*(?:"([^"]*)"|'([^']*)')`, islandFrameworks, islandHydrationModes, isRecord5 = (value) => typeof value === "object" && value !== null, isIslandFramework = (value) => islandFrameworks.some((framework) => framework === value), isIslandHydrationMode = (value) => islandHydrationModes.some((mode) => mode === value), parseHtmlAttributes = (attributeString) => {
   const attributeRe = new RegExp(ATTRIBUTE_RE_SOURCE, "g");
   const attributes = new Map;
@@ -3090,7 +3414,7 @@ var ISLAND_TAG_RE_SOURCE = "<(?:absolute-island|island)\\b([^>]*?)(?:\\/\\>|>(?:
   }
   return result + originalHtml.slice(nextIndex);
 }, transformStaticPage = async (pagePath, registry) => {
-  const originalHtml = readFileSync3(pagePath, "utf-8");
+  const originalHtml = readFileSync4(pagePath, "utf-8");
   const transformedHtml = await transformStaticPageHtml(originalHtml, registry);
   if (transformedHtml !== originalHtml) {
     writeFileSync3(pagePath, transformedHtml);
@@ -3143,10 +3467,10 @@ var init_outputLogs = __esm(() => {
 });
 
 // src/build/scanEntryPoints.ts
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync6 } from "fs";
 var {Glob: Glob2 } = globalThis.Bun;
 var scanEntryPoints = async (dir, pattern) => {
-  if (!existsSync5(dir))
+  if (!existsSync6(dir))
     return [];
   const entryPaths = [];
   const glob = new Glob2(pattern);
@@ -3160,7 +3484,7 @@ var init_scanEntryPoints = () => {};
 // src/build/scanConventions.ts
 import { basename as basename3 } from "path";
 var {Glob: Glob3 } = globalThis.Bun;
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 var CONVENTION_RE, classifyFile = (file, pageFiles, defaults, pages) => {
   const fileName = basename3(file);
   const match = CONVENTION_RE.exec(fileName);
@@ -3185,7 +3509,7 @@ var CONVENTION_RE, classifyFile = (file, pageFiles, defaults, pages) => {
   else if (kind === "loading")
     pages[pageName].loading = file;
 }, scanConventions = async (pagesDir, pattern) => {
-  if (!existsSync6(pagesDir)) {
+  if (!existsSync7(pagesDir)) {
     const pageFiles2 = [];
     return { conventions: undefined, pageFiles: pageFiles2 };
   }
@@ -3208,13 +3532,13 @@ var init_scanConventions = __esm(() => {
 });
 
 // src/build/scanCssEntryPoints.ts
-import { existsSync as existsSync7 } from "fs";
+import { existsSync as existsSync8 } from "fs";
 var {Glob: Glob4 } = globalThis.Bun;
 var scanCssEntryPoints = async (dir, ignore) => {
-  if (!existsSync7(dir))
+  if (!existsSync8(dir))
     return [];
   const entryPaths = [];
-  const glob = new Glob4("**/*.{css,scss,sass,less}");
+  const glob = new Glob4("**/*.{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)))
@@ -3228,7 +3552,7 @@ var init_scanCssEntryPoints = __esm(() => {
 });
 
 // src/utils/imageProcessing.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
 import { join as join7, resolve as resolve8 } from "path";
 var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY = 75, OPTIMIZATION_ENDPOINT = "/_absolute/image", BLUR_DEVIATION = 20, sharpModule = undefined, sharpLoaded = false, sharpWarned = false, snapToSize = (target, sizes) => {
   for (const size of sizes) {
@@ -3283,7 +3607,7 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY = 75, OPTIMIZATIO
   return [...device, ...image].sort((left, right) => left - right);
 }, getCacheDir = (buildDir) => {
   const dir = join7(buildDir, ".cache", "images");
-  if (!existsSync8(dir))
+  if (!existsSync9(dir))
     mkdirSync3(dir, { recursive: true });
   return dir;
 }, getCacheKey = (url, width, quality, format) => {
@@ -3341,11 +3665,11 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY = 75, OPTIMIZATIO
 }, readFromCache = (cacheDir, cacheKey) => {
   const metaPath = join7(cacheDir, `${cacheKey}.meta`);
   const dataPath = join7(cacheDir, `${cacheKey}.data`);
-  if (!existsSync8(metaPath) || !existsSync8(dataPath))
+  if (!existsSync9(metaPath) || !existsSync9(dataPath))
     return null;
   try {
-    const meta = JSON.parse(readFileSync4(metaPath, "utf-8"));
-    const buffer = readFileSync4(dataPath);
+    const meta = JSON.parse(readFileSync5(metaPath, "utf-8"));
+    const buffer = readFileSync5(dataPath);
     return { buffer, meta };
   } catch {
     return null;
@@ -3460,14 +3784,14 @@ var init_optimizeHtmlImages = __esm(() => {
 });
 
 // src/cli/scripts/telemetry.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync5, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
 import { homedir } from "os";
 import { join as join8 } from "path";
 var configDir, configPath, getTelemetryConfig = () => {
   try {
-    if (!existsSync9(configPath))
+    if (!existsSync10(configPath))
       return null;
-    const raw = readFileSync5(configPath, "utf-8");
+    const raw = readFileSync6(configPath, "utf-8");
     const config = JSON.parse(raw);
     return config;
   } catch {
@@ -3480,14 +3804,14 @@ var init_telemetry = __esm(() => {
 });
 
 // src/cli/telemetryEvent.ts
-import { existsSync as existsSync10, readFileSync as readFileSync6 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync7 } from "fs";
 import { arch, platform } from "os";
 import { dirname as dirname5, join as join9, parse } from "path";
 var checkCandidate = (candidate) => {
-  if (!existsSync10(candidate)) {
+  if (!existsSync11(candidate)) {
     return null;
   }
-  const pkg = JSON.parse(readFileSync6(candidate, "utf-8"));
+  const pkg = JSON.parse(readFileSync7(candidate, "utf-8"));
   if (pkg.name === "@absolutejs/absolute") {
     const ver = pkg.version;
     return ver;
@@ -3592,17 +3916,17 @@ var init_updateAssetPaths = __esm(() => {
 });
 
 // src/dev/buildHMRClient.ts
-import { existsSync as existsSync11 } from "fs";
+import { existsSync as existsSync12 } from "fs";
 import { resolve as resolve9 } from "path";
 var {build: bunBuild } = globalThis.Bun;
 var resolveHmrClientPath = () => {
   const projectRoot = process.cwd();
   const fromSource = resolve9(import.meta.dir, "client/hmrClient.ts");
-  if (existsSync11(fromSource) && fromSource.startsWith(projectRoot)) {
+  if (existsSync12(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
   const fromNodeModules = resolve9(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client/hmrClient.ts");
-  if (existsSync11(fromNodeModules))
+  if (existsSync12(fromNodeModules))
     return fromNodeModules;
   return resolve9(import.meta.dir, "dev/client/hmrClient.ts");
 }, hmrClientPath2, buildHMRClient = async () => {
@@ -3794,8 +4118,8 @@ var devVendorPaths = null, getDevVendorPaths = () => devVendorPaths, setDevVendo
 };
 
 // src/build/angularLinkerPlugin.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync7, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname6, join as join10, relative as relative4, resolve as resolve11 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname6, join as join10, relative as relative5, resolve as resolve11 } from "path";
 import { createHash } from "crypto";
 var CACHE_DIR, angularLinkerPlugin;
 var init_angularLinkerPlugin = __esm(() => {
@@ -3819,9 +4143,9 @@ var init_angularLinkerPlugin = __esm(() => {
         }
         const hash = createHash("md5").update(source).digest("hex");
         const cachePath = join10(CACHE_DIR, `${hash}.js`);
-        if (existsSync12(cachePath)) {
+        if (existsSync13(cachePath)) {
           return {
-            contents: readFileSync7(cachePath, "utf-8"),
+            contents: readFileSync8(cachePath, "utf-8"),
             loader: "js"
           };
         }
@@ -3836,9 +4160,9 @@ var init_angularLinkerPlugin = __esm(() => {
           linkerPlugin = mod.createEs2015LinkerPlugin({
             fileSystem: {
               dirname: dirname6,
-              exists: existsSync12,
-              readFile: readFileSync7,
-              relative: relative4,
+              exists: existsSync13,
+              readFile: readFileSync8,
+              relative: relative5,
               resolve: resolve11
             },
             linkerJitMode: false,
@@ -3879,11 +4203,11 @@ var HASHED_FILE_PATTERN, cleanStaleOutputs = async (buildPath, currentOutputPath
   const currentPaths = new Set(currentOutputPaths.map((path) => resolve12(path)));
   const glob = new Glob5("**/*");
   const removals = [];
-  for (const relative5 of glob.scanSync({ cwd: buildPath })) {
-    const absolute = resolve12(buildPath, relative5);
+  for (const relative6 of glob.scanSync({ cwd: buildPath })) {
+    const absolute = resolve12(buildPath, relative6);
     if (currentPaths.has(absolute))
       continue;
-    if (!HASHED_FILE_PATTERN.test(relative5))
+    if (!HASHED_FILE_PATTERN.test(relative6))
       continue;
     removals.push(rm2(absolute, { force: true }));
   }
@@ -3941,11 +4265,11 @@ var commonAncestor = (paths, fallback) => {
 var init_commonAncestor = () => {};
 
 // src/utils/validateSafePath.ts
-import { resolve as resolve13, relative as relative5 } from "path";
+import { resolve as resolve13, relative as relative6 } from "path";
 var validateSafePath = (targetPath, baseDirectory) => {
   const absoluteBase = resolve13(baseDirectory);
   const absoluteTarget = resolve13(baseDirectory, targetPath);
-  const relativePath = normalizePath(relative5(absoluteBase, absoluteTarget));
+  const relativePath = normalizePath(relative6(absoluteBase, absoluteTarget));
   if (relativePath.startsWith("../") || relativePath === "..") {
     throw new Error(`Unsafe path: ${targetPath}`);
   }
@@ -4091,7 +4415,7 @@ __export(exports_compileSvelte, {
   compileSvelte: () => compileSvelte,
   clearSvelteCompilerCache: () => clearSvelteCompilerCache
 });
-import { existsSync as existsSync13 } from "fs";
+import { existsSync as existsSync14 } from "fs";
 import { mkdir as mkdir2, stat } from "fs/promises";
 import {
   dirname as dirname7,
@@ -4099,7 +4423,7 @@ import {
   basename as basename4,
   extname as extname5,
   resolve as resolve14,
-  relative as relative6,
+  relative as relative7,
   sep as sep2
 } from "path";
 import { env } from "process";
@@ -4107,11 +4431,11 @@ var {write, file, Transpiler } = globalThis.Bun;
 var resolveDevClientDir2 = () => {
   const projectRoot = process.cwd();
   const fromSource = resolve14(import.meta.dir, "../dev/client");
-  if (existsSync13(fromSource) && fromSource.startsWith(projectRoot)) {
+  if (existsSync14(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
   const fromNodeModules = resolve14(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync13(fromNodeModules))
+  if (existsSync14(fromNodeModules))
     return fromNodeModules;
   return resolve14(import.meta.dir, "./dev/client");
 }, devClientDir2, hmrClientPath3, persistentCache, sourceHashCache, clearSvelteCompilerCache = () => {
@@ -4191,8 +4515,8 @@ var resolveDevClientDir2 = () => {
     return jsPath;
   return null;
 }, addModuleRewrite = (rewrites, rawSpec, resolvedModule, ssrOutputDir, clientOutputDir) => {
-  const toServer = relative6(ssrOutputDir, resolvedModule).replace(/\\/g, "/");
-  const toClient = relative6(clientOutputDir, resolvedModule).replace(/\\/g, "/");
+  const toServer = relative7(ssrOutputDir, resolvedModule).replace(/\\/g, "/");
+  const toClient = relative7(clientOutputDir, resolvedModule).replace(/\\/g, "/");
   rewrites.set(rawSpec, {
     client: toClient.startsWith(".") || toClient.startsWith("/") ? toClient : `./${toClient}`,
     server: toServer.startsWith(".") ? toServer : `./${toServer}`
@@ -4230,8 +4554,8 @@ var resolveDevClientDir2 = () => {
     const preprocessedClient = isModule ? loweredClientSource.code : (await preprocess(loweredClientSource.code, svelteStylePreprocessor)).code;
     const transpiledServer = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler2.transformSync(preprocessedServer) : preprocessedServer;
     const transpiledClient = src.endsWith(".ts") || src.endsWith(".svelte.ts") ? transpiler2.transformSync(preprocessedClient) : preprocessedClient;
-    const rawRel = dirname7(relative6(svelteRoot, src)).replace(/\\/g, "/");
-    const relDir = rawRel.startsWith("..") ? `_ext/${relative6(process.cwd(), dirname7(src)).replace(/\\/g, "/")}` : rawRel;
+    const rawRel = dirname7(relative7(svelteRoot, src)).replace(/\\/g, "/");
+    const relDir = rawRel.startsWith("..") ? `_ext/${relative7(process.cwd(), dirname7(src)).replace(/\\/g, "/")}` : rawRel;
     const baseName = basename4(src).replace(/\.svelte(\.(ts|js))?$/, "");
     const importPaths = Array.from(transpiledServer.matchAll(/from\s+['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((path) => path !== undefined);
     const resolvedModuleImports = await Promise.all(importPaths.map((importPath) => resolveRelativeModule2(importPath, src)));
@@ -4252,15 +4576,15 @@ var resolveDevClientDir2 = () => {
         addModuleRewrite(externalRewrites, rawSpec, resolvedModule, ssrOutputDir, clientOutputDir);
       if (!resolved)
         continue;
-      const childRel = relative6(svelteRoot, resolved).replace(/\\/g, "/");
+      const childRel = relative7(svelteRoot, resolved).replace(/\\/g, "/");
       if (!childRel.startsWith(".."))
         continue;
       const childBuilt2 = cache.get(resolved);
       if (!childBuilt2)
         continue;
       const origSpec = rawSpec.replace(/\.svelte(?:\.(?:ts|js))?$/, ".js");
-      const toServer = relative6(ssrOutputDir, childBuilt2.ssr).replace(/\\/g, "/");
-      const toClient = relative6(clientOutputDir, childBuilt2.client).replace(/\\/g, "/");
+      const toServer = relative7(ssrOutputDir, childBuilt2.ssr).replace(/\\/g, "/");
+      const toClient = relative7(clientOutputDir, childBuilt2.client).replace(/\\/g, "/");
       externalRewrites.set(origSpec, {
         client: toClient.startsWith(".") ? toClient : `./${toClient}`,
         server: toServer.startsWith(".") ? toServer : `./${toServer}`
@@ -4295,7 +4619,7 @@ var resolveDevClientDir2 = () => {
       }).js.code;
       let code = compiled.replace(/\.svelte(?:\.(?:ts|js))?(['"])/g, ".js$1");
       if (mode === "client" && isDev) {
-        const moduleKey = `/@src/${relative6(process.cwd(), src).replace(/\\/g, "/")}`;
+        const moduleKey = `/@src/${relative7(process.cwd(), src).replace(/\\/g, "/")}`;
         code = code.replace(/if\s*\(import\.meta\.hot\)\s*\{/, `if (typeof window !== "undefined") {
   if (!window.__SVELTE_HMR_ACCEPT__) window.__SVELTE_HMR_ACCEPT__ = {};
   var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleKey)}] = cb; };`);
@@ -4338,10 +4662,10 @@ var resolveDevClientDir2 = () => {
   };
   const roots = await Promise.all(entryPoints.map(build));
   await Promise.all(roots.map(async ({ client, hasAwaitSlot }) => {
-    const relClientDir = dirname7(relative6(clientDir, client));
+    const relClientDir = dirname7(relative7(clientDir, client));
     const name = basename4(client, extname5(client));
     const indexPath = join12(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative6(dirname7(indexPath), client).split(sep2).join("/");
+    const importRaw = relative7(dirname7(indexPath), client).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev ? `window.__HMR_FRAMEWORK__ = "svelte";
 import "${hmrClientPath3}";
@@ -4418,7 +4742,7 @@ if (typeof window !== "undefined") {
   return {
     svelteClientPaths: roots.map(({ client }) => client),
     svelteIndexPaths: roots.map(({ client }) => {
-      const rel = dirname7(relative6(clientDir, client));
+      const rel = dirname7(relative7(clientDir, client));
       return join12(indexDir, rel, basename4(client));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
@@ -4448,18 +4772,18 @@ __export(exports_compileVue, {
   compileVue: () => compileVue,
   clearVueHmrCaches: () => clearVueHmrCaches
 });
-import { existsSync as existsSync14 } from "fs";
+import { existsSync as existsSync15 } from "fs";
 import { mkdir as mkdir3 } from "fs/promises";
-import { basename as basename5, dirname as dirname8, join as join13, relative as relative7, resolve as resolve15 } from "path";
+import { basename as basename5, dirname as dirname8, join as join13, relative as relative8, resolve as resolve15 } from "path";
 var {file: file2, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
   const fromSource = resolve15(import.meta.dir, "../dev/client");
-  if (existsSync14(fromSource) && fromSource.startsWith(projectRoot)) {
+  if (existsSync15(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
   const fromNodeModules = resolve15(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync14(fromNodeModules))
+  if (existsSync15(fromNodeModules))
     return fromNodeModules;
   return resolve15(import.meta.dir, "./dev/client");
 }, devClientDir3, hmrClientPath4, transpiler3, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
@@ -4500,7 +4824,7 @@ var resolveDevClientDir3 = () => {
     return "template-only";
   }
   return "full";
-}, generateVueHmrId = (sourceFilePath, vueRootDir) => relative7(vueRootDir, sourceFilePath).replace(/\\/g, "/").replace(/\.vue$/, ""), extractImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => importPath !== undefined), toJs = (filePath) => {
+}, generateVueHmrId = (sourceFilePath, vueRootDir) => relative8(vueRootDir, sourceFilePath).replace(/\\/g, "/").replace(/\.vue$/, ""), extractImports = (sourceCode) => Array.from(sourceCode.matchAll(/import\s+[\s\S]+?['"]([^'"]+)['"]/g)).map((match) => match[1]).filter((importPath) => importPath !== undefined), toJs = (filePath) => {
   if (filePath.endsWith(".vue"))
     return filePath.replace(/\.vue$/, ".js");
   if (filePath.endsWith(".ts"))
@@ -4527,7 +4851,7 @@ var resolveDevClientDir3 = () => {
   const cachedResult = cacheMap.get(sourceFilePath);
   if (cachedResult)
     return cachedResult;
-  const relativeFilePath = relative7(vueRootDir, sourceFilePath).replace(/\\/g, "/");
+  const relativeFilePath = relative8(vueRootDir, sourceFilePath).replace(/\\/g, "/");
   const relativeWithoutExtension = relativeFilePath.replace(/\.vue$/, "");
   const fileBaseName = basename5(sourceFilePath, ".vue");
   const componentId = toKebab(fileBaseName);
@@ -4651,7 +4975,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     let result2 = code;
     for (const [bareImport, paths] of packageImportRewrites) {
       const targetPath = mode === "server" ? paths.server : paths.client;
-      let rel = relative7(dirname8(outputPath), targetPath).replace(/\\/g, "/");
+      let rel = relative8(dirname8(outputPath), targetPath).replace(/\\/g, "/");
       if (!rel.startsWith("."))
         rel = `./${rel}`;
       result2 = result2.replaceAll(bareImport, rel);
@@ -4700,7 +5024,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
     const entryBaseName = basename5(entryPath, ".vue");
     const indexOutputFile = join13(indexOutputDir, `${entryBaseName}.js`);
-    const clientOutputFile = join13(clientOutputDir, relative7(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
+    const clientOutputFile = join13(clientOutputDir, relative8(vueRootDir, entryPath).replace(/\\/g, "/").replace(/\.vue$/, ".js"));
     await mkdir3(dirname8(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
@@ -4708,7 +5032,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     ] : [];
     await write2(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp from "${relative7(dirname8(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      `import Comp from "${relative8(dirname8(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
       'import { createSSRApp, createApp } from "vue";',
       "",
       "// HMR State Preservation: Check for preserved state from HMR",
@@ -4828,7 +5152,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   await Promise.all(Array.from(allTsHelperPaths).map(async (tsPath) => {
     const sourceCode = await file2(tsPath).text();
     const transpiledCode = transpiler3.transformSync(sourceCode);
-    const relativeJsPath = relative7(vueRootDir, tsPath).replace(/\.ts$/, ".js");
+    const relativeJsPath = relative8(vueRootDir, tsPath).replace(/\.ts$/, ".js");
     const outClientPath = join13(clientOutputDir, relativeJsPath);
     const outServerPath = join13(serverOutputDir, relativeJsPath);
     await mkdir3(dirname8(outClientPath), { recursive: true });
@@ -5329,13 +5653,13 @@ __export(exports_compileAngular, {
   compileAngularFile: () => compileAngularFile,
   compileAngular: () => compileAngular
 });
-import { existsSync as existsSync15, readFileSync as readFileSync8, promises as fs } from "fs";
-import { join as join14, basename as basename6, sep as sep3, dirname as dirname9, resolve as resolve16, relative as relative8 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync9, promises as fs } from "fs";
+import { join as join14, basename as basename6, sep as sep3, dirname as dirname9, resolve as resolve16, relative as relative9 } from "path";
 import ts2 from "typescript";
 import { createHash as createHash2 } from "crypto";
 var computeConfigHash = () => {
   try {
-    const content = readFileSync8("./tsconfig.json", "utf-8");
+    const content = readFileSync9("./tsconfig.json", "utf-8");
     return createHash2("md5").update(content).digest("hex");
   } catch {
     return "";
@@ -5343,11 +5667,11 @@ var computeConfigHash = () => {
 }, resolveDevClientDir4 = () => {
   const projectRoot = process.cwd();
   const fromSource = resolve16(import.meta.dir, "../dev/client");
-  if (existsSync15(fromSource) && fromSource.startsWith(projectRoot)) {
+  if (existsSync16(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
   const fromNodeModules = resolve16(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync15(fromNodeModules))
+  if (existsSync16(fromNodeModules))
     return fromNodeModules;
   return resolve16(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, hmrRuntimePath, injectHMRRegistration = (content, sourceId) => {
@@ -5426,7 +5750,7 @@ ${registrations}
     join14(basePath, "index.mts"),
     join14(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve16(candidate)).find((candidate) => existsSync15(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve16(candidate)).find((candidate) => existsSync16(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile4) => {
   const hostSource = readFile4?.(fileName);
   if (typeof hostSource === "string")
@@ -5440,7 +5764,7 @@ ${registrations}
     if (visited.has(resolvedPath))
       return;
     visited.add(resolvedPath);
-    if (!existsSync15(resolvedPath) || resolvedPath.endsWith(".d.ts"))
+    if (!existsSync16(resolvedPath) || resolvedPath.endsWith(".d.ts"))
       return;
     const source = await readFileForAotTransform(resolvedPath, readFile4);
     const transformed = await inlineResources(source, dirname9(resolvedPath), stylePreprocessors);
@@ -5455,7 +5779,7 @@ ${registrations}
   await transformFile(inputPath);
   return transformedSources;
 }, compileAngularFile = async (inputPath, outDir, stylePreprocessors) => {
-  const islandMetadataExports = buildIslandMetadataExports(readFileSync8(inputPath, "utf-8"));
+  const islandMetadataExports = buildIslandMetadataExports(readFileSync9(inputPath, "utf-8"));
   const { readConfiguration, performCompilation, EmitFlags } = await import("@angular/compiler-cli");
   const configHash = computeConfigHash();
   const cached = globalThis.__angularCompilerCache;
@@ -5577,7 +5901,7 @@ ${registrations}
   return entries.map(({ target }) => target);
 }, jitContentCache, wrapperOutputCache, escapeTemplateContent = (content) => content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${"), resolveAngularDeferImportSpecifier = () => {
   const sourceEntry = resolve16(import.meta.dir, "../angular/components/index.ts");
-  if (existsSync15(sourceEntry)) {
+  if (existsSync16(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
   return "@absolutejs/absolute/angular/components";
@@ -5705,7 +6029,7 @@ ${slot.resolvedBindings.map((binding) => `		"${binding.key}": this.__absoluteDef
 ${fields}
 `);
 }, readAndEscapeFile = async (filePath, stylePreprocessors) => {
-  if (!existsSync15(filePath))
+  if (!existsSync16(filePath))
     return null;
   const content = await compileStyleFileIfNeeded(filePath, stylePreprocessors);
   return escapeTemplateContent(content);
@@ -5713,7 +6037,7 @@ ${fields}
   const templateUrlMatch = source.match(/templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
     const templatePath = join14(fileDir, templateUrlMatch[1]);
-    if (!existsSync15(templatePath)) {
+    if (!existsSync16(templatePath)) {
       return { deferSlots: [], source };
     }
     const templateRaw2 = await fs.readFile(templatePath, "utf-8");
@@ -5744,10 +6068,10 @@ ${fields}
   const templateUrlMatch = source.match(/templateUrl\s*:\s*['"]([^'"]+)['"]/);
   if (templateUrlMatch?.[1]) {
     const templatePath = join14(fileDir, templateUrlMatch[1]);
-    if (!existsSync15(templatePath)) {
+    if (!existsSync16(templatePath)) {
       return { deferSlots: [], source };
     }
-    const templateRaw2 = readFileSync8(templatePath, "utf-8");
+    const templateRaw2 = readFileSync9(templatePath, "utf-8");
     const lowered2 = lowerAngularDeferSyntax(templateRaw2);
     const escaped2 = escapeTemplateContent(lowered2.template);
     const replacedSource2 = source.replace(/templateUrl\s*:\s*['"][^'"]+['"]/, `template: \`${escaped2}\``);
@@ -5858,7 +6182,7 @@ ${fields}
     let actualPath = resolved;
     if (!actualPath.endsWith(".ts"))
       actualPath += ".ts";
-    if (!existsSync15(actualPath))
+    if (!existsSync16(actualPath))
       return;
     let sourceCode = await fs.readFile(actualPath, "utf-8");
     const inlined = await inlineResources(sourceCode, dirname9(actualPath), stylePreprocessors);
@@ -5882,7 +6206,7 @@ ${fields}
     }
     const contentHash = Bun.hash(sourceCode).toString(BASE_36_RADIX);
     const cacheKey2 = actualPath;
-    if (jitContentCache.get(cacheKey2) === contentHash && existsSync15(targetPath)) {
+    if (jitContentCache.get(cacheKey2) === contentHash && existsSync16(targetPath)) {
       allOutputs.push(targetPath);
     } else {
       const processedContent = transpileAndRewrite(sourceCode, relativeDir, actualPath);
@@ -5910,7 +6234,7 @@ ${fields}
   await fs.mkdir(indexesDir, { recursive: true });
   const compileTasks = entryPoints.map(async (entry) => {
     const resolvedEntry = resolve16(entry);
-    const relativeEntry = relative8(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
+    const relativeEntry = relative9(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
     const compileEntry = () => hmr ? compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot, stylePreprocessors) : compileAngularFile(resolvedEntry, compiledRoot, stylePreprocessors);
     let outputs = await compileEntry();
     const fileBase = basename6(resolvedEntry).replace(/\.[tj]s$/, "");
@@ -5925,12 +6249,12 @@ ${fields}
         ...candidatePaths.map((file3) => resolve16(file3)),
         ...compiledFallbackPaths
       ];
-      let candidate = normalizedCandidates.find((file3) => existsSync15(file3) && file3.endsWith(`${sep3}pages${sep3}${jsName}`));
+      let candidate = normalizedCandidates.find((file3) => existsSync16(file3) && file3.endsWith(`${sep3}pages${sep3}${jsName}`));
       if (!candidate) {
-        candidate = normalizedCandidates.find((file3) => existsSync15(file3) && file3.endsWith(`${sep3}${jsName}`));
+        candidate = normalizedCandidates.find((file3) => existsSync16(file3) && file3.endsWith(`${sep3}${jsName}`));
       }
       if (!candidate) {
-        candidate = normalizedCandidates.find((file3) => existsSync15(file3));
+        candidate = normalizedCandidates.find((file3) => existsSync16(file3));
       }
       return candidate;
     };
@@ -5938,11 +6262,11 @@ ${fields}
     if (!rawServerFile) {
       rawServerFile = resolveRawServerFile([]);
     }
-    if (rawServerFile && !existsSync15(rawServerFile)) {
+    if (rawServerFile && !existsSync16(rawServerFile)) {
       outputs = await compileEntry();
       rawServerFile = resolveRawServerFile(outputs);
     }
-    if (!rawServerFile || !existsSync15(rawServerFile)) {
+    if (!rawServerFile || !existsSync16(rawServerFile)) {
       throw new Error(`Compiled output not found for ${entry}. Looking for: ${jsName}. Available: ${[
         ...outputs,
         ...compiledFallbackPaths
@@ -5953,7 +6277,7 @@ ${fields}
     const serverContentHash = Bun.hash(original).toString(BASE_36_RADIX);
     const cachedWrapper = wrapperOutputCache.get(resolvedEntry);
     const clientFile = join14(indexesDir, jsName);
-    if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync15(clientFile)) {
+    if (hmr && cachedWrapper && cachedWrapper.serverHash === serverContentHash && existsSync16(clientFile)) {
       return {
         clientPath: clientFile,
         indexUnchanged: true,
@@ -5987,7 +6311,7 @@ export default ${componentClassName};
       await fs.writeFile(ssrDepsFile, ssrDepsContent, "utf-8");
     }
     await fs.writeFile(rawServerFile, rewritten, "utf-8");
-    const relativePath = relative8(indexesDir, rawServerFile).replace(/\\/g, "/");
+    const relativePath = relative9(indexesDir, rawServerFile).replace(/\\/g, "/");
     const normalizedImportPath = relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
     const hmrPreamble = hmr ? `window.__HMR_FRAMEWORK__ = "angular";
 import "${hmrRuntimePath}";
@@ -6152,7 +6476,7 @@ __export(exports_buildReactVendor, {
   computeVendorPaths: () => computeVendorPaths,
   buildReactVendor: () => buildReactVendor
 });
-import { existsSync as existsSync16, mkdirSync as mkdirSync6 } from "fs";
+import { existsSync as existsSync17, mkdirSync as mkdirSync6 } from "fs";
 import { join as join15, resolve as resolve17 } from "path";
 import { rm as rm4 } from "fs/promises";
 var {build: bunBuild2 } = globalThis.Bun;
@@ -6166,7 +6490,7 @@ var resolveJsxDevRuntimeCompatPath = () => {
     resolve17(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
-    if (existsSync16(candidate)) {
+    if (existsSync17(candidate)) {
       return candidate.replace(/\\/g, "/");
     }
   }
@@ -6342,11 +6666,11 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
     console.warn("\u26A0\uFE0F Vue vendor build had errors:", result.logs);
     return;
   }
-  const { readFileSync: readFileSync9, writeFileSync: writeFileSync7, readdirSync } = await import("fs");
+  const { readFileSync: readFileSync10, writeFileSync: writeFileSync7, readdirSync } = await import("fs");
   const files = readdirSync(vendorDir).filter((f) => f.endsWith(".js"));
   for (const file3 of files) {
     const filePath = join17(vendorDir, file3);
-    const content = readFileSync9(filePath, "utf-8");
+    const content = readFileSync10(filePath, "utf-8");
     if (!content.includes("__VUE_HMR_RUNTIME__"))
       continue;
     const patched = content.replace(/getGlobalThis\(\)\.__VUE_HMR_RUNTIME__\s*=\s*\{/, "getGlobalThis().__VUE_HMR_RUNTIME__ = getGlobalThis().__VUE_HMR_RUNTIME__ || {");
@@ -6469,14 +6793,14 @@ var init_rewriteImports = __esm(() => {
 import {
   copyFileSync,
   cpSync,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   mkdirSync as mkdirSync10,
-  readFileSync as readFileSync9,
+  readFileSync as readFileSync10,
   rmSync as rmSync2,
   statSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { basename as basename7, dirname as dirname10, join as join19, relative as relative9, resolve as resolve18 } from "path";
+import { basename as basename7, dirname as dirname10, join as join19, relative as relative10, resolve as resolve18 } from "path";
 import { cwd, env as env2, exit } from "process";
 var {build: bunBuild6, Glob: Glob6 } = globalThis.Bun;
 var isDev, collectConventionSourceFiles = (entry) => {
@@ -6592,7 +6916,7 @@ var isDev, collectConventionSourceFiles = (entry) => {
     addWorkerPathIfExists(file3, relPath, workerPaths);
   }
 }, collectWorkerPathsFromFile = (file3, patterns, workerPaths) => {
-  const content = readFileSync9(file3, "utf-8");
+  const content = readFileSync10(file3, "utf-8");
   for (const pattern of patterns) {
     collectWorkerPathsFromContent(content, pattern, file3, workerPaths);
   }
@@ -6637,13 +6961,13 @@ var isDev, collectConventionSourceFiles = (entry) => {
     copyVueDevIndexes(vueDir, vuePagesPath, vueEntries, devIndexDir);
   }
 }, copyReactDevIndexes = (reactIndexesPath, reactPagesPath, devIndexDir, readDir) => {
-  if (!existsSync17(reactIndexesPath)) {
+  if (!existsSync18(reactIndexesPath)) {
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file3) => file3.endsWith(".tsx"));
-  const pagesRel = relative9(process.cwd(), resolve18(reactPagesPath)).replace(/\\/g, "/");
+  const pagesRel = relative10(process.cwd(), resolve18(reactPagesPath)).replace(/\\/g, "/");
   for (const file3 of indexFiles) {
-    let content = readFileSync9(join19(reactIndexesPath, file3), "utf-8");
+    let content = readFileSync10(join19(reactIndexesPath, file3), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
     writeFileSync7(join19(devIndexDir, file3), content);
   }
@@ -6653,10 +6977,10 @@ var isDev, collectConventionSourceFiles = (entry) => {
   for (const entry of sveltePageEntries) {
     const name = basename7(entry).replace(/\.svelte(\.(ts|js))?$/, "");
     const indexFile = join19(svelteIndexDir, "pages", `${name}.js`);
-    if (!existsSync17(indexFile))
+    if (!existsSync18(indexFile))
       continue;
-    let content = readFileSync9(indexFile, "utf-8");
-    const srcRel = relative9(process.cwd(), resolve18(entry)).replace(/\\/g, "/");
+    let content = readFileSync10(indexFile, "utf-8");
+    const srcRel = relative10(process.cwd(), resolve18(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
     writeFileSync7(join19(devIndexDir, `${name}.svelte.js`), content);
   }
@@ -6666,10 +6990,10 @@ var isDev, collectConventionSourceFiles = (entry) => {
   for (const entry of vuePageEntries) {
     const name = basename7(entry, ".vue");
     const indexFile = join19(vueIndexDir, `${name}.js`);
-    if (!existsSync17(indexFile))
+    if (!existsSync18(indexFile))
       continue;
-    let content = readFileSync9(indexFile, "utf-8");
-    const srcRel = relative9(process.cwd(), resolve18(entry)).replace(/\\/g, "/");
+    let content = readFileSync10(indexFile, "utf-8");
+    const srcRel = relative10(process.cwd(), resolve18(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Comp\s+from\s+['"]([^'"]+)['"]/, `import Comp from "/@src/${srcRel}"`);
     writeFileSync7(join19(devIndexDir, `${name}.vue.js`), content);
   }
@@ -6719,7 +7043,7 @@ var isDev, collectConventionSourceFiles = (entry) => {
   }
   return result;
 }, VUE_HMR_RUNTIME, injectVueComposableTracking = (outputPath, projectRoot) => {
-  let content = readFileSync9(outputPath, "utf-8");
+  let content = readFileSync10(outputPath, "utf-8");
   const usePattern = /^var\s+(use[A-Z]\w*)\s*=/gm;
   const useNames = [];
   let match;
@@ -6744,7 +7068,7 @@ ${content.slice(firstUseIdx)}`;
 }, buildDevUrlFileMap = (urlReferencedFiles, projectRoot) => {
   const urlFileMap = new Map;
   for (const srcPath of urlReferencedFiles) {
-    const rel = relative9(projectRoot, srcPath).replace(/\\/g, "/");
+    const rel = relative10(projectRoot, srcPath).replace(/\\/g, "/");
     const name = basename7(srcPath);
     const mtime = Math.round(statSync(srcPath).mtimeMs);
     const url = `/@src/${rel}?v=${mtime}`;
@@ -6759,7 +7083,7 @@ ${content.slice(firstUseIdx)}`;
     const output = nonReactClientOutputs.find((artifact) => basename7(artifact.path).startsWith(`${srcBase}.`));
     if (!output)
       continue;
-    urlFileMap.set(basename7(srcPath), `/${relative9(buildPath, output.path).replace(/\\/g, "/")}`);
+    urlFileMap.set(basename7(srcPath), `/${relative10(buildPath, output.path).replace(/\\/g, "/")}`);
   }
   return urlFileMap;
 }, buildUrlFileMap = (urlReferencedFiles, hmr, projectRoot, buildPath, nonReactClientOutputs) => {
@@ -6769,7 +7093,7 @@ ${content.slice(firstUseIdx)}`;
 }, rewriteUrlReferences = (outputPaths, urlFileMap) => {
   const urlPattern = /new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g;
   for (const outputPath of outputPaths) {
-    let content = readFileSync9(outputPath, "utf-8");
+    let content = readFileSync10(outputPath, "utf-8");
     let changed = false;
     content = content.replace(urlPattern, (_match, relPath) => {
       const targetName = basename7(relPath);
@@ -6795,6 +7119,7 @@ ${content.slice(firstUseIdx)}`;
   vueDirectory,
   stylesConfig,
   stylePreprocessors,
+  postcss,
   tailwind,
   options,
   incrementalFiles,
@@ -6804,7 +7129,8 @@ ${content.slice(firstUseIdx)}`;
   const projectRoot = cwd();
   await resolveAbsoluteVersion();
   const isIncremental = incrementalFiles && incrementalFiles.length > 0;
-  const stylePreprocessorPlugin2 = createStylePreprocessorPlugin(stylePreprocessors);
+  const styleTransformConfig = createStyleTransformConfig(stylePreprocessors, postcss);
+  const stylePreprocessorPlugin2 = createStylePreprocessorPlugin(styleTransformConfig);
   const normalizedIncrementalFiles = incrementalFiles?.map(normalizePath);
   const throwOnError = options?.throwOnError === true;
   const hmr = options?.injectHMR === true;
@@ -7000,28 +7326,28 @@ ${content.slice(firstUseIdx)}`;
     { vueClientPaths: islandVueClientPaths },
     { clientPaths: islandAngularClientPaths }
   ] = await Promise.all([
-    shouldCompileSvelte ? Promise.resolve().then(() => (init_compileSvelte(), exports_compileSvelte)).then((mod) => mod.compileSvelte(svelteEntries, svelteDir, new Map, hmr, stylePreprocessors)) : {
+    shouldCompileSvelte ? Promise.resolve().then(() => (init_compileSvelte(), exports_compileSvelte)).then((mod) => mod.compileSvelte(svelteEntries, svelteDir, new Map, hmr, styleTransformConfig)) : {
       svelteClientPaths: [...emptyStringArray],
       svelteIndexPaths: [...emptyStringArray],
       svelteServerPaths: [...emptyStringArray]
     },
-    shouldCompileVue ? Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(vueEntries, vueDir, hmr, stylePreprocessors)) : {
+    shouldCompileVue ? Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(vueEntries, vueDir, hmr, styleTransformConfig)) : {
       vueClientPaths: [...emptyStringArray],
       vueCssPaths: [...emptyStringArray],
       vueIndexPaths: [...emptyStringArray],
       vueServerPaths: [...emptyStringArray]
     },
-    shouldCompileAngular ? Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(angularEntries, angularDir, hmr, stylePreprocessors)) : {
+    shouldCompileAngular ? Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(angularEntries, angularDir, hmr, styleTransformConfig)) : {
       clientPaths: [...emptyStringArray],
       serverPaths: [...emptyStringArray]
     },
-    shouldCompileIslandSvelte ? Promise.resolve().then(() => (init_compileSvelte(), exports_compileSvelte)).then((mod) => mod.compileSvelte(islandSvelteSources, svelteDir, new Map, hmr, stylePreprocessors)) : {
+    shouldCompileIslandSvelte ? Promise.resolve().then(() => (init_compileSvelte(), exports_compileSvelte)).then((mod) => mod.compileSvelte(islandSvelteSources, svelteDir, new Map, hmr, styleTransformConfig)) : {
       svelteClientPaths: [...emptyStringArray]
     },
-    shouldCompileIslandVue ? Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(islandVueSources, vueDir, hmr, stylePreprocessors)) : {
+    shouldCompileIslandVue ? Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(islandVueSources, vueDir, hmr, styleTransformConfig)) : {
       vueClientPaths: [...emptyStringArray]
     },
-    shouldCompileIslandAngular ? Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(islandAngularSources, angularDir, hmr, stylePreprocessors)) : {
+    shouldCompileIslandAngular ? Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(islandAngularSources, angularDir, hmr, styleTransformConfig)) : {
       clientPaths: [...emptyStringArray]
     }
   ]);
@@ -7053,8 +7379,8 @@ ${content.slice(firstUseIdx)}`;
   const vueConventionSources = collectConventionSourceFiles(conventionsMap.vue);
   if (svelteConventionSources.length > 0 || vueConventionSources.length > 0) {
     const [svelteConvResult, vueConvResult] = await Promise.all([
-      svelteConventionSources.length > 0 && svelteDir ? Promise.resolve().then(() => (init_compileSvelte(), exports_compileSvelte)).then((mod) => mod.compileSvelte(svelteConventionSources, svelteDir, new Map, false, stylePreprocessors)) : { svelteServerPaths: emptyStringArray },
-      vueConventionSources.length > 0 && vueDir ? Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(vueConventionSources, vueDir, false, stylePreprocessors)) : { vueServerPaths: emptyStringArray }
+      svelteConventionSources.length > 0 && svelteDir ? Promise.resolve().then(() => (init_compileSvelte(), exports_compileSvelte)).then((mod) => mod.compileSvelte(svelteConventionSources, svelteDir, new Map, false, styleTransformConfig)) : { svelteServerPaths: emptyStringArray },
+      vueConventionSources.length > 0 && vueDir ? Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(vueConventionSources, vueDir, false, styleTransformConfig)) : { vueServerPaths: emptyStringArray }
     ]);
     const copyConventionFiles = (framework, sources, compiledPaths) => {
       const destDir = join19(buildPath, "conventions", framework);
@@ -7426,7 +7752,7 @@ ${content.slice(firstUseIdx)}`;
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync9(filePath, "utf-8");
+    let html = readFileSync10(filePath, "utf-8");
     if (html.includes("data-hmr-client"))
       return;
     const tag = `<script>window.__HMR_FRAMEWORK__="${framework}";</script><script data-hmr-client>${hmrClientBundle}</script>`;
@@ -7587,7 +7913,7 @@ var init_build = __esm(() => {
 });
 
 // src/dev/dependencyGraph.ts
-import { existsSync as existsSync18, readFileSync as readFileSync10 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync11 } from "fs";
 var {Glob: Glob7 } = globalThis.Bun;
 import { resolve as resolve19 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
@@ -7599,7 +7925,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   if (lower.endsWith(".html") || lower.endsWith(".htm"))
     return "html";
   return null;
-}, resolveImportPath = (importPath, fromFile) => {
+}, resolveImportPath2 = (importPath, fromFile) => {
   if (!importPath.startsWith(".") && !importPath.startsWith("/")) {
     return null;
   }
@@ -7617,10 +7943,10 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   ];
   for (const ext of extensions) {
     const withExt = normalized + ext;
-    if (existsSync18(withExt))
+    if (existsSync19(withExt))
       return withExt;
   }
-  if (existsSync18(normalized))
+  if (existsSync19(normalized))
     return normalized;
   return null;
 }, clearExistingDependents = (graph, normalizedPath) => {
@@ -7635,7 +7961,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   }
 }, addFileToGraph = (graph, filePath) => {
   const normalizedPath = resolve19(filePath);
-  if (!existsSync18(normalizedPath))
+  if (!existsSync19(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
   clearExistingDependents(graph, normalizedPath);
@@ -7651,7 +7977,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
 }, IGNORED_SEGMENTS, buildInitialDependencyGraph = (graph, directories) => {
   const processedFiles = new Set;
   const glob = new Glob7("**/*.{ts,tsx,js,jsx,vue,svelte,html,htm}");
-  const resolvedDirs = directories.map((dir) => resolve19(dir)).filter((dir) => existsSync18(dir));
+  const resolvedDirs = directories.map((dir) => resolve19(dir)).filter((dir) => existsSync19(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file3 of allFiles) {
     const fullPath = resolve19(file3);
@@ -7670,7 +7996,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     const [, href] = matchLink;
     if (!href)
       continue;
-    const resolvedHref = resolveImportPath(href, filePath);
+    const resolvedHref = resolveImportPath2(href, filePath);
     if (resolvedHref)
       dependencies.push(resolvedHref);
   }
@@ -7680,7 +8006,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   while ((match = regex.exec(content)) !== null) {
     if (!match[1])
       continue;
-    const resolved = resolveImportPath(match[1], filePath);
+    const resolved = resolveImportPath2(match[1], filePath);
     if (resolved)
       dependencies.push(resolved);
   }
@@ -7690,7 +8016,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   while ((urlMatch = stringLiteralRegex.exec(matchContent)) !== null) {
     if (!urlMatch[1])
       continue;
-    const resolved = resolveImportPath(urlMatch[1], filePath);
+    const resolved = resolveImportPath2(urlMatch[1], filePath);
     if (resolved)
       dependencies.push(resolved);
   }
@@ -7713,7 +8039,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   const imports = transpiler4.scanImports(content);
   const dependencies = [];
   for (const imp of imports) {
-    const resolved = resolveImportPath(imp.path, filePath);
+    const resolved = resolveImportPath2(imp.path, filePath);
     if (resolved)
       dependencies.push(resolved);
   }
@@ -7723,7 +8049,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   return dependencies;
 }, resolveScannedImports = (imports, filePath, dependencies) => {
   for (const imp of imports) {
-    const resolved = resolveImportPath(imp.path, filePath);
+    const resolved = resolveImportPath2(imp.path, filePath);
     if (resolved)
       dependencies.push(resolved);
   }
@@ -7748,15 +8074,15 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   const lowerPath = filePath.toLowerCase();
   const isSvelteOrVue = lowerPath.endsWith(".svelte") || lowerPath.endsWith(".vue");
   if (loader === "html") {
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     return extractHtmlDependencies(filePath, content);
   }
   if (loader === "tsx" || loader === "js") {
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     return extractJsDependencies(filePath, content, loader);
   }
   if (isSvelteOrVue) {
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync11(filePath, "utf-8");
     return extractSvelteVueDependencies(filePath, content);
   }
   return [];
@@ -8039,12 +8365,12 @@ var STYLE_EXTENSION_PATTERN2, detectFramework = (filePath, resolved) => {
 };
 var init_pathUtils = __esm(() => {
   init_commonAncestor();
-  STYLE_EXTENSION_PATTERN2 = /\.(css|s[ac]ss|less)$/i;
+  STYLE_EXTENSION_PATTERN2 = /\.(css|s[ac]ss|less|styl(?:us)?)$/i;
 });
 
 // src/dev/fileWatcher.ts
 import { watch } from "fs";
-import { existsSync as existsSync19 } from "fs";
+import { existsSync as existsSync20 } from "fs";
 import { join as join20, resolve as resolve21 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
@@ -8076,12 +8402,12 @@ var safeRemoveFromGraph = (graph, fullPath) => {
     if (shouldIgnorePath(fullPath, state.resolvedPaths)) {
       return;
     }
-    if (event === "rename" && !existsSync19(fullPath)) {
+    if (event === "rename" && !existsSync20(fullPath)) {
       safeRemoveFromGraph(state.dependencyGraph, fullPath);
       onFileChange(fullPath);
       return;
     }
-    if (existsSync19(fullPath)) {
+    if (existsSync20(fullPath)) {
       onFileChange(fullPath);
       safeAddToGraph(state.dependencyGraph, fullPath);
     }
@@ -8091,7 +8417,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
     const absolutePath = resolve21(path).replace(/\\/g, "/");
-    if (!existsSync19(absolutePath)) {
+    if (!existsSync20(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -8102,7 +8428,7 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
     const absolutePath = resolve21(path).replace(/\\/g, "/");
-    if (!existsSync19(absolutePath)) {
+    if (!existsSync20(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -8223,7 +8549,7 @@ var init_assetStore = __esm(() => {
 });
 
 // src/islands/pageMetadata.ts
-import { readFileSync as readFileSync11 } from "fs";
+import { readFileSync as readFileSync12 } from "fs";
 import { dirname as dirname11, resolve as resolve23 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
@@ -8265,7 +8591,7 @@ var pagePatterns, getPageDirs = (config) => [
     return;
   const files = await scanEntryPoints(resolve23(entry.dir), pattern);
   for (const filePath of files) {
-    const source = readFileSync11(filePath, "utf-8");
+    const source = readFileSync12(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
     pageMetadata.set(resolve23(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
@@ -8295,10 +8621,10 @@ var init_pageMetadata = __esm(() => {
 });
 
 // src/dev/fileHashTracker.ts
-import { readFileSync as readFileSync12 } from "fs";
+import { readFileSync as readFileSync13 } from "fs";
 var computeFileHash = (filePath) => {
   try {
-    const fileContent = readFileSync12(filePath);
+    const fileContent = readFileSync13(filePath);
     return Number(Bun.hash(fileContent));
   } catch {
     return UNFOUND_INDEX;
@@ -9452,6 +9778,11 @@ var init_pageHandler = __esm(() => {
 });
 
 // src/react/pageHandler.ts
+var exports_pageHandler = {};
+__export(exports_pageHandler, {
+  invalidateReactSsrCache: () => invalidateReactSsrCache,
+  handleReactPageRequest: () => handleReactPageRequest
+});
 var ssrDirty2 = false, buildRefreshSetup = () => {
   if (false) {}
   return "window.__REFRESH_BUFFER__=[];" + "window.$RefreshReg$=function(t,i){window.__REFRESH_BUFFER__.push([t,i])};" + "window.$RefreshSig$=function(){return function(t){return t}};";
@@ -9855,8 +10186,8 @@ __export(exports_moduleServer, {
   createModuleServer: () => createModuleServer,
   SRC_URL_PREFIX: () => SRC_URL_PREFIX
 });
-import { existsSync as existsSync20, readFileSync as readFileSync13, statSync as statSync2 } from "fs";
-import { basename as basename12, dirname as dirname14, extname as extname6, resolve as resolve27, relative as relative10 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync14, statSync as statSync2 } from "fs";
+import { basename as basename12, dirname as dirname14, extname as extname6, resolve as resolve27, relative as relative11 } from "path";
 var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPILABLE, ALL_EXPORTS_RE, STRING_CONTENTS_RE, preserveTypeExports = (originalSource, transpiled, valueExports) => {
   const codeOnly = originalSource.replace(STRING_CONTENTS_RE, '""');
   const allExports = [];
@@ -9876,7 +10207,7 @@ var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPIL
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const found = extensions.find((ext) => existsSync20(resolve27(projectRoot, srcPath + ext)));
+  const found = extensions.find((ext) => existsSync21(resolve27(projectRoot, srcPath + ext)));
   return found ? srcPath + found : srcPath;
 }, IMPORT_EXTENSIONS, SIDE_EFFECT_EXTENSIONS, MODULE_EXTENSIONS, RESOLVED_MODULE_EXTENSIONS, REACT_EXTENSIONS, escapeRegex3 = (str) => str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"), buildImportRewriter = (vendorPaths) => {
   const entries = Object.entries(vendorPaths).sort(([a], [b]) => b.length - a.length);
@@ -9904,17 +10235,17 @@ ${stubs}
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
   const absPath = resolve27(fileDir, relPath);
-  const rel = relative10(projectRoot, absPath);
+  const rel = relative11(projectRoot, absPath);
   const extension = extname6(rel);
   let srcPath = RESOLVED_MODULE_EXTENSIONS.has(extension) ? rel : resolveRelativeExtension(rel, projectRoot, extensions);
   if (extname6(srcPath) === ".svelte") {
-    srcPath = relative10(projectRoot, resolveSvelteModulePath(resolve27(projectRoot, srcPath)));
+    srcPath = relative11(projectRoot, resolveSvelteModulePath(resolve27(projectRoot, srcPath)));
   }
   return srcUrl(srcPath, projectRoot);
 }, resolveAbsoluteSpecifier = (specifier, projectRoot) => {
   try {
     const target = resolvePackageImport(specifier, ["browser", "import"]) ?? Bun.resolveSync(specifier, projectRoot);
-    return relative10(projectRoot, target);
+    return relative11(projectRoot, target);
   } catch {
     return;
   }
@@ -9947,20 +10278,20 @@ ${stubs}
   result = result.replace(/(import\s*["'])(\.\.?\/[^"']+)(["']\s*;?)/g, (_match, prefix, relPath, suffix) => `${prefix}${resolveRelativeImport(relPath, fileDir, projectRoot, SIDE_EFFECT_EXTENSIONS)}${suffix}`);
   result = result.replace(/((?:from|import)\s*["'])(\/[^"']+\.(tsx?|jsx?|ts))(["'])/g, (_match, prefix, absPath, _ext, suffix) => {
     if (absPath.startsWith(projectRoot)) {
-      const rel2 = relative10(projectRoot, absPath).replace(/\\/g, "/");
+      const rel2 = relative11(projectRoot, absPath).replace(/\\/g, "/");
       return `${prefix}${srcUrl(rel2, projectRoot)}${suffix}`;
     }
-    const rel = relative10(projectRoot, absPath).replace(/\\/g, "/");
+    const rel = relative11(projectRoot, absPath).replace(/\\/g, "/");
     return `${prefix}${srcUrl(rel, projectRoot)}${suffix}`;
   });
   result = result.replace(/new\s+URL\(\s*["'](\.\.?\/[^"']+)["']\s*,\s*import\.meta\.url\s*\)/g, (_match, relPath) => {
     const absPath = resolve27(fileDir, relPath);
-    const rel = relative10(projectRoot, absPath);
+    const rel = relative11(projectRoot, absPath);
     return `new URL('${srcUrl(rel, projectRoot)}', import.meta.url)`;
   });
   result = result.replace(/import\.meta\.resolve\(\s*["'](\.\.?\/[^"']+)["']\s*\)/g, (_match, relPath) => {
     const absPath = resolve27(fileDir, relPath);
-    const rel = relative10(projectRoot, absPath);
+    const rel = relative11(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
   return result;
@@ -9988,7 +10319,7 @@ ${stubs}
 `)}
 ${code}`;
 }, reactTranspilerOptions, reactTranspiler, transformReactFile = (filePath, projectRoot, rewriter) => {
-  const raw = readFileSync13(filePath, "utf-8");
+  const raw = readFileSync14(filePath, "utf-8");
   const valueExports = tsxTranspiler.scan(raw).exports;
   let transpiled = reactTranspiler.transformSync(raw);
   transpiled = preserveTypeExports(raw, transpiled, valueExports);
@@ -9999,12 +10330,12 @@ ${code}`;
   transpiled = `var $RefreshReg$ = window.$RefreshReg$ || function(){};
 ` + `var $RefreshSig$ = window.$RefreshSig$ || function(){ return function(t){ return t; }; };
 ${transpiled}`;
-  const relPath = relative10(projectRoot, filePath).replace(/\\/g, "/");
+  const relPath = relative11(projectRoot, filePath).replace(/\\/g, "/");
   transpiled = transpiled.replace(/\binput\.tsx:/g, `${relPath}:`);
   transpiled += buildIslandMetadataExports(raw);
   return rewriteImports2(transpiled, filePath, projectRoot, rewriter);
 }, transformPlainFile = (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync13(filePath, "utf-8");
+  const raw = readFileSync14(filePath, "utf-8");
   const ext = extname6(filePath);
   const isTS = ext === ".ts" || ext === ".tsx";
   const isTSX = ext === ".tsx" || ext === ".jsx";
@@ -10150,17 +10481,17 @@ ${code}`;
   if (compiled.css?.code) {
     const cssPath = `${filePath}.css`;
     svelteExternalCss.set(cssPath, compiled.css.code);
-    const cssUrl = srcUrl(relative10(projectRoot, cssPath), projectRoot);
+    const cssUrl = srcUrl(relative11(projectRoot, cssPath), projectRoot);
     code = `import "${cssUrl}";
 ${code}`;
   }
-  const moduleUrl = `${SRC_PREFIX}${relative10(projectRoot, filePath).replace(/\\/g, "/")}`;
+  const moduleUrl = `${SRC_PREFIX}${relative11(projectRoot, filePath).replace(/\\/g, "/")}`;
   code = code.replace(/if\s*\(import\.meta\.hot\)\s*\{/, `if (typeof window !== "undefined") {
 ` + `  if (!window.__SVELTE_HMR_ACCEPT__) window.__SVELTE_HMR_ACCEPT__ = {};
 ` + `  var __hmr_accept = function(cb) { window.__SVELTE_HMR_ACCEPT__[${JSON.stringify(moduleUrl)}] = cb; };`);
   return code.replace(/import\.meta\.hot\.accept\(/g, "__hmr_accept(");
 }, transformSvelteFile = async (filePath, projectRoot, rewriter, stylePreprocessors) => {
-  const raw = readFileSync13(filePath, "utf-8");
+  const raw = readFileSync14(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
@@ -10218,7 +10549,7 @@ export default __script__;`;
   return `${cssInjection}
 ${code}`;
 }, transformVueFile = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
-  const raw = readFileSync13(filePath, "utf-8");
+  const raw = readFileSync14(filePath, "utf-8");
   if (!vueCompiler) {
     vueCompiler = await import("@vue/compiler-sfc");
   }
@@ -10236,7 +10567,7 @@ ${code}`;
   return rewriteImports2(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
   const hmrBase = vueDir ? resolve27(vueDir) : projectRoot;
-  const hmrId = relative10(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
+  const hmrId = relative11(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
     "",
@@ -10250,11 +10581,11 @@ ${code}`;
 `);
   return result;
 }, resolveSvelteModulePath = (path) => {
-  if (existsSync20(path))
+  if (existsSync21(path))
     return path;
-  if (existsSync20(`${path}.ts`))
+  if (existsSync21(`${path}.ts`))
     return `${path}.ts`;
-  if (existsSync20(`${path}.js`))
+  if (existsSync21(`${path}.js`))
     return `${path}.js`;
   return path;
 }, jsResponse = (body) => {
@@ -10267,7 +10598,7 @@ ${code}`;
     }
   });
 }, handleCssRequest = (filePath) => {
-  const raw = readFileSync13(filePath, "utf-8");
+  const raw = readFileSync14(filePath, "utf-8");
   const escaped = raw.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return [
     `const style = document.createElement('style');`,
@@ -10400,7 +10731,7 @@ export default {};
     return { ext, filePath: resolveSvelteModulePath(filePath) };
   if (ext)
     return { ext, filePath };
-  const found = MODULE_EXTENSIONS.find((candidate) => existsSync20(filePath + candidate));
+  const found = MODULE_EXTENSIONS.find((candidate) => existsSync21(filePath + candidate));
   if (!found)
     return { ext, filePath };
   const resolved = filePath + found;
@@ -10605,9 +10936,9 @@ var handleHTMXUpdate = async (htmxFilePath) => {
 var init_simpleHTMXHMR = () => {};
 
 // src/dev/rebuildTrigger.ts
-import { existsSync as existsSync21 } from "fs";
-import { basename as basename13, dirname as dirname15, relative as relative11, resolve as resolve30 } from "path";
-var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseErrorLocationFromMessage = (msg) => {
+import { existsSync as existsSync22 } from "fs";
+import { basename as basename13, dirname as dirname15, relative as relative12, resolve as resolve30 } from "path";
+var moduleServerPromise, getModuleServer = () => moduleServerPromise, getStyleTransformConfig = (config) => createStyleTransformConfig(config.stylePreprocessors, config.postcss), parseErrorLocationFromMessage = (msg) => {
   const pathLineCol = msg.match(/^([^\s:]+):(\d+)(?::(\d+))?/);
   if (pathLineCol) {
     const [, file3, lineStr, colStr] = pathLineCol;
@@ -10674,7 +11005,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     detectedFw = detected !== "ignored" ? detected : affectedFrameworks[0];
   }
   return { ...parsed, framework: detectedFw };
-}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync21(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
+}, isValidDeletedAffectedFile = (affectedFile, deletedPathResolved, processedFiles) => affectedFile !== deletedPathResolved && !processedFiles.has(affectedFile) && existsSync22(affectedFile), collectDeletedFileAffected = (state, filePathInSet, processedFiles, validFiles) => {
   state.fileHashes.delete(filePathInSet);
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, filePathInSet);
@@ -10692,7 +11023,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     if (!dependents || dependents.size === 0) {
       return;
     }
-    const dependentFiles = Array.from(dependents).filter((file3) => existsSync21(file3));
+    const dependentFiles = Array.from(dependents).filter((file3) => existsSync22(file3));
     if (dependentFiles.length === 0) {
       return;
     }
@@ -10708,7 +11039,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   try {
     const affectedFiles = getAffectedFiles(state.dependencyGraph, normalizedFilePath);
     affectedFiles.forEach((affectedFile) => {
-      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync21(affectedFile)) {
+      if (!processedFiles.has(affectedFile) && affectedFile !== normalizedFilePath && existsSync22(affectedFile)) {
         validFiles.push(affectedFile);
         processedFiles.add(affectedFile);
       }
@@ -10733,7 +11064,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   collectChangedFileAffected(state, normalizedFilePath, processedFiles, validFiles);
 }, processFilePathSet = (state, filePathSet, processedFiles, validFiles) => {
   filePathSet.forEach((filePathInSet) => {
-    if (!existsSync21(filePathInSet)) {
+    if (!existsSync22(filePathInSet)) {
       collectDeletedFileAffected(state, filePathInSet, processedFiles, validFiles);
       return;
     }
@@ -10801,7 +11132,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   if (framework === "unknown") {
     const { invalidate: invalidate2 } = (init_transformCache(), __toCommonJS(exports_transformCache));
     invalidate2(resolve30(filePath));
-    const relPath = relative11(process.cwd(), filePath);
+    const relPath = relative12(process.cwd(), filePath);
     logHmrUpdate(relPath);
     return;
   }
@@ -10841,7 +11172,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     return componentFile;
   }
   const tsCounterpart = componentFile.replace(/\.html$/, ".ts");
-  if (existsSync21(tsCounterpart)) {
+  if (existsSync22(tsCounterpart)) {
     return tsCounterpart;
   }
   if (!graph)
@@ -10915,7 +11246,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     naming: "[dir]/[name].[hash].[ext]",
     outdir: buildDir,
     plugins: [
-      createStylePreprocessorPlugin(state.config.stylePreprocessors)
+      createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
     ],
     root: clientRoot,
     target: "browser",
@@ -10957,7 +11288,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   });
 }, compileAndBundleAngular = async (state, pageEntries, angularDir) => {
   const { compileAngular: compileAngular2 } = await Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular));
-  const { clientPaths, serverPaths } = await compileAngular2(pageEntries, angularDir, true, state.config.stylePreprocessors);
+  const { clientPaths, serverPaths } = await compileAngular2(pageEntries, angularDir, true, getStyleTransformConfig(state.config));
   serverPaths.forEach((serverPath) => {
     const fileBase = basename13(serverPath, ".js");
     state.manifest[toPascal(fileBase)] = resolve30(serverPath);
@@ -10987,7 +11318,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
 }, resolveReactEntryForPageFile = (normalized, pagesPathResolved, reactIndexesPath) => {
   const pageName = basename13(normalized, ".tsx");
   const indexPath = resolve30(reactIndexesPath, `${pageName}.tsx`);
-  if (!existsSync21(indexPath)) {
+  if (!existsSync22(indexPath)) {
     return;
   }
   return indexPath;
@@ -10999,7 +11330,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     }
     const pageName = basename13(dep, ".tsx");
     const indexPath = resolve30(reactIndexesPath, `${pageName}.tsx`);
-    if (existsSync21(indexPath) && !reactEntries.includes(indexPath)) {
+    if (existsSync22(indexPath) && !reactEntries.includes(indexPath)) {
       reactEntries.push(indexPath);
     }
   });
@@ -11050,7 +11381,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     naming: "[dir]/[name].[hash].[ext]",
     outdir: buildDir,
     plugins: [
-      createStylePreprocessorPlugin(state.config.stylePreprocessors)
+      createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
     ],
     reactFastRefresh: true,
     root: clientRoot,
@@ -11082,7 +11413,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
 }, getModuleUrl = async (pageFile) => {
   const { invalidateModule: invalidateModule2, warmCache: warmCache2, SRC_URL_PREFIX: SRC_URL_PREFIX2 } = await Promise.resolve().then(() => (init_moduleServer(), exports_moduleServer));
   invalidateModule2(pageFile);
-  const rel = relative11(process.cwd(), pageFile).replace(/\\/g, "/");
+  const rel = relative12(process.cwd(), pageFile).replace(/\\/g, "/");
   const url = `${SRC_URL_PREFIX2}${rel}`;
   warmCache2(url);
   return url;
@@ -11114,7 +11445,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   const pageModuleUrl = await getReactModuleUrl(broadcastTarget);
   if (pageModuleUrl) {
     const serverDuration = Date.now() - startTime;
-    state.lastHmrPath = relative11(process.cwd(), primaryFile).replace(/\\/g, "/");
+    state.lastHmrPath = relative12(process.cwd(), primaryFile).replace(/\\/g, "/");
     state.lastHmrFramework = "react";
     broadcastToClients(state, {
       data: {
@@ -11224,7 +11555,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     const { compileSvelte: compileSvelte2 } = await Promise.resolve().then(() => (init_compileSvelte(), exports_compileSvelte));
     const { build: bunBuild7 } = await Promise.resolve(globalThis.Bun);
     const clientRoot = await computeClientRoot(state.resolvedPaths);
-    const { svelteServerPaths, svelteIndexPaths, svelteClientPaths } = await compileSvelte2(svelteFiles, svelteDir, new Map, true, state.config.stylePreprocessors);
+    const { svelteServerPaths, svelteIndexPaths, svelteClientPaths } = await compileSvelte2(svelteFiles, svelteDir, new Map, true, getStyleTransformConfig(state.config));
     const serverEntries = [...svelteServerPaths];
     const clientEntries = [...svelteIndexPaths, ...svelteClientPaths];
     const serverRoot = resolve30(svelteDir, "generated", "server");
@@ -11244,7 +11575,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
         naming: "[dir]/[name].[hash].[ext]",
         outdir: serverOutDir,
         plugins: [
-          createStylePreprocessorPlugin(state.config.stylePreprocessors)
+          createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
         ],
         root: serverRoot,
         target: "bun",
@@ -11256,7 +11587,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
         naming: "[dir]/[name].[hash].[ext]",
         outdir: buildDir,
         plugins: [
-          createStylePreprocessorPlugin(state.config.stylePreprocessors)
+          createStylePreprocessorPlugin(getStyleTransformConfig(state.config))
         ],
         root: clientRoot,
         target: "browser",
@@ -11578,7 +11909,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   const baseName = fileName.replace(/\.vue$/, "");
   const pascalName = toPascal(baseName);
   const vueRoot = config.vueDirectory;
-  const hmrId = vueRoot ? relative11(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
+  const hmrId = vueRoot ? relative12(vueRoot, vuePagePath).replace(/\\/g, "/").replace(/\.vue$/, "") : baseName;
   const cssKey = `${pascalName}CSS`;
   const cssUrl = manifest[cssKey] || null;
   const { vueHmrMetadata: vueHmrMetadata2 } = await Promise.resolve().then(() => (init_compileVue(), exports_compileVue));
@@ -12226,7 +12557,7 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
   return Array.from(specifiers).filter(isResolvable3);
 }, generateEntrySource2 = (specifier) => `export * from '${specifier}';
 `, rewriteVendorFiles = async (vendorDir) => {
-  const { readdirSync: readdirSync2, readFileSync: readFileSync14, writeFileSync: writeFileSync8 } = await import("fs");
+  const { readdirSync: readdirSync2, readFileSync: readFileSync15, writeFileSync: writeFileSync8 } = await import("fs");
   const { computeVendorPaths: computeVendorPaths2 } = await Promise.resolve().then(() => (init_buildReactVendor(), exports_buildReactVendor));
   const reactPaths = Object.entries(computeVendorPaths2());
   const rewriteContent = (content) => reactPaths.reduce((acc, [specifier, webPath]) => {
@@ -12237,7 +12568,7 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
   const files = readdirSync2(vendorDir).filter((f) => f.endsWith(".js"));
   for (const file3 of files) {
     const filePath = join22(vendorDir, file3);
-    const original = readFileSync14(filePath, "utf-8");
+    const original = readFileSync15(filePath, "utf-8");
     const rewritten = rewriteContent(original);
     if (rewritten !== original)
       writeFileSync8(filePath, rewritten);
@@ -12636,5 +12967,5 @@ export {
   build
 };
 
-//# debugId=001509E3B3F3F26364756E2164756E21
+//# debugId=FC044B4AB3E004F164756E2164756E21
 //# sourceMappingURL=build.js.map