@absolutejs/absolute 0.19.0-beta.692 → 0.19.0-beta.694

package/dist/index.js

@@ -2502,10 +2502,12 @@ var init_lowerAwaitSlotSyntax = __esm(() => {
 });
 
 // src/build/stylePreprocessor.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
-import { dirname as dirname2, extname, join as join3 } 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 dirname2, extname, isAbsolute, join as join3, relative, resolve as resolve4 } from "path";
+import { fileURLToPath } from "url";
+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|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";
@@ -2513,19 +2515,214 @@ 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.`), compileStyleSource = async (filePath, source, languageHint) => {
+}, missingDependencyError = (name, filePath) => new Error(`Unable to compile ${filePath}: install optional dependency "${name}" to use this stylesheet preprocessor.`), normalizeLoadPaths = (filePath, paths = []) => [
+  dirname2(filePath),
+  process.cwd(),
+  ...paths.map((path) => resolve4(process.cwd(), path))
+], 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 = resolve4(cwd, "tsconfig.json");
+  const empty = { aliases: [], baseUrl: cwd, cwd };
+  if (!existsSync4(tsconfigPath)) {
+    tsconfigAliasCache = empty;
+    return empty;
+  }
+  try {
+    const parsed = JSON.parse(stripJsonComments(readFileSync3(tsconfigPath, "utf-8")));
+    const compilerOptions = parsed.compilerOptions ?? {};
+    const baseUrl = resolve4(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(resolve4(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 = extname(basePath);
+  const paths = ext ? [basePath] : getLanguageExtensions(language).flatMap((extension) => [
+    `${basePath}${extension}`,
+    join3(basePath, `index${extension}`)
+  ]);
+  if (language === "scss" || language === "sass") {
+    return paths.flatMap((path) => {
+      const dir = dirname2(path);
+      const base = path.slice(dir.length + 1);
+      return [path, join3(dir, `_${base}`)];
+    });
+  }
+  return paths;
+}, resolveImportPath = (specifier, fromDirectory, loadPaths, language, config) => {
+  const rawCandidates = [
+    ...resolveAliasTargets(specifier, config),
+    isAbsolute(specifier) ? specifier : resolve4(fromDirectory, specifier),
+    ...loadPaths.map((path) => resolve4(path, specifier))
+  ];
+  for (const candidate of rawCandidates.flatMap((path) => getCandidatePaths(path, language))) {
+    if (existsSync4(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 = dirname2(sourceFile);
+  const entryDir = dirname2(entryFile);
+  if (sourceDir === entryDir)
+    return contents;
+  return contents.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (match, quote, rawUrl) => {
+    const trimmedUrl = rawUrl.trim();
+    if (!trimmedUrl || isExternalCssUrl(trimmedUrl))
+      return match;
+    const { marker, path } = splitCssUrl(trimmedUrl);
+    const rebased = relative(entryDir, resolve4(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, dirname2(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 ?? {}, getStylusOptions = (config) => config?.stylus ?? {}, withAdditionalData = (contents, additionalData) => additionalData ? `${additionalData}
+${contents}` : contents, createSassImporter = (entryFile, loadPaths, language, config) => ({
+  canonicalize(specifier, options) {
+    const fromDirectory = options.containingUrl ? dirname2(fileURLToPath(options.containingUrl)) : dirname2(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, resolve4(currentDirectory), loadPaths, "less", config));
+    manager.loadFile = async (filename, currentDirectory) => {
+      const resolved = resolveImportPath(filename, resolve4(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 contents = source ?? await readFile(filePath, "utf-8");
+  const rawContents = source ?? await readFile(filePath, "utf-8");
   if (language === "scss" || language === "sass") {
+    const options = getSassOptions(config, language);
+    const packageName = options.implementation ?? "sass";
     let sass;
     try {
-      sass = await importOptionalPeer("sass");
+      sass = await importOptionalPeer(packageName);
     } catch {
-      throw missingDependencyError("sass", filePath);
+      throw missingDependencyError(packageName, filePath);
     }
+    const contents = withAdditionalData(rawContents, options.additionalData);
+    const loadPaths = normalizeLoadPaths(filePath, options.loadPaths);
     const result = sass.compileString(contents, {
-      loadPaths: [dirname2(filePath), process.cwd()],
+      importers: [
+        createSassImporter(filePath, loadPaths, language, config)
+      ],
+      loadPaths,
       style: "expanded",
       syntax: language === "sass" ? "indented" : "scss",
       url: new URL(`file://${filePath}`)
@@ -2533,6 +2730,7 @@ var STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATT
     return result.css;
   }
   if (language === "less") {
+    const options = getLessOptions(config);
     let lessModule;
     try {
       lessModule = await importOptionalPeer("less");
@@ -2543,14 +2741,63 @@ var STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATT
     const render = less?.render;
     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: [dirname2(filePath), process.cwd()]
+      paths: loadPaths,
+      plugins: [
+        ...options.options?.plugins ?? [],
+        createLessFileManager(filePath, loadPaths, config)
+      ]
     });
     return result.css;
   }
-  return contents;
-}, stylePreprocessorPlugin, createSvelteStylePreprocessor = () => ({
+  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 renderStylus(contents, filePath, loadPaths, options);
+  }
+  return rawContents;
+}, createStylePreprocessorPlugin = (config) => ({
+  name: "absolute-style-preprocessor",
+  setup(build) {
+    const cssModuleSources = new Map;
+    build.onResolve({ filter: /^absolute-style-module:/ }, ({ path }) => ({
+      namespace: "absolute-style-module",
+      path: path.slice("absolute-style-module:".length)
+    }));
+    build.onLoad({ filter: /\.module\.css$/i, namespace: "absolute-style-module" }, async ({ path }) => {
+      const source = cssModuleSources.get(path);
+      if (!source) {
+        throw new Error(`Unable to resolve CSS module source for ${path}`);
+      }
+      return {
+        contents: source.css,
+        loader: "css"
+      };
+    });
+    build.onLoad({ filter: STYLE_EXTENSION_PATTERN }, async ({ path }) => {
+      if (isStyleModulePath(path)) {
+        const cssModulePath = path.replace(STYLE_EXTENSION_PATTERN, ".css");
+        const compiled = await compileStyleSource(path, undefined, undefined, config);
+        const { css, exports } = extractCssModuleExports(compiled);
+        cssModuleSources.set(cssModulePath, { css, exports });
+        const exportSource = Object.keys(exports).length > 0 ? `import styles from ${JSON.stringify(`absolute-style-module:${cssModulePath}`)}; export default Object.assign({}, styles, ${JSON.stringify(exports)});` : `export { default } from ${JSON.stringify(`absolute-style-module:${cssModulePath}`)};`;
+        return {
+          contents: exportSource,
+          loader: "js"
+        };
+      }
+      return {
+        contents: await compileStyleSource(path, undefined, undefined, config),
+        loader: "css"
+      };
+    });
+  }
+}), stylePreprocessorPlugin, createSvelteStylePreprocessor = (config) => ({
   style: async ({
     attributes,
     content,
@@ -2561,63 +2808,30 @@ var STYLE_EXTENSION_PATTERN, STYLE_MODULE_EXTENSION_PATTERN, STYLE_LANGUAGE_PATT
       return;
     const path = filename ?? `style.${language}`;
     return {
-      code: await compileStyleSource(path, content, language)
+      code: await compileStyleSource(path, content, language, config)
     };
   }
-}), compileStyleFileIfNeeded = async (filePath) => {
+}), compileStyleFileIfNeeded = async (filePath, config) => {
   if (!isPreprocessableStylePath(filePath)) {
     return readFile(filePath, "utf-8");
   }
-  return compileStyleSource(filePath);
+  return compileStyleSource(filePath, undefined, undefined, config);
 };
 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;
+  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(join3(process.cwd(), "package.json"));
-  stylePreprocessorPlugin = {
-    name: "absolute-style-preprocessor",
-    setup(build) {
-      const cssModuleSources = new Map;
-      build.onResolve({ filter: /^absolute-style-module:/ }, ({ path }) => ({
-        namespace: "absolute-style-module",
-        path: path.slice("absolute-style-module:".length)
-      }));
-      build.onLoad({ filter: /\.module\.css$/i, namespace: "absolute-style-module" }, async ({ path }) => {
-        const sourcePath = cssModuleSources.get(path);
-        if (!sourcePath) {
-          throw new Error(`Unable to resolve CSS module source for ${path}`);
-        }
-        return {
-          contents: await compileStyleSource(sourcePath),
-          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);
-          return {
-            contents: `export { default } from ${JSON.stringify(`absolute-style-module:${cssModulePath}`)};`,
-            loader: "js"
-          };
-        }
-        return {
-          contents: await compileStyleSource(path),
-          loader: "css"
-        };
-      });
-    }
-  };
+  stylePreprocessorPlugin = createStylePreprocessorPlugin();
 });
 
 // src/core/svelteServerModule.ts
 import { mkdir, readdir } from "fs/promises";
-import { basename as basename2, dirname as dirname3, extname as extname2, join as join4, relative, resolve as resolve4 } from "path";
+import { basename as basename2, dirname as dirname3, extname as extname2, join as join4, relative as relative2, resolve as resolve5 } from "path";
 var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
