@absolutejs/absolute 0.19.0-beta.807 → 0.19.0-beta.809

package/dist/chunk-xnt8c6h2.js

@@ -1,576 +0,0 @@
-// @bun
-// src/build/stylePreprocessor.ts
-import { createHash } from "crypto";
-import { existsSync, readFileSync } from "fs";
-import { readFile } from "fs/promises";
-import { createRequire } from "module";
-import {
-  dirname,
-  extname,
-  isAbsolute,
-  join,
-  relative,
-  resolve
-} from "path";
-import { fileURLToPath } from "url";
-var CSS_EXTENSION_PATTERN = /\.css$/i;
-var STYLE_EXTENSION_PATTERN = /\.(s[ac]ss|less|styl(?:us)?)$/i;
-var STYLE_MODULE_EXTENSION_PATTERN = /\.module\.(s[ac]ss|less|styl(?:us)?)$/i;
-var STYLE_LANGUAGE_PATTERN = /^(s[ac]ss|less|styl(?:us)?)$/i;
-var importOptionalPeer = new Function("specifier", "return import(specifier)");
-var requireOptionalPeer = new Function("specifier", "return require(specifier)");
-var requireFromCwd = createRequire(join(process.cwd(), "package.json"));
-var isPreprocessableStylePath = (filePath) => STYLE_EXTENSION_PATTERN.test(filePath);
-var isStyleModulePath = (filePath) => STYLE_MODULE_EXTENSION_PATTERN.test(filePath);
-var isStylePath = (filePath) => /\.(css|s[ac]ss|less|styl(?:us)?)$/i.test(filePath);
-var getStyleBaseName = (filePath) => filePath.replace(/\.(css|s[ac]ss|less|styl(?:us)?)$/i, "");
-var getStyleLanguage = (filePathOrLanguage) => {
-  const normalized = filePathOrLanguage.toLowerCase();
-  if (normalized === "scss" || normalized.endsWith(".scss"))
-    return "scss";
-  if (normalized === "sass" || normalized.endsWith(".sass"))
-    return "sass";
-  if (normalized === "less" || normalized.endsWith(".less"))
-    return "less";
-  if (normalized === "styl" || normalized === "stylus" || normalized.endsWith(".styl") || normalized.endsWith(".stylus"))
-    return "stylus";
-  return null;
-};
-var missingDependencyError = (name, filePath) => new Error(`Unable to compile ${filePath}: install optional dependency "${name}" to use this stylesheet preprocessor.`);
-var throwPreprocessorError = (error, filePath, language) => {
-  if (!(error instanceof Error)) {
-    throw new Error(`${language} compile failed in ${filePath}: ${String(error)}`);
-  }
-  const detail = error;
-  const sassLine = detail.span?.start?.line;
-  const sassCol = detail.span?.start?.column;
-  const line = detail.line ?? sassLine;
-  const column = detail.column ?? sassCol;
-  const location = typeof line === "number" ? `:${line}${typeof column === "number" ? `:${column}` : ""}` : "";
-  const message = detail.formatted ?? detail.message;
-  const wrapped = new Error(`${language} compile failed in ${filePath}${location}
-${message}`);
-  wrapped.cause = error;
-  throw wrapped;
-};
-var requireOptionalPeerSync = (specifier) => {
-  try {
-    return requireFromCwd(specifier);
-  } catch {
-    return requireOptionalPeer(specifier);
-  }
-};
-var normalizeLoadPaths = (filePath, paths = []) => [
-  dirname(filePath),
-  process.cwd(),
-  ...paths.map((path) => resolve(process.cwd(), path))
-];
-var tsconfigAliasCache;
-var stripJsonComments = (source) => source.replace(/\/\*[\s\S]*?\*\//g, "").replace(/(^|[^:])\/\/.*$/gm, "$1");
-var normalizeAliasEntries = (aliases) => Object.entries(aliases ?? {}).map(([pattern, value]) => ({
-  pattern,
-  replacements: Array.isArray(value) ? value : [value]
-}));
-var readTsconfigAliases = () => {
-  const cwd = process.cwd();
-  if (tsconfigAliasCache?.cwd === cwd)
-    return tsconfigAliasCache;
-  const tsconfigPath = resolve(cwd, "tsconfig.json");
-  const empty = { aliases: [], baseUrl: cwd, cwd };
-  if (!existsSync(tsconfigPath)) {
-    tsconfigAliasCache = empty;
-    return empty;
-  }
-  try {
-    const parsed = JSON.parse(stripJsonComments(readFileSync(tsconfigPath, "utf-8")));
-    const compilerOptions = parsed.compilerOptions ?? {};
-    const baseUrl = resolve(cwd, compilerOptions.baseUrl ?? ".");
-    tsconfigAliasCache = {
-      aliases: normalizeAliasEntries(compilerOptions.paths),
-      baseUrl,
-      cwd
-    };
-  } catch {
-    tsconfigAliasCache = empty;
-  }
-  return tsconfigAliasCache;
-};
-var getAliasEntries = (config) => {
-  const tsconfig = readTsconfigAliases();
-  return {
-    aliases: [
-      ...normalizeAliasEntries(config?.aliases),
-      ...tsconfig.aliases
-    ],
-    baseUrl: tsconfig.baseUrl
-  };
-};
-var aliasPatternToRegExp = (pattern) => new RegExp(`^${pattern.split("*").map((part) => part.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("(.+)")}$`);
-var resolveAliasTargets = (specifier, config) => {
-  const { aliases, baseUrl } = getAliasEntries(config);
-  const targets = [];
-  for (const alias of aliases) {
-    const match = specifier.match(aliasPatternToRegExp(alias.pattern));
-    if (!match)
-      continue;
-    const wildcard = match[1] ?? "";
-    for (const replacement of alias.replacements) {
-      targets.push(resolve(baseUrl, replacement.replace("*", wildcard)));
-    }
-  }
-  return targets;
-};
-var getLanguageExtensions = (language) => {
-  if (language === "less")
-    return [".less", ".css"];
-  if (language === "stylus")
-    return [".styl", ".stylus", ".css"];
-  return [".scss", ".sass", ".css"];
-};
-var getCandidatePaths = (basePath, language) => {
-  const ext = extname(basePath);
-  const paths = ext ? [basePath] : getLanguageExtensions(language).flatMap((extension) => [
-    `${basePath}${extension}`,
-    join(basePath, `index${extension}`)
-  ]);
-  if (language === "scss" || language === "sass") {
-    return paths.flatMap((path) => {
-      const dir = dirname(path);
-      const base = path.slice(dir.length + 1);
-      return [path, join(dir, `_${base}`)];
-    });
-  }
-  return paths;
-};
-var resolveImportPath = (specifier, fromDirectory, loadPaths, language, config) => {
-  const rawCandidates = [
-    ...resolveAliasTargets(specifier, config),
-    isAbsolute(specifier) ? specifier : resolve(fromDirectory, specifier),
-    ...loadPaths.map((path) => resolve(path, specifier))
-  ];
-  for (const candidate of rawCandidates.flatMap((path) => getCandidatePaths(path, language))) {
-    if (existsSync(candidate))
-      return candidate;
-  }
-  return null;
-};
-var isExternalCssUrl = (url) => /^(?:[a-z][a-z0-9+.-]*:|\/\/|#|\/)/i.test(url);
-var splitCssUrl = (url) => {
-  const markerIndex = url.search(/[?#]/);
-  if (markerIndex === -1)
-    return { marker: "", path: url };
-  return {
-    marker: url.slice(markerIndex),
-    path: url.slice(0, markerIndex)
-  };
-};
-var rebaseCssUrls = (contents, sourceFile, entryFile) => {
-  const sourceDir = dirname(sourceFile);
-  const entryDir = dirname(entryFile);
-  if (sourceDir === entryDir)
-    return contents;
-  return contents.replace(/url\(\s*(['"]?)([^'")]+)\1\s*\)/gi, (match, quote, rawUrl) => {
-    const trimmedUrl = rawUrl.trim();
-    if (!trimmedUrl || isExternalCssUrl(trimmedUrl))
-      return match;
-    const { marker, path } = splitCssUrl(trimmedUrl);
-    const rebased = relative(entryDir, resolve(sourceDir, path)).replace(/\\/g, "/");
-    const normalized = rebased.startsWith(".") ? rebased : `./${rebased}`;
-    const nextQuote = quote || '"';
-    return `url(${nextQuote}${normalized}${marker}${nextQuote})`;
-  });
-};
-var rewriteAliasedStyleImports = (contents, sourceFile, loadPaths, language, config) => contents.replace(/(@(?:use|forward|import|require)\s+)(["'])([^"']+)\2/g, (match, prefix, quote, specifier) => {
-  if (specifier.startsWith(".") || isAbsolute(specifier) || isExternalCssUrl(specifier))
-    return match;
-  const resolved = resolveImportPath(specifier, dirname(sourceFile), loadPaths, language, config);
-  return resolved ? `${prefix}${quote}${resolved}${quote}` : match;
-});
-var preprocessLoadedStyle = (contents, sourceFile, entryFile, loadPaths = [], language, config) => {
-  const rebased = rebaseCssUrls(contents, sourceFile, entryFile);
-  return language ? rewriteAliasedStyleImports(rebased, sourceFile, loadPaths, language, config) : rebased;
-};
-var extractCssModuleExports = (css) => {
-  const exports = {};
-  const nextCss = css.replace(/:export\s*\{([^}]*)\}/g, (_, body) => {
-    for (const declaration of body.split(";")) {
-      const separator = declaration.indexOf(":");
-      if (separator === -1)
-        continue;
-      const key = declaration.slice(0, separator).trim();
-      const value = declaration.slice(separator + 1).trim();
-      if (key && value)
-        exports[key] = value;
-    }
-    return "";
-  });
-  return { css: nextCss, exports };
-};
-var getSassOptions = (config, language) => ({
-  ...config?.sass ?? {},
-  ...language === "scss" ? config?.scss ?? {} : {}
-});
-var getLessOptions = (config) => config?.less ?? {};
-var getStylusOptions = (config) => config?.stylus ?? {};
-var createStyleTransformConfig = (stylePreprocessors, postcss) => postcss === undefined ? stylePreprocessors : { ...stylePreprocessors ?? {}, postcss };
-var withAdditionalData = (contents, additionalData) => additionalData ? `${additionalData}
-${contents}` : contents;
-var normalizePostcssModule = (mod) => {
-  if (mod && typeof mod === "object" && "default" in mod) {
-    return mod.default ?? mod;
-  }
-  return mod;
-};
-var loadPostcssConfigFile = async (configPath) => {
-  const resolved = resolve(process.cwd(), configPath);
-  const loaded = resolved.endsWith(".cjs") || resolved.endsWith(".cts") ? requireOptionalPeerSync(resolved) : await importOptionalPeer(`${new URL(`file://${resolved}`).href}?t=${Date.now()}`);
-  const config = normalizePostcssModule(loaded);
-  const value = typeof config === "function" ? await config({
-    cwd: process.cwd(),
-    env: "development"
-  }) : config;
-  return normalizePostcssModule(value) ?? {};
-};
-var normalizePostcssPlugins = (plugins) => {
-  if (!plugins)
-    return [];
-  if (Array.isArray(plugins))
-    return plugins.filter(Boolean);
-  const resolved = [];
-  for (const [specifier, options] of Object.entries(plugins)) {
-    if (options === false)
-      continue;
-    const mod = normalizePostcssModule(requireOptionalPeerSync(specifier));
-    const plugin = typeof mod === "function" ? mod(options === true ? undefined : options) : mod;
-    if (plugin)
-      resolved.push(plugin);
-  }
-  return resolved;
-};
-var resolvePostcssConfig = async (config) => {
-  const inlineConfig = config?.postcss;
-  if (!inlineConfig)
-    return null;
-  const fileConfig = inlineConfig.config ? await loadPostcssConfigFile(inlineConfig.config) : {};
-  const plugins = [
-    ...normalizePostcssPlugins(fileConfig.plugins),
-    ...normalizePostcssPlugins(inlineConfig.plugins)
-  ];
-  if (plugins.length === 0)
-    return null;
-  return {
-    options: {
-      ...fileConfig.options ?? {},
-      ...inlineConfig.options ?? {}
-    },
-    plugins
-  };
-};
-var runPostcss = async (css, filePath, config) => {
-  const postcssConfig = await resolvePostcssConfig(config);
-  if (!postcssConfig)
-    return css;
-  let postcssModule;
-  try {
-    postcssModule = await importOptionalPeer("postcss");
-  } catch {
-    throw missingDependencyError("postcss", filePath);
-  }
-  const postcss = postcssModule.default ?? postcssModule;
-  const result = await postcss(postcssConfig.plugins).process(css, {
-    from: filePath,
-    map: false,
-    ...postcssConfig.options
-  });
-  return result.css;
-};
-var createSassImporter = (entryFile, loadPaths, language, config, deps) => ({
-  canonicalize(specifier, options) {
-    const fromDirectory = options.containingUrl ? dirname(fileURLToPath(options.containingUrl)) : dirname(entryFile);
-    const resolved = resolveImportPath(specifier, fromDirectory, loadPaths, language, config);
-    return resolved ? new URL(`file://${resolved}`) : null;
-  },
-  load(canonicalUrl) {
-    const filePath = fileURLToPath(canonicalUrl);
-    deps?.add(filePath);
-    const fileLanguage = getStyleLanguage(filePath);
-    if (fileLanguage !== "scss" && fileLanguage !== "sass" && fileLanguage !== null)
-      return null;
-    return {
-      contents: preprocessLoadedStyle(readFileSync(filePath, "utf-8"), filePath, entryFile, loadPaths, language, config),
-      syntax: filePath.endsWith(".sass") ? "indented" : "scss"
-    };
-  }
-});
-var createLessFileManager = (entryFile, loadPaths, config, deps) => ({
-  install(less, pluginManager) {
-    const baseManager = new less.FileManager;
-    const manager = Object.create(baseManager);
-    manager.supports = (filename, currentDirectory) => Boolean(resolveImportPath(filename, resolve(currentDirectory), loadPaths, "less", config));
-    manager.loadFile = async (filename, currentDirectory) => {
-      const resolved = resolveImportPath(filename, resolve(currentDirectory), loadPaths, "less", config);
-      if (!resolved) {
-        throw new Error(`Unable to resolve Less import "${filename}"`);
-      }
-      deps?.add(resolved);
-      return {
-        contents: preprocessLoadedStyle(await readFile(resolved, "utf-8"), resolved, entryFile, loadPaths, "less", config),
-        filename: resolved
-      };
-    };
-    pluginManager.addFileManager(manager);
-  }
-});
-var renderStylus = async (contents, filePath, loadPaths, options, deps) => {
-  let stylus;
-  try {
-    const stylusModule = await importOptionalPeer("stylus");
-    stylus = stylusModule.default ?? stylusModule;
-  } catch {
-    throw missingDependencyError("stylus", filePath);
-  }
-  return new Promise((resolveCss, reject) => {
-    const renderer = stylus(contents);
-    renderer.set("filename", filePath);
-    for (const [key, value] of Object.entries(options.options ?? {})) {
-      renderer.set(key, value);
-    }
-    for (const path of loadPaths)
-      renderer.include(path);
-    renderer.render((error, css) => {
-      if (error) {
-        reject(error);
-        return;
-      }
-      if (deps) {
-        const stylusDeps = renderer.deps?.();
-        if (Array.isArray(stylusDeps)) {
-          for (const dep of stylusDeps)
-            deps.add(resolve(dep));
-        }
-      }
-      resolveCss(css ?? "");
-    });
-  });
-};
-var styleDependencyGraph = new Map;
-var styleOutputHashes = new Map;
-var recordStyleDeps = (entry, deps) => {
-  const key = resolve(entry);
-  const stripped = new Set;
-  for (const dep of deps) {
-    const resolved = resolve(dep);
-    if (resolved !== key)
-      stripped.add(resolved);
-  }
-  styleDependencyGraph.set(key, stripped);
-};
-var addStyleImporter = (importerPath, stylePath) => {
-  const key = resolve(importerPath);
-  const target = resolve(stylePath);
-  const deps = styleDependencyGraph.get(key) ?? new Set;
-  deps.add(target);
-  styleDependencyGraph.set(key, deps);
-};
-var findStyleEntriesImporting = (changedPath) => {
-  const target = resolve(changedPath);
-  const importers = [];
-  for (const [entry, deps] of styleDependencyGraph) {
-    if (deps.has(target))
-      importers.push(entry);
-  }
-  return importers;
-};
-var recordStyleOutput = (entry, css) => {
-  const key = resolve(entry);
-  const hash = createHash("sha1").update(css).digest("hex");
-  const previous = styleOutputHashes.get(key);
-  styleOutputHashes.set(key, hash);
-  return previous !== hash;
-};
-var forgetStyleEntry = (entry) => {
-  const key = resolve(entry);
-  styleDependencyGraph.delete(key);
-  styleOutputHashes.delete(key);
-};
-var compileStyleSource = async (filePath, source, languageHint, config) => {
-  const language = getStyleLanguage(languageHint ?? filePath);
-  const rawContents = source ?? await readFile(filePath, "utf-8");
-  const deps = new Set;
-  if (language === "scss" || language === "sass") {
-    const options = getSassOptions(config, language);
-    const packageName = options.implementation ?? "sass";
-    let sass;
-    try {
-      sass = await importOptionalPeer(packageName);
-    } catch {
-      throw missingDependencyError(packageName, filePath);
-    }
-    const contents = withAdditionalData(rawContents, options.additionalData);
-    const loadPaths = normalizeLoadPaths(filePath, options.loadPaths);
-    try {
-      const result = sass.compileString(contents, {
-        importers: [
-          createSassImporter(filePath, loadPaths, language, config, deps)
-        ],
-        loadPaths,
-        style: "expanded",
-        syntax: language === "sass" ? "indented" : "scss",
-        url: new URL(`file://${filePath}`)
-      });
-      const css = await runPostcss(result.css, filePath, config);
-      recordStyleDeps(filePath, deps);
-      return css;
-    } catch (error) {
-      throwPreprocessorError(error, filePath, language);
-    }
-  }
-  if (language === "less") {
-    const options = getLessOptions(config);
-    let lessModule;
-    try {
-      lessModule = await importOptionalPeer("less");
-    } catch {
-      throw missingDependencyError("less", filePath);
-    }
-    const less = lessModule.render ? lessModule : lessModule.default;
-    const render = less?.render;
-    if (!render)
-      throw missingDependencyError("less", filePath);
-    const contents = withAdditionalData(rawContents, options.additionalData);
-    const loadPaths = normalizeLoadPaths(filePath, options.paths);
-    try {
-      const result = await render(contents, {
-        ...options.options ?? {},
-        filename: filePath,
-        paths: loadPaths,
-        plugins: [
-          ...options.options?.plugins ?? [],
-          createLessFileManager(filePath, loadPaths, config, deps)
-        ]
-      });
-      const css = await runPostcss(result.css, filePath, config);
-      recordStyleDeps(filePath, deps);
-      return css;
-    } catch (error) {
-      throwPreprocessorError(error, filePath, "less");
-    }
-  }
-  if (language === "stylus") {
-    const options = getStylusOptions(config);
-    const loadPaths = normalizeLoadPaths(filePath, options.paths);
-    const contents = withAdditionalData(preprocessLoadedStyle(rawContents, filePath, filePath, loadPaths, "stylus", config), options.additionalData);
-    try {
-      const css = await runPostcss(await renderStylus(contents, filePath, loadPaths, options, deps), filePath, config);
-      recordStyleDeps(filePath, deps);
-      return css;
-    } catch (error) {
-      throwPreprocessorError(error, filePath, "stylus");
-    }
-  }
-  return runPostcss(rawContents, filePath, config);
-};
-var createStylePreprocessorPlugin = (config) => ({
-  name: "absolute-style-preprocessor",
-  setup(build) {
-    const cssModuleSources = new Map;
-    build.onResolve({ filter: /^absolute-style-module:/ }, ({ path }) => ({
-      namespace: "absolute-style-module",
-      path: path.slice("absolute-style-module:".length)
-    }));
-    build.onLoad({ filter: /\.module\.css$/i, namespace: "absolute-style-module" }, async ({ path }) => {
-      const source = cssModuleSources.get(path);
-      if (!source) {
-        throw new Error(`Unable to resolve CSS module source for ${path}`);
-      }
-      return {
-        contents: source.css,
-        loader: "css"
-      };
-    });
-    build.onLoad({ filter: STYLE_EXTENSION_PATTERN }, async ({ path }) => {
-      if (isStyleModulePath(path)) {
-        const cssModulePath = path.replace(STYLE_EXTENSION_PATTERN, ".css");
-        const compiled = await compileStyleSource(path, undefined, undefined, config);
-        const { css, exports } = extractCssModuleExports(compiled);
-        cssModuleSources.set(cssModulePath, { css, exports });
-        const exportSource = Object.keys(exports).length > 0 ? `import styles from ${JSON.stringify(`absolute-style-module:${cssModulePath}`)}; export default Object.assign({}, styles, ${JSON.stringify(exports)});` : `export { default } from ${JSON.stringify(`absolute-style-module:${cssModulePath}`)};`;
-        return {
-          contents: exportSource,
-          loader: "js"
-        };
-      }
-      return {
-        contents: await compileStyleSource(path, undefined, undefined, config),
-        loader: "css"
-      };
-    });
-    build.onLoad({ filter: CSS_EXTENSION_PATTERN }, async ({ path }) => ({
-      contents: await compileStyleSource(path, undefined, undefined, config),
-      loader: "css"
-    }));
-  }
-});
-var stylePreprocessorPlugin = createStylePreprocessorPlugin();
-var createSvelteStylePreprocessor = (config) => ({
-  style: async ({
-    attributes,
-    content,
-    filename
-  }) => {
-    const language = typeof attributes.lang === "string" ? attributes.lang : typeof attributes.type === "string" ? attributes.type.replace(/^text\//, "") : null;
-    if (!language || !STYLE_LANGUAGE_PATTERN.test(language))
-      return;
-    const path = filename ?? `style.${language}`;
-    return {
-      code: await compileStyleSource(path, content, language, config)
-    };
-  }
-});
-var compileStyleFileIfNeeded = async (filePath, config) => {
-  if (!isPreprocessableStylePath(filePath)) {
-    return runPostcss(await readFile(filePath, "utf-8"), filePath, config);
-  }
-  return compileStyleSource(filePath, undefined, undefined, config);
-};
-var compileStyleFileIfNeededSync = (filePath, config) => {
-  const rawContents = readFileSync(filePath, "utf-8");
-  const language = getStyleLanguage(filePath);
-  if (config?.postcss) {
-    throw new Error(`Unable to compile ${filePath}: PostCSS preprocessing is async-only.`);
-  }
-  if (language === "scss" || language === "sass") {
-    const options = getSassOptions(config, language);
-    const packageName = options.implementation ?? "sass";
-    let sass;
-    try {
-      sass = requireOptionalPeerSync(packageName);
-    } catch {
-      throw missingDependencyError(packageName, filePath);
-    }
-    const contents = withAdditionalData(rawContents, options.additionalData);
-    const loadPaths = normalizeLoadPaths(filePath, options.loadPaths);
-    return sass.compileString(contents, {
-      importers: [
-        createSassImporter(filePath, loadPaths, language, config)
-      ],
-      loadPaths,
-      style: "expanded",
-      syntax: language === "sass" ? "indented" : "scss",
-      url: new URL(`file://${filePath}`)
-    }).css;
-  }
-  if (language === "less") {
-    throw new Error(`Unable to compile ${filePath}: Less styleUrl preprocessing is async-only. Import the Less file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
-  }
-  if (language === "stylus") {
-    throw new Error(`Unable to compile ${filePath}: Stylus styleUrl preprocessing is async-only. Import the Stylus file from a bundled entrypoint or use SCSS/CSS for Angular styleUrl.`);
-  }
-  return rawContents;
-};
-var getCssOutputExtension = (filePath) => isPreprocessableStylePath(filePath) ? ".css" : extname(filePath);
-
-export { isPreprocessableStylePath, isStyleModulePath, isStylePath, getStyleBaseName, createStyleTransformConfig, addStyleImporter, findStyleEntriesImporting, recordStyleOutput, forgetStyleEntry, compileStyleSource, createStylePreprocessorPlugin, stylePreprocessorPlugin, createSvelteStylePreprocessor, compileStyleFileIfNeeded, compileStyleFileIfNeededSync, getCssOutputExtension };
-
-//# debugId=634C187AA2D5975464756E2164756E21
-//# sourceMappingURL=chunk-xnt8c6h2.js.map