@pandacss/config 2.1.2 → 2.2.0

package/dist/index.js

@@ -21,13 +21,12 @@ import {
 import { applyConfigDefaults as applyConfigDefaults2 } from "@pandacss/compiler-shared";
 
 // src/bundle.ts
-import { existsSync as existsSync3, realpathSync, statSync as statSync2 } from "node:fs";
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { mkdir, unlink, writeFile } from "node:fs/promises";
 import { builtinModules } from "node:module";
 import { tmpdir } from "node:os";
-import { basename, dirname as dirname3, extname as extname2, isAbsolute as isAbsolute2, join as join3, normalize, relative, sep as sep2 } from "node:path";
-import { pathToFileURL as pathToFileURL3 } from "node:url";
-import { debuglog } from "node:util";
+import { basename, dirname, extname, isAbsolute as isAbsolute2, join, normalize, relative, sep } from "node:path";
+import { pathToFileURL as pathToFileURL2 } from "node:url";
 
 // src/bundle-plugins.ts
 import { isAbsolute } from "node:path";
@@ -45,11 +44,28 @@ function importMetaUrlPlugin() {
     }
   };
 }
+var sideEffectImportRe = /^[ \t]*import[ \t]*(['"])([^'"\n]+)\1/gm;
+var nodeModulesRe = /[\\/]node_modules[\\/]/;
+function sideEffectImportsPlugin() {
+  const importsByFile = /* @__PURE__ */ new Map();
+  return {
+    name: "panda-side-effect-imports",
+    transform(code, id) {
+      if (nodeModulesRe.test(id) || !code.includes("import")) return;
+      const specifiers = new Set(Array.from(code.matchAll(sideEffectImportRe), (match) => match[2]));
+      if (specifiers.size > 0) importsByFile.set(id, specifiers);
+    },
+    async resolveId(source, importer) {
+      if (!importer || !importsByFile.get(importer)?.has(source)) return;
+      const resolved = await this.resolve(source, importer, { skipSelf: true });
+      return resolved && { ...resolved, moduleSideEffects: true };
+    }
+  };
+}
 
 // src/resolve.ts
-import { existsSync, readFileSync } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname, join, resolve } from "node:path";
+import { resolve } from "node:path";
 function tryResolveFrom(request, fromDir) {
   try {
     return createRequire(resolve(fromDir, "noop.js")).resolve(request, { paths: [fromDir] });
@@ -75,171 +91,18 @@ function resolveFrom(request, fromDir) {
 function errorCode(error) {
   return typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
 }
-function nearestPackageType(start) {
-  let current = start;
-  while (true) {
-    const candidate = join(current, "package.json");
-    if (existsSync(candidate)) return JSON.parse(readFileSync(candidate, "utf8")).type;
-    const parent = dirname(current);
-    if (parent === current) return void 0;
-    current = parent;
-  }
-}
-
-// src/transpile-loader.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2, statSync } from "node:fs";
-import * as nodeModule from "node:module";
-import { dirname as dirname2, extname, join as join2, sep } from "node:path";
-import { fileURLToPath, pathToFileURL as pathToFileURL2 } from "node:url";
-var SESSION_PARAM = "panda-config";
-var TYPESCRIPT_EXTENSION = /\.[cm]?tsx?$/;
-var RESOLVE_EXTENSIONS = [".ts", ".tsx", ".mts", ".js", ".mjs"];
-var TranspileError = class extends Error {
-  name = "TranspileError";
-};
-var MODULE_LOAD_ERROR_CODES = /* @__PURE__ */ new Set([
-  "ERR_IMPORT_ATTRIBUTE_MISSING",
-  "ERR_IMPORT_ATTRIBUTE_TYPE_INCOMPATIBLE",
-  "ERR_IMPORT_ATTRIBUTE_UNSUPPORTED",
-  "ERR_INVALID_MODULE_SPECIFIER",
-  "ERR_INVALID_PACKAGE_CONFIG",
-  "ERR_INVALID_PACKAGE_TARGET",
-  "ERR_MODULE_NOT_FOUND",
-  "ERR_PACKAGE_IMPORT_NOT_DEFINED",
-  "ERR_PACKAGE_PATH_NOT_EXPORTED",
-  "ERR_REQUIRE_ASYNC_MODULE",
-  "ERR_REQUIRE_CYCLE_MODULE",
-  "ERR_REQUIRE_ESM",
-  "ERR_UNKNOWN_FILE_EXTENSION",
-  "ERR_UNKNOWN_MODULE_FORMAT",
-  "ERR_UNSUPPORTED_DIR_IMPORT",
-  "ERR_UNSUPPORTED_ESM_URL_SCHEME",
-  "MODULE_NOT_FOUND"
-]);
-var COMMONJS_GLOBAL_MISSING = /^(require|module|exports|__dirname|__filename) is not defined\b/;
-function isLoaderFailure(error) {
-  if (error instanceof TranspileError) return true;
-  const code = error?.code;
-  if (typeof code === "string" && MODULE_LOAD_ERROR_CODES.has(code)) return true;
-  if (error instanceof SyntaxError) return true;
-  return error instanceof ReferenceError && COMMONJS_GLOBAL_MISSING.test(error.message);
-}
-var sessions = /* @__PURE__ */ new Map();
-var commonjsFiles = /* @__PURE__ */ new Set();
-var requireCache = nodeModule.createRequire(import.meta.url).cache;
-var hooksRegistered;
-var nextSession = 0;
-function canTranspile(file) {
-  return typeof nodeModule.registerHooks === "function" && !/\.c[jt]s$/.test(file);
-}
-async function importTranspiled(file, evaluate) {
-  hooksRegistered ??= registerTranspileHooks();
-  await hooksRegistered.catch((cause) => {
-    throw new TranspileError("Could not register the transpile hooks.", { cause });
-  });
-  for (const commonjsFile of commonjsFiles) delete requireCache[commonjsFile];
-  const id = String(++nextSession);
-  const session = { files: /* @__PURE__ */ new Set([file]), loaded: false };
-  sessions.set(id, session);
-  try {
-    const mod = await import(
-      /* @vite-ignore */
-      withSession(pathToFileURL2(file).href, id)
-    );
-    if (!session.loaded) throw new TranspileError("Config was not loaded through the Panda transpile hooks.");
-    return { value: await evaluate(mod), files: Array.from(session.files) };
-  } finally {
-    sessions.delete(id);
-  }
-}
-async function registerTranspileHooks() {
-  const { transformSync } = await import("rolldown/utils");
-  nodeModule.registerHooks({
-    resolve(specifier, context, nextResolve) {
-      const id = sessionId(context.parentURL);
-      if (!id || !context.parentURL) return nextResolve(specifier, context);
-      const tag = (file) => {
-        sessions.get(id)?.files.add(file);
-        return { url: withSession(pathToFileURL2(file).href, id), shortCircuit: true };
-      };
-      if (isRelative(specifier)) {
-        const file = resolveRelative(specifier, context.parentURL);
-        return file ? tag(file) : nextResolve(specifier, context);
-      }
-      const resolved = nextResolve(specifier, context);
-      const linked = linkedPackageFile(resolved.url);
-      if (linked) return tag(linked);
-      if (isCommonJs(resolved)) {
-        throw new TranspileError(`${specifier} is CommonJS, so the bundler loads this config.`);
-      }
-      return resolved;
-    },
-    load(url, context, nextLoad) {
-      const id = sessionId(url);
-      if (!id) return nextLoad(url, context);
-      const session = sessions.get(id);
-      if (session) session.loaded = true;
-      const file = fileURLToPath(url);
-      if (!TYPESCRIPT_EXTENSION.test(file)) {
-        const loaded = nextLoad(url, context);
-        if (loaded.format === "commonjs") commonjsFiles.add(file);
-        return loaded;
-      }
-      const result = transformSync(file, readFileSync2(file, "utf8"));
-      if (result.errors.length > 0) {
-        throw new TranspileError(`Could not transpile ${file}.`, { cause: result.errors[0] });
-      }
-      return { format: "module", source: result.code, shortCircuit: true };
-    }
-  });
-}
-function isCommonJs(resolved) {
-  if (resolved.format) return resolved.format === "commonjs";
-  if (!resolved.url.startsWith("file:")) return false;
-  const file = fileURLToPath(resolved.url);
-  if (file.endsWith(".cjs")) return true;
-  return file.endsWith(".js") && nearestPackageType(dirname2(file)) !== "module";
-}
-function sessionId(url) {
-  if (!url?.startsWith("file:") || !url.includes(`${SESSION_PARAM}=`)) return void 0;
-  return new URL(url).searchParams.get(SESSION_PARAM) ?? void 0;
-}
-function withSession(url, id) {
-  return `${url}?${SESSION_PARAM}=${id}`;
-}
-function isRelative(specifier) {
-  return specifier.startsWith("./") || specifier.startsWith("../");
-}
-function linkedPackageFile(url) {
-  if (!url.startsWith("file:")) return void 0;
-  const file = fileURLToPath(url);
-  return file.includes(`${sep}node_modules${sep}`) ? void 0 : file;
-}
-function resolveRelative(specifier, parentURL) {
-  const base = fileURLToPath(new URL(specifier, parentURL));
-  const candidates = [
-    base,
-    ...RESOLVE_EXTENSIONS.map((extension) => base + extension),
-    ...extname(base) === ".js" ? [base.slice(0, -3) + ".ts"] : [],
-    ...RESOLVE_EXTENSIONS.map((extension) => join2(base, `index${extension}`))
-  ];
-  return candidates.find((candidate) => existsSync2(candidate) && statSync(candidate).isFile());
-}
 
 // src/bundle.ts
-var debug = debuglog("panda");
 var nodeBuiltins = /* @__PURE__ */ new Set([...builtinModules, ...builtinModules.map((mod) => `node:${mod}`)]);
 async function bundleConfig(filepath, cwd) {
-  const transpiled = await loadTranspiled(filepath, cwd);
-  if (transpiled) return transpiled;
   const { rolldown } = await import("rolldown");
   const build = await rolldown({
     input: filepath,
     cwd,
     platform: "node",
     external: (id) => nodeBuiltins.has(id),
-    treeshake: false,
-    plugins: [importMetaUrlPlugin()]
+    treeshake: true,
+    plugins: [importMetaUrlPlugin(), sideEffectImportsPlugin()]
   });
   let chunks;
   try {
@@ -255,34 +118,15 @@ async function bundleConfig(filepath, cwd) {
   const mod = await loadBundledModule(filepath, output.code);
   return { config: await configFromModule(mod), dependencies };
 }
-async function loadTranspiled(filepath, cwd) {
-  const file = localFile(filepath, cwd);
-  if (!file || !existsSync3(file) || !canTranspile(file)) return void 0;
-  try {
-    const { value, files } = await importTranspiled(file, configFromModule);
-    const base = canonical(cwd);
-    const dependencies = new Set(files.map((dependency) => normalize(relative(base, canonical(dependency)))));
-    return { config: value, dependencies: Array.from(dependencies) };
-  } catch (error) {
-    if (!isLoaderFailure(error)) throw error;
-    debug("loading %s with the bundler: %s", relative(cwd, file) || file, errorMessage(error));
-    return void 0;
-  }
-}
-function localFile(filepath, cwd) {
-  if (isAbsolute2(filepath)) return filepath;
-  if (filepath.startsWith(".")) return join3(cwd, filepath);
-  return void 0;
-}
 async function importInstalledConfig(specifier, cwd) {
   if (specifier.startsWith(".") || isAbsolute2(specifier)) return void 0;
   const resolved = tryResolveFrom(specifier, cwd);
   if (!resolved) return void 0;
   const file = canonical(resolved);
-  if (!file.includes(`${sep2}node_modules${sep2}`) || !isEsmFile(file)) return void 0;
+  if (!file.includes(`${sep}node_modules${sep}`) || !isEsmFile(file)) return void 0;
   const mod = await import(
     /* @vite-ignore */
-    `${pathToFileURL3(file).href}?mtime=${statSync2(file).mtimeMs}`
+    `${pathToFileURL2(file).href}?mtime=${statSync(file).mtimeMs}`
   );
   return { config: await configFromModule(mod), dependencies: [normalize(relative(canonical(cwd), file))] };
 }
@@ -292,38 +136,48 @@ async function configFromModule(mod) {
   return hasDefaultExport && isPromiseLike(exported) ? await exported : exported;
 }
 function isEsmFile(file) {
-  const extension = extname2(file);
+  const extension = extname(file);
   if (extension === ".mjs") return true;
   if (extension !== ".js") return false;
-  return nearestPackageType(dirname3(file)) === "module";
+  return nearestPackageType(dirname(file)) === "module";
+}
+function nearestPackageType(start) {
+  let current = start;
+  while (true) {
+    const candidate = join(current, "package.json");
+    if (existsSync(candidate)) return JSON.parse(readFileSync(candidate, "utf8")).type;
+    const parent = dirname(current);
+    if (parent === current) return void 0;
+    current = parent;
+  }
 }
 async function loadBundledModule(filepath, code) {
   const target = tempTargetFor(filepath);
-  if (target && await writeTempModule(target, code)) {
+  let evalError;
+  if (target) {
     try {
-      return await import(
-        /* @vite-ignore */
-        pathToFileURL3(target).href
-      );
+      await mkdir(dirname(target), { recursive: true });
+      await writeFile(target, code);
+      try {
+        return await import(
+          /* @vite-ignore */
+          pathToFileURL2(target).href
+        );
+      } finally {
+        void unlink(target).catch(() => void 0);
+      }
     } catch (error) {
-      if (!isUnresolvedTempModule(error, target)) throw error;
-    } finally {
-      void unlink(target).catch(() => void 0);
+      if (!isUnresolvedTempModule(error, target)) evalError = error;
     }
   }
   const dataUrl = `data:text/javascript;base64,${Buffer.from(code).toString("base64")}`;
-  return await import(
-    /* @vite-ignore */
-    dataUrl
-  );
-}
-async function writeTempModule(target, code) {
   try {
-    await mkdir(dirname3(target), { recursive: true });
-    await writeFile(target, code);
-    return true;
-  } catch {
-    return false;
+    return await import(
+      /* @vite-ignore */
+      dataUrl
+    );
+  } catch (error) {
+    throw evalError ?? error;
   }
 }
 function isUnresolvedTempModule(error, target) {
@@ -333,16 +187,16 @@ function isUnresolvedTempModule(error, target) {
 function tempTargetFor(filepath) {
   const unique = `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
   const name = `panda.config.bundled.${unique}.mjs`;
-  const nodeModules = nearestNodeModules(dirname3(filepath));
-  const base = nodeModules ? join3(nodeModules, ".panda") : join3(tmpdir(), "panda-config");
-  return join3(base, name);
+  const nodeModules = nearestNodeModules(dirname(filepath));
+  const base = nodeModules ? join(nodeModules, ".panda") : join(tmpdir(), "panda-config");
+  return join(base, name);
 }
 function nearestNodeModules(start) {
   let current = start;
   while (true) {
-    const candidate = join3(current, "node_modules");
-    if (existsSync3(candidate)) return candidate;
-    const parent = dirname3(current);
+    const candidate = join(current, "node_modules");
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -373,7 +227,7 @@ function canonical(filepath) {
 
 // src/find.ts
 import { readdirSync } from "node:fs";
-import { dirname as dirname4, resolve as resolve2 } from "node:path";
+import { dirname as dirname2, resolve as resolve2 } from "node:path";
 var configFiles = /* @__PURE__ */ new Set([
   "panda.config.ts",
   "panda.config.js",
@@ -394,7 +248,7 @@ function findUp(cwd) {
     }
     const match = entries.find(isPandaConfig);
     if (match) return resolve2(dir, match);
-    const parent = dirname4(dir);
+    const parent = dirname2(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -635,13 +489,13 @@ import { normalize as normalize2, relative as relative5 } from "node:path";
 import {
   outdirBasename
 } from "@pandacss/compiler-shared";
-import { readFileSync as readFileSync4, statSync as statSync3 } from "node:fs";
-import { dirname as dirname6, resolve as resolve4 } from "node:path";
-import { pathToFileURL as pathToFileURL4 } from "node:url";
+import { readFileSync as readFileSync3, statSync as statSync2 } from "node:fs";
+import { dirname as dirname4, resolve as resolve4 } from "node:path";
+import { pathToFileURL as pathToFileURL3 } from "node:url";
 
 // src/design-system/package.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "node:fs";
-import { dirname as dirname5, join as join4 } from "node:path";
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname3, join as join2 } from "node:path";
 
 // src/design-system/publishable-files.ts
 import { relative as relative3, resolve as resolve3 } from "node:path";
@@ -763,7 +617,7 @@ function readPackageIdentity(cwd) {
   if (packagePath === void 0) {
     throw new Error(`Could not find a package.json from ${JSON.stringify(cwd)} to build the design system manifest.`);
   }
-  const pkg = JSON.parse(readFileSync3(packagePath, "utf8"));
+  const pkg = JSON.parse(readFileSync2(packagePath, "utf8"));
   const name = pkg.name;
   if (typeof name !== "string" || name.length === 0) {
     throw new Error(`${JSON.stringify(packagePath)} has no "name"; a design system must be a named package.`);
@@ -820,9 +674,9 @@ function isSubpathExportMap(exports) {
 function nearestPackageJson(start) {
   let current = start;
   while (true) {
-    const candidate = join4(current, "package.json");
-    if (existsSync4(candidate)) return candidate;
-    const parent = dirname5(current);
+    const candidate = join2(current, "package.json");
+    if (existsSync2(candidate)) return candidate;
+    const parent = dirname3(current);
     if (parent === current) return void 0;
     current = parent;
   }
@@ -857,7 +711,7 @@ async function loadDesignSystemChain(spec, cwd, deps) {
     levels.push(level);
     if (parent === void 0) break;
     declaredBy = level.info.name;
-    fromDir = dirname6(manifestPath);
+    fromDir = dirname4(manifestPath);
     currentSpec = parent;
   }
   return levels.reverse();
@@ -1011,7 +865,7 @@ function manifestNotExportedError(spec) {
 async function loadManifestLevel(spec, manifestPath, deps) {
   let parsed;
   try {
-    parsed = JSON.parse(readFileSync4(manifestPath, "utf8"));
+    parsed = JSON.parse(readFileSync3(manifestPath, "utf8"));
   } catch (error) {
     const message = `Failed to parse ${JSON.stringify(manifestPath)} as JSON: ${errorMessage(error)}. This file must be generated by \`panda lib\`, not hand-written or added to \`include\`.`;
     throw createConfigError(message, [
@@ -1019,8 +873,8 @@ async function loadManifestLevel(spec, manifestPath, deps) {
     ]);
   }
   const manifest = validateManifest(spec, manifestPath, parsed);
-  const presetPath = resolve4(dirname6(manifestPath), manifest.preset);
-  const buildInfoPath = resolve4(dirname6(manifestPath), manifest.buildInfo);
+  const presetPath = resolve4(dirname4(manifestPath), manifest.preset);
+  const buildInfoPath = resolve4(dirname4(manifestPath), manifest.buildInfo);
   deps.add(presetPath);
   deps.add(buildInfoPath);
   let preset;
@@ -1060,9 +914,9 @@ async function loadManifestLevel(spec, manifestPath, deps) {
 }
 function readPackageExports(manifestPath) {
   try {
-    const packageJsonPath = nearestPackageJson(dirname6(manifestPath));
+    const packageJsonPath = nearestPackageJson(dirname4(manifestPath));
     if (packageJsonPath === void 0) return void 0;
-    const pkg = JSON.parse(readFileSync4(packageJsonPath, "utf8"));
+    const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
     return isExportsMap(pkg.exports) ? pkg.exports : void 0;
   } catch {
     return void 0;
@@ -1072,8 +926,8 @@ function isExportsMap(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function presetImportUrl(path) {
-  const url = pathToFileURL4(path);
-  url.searchParams.set("mtime", String(statSync3(path).mtimeMs));
+  const url = pathToFileURL3(path);
+  url.searchParams.set("mtime", String(statSync2(path).mtimeMs));
   return url.href;
 }
 function designSystemImportMap(map, spec) {
@@ -1177,8 +1031,8 @@ function unsupportedSpecifierError(spec, protocol) {
 }
 
 // src/design-system/smart-include.ts
-import { existsSync as existsSync5 } from "node:fs";
-import { dirname as dirname7, isAbsolute as isAbsolute4, join as join5, relative as relative4, resolve as resolve5, sep as sep3 } from "node:path";
+import { existsSync as existsSync3 } from "node:fs";
+import { dirname as dirname5, isAbsolute as isAbsolute4, join as join3, relative as relative4, resolve as resolve5, sep as sep2 } from "node:path";
 var SMART_INCLUDE_EXTENSIONS = ["js", "mjs", "cjs", "jsx", "ts", "cts", "mts", "tsx", "vue", "svelte", "astro"];
 var MANIFEST_SUBPATH = "panda/lib.json";
 var PACKAGE_SPECIFIER = /^(?:@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/i;
@@ -1205,11 +1059,11 @@ function resolveSmartInclude(include, cwd, deps) {
       next.push(entry);
       continue;
     }
-    if (existsSync5(join5(packageDir, ...MANIFEST_SUBPATH.split("/")))) {
+    if (existsSync3(join3(packageDir, ...MANIFEST_SUBPATH.split("/")))) {
       offenders.push(entry);
       continue;
     }
-    deps.add(join5(packageDir, "package.json"));
+    deps.add(join3(packageDir, "package.json"));
     const base = globBase(packageDir, cwd);
     next.push(`${base}/**/*.{${SMART_INCLUDE_EXTENSIONS.join(",")}}`);
     excludes.push(`${base}/**/node_modules/**`);
@@ -1228,11 +1082,11 @@ function mergeExcludes(existing, additions) {
   return [...existing ?? [], ...additions];
 }
 function isLocalPath(entry, cwd) {
-  return existsSync5(isAbsolute4(entry) ? entry : resolve5(cwd, entry));
+  return existsSync3(isAbsolute4(entry) ? entry : resolve5(cwd, entry));
 }
 function resolvePackageDir(spec, cwd) {
   const fromPackageJson = tryResolve(`${spec}/package.json`, cwd);
-  if (fromPackageJson !== void 0) return dirname7(fromPackageJson);
+  if (fromPackageJson !== void 0) return dirname5(fromPackageJson);
   const fromEntry = tryResolve(spec, cwd);
   return fromEntry === void 0 ? void 0 : nearestPackageDir(fromEntry);
 }
@@ -1247,13 +1101,13 @@ function tryResolve(request, cwd) {
 function isInsideCwd(relativePath) {
   if (relativePath === "" || relativePath === "..") return false;
   if (isAbsolute4(relativePath)) return false;
-  return !relativePath.startsWith(`..${sep3}`);
+  return !relativePath.startsWith(`..${sep2}`);
 }
 function nearestPackageDir(from) {
-  let dir = dirname7(from);
+  let dir = dirname5(from);
   while (true) {
-    if (existsSync5(join5(dir, "package.json"))) return dir;
-    const parent = dirname7(dir);
+    if (existsSync3(join3(dir, "package.json"))) return dir;
+    const parent = dirname5(dir);
     if (parent === dir) return void 0;
     dir = parent;
   }
@@ -1719,15 +1573,15 @@ function isConfigSnapshot(input) {
 }
 
 // src/version.ts
-import { readFileSync as readFileSync5 } from "node:fs";
-import { dirname as dirname8, join as join6 } from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
+import { readFileSync as readFileSync4 } from "node:fs";
+import { dirname as dirname6, join as join4 } from "node:path";
+import { fileURLToPath } from "node:url";
 var MAJOR_VERSION_RE = /\d+/;
 var STAMPABLE_PANDA_RANGE_RE = /^[v=><~^]|^\d/;
 function readPandaVersion() {
   try {
-    const pkgPath = join6(dirname8(fileURLToPath2(import.meta.url)), "../package.json");
-    return JSON.parse(readFileSync5(pkgPath, "utf8")).version;
+    const pkgPath = join4(dirname6(fileURLToPath(import.meta.url)), "../package.json");
+    return JSON.parse(readFileSync4(pkgPath, "utf8")).version;
   } catch {
     return void 0;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pandacss/config",
-  "version": "2.1.2",
+  "version": "2.2.0",
   "description": "Self-contained loader that bundles and serializes a Panda config for the Rust compiler",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,8 +39,8 @@
     "dist"
   ],
   "dependencies": {
-    "@pandacss/compiler-shared": "2.1.2",
-    "@pandacss/types": "2.1.2",
+    "@pandacss/compiler-shared": "2.2.0",
+    "@pandacss/types": "2.2.0",
     "acorn": "^8.17.0",
     "acorn-walk": "^8.3.5",
     "javascript-stringify": "2.1.0",