dispersa 0.1.3 → 0.3.0

package/dist/builders.cjs

@@ -210,32 +210,55 @@ function filterTokensBySource(tokens, expectedSource) {
   }
   return filtered;
 }
-function interpolatePattern(pattern, modifierInputs, modifierName, context) {
-  let result = pattern;
-  if (modifierName !== void 0) {
-    result = result.replace(/\{modifierName\}/g, modifierName);
+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));
   }
-  if (context !== void 0) {
-    result = result.replace(/\{context\}/g, context);
+  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, modifierName, context) {
+function resolveFileName(fileName, modifierInputs) {
   if (typeof fileName === "function") {
     return fileName(modifierInputs);
   }
   if (/\{.+?\}/.test(fileName)) {
-    return interpolatePattern(fileName, modifierInputs, modifierName, context);
+    return interpolatePattern(fileName, modifierInputs);
   }
   const extMatch = fileName.match(/(\.[^.]+)$/);
   const extension = extMatch ? extMatch[1] : "";
   const baseName = extension ? fileName.slice(0, -extension.length) : fileName;
-  if (modifierName !== void 0 && context !== void 0) {
-    return `${baseName}-${modifierName}-${context}${extension}`;
-  }
   const modifierSuffix = Object.entries(modifierInputs).sort(([keyA], [keyB]) => keyA.localeCompare(keyB)).map(([key, value]) => `${key}-${value}`).join("-");
   if (modifierSuffix) {
     return `${baseName}-${modifierSuffix}${extension}`;
@@ -460,7 +483,7 @@ function colorObjectToHex(color) {
   return culori.formatHex(culoriColor);
 }
 
-// src/lib/processing/processors/transforms/built-in/dimension-converter.ts
+// src/processing/processors/transforms/built-in/dimension-converter.ts
 function isDimensionObject(value) {
   return typeof value === "object" && value !== null && "value" in value && "unit" in value;
 }
@@ -468,6 +491,757 @@ function dimensionObjectToString(dimension) {
   return `${dimension.value}${dimension.unit}`;
 }
 
+// src/renderers/android.ts
+init_errors();
+init_token_utils();
+init_utils();
+
+// src/renderers/output-tree.ts
+var outputTree = (files) => {
+  return {
+    kind: "outputTree",
+    files
+  };
+};
+
+// src/renderers/android.ts
+var toSRGB = culori.converter("rgb");
+var toP3 = culori.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 indent(width, level) {
+  return " ".repeat(width * level);
+}
+function escapeKotlinString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\$/g, "\\$");
+}
+function escapeKDoc(str) {
+  return str.replace(/\*\//g, "* /").replace(/\r?\n/g, " ").trim();
+}
+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, "");
+}
+function toPascalCase(name) {
+  const pascal = name.replace(/[-._]+(.)/g, (_, c) => c.toUpperCase()).replace(/[-._]+$/g, "").replace(/^[-._]+/g, "");
+  const result = pascal.charAt(0).toUpperCase() + pascal.slice(1);
+  if (/^\d/.test(result)) {
+    return `_${result}`;
+  }
+  return KOTLIN_KEYWORDS.has(result.charAt(0).toLowerCase() + result.slice(1)) ? `\`${result}\`` : result;
+}
+function toKotlinIdentifier(name) {
+  const camel = name.replace(/[-._]+(.)/g, (_, c) => c.toUpperCase()).replace(/[-._]+$/g, "").replace(/^[-._]+/g, "");
+  const identifier = camel.charAt(0).toLowerCase() + camel.slice(1);
+  if (/^\d/.test(identifier)) {
+    return `_${identifier}`;
+  }
+  return KOTLIN_KEYWORDS.has(identifier) ? `\`${identifier}\`` : identifier;
+}
+var AndroidRenderer = class {
+  async format(context, options) {
+    if (!options?.packageName) {
+      throw new ConfigurationError(
+        `Output "${context.output.name}": packageName is required for Android output`
+      );
+    }
+    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: options?.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
+  // -----------------------------------------------------------------------
+  groupTokensByType(tokens) {
+    const groupMap = /* @__PURE__ */ new Map();
+    for (const [, token] of getSortedTokenEntries(tokens)) {
+      const groupName = KOTLIN_TYPE_GROUP_MAP[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
+    }));
+  }
+  /**
+   * 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 toKotlinIdentifier(joined);
+  }
+  // -----------------------------------------------------------------------
+  // Rendering
+  // -----------------------------------------------------------------------
+  formatTokens(tokens, options) {
+    if (options.structure === "flat") {
+      return this.formatAsFlat(tokens, options);
+    }
+    return this.formatAsNested(tokens, options);
+  }
+  formatAsNested(tokens, options) {
+    const tree = this.buildTokenTree(tokens);
+    const tokenTypes = /* @__PURE__ */ new Set();
+    this.collectTokenTypes(tree, tokenTypes);
+    return this.buildFile(tokenTypes, options, (lines, vis) => {
+      lines.push(`@Suppress("unused")`);
+      lines.push(`${vis}object ${options.objectName} {`);
+      this.renderTreeChildren(lines, tree, 1, options);
+      lines.push("}");
+    });
+  }
+  formatAsFlat(tokens, options) {
+    const groups = this.groupTokensByType(tokens);
+    const tokenTypes = this.collectTokenTypesFromEntries(tokens);
+    return this.buildFile(tokenTypes, options, (lines, vis) => {
+      lines.push(`@Suppress("unused")`);
+      lines.push(`${vis}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 vis = options.visibility ? `${options.visibility} ` : "";
+    const lines = [];
+    lines.push(this.buildFileHeader());
+    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(vis, options));
+      lines.push("");
+    }
+    renderBody(lines, vis);
+    lines.push("");
+    return lines.join("\n");
+  }
+  renderFlatGroups(lines, groups, baseDepth, options) {
+    const vis = options.visibility ? `${options.visibility} ` : "";
+    const groupIndent = indent(options.indent, baseDepth);
+    const valIndent = indent(options.indent, baseDepth + 1);
+    for (const group of groups) {
+      lines.push(`${groupIndent}${vis}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);
+        if (token.$description) {
+          lines.push(`${valIndent}/** ${escapeKDoc(token.$description)} */`);
+        }
+        lines.push(`${valIndent}${vis}val ${kotlinName}${annotation} = ${kotlinValue}`);
+      }
+      lines.push(`${groupIndent}}`);
+      lines.push("");
+    }
+  }
+  renderTreeChildren(lines, node, depth, options) {
+    const vis = options.visibility ? `${options.visibility} ` : "";
+    const pad = indent(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 = toPascalCase(key);
+        lines.push(`${pad}${vis}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 vis = options.visibility ? `${options.visibility} ` : "";
+    const pad = indent(options.indent, depth);
+    const kotlinName = toKotlinIdentifier(key);
+    const kotlinValue = this.formatKotlinValue(token, options, depth);
+    const annotation = this.typeAnnotationSuffix(token);
+    if (token.$description) {
+      lines.push(`${pad}/** ${escapeKDoc(token.$description)} */`);
+    }
+    lines.push(`${pad}${vis}val ${kotlinName}${annotation} = ${kotlinValue}`);
+  }
+  buildFileHeader() {
+    return [
+      "// Generated by Dispersa - do not edit manually",
+      "// https://github.com/timges/dispersa"
+    ].join("\n");
+  }
+  // -----------------------------------------------------------------------
+  // Shadow data class
+  // -----------------------------------------------------------------------
+  buildShadowTokenClass(vis, options) {
+    const i1 = indent(options.indent, 1);
+    return [
+      "@Immutable",
+      `${vis}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();
+  }
+  collectTokenTypes(node, types) {
+    if (node.token?.$type) {
+      types.add(node.token.$type);
+    }
+    for (const child of node.children.values()) {
+      this.collectTokenTypes(child, types);
+    }
+  }
+  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 = toP3(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 = toSRGB(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 (typeof value === "object" && value !== null && "value" in value && "unit" in value) {
+      const dur = value;
+      return dur.unit === "ms" ? `${dur.value}.milliseconds` : `${dur.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 = indent(options.indent, depth + 1);
+    const closeIndent = indent(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 = indent(options.indent, depth + 1);
+    const closeIndent = indent(options.indent, depth);
+    return `TextStyle(
+${parts.map((p) => `${propIndent}${p}`).join(",\n")},
+${closeIndent})`;
+  }
+  // -----------------------------------------------------------------------
+  // Output: standalone
+  // -----------------------------------------------------------------------
+  async formatStandalone(context, options) {
+    const requiresFile = context.buildPath !== void 0 && context.buildPath !== "";
+    if (!context.output.file && requiresFile) {
+      throw new ConfigurationError(
+        `Output "${context.output.name}": file is required for standalone Android output`
+      );
+    }
+    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) {
+    const requiresFile = context.buildPath !== void 0 && context.buildPath !== "";
+    if (!context.output.file && requiresFile) {
+      throw new ConfigurationError(
+        `Output "${context.output.name}": file is required for bundle Android output`
+      );
+    }
+    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, vis) => {
+      const i1 = indent(options.indent, 1);
+      lines.push(`@Suppress("unused")`);
+      lines.push(`${vis}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}${vis}object ${permName} {`);
+        this.renderBundleTokens(lines, processedTokens, options, 2);
+        lines.push(`${i1}}`);
+        if (idx < context.permutations.length - 1) {
+          lines.push("");
+        }
+      }
+      lines.push("}");
+    });
+  }
+  collectAllPermutationTypes(context) {
+    const allTokenTypes = /* @__PURE__ */ new Set();
+    for (const { tokens } of context.permutations) {
+      const processed = stripInternalMetadata(tokens);
+      for (const [, token] of Object.entries(processed)) {
+        if (token.$type) {
+          allTokenTypes.add(token.$type);
+        }
+      }
+    }
+    return allTokenTypes;
+  }
+  renderBundleTokens(lines, tokens, options, baseDepth) {
+    if (options.structure === "flat") {
+      const groups = this.groupTokensByType(tokens);
+      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) => toPascalCase(v)).join("");
+  }
+};
+function androidRenderer() {
+  const rendererInstance = new AndroidRenderer();
+  return {
+    format: (context, options) => rendererInstance.format(
+      context,
+      options ?? context.output.options
+    )
+  };
+}
+
 // src/renderers/css.ts
 init_errors();
 init_token_utils();
@@ -599,6 +1373,33 @@ function collectRemainder(tokens, included) {
   }
   return result;
 }
+function buildSetLayerBlocks(tokens, resolver) {
+  const blocks = [];
+  const included = /* @__PURE__ */ new Set();
+  const addBlock = (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 });
+  };
+  for (const item of resolver.resolutionOrder) {
+    const ref = item.$ref;
+    if (typeof ref !== "string" || !ref.startsWith("#/sets/")) {
+      continue;
+    }
+    const setName = ref.slice("#/sets/".length);
+    addBlock(
+      `Set: ${setName}`,
+      collectSetTokens(tokens, setName, included),
+      resolver.sets?.[setName]?.description
+    );
+  }
+  addBlock("Unattributed", collectRemainder(tokens, included));
+  return blocks;
+}
 function buildDefaultLayerBlocks(tokens, baseModifierInputs, resolver) {
   const blocks = [];
   const included = /* @__PURE__ */ new Set();
@@ -794,14 +1595,14 @@ var CssRenderer = class _CssRenderer {
     return opts.minify ? cssString : await this.formatWithPrettier(cssString);
   }
   buildCssBlock(lines, groupTokens, selector, tokens, referenceTokens, opts) {
-    const indent = opts.minify ? "" : "  ";
+    const indent2 = opts.minify ? "" : "  ";
     const newline = opts.minify ? "" : "\n";
     const space = opts.minify ? "" : " ";
     const hasMediaQuery = opts.mediaQuery != null && opts.mediaQuery !== "";
-    const tokenIndent = hasMediaQuery ? indent + indent : indent;
+    const tokenIndent = hasMediaQuery ? indent2 + indent2 : indent2;
     if (hasMediaQuery) {
       lines.push(`@media ${opts.mediaQuery}${space}{${newline}`);
-      lines.push(`${indent}${selector}${space}{${newline}`);
+      lines.push(`${indent2}${selector}${space}{${newline}`);
     } else {
       lines.push(`${selector}${space}{${newline}`);
     }
@@ -818,21 +1619,21 @@ var CssRenderer = class _CssRenderer {
       );
     }
     if (hasMediaQuery) {
-      lines.push(`${indent}}${newline}`);
+      lines.push(`${indent2}}${newline}`);
     }
     lines.push(`}${newline}${newline}`);
   }
-  pushTokenLines(lines, token, tokens, referenceTokens, preserveReferences, indent, newline, space) {
+  pushTokenLines(lines, token, tokens, referenceTokens, preserveReferences, indent2, newline, space) {
     const entries = this.buildCssEntries(token, tokens, referenceTokens, preserveReferences);
     if (token.$deprecated != null && token.$deprecated !== false) {
       const deprecationMsg = formatDeprecationMessage(token, "", "comment");
-      lines.push(`${indent}/* ${this.sanitizeCssCommentText(deprecationMsg)} */${newline}`);
+      lines.push(`${indent2}/* ${this.sanitizeCssCommentText(deprecationMsg)} */${newline}`);
     }
     if (token.$description && token.$description !== "") {
-      lines.push(`${indent}/* ${this.sanitizeCssCommentText(token.$description)} */${newline}`);
+      lines.push(`${indent2}/* ${this.sanitizeCssCommentText(token.$description)} */${newline}`);
     }
     for (const entry of entries) {
-      lines.push(`${indent}--${entry.name}:${space}${entry.value};${newline}`);
+      lines.push(`${indent2}--${entry.name}:${space}${entry.value};${newline}`);
     }
   }
   async formatWithPrettier(css2) {
@@ -1319,6 +2120,10 @@ var CssRenderer = class _CssRenderer {
       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(
@@ -1334,22 +2139,75 @@ var CssRenderer = class _CssRenderer {
     }
     return { kind: "outputTree", files };
   }
-  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 };
+  async buildModifierBaseFile(context, options) {
+    const basePermutation = context.permutations.find(
+      ({ modifierInputs }) => this.isBasePermutation(modifierInputs, context.meta.defaults)
+    );
+    if (!basePermutation) {
+      return void 0;
     }
-    return { tokensFromSource, referenceTokens };
-  }
-  async buildModifierContextFile(modifierName, contextValue, context, options) {
-    const { tokensFromSource, referenceTokens } = this.collectTokensForModifierContext(
-      modifierName,
+    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 modifiers = context.resolver.modifiers;
+    const firstModifierName = Object.keys(modifiers)[0] ?? "";
+    const firstModifierContext = context.meta.defaults[firstModifierName] ?? "";
+    const baseModifierInputs = { ...context.meta.defaults };
+    const selector = resolveSelector(
+      options.selector,
+      firstModifierName,
+      firstModifierContext,
+      true,
+      baseModifierInputs
+    );
+    const mediaQuery = resolveMediaQuery(
+      options.mediaQuery,
+      firstModifierName,
+      firstModifierContext,
+      true,
+      baseModifierInputs
+    );
+    const referenceTokens = basePermutation.tokens;
+    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}`);
+    }
+    const content = cssBlocks.join("\n");
+    const fileName = context.output.file ? resolveBaseFileName(context.output.file, context.meta.defaults) : `${context.output.name}-base.css`;
+    return { fileName, content };
+  }
+  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
     );
@@ -1380,7 +2238,7 @@ var CssRenderer = class _CssRenderer {
       preserveReferences: options.preserveReferences ?? false,
       referenceTokens
     });
