@csszyx/unplugin 0.9.0 → 0.9.2

package/dist/shared/unplugin.s62yJbu1.cjs

@@ -0,0 +1,591 @@
+'use strict';
+
+const path = require('node:path');
+const fs = require('node:fs');
+const node_crypto = require('node:crypto');
+const node_os = require('node:os');
+const lockfile = require('proper-lockfile');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+
+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 lockfile__default = /*#__PURE__*/_interopDefaultCompat(lockfile);
+
+const DEFAULT_RENAME_RETRIES = 5;
+const DEFAULT_RENAME_RETRY_DELAY_MS = 10;
+const DEFAULT_STALE_LOCK_MS = 3e4;
+function resolveNextSafelistStatePaths(rootDir, cacheDir = ".csszyx/cache", outputFile = "csszyx-classes.html") {
+  const resolvedCacheDir = path__namespace.resolve(rootDir, cacheDir);
+  return {
+    cacheDir: resolvedCacheDir,
+    shardsDir: path__namespace.join(resolvedCacheDir, "safelist-shards"),
+    snapshotPath: path__namespace.join(resolvedCacheDir, "safelist.snapshot.json"),
+    outputPath: path__namespace.resolve(rootDir, outputFile)
+  };
+}
+function writeNextSafelistShard(shardsDir, input, options = {}) {
+  const shard = normalizeShardInput(input);
+  const filePath = path__namespace.join(shardsDir, `${shard.cacheKey}.json`);
+  if (isExistingShardEquivalent(filePath, shard)) {
+    return { filePath, changed: false };
+  }
+  atomicWriteFileSync(filePath, `${JSON.stringify(shard, null, 2)}
+`, options);
+  return { filePath, changed: true };
+}
+function materializeNextSafelist(paths, options = {}) {
+  const recordsBySource = /* @__PURE__ */ new Map();
+  let tombstonedSourceCount = 0;
+  for (const record of readShardRecords(paths.shardsDir)) {
+    if (!fs__namespace.existsSync(record.data.sourcePath)) {
+      fs__namespace.rmSync(record.filePath, { force: true });
+      tombstonedSourceCount++;
+      continue;
+    }
+    const previous = recordsBySource.get(record.data.sourcePath);
+    if (!previous || record.data.timestamp >= previous.data.timestamp) {
+      recordsBySource.set(record.data.sourcePath, record);
+    }
+  }
+  const sortedSources = [...recordsBySource.values()].map(({ data }) => [data.sourcePath, [...new Set(data.classes)].sort()]).sort(([left], [right]) => left.localeCompare(right));
+  const classNames = [...new Set(sortedSources.flatMap(([, classSet]) => classSet))].sort();
+  const snapshot = {
+    version: 1,
+    sources: sortedSources.map(([sourcePath, classSet]) => [sourcePath, classSet])
+  };
+  atomicWriteFileSync(paths.outputPath, renderTailwindSourceHtml(classNames), options);
+  atomicWriteFileSync(paths.snapshotPath, `${JSON.stringify(snapshot, null, 2)}
+`, options);
+  return {
+    classCount: classNames.length,
+    sourceCount: sortedSources.length,
+    tombstonedSourceCount,
+    shardCount: recordsBySource.size
+  };
+}
+function acquireNextSafelistStateLock(lockPath, pidOrOptions = {}) {
+  const options = typeof pidOrOptions === "number" ? { pid: pidOrOptions } : pidOrOptions;
+  const metadata = createLockMetadata(options);
+  const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_LOCK_MS;
+  fs__namespace.mkdirSync(path__namespace.dirname(lockPath), { recursive: true });
+  let releaseAdvisory;
+  try {
+    releaseAdvisory = lockfile__default.lockSync(lockPath, {
+      realpath: false,
+      stale: staleAfterMs,
+      update: Math.max(1e3, Math.floor(staleAfterMs / 2)),
+      retries: 0
+    });
+  } catch (error) {
+    const existing2 = readLockMetadata(lockPath);
+    if (existing2) {
+      throw new Error(formatLiveLockError(existing2));
+    }
+    throw error;
+  }
+  const existing = readLockMetadata(lockPath);
+  if (existing && isLockLive(existing, options)) {
+    releaseAdvisory();
+    throw new Error(formatLiveLockError(existing));
+  }
+  try {
+    atomicWriteFileSync(lockPath, `${JSON.stringify(metadata, null, 2)}
+`);
+  } catch (error) {
+    releaseAdvisory();
+    throw error;
+  }
+  let released = false;
+  const writeCurrentMetadata = (updatedAt) => {
+    atomicWriteFileSync(lockPath, `${JSON.stringify({ ...metadata, updatedAt }, null, 2)}
+`);
+  };
+  return {
+    lockPath,
+    token: metadata.token,
+    heartbeat: () => {
+      if (!released && readLockMetadata(lockPath)?.token === metadata.token) {
+        writeCurrentMetadata(new Date(options.now ?? Date.now()).toISOString());
+      }
+    },
+    release: () => {
+      if (released) {
+        return;
+      }
+      released = true;
+      try {
+        if (readLockMetadata(lockPath)?.token === metadata.token) {
+          fs__namespace.rmSync(lockPath, { force: true });
+        }
+      } catch {
+      } finally {
+        try {
+          releaseAdvisory?.();
+        } catch {
+        }
+      }
+    }
+  };
+}
+function atomicWriteFileSync(file, content, options = {}) {
+  const dir = path__namespace.dirname(file);
+  const tmp = path__namespace.join(
+    dir,
+    `.tmp-${path__namespace.basename(file)}-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2)}`
+  );
+  fs__namespace.mkdirSync(dir, { recursive: true });
+  fs__namespace.writeFileSync(tmp, content, "utf8");
+  try {
+    atomicRenameWithRetry(tmp, file, options);
+  } catch (error) {
+    try {
+      fs__namespace.rmSync(tmp, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function atomicRenameWithRetry(from, to, options = {}) {
+  const maxRetries = options.maxRetries ?? DEFAULT_RENAME_RETRIES;
+  const retryDelayMs = options.retryDelayMs ?? DEFAULT_RENAME_RETRY_DELAY_MS;
+  const renameSync = options.renameSync ?? fs__namespace.renameSync;
+  for (let attempt = 0; ; attempt++) {
+    try {
+      renameSync(from, to);
+      return;
+    } catch (error) {
+      if (!isRetryableRenameError(error) || attempt >= maxRetries) {
+        throw error;
+      }
+      sleepSync(retryDelayMs);
+    }
+  }
+}
+function isExistingShardEquivalent(filePath, shard) {
+  try {
+    const parsed = JSON.parse(fs__namespace.readFileSync(filePath, "utf8"));
+    return parsed.version === 1 && parsed.sourcePath === shard.sourcePath && parsed.sourceHash === shard.sourceHash;
+  } catch {
+    return false;
+  }
+}
+function normalizeShardInput(input) {
+  const sourcePath = path__namespace.resolve(input.sourcePath);
+  const classes = [
+    ...new Set(input.classes.map((className) => className.trim()).filter(Boolean))
+  ].sort();
+  const cacheKey = input.cacheKey ?? node_crypto.createHash("sha256").update(sourcePath).update("\0").update(input.sourceHash).digest("hex");
+  return {
+    version: 1,
+    cacheKey,
+    sourcePath,
+    sourceHash: input.sourceHash,
+    classes,
+    timestamp: input.timestamp !== void 0 && Number.isFinite(input.timestamp) ? input.timestamp : Date.now(),
+    pid: input.pid ?? process.pid
+  };
+}
+function readShardRecords(shardsDir) {
+  let entries;
+  try {
+    entries = fs__namespace.readdirSync(shardsDir, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  const records = [];
+  for (const entry of entries) {
+    if (!entry.isFile() || !entry.name.endsWith(".json")) {
+      continue;
+    }
+    const filePath = path__namespace.join(shardsDir, entry.name);
+    try {
+      const parsed = JSON.parse(fs__namespace.readFileSync(filePath, "utf8"));
+      const record = normalizeShardRecord(filePath, parsed);
+      if (record) {
+        records.push(record);
+      } else {
+        fs__namespace.rmSync(filePath, { force: true });
+      }
+    } catch {
+      fs__namespace.rmSync(filePath, { force: true });
+    }
+  }
+  return records;
+}
+function normalizeShardRecord(filePath, data) {
+  if (data.version !== 1 || typeof data.cacheKey !== "string" || typeof data.sourcePath !== "string" || typeof data.sourceHash !== "string" || !Array.isArray(data.classes) || typeof data.timestamp !== "number" || typeof data.pid !== "number") {
+    return null;
+  }
+  return {
+    filePath,
+    data: normalizeShardInput({
+      cacheKey: data.cacheKey,
+      sourcePath: data.sourcePath,
+      sourceHash: data.sourceHash,
+      classes: data.classes,
+      timestamp: data.timestamp,
+      pid: data.pid
+    })
+  };
+}
+function renderTailwindSourceHtml(classNames) {
+  if (classNames.length === 0) {
+    return "<!-- csszyx Next safelist: empty -->\n";
+  }
+  return `${classNames.map((className) => `<div class="${escapeHtmlAttribute(className)}"></div>`).join("\n")}
+`;
+}
+function escapeHtmlAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function createLockMetadata(options) {
+  const now = new Date(options.now ?? Date.now()).toISOString();
+  const pid = options.pid ?? process.pid;
+  return {
+    version: 1,
+    pid,
+    token: options.token ?? node_crypto.createHash("sha256").update(`${pid}\0${now}\0${Math.random().toString(36)}`).digest("hex"),
+    hostname: node_os.hostname(),
+    root: path__namespace.resolve(options.root ?? process.cwd()),
+    mode: options.mode ?? "development",
+    command: options.command ?? process.argv.join(" "),
+    startedAt: now,
+    updatedAt: now
+  };
+}
+function readLockMetadata(lockPath) {
+  try {
+    const parsed = JSON.parse(
+      fs__namespace.readFileSync(lockPath, "utf8")
+    );
+    if (parsed.version !== 1 || typeof parsed.pid !== "number" || typeof parsed.token !== "string" || typeof parsed.hostname !== "string" || typeof parsed.root !== "string" || parsed.mode !== "development" && parsed.mode !== "production" || typeof parsed.command !== "string" || typeof parsed.startedAt !== "string" || typeof parsed.updatedAt !== "string") {
+      return null;
+    }
+    return {
+      version: 1,
+      pid: parsed.pid,
+      token: parsed.token,
+      hostname: parsed.hostname,
+      root: path__namespace.resolve(parsed.root),
+      mode: parsed.mode,
+      command: parsed.command,
+      startedAt: parsed.startedAt,
+      updatedAt: parsed.updatedAt
+    };
+  } catch {
+    return null;
+  }
+}
+function isLockLive(metadata, options) {
+  const staleAfterMs = options.staleAfterMs ?? DEFAULT_STALE_LOCK_MS;
+  const updatedAt = Date.parse(metadata.updatedAt);
+  const now = options.now ?? Date.now();
+  if (Number.isFinite(updatedAt) && now - updatedAt > staleAfterMs) {
+    return false;
+  }
+  if (metadata.hostname !== (options.hostname ?? node_os.hostname())) {
+    return true;
+  }
+  return (options.isProcessAlive ?? isProcessAlive)(metadata.pid);
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function formatLiveLockError(metadata) {
+  return [
+    `csszyx Next safelist state is already locked by process ${metadata.pid}.`,
+    `root=${metadata.root}`,
+    `mode=${metadata.mode}`,
+    `host=${metadata.hostname}`,
+    `updatedAt=${metadata.updatedAt}`
+  ].join(" ");
+}
+function isRetryableRenameError(error) {
+  return typeof error === "object" && error !== null && "code" in error && (error.code === "EBUSY" || error.code === "EPERM" || error.code === "EACCES");
+}
+function sleepSync(ms) {
+  if (ms <= 0) {
+    return;
+  }
+  Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+}
+
+function resolveNextGenerationManifestPath(rootDir, cacheDir = ".csszyx/cache") {
+  return path__namespace.resolve(rootDir, cacheDir, "generation-manifest.json");
+}
+function writeNextGenerationManifest(manifestPath, manifest, options = {}) {
+  atomicWriteFileSync(
+    manifestPath,
+    `${JSON.stringify(normalizeManifest(manifest), null, 2)}
+`,
+    options
+  );
+}
+function readNextGenerationManifest(manifestPath) {
+  try {
+    return normalizeManifest(
+      JSON.parse(fs__namespace.readFileSync(manifestPath, "utf8"))
+    );
+  } catch {
+    return null;
+  }
+}
+function validateNextGenerationManifest(manifest, expected) {
+  if (!manifest) {
+    return { ok: false, reason: "missing or unreadable generation manifest" };
+  }
+  if (manifest.schema !== 1) {
+    return { ok: false, reason: `unsupported generation manifest schema ${manifest.schema}` };
+  }
+  if (!manifest.completed) {
+    return { ok: false, reason: "generation manifest is incomplete" };
+  }
+  if (manifest.root !== path__namespace.resolve(expected.root)) {
+    return { ok: false, reason: "generation manifest root does not match this Next app" };
+  }
+  if (manifest.configHash !== expected.configHash) {
+    return { ok: false, reason: "csszyx config hash changed" };
+  }
+  if (manifest.envHash !== expected.envHash) {
+    return { ok: false, reason: "csszyx env hash changed" };
+  }
+  if (manifest.nextVersion !== expected.nextVersion) {
+    return { ok: false, reason: "Next.js version changed" };
+  }
+  if (manifest.csszyxVersion !== expected.csszyxVersion) {
+    return { ok: false, reason: "csszyx version changed" };
+  }
+  if (manifest.nativeVersion !== expected.nativeVersion) {
+    return { ok: false, reason: "csszyx native engine version changed" };
+  }
+  if (manifest.mode !== expected.mode) {
+    return { ok: false, reason: "generation manifest mode changed" };
+  }
+  return { ok: true };
+}
+function normalizeManifest(manifest) {
+  if (manifest.schema !== 1 || typeof manifest.generation !== "string" || typeof manifest.root !== "string" || typeof manifest.configHash !== "string" || typeof manifest.envHash !== "string" || typeof manifest.nextVersion !== "string" || typeof manifest.csszyxVersion !== "string" || typeof manifest.nativeVersion !== "string" || manifest.mode !== "development" && manifest.mode !== "production" || typeof manifest.sourceCount !== "number" || typeof manifest.completed !== "boolean" || typeof manifest.createdAt !== "string") {
+    throw new Error("Invalid csszyx Next generation manifest.");
+  }
+  return {
+    ...manifest,
+    root: path__namespace.resolve(manifest.root),
+    sourceCount: Math.max(0, Math.trunc(manifest.sourceCount))
+  };
+}
+
+function createNextCacheIdentity(input) {
+  const configHash = hashString(stableStringify(input.config));
+  const envHash = hashString(stableStringify(pickEnv(input.env ?? {}, input.envKeys ?? [])));
+  const generation = hashString(
+    stableStringify({
+      root: input.root,
+      configHash,
+      envHash,
+      nextVersion: input.nextVersion,
+      csszyxVersion: input.csszyxVersion,
+      nativeVersion: input.nativeVersion,
+      mode: input.mode
+    })
+  );
+  return { configHash, envHash, generation };
+}
+function stableStringify(value) {
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number") {
+    return Number.isFinite(value) ? JSON.stringify(value) : "null";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).filter((entry) => entry[1] !== void 0).sort(([left], [right]) => left.localeCompare(right));
+    return `{${entries.map(([key, entryValue]) => `${JSON.stringify(key)}:${stableStringify(entryValue)}`).join(",")}}`;
+  }
+  return "null";
+}
+function pickEnv(env, envKeys) {
+  const selected = {};
+  for (const key of [...new Set(envKeys)].sort()) {
+    const value = env[key];
+    if (value !== void 0) {
+      selected[key] = value;
+    }
+  }
+  return selected;
+}
+function hashString(value) {
+  return `sha256:${node_crypto.createHash("sha256").update(value).digest("hex")}`;
+}
+
+function resolveNextAppRoot(input) {
+  if (input.explicitRoot) {
+    return { root: path__namespace.resolve(input.explicitRoot), source: "explicit" };
+  }
+  if (input.loaderRootContext) {
+    const rootContextRoot = findNearestPackageRoot(input.loaderRootContext);
+    if (input.loaderContext) {
+      const loaderContextRoot = findNearestPackageRoot(input.loaderContext);
+      if (isNestedPackageRoot(rootContextRoot, loaderContextRoot)) {
+        return { root: loaderContextRoot, source: "loader-context" };
+      }
+    }
+    return { root: rootContextRoot, source: "loader-root-context" };
+  }
+  if (input.loaderContext) {
+    return { root: findNearestPackageRoot(input.loaderContext), source: "loader-context" };
+  }
+  return { root: findNearestPackageRoot(input.cwd ?? process.cwd()), source: "cwd" };
+}
+function resolveNextAppCacheDir(appRoot, cacheDir = ".csszyx/cache") {
+  return path__namespace.resolve(appRoot, cacheDir);
+}
+function findNearestPackageRoot(start) {
+  let current = path__namespace.resolve(start);
+  try {
+    const stat = fs__namespace.statSync(current);
+    if (stat.isFile()) {
+      current = path__namespace.dirname(current);
+    }
+  } catch {
+  }
+  for (; ; ) {
+    if (fs__namespace.existsSync(path__namespace.join(current, "package.json"))) {
+      return current;
+    }
+    const parent = path__namespace.dirname(current);
+    if (parent === current) {
+      return path__namespace.resolve(start);
+    }
+    current = parent;
+  }
+}
+function isNestedPackageRoot(parentRoot, candidateRoot) {
+  const relative = path__namespace.relative(parentRoot, candidateRoot);
+  return Boolean(relative) && !relative.startsWith("..") && !path__namespace.isAbsolute(relative);
+}
+
+function createNextStateContext(input) {
+  const rootResolution = resolveNextAppRoot(input);
+  const cacheDir = resolveNextAppCacheDir(rootResolution.root, input.cacheDir);
+  const identity = createNextCacheIdentity({
+    root: rootResolution.root,
+    config: input.config,
+    env: input.env,
+    envKeys: input.envKeys,
+    nextVersion: input.nextVersion,
+    csszyxVersion: input.csszyxVersion,
+    nativeVersion: input.nativeVersion,
+    mode: input.mode
+  });
+  const manifestExpectation = {
+    root: rootResolution.root,
+    configHash: identity.configHash,
+    envHash: identity.envHash,
+    nextVersion: input.nextVersion,
+    csszyxVersion: input.csszyxVersion,
+    nativeVersion: input.nativeVersion,
+    mode: input.mode
+  };
+  return {
+    root: rootResolution.root,
+    rootSource: rootResolution.source,
+    cacheDir,
+    safelist: resolveNextSafelistStatePaths(
+      rootResolution.root,
+      relativeCacheDir(rootResolution.root, cacheDir),
+      input.safelistOutputFile
+    ),
+    manifestPath: resolveNextGenerationManifestPath(
+      rootResolution.root,
+      relativeCacheDir(rootResolution.root, cacheDir)
+    ),
+    identity,
+    manifestExpectation
+  };
+}
+function createNextGenerationManifestFromContext(context, sourceCount, createdAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  return {
+    schema: 1,
+    generation: context.identity.generation,
+    root: context.root,
+    configHash: context.identity.configHash,
+    envHash: context.identity.envHash,
+    nextVersion: context.manifestExpectation.nextVersion,
+    csszyxVersion: context.manifestExpectation.csszyxVersion,
+    nativeVersion: context.manifestExpectation.nativeVersion,
+    mode: context.manifestExpectation.mode,
+    sourceCount,
+    completed: true,
+    createdAt
+  };
+}
+function relativeCacheDir(root, cacheDir) {
+  const relative = path__namespace.relative(root, cacheDir);
+  return relative && !relative.startsWith("..") && !path__namespace.isAbsolute(relative) ? relative : cacheDir;
+}
+
+function runNextWatcherCycle(context, options = {}) {
+  const lockPath = path__namespace.join(context.cacheDir, "state.lock");
+  const lock = acquireNextSafelistStateLock(lockPath, {
+    root: context.root,
+    mode: context.manifestExpectation.mode,
+    command: "csszyx next watch",
+    ...options.lockOptions
+  });
+  try {
+    const materialize = materializeNextSafelist(context.safelist, options.writeOptions);
+    writeNextGenerationManifest(
+      context.manifestPath,
+      createNextGenerationManifestFromContext(
+        context,
+        materialize.sourceCount,
+        options.createdAt
+      ),
+      options.writeOptions
+    );
+    const validation = validateNextGenerationManifest(
+      readNextGenerationManifest(context.manifestPath),
+      context.manifestExpectation
+    );
+    if (!validation.ok) {
+      throw new Error(
+        `[csszyx] Next watcher wrote an invalid generation manifest: ${validation.reason}`
+      );
+    }
+    lock.heartbeat();
+    return {
+      materialize,
+      manifestPath: context.manifestPath,
+      lockPath
+    };
+  } finally {
+    lock.release();
+  }
+}
+
+exports.createNextStateContext = createNextStateContext;
+exports.readNextGenerationManifest = readNextGenerationManifest;
+exports.runNextWatcherCycle = runNextWatcherCycle;
+exports.validateNextGenerationManifest = validateNextGenerationManifest;
+exports.writeNextSafelistShard = writeNextSafelistShard;

package/dist/shared/unplugin.xeED_qwh.d.cts

@@ -0,0 +1,16 @@
+import { a as NextSafelistMaterializeResult, b as NextSafelistStateLockOptions, A as AtomicWriteOptions } from './unplugin.CPEWNSA0.cjs';
+
+/** Options for one synchronous watcher materialization cycle. */
+interface NextWatcherCycleOptions {
+    lockOptions?: NextSafelistStateLockOptions;
+    writeOptions?: AtomicWriteOptions;
+    createdAt?: string;
+}
+/** Result returned by one watcher materialization cycle. */
+interface NextWatcherCycleResult {
+    materialize: NextSafelistMaterializeResult;
+    manifestPath: string;
+    lockPath: string;
+}
+
+export type { NextWatcherCycleResult as N, NextWatcherCycleOptions as a };

package/dist/vite.cjs

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const unplugin = require('./shared/unplugin.CL0F6RZa.cjs');
+const unplugin = require('./shared/unplugin.CFp386gH.cjs');
 require('node:fs');
 require('node:module');
 require('node:path');
@@ -18,6 +18,8 @@ require('./css-mangler.cjs');
 require('postcss');
 require('postcss-selector-parser');
 require('node:crypto');
+require('./shared/unplugin.DUxdYaSG.cjs');
+require('postcss-value-parser');
 
 
 

package/dist/vite.d.cts

@@ -1,4 +1,5 @@
-import { v as vitePlugin } from './shared/unplugin.DUbr5w-N.cjs';
+import { v as vitePlugin } from './shared/unplugin.DLrBgECN.cjs';
+import '@csszyx/compiler';
 import '@csszyx/types';
 import 'esbuild';
 import 'rollup';

package/dist/vite.d.mts

@@ -1,4 +1,5 @@
-import { v as vitePlugin } from './shared/unplugin.DUbr5w-N.mjs';
+import { v as vitePlugin } from './shared/unplugin.DLrBgECN.mjs';
+import '@csszyx/compiler';
 import '@csszyx/types';
 import 'esbuild';
 import 'rollup';

package/dist/vite.mjs

@@ -1,4 +1,4 @@
-import { v as vitePlugin } from './shared/unplugin.BEOG6ePC.mjs';
+import { C as vitePlugin } from './shared/unplugin.BbtspS8t.mjs';
 import 'node:fs';
 import 'node:module';
 import 'node:path';
@@ -14,6 +14,8 @@ import './css-mangler.mjs';
 import 'postcss';
 import 'postcss-selector-parser';
 import 'node:crypto';
+import './shared/unplugin.BceVw1eW.mjs';
+import 'postcss-value-parser';
 
 
 

package/dist/webpack.cjs

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-const unplugin = require('./shared/unplugin.CL0F6RZa.cjs');
+const unplugin = require('./shared/unplugin.CFp386gH.cjs');
 require('node:fs');
 require('node:module');
 require('node:path');
@@ -18,6 +18,8 @@ require('./css-mangler.cjs');
 require('postcss');
 require('postcss-selector-parser');
 require('node:crypto');
+require('./shared/unplugin.DUxdYaSG.cjs');
+require('postcss-value-parser');
 
 
 

package/dist/webpack.d.cts

@@ -1,4 +1,5 @@
-import { w as webpackPlugin } from './shared/unplugin.DUbr5w-N.cjs';
+import { w as webpackPlugin } from './shared/unplugin.DLrBgECN.cjs';
+import '@csszyx/compiler';
 import '@csszyx/types';
 import 'esbuild';
 import 'rollup';

package/dist/webpack.d.mts

@@ -1,4 +1,5 @@
-import { w as webpackPlugin } from './shared/unplugin.DUbr5w-N.mjs';
+import { w as webpackPlugin } from './shared/unplugin.DLrBgECN.mjs';
+import '@csszyx/compiler';
 import '@csszyx/types';
 import 'esbuild';
 import 'rollup';