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

package/dist/src/build/compileAngular.d.ts

@@ -1,5 +1,6 @@
 import type { CompilerOptions } from '@angular/compiler-cli';
 import ts from 'typescript';
+import type { StylePreprocessorConfig } from '../../types/build';
 type AngularCompilerCache = {
     host: ts.CompilerHost;
     options: CompilerOptions;
@@ -10,14 +11,14 @@ type AngularCompilerCache = {
 declare global {
     var __angularCompilerCache: AngularCompilerCache | undefined;
 }
-export declare const compileAngularFile: (inputPath: string, outDir: string) => Promise<string[]>;
+export declare const compileAngularFile: (inputPath: string, outDir: string, stylePreprocessors?: StylePreprocessorConfig) => Promise<string[]>;
 /** Angular HMR Runtime Layer (Level 3) — JIT-mode compilation for dev/HMR builds.
  *  Uses ts.transpileModule() instead of Angular AOT performCompilation().
  *  Inlines templateUrl → template and styleUrls → styles from disk.
  *  Recursively transpiles all local imports so Bun's bundler can resolve them.
  *  ~50-100ms for a tree of ~10 files vs ~500-700ms for AOT. */
-export declare const compileAngularFileJIT: (inputPath: string, outDir: string, rootDir?: string) => Promise<string[]>;
-export declare const compileAngular: (entryPoints: string[], outRoot: string, hmr?: boolean) => Promise<{
+export declare const compileAngularFileJIT: (inputPath: string, outDir: string, rootDir?: string, stylePreprocessors?: StylePreprocessorConfig) => Promise<string[]>;
+export declare const compileAngular: (entryPoints: string[], outRoot: string, hmr?: boolean, stylePreprocessors?: StylePreprocessorConfig) => Promise<{
     clientPaths: string[];
     serverPaths: string[];
     allIndexesUnchanged?: undefined;

package/dist/src/build/compileSvelte.d.ts

@@ -1,3 +1,4 @@
+import type { StylePreprocessorConfig } from '../../types/build';
 type Built = {
     ssr: string;
     client: string;
@@ -5,7 +6,7 @@ type Built = {
 };
 type Cache = Map<string, Built>;
 export declare const clearSvelteCompilerCache: () => void;
-export declare const compileSvelte: (entryPoints: string[], svelteRoot: string, cache?: Cache, isDev?: boolean) => Promise<{
+export declare const compileSvelte: (entryPoints: string[], svelteRoot: string, cache?: Cache, isDev?: boolean, stylePreprocessors?: StylePreprocessorConfig) => Promise<{
     svelteClientPaths: string[];
     svelteIndexPaths: string[];
     svelteServerPaths: string[];

package/dist/src/build/compileVue.d.ts

@@ -1,4 +1,5 @@
 import type { SFCDescriptor } from '@vue/compiler-sfc';
+import type { StylePreprocessorConfig } from '../../types/build';
 export type VueChangeType = 'style-only' | 'template-only' | 'script' | 'full';
 export declare const vueHmrMetadata: Map<string, {
     hmrId: string;
@@ -7,7 +8,7 @@ export declare const vueHmrMetadata: Map<string, {
 export declare const clearVueHmrCaches: () => void;
 export declare const detectVueChangeType: (filePath: string, descriptor: SFCDescriptor) => "script" | "template-only" | "full" | "style-only";
 export declare const generateVueHmrId: (sourceFilePath: string, vueRootDir: string) => string;
-export declare const compileVue: (entryPoints: string[], vueRootDir: string, isDev?: boolean) => Promise<{
+export declare const compileVue: (entryPoints: string[], vueRootDir: string, isDev?: boolean, stylePreprocessors?: StylePreprocessorConfig) => Promise<{
     hmrMetadata: Map<string, {
         hmrId: string;
         changeType: VueChangeType;

package/dist/src/build/stylePreprocessor.d.ts

@@ -1,11 +1,13 @@
 import type { BunPlugin } from 'bun';
+import type { StylePreprocessorConfig } from '../../types/build';
 export declare const isPreprocessableStylePath: (filePath: string) => boolean;
 export declare const isStyleModulePath: (filePath: string) => boolean;
 export declare const isStylePath: (filePath: string) => boolean;
 export declare const getStyleBaseName: (filePath: string) => string;
-export declare const compileStyleSource: (filePath: string, source?: string, languageHint?: string) => Promise<string>;
+export declare const compileStyleSource: (filePath: string, source?: string, languageHint?: string, config?: StylePreprocessorConfig) => Promise<string>;
+export declare const createStylePreprocessorPlugin: (config?: StylePreprocessorConfig) => BunPlugin;
 export declare const stylePreprocessorPlugin: BunPlugin;
-export declare const createSvelteStylePreprocessor: () => {
+export declare const createSvelteStylePreprocessor: (config?: StylePreprocessorConfig) => {
     style: ({ attributes, content, filename }: {
         attributes: Record<string, string | boolean>;
         content: string;
@@ -14,6 +16,6 @@ export declare const createSvelteStylePreprocessor: () => {
         code: string;
     } | undefined>;
 };
-export declare const compileStyleFileIfNeeded: (filePath: string) => Promise<string>;
-export declare const compileStyleFileIfNeededSync: (filePath: string) => string;
+export declare const compileStyleFileIfNeeded: (filePath: string, config?: StylePreprocessorConfig) => Promise<string>;
+export declare const compileStyleFileIfNeededSync: (filePath: string, config?: StylePreprocessorConfig) => string;
 export declare const getCssOutputExtension: (filePath: string) => string;

package/dist/src/core/build.d.ts

@@ -1,6 +1,6 @@
 import type { ConventionsMap } from '../../types/conventions';
 import type { BuildConfig } from '../../types/build';
-export declare const build: ({ buildDirectory, assetsDirectory, publicDirectory, islands, reactDirectory, htmlDirectory, htmxDirectory, angularDirectory, svelteDirectory, vueDirectory, stylesConfig, tailwind, options, incrementalFiles, mode }: BuildConfig) => Promise<{
+export declare const build: ({ buildDirectory, assetsDirectory, publicDirectory, islands, reactDirectory, htmlDirectory, htmxDirectory, angularDirectory, svelteDirectory, vueDirectory, stylesConfig, stylePreprocessors, tailwind, options, incrementalFiles, mode }: BuildConfig) => Promise<{
     conventions?: undefined;
     manifest?: undefined;
 } | {

package/dist/src/dev/moduleServer.d.ts

@@ -1,3 +1,4 @@
+import type { StylePreprocessorConfig } from '../../types/build';
 type ModuleServerConfig = {
     projectRoot: string;
     vendorPaths: Record<string, string>;
@@ -7,6 +8,7 @@ type ModuleServerConfig = {
         svelte?: string;
         vue?: string;
     };
+    stylePreprocessors?: StylePreprocessorConfig;
 };
 export declare const warmCompilers: (frameworks: {
     svelte?: boolean;

package/dist/svelte/index.js

@@ -359,10 +359,12 @@ var init_lowerAwaitSlotSyntax = __esm(() => {
 });
 
 // src/build/stylePreprocessor.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { readFile } from "fs/promises";
 import { createRequire } from "module";
-import { dirname, extname, join as join2 } 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, extname, isAbsolute, join as join2, relative, resolve as resolve2 } 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";
@@ -370,19 +372,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 = []) => [
+  dirname(filePath),
+  process.cwd(),
+  ...paths.map((path) => resolve2(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 = resolve2(cwd, "tsconfig.json");
+  const empty = { aliases: [], baseUrl: cwd, cwd };
+  if (!existsSync2(tsconfigPath)) {
+    tsconfigAliasCache = empty;
+    return empty;
+  }
+  try {
+    const parsed = JSON.parse(stripJsonComments(readFileSync2(tsconfigPath, "utf-8")));
+    const compilerOptions = parsed.compilerOptions ?? {};
+    const baseUrl = resolve2(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(resolve2(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}`,
+    join2(basePath, `index${extension}`)
+  ]);
+  if (language === "scss" || language === "sass") {
+    return paths.flatMap((path) => {
+      const dir = dirname(path);
+      const base = path.slice(dir.length + 1);
+      return [path, join2(dir, `_${base}`)];
+    });
+  }
+  return paths;
+}, resolveImportPath = (specifier, fromDirectory, loadPaths, language, config) => {
+  const rawCandidates = [
+    ...resolveAliasTargets(specifier, config),
+    isAbsolute(specifier) ? specifier : resolve2(fromDirectory, specifier),
+    ...loadPaths.map((path) => resolve2(path, specifier))
+  ];
+  for (const candidate of rawCandidates.flatMap((path) => getCandidatePaths(path, language))) {
+    if (existsSync2(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 = dirname(sourceFile);
+  const entryDir = dirname(entryFile);
+  if (sourceDir === entryDir)
+    return contents;
+  return contents.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (match, quote, rawUrl) => {
+    const trimmedUrl = rawUrl.trim();
+    if (!trimmedUrl || isExternalCssUrl(trimmedUrl))
+      return match;
+    const { marker, path } = splitCssUrl(trimmedUrl);
+    const rebased = relative(entryDir, resolve2(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, dirname(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 ? dirname(fileURLToPath(options.containingUrl)) : dirname(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(readFileSync2(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, resolve2(currentDirectory), loadPaths, "less", config));
+    manager.loadFile = async (filename, currentDirectory) => {
+      const resolved = resolveImportPath(filename, resolve2(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: [dirname(filePath), process.cwd()],
+      importers: [
+        createSassImporter(filePath, loadPaths, language, config)
+      ],
+      loadPaths,
       style: "expanded",
       syntax: language === "sass" ? "indented" : "scss",
       url: new URL(`file://${filePath}`)
@@ -390,6 +587,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");
@@ -400,14 +598,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: [dirname(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,
@@ -418,63 +665,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(join2(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, dirname as dirname2, extname as extname2, join as join3, relative, resolve as resolve2 } from "path";
+import { basename, dirname as dirname2, extname as extname2, join as join3, relative as relative2, resolve as resolve3 } from "path";
 var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, ensureRelativeImportPath = (from, target) => {
-  const importPath = relative(dirname2(from), target).replace(/\\/g, "/");
+  const importPath = relative2(dirname2(from), target).replace(/\\/g, "/");
   return importPath.startsWith(".") ? importPath : `./${importPath}`;
 }, processDirectoryEntries = (entries, dir, targetFileName, stack) => {
   for (const entry of entries) {
@@ -520,7 +734,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const basePath = resolve2(dirname2(from), spec);
+  const basePath = resolve3(dirname2(from), spec);
   const candidates = [
     basePath,
     `${basePath}.ts`,
@@ -538,7 +752,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 join3(serverCacheRoot, `${normalizedSourcePath}.server.js`);
 }, resolveSvelteImport = async (spec, from) => {
@@ -552,7 +766,7 @@ var serverCacheRoot, compiledModuleCache, originalSourcePathCache, transpiler, e
   if (!spec.startsWith(".")) {
     return null;
   }
-  const explicitPath = resolve2(dirname2(from), spec);
+  const explicitPath = resolve3(dirname2(from), spec);
   if (extname2(explicitPath) === ".svelte") {
     return explicitPath;
   }
@@ -1736,12 +1950,12 @@ var init_startupBanner = __esm(() => {
 // src/utils/logger.ts
 var colors2, frameworkColors, formatPath = (filePath) => {
   const cwd = process.cwd();
-  let relative2 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
-  relative2 = relative2.replace(/\\/g, "/");
-  if (!relative2.startsWith("/")) {
-    relative2 = `/${relative2}`;
+  let relative3 = filePath.startsWith(cwd) ? filePath.slice(cwd.length + 1) : filePath;
+  relative3 = relative3.replace(/\\/g, "/");
+  if (!relative3.startsWith("/")) {
+    relative3 = `/${relative3}`;
   }
-  return relative2;
+  return relative3;
 }, getFrameworkColor = (framework) => frameworkColors[framework] || colors2.white, log = (action, options) => {
   const timestamp = `${colors2.dim}${formatTimestamp()}${colors2.reset}`;
   const tag = `${colors2.cyan}[hmr]${colors2.reset}`;
@@ -2282,8 +2496,8 @@ var init_pageHandler = __esm(() => {
 });
 
 // src/angular/injectorPatch.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
-import { dirname as dirname3, join as join4, resolve as resolve3 } from "path";
+import { existsSync as existsSync3, readFileSync as readFileSync3, writeFileSync } from "fs";
+import { dirname as dirname3, join as join4, resolve as resolve4 } from "path";
 var applyInjectorPatch = (chunkPath, content) => {
   if (content.includes('Symbol.for("angular.currentInjector")')) {
     return;
@@ -2319,8 +2533,8 @@ var applyInjectorPatch = (chunkPath, content) => {
   }
   writeFileSync(chunkPath, patched, "utf-8");
 }, resolveAngularCoreDir = () => {
-  const fromProject = resolve3(process.cwd(), "node_modules/@angular/core");
-  if (existsSync2(join4(fromProject, "package.json"))) {
+  const fromProject = resolve4(process.cwd(), "node_modules/@angular/core");
+  if (existsSync3(join4(fromProject, "package.json"))) {
     return fromProject;
   }
   return dirname3(__require.resolve("@angular/core/package.json"));
@@ -2328,7 +2542,7 @@ var applyInjectorPatch = (chunkPath, content) => {
   try {
     const coreDir = resolveAngularCoreDir();
     const chunkPath = join4(coreDir, "fesm2022", "_not_found-chunk.mjs");
-    const content = readFileSync2(chunkPath, "utf-8");
+    const content = readFileSync3(chunkPath, "utf-8");
     applyInjectorPatch(chunkPath, content);
   } catch {}
 };
@@ -2337,11 +2551,11 @@ var init_injectorPatch = __esm(() => {
 });
 
 // src/angular/resolveAngularPackage.ts
-import { existsSync as existsSync3 } from "fs";
-import { resolve as resolve4 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { resolve as resolve5 } from "path";
 var resolveAngularPackage = (specifier) => {
-  const fromProject = resolve4(process.cwd(), "node_modules", specifier);
-  if (existsSync3(fromProject)) {
+  const fromProject = resolve5(process.cwd(), "node_modules", specifier);
+  if (existsSync4(fromProject)) {
     return fromProject;
   }
   return specifier;
@@ -3160,5 +3374,5 @@ export {
   createTypedIsland
 };
 
-//# debugId=FEADEE763F16AA9D64756E2164756E21
+//# debugId=436071CA69710DBB64756E2164756E21
 //# sourceMappingURL=index.js.map