@csszyx/unplugin 0.11.11 → 0.13.0

package/dist/next-turbo-loader.mjs

@@ -1,62 +1,15 @@
 import { createHash } from 'node:crypto';
 import * as path from 'node:path';
-import { c as createNextStateContext, w as writeNextSafelistShard, r as runNextWatcherCycle, v as validateNextGenerationManifest, a as readNextGenerationManifest } from './shared/unplugin.DMcbmP01.mjs';
-import { r as readPackageVersion, t as transformNextSource, c as collectNextTransformMetadata, a as createNextSafelistShardFromMetadata } from './shared/unplugin.-yLpX1Ck.mjs';
-import { i as importsRuntimeHelper, a as insertAfterUseDirective } from './shared/unplugin.Lhzkcj-A.mjs';
-import { r as resolveTransformCacheDir, n as normalizePathSeparators } from './shared/unplugin.fOnGXWgS.mjs';
+import { i as injectNextRuntimeImports, e as ensureThemeGroupsFile, a as insertAfterUseDirective, t as themeGroupsSpecifier } from './shared/unplugin.5l4RHMQh.mjs';
+import { r as readPackageVersion, c as configWithImportedStaticSz, a as resolveNextCrossModule, t as transformNextSource, w as withCrossModuleStatics, n as normalizeProviderPaths, b as collectNextTransformMetadata, d as createNextSafelistShardFromMetadata } from './shared/unplugin.CogPHmDs.mjs';
+import { c as createNextStateContext, w as writeNextSafelistShard, r as runNextWatcherCycle, v as validateNextGenerationManifest, a as readNextGenerationManifest } from './shared/unplugin.BU0O4IkX.mjs';
+import { r as resolveTransformCacheDir, n as normalizePathSeparators } from './shared/unplugin.BB0iWSds.mjs';
 import 'node:fs';
-import 'node:os';
-import 'proper-lockfile';
 import './shared/unplugin.B3XoSRB8.mjs';
 import '@csszyx/compiler';
