@dsai-io/tools 0.0.1

package/dist/tokens/index.cjs

@@ -0,0 +1,3787 @@
+'use strict';
+
+var fs3 = require('fs');
+var path = require('path');
+var child_process = require('child_process');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var fs3__namespace = /*#__PURE__*/_interopNamespace(fs3);
+var path__namespace = /*#__PURE__*/_interopNamespace(path);
+
+/* @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 = fs3.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 (!fs3.existsSync(dir)) {
+    return files;
+  }
+  const entries = fs3.readdirSync(dir);
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry);
+    const stat = fs3.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 (!fs3.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 = path.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 (!fs3.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 = fs3.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 = path.basename(filePath, path.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 (!fs3.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 = path.join(targetDir, expectedCollection.input);
+    if (!fs3.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 = fs3.readdirSync(targetDir).filter(
+      (f) => f.endsWith(".json") && fs3.statSync(path.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: 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 = path.dirname(filePath);
+  if (!fs3.existsSync(dir)) {
+    fs3.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 = path.join(exportsDir, "theme.json");
+  const collectionFile = path.join(exportsDir, collectionConfig.input);
+  {
+    if (fs3.existsSync(themeFile)) {
+      return themeFile;
+    }
+    if (fs3.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 = path.join(sourceDir, "theme.json");
+  if (fs3.existsSync(themeFile)) {
+    try {
+      const content = fs3.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 (!fs3.existsSync(inputPath)) {
+      warnings.push(`Input file not found: ${inputPath}`);
+      continue;
+    }
+    let data;
+    try {
+      const content = fs3.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 = path.extname(output.file);
+          const base = path.basename(output.file, ext);
+          const dir = path.dirname(output.file);
+          if (mode !== defaultMode) {
+            outputFile = path.join(dir, `${base}-${mode.toLowerCase()}${ext}`);
+          }
+        }
+        const outputPath = path.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);
+            fs3.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: path.join(tokensDir, DEFAULT_SOURCE_RELATIVE),
+    targetFile: path.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 (!fs3.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 = fs3.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 (fs3.existsSync(targetFile)) {
+    try {
+      const existingContent = fs3.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 = path.dirname(targetFile);
+      if (!fs3.existsSync(targetDir)) {
+        fs3.mkdirSync(targetDir, { recursive: true });
+      }
+      fs3.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 (!fs3.existsSync(inputFile)) {
+    return {
+      success: false,
+      replacementsMade: 0,
+      outputFile,
+      errors: [`File not found: ${inputFile}`]
+    };
+  }
+  let content;
+  try {
+    content = fs3.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 {
+      fs3.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 = path.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 = path.join(tokensDir, DEFAULT_CSS_DIR);
+  const result = postprocessCssFiles({
+    cssDir,
+    verbose: true
+  });
+  return result.success;
+}
+function getDefaultCssDir(tokensDir) {
+  return path.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 {
+      child_process.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") ? path.dirname(tokensDir) : path.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 (!fs3.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 (!fs3.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 = path.resolve(dirPath);
+  const resolvedBase = path.resolve(baseDir);
+  if (!resolvedDir.startsWith(resolvedBase)) {
+    return {
+      valid: false,
+      error: `Directory "${dirPath}" is outside base directory "${baseDir}"`
+    };
+  }
+  const dirName = path.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 (!fs3.existsSync(dirPath)) {
+    return { files: 0, dirs: 0 };
+  }
+  let files = 0;
+  let dirs = 0;
+  const entries = fs3.readdirSync(dirPath, { withFileTypes: true });
+  for (const entry of entries) {
+    if (entry.isDirectory()) {
+      dirs++;
+      const subCounts = countContents(path.join(dirPath, entry.name));
+      files += subCounts.files;
+      dirs += subCounts.dirs;
+    } else {
+      files++;
+    }
+  }
+  return { files, dirs };
+}
+function cleanDirectory(dirPath, options) {
+  const existed = fs3.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 = fs3.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 = path.join(dirPath, entry.name);
+      fs3.rmSync(entryPath, { recursive: true, force: true });
+    }
+  } else {
+    fs3.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 = path.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 = path.resolve(filePath);
+    if (verbose) {
+      console.info(`\u{1F4D6} Reading: ${fullPath}`);
+    }
+    const content = fs3.readFileSync(fullPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveJSON(filePath, data, verbose) {
+  try {
+    const fullPath = path.resolve(filePath);
+    const content = JSON.stringify(data, null, 2);
+    fs3.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 (!fs3.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__namespace.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__namespace.promises.readdir(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const entryPath = path__namespace.join(dir, entry.name);
+      const relativePath = path__namespace.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__namespace.promises.stat(entryPath);
+        files.push({
+          absolutePath: entryPath,
+          relativePath,
+          name: path__namespace.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__namespace.resolve(dir);
+    try {
+      const stat = await fs3__namespace.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__namespace.dirname(a.relativePath);
+      const dirB = path__namespace.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__namespace.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__namespace.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__namespace.join(outputDir, `${name}${extension}`);
+  await fs3__namespace.promises.mkdir(outputDir, { recursive: true });
+  await fs3__namespace.promises.writeFile(outputPath, content, "utf-8");
+  let sourcemap;
+  if (sourcemaps) {
+    sourcemap = generateSourcemap(mergeResult.sources, name, extension);
+    const mapPath = `${outputPath}.map`;
+    await fs3__namespace.promises.writeFile(mapPath, sourcemap, "utf-8");
+    const mapRef = `
+/*# sourceMappingURL=${name}${extension}.map */`;
+    content += mapRef;
+    await fs3__namespace.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__namespace.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__namespace.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__namespace.dirname(outputPath));
+  }
+  const created = [];
+  for (const dir of directories) {
+    await fs3__namespace.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);
+}
+
+exports.DEFAULT_CLEAN_DIRECTORIES = DEFAULT_CLEAN_DIRECTORIES;
+exports.DEFAULT_FILE_NAMES = DEFAULT_FILE_NAMES;
+exports.VALID_TOKEN_TYPES = VALID_TOKEN_TYPES;
+exports.addScssImportHeader = addScssImportHeader;
+exports.buildTokens = buildTokens;
+exports.buildTokensCLI = buildTokensCLI;
+exports.builtInFormats = builtInFormats;
+exports.builtInPreprocessors = builtInPreprocessors;
+exports.builtInTransforms = builtInTransforms;
+exports.cleanTokenOutputs = cleanTokenOutputs;
+exports.cleanTokensCLI = cleanTokensCLI;
+exports.createBundle = createBundle;
+exports.createBundleFromFiles = createBundleFromFiles;
+exports.createBundles = createBundles;
+exports.createFixReferencesPreprocessor = createFixReferencesPreprocessor;
+exports.createOutputConfig = createOutputConfig;
+exports.createStyleDictionaryConfig = createStyleDictionaryConfig;
+exports.cssTransformGroup = cssTransformGroup;
+exports.cssVariablesWithComments = cssVariablesWithComments;
+exports.detectFigmaModes = detectModes;
+exports.detectTransformModes = detectModes2;
+exports.dimensionRem = dimensionRem;
+exports.ensureOutputDirs = ensureOutputDirs;
+exports.filterFiles = filterFiles;
+exports.fixReferences = fixReferences;
+exports.fontWeightUnitless = fontWeightUnitless;
+exports.getDefaultCssDir = getDefaultCssDir;
+exports.getDefaultFiles = getDefaultFiles;
+exports.getDefaultIgnorePatterns = getDefaultIgnorePatterns;
+exports.getDefaultSyncPaths = getDefaultSyncPaths;
+exports.getDefaultTransformations = getDefaultTransformations;
+exports.getSDTokenType = getSDTokenType;
+exports.getSDTokenValue = getSDTokenValue;
+exports.getTokenDescription = getTokenDescription;
+exports.getTokenType = getTokenType;
+exports.getTokenValue = getTokenValue;
+exports.hasDTCGValue = hasDTCGValue;
+exports.isDTCGToken = isDTCGToken;
+exports.isLegacyToken = isLegacyToken;
+exports.isSDToken = isSDToken;
+exports.isToken = isToken;
+exports.isTokenReference = isTokenReference;
+exports.isValidTokenType = isValidTokenType;
+exports.jsTransformGroup = jsTransformGroup;
+exports.lineHeightUnitless = lineHeightUnitless;
+exports.loadContent = loadContent;
+exports.mergeCollections = mergeCollections;
+exports.mergeCollectionsCLI = mergeCollectionsCLI;
+exports.mergeContent = mergeContent;
+exports.nameKebab = nameKebab;
+exports.parseTokenReference = parseTokenReference;
+exports.postprocessCLI = postprocessCLI;
+exports.postprocessCss = postprocessCss;
+exports.postprocessCssFiles = postprocessCssFiles;
+exports.processScssImportHeader = processScssImportHeader;
+exports.registerAll = registerAll;
+exports.registerFormats = registerFormats;
+exports.registerPreprocessors = registerPreprocessors;
+exports.registerTransformGroups = registerTransformGroups;
+exports.registerTransforms = registerTransforms;
+exports.replacePlaceholders = replacePlaceholders;
+exports.resolveAllOutputPaths = resolveAllOutputPaths;
+exports.resolveOutputPath = resolveOutputPath;
+exports.runBuildCLI = runBuildCLI;
+exports.scanDirectories = scanDirectories;
+exports.scssTransformGroup = scssTransformGroup;
+exports.setupStyleDictionary = setupStyleDictionary;
+exports.sortFiles = sortFiles;
+exports.syncTokens = syncTokens;
+exports.syncTokensCLI = syncTokensCLI;
+exports.toDTCGToken = toDTCGToken;
+exports.transformGroups = transformGroups;
+exports.transformToken = transformToken;
+exports.transformTokenTree = transformTokenTree;
+exports.transformTokens = transformTokens;
+exports.transformTokensCLI = transformTokensCLI;
+exports.transformType = transformType;
+exports.transformValue = transformValue;
+exports.typescriptDeclarations = typescriptDeclarations;
+exports.validateFigmaCLI = validateFigmaCLI;
+exports.validateFigmaExports = validateFigmaExports;
+exports.validateFigmaFile = validateFigmaFile;
+exports.validateOutputPaths = validateOutputPaths;
+exports.validateTokens = validateTokens;
+exports.validateTokensCLI = validateTokensCLI;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map