dispersa 1.2.0 → 1.3.0

package/dist/index.js

@@ -8,9 +8,9 @@ import { createRequire } from 'module';
 import process2 from 'process';
 import { createJiti } from 'jiti';
 import { JsonPointer } from 'json-ptr';
-import { kebabCase } from 'change-case';
 import { converter, formatHex8, formatHex } from 'culori';
 import prettier from 'prettier';
+import { kebabCase } from 'change-case';
 
 var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -3342,7 +3342,7 @@ var init_resolver_loader = __esm({
   }
 });
 
-// src/renderers/bundlers/utils.ts
+// src/outputs/utils.ts
 function sanitizeDataAttributeName(value) {
   return value.trim().toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "");
 }
@@ -3574,13 +3574,13 @@ function resolveFileName(fileName, modifierInputs) {
   return fileName;
 }
 var init_utils = __esm({
-  "src/renderers/bundlers/utils.ts"() {
+  "src/outputs/utils.ts"() {
     init_errors();
     init_token_utils();
   }
 });
 
-// src/renderers/metadata.ts
+// src/outputs/metadata.ts
 function sanitizeText(text, format) {
   switch (format) {
     case "css":
@@ -3664,13 +3664,13 @@ function buildKotlinDeprecationAnnotation(token) {
   return "@Deprecated";
 }
 var init_metadata = __esm({
-  "src/renderers/metadata.ts"() {
+  "src/outputs/metadata.ts"() {
   }
 });
 
-// src/renderers/bundlers/js.ts
-var js_exports = {};
-__export(js_exports, {
+// src/outputs/js/presets/bundle.ts
+var bundle_exports = {};
+__export(bundle_exports, {
   bundleAsJsModule: () => bundleAsJsModule
 });
 function updateStringTracking(state, char) {
@@ -3808,17 +3808,17 @@ async function bundleAsJsModule(bundleData, resolver, options, formatTokens) {
   }
   return assembleJsBundle(metadata, jsBlocks, options?.generateHelper ?? false);
 }
-var init_js = __esm({
-  "src/renderers/bundlers/js.ts"() {
+var init_bundle = __esm({
+  "src/outputs/js/presets/bundle.ts"() {
     init_errors();
     init_metadata();
     init_utils();
   }
 });
 
-// src/renderers/bundlers/json.ts
-var json_exports = {};
-__export(json_exports, {
+// src/outputs/json/presets/bundle.ts
+var bundle_exports2 = {};
+__export(bundle_exports2, {
   bundleAsJson: () => bundleAsJson
 });
 async function bundleAsJson(bundleData, resolver, formatTokens) {
@@ -3837,8 +3837,8 @@ async function bundleAsJson(bundleData, resolver, formatTokens) {
   const bundle = { _meta: metadata, tokens };
   return JSON.stringify(bundle, null, 2);
 }
-var init_json = __esm({
-  "src/renderers/bundlers/json.ts"() {
+var init_bundle2 = __esm({
+  "src/outputs/json/presets/bundle.ts"() {
     init_errors();
     init_utils();
   }
@@ -4082,7 +4082,7 @@ var TypeWriter = class {
   }
 };
 
-// src/build/build-orchestrator.ts
+// src/engine/build-orchestrator.ts
 init_utils();
 init_errors();
 
@@ -4124,7 +4124,7 @@ function toBuildError(error, outputName) {
   return { message, code: "UNKNOWN", severity: "error" };
 }
 
-// src/build/build-orchestrator.ts
+// src/engine/build-orchestrator.ts
 var BuildOrchestrator = class {
   constructor(pipeline, outputProcessor) {
     this.pipeline = pipeline;
@@ -4231,7 +4231,15 @@ var BuildOrchestrator = class {
       const metadata = buildMetadata(resolverDoc);
       const settled = await Promise.allSettled(
         config.outputs.map(
-          (output) => this.buildSingleOutput(output, permutations, resolverDoc, metadata, buildPath, config, resolver)
+          (output) => this.buildSingleOutput(
+            output,
+            permutations,
+            resolverDoc,
+            metadata,
+            buildPath,
+            config,
+            resolver
+          )
         )
       );
       const result = this.collectSettledResults(settled, config);
@@ -4256,14 +4264,25 @@ var BuildOrchestrator = class {
       await output.hooks.onBuildStart({ config, resolver });
     }
     try {
-      const results = await this.processOutput(output, permutations, resolverDoc, metadata, metadata.defaults, buildPath);
+      const results = await this.processOutput(
+        output,
+        permutations,
+        resolverDoc,
+        metadata,
+        metadata.defaults,
+        buildPath
+      );
       if (output.hooks?.onBuildEnd) {
         await output.hooks.onBuildEnd({ success: true, outputs: results });
       }
       return results;
     } catch (error) {
       if (output.hooks?.onBuildEnd) {
-        await output.hooks.onBuildEnd({ success: false, outputs: [], errors: [toBuildError(error, output.name)] });
+        await output.hooks.onBuildEnd({
+          success: false,
+          outputs: [],
+          errors: [toBuildError(error, output.name)]
+        });
       }
       throw error;
     }
@@ -4365,10 +4384,10 @@ function applyFilters(tokens, filterList) {
   return result;
 }
 
-// src/build/output-processor.ts
+// src/engine/output-processor.ts
 init_utils();
 
-// src/renderers/output-tree.ts
+// src/outputs/output-tree.ts
 var outputTree = (files) => {
   return {
     kind: "outputTree",
@@ -4379,7 +4398,7 @@ var isOutputTree = (value) => {
   return typeof value === "object" && value !== null && value.kind === "outputTree";
 };
 
-// src/build/output-processor.ts
+// src/engine/output-processor.ts
 init_errors();
 var OutputProcessor = class {
   /**
@@ -4459,7 +4478,7 @@ var OutputProcessor = class {
   }
 };
 
-// src/build/pipeline/token-pipeline.ts
+// src/engine/pipeline/token-pipeline.ts
 init_resolver_loader();
 
 // src/lint/plugin-loader.ts
@@ -6054,7 +6073,7 @@ var ResolutionEngine = class {
   }
 };
 
-// src/build/pipeline/token-pipeline.ts
+// src/engine/pipeline/token-pipeline.ts
 init_errors();
 init_token_utils();
 init_validation_handler();
@@ -6068,12 +6087,12 @@ function formatTokenPath(parentPath, name) {
   return parentPath.length > 0 ? `${parentPath.join(".")}.${name}` : name;
 }
 
-// src/tokens/token-parser.ts
+// src/engine/token-parser.ts
 init_token_utils();
 init_validation_handler();
 init_validator();
 
-// src/tokens/group-extension-resolver.ts
+// src/engine/group-extension-resolver.ts
 init_errors();
 init_token_utils();
 var GroupExtensionResolver = class {
@@ -6235,7 +6254,7 @@ var GroupExtensionResolver = class {
   }
 };
 
-// src/tokens/token-parser.ts
+// src/engine/token-parser.ts
 var INVALID_NAME_CHARS_REGEX = /[{}.]/;
 var TokenParser = class {
   validator;
@@ -6517,7 +6536,7 @@ var TokenParser = class {
   }
 };
 
-// src/build/pipeline/token-pipeline.ts
+// src/engine/pipeline/token-pipeline.ts
 var TokenPipeline = class {
   options;
   validationHandler;
@@ -6918,7 +6937,7 @@ async function generateTypes(tokens, fileName, options) {
   });
 }
 
-// src/tokens/types.ts
+// src/shared/token-types/types.ts
 function isColorToken(token) {
   return token.$type === "color";
 }
@@ -6943,17 +6962,6 @@ function isTransitionToken(token) {
 function isGradientToken(token) {
   return token.$type === "gradient";
 }
-function nameKebabCase() {
-  return {
-    transform: (token) => {
-      const name = kebabCase(token.path.join(" "));
-      return {
-        ...token,
-        name
-      };
-    }
-  };
-}
 function isColorObject(value) {
   return typeof value === "object" && value !== null && "colorSpace" in value && "components" in value;
 }
@@ -7027,1734 +7035,1651 @@ function durationObjectToString(duration) {
   return `${duration.value}${duration.unit}`;
 }
 
-// src/renderers/android.ts
+// src/outputs/css/renderer.ts
 init_errors();
 init_token_utils();
+
+// src/outputs/css/presets/bundle.ts
+init_errors();
 init_utils();
-init_metadata();
-var toSRGB = converter("rgb");
-var toP3 = 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"
+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;
 };
-function resolveColorFormat(format) {
-  if (format === "argb_floats" || format === "argb_float") {
-    return "argb_float";
+var getSourceModifier = (token) => {
+  if (typeof token !== "object" || token === null) {
+    return void 0;
   }
-  return "argb_hex";
-}
-function escapeKotlinString(str) {
-  return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\$/g, "\\$");
+  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");
 }
-function formatKotlinNumber(value) {
-  return Number.isInteger(value) ? `${value}.0` : String(value);
+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;
 }
-function roundComponent(value) {
-  return Math.round(value * 1e3) / 1e3;
+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 toResourceName(family) {
-  return family.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
+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 });
 }
-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);
+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 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 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 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 path7 = token.path;
-    const withoutTypePrefix = path7.length > 1 ? path7.slice(1) : path7;
-    const joined = withoutTypePrefix.join("_");
-    return toSafeIdentifier(joined, KOTLIN_KEYWORDS, false);
   }
-  // -----------------------------------------------------------------------
-  // Rendering
-  // -----------------------------------------------------------------------
-  formatTokens(tokens, options) {
-    if (options.structure === "flat") {
-      return this.formatAsFlat(tokens, options);
+  return result;
+}
+function collectRemainder(tokens, included) {
+  const result = {};
+  for (const [name, token] of Object.entries(tokens)) {
+    if (!included.has(name)) {
+      result[name] = token;
     }
-    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 = 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)`;
+  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 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)`;
+    const setName = ref.slice(REF_PREFIX_SETS.length);
+    addLayerBlock(
+      blocks,
+      included,
+      `Set: ${setName}`,
+      collectSetTokens(tokens, setName, included),
+      resolver.sets?.[setName]?.description
+    );
   }
-  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()})`;
+  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;
     }
-    const alphaHex = alpha < 1 ? Math.round(alpha * 255).toString(16).padStart(2, "0").toUpperCase() : "FF";
-    return `Color(0x${alphaHex}${hexClean.toUpperCase()})`;
+    processResolutionOrderRef(ref, tokens, blocks, included, baseInputs, resolver);
   }
-  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`;
+  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;
   }
-  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";
+  if (!ref.startsWith(REF_PREFIX_MODIFIERS)) {
+    return;
   }
-  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)})`;
+  const modifierName = ref.slice(REF_PREFIX_MODIFIERS.length);
+  const modifier = resolver.modifiers?.[modifierName];
+  const selectedContext = baseInputs[modifierName.toLowerCase()];
+  if (!modifier || !selectedContext) {
+    return;
   }
-  formatFontWeightValue(value) {
-    if (typeof value === "number") {
-      return this.numericFontWeight(value);
+  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;
     }
-    if (typeof value === "string") {
-      return this.namedFontWeight(value) ?? "FontWeight.Normal";
+    const inputs = normalizeModifierInputs(item.modifierInputs);
+    if (inputs[normalizedModifier] !== normalizedContext) {
+      return false;
     }
-    return "FontWeight.Normal";
+    return Object.entries(baseInputs).every(([k, v]) => k === normalizedModifier || inputs[k] === v);
+  });
+}
+function pushUniqueBundleItem(ordered, includedKeys, item) {
+  if (!item) {
+    return;
   }
-  numericFontWeight(weight) {
-    if (weight <= 100) {
-      return "FontWeight.Thin";
-    }
-    if (weight <= 200) {
-      return "FontWeight.ExtraLight";
+  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;
     }
-    if (weight <= 300) {
-      return "FontWeight.Light";
+    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)
+      );
     }
-    if (weight <= 400) {
-      return "FontWeight.Normal";
+  }
+}
+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 (weight <= 500) {
-      return "FontWeight.Medium";
+    if (!ref.startsWith(REF_PREFIX_MODIFIERS)) {
+      continue;
     }
-    if (weight <= 600) {
-      return "FontWeight.SemiBold";
+    const name = ref.slice(REF_PREFIX_MODIFIERS.length);
+    if (seen.has(name)) {
+      continue;
     }
-    if (weight <= 700) {
-      return "FontWeight.Bold";
+    if (!(name in modifiers)) {
+      continue;
     }
-    if (weight <= 800) {
-      return "FontWeight.ExtraBold";
+    ordered.push(name);
+    seen.add(name);
+  }
+  for (const name of Object.keys(modifiers)) {
+    if (seen.has(name)) {
+      continue;
     }
-    return "FontWeight.Black";
+    ordered.push(name);
+    seen.add(name);
   }
-  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 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
     };
-    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 (opts.preset === "bundle") {
+      return await this.formatBundle(context, opts);
     }
-    if (typeof value === "object" && value !== null) {
-      return this.formatSingleShadow(value, options, depth);
+    if (opts.preset === "modifier") {
+      return await this.formatModifier(context, opts);
     }
-    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");
+    return await this.formatStandalone(context, opts);
   }
-  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})`;
+  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);
   }
-  formatTypographyValue(value, options, depth) {
-    if (typeof value !== "object" || value === null) {
-      return "TextStyle()";
+  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}`);
     }
-    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`);
+    for (const token of groupTokens) {
+      this.pushTokenLines(
+        lines,
+        token,
+        tokens,
+        referenceTokens,
+        opts.preserveReferences ?? false,
+        tokenIndent,
+        newline,
+        space
+      );
     }
-    if (typo.fontWeight != null) {
-      parts.push(`fontWeight = ${this.formatFontWeightValue(typo.fontWeight)}`);
+    if (hasMediaQuery) {
+      lines.push(`${indent}}${newline}`);
     }
-    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`);
-      }
+    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}`);
     }
-    if (isDimensionObject(typo.letterSpacing)) {
-      const dim = typo.letterSpacing;
-      const spValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
-      parts.push(`letterSpacing = ${spValue}.sp`);
+    const descriptionComment = buildTokenDescriptionComment(token, "css");
+    if (descriptionComment) {
+      lines.push(`${indent}${descriptionComment}${newline}`);
     }
-    if (parts.length === 0) {
-      return "TextStyle()";
+    for (const entry of entries) {
+      lines.push(`${indent}--${entry.name}:${space}${entry.value};${newline}`);
     }
-    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
+  async formatWithPrettier(css2) {
+    try {
+      return await prettier.format(css2, {
+        parser: "css",
+        printWidth: _CssRenderer.PRETTIER_PRINT_WIDTH,
+        tabWidth: _CssRenderer.PRETTIER_TAB_WIDTH,
+        useTabs: false
       });
-      files[fileName] = content;
+    } catch {
+      return css2;
     }
-    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("");
-        }
+  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)
+          }
+        ];
       }
-      lines.push("}");
-    });
+    }
+    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];
   }
-  collectAllPermutationTypes(context) {
-    const types = /* @__PURE__ */ new Set();
-    for (const { tokens } of context.permutations) {
-      for (const t of this.collectTokenTypesFromEntries(stripInternalMetadata(tokens))) {
-        types.add(t);
-      }
+  isCompositeToken(token) {
+    const isCompositeType = [
+      "shadow",
+      "typography",
+      "border",
+      "strokeStyle",
+      "transition",
+      "gradient"
+    ].includes(token.$type ?? "");
+    if (!isCompositeType) {
+      return false;
     }
-    return types;
+    const value = token.$value;
+    return typeof value === "object" && value !== null || Array.isArray(value);
   }
-  renderBundleTokens(lines, tokens, options, baseDepth) {
-    if (options.structure === "flat") {
-      const groups = groupTokensByType(tokens, KOTLIN_TYPE_GROUP_MAP);
-      this.renderFlatGroups(lines, groups, baseDepth, options);
-      return;
+  buildCompositeWholeValue(token, preserveReferences) {
+    if (token.$type === "shadow") {
+      return preserveReferences ? this.buildShadowWholeValue(token) : this.formatValue(token);
     }
-    const tree = this.buildTokenTree(tokens);
-    this.renderTreeChildren(lines, tree, baseDepth, options);
-  }
-  buildPermutationName(modifierInputs) {
-    const values = Object.values(modifierInputs);
-    if (values.length === 0) {
-      return "Default";
+    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 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/renderers/css.ts
-init_errors();
-init_token_utils();
-
-// src/renderers/bundlers/css.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");
+  hasBorderShorthandStyle(token) {
+    const value = token.$value;
+    if (typeof value !== "object" || value === null) {
+      return false;
+    }
+    return typeof value.style === "string";
   }
-  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;
+  buildShadowWholeValue(token) {
+    const value = token.$value;
+    if (Array.isArray(value)) {
+      return value.map((shadow, index) => this.buildShadowLayerValue(token.name, shadow, [String(index)])).join(", ");
     }
-    const block = await formatModifierPermutation(item, baseItem, options, formatTokens);
-    if (block) {
-      cssBlocks.push(block);
+    if (typeof value === "object" && value !== null) {
+      return this.buildShadowLayerValue(token.name, value, []);
     }
-  }
-  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;
+  buildShadowLayerValue(baseName, shadow, prefix) {
+    if (typeof shadow !== "object" || shadow === null) {
+      return String(shadow);
     }
-  }
-  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;
+    const shadowObj = shadow;
+    const parts = [];
+    if (shadowObj.inset === true) {
+      parts.push("inset");
     }
-  }
-  return result;
-}
-function collectRemainder(tokens, included) {
-  const result = {};
-  for (const [name, token] of Object.entries(tokens)) {
-    if (!included.has(name)) {
-      result[name] = token;
+    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(" ");
   }
-  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;
+  buildBorderWholeValue(token) {
+    const value = token.$value;
+    if (typeof value !== "object" || value === null) {
+      return void 0;
     }
-    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;
+    const border = value;
+    if (typeof border.style !== "string") {
+      return void 0;
     }
-    processResolutionOrderRef(ref, tokens, blocks, included, baseInputs, resolver);
+    return [
+      this.buildCompositeVar(token.name, ["width"]),
+      this.buildCompositeVar(token.name, ["style"]),
+      this.buildCompositeVar(token.name, ["color"])
+    ].join(" ");
   }
-  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;
+  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(" ");
   }
-  if (!ref.startsWith(REF_PREFIX_MODIFIERS)) {
-    return;
+  buildCompositeVar(baseName, path7) {
+    return `var(--${this.buildCompositeName(baseName, path7)})`;
   }
-  const modifierName = ref.slice(REF_PREFIX_MODIFIERS.length);
-  const modifier = resolver.modifiers?.[modifierName];
-  const selectedContext = baseInputs[modifierName.toLowerCase()];
-  if (!modifier || !selectedContext) {
-    return;
+  collectCompositeLeaves(value) {
+    const leaves = [];
+    this.collectLeafEntries(value, [], leaves);
+    return leaves;
   }
-  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;
+  collectLeafEntries(value, path7, leaves) {
+    if (this.isPrimitiveValue(value)) {
+      leaves.push({ path: path7, value });
+      return;
     }
-    const inputs = normalizeModifierInputs(item.modifierInputs);
-    if (inputs[normalizedModifier] !== normalizedContext) {
-      return false;
+    if (isColorObject(value) || isDimensionObject(value) || isDurationObject(value)) {
+      leaves.push({ path: path7, value });
+      return;
     }
-    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;
+    if (Array.isArray(value)) {
+      if (value.length === 0) {
+        leaves.push({ path: path7, value });
+        return;
+      }
+      value.forEach((item, index) => {
+        this.collectLeafEntries(item, [...path7, String(index)], leaves);
+      });
+      return;
     }
-    const defaultValue = baseInputs[modifierName.toLowerCase()] ?? "";
-    for (const ctx of Object.keys(modifierDef.contexts)) {
-      if (defaultValue === ctx.toLowerCase()) {
-        continue;
+    if (typeof value === "object" && value !== null) {
+      const entries = Object.entries(value);
+      if (entries.length === 0) {
+        leaves.push({ path: path7, value });
+        return;
       }
-      pushUniqueBundleItem(
-        ordered,
-        includedKeys,
-        findSingleDiffPermutation(bundleData, modifierName, ctx, baseInputs)
-      );
+      for (const [key, child] of entries) {
+        this.collectLeafEntries(child, [...path7, this.normalizePathSegment(key)], leaves);
+      }
+      return;
     }
+    leaves.push({ path: path7, value });
   }
-}
-function orderBundleData(bundleData, resolver, baseItem) {
-  const modifiers = resolver.modifiers;
-  if (!modifiers) {
-    return bundleData;
+  normalizePathSegment(segment) {
+    return segment.trim().replace(/\s+/g, "-");
   }
-  const baseInputs = normalizeModifierInputs(baseItem.modifierInputs);
-  const orderedModifierNames = getOrderedModifierNames(resolver);
-  if (orderedModifierNames.length === 0) {
-    return bundleData;
+  buildCompositeName(base, path7) {
+    if (path7.length === 0) {
+      return base;
+    }
+    return `${base}-${path7.join("-")}`;
   }
-  const firstModifierDef = modifiers[orderedModifierNames[0] ?? ""];
-  if (!firstModifierDef) {
-    return bundleData;
+  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);
   }
-  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;
+  resolveCompositeLeafValue(leaf, originalValue, tokens, referenceTokens, preserveReferences) {
+    if (!preserveReferences) {
+      return leaf.value;
     }
-    if (!ref.startsWith(REF_PREFIX_MODIFIERS)) {
-      continue;
+    const originalLeafValue = this.getOriginalLeafValue(originalValue, leaf.path);
+    const refName = getPureAliasReferenceName(originalLeafValue);
+    if (refName === void 0) {
+      return leaf.value;
     }
-    const name = ref.slice(REF_PREFIX_MODIFIERS.length);
-    if (seen.has(name)) {
-      continue;
+    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.`
+      );
     }
-    if (!(name in modifiers)) {
-      continue;
+    return `var(--${referencedToken.name})`;
+  }
+  getOriginalLeafValue(value, path7) {
+    let current = value;
+    for (const segment of path7) {
+      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;
     }
-    ordered.push(name);
-    seen.add(name);
+    return current;
   }
-  for (const name of Object.keys(modifiers)) {
-    if (seen.has(name)) {
-      continue;
+  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;
     }
-    ordered.push(name);
-    seen.add(name);
+    return this.formatPrimitiveOrStructured(value, token.$type);
   }
-  return ordered;
-}
-function stableInputsKey(modifierInputs) {
-  const normalized = normalizeModifierInputs(modifierInputs);
-  return Object.keys(normalized).sort().map((k) => `${k}=${normalized[k]}`).join("|");
-}
-
-// src/renderers/css.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);
+  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 (opts.preset === "modifier") {
-      return await this.formatModifier(context, opts);
+    if (typeof value === "number") {
+      return String(value);
     }
-    return await this.formatStandalone(context, opts);
+    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(", ");
   }
-  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
+   * Format composite token values
    */
-  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}`);
+  formatCompositeValue(value, tokenType) {
+    if (tokenType === "shadow") {
+      return this.formatShadow(value);
     }
-    for (const token of groupTokens) {
-      this.pushTokenLines(
-        lines,
-        token,
-        tokens,
-        referenceTokens,
-        opts.preserveReferences ?? false,
-        tokenIndent,
-        newline,
-        space
-      );
+    if (tokenType === "border") {
+      return this.formatBorder(value);
     }
-    if (hasMediaQuery) {
-      lines.push(`${indent}}${newline}`);
+    if (tokenType === "transition") {
+      return this.formatTransition(value);
     }
-    lines.push(`}${newline}${newline}`);
+    return JSON.stringify(value);
   }
-  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}`);
+  /**
+   * Format a single shadow object to CSS box-shadow syntax
+   */
+  formatShadow(shadow) {
+    const parts = [];
+    if (shadow.inset === true) {
+      parts.push("inset");
     }
-    const descriptionComment = buildTokenDescriptionComment(token, "css");
-    if (descriptionComment) {
-      lines.push(`${indent}${descriptionComment}${newline}`);
+    parts.push(dimensionObjectToString(shadow.offsetX));
+    parts.push(dimensionObjectToString(shadow.offsetY));
+    parts.push(dimensionObjectToString(shadow.blur));
+    if (shadow.spread != null) {
+      parts.push(dimensionObjectToString(shadow.spread));
     }
-    for (const entry of entries) {
-      lines.push(`${indent}--${entry.name}:${space}${entry.value};${newline}`);
+    if (isColorObject(shadow.color)) {
+      parts.push(colorObjectToHex(shadow.color));
+    } else {
+      parts.push(String(shadow.color));
     }
+    return parts.join(" ");
   }
-  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;
+  /**
+   * 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(" ");
   }
-  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)
-          }
-        ];
-      }
+  /**
+   * 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 (!this.isCompositeToken(token)) {
-      return [{ name: token.name, value: this.formatValue(token) }];
+    if (Array.isArray(value.timingFunction) && value.timingFunction.length === 4) {
+      parts.push(`cubic-bezier(${value.timingFunction.join(", ")})`);
     }
-    const leaves = this.collectCompositeLeaves(token.$value);
-    if (leaves.length === 0) {
-      return [{ name: token.name, value: this.formatLeafValue(token.$value) }];
+    if (isDurationObject(value.delay)) {
+      parts.push(durationObjectToString(value.delay));
+    } else if (value.delay != null) {
+      parts.push(String(value.delay));
     }
-    const leafEntries = leaves.map((leaf) => ({
-      name: this.buildCompositeName(token.name, leaf.path),
-      value: this.formatLeafValue(
-        this.resolveCompositeLeafValue(
-          leaf,
-          token.originalValue,
-          tokens,
-          referenceTokens,
-          preserveReferences
-        )
-      )
+    return parts.join(" ");
+  }
+  async formatBundle(context, options) {
+    const bundleData = context.permutations.map(({ tokens, modifierInputs }) => ({
+      tokens,
+      modifierInputs,
+      isBase: isBasePermutation(modifierInputs, context.meta.defaults)
     }));
-    const wholeValue = this.buildCompositeWholeValue(token, preserveReferences);
-    if (!wholeValue) {
-      return leafEntries;
-    }
-    return [{ name: token.name, value: wholeValue }, ...leafEntries];
+    return await bundleAsCss(bundleData, context.resolver, options, async (tokens, resolved) => {
+      return await this.formatTokens(tokens, {
+        ...resolved,
+        preserveReferences: options.preserveReferences ?? false
+      });
+    });
   }
-  isCompositeToken(token) {
-    const isCompositeType = [
-      "shadow",
-      "typography",
-      "border",
-      "strokeStyle",
-      "transition",
-      "gradient"
-    ].includes(token.$type ?? "");
-    if (!isCompositeType) {
-      return 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;
     }
-    const value = token.$value;
-    return typeof value === "object" && value !== null || Array.isArray(value);
+    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 };
   }
-  buildCompositeWholeValue(token, preserveReferences) {
-    if (token.$type === "shadow") {
-      return preserveReferences ? this.buildShadowWholeValue(token) : this.formatValue(token);
+  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");
     }
-    if (token.$type === "border") {
-      if (!this.hasBorderShorthandStyle(token)) {
-        return void 0;
-      }
-      return preserveReferences ? this.buildBorderWholeValue(token) : this.formatValue(token);
+    const files = {};
+    const baseResult = await this.buildModifierBaseFile(context, options);
+    if (baseResult) {
+      files[baseResult.fileName] = baseResult.content;
     }
-    if (token.$type === "transition") {
-      return preserveReferences ? this.buildTransitionWholeValue(token) : this.formatValue(token);
+    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 void 0;
+    return { kind: "outputTree", files };
   }
-  hasBorderShorthandStyle(token) {
-    const value = token.$value;
-    if (typeof value !== "object" || value === null) {
-      return false;
+  async buildModifierBaseFile(context, options) {
+    const basePermutation = context.permutations.find(
+      ({ modifierInputs }) => isBasePermutation(modifierInputs, context.meta.defaults)
+    );
+    if (!basePermutation) {
+      return void 0;
     }
-    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(", ");
+    const setTokens = filterTokensFromSets(basePermutation.tokens);
+    if (Object.keys(setTokens).length === 0) {
+      return void 0;
     }
-    if (typeof value === "object" && value !== null) {
-      return this.buildShadowLayerValue(token.name, value, []);
+    const setBlocks = buildSetLayerBlocks(setTokens, context.resolver);
+    if (setBlocks.length === 0) {
+      return void 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 };
   }
-  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(" ");
+  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
+      )
+    };
   }
-  buildBorderWholeValue(token) {
-    const value = token.$value;
-    if (typeof value !== "object" || value === null) {
-      return void 0;
+  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}`);
     }
-    const border = value;
-    if (typeof border.style !== "string") {
-      return void 0;
+    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 [
-      this.buildCompositeVar(token.name, ["width"]),
-      this.buildCompositeVar(token.name, ["style"]),
-      this.buildCompositeVar(token.name, ["color"])
-    ].join(" ");
+    return { tokensFromSource, referenceTokens };
   }
-  buildTransitionWholeValue(token) {
-    const value = token.$value;
-    if (typeof value !== "object" || value === null) {
+  async buildModifierContextFile(modifierName, contextValue, context, options) {
+    const { tokensFromSource, referenceTokens } = this.collectTokensForModifierContext(
+      modifierName,
+      contextValue,
+      context.permutations
+    );
+    if (Object.keys(tokensFromSource).length === 0) {
       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, path7) {
-    return `var(--${this.buildCompositeName(baseName, path7)})`;
-  }
-  collectCompositeLeaves(value) {
-    const leaves = [];
-    this.collectLeafEntries(value, [], leaves);
-    return leaves;
+    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 };
   }
-  collectLeafEntries(value, path7, leaves) {
-    if (this.isPrimitiveValue(value)) {
-      leaves.push({ path: path7, value });
-      return;
+  resolveModifierContext(modifierInputs, context, isBase) {
+    if (!context.resolver.modifiers) {
+      return { modifierName: "", modifierContext: "" };
     }
-    if (isColorObject(value) || isDimensionObject(value) || isDurationObject(value)) {
-      leaves.push({ path: path7, value });
-      return;
+    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] ?? ""
+      };
     }
-    if (Array.isArray(value)) {
-      if (value.length === 0) {
-        leaves.push({ path: path7, value });
-        return;
+    for (const [name, value] of Object.entries(normalizedInputs)) {
+      if (value !== normalizedDefaults[name]) {
+        return { modifierName: name, modifierContext: value };
       }
-      value.forEach((item, index) => {
-        this.collectLeafEntries(item, [...path7, String(index)], leaves);
+    }
+    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();
+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);
       });
-      return;
     }
-    if (typeof value === "object" && value !== null) {
-      const entries = Object.entries(value);
-      if (entries.length === 0) {
-        leaves.push({ path: path7, value });
-        return;
-      }
-      for (const [key, child] of entries) {
-        this.collectLeafEntries(child, [...path7, this.normalizePathSegment(key)], leaves);
-      }
-      return;
+    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;
     }
-    leaves.push({ path: path7, value });
-  }
-  normalizePathSegment(segment) {
-    return segment.trim().replace(/\s+/g, "-");
+    return outputTree(files);
   }
-  buildCompositeName(base, path7) {
-    if (path7.length === 0) {
-      return base;
+  async formatTokens(tokens, options) {
+    const lines = [];
+    lines.push(...this.formatAsObject(tokens, options));
+    const code = lines.join("\n");
+    if (options.minify) {
+      return code;
     }
-    return `${base}-${path7.join("-")}`;
+    return await prettier.format(code, {
+      parser: "babel",
+      printWidth: 80,
+      tabWidth: 2,
+      useTabs: false,
+      semi: false,
+      singleQuote: true,
+      trailingComma: "es5"
+    });
   }
-  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);
+  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("}");
     }
-    if (Array.isArray(value)) {
-      return JSON.stringify(value);
+    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);
     }
-    if (typeof value === "object" && value != null) {
-      return JSON.stringify(value);
+    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 ? "" : ","}`
+      );
     }
-    return String(value);
   }
-  resolveCompositeLeafValue(leaf, originalValue, tokens, referenceTokens, preserveReferences) {
-    if (!preserveReferences) {
-      return leaf.value;
+  pushTokenComments(lines, token, indent) {
+    const deprecationComment = buildTokenDeprecationComment(token, "js");
+    if (deprecationComment) {
+      lines.push(`${indent}${deprecationComment}`);
     }
-    const originalLeafValue = this.getOriginalLeafValue(originalValue, leaf.path);
-    const refName = getPureAliasReferenceName(originalLeafValue);
-    if (refName === void 0) {
-      return leaf.value;
+    const descriptionComment = buildTokenDescriptionComment(token, "js");
+    if (descriptionComment) {
+      lines.push(`${indent}${descriptionComment}`);
     }
-    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.`
-      );
+  tokensToPlainObject(tokens, structure) {
+    if (structure === "nested") {
+      return buildNestedTokenObject(tokens, (token) => token.$value);
     }
-    return `var(--${referencedToken.name})`;
+    const result = {};
+    for (const [name, token] of getSortedTokenEntries(tokens)) {
+      result[name] = token.$value;
+    }
+    return result;
   }
-  getOriginalLeafValue(value, path7) {
-    let current = value;
-    for (const segment of path7) {
-      if (Array.isArray(current)) {
-        const index = Number(segment);
-        if (!Number.isInteger(index)) {
-          return void 0;
-        }
-        current = current[index];
+  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;
       }
-      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;
+      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);
         }
-        current = matched[1];
+        lines.push(
+          `${indentStr2}${this.quoteKey(key)}: ${JSON.stringify(value)}${isLast ? "" : ","}`
+        );
         continue;
       }
-      return void 0;
+      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 current;
-  }
-  isPrimitiveValue(value) {
-    return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
+    return jsonString;
   }
   /**
-   * Format token value for CSS
-   * Handles DTCG 2025.10 object formats for colors and dimensions
+   * Flatten tokens to simple key-value pairs
    */
-  formatValue(token) {
-    const value = token.$value;
-    const typed = this.formatTypedValue(token.$type, value);
-    if (typed !== void 0) {
-      return typed;
+  flattenValues(tokens) {
+    const result = {};
+    for (const [name, token] of getSortedTokenEntries(tokens)) {
+      result[name] = token.$value;
     }
-    return this.formatPrimitiveOrStructured(value, token.$type);
+    return result;
   }
-  formatTypedValue(type, value) {
-    if (type === "color" && isColorObject(value)) {
-      return colorObjectToHex(value);
+  /**
+   * Flatten tokens to metadata objects
+   */
+  flattenTokens(tokens) {
+    const result = {};
+    for (const [name, token] of getSortedTokenEntries(tokens)) {
+      result[name] = this.serializeToken(token);
     }
-    if (type === "dimension") {
-      return typeof value === "string" ? value : dimensionObjectToString(value);
+    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;
     }
-    if (type === "duration") {
-      if (isDurationObject(value)) {
-        return durationObjectToString(value);
-      }
-      if (typeof value === "string") {
-        return value;
-      }
+    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;
   }
-  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);
+  const tokensToInclude = filterTokensByValueChange(tokens, baseItem.tokens);
+  if (Object.keys(tokensToInclude).length === 0) {
+    return void 0;
   }
-  formatArrayValue(value, tokenType) {
-    if (tokenType === "shadow" && value.length > 0 && typeof value[0] === "object") {
-      return value.map((shadowObj) => this.formatShadow(shadowObj)).join(", ");
+  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 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);
+  return changed;
+}
+function collectVariantDeclarations(bundleData, baseItem, options) {
+  const declarations = [];
+  for (const item of bundleData) {
+    if (item.isBase) {
+      continue;
     }
-    if (tokenType === "border") {
-      return this.formatBorder(value);
+    const differenceCount = countModifierDifferences(item.modifierInputs, baseItem.modifierInputs);
+    if (differenceCount > 1) {
+      continue;
     }
-    if (tokenType === "transition") {
-      return this.formatTransition(value);
+    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;
     }
-    return JSON.stringify(value);
+    const selector = resolveSelector(options.selector, modifier, context, false, normalized);
+    declarations.push(`@custom-variant ${variantName} (&:where(${selector}, ${selector} *));`);
   }
-  /**
-   * 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 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 parts.join(" ");
+    return await this.formatStandalone(context, opts);
   }
   /**
-   * Format a border object to CSS border shorthand syntax
+   * Format tokens as Tailwind v4 @theme CSS variables
    */
-  formatBorder(value) {
-    const parts = [];
-    if (isDimensionObject(value.width)) {
-      parts.push(dimensionObjectToString(value.width));
-    } else if (value.width != null) {
-      parts.push(String(value.width));
+  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 (typeof value.style === "string") {
-      parts.push(value.style);
+    if (options.includeImport || options.variantDeclarations.length > 0) {
+      lines.push(newline);
     }
-    if (isColorObject(value.color)) {
-      parts.push(colorObjectToHex(value.color));
-    } else if (value.color != null) {
-      parts.push(String(value.color));
+    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}`);
     }
-    return parts.join(" ");
+    lines.push(`}${newline}`);
+    const cssString = lines.join("");
+    return options.minify ? cssString : await this.formatWithPrettier(cssString);
   }
   /**
-   * Format a transition object to CSS transition shorthand syntax
+   * 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.
    */
-  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(", ")})`);
+  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}`);
     }
-    if (isDurationObject(value.delay)) {
-      parts.push(durationObjectToString(value.delay));
-    } else if (value.delay != null) {
-      parts.push(String(value.delay));
+    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}`);
     }
-    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;
+    if (hasMediaQuery) {
+      lines.push(`${indent}}${newline}`);
+      lines.push(`}${newline}`);
+    } else {
+      lines.push(`}${newline}`);
     }
-    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 };
+    return lines.join("");
   }
-  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;
+  buildVariableName(token) {
+    const prefix = TAILWIND_NAMESPACE_MAP[token.$type ?? ""];
+    if (!prefix) {
+      return token.name;
     }
-    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;
-        }
-      }
+    const nameLower = token.name.toLowerCase();
+    const prefixLower = prefix.toLowerCase();
+    if (nameLower.startsWith(`${prefixLower}-`) || nameLower.startsWith(`${prefixLower}.`)) {
+      return token.name;
     }
-    return { kind: "outputTree", files };
+    return `${prefix}-${token.name}`;
   }
-  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;
+  formatValue(token) {
+    const value = token.$value;
+    if (token.$type === "color" && isColorObject(value)) {
+      return colorObjectToHex(value);
     }
-    const setBlocks = buildSetLayerBlocks(setTokens, context.resolver);
-    if (setBlocks.length === 0) {
-      return void 0;
+    if (token.$type === "dimension" && isDimensionObject(value)) {
+      return dimensionObjectToString(value);
     }
-    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}`);
+    if (token.$type === "duration" && isDurationObject(value)) {
+      return durationObjectToString(value);
     }
-    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;
+    if (token.$type === "fontFamily") {
+      if (Array.isArray(value)) {
+        return value.map((v) => typeof v === "string" && v.includes(" ") ? `"${v}"` : v).join(", ");
       }
-      tokensFromSource = { ...tokensFromSource, ...filterTokensBySource(tokens, expectedSource) };
-      referenceTokens = { ...referenceTokens, ...tokens };
+      return typeof value === "string" ? value : String(value);
     }
-    return { tokensFromSource, referenceTokens };
+    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);
   }
-  async buildModifierContextFile(modifierName, contextValue, context, options) {
-    const { tokensFromSource, referenceTokens } = this.collectTokensForModifierContext(
-      modifierName,
-      contextValue,
-      context.permutations
-    );
-    if (Object.keys(tokensFromSource).length === 0) {
-      return void 0;
+  formatShadowValue(value) {
+    if (Array.isArray(value) && value.length > 0 && typeof value[0] === "object") {
+      return value.map((s) => this.formatSingleShadow(s)).join(", ");
     }
-    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 };
+    if (typeof value === "object" && value !== null) {
+      return this.formatSingleShadow(value);
+    }
+    return String(value);
   }
-  resolveModifierContext(modifierInputs, context, isBase) {
-    if (!context.resolver.modifiers) {
-      return { modifierName: "", modifierContext: "" };
+  formatSingleShadow(shadow) {
+    const parts = [];
+    if (shadow.inset === true) {
+      parts.push("inset");
     }
-    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] ?? ""
-      };
+    if (isDimensionObject(shadow.offsetX)) {
+      parts.push(dimensionObjectToString(shadow.offsetX));
     }
-    for (const [name, value] of Object.entries(normalizedInputs)) {
-      if (value !== normalizedDefaults[name]) {
-        return { modifierName: name, modifierContext: value };
-      }
+    if (isDimensionObject(shadow.offsetY)) {
+      parts.push(dimensionObjectToString(shadow.offsetY));
     }
-    return { modifierName: "", modifierContext: "" };
+    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 cssRenderer() {
-  const rendererInstance = new CssRenderer();
+function tailwindRenderer() {
+  const rendererInstance = new TailwindRenderer();
   return {
     format: (context, options) => rendererInstance.format(
       context,
@@ -8763,11 +8688,11 @@ function cssRenderer() {
   };
 }
 
-// src/renderers/ios.ts
+// src/outputs/ios/renderer.ts
 init_utils();
 init_metadata();
-var toSRGB2 = converter("rgb");
-var toP32 = converter("p3");
+var toSRGB = converter("rgb");
+var toP3 = converter("p3");
 var SWIFT_TYPE_GROUP_MAP = {
   color: "Colors",
   dimension: "Spacing",
@@ -8993,13 +8918,13 @@ var IosRenderer = class {
     const colorObj = value;
     const alpha = colorObj.alpha ?? 1;
     if (options.colorSpace === "displayP3") {
-      const p3 = toP32(dtcgObjectToCulori(colorObj));
+      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 = toSRGB2(dtcgObjectToCulori(colorObj));
+    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);
@@ -9317,602 +9242,620 @@ function iosRenderer() {
   };
 }
 
-// src/renderers/js-module.ts
-init_utils();
+// src/outputs/android/renderer.ts
+init_errors();
 init_token_utils();
+init_utils();
 init_metadata();
-var JsModuleRenderer = class {
+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) {
-    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_js(), js_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;
+    if (!options?.packageName) {
+      throw new ConfigurationError(
+        `Output "${context.output.name}": packageName is required for Android output`
+      );
     }
-    return outputTree(files);
+    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);
   }
-  async formatTokens(tokens, options) {
-    const lines = [];
-    lines.push(...this.formatAsObject(tokens, options));
-    const code = lines.join("\n");
-    if (options.minify) {
-      return code;
+  // -----------------------------------------------------------------------
+  // 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 await prettier.format(code, {
-      parser: "babel",
-      printWidth: 80,
-      tabWidth: 2,
-      useTabs: false,
-      semi: false,
-      singleQuote: true,
-      trailingComma: "es5"
-    });
+    return root;
   }
-  formatAsObject(tokens, options) {
-    const lines = [];
-    const tokenMap = this.buildTokenMap(tokens);
-    const varName = options.moduleName !== "" ? options.moduleName : "tokens";
+  // -----------------------------------------------------------------------
+  // 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 path7 = token.path;
+    const withoutTypePrefix = path7.length > 1 ? path7.slice(1) : path7;
+    const joined = withoutTypePrefix.join("_");
+    return toSafeIdentifier(joined, KOTLIN_KEYWORDS, false);
+  }
+  // -----------------------------------------------------------------------
+  // Rendering
+  // -----------------------------------------------------------------------
+  formatTokens(tokens, options) {
     if (options.structure === "flat") {
-      lines.push(`const ${varName} = {`);
-      this.addFlatProperties(lines, tokens, 1);
+      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("}");
-    } else {
-      lines.push(`const ${varName} = {`);
-      const tokenObj = this.tokensToPlainObject(tokens, "nested");
-      this.addNestedProperties(lines, tokenObj, tokenMap, 1);
+    });
+  }
+  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("");
-    lines.push(`export default ${varName}`);
-    return lines;
+    return lines.join("\n");
   }
-  buildTokenMap(tokens) {
-    const map = /* @__PURE__ */ new Map();
-    for (const [name, token] of Object.entries(tokens)) {
-      map.set(name, token);
+  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("");
     }
-    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 ? "" : ","}`
-      );
+  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);
+      }
     }
   }
-  pushTokenComments(lines, token, indent) {
-    const deprecationComment = buildTokenDeprecationComment(token, "js");
-    if (deprecationComment) {
-      lines.push(`${indent}${deprecationComment}`);
-    }
-    const descriptionComment = buildTokenDescriptionComment(token, "js");
+  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(`${indent}${descriptionComment}`);
-    }
-  }
-  tokensToPlainObject(tokens, structure) {
-    if (structure === "nested") {
-      return buildNestedTokenObject(tokens, (token) => token.$value);
+      lines.push(`${pad}${descriptionComment}`);
     }
-    const result = {};
-    for (const [name, token] of getSortedTokenEntries(tokens)) {
-      result[name] = token.$value;
+    const deprecation = buildKotlinDeprecationAnnotation(token);
+    if (deprecation) {
+      lines.push(`${pad}${deprecation}`);
     }
-    return result;
+    lines.push(`${pad}${options.visPrefix}val ${kotlinName}${annotation} = ${kotlinValue}`);
   }
-  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 ? "" : ","}`);
+  // -----------------------------------------------------------------------
+  // 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`);
     }
-  }
-  quoteKey(key) {
-    if (/^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(key)) {
-      return key;
+    if (tokenTypes.has("dimension") || tokenTypes.has("shadow") || tokenTypes.has("border")) {
+      imports.add(`${ns}.ui.unit.Dp`);
+      imports.add(`${ns}.ui.unit.dp`);
     }
-    return `"${key}"`;
-  }
-};
-function jsRenderer() {
-  const rendererInstance = new JsModuleRenderer();
-  return {
-    format: (context, options) => rendererInstance.format(
-      context,
-      options ?? context.output.options
-    )
-  };
-}
-
-// src/renderers/json.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_json(), json_exports));
-      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);
-      });
+    if (tokenTypes.has("typography") || tokenTypes.has("fontFamily")) {
+      imports.add(`${ns}.ui.text.TextStyle`);
+      imports.add(`${ns}.ui.unit.sp`);
     }
-    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;
+    if (tokenTypes.has("typography") || tokenTypes.has("fontWeight")) {
+      imports.add(`${ns}.ui.text.font.FontWeight`);
     }
-    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);
+    if (tokenTypes.has("fontFamily")) {
+      imports.add(`${ns}.ui.text.font.FontFamily`);
     }
-    const jsonString = JSON.stringify(output);
-    if (!opts.minify) {
-      return await prettier.format(jsonString, {
-        parser: "json",
-        printWidth: 80,
-        tabWidth: 2,
-        useTabs: false
-      });
+    if (tokenTypes.has("duration")) {
+      imports.add("kotlin.time.Duration");
+      imports.add("kotlin.time.Duration.Companion.milliseconds");
+      imports.add("kotlin.time.Duration.Companion.seconds");
     }
-    return jsonString;
-  }
-  /**
-   * Flatten tokens to simple key-value pairs
-   */
-  flattenValues(tokens) {
-    const result = {};
-    for (const [name, token] of getSortedTokenEntries(tokens)) {
-      result[name] = token.$value;
+    if (tokenTypes.has("cubicBezier")) {
+      imports.add(`${ns}.animation.core.CubicBezierEasing`);
     }
-    return result;
-  }
-  /**
-   * Flatten tokens to metadata objects
-   */
-  flattenTokens(tokens) {
-    const result = {};
-    for (const [name, token] of getSortedTokenEntries(tokens)) {
-      result[name] = this.serializeToken(token);
+    if (tokenTypes.has("shadow")) {
+      imports.add(`${ns}.runtime.Immutable`);
     }
-    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/renderers/tailwind.ts
-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;
+    if (tokenTypes.has("border")) {
+      imports.add(`${ns}.foundation.BorderStroke`);
     }
-    const block = await formatModifierOverride(item, baseItem, resolvedOpts, formatOverrideBlock);
-    if (block) {
-      cssBlocks.push(block);
+    if (options.colorSpace === "displayP3" && hasColors) {
+      imports.add(`${ns}.ui.graphics.colorspace.ColorSpaces`);
     }
+    return Array.from(imports).sort();
   }
-  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;
+  collectTokenTypesFromEntries(tokens) {
+    const types = /* @__PURE__ */ new Set();
+    for (const [, token] of Object.entries(tokens)) {
+      if (token.$type) {
+        types.add(token.$type);
+      }
+    }
+    return types;
   }
-  const tokensToInclude = filterTokensByValueChange(tokens, baseItem.tokens);
-  if (Object.keys(tokensToInclude).length === 0) {
-    return void 0;
+  // -----------------------------------------------------------------------
+  // 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;
+      }
+    }
   }
-  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;
+  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 (JSON.stringify(token.$value) !== JSON.stringify(baseToken.$value)) {
-      changed[name] = token;
+    if (token.$type === "dimension") {
+      return this.formatDimensionValue(value);
     }
-  }
-  return changed;
-}
-function collectVariantDeclarations(bundleData, baseItem, options) {
-  const declarations = [];
-  for (const item of bundleData) {
-    if (item.isBase) {
-      continue;
+    if (token.$type === "fontFamily") {
+      return this.formatFontFamilyValue(value);
     }
-    const differenceCount = countModifierDifferences(item.modifierInputs, baseItem.modifierInputs);
-    if (differenceCount > 1) {
-      continue;
+    if (token.$type === "fontWeight") {
+      return this.formatFontWeightValue(value);
     }
-    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;
+    if (token.$type === "duration") {
+      return this.formatDurationValue(value);
     }
-    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();
-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);
+    if (token.$type === "shadow") {
+      return this.formatShadowValue(value, options, depth);
     }
-    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 (token.$type === "typography") {
+      return this.formatTypographyValue(value, options, depth);
     }
-    if (options.variantDeclarations.length > 0) {
-      if (options.includeImport) {
-        lines.push(newline);
-      }
-      for (const declaration of options.variantDeclarations) {
-        lines.push(`${declaration}${newline}`);
-      }
+    if (token.$type === "border") {
+      return this.formatBorderValue(value, options);
     }
-    if (options.includeImport || options.variantDeclarations.length > 0) {
-      lines.push(newline);
+    if (token.$type === "number") {
+      return typeof value === "number" ? formatKotlinNumber(value) : String(value);
     }
-    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}`);
+    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()})`;
+        }
       }
-      lines.push(`${indent}--${varName}:${space}${varValue};${newline}`);
+      return "Color.Unspecified";
     }
-    lines.push(`}${newline}`);
-    const cssString = lines.join("");
-    return options.minify ? cssString : await this.formatWithPrettier(cssString);
+    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);
   }
-  /**
-   * 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}`);
+  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)`;
     }
-    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}`);
+    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()})`;
     }
-    if (hasMediaQuery) {
-      lines.push(`${indent}}${newline}`);
-      lines.push(`}${newline}`);
-    } else {
-      lines.push(`}${newline}`);
+    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 lines.join("");
+    return typeof value === "number" ? `${value}.dp` : `0.dp`;
   }
-  buildVariableName(token) {
-    const prefix = TAILWIND_NAMESPACE_MAP[token.$type ?? ""];
-    if (!prefix) {
-      return token.name;
+  formatFontFamilyValue(value) {
+    if (Array.isArray(value)) {
+      const primary = value[0];
+      if (typeof primary === "string") {
+        return this.mapKotlinFontFamily(primary);
+      }
+      return "FontFamily.Default";
     }
-    const nameLower = token.name.toLowerCase();
-    const prefixLower = prefix.toLowerCase();
-    if (nameLower.startsWith(`${prefixLower}-`) || nameLower.startsWith(`${prefixLower}.`)) {
-      return token.name;
+    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);
     }
-    return `${prefix}-${token.name}`;
+    if (typeof value === "string") {
+      return this.namedFontWeight(value) ?? "FontWeight.Normal";
+    }
+    return "FontWeight.Normal";
   }
-  formatValue(token) {
-    const value = token.$value;
-    if (token.$type === "color" && isColorObject(value)) {
-      return colorObjectToHex(value);
+  numericFontWeight(weight) {
+    if (weight <= 100) {
+      return "FontWeight.Thin";
+    }
+    if (weight <= 200) {
+      return "FontWeight.ExtraLight";
     }
-    if (token.$type === "dimension" && isDimensionObject(value)) {
-      return dimensionObjectToString(value);
+    if (weight <= 300) {
+      return "FontWeight.Light";
     }
-    if (token.$type === "duration" && isDurationObject(value)) {
-      return durationObjectToString(value);
+    if (weight <= 400) {
+      return "FontWeight.Normal";
     }
-    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 (weight <= 500) {
+      return "FontWeight.Medium";
     }
-    if (token.$type === "shadow") {
-      return this.formatShadowValue(value);
+    if (weight <= 600) {
+      return "FontWeight.SemiBold";
     }
-    if (token.$type === "cubicBezier" && Array.isArray(value) && value.length === 4) {
-      return `cubic-bezier(${value.join(", ")})`;
+    if (weight <= 700) {
+      return "FontWeight.Bold";
     }
-    if (typeof value === "string") {
-      return value;
+    if (weight <= 800) {
+      return "FontWeight.ExtraBold";
     }
-    if (typeof value === "number") {
-      return String(value);
+    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 String(value);
+    return typeof value === "number" ? `${value}.milliseconds` : "0.milliseconds";
   }
-  formatShadowValue(value) {
-    if (Array.isArray(value) && value.length > 0 && typeof value[0] === "object") {
-      return value.map((s) => this.formatSingleShadow(s)).join(", ");
+  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);
+      return this.formatSingleShadow(value, options, depth);
     }
-    return String(value);
+    return "ShadowToken(color = Color.Unspecified, elevation = 0.dp, offsetX = 0.dp, offsetY = 0.dp)";
   }
-  formatSingleShadow(shadow) {
-    const parts = [];
-    if (shadow.inset === true) {
-      parts.push("inset");
+  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)";
     }
-    if (isDimensionObject(shadow.offsetX)) {
-      parts.push(dimensionObjectToString(shadow.offsetX));
+    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()";
     }
-    if (isDimensionObject(shadow.offsetY)) {
-      parts.push(dimensionObjectToString(shadow.offsetY));
+    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 (isDimensionObject(shadow.blur)) {
-      parts.push(dimensionObjectToString(shadow.blur));
+    if (typo.fontWeight != null) {
+      parts.push(`fontWeight = ${this.formatFontWeightValue(typo.fontWeight)}`);
     }
-    if (shadow.spread != null && isDimensionObject(shadow.spread)) {
-      parts.push(dimensionObjectToString(shadow.spread));
+    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 (isColorObject(shadow.color)) {
-      parts.push(colorObjectToHex(shadow.color));
-    } else if (shadow.color != null) {
-      parts.push(String(shadow.color));
+    if (isDimensionObject(typo.letterSpacing)) {
+      const dim = typo.letterSpacing;
+      const spValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
+      parts.push(`letterSpacing = ${spValue}.sp`);
     }
-    return parts.join(" ");
-  }
-  async formatWithPrettier(css2) {
-    try {
-      return await prettier.format(css2, {
-        parser: "css",
-        printWidth: 80,
-        tabWidth: 2,
-        useTabs: false
-      });
-    } catch {
-      return css2;
+    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})`;
   }
-  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)
-    );
-  }
+  // -----------------------------------------------------------------------
+  // Output: standalone
+  // -----------------------------------------------------------------------
   async formatStandalone(context, options) {
     assertFileRequired(
       context.buildPath,
       context.output.file,
       context.output.name,
-      "standalone Tailwind"
+      "standalone Android"
     );
     const files = {};
     for (const { tokens, modifierInputs } of context.permutations) {
       const processedTokens = stripInternalMetadata(tokens);
-      const content = await this.formatTokens(processedTokens, options);
+      const content = this.formatTokens(processedTokens, options);
       const fileName = context.output.file ? resolveFileName(context.output.file, modifierInputs) : buildInMemoryOutputKey({
         outputName: context.output.name,
-        extension: "css",
+        extension: "kt",
         modifierInputs,
         resolver: context.resolver,
         defaults: context.meta.defaults
@@ -9921,9 +9864,74 @@ var TailwindRenderer = class {
     }
     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 tailwindRenderer() {
-  const rendererInstance = new TailwindRenderer();
+function androidRenderer() {
+  const rendererInstance = new AndroidRenderer();
   return {
     format: (context, options) => rendererInstance.format(
       context,
@@ -9932,7 +9940,23 @@ function tailwindRenderer() {
   };
 }
 
-// src/builders.ts
+// 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,
@@ -10046,11 +10070,6 @@ function android(config) {
   };
 }
 
-// src/renderers/types.ts
-function defineRenderer(renderer) {
-  return renderer;
-}
-
 // src/index.ts
 init_errors();
 /**