@dsai-io/tools 0.0.1

package/dist/tokens/index.js

@@ -0,0 +1,3682 @@
+import * as fs3 from 'fs';
+import { existsSync, readFileSync, readdirSync, statSync, writeFileSync, mkdirSync, rmSync } from 'fs';
+import * as path from 'path';
+import { relative, basename, extname, join, dirname, resolve } from 'path';
+import { execSync } from 'child_process';
+
+/* @dsai-io/tools - DSAi Design System Build Tools */
+
+// src/tokens/types.ts
+var VALID_TOKEN_TYPES = [
+  "color",
+  "dimension",
+  "fontFamily",
+  "fontWeight",
+  "fontStyle",
+  "shadow",
+  "number",
+  "string",
+  "duration",
+  "cubicBezier",
+  "strokeStyle",
+  "border",
+  "transition",
+  "gradient",
+  "typography",
+  "letterSpacing",
+  "lineHeight",
+  "paragraphSpacing",
+  "textDecoration",
+  "textCase"
+];
+function isDTCGToken(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  return "$value" in obj;
+}
+function isLegacyToken(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  return "value" in obj && !("$value" in obj);
+}
+function isToken(obj) {
+  return isDTCGToken(obj) || isLegacyToken(obj);
+}
+function isValidTokenType(type) {
+  return VALID_TOKEN_TYPES.includes(type);
+}
+function isTokenReference(value) {
+  return typeof value === "string" && value.startsWith("{") && value.endsWith("}");
+}
+function getTokenValue(token) {
+  return isDTCGToken(token) ? token.$value : token.value;
+}
+function getTokenType(token) {
+  if (isDTCGToken(token)) {
+    return token.$type;
+  }
+  return token.type;
+}
+function getTokenDescription(token) {
+  if (isDTCGToken(token)) {
+    return token.$description;
+  }
+  const legacy = token;
+  return legacy.description ?? legacy.comment;
+}
+function toDTCGToken(token) {
+  const dtcg = {
+    $value: token.value
+  };
+  if (token.type && isValidTokenType(token.type)) {
+    dtcg.$type = token.type;
+  }
+  const desc = token.description ?? token.comment;
+  if (desc) {
+    dtcg.$description = desc;
+  }
+  return dtcg;
+}
+function parseTokenReference(ref) {
+  if (!isTokenReference(ref)) {
+    return null;
+  }
+  const inner = ref.slice(1, -1);
+  return inner.split(".");
+}
+var HEX_COLOR_PATTERN = /^#(?:[0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+var RGB_PATTERN = /^rgba?\s*\(/i;
+var HSL_PATTERN = /^hsla?\s*\(/i;
+var NAMED_COLORS = /* @__PURE__ */ new Set([
+  "transparent",
+  "currentcolor",
+  "inherit",
+  "initial",
+  "unset",
+  "black",
+  "white",
+  "red",
+  "green",
+  "blue",
+  "yellow",
+  "orange",
+  "purple",
+  "pink",
+  "gray",
+  "grey"
+]);
+function isValidColor(value) {
+  if (HEX_COLOR_PATTERN.test(value)) {
+    return true;
+  }
+  if (RGB_PATTERN.test(value)) {
+    return true;
+  }
+  if (HSL_PATTERN.test(value)) {
+    return true;
+  }
+  if (isTokenReference(value)) {
+    return true;
+  }
+  if (NAMED_COLORS.has(value.toLowerCase())) {
+    return true;
+  }
+  return false;
+}
+var VALID_UNITS = /* @__PURE__ */ new Set([
+  "px",
+  "rem",
+  "em",
+  "%",
+  "vh",
+  "vw",
+  "vmin",
+  "vmax",
+  "pt",
+  "cm",
+  "mm",
+  "in",
+  "ch",
+  "ex"
+]);
+function isValidDimension(value) {
+  if (value === "0") {
+    return true;
+  }
+  if (isTokenReference(value)) {
+    return true;
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    return false;
+  }
+  let i = 0;
+  const firstChar = trimmed.charAt(0);
+  if (firstChar === "-" || firstChar === "+") {
+    i = 1;
+  }
+  let hasDigits = false;
+  let hasDot = false;
+  while (i < trimmed.length) {
+    const char = trimmed.charAt(i);
+    if (char >= "0" && char <= "9") {
+      hasDigits = true;
+      i++;
+    } else if (char === "." && !hasDot) {
+      hasDot = true;
+      i++;
+    } else {
+      break;
+    }
+  }
+  if (!hasDigits) {
+    return false;
+  }
+  const unit = trimmed.slice(i).toLowerCase();
+  if (unit === "") {
+    return true;
+  }
+  return VALID_UNITS.has(unit);
+}
+function validateSingleToken(path5, token, errors, warnings) {
+  const value = getTokenValue(token);
+  const type = getTokenType(token);
+  const isDtcg = isDTCGToken(token);
+  if (!isDtcg) {
+    warnings.push({
+      path: path5,
+      message: "Token uses legacy format. Consider migrating to DTCG ($value, $type).",
+      severity: "warning",
+      suggestion: "Use $value instead of value, $type instead of type"
+    });
+  }
+  if (value === void 0 || value === null) {
+    errors.push({
+      path: path5,
+      message: "Token has no value",
+      severity: "error"
+    });
+    return;
+  }
+  if (value === "") {
+    warnings.push({
+      path: path5,
+      message: "Token has empty string value",
+      severity: "warning",
+      value
+    });
+  }
+  if (!type) {
+    warnings.push({
+      path: path5,
+      message: "Token has no type specified",
+      severity: "warning",
+      suggestion: `Add $type property with one of: ${VALID_TOKEN_TYPES.slice(0, 5).join(", ")}...`
+    });
+  } else if (!isValidTokenType(type)) {
+    warnings.push({
+      path: path5,
+      message: `Unknown token type: "${type}"`,
+      severity: "warning",
+      value: type,
+      suggestion: `Valid types: ${VALID_TOKEN_TYPES.join(", ")}`
+    });
+  }
+  if (type && typeof value === "string") {
+    validateTypedValue(path5, value, type, errors);
+  }
+}
+function validateTypedValue(path5, value, type, errors) {
+  switch (type) {
+    case "color":
+      if (!isValidColor(value)) {
+        errors.push({
+          path: path5,
+          message: `Invalid color value: "${value}"`,
+          severity: "error",
+          value,
+          suggestion: "Use hex (#fff), rgb(), hsl(), or token reference"
+        });
+      }
+      break;
+    case "dimension":
+      if (!isValidDimension(value)) {
+        errors.push({
+          path: path5,
+          message: `Invalid dimension value: "${value}"`,
+          severity: "error",
+          value,
+          suggestion: "Use value with unit (16px, 1rem) or token reference"
+        });
+      }
+      break;
+    case "fontWeight":
+      if (!isValidFontWeight(value)) {
+        errors.push({
+          path: path5,
+          message: `Invalid fontWeight value: "${value}"`,
+          severity: "error",
+          value,
+          suggestion: "Use numeric (100-900) or keyword (normal, bold)"
+        });
+      }
+      break;
+  }
+}
+function isValidFontWeight(value) {
+  const numeric = parseInt(value, 10);
+  if (!Number.isNaN(numeric) && numeric >= 1 && numeric <= 1e3) {
+    return true;
+  }
+  const keywords = ["normal", "bold", "lighter", "bolder"];
+  if (keywords.includes(value.toLowerCase())) {
+    return true;
+  }
+  if (isTokenReference(value)) {
+    return true;
+  }
+  return false;
+}
+function validateCollection(collection, basePath, errors, warnings, tokenCount) {
+  for (const [key, value] of Object.entries(collection)) {
+    if (key.startsWith("$")) {
+      continue;
+    }
+    const path5 = basePath ? `${basePath}.${key}` : key;
+    if (isToken(value)) {
+      tokenCount.count += 1;
+      validateSingleToken(path5, value, errors, warnings);
+    } else if (typeof value === "object" && value !== null) {
+      validateCollection(value, path5, errors, warnings, tokenCount);
+    }
+  }
+}
+function validateFile(filePath, errors, warnings) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const data = JSON.parse(content);
+    const tokenCount = { count: 0 };
+    validateCollection(data, "", errors, warnings, tokenCount);
+    return tokenCount.count;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    errors.push({
+      path: filePath,
+      message: `Failed to parse file: ${errorMessage}`,
+      severity: "error"
+    });
+    return 0;
+  }
+}
+function findJsonFiles(dir, files = []) {
+  if (!existsSync(dir)) {
+    return files;
+  }
+  const entries = readdirSync(dir);
+  for (const entry of entries) {
+    const fullPath = join(dir, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory()) {
+      findJsonFiles(fullPath, files);
+    } else if (entry.endsWith(".json")) {
+      files.push(fullPath);
+    }
+  }
+  return files;
+}
+async function validateTokens(config, options = {}) {
+  const startTime = Date.now();
+  const { verbose = false, quiet = false, strict = false } = options;
+  const errors = [];
+  const warnings = [];
+  let totalTokens = 0;
+  let fileCount = 0;
+  const collectionsDir = options.collectionsDir ?? config.tokens.collectionsDir;
+  if (!existsSync(collectionsDir)) {
+    return {
+      valid: false,
+      errors: [
+        {
+          path: collectionsDir,
+          message: "Collections directory does not exist",
+          severity: "error"
+        }
+      ],
+      warnings: [],
+      tokenCount: 0,
+      fileCount: 0,
+      duration: Date.now() - startTime
+    };
+  }
+  const jsonFiles = findJsonFiles(collectionsDir);
+  if (!quiet) {
+    logInfo(`Validating ${jsonFiles.length} token files...`);
+  }
+  for (const file of jsonFiles) {
+    fileCount += 1;
+    const relativePath = relative(collectionsDir, file);
+    if (verbose) {
+      logDebug(`Validating: ${relativePath}`);
+    }
+    const tokenCount = validateFile(file, errors, warnings);
+    totalTokens += tokenCount;
+  }
+  const valid = strict ? errors.length === 0 && warnings.length === 0 : errors.length === 0;
+  if (!quiet) {
+    if (valid) {
+      logSuccess(`Validated ${totalTokens} tokens in ${fileCount} files`);
+      if (warnings.length > 0) {
+        logWarn(`${warnings.length} warnings found`);
+      }
+    } else {
+      logError(`Validation failed with ${errors.length} errors`);
+    }
+  }
+  return {
+    valid,
+    errors,
+    warnings,
+    tokenCount: totalTokens,
+    fileCount,
+    duration: Date.now() - startTime
+  };
+}
+async function validateTokensCLI(config, options = {}) {
+  const result = await validateTokens(config, { ...options, verbose: true });
+  if (!result.valid) {
+    for (const error of result.errors) {
+      console.error(`\u274C ${error.path}: ${error.message}`);
+    }
+    process.exit(1);
+  }
+  for (const warning of result.warnings) {
+    console.warn(`\u26A0\uFE0F  ${warning.path}: ${warning.message}`);
+  }
+}
+function logInfo(message) {
+  console.info(`\u2139\uFE0F  ${message}`);
+}
+function logDebug(message) {
+  console.info(`\u{1F50D} ${message}`);
+}
+function logSuccess(message) {
+  console.info(`\u2705 ${message}`);
+}
+function logWarn(message) {
+  console.warn(`\u26A0\uFE0F  ${message}`);
+}
+function logError(message) {
+  console.error(`\u274C ${message}`);
+}
+var DEFAULT_COLLECTIONS = {
+  foundation: {
+    input: "foundation.json",
+    modeAware: true,
+    modes: ["Light", "Dark"]
+  },
+  typography: {
+    input: "typography.json",
+    modeAware: false,
+    modes: ["Base"]
+  },
+  spacing: {
+    input: "spacing.json",
+    modeAware: false,
+    modes: ["Base"]
+  },
+  radius: {
+    input: "radius.json",
+    modeAware: false,
+    modes: ["Base"]
+  },
+  layout: {
+    input: "layout.json",
+    modeAware: false,
+    modes: ["Base"]
+  },
+  shadows: {
+    input: "shadows.json",
+    modeAware: false,
+    modes: ["Base"]
+  }
+};
+function validateFigmaToken(path5, token, errors, warnings) {
+  if (!isToken(token)) {
+    return;
+  }
+  if (isDTCGToken(token)) {
+    if (token.$value === void 0 || token.$value === null) {
+      errors.push({
+        path: path5,
+        message: "Token has $value property but value is undefined or null",
+        severity: "error"
+      });
+    }
+    if (token.$type !== void 0) {
+      if (!isValidTokenType(token.$type)) {
+        warnings.push({
+          path: path5,
+          message: `Unknown token type: ${token.$type}`,
+          severity: "warning"
+        });
+      }
+    }
+  } else if (isLegacyToken(token)) {
+    if (token.value === void 0 || token.value === null) {
+      errors.push({
+        path: path5,
+        message: "Token has value property but value is undefined or null",
+        severity: "error"
+      });
+    }
+    warnings.push({
+      path: path5,
+      message: "Token uses legacy format (value instead of $value), consider migrating to DTCG",
+      severity: "warning"
+    });
+  }
+}
+function validateTokenTree(obj, basePath, errors, warnings) {
+  if (obj === null || typeof obj !== "object") {
+    return;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    const path5 = basePath ? `${basePath}.${key}` : key;
+    if (isToken(value)) {
+      validateFigmaToken(path5, value, errors, warnings);
+    } else if (typeof value === "object" && value !== null) {
+      validateTokenTree(value, path5, errors, warnings);
+    }
+  }
+}
+function validateCollectionStructure(data, collectionName, expectedCollection, errors, warnings) {
+  const detectedModes = /* @__PURE__ */ new Set();
+  const collection = Object.entries(data).find(
+    ([key]) => key.toLowerCase() === collectionName.toLowerCase()
+  )?.[1];
+  if (!collection) {
+    errors.push({
+      path: collectionName,
+      message: `Expected collection "${collectionName}" not found in export`,
+      severity: "error"
+    });
+    return detectedModes;
+  }
+  if (collection.modes) {
+    const modes = Object.keys(collection.modes);
+    for (const mode of modes) {
+      detectedModes.add(mode);
+    }
+    if (expectedCollection.modeAware && expectedCollection.modes) {
+      for (const expectedMode of expectedCollection.modes) {
+        if (!modes.includes(expectedMode)) {
+          warnings.push({
+            path: `${collectionName}.modes`,
+            message: `Expected mode "${expectedMode}" not found, available modes: ${modes.join(", ")}`,
+            severity: "warning"
+          });
+        }
+      }
+    }
+    for (const [modeName, modeData] of Object.entries(collection.modes)) {
+      if (modeData && typeof modeData === "object") {
+        validateTokenTree(modeData, `${collectionName}.modes.${modeName}`, errors, warnings);
+      }
+    }
+  } else {
+    validateTokenTree(collection, collectionName, errors, warnings);
+  }
+  return detectedModes;
+}
+function validateFigmaFile(filePath, expectedCollection) {
+  const errors = [];
+  const warnings = [];
+  const detectedModes = /* @__PURE__ */ new Set();
+  let tokenCount = 0;
+  if (!existsSync(filePath)) {
+    errors.push({
+      path: filePath,
+      message: "File not found",
+      severity: "error"
+    });
+    return { valid: false, errors, warnings, detectedModes, tokenCount: 0, fileCount: 0 };
+  }
+  let data;
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    data = JSON.parse(content);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    errors.push({
+      path: filePath,
+      message: `Failed to parse JSON: ${message}`,
+      severity: "error"
+    });
+    return { valid: false, errors, warnings, detectedModes, tokenCount: 0, fileCount: 1 };
+  }
+  if (data === null || typeof data !== "object" || Array.isArray(data)) {
+    errors.push({
+      path: filePath,
+      message: "Figma export must be a JSON object",
+      severity: "error"
+    });
+    return { valid: false, errors, warnings, detectedModes, tokenCount: 0, fileCount: 1 };
+  }
+  const fileName = basename(filePath, extname(filePath));
+  const collectionName = fileName.charAt(0).toUpperCase() + fileName.slice(1);
+  const countTokens2 = (obj) => {
+    if (obj === null || typeof obj !== "object") {
+      return 0;
+    }
+    if (isToken(obj)) {
+      return 1;
+    }
+    let count = 0;
+    for (const value of Object.values(obj)) {
+      count += countTokens2(value);
+    }
+    return count;
+  };
+  if (expectedCollection) {
+    const modes = validateCollectionStructure(
+      data,
+      collectionName,
+      expectedCollection,
+      errors,
+      warnings
+    );
+    for (const mode of modes) {
+      detectedModes.add(mode);
+    }
+  } else {
+    for (const [key, value] of Object.entries(data)) {
+      if (typeof value === "object" && value !== null) {
+        const collection = value;
+        if (collection.modes) {
+          for (const mode of Object.keys(collection.modes)) {
+            detectedModes.add(mode);
+          }
+        }
+        validateTokenTree(value, key, errors, warnings);
+      }
+    }
+  }
+  tokenCount = countTokens2(data);
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    detectedModes,
+    tokenCount,
+    fileCount: 1
+  };
+}
+function validateFigmaExports(options = {}) {
+  const {
+    exportsDir,
+    collections = DEFAULT_COLLECTIONS,
+    strict = false,
+    skipMissing = false
+  } = options;
+  const errors = [];
+  const warnings = [];
+  const files = /* @__PURE__ */ new Map();
+  const detectedModes = /* @__PURE__ */ new Set();
+  const missingFiles = [];
+  let totalTokenCount = 0;
+  let totalFileCount = 0;
+  const targetDir = exportsDir ?? options.config?.tokens.sourceDir;
+  if (!targetDir) {
+    errors.push({
+      path: "config",
+      message: "Figma exports directory not specified",
+      severity: "error"
+    });
+    return {
+      valid: false,
+      errors,
+      warnings,
+      files,
+      detectedModes,
+      missingFiles,
+      tokenCount: 0,
+      fileCount: 0
+    };
+  }
+  if (!existsSync(targetDir)) {
+    errors.push({
+      path: targetDir,
+      message: "Figma exports directory not found",
+      severity: "error"
+    });
+    return {
+      valid: false,
+      errors,
+      warnings,
+      files,
+      detectedModes,
+      missingFiles,
+      tokenCount: 0,
+      fileCount: 0
+    };
+  }
+  for (const [_name, expectedCollection] of Object.entries(collections)) {
+    const filePath = join(targetDir, expectedCollection.input);
+    if (!existsSync(filePath)) {
+      missingFiles.push(expectedCollection.input);
+      if (!skipMissing) {
+        errors.push({
+          path: filePath,
+          message: `Expected Figma export "${expectedCollection.input}" not found`,
+          severity: "error"
+        });
+      }
+      continue;
+    }
+    const result = validateFigmaFile(filePath, expectedCollection);
+    files.set(expectedCollection.input, {
+      valid: result.valid,
+      errors: result.errors,
+      warnings: result.warnings,
+      tokenCount: result.tokenCount,
+      fileCount: result.fileCount
+    });
+    errors.push(...result.errors);
+    warnings.push(...result.warnings);
+    totalTokenCount += result.tokenCount;
+    totalFileCount += result.fileCount;
+    for (const mode of result.detectedModes) {
+      detectedModes.add(mode);
+    }
+  }
+  try {
+    const existingFiles = readdirSync(targetDir).filter(
+      (f) => f.endsWith(".json") && statSync(join(targetDir, f)).isFile()
+    );
+    const expectedFiles = new Set(Object.values(collections).map((c) => c.input));
+    for (const file of existingFiles) {
+      if (!expectedFiles.has(file)) {
+        warnings.push({
+          path: join(targetDir, file),
+          message: `Unexpected file in exports directory: ${file}`,
+          severity: "warning"
+        });
+      }
+    }
+  } catch {
+  }
+  const effectiveErrors = strict ? [...errors, ...warnings] : errors;
+  return {
+    valid: effectiveErrors.length === 0,
+    errors,
+    warnings,
+    files,
+    detectedModes,
+    missingFiles,
+    tokenCount: totalTokenCount,
+    fileCount: totalFileCount
+  };
+}
+function detectModes(data, collectionName) {
+  if (!data || typeof data !== "object") {
+    return ["Base"];
+  }
+  if (collectionName) {
+    const collection = Object.entries(data).find(
+      ([key]) => key.toLowerCase() === collectionName.toLowerCase()
+    )?.[1];
+    if (collection?.modes) {
+      return Object.keys(collection.modes);
+    }
+    return ["Base"];
+  }
+  for (const [, value] of Object.entries(data)) {
+    if (typeof value === "object" && value !== null) {
+      const collection = value;
+      if (collection.modes) {
+        return Object.keys(collection.modes);
+      }
+    }
+  }
+  return ["Base"];
+}
+function validateFigmaCLI(exportsDir, options = {}) {
+  console.info(`
+\u{1F50D} Validating Figma exports in: ${exportsDir}
+`);
+  const result = validateFigmaExports({ ...options, exportsDir });
+  for (const [file, fileResult] of result.files) {
+    if (fileResult.errors.length === 0 && fileResult.warnings.length === 0) {
+      console.info(`\u2705 ${file}`);
+    } else {
+      console.info(`
+\u{1F4C4} ${file}`);
+      for (const error of fileResult.errors) {
+        console.error(`   \u274C ${error.path}: ${error.message}`);
+      }
+      for (const warning of fileResult.warnings) {
+        console.warn(`   \u26A0\uFE0F  ${warning.path}: ${warning.message}`);
+      }
+    }
+  }
+  if (result.missingFiles.length > 0) {
+    console.warn(`
+\u26A0\uFE0F  Missing files: ${result.missingFiles.join(", ")}`);
+  }
+  if (result.detectedModes.size > 0) {
+    console.info(`
+\u{1F4CA} Detected modes: ${[...result.detectedModes].join(", ")}`);
+  }
+  console.info(`
+${"\u2500".repeat(50)}`);
+  if (result.valid) {
+    console.info("\u2705 All Figma exports are valid");
+  } else {
+    console.error(
+      `\u274C Validation failed: ${result.errors.length} error(s), ${result.warnings.length} warning(s)`
+    );
+  }
+  return result.valid;
+}
+var UNSAFE_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function isSafeKey(key) {
+  return !UNSAFE_KEYS.has(key);
+}
+function getNestedValue(obj, ...keys) {
+  let current = obj;
+  for (const key of keys) {
+    if (current === null || current === void 0 || typeof current !== "object") {
+      return void 0;
+    }
+    if (!isSafeKey(key)) {
+      return void 0;
+    }
+    current = current[key];
+  }
+  return current;
+}
+function shouldKeepUnitless(_type, scopes = [], tokenPath = "") {
+  if (scopes.includes("FONT_WEIGHT")) {
+    return true;
+  }
+  if (scopes.includes("LINE_HEIGHT")) {
+    return true;
+  }
+  const pathLower = tokenPath.toLowerCase();
+  if (pathLower.includes("columns") || pathLower.includes("row-columns")) {
+    return true;
+  }
+  return false;
+}
+function shouldAddUnit(type, scopes = [], tokenPath = "") {
+  if (shouldKeepUnitless(type, scopes, tokenPath)) {
+    return false;
+  }
+  return type === "number";
+}
+function transformValue(value, type, options = {}) {
+  if (type === "string" && options.fontStack && typeof value === "string") {
+    const fontName = value;
+    const stack = options.fontStack;
+    if (stack.toLowerCase().includes(fontName.toLowerCase())) {
+      return stack;
+    }
+    return `${fontName}, ${stack}`;
+  }
+  if (typeof value === "number" && shouldKeepUnitless(type ?? "", options.scopes, options.tokenPath)) {
+    return value;
+  }
+  if (typeof value === "number" && shouldAddUnit(type ?? "", options.scopes, options.tokenPath)) {
+    if (options.isCircle) {
+      return "50%";
+    }
+    if (options.isPill) {
+      return "9999px";
+    }
+    return `${value}px`;
+  }
+  return value;
+}
+function transformType(figmaType) {
+  if (!figmaType) {
+    return void 0;
+  }
+  const typeMap = {
+    number: "dimension",
+    string: "fontFamily",
+    color: "color"
+  };
+  return typeMap[figmaType] ?? figmaType;
+}
+function transformToken(figmaToken, options = {}) {
+  if (!figmaToken || typeof figmaToken !== "object") {
+    return null;
+  }
+  const tokenObj = figmaToken;
+  if (!Object.hasOwn(tokenObj, "$value")) {
+    return null;
+  }
+  const transformOptions = {
+    ...options,
+    scopes: tokenObj["$scopes"] ?? []
+  };
+  const rawType = tokenObj["$type"];
+  const transformedType = transformType(rawType);
+  const token = {
+    $value: transformValue(tokenObj["$value"], rawType, transformOptions),
+    $type: transformedType ?? "string"
+  };
+  if (tokenObj["$description"] && typeof tokenObj["$description"] === "string") {
+    token.$description = tokenObj["$description"];
+  }
+  if (tokenObj["$extensions"] && typeof tokenObj["$extensions"] === "object") {
+    token.$extensions = tokenObj["$extensions"];
+  }
+  return token;
+}
+function transformTokenTree(obj, parentKey = "", options = {}) {
+  const result = {};
+  if (obj === null || typeof obj !== "object" || Array.isArray(obj)) {
+    return result;
+  }
+  for (const [key, value] of Object.entries(obj)) {
+    const currentPath = parentKey ? `${parentKey}.${key}` : key;
+    const tokenOptions = {
+      ...options[key] ?? {},
+      tokenPath: currentPath
+    };
+    const transformed = transformToken(value, tokenOptions);
+    if (transformed) {
+      result[key] = transformed;
+    } else if (typeof value === "object" && value !== null) {
+      const nested = transformTokenTree(
+        value,
+        currentPath,
+        options[key] ?? {}
+      );
+      if (Object.keys(nested).length > 0) {
+        result[key] = nested;
+      }
+    }
+  }
+  return result;
+}
+function extractBrandColors(data, mode = "Light") {
+  const brandData = getNestedValue(data, "Foundation", "modes", mode, "colors", "brand");
+  if (!brandData) {
+    console.warn(`No brand colors found in ${mode} mode`);
+    return {};
+  }
+  return {
+    color: transformTokenTree(brandData)
+  };
+}
+function extractThemeColors(data, mode = "Light") {
+  const themeData = getNestedValue(data, "Foundation", "modes", mode, "colors", "theme");
+  if (!themeData) {
+    console.warn(`No theme colors found in ${mode} mode`);
+    return {};
+  }
+  return {
+    theme: transformTokenTree(themeData)
+  };
+}
+function extractSemanticColors(data, mode = "Light") {
+  const semantic = getNestedValue(data, "Foundation", "modes", mode, "semantic");
+  if (!semantic) {
+    console.warn(`No semantic colors found in ${mode} mode`);
+    return {};
+  }
+  return {
+    semantic: transformTokenTree(semantic)
+  };
+}
+function extractNeutralColors(data, mode = "Light") {
+  const neutral = getNestedValue(data, "Foundation", "modes", mode, "colors", "neutral");
+  if (!neutral) {
+    console.warn(`No neutral colors found in ${mode} mode`);
+    return {};
+  }
+  return {
+    neutral: transformTokenTree(neutral)
+  };
+}
+function extractBackgroundColors(data, mode = "Light") {
+  const background = getNestedValue(data, "Foundation", "modes", mode, "colors", "background");
+  if (!background) {
+    console.warn(`No background colors found in ${mode} mode`);
+    return {};
+  }
+  return {
+    background: transformTokenTree(background)
+  };
+}
+function extractOpacityColors(data, mode = "Light") {
+  const opacity = getNestedValue(data, "Foundation", "modes", mode, "colors", "opacity");
+  if (!opacity) {
+    console.warn(`No opacity tokens found in ${mode} mode`);
+    return {};
+  }
+  return {
+    opacity: transformTokenTree(opacity)
+  };
+}
+function extractBorderColors(data, mode = "Light") {
+  const borderColor = getNestedValue(data, "Foundation", "modes", mode, "borders", "color");
+  if (!borderColor) {
+    console.warn(`No border color tokens found in ${mode} mode`);
+    return {};
+  }
+  return {
+    border: {
+      color: transformTokenTree(borderColor)
+    }
+  };
+}
+function extractBorderWidths(data, mode = "Light") {
+  const borderWidth = getNestedValue(data, "Foundation", "modes", mode, "borders", "width");
+  if (!borderWidth) {
+    console.warn(`No border width tokens found in ${mode} mode`);
+    return {};
+  }
+  return {
+    border: {
+      width: transformTokenTree(borderWidth)
+    }
+  };
+}
+function extractTypography(data) {
+  const base = getNestedValue(data, "Typography", "modes", "Base");
+  if (!base) {
+    console.warn("No typography tokens found");
+    return {};
+  }
+  const options = {};
+  const fontFamily = base["fontFamily"];
+  if (fontFamily) {
+    for (const key of Object.keys(fontFamily)) {
+      const fontToken = fontFamily[key];
+      const extensions = fontToken?.["$extensions"];
+      const fontStack = extensions?.["platform"]?.["fontStack"];
+      if (fontStack) {
+        options[key] = { fontStack };
+      }
+    }
+  }
+  return {
+    typography: transformTokenTree(base, "", { fontFamily: options })
+  };
+}
+function extractSpacing(data) {
+  const base = getNestedValue(data, "Spacing", "modes", "Base", "spacing");
+  if (!base) {
+    console.warn("No spacing tokens found");
+    return {};
+  }
+  return {
+    spacing: transformTokenTree(base)
+  };
+}
+function extractRadius(data) {
+  const base = getNestedValue(data, "Radius", "modes", "Base", "border-radius") || getNestedValue(data, "Radius", "modes", "Base", "radius");
+  if (!base) {
+    console.warn("No radius tokens found");
+    return {};
+  }
+  const options = {
+    circle: { isCircle: true },
+    pill: { isPill: true }
+  };
+  return {
+    border: {
+      radius: transformTokenTree(base, "", options)
+    }
+  };
+}
+function extractBreakpoints(data) {
+  const breakpoints = getNestedValue(data, "Layout", "modes", "Base", "breakpoints");
+  if (!breakpoints) {
+    console.warn("No breakpoint tokens found");
+    return {};
+  }
+  return {
+    layout: {
+      breakpoints: transformTokenTree(breakpoints)
+    }
+  };
+}
+function extractContainers(data) {
+  const container = getNestedValue(data, "Layout", "modes", "Base", "container");
+  if (!container) {
+    console.warn("No container tokens found");
+    return {};
+  }
+  return {
+    layout: {
+      container: transformTokenTree(container)
+    }
+  };
+}
+function extractGrid(data) {
+  const base = getNestedValue(data, "Layout", "modes", "Base");
+  const grid = base?.["grid"];
+  const gutters = base?.["gutters"];
+  if (!grid) {
+    console.warn("No grid tokens found");
+    return {};
+  }
+  const result = {
+    layout: {
+      grid: transformTokenTree(grid)
+    }
+  };
+  if (gutters) {
+    result.layout.gutters = transformTokenTree(gutters);
+  }
+  return result;
+}
+function extractShadows(data) {
+  const base = getNestedValue(data, "Shadows", "modes", "Base", "shadows");
+  if (!base) {
+    console.warn("No shadow tokens found");
+    return {};
+  }
+  const result = { shadow: {} };
+  for (const [key, value] of Object.entries(base)) {
+    const composite = value?.["composite"];
+    if (composite) {
+      const token = {
+        $value: composite["$value"],
+        $type: "shadow"
+      };
+      if (composite["$description"] && typeof composite["$description"] === "string") {
+        token.$description = composite["$description"];
+      }
+      if (composite["$extensions"] && typeof composite["$extensions"] === "object") {
+        token.$extensions = composite["$extensions"];
+      }
+      result.shadow[key] = token;
+    }
+  }
+  return result;
+}
+var DEFAULT_COLLECTIONS2 = {
+  foundation: {
+    input: "foundation.json",
+    modeAware: true,
+    outputs: [
+      { file: "collections/color/primitive.json", extractor: extractBrandColors },
+      { file: "collections/color/neutral.json", extractor: extractNeutralColors },
+      { file: "collections/color/background.json", extractor: extractBackgroundColors },
+      { file: "collections/color/opacity.json", extractor: extractOpacityColors },
+      { file: "collections/color/semantic.json", extractor: extractThemeColors },
+      { file: "collections/color/component.json", extractor: extractSemanticColors },
+      { file: "collections/border/color.json", extractor: extractBorderColors },
+      { file: "collections/border/width.json", extractor: extractBorderWidths }
+    ]
+  },
+  typography: {
+    input: "typography.json",
+    modeAware: false,
+    outputs: [{ file: "collections/typography/base.json", extractor: extractTypography }]
+  },
+  spacing: {
+    input: "spacing.json",
+    modeAware: false,
+    outputs: [{ file: "collections/spacing/base.json", extractor: extractSpacing }]
+  },
+  radius: {
+    input: "radius.json",
+    modeAware: false,
+    outputs: [{ file: "collections/border/radius.json", extractor: extractRadius }]
+  },
+  layout: {
+    input: "layout.json",
+    modeAware: false,
+    outputs: [
+      { file: "collections/layout/breakpoints.json", extractor: extractBreakpoints },
+      { file: "collections/layout/containers.json", extractor: extractContainers },
+      { file: "collections/layout/grid.json", extractor: extractGrid }
+    ]
+  },
+  shadows: {
+    input: "shadows.json",
+    modeAware: false,
+    outputs: [{ file: "collections/shadow/base.json", extractor: extractShadows }]
+  }
+};
+function ensureDir(filePath) {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function detectModes2(data, collectionPath) {
+  if (!data || typeof data !== "object") {
+    return ["Base"];
+  }
+  if (collectionPath) {
+    const collection = getNestedValue(data, collectionPath);
+    const modes = collection?.["modes"];
+    if (modes) {
+      return Object.keys(modes);
+    }
+    return ["Base"];
+  }
+  for (const value of Object.values(data)) {
+    if (typeof value === "object" && value !== null) {
+      const collection = value;
+      const modes = collection["modes"];
+      if (modes) {
+        return Object.keys(modes);
+      }
+    }
+  }
+  return ["Base"];
+}
+function getInputSource(collectionConfig, exportsDir, buildSource) {
+  const themeFile = join(exportsDir, "theme.json");
+  const collectionFile = join(exportsDir, collectionConfig.input);
+  {
+    if (existsSync(themeFile)) {
+      return themeFile;
+    }
+    if (existsSync(collectionFile)) {
+      console.warn(`   \u26A0\uFE0F  theme.json not found, using ${collectionConfig.input}`);
+      return collectionFile;
+    }
+    return themeFile;
+  }
+}
+function transformTokens(options) {
+  const {
+    sourceDir,
+    collectionsDir,
+    ignoreModes = [],
+    defaultMode = "Light",
+    dryRun = false,
+    verbose = false
+  } = options;
+  const startTime = Date.now();
+  const errors = [];
+  const warnings = [];
+  const filesWritten = [];
+  const allModesDetected = /* @__PURE__ */ new Set();
+  let tokensProcessed = 0;
+  if (verbose) {
+    console.info("\u{1F3A8} Transforming Figma tokens to Style Dictionary format...\n");
+    console.info("\u{1F4CB} Configuration:");
+    console.info(`   Source directory: ${sourceDir}`);
+    console.info(`   Output directory: ${collectionsDir}`);
+    console.info(`   Default mode: ${defaultMode}`);
+    if (ignoreModes.length > 0) {
+      console.info(`   Ignored modes: ${ignoreModes.join(", ")}`);
+    }
+    if (dryRun) {
+      console.info("   DRY RUN - no files will be written");
+    }
+    console.info("");
+  }
+  const detectedModes = {};
+  const themeFile = join(sourceDir, "theme.json");
+  if (existsSync(themeFile)) {
+    try {
+      const content = readFileSync(themeFile, "utf-8");
+      const themeData = JSON.parse(content);
+      for (const [name, collectionConfig] of Object.entries(DEFAULT_COLLECTIONS2)) {
+        const typedConfig = collectionConfig;
+        if (typedConfig.modeAware) {
+          const collectionPath = name.charAt(0).toUpperCase() + name.slice(1);
+          const modes = detectModes2(themeData, collectionPath);
+          if (modes.length > 0) {
+            detectedModes[collectionPath] = modes;
+            for (const mode of modes) {
+              allModesDetected.add(mode);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      warnings.push(
+        `Failed to read theme.json for mode detection: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  for (const [collectionName, collectionConfig] of Object.entries(DEFAULT_COLLECTIONS2)) {
+    const typedConfig = collectionConfig;
+    if (verbose) {
+      console.info(`Processing ${collectionName} collection...`);
+    }
+    const inputPath = getInputSource(typedConfig, sourceDir);
+    if (!existsSync(inputPath)) {
+      warnings.push(`Input file not found: ${inputPath}`);
+      continue;
+    }
+    let data;
+    try {
+      const content = readFileSync(inputPath, "utf-8");
+      data = JSON.parse(content);
+    } catch (error) {
+      errors.push(
+        `Failed to read ${inputPath}: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      continue;
+    }
+    let modesToProcess = [defaultMode];
+    if (typedConfig.modeAware) {
+      const collectionPath = collectionName.charAt(0).toUpperCase() + collectionName.slice(1);
+      if (detectedModes[collectionPath]) {
+        modesToProcess = detectedModes[collectionPath].filter((m) => !ignoreModes.includes(m));
+      } else {
+        const modes = detectModes2(data, collectionPath);
+        if (modes.length > 1 || !modes.includes("Base")) {
+          modesToProcess = modes.filter((m) => !ignoreModes.includes(m));
+        }
+      }
+    }
+    for (const output of typedConfig.outputs) {
+      for (const mode of modesToProcess) {
+        let outputFile = output.file;
+        if (typedConfig.modeAware && modesToProcess.length > 1) {
+          const ext = extname(output.file);
+          const base = basename(output.file, ext);
+          const dir = dirname(output.file);
+          if (mode !== defaultMode) {
+            outputFile = join(dir, `${base}-${mode.toLowerCase()}${ext}`);
+          }
+        }
+        const outputPath = join(collectionsDir, outputFile);
+        try {
+          const tokens = typedConfig.modeAware ? output.extractor(data, mode) : output.extractor(data);
+          const tokenCount = Object.keys(tokens).length;
+          if (tokenCount === 0) {
+            warnings.push(`No tokens extracted for ${outputFile} (${mode} mode)`);
+            continue;
+          }
+          tokensProcessed += tokenCount;
+          if (!dryRun) {
+            ensureDir(outputPath);
+            writeFileSync(outputPath, `${JSON.stringify(tokens, null, 2)}
+`, "utf-8");
+          }
+          filesWritten.push(outputFile);
+          if (verbose) {
+            const dryRunLabel = dryRun ? " (dry run)" : "";
+            console.info(
+              `  \u2705 Created ${outputFile}${modesToProcess.length > 1 ? ` (${mode})` : ""}${dryRunLabel}`
+            );
+          }
+        } catch (error) {
+          errors.push(
+            `Error processing ${outputFile}: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+    }
+  }
+  const duration = Date.now() - startTime;
+  if (verbose) {
+    console.info("\n\u2728 Transformation complete!");
+    console.info(`
+\u{1F4C1} Output directory: ${collectionsDir}`);
+    console.info(`\u23F1\uFE0F  Duration: ${duration}ms`);
+  }
+  return {
+    success: errors.length === 0,
+    filesWritten,
+    tokensProcessed,
+    modesDetected: Array.from(allModesDetected),
+    errors,
+    warnings,
+    duration
+  };
+}
+function transformTokensCLI(sourceDir, collectionsDir, options = {}) {
+  const result = transformTokens({
+    sourceDir,
+    collectionsDir,
+    verbose: true,
+    ...options
+  });
+  for (const error of result.errors) {
+    console.error(`\u274C ${error}`);
+  }
+  for (const warning of result.warnings) {
+    console.warn(`\u26A0\uFE0F  ${warning}`);
+  }
+  return result.success;
+}
+var DEFAULT_SOURCE_RELATIVE = "dist/js/tokens.js";
+var DEFAULT_TARGET_RELATIVE = "src/tokens-flat.ts";
+var TS_HEADER = `/**
+ * Do not edit directly, this file was auto-generated.
+ * Generated from Style Dictionary output (dist/js/tokens.js)
+ *
+ * To update: run \`pnpm tokens:build\` which will:
+ * 1. Transform Figma tokens
+ * 2. Build with Style Dictionary
+ * 3. Sync this file automatically
+ */
+
+`;
+var EXPECTED_FONTS = ["Inter", "Roboto Mono"];
+function verifyFontFamilies(content) {
+  const found = [];
+  const missing = [];
+  for (const font of EXPECTED_FONTS) {
+    const pattern = `'${font},`;
+    if (content.includes(pattern) || content.includes(`"${font},`)) {
+      found.push(font);
+    } else {
+      missing.push(font);
+    }
+  }
+  return { found, missing };
+}
+function countTokenExports(content) {
+  const exportPattern = /export\s+const\s+\w+/g;
+  const matches = content.match(exportPattern);
+  return matches ? matches.length : 0;
+}
+function getDefaultSyncPaths(tokensDir) {
+  return {
+    sourceFile: join(tokensDir, DEFAULT_SOURCE_RELATIVE),
+    targetFile: join(tokensDir, DEFAULT_TARGET_RELATIVE)
+  };
+}
+function syncTokens(options) {
+  const { sourceFile, targetFile, dryRun = false, verbose = false } = options;
+  const errors = [];
+  if (verbose) {
+    console.info("\u{1F504} Syncing tokens from Style Dictionary output...");
+    console.info(`   Source: ${sourceFile}`);
+    console.info(`   Target: ${targetFile}`);
+    if (dryRun) {
+      console.info("   DRY RUN - no files will be written");
+    }
+  }
+  if (!existsSync(sourceFile)) {
+    const error = `Source file not found: ${sourceFile}`;
+    if (verbose) {
+      console.error(`\u274C ${error}`);
+    }
+    return {
+      success: false,
+      tokensCount: 0,
+      changed: false,
+      errors: [error]
+    };
+  }
+  let sourceContent;
+  try {
+    sourceContent = readFileSync(sourceFile, "utf-8");
+  } catch (err) {
+    const error = `Failed to read source file: ${err instanceof Error ? err.message : "Unknown error"}`;
+    if (verbose) {
+      console.error(`\u274C ${error}`);
+    }
+    return {
+      success: false,
+      tokensCount: 0,
+      changed: false,
+      errors: [error]
+    };
+  }
+  const tsContent = `${TS_HEADER}${sourceContent}`;
+  const fontFamilies = verifyFontFamilies(sourceContent);
+  if (fontFamilies.missing.length > 0) {
+    for (const font of fontFamilies.missing) {
+      errors.push(`Font family may be missing: ${font}`);
+    }
+  }
+  const tokensCount = countTokenExports(sourceContent);
+  let changed = true;
+  if (existsSync(targetFile)) {
+    try {
+      const existingContent = readFileSync(targetFile, "utf-8");
+      if (existingContent === tsContent) {
+        changed = false;
+        if (verbose) {
+          console.info("\u2705 Target file is already up to date");
+        }
+      }
+    } catch {
+    }
+  }
+  if (changed && !dryRun) {
+    try {
+      const targetDir = dirname(targetFile);
+      if (!existsSync(targetDir)) {
+        mkdirSync(targetDir, { recursive: true });
+      }
+      writeFileSync(targetFile, tsContent, "utf-8");
+    } catch (err) {
+      const error = `Failed to write target file: ${err instanceof Error ? err.message : "Unknown error"}`;
+      if (verbose) {
+        console.error(`\u274C ${error}`);
+      }
+      return {
+        success: false,
+        tokensCount,
+        changed: false,
+        errors: [error]
+      };
+    }
+  }
+  if (verbose) {
+    if (changed) {
+      console.info("\u2705 Successfully synced tokens");
+    }
+    console.info(`   Tokens exported: ${tokensCount}`);
+    if (fontFamilies.found.length > 0) {
+      console.info(`   Font families found: ${fontFamilies.found.join(", ")}`);
+    }
+    if (fontFamilies.missing.length > 0) {
+      console.warn(`   \u26A0\uFE0F  Missing fonts: ${fontFamilies.missing.join(", ")}`);
+    }
+  }
+  return {
+    success: errors.length === 0 || errors.every((e) => e.includes("Font family")),
+    tokensCount,
+    changed,
+    errors: errors.length > 0 ? errors : void 0
+  };
+}
+function syncTokensCLI(tokensDir) {
+  const paths = getDefaultSyncPaths(tokensDir);
+  const result = syncTokens({
+    ...paths,
+    verbose: true
+  });
+  if (result.errors) {
+    for (const error of result.errors) {
+      if (error.includes("Font family")) {
+        console.warn(`\u26A0\uFE0F  ${error}`);
+      } else {
+        console.error(`\u274C ${error}`);
+      }
+    }
+  }
+  return result.success;
+}
+var DEFAULT_CSS_DIR = "dist/css";
+var DEFAULT_FILES = ["dsai-theme-bs.css", "dsai-theme-bs.min.css"];
+var DEFAULT_TRANSFORMATIONS = [
+  {
+    description: "Theme attribute",
+    from: /data-bs-theme/g,
+    to: "data-dsai-theme"
+  }
+];
+function applyReplacements(content, replacements, verbose) {
+  let result = content;
+  let totalCount = 0;
+  for (const rule of replacements) {
+    let matchCount = 0;
+    if (typeof rule.from === "string") {
+      let pos = 0;
+      const searchStr = rule.from;
+      while (pos < result.length) {
+        const idx = result.indexOf(searchStr, pos);
+        if (idx === -1) {
+          break;
+        }
+        matchCount++;
+        pos = idx + 1;
+      }
+      if (matchCount > 0) {
+        result = result.split(rule.from).join(rule.to);
+      }
+    } else {
+      const matches = result.match(rule.from);
+      matchCount = matches ? matches.length : 0;
+      if (matchCount > 0) {
+        result = result.replace(rule.from, rule.to);
+      }
+    }
+    if (matchCount > 0) {
+      totalCount += matchCount;
+      if (verbose) {
+        const desc = rule.description ?? (typeof rule.from === "string" ? rule.from : String(rule.from));
+        console.info(`   \u2713 ${desc}: ${matchCount} replacement(s)`);
+      }
+    }
+  }
+  return { result, count: totalCount };
+}
+function postprocessCss(options) {
+  const {
+    inputFile,
+    outputFile = inputFile,
+    replacements = DEFAULT_TRANSFORMATIONS,
+    dryRun = false,
+    verbose = false
+  } = options;
+  if (!existsSync(inputFile)) {
+    return {
+      success: false,
+      replacementsMade: 0,
+      outputFile,
+      errors: [`File not found: ${inputFile}`]
+    };
+  }
+  let content;
+  try {
+    content = readFileSync(inputFile, "utf-8");
+  } catch (err) {
+    return {
+      success: false,
+      replacementsMade: 0,
+      outputFile,
+      errors: [`Failed to read file: ${err instanceof Error ? err.message : "Unknown error"}`]
+    };
+  }
+  const { result, count } = applyReplacements(content, replacements, verbose);
+  if (count > 0 && !dryRun) {
+    try {
+      writeFileSync(outputFile, result, "utf-8");
+    } catch (err) {
+      return {
+        success: false,
+        replacementsMade: count,
+        outputFile,
+        errors: [`Failed to write file: ${err instanceof Error ? err.message : "Unknown error"}`]
+      };
+    }
+  }
+  return {
+    success: true,
+    replacementsMade: count,
+    outputFile
+  };
+}
+function postprocessCssFiles(options) {
+  const {
+    cssDir,
+    files = DEFAULT_FILES,
+    replacements = DEFAULT_TRANSFORMATIONS,
+    dryRun = false,
+    verbose = false
+  } = options;
+  let filesModified = 0;
+  let totalReplacements = 0;
+  const errors = [];
+  if (verbose) {
+    console.info("\u{1F527} Post-processing CSS files...\n");
+  }
+  for (const fileName of files) {
+    const filePath = join(cssDir, fileName);
+    if (verbose) {
+      console.info(`\u{1F4C4} ${fileName}`);
+    }
+    const result = postprocessCss({
+      inputFile: filePath,
+      replacements,
+      dryRun,
+      verbose
+    });
+    if (result.success) {
+      if (result.replacementsMade > 0) {
+        filesModified++;
+        totalReplacements += result.replacementsMade;
+      } else if (verbose) {
+        console.info("   (no changes needed)");
+      }
+    } else if (result.errors) {
+      errors.push(...result.errors);
+      if (verbose) {
+        for (const err of result.errors) {
+          console.warn(`   \u26A0\uFE0F  ${err}`);
+        }
+      }
+    }
+  }
+  if (verbose) {
+    console.info(`
+\u2705 Post-processing complete. ${filesModified} file(s) modified.`);
+    if (totalReplacements > 0) {
+      console.info(`   Total replacements: ${totalReplacements}`);
+    }
+  }
+  return {
+    success: errors.length === 0,
+    filesModified,
+    totalReplacements,
+    errors
+  };
+}
+function postprocessCLI(tokensDir) {
+  const cssDir = join(tokensDir, DEFAULT_CSS_DIR);
+  const result = postprocessCssFiles({
+    cssDir,
+    verbose: true
+  });
+  return result.success;
+}
+function getDefaultCssDir(tokensDir) {
+  return join(tokensDir, DEFAULT_CSS_DIR);
+}
+function getDefaultFiles() {
+  return [...DEFAULT_FILES];
+}
+function getDefaultTransformations() {
+  return [...DEFAULT_TRANSFORMATIONS];
+}
+
+// src/tokens/build.ts
+var SASS_FLAGS = [
+  "--quiet-deps",
+  "--silence-deprecation=import",
+  "--silence-deprecation=global-builtin",
+  "--silence-deprecation=color-functions"
+].join(" ");
+var SASS_FLAGS_MINIMAL = ["--quiet-deps", "--silence-deprecation=import"].join(" ");
+var DEFAULT_PIPELINE_STEPS = [
+  "validate",
+  "transform",
+  "style-dictionary",
+  "sync",
+  "sass-theme",
+  "sass-theme-minified",
+  "postprocess",
+  "sass-utilities",
+  "sass-utilities-minified",
+  "bundle"
+];
+var DEFAULT_PIPELINE_PATHS = {
+  syncSource: "dist/js/tokens.js",
+  syncTarget: "src/tokens-flat.ts",
+  sassThemeInput: "src/scss/dsai-theme-bs.scss",
+  sassThemeOutput: "dist/css/dsai-theme-bs.css",
+  sassThemeMinifiedOutput: "dist/css/dsai-theme-bs.min.css",
+  sassUtilitiesInput: "src/scss/dsai-utilities.scss",
+  sassUtilitiesOutput: "dist/css/dsai.css",
+  sassUtilitiesMinifiedOutput: "dist/css/dsai.min.css"
+};
+function runStep(step, index, total, verbose) {
+  const stepNum = `[${index + 1}/${total}]`;
+  if (step.skip) {
+    if (verbose) {
+      console.info(`${stepNum} \u23ED\uFE0F  ${step.name} (skipped)`);
+    }
+    return true;
+  }
+  if (verbose) {
+    console.info(`
+${stepNum} \u{1F527} ${step.name}`);
+  }
+  if (step.fn) {
+    try {
+      const result = step.fn();
+      if (result instanceof Promise) {
+        console.warn(`    \u26A0\uFE0F  Async step ${step.name} - running synchronously`);
+      }
+      if (result === false) {
+        console.error(`    \u274C Failed: Step returned false`);
+        return false;
+      }
+      if (verbose) {
+        console.info("    \u2705 Done");
+      }
+      return true;
+    } catch (error) {
+      console.error(`    \u274C Failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+      return false;
+    }
+  }
+  if (step.command) {
+    if (verbose) {
+      const shortCmd = step.command.split(" ").slice(0, 4).join(" ");
+      console.info(`    $ ${shortCmd}...`);
+    }
+    try {
+      execSync(step.command, {
+        cwd: step.cwd ?? process.cwd(),
+        stdio: verbose ? "inherit" : "pipe",
+        env: { ...process.env, FORCE_COLOR: "1" }
+      });
+      if (verbose) {
+        console.info("    \u2705 Done");
+      }
+      return true;
+    } catch (error) {
+      console.error(`    \u274C Failed: ${error instanceof Error ? error.message : "Unknown error"}`);
+      return false;
+    }
+  }
+  console.warn(`    \u26A0\uFE0F  Step ${step.name} has no command or function`);
+  return true;
+}
+function getPipelinePaths(customPaths) {
+  return {
+    ...DEFAULT_PIPELINE_PATHS,
+    ...customPaths
+  };
+}
+var STEP_DISPLAY_NAMES = {
+  validate: "Validate Tokens",
+  transform: "Transform Figma Tokens",
+  "style-dictionary": "Build Style Dictionary",
+  sync: "Sync tokens-flat.ts",
+  "sass-theme": "Compile Bootstrap Theme (unminified)",
+  "sass-theme-minified": "Compile Bootstrap Theme (minified)",
+  postprocess: "Post-process Theme CSS",
+  "sass-utilities": "Compile DSAi Utilities (unminified)",
+  "sass-utilities-minified": "Compile DSAi Utilities (minified)",
+  bundle: "Bundle with tsup"
+};
+function createStepFromName(stepName, tokensPackageDir, figmaExportsDir, tokensDir, paths, sdConfigFile) {
+  const displayName = STEP_DISPLAY_NAMES[stepName];
+  switch (stepName) {
+    case "validate":
+      return {
+        name: displayName,
+        command: "dsai tokens validate",
+        cwd: tokensPackageDir
+      };
+    case "transform":
+      return {
+        name: displayName,
+        fn: () => {
+          const result = transformTokens({
+            sourceDir: figmaExportsDir,
+            collectionsDir: tokensDir,
+            verbose: true
+          });
+          if (!result.success) {
+            for (const error of result.errors) {
+              console.error(`\u274C ${error}`);
+            }
+          }
+          return result.success;
+        }
+      };
+    case "style-dictionary":
+      return {
+        name: displayName,
+        command: `style-dictionary build --config ${sdConfigFile}`,
+        cwd: tokensPackageDir
+      };
+    case "sync":
+      return {
+        name: displayName,
+        fn: () => syncTokensCLI(tokensPackageDir)
+      };
+    case "sass-theme":
+      return {
+        name: displayName,
+        command: `sass ${SASS_FLAGS} ${paths.sassThemeInput} ${paths.sassThemeOutput}`,
+        cwd: tokensPackageDir
+      };
+    case "sass-theme-minified":
+      return {
+        name: displayName,
+        command: `sass ${SASS_FLAGS} ${paths.sassThemeInput} ${paths.sassThemeMinifiedOutput} --style=compressed`,
+        cwd: tokensPackageDir
+      };
+    case "postprocess":
+      return {
+        name: displayName,
+        fn: () => postprocessCLI(tokensPackageDir)
+      };
+    case "sass-utilities":
+      return {
+        name: displayName,
+        command: `sass ${SASS_FLAGS_MINIMAL} ${paths.sassUtilitiesInput} ${paths.sassUtilitiesOutput}`,
+        cwd: tokensPackageDir
+      };
+    case "sass-utilities-minified":
+      return {
+        name: displayName,
+        command: `sass ${SASS_FLAGS_MINIMAL} ${paths.sassUtilitiesInput} ${paths.sassUtilitiesMinifiedOutput} --style=compressed`,
+        cwd: tokensPackageDir
+      };
+    case "bundle":
+      return {
+        name: displayName,
+        command: "tsup",
+        cwd: tokensPackageDir
+      };
+    default:
+      return {
+        name: `Unknown step: ${stepName}`,
+        fn: () => {
+          console.warn(`\u26A0\uFE0F Unknown pipeline step: ${stepName}`);
+          return true;
+        }
+      };
+  }
+}
+function createBuildSteps(tokensDir, _toolsDir, options, pipeline) {
+  const { skipValidate, skipTransform, onlyTheme } = options;
+  const tokensPackageDir = tokensDir.endsWith("/collections") ? dirname(tokensDir) : dirname(tokensDir);
+  const figmaExportsDir = `${tokensPackageDir}/figma-exports`;
+  const pipelineSteps = pipeline?.steps ?? DEFAULT_PIPELINE_STEPS;
+  const paths = getPipelinePaths(pipeline?.paths);
+  const sdConfigFile = pipeline?.styleDictionaryConfig ?? "sd.config.mjs";
+  const steps = [];
+  for (const stepName of pipelineSteps) {
+    const step = createStepFromName(
+      stepName,
+      tokensPackageDir,
+      figmaExportsDir,
+      tokensDir,
+      paths,
+      sdConfigFile
+    );
+    if (stepName === "validate" && skipValidate) {
+      step.skip = true;
+    }
+    if (stepName === "transform" && (skipTransform || onlyTheme)) {
+      step.skip = true;
+    }
+    if (onlyTheme && !["sass-theme", "sass-theme-minified", "postprocess"].includes(stepName)) {
+      if (!["validate"].includes(stepName)) {
+        step.skip = true;
+      }
+    }
+    steps.push(step);
+  }
+  return steps;
+}
+function buildTokens(tokensDir, toolsDir, options = {}) {
+  const { skipValidate, onlyTheme, verbose = true, quiet = false } = options;
+  const startTime = Date.now();
+  const stepsCompleted = [];
+  const stepsFailed = [];
+  const errors = [];
+  const warnings = [];
+  try {
+    if (!existsSync(tokensDir)) {
+      return {
+        success: false,
+        stepsCompleted,
+        stepsFailed: ["Directory Check"],
+        duration: Date.now() - startTime,
+        errors: [`Tokens directory not found: ${tokensDir}`],
+        warnings
+      };
+    }
+  } catch {
+    return {
+      success: false,
+      stepsCompleted,
+      stepsFailed: ["Directory Check"],
+      duration: Date.now() - startTime,
+      errors: [`Failed to check tokens directory: ${tokensDir}`],
+      warnings
+    };
+  }
+  try {
+    if (!existsSync(toolsDir)) {
+      return {
+        success: false,
+        stepsCompleted,
+        stepsFailed: ["Directory Check"],
+        duration: Date.now() - startTime,
+        errors: [`Tools directory not found: ${toolsDir}`],
+        warnings
+      };
+    }
+  } catch {
+    return {
+      success: false,
+      stepsCompleted,
+      stepsFailed: ["Directory Check"],
+      duration: Date.now() - startTime,
+      errors: [`Failed to check tools directory: ${toolsDir}`],
+      warnings
+    };
+  }
+  if (verbose && !quiet) {
+    console.info("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+    console.info("\u2551           DSAi Tokens - Complete Build                     \u2551");
+    console.info("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+    if (skipValidate) {
+      console.info("\u26A0\uFE0F  Skipping validation (--skip-validate)");
+    }
+    if (onlyTheme) {
+      console.info("\u26A0\uFE0F  Building only theme CSS (--only-theme)");
+    }
+  }
+  const steps = createBuildSteps(tokensDir, toolsDir, options, options.pipeline);
+  for (const step of steps) {
+    const stepIndex = steps.indexOf(step);
+    const success = runStep(step, stepIndex, steps.length, verbose && !quiet);
+    if (success) {
+      if (!step.skip) {
+        stepsCompleted.push(step.name);
+      }
+    } else {
+      stepsFailed.push(step.name);
+      errors.push(`Build failed at step: ${step.name}`);
+      const failDuration = Date.now() - startTime;
+      if (verbose && !quiet) {
+        console.error(`
+\u{1F4A5} Build failed at step: ${step.name}`);
+      }
+      return {
+        success: false,
+        stepsCompleted,
+        stepsFailed,
+        duration: failDuration,
+        errors,
+        warnings
+      };
+    }
+  }
+  const duration = Date.now() - startTime;
+  const durationSec = (duration / 1e3).toFixed(2);
+  if (verbose && !quiet) {
+    console.info("\n\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557");
+    console.info("\u2551  \u2705 Build Complete                                         \u2551");
+    console.info(
+      `\u2551  \u{1F4CA} ${stepsCompleted.length} steps passed in ${durationSec}s                              \u2551`
+    );
+    console.info("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D");
+  }
+  return {
+    success: true,
+    stepsCompleted,
+    stepsFailed,
+    duration,
+    errors,
+    warnings
+  };
+}
+function buildTokensCLI(tokensDir, toolsDir, args = []) {
+  const skipValidate = args.includes("--skip-validate");
+  const skipTransform = args.includes("--skip-transform");
+  const onlyTheme = args.includes("--only-theme");
+  const quiet = args.includes("--quiet") || args.includes("-q");
+  const result = buildTokens(tokensDir, toolsDir, {
+    skipValidate,
+    skipTransform,
+    onlyTheme,
+    verbose: !quiet,
+    quiet
+  });
+  return result.success;
+}
+function runBuildCLI(tokensDir, toolsDir) {
+  const args = process.argv.slice(2);
+  const success = buildTokensCLI(tokensDir, toolsDir, args);
+  process.exit(success ? 0 : 1);
+}
+var DEFAULT_CLEAN_DIRECTORIES = ["dist"];
+var ALWAYS_PRESERVE = [".gitkeep", ".gitignore"];
+var PROTECTED_DIRECTORIES = [
+  "src",
+  "node_modules",
+  ".git",
+  ".github",
+  "test",
+  "tests",
+  "__tests__",
+  "docs",
+  "config"
+];
+function validateCleanTarget(dirPath, baseDir) {
+  const resolvedDir = resolve(dirPath);
+  const resolvedBase = resolve(baseDir);
+  if (!resolvedDir.startsWith(resolvedBase)) {
+    return {
+      valid: false,
+      error: `Directory "${dirPath}" is outside base directory "${baseDir}"`
+    };
+  }
+  const dirName = basename(resolvedDir);
+  if (PROTECTED_DIRECTORIES.includes(dirName)) {
+    return {
+      valid: false,
+      error: `Directory "${dirName}" is protected and cannot be cleaned`
+    };
+  }
+  if (resolvedDir === resolvedBase) {
+    return {
+      valid: false,
+      error: "Cannot clean the base directory itself"
+    };
+  }
+  return { valid: true };
+}
+function escapeRegexChars(str) {
+  return str.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+}
+function globToSafePattern(pattern) {
+  const escaped = escapeRegexChars(pattern);
+  return escaped.replace(/\*/g, ".*?").replace(/\?/g, ".");
+}
+function matchGlobPattern(fileName, pattern) {
+  if (!pattern.includes("*") && !pattern.includes("?")) {
+    return fileName === pattern;
+  }
+  if (pattern.startsWith("*.") && !pattern.slice(2).includes("*") && !pattern.includes("?")) {
+    const extension = pattern.slice(1);
+    return fileName.endsWith(extension);
+  }
+  if (pattern.endsWith("*") && !pattern.slice(0, -1).includes("*") && !pattern.includes("?")) {
+    const prefix = pattern.slice(0, -1);
+    return fileName.startsWith(prefix);
+  }
+  const safePattern = globToSafePattern(pattern);
+  const regex = new RegExp(`^${safePattern}$`);
+  return regex.test(fileName);
+}
+function shouldPreserve(fileName, preservePatterns) {
+  const allPatterns = [...ALWAYS_PRESERVE, ...preservePatterns];
+  return allPatterns.some((pattern) => matchGlobPattern(fileName, pattern));
+}
+function countContents(dirPath) {
+  if (!existsSync(dirPath)) {
+    return { files: 0, dirs: 0 };
+  }
+  let files = 0;
+  let dirs = 0;
+  const entries = readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      dirs++;
+      const subCounts = countContents(join(dirPath, entry.name));
+      files += subCounts.files;
+      dirs += subCounts.dirs;
+    } else {
+      files++;
+    }
+  }
+  return { files, dirs };
+}
+function cleanDirectory(dirPath, options) {
+  const existed = existsSync(dirPath);
+  if (!existed) {
+    if (options.verbose) {
+      console.info(`  \u2139\uFE0F  Directory does not exist: ${dirPath}`);
+    }
+    return {
+      path: dirPath,
+      filesRemoved: 0,
+      directoriesRemoved: 0,
+      existed: false
+    };
+  }
+  const counts = countContents(dirPath);
+  if (options.dryRun) {
+    if (options.verbose) {
+      console.info(
+        `  \u{1F50D} Would remove: ${dirPath} (${counts.files} files, ${counts.dirs} directories)`
+      );
+    }
+    return {
+      path: dirPath,
+      filesRemoved: counts.files,
+      directoriesRemoved: counts.dirs,
+      existed: true
+    };
+  }
+  const entries = readdirSync(dirPath, { withFileTypes: true });
+  const toPreserve = entries.filter((e) => shouldPreserve(e.name, options.preserve));
+  if (toPreserve.length > 0) {
+    for (const entry of entries) {
+      if (shouldPreserve(entry.name, options.preserve)) {
+        if (options.verbose) {
+          console.info(`  \u{1F4CC} Preserving: ${entry.name}`);
+        }
+        continue;
+      }
+      const entryPath = join(dirPath, entry.name);
+      rmSync(entryPath, { recursive: true, force: true });
+    }
+  } else {
+    rmSync(dirPath, { recursive: true, force: true });
+  }
+  if (options.verbose) {
+    console.info(`  \u2705 Cleaned: ${dirPath} (${counts.files} files, ${counts.dirs} directories)`);
+  }
+  return {
+    path: dirPath,
+    filesRemoved: counts.files,
+    directoriesRemoved: counts.dirs,
+    existed: true
+  };
+}
+function cleanTokenOutputs(options = {}) {
+  const startTime = Date.now();
+  const normalizedOptions = {
+    baseDir: options.baseDir ?? process.cwd(),
+    directories: options.directories ?? [...DEFAULT_CLEAN_DIRECTORIES],
+    dryRun: options.dryRun ?? false,
+    verbose: options.verbose ?? false,
+    preserve: options.preserve ?? []
+  };
+  const result = {
+    success: true,
+    cleaned: [],
+    totalFilesRemoved: 0,
+    totalDirectoriesRemoved: 0,
+    errors: [],
+    warnings: [],
+    dryRun: normalizedOptions.dryRun,
+    duration: 0
+  };
+  if (normalizedOptions.verbose) {
+    const modeStr = normalizedOptions.dryRun ? "(dry-run)" : "";
+    console.info(`
+\u{1F9F9} Cleaning token outputs ${modeStr}`);
+    console.info(`   Base: ${normalizedOptions.baseDir}`);
+  }
+  for (const dir of normalizedOptions.directories) {
+    const absolutePath = resolve(normalizedOptions.baseDir, dir);
+    const validation = validateCleanTarget(absolutePath, normalizedOptions.baseDir);
+    if (!validation.valid && validation.error) {
+      result.errors.push(validation.error);
+      result.success = false;
+      continue;
+    }
+    try {
+      const cleaned = cleanDirectory(absolutePath, {
+        dryRun: normalizedOptions.dryRun,
+        verbose: normalizedOptions.verbose,
+        preserve: normalizedOptions.preserve
+      });
+      result.cleaned.push(cleaned);
+      result.totalFilesRemoved += cleaned.filesRemoved;
+      result.totalDirectoriesRemoved += cleaned.directoriesRemoved;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      result.errors.push(`Failed to clean "${dir}": ${errorMessage}`);
+      result.success = false;
+    }
+  }
+  result.duration = Date.now() - startTime;
+  if (normalizedOptions.verbose) {
+    console.info("");
+    if (result.success) {
+      const actionStr = normalizedOptions.dryRun ? "Would remove" : "Removed";
+      console.info(
+        `\u2705 ${actionStr} ${result.totalFilesRemoved} files, ${result.totalDirectoriesRemoved} directories in ${result.duration}ms`
+      );
+    } else {
+      console.error("\u274C Clean failed with errors:");
+      for (const error of result.errors) {
+        console.error(`   - ${error}`);
+      }
+    }
+  }
+  return result;
+}
+function cleanTokensCLI(baseDir, options = {}) {
+  const result = cleanTokenOutputs({
+    ...options,
+    baseDir,
+    verbose: options.verbose ?? true
+  });
+  return result.success;
+}
+function isToken2(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  const record = obj;
+  return "$type" in record || "$value" in record;
+}
+function hasChildTokens(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  const record = obj;
+  for (const key of Object.keys(record)) {
+    if (!key.startsWith("$") && typeof record[key] === "object") {
+      return true;
+    }
+  }
+  return false;
+}
+function deepMerge(target, source, verbose = false) {
+  const result = target ? { ...target } : {};
+  const targetIsToken = isToken2(target);
+  const sourceIsToken = isToken2(source);
+  const targetHasChildren = hasChildTokens(target);
+  const sourceHasChildren = hasChildTokens(source);
+  if (targetHasChildren && sourceIsToken) {
+    if (verbose) {
+      console.info("  \u26A0\uFE0F  Skipping single token in favor of children structure");
+    }
+    return result;
+  }
+  if (sourceHasChildren && targetIsToken) {
+    if (verbose) {
+      console.info("  \u26A0\uFE0F  Replacing single token with children structure");
+    }
+    return { ...source };
+  }
+  for (const key of Object.keys(source)) {
+    const sourceValue = source[key];
+    const targetValue = result[key];
+    if (sourceValue && typeof sourceValue === "object" && !Array.isArray(sourceValue)) {
+      result[key] = deepMerge(
+        targetValue,
+        sourceValue,
+        verbose
+      );
+    } else if (Array.isArray(sourceValue)) {
+      const existingArray = Array.isArray(targetValue) ? targetValue : [];
+      result[key] = [...existingArray, ...sourceValue];
+    } else if (sourceValue !== void 0) {
+      result[key] = sourceValue;
+    }
+  }
+  return result;
+}
+function countTokens(obj) {
+  if (!obj || typeof obj !== "object") {
+    return 0;
+  }
+  let count = 0;
+  const record = obj;
+  for (const key of Object.keys(record)) {
+    const value = record[key];
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      const valueRecord = value;
+      if ("$type" in valueRecord || "$value" in valueRecord) {
+        count++;
+      } else {
+        count += countTokens(value);
+      }
+    }
+  }
+  return count;
+}
+function updateReferences(obj, oldName, newName, collectionName) {
+  const normalizedOld = oldName.toLowerCase().replace(/\s+/g, "");
+  const normalizedNew = newName.toLowerCase().replace(/\s+/g, "");
+  const patternsLower = [`{${oldName.toLowerCase()}.`, `{${normalizedOld}.`];
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (typeof value === "string" && value.startsWith("{") && value.endsWith("}")) {
+      let newValue = value;
+      const valueLower = value.toLowerCase();
+      for (const pattern of patternsLower) {
+        if (valueLower.startsWith(pattern)) {
+          const suffix = value.slice(pattern.length);
+          newValue = `{${normalizedNew}.${suffix}`;
+          break;
+        }
+      }
+      obj[key] = newValue;
+      if (obj[key].startsWith("{")) {
+        if (!("$libraryName" in obj)) {
+          obj["$libraryName"] = "";
+        }
+        if (!("$collectionName" in obj)) {
+          obj["$collectionName"] = collectionName;
+        }
+      }
+    } else if (value && typeof value === "object" && !Array.isArray(value)) {
+      updateReferences(value, oldName, newName, collectionName);
+    }
+  }
+}
+function sortProperties(obj) {
+  if (!obj || typeof obj !== "object" || Array.isArray(obj)) {
+    return obj;
+  }
+  const record = obj;
+  const sorted = {};
+  const keys = Object.keys(record).sort((a, b) => {
+    const aIsMeta = a.startsWith("$");
+    const bIsMeta = b.startsWith("$");
+    if (aIsMeta && !bIsMeta) {
+      return -1;
+    }
+    if (!aIsMeta && bIsMeta) {
+      return 1;
+    }
+    return a.localeCompare(b);
+  });
+  for (const key of keys) {
+    sorted[key] = sortProperties(record[key]);
+  }
+  return sorted;
+}
+function isDuplicateSection(obj) {
+  if (!obj || typeof obj !== "object") {
+    return false;
+  }
+  let hasOnlyReferences = true;
+  let referenceCount = 0;
+  function checkReferences(item) {
+    for (const key of Object.keys(item)) {
+      if (key.startsWith("$")) {
+        continue;
+      }
+      const value = item[key];
+      if (value && typeof value === "object" && !Array.isArray(value)) {
+        const valueRecord = value;
+        if ("$value" in valueRecord) {
+          referenceCount++;
+          if (typeof valueRecord["$value"] === "string" && valueRecord["$value"].startsWith("{")) {
+            continue;
+          } else {
+            hasOnlyReferences = false;
+            return;
+          }
+        }
+        checkReferences(valueRecord);
+      }
+    }
+  }
+  checkReferences(obj);
+  return hasOnlyReferences && referenceCount > 10;
+}
+function getCollectionName(data) {
+  if (Array.isArray(data) && data[0]) {
+    const keys = Object.keys(data[0]);
+    return keys[0] ?? null;
+  }
+  return null;
+}
+function loadJSON(filePath, verbose) {
+  try {
+    const fullPath = resolve(filePath);
+    if (verbose) {
+      console.info(`\u{1F4D6} Reading: ${fullPath}`);
+    }
+    const content = readFileSync(fullPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveJSON(filePath, data, verbose) {
+  try {
+    const fullPath = resolve(filePath);
+    const content = JSON.stringify(data, null, 2);
+    writeFileSync(fullPath, content, "utf-8");
+    if (verbose) {
+      console.info(`\u2705 Saved: ${fullPath}`);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+function mergeCollections(options) {
+  const { sourceFiles, outputFile, strategy = "last", dryRun = false, verbose = false } = options;
+  const errors = [];
+  const conflicts = [];
+  if (sourceFiles.length < 2) {
+    return {
+      success: false,
+      collectionsCount: 0,
+      tokensCount: 0,
+      outputFile,
+      errors: ["At least two source files are required"]
+    };
+  }
+  for (const file of sourceFiles) {
+    if (!existsSync(file)) {
+      errors.push(`Source file not found: ${file}`);
+    }
+  }
+  if (errors.length > 0) {
+    return {
+      success: false,
+      collectionsCount: 0,
+      tokensCount: 0,
+      outputFile,
+      errors
+    };
+  }
+  if (verbose) {
+    console.info("\u{1F504} Starting merge process...\n");
+  }
+  const collections = [];
+  for (const file of sourceFiles) {
+    const data = loadJSON(file, verbose);
+    if (!data || !Array.isArray(data) || !data[0]) {
+      errors.push(`Invalid collection structure in: ${file}`);
+      continue;
+    }
+    const name = getCollectionName(data);
+    const collectionData = name ? data[0][name] : data[0];
+    const tokenCount = countTokens(collectionData);
+    if (verbose) {
+      console.info(`\u{1F4E6} Collection: "${name ?? "unknown"}" (${tokenCount} tokens)`);
+    }
+    collections.push({ name, data: collectionData, tokenCount });
+  }
+  if (collections.length < 2) {
+    return {
+      success: false,
+      collectionsCount: collections.length,
+      tokensCount: 0,
+      outputFile,
+      errors: errors.length > 0 ? errors : ["Not enough valid collections to merge"]
+    };
+  }
+  const collectionNames = collections.map((c) => c.name).filter((n) => n !== null);
+  const defaultName = collectionNames[0] ?? "Tokens";
+  const unifiedName = collectionNames.includes("Colors") ? "Colors" : collectionNames.reduce((a, b) => a.length <= b.length ? a : b, defaultName);
+  if (verbose) {
+    console.info(`
+\u{1F3AF} Unified collection name: "${unifiedName}"`);
+    console.info("\n\u{1F500} Merging structures...");
+  }
+  const firstCollection = collections[0];
+  if (!firstCollection) {
+    return {
+      success: false,
+      collectionsCount: 0,
+      tokensCount: 0,
+      outputFile,
+      errors: ["No collections to merge"]
+    };
+  }
+  let merged = firstCollection.data;
+  for (let i = 1; i < collections.length; i++) {
+    const source = collections[i];
+    if (!source) {
+      continue;
+    }
+    if (strategy === "first") {
+      merged = deepMerge(source.data, merged, verbose);
+    } else {
+      merged = deepMerge(merged, source.data, verbose);
+    }
+  }
+  if (verbose) {
+    console.info("\u{1F5D1}\uFE0F  Checking for duplicate sections...");
+  }
+  const modes = merged["modes"];
+  if (modes) {
+    for (const modeName of Object.keys(modes)) {
+      const mode = modes[modeName];
+      const colors = mode?.["colors"];
+      if (colors) {
+        for (const sectionName of Object.keys(colors)) {
+          if (isDuplicateSection(colors[sectionName])) {
+            if (verbose) {
+              console.info(`  \u26A0\uFE0F  Removing duplicate section: ${sectionName}`);
+            }
+            delete colors[sectionName];
+          }
+        }
+      }
+    }
+  }
+  if (verbose) {
+    const normalized = unifiedName.toLowerCase().replace(/\s+/g, "");
+    console.info(`\u{1F517} Normalizing references to lowercase "{${normalized}." format...`);
+  }
+  for (const coll of collections) {
+    if (coll.name) {
+      updateReferences(merged, coll.name, unifiedName, unifiedName);
+    }
+  }
+  if (verbose) {
+    console.info("\u{1F4CB} Sorting properties alphabetically...");
+  }
+  const sorted = sortProperties(merged);
+  const tokensCount = countTokens(sorted);
+  if (verbose) {
+    console.info(`\u2728 Merged collection: ${tokensCount} tokens
+`);
+  }
+  const output = [{ [unifiedName]: sorted }];
+  if (!dryRun) {
+    if (!saveJSON(outputFile, output, verbose)) {
+      errors.push(`Failed to write output file: ${outputFile}`);
+      return {
+        success: false,
+        collectionsCount: collections.length,
+        tokensCount,
+        outputFile,
+        errors,
+        conflicts: conflicts.length > 0 ? conflicts : void 0
+      };
+    }
+  }
+  if (verbose) {
+    console.info("\n\u2705 Merge complete!");
+    console.info("\u{1F4CA} Summary:");
+    for (const coll of collections) {
+      console.info(`   Source: ${coll.tokenCount} tokens`);
+    }
+    console.info(`   Merged:   ${tokensCount} tokens`);
+  }
+  return {
+    success: true,
+    collectionsCount: collections.length,
+    tokensCount,
+    outputFile,
+    conflicts: conflicts.length > 0 ? conflicts : void 0,
+    errors: errors.length > 0 ? errors : void 0
+  };
+}
+function mergeCollectionsCLI(source1, source2, output) {
+  const result = mergeCollections({
+    sourceFiles: [source1, source2],
+    outputFile: output,
+    verbose: true
+  });
+  if (result.errors) {
+    for (const error of result.errors) {
+      console.error(`\u274C ${error}`);
+    }
+  }
+  return result.success;
+}
+var DEFAULT_IGNORE_PATTERNS = [
+  "**/node_modules/**",
+  "**/.git/**",
+  "**/_index.scss",
+  "**/*.test.scss",
+  "**/*.spec.scss",
+  "**/test/**",
+  "**/tests/**"
+];
+function globToRegex(pattern) {
+  const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<<GLOBSTAR>>>").replace(/\*/g, "[^/]*").replace(/\?/g, ".").replace(/<<<GLOBSTAR>>>/g, ".*");
+  return new RegExp(`^${regex}$`);
+}
+function matchesIgnorePattern(relativePath, patterns) {
+  for (const pattern of patterns) {
+    const regex = globToRegex(pattern);
+    if (regex.test(relativePath)) {
+      return true;
+    }
+    const fileName = path.basename(relativePath);
+    if (regex.test(fileName)) {
+      return true;
+    }
+  }
+  return false;
+}
+async function scanDirectory(dir, rootDir, extension, ignorePatterns, maxDepth, currentDepth, followSymlinks) {
+  const files = [];
+  if (currentDepth > maxDepth) {
+    return files;
+  }
+  try {
+    const entries = await fs3.promises.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = path.join(dir, entry.name);
+      const relativePath = path.relative(rootDir, entryPath);
+      if (matchesIgnorePattern(relativePath, ignorePatterns)) {
+        continue;
+      }
+      if (entry.isDirectory() || followSymlinks && entry.isSymbolicLink()) {
+        const subFiles = await scanDirectory(
+          entryPath,
+          rootDir,
+          extension,
+          ignorePatterns,
+          maxDepth,
+          currentDepth + 1,
+          followSymlinks
+        );
+        files.push(...subFiles);
+      } else if (entry.isFile() && entry.name.endsWith(`.${extension}`)) {
+        const stat = await fs3.promises.stat(entryPath);
+        files.push({
+          absolutePath: entryPath,
+          relativePath,
+          name: path.basename(entry.name, `.${extension}`),
+          extension,
+          size: stat.size,
+          mtime: stat.mtime,
+          depth: currentDepth
+        });
+      }
+    }
+  } catch (error) {
+    console.warn(`Warning: Could not read directory ${dir}: ${error.message}`);
+  }
+  return files;
+}
+async function scanDirectories(options) {
+  const {
+    directories,
+    extension,
+    ignorePatterns = DEFAULT_IGNORE_PATTERNS,
+    followSymlinks = false,
+    maxDepth = 10
+  } = options;
+  const files = [];
+  const scannedDirs = [];
+  const missingDirs = [];
+  for (const dir of directories) {
+    const absoluteDir = path.resolve(dir);
+    try {
+      const stat = await fs3.promises.stat(absoluteDir);
+      if (!stat.isDirectory()) {
+        missingDirs.push(absoluteDir);
+        continue;
+      }
+    } catch {
+      missingDirs.push(absoluteDir);
+      continue;
+    }
+    scannedDirs.push(absoluteDir);
+    const foundFiles = await scanDirectory(
+      absoluteDir,
+      absoluteDir,
+      extension,
+      ignorePatterns,
+      maxDepth,
+      0,
+      followSymlinks
+    );
+    files.push(...foundFiles);
+  }
+  const totalSize = files.reduce((sum, file) => sum + file.size, 0);
+  return {
+    files,
+    directories: scannedDirs,
+    missingDirectories: missingDirs,
+    totalFiles: files.length,
+    totalSize
+  };
+}
+function sortFiles(files, order = "alphabetical") {
+  const sorted = [...files];
+  if (order === "alphabetical") {
+    sorted.sort((a, b) => a.name.localeCompare(b.name));
+  } else if (order === "directory-first") {
+    sorted.sort((a, b) => {
+      const dirA = path.dirname(a.relativePath);
+      const dirB = path.dirname(b.relativePath);
+      if (dirA !== dirB) {
+        return dirA.localeCompare(dirB);
+      }
+      return a.name.localeCompare(b.name);
+    });
+  }
+  return sorted;
+}
+function filterFiles(files, patterns, include = false) {
+  return files.filter((file) => {
+    const matches = matchesIgnorePattern(file.relativePath, patterns);
+    return include ? matches : !matches;
+  });
+}
+function getDefaultIgnorePatterns() {
+  return [...DEFAULT_IGNORE_PATTERNS];
+}
+function generateHeaderComment(_format) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  const comment = `/**
+ * DSAi Design Tokens - Merged Bundle
+ * Generated: ${timestamp}
+ *
+ * This file was automatically generated and includes:
+ * - Generated design tokens
+ * - Merged additional stylesheets
+ *
+ * DO NOT EDIT DIRECTLY - changes will be overwritten on rebuild
+ */`;
+  return comment;
+}
+function generateSourceComment(source, _format) {
+  return `/* ========== Source: ${source} ========== */`;
+}
+function detectMergeIssues(content, format) {
+  const warnings = [];
+  const rootMatches = content.match(/:root\s*\{/g);
+  const rootCount = rootMatches ? rootMatches.length : 0;
+  if (rootCount > 1) {
+    warnings.push(
+      `Found ${rootCount} :root selectors. Consider consolidating for better performance.`
+    );
+  }
+  const customProps = content.match(/--[\w-]+:/g) ?? [];
+  const uniqueProps = new Set(customProps);
+  if (customProps.length > uniqueProps.size) {
+    warnings.push(
+      `Found duplicate CSS custom properties. Later definitions will override earlier ones.`
+    );
+  }
+  if (format === "scss") {
+    const importAfterContent = /@import\s+['"][^'"]+['"];?\s*$/gm;
+    if (importAfterContent.test(content)) {
+      warnings.push(`Found @import statements that may not be at the top of the file.`);
+    }
+  }
+  return warnings;
+}
+async function mergeContent(tokenContent, userContent, config = {}) {
+  const { mergeOrder = "after" } = config;
+  const parts = [];
+  const sources = ["<generated-tokens>"];
+  const warnings = [];
+  parts.push(generateHeaderComment(tokenContent.format));
+  if (mergeOrder === "before") {
+    for (const content of userContent) {
+      parts.push(generateSourceComment(content.source, tokenContent.format));
+      parts.push(content.content);
+      sources.push(content.source);
+    }
+    parts.push(generateSourceComment("<generated-tokens>", tokenContent.format));
+    parts.push(tokenContent.content);
+  } else {
+    parts.push(generateSourceComment("<generated-tokens>", tokenContent.format));
+    parts.push(tokenContent.content);
+    for (const content of userContent) {
+      parts.push(generateSourceComment(content.source, tokenContent.format));
+      parts.push(content.content);
+      sources.push(content.source);
+    }
+  }
+  const mergedContent = parts.join("\n\n");
+  warnings.push(...detectMergeIssues(mergedContent, tokenContent.format));
+  return {
+    content: mergedContent,
+    sources,
+    warnings
+  };
+}
+async function loadContent(files, type, format) {
+  const content = [];
+  for (const filePath of files) {
+    try {
+      const fileContent = await fs3.promises.readFile(filePath, "utf-8");
+      content.push({
+        source: filePath,
+        content: fileContent,
+        type,
+        format
+      });
+    } catch (error) {
+      console.warn(`Failed to load file: ${filePath}`, error);
+    }
+  }
+  return content;
+}
+function processScssImportHeader(importHeader, configDir) {
+  if (!importHeader) {
+    return "";
+  }
+  const imports = Array.isArray(importHeader) ? importHeader : [importHeader];
+  const statements = [];
+  for (const importPath of imports) {
+    if (importPath.startsWith(".") || importPath.startsWith("/")) {
+      const resolvedPath = path.resolve(configDir, importPath);
+      statements.push(`@import '${resolvedPath}';`);
+    } else {
+      statements.push(`@import '${importPath}';`);
+    }
+  }
+  return `${statements.join("\n")}
+
+`;
+}
+function addScssImportHeader(content, importHeader, configDir) {
+  const header = processScssImportHeader(importHeader, configDir);
+  if (!header) {
+    return content;
+  }
+  return header + content;
+}
+function removeSourceComments(content) {
+  return content.replace(/\/\* ========== Source: .+ ========== \*\/\n?/g, "");
+}
+function minifyContent(content) {
+  return content.replace(/\/\*(?!!)[^*]*\*+([^/*][^*]*\*+)*\//g, "").replace(/\s+/g, " ").replace(/\s*([{}:;,>+~])\s*/g, "$1").replace(/;}/g, "}").replace(/[^{}]+\{\s*\}/g, "").trim();
+}
+function detectExtension(mergeResult) {
+  const hasScssFeatures = mergeResult.content.match(/@mixin|@include|\$[a-zA-Z]/);
+  return hasScssFeatures ? ".scss" : ".css";
+}
+function generateSourcemap(sources, name, extension) {
+  const sourceMapV3 = {
+    version: 3,
+    file: `${name}${extension}`,
+    sources,
+    names: [],
+    mappings: ""
+  };
+  return JSON.stringify(sourceMapV3, null, 2);
+}
+async function createBundle(mergeResult, config) {
+  const { name, outputDir, includeSourceComments, sourcemaps, minify } = config;
+  let content = mergeResult.content;
+  if (!includeSourceComments) {
+    content = removeSourceComments(content);
+  }
+  let minifiedSize;
+  if (minify) {
+    const minified = minifyContent(content);
+    minifiedSize = Buffer.byteLength(minified, "utf-8");
+    content = minified;
+  }
+  const extension = detectExtension(mergeResult);
+  const outputPath = path.join(outputDir, `${name}${extension}`);
+  await fs3.promises.mkdir(outputDir, { recursive: true });
+  await fs3.promises.writeFile(outputPath, content, "utf-8");
+  let sourcemap;
+  if (sourcemaps) {
+    sourcemap = generateSourcemap(mergeResult.sources, name, extension);
+    const mapPath = `${outputPath}.map`;
+    await fs3.promises.writeFile(mapPath, sourcemap, "utf-8");
+    const mapRef = `
+/*# sourceMappingURL=${name}${extension}.map */`;
+    content += mapRef;
+    await fs3.promises.writeFile(outputPath, content, "utf-8");
+  }
+  return {
+    content,
+    sourcemap,
+    outputPath,
+    files: mergeResult.sources,
+    size: Buffer.byteLength(content, "utf-8"),
+    minifiedSize
+  };
+}
+async function createBundles(tokenCss, tokenScss, cssFiles, scssFiles, config) {
+  const { baseName = "tokens-bundle", ...bundleConfig } = config;
+  const results = {};
+  const sortedCss = sortFiles(cssFiles);
+  if (tokenCss || sortedCss.length > 0) {
+    const userContent = await loadContent(
+      sortedCss.map((f) => f.absolutePath),
+      "user",
+      "css"
+    );
+    const mergeResult = await mergeContent({ content: tokenCss, format: "css" }, userContent);
+    results.css = await createBundle(mergeResult, {
+      ...bundleConfig,
+      name: baseName
+    });
+  }
+  const sortedScss = sortFiles(scssFiles);
+  if (tokenScss || sortedScss.length > 0) {
+    const userContent = await loadContent(
+      sortedScss.map((f) => f.absolutePath),
+      "user",
+      "scss"
+    );
+    const mergeResult = await mergeContent({ content: tokenScss, format: "scss" }, userContent);
+    results.scss = await createBundle(mergeResult, {
+      ...bundleConfig,
+      name: `_${baseName}`
+    });
+  }
+  return results;
+}
+async function createBundleFromFiles(files, format, config) {
+  const sorted = sortFiles(files);
+  const userContent = await loadContent(
+    sorted.map((f) => f.absolutePath),
+    "user",
+    format
+  );
+  const mergeResult = await mergeContent({ content: "", format }, userContent);
+  return createBundle(mergeResult, config);
+}
+var DEFAULT_FILE_NAMES = {
+  css: "tokens.css",
+  scss: "_tokens.scss",
+  js: "tokens.js",
+  ts: "tokens.ts",
+  json: "tokens.json",
+  android: "tokens.xml",
+  ios: "Tokens.swift"
+};
+function replacePlaceholders(template, values) {
+  const now = /* @__PURE__ */ new Date();
+  const allValues = {
+    theme: values.theme ?? "default",
+    name: values.name ?? "tokens",
+    format: values.format ?? "",
+    date: values.date ?? now.toISOString().split("T")[0] ?? "",
+    timestamp: values.timestamp ?? now.toISOString()
+  };
+  let result = template;
+  for (const [key, value] of Object.entries(allValues)) {
+    result = result.replaceAll(`{${key}}`, value);
+  }
+  return result;
+}
+function resolveOutputPath(format, config, values = {}) {
+  const dir = config.formatDirs[format] ?? config.baseDir;
+  let fileName = config.fileNames[format] ?? DEFAULT_FILE_NAMES[format];
+  fileName = replacePlaceholders(fileName, values);
+  return path.join(dir, fileName);
+}
+function resolveAllOutputPaths(formats, config, values = {}) {
+  const result = {};
+  for (const format of formats) {
+    result[format] = resolveOutputPath(format, config, values);
+  }
+  return result;
+}
+function validateOutputPaths(paths) {
+  const conflicts = [];
+  const pathToFormat = {};
+  for (const [format, outputPath] of Object.entries(paths)) {
+    const normalized = path.normalize(outputPath);
+    const existingFormat = pathToFormat[normalized];
+    if (existingFormat !== void 0) {
+      conflicts.push([existingFormat, format]);
+    } else {
+      pathToFormat[normalized] = format;
+    }
+  }
+  return {
+    valid: conflicts.length === 0,
+    conflicts
+  };
+}
+async function ensureOutputDirs(paths) {
+  const directories = /* @__PURE__ */ new Set();
+  for (const outputPath of Object.values(paths)) {
+    directories.add(path.dirname(outputPath));
+  }
+  const created = [];
+  for (const dir of directories) {
+    await fs3.promises.mkdir(dir, { recursive: true });
+    created.push(dir);
+  }
+  return created;
+}
+function createOutputConfig(tokenConfig) {
+  return {
+    baseDir: tokenConfig.outputDir ?? "dist",
+    formatDirs: tokenConfig.outputDirs ?? {},
+    fileNames: tokenConfig.outputFileNames ?? {},
+    createDirs: true
+  };
+}
+
+// src/tokens/style-dictionary/types.ts
+function isSDToken(obj) {
+  if (typeof obj !== "object" || obj === null) {
+    return false;
+  }
+  const token = obj;
+  if (typeof token["name"] !== "string") {
+    return false;
+  }
+  if (!Array.isArray(token["path"])) {
+    return false;
+  }
+  return true;
+}
+function hasDTCGValue(token) {
+  return token.$value !== void 0;
+}
+function getSDTokenValue(token) {
+  return token.$value ?? token.value;
+}
+function getSDTokenType(token) {
+  return token.$type ?? token.type;
+}
+
+// src/tokens/style-dictionary/formats/css-dark-mode.ts
+var cssDarkModeVariables = {
+  name: "css/variables-dark-mode",
+  format: ({ dictionary, options }) => {
+    const prefix = options["prefix"] ?? "--";
+    const selector = options["selector"] ?? '[data-bs-theme="dark"]';
+    const variables = dictionary.allTokens.map((token) => {
+      const lines = [];
+      if (token.comment) {
+        lines.push(`  /* ${token.comment} */`);
+      }
+      const description = token.$description ?? token.description;
+      if (description && description !== token.comment) {
+        lines.push(`  /* ${description} */`);
+      }
+      const tokenValue = token.$value !== void 0 ? token.$value : token.value;
+      const value = typeof tokenValue === "string" ? tokenValue : JSON.stringify(tokenValue);
+      lines.push(`  ${prefix}${token.name}: ${value};`);
+      return lines.join("\n");
+    });
+    return `${selector} {
+${variables.join("\n")}
+}
+`;
+  }
+};
+
+// src/tokens/style-dictionary/formats/css-variables.ts
+var cssVariablesWithComments = {
+  name: "css/variables-with-comments",
+  format: ({ dictionary, options }) => {
+    const prefix = options["prefix"] ?? "--";
+    const variables = dictionary.allTokens.map((token) => {
+      const lines = [];
+      if (token.comment) {
+        lines.push(`  /* ${token.comment} */`);
+      }
+      const description = token.$description ?? token.description;
+      if (description && description !== token.comment) {
+        lines.push(`  /* ${description} */`);
+      }
+      const tokenValue = token.$value !== void 0 ? token.$value : token.value;
+      const value = typeof tokenValue === "string" ? tokenValue : JSON.stringify(tokenValue);
+      lines.push(`  ${prefix}${token.name}: ${value};`);
+      return lines.join("\n");
+    });
+    return `:root {
+${variables.join("\n")}
+}
+`;
+  }
+};
+
+// src/tokens/style-dictionary/formats/typescript.ts
+function getTypeScriptType(token) {
+  const value = token.value;
+  if (typeof value === "number") {
+    return "number";
+  }
+  if (typeof value === "boolean") {
+    return "boolean";
+  }
+  return "string";
+}
+function buildTokenInterface(obj, indent = 0) {
+  const spaces = "  ".repeat(indent);
+  let output = "{\n";
+  for (const key of Object.keys(obj)) {
+    if (key.startsWith("_")) {
+      continue;
+    }
+    const value = obj[key];
+    if (!value || typeof value !== "object") {
+      continue;
+    }
+    const quotedKey = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key) ? key : `"${key}"`;
+    const typedValue = value;
+    if (typedValue._isToken) {
+      output += `${spaces}  ${quotedKey}: ${typedValue._type};
+`;
+    } else {
+      output += `${spaces}  ${quotedKey}: ${buildTokenInterface(typedValue, indent + 1)}
+`;
+    }
+  }
+  output += `${spaces}}`;
+  return output;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+var typescriptDeclarations = {
+  name: "typescript/declarations",
+  format: ({ dictionary }) => {
+    const tokenTree = {};
+    for (const token of dictionary.allTokens) {
+      let current = tokenTree;
+      for (let i = 0; i < token.path.length - 1; i++) {
+        const key = token.path[i];
+        if (key === "__proto__" || key === "constructor" || key === "prototype") {
+          continue;
+        }
+        if (!current[key] || typeof current[key] !== "object") {
+          current[key] = {};
+        }
+        current = current[key];
+      }
+      const lastKey = token.path[token.path.length - 1];
+      if (lastKey) {
+        current[lastKey] = {
+          _isToken: true,
+          _type: getTypeScriptType(token)
+        };
+      }
+    }
+    const categories = {};
+    for (const token of dictionary.allTokens) {
+      const category = token.path[0];
+      if (category) {
+        if (!categories[category]) {
+          categories[category] = [];
+        }
+        categories[category].push(token.path.join("."));
+      }
+    }
+    let literalTypes = "";
+    for (const category of Object.keys(categories).sort()) {
+      const categoryTokens = categories[category];
+      if (!categoryTokens) {
+        continue;
+      }
+      const typeName = `${capitalize(category)}TokenName`;
+      literalTypes += `/**
+ * All ${category} token names as string literals
+ */
+`;
+      literalTypes += `export type ${typeName} =
+`;
+      literalTypes += categoryTokens.map((t) => `  | '${t}'`).join("\n");
+      literalTypes += ";\n\n";
+    }
+    const allTokenNames = dictionary.allTokens.map((t) => t.path.join("."));
+    literalTypes += `/**
+ * All token names as string literals
+ */
+`;
+    literalTypes += `export type TokenName =
+`;
+    literalTypes += allTokenNames.map((t) => `  | '${t}'`).join("\n");
+    literalTypes += ";\n\n";
+    let flatExports = "/**\n * Flat token exports (camelCase names)\n */\n";
+    for (const token of dictionary.allTokens) {
+      const type = getTypeScriptType(token);
+      flatExports += `export declare const ${token.name}: ${type};
+`;
+    }
+    return `/**
+ * Design Tokens - TypeScript Declarations
+ * Auto-generated by @dsai-io/tools
+ * DO NOT EDIT DIRECTLY
+ *
+ * @packageDocumentation
+ */
+
+// ============================================================================
+// String Literal Types (for type-safe token access)
+// ============================================================================
+
+${literalTypes}
+// ============================================================================
+// Nested Token Interface
+// ============================================================================
+
+/**
+ * Design tokens organized by category
+ */
+export interface DesignTokens ${buildTokenInterface(tokenTree)}
+
+// ============================================================================
+// Flat Token Exports
+// ============================================================================
+
+${flatExports}
+// ============================================================================
+// Default Export
+// ============================================================================
+
+export declare const tokens: DesignTokens;
+export default tokens;
+`;
+  }
+};
+
+// src/tokens/style-dictionary/formats/index.ts
+var builtInFormats = [
+  cssDarkModeVariables,
+  cssVariablesWithComments,
+  typescriptDeclarations
+];
+function registerFormats(sd, customFormats = []) {
+  const allFormats = [...builtInFormats, ...customFormats];
+  for (const format of allFormats) {
+    sd.registerFormat({
+      name: format.name,
+      format: format.format
+    });
+  }
+}
+
+// src/tokens/style-dictionary/groups/css.ts
+var cssTransformGroup = {
+  name: "custom/css",
+  transforms: [
+    "attribute/cti",
+    "name/kebab",
+    "time/seconds",
+    "fontWeight/unitless",
+    // Must run before dimension/rem
+    "lineHeight/unitless",
+    // Must run before dimension/rem
+    "dimension/rem",
+    "color/css"
+  ]
+};
+
+// src/tokens/style-dictionary/groups/js.ts
+var jsTransformGroup = {
+  name: "custom/js",
+  transforms: [
+    "attribute/cti",
+    "name/camel",
+    "fontWeight/unitless",
+    // Must run before dimension/rem
+    "lineHeight/unitless",
+    // Must run before dimension/rem
+    "dimension/rem",
+    "color/css"
+  ]
+};
+
+// src/tokens/style-dictionary/groups/scss.ts
+var scssTransformGroup = {
+  name: "custom/scss",
+  transforms: [
+    "attribute/cti",
+    // Add CTI attributes
+    "name/kebab",
+    // kebab-case names
+    "time/seconds",
+    // Convert time to seconds
+    "fontWeight/unitless",
+    // Font weights stay unitless (MUST run before dimension/rem)
+    "lineHeight/unitless",
+    // Line heights stay unitless (MUST run before dimension/rem)
+    "dimension/rem",
+    // Convert dimensions to rem
+    "color/css"
+    // Convert colors to CSS format
+  ]
+};
+
+// src/tokens/style-dictionary/groups/index.ts
+var transformGroups = [
+  cssTransformGroup,
+  jsTransformGroup,
+  scssTransformGroup
+];
+function registerTransformGroups(sd, customGroups = []) {
+  const allGroups = [...transformGroups, ...customGroups];
+  for (const group of allGroups) {
+    sd.registerTransformGroup({
+      name: group.name,
+      transforms: group.transforms
+    });
+  }
+}
+
+// src/tokens/style-dictionary/preprocessors/fix-references.ts
+var DEFAULT_PATH_MAPPINGS = [
+  ["{colors.brand.", "{color."],
+  ["{colors.neutral.", "{neutral."],
+  ["{borders.width.", "{border.width."]
+];
+function fixValue(value, mappings) {
+  if (typeof value !== "string" || !value.startsWith("{")) {
+    return value;
+  }
+  let result = value;
+  for (const mapping of mappings) {
+    result = result.split(mapping[0]).join(mapping[1]);
+  }
+  return result;
+}
+function processTokens(obj, mappings) {
+  for (const key of Object.keys(obj)) {
+    const value = obj[key];
+    if (value && typeof value === "object") {
+      const typedValue = value;
+      if ("$value" in typedValue) {
+        typedValue["$value"] = fixValue(typedValue["$value"], mappings);
+      } else if ("value" in typedValue) {
+        typedValue["value"] = fixValue(typedValue["value"], mappings);
+      } else {
+        processTokens(typedValue, mappings);
+      }
+    }
+  }
+}
+var fixReferences = {
+  name: "fix-references",
+  preprocessor: (dictionary) => {
+    processTokens(dictionary, DEFAULT_PATH_MAPPINGS);
+    return dictionary;
+  }
+};
+function createFixReferencesPreprocessor(mappings) {
+  return {
+    name: "fix-references-custom",
+    preprocessor: (dictionary) => {
+      processTokens(dictionary, mappings);
+      return dictionary;
+    }
+  };
+}
+
+// src/tokens/style-dictionary/preprocessors/index.ts
+var builtInPreprocessors = [fixReferences];
+function registerPreprocessors(sd, customPreprocessors = []) {
+  const allPreprocessors = [...builtInPreprocessors, ...customPreprocessors];
+  for (const preprocessor of allPreprocessors) {
+    sd.registerPreprocessor({
+      name: preprocessor.name,
+      preprocessor: preprocessor.preprocessor
+    });
+  }
+}
+
+// src/tokens/style-dictionary/transforms/dimension.ts
+var DEFAULT_BASE_FONT_SIZE = 16;
+function isDimension(token) {
+  const tokenType = token.$type ?? token.type;
+  if (tokenType === "fontWeight") {
+    return false;
+  }
+  const pathHasFontWeight = token.path?.some((part) => {
+    const lower = String(part).toLowerCase();
+    return lower.includes("fontweight") || lower.includes("font-weight");
+  });
+  if (pathHasFontWeight) {
+    return false;
+  }
+  if (tokenType === "lineHeight") {
+    return false;
+  }
+  const pathHasLineHeight = token.path?.some((part) => {
+    const lower = String(part).toLowerCase();
+    return lower.includes("lineheight") || lower.includes("line-height");
+  });
+  if (pathHasLineHeight) {
+    return false;
+  }
+  const scopeHasLineHeight = token.$scopes?.includes("LINE_HEIGHT");
+  if (scopeHasLineHeight) {
+    return false;
+  }
+  const pathHasGridConfig = token.path?.some((part) => {
+    const lower = String(part).toLowerCase();
+    return lower === "columns" || lower === "row-columns";
+  });
+  if (pathHasGridConfig) {
+    return false;
+  }
+  return tokenType === "dimension" || tokenType === "spacing" || tokenType === "sizing";
+}
+var dimensionRem = {
+  name: "dimension/rem",
+  type: "value",
+  filter: isDimension,
+  transform: (token, options) => {
+    const value = token.$value ?? token.value;
+    const baseFontSize = options?.basePxFontSize ?? DEFAULT_BASE_FONT_SIZE;
+    if (typeof value === "number") {
+      if (value === 0) {
+        return "0";
+      }
+      return `${value / baseFontSize}rem`;
+    }
+    if (typeof value === "string" && value.endsWith("px")) {
+      const numValue = Number.parseFloat(value);
+      if (numValue === 0) {
+        return "0";
+      }
+      return `${numValue / baseFontSize}rem`;
+    }
+    return value;
+  }
+};
+
+// src/tokens/style-dictionary/transforms/font-weight.ts
+var NAMED_WEIGHTS = {
+  thin: 100,
+  hairline: 100,
+  extralight: 200,
+  ultralight: 200,
+  light: 300,
+  normal: 400,
+  regular: 400,
+  medium: 500,
+  semibold: 600,
+  demibold: 600,
+  bold: 700,
+  extrabold: 800,
+  ultrabold: 800,
+  black: 900,
+  heavy: 900
+};
+function isFontWeight(token) {
+  const tokenType = token.$type ?? token.type;
+  if (tokenType === "fontWeight" || tokenType === "number") {
+    return true;
+  }
+  const pathHasFontWeight = token.path?.some((part) => {
+    const lower = String(part).toLowerCase();
+    return lower === "fontweight" || lower.includes("font-weight") || lower.includes("fontweight");
+  });
+  return pathHasFontWeight ?? false;
+}
+var fontWeightUnitless = {
+  name: "fontWeight/unitless",
+  type: "value",
+  filter: isFontWeight,
+  transform: (token) => {
+    const value = token.$value ?? token.value;
+    if (typeof value === "number") {
+      return value;
+    }
+    if (typeof value === "string") {
+      const parsed = Number.parseInt(value, 10);
+      if (!Number.isNaN(parsed)) {
+        return parsed;
+      }
+      const normalized = value.toLowerCase().replace(/[^a-z]/g, "");
+      if (Object.hasOwn(NAMED_WEIGHTS, normalized)) {
+        const namedWeight = NAMED_WEIGHTS[normalized];
+        if (namedWeight !== void 0) {
+          return namedWeight;
+        }
+      }
+    }
+    return value;
+  }
+};
+
+// src/tokens/style-dictionary/transforms/line-height.ts
+var DEFAULT_BASE_FONT_SIZE2 = 16;
+function isLineHeight(token) {
+  const tokenType = token.$type ?? token.type;
+  if (tokenType === "lineHeight") {
+    return true;
+  }
+  const pathHasLineHeight = token.path?.some((part) => {
+    const lower = String(part).toLowerCase();
+    return lower === "lineheight" || lower.includes("line-height") || lower.includes("lineheight");
+  });
+  const scopeHasLineHeight = token.$scopes?.includes("LINE_HEIGHT");
+  return (pathHasLineHeight ?? false) || (scopeHasLineHeight ?? false);
+}
+var lineHeightUnitless = {
+  name: "lineHeight/unitless",
+  type: "value",
+  filter: isLineHeight,
+  transform: (token) => {
+    const value = token.$value ?? token.value;
+    if (typeof value === "number") {
+      if (value <= 3) {
+        return value;
+      }
+      return value / DEFAULT_BASE_FONT_SIZE2;
+    }
+    if (typeof value === "string" && value.endsWith("%")) {
+      return Number.parseFloat(value) / 100;
+    }
+    if (typeof value === "string") {
+      const numValue = Number.parseFloat(value);
+      if (!Number.isNaN(numValue)) {
+        if (numValue <= 3) {
+          return numValue;
+        }
+        return numValue / DEFAULT_BASE_FONT_SIZE2;
+      }
+    }
+    return value;
+  }
+};
+
+// src/tokens/style-dictionary/transforms/name.ts
+var nameKebab = {
+  name: "name/kebab",
+  type: "name",
+  transform: (token) => {
+    return token.path.join("-").replace(/_/g, "-").toLowerCase();
+  }
+};
+
+// src/tokens/style-dictionary/transforms/index.ts
+var builtInTransforms = [
+  fontWeightUnitless,
+  lineHeightUnitless,
+  dimensionRem,
+  nameKebab
+];
+function registerTransforms(sd, customTransforms = []) {
+  const allTransforms = [...builtInTransforms, ...customTransforms];
+  for (const transform of allTransforms) {
+    sd.registerTransform({
+      name: transform.name,
+      type: transform.type,
+      filter: transform.filter,
+      transform: transform.transform
+    });
+  }
+}
+
+// src/tokens/style-dictionary/config.ts
+var DEFAULT_SOURCE_PATTERNS = [
+  "collections/color/*.json",
+  "collections/typography/*.json",
+  "collections/spacing/*.json",
+  "collections/border/*.json",
+  "collections/shadow/*.json",
+  "collections/layout/*.json"
+];
+var DEFAULT_PLATFORMS = ["css", "js", "ts", "scss", "scss-dist", "json"];
+function createStyleDictionaryConfig(dsaiConfig, options = {}) {
+  const {
+    source = DEFAULT_SOURCE_PATTERNS,
+    prefix = dsaiConfig.tokens.prefix,
+    buildPath = dsaiConfig.tokens.outputDir,
+    baseFontSize = dsaiConfig.tokens.baseFontSize ?? 16,
+    outputReferences = dsaiConfig.tokens.outputReferences ?? true,
+    platforms = DEFAULT_PLATFORMS,
+    verbose = dsaiConfig.global.debug ?? false
+  } = options;
+  const config = {
+    log: {
+      verbosity: verbose ? "verbose" : "default",
+      warnings: "warn",
+      errors: "error"
+    },
+    preprocessors: ["fix-references"],
+    source,
+    platforms: {}
+  };
+  const normalizedBuildPath = buildPath.endsWith("/") ? buildPath : `${buildPath}/`;
+  const platformConfigs = config.platforms ?? {};
+  if (platforms.includes("css")) {
+    platformConfigs["css"] = {
+      transformGroup: "custom/css",
+      buildPath: `${normalizedBuildPath}css/`,
+      files: [
+        {
+          destination: "variables.css",
+          format: "css/variables-with-comments",
+          options: {
+            prefix,
+            outputReferences
+          }
+        }
+      ]
+    };
+  }
+  if (platforms.includes("js")) {
+    platformConfigs["js"] = {
+      transformGroup: "custom/js",
+      buildPath: `${normalizedBuildPath}js/`,
+      files: [
+        {
+          destination: "tokens.js",
+          format: "javascript/es6",
+          options: { outputReferences }
+        },
+        {
+          destination: "tokens.cjs",
+          format: "javascript/module",
+          options: { outputReferences }
+        }
+      ]
+    };
+  }
+  if (platforms.includes("ts")) {
+    platformConfigs["ts"] = {
+      transformGroup: "custom/js",
+      buildPath: `${normalizedBuildPath}ts/`,
+      files: [
+        {
+          destination: "tokens.ts",
+          format: "javascript/es6",
+          options: { outputReferences }
+        },
+        {
+          destination: "tokens.d.ts",
+          format: "typescript/declarations"
+        }
+      ]
+    };
+  }
+  if (platforms.includes("scss")) {
+    platformConfigs["scss"] = {
+      transformGroup: "custom/scss",
+      buildPath: "src/scss/",
+      files: [
+        {
+          destination: "_variables.scss",
+          format: "scss/variables",
+          options: {
+            outputReferences,
+            basePxFontSize: baseFontSize
+          }
+        }
+      ]
+    };
+  }
+  if (platforms.includes("scss-dist")) {
+    platformConfigs["scss-dist"] = {
+      transformGroup: "custom/scss",
+      buildPath: `${normalizedBuildPath}scss/`,
+      files: [
+        {
+          destination: "_variables.scss",
+          format: "scss/variables",
+          options: {
+            outputReferences,
+            basePxFontSize: baseFontSize
+          }
+        }
+      ]
+    };
+  }
+  if (platforms.includes("json")) {
+    platformConfigs["json"] = {
+      transformGroup: "js",
+      buildPath: `${normalizedBuildPath}json/`,
+      files: [
+        { destination: "tokens.json", format: "json/flat" },
+        { destination: "tokens-nested.json", format: "json/nested" }
+      ]
+    };
+  }
+  config.platforms = platformConfigs;
+  return config;
+}
+function registerAll(sd, options = {}) {
+  const { customTransforms = [], customFormats = [], customPreprocessors = [] } = options;
+  registerTransforms(sd, customTransforms);
+  registerTransformGroups(sd);
+  registerFormats(sd, customFormats);
+  registerPreprocessors(sd, customPreprocessors);
+}
+function setupStyleDictionary(sd, dsaiConfig, options = {}) {
+  registerAll(sd, options);
+  return createStyleDictionaryConfig(dsaiConfig, options);
+}
+
+export { DEFAULT_CLEAN_DIRECTORIES, DEFAULT_FILE_NAMES, VALID_TOKEN_TYPES, addScssImportHeader, buildTokens, buildTokensCLI, builtInFormats, builtInPreprocessors, builtInTransforms, cleanTokenOutputs, cleanTokensCLI, createBundle, createBundleFromFiles, createBundles, createFixReferencesPreprocessor, createOutputConfig, createStyleDictionaryConfig, cssTransformGroup, cssVariablesWithComments, detectModes as detectFigmaModes, detectModes2 as detectTransformModes, dimensionRem, ensureOutputDirs, filterFiles, fixReferences, fontWeightUnitless, getDefaultCssDir, getDefaultFiles, getDefaultIgnorePatterns, getDefaultSyncPaths, getDefaultTransformations, getSDTokenType, getSDTokenValue, getTokenDescription, getTokenType, getTokenValue, hasDTCGValue, isDTCGToken, isLegacyToken, isSDToken, isToken, isTokenReference, isValidTokenType, jsTransformGroup, lineHeightUnitless, loadContent, mergeCollections, mergeCollectionsCLI, mergeContent, nameKebab, parseTokenReference, postprocessCLI, postprocessCss, postprocessCssFiles, processScssImportHeader, registerAll, registerFormats, registerPreprocessors, registerTransformGroups, registerTransforms, replacePlaceholders, resolveAllOutputPaths, resolveOutputPath, runBuildCLI, scanDirectories, scssTransformGroup, setupStyleDictionary, sortFiles, syncTokens, syncTokensCLI, toDTCGToken, transformGroups, transformToken, transformTokenTree, transformTokens, transformTokensCLI, transformType, transformValue, typescriptDeclarations, validateFigmaCLI, validateFigmaExports, validateFigmaFile, validateOutputPaths, validateTokens, validateTokensCLI };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map