dispersa 1.2.0 → 1.3.0

package/dist/outputs/index.js

@@ -0,0 +1,3730 @@
+import { converter, formatHex8, formatHex } from 'culori';
+import prettier from 'prettier';
+import { kebabCase } from 'change-case';
+
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/shared/errors/index.ts
+var DispersaError, ConfigurationError, BasePermutationError;
+var init_errors = __esm({
+  "src/shared/errors/index.ts"() {
+    DispersaError = class extends Error {
+      constructor(message) {
+        super(message);
+        this.name = "DispersaError";
+        if (typeof Error.captureStackTrace === "function") {
+          Error.captureStackTrace(this, this.constructor);
+        }
+      }
+    };
+    ConfigurationError = class extends DispersaError {
+      constructor(message) {
+        super(message);
+        this.name = "ConfigurationError";
+      }
+    };
+    BasePermutationError = class extends DispersaError {
+      constructor(message = "Base permutation determination failed. Define a default modifier in resolver.") {
+        super(message);
+        this.name = "BasePermutationError";
+      }
+    };
+  }
+});
+
+// src/shared/utils/token-utils.ts
+function stripInternalTokenMetadata(tokens) {
+  const cleaned = {};
+  for (const [name, token] of Object.entries(tokens)) {
+    const { _isAlias: _alias, _sourceModifier: _source, _sourceSet, ...rest } = token;
+    cleaned[name] = rest;
+  }
+  return cleaned;
+}
+function getSortedTokenEntries(tokens) {
+  return Object.entries(tokens).sort(([nameA], [nameB]) => nameA.localeCompare(nameB));
+}
+function buildNestedTokenObject(tokens, extractValue) {
+  const result = {};
+  for (const [, token] of getSortedTokenEntries(tokens)) {
+    setNestedValue(result, token.path, extractValue(token));
+  }
+  return result;
+}
+function setNestedValue(root, path, value) {
+  let current = root;
+  for (let i = 0; i < path.length - 1; i++) {
+    const part = path[i];
+    if (part == null) {
+      continue;
+    }
+    if (!(part in current)) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  const lastPart = path[path.length - 1];
+  if (lastPart != null) {
+    current[lastPart] = value;
+  }
+}
+function getPureAliasReferenceName(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const match = /^\{([^}]+)\}$/.exec(value);
+  return match?.[1]?.trim();
+}
+var init_token_utils = __esm({
+  "src/shared/utils/token-utils.ts"() {
+  }
+});
+
+// src/outputs/utils.ts
+function sanitizeDataAttributeName(value) {
+  return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
+}
+function escapeCssString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r?\n/g, " ");
+}
+function groupTokensByType(tokens, typeGroupMap) {
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const [, token] of getSortedTokenEntries(tokens)) {
+    const groupName = typeGroupMap[token.$type ?? ""] ?? "Other";
+    const existing = groupMap.get(groupName) ?? [];
+    existing.push(token);
+    groupMap.set(groupName, existing);
+  }
+  return Array.from(groupMap.entries()).map(([name, groupTokens]) => ({
+    name,
+    tokens: groupTokens
+  }));
+}
+function indentStr(width, level) {
+  return " ".repeat(width * level);
+}
+function buildGeneratedFileHeader() {
+  return [
+    "// Generated by Dispersa - do not edit manually",
+    "// https://github.com/dispersa-core/dispersa"
+  ].join("\n");
+}
+function toSafeIdentifier(name, keywords, capitalize) {
+  const camel = name.replace(/[-._]+(.)/g, (_, c) => c.toUpperCase()).replace(/[-._]+$/g, "").replace(/^[-._]+/g, "");
+  const cased = capitalize ? camel.charAt(0).toUpperCase() + camel.slice(1) : camel.charAt(0).toLowerCase() + camel.slice(1);
+  const safe = /^\d/.test(cased) ? `_${cased}` : cased;
+  const keyCheck = capitalize ? safe.charAt(0).toLowerCase() + safe.slice(1) : safe;
+  return keywords.has(keyCheck) ? `\`${safe}\`` : safe;
+}
+function normalizeModifierInputs(inputs) {
+  const normalized = {};
+  for (const [key, value] of Object.entries(inputs)) {
+    normalized[key.toLowerCase()] = value.toLowerCase();
+  }
+  return normalized;
+}
+function assertFileRequired(buildPath, outputFile, outputName, presetLabel) {
+  const requiresFile = buildPath !== void 0 && buildPath !== "";
+  if (!outputFile && requiresFile) {
+    throw new ConfigurationError(
+      `Output "${outputName}": file is required for ${presetLabel} output`
+    );
+  }
+}
+function buildStablePermutationKey(modifierInputs, dimensions) {
+  return dimensions.map((dimension) => `${dimension}=${modifierInputs[dimension] ?? ""}`).join("|");
+}
+function resolveSelector(selector, modifierName, context, isBase, allModifierInputs) {
+  if (typeof selector === "function") {
+    return selector(modifierName, context, isBase, allModifierInputs);
+  }
+  if (typeof selector === "string") {
+    return selector;
+  }
+  if (isBase) {
+    return ":root";
+  }
+  const attrName = sanitizeDataAttributeName(modifierName);
+  const attrValue = escapeCssString(context);
+  return `[data-${attrName}="${attrValue}"]`;
+}
+function resolveMediaQuery(mediaQuery, modifierName, context, isBase, allModifierInputs) {
+  if (typeof mediaQuery === "function") {
+    return mediaQuery(modifierName, context, isBase, allModifierInputs);
+  }
+  if (typeof mediaQuery === "string") {
+    return mediaQuery;
+  }
+  return "";
+}
+function stripInternalMetadata(tokens) {
+  return stripInternalTokenMetadata(tokens);
+}
+function generatePermutationKey(modifierInputs, resolver, isBase) {
+  if (isBase) {
+    return "base";
+  }
+  const metadata = buildMetadata(resolver);
+  const normalizedInputs = normalizeModifierInputs(modifierInputs);
+  const defaults = metadata.defaults;
+  const differences = [];
+  for (const dimension of metadata.dimensions) {
+    const value = normalizedInputs[dimension];
+    if (value !== void 0 && value !== defaults[dimension]) {
+      differences.push({ name: dimension, value });
+    }
+  }
+  if (differences.length === 1 && differences[0]) {
+    const diff = differences[0];
+    return `${diff.name}-${diff.value}`;
+  }
+  return buildStablePermutationKey(normalizedInputs, metadata.dimensions);
+}
+function isBasePermutation(modifierInputs, defaults) {
+  const normalizedInputs = normalizeModifierInputs(modifierInputs);
+  const normalizedDefaults = normalizeModifierInputs(defaults);
+  return Object.entries(normalizedDefaults).every(([key, value]) => normalizedInputs[key] === value);
+}
+function buildInMemoryOutputKey(params) {
+  const { outputName, extension, modifierInputs, resolver, defaults } = params;
+  const permutationKey = generatePermutationKey(
+    modifierInputs,
+    resolver,
+    isBasePermutation(modifierInputs, defaults)
+  );
+  return `${outputName}-${permutationKey}.${extension}`;
+}
+function buildMetadata(resolver) {
+  const metadata = {
+    dimensions: [],
+    defaults: {}
+  };
+  if (resolver.modifiers) {
+    for (const [name, modifier] of Object.entries(resolver.modifiers)) {
+      const normalizedName = name.toLowerCase();
+      const defaultContext = modifier.default ?? Object.keys(modifier.contexts)[0] ?? "";
+      metadata.dimensions.push(normalizedName);
+      metadata.defaults[normalizedName] = defaultContext.toLowerCase();
+    }
+  }
+  return metadata;
+}
+function countModifierDifferences(currentInputs, baseInputs) {
+  const normalizedCurrent = normalizeModifierInputs(currentInputs);
+  const normalizedBase = normalizeModifierInputs(baseInputs);
+  let count = 0;
+  for (const [key, value] of Object.entries(normalizedCurrent)) {
+    if (value !== normalizedBase[key]) {
+      count++;
+    }
+  }
+  return count;
+}
+function getExpectedSource(currentInputs, baseInputs) {
+  const normalizedCurrent = normalizeModifierInputs(currentInputs);
+  const normalizedBase = normalizeModifierInputs(baseInputs);
+  for (const [key, value] of Object.entries(normalizedCurrent)) {
+    if (value !== normalizedBase[key]) {
+      return `${key}-${value}`;
+    }
+  }
+  return "base";
+}
+function parseModifierSource(source) {
+  const dashIndex = source.indexOf("-");
+  if (dashIndex === -1) {
+    return [source, ""];
+  }
+  return [source.slice(0, dashIndex), source.slice(dashIndex + 1)];
+}
+function filterTokensBySource(tokens, expectedSource) {
+  const filtered = {};
+  const expected = expectedSource.toLowerCase();
+  for (const [name, token] of Object.entries(tokens)) {
+    const source = typeof token._sourceModifier === "string" ? token._sourceModifier.toLowerCase() : "";
+    if (source !== "" && source === expected) {
+      filtered[name] = token;
+    }
+  }
+  return filtered;
+}
+function filterTokensFromSets(tokens) {
+  const filtered = {};
+  for (const [name, token] of Object.entries(tokens)) {
+    const hasModifierSource = typeof token._sourceModifier === "string" && token._sourceModifier !== "";
+    if (!hasModifierSource) {
+      filtered[name] = token;
+    }
+  }
+  return filtered;
+}
+function resolveBaseFileName(fileName, defaults) {
+  if (typeof fileName === "function") {
+    return fileName({ ...defaults, _base: "true" });
+  }
+  if (/\{.+?\}/.test(fileName)) {
+    const baseInputs = Object.fromEntries(Object.keys(defaults).map((k) => [k, "base"]));
+    return collapseBaseSegments(interpolatePattern(fileName, baseInputs));
+  }
+  const extMatch = fileName.match(/(\.[^.]+)$/);
+  const extension = extMatch ? extMatch[1] : "";
+  const baseName = extension ? fileName.slice(0, -extension.length) : fileName;
+  return `${baseName}-base${extension}`;
+}
+function collapseBaseSegments(value) {
+  let result = value;
+  let previous = "";
+  while (result !== previous) {
+    previous = result;
+    result = result.replace(/\bbase([/-])base\b/, "base");
+  }
+  return result;
+}
+function interpolatePattern(pattern, modifierInputs) {
+  let result = pattern;
+  for (const [key, value] of Object.entries(modifierInputs)) {
+    result = result.replaceAll(`{${key}}`, value);
+  }
+  return result;
+}
+function resolveFileName(fileName, modifierInputs) {
+  if (typeof fileName === "function") {
+    return fileName(modifierInputs);
+  }
+  if (/\{.+?\}/.test(fileName)) {
+    return interpolatePattern(fileName, modifierInputs);
+  }
+  const extMatch = fileName.match(/(\.[^.]+)$/);
+  const extension = extMatch ? extMatch[1] : "";
+  const baseName = extension ? fileName.slice(0, -extension.length) : fileName;
+  const modifierSuffix = Object.entries(modifierInputs).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, value]) => `${key}-${value}`).join("-");
+  if (modifierSuffix) {
+    return `${baseName}-${modifierSuffix}${extension}`;
+  }
+  return fileName;
+}
+var init_utils = __esm({
+  "src/outputs/utils.ts"() {
+    init_errors();
+    init_token_utils();
+  }
+});
+
+// src/outputs/metadata.ts
+function sanitizeText(text, format) {
+  switch (format) {
+    case "css":
+    case "tailwind":
+      return text.replace(/\*\//g, "*\\/").replace(/\r?\n/g, " ").trim();
+    case "kotlin":
+      return text.replace(/\*\//g, "* /").replace(/\r?\n/g, " ").trim();
+    case "js":
+    case "swift":
+      return text.replace(/\r?\n/g, " ").trim();
+    default:
+      return text.trim();
+  }
+}
+function buildDeprecationText(token) {
+  if (token.$deprecated == null || token.$deprecated === false) {
+    return "";
+  }
+  const msg = typeof token.$deprecated === "string" ? token.$deprecated : "";
+  return msg ? `DEPRECATED: ${msg}` : "DEPRECATED";
+}
+function buildTokenDescriptionComment(token, format) {
+  if (!token.$description || token.$description === "") {
+    return void 0;
+  }
+  const text = sanitizeText(token.$description, format);
+  switch (format) {
+    case "css":
+    case "tailwind":
+      return `/* ${text} */`;
+    case "js":
+      return `// ${text}`;
+    case "swift":
+      return `/// ${text}`;
+    case "kotlin":
+      return `/** ${text} */`;
+    default:
+      return void 0;
+  }
+}
+function buildTokenDeprecationComment(token, format) {
+  const text = buildDeprecationText(token);
+  if (!text) {
+    return void 0;
+  }
+  switch (format) {
+    case "css":
+    case "tailwind":
+      return `/* ${text} */`;
+    case "js":
+      return `// ${text}`;
+    case "swift":
+      return `/// ${text}`;
+    case "kotlin":
+      return `/** ${text} */`;
+    default:
+      return void 0;
+  }
+}
+function buildModifierComment(modifier, context) {
+  return `/* Modifier: ${modifier}=${context} */`;
+}
+function buildSwiftDeprecationAttribute(token) {
+  if (token.$deprecated == null || token.$deprecated === false) {
+    return void 0;
+  }
+  const msg = typeof token.$deprecated === "string" ? token.$deprecated : "";
+  if (msg) {
+    return `@available(*, deprecated, message: "${sanitizeText(msg, "swift")}")`;
+  }
+  return "@available(*, deprecated)";
+}
+function buildKotlinDeprecationAnnotation(token) {
+  if (token.$deprecated == null || token.$deprecated === false) {
+    return void 0;
+  }
+  const msg = typeof token.$deprecated === "string" ? token.$deprecated : "";
+  if (msg) {
+    return `@Deprecated(message = "${sanitizeText(msg, "kotlin")}")`;
+  }
+  return "@Deprecated";
+}
+var init_metadata = __esm({
+  "src/outputs/metadata.ts"() {
+  }
+});
+
+// src/outputs/js/presets/bundle.ts
+var bundle_exports = {};
+__export(bundle_exports, {
+  bundleAsJsModule: () => bundleAsJsModule
+});
+function updateStringTracking(state, char) {
+  if (!state.escaped && (char === '"' || char === "'" || char === "`")) {
+    if (!state.inString) {
+      state.inString = true;
+      state.stringChar = char;
+    } else if (char === state.stringChar) {
+      state.inString = false;
+      state.stringChar = "";
+    }
+  }
+  state.escaped = !state.escaped && char === "\\";
+}
+function extractObjectFromJsModule(formattedJs) {
+  const assignmentMatch = /const\s+\w+\s*=\s*\{/.exec(formattedJs);
+  if (!assignmentMatch) {
+    return "{}";
+  }
+  const startIndex = assignmentMatch.index + assignmentMatch[0].length - 1;
+  const state = { inString: false, stringChar: "", escaped: false };
+  let braceCount = 0;
+  for (let i = startIndex; i < formattedJs.length; i++) {
+    const char = formattedJs[i];
+    updateStringTracking(state, char);
+    if (state.inString) {
+      continue;
+    }
+    if (char === "{") {
+      braceCount++;
+    } else if (char === "}") {
+      braceCount--;
+      if (braceCount === 0) {
+        return formattedJs.substring(startIndex, i + 1);
+      }
+    }
+  }
+  return "{}";
+}
+function toCamelKey(key) {
+  if (key === "") {
+    return "";
+  }
+  return key.split("-").filter((part) => part !== "").map((w, i) => i === 0 ? w : w.charAt(0).toUpperCase() + w.slice(1)).join("");
+}
+function buildStableDashKey(params) {
+  const { modifierInputs, dimensions, defaults } = params;
+  const inputs = normalizeModifierInputs(modifierInputs);
+  return dimensions.map((dimension) => {
+    const value = inputs[dimension] ?? defaults[dimension] ?? "";
+    return String(value);
+  }).join("-");
+}
+function buildHelperFunction(dimensions) {
+  const dimensionOrder = dimensions.map((d) => JSON.stringify(d)).join(", ");
+  return [
+    `/**`,
+    ` * Get tokens for a specific modifier combination`,
+    ` * @param {Object} modifiers - Modifier values (e.g., { theme: 'dark', brand: 'partner-a' })`,
+    ` * @returns {Object} Resolved tokens for the combination`,
+    ` */`,
+    `export function getTokens(modifiers = {}) {`,
+    `  const key = [${dimensionOrder}]`,
+    `    .map(dim => modifiers[dim] ?? tokenBundle._meta.defaults[dim])`,
+    `    .join('-')`,
+    `  const camelKey = key`,
+    `    .split('-')`,
+    `    .filter(Boolean)`,
+    `    .map((w, i) => (i === 0 ? w : w.charAt(0).toUpperCase() + w.slice(1)))`,
+    `    .join('')`,
+    `  return tokenBundle.tokens[camelKey]`,
+    `}`,
+    ``,
+    ``
+  ].join("\n");
+}
+function assembleJsBundle(metadata, jsBlocks, generateHelper) {
+  let output = `const tokenBundle = {
+`;
+  output += `  _meta: ${JSON.stringify(metadata, null, 2).replace(/\n/g, "\n  ")},
+`;
+  output += `  tokens: {
+${jsBlocks.join(",\n")}
+  }
+`;
+  output += `}
+
+`;
+  if (generateHelper) {
+    output += buildHelperFunction(metadata.dimensions);
+  }
+  output += `export default tokenBundle
+`;
+  return output;
+}
+async function bundleAsJsModule(bundleData, resolver, options, formatTokens) {
+  if (!formatTokens) {
+    throw new ConfigurationError("JS formatter was not provided");
+  }
+  const metadata = buildMetadata(resolver);
+  const jsBlocks = [];
+  for (const { tokens, modifierInputs, isBase } of bundleData) {
+    const cleanTokens = stripInternalMetadata(tokens);
+    const key = buildStableDashKey({
+      modifierInputs,
+      dimensions: metadata.dimensions,
+      defaults: metadata.defaults
+    });
+    const camelKey = toCamelKey(key);
+    const normalizedInputs = normalizeModifierInputs(modifierInputs);
+    const modifierParts = [];
+    for (const dim of metadata.dimensions) {
+      const value = normalizedInputs[dim.toLowerCase()];
+      if (value) {
+        modifierParts.push(`${dim}=${value}`);
+      }
+    }
+    const formattedJs = await formatTokens(cleanTokens);
+    const tokenObject = extractObjectFromJsModule(formattedJs);
+    const indentedObject = tokenObject.replace(/\n/g, "\n  ");
+    let comment;
+    if (modifierParts.length > 0) {
+      const modifierPart = modifierParts[0];
+      const eqIndex = modifierPart.indexOf("=");
+      const modifier = modifierPart.slice(0, eqIndex);
+      const context = modifierPart.slice(eqIndex + 1);
+      comment = buildModifierComment(modifier, context);
+    } else if (isBase) {
+      comment = "// Base permutation";
+    } else {
+      comment = `// ${key}`;
+    }
+    jsBlocks.push(`  ${comment}
+  ${JSON.stringify(camelKey)}: ${indentedObject}`);
+  }
+  return assembleJsBundle(metadata, jsBlocks, options?.generateHelper ?? false);
+}
+var init_bundle = __esm({
+  "src/outputs/js/presets/bundle.ts"() {
+    init_errors();
+    init_metadata();
+    init_utils();
+  }
+});
+
+// src/outputs/json/presets/bundle.ts
+var bundle_exports2 = {};
+__export(bundle_exports2, {
+  bundleAsJson: () => bundleAsJson
+});
+async function bundleAsJson(bundleData, resolver, formatTokens) {
+  if (!formatTokens) {
+    throw new ConfigurationError("JSON formatter was not provided");
+  }
+  const metadata = buildMetadata(resolver);
+  const tokens = {};
+  for (const { tokens: tokenSet, modifierInputs } of bundleData) {
+    const cleanTokens = stripInternalMetadata(tokenSet);
+    const normalizedInputs = normalizeModifierInputs(modifierInputs);
+    const key = buildStablePermutationKey(normalizedInputs, metadata.dimensions);
+    const themeJson = await formatTokens(cleanTokens);
+    tokens[key] = JSON.parse(themeJson);
+  }
+  const bundle = { _meta: metadata, tokens };
+  return JSON.stringify(bundle, null, 2);
+}
+var init_bundle2 = __esm({
+  "src/outputs/json/presets/bundle.ts"() {
+    init_errors();
+    init_utils();
+  }
+});
+function isColorObject(value) {
+  return typeof value === "object" && value !== null && "colorSpace" in value && "components" in value;
+}
+function componentToCulori(component) {
+  return component === "none" ? void 0 : component;
+}
+function dtcgObjectToCulori(color) {
+  const [c1, c2, c3] = color.components.map(componentToCulori);
+  const alpha = color.alpha !== void 0 ? componentToCulori(color.alpha) : void 0;
+  const colorSpace = color.colorSpace.toLowerCase();
+  switch (colorSpace) {
+    // RGB-based color spaces (components are R, G, B in 0-1 range)
+    case "srgb":
+      return { mode: "rgb", r: c1, g: c2, b: c3, alpha };
+    case "srgb-linear":
+      return { mode: "lrgb", r: c1, g: c2, b: c3, alpha };
+    case "display-p3":
+      return { mode: "p3", r: c1, g: c2, b: c3, alpha };
+    case "a98-rgb":
+      return { mode: "a98", r: c1, g: c2, b: c3, alpha };
+    case "prophoto-rgb":
+      return { mode: "prophoto", r: c1, g: c2, b: c3, alpha };
+    case "rec2020":
+      return { mode: "rec2020", r: c1, g: c2, b: c3, alpha };
+    // Cylindrical color spaces (Hue, Saturation/Whiteness, Lightness/Blackness)
+    case "hsl":
+      return { mode: "hsl", h: c1, s: c2, l: c3, alpha };
+    case "hwb":
+      return { mode: "hwb", h: c1, w: c2, b: c3, alpha };
+    // Lab color spaces (Lightness, a/b or Chroma/Hue)
+    case "lab":
+      return { mode: "lab", l: c1, a: c2, b: c3, alpha };
+    case "lch":
+      return { mode: "lch", l: c1, c: c2, h: c3, alpha };
+    case "oklab":
+      return { mode: "oklab", l: c1, a: c2, b: c3, alpha };
+    case "oklch":
+      return { mode: "oklch", l: c1, c: c2, h: c3, alpha };
+    // XYZ color spaces
+    case "xyz-d65":
+      return { mode: "xyz65", x: c1, y: c2, z: c3, alpha };
+    case "xyz-d50":
+      return { mode: "xyz50", x: c1, y: c2, z: c3, alpha };
+    // Fallback to sRGB if color space is not recognized
+    default:
+      return { mode: "rgb", r: c1, g: c2, b: c3, alpha };
+  }
+}
+function colorObjectToHex(color) {
+  const culoriColor = dtcgObjectToCulori(color);
+  const alpha = color.alpha ?? 1;
+  if (alpha < 1) {
+    return formatHex8(culoriColor);
+  }
+  return formatHex(culoriColor);
+}
+
+// src/processing/transforms/built-in/dimension-converter.ts
+function isDimensionObject(value) {
+  return typeof value === "object" && value !== null && "value" in value && "unit" in value;
+}
+function dimensionObjectToString(dimension) {
+  return `${dimension.value}${dimension.unit}`;
+}
+
+// src/processing/transforms/built-in/duration-converter.ts
+function isDurationObject(value) {
+  return typeof value === "object" && value !== null && "value" in value && "unit" in value && value.unit !== void 0;
+}
+function durationObjectToString(duration) {
+  return `${duration.value}${duration.unit}`;
+}
+
+// src/outputs/css/renderer.ts
+init_errors();
+init_token_utils();
+
+// src/outputs/css/presets/bundle.ts
+init_errors();
+init_utils();
+var REF_PREFIX_SETS = "#/sets/";
+var REF_PREFIX_MODIFIERS = "#/modifiers/";
+var getSourceSet = (token) => {
+  if (typeof token !== "object" || token === null) {
+    return void 0;
+  }
+  return "_sourceSet" in token && typeof token._sourceSet === "string" ? token._sourceSet : void 0;
+};
+var getSourceModifier = (token) => {
+  if (typeof token !== "object" || token === null) {
+    return void 0;
+  }
+  return "_sourceModifier" in token && typeof token._sourceModifier === "string" ? token._sourceModifier : void 0;
+};
+async function bundleAsCss(bundleData, resolver, options, formatTokens) {
+  const baseItem = bundleData.find((item) => item.isBase);
+  if (!baseItem) {
+    throw new BasePermutationError("Base permutation not found in bundle data");
+  }
+  if (!formatTokens) {
+    throw new ConfigurationError("CSS formatter was not provided");
+  }
+  const orderedBundleData = orderBundleData(bundleData, resolver, baseItem);
+  const cssBlocks = [];
+  for (const item of orderedBundleData) {
+    if (item.isBase) {
+      const blocks = await formatBasePermutation(item, resolver, options, formatTokens);
+      cssBlocks.push(...blocks);
+      continue;
+    }
+    const block = await formatModifierPermutation(item, baseItem, options, formatTokens);
+    if (block) {
+      cssBlocks.push(block);
+    }
+  }
+  return cssBlocks.join("\n\n");
+}
+async function formatBasePermutation({ tokens, modifierInputs }, resolver, options, formatTokens) {
+  const firstModifierName = resolver.modifiers ? Object.keys(resolver.modifiers)[0] : "";
+  const modifier = firstModifierName ?? "";
+  const context = modifierInputs[modifier] ?? "";
+  const selector = resolveSelector(options?.selector, modifier, context, true, modifierInputs);
+  const mediaQuery = resolveMediaQuery(options?.mediaQuery, modifier, context, true, modifierInputs);
+  const referenceTokens = stripInternalMetadata(tokens);
+  const defaultBlocks = buildDefaultLayerBlocks(tokens, modifierInputs, resolver);
+  const cssBlocks = [];
+  for (const block of defaultBlocks) {
+    const cleanTokens = stripInternalMetadata(block.tokens);
+    const css2 = await formatTokens(cleanTokens, {
+      selector,
+      mediaQuery,
+      minify: options?.minify,
+      referenceTokens
+    });
+    const header = block.description ? `/* ${block.key} */
+/* ${block.description} */` : `/* ${block.key} */`;
+    cssBlocks.push(`${header}
+${css2}`);
+  }
+  return cssBlocks;
+}
+async function formatModifierPermutation({ tokens, modifierInputs }, baseItem, options, formatTokens) {
+  const differenceCount = countModifierDifferences(modifierInputs, baseItem.modifierInputs);
+  if (differenceCount > 1) {
+    return void 0;
+  }
+  const expectedSource = getExpectedSource(modifierInputs, baseItem.modifierInputs);
+  let tokensToInclude = filterTokensBySource(tokens, expectedSource);
+  const hasSourceMetadata = Object.values(tokens).some(
+    (token) => token != null && getSourceModifier(token) !== void 0
+  );
+  if (Object.keys(tokensToInclude).length === 0 && !hasSourceMetadata) {
+    tokensToInclude = tokens;
+  }
+  if (Object.keys(tokensToInclude).length === 0) {
+    return void 0;
+  }
+  const [modifier, context] = parseModifierSource(expectedSource);
+  const cleanTokens = stripInternalMetadata(tokensToInclude);
+  const referenceTokens = stripInternalMetadata(tokens);
+  const selector = resolveSelector(options?.selector, modifier, context, false, modifierInputs);
+  const mediaQuery = resolveMediaQuery(
+    options?.mediaQuery,
+    modifier,
+    context,
+    false,
+    modifierInputs
+  );
+  const css2 = await formatTokens(cleanTokens, {
+    selector,
+    mediaQuery,
+    minify: options?.minify,
+    referenceTokens
+  });
+  return `/* Modifier: ${modifier}=${context} */
+${css2}`;
+}
+function addLayerBlock(blocks, included, key, blockTokens, description) {
+  if (Object.keys(blockTokens).length === 0) {
+    return;
+  }
+  for (const k of Object.keys(blockTokens)) {
+    included.add(k);
+  }
+  blocks.push({ key, description, tokens: blockTokens });
+}
+function collectSetTokens(tokens, setName, included) {
+  const result = {};
+  for (const [name, token] of Object.entries(tokens)) {
+    if (!included.has(name) && getSourceSet(token) === setName) {
+      result[name] = token;
+    }
+  }
+  return result;
+}
+function collectModifierTokens(tokens, expectedSource, included) {
+  const result = {};
+  for (const [name, token] of Object.entries(tokens)) {
+    if (!included.has(name) && (getSourceModifier(token) ?? "").toLowerCase() === expectedSource) {
+      result[name] = token;
+    }
+  }
+  return result;
+}
+function collectRemainder(tokens, included) {
+  const result = {};
+  for (const [name, token] of Object.entries(tokens)) {
+    if (!included.has(name)) {
+      result[name] = token;
+    }
+  }
+  return result;
+}
+function buildSetLayerBlocks(tokens, resolver) {
+  const blocks = [];
+  const included = /* @__PURE__ */ new Set();
+  for (const item of resolver.resolutionOrder) {
+    const ref = item.$ref;
+    if (typeof ref !== "string" || !ref.startsWith(REF_PREFIX_SETS)) {
+      continue;
+    }
+    const setName = ref.slice(REF_PREFIX_SETS.length);
+    addLayerBlock(
+      blocks,
+      included,
+      `Set: ${setName}`,
+      collectSetTokens(tokens, setName, included),
+      resolver.sets?.[setName]?.description
+    );
+  }
+  addLayerBlock(blocks, included, "Unattributed", collectRemainder(tokens, included));
+  return blocks;
+}
+function buildDefaultLayerBlocks(tokens, baseModifierInputs, resolver) {
+  const blocks = [];
+  const included = /* @__PURE__ */ new Set();
+  const baseInputs = normalizeModifierInputs(baseModifierInputs);
+  for (const item of resolver.resolutionOrder) {
+    const ref = item.$ref;
+    if (typeof ref !== "string") {
+      continue;
+    }
+    processResolutionOrderRef(ref, tokens, blocks, included, baseInputs, resolver);
+  }
+  addLayerBlock(blocks, included, "Unattributed", collectRemainder(tokens, included));
+  return blocks;
+}
+function processResolutionOrderRef(ref, tokens, blocks, included, baseInputs, resolver) {
+  if (ref.startsWith(REF_PREFIX_SETS)) {
+    const setName = ref.slice(REF_PREFIX_SETS.length);
+    addLayerBlock(
+      blocks,
+      included,
+      `Set: ${setName}`,
+      collectSetTokens(tokens, setName, included),
+      resolver.sets?.[setName]?.description
+    );
+    return;
+  }
+  if (!ref.startsWith(REF_PREFIX_MODIFIERS)) {
+    return;
+  }
+  const modifierName = ref.slice(REF_PREFIX_MODIFIERS.length);
+  const modifier = resolver.modifiers?.[modifierName];
+  const selectedContext = baseInputs[modifierName.toLowerCase()];
+  if (!modifier || !selectedContext) {
+    return;
+  }
+  const expectedSource = `${modifierName}-${selectedContext}`.toLowerCase();
+  addLayerBlock(
+    blocks,
+    included,
+    `Modifier: ${modifierName}=${selectedContext} (default)`,
+    collectModifierTokens(tokens, expectedSource, included),
+    modifier.description
+  );
+}
+function findSingleDiffPermutation(bundleData, modifierName, context, baseInputs) {
+  const normalizedModifier = modifierName.toLowerCase();
+  const normalizedContext = context.toLowerCase();
+  return bundleData.find((item) => {
+    if (item.isBase) {
+      return false;
+    }
+    const inputs = normalizeModifierInputs(item.modifierInputs);
+    if (inputs[normalizedModifier] !== normalizedContext) {
+      return false;
+    }
+    return Object.entries(baseInputs).every(([k, v]) => k === normalizedModifier || inputs[k] === v);
+  });
+}
+function pushUniqueBundleItem(ordered, includedKeys, item) {
+  if (!item) {
+    return;
+  }
+  const key = stableInputsKey(item.modifierInputs);
+  if (includedKeys.has(key)) {
+    return;
+  }
+  includedKeys.add(key);
+  ordered.push(item);
+}
+function appendModifierPermutations(bundleData, modifiers, orderedNames, baseInputs, ordered, includedKeys) {
+  for (const modifierName of orderedNames) {
+    const modifierDef = modifiers[modifierName];
+    if (!modifierDef) {
+      continue;
+    }
+    const defaultValue = baseInputs[modifierName.toLowerCase()] ?? "";
+    for (const ctx of Object.keys(modifierDef.contexts)) {
+      if (defaultValue === ctx.toLowerCase()) {
+        continue;
+      }
+      pushUniqueBundleItem(
+        ordered,
+        includedKeys,
+        findSingleDiffPermutation(bundleData, modifierName, ctx, baseInputs)
+      );
+    }
+  }
+}
+function orderBundleData(bundleData, resolver, baseItem) {
+  const modifiers = resolver.modifiers;
+  if (!modifiers) {
+    return bundleData;
+  }
+  const baseInputs = normalizeModifierInputs(baseItem.modifierInputs);
+  const orderedModifierNames = getOrderedModifierNames(resolver);
+  if (orderedModifierNames.length === 0) {
+    return bundleData;
+  }
+  const firstModifierDef = modifiers[orderedModifierNames[0] ?? ""];
+  if (!firstModifierDef) {
+    return bundleData;
+  }
+  const includedKeys = /* @__PURE__ */ new Set();
+  const ordered = [];
+  pushUniqueBundleItem(ordered, includedKeys, baseItem);
+  appendModifierPermutations(
+    bundleData,
+    modifiers,
+    orderedModifierNames,
+    baseInputs,
+    ordered,
+    includedKeys
+  );
+  return ordered.length > 0 ? ordered : bundleData;
+}
+function getOrderedModifierNames(resolver) {
+  const modifiers = resolver.modifiers ?? {};
+  const seen = /* @__PURE__ */ new Set();
+  const ordered = [];
+  for (const item of resolver.resolutionOrder) {
+    const ref = item.$ref;
+    if (typeof ref !== "string") {
+      continue;
+    }
+    if (!ref.startsWith(REF_PREFIX_MODIFIERS)) {
+      continue;
+    }
+    const name = ref.slice(REF_PREFIX_MODIFIERS.length);
+    if (seen.has(name)) {
+      continue;
+    }
+    if (!(name in modifiers)) {
+      continue;
+    }
+    ordered.push(name);
+    seen.add(name);
+  }
+  for (const name of Object.keys(modifiers)) {
+    if (seen.has(name)) {
+      continue;
+    }
+    ordered.push(name);
+    seen.add(name);
+  }
+  return ordered;
+}
+function stableInputsKey(modifierInputs) {
+  const normalized = normalizeModifierInputs(modifierInputs);
+  return Object.keys(normalized).sort().map((k) => `${k}=${normalized[k]}`).join("|");
+}
+
+// src/outputs/css/renderer.ts
+init_utils();
+init_metadata();
+var CssRenderer = class _CssRenderer {
+  async format(context, options) {
+    const opts = {
+      preset: options?.preset ?? "bundle",
+      selector: options?.selector,
+      mediaQuery: options?.mediaQuery,
+      minify: options?.minify ?? false,
+      preserveReferences: options?.preserveReferences ?? false
+    };
+    if (opts.preset === "bundle") {
+      return await this.formatBundle(context, opts);
+    }
+    if (opts.preset === "modifier") {
+      return await this.formatModifier(context, opts);
+    }
+    return await this.formatStandalone(context, opts);
+  }
+  static PRETTIER_PRINT_WIDTH = 80;
+  static PRETTIER_TAB_WIDTH = 2;
+  /**
+   * Format tokens as CSS custom properties
+   *
+   * Converts resolved design tokens into CSS format with configurable selector,
+   * media queries, and formatting options. Supports DTCG color and dimension objects.
+   *
+   * Note: This method expects selector and mediaQuery to be resolved strings.
+   * Function-based selectors should be resolved before calling format().
+   *
+   * @param tokens - Resolved tokens to format
+   * @param options - CSS formatting options (selector, media query, minify, etc.)
+   * @returns Formatted CSS string with custom properties
+   */
+  async formatTokens(tokens, options) {
+    const opts = {
+      preset: "bundle",
+      selector: ":root",
+      mediaQuery: "",
+      minify: false,
+      preserveReferences: false,
+      ...options,
+      referenceTokens: options?.referenceTokens ?? tokens
+    };
+    const sortedTokens = getSortedTokenEntries(tokens).map(([, token]) => token);
+    const referenceTokens = opts.referenceTokens;
+    const lines = [];
+    this.buildCssBlock(lines, sortedTokens, opts.selector, tokens, referenceTokens, opts);
+    const cssString = lines.join("");
+    return opts.minify ? cssString : await this.formatWithPrettier(cssString);
+  }
+  buildCssBlock(lines, groupTokens, selector, tokens, referenceTokens, opts) {
+    const indent = opts.minify ? "" : "  ";
+    const newline = opts.minify ? "" : "\n";
+    const space = opts.minify ? "" : " ";
+    const hasMediaQuery = opts.mediaQuery != null && opts.mediaQuery !== "";
+    const tokenIndent = hasMediaQuery ? indent + indent : indent;
+    if (hasMediaQuery) {
+      lines.push(`@media ${opts.mediaQuery}${space}{${newline}`);
+      lines.push(`${indent}${selector}${space}{${newline}`);
+    } else {
+      lines.push(`${selector}${space}{${newline}`);
+    }
+    for (const token of groupTokens) {
+      this.pushTokenLines(
+        lines,
+        token,
+        tokens,
+        referenceTokens,
+        opts.preserveReferences ?? false,
+        tokenIndent,
+        newline,
+        space
+      );
+    }
+    if (hasMediaQuery) {
+      lines.push(`${indent}}${newline}`);
+    }
+    lines.push(`}${newline}${newline}`);
+  }
+  pushTokenLines(lines, token, tokens, referenceTokens, preserveReferences, indent, newline, space) {
+    const entries = this.buildCssEntries(token, tokens, referenceTokens, preserveReferences);
+    const deprecationComment = buildTokenDeprecationComment(token, "css");
+    if (deprecationComment) {
+      lines.push(`${indent}${deprecationComment}${newline}`);
+    }
+    const descriptionComment = buildTokenDescriptionComment(token, "css");
+    if (descriptionComment) {
+      lines.push(`${indent}${descriptionComment}${newline}`);
+    }
+    for (const entry of entries) {
+      lines.push(`${indent}--${entry.name}:${space}${entry.value};${newline}`);
+    }
+  }
+  async formatWithPrettier(css2) {
+    try {
+      return await prettier.format(css2, {
+        parser: "css",
+        printWidth: _CssRenderer.PRETTIER_PRINT_WIDTH,
+        tabWidth: _CssRenderer.PRETTIER_TAB_WIDTH,
+        useTabs: false
+      });
+    } catch {
+      return css2;
+    }
+  }
+  buildCssEntries(token, tokens, referenceTokens, preserveReferences) {
+    if (preserveReferences) {
+      const refName = getPureAliasReferenceName(token.originalValue);
+      if (refName !== void 0) {
+        return [
+          {
+            name: token.name,
+            value: this.buildCssVarReference(refName, referenceTokens, tokens)
+          }
+        ];
+      }
+    }
+    if (!this.isCompositeToken(token)) {
+      return [{ name: token.name, value: this.formatValue(token) }];
+    }
+    const leaves = this.collectCompositeLeaves(token.$value);
+    if (leaves.length === 0) {
+      return [{ name: token.name, value: this.formatLeafValue(token.$value) }];
+    }
+    const leafEntries = leaves.map((leaf) => ({
+      name: this.buildCompositeName(token.name, leaf.path),
+      value: this.formatLeafValue(
+        this.resolveCompositeLeafValue(
+          leaf,
+          token.originalValue,
+          tokens,
+          referenceTokens,
+          preserveReferences
+        )
+      )
+    }));
+    const wholeValue = this.buildCompositeWholeValue(token, preserveReferences);
+    if (!wholeValue) {
+      return leafEntries;
+    }
+    return [{ name: token.name, value: wholeValue }, ...leafEntries];
+  }
+  isCompositeToken(token) {
+    const isCompositeType = [
+      "shadow",
+      "typography",
+      "border",
+      "strokeStyle",
+      "transition",
+      "gradient"
+    ].includes(token.$type ?? "");
+    if (!isCompositeType) {
+      return false;
+    }
+    const value = token.$value;
+    return typeof value === "object" && value !== null || Array.isArray(value);
+  }
+  buildCompositeWholeValue(token, preserveReferences) {
+    if (token.$type === "shadow") {
+      return preserveReferences ? this.buildShadowWholeValue(token) : this.formatValue(token);
+    }
+    if (token.$type === "border") {
+      if (!this.hasBorderShorthandStyle(token)) {
+        return void 0;
+      }
+      return preserveReferences ? this.buildBorderWholeValue(token) : this.formatValue(token);
+    }
+    if (token.$type === "transition") {
+      return preserveReferences ? this.buildTransitionWholeValue(token) : this.formatValue(token);
+    }
+    return void 0;
+  }
+  hasBorderShorthandStyle(token) {
+    const value = token.$value;
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    return typeof value.style === "string";
+  }
+  buildShadowWholeValue(token) {
+    const value = token.$value;
+    if (Array.isArray(value)) {
+      return value.map((shadow, index) => this.buildShadowLayerValue(token.name, shadow, [String(index)])).join(", ");
+    }
+    if (typeof value === "object" && value !== null) {
+      return this.buildShadowLayerValue(token.name, value, []);
+    }
+    return void 0;
+  }
+  buildShadowLayerValue(baseName, shadow, prefix) {
+    if (typeof shadow !== "object" || shadow === null) {
+      return String(shadow);
+    }
+    const shadowObj = shadow;
+    const parts = [];
+    if (shadowObj.inset === true) {
+      parts.push("inset");
+    }
+    parts.push(this.buildCompositeVar(baseName, [...prefix, "offsetX"]));
+    parts.push(this.buildCompositeVar(baseName, [...prefix, "offsetY"]));
+    parts.push(this.buildCompositeVar(baseName, [...prefix, "blur"]));
+    if (shadowObj.spread != null) {
+      parts.push(this.buildCompositeVar(baseName, [...prefix, "spread"]));
+    }
+    parts.push(this.buildCompositeVar(baseName, [...prefix, "color"]));
+    return parts.join(" ");
+  }
+  buildBorderWholeValue(token) {
+    const value = token.$value;
+    if (typeof value !== "object" || value === null) {
+      return void 0;
+    }
+    const border = value;
+    if (typeof border.style !== "string") {
+      return void 0;
+    }
+    return [
+      this.buildCompositeVar(token.name, ["width"]),
+      this.buildCompositeVar(token.name, ["style"]),
+      this.buildCompositeVar(token.name, ["color"])
+    ].join(" ");
+  }
+  buildTransitionWholeValue(token) {
+    const value = token.$value;
+    if (typeof value !== "object" || value === null) {
+      return void 0;
+    }
+    return [
+      this.buildCompositeVar(token.name, ["duration"]),
+      `cubic-bezier(${this.buildCompositeVar(token.name, ["timingFunction", "0"])}, ${this.buildCompositeVar(token.name, ["timingFunction", "1"])}, ${this.buildCompositeVar(token.name, ["timingFunction", "2"])}, ${this.buildCompositeVar(token.name, ["timingFunction", "3"])})`,
+      this.buildCompositeVar(token.name, ["delay"])
+    ].join(" ");
+  }
+  buildCompositeVar(baseName, path) {
+    return `var(--${this.buildCompositeName(baseName, path)})`;
+  }
+  collectCompositeLeaves(value) {
+    const leaves = [];
+    this.collectLeafEntries(value, [], leaves);
+    return leaves;
+  }
+  collectLeafEntries(value, path, leaves) {
+    if (this.isPrimitiveValue(value)) {
+      leaves.push({ path, value });
+      return;
+    }
+    if (isColorObject(value) || isDimensionObject(value) || isDurationObject(value)) {
+      leaves.push({ path, value });
+      return;
+    }
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        leaves.push({ path, value });
+        return;
+      }
+      value.forEach((item, index) => {
+        this.collectLeafEntries(item, [...path, String(index)], leaves);
+      });
+      return;
+    }
+    if (typeof value === "object" && value !== null) {
+      const entries = Object.entries(value);
+      if (entries.length === 0) {
+        leaves.push({ path, value });
+        return;
+      }
+      for (const [key, child] of entries) {
+        this.collectLeafEntries(child, [...path, this.normalizePathSegment(key)], leaves);
+      }
+      return;
+    }
+    leaves.push({ path, value });
+  }
+  normalizePathSegment(segment) {
+    return segment.trim().replace(/\s+/g, "-");
+  }
+  buildCompositeName(base, path) {
+    if (path.length === 0) {
+      return base;
+    }
+    return `${base}-${path.join("-")}`;
+  }
+  formatLeafValue(value) {
+    if (isColorObject(value)) {
+      return colorObjectToHex(value);
+    }
+    if (isDimensionObject(value)) {
+      return dimensionObjectToString(value);
+    }
+    if (isDurationObject(value)) {
+      return durationObjectToString(value);
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    if (typeof value === "number" || typeof value === "boolean") {
+      return String(value);
+    }
+    if (Array.isArray(value)) {
+      return JSON.stringify(value);
+    }
+    if (typeof value === "object" && value != null) {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  }
+  resolveCompositeLeafValue(leaf, originalValue, tokens, referenceTokens, preserveReferences) {
+    if (!preserveReferences) {
+      return leaf.value;
+    }
+    const originalLeafValue = this.getOriginalLeafValue(originalValue, leaf.path);
+    const refName = getPureAliasReferenceName(originalLeafValue);
+    if (refName === void 0) {
+      return leaf.value;
+    }
+    return this.buildCssVarReference(refName, referenceTokens, tokens);
+  }
+  buildCssVarReference(refName, referenceTokens, tokens) {
+    const referencedToken = referenceTokens[refName] ?? tokens[refName];
+    if (!referencedToken) {
+      throw new ConfigurationError(
+        `CSS reference "{${refName}}" could not be resolved. The referenced token is not present in the current output's token set. This usually means a filter (e.g. isAlias()) excluded the referenced token while preserveReferences is true. Either remove the filter, include the referenced token, or set preserveReferences to false.`
+      );
+    }
+    return `var(--${referencedToken.name})`;
+  }
+  getOriginalLeafValue(value, path) {
+    let current = value;
+    for (const segment of path) {
+      if (Array.isArray(current)) {
+        const index = Number(segment);
+        if (!Number.isInteger(index)) {
+          return void 0;
+        }
+        current = current[index];
+        continue;
+      }
+      if (typeof current === "object" && current !== null) {
+        const entries = Object.entries(current);
+        const matched = entries.find(([key]) => this.normalizePathSegment(key) === segment);
+        if (!matched) {
+          return void 0;
+        }
+        current = matched[1];
+        continue;
+      }
+      return void 0;
+    }
+    return current;
+  }
+  isPrimitiveValue(value) {
+    return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+  }
+  /**
+   * Format token value for CSS
+   * Handles DTCG 2025.10 object formats for colors and dimensions
+   */
+  formatValue(token) {
+    const value = token.$value;
+    const typed = this.formatTypedValue(token.$type, value);
+    if (typed !== void 0) {
+      return typed;
+    }
+    return this.formatPrimitiveOrStructured(value, token.$type);
+  }
+  formatTypedValue(type, value) {
+    if (type === "color" && isColorObject(value)) {
+      return colorObjectToHex(value);
+    }
+    if (type === "dimension") {
+      return typeof value === "string" ? value : dimensionObjectToString(value);
+    }
+    if (type === "duration") {
+      if (isDurationObject(value)) {
+        return durationObjectToString(value);
+      }
+      if (typeof value === "string") {
+        return value;
+      }
+    }
+    return void 0;
+  }
+  formatPrimitiveOrStructured(value, tokenType) {
+    if (typeof value === "string") {
+      return value;
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (Array.isArray(value)) {
+      return this.formatArrayValue(value, tokenType);
+    }
+    if (typeof value === "object" && value != null) {
+      return this.formatCompositeValue(value, tokenType);
+    }
+    return String(value);
+  }
+  formatArrayValue(value, tokenType) {
+    if (tokenType === "shadow" && value.length > 0 && typeof value[0] === "object") {
+      return value.map((shadowObj) => this.formatShadow(shadowObj)).join(", ");
+    }
+    return value.map((v) => typeof v === "string" && v.includes(" ") ? `"${v}"` : v).join(", ");
+  }
+  /**
+   * Format composite token values
+   */
+  formatCompositeValue(value, tokenType) {
+    if (tokenType === "shadow") {
+      return this.formatShadow(value);
+    }
+    if (tokenType === "border") {
+      return this.formatBorder(value);
+    }
+    if (tokenType === "transition") {
+      return this.formatTransition(value);
+    }
+    return JSON.stringify(value);
+  }
+  /**
+   * Format a single shadow object to CSS box-shadow syntax
+   */
+  formatShadow(shadow) {
+    const parts = [];
+    if (shadow.inset === true) {
+      parts.push("inset");
+    }
+    parts.push(dimensionObjectToString(shadow.offsetX));
+    parts.push(dimensionObjectToString(shadow.offsetY));
+    parts.push(dimensionObjectToString(shadow.blur));
+    if (shadow.spread != null) {
+      parts.push(dimensionObjectToString(shadow.spread));
+    }
+    if (isColorObject(shadow.color)) {
+      parts.push(colorObjectToHex(shadow.color));
+    } else {
+      parts.push(String(shadow.color));
+    }
+    return parts.join(" ");
+  }
+  /**
+   * Format a border object to CSS border shorthand syntax
+   */
+  formatBorder(value) {
+    const parts = [];
+    if (isDimensionObject(value.width)) {
+      parts.push(dimensionObjectToString(value.width));
+    } else if (value.width != null) {
+      parts.push(String(value.width));
+    }
+    if (typeof value.style === "string") {
+      parts.push(value.style);
+    }
+    if (isColorObject(value.color)) {
+      parts.push(colorObjectToHex(value.color));
+    } else if (value.color != null) {
+      parts.push(String(value.color));
+    }
+    return parts.join(" ");
+  }
+  /**
+   * Format a transition object to CSS transition shorthand syntax
+   */
+  formatTransition(value) {
+    const parts = [];
+    if (isDurationObject(value.duration)) {
+      parts.push(durationObjectToString(value.duration));
+    } else if (value.duration != null) {
+      parts.push(String(value.duration));
+    }
+    if (Array.isArray(value.timingFunction) && value.timingFunction.length === 4) {
+      parts.push(`cubic-bezier(${value.timingFunction.join(", ")})`);
+    }
+    if (isDurationObject(value.delay)) {
+      parts.push(durationObjectToString(value.delay));
+    } else if (value.delay != null) {
+      parts.push(String(value.delay));
+    }
+    return parts.join(" ");
+  }
+  async formatBundle(context, options) {
+    const bundleData = context.permutations.map(({ tokens, modifierInputs }) => ({
+      tokens,
+      modifierInputs,
+      isBase: isBasePermutation(modifierInputs, context.meta.defaults)
+    }));
+    return await bundleAsCss(bundleData, context.resolver, options, async (tokens, resolved) => {
+      return await this.formatTokens(tokens, {
+        ...resolved,
+        preserveReferences: options.preserveReferences ?? false
+      });
+    });
+  }
+  async formatStandalone(context, options) {
+    assertFileRequired(
+      context.buildPath,
+      context.output.file,
+      context.output.name,
+      "standalone CSS"
+    );
+    const files = {};
+    for (const { tokens, modifierInputs } of context.permutations) {
+      const { fileName, content } = await this.buildStandaloneFile(
+        tokens,
+        modifierInputs,
+        context,
+        options
+      );
+      files[fileName] = content;
+    }
+    return { kind: "outputTree", files };
+  }
+  async buildStandaloneFile(tokens, modifierInputs, context, options) {
+    const isBase = isBasePermutation(modifierInputs, context.meta.defaults);
+    const { modifierName, modifierContext } = this.resolveModifierContext(
+      modifierInputs,
+      context,
+      isBase
+    );
+    const selector = resolveSelector(
+      options.selector,
+      modifierName,
+      modifierContext,
+      isBase,
+      modifierInputs
+    );
+    const mediaQuery = resolveMediaQuery(
+      options.mediaQuery,
+      modifierName,
+      modifierContext,
+      isBase,
+      modifierInputs
+    );
+    const content = await this.formatTokens(tokens, {
+      selector,
+      mediaQuery,
+      minify: options.minify ?? false,
+      preserveReferences: options.preserveReferences ?? false,
+      referenceTokens: tokens
+    });
+    const fileName = context.output.file ? resolveFileName(context.output.file, modifierInputs) : buildInMemoryOutputKey({
+      outputName: context.output.name,
+      extension: "css",
+      modifierInputs,
+      resolver: context.resolver,
+      defaults: context.meta.defaults
+    });
+    return { fileName, content };
+  }
+  async formatModifier(context, options) {
+    assertFileRequired(context.buildPath, context.output.file, context.output.name, "modifier CSS");
+    if (!context.resolver.modifiers) {
+      throw new ConfigurationError("Modifier preset requires modifiers to be defined in resolver");
+    }
+    const files = {};
+    const baseResult = await this.buildModifierBaseFile(context, options);
+    if (baseResult) {
+      files[baseResult.fileName] = baseResult.content;
+    }
+    for (const [modifierName, modifierDef] of Object.entries(context.resolver.modifiers)) {
+      for (const contextValue of Object.keys(modifierDef.contexts)) {
+        const result = await this.buildModifierContextFile(
+          modifierName,
+          contextValue,
+          context,
+          options
+        );
+        if (result) {
+          files[result.fileName] = result.content;
+        }
+      }
+    }
+    return { kind: "outputTree", files };
+  }
+  async buildModifierBaseFile(context, options) {
+    const basePermutation = context.permutations.find(
+      ({ modifierInputs }) => isBasePermutation(modifierInputs, context.meta.defaults)
+    );
+    if (!basePermutation) {
+      return void 0;
+    }
+    const setTokens = filterTokensFromSets(basePermutation.tokens);
+    if (Object.keys(setTokens).length === 0) {
+      return void 0;
+    }
+    const setBlocks = buildSetLayerBlocks(setTokens, context.resolver);
+    if (setBlocks.length === 0) {
+      return void 0;
+    }
+    const { selector, mediaQuery } = this.resolveBaseModifierContext(context, options);
+    const content = await this.formatSetBlocksCss(
+      setBlocks,
+      basePermutation.tokens,
+      selector,
+      mediaQuery,
+      options
+    );
+    const fileName = context.output.file ? resolveBaseFileName(context.output.file, context.meta.defaults) : `${context.output.name}-base.css`;
+    return { fileName, content };
+  }
+  resolveBaseModifierContext(context, options) {
+    const modifiers = context.resolver.modifiers;
+    const firstModifierName = Object.keys(modifiers)[0] ?? "";
+    const firstModifierContext = context.meta.defaults[firstModifierName] ?? "";
+    const baseModifierInputs = { ...context.meta.defaults };
+    return {
+      selector: resolveSelector(
+        options.selector,
+        firstModifierName,
+        firstModifierContext,
+        true,
+        baseModifierInputs
+      ),
+      mediaQuery: resolveMediaQuery(
+        options.mediaQuery,
+        firstModifierName,
+        firstModifierContext,
+        true,
+        baseModifierInputs
+      )
+    };
+  }
+  async formatSetBlocksCss(setBlocks, referenceTokens, selector, mediaQuery, options) {
+    const cssBlocks = [];
+    for (const block of setBlocks) {
+      const cleanTokens = stripInternalMetadata(block.tokens);
+      const css2 = await this.formatTokens(cleanTokens, {
+        selector,
+        mediaQuery,
+        minify: options.minify ?? false,
+        preserveReferences: options.preserveReferences ?? false,
+        referenceTokens
+      });
+      const header = block.description ? `/* ${block.key} */
+/* ${block.description} */` : `/* ${block.key} */`;
+      cssBlocks.push(`${header}
+${css2}`);
+    }
+    return cssBlocks.join("\n");
+  }
+  collectTokensForModifierContext(modifierName, contextValue, permutations) {
+    const expectedSource = `${modifierName}-${contextValue}`;
+    let tokensFromSource = {};
+    let referenceTokens = {};
+    for (const { tokens, modifierInputs } of permutations) {
+      if (modifierInputs[modifierName] !== contextValue) {
+        continue;
+      }
+      tokensFromSource = { ...tokensFromSource, ...filterTokensBySource(tokens, expectedSource) };
+      referenceTokens = { ...referenceTokens, ...tokens };
+    }
+    return { tokensFromSource, referenceTokens };
+  }
+  async buildModifierContextFile(modifierName, contextValue, context, options) {
+    const { tokensFromSource, referenceTokens } = this.collectTokensForModifierContext(
+      modifierName,
+      contextValue,
+      context.permutations
+    );
+    if (Object.keys(tokensFromSource).length === 0) {
+      return void 0;
+    }
+    const defaults = context.meta.defaults;
+    const isBase = contextValue === defaults[modifierName];
+    const modifierInputs = { ...defaults, [modifierName]: contextValue };
+    const selector = resolveSelector(
+      options.selector,
+      modifierName,
+      contextValue,
+      isBase,
+      modifierInputs
+    );
+    const mediaQuery = resolveMediaQuery(
+      options.mediaQuery,
+      modifierName,
+      contextValue,
+      isBase,
+      modifierInputs
+    );
+    const content = await this.formatTokens(tokensFromSource, {
+      selector,
+      mediaQuery,
+      minify: options.minify ?? false,
+      preserveReferences: options.preserveReferences ?? false,
+      referenceTokens
+    });
+    const fileName = context.output.file ? resolveFileName(context.output.file, modifierInputs) : buildInMemoryOutputKey({
+      outputName: context.output.name,
+      extension: "css",
+      modifierInputs,
+      resolver: context.resolver,
+      defaults: context.meta.defaults
+    });
+    return { fileName, content };
+  }
+  resolveModifierContext(modifierInputs, context, isBase) {
+    if (!context.resolver.modifiers) {
+      return { modifierName: "", modifierContext: "" };
+    }
+    const normalizedInputs = normalizeModifierInputs(modifierInputs);
+    const normalizedDefaults = normalizeModifierInputs(context.meta.defaults);
+    if (isBase) {
+      const firstModifier = Object.keys(context.resolver.modifiers)[0] ?? "";
+      return {
+        modifierName: firstModifier,
+        modifierContext: normalizedInputs[firstModifier] ?? ""
+      };
+    }
+    for (const [name, value] of Object.entries(normalizedInputs)) {
+      if (value !== normalizedDefaults[name]) {
+        return { modifierName: name, modifierContext: value };
+      }
+    }
+    return { modifierName: "", modifierContext: "" };
+  }
+};
+function cssRenderer() {
+  const rendererInstance = new CssRenderer();
+  return {
+    format: (context, options) => rendererInstance.format(
+      context,
+      options ?? context.output.options
+    )
+  };
+}
+
+// src/outputs/js/renderer.ts
+init_utils();
+init_token_utils();
+init_metadata();
+
+// src/outputs/output-tree.ts
+var outputTree = (files) => {
+  return {
+    kind: "outputTree",
+    files
+  };
+};
+var isOutputTree = (value) => {
+  return typeof value === "object" && value !== null && value.kind === "outputTree";
+};
+
+// src/outputs/js/renderer.ts
+var JsModuleRenderer = class {
+  async format(context, options) {
+    const opts = {
+      preset: options?.preset ?? "standalone",
+      structure: options?.structure ?? "nested",
+      minify: options?.minify ?? false,
+      moduleName: options?.moduleName ?? "tokens",
+      generateHelper: options?.generateHelper ?? false
+    };
+    if (opts.preset === "bundle") {
+      const { bundleAsJsModule: bundleAsJsModule2 } = await Promise.resolve().then(() => (init_bundle(), bundle_exports));
+      const bundleData = context.permutations.map(({ tokens, modifierInputs }) => ({
+        tokens: stripInternalMetadata(tokens),
+        modifierInputs,
+        isBase: isBasePermutation(modifierInputs, context.meta.defaults)
+      }));
+      return await bundleAsJsModule2(bundleData, context.resolver, opts, async (tokens) => {
+        return await this.formatTokens(tokens, opts);
+      });
+    }
+    assertFileRequired(context.buildPath, context.output.file, context.output.name, "JS module");
+    const files = {};
+    for (const { tokens, modifierInputs } of context.permutations) {
+      const cleanTokens = stripInternalMetadata(tokens);
+      const content = await this.formatTokens(cleanTokens, opts);
+      const fileName = context.output.file ? resolveFileName(context.output.file, modifierInputs) : buildInMemoryOutputKey({
+        outputName: context.output.name,
+        extension: "js",
+        modifierInputs,
+        resolver: context.resolver,
+        defaults: context.meta.defaults
+      });
+      files[fileName] = content;
+    }
+    return outputTree(files);
+  }
+  async formatTokens(tokens, options) {
+    const lines = [];
+    lines.push(...this.formatAsObject(tokens, options));
+    const code = lines.join("\n");
+    if (options.minify) {
+      return code;
+    }
+    return await prettier.format(code, {
+      parser: "babel",
+      printWidth: 80,
+      tabWidth: 2,
+      useTabs: false,
+      semi: false,
+      singleQuote: true,
+      trailingComma: "es5"
+    });
+  }
+  formatAsObject(tokens, options) {
+    const lines = [];
+    const tokenMap = this.buildTokenMap(tokens);
+    const varName = options.moduleName !== "" ? options.moduleName : "tokens";
+    if (options.structure === "flat") {
+      lines.push(`const ${varName} = {`);
+      this.addFlatProperties(lines, tokens, 1);
+      lines.push("}");
+    } else {
+      lines.push(`const ${varName} = {`);
+      const tokenObj = this.tokensToPlainObject(tokens, "nested");
+      this.addNestedProperties(lines, tokenObj, tokenMap, 1);
+      lines.push("}");
+    }
+    lines.push("");
+    lines.push(`export default ${varName}`);
+    return lines;
+  }
+  buildTokenMap(tokens) {
+    const map = /* @__PURE__ */ new Map();
+    for (const [name, token] of Object.entries(tokens)) {
+      map.set(name, token);
+    }
+    return map;
+  }
+  addFlatProperties(lines, tokens, indent) {
+    const indentStr2 = "  ".repeat(indent);
+    const sortedEntries = getSortedTokenEntries(tokens);
+    for (let i = 0; i < sortedEntries.length; i++) {
+      const [name, token] = sortedEntries[i];
+      const isLast = i === sortedEntries.length - 1;
+      this.pushTokenComments(lines, token, indentStr2);
+      lines.push(
+        `${indentStr2}${this.quoteKey(name)}: ${JSON.stringify(token.$value)}${isLast ? "" : ","}`
+      );
+    }
+  }
+  pushTokenComments(lines, token, indent) {
+    const deprecationComment = buildTokenDeprecationComment(token, "js");
+    if (deprecationComment) {
+      lines.push(`${indent}${deprecationComment}`);
+    }
+    const descriptionComment = buildTokenDescriptionComment(token, "js");
+    if (descriptionComment) {
+      lines.push(`${indent}${descriptionComment}`);
+    }
+  }
+  tokensToPlainObject(tokens, structure) {
+    if (structure === "nested") {
+      return buildNestedTokenObject(tokens, (token) => token.$value);
+    }
+    const result = {};
+    for (const [name, token] of getSortedTokenEntries(tokens)) {
+      result[name] = token.$value;
+    }
+    return result;
+  }
+  addNestedProperties(lines, obj, tokenMap, indent) {
+    const indentStr2 = "  ".repeat(indent);
+    const entries = Object.entries(obj).sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
+    for (let i = 0; i < entries.length; i++) {
+      const entry = entries[i];
+      if (entry == null) {
+        continue;
+      }
+      const [key, value] = entry;
+      const isLast = i === entries.length - 1;
+      const isNestedObject = typeof value === "object" && value !== null && !Array.isArray(value);
+      if (!isNestedObject) {
+        const token = tokenMap.get(key);
+        if (token) {
+          this.pushTokenComments(lines, token, indentStr2);
+        }
+        lines.push(
+          `${indentStr2}${this.quoteKey(key)}: ${JSON.stringify(value)}${isLast ? "" : ","}`
+        );
+        continue;
+      }
+      lines.push(`${indentStr2}${this.quoteKey(key)}: {`);
+      this.addNestedProperties(lines, value, tokenMap, indent + 1);
+      lines.push(`${indentStr2}}${isLast ? "" : ","}`);
+    }
+  }
+  quoteKey(key) {
+    if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
+      return key;
+    }
+    return `"${key}"`;
+  }
+};
+function jsRenderer() {
+  const rendererInstance = new JsModuleRenderer();
+  return {
+    format: (context, options) => rendererInstance.format(
+      context,
+      options ?? context.output.options
+    )
+  };
+}
+
+// src/outputs/json/renderer.ts
+init_utils();
+init_token_utils();
+var JsonRenderer = class {
+  async format(context, options) {
+    const opts = {
+      preset: options?.preset ?? "standalone",
+      structure: options?.structure ?? "nested",
+      minify: options?.minify ?? false,
+      includeMetadata: options?.includeMetadata ?? false
+    };
+    if (opts.preset === "bundle") {
+      const { bundleAsJson: bundleAsJson2 } = await Promise.resolve().then(() => (init_bundle2(), bundle_exports2));
+      const bundleData = context.permutations.map(({ tokens, modifierInputs }) => ({
+        tokens: stripInternalMetadata(tokens),
+        modifierInputs,
+        isBase: isBasePermutation(modifierInputs, context.meta.defaults)
+      }));
+      return await bundleAsJson2(bundleData, context.resolver, async (tokens) => {
+        return await this.formatTokens(tokens, opts);
+      });
+    }
+    assertFileRequired(context.buildPath, context.output.file, context.output.name, "JSON");
+    const files = {};
+    for (const { tokens, modifierInputs } of context.permutations) {
+      const processedTokens = stripInternalMetadata(tokens);
+      const content = await this.formatTokens(processedTokens, opts);
+      const fileName = context.output.file ? resolveFileName(context.output.file, modifierInputs) : buildInMemoryOutputKey({
+        outputName: context.output.name,
+        extension: "json",
+        modifierInputs,
+        resolver: context.resolver,
+        defaults: context.meta.defaults
+      });
+      files[fileName] = content;
+    }
+    return outputTree(files);
+  }
+  async formatTokens(tokens, options) {
+    const opts = {
+      preset: options.preset ?? "standalone",
+      structure: options.structure ?? "nested",
+      minify: options.minify ?? false,
+      includeMetadata: options.includeMetadata ?? false
+    };
+    let output;
+    if (opts.structure === "flat") {
+      output = opts.includeMetadata ? this.flattenTokens(tokens) : this.flattenValues(tokens);
+    } else {
+      output = opts.includeMetadata ? this.nestTokens(tokens) : this.nestValues(tokens);
+    }
+    const jsonString = JSON.stringify(output);
+    if (!opts.minify) {
+      return await prettier.format(jsonString, {
+        parser: "json",
+        printWidth: 80,
+        tabWidth: 2,
+        useTabs: false
+      });
+    }
+    return jsonString;
+  }
+  /**
+   * Flatten tokens to simple key-value pairs
+   */
+  flattenValues(tokens) {
+    const result = {};
+    for (const [name, token] of getSortedTokenEntries(tokens)) {
+      result[name] = token.$value;
+    }
+    return result;
+  }
+  /**
+   * Flatten tokens to metadata objects
+   */
+  flattenTokens(tokens) {
+    const result = {};
+    for (const [name, token] of getSortedTokenEntries(tokens)) {
+      result[name] = this.serializeToken(token);
+    }
+    return result;
+  }
+  nestValues(tokens) {
+    return buildNestedTokenObject(tokens, (token) => token.$value);
+  }
+  nestTokens(tokens) {
+    return buildNestedTokenObject(tokens, (token) => this.serializeToken(token));
+  }
+  serializeToken(token) {
+    return {
+      $value: token.$value,
+      ...typeof token.$type === "string" && { $type: token.$type },
+      ...token.$description != null && token.$description !== "" && { $description: token.$description },
+      ...token.$deprecated != null && token.$deprecated !== false && { $deprecated: token.$deprecated },
+      ...token.$extensions != null && { $extensions: token.$extensions }
+    };
+  }
+};
+function jsonRenderer() {
+  const rendererInstance = new JsonRenderer();
+  return {
+    format: (context, options) => rendererInstance.format(
+      context,
+      options ?? context.output.options
+    )
+  };
+}
+
+// src/outputs/tailwind/renderer.ts
+init_token_utils();
+
+// src/outputs/tailwind/presets/bundle.ts
+init_errors();
+init_utils();
+async function bundleAsTailwind(bundleData, options, formatThemeTokens, formatOverrideBlock) {
+  const baseItem = bundleData.find((item) => item.isBase);
+  if (!baseItem) {
+    throw new BasePermutationError("Base permutation not found in bundle data");
+  }
+  const resolvedOpts = resolveOptions(options);
+  const cssBlocks = [];
+  const variantDeclarations = collectVariantDeclarations(bundleData, baseItem, resolvedOpts);
+  const themeOpts = { ...resolvedOpts, variantDeclarations };
+  const baseTokens = stripInternalMetadata(baseItem.tokens);
+  const themeBlock = await formatThemeTokens(baseTokens, themeOpts);
+  cssBlocks.push(themeBlock);
+  for (const item of bundleData) {
+    if (item.isBase) {
+      continue;
+    }
+    const block = await formatModifierOverride(item, baseItem, resolvedOpts, formatOverrideBlock);
+    if (block) {
+      cssBlocks.push(block);
+    }
+  }
+  return cssBlocks.join("\n");
+}
+function resolveModifierSelectorAndMedia(options, modifier, context, modifierInputs) {
+  const normalized = normalizeModifierInputs(modifierInputs);
+  return {
+    selector: resolveSelector(options.selector, modifier, context, false, normalized),
+    mediaQuery: resolveMediaQuery(options.mediaQuery, modifier, context, false, normalized)
+  };
+}
+async function formatModifierOverride({ tokens, modifierInputs }, baseItem, options, formatOverrideBlock) {
+  const differenceCount = countModifierDifferences(modifierInputs, baseItem.modifierInputs);
+  if (differenceCount > 1) {
+    return void 0;
+  }
+  const tokensToInclude = filterTokensByValueChange(tokens, baseItem.tokens);
+  if (Object.keys(tokensToInclude).length === 0) {
+    return void 0;
+  }
+  const expectedSource = getExpectedSource(modifierInputs, baseItem.modifierInputs);
+  const [modifier, context] = parseModifierSource(expectedSource);
+  const cleanTokens = stripInternalMetadata(tokensToInclude);
+  const { selector, mediaQuery } = resolveModifierSelectorAndMedia(
+    options,
+    modifier,
+    context,
+    modifierInputs
+  );
+  const css2 = await formatOverrideBlock(cleanTokens, selector, mediaQuery, options.minify);
+  return `/* Modifier: ${modifier}=${context} */
+${css2}`;
+}
+function filterTokensByValueChange(currentTokens, baseTokens) {
+  const changed = {};
+  for (const [name, token] of Object.entries(currentTokens)) {
+    const baseToken = baseTokens[name];
+    if (!baseToken) {
+      changed[name] = token;
+      continue;
+    }
+    if (JSON.stringify(token.$value) !== JSON.stringify(baseToken.$value)) {
+      changed[name] = token;
+    }
+  }
+  return changed;
+}
+function collectVariantDeclarations(bundleData, baseItem, options) {
+  const declarations = [];
+  for (const item of bundleData) {
+    if (item.isBase) {
+      continue;
+    }
+    const differenceCount = countModifierDifferences(item.modifierInputs, baseItem.modifierInputs);
+    if (differenceCount > 1) {
+      continue;
+    }
+    const expectedSource = getExpectedSource(item.modifierInputs, baseItem.modifierInputs);
+    const [modifier, context] = parseModifierSource(expectedSource);
+    const variantName = `${modifier}-${context}`;
+    const normalized = normalizeModifierInputs(item.modifierInputs);
+    const mediaQuery = resolveMediaQuery(options.mediaQuery, modifier, context, false, normalized);
+    if (mediaQuery !== "") {
+      declarations.push(`@custom-variant ${variantName} (@media ${mediaQuery});`);
+      continue;
+    }
+    const selector = resolveSelector(options.selector, modifier, context, false, normalized);
+    declarations.push(`@custom-variant ${variantName} (&:where(${selector}, ${selector} *));`);
+  }
+  return declarations;
+}
+function resolveOptions(options) {
+  return {
+    preset: options.preset ?? "bundle",
+    includeImport: options.includeImport ?? true,
+    namespace: options.namespace ?? "",
+    minify: options.minify ?? false,
+    selector: options.selector,
+    mediaQuery: options.mediaQuery,
+    variantDeclarations: []
+  };
+}
+
+// src/outputs/tailwind/renderer.ts
+init_utils();
+init_metadata();
+var TAILWIND_NAMESPACE_MAP = {
+  color: "color",
+  dimension: "spacing",
+  fontFamily: "font",
+  fontWeight: "font-weight",
+  duration: "duration",
+  shadow: "shadow",
+  number: "number",
+  cubicBezier: "ease"
+};
+var TailwindRenderer = class {
+  async format(context, options) {
+    const opts = {
+      preset: options?.preset ?? "bundle",
+      includeImport: options?.includeImport ?? true,
+      namespace: options?.namespace ?? "",
+      minify: options?.minify ?? false,
+      selector: options?.selector,
+      mediaQuery: options?.mediaQuery,
+      variantDeclarations: []
+    };
+    if (opts.preset === "bundle") {
+      return await this.formatBundle(context, opts);
+    }
+    return await this.formatStandalone(context, opts);
+  }
+  /**
+   * Format tokens as Tailwind v4 @theme CSS variables
+   */
+  async formatTokens(tokens, options) {
+    const lines = [];
+    const indent = options.minify ? "" : "  ";
+    const newline = options.minify ? "" : "\n";
+    const space = options.minify ? "" : " ";
+    if (options.includeImport) {
+      lines.push(`@import "tailwindcss";${newline}`);
+    }
+    if (options.variantDeclarations.length > 0) {
+      if (options.includeImport) {
+        lines.push(newline);
+      }
+      for (const declaration of options.variantDeclarations) {
+        lines.push(`${declaration}${newline}`);
+      }
+    }
+    if (options.includeImport || options.variantDeclarations.length > 0) {
+      lines.push(newline);
+    }
+    const themeDirective = options.namespace ? `@theme namespace(${options.namespace})` : "@theme";
+    lines.push(`${themeDirective}${space}{${newline}`);
+    for (const [, token] of getSortedTokenEntries(tokens)) {
+      const varName = this.buildVariableName(token);
+      const varValue = this.formatValue(token);
+      const deprecationComment = buildTokenDeprecationComment(token, "tailwind");
+      if (deprecationComment) {
+        lines.push(`${indent}${deprecationComment}${newline}`);
+      }
+      const descriptionComment = buildTokenDescriptionComment(token, "tailwind");
+      if (descriptionComment) {
+        lines.push(`${indent}${descriptionComment}${newline}`);
+      }
+      lines.push(`${indent}--${varName}:${space}${varValue};${newline}`);
+    }
+    lines.push(`}${newline}`);
+    const cssString = lines.join("");
+    return options.minify ? cssString : await this.formatWithPrettier(cssString);
+  }
+  /**
+   * Format tokens as plain CSS custom property overrides inside a selector block.
+   * Used for modifier overrides (e.g., dark mode) appended after the @theme block.
+   */
+  async formatOverrideBlock(tokens, selector, mediaQuery, minify) {
+    const indent = minify ? "" : "  ";
+    const newline = minify ? "" : "\n";
+    const space = minify ? "" : " ";
+    const hasMediaQuery = mediaQuery !== "";
+    const tokenIndent = hasMediaQuery ? indent + indent : indent;
+    const lines = [];
+    if (hasMediaQuery) {
+      lines.push(`@media ${mediaQuery}${space}{${newline}`);
+      lines.push(`${indent}${selector}${space}{${newline}`);
+    } else {
+      lines.push(`${selector}${space}{${newline}`);
+    }
+    for (const [, token] of getSortedTokenEntries(tokens)) {
+      const varName = this.buildVariableName(token);
+      const varValue = this.formatValue(token);
+      const deprecationComment = buildTokenDeprecationComment(token, "tailwind");
+      if (deprecationComment) {
+        lines.push(`${tokenIndent}${deprecationComment}${newline}`);
+      }
+      const descriptionComment = buildTokenDescriptionComment(token, "tailwind");
+      if (descriptionComment) {
+        lines.push(`${tokenIndent}${descriptionComment}${newline}`);
+      }
+      lines.push(`${tokenIndent}--${varName}:${space}${varValue};${newline}`);
+    }
+    if (hasMediaQuery) {
+      lines.push(`${indent}}${newline}`);
+      lines.push(`}${newline}`);
+    } else {
+      lines.push(`}${newline}`);
+    }
+    return lines.join("");
+  }
+  buildVariableName(token) {
+    const prefix = TAILWIND_NAMESPACE_MAP[token.$type ?? ""];
+    if (!prefix) {
+      return token.name;
+    }
+    const nameLower = token.name.toLowerCase();
+    const prefixLower = prefix.toLowerCase();
+    if (nameLower.startsWith(`${prefixLower}-`) || nameLower.startsWith(`${prefixLower}.`)) {
+      return token.name;
+    }
+    return `${prefix}-${token.name}`;
+  }
+  formatValue(token) {
+    const value = token.$value;
+    if (token.$type === "color" && isColorObject(value)) {
+      return colorObjectToHex(value);
+    }
+    if (token.$type === "dimension" && isDimensionObject(value)) {
+      return dimensionObjectToString(value);
+    }
+    if (token.$type === "duration" && isDurationObject(value)) {
+      return durationObjectToString(value);
+    }
+    if (token.$type === "fontFamily") {
+      if (Array.isArray(value)) {
+        return value.map((v) => typeof v === "string" && v.includes(" ") ? `"${v}"` : v).join(", ");
+      }
+      return typeof value === "string" ? value : String(value);
+    }
+    if (token.$type === "shadow") {
+      return this.formatShadowValue(value);
+    }
+    if (token.$type === "cubicBezier" && Array.isArray(value) && value.length === 4) {
+      return `cubic-bezier(${value.join(", ")})`;
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+    return String(value);
+  }
+  formatShadowValue(value) {
+    if (Array.isArray(value) && value.length > 0 && typeof value[0] === "object") {
+      return value.map((s) => this.formatSingleShadow(s)).join(", ");
+    }
+    if (typeof value === "object" && value !== null) {
+      return this.formatSingleShadow(value);
+    }
+    return String(value);
+  }
+  formatSingleShadow(shadow) {
+    const parts = [];
+    if (shadow.inset === true) {
+      parts.push("inset");
+    }
+    if (isDimensionObject(shadow.offsetX)) {
+      parts.push(dimensionObjectToString(shadow.offsetX));
+    }
+    if (isDimensionObject(shadow.offsetY)) {
+      parts.push(dimensionObjectToString(shadow.offsetY));
+    }
+    if (isDimensionObject(shadow.blur)) {
+      parts.push(dimensionObjectToString(shadow.blur));
+    }
+    if (shadow.spread != null && isDimensionObject(shadow.spread)) {
+      parts.push(dimensionObjectToString(shadow.spread));
+    }
+    if (isColorObject(shadow.color)) {
+      parts.push(colorObjectToHex(shadow.color));
+    } else if (shadow.color != null) {
+      parts.push(String(shadow.color));
+    }
+    return parts.join(" ");
+  }
+  async formatWithPrettier(css2) {
+    try {
+      return await prettier.format(css2, {
+        parser: "css",
+        printWidth: 80,
+        tabWidth: 2,
+        useTabs: false
+      });
+    } catch {
+      return css2;
+    }
+  }
+  async formatBundle(context, options) {
+    const bundleData = context.permutations.map(({ tokens, modifierInputs }) => ({
+      tokens,
+      modifierInputs,
+      isBase: isBasePermutation(modifierInputs, context.meta.defaults)
+    }));
+    return await bundleAsTailwind(
+      bundleData,
+      options,
+      async (tokens, opts) => await this.formatTokens(tokens, opts),
+      async (tokens, selector, mediaQuery, minify) => await this.formatOverrideBlock(tokens, selector, mediaQuery, minify)
+    );
+  }
+  async formatStandalone(context, options) {
+    assertFileRequired(
+      context.buildPath,
+      context.output.file,
+      context.output.name,
+      "standalone Tailwind"
+    );
+    const files = {};
+    for (const { tokens, modifierInputs } of context.permutations) {
+      const processedTokens = stripInternalMetadata(tokens);
+      const content = await this.formatTokens(processedTokens, options);
+      const fileName = context.output.file ? resolveFileName(context.output.file, modifierInputs) : buildInMemoryOutputKey({
+        outputName: context.output.name,
+        extension: "css",
+        modifierInputs,
+        resolver: context.resolver,
+        defaults: context.meta.defaults
+      });
+      files[fileName] = content;
+    }
+    return outputTree(files);
+  }
+};
+function tailwindRenderer() {
+  const rendererInstance = new TailwindRenderer();
+  return {
+    format: (context, options) => rendererInstance.format(
+      context,
+      options ?? context.output.options
+    )
+  };
+}
+
+// src/shared/token-types/types.ts
+function isShadowToken(token) {
+  return token.$type === "shadow";
+}
+function isTypographyToken(token) {
+  return token.$type === "typography";
+}
+function isBorderToken(token) {
+  return token.$type === "border";
+}
+
+// src/outputs/ios/renderer.ts
+init_utils();
+init_metadata();
+var toSRGB = converter("rgb");
+var toP3 = converter("p3");
+var SWIFT_TYPE_GROUP_MAP = {
+  color: "Colors",
+  dimension: "Spacing",
+  fontFamily: "Fonts",
+  fontWeight: "FontWeights",
+  duration: "Durations",
+  shadow: "Shadows",
+  typography: "Typography",
+  number: "Numbers",
+  cubicBezier: "Animations",
+  border: "Borders",
+  gradient: "Gradients"
+};
+var SWIFT_KEYWORDS = /* @__PURE__ */ new Set([
+  "associatedtype",
+  "class",
+  "deinit",
+  "enum",
+  "extension",
+  "fileprivate",
+  "func",
+  "import",
+  "init",
+  "inout",
+  "internal",
+  "let",
+  "open",
+  "operator",
+  "private",
+  "protocol",
+  "public",
+  "rethrows",
+  "static",
+  "struct",
+  "subscript",
+  "typealias",
+  "var",
+  "break",
+  "case",
+  "continue",
+  "default",
+  "defer",
+  "do",
+  "else",
+  "fallthrough",
+  "for",
+  "guard",
+  "if",
+  "in",
+  "repeat",
+  "return",
+  "switch",
+  "where",
+  "while",
+  "as",
+  "catch",
+  "false",
+  "is",
+  "nil",
+  "super",
+  "self",
+  "Self",
+  "throw",
+  "throws",
+  "true",
+  "try",
+  "Type",
+  "Protocol"
+]);
+var IosRenderer = class {
+  async format(context, options) {
+    const opts = {
+      preset: options?.preset ?? "standalone",
+      accessLevel: options?.accessLevel ?? "public",
+      structure: options?.structure ?? "enum",
+      enumName: options?.enumName ?? "DesignTokens",
+      extensionNamespace: options?.extensionNamespace ?? "DesignTokens",
+      colorSpace: options?.colorSpace ?? "sRGB",
+      swiftVersion: options?.swiftVersion ?? "5.9",
+      indent: options?.indent ?? 4,
+      frozen: options?.frozen ?? false
+    };
+    return await this.formatStandalone(context, opts);
+  }
+  formatTokens(tokens, options) {
+    const access = options.accessLevel;
+    const groups = groupTokensByType(tokens, SWIFT_TYPE_GROUP_MAP);
+    const imports = this.collectImports(tokens);
+    const staticPrefix = this.staticLetPrefix(options);
+    const frozen = this.frozenPrefix(options);
+    const lines = [];
+    lines.push(buildGeneratedFileHeader());
+    lines.push("");
+    for (const imp of imports) {
+      lines.push(`import ${imp}`);
+    }
+    lines.push(...this.buildStructDefinitions(tokens, access, options));
+    this.pushTokenLayout(lines, groups, options, access, staticPrefix, frozen);
+    lines.push(...this.buildViewExtensions(tokens, access, options));
+    if (options.structure !== "grouped") {
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  pushTokenLayout(lines, groups, options, access, staticPrefix, frozen) {
+    const i1 = indentStr(options.indent, 1);
+    const i2 = indentStr(options.indent, 2);
+    if (options.structure === "grouped") {
+      this.pushGroupedLayout(lines, groups, options, access, i1, i2, staticPrefix, frozen);
+      return;
+    }
+    lines.push("");
+    lines.push(`${frozen}${access} enum ${options.enumName} {`);
+    for (const group of groups) {
+      lines.push(`${i1}${frozen}${access} enum ${group.name} {`);
+      this.pushTokenDeclarations(lines, group.tokens, options, access, i2, staticPrefix);
+      lines.push(`${i1}}`);
+      lines.push("");
+    }
+    lines.push("}");
+  }
+  pushGroupedLayout(lines, groups, options, access, i1, i2, staticPrefix, frozen) {
+    const namespace = options.extensionNamespace;
+    lines.push("");
+    lines.push(`${frozen}${access} enum ${namespace} {}`);
+    lines.push("");
+    for (const group of groups) {
+      lines.push(`${access} extension ${namespace} {`);
+      lines.push(`${i1}${frozen}enum ${group.name} {`);
+      this.pushTokenDeclarations(lines, group.tokens, options, access, i2, staticPrefix);
+      lines.push(`${i1}}`);
+      lines.push("}");
+      lines.push("");
+    }
+  }
+  pushTokenDeclarations(lines, tokens, options, access, indent, staticPrefix) {
+    for (const token of tokens) {
+      const swiftName = this.buildQualifiedSwiftName(token);
+      const swiftValue = this.formatSwiftValue(token, options);
+      const typeAnnotation = this.getTypeAnnotation(token);
+      const annotation = typeAnnotation ? `: ${typeAnnotation}` : "";
+      const docComment = buildTokenDescriptionComment(token, "swift");
+      if (docComment) {
+        lines.push(`${indent}${docComment}`);
+      }
+      const deprecationAttr = buildSwiftDeprecationAttribute(token);
+      if (deprecationAttr) {
+        lines.push(`${indent}${deprecationAttr}`);
+      }
+      lines.push(`${indent}${access} ${staticPrefix}${swiftName}${annotation} = ${swiftValue}`);
+    }
+  }
+  collectImports(tokens) {
+    const imports = /* @__PURE__ */ new Set();
+    imports.add("SwiftUI");
+    for (const [, token] of Object.entries(tokens)) {
+      if (token.$type === "duration") {
+        imports.add("Foundation");
+      }
+    }
+    return Array.from(imports).sort();
+  }
+  /**
+   * Builds a qualified Swift name from a token's path, preserving parent
+   * hierarchy segments to avoid duplicate identifiers.
+   *
+   * For example, `color.blue.400` in the `Colors` group becomes `blue400`
+   * instead of just `_400`.
+   */
+  buildQualifiedSwiftName(token) {
+    const path = token.path;
+    const withoutTypePrefix = path.length > 1 ? path.slice(1) : path;
+    const joined = withoutTypePrefix.join("_");
+    return toSafeIdentifier(joined, SWIFT_KEYWORDS, false);
+  }
+  formatSwiftValue(token, options) {
+    const { $type, $value: value } = token;
+    switch ($type) {
+      case "color":
+        return this.formatColorValue(value, options);
+      case "dimension":
+        return this.formatDimensionValue(value);
+      case "fontFamily":
+        return this.formatFontFamilyValue(value);
+      case "fontWeight":
+        return this.formatFontWeightValue(value);
+      case "duration":
+        return this.formatDurationValue(value);
+      case "shadow":
+        return this.formatShadowValue(value, options);
+      case "typography":
+        return this.formatTypographyValue(value);
+      case "border":
+        return this.formatBorderValue(value, options);
+      case "gradient":
+        return this.formatGradientValue(value, options);
+      case "number":
+        return String(value);
+      case "cubicBezier":
+        if (Array.isArray(value) && value.length === 4) {
+          return `UnitCurve.bezier(startControlPoint: UnitPoint(x: ${value[0]}, y: ${value[1]}), endControlPoint: UnitPoint(x: ${value[2]}, y: ${value[3]}))`;
+        }
+        break;
+    }
+    return this.formatSwiftPrimitive(value);
+  }
+  formatSwiftPrimitive(value) {
+    if (typeof value === "string") {
+      return `"${this.escapeSwiftString(value)}"`;
+    }
+    if (typeof value === "number") {
+      return String(value);
+    }
+    if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    }
+    return `"${this.escapeSwiftString(String(value))}"`;
+  }
+  formatColorValue(value, options) {
+    if (!isColorObject(value)) {
+      return typeof value === "string" ? `Color("${this.escapeSwiftString(value)}")` : "Color.clear";
+    }
+    const colorObj = value;
+    const alpha = colorObj.alpha ?? 1;
+    if (options.colorSpace === "displayP3") {
+      const p3 = toP3(dtcgObjectToCulori(colorObj));
+      const r2 = this.roundComponent(p3?.r ?? 0);
+      const g2 = this.roundComponent(p3?.g ?? 0);
+      const b2 = this.roundComponent(p3?.b ?? 0);
+      return alpha < 1 ? `Color(.displayP3, red: ${r2}, green: ${g2}, blue: ${b2}, opacity: ${this.roundComponent(alpha)})` : `Color(.displayP3, red: ${r2}, green: ${g2}, blue: ${b2})`;
+    }
+    const rgb = toSRGB(dtcgObjectToCulori(colorObj));
+    const r = this.roundComponent(rgb?.r ?? 0);
+    const g = this.roundComponent(rgb?.g ?? 0);
+    const b = this.roundComponent(rgb?.b ?? 0);
+    return alpha < 1 ? `Color(red: ${r}, green: ${g}, blue: ${b}, opacity: ${this.roundComponent(alpha)})` : `Color(red: ${r}, green: ${g}, blue: ${b})`;
+  }
+  formatDimensionValue(value) {
+    if (isDimensionObject(value)) {
+      return this.dimensionToPoints(value);
+    }
+    return String(value);
+  }
+  formatFontFamilyValue(value) {
+    if (Array.isArray(value)) {
+      const primary = value[0];
+      return typeof primary === "string" ? `"${this.escapeSwiftString(primary)}"` : '"system"';
+    }
+    return typeof value === "string" ? `"${this.escapeSwiftString(value)}"` : '"system"';
+  }
+  formatFontWeightValue(value) {
+    if (typeof value === "number") {
+      return this.numericFontWeight(value);
+    }
+    if (typeof value === "string") {
+      return this.namedFontWeight(value) ?? "Font.Weight.regular";
+    }
+    return "Font.Weight.regular";
+  }
+  numericFontWeight(weight) {
+    if (weight <= 100) {
+      return "Font.Weight.ultraLight";
+    }
+    if (weight <= 200) {
+      return "Font.Weight.thin";
+    }
+    if (weight <= 300) {
+      return "Font.Weight.light";
+    }
+    if (weight <= 400) {
+      return "Font.Weight.regular";
+    }
+    if (weight <= 500) {
+      return "Font.Weight.medium";
+    }
+    if (weight <= 600) {
+      return "Font.Weight.semibold";
+    }
+    if (weight <= 700) {
+      return "Font.Weight.bold";
+    }
+    if (weight <= 800) {
+      return "Font.Weight.heavy";
+    }
+    return "Font.Weight.black";
+  }
+  namedFontWeight(name) {
+    const map = {
+      thin: "Font.Weight.thin",
+      ultralight: "Font.Weight.ultraLight",
+      extralight: "Font.Weight.ultraLight",
+      light: "Font.Weight.light",
+      regular: "Font.Weight.regular",
+      normal: "Font.Weight.regular",
+      medium: "Font.Weight.medium",
+      semibold: "Font.Weight.semibold",
+      demibold: "Font.Weight.semibold",
+      bold: "Font.Weight.bold",
+      heavy: "Font.Weight.heavy",
+      extrabold: "Font.Weight.heavy",
+      black: "Font.Weight.black",
+      ultrabold: "Font.Weight.black"
+    };
+    return map[name.toLowerCase()];
+  }
+  formatDurationValue(value) {
+    if (isDurationObject(value)) {
+      const dur = value;
+      const seconds = dur.unit === "ms" ? dur.value / 1e3 : dur.value;
+      return String(seconds);
+    }
+    return typeof value === "number" ? String(value) : "0";
+  }
+  formatShadowValue(value, options) {
+    if (Array.isArray(value) && value.length > 0) {
+      return this.formatSingleShadow(value[0], options);
+    }
+    if (typeof value === "object" && value !== null) {
+      return this.formatSingleShadow(value, options);
+    }
+    return "ShadowStyle(color: .clear, radius: 0, x: 0, y: 0, spread: 0)";
+  }
+  formatSingleShadow(shadow, options) {
+    const color = isColorObject(shadow.color) ? this.formatColorValue(shadow.color, options) : "Color.black.opacity(0.25)";
+    const radius = isDimensionObject(shadow.blur) ? this.dimensionToCGFloat(shadow.blur) : "8";
+    const x = isDimensionObject(shadow.offsetX) ? this.dimensionToCGFloat(shadow.offsetX) : "0";
+    const y = isDimensionObject(shadow.offsetY) ? this.dimensionToCGFloat(shadow.offsetY) : "0";
+    const spread = isDimensionObject(shadow.spread) ? this.dimensionToCGFloat(shadow.spread) : "0";
+    return `ShadowStyle(color: ${color}, radius: ${radius}, x: ${x}, y: ${y}, spread: ${spread})`;
+  }
+  formatTypographyValue(value) {
+    if (typeof value !== "object" || value === null) {
+      return "TypographyStyle(font: Font.body, tracking: 0, lineSpacing: 0)";
+    }
+    const typo = value;
+    const size = isDimensionObject(typo.fontSize) ? this.dimensionToPoints(typo.fontSize) : "16";
+    const weight = typo.fontWeight != null ? this.formatFontWeightValue(typo.fontWeight) : "Font.Weight.regular";
+    const fontExpr = this.buildFontExpression(typo, size, weight);
+    const tracking = this.extractTracking(typo);
+    const lineSpacing = this.extractLineSpacing(typo);
+    return `TypographyStyle(font: ${fontExpr}, tracking: ${tracking}, lineSpacing: ${lineSpacing})`;
+  }
+  buildFontExpression(typo, size, weight) {
+    if (typo.fontFamily != null) {
+      const family = Array.isArray(typo.fontFamily) ? typo.fontFamily[0] : typo.fontFamily;
+      if (typeof family === "string") {
+        return `Font.custom("${this.escapeSwiftString(family)}", size: ${size}).weight(${weight})`;
+      }
+    }
+    return `Font.system(size: ${size}, weight: ${weight})`;
+  }
+  extractTracking(typo) {
+    if (!isDimensionObject(typo.letterSpacing)) {
+      return "0";
+    }
+    return this.dimensionToPoints(typo.letterSpacing);
+  }
+  extractLineSpacing(typo) {
+    if (typo.lineHeight == null || typeof typo.lineHeight !== "number") {
+      return "0";
+    }
+    if (!isDimensionObject(typo.fontSize)) {
+      return "0";
+    }
+    const basePt = this.dimensionToNumericPoints(typo.fontSize);
+    const lineHeightPt = Math.round(basePt * typo.lineHeight * 100) / 100;
+    return String(lineHeightPt - basePt);
+  }
+  dimensionToNumericPoints(dim) {
+    return dim.unit === "rem" ? dim.value * 16 : dim.value;
+  }
+  dimensionToPoints(dim) {
+    return String(this.dimensionToNumericPoints(dim));
+  }
+  /** Formats a dimension as a CGFloat literal (appends `.0` for integers). */
+  dimensionToCGFloat(dim) {
+    const ptValue = this.dimensionToNumericPoints(dim);
+    return Number.isInteger(ptValue) ? `${ptValue}.0` : String(ptValue);
+  }
+  getTypeAnnotation(token) {
+    switch (token.$type) {
+      case "dimension":
+        return "CGFloat";
+      case "duration":
+        return "TimeInterval";
+      case "number":
+        return "Double";
+      case "fontWeight":
+        return "Font.Weight";
+      case "fontFamily":
+        return "String";
+      default:
+        return void 0;
+    }
+  }
+  escapeSwiftString(str) {
+    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+  }
+  roundComponent(value) {
+    return Math.round(value * 1e4) / 1e4;
+  }
+  /**
+   * Returns the prefix for `static let` declarations.
+   * Swift 6 requires `nonisolated(unsafe)` on global stored properties.
+   */
+  staticLetPrefix(options) {
+    return options.swiftVersion === "6.0" ? "nonisolated(unsafe) static let " : "static let ";
+  }
+  /** Returns `@frozen ` when the frozen option is enabled, empty string otherwise. */
+  frozenPrefix(options) {
+    return options.frozen ? "@frozen " : "";
+  }
+  /** Returns `: Sendable` when targeting Swift 6, empty string otherwise. */
+  structConformances(options) {
+    return options.swiftVersion === "6.0" ? ": Sendable" : "";
+  }
+  /** Emits all struct definitions needed by the token set. */
+  buildStructDefinitions(tokens, access, options) {
+    const lines = [];
+    if (Object.values(tokens).some(isShadowToken)) {
+      lines.push("");
+      lines.push(...this.buildShadowStyleStruct(access, options));
+    }
+    if (Object.values(tokens).some(isTypographyToken)) {
+      lines.push("");
+      lines.push(...this.buildTypographyStyleStruct(access, options));
+    }
+    if (Object.values(tokens).some(isBorderToken)) {
+      lines.push("");
+      lines.push(...this.buildBorderStyleStruct(access, options));
+    }
+    return lines;
+  }
+  buildShadowStyleStruct(access, options) {
+    const i1 = indentStr(options.indent, 1);
+    const conformances = this.structConformances(options);
+    const frozen = this.frozenPrefix(options);
+    return [
+      `${frozen}${access} struct ShadowStyle${conformances} {`,
+      `${i1}${access} let color: Color`,
+      `${i1}${access} let radius: CGFloat`,
+      `${i1}${access} let x: CGFloat`,
+      `${i1}${access} let y: CGFloat`,
+      `${i1}${access} let spread: CGFloat`,
+      "}"
+    ];
+  }
+  buildTypographyStyleStruct(access, options) {
+    const i1 = indentStr(options.indent, 1);
+    const conformances = this.structConformances(options);
+    const frozen = this.frozenPrefix(options);
+    return [
+      `${frozen}${access} struct TypographyStyle${conformances} {`,
+      `${i1}${access} let font: Font`,
+      `${i1}${access} let tracking: CGFloat`,
+      `${i1}${access} let lineSpacing: CGFloat`,
+      "}"
+    ];
+  }
+  buildBorderStyleStruct(access, options) {
+    const i1 = indentStr(options.indent, 1);
+    const conformances = this.structConformances(options);
+    const frozen = this.frozenPrefix(options);
+    return [
+      `${frozen}${access} struct BorderStyle${conformances} {`,
+      `${i1}${access} let color: Color`,
+      `${i1}${access} let width: CGFloat`,
+      "}"
+    ];
+  }
+  /** Emits convenience View extensions for shadow and typography application. */
+  buildViewExtensions(tokens, access, options) {
+    const lines = [];
+    const i1 = indentStr(options.indent, 1);
+    const i2 = indentStr(options.indent, 2);
+    if (Object.values(tokens).some(isShadowToken)) {
+      lines.push("");
+      lines.push(`${access} extension View {`);
+      lines.push(`${i1}func shadowStyle(_ style: ShadowStyle) -> some View {`);
+      lines.push(
+        `${i2}self.shadow(color: style.color, radius: style.radius, x: style.x, y: style.y)`
+      );
+      lines.push(`${i1}}`);
+      lines.push("}");
+    }
+    if (Object.values(tokens).some(isTypographyToken)) {
+      lines.push("");
+      lines.push(`${access} extension View {`);
+      lines.push(`${i1}func typographyStyle(_ style: TypographyStyle) -> some View {`);
+      lines.push(
+        `${i2}self.font(style.font).tracking(style.tracking).lineSpacing(style.lineSpacing)`
+      );
+      lines.push(`${i1}}`);
+      lines.push("}");
+    }
+    return lines;
+  }
+  formatBorderValue(value, options) {
+    if (typeof value !== "object" || value === null) {
+      return "BorderStyle(color: .clear, width: 0)";
+    }
+    const border = value;
+    const color = isColorObject(border.color) ? this.formatColorValue(border.color, options) : "Color.clear";
+    const width = isDimensionObject(border.width) ? this.dimensionToCGFloat(border.width) : "1.0";
+    return `BorderStyle(color: ${color}, width: ${width})`;
+  }
+  formatGradientValue(value, options) {
+    if (!Array.isArray(value) || value.length === 0) {
+      return "Gradient(stops: [])";
+    }
+    const stops = value.map((stop) => {
+      const color = isColorObject(stop.color) ? this.formatColorValue(stop.color, options) : "Color.clear";
+      return `.init(color: ${color}, location: ${stop.position})`;
+    });
+    return `Gradient(stops: [${stops.join(", ")}])`;
+  }
+  async formatStandalone(context, options) {
+    assertFileRequired(
+      context.buildPath,
+      context.output.file,
+      context.output.name,
+      "standalone iOS"
+    );
+    const files = {};
+    for (const { tokens, modifierInputs } of context.permutations) {
+      const processedTokens = stripInternalMetadata(tokens);
+      const content = this.formatTokens(processedTokens, options);
+      const fileName = context.output.file ? resolveFileName(context.output.file, modifierInputs) : buildInMemoryOutputKey({
+        outputName: context.output.name,
+        extension: "swift",
+        modifierInputs,
+        resolver: context.resolver,
+        defaults: context.meta.defaults
+      });
+      files[fileName] = content;
+    }
+    return outputTree(files);
+  }
+};
+function iosRenderer() {
+  const rendererInstance = new IosRenderer();
+  return {
+    format: (context, options) => rendererInstance.format(
+      context,
+      options ?? context.output.options
+    )
+  };
+}
+
+// src/outputs/android/renderer.ts
+init_errors();
+init_token_utils();
+init_utils();
+init_metadata();
+var toSRGB2 = converter("rgb");
+var toP32 = converter("p3");
+var KOTLIN_KEYWORDS = /* @__PURE__ */ new Set([
+  "val",
+  "var",
+  "fun",
+  "class",
+  "object",
+  "when",
+  "is",
+  "in",
+  "return",
+  "break",
+  "continue",
+  "do",
+  "while",
+  "for",
+  "if",
+  "else",
+  "try",
+  "catch",
+  "throw",
+  "as",
+  "this",
+  "super",
+  "null",
+  "true",
+  "false"
+]);
+var KOTLIN_TYPE_GROUP_MAP = {
+  color: "Colors",
+  dimension: "Spacing",
+  fontFamily: "Fonts",
+  fontWeight: "FontWeights",
+  duration: "Durations",
+  shadow: "Shadows",
+  typography: "Typography",
+  number: "Numbers",
+  cubicBezier: "Animations",
+  border: "Borders"
+};
+function resolveColorFormat(format) {
+  if (format === "argb_floats" || format === "argb_float") {
+    return "argb_float";
+  }
+  return "argb_hex";
+}
+function escapeKotlinString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\$/g, "\\$");
+}
+function formatKotlinNumber(value) {
+  return Number.isInteger(value) ? `${value}.0` : String(value);
+}
+function roundComponent(value) {
+  return Math.round(value * 1e3) / 1e3;
+}
+function toResourceName(family) {
+  return family.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+}
+var AndroidRenderer = class {
+  async format(context, options) {
+    if (!options?.packageName) {
+      throw new ConfigurationError(
+        `Output "${context.output.name}": packageName is required for Android output`
+      );
+    }
+    const visibility = options?.visibility;
+    const opts = {
+      preset: options?.preset ?? "standalone",
+      packageName: options.packageName,
+      objectName: options?.objectName ?? "DesignTokens",
+      colorFormat: resolveColorFormat(options?.colorFormat),
+      colorSpace: options?.colorSpace ?? "sRGB",
+      structure: options?.structure ?? "nested",
+      visibility,
+      visPrefix: visibility ? `${visibility} ` : "",
+      indent: options?.indent ?? 4
+    };
+    if (opts.preset === "bundle") {
+      return await this.formatBundle(context, opts);
+    }
+    return await this.formatStandalone(context, opts);
+  }
+  // -----------------------------------------------------------------------
+  // Token tree (nested mode)
+  // -----------------------------------------------------------------------
+  buildTokenTree(tokens) {
+    const root = { children: /* @__PURE__ */ new Map() };
+    for (const [, token] of getSortedTokenEntries(tokens)) {
+      let current = root;
+      const segments = token.path;
+      for (let i = 0; i < segments.length - 1; i++) {
+        const seg = segments[i];
+        if (!current.children.has(seg)) {
+          current.children.set(seg, { children: /* @__PURE__ */ new Map() });
+        }
+        current = current.children.get(seg);
+      }
+      const leafName = segments[segments.length - 1] ?? token.name;
+      const leaf = current.children.get(leafName) ?? { children: /* @__PURE__ */ new Map() };
+      leaf.token = token;
+      current.children.set(leafName, leaf);
+    }
+    return root;
+  }
+  // -----------------------------------------------------------------------
+  // Flat structure grouping
+  // -----------------------------------------------------------------------
+  /**
+   * Builds a flattened camelCase name from a token's path, stripping the
+   * type prefix segment (which is already represented by the group object).
+   */
+  buildFlatKotlinName(token) {
+    const path = token.path;
+    const withoutTypePrefix = path.length > 1 ? path.slice(1) : path;
+    const joined = withoutTypePrefix.join("_");
+    return toSafeIdentifier(joined, KOTLIN_KEYWORDS, false);
+  }
+  // -----------------------------------------------------------------------
+  // Rendering
+  // -----------------------------------------------------------------------
+  formatTokens(tokens, options) {
+    if (options.structure === "flat") {
+      return this.formatAsFlat(tokens, options);
+    }
+    return this.formatAsNested(tokens, options);
+  }
+  formatAsNested(tokens, options) {
+    const tokenTypes = this.collectTokenTypesFromEntries(tokens);
+    const tree = this.buildTokenTree(tokens);
+    return this.buildFile(tokenTypes, options, (lines) => {
+      lines.push(`@Suppress("unused")`);
+      lines.push(`${options.visPrefix}object ${options.objectName} {`);
+      this.renderTreeChildren(lines, tree, 1, options);
+      lines.push("}");
+    });
+  }
+  formatAsFlat(tokens, options) {
+    const groups = groupTokensByType(tokens, KOTLIN_TYPE_GROUP_MAP);
+    const tokenTypes = this.collectTokenTypesFromEntries(tokens);
+    return this.buildFile(tokenTypes, options, (lines) => {
+      lines.push(`@Suppress("unused")`);
+      lines.push(`${options.visPrefix}object ${options.objectName} {`);
+      this.renderFlatGroups(lines, groups, 1, options);
+      lines.push("}");
+    });
+  }
+  /**
+   * Shared file preamble: header, package, imports, optional ShadowToken class.
+   * The `renderBody` callback appends the main object(s) to `lines`.
+   */
+  buildFile(tokenTypes, options, renderBody) {
+    const imports = this.collectImports(tokenTypes, options);
+    const lines = [];
+    lines.push(buildGeneratedFileHeader());
+    lines.push("");
+    lines.push(`package ${options.packageName}`);
+    lines.push("");
+    for (const imp of imports) {
+      lines.push(`import ${imp}`);
+    }
+    if (imports.length > 0) {
+      lines.push("");
+    }
+    if (tokenTypes.has("shadow")) {
+      lines.push(...this.buildShadowTokenClass(options));
+      lines.push("");
+    }
+    renderBody(lines);
+    lines.push("");
+    return lines.join("\n");
+  }
+  renderFlatGroups(lines, groups, baseDepth, options) {
+    const groupIndent = indentStr(options.indent, baseDepth);
+    const valIndent = indentStr(options.indent, baseDepth + 1);
+    for (const group of groups) {
+      lines.push(`${groupIndent}${options.visPrefix}object ${group.name} {`);
+      for (const token of group.tokens) {
+        const kotlinName = this.buildFlatKotlinName(token);
+        const kotlinValue = this.formatKotlinValue(token, options, baseDepth + 1);
+        const annotation = this.typeAnnotationSuffix(token);
+        const descriptionComment = buildTokenDescriptionComment(token, "kotlin");
+        if (descriptionComment) {
+          lines.push(`${valIndent}${descriptionComment}`);
+        }
+        const deprecation = buildKotlinDeprecationAnnotation(token);
+        if (deprecation) {
+          lines.push(`${valIndent}${deprecation}`);
+        }
+        lines.push(
+          `${valIndent}${options.visPrefix}val ${kotlinName}${annotation} = ${kotlinValue}`
+        );
+      }
+      lines.push(`${groupIndent}}`);
+      lines.push("");
+    }
+  }
+  renderTreeChildren(lines, node, depth, options) {
+    const pad = indentStr(options.indent, depth);
+    const entries = Array.from(node.children.entries());
+    for (let idx = 0; idx < entries.length; idx++) {
+      const [key, child] = entries[idx];
+      if (child.token && child.children.size === 0) {
+        this.renderLeaf(lines, key, child.token, depth, options);
+      } else if (child.children.size > 0 && !child.token) {
+        const objectName = toSafeIdentifier(key, KOTLIN_KEYWORDS, true);
+        lines.push(`${pad}${options.visPrefix}object ${objectName} {`);
+        this.renderTreeChildren(lines, child, depth + 1, options);
+        lines.push(`${pad}}`);
+        if (idx < entries.length - 1) {
+          lines.push("");
+        }
+      } else {
+        this.renderLeaf(lines, key, child.token, depth, options);
+        this.renderTreeChildren(lines, child, depth, options);
+      }
+    }
+  }
+  renderLeaf(lines, key, token, depth, options) {
+    const pad = indentStr(options.indent, depth);
+    const kotlinName = toSafeIdentifier(key, KOTLIN_KEYWORDS, false);
+    const kotlinValue = this.formatKotlinValue(token, options, depth);
+    const annotation = this.typeAnnotationSuffix(token);
+    const descriptionComment = buildTokenDescriptionComment(token, "kotlin");
+    if (descriptionComment) {
+      lines.push(`${pad}${descriptionComment}`);
+    }
+    const deprecation = buildKotlinDeprecationAnnotation(token);
+    if (deprecation) {
+      lines.push(`${pad}${deprecation}`);
+    }
+    lines.push(`${pad}${options.visPrefix}val ${kotlinName}${annotation} = ${kotlinValue}`);
+  }
+  // -----------------------------------------------------------------------
+  // Shadow data class
+  // -----------------------------------------------------------------------
+  buildShadowTokenClass(options) {
+    const i1 = indentStr(options.indent, 1);
+    return [
+      "@Immutable",
+      `${options.visPrefix}data class ShadowToken(`,
+      `${i1}val color: Color,`,
+      `${i1}val elevation: Dp,`,
+      `${i1}val offsetX: Dp,`,
+      `${i1}val offsetY: Dp,`,
+      ")"
+    ];
+  }
+  // -----------------------------------------------------------------------
+  // Imports (tree-shaken)
+  // -----------------------------------------------------------------------
+  collectImports(tokenTypes, options) {
+    const imports = /* @__PURE__ */ new Set();
+    const ns = "androidx.compose";
+    const hasColors = tokenTypes.has("color") || tokenTypes.has("shadow") || tokenTypes.has("border");
+    if (hasColors) {
+      imports.add(`${ns}.ui.graphics.Color`);
+    }
+    if (tokenTypes.has("dimension") || tokenTypes.has("shadow") || tokenTypes.has("border")) {
+      imports.add(`${ns}.ui.unit.Dp`);
+      imports.add(`${ns}.ui.unit.dp`);
+    }
+    if (tokenTypes.has("typography") || tokenTypes.has("fontFamily")) {
+      imports.add(`${ns}.ui.text.TextStyle`);
+      imports.add(`${ns}.ui.unit.sp`);
+    }
+    if (tokenTypes.has("typography") || tokenTypes.has("fontWeight")) {
+      imports.add(`${ns}.ui.text.font.FontWeight`);
+    }
+    if (tokenTypes.has("fontFamily")) {
+      imports.add(`${ns}.ui.text.font.FontFamily`);
+    }
+    if (tokenTypes.has("duration")) {
+      imports.add("kotlin.time.Duration");
+      imports.add("kotlin.time.Duration.Companion.milliseconds");
+      imports.add("kotlin.time.Duration.Companion.seconds");
+    }
+    if (tokenTypes.has("cubicBezier")) {
+      imports.add(`${ns}.animation.core.CubicBezierEasing`);
+    }
+    if (tokenTypes.has("shadow")) {
+      imports.add(`${ns}.runtime.Immutable`);
+    }
+    if (tokenTypes.has("border")) {
+      imports.add(`${ns}.foundation.BorderStroke`);
+    }
+    if (options.colorSpace === "displayP3" && hasColors) {
+      imports.add(`${ns}.ui.graphics.colorspace.ColorSpaces`);
+    }
+    return Array.from(imports).sort();
+  }
+  collectTokenTypesFromEntries(tokens) {
+    const types = /* @__PURE__ */ new Set();
+    for (const [, token] of Object.entries(tokens)) {
+      if (token.$type) {
+        types.add(token.$type);
+      }
+    }
+    return types;
+  }
+  // -----------------------------------------------------------------------
+  // Type annotations
+  // -----------------------------------------------------------------------
+  getTypeAnnotation(token) {
+    switch (token.$type) {
+      case "color":
+        return "Color";
+      case "dimension":
+        return "Dp";
+      case "fontFamily":
+        return "FontFamily";
+      case "fontWeight":
+        return "FontWeight";
+      case "duration":
+        return "Duration";
+      case "shadow":
+        return "ShadowToken";
+      case "cubicBezier":
+        return "CubicBezierEasing";
+      case "number":
+        return "Double";
+      case "typography":
+        return "TextStyle";
+      case "border":
+        return "BorderStroke";
+      default: {
+        const value = token.$value;
+        if (typeof value === "string") {
+          return "String";
+        }
+        if (typeof value === "boolean") {
+          return "Boolean";
+        }
+        if (typeof value === "number") {
+          return "Double";
+        }
+        return void 0;
+      }
+    }
+  }
+  typeAnnotationSuffix(token) {
+    const type = this.getTypeAnnotation(token);
+    return type ? `: ${type}` : "";
+  }
+  // -----------------------------------------------------------------------
+  // Value formatting
+  // -----------------------------------------------------------------------
+  formatKotlinValue(token, options, depth) {
+    const value = token.$value;
+    if (token.$type === "color") {
+      return this.formatColorValue(value, options);
+    }
+    if (token.$type === "dimension") {
+      return this.formatDimensionValue(value);
+    }
+    if (token.$type === "fontFamily") {
+      return this.formatFontFamilyValue(value);
+    }
+    if (token.$type === "fontWeight") {
+      return this.formatFontWeightValue(value);
+    }
+    if (token.$type === "duration") {
+      return this.formatDurationValue(value);
+    }
+    if (token.$type === "shadow") {
+      return this.formatShadowValue(value, options, depth);
+    }
+    if (token.$type === "typography") {
+      return this.formatTypographyValue(value, options, depth);
+    }
+    if (token.$type === "border") {
+      return this.formatBorderValue(value, options);
+    }
+    if (token.$type === "number") {
+      return typeof value === "number" ? formatKotlinNumber(value) : String(value);
+    }
+    if (token.$type === "cubicBezier" && Array.isArray(value) && value.length === 4) {
+      return `CubicBezierEasing(${value[0]}f, ${value[1]}f, ${value[2]}f, ${value[3]}f)`;
+    }
+    if (typeof value === "string") {
+      return `"${escapeKotlinString(value)}"`;
+    }
+    if (typeof value === "number") {
+      return formatKotlinNumber(value);
+    }
+    if (typeof value === "boolean") {
+      return value ? "true" : "false";
+    }
+    return `"${escapeKotlinString(String(value))}"`;
+  }
+  formatColorValue(value, options) {
+    if (!isColorObject(value)) {
+      if (typeof value === "string") {
+        const hex = value.replace("#", "");
+        if (/^[0-9a-fA-F]{6,8}$/.test(hex)) {
+          const argb = hex.length === 8 ? hex : `FF${hex}`;
+          return `Color(0x${argb.toUpperCase()})`;
+        }
+      }
+      return "Color.Unspecified";
+    }
+    const colorObj = value;
+    const alpha = colorObj.alpha ?? 1;
+    if (options.colorFormat === "argb_float" || options.colorSpace === "displayP3") {
+      return this.formatFloatColor(colorObj, alpha, options);
+    }
+    return this.formatHexColor(colorObj, alpha);
+  }
+  formatFloatColor(colorObj, alpha, options) {
+    if (options.colorSpace === "displayP3") {
+      const p3 = toP32(dtcgObjectToCulori(colorObj));
+      const r2 = roundComponent(p3?.r ?? 0);
+      const g2 = roundComponent(p3?.g ?? 0);
+      const b2 = roundComponent(p3?.b ?? 0);
+      return `Color(${r2}f, ${g2}f, ${b2}f, ${roundComponent(alpha)}f, ColorSpaces.DisplayP3)`;
+    }
+    const rgb = toSRGB2(dtcgObjectToCulori(colorObj));
+    const r = roundComponent(rgb?.r ?? 0);
+    const g = roundComponent(rgb?.g ?? 0);
+    const b = roundComponent(rgb?.b ?? 0);
+    return `Color(${r}f, ${g}f, ${b}f, ${roundComponent(alpha)}f)`;
+  }
+  formatHexColor(colorObj, alpha) {
+    const hex = colorObjectToHex(colorObj);
+    const hexClean = hex.replace("#", "");
+    if (hexClean.length === 8) {
+      const rrggbb = hexClean.slice(0, 6);
+      const aa = hexClean.slice(6, 8);
+      return `Color(0x${aa.toUpperCase()}${rrggbb.toUpperCase()})`;
+    }
+    const alphaHex = alpha < 1 ? Math.round(alpha * 255).toString(16).padStart(2, "0").toUpperCase() : "FF";
+    return `Color(0x${alphaHex}${hexClean.toUpperCase()})`;
+  }
+  formatDimensionValue(value) {
+    if (isDimensionObject(value)) {
+      const dim = value;
+      const dpValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
+      return `${dpValue}.dp`;
+    }
+    return typeof value === "number" ? `${value}.dp` : `0.dp`;
+  }
+  formatFontFamilyValue(value) {
+    if (Array.isArray(value)) {
+      const primary = value[0];
+      if (typeof primary === "string") {
+        return this.mapKotlinFontFamily(primary);
+      }
+      return "FontFamily.Default";
+    }
+    return typeof value === "string" ? this.mapKotlinFontFamily(value) : "FontFamily.Default";
+  }
+  mapKotlinFontFamily(family) {
+    const normalized = family.toLowerCase().replace(/['"]/g, "").trim();
+    const builtIn = {
+      "sans-serif": "FontFamily.SansSerif",
+      serif: "FontFamily.Serif",
+      monospace: "FontFamily.Monospace",
+      cursive: "FontFamily.Cursive"
+    };
+    return builtIn[normalized] ?? `FontFamily.Default // TODO: load "${family}" via Font(R.font.${toResourceName(family)})`;
+  }
+  formatFontWeightValue(value) {
+    if (typeof value === "number") {
+      return this.numericFontWeight(value);
+    }
+    if (typeof value === "string") {
+      return this.namedFontWeight(value) ?? "FontWeight.Normal";
+    }
+    return "FontWeight.Normal";
+  }
+  numericFontWeight(weight) {
+    if (weight <= 100) {
+      return "FontWeight.Thin";
+    }
+    if (weight <= 200) {
+      return "FontWeight.ExtraLight";
+    }
+    if (weight <= 300) {
+      return "FontWeight.Light";
+    }
+    if (weight <= 400) {
+      return "FontWeight.Normal";
+    }
+    if (weight <= 500) {
+      return "FontWeight.Medium";
+    }
+    if (weight <= 600) {
+      return "FontWeight.SemiBold";
+    }
+    if (weight <= 700) {
+      return "FontWeight.Bold";
+    }
+    if (weight <= 800) {
+      return "FontWeight.ExtraBold";
+    }
+    return "FontWeight.Black";
+  }
+  namedFontWeight(name) {
+    const map = {
+      thin: "FontWeight.Thin",
+      extralight: "FontWeight.ExtraLight",
+      ultralight: "FontWeight.ExtraLight",
+      light: "FontWeight.Light",
+      regular: "FontWeight.Normal",
+      normal: "FontWeight.Normal",
+      medium: "FontWeight.Medium",
+      semibold: "FontWeight.SemiBold",
+      demibold: "FontWeight.SemiBold",
+      bold: "FontWeight.Bold",
+      extrabold: "FontWeight.ExtraBold",
+      heavy: "FontWeight.ExtraBold",
+      black: "FontWeight.Black",
+      ultrabold: "FontWeight.Black"
+    };
+    return map[name.toLowerCase()];
+  }
+  formatDurationValue(value) {
+    if (isDurationObject(value)) {
+      return value.unit === "ms" ? `${value.value}.milliseconds` : `${value.value}.seconds`;
+    }
+    return typeof value === "number" ? `${value}.milliseconds` : "0.milliseconds";
+  }
+  formatShadowValue(value, options, depth) {
+    if (Array.isArray(value) && value.length > 0) {
+      return this.formatSingleShadow(value[0], options, depth);
+    }
+    if (typeof value === "object" && value !== null) {
+      return this.formatSingleShadow(value, options, depth);
+    }
+    return "ShadowToken(color = Color.Unspecified, elevation = 0.dp, offsetX = 0.dp, offsetY = 0.dp)";
+  }
+  formatSingleShadow(shadow, options, depth) {
+    const color = isColorObject(shadow.color) ? this.formatColorValue(shadow.color, options) : "Color.Black";
+    const elevation = isDimensionObject(shadow.blur) ? this.formatDimensionValue(shadow.blur) : "0.dp";
+    const offsetX = isDimensionObject(shadow.offsetX) ? this.formatDimensionValue(shadow.offsetX) : "0.dp";
+    const offsetY = isDimensionObject(shadow.offsetY) ? this.formatDimensionValue(shadow.offsetY) : "0.dp";
+    const propIndent = indentStr(options.indent, depth + 1);
+    const closeIndent = indentStr(options.indent, depth);
+    return [
+      "ShadowToken(",
+      `${propIndent}color = ${color},`,
+      `${propIndent}elevation = ${elevation},`,
+      `${propIndent}offsetX = ${offsetX},`,
+      `${propIndent}offsetY = ${offsetY},`,
+      `${closeIndent})`
+    ].join("\n");
+  }
+  formatBorderValue(value, options) {
+    if (typeof value !== "object" || value === null) {
+      return "BorderStroke(0.dp, Color.Unspecified)";
+    }
+    const border = value;
+    const width = isDimensionObject(border.width) ? this.formatDimensionValue(border.width) : "0.dp";
+    const color = isColorObject(border.color) ? this.formatColorValue(border.color, options) : "Color.Unspecified";
+    return `BorderStroke(${width}, ${color})`;
+  }
+  formatTypographyValue(value, options, depth) {
+    if (typeof value !== "object" || value === null) {
+      return "TextStyle()";
+    }
+    const typo = value;
+    const parts = [];
+    if (isDimensionObject(typo.fontSize)) {
+      const dim = typo.fontSize;
+      const spValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
+      parts.push(`fontSize = ${spValue}.sp`);
+    }
+    if (typo.fontWeight != null) {
+      parts.push(`fontWeight = ${this.formatFontWeightValue(typo.fontWeight)}`);
+    }
+    if (typo.lineHeight != null && typeof typo.lineHeight === "number") {
+      if (isDimensionObject(typo.fontSize)) {
+        const dim = typo.fontSize;
+        const spValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
+        const lineHeightSp = Math.round(spValue * typo.lineHeight * 100) / 100;
+        parts.push(`lineHeight = ${lineHeightSp}.sp`);
+      }
+    }
+    if (isDimensionObject(typo.letterSpacing)) {
+      const dim = typo.letterSpacing;
+      const spValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
+      parts.push(`letterSpacing = ${spValue}.sp`);
+    }
+    if (parts.length === 0) {
+      return "TextStyle()";
+    }
+    const propIndent = indentStr(options.indent, depth + 1);
+    const closeIndent = indentStr(options.indent, depth);
+    return `TextStyle(
+${parts.map((p) => `${propIndent}${p}`).join(",\n")},
+${closeIndent})`;
+  }
+  // -----------------------------------------------------------------------
+  // Output: standalone
+  // -----------------------------------------------------------------------
+  async formatStandalone(context, options) {
+    assertFileRequired(
+      context.buildPath,
+      context.output.file,
+      context.output.name,
+      "standalone Android"
+    );
+    const files = {};
+    for (const { tokens, modifierInputs } of context.permutations) {
+      const processedTokens = stripInternalMetadata(tokens);
+      const content = this.formatTokens(processedTokens, options);
+      const fileName = context.output.file ? resolveFileName(context.output.file, modifierInputs) : buildInMemoryOutputKey({
+        outputName: context.output.name,
+        extension: "kt",
+        modifierInputs,
+        resolver: context.resolver,
+        defaults: context.meta.defaults
+      });
+      files[fileName] = content;
+    }
+    return outputTree(files);
+  }
+  // -----------------------------------------------------------------------
+  // Output: bundle
+  // -----------------------------------------------------------------------
+  async formatBundle(context, options) {
+    assertFileRequired(
+      context.buildPath,
+      context.output.file,
+      context.output.name,
+      "bundle Android"
+    );
+    const content = this.formatBundleContent(context, options);
+    const fileName = context.output.file ? resolveFileName(context.output.file, context.meta.basePermutation) : buildInMemoryOutputKey({
+      outputName: context.output.name,
+      extension: "kt",
+      modifierInputs: context.meta.basePermutation,
+      resolver: context.resolver,
+      defaults: context.meta.defaults
+    });
+    return outputTree({ [fileName]: content });
+  }
+  formatBundleContent(context, options) {
+    const allTokenTypes = this.collectAllPermutationTypes(context);
+    return this.buildFile(allTokenTypes, options, (lines) => {
+      const i1 = indentStr(options.indent, 1);
+      lines.push(`@Suppress("unused")`);
+      lines.push(`${options.visPrefix}object ${options.objectName} {`);
+      for (let idx = 0; idx < context.permutations.length; idx++) {
+        const { tokens, modifierInputs } = context.permutations[idx];
+        const processedTokens = stripInternalMetadata(tokens);
+        const permName = this.buildPermutationName(modifierInputs);
+        lines.push(`${i1}${options.visPrefix}object ${permName} {`);
+        this.renderBundleTokens(lines, processedTokens, options, 2);
+        lines.push(`${i1}}`);
+        if (idx < context.permutations.length - 1) {
+          lines.push("");
+        }
+      }
+      lines.push("}");
+    });
+  }
+  collectAllPermutationTypes(context) {
+    const types = /* @__PURE__ */ new Set();
+    for (const { tokens } of context.permutations) {
+      for (const t of this.collectTokenTypesFromEntries(stripInternalMetadata(tokens))) {
+        types.add(t);
+      }
+    }
+    return types;
+  }
+  renderBundleTokens(lines, tokens, options, baseDepth) {
+    if (options.structure === "flat") {
+      const groups = groupTokensByType(tokens, KOTLIN_TYPE_GROUP_MAP);
+      this.renderFlatGroups(lines, groups, baseDepth, options);
+      return;
+    }
+    const tree = this.buildTokenTree(tokens);
+    this.renderTreeChildren(lines, tree, baseDepth, options);
+  }
+  buildPermutationName(modifierInputs) {
+    const values = Object.values(modifierInputs);
+    if (values.length === 0) {
+      return "Default";
+    }
+    return values.map((v) => toSafeIdentifier(v, KOTLIN_KEYWORDS, true)).join("");
+  }
+};
+function androidRenderer() {
+  const rendererInstance = new AndroidRenderer();
+  return {
+    format: (context, options) => rendererInstance.format(
+      context,
+      options ?? context.output.options
+    )
+  };
+}
+
+// src/outputs/types.ts
+function defineRenderer(renderer) {
+  return renderer;
+}
+function nameKebabCase() {
+  return {
+    transform: (token) => {
+      const name = kebabCase(token.path.join(" "));
+      return {
+        ...token,
+        name
+      };
+    }
+  };
+}
+
+// src/outputs/builders.ts
+function css(config) {
+  const {
+    name,
+    file,
+    transforms,
+    filters,
+    hooks,
+    preset = "bundle",
+    ...rendererOptions
+  } = config;
+  return {
+    name,
+    file,
+    renderer: cssRenderer(),
+    options: { preset, ...rendererOptions },
+    transforms: [nameKebabCase(), ...transforms ?? []],
+    filters,
+    hooks
+  };
+}
+function json(config) {
+  const {
+    name,
+    file,
+    transforms,
+    filters,
+    hooks,
+    preset = "standalone",
+    ...rendererOptions
+  } = config;
+  return {
+    name,
+    file,
+    renderer: jsonRenderer(),
+    options: { preset, ...rendererOptions },
+    transforms,
+    filters,
+    hooks
+  };
+}
+function js(config) {
+  const {
+    name,
+    file,
+    transforms,
+    filters,
+    hooks,
+    preset = "standalone",
+    ...rendererOptions
+  } = config;
+  return {
+    name,
+    file,
+    renderer: jsRenderer(),
+    options: { preset, ...rendererOptions },
+    transforms,
+    filters,
+    hooks
+  };
+}
+function tailwind(config) {
+  const { name, file, transforms, filters, hooks, preset = "bundle", ...rendererOptions } = config;
+  return {
+    name,
+    file,
+    renderer: tailwindRenderer(),
+    options: { preset, ...rendererOptions },
+    transforms,
+    filters,
+    hooks
+  };
+}
+function ios(config) {
+  const {
+    name,
+    file,
+    transforms,
+    filters,
+    hooks,
+    preset = "standalone",
+    ...rendererOptions
+  } = config;
+  return {
+    name,
+    file,
+    renderer: iosRenderer(),
+    options: { preset, ...rendererOptions },
+    transforms,
+    filters,
+    hooks
+  };
+}
+function android(config) {
+  const {
+    name,
+    file,
+    transforms,
+    filters,
+    hooks,
+    preset = "standalone",
+    ...rendererOptions
+  } = config;
+  return {
+    name,
+    file,
+    renderer: androidRenderer(),
+    options: { preset, ...rendererOptions },
+    transforms,
+    filters,
+    hooks
+  };
+}
+/**
+ * @license MIT
+ * Copyright (c) 2025-present Dispersa Contributors
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+/**
+ * @license
+ * Copyright (c) 2025 Dispersa Contributors
+ * SPDX-License-Identifier: MIT
+ */
+
+export { android, androidRenderer, css, cssRenderer, defineRenderer, ios, iosRenderer, isOutputTree, js, jsRenderer, json, jsonRenderer, outputTree, tailwind, tailwindRenderer };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map