-
-function injectNextRuntimeImports(code, usage) {
-  const helpers = runtimeHelpersFromUsage(usage);
-  if (helpers.length === 0) {
-    return { code, injected: [] };
-  }
-  const hasRuntimeImport = code.includes("@csszyx/runtime");
-  const missing = hasRuntimeImport ? helpers.filter((helper) => !importsRuntimeHelper(code, helper)) : helpers;
-  if (missing.length === 0) {
-    return { code, injected: [] };
-  }
-  return {
-    code: insertRuntimeImport(
-      code,
-      `import { ${missing.join(", ")} } from '@csszyx/runtime';
-`
-    ),
-    injected: missing
-  };
-}
-function runtimeHelpersFromUsage(usage) {
-  const helpers = [];
-  if (usage.usesRuntime) {
-    helpers.push("_sz");
-  }
-  if (usage.usesMerge) {
-    helpers.push("_szMerge");
-  }
-  if (usage.usesSzcn) {
-    helpers.push("_szcn");
-  }
-  if (usage.usesSzPart) {
-    helpers.push("_szPart");
-  }
-  if (usage.usesColorVar) {
-    helpers.push("__szColorVar");
-  }
-  if (usage.usesSpacingVar) {
-    helpers.push("__szSpacingVar");
-  }
-  if (usage.usesUnitVar) {
-    helpers.push("__szUnitVar");
-  }
-  return helpers;
-}
-function insertRuntimeImport(code, importStmt) {
-  return insertAfterUseDirective(code, importStmt);
-}
+import '@csszyx/types';
+import 'node:os';
+import 'proper-lockfile';
 
 function runNextTurboLoader(source, loaderContext, explicitOptions = {}) {
   const options = normalizeOptions(loaderContext, explicitOptions);
@@ -67,7 +20,7 @@ function runNextTurboLoader(source, loaderContext, explicitOptions = {}) {
     loaderContext: loaderContext.context,
     cacheDir: options.cacheDir,
     safelistOutputFile: options.safelistOutputFile,
-    config: options.config ?? {},
+    config: configWithImportedStaticSz(options.config ?? {}, options.importedStaticSz),
     env: options.env ?? process.env,
     envKeys: options.envKeys,
     nextVersion: options.nextVersion ?? "unknown-next",
@@ -76,11 +29,17 @@ function runNextTurboLoader(source, loaderContext, explicitOptions = {}) {
     mode: options.mode ?? normalizeMode(loaderContext.mode)
   });
   assertProductionManifestReady(context, options);
+  const crossModule = resolveNextCrossModule({
+    filename: loaderContext.resourcePath,
+    source,
+    root: context.root,
+    importedStaticSz: options.importedStaticSz
+  });
   const transform = transformNextSource({
     source,
     filename: loaderContext.resourcePath,
     parserMode: options.parserMode ?? "rust",
-    compilerOptions: options.compilerOptions,
+    compilerOptions: withCrossModuleStatics(options.compilerOptions, crossModule.statics),
     cacheRoot: resolveTransformCacheDir(
       context.root,
       path.relative(context.root, context.cacheDir)
@@ -91,6 +50,17 @@ function runNextTurboLoader(source, loaderContext, explicitOptions = {}) {
     allowBabelFallback: options.allowBabelFallback
   });
   const injected = injectNextRuntimeImports(transform.result.code, transform.result);
+  const callsSzcn = transform.result.usesSzcn || /\bszcn\s*\(/.test(source);
+  const themeGroups = callsSzcn ? ensureThemeGroupsFile(context.root, path.join(context.root, ".csszyx")) : { file: null, watch: [] };
+  for (const stylesheet of themeGroups.watch) loaderContext.addDependency?.(stylesheet);
+  for (const provider of normalizeProviderPaths(crossModule.providers)) {
+    loaderContext.addDependency?.(provider);
+  }
+  const code = themeGroups.file === null ? injected.code : insertAfterUseDirective(
+    injected.code,
+    `import '${themeGroupsSpecifier(loaderContext.resourcePath, themeGroups.file)}';
+`
+  );
   const metadata = collectNextTransformMetadata(
     transform.result,
     source,
@@ -116,12 +86,12 @@ function runNextTurboLoader(source, loaderContext, explicitOptions = {}) {
     materialized = true;
   }
   return {
-    code: injected.code,
+    code,
     context,
     transform,
     shardPath,
     materialized,
-    dependencies: []
+    dependencies: themeGroups.watch
   };
 }
 function nextTurboLoader(source) {

package/dist/next-watcher.cjs

@@ -1,7 +1,7 @@
 'use strict';
 
 const path = require('node:path');
-const nextWatcherCycle = require('./shared/unplugin.DblMogcN.cjs');
+const nextWatcherCycle = require('./shared/unplugin.Cji6O5jv.cjs');
 require('node:fs');
 require('node:crypto');
 require('node:os');

package/dist/next-watcher.mjs

@@ -1,5 +1,5 @@
 import * as path from 'node:path';
-import { r as runNextWatcherCycle } from './shared/unplugin.DMcbmP01.mjs';
+import { r as runNextWatcherCycle } from './shared/unplugin.BU0O4IkX.mjs';
 import 'node:fs';
 import 'node:crypto';
 import 'node:os';

package/dist/shared/unplugin.4du3qMst.cjs

@@ -0,0 +1,529 @@
+'use strict';
+
+const compiler = require('@csszyx/compiler');
+const path = require('node:path');
+const fs = require('node:fs');
+const node_crypto = require('node:crypto');
+
+function _interopNamespaceCompat(e) {
+    if (e && typeof e === 'object' && 'default' in e) return e;
+    const n = Object.create(null);
+    if (e) {
+        for (const k in e) {
+            n[k] = e[k];
+        }
+    }
+    n.default = e;
+    return n;
+}
+
+const path__namespace = /*#__PURE__*/_interopNamespaceCompat(path);
+const fs__namespace = /*#__PURE__*/_interopNamespaceCompat(fs);
+
+const WINDOWS_PATH_SEPARATOR = String.fromCodePoint(92);
+function normalizePathSeparators(value) {
+  return value.split(WINDOWS_PATH_SEPARATOR).join("/");
+}
+
+function babelFallbackReason(error) {
+  if (error instanceof compiler.OxcNotImplementedError) {
+    return error.detail;
+  }
+  return error instanceof Error ? error.message : String(error);
+}
+
+const TSCONFIG_CANDIDATES = ["tsconfig.json", "jsconfig.json", "tsconfig.app.json"];
+const MAX_EXTENDS_DEPTH = 8;
+function collectSpecifierAliases(rootDir, resolveAlias) {
+  return [...aliasesFromResolveConfig(rootDir, resolveAlias), ...aliasesFromTsconfig(rootDir)];
+}
+function aliasesFromResolveConfig(rootDir, raw) {
+  const aliases = [];
+  if (Array.isArray(raw)) {
+    for (const entry of raw) {
+      const find = entry.find;
+      const replacement = entry.replacement;
+      if (typeof find !== "string" || typeof replacement !== "string") continue;
+      aliases.push(makeAlias(rootDir, find, replacement));
+    }
+    return aliases;
+  }
+  if (raw === null || typeof raw !== "object") return aliases;
+  for (const [find, target] of Object.entries(raw)) {
+    for (const value of Array.isArray(target) ? target : [target]) {
+      if (typeof value !== "string") continue;
+      aliases.push(makeAlias(rootDir, find, value));
+    }
+  }
+  return aliases;
+}
+function makeAlias(rootDir, find, replacement) {
+  const exact = find.endsWith("$");
+  return {
+    find: exact ? find.slice(0, -1) : find,
+    replacement: absolute(rootDir, replacement),
+    exact
+  };
+}
+function aliasesFromTsconfig(rootDir) {
+  for (const candidate of TSCONFIG_CANDIDATES) {
+    const loaded = loadPathsConfig(path__namespace.join(rootDir, candidate), 0);
+    if (loaded === void 0) continue;
+    const aliases = pathsToAliases(loaded.base, loaded.paths);
+    if (aliases.length > 0) return aliases;
+  }
+  return [];
+}
+function loadPathsConfig(configPath, depth) {
+  if (depth > MAX_EXTENDS_DEPTH) return void 0;
+  let parsed;
+  try {
+    parsed = parseJsonc(fs__namespace.readFileSync(configPath, "utf-8"));
+  } catch {
+    return void 0;
+  }
+  const directory = path__namespace.dirname(configPath);
+  const compilerOptions = asRecord(parsed.compilerOptions);
+  const paths = asRecord(compilerOptions?.paths);
+  if (paths !== void 0) {
+    const baseUrl = compilerOptions?.baseUrl;
+    return {
+      base: typeof baseUrl === "string" ? absolute(directory, baseUrl) : absolute(directory, "."),
+      paths
+    };
+  }
+  const extended = parsed.extends;
+  if (typeof extended !== "string" || !extended.startsWith(".")) return void 0;
+  const resolved = path__namespace.resolve(directory, extended);
+  return loadPathsConfig(resolved, depth + 1) ?? loadPathsConfig(`${resolved}.json`, depth + 1);
+}
+function pathsToAliases(base, paths) {
+  return Object.entries(paths).flatMap(
+    ([pattern, targets]) => patternToAliases(base, pattern, targets)
+  );
+}
+function patternToAliases(base, pattern, targets) {
+  const wildcard = pattern.indexOf("*");
+  if (wildcard !== -1 && wildcard !== pattern.length - 1) return [];
+  const exact = wildcard === -1;
+  const find = exact ? pattern : pattern.slice(0, -1);
+  const declared = Array.isArray(targets) ? targets : [targets];
+  return declared.filter((target) => typeof target === "string").map((target) => ({
+    find,
+    replacement: absolute(base, target.endsWith("*") ? target.slice(0, -1) : target),
+    exact
+  }));
+}
+function aliasedSpecifierBases(specifier, aliases) {
+  const bases = [];
+  for (const alias of aliases) {
+    if (alias.exact) {
+      if (specifier === alias.find) bases.push(alias.replacement);
+      continue;
+    }
+    if (!specifier.startsWith(alias.find)) continue;
+    bases.push(normalizePathSeparators(alias.replacement + specifier.slice(alias.find.length)));
+  }
+  return bases;
+}
+function absolute(directory, target) {
+  const resolved = normalizePathSeparators(path__namespace.resolve(directory, target));
+  const declaredTrailingSlash = target.endsWith("/") || target.endsWith("\\");
+  return declaredTrailingSlash && !resolved.endsWith("/") ? `${resolved}/` : resolved;
+}
+function asRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function parseJsonc(text) {
+  const parsed = JSON.parse(stripComments(text).replace(/,(\s*[}\]])/g, "$1"));
+  return asRecord(parsed) ?? {};
+}
+function stripComments(text) {
+  const out = [];
+  let index = 0;
+  while (index < text.length) {
+    const run = consumeString(text, index) ?? consumeComment(text, index);
+    if (run === void 0) {
+      out.push(text[index]);
+      index += 1;
+      continue;
+    }
+    out.push(run.keep);
+    index = run.next;
+  }
+  return out.join("");
+}
+function consumeString(text, start) {
+  if (text[start] !== '"') return void 0;
+  let index = start + 1;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "\\") {
+      index += 2;
+      continue;
+    }
+    index += 1;
+    if (char === '"') break;
+  }
+  return { keep: text.slice(start, index), next: index };
+}
+function consumeComment(text, start) {
+  if (text[start] !== "/") return void 0;
+  if (text[start + 1] === "/") {
+    const end = text.indexOf("\n", start);
+    return { keep: "", next: end === -1 ? text.length : end };
+  }
+  if (text[start + 1] === "*") {
+    const end = text.indexOf("*/", start + 2);
+    return { keep: "", next: end === -1 ? text.length : end + 2 };
+  }
+  return void 0;
+}
+
+function mayExportSzvFactories(content) {
+  return content.includes("szv(") && content.includes("export");
+}
+function recordSzvRegistryFile(registry, filePath, content) {
+  const entries = mayExportSzvFactories(content) ? compiler.extractCrossModuleRegistryEntries(content, filePath) : [];
+  replaceEntriesOfKind(registry, filePath, "szv-config", entries);
+}
+function recordSzObjectRegistryFile(registry, filePath, content) {
+  replaceEntriesOfKind(
+    registry,
+    filePath,
+    "sz-object",
+    compiler.extractCrossModuleRegistryEntries(content, filePath)
+  );
+}
+function replaceEntriesOfKind(registry, filePath, kind, entries) {
+  const key = normalizePathSeparators(filePath);
+  const byName = emptyNameIndex();
+  for (const [name, recorded] of Object.entries(registry.get(key) ?? {})) {
+    if (recorded.kind !== kind) byName[name] = recorded;
+  }
+  for (const entry of entries) {
+    if (entry.kind === kind) byName[entry.exportName] = { kind, value: entry.value };
+  }
+  if (Object.keys(byName).length === 0) registry.delete(key);
+  else registry.set(key, byName);
+}
+function emptyNameIndex() {
+  return /* @__PURE__ */ Object.create(null);
+}
+const SPECIFIER_PROBES = ["", ".ts", ".tsx", ".js", ".jsx", "/index.ts", "/index.tsx"];
+const EMITTED_EXTENSION_SOURCES = [
+  [".js", [".ts", ".tsx"]],
+  [".jsx", [".tsx"]],
+  [".mjs", [".mts"]],
+  [".cjs", [".cts"]]
+];
+function resolveCrossModuleStaticsFor(registry, filename, source, aliases = []) {
+  if (registry.size === 0 || !source.includes("from")) return {};
+  const directory = path__namespace.dirname(filename);
+  const resolved = {};
+  const seen = /* @__PURE__ */ new Set();
+  for (const specifier of importedSpecifiersIn(source)) {
+    if (seen.has(specifier)) continue;
+    seen.add(specifier);
+    const entries = firstRegistryHit(registry, specifier, directory, aliases);
+    if (entries !== void 0) fileUnderSpecifier(resolved, specifier, entries);
+  }
+  return resolved;
+}
+function firstRegistryHit(registry, specifier, directory, aliases) {
+  for (const base of specifierBases(specifier, directory, aliases)) {
+    const entries = lookupRegistryKey(registry, base);
+    if (entries !== void 0) return entries;
+  }
+  return void 0;
+}
+function recordResolvedEntry(resolved, kind, specifier, name, value) {
+  if (specifier === "__proto__" || name === "__proto__") return;
+  const channel = kind === "szv-config" ? "szvConfigs" : "szObjects";
+  let bySpecifier = resolved[channel];
+  if (bySpecifier === void 0) {
+    bySpecifier = emptyNameIndex();
+    resolved[channel] = bySpecifier;
+  }
+  let byName = bySpecifier[specifier];
+  if (byName === void 0) {
+    byName = emptyNameIndex();
+    bySpecifier[specifier] = byName;
+  }
+  byName[name] = value;
+}
+function fileUnderSpecifier(resolved, specifier, entries) {
+  for (const [name, recorded] of Object.entries(entries)) {
+    recordResolvedEntry(resolved, recorded.kind, specifier, name, recorded.value);
+  }
+}
+function importedSpecifiersIn(source) {
+  if (!source.includes("from")) return [];
+  return [...source.matchAll(/from\s*['"]([^'"]*)['"]/g)].map((match) => match[1]);
+}
+function specifierBases(specifier, directory, aliases) {
+  if (specifier.startsWith(".")) {
+    return [normalizePathSeparators(path__namespace.resolve(directory, specifier))];
+  }
+  return aliasedSpecifierBases(specifier, aliases);
+}
+function resolveProviderPath(seenPaths, base) {
+  return resolveProviderPathWith(base, (candidate) => seenPaths.has(candidate));
+}
+function resolveProviderPathWith(base, exists) {
+  return probeSpecifier(base, (candidate) => exists(candidate) ? candidate : void 0);
+}
+function probeSpecifier(base, lookup) {
+  for (const probe of SPECIFIER_PROBES) {
+    const found = lookup(`${base}${probe}`);
+    if (found !== void 0) return found;
+  }
+  for (const [emitted, sources] of EMITTED_EXTENSION_SOURCES) {
+    if (!base.endsWith(emitted)) continue;
+    const stem = base.slice(0, -emitted.length);
+    for (const extension of sources) {
+      const found = lookup(`${stem}${extension}`);
+      if (found !== void 0) return found;
+    }
+    break;
+  }
+  return void 0;
+}
+function lookupRegistryKey(registry, base) {
+  return probeSpecifier(base, (candidate) => registry.get(candidate));
+}
+
+function isReadableProviderFile(candidate) {
+  try {
+    return fs.existsSync(candidate) && fs.statSync(candidate).isFile();
+  } catch {
+    return false;
+  }
+}
+
+const CACHE_SCHEMA_VERSION = 16;
+function resolveTransformCacheDir(rootDir, cacheDir) {
+  return path__namespace.resolve(rootDir, cacheDir ?? ".csszyx/cache", "transform");
+}
+function createTransformCacheKey(input) {
+  const inputSha256 = node_crypto.createHash("sha256").update(input.source).digest("hex");
+  const globalVarAliases = normalizeGlobalVarAliasEntries(input.globalVarAliases);
+  const keyMaterial = [
+    `schema=${CACHE_SCHEMA_VERSION}`,
+    `plugin=${input.pluginVersion}`,
+    `compiler=${input.compilerVersion}`,
+    `native=${input.nativeIdentity ?? "none"}`,
+    `parser=${input.parserMode}`,
+    `producer=${input.producer}`,
+    `astBudget=${input.astBudget ?? "default"}`,
+    `mangleVars=${input.mangleVars === true}`,
+    `mangleVarHoistMaxDepth=${input.mangleVarHoistMaxDepth ?? "default"}`,
+    `globalVarAliases=${JSON.stringify(globalVarAliases)}`,
+    `crossModuleStatics=${input.crossModuleStatics ?? "none"}`,
+    `crossModuleSzObjects=${input.crossModuleSzObjects ?? "none"}`,
+    `filename=${input.filename}`,
+    `source=${inputSha256}`
+  ].join("\n");
+  return {
+    key: node_crypto.createHash("sha256").update(keyMaterial).digest("hex").slice(0, 16),
+    inputSha256
+  };
+}
+function readTransformCache(cacheRoot, input, precomputedKey) {
+  const { key, inputSha256 } = precomputedKey ?? createTransformCacheKey(input);
+  const globalVarAliases = normalizeGlobalVarAliasEntries(input.globalVarAliases);
+  const file = cacheEntryPath(cacheRoot, key);
+  let entry;
+  try {
+    entry = JSON.parse(fs__namespace.readFileSync(file, "utf8"));
+  } catch {
+    return null;
+  }
+  if (entry.version !== CACHE_SCHEMA_VERSION || entry.pluginVersion !== input.pluginVersion || entry.compilerVersion !== input.compilerVersion || entry.nativeIdentity !== (input.nativeIdentity ?? null) || entry.parserMode !== input.parserMode || entry.producer !== input.producer || entry.astBudget !== (input.astBudget ?? null) || entry.mangleVars !== (input.mangleVars === true) || entry.mangleVarHoistMaxDepth !== (input.mangleVarHoistMaxDepth ?? null) || !sameGlobalVarAliases(entry.globalVarAliases, globalVarAliases) || entry.filename !== input.filename || entry.inputSha256 !== inputSha256) {
+    return null;
+  }
+  return deserializeResult(entry.result);
+}
+function writeTransformCache(cacheRoot, input, result, precomputedKey) {
+  const { key, inputSha256 } = precomputedKey ?? createTransformCacheKey(input);
+  const globalVarAliases = normalizeGlobalVarAliasEntries(input.globalVarAliases);
+  const file = cacheEntryPath(cacheRoot, key);
+  const dir = path__namespace.dirname(file);
+  const tmp = path__namespace.join(dir, `.tmp-${process.pid}-${Date.now()}-${node_crypto.randomUUID()}.json`);
+  const entry = {
+    version: CACHE_SCHEMA_VERSION,
+    pluginVersion: input.pluginVersion,
+    compilerVersion: input.compilerVersion,
+    nativeIdentity: input.nativeIdentity ?? null,
+    parserMode: input.parserMode,
+    producer: input.producer,
+    astBudget: input.astBudget ?? null,
+    mangleVars: input.mangleVars === true,
+    mangleVarHoistMaxDepth: input.mangleVarHoistMaxDepth ?? null,
+    globalVarAliases,
+    filename: input.filename,
+    inputSha256,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    result: serializeResult(result)
+  };
+  try {
+    fs__namespace.mkdirSync(dir, { recursive: true });
+    fs__namespace.writeFileSync(tmp, JSON.stringify(entry), "utf8");
+    fs__namespace.renameSync(tmp, file);
+  } catch {
+    try {
+      fs__namespace.rmSync(tmp, { force: true });
+    } catch {
+    }
+  }
+}
+function evictOldTransformCacheEntries(cacheRoot, options) {
+  let deleted = 0;
+  const now = options.now ?? Date.now();
+  const survivors = [];
+  for (const file of listJsonFiles(cacheRoot)) {
+    try {
+      const entry = JSON.parse(fs__namespace.readFileSync(file, "utf8"));
+      const timestamp = typeof entry.timestamp === "string" ? Date.parse(entry.timestamp) : 0;
+      if (!Number.isFinite(timestamp) || now - timestamp > options.maxAgeMs) {
+        fs__namespace.rmSync(file, { force: true });
+        deleted++;
+      } else {
+        survivors.push({ file, timestamp });
+      }
+    } catch {
+      fs__namespace.rmSync(file, { force: true });
+      deleted++;
+    }
+  }
+  const overflow = survivors.length - options.maxEntries ;
+  if (overflow > 0) {
+    survivors.sort((a, b) => a.timestamp - b.timestamp);
+    for (const survivor of survivors.slice(0, overflow)) {
+      fs__namespace.rmSync(survivor.file, { force: true });
+      deleted++;
+    }
+  }
+  return deleted;
+}
+function cacheEntryPath(cacheRoot, key) {
+  return path__namespace.join(cacheRoot, key.slice(0, 2), `${key.slice(2)}.json`);
+}
+function serializeResult(result) {
+  return {
+    code: result.code,
+    transformed: result.transformed,
+    usesRuntime: result.usesRuntime,
+    usesMerge: result.usesMerge,
+    usesSzcn: result.usesSzcn,
+    usesSzPart: result.usesSzPart,
+    usesSzvPick: result.usesSzvPick,
+    usesSzvPick1: result.usesSzvPick1,
+    szPartArgsProvable: result.szPartArgsProvable,
+    usesColorVar: result.usesColorVar,
+    usesSpacingVar: result.usesSpacingVar,
+    usesUnitVar: result.usesUnitVar,
+    classes: [...result.classes],
+    rawClassNames: [...result.rawClassNames],
+    diagnostics: [...result.diagnostics],
+    recoveryTokens: [...result.recoveryTokens],
+    cssVariableMap: [...result.cssVariableMap ?? /* @__PURE__ */ new Map()]
+  };
+}
+function deserializeResult(result) {
+  return {
+    code: result.code,
+    transformed: result.transformed,
+    usesRuntime: result.usesRuntime,
+    usesMerge: result.usesMerge,
+    usesSzcn: result.usesSzcn,
+    usesSzPart: result.usesSzPart,
+    usesSzvPick: result.usesSzvPick,
+    usesSzvPick1: result.usesSzvPick1,
+    szPartArgsProvable: result.szPartArgsProvable,
+    usesColorVar: result.usesColorVar,
+    usesSpacingVar: result.usesSpacingVar,
+    usesUnitVar: result.usesUnitVar,
+    classes: new Set(result.classes),
+    rawClassNames: new Set(result.rawClassNames),
+    diagnostics: [...result.diagnostics],
+    recoveryTokens: new Map(result.recoveryTokens),
+    cssVariableMap: new Map(result.cssVariableMap ?? [])
+  };
+}
+function normalizeGlobalVarAliasEntries(aliases) {
+  if (!aliases || aliases.length === 0) {
+    return [];
+  }
+  const normalized = /* @__PURE__ */ new Map();
+  for (const [original, alias] of aliases) {
+    if (typeof original === "string" && typeof alias === "string") {
+      normalized.set(original, alias);
+    }
+  }
+  return [...normalized].sort(([left], [right]) => left.localeCompare(right));
+}
+function sameGlobalVarAliases(left, right) {
+  if (!Array.isArray(left) || left.length !== right.length) {
+    return false;
+  }
+  for (let index = 0; index < left.length; index++) {
+    const leftEntry = left[index];
+    const rightEntry = right[index];
+    if (leftEntry?.[0] !== rightEntry?.[0] || leftEntry?.[1] !== rightEntry?.[1]) {
+      return false;
+    }
+  }
+  return true;
+}
+function listJsonFiles(dir) {
+  let entries;
+  try {
+    entries = fs__namespace.readdirSync(dir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path__namespace.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...listJsonFiles(fullPath));
+    } else if (entry.isFile() && entry.name.endsWith(".json")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+function evictMemoryCacheToBudget(cache, totalCodeChars, maxEntries, maxCodeChars) {
+  let total = totalCodeChars;
+  while (cache.size > maxEntries || total > maxCodeChars && cache.size > 1) {
+    const oldest = cache.keys().next().value;
+    if (oldest === void 0) {
+      break;
+    }
+    const evicted = cache.get(oldest);
+    cache.delete(oldest);
+    total -= evicted?.code.length ?? 0;
+  }
+  return total;
+}
+
+exports.babelFallbackReason = babelFallbackReason;
+exports.collectSpecifierAliases = collectSpecifierAliases;
+exports.createTransformCacheKey = createTransformCacheKey;
+exports.evictMemoryCacheToBudget = evictMemoryCacheToBudget;
+exports.evictOldTransformCacheEntries = evictOldTransformCacheEntries;
+exports.importedSpecifiersIn = importedSpecifiersIn;
+exports.isReadableProviderFile = isReadableProviderFile;
+exports.mayExportSzvFactories = mayExportSzvFactories;
+exports.normalizePathSeparators = normalizePathSeparators;
+exports.readTransformCache = readTransformCache;
+exports.recordResolvedEntry = recordResolvedEntry;
+exports.recordSzObjectRegistryFile = recordSzObjectRegistryFile;
+exports.recordSzvRegistryFile = recordSzvRegistryFile;
+exports.resolveCrossModuleStaticsFor = resolveCrossModuleStaticsFor;
+exports.resolveProviderPath = resolveProviderPath;
+exports.resolveProviderPathWith = resolveProviderPathWith;
+exports.resolveTransformCacheDir = resolveTransformCacheDir;
+exports.specifierBases = specifierBases;
+exports.writeTransformCache = writeTransformCache;