@pandacss/node 0.40.1 → 0.42.0

package/dist/index.js

@@ -33,9 +33,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// ../../node_modules/.pnpm/tsup@8.0.2_typescript@5.3.3/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.pnpm/tsup@8.0.2_@swc+core@1.4.0_postcss@8.4.39_typescript@5.3.3/node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
-  "../../node_modules/.pnpm/tsup@8.0.2_typescript@5.3.3/node_modules/tsup/assets/cjs_shims.js"() {
+  "../../node_modules/.pnpm/tsup@8.0.2_@swc+core@1.4.0_postcss@8.4.39_typescript@5.3.3/node_modules/tsup/assets/cjs_shims.js"() {
     "use strict";
   }
 });
@@ -428,49 +428,53 @@ init_cjs_shims();
 var import_logger = require("@pandacss/logger");
 var import_filesize = require("filesize");
 var import_promises = require("fs/promises");
+var import_node_path = __toESM(require("path"));
 var import_zlib = __toESM(require("zlib"));
 
+// package.json
+var version = "0.42.0";
+
 // src/classify.ts
 init_cjs_shims();
 var import_extractor = require("@pandacss/extractor");
 var createReportMaps = () => {
-  const byInstanceOfKind = /* @__PURE__ */ new Map();
+  const byComponentOfKind = /* @__PURE__ */ new Map();
   const byPropertyName = /* @__PURE__ */ new Map();
-  const byCategory = /* @__PURE__ */ new Map();
+  const byTokenType = /* @__PURE__ */ new Map();
   const byConditionName = /* @__PURE__ */ new Map();
   const byShorthand = /* @__PURE__ */ new Map();
   const byTokenName = /* @__PURE__ */ new Map();
   const byPropertyPath = /* @__PURE__ */ new Map();
   const fromKind = /* @__PURE__ */ new Map();
   const byType = /* @__PURE__ */ new Map();
-  const byInstanceName = /* @__PURE__ */ new Map();
+  const byComponentName = /* @__PURE__ */ new Map();
   const colorsUsed = /* @__PURE__ */ new Map();
   return {
-    byInstanceOfKind,
+    byComponentOfKind,
     byPropertyName,
-    byCategory,
+    byTokenType,
     byConditionName,
     byShorthand,
     byTokenName,
     byPropertyPath,
     fromKind,
     byType,
-    byInstanceName,
+    byComponentName,
     colorsUsed
   };
 };
