@pandacss/node 0.0.0-dev-20230321103030 → 0.0.0-dev-20230323194924

package/dist/index.mjs

@@ -27,9 +27,9 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
-// ../../node_modules/.pnpm/tsup@6.7.0_typescript@4.9.5/node_modules/tsup/assets/esm_shims.js
+// ../../node_modules/.pnpm/tsup@6.7.0_typescript@5.0.2/node_modules/tsup/assets/esm_shims.js
 var init_esm_shims = __esm({
-  "../../node_modules/.pnpm/tsup@6.7.0_typescript@4.9.5/node_modules/tsup/assets/esm_shims.js"() {
+  "../../node_modules/.pnpm/tsup@6.7.0_typescript@5.0.2/node_modules/tsup/assets/esm_shims.js"() {
   }
 });
 
@@ -396,11 +396,381 @@ var require_ansi_align = __commonJS({
 init_esm_shims();
 import { discardDuplicate as discardDuplicate2 } from "@pandacss/core";
 
+// src/analyze-tokens.ts
+init_esm_shims();
+import { logger } from "@pandacss/logger";
+import { writeFile } from "fs/promises";
+import { Node } from "ts-morph";
+
+// src/classify.ts
+init_esm_shims();
+var createReportMaps = () => {
+  const byInstanceOfKind = /* @__PURE__ */ new Map();
+  const byPropertyName = /* @__PURE__ */ new Map();
+  const byCategory = /* @__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 colorsUsed = /* @__PURE__ */ new Map();
+  return {
+    byInstanceOfKind,
+    byPropertyName,
+    byCategory,
+    byConditionName,
+    byShorthand,
+    byTokenName,
+    byPropertyPath,
+    fromKind,
+    byType,
+    byInstanceName,
+    colorsUsed
+  };
+};
+var colorPropNames = /* @__PURE__ */ new Set(["background", "outline", "border"]);
+var classifyTokens = (ctx, parserResultByFilepath) => {
+  const byId = /* @__PURE__ */ new Map();
+  const byInstanceId = /* @__PURE__ */ new Map();
+  const byFilepath = /* @__PURE__ */ new Map();
+  const byInstanceInFilepath = /* @__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 utility = ctx.config.utilities?.[propName];
+    if (utility) {
+      if (!utility.shorthand) {
+        return Boolean(ctx.tokens.getByName(`${utility.values}.${value}`));
+      }
+      return Boolean(ctx.tokens.getByName(`${utility.values}.${value}`));
+    }
+    if (type === "pattern") {
+      const pattern = ctx.patterns.getConfig(from.toLowerCase());
+      const patternProp = pattern.properties[propName];
+      if (!patternProp)
+        return false;
+      if (patternProp.type === "boolean" || patternProp.type === "number") {
+        return true;
+      }
+      if (patternProp.type === "property") {
+        return Boolean(ctx.config.utilities?.[patternProp.value]);
+      }
+      if (patternProp.type === "enum") {
+        return Boolean(patternProp.value.includes(String(value)));
+      }
+      if (patternProp.type === "token") {
+        return Boolean(ctx.tokens.getByName(`${patternProp.value}.${value}`));
+      }
+      return false;
+    }
+    return false;
+  };
+  parserResultByFilepath.forEach((parserResult, filepath) => {
+    if (parserResult.isEmpty())
+      return;
+    const localMaps = createReportMaps();
+    const addTo = (map, key, value) => {
+      const set = map.get(key) ?? /* @__PURE__ */ new Set();
+      set.add(value);
+      map.set(key, set);
+    };
+    const processMap = (map, current, reportInstanceItem) => {
+      const { from, type, kind } = reportInstanceItem;
+      map.value.forEach((attrNode, attrName) => {
+        if (attrNode.isLiteral() || attrNode.isEmptyInitializer()) {
+          const value = attrNode.isLiteral() ? attrNode.value : true;
+          const reportItem = {
+            id: id++,
+            instanceId,
+            category: "unknown",
+            propName: attrName,
+            from,
+            type,
+            kind,
+            filepath,
+            path: current.concat(attrName),
+            value,
+            box: attrNode,
+            isKnown: false
+          };
+          reportInstanceItem.contains.push(reportItem.id);
+          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;
+          } 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);
+            }
+            const propName = ctx.utility.shorthands.get(attrName) ?? attrName;
+            reportItem.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);
+            }
+            if (ctx.utility.shorthands.has(attrName)) {
+              addTo(globalMaps.byShorthand, attrName, reportItem.id);
+              addTo(localMaps.byShorthand, attrName, reportItem.id);
+            }
+          }
+          if (current.length) {
+            addTo(globalMaps.byPropertyPath, reportItem.path.join("."), reportItem.id);
+            addTo(localMaps.byPropertyPath, reportItem.path.join("."), reportItem.id);
+          }
+          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);
+          return;
+        }
+        if (attrNode.isMap() && attrNode.value.size) {
+          return processMap(attrNode, current.concat(attrName), reportInstanceItem);
+        }
+      });
+    };
+    const processResultItem = (item, kind) => {
+      if (!item.box || item.box.isUnresolvable()) {
+        return;
+      }
+      if (!item.data) {
+        return;
+      }
+      const from = item.name;
+      const type = item.type;
+      const reportInstanceItem = {
+        instanceId: instanceId++,
+        from,
+        type,
+        kind,
+        filepath,
+        value: item.data,
+        box: item.box,
+        contains: []
+      };
+      if (item.box.isList()) {
+        addTo(byInstanceInFilepath, filepath, reportInstanceItem.instanceId);
+        return reportInstanceItem;
+      }
+      if (item.box.isMap() && item.box.value.size) {
+        addTo(byInstanceInFilepath, filepath, reportInstanceItem.instanceId);
+        processMap(item.box, [], reportInstanceItem);
+        return reportInstanceItem;
+      }
+    };
+    const processComponentResultItem = (item) => {
+      const reportInstanceItem = processResultItem(item, "component");
+      if (!reportInstanceItem)
+        return;
+      addTo(globalMaps.byInstanceOfKind, "component", reportInstanceItem.instanceId);
+      addTo(localMaps.byInstanceOfKind, "component", reportInstanceItem.instanceId);
+      byInstanceId.set(reportInstanceItem.instanceId, reportInstanceItem);
+    };
+    const processFunctionResultItem = (item) => {
+      const reportInstanceItem = processResultItem(item, "function");
+      if (!reportInstanceItem)
+        return;
+      addTo(globalMaps.byInstanceOfKind, "function", reportInstanceItem.instanceId);
+      addTo(localMaps.byInstanceOfKind, "function", reportInstanceItem.instanceId);
+      byInstanceId.set(reportInstanceItem.instanceId, reportInstanceItem);
+    };
+    parserResult.jsx.forEach(processComponentResultItem);
+    parserResult.css.forEach(processFunctionResultItem);
+    parserResult.cva.forEach(processFunctionResultItem);
+    parserResult.pattern.forEach((itemList) => {
+      itemList.forEach(processFunctionResultItem);
+    });
+    parserResult.recipe.forEach((itemList) => {
+      itemList.forEach(processFunctionResultItem);
+    });
+    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)
+  );
+  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)
+    },
+    details: {
+      byId,
+      byInstanceId,
+      byFilepath,
+      byInstanceInFilepath,
+      globalMaps,
+      byFilePathMaps
+    }
+  };
+};
+var getXMostUseds = (globalMaps, pickCount) => {
+  return {
+    propNames: getMostUsedInMap(globalMaps.byPropertyName, pickCount),
+    tokens: getMostUsedInMap(globalMaps.byTokenName, pickCount),
+    shorthands: getMostUsedInMap(globalMaps.byShorthand, pickCount),
+    conditions: getMostUsedInMap(globalMaps.byConditionName, pickCount),
+    propertyPaths: getMostUsedInMap(globalMaps.byPropertyPath, pickCount),
+    categories: getMostUsedInMap(globalMaps.byCategory, pickCount),
+    types: getMostUsedInMap(globalMaps.byType, pickCount),
+    instanceNames: getMostUsedInMap(globalMaps.byInstanceName, pickCount),
+    fromKinds: getMostUsedInMap(globalMaps.fromKind, pickCount),
+    instanceOfKinds: getMostUsedInMap(globalMaps.byInstanceOfKind, 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 }));
+};
+
+// src/get-node-range.ts
+init_esm_shims();
+var getNodeRange = (node) => {
+  const src = node.getSourceFile();
+  const [startPosition, endPosition] = [node.getStart(), node.getEnd()];
+  const startInfo = src.getLineAndColumnAtPos(startPosition);
+  const endInfo = src.getLineAndColumnAtPos(endPosition);
+  return {
+    startPosition,
+    startLineNumber: startInfo.line,
+    startColumn: startInfo.column,
+    endPosition,
+    endLineNumber: endInfo.line,
+    endColumn: endInfo.column
+  };
+};
+
+// src/analyze-tokens.ts
+import gzipSize from "gzip-size";
+import { filesize } from "filesize";
+function analyzeTokens(ctx, options = {
+  mode: "box-extractor"
+}) {
+  const parserResultByFilepath = /* @__PURE__ */ new Map();
+  const extractTimeByFilepath = /* @__PURE__ */ new Map();
+  ctx.getFiles().map((file) => {
+    const start2 = performance.now();
+    const result = ctx.project.parseSourceFile(file, ctx.properties, options.mode);
+    const extractMs = performance.now() - start2;
+    extractTimeByFilepath.set(file, extractMs);
+    logger.debug("analyze", `Extracted ${file} in ${extractMs}ms`);
+    if (result) {
+      parserResultByFilepath.set(file, result);
+      options.onResult?.(file, result);
+    }
+    return [file, result];
+  }).filter(([, result]) => result);
+  const totalMs = Array.from(extractTimeByFilepath.values()).reduce((a, b) => a + b, 0);
+  logger.debug("analyze", `Analyzed ${ctx.getFiles().length} files in ${totalMs.toFixed(2)}ms`);
+  const minify = ctx.config.minify;
+  const files = ctx.chunks.getFiles();
+  ctx.config.minify = false;
+  const css = ctx.getCss({ files });
+  ctx.config.minify = true;
+  const minifiedCss = ctx.getCss({ files });
+  ctx.config.minify = minify;
+  const start = performance.now();
+  const analysis = classifyTokens(ctx, parserResultByFilepath);
+  const classifyMs = performance.now() - start;
+  return Object.assign(
+    {
+      duration: {
+        extractTimeByFiles: Object.fromEntries(extractTimeByFilepath.entries()),
+        extractTotal: totalMs,
+        classify: classifyMs
+      },
+      fileSizes: {
+        lineCount: css.split("\n").length,
+        // rulesCount: css.split('{').length - 1, ?
+        normal: filesize(Buffer.byteLength(css, "utf-8")),
+        minified: filesize(Buffer.byteLength(minifiedCss, "utf-8")),
+        gzip: {
+          normal: filesize(gzipSize.sync(css)),
+          minified: filesize(gzipSize.sync(minifiedCss))
+        }
+      }
+    },
+    analysis
+  );
+}
+var analyzeResultSerializer = (_key, value) => {
+  if (value instanceof Set) {
+    return Array.from(value);
+  }
+  if (value instanceof Map) {
+    return Object.fromEntries(value);
+  }
+  if (Node.isNode(value)) {
+    return { kind: value.getKindName(), range: getNodeRange(value) };
+  }
+  return value;
+};
+var writeAnalyzeJSON = (fileName, result, ctx) => {
+  result.details.byInstanceId.forEach((item) => {
+    item.box = { type: item.box.type, node: item.box.getNode(), stack: item.box.getStack() };
+  });
+  return writeFile(
+    fileName,
+    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,
+        parserOptions: ctx.parserOptions
+      }),
+      analyzeResultSerializer,
+      2
+    )
+  );
+};
+
 // src/builder.ts
 init_esm_shims();
 import { discardDuplicate, mergeCss as mergeCss2 } from "@pandacss/core";
 import { ConfigNotFoundError } from "@pandacss/error";
