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

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@6.7.0_typescript@4.9.5/node_modules/tsup/assets/cjs_shims.js
+// ../../node_modules/.pnpm/tsup@6.7.0_typescript@5.0.2/node_modules/tsup/assets/cjs_shims.js
 var init_cjs_shims = __esm({
-  "../../node_modules/.pnpm/tsup@6.7.0_typescript@4.9.5/node_modules/tsup/assets/cjs_shims.js"() {
+  "../../node_modules/.pnpm/tsup@6.7.0_typescript@5.0.2/node_modules/tsup/assets/cjs_shims.js"() {
   }
 });
 
@@ -402,6 +402,7 @@ var require_ansi_align = __commonJS({
 var src_exports = {};
 __export(src_exports, {
   Builder: () => Builder,
+  analyzeTokens: () => analyzeTokens,
   createContext: () => createContext,
   discardDuplicate: () => import_core3.discardDuplicate,
   emitAndExtract: () => emitAndExtract,
@@ -412,17 +413,388 @@ __export(src_exports, {
   loadConfigAndCreateContext: () => loadConfigAndCreateContext,
   setupConfig: () => setupConfig,
   setupGitIgnore: () => setupGitIgnore,
-  setupPostcss: () => setupPostcss
+  setupPostcss: () => setupPostcss,
+  writeAnalyzeJSON: () => writeAnalyzeJSON
 });
 module.exports = __toCommonJS(src_exports);
 init_cjs_shims();
 var import_core3 = require("@pandacss/core");
 
+// src/analyze-tokens.ts
+init_cjs_shims();
+var import_logger = require("@pandacss/logger");
+var import_promises = require("fs/promises");
+var import_ts_morph = require("ts-morph");
+
+// src/classify.ts
+init_cjs_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_cjs_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
+var import_gzip_size = __toESM(require("gzip-size"));
+var import_filesize = require("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);
+    import_logger.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);
+  import_logger.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: (0, import_filesize.filesize)(Buffer.byteLength(css, "utf-8")),
+        minified: (0, import_filesize.filesize)(Buffer.byteLength(minifiedCss, "utf-8")),
+        gzip: {
+          normal: (0, import_filesize.filesize)(import_gzip_size.default.sync(css)),
+          minified: (0, import_filesize.filesize)(import_gzip_size.default.sync(minifiedCss))
+        }
+      }
+    },
+    analysis
+  );
+}
+var analyzeResultSerializer = (_key, value) => {
+  if (value instanceof Set) {
+    return Array.from(value);
+  }
+  if (value instanceof Map) {
+    return Object.fromEntries(value);
+  }
+  if (import_ts_morph.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 (0, import_promises.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_cjs_shims();
 var import_core2 = require("@pandacss/core");
 var import_error = require("@pandacss/error");
-var import_logger3 = require("@pandacss/logger");
+var import_logger4 = require("@pandacss/logger");
 var import_shared = require("@pandacss/shared");
 var import_fs = require("fs");
 var import_fs_extra2 = require("fs-extra");
@@ -476,7 +848,7 @@ var getChunkEngine = ({ paths, config, runtime: { path, fs } }) => ({
 
 // src/node-runtime.ts
 init_cjs_shims();
-var import_logger = require("@pandacss/logger");
+var import_logger2 = require("@pandacss/logger");
 var import_chokidar = __toESM(require("chokidar"));
 var import_fast_glob = __toESM(require("fast-glob"));
 var import_fs_extra = require("fs-extra");
@@ -528,7 +900,7 @@ var nodeRuntime = {
         ignored: exclude,
         awaitWriteFinish: coalesce ? { stabilityThreshold: 50, pollInterval: 10 } : false
       });
-      import_logger.logger.debug("watch:file", `watching [${include}]`);
+      import_logger2.logger.debug("watch:file", `watching [${include}]`);
       process.once("SIGINT", async () => {
         await watcher.close();
       });
@@ -538,10 +910,10 @@ var nodeRuntime = {
 };
 process.setMaxListeners(Infinity);
 process.on("unhandledRejection", (reason) => {
-  import_logger.logger.error("unhandled-rejection", reason);
+  import_logger2.logger.error("unhandled-rejection", reason);
 });
 process.on("uncaughtException", (reason) => {
-  import_logger.logger.error("uncaught-exception", reason);
+  import_logger2.logger.error("uncaught-exception", reason);
 });
 
 // src/output-engine.ts
@@ -605,18 +977,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_cjs_shims();
-var import_logger2 = require("@pandacss/logger");
+var import_logger3 = require("@pandacss/logger");
 var import_lil_fp2 = require("lil-fp");
 
 // src/cli-box.ts
 init_cjs_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_cjs_shims();
 var import_node_process2 = __toESM(require("process"), 1);
 
@@ -686,102 +1061,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_cjs_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_cjs_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;
@@ -796,12 +1179,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("");
         }
@@ -817,11 +1200,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;
         }
@@ -855,25 +1238,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_cjs_shims();
 var import_node_process = __toESM(require("process"), 1);
 var import_node_os = __toESM(require("os"), 1);
 var import_node_tty = __toESM(require("tty"), 1);
-function hasFlag(flag, argv = import_node_process.default.argv) {
+function hasFlag(flag, argv = globalThis.Deno ? globalThis.Deno.args : import_node_process.default.argv) {
   const prefix = flag.startsWith("-") ? "" : flag.length === 1 ? "-" : "--";
   const position = argv.indexOf(prefix + flag);
   const terminatorPosition = argv.indexOf("--");
@@ -925,6 +1308,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;
   }
@@ -940,7 +1326,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;
@@ -948,19 +1337,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)) {
@@ -987,7 +1378,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_cjs_shims();
 function stringReplaceAll(string, substring, replacer) {
   let index = string.indexOf(substring);
@@ -998,7 +1389,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);
@@ -1010,7 +1401,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);
@@ -1018,7 +1409,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");
@@ -1029,7 +1420,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");
@@ -1048,7 +1439,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 });
@@ -1056,7 +1447,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 });
@@ -1080,7 +1471,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_) {
@@ -1090,7 +1481,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_) {
@@ -1102,7 +1493,7 @@ for (const model of usedModels) {
 }
 var proto = Object.defineProperties(() => {
 }, {
-  ...styles,
+  ...styles2,
   level: {
     enumerable: true,
     get() {
@@ -1160,7 +1551,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;
@@ -1175,7 +1566,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
@@ -1259,7 +1650,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
@@ -1273,7 +1664,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
@@ -1325,37 +1716,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) {
@@ -1393,7 +1784,7 @@ function assembleStyles2() {
       enumerable: false
     },
     hexToAnsi256: {
-      value: (hex) => styles2.rgbToAnsi256(...styles2.hexToRgb(hex)),
+      value: (hex) => styles3.rgbToAnsi256(...styles3.hexToRgb(hex)),
       enumerable: false
     },
     ansi256ToAnsi: {
@@ -1431,15 +1822,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;
@@ -1595,7 +1986,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 = " ";
@@ -1879,7 +2270,7 @@ async function bundleChunks(ctx) {
 }
 async function writeFileChunk(ctx, file) {
   const { path } = ctx.runtime;
-  import_logger2.logger.debug("chunk:write", `File: ${path.relative(ctx.config.cwd, file)}`);
+  import_logger3.logger.debug("chunk:write", `File: ${path.relative(ctx.config.cwd, file)}`);
   const css = extractFile(ctx, file);
   if (!css)
     return;
@@ -1893,17 +2284,18 @@ function extractFile(ctx, file) {
   } = ctx;
   return (0, import_lil_fp2.pipe)(
     { file: path.abs(cwd, file) },
-    (0, import_lil_fp2.tap)(() => import_logger2.logger.debug("file:extract", file)),
-    import_lil_fp2.Obj.bind("measure", () => import_logger2.logger.time.debug(`Extracted ${file}`)),
+    (0, import_lil_fp2.tap)(() => import_logger3.logger.debug("file:extract", file)),
+    import_lil_fp2.Obj.bind("measure", () => import_logger3.logger.time.debug(`Extracted ${file}`)),
     import_lil_fp2.Obj.bind(
       "result",
       (0, import_lil_fp2.tryCatch)(
-        ({ file: file2 }) => ctx.project.parseSourceFile(file2),
-        (error) => import_logger2.logger.error("file:parse", error)
+        ({ file: file2 }) => ctx.project.parseSourceFile(file2, ctx.properties),
+        (error) => import_logger3.logger.error("file:parse", error)
       )
     ),
+    import_lil_fp2.Obj.bind("measureCss", () => import_logger3.logger.time.debug(`Parsed ${file}`)),
     import_lil_fp2.Obj.bind("css", ({ result }) => result ? ctx.getParserCss(result) : void 0),
-    (0, import_lil_fp2.tap)(({ measure }) => measure()),
+    (0, import_lil_fp2.tap)(({ measure, measureCss }) => [measureCss(), measure()]),
     import_lil_fp2.Obj.get("css")
   );
 }
@@ -2029,7 +2421,7 @@ var Builder = class {
   }
   async extract() {
     const ctx = this.ensure();
-    const done = import_logger3.logger.time.info("Extracted in");
+    const done = import_logger4.logger.time.info("Extracted in");
     await Promise.all(
       ctx.getFiles().map(async (file) => {
         const mtime = (0, import_fs.existsSync)(file) ? (0, import_fs_extra2.statSync)(file).mtimeMs : -Infinity;
@@ -2090,7 +2482,7 @@ var Builder = class {
 
 // src/exec-command.ts
 init_cjs_shims();
-var import_logger4 = require("@pandacss/logger");
+var import_logger5 = require("@pandacss/logger");
 var import_child_process = require("child_process");
 var import_preferred_pm = __toESM(require("preferred-pm"));
 async function execCommand(cmd, cwd) {
@@ -2102,13 +2494,13 @@ async function execCommand(cmd, cwd) {
   }
   const check = (0, import_child_process.spawnSync)(pm, args, { cwd, stdio: "pipe" });
   if (check.status !== 0) {
-    import_logger4.logger.error("exec", check.stderr.toString());
+    import_logger5.logger.error("exec", check.stderr.toString());
   }
 }
 
 // src/generate.ts
 init_cjs_shims();
-var import_logger5 = require("@pandacss/logger");
+var import_logger6 = require("@pandacss/logger");
 var import_ts_pattern = require("ts-pattern");
 
 // src/load-context.ts
@@ -2126,7 +2518,7 @@ var loadContext = async (config, configPath) => {
 // src/generate.ts
 async function build(ctx) {
   const msg = await emitAndExtract(ctx);
-  import_logger5.logger.info("css:emit", msg);
+  import_logger6.logger.info("css:emit", msg);
 }
 async function generate(config, configPath) {
   const [ctxRef, loadCtx] = await loadContext(config, configPath);
@@ -2140,13 +2532,13 @@ async function generate(config, configPath) {
   if (ctx.config.watch) {
     const configWatcher = fs.watch({ include: dependencies });
     configWatcher.on("change", async () => {
-      import_logger5.logger.info("config:change", "Config changed, restarting...");
+      import_logger6.logger.info("config:change", "Config changed, restarting...");
       await loadCtx();
       return build(ctxRef.current);
     });
     const contentWatcher = fs.watch(ctx.config);
     contentWatcher.on("all", async (event, file) => {
-      import_logger5.logger.info(`file:${event}`, file);
+      import_logger6.logger.info(`file:${event}`, file);
       (0, import_ts_pattern.match)(event).with("unlink", () => {
         ctx.project.removeSourceFile(path.abs(cwd, file));
         ctx.chunks.rm(file);
@@ -2160,7 +2552,7 @@ async function generate(config, configPath) {
       }).otherwise(() => {
       });
     });
-    import_logger5.logger.info("ctx:watch", ctx.messages.watch());
+    import_logger6.logger.info("ctx:watch", ctx.messages.watch());
   }
 }
 
@@ -2186,7 +2578,7 @@ function setupGitIgnore({ config: { outdir } }) {
 
 // src/setup-config.ts
 init_cjs_shims();
-var import_logger6 = require("@pandacss/logger");
+var import_logger7 = require("@pandacss/logger");
 var import_generator2 = require("@pandacss/generator");
 var import_fs_extra3 = require("fs-extra");
 var import_look_it_up3 = require("look-it-up");
@@ -2200,9 +2592,9 @@ async function setupConfig(cwd, { force }) {
   const cmd = pm === "npm" ? "npm run" : pm;
   const isTs = (0, import_look_it_up3.lookItUpSync)("tsconfig.json", cwd);
   const file = isTs ? "panda.config.ts" : "panda.config.mjs";
-  import_logger6.logger.info("init:config", `creating panda config file: ${(0, import_logger6.quote)(file)}`);
+  import_logger7.logger.info("init:config", `creating panda config file: ${(0, import_logger7.quote)(file)}`);
   if (!force && configFile) {
-    import_logger6.logger.warn("init:config", import_generator2.messages.configExists(cmd));
+    import_logger7.logger.warn("init:config", import_generator2.messages.configExists(cmd));
   } else {
     const content = import_outdent2.outdent`
        import { defineConfig } from "@pandacss/dev"
@@ -2222,11 +2614,11 @@ async function setupConfig(cwd, { force }) {
        })
     `;
     await (0, import_fs_extra3.writeFile)((0, import_path4.join)(cwd, file), content);
-    import_logger6.logger.log(import_generator2.messages.thankYou());
+    import_logger7.logger.log(import_generator2.messages.thankYou());
   }
 }
 async function setupPostcss(cwd) {
-  import_logger6.logger.info("init:postcss", `creating postcss config file: ${(0, import_logger6.quote)("postcss.config.cjs")}`);
+  import_logger7.logger.info("init:postcss", `creating postcss config file: ${(0, import_logger7.quote)("postcss.config.cjs")}`);
   const content = import_outdent2.outdent`
   module.exports = {
     plugins: {
@@ -2239,6 +2631,7 @@ async function setupPostcss(cwd) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Builder,
+  analyzeTokens,
   createContext,
   discardDuplicate,
   emitAndExtract,
@@ -2249,5 +2642,6 @@ async function setupPostcss(cwd) {
   loadConfigAndCreateContext,
   setupConfig,
   setupGitIgnore,
-  setupPostcss
+  setupPostcss,
+  writeAnalyzeJSON
 });