-var colorPropNames = /* @__PURE__ */ new Set(["background", "outline", "border"]);
 var classifyTokens = (ctx, parserResultByFilepath) => {
   const byId = /* @__PURE__ */ new Map();
-  const byInstanceId = /* @__PURE__ */ new Map();
+  const byComponentIndex = /* @__PURE__ */ new Map();
   const byFilepath = /* @__PURE__ */ new Map();
-  const byInstanceInFilepath = /* @__PURE__ */ new Map();
+  const byComponentInFilepath = /* @__PURE__ */ new Map();
   const globalMaps = createReportMaps();
   const byFilePathMaps = /* @__PURE__ */ new Map();
   const conditions = new Map(Object.entries(ctx.conditions.values));
-  let id = 0, instanceId = 0;
-  const isKnownUtility = (reportItem) => {
-    const { propName, type, value, from } = reportItem;
+  const { groupByProp } = getPropertyGroupMap(ctx);
+  let id = 0, componentIndex = 0;
+  const isKnownUtility = (reportItem, componentReportItem) => {
+    const { propName, value } = reportItem;
     const utility = ctx.config.utilities?.[propName];
     if (utility) {
       if (!utility.shorthand) {
@@ -478,8 +482,8 @@ var classifyTokens = (ctx, parserResultByFilepath) => {
       }
       return Boolean(ctx.tokens.getByName(`${utility.values}.${value}`));
     }
-    if (type === "pattern") {
-      const pattern = ctx.patterns.getConfig(from.toLowerCase());
+    if (componentReportItem.reportItemType === "pattern") {
+      const pattern = ctx.patterns.getConfig(componentReportItem.componentName.toLowerCase());
       const patternProp = pattern?.properties?.[propName];
       if (!patternProp)
         return false;
@@ -508,75 +512,82 @@ var classifyTokens = (ctx, parserResultByFilepath) => {
       set.add(value);
       map.set(key, set);
     };
-    const processMap = (map, current, reportInstanceItem) => {
-      const { from, type, kind } = reportInstanceItem;
+    const processMap = (map, current, componentReportItem) => {
+      const { reportItemType: type, kind } = componentReportItem;
+      const name = componentReportItem.componentName;
       map.value.forEach((attrNode, attrName) => {
         if (import_extractor.box.isLiteral(attrNode) || import_extractor.box.isEmptyInitializer(attrNode)) {
           const value = import_extractor.box.isLiteral(attrNode) ? attrNode.value : true;
-          const reportItem = {
-            id: id++,
-            instanceId,
-            category: "unknown",
+          const propReportItem = {
+            index: String(id++),
+            componentIndex: String(componentReportItem.componentIndex),
+            componentName: name,
+            tokenType: void 0,
             propName: attrName,
-            from,
-            type,
+            reportItemKind: "utility",
+            reportItemType: type,
             kind,
             filepath,
             path: current.concat(attrName),
             value,
-            box: attrNode,
-            isKnown: false
+            isKnownValue: false,
+            range: map.getRange()
           };
-          reportInstanceItem.contains.push(reportItem.id);
+          componentReportItem.contains.push(propReportItem.index);
           if (conditions.has(attrName)) {
-            addTo(globalMaps.byConditionName, attrName, reportItem.id);
-            addTo(localMaps.byConditionName, attrName, reportItem.id);
-            reportItem.propName = current[0] ?? attrName;
-            reportItem.isKnown = isKnownUtility(reportItem);
-            reportItem.conditionName = attrName;
+            addTo(globalMaps.byConditionName, attrName, propReportItem.index);
+            addTo(localMaps.byConditionName, attrName, propReportItem.index);
+            propReportItem.propName = current[0] ?? attrName;
+            propReportItem.isKnownValue = isKnownUtility(propReportItem, componentReportItem);
+            propReportItem.conditionName = attrName;
           } else {
             if (current.length && conditions.has(current[0])) {
-              reportItem.conditionName = current[0];
-              addTo(globalMaps.byConditionName, current[0], reportItem.id);
-              addTo(localMaps.byConditionName, current[0], reportItem.id);
+              propReportItem.conditionName = current[0];
+              addTo(globalMaps.byConditionName, current[0], propReportItem.index);
+              addTo(localMaps.byConditionName, current[0], propReportItem.index);
             }
             const propName = ctx.utility.shorthands.get(attrName) ?? attrName;
-            reportItem.propName = propName;
+            propReportItem.propName = propName;
             const utility = ctx.config.utilities?.[propName];
-            reportItem.isKnown = isKnownUtility(reportItem);
-            const category = typeof utility?.values === "string" ? utility?.values : "unknown";
-            reportItem.category = category;
-            addTo(globalMaps.byPropertyName, propName, reportItem.id);
-            addTo(localMaps.byPropertyName, propName, reportItem.id);
-            addTo(globalMaps.byCategory, category, reportItem.id);
-            addTo(localMaps.byCategory, category, reportItem.id);
-            if (propName.toLowerCase().includes("color") || colorPropNames.has(propName)) {
-              addTo(globalMaps.colorsUsed, value, reportItem.id);
-              addTo(localMaps.colorsUsed, value, reportItem.id);
+            propReportItem.isKnownValue = isKnownUtility(propReportItem, componentReportItem);
+            const tokenType = typeof utility?.values === "string" ? utility?.values : void 0;
+            if (tokenType) {
+              propReportItem.reportItemKind = "token";
+              propReportItem.tokenType = tokenType;
+            }
+            addTo(globalMaps.byPropertyName, propName, propReportItem.index);
+            addTo(localMaps.byPropertyName, propName, propReportItem.index);
+            if (tokenType) {
+              addTo(globalMaps.byTokenType, tokenType, propReportItem.index);
+              addTo(localMaps.byTokenType, tokenType, propReportItem.index);
+            }
+            if (propName.toLowerCase().includes("color") || groupByProp.get(propName) === "Color" || tokenType === "colors") {
+              addTo(globalMaps.colorsUsed, value, propReportItem.index);
+              addTo(localMaps.colorsUsed, value, propReportItem.index);
             }
             if (ctx.utility.shorthands.has(attrName)) {
-              addTo(globalMaps.byShorthand, attrName, reportItem.id);
-              addTo(localMaps.byShorthand, attrName, reportItem.id);
+              addTo(globalMaps.byShorthand, attrName, propReportItem.index);
+              addTo(localMaps.byShorthand, attrName, propReportItem.index);
             }
           }
           if (current.length) {
-            addTo(globalMaps.byPropertyPath, reportItem.path.join("."), reportItem.id);
-            addTo(localMaps.byPropertyPath, reportItem.path.join("."), reportItem.id);
+            addTo(globalMaps.byPropertyPath, propReportItem.path.join("."), propReportItem.index);
+            addTo(localMaps.byPropertyPath, propReportItem.path.join("."), propReportItem.index);
           }
-          addTo(globalMaps.byTokenName, String(value), reportItem.id);
-          addTo(localMaps.byTokenName, String(value), reportItem.id);
-          addTo(globalMaps.byType, type, reportItem.id);
-          addTo(localMaps.byType, type, reportItem.id);
-          addTo(globalMaps.byInstanceName, from, reportItem.id);
-          addTo(localMaps.byInstanceName, from, reportItem.id);
-          addTo(globalMaps.fromKind, kind, reportItem.id);
-          addTo(localMaps.fromKind, kind, reportItem.id);
-          addTo(byFilepath, filepath, reportItem.id);
-          byId.set(reportItem.id, reportItem);
+          addTo(globalMaps.byTokenName, String(value), propReportItem.index);
+          addTo(localMaps.byTokenName, String(value), propReportItem.index);
+          addTo(globalMaps.byType, type, propReportItem.index);
+          addTo(localMaps.byType, type, propReportItem.index);
+          addTo(globalMaps.byComponentName, name, propReportItem.index);
+          addTo(localMaps.byComponentName, name, propReportItem.index);
+          addTo(globalMaps.fromKind, kind, propReportItem.index);
+          addTo(localMaps.fromKind, kind, propReportItem.index);
+          addTo(byFilepath, filepath, propReportItem.index);
+          byId.set(propReportItem.index, propReportItem);
           return;
         }
         if (import_extractor.box.isMap(attrNode) && attrNode.value.size) {
-          return processMap(attrNode, current.concat(attrName), reportInstanceItem);
+          return processMap(attrNode, current.concat(attrName), componentReportItem);
         }
       });
     };
@@ -585,45 +596,44 @@ var classifyTokens = (ctx, parserResultByFilepath) => {
         return;
       }
       if (!item.data) {
+        console.log("no data", item);
         return;
       }
-      const from = item.name;
-      const type = item.type;
-      const reportInstanceItem = {
-        instanceId: instanceId++,
-        from,
-        type,
+      const componentReportItem = {
+        componentIndex: String(componentIndex++),
+        componentName: item.name,
+        reportItemType: item.type,
         kind,
         filepath,
         value: item.data,
-        box: item.box,
+        range: item.box.getRange(),
         contains: []
       };
       if (import_extractor.box.isArray(item.box)) {
-        addTo(byInstanceInFilepath, filepath, reportInstanceItem.instanceId);
-        return reportInstanceItem;
+        addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
+        return componentReportItem;
       }
       if (import_extractor.box.isMap(item.box) && item.box.value.size) {
-        addTo(byInstanceInFilepath, filepath, reportInstanceItem.instanceId);
-        processMap(item.box, [], reportInstanceItem);
-        return reportInstanceItem;
+        addTo(byComponentInFilepath, filepath, componentReportItem.componentIndex);
+        processMap(item.box, [], componentReportItem);
+        return componentReportItem;
       }
     };
     const processComponentResultItem = (item) => {
-      const reportInstanceItem = processResultItem(item, "component");
-      if (!reportInstanceItem)
+      const componentReportItem = processResultItem(item, "component");
+      if (!componentReportItem)
         return;
-      addTo(globalMaps.byInstanceOfKind, "component", reportInstanceItem.instanceId);
-      addTo(localMaps.byInstanceOfKind, "component", reportInstanceItem.instanceId);
-      byInstanceId.set(reportInstanceItem.instanceId, reportInstanceItem);
+      addTo(globalMaps.byComponentOfKind, "component", componentReportItem.componentIndex);
+      addTo(localMaps.byComponentOfKind, "component", componentReportItem.componentIndex);
+      byComponentIndex.set(componentReportItem.componentIndex, componentReportItem);
     };
     const processFunctionResultItem = (item) => {
-      const reportInstanceItem = processResultItem(item, "function");
-      if (!reportInstanceItem)
+      const componentReportItem = processResultItem(item, "function");
+      if (!componentReportItem)
         return;
-      addTo(globalMaps.byInstanceOfKind, "function", reportInstanceItem.instanceId);
-      addTo(localMaps.byInstanceOfKind, "function", reportInstanceItem.instanceId);
-      byInstanceId.set(reportInstanceItem.instanceId, reportInstanceItem);
+      addTo(globalMaps.byComponentOfKind, "function", componentReportItem.componentIndex);
+      addTo(localMaps.byComponentOfKind, "function", componentReportItem.componentIndex);
+      byComponentIndex.set(componentReportItem.componentIndex, componentReportItem);
     };
     parserResult.jsx.forEach(processComponentResultItem);
     parserResult.css.forEach(processFunctionResultItem);
@@ -637,37 +647,33 @@ var classifyTokens = (ctx, parserResultByFilepath) => {
     byFilePathMaps.set(filepath, localMaps);
   });
   const pickCount = 10;
-  const filesWithMostInstance = Object.fromEntries(
-    Array.from(byInstanceInFilepath.entries()).map(([filepath, list]) => [filepath, list.size]).sort((a, b) => b[1] - a[1]).slice(0, pickCount)
-  );
-  const filesWithMostPropValueCombinations = Object.fromEntries(
-    Array.from(byFilepath.entries()).map(([token, list]) => [token, list.size]).sort((a, b) => b[1] - a[1]).slice(0, pickCount)
+  const filesWithMostComponent = Object.fromEntries(
+    Array.from(byComponentInFilepath.entries()).map(([filepath, list]) => [filepath, list.size]).sort((a, b) => b[1] - a[1]).slice(0, pickCount)
   );
   return {
-    counts: {
-      filesWithTokens: byFilepath.size,
-      propNameUsed: globalMaps.byPropertyName.size,
-      tokenUsed: globalMaps.byTokenName.size,
-      shorthandUsed: globalMaps.byShorthand.size,
-      propertyPathUsed: globalMaps.byPropertyPath.size,
-      typeUsed: globalMaps.byType.size,
-      instanceNameUsed: globalMaps.byInstanceName.size,
-      kindUsed: globalMaps.fromKind.size,
-      instanceOfKindUsed: globalMaps.byInstanceOfKind.size,
-      colorsUsed: globalMaps.colorsUsed.size
-    },
-    stats: {
-      //
-      filesWithMostInstance,
-      filesWithMostPropValueCombinations,
-      //
-      mostUseds: getXMostUseds(globalMaps, 10)
-    },
+    propById: byId,
+    componentById: byComponentIndex,
     details: {
-      byId,
-      byInstanceId,
+      counts: {
+        filesWithTokens: byFilepath.size,
+        propNameUsed: globalMaps.byPropertyName.size,
+        tokenUsed: globalMaps.byTokenName.size,
+        shorthandUsed: globalMaps.byShorthand.size,
+        propertyPathUsed: globalMaps.byPropertyPath.size,
+        typeUsed: globalMaps.byType.size,
+        componentNameUsed: globalMaps.byComponentName.size,
+        kindUsed: globalMaps.fromKind.size,
+        componentOfKindUsed: globalMaps.byComponentOfKind.size,
+        colorsUsed: globalMaps.colorsUsed.size
+      },
+      stats: {
+        filesWithMostComponent,
+        mostUseds: getXMostUseds(globalMaps, 10)
+      }
+    },
+    derived: {
       byFilepath,
-      byInstanceInFilepath,
+      byComponentInFilepath,
       globalMaps,
       byFilePathMaps
     }
@@ -680,17 +686,78 @@ var getXMostUseds = (globalMaps, pickCount) => {
     shorthands: getMostUsedInMap(globalMaps.byShorthand, pickCount),
     conditions: getMostUsedInMap(globalMaps.byConditionName, pickCount),
     propertyPaths: getMostUsedInMap(globalMaps.byPropertyPath, pickCount),
-    categories: getMostUsedInMap(globalMaps.byCategory, pickCount),
+    categories: getMostUsedInMap(globalMaps.byTokenType, pickCount),
     types: getMostUsedInMap(globalMaps.byType, pickCount),
-    instanceNames: getMostUsedInMap(globalMaps.byInstanceName, pickCount),
+    componentNames: getMostUsedInMap(globalMaps.byComponentName, pickCount),
     fromKinds: getMostUsedInMap(globalMaps.fromKind, pickCount),
-    instanceOfKinds: getMostUsedInMap(globalMaps.byInstanceOfKind, pickCount),
+    componentOfKinds: getMostUsedInMap(globalMaps.byComponentOfKind, pickCount),
     colors: getMostUsedInMap(globalMaps.colorsUsed, pickCount)
   };
 };
 var getMostUsedInMap = (map, pickCount) => {
   return Array.from(map.entries()).map(([key, list]) => [key, list.size]).sort((a, b) => b[1] - a[1]).slice(0, pickCount).map(([key, count]) => ({ key, count }));
 };
+var defaultGroupNames = [
+  "System",
+  "Container",
+  "Display",
+  "Visibility",
+  "Position",
+  "Transform",
+  "Flex Layout",
+  "Grid Layout",
+  "Layout",
+  "Border",
+  "Border Radius",
+  "Width",
+  "Height",
+  "Margin",
+  "Padding",
+  "Color",
+  "Typography",
+  "Background",
+  "Shadow",
+  "Table",
+  "List",
+  "Scroll",
+  "Interactivity",
+  "Transition",
+  "Effect",
+  "Other"
+];
+var getPropertyGroupMap = (context) => {
+  const groups = new Map(defaultGroupNames.map((name) => [name, /* @__PURE__ */ new Set()]));
+  const groupByProp = /* @__PURE__ */ new Map();
+  const systemGroup = groups.get("System");
+  systemGroup.add("base");
+  systemGroup.add("colorPalette");
+  const otherStyleProps = groups.get("Other");
+  Object.entries(context.utility.config).map(([key, value]) => {
+    const group = value?.group;
+    if (!group) {
+      otherStyleProps.add(key);
+      return;
+    }
+    if (!groups.has(group)) {
+      groups.set(group, /* @__PURE__ */ new Set());
+    }
+    const set = groups.get(group);
+    if (value.shorthand) {
+      if (Array.isArray(value.shorthand)) {
+        value.shorthand.forEach((shorthand) => {
+          set.add(shorthand);
+          groupByProp.set(shorthand, group);
+        });
+      } else {
+        set.add(value.shorthand);
+        groupByProp.set(value.shorthand, group);
+      }
+    }
+    set.add(key);
+    groupByProp.set(key, group);
+  });
+  return { groups, groupByProp };
+};
 
 // src/analyze-tokens.ts
 var gzipSizeSync = (code) => import_zlib.default.gzipSync(code, { level: import_zlib.default.constants.Z_BEST_COMPRESSION }).length;
@@ -698,34 +765,66 @@ function analyzeTokens(ctx, options = {}) {
   const filesMap = /* @__PURE__ */ new Map();
   const timesMap = /* @__PURE__ */ new Map();
   const files = ctx.getFiles();
+  const sheet = ctx.createSheet();
+  ctx.appendLayerParams(sheet);
+  ctx.appendBaselineCss(sheet);
   files.forEach((file) => {
     const start2 = performance.now();
     const result = ctx.project.parseSourceFile(file);
     const extractMs = performance.now() - start2;
-    timesMap.set(file, extractMs);
+    const relativePath = import_node_path.default.relative(ctx.config.cwd, file);
+    timesMap.set(relativePath, extractMs);
     import_logger.logger.debug("analyze", `Parsed ${file} in ${extractMs}ms`);
     if (result) {
-      filesMap.set(file, result);
+      filesMap.set(relativePath, result);
       options.onResult?.(file, result);
     }
   });
   const totalMs = Array.from(timesMap.values()).reduce((a, b) => a + b, 0);
   import_logger.logger.debug("analyze", `Analyzed ${files.length} files in ${totalMs.toFixed(2)}ms`);
-  const minify = ctx.config.minify;
-  ctx.config.optimize = true;
+  ctx.appendParserCss(sheet);
+  const cssStart = performance.now();
   ctx.config.minify = false;
-  const css = "";
-  const minifiedCss = "";
-  ctx.config.minify = minify;
+  const css = ctx.getCss(sheet);
+  const cssMs = performance.now() - cssStart;
+  const cssMinifyStart = performance.now();
+  ctx.config.minify = true;
+  const minifiedCss = ctx.getCss(sheet);
+  const cssMinifyMs = performance.now() - cssMinifyStart;
+  let lightningCss = "";
+  let lightningCssMs;
+  let lightningCssMinifiedCss = "";
+  let lightningCssMinifiedMs;
+  const isUsingLightningCss = ctx.config.lightningcss;
+  if (!isUsingLightningCss) {
+    sheet["context"].lightningcss = true;
+    ctx.config.minify = false;
+    const lightningcssStart = performance.now();
+    lightningCss = ctx.getCss(sheet);
+    lightningCssMs = performance.now() - lightningcssStart;
+    ctx.config.minify = true;
+    const lightningcssMinifyStart = performance.now();
+    lightningCssMinifiedCss = ctx.getCss(sheet);
+    lightningCssMinifiedMs = performance.now() - lightningcssMinifyStart;
+  }
   const start = performance.now();
   const analysis = classifyTokens(ctx, filesMap);
   const classifyMs = performance.now() - start;
-  return Object.assign(
+  const details = Object.assign(
     {
       duration: {
-        extractTimeByFiles: Object.fromEntries(timesMap.entries()),
+        classify: classifyMs,
+        //
+        cssMs,
+        cssMinifyMs,
+        //
+        ...!isUsingLightningCss ? {
+          lightningCssMs,
+          lightningCssMinifiedMs
+        } : {},
+        //
         extractTotal: totalMs,
-        classify: classifyMs
+        extractTimeByFiles: Object.fromEntries(timesMap.entries())
       },
       fileSizes: {
         lineCount: css.split("\n").length,
@@ -734,11 +833,24 @@ function analyzeTokens(ctx, options = {}) {
         gzip: {
           normal: (0, import_filesize.filesize)(gzipSizeSync(css)),
           minified: (0, import_filesize.filesize)(gzipSizeSync(minifiedCss))
-        }
+        },
+        lightningCss: !isUsingLightningCss ? {
+          normal: (0, import_filesize.filesize)(Buffer.byteLength(lightningCss, "utf-8")),
+          minified: (0, import_filesize.filesize)(Buffer.byteLength(lightningCssMinifiedCss, "utf-8"))
+        } : void 0
       }
     },
-    analysis
+    analysis.details
   );
+  const { globalCss, ...config } = ctx.config;
+  return {
+    schemaVersion: version,
+    details,
+    propByIndex: analysis.propById,
+    componentByIndex: analysis.componentById,
+    derived: analysis.derived,
+    config
+  };
 }
 var analyzeResultSerializer = (_key, value) => {
   if (value instanceof Set) {
@@ -750,25 +862,9 @@ var analyzeResultSerializer = (_key, value) => {
   return value;
 };
 var writeAnalyzeJSON = (filePath, result, ctx) => {
-  result.details.byInstanceId.forEach((item) => {
-    item.box = item.box.toJSON();
-  });
   const dirname2 = ctx.runtime.path.dirname(filePath);
   ctx.runtime.fs.ensureDirSync(dirname2);
-  return (0, import_promises.writeFile)(
-    filePath,
-    JSON.stringify(
-      Object.assign(result, {
-        cwd: ctx.config.cwd,
-        theme: ctx.config.theme,
-        utilities: ctx.config.utilities,
-        conditions: ctx.config.conditions,
-        shorthands: ctx.utility.shorthands
-      }),
-      analyzeResultSerializer,
-      2
-    )
-  );
+  return (0, import_promises.writeFile)(filePath, JSON.stringify(result, analyzeResultSerializer, 2));
 };
 
 // src/build-info.ts
@@ -1297,10 +1393,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return 3;
   }
   if ("TERM_PROGRAM" in env) {
-    const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
+    const version2 = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
     switch (env.TERM_PROGRAM) {
       case "iTerm.app": {
-        return version >= 3 ? 3 : 2;
+        return version2 >= 3 ? 3 : 2;
       }
       case "Apple_Terminal": {
         return 2;
@@ -2331,8 +2427,8 @@ var nodeRuntime = {
     readDirSync: import_fs_extra.default.readdirSync,
     rmDirSync: import_fs_extra.default.emptyDirSync,
     rmFileSync: import_fs_extra.default.removeSync,
-    ensureDirSync(path3) {
-      return import_fs_extra.default.ensureDirSync(path3);
+    ensureDirSync(path4) {
+      return import_fs_extra.default.ensureDirSync(path4);
     },
     watch(options) {
       const { include, exclude, cwd, poll } = options;
@@ -2777,7 +2873,7 @@ var Builder = class {
 init_cjs_shims();
 var import_logger7 = require("@pandacss/logger");
 var import_node_fs = __toESM(require("fs"));
-var import_node_path = __toESM(require("path"));
+var import_node_path2 = __toESM(require("path"));
 var import_node_readline = __toESM(require("readline"));
 var startProfiling = async (cwd, prefix, isWatching) => {
   const inspector = await import("inspector").then((r) => r.default);
@@ -2842,7 +2938,7 @@ var startProfiling = async (cwd, prefix, isWatching) => {
       const date = /* @__PURE__ */ new Date();
       const timestamp = date.toISOString().replace(/[-:.]/g, "");
       const title = `panda-${prefix}-${timestamp}`;
-      const outfile = import_node_path.default.join(cwd, `${title}.cpuprofile`);
+      const outfile = import_node_path2.default.join(cwd, `${title}.cpuprofile`);
       import_node_fs.default.writeFileSync(outfile, JSON.stringify(params.profile));
       import_logger7.logger.info("cpu-prof", outfile);
       cb?.();
@@ -2895,8 +2991,7 @@ async function debug(ctx, options) {
   const files = ctx.getFiles();
   const measureTotal = import_logger9.logger.time.debug(`Done parsing ${files.length} files`);
   ctx.config.minify = false;
-  ctx.config.optimize = true;
-  const { fs: fs3, path: path3 } = ctx.runtime;
+  const { fs: fs3, path: path4 } = ctx.runtime;
   const outdir = options.outdir;
   if (!options.dry && outdir) {
     fs3.ensureDirSync(outdir);
@@ -2926,14 +3021,14 @@ async function debug(ctx, options) {
     if (outdir) {
       filesWithCss.push(file);
       const parsedPath = (0, import_path4.parse)(file);
-      const relative2 = path3.relative(ctx.config.cwd, parsedPath.dir);
-      const astJsonPath = `${relative2}${path3.sep}${parsedPath.name}.ast.json`.replaceAll(path3.sep, "__");
-      const cssPath = `${relative2}${path3.sep}${parsedPath.name}.css`.replaceAll(path3.sep, "__");
+      const relative2 = path4.relative(ctx.config.cwd, parsedPath.dir);
+      const astJsonPath = `${relative2}${path4.sep}${parsedPath.name}.ast.json`.replaceAll(path4.sep, "__");
+      const cssPath = `${relative2}${path4.sep}${parsedPath.name}.css`.replaceAll(path4.sep, "__");
       import_logger9.logger.info("cli", `Writing ${import_logger9.colors.bold(`${outdir}/${astJsonPath}`)}`);
       import_logger9.logger.info("cli", `Writing ${import_logger9.colors.bold(`${outdir}/${cssPath}`)}`);
       return Promise.allSettled([
-        fs3.writeFile(`${outdir}${path3.sep}${astJsonPath}`, JSON.stringify(result.toJSON(), null, 2)),
-        fs3.writeFile(`${outdir}${path3.sep}${cssPath}`, css)
+        fs3.writeFile(`${outdir}${path4.sep}${astJsonPath}`, JSON.stringify(result.toJSON(), null, 2)),
+        fs3.writeFile(`${outdir}${path4.sep}${cssPath}`, css)
       ]);
     }
   });
@@ -3032,12 +3127,12 @@ function setupGitIgnore(ctx) {
 init_cjs_shims();
 var import_logger11 = require("@pandacss/logger");
 var import_node_fs2 = __toESM(require("fs"));
-var import_node_path2 = __toESM(require("path"));
+var import_node_path3 = __toESM(require("path"));
 var setLogStream = (options) => {
   const { cwd = process.cwd() } = options;
   let stream;
   if (options.logfile) {
-    const outPath = import_node_path2.default.resolve(cwd, options.logfile);
+    const outPath = import_node_path3.default.resolve(cwd, options.logfile);
     ensure(outPath);
     import_logger11.logger.info("logfile", outPath);
     stream = import_node_fs2.default.createWriteStream(outPath, { flags: "a" });
@@ -3058,7 +3153,7 @@ var setLogStream = (options) => {
   };
 };
 var ensure = (outPath) => {
-  const dirname2 = import_node_path2.default.dirname(outPath);
+  const dirname2 = import_node_path3.default.dirname(outPath);
   import_node_fs2.default.mkdirSync(dirname2, { recursive: true });
   return outPath;
 };