-import { logger as logger3 } from "@pandacss/logger";
+import { logger as logger4 } from "@pandacss/logger";
 import { toHash } from "@pandacss/shared";
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { statSync } from "fs-extra";
@@ -454,7 +824,7 @@ var getChunkEngine = ({ paths, config, runtime: { path, fs } }) => ({
 
 // src/node-runtime.ts
 init_esm_shims();
-import { logger } from "@pandacss/logger";
+import { logger as logger2 } from "@pandacss/logger";
 import chokidar from "chokidar";
 import glob from "fast-glob";
 import {
@@ -464,7 +834,7 @@ import {
   readdirSync,
   readFileSync,
   removeSync,
-  writeFile,
+  writeFile as writeFile2,
   writeFileSync
 } from "fs-extra";
 import { dirname, extname, isAbsolute, join, relative, sep } from "path";
@@ -496,7 +866,7 @@ var nodeRuntime = {
         return [];
       return glob.sync(opts.include, { cwd: opts.cwd, ignore: opts.exclude, absolute: true });
     },
-    writeFile,
+    writeFile: writeFile2,
     writeFileSync,
     readDirSync: readdirSync,
     rmDirSync: emptyDirSync,
@@ -515,7 +885,7 @@ var nodeRuntime = {
         ignored: exclude,
         awaitWriteFinish: coalesce ? { stabilityThreshold: 50, pollInterval: 10 } : false
       });
-      logger.debug("watch:file", `watching [${include}]`);
+      logger2.debug("watch:file", `watching [${include}]`);
       process.once("SIGINT", async () => {
         await watcher.close();
       });
@@ -525,10 +895,10 @@ var nodeRuntime = {
 };
 process.setMaxListeners(Infinity);
 process.on("unhandledRejection", (reason) => {
-  logger.error("unhandled-rejection", reason);
+  logger2.error("unhandled-rejection", reason);
 });
 process.on("uncaughtException", (reason) => {
-  logger.error("uncaught-exception", reason);
+  logger2.error("uncaught-exception", reason);
 });
 
 // src/output-engine.ts
@@ -592,18 +962,21 @@ async function loadConfigAndCreateContext(options = {}) {
   if (config) {
     Object.assign(conf.config, config);
   }
+  if (options.cwd) {
+    conf.config.cwd = options.cwd;
+  }
   return createContext(conf);
 }
 
 // src/extract.ts
 init_esm_shims();
-import { logger as logger2 } from "@pandacss/logger";
+import { logger as logger3 } from "@pandacss/logger";
 import { Obj as Obj2, pipe as pipe2, tap as tap2, tryCatch } from "lil-fp";
 
 // src/cli-box.ts
 init_esm_shims();
 
-// ../../node_modules/.pnpm/boxen@7.0.1/node_modules/boxen/index.js
+// ../../node_modules/.pnpm/boxen@7.0.2/node_modules/boxen/index.js
 init_esm_shims();
 import process3 from "node:process";
 
@@ -673,102 +1046,110 @@ function stringWidth(string, options = {}) {
   return width;
 }
 
-// ../../node_modules/.pnpm/chalk@5.0.1/node_modules/chalk/source/index.js
+// ../../node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/index.js
 init_esm_shims();
 
-// ../../node_modules/.pnpm/chalk@5.0.1/node_modules/chalk/source/vendor/ansi-styles/index.js
+// ../../node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/vendor/ansi-styles/index.js
 init_esm_shims();
 var ANSI_BACKGROUND_OFFSET = 10;
 var wrapAnsi16 = (offset = 0) => (code) => `\x1B[${code + offset}m`;
 var wrapAnsi256 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
 var wrapAnsi16m = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
+var styles = {
+  modifier: {
+    reset: [0, 0],
+    // 21 isn't widely supported and 22 does the same thing
+    bold: [1, 22],
+    dim: [2, 22],
+    italic: [3, 23],
+    underline: [4, 24],
+    overline: [53, 55],
+    inverse: [7, 27],
+    hidden: [8, 28],
+    strikethrough: [9, 29]
+  },
+  color: {
+    black: [30, 39],
+    red: [31, 39],
+    green: [32, 39],
+    yellow: [33, 39],
+    blue: [34, 39],
+    magenta: [35, 39],
+    cyan: [36, 39],
+    white: [37, 39],
+    // Bright color
+    blackBright: [90, 39],
+    gray: [90, 39],
+    // Alias of `blackBright`
+    grey: [90, 39],
+    // Alias of `blackBright`
+    redBright: [91, 39],
+    greenBright: [92, 39],
+    yellowBright: [93, 39],
+    blueBright: [94, 39],
+    magentaBright: [95, 39],
+    cyanBright: [96, 39],
+    whiteBright: [97, 39]
+  },
+  bgColor: {
+    bgBlack: [40, 49],
+    bgRed: [41, 49],
+    bgGreen: [42, 49],
+    bgYellow: [43, 49],
+    bgBlue: [44, 49],
+    bgMagenta: [45, 49],
+    bgCyan: [46, 49],
+    bgWhite: [47, 49],
+    // Bright color
+    bgBlackBright: [100, 49],
+    bgGray: [100, 49],
+    // Alias of `bgBlackBright`
+    bgGrey: [100, 49],
+    // Alias of `bgBlackBright`
+    bgRedBright: [101, 49],
+    bgGreenBright: [102, 49],
+    bgYellowBright: [103, 49],
+    bgBlueBright: [104, 49],
+    bgMagentaBright: [105, 49],
+    bgCyanBright: [106, 49],
+    bgWhiteBright: [107, 49]
+  }
+};
+var modifierNames = Object.keys(styles.modifier);
+var foregroundColorNames = Object.keys(styles.color);
+var backgroundColorNames = Object.keys(styles.bgColor);
+var colorNames = [...foregroundColorNames, ...backgroundColorNames];
 function assembleStyles() {
   const codes = /* @__PURE__ */ new Map();
-  const styles2 = {
-    modifier: {
-      reset: [0, 0],
-      // 21 isn't widely supported and 22 does the same thing
-      bold: [1, 22],
-      dim: [2, 22],
-      italic: [3, 23],
-      underline: [4, 24],
-      overline: [53, 55],
-      inverse: [7, 27],
-      hidden: [8, 28],
-      strikethrough: [9, 29]
-    },
-    color: {
-      black: [30, 39],
-      red: [31, 39],
-      green: [32, 39],
-      yellow: [33, 39],
-      blue: [34, 39],
-      magenta: [35, 39],
-      cyan: [36, 39],
-      white: [37, 39],
-      // Bright color
-      blackBright: [90, 39],
-      redBright: [91, 39],
-      greenBright: [92, 39],
-      yellowBright: [93, 39],
-      blueBright: [94, 39],
-      magentaBright: [95, 39],
-      cyanBright: [96, 39],
-      whiteBright: [97, 39]
-    },
-    bgColor: {
-      bgBlack: [40, 49],
-      bgRed: [41, 49],
-      bgGreen: [42, 49],
-      bgYellow: [43, 49],
-      bgBlue: [44, 49],
-      bgMagenta: [45, 49],
-      bgCyan: [46, 49],
-      bgWhite: [47, 49],
-      // Bright color
-      bgBlackBright: [100, 49],
-      bgRedBright: [101, 49],
-      bgGreenBright: [102, 49],
-      bgYellowBright: [103, 49],
-      bgBlueBright: [104, 49],
-      bgMagentaBright: [105, 49],
-      bgCyanBright: [106, 49],
-      bgWhiteBright: [107, 49]
-    }
-  };
-  styles2.color.gray = styles2.color.blackBright;
-  styles2.bgColor.bgGray = styles2.bgColor.bgBlackBright;
-  styles2.color.grey = styles2.color.blackBright;
-  styles2.bgColor.bgGrey = styles2.bgColor.bgBlackBright;
-  for (const [groupName, group] of Object.entries(styles2)) {
+  for (const [groupName, group] of Object.entries(styles)) {
     for (const [styleName, style] of Object.entries(group)) {
-      styles2[styleName] = {
+      styles[styleName] = {
         open: `\x1B[${style[0]}m`,
         close: `\x1B[${style[1]}m`
       };
-      group[styleName] = styles2[styleName];
+      group[styleName] = styles[styleName];
       codes.set(style[0], style[1]);
     }
-    Object.defineProperty(styles2, groupName, {
+    Object.defineProperty(styles, groupName, {
       value: group,
       enumerable: false
     });
   }
-  Object.defineProperty(styles2, "codes", {
+  Object.defineProperty(styles, "codes", {
     value: codes,
     enumerable: false
   });
-  styles2.color.close = "\x1B[39m";
-  styles2.bgColor.close = "\x1B[49m";
-  styles2.color.ansi = wrapAnsi16();
-  styles2.color.ansi256 = wrapAnsi256();
-  styles2.color.ansi16m = wrapAnsi16m();
-  styles2.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
-  styles2.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
-  styles2.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
-  Object.defineProperties(styles2, {
+  styles.color.close = "\x1B[39m";
+  styles.bgColor.close = "\x1B[49m";
+  styles.color.ansi = wrapAnsi16();
+  styles.color.ansi256 = wrapAnsi256();
+  styles.color.ansi16m = wrapAnsi16m();
+  styles.bgColor.ansi = wrapAnsi16(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi256 = wrapAnsi256(ANSI_BACKGROUND_OFFSET);
+  styles.bgColor.ansi16m = wrapAnsi16m(ANSI_BACKGROUND_OFFSET);
+  Object.defineProperties(styles, {
     rgbToAnsi256: {
-      value: (red, green, blue) => {
+      value(red, green, blue) {
         if (red === green && green === blue) {
           if (red < 8) {
             return 16;
@@ -783,12 +1164,12 @@ function assembleStyles() {
       enumerable: false
     },
     hexToRgb: {
-      value: (hex) => {
-        const matches = /(?<colorString>[a-f\d]{6}|[a-f\d]{3})/i.exec(hex.toString(16));
+      value(hex) {
+        const matches = /[a-f\d]{6}|[a-f\d]{3}/i.exec(hex.toString(16));
         if (!matches) {
           return [0, 0, 0];
         }
-        let { colorString } = matches.groups;
+        let [colorString] = matches;
         if (colorString.length === 3) {
           colorString = [...colorString].map((character) => character + character).join("");
         }
@@ -804,11 +1185,11 @@ function assembleStyles() {
       enumerable: false
     },
     hexToAnsi256: {
-      value: (hex) => styles2.rgbToAnsi256(...styles2.hexToRgb(hex)),
+      value: (hex) => styles.rgbToAnsi256(...styles.hexToRgb(hex)),
       enumerable: false
     },
     ansi256ToAnsi: {
-      value: (code) => {
+      value(code) {
         if (code < 8) {
           return 30 + code;
         }
@@ -842,25 +1223,25 @@ function assembleStyles() {
       enumerable: false
     },
     rgbToAnsi: {
-      value: (red, green, blue) => styles2.ansi256ToAnsi(styles2.rgbToAnsi256(red, green, blue)),
+      value: (red, green, blue) => styles.ansi256ToAnsi(styles.rgbToAnsi256(red, green, blue)),
       enumerable: false
     },
     hexToAnsi: {
-      value: (hex) => styles2.ansi256ToAnsi(styles2.hexToAnsi256(hex)),
+      value: (hex) => styles.ansi256ToAnsi(styles.hexToAnsi256(hex)),
       enumerable: false
     }
   });
-  return styles2;
+  return styles;
 }
 var ansiStyles = assembleStyles();
 var ansi_styles_default = ansiStyles;
 
-// ../../node_modules/.pnpm/chalk@5.0.1/node_modules/chalk/source/vendor/supports-color/index.js
+// ../../node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/vendor/supports-color/index.js
 init_esm_shims();
 import process2 from "node:process";
 import os from "node:os";
 import tty from "node:tty";
-function hasFlag(flag, argv = process2.argv) {
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : process2.argv) {
   const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
   const position = argv.indexOf(prefix + flag);
   const terminatorPosition = argv.indexOf("--");
@@ -912,6 +1293,9 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
       return 2;
     }
   }
+  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
+    return 1;
+  }
   if (haveStream && !streamIsTTY && forceColor === void 0) {
     return 0;
   }
@@ -927,7 +1311,10 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
     return 1;
   }
   if ("CI" in env) {
-    if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "GITHUB_ACTIONS", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
+    if ("GITHUB_ACTIONS" in env) {
+      return 3;
+    }
+    if (["TRAVIS", "CIRCLECI", "APPVEYOR", "GITLAB_CI", "BUILDKITE", "DRONE"].some((sign) => sign in env) || env.CI_NAME === "codeship") {
       return 1;
     }
     return min;
@@ -935,19 +1322,21 @@ function _supportsColor(haveStream, { streamIsTTY, sniffFlags = true } = {}) {
   if ("TEAMCITY_VERSION" in env) {
     return /^(9\.(0*[1-9]\d*)\.|\d{2,}\.)/.test(env.TEAMCITY_VERSION) ? 1 : 0;
   }
-  if ("TF_BUILD" in env && "AGENT_NAME" in env) {
-    return 1;
-  }
   if (env.COLORTERM === "truecolor") {
     return 3;
   }
+  if (env.TERM === "xterm-kitty") {
+    return 3;
+  }
   if ("TERM_PROGRAM" in env) {
     const version = Number.parseInt((env.TERM_PROGRAM_VERSION || "").split(".")[0], 10);
     switch (env.TERM_PROGRAM) {
-      case "iTerm.app":
+      case "iTerm.app": {
         return version >= 3 ? 3 : 2;
-      case "Apple_Terminal":
+      }
+      case "Apple_Terminal": {
         return 2;
+      }
     }
   }
   if (/-256(color)?$/i.test(env.TERM)) {
@@ -974,7 +1363,7 @@ var supportsColor = {
 };
 var supports_color_default = supportsColor;
 
-// ../../node_modules/.pnpm/chalk@5.0.1/node_modules/chalk/source/utilities.js
+// ../../node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/utilities.js
 init_esm_shims();
 function stringReplaceAll(string, substring, replacer) {
   let index = string.indexOf(substring);
@@ -985,7 +1374,7 @@ function stringReplaceAll(string, substring, replacer) {
   let endIndex = 0;
   let returnValue = "";
   do {
-    returnValue += string.substr(endIndex, index - endIndex) + substring + replacer;
+    returnValue += string.slice(endIndex, index) + substring + replacer;
     endIndex = index + substringLength;
     index = string.indexOf(substring, endIndex);
   } while (index !== -1);
@@ -997,7 +1386,7 @@ function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
   let returnValue = "";
   do {
     const gotCR = string[index - 1] === "\r";
-    returnValue += string.substr(endIndex, (gotCR ? index - 1 : index) - endIndex) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
+    returnValue += string.slice(endIndex, gotCR ? index - 1 : index) + prefix + (gotCR ? "\r\n" : "\n") + postfix;
     endIndex = index + 1;
     index = string.indexOf("\n", endIndex);
   } while (index !== -1);
@@ -1005,7 +1394,7 @@ function stringEncaseCRLFWithFirstIndex(string, prefix, postfix, index) {
   return returnValue;
 }
 
-// ../../node_modules/.pnpm/chalk@5.0.1/node_modules/chalk/source/index.js
+// ../../node_modules/.pnpm/chalk@5.2.0/node_modules/chalk/source/index.js
 var { stdout: stdoutColor, stderr: stderrColor } = supports_color_default;
 var GENERATOR = Symbol("GENERATOR");
 var STYLER = Symbol("STYLER");
@@ -1016,7 +1405,7 @@ var levelMapping = [
   "ansi256",
   "ansi16m"
 ];
-var styles = /* @__PURE__ */ Object.create(null);
+var styles2 = /* @__PURE__ */ Object.create(null);
 var applyOptions = (object, options = {}) => {
   if (options.level && !(Number.isInteger(options.level) && options.level >= 0 && options.level <= 3)) {
     throw new Error("The `level` option should be an integer from 0 to 3");
@@ -1035,7 +1424,7 @@ function createChalk(options) {
 }
 Object.setPrototypeOf(createChalk.prototype, Function.prototype);
 for (const [styleName, style] of Object.entries(ansi_styles_default)) {
-  styles[styleName] = {
+  styles2[styleName] = {
     get() {
       const builder = createBuilder(this, createStyler(style.open, style.close, this[STYLER]), this[IS_EMPTY]);
       Object.defineProperty(this, styleName, { value: builder });
@@ -1043,7 +1432,7 @@ for (const [styleName, style] of Object.entries(ansi_styles_default)) {
     }
   };
 }
-styles.visible = {
+styles2.visible = {
   get() {
     const builder = createBuilder(this, this[STYLER], true);
     Object.defineProperty(this, "visible", { value: builder });
@@ -1067,7 +1456,7 @@ var getModelAnsi = (model, level, type, ...arguments_) => {
 };
 var usedModels = ["rgb", "hex", "ansi256"];
 for (const model of usedModels) {
-  styles[model] = {
+  styles2[model] = {
     get() {
       const { level } = this;
       return function(...arguments_) {
@@ -1077,7 +1466,7 @@ for (const model of usedModels) {
     }
   };
   const bgModel = "bg" + model[0].toUpperCase() + model.slice(1);
-  styles[bgModel] = {
+  styles2[bgModel] = {
     get() {
       const { level } = this;
       return function(...arguments_) {
@@ -1089,7 +1478,7 @@ for (const model of usedModels) {
 }
 var proto = Object.defineProperties(() => {
 }, {
-  ...styles,
+  ...styles2,
   level: {
     enumerable: true,
     get() {
@@ -1147,7 +1536,7 @@ var applyStyle = (self, string) => {
   }
   return openAll + string + closeAll;
 };
-Object.defineProperties(createChalk.prototype, styles);
+Object.defineProperties(createChalk.prototype, styles2);
 var chalk = createChalk();
 var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
@@ -1162,7 +1551,7 @@ function widestLine(string) {
   return lineWidth;
 }
 
-// ../../node_modules/.pnpm/boxen@7.0.1/node_modules/boxen/index.js
+// ../../node_modules/.pnpm/boxen@7.0.2/node_modules/boxen/index.js
 var import_cli_boxes = __toESM(require_cli_boxes(), 1);
 
 // ../../node_modules/.pnpm/camelcase@7.0.0/node_modules/camelcase/index.js
@@ -1246,7 +1635,7 @@ function camelCase(input, options) {
   return postProcess(input, toUpperCase);
 }
 
-// ../../node_modules/.pnpm/boxen@7.0.1/node_modules/boxen/index.js
+// ../../node_modules/.pnpm/boxen@7.0.2/node_modules/boxen/index.js
 var import_ansi_align = __toESM(require_ansi_align(), 1);
 
 // ../../node_modules/.pnpm/wrap-ansi@8.0.1/node_modules/wrap-ansi/index.js
@@ -1260,7 +1649,7 @@ var wrapAnsi2562 = (offset = 0) => (code) => `\x1B[${38 + offset};5;${code}m`;
 var wrapAnsi16m2 = (offset = 0) => (red, green, blue) => `\x1B[${38 + offset};2;${red};${green};${blue}m`;
 function assembleStyles2() {
   const codes = /* @__PURE__ */ new Map();
-  const styles2 = {
+  const styles3 = {
     modifier: {
       reset: [0, 0],
       // 21 isn't widely supported and 22 does the same thing
@@ -1312,37 +1701,37 @@ function assembleStyles2() {
       bgWhiteBright: [107, 49]
     }
   };
-  styles2.color.gray = styles2.color.blackBright;
-  styles2.bgColor.bgGray = styles2.bgColor.bgBlackBright;
-  styles2.color.grey = styles2.color.blackBright;
-  styles2.bgColor.bgGrey = styles2.bgColor.bgBlackBright;
-  for (const [groupName, group] of Object.entries(styles2)) {
+  styles3.color.gray = styles3.color.blackBright;
+  styles3.bgColor.bgGray = styles3.bgColor.bgBlackBright;
+  styles3.color.grey = styles3.color.blackBright;
+  styles3.bgColor.bgGrey = styles3.bgColor.bgBlackBright;
+  for (const [groupName, group] of Object.entries(styles3)) {
     for (const [styleName, style] of Object.entries(group)) {
-      styles2[styleName] = {
+      styles3[styleName] = {
         open: `\x1B[${style[0]}m`,
         close: `\x1B[${style[1]}m`
       };
-      group[styleName] = styles2[styleName];
+      group[styleName] = styles3[styleName];
       codes.set(style[0], style[1]);
     }
-    Object.defineProperty(styles2, groupName, {
+    Object.defineProperty(styles3, groupName, {
       value: group,
       enumerable: false
     });
   }
-  Object.defineProperty(styles2, "codes", {
+  Object.defineProperty(styles3, "codes", {
     value: codes,
     enumerable: false
   });
-  styles2.color.close = "\x1B[39m";
-  styles2.bgColor.close = "\x1B[49m";
-  styles2.color.ansi = wrapAnsi162();
-  styles2.color.ansi256 = wrapAnsi2562();
-  styles2.color.ansi16m = wrapAnsi16m2();
-  styles2.bgColor.ansi = wrapAnsi162(ANSI_BACKGROUND_OFFSET2);
-  styles2.bgColor.ansi256 = wrapAnsi2562(ANSI_BACKGROUND_OFFSET2);
-  styles2.bgColor.ansi16m = wrapAnsi16m2(ANSI_BACKGROUND_OFFSET2);
-  Object.defineProperties(styles2, {
+  styles3.color.close = "\x1B[39m";
+  styles3.bgColor.close = "\x1B[49m";
+  styles3.color.ansi = wrapAnsi162();
+  styles3.color.ansi256 = wrapAnsi2562();
+  styles3.color.ansi16m = wrapAnsi16m2();
+  styles3.bgColor.ansi = wrapAnsi162(ANSI_BACKGROUND_OFFSET2);
+  styles3.bgColor.ansi256 = wrapAnsi2562(ANSI_BACKGROUND_OFFSET2);
+  styles3.bgColor.ansi16m = wrapAnsi16m2(ANSI_BACKGROUND_OFFSET2);
+  Object.defineProperties(styles3, {
     rgbToAnsi256: {
       value: (red, green, blue) => {
         if (red === green && green === blue) {
@@ -1380,7 +1769,7 @@ function assembleStyles2() {
       enumerable: false
     },
     hexToAnsi256: {
-      value: (hex) => styles2.rgbToAnsi256(...styles2.hexToRgb(hex)),
+      value: (hex) => styles3.rgbToAnsi256(...styles3.hexToRgb(hex)),
       enumerable: false
     },
     ansi256ToAnsi: {
@@ -1418,15 +1807,15 @@ function assembleStyles2() {
       enumerable: false
     },
     rgbToAnsi: {
-      value: (red, green, blue) => styles2.ansi256ToAnsi(styles2.rgbToAnsi256(red, green, blue)),
+      value: (red, green, blue) => styles3.ansi256ToAnsi(styles3.rgbToAnsi256(red, green, blue)),
       enumerable: false
     },
     hexToAnsi: {
-      value: (hex) => styles2.ansi256ToAnsi(styles2.hexToAnsi256(hex)),
+      value: (hex) => styles3.ansi256ToAnsi(styles3.hexToAnsi256(hex)),
       enumerable: false
     }
   });
-  return styles2;
+  return styles3;
 }
 var ansiStyles2 = assembleStyles2();
 var ansi_styles_default2 = ansiStyles2;
@@ -1582,7 +1971,7 @@ function wrapAnsi(string, columns, options) {
   return String(string).normalize().replace(/\r\n/g, "\n").split("\n").map((line) => exec(line, columns, options)).join("\n");
 }
 
-// ../../node_modules/.pnpm/boxen@7.0.1/node_modules/boxen/index.js
+// ../../node_modules/.pnpm/boxen@7.0.2/node_modules/boxen/index.js
 var import_cli_boxes2 = __toESM(require_cli_boxes(), 1);
 var NEWLINE = "\n";
 var PAD = " ";
@@ -1866,7 +2255,7 @@ async function bundleChunks(ctx) {
 }
 async function writeFileChunk(ctx, file) {
   const { path } = ctx.runtime;
-  logger2.debug("chunk:write", `File: ${path.relative(ctx.config.cwd, file)}`);
+  logger3.debug("chunk:write", `File: ${path.relative(ctx.config.cwd, file)}`);
   const css = extractFile(ctx, file);
   if (!css)
     return;
@@ -1880,17 +2269,18 @@ function extractFile(ctx, file) {
   } = ctx;
   return pipe2(
     { file: path.abs(cwd, file) },
-    tap2(() => logger2.debug("file:extract", file)),
-    Obj2.bind("measure", () => logger2.time.debug(`Extracted ${file}`)),
+    tap2(() => logger3.debug("file:extract", file)),
+    Obj2.bind("measure", () => logger3.time.debug(`Extracted ${file}`)),
     Obj2.bind(
       "result",
       tryCatch(
-        ({ file: file2 }) => ctx.project.parseSourceFile(file2),
-        (error) => logger2.error("file:parse", error)
+        ({ file: file2 }) => ctx.project.parseSourceFile(file2, ctx.properties),
+        (error) => logger3.error("file:parse", error)
       )
     ),
+    Obj2.bind("measureCss", () => logger3.time.debug(`Parsed ${file}`)),
     Obj2.bind("css", ({ result }) => result ? ctx.getParserCss(result) : void 0),
-    tap2(({ measure }) => measure()),
+    tap2(({ measure, measureCss }) => [measureCss(), measure()]),
     Obj2.get("css")
   );
 }
@@ -2016,7 +2406,7 @@ var Builder = class {
   }
   async extract() {
     const ctx = this.ensure();
-    const done = logger3.time.info("Extracted in");
+    const done = logger4.time.info("Extracted in");
     await Promise.all(
       ctx.getFiles().map(async (file) => {
         const mtime = existsSync2(file) ? statSync(file).mtimeMs : -Infinity;
@@ -2077,7 +2467,7 @@ var Builder = class {
 
 // src/exec-command.ts
 init_esm_shims();
-import { logger as logger4 } from "@pandacss/logger";
+import { logger as logger5 } from "@pandacss/logger";
 import { spawnSync } from "child_process";
 import getPackageManager from "preferred-pm";
 async function execCommand(cmd, cwd) {
@@ -2089,13 +2479,13 @@ async function execCommand(cmd, cwd) {
   }
   const check = spawnSync(pm, args, { cwd, stdio: "pipe" });
   if (check.status !== 0) {
-    logger4.error("exec", check.stderr.toString());
+    logger5.error("exec", check.stderr.toString());
   }
 }
 
 // src/generate.ts
 init_esm_shims();
-import { logger as logger5 } from "@pandacss/logger";
+import { logger as logger6 } from "@pandacss/logger";
 import { match } from "ts-pattern";
 
 // src/load-context.ts
@@ -2113,7 +2503,7 @@ var loadContext = async (config, configPath) => {
 // src/generate.ts
 async function build(ctx) {
   const msg = await emitAndExtract(ctx);
-  logger5.info("css:emit", msg);
+  logger6.info("css:emit", msg);
 }
 async function generate(config, configPath) {
   const [ctxRef, loadCtx] = await loadContext(config, configPath);
@@ -2127,13 +2517,13 @@ async function generate(config, configPath) {
   if (ctx.config.watch) {
     const configWatcher = fs.watch({ include: dependencies });
     configWatcher.on("change", async () => {
-      logger5.info("config:change", "Config changed, restarting...");
+      logger6.info("config:change", "Config changed, restarting...");
       await loadCtx();
       return build(ctxRef.current);
     });
     const contentWatcher = fs.watch(ctx.config);
     contentWatcher.on("all", async (event, file) => {
-      logger5.info(`file:${event}`, file);
+      logger6.info(`file:${event}`, file);
       match(event).with("unlink", () => {
         ctx.project.removeSourceFile(path.abs(cwd, file));
         ctx.chunks.rm(file);
@@ -2147,7 +2537,7 @@ async function generate(config, configPath) {
       }).otherwise(() => {
       });
     });
-    logger5.info("ctx:watch", ctx.messages.watch());
+    logger6.info("ctx:watch", ctx.messages.watch());
   }
 }
 
@@ -2173,9 +2563,9 @@ function setupGitIgnore({ config: { outdir } }) {
 
 // src/setup-config.ts
 init_esm_shims();
-import { logger as logger6, quote } from "@pandacss/logger";
+import { logger as logger7, quote } from "@pandacss/logger";
 import { messages } from "@pandacss/generator";
-import { writeFile as writeFile2 } from "fs-extra";
+import { writeFile as writeFile3 } from "fs-extra";
 import { lookItUpSync as lookItUpSync3 } from "look-it-up";
 import { outdent as outdent2 } from "outdent";
 import { join as join2 } from "path";
@@ -2187,9 +2577,9 @@ async function setupConfig(cwd, { force }) {
   const cmd = pm === "npm" ? "npm run" : pm;
   const isTs = lookItUpSync3("tsconfig.json", cwd);
   const file = isTs ? "panda.config.ts" : "panda.config.mjs";
-  logger6.info("init:config", `creating panda config file: ${quote(file)}`);
+  logger7.info("init:config", `creating panda config file: ${quote(file)}`);
   if (!force && configFile) {
-    logger6.warn("init:config", messages.configExists(cmd));
+    logger7.warn("init:config", messages.configExists(cmd));
   } else {
     const content = outdent2`
        import { defineConfig } from "@pandacss/dev"
@@ -2208,12 +2598,12 @@ async function setupConfig(cwd, { force }) {
         outdir: "styled-system",
        })
     `;
-    await writeFile2(join2(cwd, file), content);
-    logger6.log(messages.thankYou());
+    await writeFile3(join2(cwd, file), content);
+    logger7.log(messages.thankYou());
   }
 }
 async function setupPostcss(cwd) {
-  logger6.info("init:postcss", `creating postcss config file: ${quote("postcss.config.cjs")}`);
+  logger7.info("init:postcss", `creating postcss config file: ${quote("postcss.config.cjs")}`);
   const content = outdent2`
   module.exports = {
     plugins: {
@@ -2221,10 +2611,11 @@ async function setupPostcss(cwd) {
     },
   }
   `;
-  await writeFile2(join2(cwd, "postcss.config.cjs"), content);
+  await writeFile3(join2(cwd, "postcss.config.cjs"), content);
 }
 export {
   Builder,
+  analyzeTokens,
   createContext,
   discardDuplicate2 as discardDuplicate,
   emitAndExtract,
@@ -2235,5 +2626,6 @@ export {
   loadConfigAndCreateContext,
   setupConfig,
   setupGitIgnore,
-  setupPostcss
+  setupPostcss,
+  writeAnalyzeJSON
 };