-    const fileName = context.output.file ? resolveFileName(context.output.file, modifierInputs, modifierName, contextValue) : buildInMemoryOutputKey({
+    const fileName = context.output.file ? resolveFileName(context.output.file, modifierInputs) : buildInMemoryOutputKey({
       outputName: context.output.name,
       extension: "css",
       modifierInputs,
@@ -1427,20 +2285,633 @@ function cssRenderer() {
   };
 }
 
-// src/renderers/js-module.ts
-init_utils();
+// src/renderers/ios.ts
 init_errors();
 init_token_utils();
-
-// src/renderers/output-tree.ts
-var outputTree = (files) => {
+init_utils();
+var toSRGB2 = culori.converter("rgb");
+var toP32 = culori.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) {
+    if (options.structure === "grouped") {
+      return this.formatAsGrouped(tokens, options);
+    }
+    return this.formatAsEnum(tokens, options);
+  }
+  formatAsEnum(tokens, options) {
+    const access = options.accessLevel;
+    const groups = this.groupTokensByType(tokens);
+    const imports = this.collectImports(tokens);
+    const i1 = this.indentStr(options.indent, 1);
+    const i2 = this.indentStr(options.indent, 2);
+    const staticPrefix = this.staticLetPrefix(options);
+    const frozen = this.frozenPrefix(options);
+    const lines = [];
+    lines.push(this.buildFileHeader());
+    lines.push("");
+    for (const imp of imports) {
+      lines.push(`import ${imp}`);
+    }
+    lines.push(...this.buildStructDefinitions(tokens, access, options));
+    lines.push("");
+    lines.push(`${frozen}${access} enum ${options.enumName} {`);
+    for (const group of groups) {
+      lines.push(`${i1}${frozen}${access} enum ${group.name} {`);
+      for (const token of group.tokens) {
+        const swiftName = this.buildQualifiedSwiftName(token);
+        const swiftValue = this.formatSwiftValue(token, options);
+        const typeAnnotation = this.getTypeAnnotation(token);
+        const annotation = typeAnnotation ? `: ${typeAnnotation}` : "";
+        const docComment = this.buildDocComment(token, i2);
+        if (docComment) {
+          lines.push(docComment);
+        }
+        lines.push(`${i2}${access} ${staticPrefix}${swiftName}${annotation} = ${swiftValue}`);
+      }
+      lines.push(`${i1}}`);
+      lines.push("");
+    }
+    lines.push("}");
+    lines.push(...this.buildViewExtensions(tokens, access, options));
+    lines.push("");
+    return lines.join("\n");
+  }
+  formatAsGrouped(tokens, options) {
+    const access = options.accessLevel;
+    const namespace = options.extensionNamespace;
+    const groups = this.groupTokensByType(tokens);
+    const imports = this.collectImports(tokens);
+    const i1 = this.indentStr(options.indent, 1);
+    const i2 = this.indentStr(options.indent, 2);
+    const staticPrefix = this.staticLetPrefix(options);
+    const frozen = this.frozenPrefix(options);
+    const lines = [];
+    lines.push(this.buildFileHeader());
+    lines.push("");
+    for (const imp of imports) {
+      lines.push(`import ${imp}`);
+    }
+    lines.push(...this.buildStructDefinitions(tokens, access, options));
+    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} {`);
+      for (const token of group.tokens) {
+        const swiftName = this.buildQualifiedSwiftName(token);
+        const swiftValue = this.formatSwiftValue(token, options);
+        const typeAnnotation = this.getTypeAnnotation(token);
+        const annotation = typeAnnotation ? `: ${typeAnnotation}` : "";
+        const docComment = this.buildDocComment(token, i2);
+        if (docComment) {
+          lines.push(docComment);
+        }
+        lines.push(`${i2}${access} ${staticPrefix}${swiftName}${annotation} = ${swiftValue}`);
+      }
+      lines.push(`${i1}}`);
+      lines.push("}");
+      lines.push("");
+    }
+    lines.push(...this.buildViewExtensions(tokens, access, options));
+    return lines.join("\n");
+  }
+  buildFileHeader() {
+    return [
+      "// Generated by Dispersa - do not edit manually",
+      "// https://github.com/timges/dispersa"
+    ].join("\n");
+  }
+  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 `///` doc comment from a token's `$description`, if present.
+   */
+  buildDocComment(token, indent2) {
+    if (!token.$description) {
+      return void 0;
+    }
+    return `${indent2}/// ${token.$description}`;
+  }
+  groupTokensByType(tokens) {
+    const groupMap = /* @__PURE__ */ new Map();
+    for (const [, token] of getSortedTokenEntries(tokens)) {
+      const groupName = SWIFT_TYPE_GROUP_MAP[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
+    }));
+  }
+  /**
+   * 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 this.toSwiftIdentifier(joined);
+  }
+  formatSwiftValue(token, options) {
+    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);
+    }
+    if (token.$type === "typography") {
+      return this.formatTypographyValue(value);
+    }
+    if (token.$type === "border") {
+      return this.formatBorderValue(value, options);
+    }
+    if (token.$type === "gradient") {
+      return this.formatGradientValue(value, options);
+    }
+    if (token.$type === "number") {
+      return String(value);
+    }
+    if (token.$type === "cubicBezier" && 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]}))`;
+    }
+    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 = toP32(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 = toSRGB2(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)) {
+      const dim = value;
+      const ptValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
+      return String(ptValue);
+    }
+    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 (typeof value === "object" && value !== null && "value" in value && "unit" in 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";
+    }
+    const dim = typo.letterSpacing;
+    const ptValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
+    return String(ptValue);
+  }
+  extractLineSpacing(typo) {
+    if (typo.lineHeight == null || typeof typo.lineHeight !== "number") {
+      return "0";
+    }
+    if (!isDimensionObject(typo.fontSize)) {
+      return "0";
+    }
+    const dim = typo.fontSize;
+    const basePt = dim.unit === "rem" ? dim.value * 16 : dim.value;
+    const lineHeightPt = Math.round(basePt * typo.lineHeight * 100) / 100;
+    return String(lineHeightPt - basePt);
+  }
+  dimensionToPoints(dim) {
+    const ptValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
+    return String(ptValue);
+  }
+  /** Formats a dimension as a CGFloat literal (appends `.0` for integers). */
+  dimensionToCGFloat(dim) {
+    const ptValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
+    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;
+    }
+  }
+  toSwiftIdentifier(name) {
+    const camel = name.replace(/[-._]+(.)/g, (_, c) => c.toUpperCase()).replace(/[-._]+$/g, "").replace(/^[-._]+/g, "");
+    const identifier = camel.charAt(0).toLowerCase() + camel.slice(1);
+    const safe = /^\d/.test(identifier) ? `_${identifier}` : identifier;
+    return SWIFT_KEYWORDS.has(safe) ? `\`${safe}\`` : safe;
+  }
+  escapeSwiftString(str) {
+    return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
+  }
+  roundComponent(value) {
+    return Math.round(value * 1e4) / 1e4;
+  }
+  indentStr(width, level) {
+    return " ".repeat(width * level);
+  }
+  /**
+   * 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" : "";
+  }
+  hasShadowTokens(tokens) {
+    return Object.values(tokens).some((t) => t.$type === "shadow");
+  }
+  hasTypographyTokens(tokens) {
+    return Object.values(tokens).some((t) => t.$type === "typography");
+  }
+  hasBorderTokens(tokens) {
+    return Object.values(tokens).some((t) => t.$type === "border");
+  }
+  /** Emits all struct definitions needed by the token set. */
+  buildStructDefinitions(tokens, access, options) {
+    const lines = [];
+    if (this.hasShadowTokens(tokens)) {
+      lines.push("");
+      lines.push(...this.buildShadowStyleStruct(access, options));
+    }
+    if (this.hasTypographyTokens(tokens)) {
+      lines.push("");
+      lines.push(...this.buildTypographyStyleStruct(access, options));
+    }
+    if (this.hasBorderTokens(tokens)) {
+      lines.push("");
+      lines.push(...this.buildBorderStyleStruct(access, options));
+    }
+    return lines;
+  }
+  buildShadowStyleStruct(access, options) {
+    const i1 = this.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 = this.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 = this.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 = this.indentStr(options.indent, 1);
+    const i2 = this.indentStr(options.indent, 2);
+    if (this.hasShadowTokens(tokens)) {
+      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 (this.hasTypographyTokens(tokens)) {
+      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) {
+    const requiresFile = context.buildPath !== void 0 && context.buildPath !== "";
+    if (!context.output.file && requiresFile) {
+      throw new ConfigurationError(
+        `Output "${context.output.name}": file is required for standalone iOS output`
+      );
+    }
+    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 {
-    kind: "outputTree",
-    files
+    format: (context, options) => rendererInstance.format(
+      context,
+      options ?? context.output.options
+    )
   };
-};
+}
 
 // src/renderers/js-module.ts
+init_utils();
+init_errors();
+init_token_utils();
 var JsModuleRenderer = class {
   async format(context, options) {
     const opts = {
@@ -1554,8 +3025,8 @@ var JsModuleRenderer = class {
   /**
    * Add object properties to lines
    */
-  addObjectProperties(lines, obj, indent) {
-    const indentStr = "  ".repeat(indent);
+  addObjectProperties(lines, obj, indent2) {
+    const indentStr = "  ".repeat(indent2);
     const entries = Object.entries(obj).sort(([keyA], [keyB]) => keyA.localeCompare(keyB));
     for (let i = 0; i < entries.length; i++) {
       const entry = entries[i];
@@ -1566,7 +3037,7 @@ var JsModuleRenderer = class {
       const isLast = i === entries.length - 1;
       if (typeof value === "object" && value !== null && !Array.isArray(value)) {
         lines.push(`${indentStr}${this.quoteKey(key)}: {`);
-        this.addObjectProperties(lines, value, indent + 1);
+        this.addObjectProperties(lines, value, indent2 + 1);
         lines.push(`${indentStr}}${isLast ? "" : ","}`);
       } else {
         const valueStr = JSON.stringify(value);
@@ -1758,6 +3229,349 @@ function jsonRenderer() {
   };
 }
 
+// src/renderers/tailwind.ts
+init_errors();
+init_token_utils();
+
+// src/renderers/bundlers/tailwind.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");
+}
+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 = resolveSelector(
+    options.selector,
+    modifier,
+    context,
+    false,
+    normalizeModifierInputs(modifierInputs)
+  );
+  const mediaQuery = resolveMediaQuery(
+    options.mediaQuery,
+    modifier,
+    context,
+    false,
+    normalizeModifierInputs(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/renderers/tailwind.ts
+init_utils();
+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 indent2 = 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);
+      lines.push(`${indent2}--${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 indent2 = minify ? "" : "  ";
+    const newline = minify ? "" : "\n";
+    const space = minify ? "" : " ";
+    const hasMediaQuery = mediaQuery !== "";
+    const tokenIndent = hasMediaQuery ? indent2 + indent2 : indent2;
+    const lines = [];
+    if (hasMediaQuery) {
+      lines.push(`@media ${mediaQuery}${space}{${newline}`);
+      lines.push(`${indent2}${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);
+      lines.push(`${tokenIndent}--${varName}:${space}${varValue};${newline}`);
+    }
+    if (hasMediaQuery) {
+      lines.push(`${indent2}}${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" && this.isDurationObject(value)) {
+      return `${value.value}${value.unit}`;
+    }
+    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(" ");
+  }
+  isDurationObject(value) {
+    return typeof value === "object" && value !== null && "value" in value && "unit" in value && value.unit !== void 0;
+  }
+  async formatWithPrettier(css2) {
+    try {
+      return await prettier__default.default.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: this.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) {
+    const requiresFile = context.buildPath !== void 0 && context.buildPath !== "";
+    if (!context.output.file && requiresFile) {
+      throw new ConfigurationError(
+        `Output "${context.output.name}": file is required for standalone Tailwind output`
+      );
+    }
+    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);
+  }
+  isBasePermutation(modifierInputs, defaults) {
+    return Object.entries(defaults).every(
+      ([key, value]) => modifierInputs[key]?.toLowerCase() === value.toLowerCase()
+    );
+  }
+};
+function tailwindRenderer() {
+  const rendererInstance = new TailwindRenderer();
+  return {
+    format: (context, options) => rendererInstance.format(
+      context,
+      options ?? context.output.options
+    )
+  };
+}
+
 // src/builders.ts
 function css(config) {
   const {
@@ -1819,14 +3633,76 @@ function js(config) {
     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
  */
 
+exports.android = android;
 exports.css = css;
+exports.ios = ios;
 exports.js = js;
 exports.json = json;
+exports.tailwind = tailwind;
 //# sourceMappingURL=builders.cjs.map
 //# sourceMappingURL=builders.cjs.map