-  const importPath = relative(dirname3(from), target).replace(/\\/g, "/");
+  const importPath = relative2(dirname3(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, processDirectoryEntries = (entries, dir, targetFileName, stack) => {
   for (const entry of entries) {
@@ -2663,7 +2877,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const basePath = resolve4(dirname3(from), spec);
+  const basePath = resolve5(dirname3(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -2681,7 +2895,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   const foundIndex = existResults.indexOf(true);
   return foundIndex >= 0 ? candidates[foundIndex] ?? null : null;
 }, getCachedModulePath = (sourcePath) => {
-  const relativeSourcePath = relative(process.cwd(), sourcePath).replace(/\\/g, "/");
+  const relativeSourcePath = relative2(process.cwd(), sourcePath).replace(/\\/g, "/");
   const normalizedSourcePath = relativeSourcePath.startsWith("..") ? sourcePath.replace(/[:\\/]/g, "_") : relativeSourcePath;
   return join4(serverCacheRoot, `${normalizedSourcePath}.server.js`);
 }, resolveSvelteImport = async (spec, from) => {
@@ -2695,7 +2909,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const explicitPath = resolve4(dirname3(from), spec);
+  const explicitPath = resolve5(dirname3(from), spec);
   if (extname2(explicitPath) === ".svelte") {
     return explicitPath;
   }
@@ -2950,7 +3164,7 @@ import {
   rmSync,
   writeFileSync as writeFileSync2
 } from "fs";
-import { dirname as dirname4, extname as extname3, join as join5, relative as relative2, resolve as resolve5 } from "path";
+import { dirname as dirname4, extname as extname3, join as join5, relative as relative3, resolve as resolve6 } from "path";
 import ts from "typescript";
 var frameworks, isRecord4 = (value) => typeof value === "object" && value !== null, resolveRegistryExport = (mod) => {
   if (isRecord4(mod.islandRegistry))
@@ -2959,13 +3173,13 @@ var frameworks, isRecord4 = (value) => typeof value === "object" && value !== nu
     return mod.default;
   throw new Error("Island registry module must export `islandRegistry` or a default registry object.");
 }, normalizeImportPath = (wrapperPath, targetPath) => {
-  const importPath = relative2(dirname4(wrapperPath), targetPath).replace(/\\/g, "/");
+  const importPath = relative3(dirname4(wrapperPath), targetPath).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, isIdentifier = (value) => /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(value), resolveIslandSourcePath = (registryPath, sourcePath) => {
   if (sourcePath.startsWith("file://")) {
     return new URL(sourcePath).pathname;
   }
-  return resolve5(dirname4(registryPath), sourcePath);
+  return resolve6(dirname4(registryPath), sourcePath);
 }, getObjectPropertyName = (name) => {
   if (ts.isIdentifier(name) || ts.isStringLiteral(name)) {
     return name.text;
@@ -3128,7 +3342,7 @@ export default component;
     generatedRoot
   };
 }, loadIslandRegistryBuildInfo = async (registryPath) => {
-  const resolvedRegistryPath = resolve5(registryPath);
+  const resolvedRegistryPath = resolve6(registryPath);
   const registrySource = Bun.file(resolvedRegistryPath);
   const registrySourceText = await registrySource.text();
   const registryModule = await import(resolvedRegistryPath);
@@ -3217,7 +3431,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;
@@ -3346,7 +3560,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);
@@ -3382,10 +3596,10 @@ var init_staticIslandPages = __esm(() => {
 });
 
 // src/build/scanEntryPoints.ts
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 var {Glob } = globalThis.Bun;
 var scanEntryPoints = async (dir, pattern) => {
-  if (!existsSync4(dir))
+  if (!existsSync5(dir))
     return [];
   const entryPaths = [];
   const glob = new Glob(pattern);
@@ -3474,8 +3688,8 @@ var init_sourceMetadata = __esm(() => {
 });
 
 // src/islands/pageMetadata.ts
-import { readFileSync as readFileSync4 } from "fs";
-import { dirname as dirname5, resolve as resolve8 } from "path";
+import { readFileSync as readFileSync5 } from "fs";
+import { dirname as dirname5, resolve as resolve9 } from "path";
 var pagePatterns, getPageDirs = (config) => [
   { dir: config.angularDirectory, framework: "angular" },
   { dir: config.reactDirectory, framework: "react" },
@@ -3494,15 +3708,15 @@ var pagePatterns, getPageDirs = (config) => [
     const source = definition.buildReference?.source;
     if (!source)
       continue;
-    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve8(dirname5(buildInfo.resolvedRegistryPath), source);
-    lookup.set(`${definition.framework}:${definition.component}`, resolve8(resolvedSource));
+    const resolvedSource = source.startsWith("file://") ? new URL(source).pathname : resolve9(dirname5(buildInfo.resolvedRegistryPath), source);
+    lookup.set(`${definition.framework}:${definition.component}`, resolve9(resolvedSource));
   }
   return lookup;
 }, getCurrentPageIslandMetadata = () => globalThis.__absolutePageIslandMetadata ?? new Map, metadataUsesSource = (metadata2, target) => metadata2.islands.some((usage) => {
   const candidate = usage.source;
-  return candidate ? resolve8(candidate) === target : false;
+  return candidate ? resolve9(candidate) === target : false;
 }), getPagesUsingIslandSource = (sourcePath) => {
-  const target = resolve8(sourcePath);
+  const target = resolve9(sourcePath);
   return [...getCurrentPageIslandMetadata().values()].filter((metadata2) => metadataUsesSource(metadata2, target)).map((metadata2) => metadata2.pagePath);
 }, resolveIslandUsages = (islands, islandSourceLookup) => islands.map((usage) => {
   const sourcePath = islandSourceLookup.get(`${usage.framework}:${usage.component}`);
@@ -3514,13 +3728,13 @@ var pagePatterns, getPageDirs = (config) => [
   const pattern = pagePatterns[entry.framework];
   if (!pattern)
     return;
-  const files = await scanEntryPoints(resolve8(entry.dir), pattern);
+  const files = await scanEntryPoints(resolve9(entry.dir), pattern);
   for (const filePath of files) {
-    const source = readFileSync4(filePath, "utf-8");
+    const source = readFileSync5(filePath, "utf-8");
     const islands = extractIslandUsagesFromSource(source);
-    pageMetadata.set(resolve8(filePath), {
+    pageMetadata.set(resolve9(filePath), {
       islands: resolveIslandUsages(islands, islandSourceLookup),
-      pagePath: resolve8(filePath)
+      pagePath: resolve9(filePath)
     });
   }
 }, loadPageIslandMetadata = async (config) => {
@@ -3599,9 +3813,9 @@ var getManifestKey = (folder, pascalName, isClientComponent, isReact, isVue, isS
 }, generateManifest = (outputs, buildPath) => outputs.reduce((manifest, artifact) => {
   const normalizedArtifactPath = normalizePath(artifact.path);
   const normalizedBuildPath = normalizePath(buildPath);
-  let relative3 = normalizedArtifactPath.startsWith(normalizedBuildPath) ? normalizedArtifactPath.slice(normalizedBuildPath.length) : normalizedArtifactPath;
-  relative3 = relative3.replace(/^\/+/, "");
-  const segments = relative3.split("/");
+  let relative4 = normalizedArtifactPath.startsWith(normalizedBuildPath) ? normalizedArtifactPath.slice(normalizedBuildPath.length) : normalizedArtifactPath;
+  relative4 = relative4.replace(/^\/+/, "");
+  const segments = relative4.split("/");
   const fileWithHash = segments.pop();
   if (!fileWithHash)
     return manifest;
@@ -3613,15 +3827,15 @@ var getManifestKey = (folder, pascalName, isClientComponent, isReact, isVue, isS
   const islandIndex = segments.findIndex((seg) => seg === "islands");
   if (ext === ".css") {
     const cssKey = getCssKey(pascalName, segments);
-    if (manifest[cssKey] && manifest[cssKey] !== `/${relative3}`)
-      logWarn(`Duplicate manifest key "${cssKey}" \u2014 "${manifest[cssKey]}" will be overwritten by "/${relative3}". Use unique page names across frameworks.`);
-    manifest[cssKey] = `/${relative3}`;
+    if (manifest[cssKey] && manifest[cssKey] !== `/${relative4}`)
+      logWarn(`Duplicate manifest key "${cssKey}" \u2014 "${manifest[cssKey]}" will be overwritten by "/${relative4}". Use unique page names across frameworks.`);
+    manifest[cssKey] = `/${relative4}`;
     return manifest;
   }
   const frameworkSegment = islandIndex > UNFOUND_INDEX ? segments[islandIndex + 1] : undefined;
   if (frameworkSegment === "react" || frameworkSegment === "svelte" || frameworkSegment === "vue" || frameworkSegment === "angular") {
     const manifestKey2 = getIslandManifestKey(frameworkSegment, pascalName);
-    manifest[manifestKey2] = `/${relative3}`;
+    manifest[manifestKey2] = `/${relative4}`;
     return manifest;
   }
   const idx = segments.findIndex((seg) => seg === "indexes" || seg === "pages" || seg === "client");
@@ -3632,10 +3846,10 @@ var getManifestKey = (folder, pascalName, isClientComponent, isReact, isVue, isS
   const isAngular = segments.some((seg) => seg === "angular");
   const isClientComponent = segments.includes("client");
   const manifestKey = getManifestKey(folder, pascalName, isClientComponent, isReact, isVue, isSvelte, isAngular);
-  if (manifest[manifestKey] && manifest[manifestKey] !== `/${relative3}`) {
-    logWarn(`Duplicate manifest key "${manifestKey}" \u2014 "${manifest[manifestKey]}" will be overwritten by "/${relative3}". Use unique page names across frameworks.`);
+  if (manifest[manifestKey] && manifest[manifestKey] !== `/${relative4}`) {
+    logWarn(`Duplicate manifest key "${manifestKey}" \u2014 "${manifest[manifestKey]}" will be overwritten by "/${relative4}". Use unique page names across frameworks.`);
   }
-  manifest[manifestKey] = `/${relative3}`;
+  manifest[manifestKey] = `/${relative4}`;
   return manifest;
 }, {});
 var init_generateManifest = __esm(() => {
@@ -3648,22 +3862,22 @@ var exports_generateReactIndexes = {};
 __export(exports_generateReactIndexes, {
   generateReactIndexFiles: () => generateReactIndexFiles
 });
-import { existsSync as existsSync5, mkdirSync as mkdirSync2 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync2 } from "fs";
 import { readdir as readdir2, rm, writeFile } from "fs/promises";
-import { basename as basename3, join as join6, relative as relative3, resolve as resolve9, sep } from "path";
+import { basename as basename3, join as join6, relative as relative4, resolve as resolve10, sep } from "path";
 var {Glob: Glob2 } = globalThis.Bun;
 var indexContentCache, resolveDevClientDir = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve9(import.meta.dir, "../dev/client");
-  if (existsSync5(fromSource) && fromSource.startsWith(projectRoot)) {
+  const fromSource = resolve10(import.meta.dir, "../dev/client");
+  if (existsSync6(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve9(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync5(fromNodeModules))
+  const fromNodeModules = resolve10(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  if (existsSync6(fromNodeModules))
     return fromNodeModules;
-  return resolve9(import.meta.dir, "./dev/client");
+  return resolve10(import.meta.dir, "./dev/client");
 }, devClientDir, errorOverlayPath, hmrClientPath, refreshSetupPath, generateReactIndexFiles = async (reactPagesDirectory, reactIndexesDirectory, isDev2 = false) => {
-  if (!existsSync5(reactIndexesDirectory)) {
+  if (!existsSync6(reactIndexesDirectory)) {
     mkdirSync2(reactIndexesDirectory, { recursive: true });
   }
   const CONVENTION_RE = /^(?:(.+)\.)?(error|loading|not-found)\.[^.]+$/;
@@ -3689,7 +3903,7 @@ var indexContentCache, resolveDevClientDir = () => {
       });
     }));
   }
-  const pagesRelPath = relative3(resolve9(reactIndexesDirectory), resolve9(reactPagesDirectory)).split(sep).join("/");
+  const pagesRelPath = relative4(resolve10(reactIndexesDirectory), resolve10(reactPagesDirectory)).split(sep).join("/");
   const promises = files.map(async (file2) => {
     const fileName = basename3(file2);
     const [componentName] = fileName.split(".");
@@ -3949,7 +4163,7 @@ var indexContentCache, resolveDevClientDir = () => {
         `
 // Pre-warm: import the page module from the module server`,
         `// immediately so the browser caches all /@src/ URLs.`,
-        `import('/@src/${relative3(process.cwd(), resolve9(reactPagesDirectory, `${componentName}.tsx`)).replace(/\\/g, "/")}').catch(() => {});`
+        `import('/@src/${relative4(process.cwd(), resolve10(reactPagesDirectory, `${componentName}.tsx`)).replace(/\\/g, "/")}').catch(() => {});`
       ] : []
     ].join(`
 `);
@@ -3957,7 +4171,7 @@ var indexContentCache, resolveDevClientDir = () => {
     const hasher = new Bun.CryptoHasher("md5");
     hasher.update(content);
     const contentHash = hasher.digest("hex");
-    if (indexContentCache.get(indexPath) === contentHash && existsSync5(indexPath)) {
+    if (indexContentCache.get(indexPath) === contentHash && existsSync6(indexPath)) {
       return;
     }
     indexContentCache.set(indexPath, contentHash);
@@ -3968,7 +4182,7 @@ var indexContentCache, resolveDevClientDir = () => {
     return;
   }
   const refreshPath = join6(reactIndexesDirectory, "_refresh.tsx");
-  if (!existsSync5(refreshPath)) {
+  if (!existsSync6(refreshPath)) {
     await writeFile(refreshPath, `import '${refreshSetupPath}';
 import 'react';
 import 'react-dom/client';
@@ -4048,7 +4262,7 @@ var init_outputLogs = __esm(() => {
 // src/build/scanConventions.ts
 import { basename as basename4 } from "path";
 var {Glob: Glob3 } = globalThis.Bun;
-import { existsSync as existsSync6 } from "fs";
+import { existsSync as existsSync7 } from "fs";
 var CONVENTION_RE, classifyFile = (file2, pageFiles, defaults, pages) => {
   const fileName = basename4(file2);
   const match = CONVENTION_RE.exec(fileName);
@@ -4073,7 +4287,7 @@ var CONVENTION_RE, classifyFile = (file2, pageFiles, defaults, pages) => {
   else if (kind === "loading")
     pages[pageName].loading = file2;
 }, scanConventions = async (pagesDir, pattern) => {
-  if (!existsSync6(pagesDir)) {
+  if (!existsSync7(pagesDir)) {
     const pageFiles2 = [];
     return { conventions: undefined, pageFiles: pageFiles2 };
   }
@@ -4096,13 +4310,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 file2 of glob.scan({ absolute: true, cwd: dir })) {
     const normalized = normalizePath(file2);
     if (isStyleModulePath(normalized) || ignore?.some((pattern) => normalized.includes(pattern)))
@@ -4116,8 +4330,8 @@ var init_scanCssEntryPoints = __esm(() => {
 });
 
 // src/utils/imageProcessing.ts
-import { existsSync as existsSync8, mkdirSync as mkdirSync3, readFileSync as readFileSync5, writeFileSync as writeFileSync4 } from "fs";
-import { join as join7, resolve as resolve10 } from "path";
+import { existsSync as existsSync9, mkdirSync as mkdirSync3, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { join as join7, resolve as resolve11 } 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) {
     if (size >= target)
@@ -4171,7 +4385,7 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY = 75, OPTIMIZATIO
   return [...device, ...image2].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) => {
@@ -4229,11 +4443,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(readFileSync5(metaPath, "utf-8"));
-    const buffer = readFileSync5(dataPath);
+    const meta = JSON.parse(readFileSync6(metaPath, "utf-8"));
+    const buffer = readFileSync6(dataPath);
     return { buffer, meta };
   } catch {
     return null;
@@ -4243,7 +4457,7 @@ var DEFAULT_DEVICE_SIZES, DEFAULT_IMAGE_SIZES, DEFAULT_QUALITY = 75, OPTIMIZATIO
     return sharpModule;
   sharpLoaded = true;
   try {
-    const sharpPath = resolve10(process.cwd(), "node_modules/sharp");
+    const sharpPath = resolve11(process.cwd(), "node_modules/sharp");
     const mod = await import(sharpPath);
     sharpModule = mod.default ?? mod;
     return sharpModule;
@@ -4348,14 +4562,14 @@ var init_optimizeHtmlImages = __esm(() => {
 });
 
 // src/cli/scripts/telemetry.ts
-import { existsSync as existsSync9, mkdirSync as mkdirSync4, readFileSync as readFileSync6, writeFileSync as writeFileSync5 } from "fs";
+import { existsSync as existsSync10, mkdirSync as mkdirSync4, readFileSync as readFileSync7, 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 = readFileSync6(configPath, "utf-8");
+    const raw = readFileSync7(configPath, "utf-8");
     const config = JSON.parse(raw);
     return config;
   } catch {
@@ -4368,14 +4582,14 @@ var init_telemetry = __esm(() => {
 });
 
 // src/cli/telemetryEvent.ts
-import { existsSync as existsSync10, readFileSync as readFileSync7 } from "fs";
+import { existsSync as existsSync11, readFileSync as readFileSync8 } from "fs";
 import { arch, platform } from "os";
 import { dirname as dirname6, join as join9, parse } from "path";
 var checkCandidate = (candidate) => {
-  if (!existsSync10(candidate)) {
+  if (!existsSync11(candidate)) {
     return null;
   }
-  const pkg = JSON.parse(readFileSync7(candidate, "utf-8"));
+  const pkg = JSON.parse(readFileSync8(candidate, "utf-8"));
   if (pkg.name === "@absolutejs/absolute") {
     const ver = pkg.version;
     return ver;
@@ -4480,19 +4694,19 @@ var init_updateAssetPaths = __esm(() => {
 });
 
 // src/dev/buildHMRClient.ts
-import { existsSync as existsSync11 } from "fs";
-import { resolve as resolve11 } from "path";
+import { existsSync as existsSync12 } from "fs";
+import { resolve as resolve12 } from "path";
 var {build: bunBuild } = globalThis.Bun;
 var resolveHmrClientPath = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve11(import.meta.dir, "client/hmrClient.ts");
-  if (existsSync11(fromSource) && fromSource.startsWith(projectRoot)) {
+  const fromSource = resolve12(import.meta.dir, "client/hmrClient.ts");
+  if (existsSync12(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve11(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client/hmrClient.ts");
-  if (existsSync11(fromNodeModules))
+  const fromNodeModules = resolve12(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client/hmrClient.ts");
+  if (existsSync12(fromNodeModules))
     return fromNodeModules;
-  return resolve11(import.meta.dir, "dev/client/hmrClient.ts");
+  return resolve12(import.meta.dir, "dev/client/hmrClient.ts");
 }, hmrClientPath2, buildHMRClient = async () => {
   const entryPoint = hmrClientPath2;
   const result = await bunBuild({
@@ -4522,7 +4736,7 @@ var init_buildHMRClient = __esm(() => {
 // src/build/nativeRewrite.ts
 import { dlopen, FFIType, ptr } from "bun:ffi";
 import { platform as platform2, arch as arch2 } from "os";
-import { resolve as resolve12 } from "path";
+import { resolve as resolve13 } from "path";
 var ffiDefinition, nativeLib = null, loadNative = () => {
   if (nativeLib !== null)
     return nativeLib;
@@ -4540,7 +4754,7 @@ var ffiDefinition, nativeLib = null, loadNative = () => {
   if (!libPath)
     return null;
   try {
-    const fullPath = resolve12(import.meta.dir, "../../native/packages", libPath);
+    const fullPath = resolve13(import.meta.dir, "../../native/packages", libPath);
     const lib = dlopen(fullPath, ffiDefinition);
     nativeLib = lib.symbols;
     return nativeLib;
@@ -4682,12 +4896,12 @@ var devVendorPaths = null, getDevVendorPaths = () => devVendorPaths, setDevVendo
 };
 
 // src/build/angularLinkerPlugin.ts
-import { existsSync as existsSync12, mkdirSync as mkdirSync5, readFileSync as readFileSync8, writeFileSync as writeFileSync6 } from "fs";
-import { dirname as dirname7, join as join10, relative as relative4, resolve as resolve13 } from "path";
+import { existsSync as existsSync13, mkdirSync as mkdirSync5, readFileSync as readFileSync9, writeFileSync as writeFileSync6 } from "fs";
+import { dirname as dirname7, join as join10, relative as relative5, resolve as resolve14 } from "path";
 import { createHash } from "crypto";
 var CACHE_DIR, angularLinkerPlugin;
 var init_angularLinkerPlugin = __esm(() => {
-  CACHE_DIR = resolve13(".absolutejs", "cache", "angular-linker");
+  CACHE_DIR = resolve14(".absolutejs", "cache", "angular-linker");
   angularLinkerPlugin = {
     name: "angular-linker",
     setup(bld) {
@@ -4707,9 +4921,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: readFileSync8(cachePath, "utf-8"),
+            contents: readFileSync9(cachePath, "utf-8"),
             loader: "js"
           };
         }
@@ -4724,10 +4938,10 @@ var init_angularLinkerPlugin = __esm(() => {
           linkerPlugin = mod.createEs2015LinkerPlugin({
             fileSystem: {
               dirname: dirname7,
-              exists: existsSync12,
-              readFile: readFileSync8,
-              relative: relative4,
-              resolve: resolve13
+              exists: existsSync13,
+              readFile: readFileSync9,
+              relative: relative5,
+              resolve: resolve14
             },
             linkerJitMode: false,
             logger: {
@@ -4761,17 +4975,17 @@ var init_angularLinkerPlugin = __esm(() => {
 
 // src/utils/cleanStaleOutputs.ts
 import { rm as rm2 } from "fs/promises";
-import { resolve as resolve14 } from "path";
+import { resolve as resolve15 } from "path";
 var {Glob: Glob5 } = globalThis.Bun;
 var HASHED_FILE_PATTERN, cleanStaleOutputs = async (buildPath, currentOutputPaths) => {
-  const currentPaths = new Set(currentOutputPaths.map((path) => resolve14(path)));
+  const currentPaths = new Set(currentOutputPaths.map((path) => resolve15(path)));
   const glob = new Glob5("**/*");
   const removals = [];
-  for (const relative5 of glob.scanSync({ cwd: buildPath })) {
-    const absolute = resolve14(buildPath, relative5);
+  for (const relative6 of glob.scanSync({ cwd: buildPath })) {
+    const absolute = resolve15(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 }));
   }
@@ -4829,11 +5043,11 @@ var commonAncestor = (paths, fallback) => {
 var init_commonAncestor = () => {};
 
 // src/utils/validateSafePath.ts
-import { resolve as resolve15, relative as relative5 } from "path";
+import { resolve as resolve16, relative as relative6 } from "path";
 var validateSafePath = (targetPath, baseDirectory) => {
-  const absoluteBase = resolve15(baseDirectory);
-  const absoluteTarget = resolve15(baseDirectory, targetPath);
-  const relativePath = normalizePath(relative5(absoluteBase, absoluteTarget));
+  const absoluteBase = resolve16(baseDirectory);
+  const absoluteTarget = resolve16(baseDirectory, targetPath);
+  const relativePath = normalizePath(relative6(absoluteBase, absoluteTarget));
   if (relativePath.startsWith("../") || relativePath === "..") {
     throw new Error(`Unsafe path: ${targetPath}`);
   }
@@ -4902,29 +5116,29 @@ __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 dirname8,
   join as join12,
   basename as basename5,
   extname as extname5,
-  resolve as resolve16,
-  relative as relative6,
+  resolve as resolve17,
+  relative as relative7,
   sep as sep2
 } from "path";
 import { env as env2 } from "process";
 var {write, file: file2, Transpiler } = globalThis.Bun;
 var resolveDevClientDir2 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve16(import.meta.dir, "../dev/client");
-  if (existsSync13(fromSource) && fromSource.startsWith(projectRoot)) {
+  const fromSource = resolve17(import.meta.dir, "../dev/client");
+  if (existsSync14(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve16(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync13(fromNodeModules))
+  const fromNodeModules = resolve17(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  if (existsSync14(fromNodeModules))
     return fromNodeModules;
-  return resolve16(import.meta.dir, "./dev/client");
+  return resolve17(import.meta.dir, "./dev/client");
 }, devClientDir2, hmrClientPath3, persistentCache, sourceHashCache, clearSvelteCompilerCache = () => {
   persistentCache.clear();
   sourceHashCache.clear();
@@ -4954,7 +5168,7 @@ var resolveDevClientDir2 = () => {
 }, resolveRelativeModule2 = async (spec, from) => {
   if (!spec.startsWith("."))
     return null;
-  const basePath = resolve16(dirname8(from), spec);
+  const basePath = resolve17(dirname8(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -4981,7 +5195,7 @@ var resolveDevClientDir2 = () => {
     const resolved = resolvePackageImport(spec);
     return resolved && /\.svelte(\.(?:ts|js))?$/.test(resolved) ? resolved : null;
   }
-  const basePath = resolve16(dirname8(from), spec);
+  const basePath = resolve17(dirname8(from), spec);
   const explicit = /\.(svelte|svelte\.(?:ts|js))$/.test(basePath);
   if (!explicit) {
     const extensions = [".svelte", ".svelte.ts", ".svelte.js"];
@@ -5002,13 +5216,13 @@ 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}`
   });
-}, compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev2 = false) => {
+}, compileSvelte = async (entryPoints, svelteRoot, cache = new Map, isDev2 = false, stylePreprocessors) => {
   const { compile, compileModule, preprocess } = await import("svelte/compiler");
   const generatedDir = join12(svelteRoot, "generated");
   const clientDir = join12(generatedDir, "client");
@@ -5036,13 +5250,13 @@ var resolveDevClientDir2 = () => {
     const loweredServerSource = isModule ? loweredAwaitServerSource : lowerSvelteIslandSyntax(loweredAwaitServerSource.code, "server");
     const loweredClientSource = isModule ? loweredAwaitClientSource : lowerSvelteIslandSyntax(loweredAwaitClientSource.code, "client");
     const transformedByLowering = loweredAwaitServerSource.transformed || loweredAwaitClientSource.transformed || loweredServerSource.transformed || loweredClientSource.transformed;
-    const svelteStylePreprocessor = createSvelteStylePreprocessor();
+    const svelteStylePreprocessor = createSvelteStylePreprocessor(stylePreprocessors);
     const preprocessedServer = isModule ? loweredServerSource.code : (await preprocess(loweredServerSource.code, svelteStylePreprocessor)).code;
     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 = dirname8(relative6(svelteRoot, src)).replace(/\\/g, "/");
-    const relDir = rawRel.startsWith("..") ? `_ext/${relative6(process.cwd(), dirname8(src)).replace(/\\/g, "/")}` : rawRel;
+    const rawRel = dirname8(relative7(svelteRoot, src)).replace(/\\/g, "/");
+    const relDir = rawRel.startsWith("..") ? `_ext/${relative7(process.cwd(), dirname8(src)).replace(/\\/g, "/")}` : rawRel;
     const baseName = basename5(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)));
@@ -5063,15 +5277,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}`
@@ -5106,7 +5320,7 @@ var resolveDevClientDir2 = () => {
       }).js.code;
       let code = compiled.replace(/\.svelte(?:\.(?:ts|js))?(['"])/g, ".js$1");
       if (mode === "client" && isDev2) {
-        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; };`);
@@ -5149,10 +5363,10 @@ var resolveDevClientDir2 = () => {
   };
   const roots = await Promise.all(entryPoints.map(build2));
   await Promise.all(roots.map(async ({ client: client2, hasAwaitSlot }) => {
-    const relClientDir = dirname8(relative6(clientDir, client2));
+    const relClientDir = dirname8(relative7(clientDir, client2));
     const name = basename5(client2, extname5(client2));
     const indexPath = join12(indexDir, relClientDir, `${name}.js`);
-    const importRaw = relative6(dirname8(indexPath), client2).split(sep2).join("/");
+    const importRaw = relative7(dirname8(indexPath), client2).split(sep2).join("/");
     const importPath = importRaw.startsWith(".") || importRaw.startsWith("/") ? importRaw : `./${importRaw}`;
     const hmrImports = isDev2 ? `window.__HMR_FRAMEWORK__ = "svelte";
 import "${hmrClientPath3}";
@@ -5229,7 +5443,7 @@ if (typeof window !== "undefined") {
   return {
     svelteClientPaths: roots.map(({ client: client2 }) => client2),
     svelteIndexPaths: roots.map(({ client: client2 }) => {
-      const rel = dirname8(relative6(clientDir, client2));
+      const rel = dirname8(relative7(clientDir, client2));
       return join12(indexDir, rel, basename5(client2));
     }),
     svelteServerPaths: roots.map(({ ssr }) => ssr)
@@ -5259,20 +5473,20 @@ __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 basename6, dirname as dirname9, join as join13, relative as relative7, resolve as resolve17 } from "path";
+import { basename as basename6, dirname as dirname9, join as join13, relative as relative8, resolve as resolve18 } from "path";
 var {file: file3, write: write2, Transpiler: Transpiler2 } = globalThis.Bun;
 var resolveDevClientDir3 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve17(import.meta.dir, "../dev/client");
-  if (existsSync14(fromSource) && fromSource.startsWith(projectRoot)) {
+  const fromSource = resolve18(import.meta.dir, "../dev/client");
+  if (existsSync15(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve17(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync14(fromNodeModules))
+  const fromNodeModules = resolve18(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  if (existsSync15(fromNodeModules))
     return fromNodeModules;
-  return resolve17(import.meta.dir, "./dev/client");
+  return resolve18(import.meta.dir, "./dev/client");
 }, devClientDir3, hmrClientPath4, transpiler3, scriptCache, scriptSetupCache, templateCache, styleCache, persistentBuildCache, vueSourceHashCache, vueHmrMetadata, clearVueHmrCaches = () => {
   scriptCache.clear();
   scriptSetupCache.clear();
@@ -5311,7 +5525,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"))
@@ -5334,11 +5548,11 @@ var resolveDevClientDir3 = () => {
   ].join(`
 `) : nonVueLines.join(`
 `);
-}, compileVueFile = async (sourceFilePath, outputDirs, cacheMap, isEntryPoint, vueRootDir, compiler) => {
+}, compileVueFile = async (sourceFilePath, outputDirs, cacheMap, isEntryPoint, vueRootDir, compiler, stylePreprocessors) => {
   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 = basename6(sourceFilePath, ".vue");
   const componentId = toKebab(fileBaseName);
@@ -5372,8 +5586,8 @@ var resolveDevClientDir3 = () => {
   const packageComponentPaths = Array.from(resolvedPackageVueImports.entries());
   const helperModulePaths = importPaths.filter((path) => path.startsWith(".") && !path.endsWith(".vue"));
   const childBuildResults = await Promise.all([
-    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve17(dirname9(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler)),
-    ...packageComponentPaths.map(([, absolutePath]) => compileVueFile(absolutePath, outputDirs, cacheMap, false, vueRootDir, compiler))
+    ...childComponentPaths.map((relativeChildPath) => compileVueFile(resolve18(dirname9(sourceFilePath), relativeChildPath), outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors)),
+    ...packageComponentPaths.map(([, absolutePath]) => compileVueFile(absolutePath, outputDirs, cacheMap, false, vueRootDir, compiler, stylePreprocessors))
   ]);
   const hasScript = descriptor.script || descriptor.scriptSetup;
   const compiledScript = hasScript ? compiler.compileScript(descriptor, {
@@ -5408,7 +5622,7 @@ var resolveDevClientDir3 = () => {
     filename: sourceFilePath,
     id: componentId,
     scoped: styleBlock.scoped,
-    source: styleBlock.lang ? await compileStyleSource(sourceFilePath, styleBlock.content, styleBlock.lang) : styleBlock.content,
+    source: styleBlock.lang ? await compileStyleSource(sourceFilePath, styleBlock.content, styleBlock.lang, stylePreprocessors) : styleBlock.content,
     trim: true
   }).code));
   const allCss = [
@@ -5462,7 +5676,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(dirname9(outputPath), targetPath).replace(/\\/g, "/");
+      let rel = relative8(dirname9(outputPath), targetPath).replace(/\\/g, "/");
       if (!rel.startsWith("."))
         rel = `./${rel}`;
       result2 = result2.replaceAll(bareImport, rel);
@@ -5480,14 +5694,14 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     hmrId,
     serverPath: serverOutputPath,
     tsHelperPaths: [
-      ...helperModulePaths.map((helper) => resolve17(dirname9(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
+      ...helperModulePaths.map((helper) => resolve18(dirname9(sourceFilePath), helper.endsWith(".ts") ? helper : `${helper}.ts`)),
       ...childBuildResults.flatMap((child) => child.tsHelperPaths)
     ]
   };
   cacheMap.set(sourceFilePath, result);
   persistentBuildCache.set(sourceFilePath, result);
   return result;
-}, compileVue = async (entryPoints, vueRootDir, isDev2 = false) => {
+}, compileVue = async (entryPoints, vueRootDir, isDev2 = false, stylePreprocessors) => {
   const compiler = await import("@vue/compiler-sfc");
   const generatedDir = join13(vueRootDir, "generated");
   const clientOutputDir = join13(generatedDir, "client");
@@ -5503,15 +5717,15 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   const buildCache = new Map;
   const allTsHelperPaths = new Set;
   const compiledPages = await Promise.all(entryPoints.map(async (entryPath) => {
-    const result = await compileVueFile(resolve17(entryPath), {
+    const result = await compileVueFile(resolve18(entryPath), {
       client: clientOutputDir,
       css: cssOutputDir,
       server: serverOutputDir
-    }, buildCache, true, vueRootDir, compiler);
+    }, buildCache, true, vueRootDir, compiler, stylePreprocessors);
     result.tsHelperPaths.forEach((path) => allTsHelperPaths.add(path));
     const entryBaseName = basename6(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(dirname9(indexOutputFile), { recursive: true });
     const vueHmrImports = isDev2 ? [
       `window.__HMR_FRAMEWORK__ = "vue";`,
@@ -5519,7 +5733,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
     ] : [];
     await write2(indexOutputFile, [
       ...vueHmrImports,
-      `import Comp from "${relative7(dirname9(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
+      `import Comp from "${relative8(dirname9(indexOutputFile), clientOutputFile).replace(/\\/g, "/")}";`,
       'import { createSSRApp, createApp } from "vue";',
       "",
       "// HMR State Preservation: Check for preserved state from HMR",
@@ -5639,7 +5853,7 @@ if (typeof __VUE_HMR_RUNTIME__ !== 'undefined') {
   await Promise.all(Array.from(allTsHelperPaths).map(async (tsPath) => {
     const sourceCode = await file3(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(dirname9(outClientPath), { recursive: true });
@@ -6140,27 +6354,27 @@ __export(exports_compileAngular, {
   compileAngularFile: () => compileAngularFile,
   compileAngular: () => compileAngular
 });
-import { existsSync as existsSync15, readFileSync as readFileSync9, promises as fs } from "fs";
-import { join as join14, basename as basename7, sep as sep3, dirname as dirname10, resolve as resolve18, relative as relative8 } from "path";
+import { existsSync as existsSync16, readFileSync as readFileSync10, promises as fs } from "fs";
+import { join as join14, basename as basename7, sep as sep3, dirname as dirname10, resolve as resolve19, relative as relative9 } from "path";
 import ts2 from "typescript";
 import { createHash as createHash2 } from "crypto";
 var computeConfigHash = () => {
   try {
-    const content = readFileSync9("./tsconfig.json", "utf-8");
+    const content = readFileSync10("./tsconfig.json", "utf-8");
     return createHash2("md5").update(content).digest("hex");
   } catch {
     return "";
   }
 }, resolveDevClientDir4 = () => {
   const projectRoot = process.cwd();
-  const fromSource = resolve18(import.meta.dir, "../dev/client");
-  if (existsSync15(fromSource) && fromSource.startsWith(projectRoot)) {
+  const fromSource = resolve19(import.meta.dir, "../dev/client");
+  if (existsSync16(fromSource) && fromSource.startsWith(projectRoot)) {
     return fromSource;
   }
-  const fromNodeModules = resolve18(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
-  if (existsSync15(fromNodeModules))
+  const fromNodeModules = resolve19(projectRoot, "node_modules/@absolutejs/absolute/dist/dev/client");
+  if (existsSync16(fromNodeModules))
     return fromNodeModules;
-  return resolve18(import.meta.dir, "./dev/client");
+  return resolve19(import.meta.dir, "./dev/client");
 }, devClientDir4, hmrClientPath5, hmrRuntimePath, injectHMRRegistration = (content, sourceId) => {
   const componentClassRegex = /(?:export\s+)?class\s+(\w+Component)\s/g;
   const componentNames = [];
@@ -6226,7 +6440,7 @@ ${registrations}
 }, resolveLocalTsImport = (fromFile, specifier) => {
   if (!isRelativeModuleSpecifier(specifier))
     return null;
-  const basePath = resolve18(dirname10(fromFile), specifier);
+  const basePath = resolve19(dirname10(fromFile), specifier);
   const candidates = /\.[cm]?[tj]sx?$/.test(basePath) ? [basePath] : [
     `${basePath}.ts`,
     `${basePath}.tsx`,
@@ -6237,24 +6451,24 @@ ${registrations}
     join14(basePath, "index.mts"),
     join14(basePath, "index.cts")
   ];
-  return candidates.map((candidate) => resolve18(candidate)).find((candidate) => existsSync15(candidate) && !candidate.endsWith(".d.ts")) ?? null;
+  return candidates.map((candidate) => resolve19(candidate)).find((candidate) => existsSync16(candidate) && !candidate.endsWith(".d.ts")) ?? null;
 }, readFileForAotTransform = async (fileName, readFile4) => {
   const hostSource = readFile4?.(fileName);
   if (typeof hostSource === "string")
     return hostSource;
   return fs.readFile(fileName, "utf-8");
-}, precomputeAotResourceTransforms = async (inputPath, readFile4) => {
+}, precomputeAotResourceTransforms = async (inputPath, readFile4, stylePreprocessors) => {
   const transformedSources = new Map;
   const visited = new Set;
   const transformFile = async (filePath) => {
-    const resolvedPath = resolve18(filePath);
+    const resolvedPath = resolve19(filePath);
     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, dirname10(resolvedPath));
+    const transformed = await inlineResources(source, dirname10(resolvedPath), stylePreprocessors);
     transformedSources.set(resolvedPath, transformed.source);
     const imports = extractLocalImportSpecifiers(source, resolvedPath);
     await Promise.all(imports.map(async (specifier) => {
@@ -6265,8 +6479,8 @@ ${registrations}
   };
   await transformFile(inputPath);
   return transformedSources;
-}, compileAngularFile = async (inputPath, outDir) => {
-  const islandMetadataExports = buildIslandMetadataExports(readFileSync9(inputPath, "utf-8"));
+}, compileAngularFile = async (inputPath, outDir, stylePreprocessors) => {
+  const islandMetadataExports = buildIslandMetadataExports(readFileSync10(inputPath, "utf-8"));
   const { readConfiguration, performCompilation, EmitFlags } = await import("@angular/compiler-cli");
   const configHash = computeConfigHash();
   const cached = globalThis.__angularCompilerCache;
@@ -6281,7 +6495,7 @@ ${registrations}
   } else {
     const tsPath = __require.resolve("typescript");
     const tsRootDir = dirname10(tsPath);
-    tsLibDir = tsRootDir.endsWith("lib") ? tsRootDir : resolve18(tsRootDir, "lib");
+    tsLibDir = tsRootDir.endsWith("lib") ? tsRootDir : resolve19(tsRootDir, "lib");
     const config = readConfiguration("./tsconfig.json");
     options = {
       emitDecoratorMetadata: true,
@@ -6328,13 +6542,13 @@ ${registrations}
     };
   }
   const emitted = {};
-  const resolvedOutDir = resolve18(outDir);
+  const resolvedOutDir = resolve19(outDir);
   host.writeFile = (fileName, text) => {
     const relativePath = resolveRelativePath(fileName, resolvedOutDir, outDir);
     emitted[relativePath] = text;
   };
   const originalReadFile = host.readFile;
-  const aotTransformedSources = await precomputeAotResourceTransforms(inputPath, originalReadFile?.bind(host));
+  const aotTransformedSources = await precomputeAotResourceTransforms(inputPath, originalReadFile?.bind(host), stylePreprocessors);
   host.readFile = (fileName) => {
     const source = originalReadFile ? originalReadFile.call(host, fileName) : undefined;
     if (typeof source !== "string")
@@ -6342,7 +6556,7 @@ ${registrations}
     if (!fileName.endsWith(".ts") || fileName.endsWith(".d.ts")) {
       return source;
     }
-    const resolvedPath = resolve18(fileName);
+    const resolvedPath = resolve19(fileName);
     return aotTransformedSources.get(resolvedPath) ?? source;
   };
   const originalGetSourceFileForCompile = host.getSourceFile;
@@ -6387,8 +6601,8 @@ ${registrations}
   await Promise.all(entries.map(({ target, content }) => fs.writeFile(target, content, "utf-8")));
   return entries.map(({ target }) => target);
 }, jitContentCache, wrapperOutputCache, escapeTemplateContent = (content) => content.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${"), resolveAngularDeferImportSpecifier = () => {
-  const sourceEntry = resolve18(import.meta.dir, "../angular/components/index.ts");
-  if (existsSync15(sourceEntry)) {
+  const sourceEntry = resolve19(import.meta.dir, "../angular/components/index.ts");
+  if (existsSync16(sourceEntry)) {
     return sourceEntry.replace(/\\/g, "/");
   }
   return "@absolutejs/absolute/angular/components";
@@ -6515,16 +6729,16 @@ ${slot.resolvedBindings.map((binding) => `		"${binding.key}": this.__absoluteDef
   return rewritten.replace(/export(?:\s+default)?\s+class\s+([A-Za-z_$][\w$]*)\s*{/, (match) => `${match}
 ${fields}
 `);
-}, readAndEscapeFile = async (filePath) => {
-  if (!existsSync15(filePath))
+}, readAndEscapeFile = async (filePath, stylePreprocessors) => {
+  if (!existsSync16(filePath))
     return null;
-  const content = await compileStyleFileIfNeeded(filePath);
+  const content = await compileStyleFileIfNeeded(filePath, stylePreprocessors);
   return escapeTemplateContent(content);
 }, inlineTemplateAndLowerDefer = async (source, fileDir) => {
   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");
@@ -6555,10 +6769,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 = readFileSync9(templatePath, "utf-8");
+    const templateRaw2 = readFileSync10(templatePath, "utf-8");
     const lowered2 = lowerAngularDeferSyntax(templateRaw2);
     const escaped2 = escapeTemplateContent(lowered2.template);
     const replacedSource2 = source.replace(/templateUrl\s*:\s*['"][^'"]+['"]/, `template: \`${escaped2}\``);
@@ -6582,7 +6796,7 @@ ${fields}
     deferSlots: lowered.slots,
     source: injectDeferSlotFields(replacedSource, lowered.slots, resolveAngularDeferImportSpecifier())
   };
-}, inlineStyleUrls = async (source, fileDir) => {
+}, inlineStyleUrls = async (source, fileDir, stylePreprocessors) => {
   const styleUrlsMatch = source.match(/styleUrls\s*:\s*\[([^\]]+)\]/);
   if (!styleUrlsMatch?.[1])
     return source;
@@ -6591,35 +6805,35 @@ ${fields}
     return source;
   const stylePromises = urlMatches.map((urlMatch) => {
     const styleUrl = urlMatch.replace(/['"]/g, "");
-    return readAndEscapeFile(join14(fileDir, styleUrl));
+    return readAndEscapeFile(join14(fileDir, styleUrl), stylePreprocessors);
   });
   const results = await Promise.all(stylePromises);
   const inlinedStyles = results.filter(Boolean).map((escaped) => `\`${escaped}\``);
   if (inlinedStyles.length === 0)
     return source;
   return source.replace(/styleUrls\s*:\s*\[[^\]]+\]/, `styles: [${inlinedStyles.join(", ")}]`);
-}, inlineSingleStyleUrl = async (source, fileDir) => {
+}, inlineSingleStyleUrl = async (source, fileDir, stylePreprocessors) => {
   const styleUrlMatch = source.match(/styleUrl\s*:\s*['"]([^'"]+)['"]/);
   if (!styleUrlMatch?.[1])
     return source;
-  const escaped = await readAndEscapeFile(join14(fileDir, styleUrlMatch[1]));
+  const escaped = await readAndEscapeFile(join14(fileDir, styleUrlMatch[1]), stylePreprocessors);
   if (!escaped)
     return source;
   return source.replace(/styleUrl\s*:\s*['"][^'"]+['"]/, `styles: [\`${escaped}\`]`);
-}, inlineResources = async (source, fileDir) => {
+}, inlineResources = async (source, fileDir, stylePreprocessors) => {
   const inlinedTemplate = await inlineTemplateAndLowerDefer(source, fileDir);
   let result = inlinedTemplate.source;
-  result = await inlineStyleUrls(result, fileDir);
-  result = await inlineSingleStyleUrl(result, fileDir);
+  result = await inlineStyleUrls(result, fileDir, stylePreprocessors);
+  result = await inlineSingleStyleUrl(result, fileDir, stylePreprocessors);
   return {
     deferSlots: inlinedTemplate.deferSlots,
     source: result
   };
-}, compileAngularFileJIT = async (inputPath, outDir, rootDir) => {
-  const entryPath = resolve18(inputPath);
+}, compileAngularFileJIT = async (inputPath, outDir, rootDir, stylePreprocessors) => {
+  const entryPath = resolve19(inputPath);
   const allOutputs = [];
   const visited = new Set;
-  const baseDir = resolve18(rootDir ?? process.cwd());
+  const baseDir = resolve19(rootDir ?? process.cwd());
   const angularTranspiler = new Bun.Transpiler({
     loader: "ts",
     tsconfig: JSON.stringify({
@@ -6656,23 +6870,23 @@ ${fields}
         return `${prefix}${dots}`;
       return `${prefix}../${dots}`;
     });
-    if (resolve18(actualPath) === entryPath) {
+    if (resolve19(actualPath) === entryPath) {
       processedContent += buildIslandMetadataExports(sourceCode);
     }
     return processedContent;
   };
   const transpileFile = async (filePath) => {
-    const resolved = resolve18(filePath);
+    const resolved = resolve19(filePath);
     if (visited.has(resolved))
       return;
     visited.add(resolved);
     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, dirname10(actualPath));
+    const inlined = await inlineResources(sourceCode, dirname10(actualPath), stylePreprocessors);
     sourceCode = inlineTemplateAndLowerDeferSync(inlined.source, dirname10(actualPath)).source;
     const inputDir = dirname10(actualPath);
     const relativeDir = inputDir.startsWith(baseDir) ? inputDir.substring(baseDir.length + 1) : inputDir;
@@ -6693,7 +6907,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);
@@ -6704,13 +6918,13 @@ ${fields}
     }
     const inputDirForResolve = dirname10(actualPath);
     await Promise.all(localImports.map((imp) => {
-      const importPath = resolve18(inputDirForResolve, imp);
+      const importPath = resolve19(inputDirForResolve, imp);
       return transpileFile(importPath);
     }));
   };
   await transpileFile(inputPath);
   return allOutputs;
-}, compileAngular = async (entryPoints, outRoot, hmr = false) => {
+}, compileAngular = async (entryPoints, outRoot, hmr = false, stylePreprocessors) => {
   const compiledParent = join14(outRoot, "generated");
   if (entryPoints.length === 0) {
     const emptyPaths = [];
@@ -6720,9 +6934,9 @@ ${fields}
   const indexesDir = join14(compiledParent, "indexes");
   await fs.mkdir(indexesDir, { recursive: true });
   const compileTasks = entryPoints.map(async (entry) => {
-    const resolvedEntry = resolve18(entry);
-    const relativeEntry = relative8(outRoot, resolvedEntry).replace(/\.[tj]s$/, ".js");
-    const compileEntry = () => hmr ? compileAngularFileJIT(resolvedEntry, compiledRoot, outRoot) : compileAngularFile(resolvedEntry, compiledRoot);
+    const resolvedEntry = resolve19(entry);
+    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 = basename7(resolvedEntry).replace(/\.[tj]s$/, "");
     const jsName = `${fileBase}.js`;
@@ -6730,18 +6944,18 @@ ${fields}
       join14(compiledRoot, relativeEntry),
       join14(compiledRoot, "pages", jsName),
       join14(compiledRoot, jsName)
-    ].map((file4) => resolve18(file4));
+    ].map((file4) => resolve19(file4));
     const resolveRawServerFile = (candidatePaths) => {
       const normalizedCandidates = [
-        ...candidatePaths.map((file4) => resolve18(file4)),
+        ...candidatePaths.map((file4) => resolve19(file4)),
         ...compiledFallbackPaths
       ];
-      let candidate = normalizedCandidates.find((file4) => existsSync15(file4) && file4.endsWith(`${sep3}pages${sep3}${jsName}`));
+      let candidate = normalizedCandidates.find((file4) => existsSync16(file4) && file4.endsWith(`${sep3}pages${sep3}${jsName}`));
       if (!candidate) {
-        candidate = normalizedCandidates.find((file4) => existsSync15(file4) && file4.endsWith(`${sep3}${jsName}`));
+        candidate = normalizedCandidates.find((file4) => existsSync16(file4) && file4.endsWith(`${sep3}${jsName}`));
       }
       if (!candidate) {
-        candidate = normalizedCandidates.find((file4) => existsSync15(file4));
+        candidate = normalizedCandidates.find((file4) => existsSync16(file4));
       }
       return candidate;
     };
@@ -6749,11 +6963,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
@@ -6764,7 +6978,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,
@@ -6798,7 +7012,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}";
@@ -6963,25 +7177,25 @@ __export(exports_buildReactVendor, {
   computeVendorPaths: () => computeVendorPaths,
   buildReactVendor: () => buildReactVendor
 });
-import { existsSync as existsSync16, mkdirSync as mkdirSync6 } from "fs";
-import { join as join15, resolve as resolve19 } from "path";
+import { existsSync as existsSync17, mkdirSync as mkdirSync6 } from "fs";
+import { join as join15, resolve as resolve20 } from "path";
 import { rm as rm4 } from "fs/promises";
 var {build: bunBuild2 } = globalThis.Bun;
 var resolveJsxDevRuntimeCompatPath = () => {
   const candidates = [
-    resolve19(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
-    resolve19(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve19(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
-    resolve19(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
-    resolve19(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
-    resolve19(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
+    resolve20(import.meta.dir, "react", "jsxDevRuntimeCompat.js"),
+    resolve20(import.meta.dir, "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve20(import.meta.dir, "..", "react", "jsxDevRuntimeCompat.js"),
+    resolve20(import.meta.dir, "..", "src", "react", "jsxDevRuntimeCompat.ts"),
+    resolve20(import.meta.dir, "..", "..", "dist", "react", "jsxDevRuntimeCompat.js"),
+    resolve20(import.meta.dir, "..", "..", "src", "react", "jsxDevRuntimeCompat.ts")
   ];
   for (const candidate of candidates) {
-    if (existsSync16(candidate)) {
+    if (existsSync17(candidate)) {
       return candidate.replace(/\\/g, "/");
     }
   }
-  return (candidates[0] ?? resolve19(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
+  return (candidates[0] ?? resolve20(import.meta.dir, "react", "jsxDevRuntimeCompat.js")).replace(/\\/g, "/");
 }, jsxDevRuntimeCompatPath, reactSpecifiers, isResolvable = (specifier) => {
   try {
     Bun.resolveSync(specifier, process.cwd());
@@ -7153,11 +7367,11 @@ var vueSpecifiers, toSafeFileName3 = (specifier) => specifier.replace(/\//g, "_"
     console.warn("\u26A0\uFE0F Vue vendor build had errors:", result.logs);
     return;
   }
-  const { readFileSync: readFileSync10, writeFileSync: writeFileSync7, readdirSync } = await import("fs");
+  const { readFileSync: readFileSync11, writeFileSync: writeFileSync7, readdirSync } = await import("fs");
   const files = readdirSync(vendorDir).filter((f) => f.endsWith(".js"));
   for (const file4 of files) {
     const filePath = join17(vendorDir, file4);
-    const content = readFileSync10(filePath, "utf-8");
+    const content = readFileSync11(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__ || {");
@@ -7280,14 +7494,14 @@ var init_rewriteImports = __esm(() => {
 import {
   copyFileSync,
   cpSync,
-  existsSync as existsSync17,
+  existsSync as existsSync18,
   mkdirSync as mkdirSync10,
-  readFileSync as readFileSync10,
+  readFileSync as readFileSync11,
   rmSync as rmSync2,
   statSync,
   writeFileSync as writeFileSync7
 } from "fs";
-import { basename as basename8, dirname as dirname11, join as join19, relative as relative9, resolve as resolve20 } from "path";
+import { basename as basename8, dirname as dirname11, join as join19, relative as relative10, resolve as resolve21 } from "path";
 import { cwd, env as env3, exit } from "process";
 var {build: bunBuild6, Glob: Glob6 } = globalThis.Bun;
 var isDev2, collectConventionSourceFiles = (entry) => {
@@ -7375,8 +7589,8 @@ var isDev2, collectConventionSourceFiles = (entry) => {
   }
 }, resolveAbsoluteVersion = async () => {
   const candidates = [
-    resolve20(import.meta.dir, "..", "..", "package.json"),
-    resolve20(import.meta.dir, "..", "package.json")
+    resolve21(import.meta.dir, "..", "..", "package.json"),
+    resolve21(import.meta.dir, "..", "package.json")
   ];
   for (const candidate of candidates) {
     const pkg = await tryReadPackageJson(candidate);
@@ -7388,7 +7602,7 @@ var isDev2, collectConventionSourceFiles = (entry) => {
     return;
   }
 }, SKIP_DIRS, addWorkerPathIfExists = (file4, relPath, workerPaths) => {
-  const absPath = resolve20(file4, "..", relPath);
+  const absPath = resolve21(file4, "..", relPath);
   try {
     statSync(absPath);
     workerPaths.add(absPath);
@@ -7403,7 +7617,7 @@ var isDev2, collectConventionSourceFiles = (entry) => {
     addWorkerPathIfExists(file4, relPath, workerPaths);
   }
 }, collectWorkerPathsFromFile = (file4, patterns, workerPaths) => {
-  const content = readFileSync10(file4, "utf-8");
+  const content = readFileSync11(file4, "utf-8");
   for (const pattern of patterns) {
     collectWorkerPathsFromContent(content, pattern, file4, workerPaths);
   }
@@ -7448,39 +7662,39 @@ var isDev2, collectConventionSourceFiles = (entry) => {
     copyVueDevIndexes(vueDir, vuePagesPath, vueEntries, devIndexDir);
   }
 }, copyReactDevIndexes = (reactIndexesPath, reactPagesPath, devIndexDir, readDir) => {
-  if (!existsSync17(reactIndexesPath)) {
+  if (!existsSync18(reactIndexesPath)) {
     return;
   }
   const indexFiles = readDir(reactIndexesPath).filter((file4) => file4.endsWith(".tsx"));
-  const pagesRel = relative9(process.cwd(), resolve20(reactPagesPath)).replace(/\\/g, "/");
+  const pagesRel = relative10(process.cwd(), resolve21(reactPagesPath)).replace(/\\/g, "/");
   for (const file4 of indexFiles) {
-    let content = readFileSync10(join19(reactIndexesPath, file4), "utf-8");
+    let content = readFileSync11(join19(reactIndexesPath, file4), "utf-8");
     content = content.replace(/from\s*['"]([^'"]*\/pages\/([^'"]+))['"]/g, (_match, _fullPath, componentName) => `from '/@src/${pagesRel}/${componentName}'`);
     writeFileSync7(join19(devIndexDir, file4), content);
   }
 }, copySvelteDevIndexes = (svelteDir, sveltePagesPath, svelteEntries, devIndexDir) => {
   const svelteIndexDir = join19(svelteDir, "generated", "indexes");
-  const sveltePageEntries = svelteEntries.filter((file4) => resolve20(file4).startsWith(resolve20(sveltePagesPath)));
+  const sveltePageEntries = svelteEntries.filter((file4) => resolve21(file4).startsWith(resolve21(sveltePagesPath)));
   for (const entry of sveltePageEntries) {
     const name = basename8(entry).replace(/\.svelte(\.(ts|js))?$/, "");
     const indexFile = join19(svelteIndexDir, "pages", `${name}.js`);
-    if (!existsSync17(indexFile))
+    if (!existsSync18(indexFile))
       continue;
-    let content = readFileSync10(indexFile, "utf-8");
-    const srcRel = relative9(process.cwd(), resolve20(entry)).replace(/\\/g, "/");
+    let content = readFileSync11(indexFile, "utf-8");
+    const srcRel = relative10(process.cwd(), resolve21(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Component\s+from\s+['"]([^'"]+)['"]/, `import Component from "/@src/${srcRel}"`);
     writeFileSync7(join19(devIndexDir, `${name}.svelte.js`), content);
   }
 }, copyVueDevIndexes = (vueDir, vuePagesPath, vueEntries, devIndexDir) => {
   const vueIndexDir = join19(vueDir, "generated", "indexes");
-  const vuePageEntries = vueEntries.filter((file4) => resolve20(file4).startsWith(resolve20(vuePagesPath)));
+  const vuePageEntries = vueEntries.filter((file4) => resolve21(file4).startsWith(resolve21(vuePagesPath)));
   for (const entry of vuePageEntries) {
     const name = basename8(entry, ".vue");
     const indexFile = join19(vueIndexDir, `${name}.js`);
-    if (!existsSync17(indexFile))
+    if (!existsSync18(indexFile))
       continue;
-    let content = readFileSync10(indexFile, "utf-8");
-    const srcRel = relative9(process.cwd(), resolve20(entry)).replace(/\\/g, "/");
+    let content = readFileSync11(indexFile, "utf-8");
+    const srcRel = relative10(process.cwd(), resolve21(entry)).replace(/\\/g, "/");
     content = content.replace(/import\s+Comp\s+from\s+['"]([^'"]+)['"]/, `import Comp from "/@src/${srcRel}"`);
     writeFileSync7(join19(devIndexDir, `${name}.vue.js`), content);
   }
@@ -7493,7 +7707,7 @@ var isDev2, collectConventionSourceFiles = (entry) => {
   const last = allComments[allComments.length - 1];
   if (!last?.[1])
     return JSON.stringify(outputPath);
-  const srcPath = resolve20(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
+  const srcPath = resolve21(projectRoot, last[1].replace("/client/", "/").replace(/\.js$/, ".ts"));
   return JSON.stringify(srcPath);
 }, QUOTE_CHARS, OPEN_BRACES, CLOSE_BRACES, findFunctionExpressionEnd = (content, startPos) => {
   let depth = 0;
@@ -7530,7 +7744,7 @@ var isDev2, collectConventionSourceFiles = (entry) => {
   }
   return result;
 }, VUE_HMR_RUNTIME, injectVueComposableTracking = (outputPath, projectRoot) => {
-  let content = readFileSync10(outputPath, "utf-8");
+  let content = readFileSync11(outputPath, "utf-8");
   const usePattern = /^var\s+(use[A-Z]\w*)\s*=/gm;
   const useNames = [];
   let match;
@@ -7555,7 +7769,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 = basename8(srcPath);
     const mtime = Math.round(statSync(srcPath).mtimeMs);
     const url = `/@src/${rel}?v=${mtime}`;
@@ -7570,7 +7784,7 @@ ${content.slice(firstUseIdx)}`;
     const output = nonReactClientOutputs.find((artifact) => basename8(artifact.path).startsWith(`${srcBase}.`));
     if (!output)
       continue;
-    urlFileMap.set(basename8(srcPath), `/${relative9(buildPath, output.path).replace(/\\/g, "/")}`);
+    urlFileMap.set(basename8(srcPath), `/${relative10(buildPath, output.path).replace(/\\/g, "/")}`);
   }
   return urlFileMap;
 }, buildUrlFileMap = (urlReferencedFiles, hmr, projectRoot, buildPath, nonReactClientOutputs) => {
@@ -7580,7 +7794,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 = readFileSync10(outputPath, "utf-8");
+    let content = readFileSync11(outputPath, "utf-8");
     let changed = false;
     content = content.replace(urlPattern, (_match, relPath) => {
       const targetName = basename8(relPath);
@@ -7605,6 +7819,7 @@ ${content.slice(firstUseIdx)}`;
   svelteDirectory,
   vueDirectory,
   stylesConfig,
+  stylePreprocessors,
   tailwind,
   options,
   incrementalFiles,
@@ -7614,6 +7829,7 @@ ${content.slice(firstUseIdx)}`;
   const projectRoot = cwd();
   await resolveAbsoluteVersion();
   const isIncremental = incrementalFiles && incrementalFiles.length > 0;
+  const stylePreprocessorPlugin2 = createStylePreprocessorPlugin(stylePreprocessors);
   const normalizedIncrementalFiles = incrementalFiles?.map(normalizePath);
   const throwOnError = options?.throwOnError === true;
   const hmr = options?.injectHMR === true;
@@ -7702,13 +7918,13 @@ ${content.slice(firstUseIdx)}`;
   const filterToIncrementalEntries = (entryPoints, mapToSource) => {
     if (!isIncremental || !incrementalFiles)
       return entryPoints;
-    const normalizedIncremental = new Set(incrementalFiles.map((f) => resolve20(f)));
+    const normalizedIncremental = new Set(incrementalFiles.map((f) => resolve21(f)));
     const matchingEntries = [];
     for (const entry of entryPoints) {
       const sourceFile = mapToSource(entry);
       if (!sourceFile)
         continue;
-      if (!normalizedIncremental.has(resolve20(sourceFile)))
+      if (!normalizedIncremental.has(resolve21(sourceFile)))
         continue;
       matchingEntries.push(entry);
     }
@@ -7777,7 +7993,7 @@ ${content.slice(firstUseIdx)}`;
   }
   const shouldIncludeHtmlAssets = !isIncremental || normalizedIncrementalFiles?.some((f) => f.includes("/html/") && (f.endsWith(".html") || isStylePath(f)));
   const reactEntries = isIncremental && reactIndexesPath && reactPagesPath ? filterToIncrementalEntries(allReactEntries, (entry) => {
-    if (entry.startsWith(resolve20(reactIndexesPath))) {
+    if (entry.startsWith(resolve21(reactIndexesPath))) {
       const pageName = basename8(entry, ".tsx");
       return join19(reactPagesPath, `${pageName}.tsx`);
     }
@@ -7809,28 +8025,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)) : {
+    shouldCompileSvelte ? Promise.resolve().then(() => (init_compileSvelte(), exports_compileSvelte)).then((mod) => mod.compileSvelte(svelteEntries, svelteDir, new Map, hmr, stylePreprocessors)) : {
       svelteClientPaths: [...emptyStringArray],
       svelteIndexPaths: [...emptyStringArray],
       svelteServerPaths: [...emptyStringArray]
     },
-    shouldCompileVue ? Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(vueEntries, vueDir, hmr)) : {
+    shouldCompileVue ? Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(vueEntries, vueDir, hmr, stylePreprocessors)) : {
       vueClientPaths: [...emptyStringArray],
       vueCssPaths: [...emptyStringArray],
       vueIndexPaths: [...emptyStringArray],
       vueServerPaths: [...emptyStringArray]
     },
-    shouldCompileAngular ? Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(angularEntries, angularDir, hmr)) : {
+    shouldCompileAngular ? Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(angularEntries, angularDir, hmr, stylePreprocessors)) : {
       clientPaths: [...emptyStringArray],
       serverPaths: [...emptyStringArray]
     },
-    shouldCompileIslandSvelte ? Promise.resolve().then(() => (init_compileSvelte(), exports_compileSvelte)).then((mod) => mod.compileSvelte(islandSvelteSources, svelteDir, new Map, hmr)) : {
+    shouldCompileIslandSvelte ? Promise.resolve().then(() => (init_compileSvelte(), exports_compileSvelte)).then((mod) => mod.compileSvelte(islandSvelteSources, svelteDir, new Map, hmr, stylePreprocessors)) : {
       svelteClientPaths: [...emptyStringArray]
     },
-    shouldCompileIslandVue ? Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(islandVueSources, vueDir, hmr)) : {
+    shouldCompileIslandVue ? Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(islandVueSources, vueDir, hmr, stylePreprocessors)) : {
       vueClientPaths: [...emptyStringArray]
     },
-    shouldCompileIslandAngular ? Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(islandAngularSources, angularDir, hmr)) : {
+    shouldCompileIslandAngular ? Promise.resolve().then(() => (init_compileAngular(), exports_compileAngular)).then((mod) => mod.compileAngular(islandAngularSources, angularDir, hmr, stylePreprocessors)) : {
       clientPaths: [...emptyStringArray]
     }
   ]);
@@ -7840,7 +8056,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandSvelteClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandSvelteClientPathMap.set(resolve20(sourcePath), clientPath);
+    islandSvelteClientPathMap.set(resolve21(sourcePath), clientPath);
   }
   const islandVueClientPathMap = new Map;
   for (let idx = 0;idx < islandVueSources.length; idx++) {
@@ -7848,7 +8064,7 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandVueClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandVueClientPathMap.set(resolve20(sourcePath), clientPath);
+    islandVueClientPathMap.set(resolve21(sourcePath), clientPath);
   }
   const islandAngularClientPathMap = new Map;
   for (let idx = 0;idx < islandAngularSources.length; idx++) {
@@ -7856,14 +8072,14 @@ ${content.slice(firstUseIdx)}`;
     const clientPath = islandAngularClientPaths[idx];
     if (!sourcePath || !clientPath)
       continue;
-    islandAngularClientPathMap.set(resolve20(sourcePath), clientPath);
+    islandAngularClientPathMap.set(resolve21(sourcePath), clientPath);
   }
   const svelteConventionSources = collectConventionSourceFiles(conventionsMap.svelte);
   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)) : { svelteServerPaths: emptyStringArray },
-      vueConventionSources.length > 0 && vueDir ? Promise.resolve().then(() => (init_compileVue(), exports_compileVue)).then((mod) => mod.compileVue(vueConventionSources, vueDir, false)) : { vueServerPaths: emptyStringArray }
+      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 }
     ]);
     const copyConventionFiles = (framework, sources, compiledPaths) => {
       const destDir = join19(buildPath, "conventions", framework);
@@ -7999,7 +8215,7 @@ ${content.slice(firstUseIdx)}`;
     naming: `[dir]/[name].[hash].[ext]`,
     outdir: buildPath,
     ...hmr ? { jsx: { development: true }, reactFastRefresh: true } : {},
-    plugins: [stylePreprocessorPlugin],
+    plugins: [stylePreprocessorPlugin2],
     root: clientRoot,
     splitting: true,
     target: "browser",
@@ -8057,7 +8273,7 @@ ${content.slice(firstUseIdx)}`;
       format: "esm",
       naming: `[dir]/[name].[hash].[ext]`,
       outdir: serverOutDir,
-      plugins: [stylePreprocessorPlugin],
+      plugins: [stylePreprocessorPlugin2],
       root: serverRoot,
       target: "bun",
       throw: false,
@@ -8073,7 +8289,7 @@ ${content.slice(firstUseIdx)}`;
       naming: `[dir]/[name].[hash].[ext]`,
       outdir: buildPath,
       plugins: [
-        stylePreprocessorPlugin,
+        stylePreprocessorPlugin2,
         ...angularDir && !isDev2 ? [angularLinkerPlugin] : [],
         ...htmlScriptPlugin ? [htmlScriptPlugin] : []
       ],
@@ -8092,7 +8308,7 @@ ${content.slice(firstUseIdx)}`;
       naming: `[dir]/[name].[hash].[ext]`,
       outdir: buildPath,
       plugins: [
-        stylePreprocessorPlugin,
+        stylePreprocessorPlugin2,
         ...angularDir && !isDev2 ? [angularLinkerPlugin] : []
       ],
       root: islandEntryResult.generatedRoot,
@@ -8107,7 +8323,7 @@ ${content.slice(firstUseIdx)}`;
       outdir: stylesDir ? join19(buildPath, basename8(stylesDir)) : buildPath,
       root: stylesDir || clientRoot,
       target: "browser",
-      plugins: [stylePreprocessorPlugin],
+      plugins: [stylePreprocessorPlugin2],
       throw: false
     }) : undefined,
     vueCssPaths.length > 0 ? bunBuild6({
@@ -8235,7 +8451,7 @@ ${content.slice(firstUseIdx)}`;
   const injectHMRIntoHTMLFile = (filePath, framework) => {
     if (!hmrClientBundle)
       return;
-    let html = readFileSync10(filePath, "utf-8");
+    let html = readFileSync11(filePath, "utf-8");
     if (html.includes("data-hmr-client"))
       return;
     const tag = `<script>window.__HMR_FRAMEWORK__="${framework}";</script><script data-hmr-client>${hmrClientBundle}</script>`;
@@ -8396,9 +8612,9 @@ var init_build = __esm(() => {
 });
 
 // src/dev/dependencyGraph.ts
-import { existsSync as existsSync18, readFileSync as readFileSync11 } from "fs";
+import { existsSync as existsSync19, readFileSync as readFileSync12 } from "fs";
 var {Glob: Glob7 } = globalThis.Bun;
-import { resolve as resolve21 } from "path";
+import { resolve as resolve22 } from "path";
 var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath) => {
   const lower = filePath.toLowerCase();
   if (lower.endsWith(".ts") || lower.endsWith(".tsx") || lower.endsWith(".jsx"))
@@ -8408,12 +8624,12 @@ 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;
   }
-  const fromDir = resolve21(fromFile, "..");
-  const normalized = resolve21(fromDir, importPath);
+  const fromDir = resolve22(fromFile, "..");
+  const normalized = resolve22(fromDir, importPath);
   const extensions = [
     ".ts",
     ".tsx",
@@ -8426,10 +8642,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) => {
@@ -8443,8 +8659,8 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     dependents.delete(normalizedPath);
   }
 }, addFileToGraph = (graph, filePath) => {
-  const normalizedPath = resolve21(filePath);
-  if (!existsSync18(normalizedPath))
+  const normalizedPath = resolve22(filePath);
+  if (!existsSync19(normalizedPath))
     return;
   const dependencies = extractDependencies(normalizedPath);
   clearExistingDependents(graph, normalizedPath);
@@ -8460,10 +8676,10 @@ 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) => resolve21(dir)).filter((dir) => existsSync18(dir));
+  const resolvedDirs = directories.map((dir) => resolve22(dir)).filter((dir) => existsSync19(dir));
   const allFiles = resolvedDirs.flatMap((dir) => Array.from(glob.scanSync({ absolute: true, cwd: dir })));
   for (const file4 of allFiles) {
-    const fullPath = resolve21(file4);
+    const fullPath = resolve22(file4);
     if (IGNORED_SEGMENTS.some((seg) => fullPath.includes(seg)))
       continue;
     if (processedFiles.has(fullPath))
@@ -8479,7 +8695,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);
   }
@@ -8489,7 +8705,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);
   }
@@ -8499,7 +8715,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);
   }
@@ -8522,7 +8738,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);
   }
@@ -8532,7 +8748,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);
   }
@@ -8557,15 +8773,15 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   const lowerPath = filePath.toLowerCase();
   const isSvelteOrVue = lowerPath.endsWith(".svelte") || lowerPath.endsWith(".vue");
   if (loader === "html") {
-    const content = readFileSync11(filePath, "utf-8");
+    const content = readFileSync12(filePath, "utf-8");
     return extractHtmlDependencies(filePath, content);
   }
   if (loader === "tsx" || loader === "js") {
-    const content = readFileSync11(filePath, "utf-8");
+    const content = readFileSync12(filePath, "utf-8");
     return extractJsDependencies(filePath, content, loader);
   }
   if (isSvelteOrVue) {
-    const content = readFileSync11(filePath, "utf-8");
+    const content = readFileSync12(filePath, "utf-8");
     return extractSvelteVueDependencies(filePath, content);
   }
   return [];
@@ -8576,7 +8792,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
     return [];
   }
 }, getAffectedFiles = (graph, changedFile) => {
-  const normalizedPath = resolve21(changedFile);
+  const normalizedPath = resolve22(changedFile);
   const affected = new Set;
   const toProcess = [normalizedPath];
   const processNode = (current) => {
@@ -8616,7 +8832,7 @@ var emptyDependencyGraph, tsTranspiler, jsTranspiler, loaderForFile = (filePath)
   }
   graph.dependents.delete(normalizedPath);
 }, removeFileFromGraph = (graph, filePath) => {
-  const normalizedPath = resolve21(filePath);
+  const normalizedPath = resolve22(filePath);
   removeDepsForFile(graph, normalizedPath);
   removeDependentsForFile(graph, normalizedPath);
 };
@@ -8659,12 +8875,12 @@ var globalVersionCounter = 0, createModuleVersionTracker = () => new Map, getNex
 };
 
 // src/dev/configResolver.ts
-import { resolve as resolve22 } from "path";
+import { resolve as resolve23 } from "path";
 var resolveBuildPaths = (config) => {
   const cwd2 = process.cwd();
   const normalize = (path) => path.replace(/\\/g, "/");
-  const withDefault = (value, fallback) => normalize(resolve22(cwd2, value ?? fallback));
-  const optional = (value) => value ? normalize(resolve22(cwd2, value)) : undefined;
+  const withDefault = (value, fallback) => normalize(resolve23(cwd2, value ?? fallback));
+  const optional = (value) => value ? normalize(resolve23(cwd2, value)) : undefined;
   return {
     angularDir: optional(config.angularDirectory),
     assetsDir: optional(config.assetsDirectory),
@@ -8848,13 +9064,13 @@ 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 { join as join20, resolve as resolve23 } from "path";
+import { existsSync as existsSync20 } from "fs";
+import { join as join20, resolve as resolve24 } from "path";
 var safeRemoveFromGraph = (graph, fullPath) => {
   try {
     removeFileFromGraph(graph, fullPath);
@@ -8885,12 +9101,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);
     }
@@ -8899,8 +9115,8 @@ var safeRemoveFromGraph = (graph, fullPath) => {
 }, addFileWatchers = (state, paths, onFileChange) => {
   const stylesDir = state.resolvedPaths?.stylesDir;
   paths.forEach((path) => {
-    const absolutePath = resolve23(path).replace(/\\/g, "/");
-    if (!existsSync19(absolutePath)) {
+    const absolutePath = resolve24(path).replace(/\\/g, "/");
+    if (!existsSync20(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -8910,8 +9126,8 @@ var safeRemoveFromGraph = (graph, fullPath) => {
   const watchPaths = getWatchPaths(config, state.resolvedPaths);
   const stylesDir = state.resolvedPaths?.stylesDir;
   watchPaths.forEach((path) => {
-    const absolutePath = resolve23(path).replace(/\\/g, "/");
-    if (!existsSync19(absolutePath)) {
+    const absolutePath = resolve24(path).replace(/\\/g, "/");
+    if (!existsSync20(absolutePath)) {
       return;
     }
     const isStylesDir = Boolean(stylesDir && absolutePath.startsWith(stylesDir));
@@ -8925,13 +9141,13 @@ var init_fileWatcher = __esm(() => {
 });
 
 // src/dev/assetStore.ts
-import { resolve as resolve24 } from "path";
+import { resolve as resolve25 } from "path";
 import { readdir as readdir3, unlink } from "fs/promises";
 var mimeTypes, getMimeType = (filePath) => {
   const ext = filePath.slice(filePath.lastIndexOf("."));
   return mimeTypes[ext] ?? "application/octet-stream";
 }, HASHED_FILE_RE, stripHash = (webPath) => webPath.replace(/\.[a-z0-9]{8}(\.(js|css|mjs))$/, "$1"), processWalkEntry = (entry, dir, liveByIdentity, walkAndClean) => {
-  const fullPath = resolve24(dir, entry.name);
+  const fullPath = resolve25(dir, entry.name);
   if (entry.isDirectory()) {
     return walkAndClean(fullPath);
   }
@@ -8947,10 +9163,10 @@ var mimeTypes, getMimeType = (filePath) => {
 }, cleanStaleAssets = async (store, manifest, buildDir) => {
   const liveByIdentity = new Map;
   for (const webPath of store.keys()) {
-    const diskPath = resolve24(buildDir, webPath.slice(1));
+    const diskPath = resolve25(buildDir, webPath.slice(1));
     liveByIdentity.set(stripHash(diskPath), diskPath);
   }
-  const absBuildDir = resolve24(buildDir);
+  const absBuildDir = resolve25(buildDir);
   Object.values(manifest).forEach((val) => {
     if (!HASHED_FILE_RE.test(val))
       return;
@@ -8968,7 +9184,7 @@ var mimeTypes, getMimeType = (filePath) => {
   } catch {}
 }, lookupAsset = (store, path) => store.get(path), processScanEntry = (entry, dir, prefix, store, scanDir) => {
   if (entry.isDirectory()) {
-    return scanDir(resolve24(dir, entry.name), `${prefix}${entry.name}/`);
+    return scanDir(resolve25(dir, entry.name), `${prefix}${entry.name}/`);
   }
   if (!entry.name.startsWith("chunk-")) {
     return null;
@@ -8977,7 +9193,7 @@ var mimeTypes, getMimeType = (filePath) => {
   if (store.has(webPath)) {
     return null;
   }
-  return Bun.file(resolve24(dir, entry.name)).bytes().then((bytes) => {
+  return Bun.file(resolve25(dir, entry.name)).bytes().then((bytes) => {
     store.set(webPath, bytes);
     return;
   }).catch(() => {});
@@ -9002,7 +9218,7 @@ var mimeTypes, getMimeType = (filePath) => {
   for (const webPath of newIdentities.values()) {
     if (store.has(webPath))
       continue;
-    loadPromises.push(Bun.file(resolve24(buildDir, webPath.slice(1))).bytes().then((bytes) => {
+    loadPromises.push(Bun.file(resolve25(buildDir, webPath.slice(1))).bytes().then((bytes) => {
       store.set(webPath, bytes);
       return;
     }).catch(() => {}));
@@ -9032,10 +9248,10 @@ var init_assetStore = __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;
@@ -9053,9 +9269,9 @@ var init_fileHashTracker = __esm(() => {
 });
 
 // src/dev/reactComponentClassifier.ts
-import { resolve as resolve25 } from "path";
+import { resolve as resolve26 } from "path";
 var classifyComponent = (filePath) => {
-  const normalizedPath = resolve25(filePath);
+  const normalizedPath = resolve26(filePath);
   if (normalizedPath.includes("/react/pages/")) {
     return "server";
   }
@@ -9067,7 +9283,7 @@ var classifyComponent = (filePath) => {
 var init_reactComponentClassifier = () => {};
 
 // src/dev/moduleMapper.ts
-import { basename as basename9, resolve as resolve26 } from "path";
+import { basename as basename9, resolve as resolve27 } from "path";
 var buildModulePaths = (moduleKeys, manifest) => {
   const modulePaths = {};
   moduleKeys.forEach((key) => {
@@ -9077,7 +9293,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return modulePaths;
 }, processChangedFile = (sourceFile, framework, manifest, resolvedPaths, processedFiles) => {
-  const normalizedFile = resolve26(sourceFile);
+  const normalizedFile = resolve27(sourceFile);
   const normalizedPath = normalizedFile.replace(/\\/g, "/");
   if (processedFiles.has(normalizedFile)) {
     return null;
@@ -9113,7 +9329,7 @@ var buildModulePaths = (moduleKeys, manifest) => {
   });
   return grouped;
 }, mapSourceFileToManifestKeys = (sourceFile, framework, resolvedPaths) => {
-  const normalizedFile = resolve26(sourceFile);
+  const normalizedFile = resolve27(sourceFile);
   const fileName = basename9(normalizedFile);
   const baseName = fileName.replace(/\.(tsx?|jsx?|vue|svelte|css|html)$/, "");
   const pascalName = toPascal(baseName);
@@ -9396,19 +9612,19 @@ var escapeHtml = (str) => String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;
 import { AsyncLocalStorage as AsyncLocalStorage3 } from "async_hooks";
 import { mkdir as mkdir4, symlink } from "fs/promises";
 import { tmpdir } from "os";
-import { basename as basename10, dirname as dirname12, join as join21, resolve as resolve27 } from "path";
+import { basename as basename10, dirname as dirname12, join as join21, resolve as resolve28 } from "path";
 var ssrDirty2 = false, lastSelector = "angular-page", isRecord8 = (value) => typeof value === "object" && value !== null, isAngularComponent = (value) => typeof value === "function", compilerImportPromise = null, ensureAngularCompiler = () => {
   if (!compilerImportPromise) {
     compilerImportPromise = import("@angular/compiler");
   }
   return compilerImportPromise;
 }, readAngularPageModule = (value) => isRecord8(value) ? value : null, resolveAngularSsrOutDir = () => process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR ?? join21(tmpdir(), "absolutejs", "generated", "angular-ssr"), ensureAngularSsrNodeModules = async (outDir) => {
-  const outRoot = resolve27(dirname12(dirname12(outDir)));
+  const outRoot = resolve28(dirname12(dirname12(outDir)));
   const nodeModulesLink = join21(outRoot, "node_modules");
   if (process.env.ABSOLUTE_ANGULAR_SSR_OUTDIR) {
     return;
   }
-  if (nodeModulesLink === resolve27(process.cwd(), "node_modules")) {
+  if (nodeModulesLink === resolve28(process.cwd(), "node_modules")) {
     return;
   }
   if (await Bun.file(nodeModulesLink).exists()) {
@@ -9416,7 +9632,7 @@ var ssrDirty2 = false, lastSelector = "angular-page", isRecord8 = (value) => typ
   }
   await mkdir4(outRoot, { recursive: true });
   try {
-    await symlink(resolve27(process.cwd(), "node_modules"), nodeModulesLink, "dir");
+    await symlink(resolve28(process.cwd(), "node_modules"), nodeModulesLink, "dir");
   } catch (error) {
     if (!(error instanceof Error) || !("code" in error) || error.code !== "EEXIST") {
       throw error;
@@ -9859,8 +10075,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 resolve28, 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 resolve29, 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 = [];
@@ -9880,7 +10096,7 @@ var SRC_PREFIX = "/@src/", jsTranspiler2, tsTranspiler2, tsxTranspiler, TRANSPIL
 ${stubs}
 `;
 }, resolveRelativeExtension = (srcPath, projectRoot, extensions) => {
-  const found = extensions.find((ext) => existsSync20(resolve28(projectRoot, srcPath + ext)));
+  const found = extensions.find((ext) => existsSync21(resolve29(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);
@@ -9895,7 +10111,7 @@ ${stubs}
   return invalidationVersion > 0 ? `${mtime}.${invalidationVersion}` : `${mtime}`;
 }, srcUrl = (relPath, projectRoot) => {
   const base = `${SRC_PREFIX}${relPath.replace(/\\/g, "/")}`;
-  const absPath = resolve28(projectRoot, relPath);
+  const absPath = resolve29(projectRoot, relPath);
   const cached = mtimeCache.get(absPath);
   if (cached !== undefined)
     return `${base}?v=${buildVersion(cached, absPath)}`;
@@ -9907,18 +10123,18 @@ ${stubs}
     return base;
   }
 }, resolveRelativeImport = (relPath, fileDir, projectRoot, extensions) => {
-  const absPath = resolve28(fileDir, relPath);
-  const rel = relative10(projectRoot, absPath);
+  const absPath = resolve29(fileDir, relPath);
+  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(resolve28(projectRoot, srcPath)));
+    srcPath = relative11(projectRoot, resolveSvelteModulePath(resolve29(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;
   }
@@ -9951,20 +10167,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 = resolve28(fileDir, relPath);
-    const rel = relative10(projectRoot, absPath);
+    const absPath = resolve29(fileDir, relPath);
+    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 = resolve28(fileDir, relPath);
-    const rel = relative10(projectRoot, absPath);
+    const absPath = resolve29(fileDir, relPath);
+    const rel = relative11(projectRoot, absPath);
     return `'${srcUrl(rel, projectRoot)}'`;
   });
   return result;
@@ -9992,7 +10208,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);
@@ -10003,12 +10219,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";
@@ -10154,24 +10370,24 @@ ${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) => {
-  const raw = readFileSync13(filePath, "utf-8");
+}, transformSvelteFile = async (filePath, projectRoot, rewriter, stylePreprocessors) => {
+  const raw = readFileSync14(filePath, "utf-8");
   if (!svelteCompiler) {
     svelteCompiler = await import("svelte/compiler");
   }
   const isModule = filePath.endsWith(".svelte.ts") || filePath.endsWith(".svelte.js");
   const loweredAwaitSource = isModule ? { code: raw, transformed: false } : lowerSvelteAwaitSlotSyntax(raw);
   const loweredSource = isModule ? loweredAwaitSource : lowerSvelteIslandSyntax(loweredAwaitSource.code, "client");
-  const source = loweredSource.code;
+  const source = isModule ? loweredSource.code : (await svelteCompiler.preprocess(loweredSource.code, createSvelteStylePreprocessor(stylePreprocessors))).code;
   const enableAsync = loweredAwaitSource.transformed || loweredSource.transformed;
   const code = isModule ? compileSvelteModule(source, filePath) : compileSvelteComponent(source, filePath, projectRoot, enableAsync);
   return rewriteImports2(code, filePath, projectRoot, rewriter);
@@ -10198,16 +10414,16 @@ __script__.render = render;`;
   code += `
 export default __script__;`;
   return code;
-}, compileVueStyles = (descriptor, filePath, componentId, code) => {
+}, compileVueStyles = async (descriptor, filePath, componentId, code, stylePreprocessors) => {
   if (descriptor.styles.length === 0)
     return code;
-  const cssCode = descriptor.styles.map((style) => vueCompiler.compileStyle({
+  const cssCode = (await Promise.all(descriptor.styles.map(async (style) => vueCompiler.compileStyle({
     filename: filePath,
     id: `data-v-${componentId}`,
     scoped: style.scoped,
-    source: style.content,
+    source: style.lang ? await compileStyleSource(filePath, style.content, style.lang, stylePreprocessors) : style.content,
     trim: true
-  }).code).join(`
+  }).code))).join(`
 `);
   const escaped = cssCode.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   const hmrId = JSON.stringify(filePath);
@@ -10221,8 +10437,8 @@ export default __script__;`;
   ].join("");
   return `${cssInjection}
 ${code}`;
-}, transformVueFile = async (filePath, projectRoot, rewriter, vueDir) => {
-  const raw = readFileSync13(filePath, "utf-8");
+}, transformVueFile = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
+  const raw = readFileSync14(filePath, "utf-8");
   if (!vueCompiler) {
     vueCompiler = await import("@vue/compiler-sfc");
   }
@@ -10234,13 +10450,13 @@ ${code}`;
     inlineTemplate: false
   });
   let code = compileVueTemplate(descriptor, compiledScript, filePath, componentId);
-  code = compileVueStyles(descriptor, filePath, componentId, code);
+  code = await compileVueStyles(descriptor, filePath, componentId, code, stylePreprocessors);
   code = tsTranspiler2.transformSync(code);
   code = injectVueHmr(code, filePath, projectRoot, vueDir);
   return rewriteImports2(code, filePath, projectRoot, rewriter);
 }, injectVueHmr = (code, filePath, projectRoot, vueDir) => {
-  const hmrBase = vueDir ? resolve28(vueDir) : projectRoot;
-  const hmrId = relative10(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
+  const hmrBase = vueDir ? resolve29(vueDir) : projectRoot;
+  const hmrId = relative11(hmrBase, filePath).replace(/\\/g, "/").replace(/\.vue$/, "");
   let result = code.replace(/export\s+default\s+/, "var __hmr_comp__ = ");
   result += [
     "",
@@ -10254,11 +10470,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) => {
@@ -10271,7 +10487,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');`,
@@ -10398,20 +10614,20 @@ export default {};
   const escaped = virtualCss.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$/g, "\\$");
   return jsResponse(`var s=document.createElement('style');s.textContent=\`${escaped}\`;s.dataset.svelteHmr=${JSON.stringify(cssCheckPath)};var p=document.querySelector('style[data-svelte-hmr="${cssCheckPath}"]');if(p)p.remove();document.head.appendChild(s);`);
 }, resolveSourcePath = (relPath, projectRoot) => {
-  const filePath = resolve28(projectRoot, relPath);
+  const filePath = resolve29(projectRoot, relPath);
   const ext = extname6(filePath);
   if (ext === ".svelte")
     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;
   if (found === ".svelte")
     return { ext: found, filePath: resolveSvelteModulePath(resolved) };
   return { ext: found, filePath: resolved };
-}, transformAndCache = async (filePath, ext, projectRoot, rewriter, vueDir) => {
+}, transformAndCache = async (filePath, ext, projectRoot, rewriter, vueDir, stylePreprocessors) => {
   if (ext === ".css")
     return jsResponse(handleCssRequest(filePath));
   const isSvelte = ext === ".svelte" || filePath.endsWith(".svelte.ts") || filePath.endsWith(".svelte.js");
@@ -10419,24 +10635,24 @@ export default {};
   if (cached)
     return jsResponse(cached);
   if (isSvelte)
-    return transformAndCacheSvelte(filePath, projectRoot, rewriter);
+    return transformAndCacheSvelte(filePath, projectRoot, rewriter, stylePreprocessors);
   if (ext === ".vue")
-    return transformAndCacheVue(filePath, projectRoot, rewriter, vueDir);
+    return transformAndCacheVue(filePath, projectRoot, rewriter, vueDir, stylePreprocessors);
   if (!TRANSPILABLE.has(ext))
     return;
   const stat2 = statSync2(filePath);
-  const resolvedVueDir = vueDir ? resolve28(vueDir) : undefined;
+  const resolvedVueDir = vueDir ? resolve29(vueDir) : undefined;
   const content = REACT_EXTENSIONS.has(ext) ? transformReactFile(filePath, projectRoot, rewriter) : transformPlainFile(filePath, projectRoot, rewriter, resolvedVueDir);
   setTransformed(filePath, content, stat2.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
-}, transformAndCacheSvelte = async (filePath, projectRoot, rewriter) => {
+}, transformAndCacheSvelte = async (filePath, projectRoot, rewriter, stylePreprocessors) => {
   const stat2 = statSync2(filePath);
-  const content = await transformSvelteFile(filePath, projectRoot, rewriter);
+  const content = await transformSvelteFile(filePath, projectRoot, rewriter, stylePreprocessors);
   setTransformed(filePath, content, stat2.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
-}, transformAndCacheVue = async (filePath, projectRoot, rewriter, vueDir) => {
+}, transformAndCacheVue = async (filePath, projectRoot, rewriter, vueDir, stylePreprocessors) => {
   const stat2 = statSync2(filePath);
-  const content = await transformVueFile(filePath, projectRoot, rewriter, vueDir);
+  const content = await transformVueFile(filePath, projectRoot, rewriter, vueDir, stylePreprocessors);
   setTransformed(filePath, content, stat2.mtimeMs, extractImportedFiles(content, projectRoot));
   return jsResponse(content);
 }, transformErrorResponse = (err) => {
@@ -10446,7 +10662,7 @@ export default {};
     status: 500
   });
 }, createModuleServer = (config) => {
-  const { projectRoot, vendorPaths, frameworkDirs } = config;
+  const { projectRoot, vendorPaths, frameworkDirs, stylePreprocessors } = config;
   const rewriter = buildImportRewriter(vendorPaths);
   return async (pathname) => {
     if (pathname.startsWith("/@stub/"))
@@ -10456,12 +10672,12 @@ export default {};
     if (!pathname.startsWith(SRC_PREFIX))
       return;
     const relPath = pathname.slice(SRC_PREFIX.length);
-    const virtualCssResponse = handleVirtualSvelteCss(resolve28(projectRoot, relPath));
+    const virtualCssResponse = handleVirtualSvelteCss(resolve29(projectRoot, relPath));
     if (virtualCssResponse)
       return virtualCssResponse;
     const { filePath, ext } = resolveSourcePath(relPath, projectRoot);
     try {
-      return await transformAndCache(filePath, ext, projectRoot, rewriter, frameworkDirs?.vue);
+      return await transformAndCache(filePath, ext, projectRoot, rewriter, frameworkDirs?.vue, stylePreprocessors);
     } catch (err) {
       return transformErrorResponse(err);
     }
@@ -10472,11 +10688,11 @@ export default {};
   SRC_IMPORT_RE.lastIndex = 0;
   while ((match = SRC_IMPORT_RE.exec(content)) !== null) {
     if (match[1])
-      files.push(resolve28(projectRoot, match[1]));
+      files.push(resolve29(projectRoot, match[1]));
   }
   return files;
 }, invalidateModule = (filePath) => {
-  const resolved = resolve28(filePath);
+  const resolved = resolve29(filePath);
   invalidate(filePath);
   if (resolved !== filePath)
     invalidate(resolved);
@@ -10495,6 +10711,7 @@ var init_moduleServer = __esm(() => {
   init_constants();
   init_resolvePackageImport();
   init_sourceMetadata();
+  init_stylePreprocessor();
   init_lowerAwaitSlotSyntax();
   init_lowerIslandSyntax();
   init_transformCache();
@@ -10552,11 +10769,11 @@ var exports_simpleHTMLHMR = {};
 __export(exports_simpleHTMLHMR, {
   handleHTMLUpdate: () => handleHTMLUpdate
 });
-import { resolve as resolve29 } from "path";
+import { resolve as resolve30 } from "path";
 var handleHTMLUpdate = async (htmlFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve29(htmlFilePath);
+    const resolvedPath = resolve30(htmlFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -10582,11 +10799,11 @@ var exports_simpleHTMXHMR = {};
 __export(exports_simpleHTMXHMR, {
   handleHTMXUpdate: () => handleHTMXUpdate
 });
-import { resolve as resolve30 } from "path";
+import { resolve as resolve31 } from "path";
 var handleHTMXUpdate = async (htmxFilePath) => {
   let htmlContent;
   try {
-    const resolvedPath = resolve30(htmxFilePath);
+    const resolvedPath = resolve31(htmxFilePath);
     const file4 = Bun.file(resolvedPath);
     if (!await file4.exists()) {
       return null;
@@ -10608,8 +10825,8 @@ 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 resolve31 } from "path";
+import { existsSync as existsSync22 } from "fs";
+import { basename as basename13, dirname as dirname15, relative as relative12, resolve as resolve32 } from "path";
 var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseErrorLocationFromMessage = (msg) => {
   const pathLineCol = msg.match(/^([^\s:]+):(\d+)(?::(\d+))?/);
   if (pathLineCol) {
@@ -10677,11 +10894,11 @@ 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);
-    const deletedPathResolved = resolve31(filePathInSet);
+    const deletedPathResolved = resolve32(filePathInSet);
     affectedFiles.forEach((affectedFile) => {
       if (isValidDeletedAffectedFile(affectedFile, deletedPathResolved, processedFiles)) {
         validFiles.push(affectedFile);
@@ -10695,7 +10912,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     if (!dependents || dependents.size === 0) {
       return;
     }
-    const dependentFiles = Array.from(dependents).filter((file4) => existsSync21(file4));
+    const dependentFiles = Array.from(dependents).filter((file4) => existsSync22(file4));
     if (dependentFiles.length === 0) {
       return;
     }
@@ -10711,7 +10928,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);
       }
@@ -10725,7 +10942,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   if (storedHash !== undefined && storedHash === fileHash) {
     return;
   }
-  const normalizedFilePath = resolve31(filePathInSet);
+  const normalizedFilePath = resolve32(filePathInSet);
   if (!processedFiles.has(normalizedFilePath)) {
     validFiles.push(normalizedFilePath);
     processedFiles.add(normalizedFilePath);
@@ -10736,7 +10953,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;
     }
@@ -10803,8 +11020,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   }
   if (framework === "unknown") {
     const { invalidate: invalidate2 } = (init_transformCache(), __toCommonJS(exports_transformCache));
-    invalidate2(resolve31(filePath));
-    const relPath = relative11(process.cwd(), filePath);
+    invalidate2(resolve32(filePath));
+    const relPath = relative12(process.cwd(), filePath);
     logHmrUpdate(relPath);
     return;
   }
@@ -10844,12 +11061,12 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     return componentFile;
   }
   const tsCounterpart = componentFile.replace(/\.html$/, ".ts");
-  if (existsSync21(tsCounterpart)) {
+  if (existsSync22(tsCounterpart)) {
     return tsCounterpart;
   }
   if (!graph)
     return componentFile;
-  const dependents = graph.dependents.get(resolve31(componentFile));
+  const dependents = graph.dependents.get(resolve32(componentFile));
   if (!dependents)
     return componentFile;
   for (const dep of dependents) {
@@ -10858,7 +11075,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   }
   return componentFile;
 }, resolveAngularPageEntries = (state, angularFiles, angularPagesPath) => {
-  const pageEntries = angularFiles.filter((file4) => file4.endsWith(".ts") && resolve31(file4).startsWith(angularPagesPath));
+  const pageEntries = angularFiles.filter((file4) => file4.endsWith(".ts") && resolve32(file4).startsWith(angularPagesPath));
   if (pageEntries.length > 0 || !state.dependencyGraph) {
     return pageEntries;
   }
@@ -10867,7 +11084,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     const lookupFile = resolveComponentLookupFile(componentFile, state.dependencyGraph);
     const affected = getAffectedFiles(state.dependencyGraph, lookupFile);
     affected.forEach((file4) => {
-      if (file4.endsWith(".ts") && resolve31(file4).startsWith(angularPagesPath)) {
+      if (file4.endsWith(".ts") && resolve32(file4).startsWith(angularPagesPath)) {
         resolvedPages.add(file4);
       }
     });
@@ -10917,7 +11134,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     format: "esm",
     naming: "[dir]/[name].[hash].[ext]",
     outdir: buildDir,
-    plugins: [stylePreprocessorPlugin],
+    plugins: [
+      createStylePreprocessorPlugin(state.config.stylePreprocessors)
+    ],
     root: clientRoot,
     target: "browser",
     throw: false
@@ -10958,10 +11177,10 @@ 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);
+  const { clientPaths, serverPaths } = await compileAngular2(pageEntries, angularDir, true, state.config.stylePreprocessors);
   serverPaths.forEach((serverPath) => {
     const fileBase = basename13(serverPath, ".js");
-    state.manifest[toPascal(fileBase)] = resolve31(serverPath);
+    state.manifest[toPascal(fileBase)] = resolve32(serverPath);
   });
   if (clientPaths.length > 0) {
     await bundleAngularClient(state, clientPaths, state.resolvedPaths.buildDir);
@@ -10970,9 +11189,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   const angularDir = config.angularDirectory ?? "";
   const angularFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "angular");
   for (const file4 of angularFiles) {
-    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve32(file4), computeFileHash(file4));
   }
-  const angularPagesPath = resolve31(angularDir, "pages");
+  const angularPagesPath = resolve32(angularDir, "pages");
   const pageEntries = resolveAngularPageEntries(state, angularFiles, angularPagesPath);
   if (pageEntries.length > 0) {
     await compileAndBundleAngular(state, pageEntries, angularDir);
@@ -10987,8 +11206,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   return manifest;
 }, resolveReactEntryForPageFile = (normalized, pagesPathResolved, reactIndexesPath) => {
   const pageName = basename13(normalized, ".tsx");
-  const indexPath = resolve31(reactIndexesPath, `${pageName}.tsx`);
-  if (!existsSync21(indexPath)) {
+  const indexPath = resolve32(reactIndexesPath, `${pageName}.tsx`);
+  if (!existsSync22(indexPath)) {
     return;
   }
   return indexPath;
@@ -10999,13 +11218,13 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
       return;
     }
     const pageName = basename13(dep, ".tsx");
-    const indexPath = resolve31(reactIndexesPath, `${pageName}.tsx`);
-    if (existsSync21(indexPath) && !reactEntries.includes(indexPath)) {
+    const indexPath = resolve32(reactIndexesPath, `${pageName}.tsx`);
+    if (existsSync22(indexPath) && !reactEntries.includes(indexPath)) {
       reactEntries.push(indexPath);
     }
   });
 }, resolveReactEntryForFile = (state, file4, pagesPathResolved, reactIndexesPath, reactEntries) => {
-  const normalized = resolve31(file4);
+  const normalized = resolve32(file4);
   if (!normalized.startsWith(pagesPathResolved)) {
     resolveReactEntriesFromDeps(state, normalized, pagesPathResolved, reactIndexesPath, reactEntries);
     return;
@@ -11016,7 +11235,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   }
 }, collectReactEntries = (state, filesToRebuild, reactPagesPath, reactIndexesPath) => {
   const reactEntries = [];
-  const pagesPathResolved = resolve31(reactPagesPath);
+  const pagesPathResolved = resolve32(reactPagesPath);
   filesToRebuild.forEach((file4) => {
     resolveReactEntryForFile(state, file4, pagesPathResolved, reactIndexesPath, reactEntries);
   });
@@ -11028,7 +11247,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   const { rewriteReactImports: rewriteReactImports2 } = await Promise.resolve().then(() => (init_rewriteReactImports(), exports_rewriteReactImports));
   const clientRoot = await computeClientRoot(state.resolvedPaths);
   const depVendorPaths = globalThis.__depVendorPaths ?? {};
-  const refreshEntry = resolve31(reactIndexesPath, "_refresh.tsx");
+  const refreshEntry = resolve32(reactIndexesPath, "_refresh.tsx");
   if (!reactEntries.includes(refreshEntry)) {
     reactEntries.push(refreshEntry);
   }
@@ -11040,7 +11259,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     setDevVendorPaths2(vendorPaths);
   }
   const { rmSync: rmSync3 } = await import("fs");
-  rmSync3(resolve31(buildDir, "react", "generated", "indexes"), {
+  rmSync3(resolve32(buildDir, "react", "generated", "indexes"), {
     force: true,
     recursive: true
   });
@@ -11050,7 +11269,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
     jsx: { development: true },
     naming: "[dir]/[name].[hash].[ext]",
     outdir: buildDir,
-    plugins: [stylePreprocessorPlugin],
+    plugins: [
+      createStylePreprocessorPlugin(state.config.stylePreprocessors)
+    ],
     reactFastRefresh: true,
     root: clientRoot,
     splitting: true,
@@ -11081,7 +11302,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;
@@ -11090,11 +11311,11 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   if (isComponentFile2)
     return primaryFile;
   const { findNearestComponent: findNearestComponent2 } = await Promise.resolve().then(() => (init_transformCache(), exports_transformCache));
-  const nearest = findNearestComponent2(resolve31(primaryFile));
+  const nearest = findNearestComponent2(resolve32(primaryFile));
   return nearest ?? primaryFile;
 }, handleReactModuleServerPath = async (state, reactFiles, startTime, onRebuildComplete) => {
   for (const file4 of reactFiles) {
-    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve32(file4), computeFileHash(file4));
   }
   invalidateReactSsrCache();
   const primaryFile = reactFiles.find((file4) => !file4.replace(/\\/g, "/").includes("/pages/")) ?? reactFiles[0];
@@ -11113,7 +11334,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: {
@@ -11136,8 +11357,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   return state.manifest;
 }, handleReactFastPath = async (state, config, filesToRebuild, startTime, onRebuildComplete) => {
   const reactDir = config.reactDirectory ?? "";
-  const reactPagesPath = resolve31(reactDir, "pages");
-  const reactIndexesPath = resolve31(reactDir, "generated", "indexes");
+  const reactPagesPath = resolve32(reactDir, "pages");
+  const reactIndexesPath = resolve32(reactDir, "generated", "indexes");
   const { buildDir } = state.resolvedPaths;
   const reactFiles = filesToRebuild.filter((file4) => detectFramework(file4, state.resolvedPaths) === "react");
   if (reactFiles.length > 0) {
@@ -11200,7 +11421,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   });
 }, handleSvelteModuleServerPath = async (state, svelteFiles, startTime, onRebuildComplete) => {
   for (const file4 of svelteFiles) {
-    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve32(file4), computeFileHash(file4));
   }
   invalidateSvelteSsrCache();
   const serverDuration = Date.now() - startTime;
@@ -11223,11 +11444,11 @@ 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);
+    const { svelteServerPaths, svelteIndexPaths, svelteClientPaths } = await compileSvelte2(svelteFiles, svelteDir, new Map, true, state.config.stylePreprocessors);
     const serverEntries = [...svelteServerPaths];
     const clientEntries = [...svelteIndexPaths, ...svelteClientPaths];
-    const serverRoot = resolve31(svelteDir, "generated", "server");
-    const serverOutDir = resolve31(buildDir, basename13(svelteDir));
+    const serverRoot = resolve32(svelteDir, "generated", "server");
+    const serverOutDir = resolve32(buildDir, basename13(svelteDir));
     const [serverResult, clientResult] = await Promise.all([
       serverEntries.length > 0 ? bunBuild7({
         entrypoints: serverEntries,
@@ -11242,7 +11463,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
         format: "esm",
         naming: "[dir]/[name].[hash].[ext]",
         outdir: serverOutDir,
-        plugins: [stylePreprocessorPlugin],
+        plugins: [
+          createStylePreprocessorPlugin(state.config.stylePreprocessors)
+        ],
         root: serverRoot,
         target: "bun",
         throw: false
@@ -11252,7 +11475,9 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
         format: "esm",
         naming: "[dir]/[name].[hash].[ext]",
         outdir: buildDir,
-        plugins: [stylePreprocessorPlugin],
+        plugins: [
+          createStylePreprocessorPlugin(state.config.stylePreprocessors)
+        ],
         root: clientRoot,
         target: "browser",
         throw: false
@@ -11320,7 +11545,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   });
 }, handleVueModuleServerPath = async (state, vueFiles, nonVueFiles, startTime, onRebuildComplete) => {
   for (const file4 of [...vueFiles, ...nonVueFiles]) {
-    state.fileHashes.set(resolve31(file4), computeFileHash(file4));
+    state.fileHashes.set(resolve32(file4), computeFileHash(file4));
   }
   invalidateVueSsrCache();
   await invalidateNonVueModules(nonVueFiles);
@@ -11415,8 +11640,8 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   if (!buildReference?.source) {
     return;
   }
-  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve31(dirname15(buildInfo.resolvedRegistryPath), buildReference.source);
-  islandFiles.add(resolve31(sourcePath));
+  const sourcePath = buildReference.source.startsWith("file://") ? new URL(buildReference.source).pathname : resolve32(dirname15(buildInfo.resolvedRegistryPath), buildReference.source);
+  islandFiles.add(resolve32(sourcePath));
 }, resolveIslandSourceFiles = async (config) => {
   const registryPath = config.islands?.registry;
   if (!registryPath) {
@@ -11424,7 +11649,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   }
   const buildInfo = await loadIslandRegistryBuildInfo(registryPath);
   const islandFiles = new Set([
-    resolve31(buildInfo.resolvedRegistryPath)
+    resolve32(buildInfo.resolvedRegistryPath)
   ]);
   for (const definition of buildInfo.definitions) {
     resolveIslandDefinitionSource(definition, buildInfo, islandFiles);
@@ -11435,7 +11660,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   if (islandFiles.size === 0) {
     return false;
   }
-  return filesToRebuild.some((file4) => islandFiles.has(resolve31(file4)));
+  return filesToRebuild.some((file4) => islandFiles.has(resolve32(file4)));
 }, handleIslandSourceReload = async (state, config, filesToRebuild, manifest) => {
   const shouldReload = await didStaticPagesNeedIslandRefresh(config, filesToRebuild);
   if (!shouldReload) {
@@ -11470,10 +11695,10 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
 }, computeOutputPagesDir = (state, config, framework) => {
   const isSingle = !config.reactDirectory && !config.svelteDirectory && !config.vueDirectory && (framework === "html" ? !config.htmxDirectory : !config.htmlDirectory);
   if (isSingle) {
-    return resolve31(state.resolvedPaths.buildDir, "pages");
+    return resolve32(state.resolvedPaths.buildDir, "pages");
   }
   const dirName = framework === "html" ? basename13(config.htmlDirectory ?? "html") : basename13(config.htmxDirectory ?? "htmx");
-  return resolve31(state.resolvedPaths.buildDir, dirName, "pages");
+  return resolve32(state.resolvedPaths.buildDir, dirName, "pages");
 }, processHtmlPageUpdate = async (state, pageFile, builtHtmlPagePath, manifest, duration) => {
   try {
     const { handleHTMLUpdate: handleHTMLUpdate2 } = await Promise.resolve().then(() => (init_simpleHTMLHMR(), exports_simpleHTMLHMR));
@@ -11512,7 +11737,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmlPages, "*.html") : htmlPageFiles;
   for (const pageFile of pageFilesToUpdate) {
     const htmlPageName = basename13(pageFile);
-    const builtHtmlPagePath = resolve31(outputHtmlPages, htmlPageName);
+    const builtHtmlPagePath = resolve32(outputHtmlPages, htmlPageName);
     await processHtmlPageUpdate(state, pageFile, builtHtmlPagePath, manifest, duration);
   }
 }, handleVueCssOnlyUpdate = (state, vueCssFiles, manifest, duration) => {
@@ -11573,11 +11798,11 @@ 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));
-  const hmrMeta = vueHmrMetadata2.get(resolve31(vuePagePath));
+  const hmrMeta = vueHmrMetadata2.get(resolve32(vuePagePath));
   const changeType = hmrMeta?.changeType ?? "full";
   if (changeType === "style-only") {
     broadcastVueStyleOnly(state, vuePagePath, baseName, cssUrl, hmrId, manifest, duration);
@@ -11814,7 +12039,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   const pageFilesToUpdate = shouldRefreshAllPages ? await scanEntryPoints(outputHtmxPages, "*.html") : htmxPageFiles;
   for (const htmxPageFile of pageFilesToUpdate) {
     const htmxPageName = basename13(htmxPageFile);
-    const builtHtmxPagePath = resolve31(outputHtmxPages, htmxPageName);
+    const builtHtmxPagePath = resolve32(outputHtmxPages, htmxPageName);
     await processHtmxPageUpdate(state, htmxPageFile, builtHtmxPagePath, manifest, duration);
   }
 }, collectUpdatedModulePaths = (allModuleUpdates) => {
@@ -11923,7 +12148,7 @@ var moduleServerPromise, getModuleServer = () => moduleServerPromise, parseError
   html = html.slice(0, bodyClose.index) + hmrScript + html.slice(bodyClose.index);
   writeFs(destPath, html);
 }, processMarkupFileFastPath = async (state, sourceFile, outputDir, framework, startTime, updateAssetPaths2, handleUpdate, readFs, writeFs) => {
-  const destPath = resolve31(outputDir, basename13(sourceFile));
+  const destPath = resolve32(outputDir, basename13(sourceFile));
   const hmrScript = extractHmrScript(destPath, readFs);
   const source = await Bun.file(sourceFile).text();
   await Bun.write(destPath, source);
@@ -12201,7 +12426,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]) => {
@@ -12212,7 +12437,7 @@ var toSafeFileName5 = (specifier) => specifier.replace(/\//g, "_").replace(/@/g,
   const files = readdirSync2(vendorDir).filter((f) => f.endsWith(".js"));
   for (const file4 of files) {
     const filePath = join22(vendorDir, file4);
-    const original = readFileSync14(filePath, "utf-8");
+    const original = readFileSync15(filePath, "utf-8");
     const rewritten = rewriteContent(original);
     if (rewritten !== original)
       writeFileSync8(filePath, rewritten);
@@ -12299,7 +12524,7 @@ __export(exports_devBuild, {
 });
 import { readdir as readdir5 } from "fs/promises";
 import { statSync as statSync3 } from "fs";
-import { dirname as dirname16, resolve as resolve32 } from "path";
+import { dirname as dirname16, resolve as resolve33 } from "path";
 var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const configuredDirs = [
     config.reactDirectory,
@@ -12322,7 +12547,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return Object.keys(config).length > 0 ? config : null;
 }, reloadConfig = async () => {
   try {
-    const configPath2 = resolve32(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+    const configPath2 = resolve33(process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
     const source = await Bun.file(configPath2).text();
     return parseDirectoryConfig(source);
   } catch {
@@ -12402,7 +12627,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     state.fileChangeQueue.clear();
   }
 }, handleCachedReload = async () => {
-  const serverMtime = statSync3(resolve32(Bun.main)).mtimeMs;
+  const serverMtime = statSync3(resolve33(Bun.main)).mtimeMs;
   const lastMtime = globalThis.__hmrServerMtime;
   globalThis.__hmrServerMtime = serverMtime;
   const cached = globalThis.__hmrDevResult;
@@ -12436,8 +12661,8 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   return true;
 }, resolveAbsoluteVersion2 = async () => {
   const candidates = [
-    resolve32(import.meta.dir, "..", "..", "package.json"),
-    resolve32(import.meta.dir, "..", "package.json")
+    resolve33(import.meta.dir, "..", "..", "package.json"),
+    resolve33(import.meta.dir, "..", "package.json")
   ];
   for (const candidate of candidates) {
     const found = await tryReadPackageVersion(candidate);
@@ -12450,7 +12675,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   const entries = await readdir5(vendorDir).catch(() => emptyStringArray);
   await Promise.all(entries.map(async (entry) => {
     const webPath = `/${framework}/vendor/${entry}`;
-    const bytes = await Bun.file(resolve32(vendorDir, entry)).bytes();
+    const bytes = await Bun.file(resolve33(vendorDir, entry)).bytes();
     assetStore.set(webPath, bytes);
   }));
 }, devBuild = async (config) => {
@@ -12514,7 +12739,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
   recordStep("populate asset store", stepStartedAt);
   stepStartedAt = performance.now();
   const buildReactVendorTask = config.reactDirectory ? buildReactVendor(state.resolvedPaths.buildDir).then(async () => {
-    const vendorDir = resolve32(state.resolvedPaths.buildDir, "react", "vendor");
+    const vendorDir = resolve33(state.resolvedPaths.buildDir, "react", "vendor");
     await loadVendorFiles(state.assetStore, vendorDir, "react");
     if (!globalThis.__reactModuleRef) {
       globalThis.__reactModuleRef = await import("react");
@@ -12522,23 +12747,23 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     return true;
   }) : undefined;
   const buildAngularVendorTask = config.angularDirectory ? buildAngularVendor(state.resolvedPaths.buildDir).then(async () => {
-    const vendorDir = resolve32(state.resolvedPaths.buildDir, "angular", "vendor");
+    const vendorDir = resolve33(state.resolvedPaths.buildDir, "angular", "vendor");
     await loadVendorFiles(state.assetStore, vendorDir, "angular");
     return true;
   }) : undefined;
   const buildSvelteVendorTask = config.svelteDirectory ? buildSvelteVendor(state.resolvedPaths.buildDir).then(async () => {
-    const vendorDir = resolve32(state.resolvedPaths.buildDir, "svelte", "vendor");
+    const vendorDir = resolve33(state.resolvedPaths.buildDir, "svelte", "vendor");
     await loadVendorFiles(state.assetStore, vendorDir, "svelte");
     return true;
   }) : undefined;
   const buildVueVendorTask = config.vueDirectory ? buildVueVendor(state.resolvedPaths.buildDir).then(async () => {
-    const vendorDir = resolve32(state.resolvedPaths.buildDir, "vue", "vendor");
+    const vendorDir = resolve33(state.resolvedPaths.buildDir, "vue", "vendor");
     await loadVendorFiles(state.assetStore, vendorDir, "vue");
     return true;
   }) : undefined;
   const { buildDepVendor: buildDepVendor2 } = await Promise.resolve().then(() => (init_buildDepVendor(), exports_buildDepVendor));
   const buildDepVendorTask = buildDepVendor2(state.resolvedPaths.buildDir, sourceDirs).then(async (depPaths) => {
-    const vendorDir = resolve32(state.resolvedPaths.buildDir, "vendor");
+    const vendorDir = resolve33(state.resolvedPaths.buildDir, "vendor");
     await loadVendorFiles(state.assetStore, vendorDir, "vendor");
     globalThis.__depVendorPaths = depPaths;
     return true;
@@ -12575,7 +12800,7 @@ var FRAMEWORK_DIR_KEYS, collectDepVendorSourceDirs = (config) => {
     manifest
   };
   globalThis.__hmrDevResult = result;
-  globalThis.__hmrServerMtime = statSync3(resolve32(Bun.main)).mtimeMs;
+  globalThis.__hmrServerMtime = statSync3(resolve33(Bun.main)).mtimeMs;
   return result;
 };
 var init_devBuild = __esm(() => {
@@ -12724,17 +12949,17 @@ __export(exports_devtoolsJson, {
   normalizeDevtoolsWorkspaceRoot: () => normalizeDevtoolsWorkspaceRoot,
   devtoolsJson: () => devtoolsJson
 });
-import { existsSync as existsSync22, mkdirSync as mkdirSync12, readFileSync as readFileSync14, writeFileSync as writeFileSync8 } from "fs";
-import { dirname as dirname17, join as join23, resolve as resolve33 } from "path";
+import { existsSync as existsSync23, mkdirSync as mkdirSync12, readFileSync as readFileSync15, writeFileSync as writeFileSync8 } from "fs";
+import { dirname as dirname17, join as join23, resolve as resolve34 } from "path";
 import { Elysia as Elysia3 } from "elysia";
 var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_KEY = "__absoluteDevtoolsWorkspaceUuid", getGlobalUuid = () => Reflect.get(globalThis, UUID_CACHE_KEY), setGlobalUuid = (uuid) => {
   Reflect.set(globalThis, UUID_CACHE_KEY, uuid);
   return uuid;
-}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve33(uuidCachePath ?? join23(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
-  if (!existsSync22(cachePath))
+}, isUuidV4 = (value) => /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(value), resolveDevtoolsUuidCachePath = (buildDir, uuidCachePath) => resolve34(uuidCachePath ?? join23(buildDir, ".absolute", "chrome-devtools-workspace-uuid")), readCachedUuid = (cachePath) => {
+  if (!existsSync23(cachePath))
     return null;
   try {
-    const value = readFileSync14(cachePath, "utf-8").trim();
+    const value = readFileSync15(cachePath, "utf-8").trim();
     return isUuidV4(value) ? value : null;
   } catch {
     return null;
@@ -12756,7 +12981,7 @@ var ENDPOINT = "/.well-known/appspecific/com.chrome.devtools.json", UUID_CACHE_K
   writeFileSync8(cachePath, uuid, "utf-8");
   return setGlobalUuid(uuid);
 }, devtoolsJson = (buildDir, options = {}) => {
-  const rootPath = resolve33(options.projectRoot ?? process.cwd());
+  const rootPath = resolve34(options.projectRoot ?? process.cwd());
   const root = options.normalizeForWindowsContainer === false ? rootPath : normalizeDevtoolsWorkspaceRoot(rootPath);
   const uuid = getOrCreateUuid(buildDir, options);
   return new Elysia3({ name: "absolute-devtools-json" }).get(ENDPOINT, () => ({
@@ -12784,13 +13009,13 @@ var exports_imageOptimizer = {};
 __export(exports_imageOptimizer, {
   imageOptimizer: () => imageOptimizer
 });
-import { existsSync as existsSync23 } from "fs";
-import { resolve as resolve34 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import { resolve as resolve35 } from "path";
 import { Elysia as Elysia4 } from "elysia";
 var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avifInProgress, safeResolve = (path, baseDir) => {
   try {
     const resolved = validateSafePath(path, baseDir);
-    if (existsSync23(resolved))
+    if (existsSync24(resolved))
       return resolved;
     return null;
   } catch {
@@ -12798,7 +13023,7 @@ var DEFAULT_CACHE_TTL_SECONDS = 60, MS_PER_SECOND = 1000, MAX_QUALITY = 100, avi
   }
 }, resolveLocalImage = (url, buildDir) => {
   const cleanPath = url.startsWith("/") ? url.slice(1) : url;
-  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve34(process.cwd()));
+  return safeResolve(cleanPath, buildDir) ?? safeResolve(cleanPath, resolve35(process.cwd()));
 }, parseQueryParams = (query, allowedSizes, defaultQuality) => {
   const url = typeof query["url"] === "string" ? query["url"] : undefined;
   const wParam = typeof query["w"] === "string" ? query["w"] : undefined;
@@ -13089,7 +13314,7 @@ __export(exports_prerender, {
   prerender: () => prerender,
   PRERENDER_BYPASS_HEADER: () => PRERENDER_BYPASS_HEADER
 });
-import { mkdirSync as mkdirSync13, readFileSync as readFileSync15 } from "fs";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync16 } from "fs";
 import { join as join24 } from "path";
 var MAX_STARTUP_ATTEMPTS = 50, STARTUP_POLL_INTERVAL_MS = 100, PRERENDER_BYPASS_HEADER = "X-Absolute-Prerender-Bypass", routeToFilename = (route) => route === "/" ? "index.html" : `${route.slice(1).replace(/\//g, "-")}.html`, writeTimestamp = async (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
@@ -13097,7 +13322,7 @@ var MAX_STARTUP_ATTEMPTS = 50, STARTUP_POLL_INTERVAL_MS = 100, PRERENDER_BYPASS_
 }, readTimestamp = (htmlPath) => {
   const metaPath = htmlPath.replace(/\.html$/, ".meta");
   try {
-    const content = readFileSync15(metaPath, "utf-8");
+    const content = readFileSync16(metaPath, "utf-8");
     return Number(content) || 0;
   } catch {
     return 0;
@@ -13437,12 +13662,12 @@ var handleHTMXPageRequest = async (pagePath) => {
   });
 };
 // src/core/prepare.ts
-import { existsSync as existsSync24, readdirSync as readdirSync2, readFileSync as readFileSync16 } from "fs";
-import { basename as basename14, join as join25, relative as relative12, resolve as resolve35 } from "path";
+import { existsSync as existsSync25, readdirSync as readdirSync2, readFileSync as readFileSync17 } from "fs";
+import { basename as basename14, join as join25, relative as relative13, resolve as resolve36 } from "path";
 import { Elysia as Elysia5 } from "elysia";
 
 // src/utils/loadConfig.ts
-import { resolve as resolve6 } from "path";
+import { resolve as resolve7 } from "path";
 var RESERVED_TOP_LEVEL_KEYS = new Set([
   "assetsDirectory",
   "astroDirectory",
@@ -13520,7 +13745,7 @@ var projectServiceConfig = (config, serviceName) => {
   return serviceConfig;
 };
 var loadRawConfig = async (configPath) => {
-  const resolved = resolve6(configPath ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
+  const resolved = resolve7(configPath ?? process.env.ABSOLUTE_CONFIG ?? "absolute.config.ts");
   const mod = await import(resolved);
   const config = mod.default ?? mod.config;
   if (!config) {
@@ -13548,7 +13773,7 @@ var loadConfig = async (configPath) => {
 init_islandPageContext();
 
 // src/core/loadIslandRegistry.ts
-import { resolve as resolve7 } from "path";
+import { resolve as resolve8 } from "path";
 var isRecord6 = (value) => typeof value === "object" && value !== null;
 var resolveRegistryExport2 = (mod) => {
   if (isRecord6(mod.islandRegistry))
@@ -13560,7 +13785,7 @@ var resolveRegistryExport2 = (mod) => {
 var isRegistryModuleExport = (value) => isRecord6(value);
 var isIslandRegistryInput = (value) => isRecord6(value);
 var loadIslandRegistry = async (registryPath) => {
-  const resolvedRegistryPath = resolve7(registryPath);
+  const resolvedRegistryPath = resolve8(registryPath);
   const importedModule = await import(resolvedRegistryPath);
   if (!isRegistryModuleExport(importedModule)) {
     throw new Error("Island registry module must export an object namespace.");
@@ -13604,7 +13829,7 @@ var collectPrewarmFiles = async (prewarmDirs) => {
   for (const { dir, pattern } of prewarmDirs) {
     const glob = new Glob9(pattern);
     const matches = [
-      ...glob.scanSync({ absolute: true, cwd: resolve35(dir) })
+      ...glob.scanSync({ absolute: true, cwd: resolve36(dir) })
     ];
     files.push(...matches);
   }
@@ -13615,7 +13840,7 @@ var warmPrewarmDirs = async (prewarmDirs, warmCache2, SRC_URL_PREFIX2) => {
   for (const file4 of files) {
     if (file4.includes("/node_modules/"))
       continue;
-    const rel = relative12(process.cwd(), file4).replace(/\\/g, "/");
+    const rel = relative13(process.cwd(), file4).replace(/\\/g, "/");
     warmCache2(`${SRC_URL_PREFIX2}${rel}`);
   }
 };
@@ -13640,10 +13865,10 @@ var patchManifestIndexes = (manifest, devIndexDir, SRC_URL_PREFIX2) => {
     const fileName = resolveDevIndexFileName(manifest[key], baseName);
     if (!fileName)
       continue;
-    const srcPath = resolve35(devIndexDir, fileName);
-    if (!existsSync24(srcPath))
+    const srcPath = resolve36(devIndexDir, fileName);
+    if (!existsSync25(srcPath))
       continue;
-    const rel = relative12(process.cwd(), srcPath).replace(/\\/g, "/");
+    const rel = relative13(process.cwd(), srcPath).replace(/\\/g, "/");
     manifest[key] = `${SRC_URL_PREFIX2}${rel}`;
   }
 };
@@ -13692,6 +13917,7 @@ var prepareDev = async (config, buildDir) => {
       vue: config.vueDirectory
     },
     projectRoot: process.cwd(),
+    stylePreprocessors: config.stylePreprocessors,
     vendorPaths: allVendorPaths
   });
   setGlobalModuleServer2(moduleHandler);
@@ -13710,7 +13936,7 @@ var prepareDev = async (config, buildDir) => {
   stepStartedAt = performance.now();
   const hmrPlugin = hmr2(result.hmrState, result.manifest, moduleHandler);
   const { devtoolsJson: devtoolsJson2 } = await Promise.resolve().then(() => (init_devtoolsJson(), exports_devtoolsJson));
-  const devIndexDir = resolve35(buildDir, "_src_indexes");
+  const devIndexDir = resolve36(buildDir, "_src_indexes");
   patchManifestIndexes(result.manifest, devIndexDir, SRC_URL_PREFIX2);
   recordStep("configure dev plugins", stepStartedAt);
   stepStartedAt = performance.now();
@@ -13746,7 +13972,7 @@ var prepareDev = async (config, buildDir) => {
 };
 var loadPrerenderMap = (prerenderDir) => {
   const map = new Map;
-  if (!existsSync24(prerenderDir))
+  if (!existsSync25(prerenderDir))
     return map;
   let entries;
   try {
@@ -13790,7 +14016,7 @@ var prepare = async (configOrPath) => {
   recordStep("load config", stepStartedAt);
   const nodeEnv = process.env["NODE_ENV"];
   const isDev3 = nodeEnv === "development";
-  const buildDir = resolve35(process.env.ABSOLUTE_BUILD_DIR ?? config.buildDirectory ?? "build");
+  const buildDir = resolve36(process.env.ABSOLUTE_BUILD_DIR ?? config.buildDirectory ?? "build");
   if (isDev3) {
     stepStartedAt = performance.now();
     const result = await prepareDev(config, buildDir);
@@ -13799,7 +14025,7 @@ var prepare = async (configOrPath) => {
     return result;
   }
   stepStartedAt = performance.now();
-  const manifest = JSON.parse(readFileSync16(`${buildDir}/manifest.json`, "utf-8"));
+  const manifest = JSON.parse(readFileSync17(`${buildDir}/manifest.json`, "utf-8"));
   setCurrentIslandManifest(manifest);
   if (config.islands?.registry) {
     setCurrentIslandRegistry(await loadIslandRegistry(config.islands.registry));
@@ -13808,8 +14034,8 @@ var prepare = async (configOrPath) => {
   recordStep("load production manifest and island metadata", stepStartedAt);
   stepStartedAt = performance.now();
   const conventionsPath = join25(buildDir, "conventions.json");
-  if (existsSync24(conventionsPath)) {
-    const conventions2 = JSON.parse(readFileSync16(conventionsPath, "utf-8"));
+  if (existsSync25(conventionsPath)) {
+    const conventions2 = JSON.parse(readFileSync17(conventionsPath, "utf-8"));
     setConventions(conventions2);
   }
   recordStep("load production conventions", stepStartedAt);
@@ -13878,7 +14104,7 @@ import { argv } from "process";
 var {env: env4 } = globalThis.Bun;
 
 // src/dev/devCert.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync14, readFileSync as readFileSync17, rmSync as rmSync3 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync14, readFileSync as readFileSync18, rmSync as rmSync3 } from "fs";
 import { join as join26 } from "path";
 var CERT_DIR = join26(process.cwd(), ".absolutejs");
 var CERT_PATH = join26(CERT_DIR, "cert.pem");
@@ -13886,10 +14112,10 @@ var KEY_PATH = join26(CERT_DIR, "key.pem");
 var CERT_VALIDITY_DAYS = 365;
 var devLog = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[36m[dev]\x1B[0m ${msg}`);
 var devWarn = (msg) => console.log(`\x1B[2m${new Date().toLocaleTimeString()}\x1B[0m \x1B[33m[dev]\x1B[0m \x1B[33m${msg}\x1B[0m`);
-var certFilesExist = () => existsSync25(CERT_PATH) && existsSync25(KEY_PATH);
+var certFilesExist = () => existsSync26(CERT_PATH) && existsSync26(KEY_PATH);
 var isCertExpired = () => {
   try {
-    const certPem = readFileSync17(CERT_PATH, "utf-8");
+    const certPem = readFileSync18(CERT_PATH, "utf-8");
     const proc = Bun.spawnSync(["openssl", "x509", "-enddate", "-noout"], {
       stdin: new TextEncoder().encode(certPem)
     });
@@ -13985,8 +14211,8 @@ var loadDevCert = () => {
     return null;
   try {
     return {
-      cert: readFileSync17(paths.cert, "utf-8"),
-      key: readFileSync17(paths.key, "utf-8")
+      cert: readFileSync18(paths.cert, "utf-8"),
+      key: readFileSync18(paths.key, "utf-8")
     };
   } catch {
     return null;
@@ -14214,8 +14440,8 @@ var jsonLd2 = (schema) => {
 };
 // src/utils/defineEnv.ts
 var {env: bunEnv } = globalThis.Bun;
-import { existsSync as existsSync26, readFileSync as readFileSync18 } from "fs";
-import { resolve as resolve36 } from "path";
+import { existsSync as existsSync27, readFileSync as readFileSync19 } from "fs";
+import { resolve as resolve37 } from "path";
 
 // node_modules/@sinclair/typebox/build/esm/type/guard/value.mjs
 var exports_value = {};
@@ -20250,19 +20476,19 @@ ${lines.join(`
 };
 var checkEnvFileSecurity = (properties) => {
   const cwd2 = process.cwd();
-  const envPath = resolve36(cwd2, ".env");
-  if (!existsSync26(envPath))
+  const envPath = resolve37(cwd2, ".env");
+  if (!existsSync27(envPath))
     return;
   const sensitiveKeys = Object.keys(properties).filter(isSensitive);
   if (sensitiveKeys.length === 0)
     return;
-  const envContent = readFileSync18(envPath, "utf-8");
+  const envContent = readFileSync19(envPath, "utf-8");
   const presentKeys = sensitiveKeys.filter((key) => envContent.includes(`${key}=`));
   if (presentKeys.length === 0)
     return;
-  const gitignorePath = resolve36(cwd2, ".gitignore");
-  if (existsSync26(gitignorePath)) {
-    const gitignore = readFileSync18(gitignorePath, "utf-8");
+  const gitignorePath = resolve37(cwd2, ".gitignore");
+  if (existsSync27(gitignorePath)) {
+    const gitignore = readFileSync19(gitignorePath, "utf-8");
     if (gitignore.split(`
 `).some((line) => line.trim() === ".env"))
       return;
@@ -20469,5 +20695,5 @@ export {
   ANGULAR_INIT_TIMEOUT_MS
 };
 
-//# debugId=F5E990EFAC399D1764756E2164756E21
+//# debugId=994C58D8A1A6025964756E2164756E21
 //# sourceMappingURL=index.js.map