@fragments-sdk/cli 0.15.10 → 0.17.0

package/dist/{chunk-6SQPP47U.js → chunk-ANTWP3UG.js}

@@ -2,12 +2,7 @@ import { createRequire as __banner_createRequire } from 'module'; const require
 import {
   BRAND,
   DEFAULTS
-} from "./chunk-32LIWN2P.js";
-import {
-  hexToRgb,
-  parseRgb,
-  parseTokenFiles
-} from "./chunk-MHIBEEW4.js";
+} from "./chunk-FFCI6OVZ.js";
 import {
   BABEL_PARSER_OPTIONS
 } from "./chunk-7DZC4YEV.js";
@@ -80,8 +75,8 @@ var BrowserPool = class {
     }
     await this.clearContext(context);
     if (this.waitingQueue.length > 0) {
-      const resolve3 = this.waitingQueue.shift();
-      resolve3(context);
+      const resolve4 = this.waitingQueue.shift();
+      resolve4(context);
       return;
     }
     this.available.push(context);
@@ -108,7 +103,7 @@ var BrowserPool = class {
       clearTimeout(this.idleTimeout);
       this.idleTimeout = null;
     }
-    for (const resolve3 of this.waitingQueue) {
+    for (const resolve4 of this.waitingQueue) {
     }
     this.waitingQueue = [];
     for (const context of this.contexts) {
@@ -195,9 +190,9 @@ var BrowserPool = class {
    * Wait for an available context.
    */
   waitForAvailable() {
-    return new Promise((resolve3, reject) => {
+    return new Promise((resolve4, reject) => {
       const timeout = setTimeout(() => {
-        const index = this.waitingQueue.indexOf(resolve3);
+        const index = this.waitingQueue.indexOf(resolve4);
         if (index > -1) {
           this.waitingQueue.splice(index, 1);
         }
@@ -210,7 +205,7 @@ var BrowserPool = class {
       }, 3e4);
       const wrappedResolve = (ctx) => {
         clearTimeout(timeout);
-        resolve3(ctx);
+        resolve4(ctx);
       };
       this.waitingQueue.push(wrappedResolve);
     });
@@ -293,16 +288,16 @@ var Timer = class {
   }
 };
 function createDeferred() {
-  let resolve3;
+  let resolve4;
   let reject;
   const promise = new Promise((res, rej) => {
-    resolve3 = res;
+    resolve4 = res;
     reject = rej;
   });
-  return { promise, resolve: resolve3, reject };
+  return { promise, resolve: resolve4, reject };
 }
 function sleep(ms) {
-  return new Promise((resolve3) => setTimeout(resolve3, ms));
+  return new Promise((resolve4) => setTimeout(resolve4, ms));
 }
 function bufferToBase64Url(buffer, mimeType = "image/png") {
   return `data:${mimeType};base64,${buffer.toString("base64")}`;
@@ -458,7 +453,7 @@ var CaptureEngine = class {
       await page.evaluate(async (timeoutMs) => {
         await Promise.race([
           document.fonts.ready,
-          new Promise((resolve3) => setTimeout(resolve3, timeoutMs))
+          new Promise((resolve4) => setTimeout(resolve4, timeoutMs))
         ]);
       }, timeout);
     } catch {
@@ -2556,6 +2551,503 @@ function getScripts() {
   `;
 }
 
+// src/service/token-parser.ts
+import { readFile as readFile2 } from "fs/promises";
+import { readFileSync } from "fs";
+import { relative } from "path";
+import fastGlob from "fast-glob";
+
+// src/service/tailwind-v4-parser.ts
+var CATEGORY_PATTERNS = [
+  { pattern: /color|bg|background|border-color|fill|stroke/i, category: "color" },
+  { pattern: /spacing|margin|padding|gap|space|inset/i, category: "spacing" },
+  { pattern: /font|text|line-height|letter-spacing|typography/i, category: "typography" },
+  { pattern: /radius|rounded|corner/i, category: "radius" },
+  { pattern: /shadow|elevation/i, category: "shadow" },
+  { pattern: /size|width|height|min|max/i, category: "sizing" },
+  { pattern: /border(?!-color)|stroke-width|outline/i, category: "border" },
+  { pattern: /animation|transition|duration|timing|delay/i, category: "animation" },
+  { pattern: /z-index|layer|stack/i, category: "z-index" }
+];
+function inferCategory(name) {
+  const lowerName = name.toLowerCase();
+  for (const { pattern, category } of CATEGORY_PATTERNS) {
+    if (pattern.test(lowerName)) {
+      return category;
+    }
+  }
+  return "other";
+}
+function inferLevel(rawValue) {
+  if (/var\(/.test(rawValue)) {
+    return 2;
+  }
+  return 1;
+}
+function stripBlockComments(css) {
+  return css.replace(/\/\*[\s\S]*?\*\//g, "");
+}
+var CUSTOM_PROPERTY_PATTERN = /^\s*(--[\w-]+)\s*:\s*(.+?)\s*;?\s*$/;
+function parseTailwindV4Theme(cssContent, filePath) {
+  const startTime = performance.now();
+  const tokens = [];
+  const errors = [];
+  const warnings = [];
+  const source = filePath ?? "unknown";
+  const cleaned = stripBlockComments(cssContent);
+  const lines = cleaned.split("\n");
+  let insideTheme = false;
+  let themeDepth = 0;
+  let pendingTheme = false;
+  for (let i = 0; i < lines.length; i++) {
+    let line = lines[i];
+    const lineNumber = i + 1;
+    const singleCommentIdx = line.indexOf("//");
+    if (singleCommentIdx !== -1) {
+      const beforeComment = line.slice(0, singleCommentIdx);
+      const singleQuotes = (beforeComment.match(/'/g) || []).length;
+      const doubleQuotes = (beforeComment.match(/"/g) || []).length;
+      if (singleQuotes % 2 === 0 && doubleQuotes % 2 === 0) {
+        line = beforeComment;
+      }
+    }
+    const trimmed = line.trim();
+    if (trimmed === "") {
+      continue;
+    }
+    if (!insideTheme && !pendingTheme) {
+      if (/^@theme\b/.test(trimmed)) {
+        pendingTheme = true;
+        const braceIdx = trimmed.indexOf("{");
+        if (braceIdx !== -1) {
+          pendingTheme = false;
+          insideTheme = true;
+          themeDepth = 1;
+          const afterBrace = trimmed.slice(braceIdx + 1);
+          for (const ch of afterBrace) {
+            if (ch === "{") themeDepth++;
+            else if (ch === "}") themeDepth--;
+          }
+          const inlineContent = afterBrace.trim();
+          if (inlineContent && themeDepth > 0) {
+            processThemeLine(inlineContent, lineNumber, source, tokens, warnings);
+          }
+          if (themeDepth <= 0) {
+            insideTheme = false;
+          }
+        }
+        continue;
+      }
+    }
+    if (pendingTheme) {
+      const braceIdx = trimmed.indexOf("{");
+      if (braceIdx !== -1) {
+        pendingTheme = false;
+        insideTheme = true;
+        themeDepth = 1;
+        const afterBrace = trimmed.slice(braceIdx + 1);
+        for (const ch of afterBrace) {
+          if (ch === "{") themeDepth++;
+          else if (ch === "}") themeDepth--;
+        }
+        const inlineContent = afterBrace.trim();
+        if (inlineContent && themeDepth > 0) {
+          processThemeLine(inlineContent, lineNumber, source, tokens, warnings);
+        }
+        if (themeDepth <= 0) {
+          insideTheme = false;
+        }
+      }
+      continue;
+    }
+    if (insideTheme) {
+      for (const ch of trimmed) {
+        if (ch === "{") {
+          themeDepth++;
+        } else if (ch === "}") {
+          themeDepth--;
+          if (themeDepth <= 0) {
+            insideTheme = false;
+            break;
+          }
+        }
+      }
+      if (insideTheme || themeDepth > 0) {
+        const contentLine = trimmed.replace(/\}/g, "").trim();
+        if (contentLine) {
+          processThemeLine(contentLine, lineNumber, source, tokens, warnings);
+        }
+      }
+    }
+  }
+  if (pendingTheme) {
+    warnings.push(
+      `@theme keyword found but no opening brace \u2014 incomplete block in ${source}`
+    );
+  }
+  if (insideTheme) {
+    warnings.push(
+      `Unclosed @theme block \u2014 missing closing brace in ${source}`
+    );
+  }
+  return {
+    tokens,
+    errors,
+    warnings,
+    parseTimeMs: performance.now() - startTime
+  };
+}
+function processThemeLine(line, lineNumber, source, tokens, warnings) {
+  const match = line.match(CUSTOM_PROPERTY_PATTERN);
+  if (!match) {
+    const partialMatch = line.match(/^\s*(--[\w-]+)\s*:\s*(.+?)\s*$/);
+    if (partialMatch) {
+      const [, name2, rawValue2] = partialMatch;
+      tokens.push(buildToken(name2, rawValue2, lineNumber, source));
+      return;
+    }
+    if (/^\s*--/.test(line)) {
+      warnings.push(
+        `Line ${lineNumber}: Could not parse custom property declaration: ${line.trim()}`
+      );
+    }
+    return;
+  }
+  const [, name, rawValue] = match;
+  tokens.push(buildToken(name, rawValue, lineNumber, source));
+}
+function buildToken(name, rawValue, lineNumber, source) {
+  const value = rawValue.trim();
+  return {
+    name,
+    rawValue: value,
+    resolvedValue: value,
+    category: inferCategory(name),
+    level: inferLevel(value),
+    referenceChain: [],
+    sourceFile: source,
+    lineNumber,
+    theme: "default",
+    selector: "@theme"
+  };
+}
+
+// src/service/token-parser.ts
+var TOKEN_DECLARATION_PATTERN = /--([a-zA-Z0-9_-]+)\s*:\s*([^;]+);/g;
+var CATEGORY_PATTERNS2 = [
+  { pattern: /color|bg|background|border-color|fill|stroke/i, category: "color" },
+  { pattern: /spacing|margin|padding|gap|space|inset/i, category: "spacing" },
+  { pattern: /font|text|line-height|letter-spacing|typography/i, category: "typography" },
+  { pattern: /radius|rounded|corner/i, category: "radius" },
+  { pattern: /shadow|elevation/i, category: "shadow" },
+  { pattern: /size|width|height|min|max/i, category: "sizing" },
+  { pattern: /border(?!-color)|stroke-width|outline/i, category: "border" },
+  { pattern: /animation|transition|duration|timing|delay/i, category: "animation" },
+  { pattern: /z-index|layer|stack/i, category: "z-index" }
+];
+async function parseTokenFile(filePath, themeSelectors = { ":root": "default" }, projectRoot) {
+  const startTime = performance.now();
+  const tokens = [];
+  const errors = [];
+  const warnings = [];
+  try {
+    const content = await readFile2(filePath, "utf-8");
+    const relativePath = projectRoot ? relative(projectRoot, filePath) : filePath;
+    if (containsTailwindV4Theme(content)) {
+      const v4Result = parseTailwindV4Theme(content, relativePath);
+      tokens.push(...v4Result.tokens);
+      warnings.push(...v4Result.warnings);
+      for (const err of v4Result.errors) {
+        errors.push({ message: err, file: filePath });
+      }
+    }
+    const tokensByName = /* @__PURE__ */ new Map();
+    let lineNumber = 1;
+    const lines = content.split("\n");
+    let currentSelector = ":root";
+    let braceDepth = 0;
+    const selectorStack = [];
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      lineNumber = i + 1;
+      const openBraces = (line.match(/\{/g) || []).length;
+      const closeBraces = (line.match(/\}/g) || []).length;
+      if (openBraces > closeBraces) {
+        const selectorMatch = line.match(/^\s*([^{]+)\s*\{/);
+        if (selectorMatch) {
+          selectorStack.push(selectorMatch[1].trim());
+          currentSelector = selectorStack[selectorStack.length - 1];
+        }
+        braceDepth += openBraces - closeBraces;
+      } else if (closeBraces > openBraces) {
+        braceDepth -= closeBraces - openBraces;
+        if (braceDepth >= 0 && selectorStack.length > 0) {
+          selectorStack.pop();
+          currentSelector = selectorStack.length > 0 ? selectorStack[selectorStack.length - 1] : ":root";
+        }
+      }
+      const tokenMatches = [...line.matchAll(TOKEN_DECLARATION_PATTERN)];
+      for (const match of tokenMatches) {
+        const [, name, rawValue] = match;
+        const fullName = `--${name}`;
+        tokensByName.set(fullName, { rawValue: rawValue.trim(), line: lineNumber });
+      }
+    }
+    for (const [name, { rawValue, line }] of tokensByName) {
+      const selector = findSelectorForLine(content, line || 1);
+      const theme = themeSelectors[selector] || "default";
+      const { resolvedValue, chain, hasCircular, unresolvedRef } = resolveValue(
+        rawValue,
+        tokensByName
+      );
+      if (hasCircular) {
+        warnings.push(
+          `Circular reference detected for ${name} at line ${line}`
+        );
+      }
+      if (unresolvedRef) {
+        warnings.push(
+          `Unresolved reference in ${name}: ${unresolvedRef}`
+        );
+      }
+      const category = inferCategory2(name);
+      const level = inferLevel2(name, rawValue, chain);
+      const description = extractDescription(content, line || 1);
+      tokens.push({
+        name,
+        rawValue,
+        resolvedValue,
+        category,
+        level,
+        referenceChain: chain,
+        sourceFile: relativePath,
+        lineNumber: line,
+        theme,
+        selector,
+        description
+      });
+    }
+  } catch (error) {
+    errors.push({
+      message: error instanceof Error ? error.message : "Unknown error",
+      file: filePath
+    });
+  }
+  return {
+    tokens,
+    errors,
+    warnings,
+    parseTimeMs: performance.now() - startTime
+  };
+}
+async function parseTokenFiles(config, projectRoot) {
+  const startTime = performance.now();
+  const allTokens = [];
+  const allErrors = [];
+  const allWarnings = [];
+  const files = await fastGlob(config.include, {
+    cwd: projectRoot,
+    ignore: config.exclude || ["**/node_modules/**"],
+    absolute: true
+  });
+  if (files.length === 0) {
+    allWarnings.push(
+      `No token files found matching: ${config.include.join(", ")}`
+    );
+  }
+  for (const file of files) {
+    const result = await parseTokenFile(
+      file,
+      config.themeSelectors,
+      projectRoot
+    );
+    allTokens.push(...result.tokens);
+    allErrors.push(...result.errors);
+    allWarnings.push(...result.warnings);
+  }
+  return {
+    tokens: allTokens,
+    errors: allErrors,
+    warnings: allWarnings,
+    parseTimeMs: performance.now() - startTime
+  };
+}
+function resolveValue(rawValue, tokensByName, visited = /* @__PURE__ */ new Set()) {
+  const chain = [];
+  let current = rawValue;
+  let hasCircular = false;
+  let unresolvedRef;
+  const maxIterations = 20;
+  let iterations = 0;
+  while (iterations < maxIterations) {
+    iterations++;
+    const varMatch = current.match(/var\(\s*--([a-zA-Z0-9_-]+)(?:\s*,\s*([^)]+))?\s*\)/);
+    if (!varMatch) {
+      break;
+    }
+    const [, refName, fallback] = varMatch;
+    const fullRefName = `--${refName}`;
+    if (visited.has(fullRefName)) {
+      hasCircular = true;
+      break;
+    }
+    visited.add(fullRefName);
+    chain.push(fullRefName);
+    const refToken = tokensByName.get(fullRefName);
+    if (refToken) {
+      current = current.replace(
+        varMatch[0],
+        refToken.rawValue
+      );
+    } else if (fallback) {
+      current = current.replace(varMatch[0], fallback.trim());
+    } else {
+      unresolvedRef = fullRefName;
+      break;
+    }
+  }
+  return {
+    resolvedValue: normalizeValue(current.trim()),
+    chain,
+    hasCircular,
+    unresolvedRef
+  };
+}
+function normalizeValue(value) {
+  value = value.replace(/#[0-9a-fA-F]+/g, (match) => match.toLowerCase());
+  value = value.replace(/\s+/g, " ").trim();
+  value = value.replace(
+    /rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+))?\s*\)/g,
+    (_, r, g, b, a) => a !== void 0 ? `rgba(${r}, ${g}, ${b}, ${a})` : `rgb(${r}, ${g}, ${b})`
+  );
+  return value;
+}
+function inferCategory2(name) {
+  const lowerName = name.toLowerCase();
+  for (const { pattern, category } of CATEGORY_PATTERNS2) {
+    if (pattern.test(lowerName)) {
+      return category;
+    }
+  }
+  return "other";
+}
+function inferLevel2(name, rawValue, referenceChain) {
+  const lowerName = name.toLowerCase();
+  if (/btn|button|input|card|modal|dialog|menu|nav|header|footer|table|form/i.test(
+    lowerName
+  )) {
+    return 3;
+  }
+  if (referenceChain.length > 0) {
+    return 2;
+  }
+  if (rawValue.match(/^#[0-9a-fA-F]+$/) || rawValue.match(/^\d+(\.\d+)?(px|rem|em|%|vh|vw)?$/)) {
+    return 1;
+  }
+  return 2;
+}
+function findSelectorForLine(content, targetLine) {
+  const lines = content.split("\n");
+  let currentSelector = ":root";
+  let braceDepth = 0;
+  for (let i = 0; i < Math.min(targetLine, lines.length); i++) {
+    const line = lines[i];
+    const selectorMatch = line.match(/^\s*([^{]+)\s*\{/);
+    if (selectorMatch) {
+      const selector = selectorMatch[1].trim();
+      if ((line.match(/\{/g) || []).length > (line.match(/\}/g) || []).length) {
+        currentSelector = selector;
+      }
+    }
+    braceDepth += (line.match(/\{/g) || []).length;
+    braceDepth -= (line.match(/\}/g) || []).length;
+    if (braceDepth === 0) {
+      currentSelector = ":root";
+    }
+  }
+  return currentSelector;
+}
+function extractDescription(content, line) {
+  const lines = content.split("\n");
+  if (line <= 1) return void 0;
+  const prevLine = lines[line - 2]?.trim();
+  const singleLineMatch = prevLine?.match(/\/\/\s*(.+)$/);
+  if (singleLineMatch) {
+    return singleLineMatch[1].trim();
+  }
+  const multiLineMatch = prevLine?.match(/\*\s*(.+)\s*\*\//);
+  if (multiLineMatch) {
+    return multiLineMatch[1].trim();
+  }
+  const inlineMatch = prevLine?.match(/\/\*\s*(.+)\s*\*\//);
+  if (inlineMatch) {
+    return inlineMatch[1].trim();
+  }
+  return void 0;
+}
+function hexToRgb(hex) {
+  const match = hex.match(/^#([0-9a-f]{2})([0-9a-f]{2})([0-9a-f]{2})$/i);
+  if (!match) return null;
+  return {
+    r: parseInt(match[1], 16),
+    g: parseInt(match[2], 16),
+    b: parseInt(match[3], 16)
+  };
+}
+function rgbToHex(r, g, b) {
+  return `#${[r, g, b].map((x) => Math.round(x).toString(16).padStart(2, "0")).join("")}`;
+}
+function parseRgb(color) {
+  const match = color.match(
+    /rgba?\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*(?:,\s*([\d.]+))?\s*\)/
+  );
+  if (!match) return null;
+  return {
+    r: parseInt(match[1], 10),
+    g: parseInt(match[2], 10),
+    b: parseInt(match[3], 10),
+    a: match[4] ? parseFloat(match[4]) : void 0
+  };
+}
+function normalizeColor(color) {
+  if (color.startsWith("#")) {
+    return color.toLowerCase();
+  }
+  const rgb = parseRgb(color);
+  if (rgb) {
+    return rgbToHex(rgb.r, rgb.g, rgb.b);
+  }
+  return color.toLowerCase();
+}
+function parseTailwindV4File(filePath) {
+  const startTime = performance.now();
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const result = parseTailwindV4Theme(content, filePath);
+    return {
+      tokens: result.tokens,
+      errors: result.errors.map((message) => ({ message, file: filePath })),
+      warnings: result.warnings,
+      parseTimeMs: result.parseTimeMs
+    };
+  } catch (error) {
+    return {
+      tokens: [],
+      errors: [
+        {
+          message: error instanceof Error ? error.message : "Unknown error",
+          file: filePath
+        }
+      ],
+      warnings: [],
+      parseTimeMs: performance.now() - startTime
+    };
+  }
+}
+function containsTailwindV4Theme(content) {
+  return /^@theme\b/m.test(content);
+}
+
 // src/service/token-registry.ts
 var TokenRegistryManager = class {
   registry = null;
@@ -3576,7 +4068,7 @@ function applyPatches(sourceCode, patches) {
 }
 
 // src/service/metrics-store.ts
-import { readFile as readFile2, writeFile as writeFile2, mkdir as mkdir2, readdir as readdir2 } from "fs/promises";
+import { readFile as readFile3, writeFile as writeFile2, mkdir as mkdir2, readdir as readdir2 } from "fs/promises";
 import { join as join2 } from "path";
 var MetricsStore = class {
   projectRoot;
@@ -3596,7 +4088,7 @@ var MetricsStore = class {
     const filepath = join2(this.metricsDir, filename);
     let snapshots = [];
     try {
-      const existing = await readFile2(filepath, "utf-8");
+      const existing = await readFile3(filepath, "utf-8");
       snapshots = JSON.parse(existing);
     } catch {
     }
@@ -3623,7 +4115,7 @@ var MetricsStore = class {
           continue;
         }
         try {
-          const content = await readFile2(join2(this.metricsDir, file), "utf-8");
+          const content = await readFile3(join2(this.metricsDir, file), "utf-8");
           const fileSnapshots = JSON.parse(content);
           const matching = component === "all" ? fileSnapshots : fileSnapshots.filter((s) => s.component === component);
           snapshots.push(...matching);
@@ -3754,12 +4246,12 @@ function createMetricsStore(projectRoot) {
 import { parse as parse2 } from "@babel/parser";
 import _traverse from "@babel/traverse";
 import * as t2 from "@babel/types";
-import { readFile as readFile3 } from "fs/promises";
+import { readFile as readFile4 } from "fs/promises";
 import { existsSync as existsSync2 } from "fs";
 import { basename, dirname as dirname3, join as join3 } from "path";
 var traverse2 = _traverse.default || _traverse;
 async function extractComponentDocs(filePath) {
-  const content = await readFile3(filePath, "utf-8");
+  const content = await readFile4(filePath, "utf-8");
   return extractDocsFromSource(content, filePath);
 }
 function extractDocsFromSource(source, filePath) {
@@ -4101,12 +4593,12 @@ async function extractAllComponentDocs(componentFiles) {
 import { parse as parse3 } from "@babel/parser";
 import _traverse2 from "@babel/traverse";
 import * as t3 from "@babel/types";
-import { readFile as readFile4 } from "fs/promises";
+import { readFile as readFile5 } from "fs/promises";
 import fg from "fast-glob";
-import { basename as basename2, relative } from "path";
+import { basename as basename2, relative as relative2 } from "path";
 var traverse3 = _traverse2.default || _traverse2;
 async function parseStoryFile(filePath) {
-  const content = await readFile4(filePath, "utf-8");
+  const content = await readFile5(filePath, "utf-8");
   return parseStorySource(content, filePath);
 }
 function parseStorySource(source, filePath) {
@@ -4403,7 +4895,7 @@ async function parseAllStories(rootDir) {
       results.set(parsed.meta.componentName, parsed);
     } catch (error) {
       console.warn(
-        `Failed to parse story file ${relative(rootDir, filePath)}:`,
+        `Failed to parse story file ${relative2(rootDir, filePath)}:`,
         error.message
       );
     }
@@ -4741,11 +5233,11 @@ If there isn't enough usage data to make confident recommendations, indicate tha
 
 // src/service/enhance/props-extractor.ts
 import * as ts from "typescript";
-import { readFile as readFile5 } from "fs/promises";
+import { readFile as readFile6 } from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import { basename as basename3, dirname as dirname5, join as join5, resolve as resolve2 } from "path";
+import { basename as basename3, dirname as dirname5, join as join5, resolve as resolve3 } from "path";
 async function extractPropsFromFile(filePath, options = {}) {
-  const absPath = resolve2(filePath);
+  const absPath = resolve3(filePath);
   if (!existsSync3(absPath)) {
     return {
       filePath: absPath,
@@ -4755,7 +5247,7 @@ async function extractPropsFromFile(filePath, options = {}) {
       warnings: [`File not found: ${absPath}`]
     };
   }
-  const content = await readFile5(absPath, "utf-8");
+  const content = await readFile6(absPath, "utf-8");
   return extractPropsFromSource(content, absPath, options);
 }
 function extractPropsFromSource(source, filePath, options = {}) {
@@ -5545,6 +6037,15 @@ export {
   getGrade,
   getScoreColor,
   generateHtmlReport,
+  parseTailwindV4Theme,
+  parseTokenFile,
+  parseTokenFiles,
+  hexToRgb,
+  rgbToHex,
+  parseRgb,
+  normalizeColor,
+  parseTailwindV4File,
+  containsTailwindV4Theme,
   TokenRegistryManager,
   getSharedTokenRegistry,
   initializeSharedRegistry,
@@ -5587,4 +6088,4 @@ export {
   getStorybookStoryIds,
   renderAllComponentVariants
 };
-//# sourceMappingURL=chunk-6SQPP47U.js.map
+//# sourceMappingURL=chunk-ANTWP3UG.js.map