dispersa 0.4.1 → 0.4.2

package/dist/index.js

@@ -17,47 +17,6 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
-// src/shared/utils/token-utils.ts
-function formatDeprecationMessage(token, description = "", format = "bracket") {
-  if (token.$deprecated == null || token.$deprecated === false) {
-    return description;
-  }
-  const deprecationMsg = typeof token.$deprecated === "string" ? token.$deprecated : "";
-  if (format === "comment") {
-    const msg = deprecationMsg ? ` ${deprecationMsg}` : "";
-    return `DEPRECATED${msg}`;
-  } else {
-    const msg = deprecationMsg ? `: ${deprecationMsg}` : "";
-    const prefix = `[DEPRECATED${msg}]`;
-    return description ? `${prefix} ${description}` : prefix;
-  }
-}
-function stripInternalTokenMetadata(tokens) {
-  const cleaned = {};
-  for (const [name, token] of Object.entries(tokens)) {
-    const { _isAlias: _alias, _sourceModifier: _source, _sourceSet, ...rest } = token;
-    cleaned[name] = rest;
-  }
-  return cleaned;
-}
-function getSortedTokenEntries(tokens) {
-  return Object.entries(tokens).sort(([nameA], [nameB]) => nameA.localeCompare(nameB));
-}
-function isTokenLike(value) {
-  return typeof value === "object" && value !== null && ("$value" in value || "$ref" in value);
-}
-function getPureAliasReferenceName(value) {
-  if (typeof value !== "string") {
-    return void 0;
-  }
-  const match = /^\{([^}]+)\}$/.exec(value);
-  return match?.[1]?.trim();
-}
-var init_token_utils = __esm({
-  "src/shared/utils/token-utils.ts"() {
-  }
-});
-
 // src/shared/errors/index.ts
 var DispersaError, TokenReferenceError, CircularReferenceError, ValidationError, FileOperationError, ConfigurationError, BasePermutationError, ModifierError;
 var init_errors = __esm({
@@ -145,6 +104,70 @@ var init_errors = __esm({
   }
 });
 
+// src/shared/utils/token-utils.ts
+function formatDeprecationMessage(token, description = "", format = "bracket") {
+  if (token.$deprecated == null || token.$deprecated === false) {
+    return description;
+  }
+  const deprecationMsg = typeof token.$deprecated === "string" ? token.$deprecated : "";
+  if (format === "comment") {
+    const msg2 = deprecationMsg ? ` ${deprecationMsg}` : "";
+    return `DEPRECATED${msg2}`;
+  }
+  const msg = deprecationMsg ? `: ${deprecationMsg}` : "";
+  const prefix = `[DEPRECATED${msg}]`;
+  return description ? `${prefix} ${description}` : prefix;
+}
+function stripInternalTokenMetadata(tokens) {
+  const cleaned = {};
+  for (const [name, token] of Object.entries(tokens)) {
+    const { _isAlias: _alias, _sourceModifier: _source, _sourceSet, ...rest } = token;
+    cleaned[name] = rest;
+  }
+  return cleaned;
+}
+function getSortedTokenEntries(tokens) {
+  return Object.entries(tokens).sort(([nameA], [nameB]) => nameA.localeCompare(nameB));
+}
+function buildNestedTokenObject(tokens, extractValue) {
+  const result = {};
+  for (const [, token] of getSortedTokenEntries(tokens)) {
+    setNestedValue(result, token.path, extractValue(token));
+  }
+  return result;
+}
+function setNestedValue(root, path7, value) {
+  let current = root;
+  for (let i = 0; i < path7.length - 1; i++) {
+    const part = path7[i];
+    if (part == null) {
+      continue;
+    }
+    if (!(part in current)) {
+      current[part] = {};
+    }
+    current = current[part];
+  }
+  const lastPart = path7[path7.length - 1];
+  if (lastPart != null) {
+    current[lastPart] = value;
+  }
+}
+function isTokenLike(value) {
+  return typeof value === "object" && value !== null && ("$value" in value || "$ref" in value);
+}
+function getPureAliasReferenceName(value) {
+  if (typeof value !== "string") {
+    return void 0;
+  }
+  const match = /^\{([^}]+)\}$/.exec(value);
+  return match?.[1]?.trim();
+}
+var init_token_utils = __esm({
+  "src/shared/utils/token-utils.ts"() {
+  }
+});
+
 // src/shared/utils/validation-handler.ts
 var ValidationHandler;
 var init_validation_handler = __esm({
@@ -2884,30 +2907,29 @@ var init_validator = __esm({
       validateTokenOrGroup(obj) {
         const hasValue = isTokenLike(obj);
         if (hasValue) {
-          const tokenErrors = this.validateToken(obj);
-          if (tokenErrors.length === 0) {
+          const tokenErrors2 = this.validateToken(obj);
+          if (tokenErrors2.length === 0) {
             return { type: "token", errors: [] };
           }
           return {
             type: "invalid",
-            errors: tokenErrors,
+            errors: tokenErrors2,
             message: "Object has $value/$ref but failed token validation"
           };
-        } else {
-          const groupErrors = this.validateGroup(obj);
-          if (groupErrors.length === 0) {
-            return { type: "group", errors: [] };
-          }
-          const tokenErrors = this.validateToken(obj);
-          if (tokenErrors.length === 0) {
-            return { type: "token", errors: [] };
-          }
-          return {
-            type: "invalid",
-            errors: groupErrors.length < tokenErrors.length ? groupErrors : tokenErrors,
-            message: groupErrors.length < tokenErrors.length ? "Object appears to be a group but failed validation" : "Object appears to be a token but failed validation"
-          };
         }
+        const groupErrors = this.validateGroup(obj);
+        if (groupErrors.length === 0) {
+          return { type: "group", errors: [] };
+        }
+        const tokenErrors = this.validateToken(obj);
+        if (tokenErrors.length === 0) {
+          return { type: "token", errors: [] };
+        }
+        return {
+          type: "invalid",
+          errors: groupErrors.length < tokenErrors.length ? groupErrors : tokenErrors,
+          message: groupErrors.length < tokenErrors.length ? "Object appears to be a group but failed validation" : "Object appears to be a token but failed validation"
+        };
       }
       /**
        * Format AJV errors into readable ValidationError objects
@@ -3102,35 +3124,34 @@ var init_resolver_parser = __esm({
             this.validateSourceReferences(set.sources, `set "${setName}"`, contextMsg);
           }
         }
-        if (resolver.modifiers) {
-          for (const [modifierName, modifier] of Object.entries(resolver.modifiers)) {
-            for (const [contextName, sources] of Object.entries(modifier.contexts)) {
-              this.validateSourceReferences(
-                sources,
-                `modifier "${modifierName}" context "${contextName}"`,
-                contextMsg
-              );
-            }
+        if (!resolver.modifiers) {
+          return;
+        }
+        for (const [modifierName, modifier] of Object.entries(resolver.modifiers)) {
+          for (const [contextName, sources] of Object.entries(modifier.contexts)) {
+            this.validateSourceReferences(
+              sources,
+              `modifier "${modifierName}" context "${contextName}"`,
+              contextMsg
+            );
           }
         }
       }
-      /**
-       * Validate source references in an array
-       */
       validateSourceReferences(sources, location, contextMsg) {
         for (const source of sources) {
-          if (typeof source === "object" && source !== null && "$ref" in source) {
-            const ref = source.$ref;
-            if (ref.startsWith("#/modifiers/")) {
-              this.handleValidationIssue(
-                `Invalid reference in ${location}: "${ref}". Sets and modifier contexts MUST NOT reference modifiers${contextMsg}`
-              );
-            }
-            if (ref.startsWith("#/resolutionOrder/")) {
-              this.handleValidationIssue(
-                `Invalid reference in ${location}: "${ref}". References MUST NOT point to resolutionOrder array items${contextMsg}`
-              );
-            }
+          if (typeof source !== "object" || source === null || !("$ref" in source)) {
+            continue;
+          }
+          const ref = source.$ref;
+          if (ref.startsWith("#/modifiers/")) {
+            this.handleValidationIssue(
+              `Invalid reference in ${location}: "${ref}". Sets and modifier contexts MUST NOT reference modifiers${contextMsg}`
+            );
+          }
+          if (ref.startsWith("#/resolutionOrder/")) {
+            this.handleValidationIssue(
+              `Invalid reference in ${location}: "${ref}". References MUST NOT point to resolutionOrder array items${contextMsg}`
+            );
           }
         }
       }
@@ -3210,15 +3231,14 @@ var init_resolver_loader = __esm({
        * ```
        */
       async load(resolver) {
-        if (typeof resolver === "string") {
-          const absolutePath = path.resolve(this.options.baseDir, resolver);
-          const resolverDoc = await this.parser.parseFile(absolutePath);
-          const baseDir = path.dirname(absolutePath);
-          return { resolverDoc, baseDir };
-        } else {
-          const resolverDoc = this.parser.parseInline(resolver);
-          return { resolverDoc, baseDir: this.options.baseDir };
+        if (typeof resolver !== "string") {
+          const resolverDoc2 = this.parser.parseInline(resolver);
+          return { resolverDoc: resolverDoc2, baseDir: this.options.baseDir };
         }
+        const absolutePath = path.resolve(this.options.baseDir, resolver);
+        const resolverDoc = await this.parser.parseFile(absolutePath);
+        const baseDir = path.dirname(absolutePath);
+        return { resolverDoc, baseDir };
       }
       /**
        * Load only the resolver document (without base directory)
@@ -3251,6 +3271,35 @@ function sanitizeDataAttributeName(value) {
 function escapeCssString(value) {
   return value.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r?\n/g, " ");
 }
+function groupTokensByType(tokens, typeGroupMap) {
+  const groupMap = /* @__PURE__ */ new Map();
+  for (const [, token] of getSortedTokenEntries(tokens)) {
+    const groupName = typeGroupMap[token.$type ?? ""] ?? "Other";
+    const existing = groupMap.get(groupName) ?? [];
+    existing.push(token);
+    groupMap.set(groupName, existing);
+  }
+  return Array.from(groupMap.entries()).map(([name, groupTokens]) => ({
+    name,
+    tokens: groupTokens
+  }));
+}
+function indentStr(width, level) {
+  return " ".repeat(width * level);
+}
+function buildGeneratedFileHeader() {
+  return [
+    "// Generated by Dispersa - do not edit manually",
+    "// https://github.com/timges/dispersa"
+  ].join("\n");
+}
+function toSafeIdentifier(name, keywords, capitalize) {
+  const camel = name.replace(/[-._]+(.)/g, (_, c) => c.toUpperCase()).replace(/[-._]+$/g, "").replace(/^[-._]+/g, "");
+  const cased = capitalize ? camel.charAt(0).toUpperCase() + camel.slice(1) : camel.charAt(0).toLowerCase() + camel.slice(1);
+  const safe = /^\d/.test(cased) ? `_${cased}` : cased;
+  const keyCheck = capitalize ? safe.charAt(0).toLowerCase() + safe.slice(1) : safe;
+  return keywords.has(keyCheck) ? `\`${safe}\`` : safe;
+}
 function normalizeModifierInputs(inputs) {
   const normalized = {};
   for (const [key, value] of Object.entries(inputs)) {
@@ -3258,6 +3307,14 @@ function normalizeModifierInputs(inputs) {
   }
   return normalized;
 }
+function assertFileRequired(buildPath, outputFile, outputName, presetLabel) {
+  const requiresFile = buildPath !== void 0 && buildPath !== "";
+  if (!outputFile && requiresFile) {
+    throw new ConfigurationError(
+      `Output "${outputName}": file is required for ${presetLabel} output`
+    );
+  }
+}
 function buildStablePermutationKey(modifierInputs, dimensions) {
   return dimensions.map((dimension) => `${dimension}=${modifierInputs[dimension] ?? ""}`).join("|");
 }
@@ -3307,14 +3364,18 @@ function generatePermutationKey(modifierInputs, resolver, isBase) {
   }
   return buildStablePermutationKey(normalizedInputs, metadata.dimensions);
 }
-function buildInMemoryOutputKey(params) {
-  const { outputName, extension, modifierInputs, resolver, defaults } = params;
+function isBasePermutation(modifierInputs, defaults) {
   const normalizedInputs = normalizeModifierInputs(modifierInputs);
   const normalizedDefaults = normalizeModifierInputs(defaults);
-  const isBase = Object.entries(normalizedDefaults).every(
-    ([key, value]) => normalizedInputs[key] === value
+  return Object.entries(normalizedDefaults).every(([key, value]) => normalizedInputs[key] === value);
+}
+function buildInMemoryOutputKey(params) {
+  const { outputName, extension, modifierInputs, resolver, defaults } = params;
+  const permutationKey = generatePermutationKey(
+    modifierInputs,
+    resolver,
+    isBasePermutation(modifierInputs, defaults)
   );
-  const permutationKey = generatePermutationKey(modifierInputs, resolver, isBase);
   return `${outputName}-${permutationKey}.${extension}`;
 }
 function buildMetadata(resolver) {
@@ -3436,6 +3497,7 @@ function resolveFileName(fileName, modifierInputs) {
 }
 var init_utils = __esm({
   "src/renderers/bundlers/utils.ts"() {
+    init_errors();
     init_token_utils();
   }
 });
@@ -3445,36 +3507,38 @@ var js_exports = {};
 __export(js_exports, {
   bundleAsJsModule: () => bundleAsJsModule
 });
+function updateStringTracking(state, char) {
+  if (!state.escaped && (char === '"' || char === "'" || char === "`")) {
+    if (!state.inString) {
+      state.inString = true;
+      state.stringChar = char;
+    } else if (char === state.stringChar) {
+      state.inString = false;
+      state.stringChar = "";
+    }
+  }
+  state.escaped = !state.escaped && char === "\\";
+}
 function extractObjectFromJsModule(formattedJs) {
   const assignmentMatch = /const\s+\w+\s*=\s*\{/.exec(formattedJs);
   if (!assignmentMatch) {
     return "{}";
   }
   const startIndex = assignmentMatch.index + assignmentMatch[0].length - 1;
+  const state = { inString: false, stringChar: "", escaped: false };
   let braceCount = 0;
-  let inString = false;
-  let stringChar = "";
-  let escaped = false;
   for (let i = startIndex; i < formattedJs.length; i++) {
     const char = formattedJs[i];
-    if (!escaped && (char === '"' || char === "'" || char === "`")) {
-      if (!inString) {
-        inString = true;
-        stringChar = char;
-      } else if (char === stringChar) {
-        inString = false;
-        stringChar = "";
-      }
-    }
-    escaped = !escaped && char === "\\";
-    if (!inString) {
-      if (char === "{") {
-        braceCount++;
-      } else if (char === "}") {
-        braceCount--;
-        if (braceCount === 0) {
-          return formattedJs.substring(startIndex, i + 1);
-        }
+    updateStringTracking(state, char);
+    if (state.inString) {
+      continue;
+    }
+    if (char === "{") {
+      braceCount++;
+    } else if (char === "}") {
+      braceCount--;
+      if (braceCount === 0) {
+        return formattedJs.substring(startIndex, i + 1);
       }
     }
   }
@@ -3571,22 +3635,19 @@ __export(json_exports, {
   bundleAsJson: () => bundleAsJson
 });
 async function bundleAsJson(bundleData, resolver, formatTokens) {
+  if (!formatTokens) {
+    throw new ConfigurationError("JSON formatter was not provided");
+  }
   const metadata = buildMetadata(resolver);
   const tokens = {};
   for (const { tokens: tokenSet, modifierInputs } of bundleData) {
     const cleanTokens = stripInternalMetadata(tokenSet);
-    if (!formatTokens) {
-      throw new ConfigurationError("JSON formatter was not provided");
-    }
     const normalizedInputs = normalizeModifierInputs(modifierInputs);
     const key = buildStablePermutationKey(normalizedInputs, metadata.dimensions);
     const themeJson = await formatTokens(cleanTokens);
     tokens[key] = JSON.parse(themeJson);
   }
-  const bundle = {
-    _meta: metadata,
-    tokens
-  };
+  const bundle = { _meta: metadata, tokens };
   return JSON.stringify(bundle, null, 2);
 }
 var init_json = __esm({
@@ -3652,15 +3713,15 @@ var TypeGenerator = class {
     const lines = [];
     if (names.length === 0) {
       lines.push(`export type ${typeName} = never`);
-    } else {
-      lines.push(`export type ${typeName} =`);
-      for (let i = 0; i < names.length; i++) {
-        const name = names[i];
-        if (name == null) {
-          continue;
-        }
-        lines.push(`  | "${name}"`);
+      return lines;
+    }
+    lines.push(`export type ${typeName} =`);
+    for (let i = 0; i < names.length; i++) {
+      const name = names[i];
+      if (name == null) {
+        continue;
       }
+      lines.push(`  | "${name}"`);
     }
     return lines;
   }
@@ -3686,15 +3747,10 @@ var TypeGenerator = class {
   generateStructureType(tokens, options) {
     const lines = [];
     const structure = this.buildNestedStructure(tokens);
-    if (options.exportType === "type") {
-      lines.push(`export type ${options.moduleName} = {`);
-      this.addStructureProperties(lines, structure, 1);
-      lines.push("}");
-    } else {
-      lines.push(`export interface ${options.moduleName} {`);
-      this.addStructureProperties(lines, structure, 1);
-      lines.push("}");
-    }
+    const opener = options.exportType === "type" ? `export type ${options.moduleName} = {` : `export interface ${options.moduleName} {`;
+    lines.push(opener);
+    this.addStructureProperties(lines, structure, 1);
+    lines.push("}");
     return lines;
   }
   /**
@@ -3728,20 +3784,20 @@ var TypeGenerator = class {
   /**
    * Add structure properties to lines
    */
-  addStructureProperties(lines, structure, indent2) {
-    const indentStr = "  ".repeat(indent2);
+  addStructureProperties(lines, structure, indent) {
+    const indentStr2 = "  ".repeat(indent);
     for (const [key, value] of Object.entries(structure)) {
       if (this.isToken(value)) {
         const token = value;
         if (token.$description) {
-          lines.push(`${indentStr}/** ${token.$description} */`);
+          lines.push(`${indentStr2}/** ${token.$description} */`);
         }
         const valueType = this.inferValueType(token);
-        lines.push(`${indentStr}${this.quoteKey(key)}: ${valueType}`);
+        lines.push(`${indentStr2}${this.quoteKey(key)}: ${valueType}`);
       } else {
-        lines.push(`${indentStr}${this.quoteKey(key)}: {`);
-        this.addStructureProperties(lines, value, indent2 + 1);
-        lines.push(`${indentStr}}`);
+        lines.push(`${indentStr2}${this.quoteKey(key)}: {`);
+        this.addStructureProperties(lines, value, indent + 1);
+        lines.push(`${indentStr2}}`);
       }
     }
   }
@@ -3933,28 +3989,27 @@ var BuildOrchestrator = class {
     if (config.hooks?.onBuildStart) {
       await config.hooks.onBuildStart({ config, resolver });
     }
-    let permutations;
-    if (config.permutations && config.permutations.length > 0) {
-      permutations = await Promise.all(
-        config.permutations.map(async (modifierInputs) => {
-          const { tokens, modifierInputs: resolvedInputs } = await this.pipeline.resolve(
-            resolver,
-            modifierInputs,
-            config.transforms,
-            config.preprocessors,
-            config.filters
-          );
-          return { tokens, modifierInputs: resolvedInputs };
-        })
-      );
-    } else {
-      permutations = await this.pipeline.resolveAllPermutations(
+    if (!config.permutations || config.permutations.length === 0) {
+      const permutations2 = await this.pipeline.resolveAllPermutations(
         resolver,
         config.transforms,
         config.preprocessors,
         config.filters
       );
+      return this.executeBuild(buildPath, config, permutations2, resolver);
     }
+    const permutations = await Promise.all(
+      config.permutations.map(async (modifierInputs) => {
+        const { tokens, modifierInputs: resolvedInputs } = await this.pipeline.resolve(
+          resolver,
+          modifierInputs,
+          config.transforms,
+          config.preprocessors,
+          config.filters
+        );
+        return { tokens, modifierInputs: resolvedInputs };
+      })
+    );
     return this.executeBuild(buildPath, config, permutations, resolver);
   }
   /**
@@ -3976,44 +4031,15 @@ var BuildOrchestrator = class {
    * @returns Build result with success status, outputs, and any errors
    */
   async executeBuild(buildPath, config, permutations, resolver) {
-    const outputs = [];
-    const errors = [];
     try {
       const resolverDoc = await resolveResolverDocument(resolver);
       const metadata = buildMetadata(resolverDoc);
-      const basePermutation = metadata.defaults;
       const settled = await Promise.allSettled(
-        config.outputs.map(async (output) => {
-          if (output.hooks?.onBuildStart) {
-            await output.hooks.onBuildStart({ config, resolver });
-          }
-          try {
-            const results = await this.processOutput(output, permutations, resolverDoc, metadata, basePermutation, 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)] });
-            }
-            throw error;
-          }
-        })
+        config.outputs.map(
+          (output) => this.buildSingleOutput(output, permutations, resolverDoc, metadata, buildPath, config, resolver)
+        )
       );
-      for (let i = 0; i < settled.length; i++) {
-        const outcome = settled[i];
-        if (outcome.status === "fulfilled") {
-          outputs.push(...outcome.value);
-        } else {
-          errors.push(toBuildError(outcome.reason, config.outputs[i].name));
-        }
-      }
-      const result = {
-        success: errors.length === 0,
-        outputs,
-        errors: errors.length > 0 ? errors : void 0
-      };
+      const result = this.collectSettledResults(settled, config);
       if (config.hooks?.onBuildEnd) {
         await config.hooks.onBuildEnd(result);
       }
@@ -4030,6 +4056,40 @@ var BuildOrchestrator = class {
       return result;
     }
   }
+  async buildSingleOutput(output, permutations, resolverDoc, metadata, buildPath, config, resolver) {
+    if (output.hooks?.onBuildStart) {
+      await output.hooks.onBuildStart({ config, resolver });
+    }
+    try {
+      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)] });
+      }
+      throw error;
+    }
+  }
+  collectSettledResults(settled, config) {
+    const outputs = [];
+    const errors = [];
+    for (let i = 0; i < settled.length; i++) {
+      const outcome = settled[i];
+      if (outcome.status === "fulfilled") {
+        outputs.push(...outcome.value);
+      } else {
+        errors.push(toBuildError(outcome.reason, config.outputs[i].name));
+      }
+    }
+    return {
+      success: errors.length === 0,
+      outputs,
+      errors: errors.length > 0 ? errors : void 0
+    };
+  }
   async processOutput(output, permutations, resolverDoc, metadata, basePermutation, buildPath) {
     if (!output.renderer.format) {
       throw new ConfigurationError("Renderer does not implement format()");
@@ -4079,7 +4139,7 @@ async function writeOutputFile(fileName, content, encoding = "utf-8") {
   }
 }
 
-// src/processing/token-modifier.ts
+// src/processing/apply.ts
 function applyTransforms(tokens, transformList) {
   const result = {};
   for (const [name, token] of Object.entries(tokens)) {
@@ -5357,14 +5417,15 @@ var ResolutionEngine = class {
   mergeTokens(target, source) {
     const result = { ...target };
     for (const [key, value] of Object.entries(source)) {
-      if (typeof value === "object" && value !== null && !Array.isArray(value) && !("$value" in value)) {
-        result[key] = this.mergeTokens(
-          result[key] ?? {},
-          value
-        );
-      } else {
+      const isGroup = typeof value === "object" && value !== null && !Array.isArray(value) && !("$value" in value);
+      if (!isGroup) {
         result[key] = value;
+        continue;
       }
+      result[key] = this.mergeTokens(
+        result[key] ?? {},
+        value
+      );
     }
     return result;
   }
@@ -6510,7 +6571,7 @@ function colorObjectToHex(color) {
   return formatHex(culoriColor);
 }
 
-// src/processing/processors/transforms/built-in/dimension-converter.ts
+// src/processing/transforms/built-in/dimension-converter.ts
 function isDimensionObject(value) {
   return typeof value === "object" && value !== null && "value" in value && "unit" in value;
 }
@@ -6518,6 +6579,14 @@ function dimensionObjectToString(dimension) {
   return `${dimension.value}${dimension.unit}`;
 }
 
+// src/processing/transforms/built-in/duration-converter.ts
+function isDurationObject(value) {
+  return typeof value === "object" && value !== null && "value" in value && "unit" in value && value.unit !== void 0;
+}
+function durationObjectToString(duration) {
+  return `${duration.value}${duration.unit}`;
+}
+
 // src/renderers/android.ts
 init_errors();
 init_token_utils();
@@ -6569,9 +6638,6 @@ function resolveColorFormat(format) {
   }
   return "argb_hex";
 }
-function indent(width, level) {
-  return " ".repeat(width * level);
-}
 function escapeKotlinString(str) {
   return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\$/g, "\\$");
 }
@@ -6587,22 +6653,6 @@ function roundComponent(value) {
 function toResourceName(family) {
   return family.toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_|_$/g, "");
 }
-function toPascalCase(name) {
-  const pascal = name.replace(/[-._]+(.)/g, (_, c) => c.toUpperCase()).replace(/[-._]+$/g, "").replace(/^[-._]+/g, "");
-  const result = pascal.charAt(0).toUpperCase() + pascal.slice(1);
-  if (/^\d/.test(result)) {
-    return `_${result}`;
-  }
-  return KOTLIN_KEYWORDS.has(result.charAt(0).toLowerCase() + result.slice(1)) ? `\`${result}\`` : result;
-}
-function toKotlinIdentifier(name) {
-  const camel = name.replace(/[-._]+(.)/g, (_, c) => c.toUpperCase()).replace(/[-._]+$/g, "").replace(/^[-._]+/g, "");
-  const identifier = camel.charAt(0).toLowerCase() + camel.slice(1);
-  if (/^\d/.test(identifier)) {
-    return `_${identifier}`;
-  }
-  return KOTLIN_KEYWORDS.has(identifier) ? `\`${identifier}\`` : identifier;
-}
 var AndroidRenderer = class {
   async format(context, options) {
     if (!options?.packageName) {
@@ -6610,6 +6660,7 @@ var AndroidRenderer = class {
         `Output "${context.output.name}": packageName is required for Android output`
       );
     }
+    const visibility = options?.visibility;
     const opts = {
       preset: options?.preset ?? "standalone",
       packageName: options.packageName,
@@ -6617,7 +6668,8 @@ var AndroidRenderer = class {
       colorFormat: resolveColorFormat(options?.colorFormat),
       colorSpace: options?.colorSpace ?? "sRGB",
       structure: options?.structure ?? "nested",
-      visibility: options?.visibility,
+      visibility,
+      visPrefix: visibility ? `${visibility} ` : "",
       indent: options?.indent ?? 4
     };
     if (opts.preset === "bundle") {
@@ -6650,19 +6702,6 @@ var AndroidRenderer = class {
   // -----------------------------------------------------------------------
   // Flat structure grouping
   // -----------------------------------------------------------------------
-  groupTokensByType(tokens) {
-    const groupMap = /* @__PURE__ */ new Map();
-    for (const [, token] of getSortedTokenEntries(tokens)) {
-      const groupName = KOTLIN_TYPE_GROUP_MAP[token.$type ?? ""] ?? "Other";
-      const existing = groupMap.get(groupName) ?? [];
-      existing.push(token);
-      groupMap.set(groupName, existing);
-    }
-    return Array.from(groupMap.entries()).map(([name, groupTokens]) => ({
-      name,
-      tokens: groupTokens
-    }));
-  }
   /**
    * Builds a flattened camelCase name from a token's path, stripping the
    * type prefix segment (which is already represented by the group object).
@@ -6671,7 +6710,7 @@ var AndroidRenderer = class {
     const path7 = token.path;
     const withoutTypePrefix = path7.length > 1 ? path7.slice(1) : path7;
     const joined = withoutTypePrefix.join("_");
-    return toKotlinIdentifier(joined);
+    return toSafeIdentifier(joined, KOTLIN_KEYWORDS, false);
   }
   // -----------------------------------------------------------------------
   // Rendering
@@ -6683,22 +6722,21 @@ var AndroidRenderer = class {
     return this.formatAsNested(tokens, options);
   }
   formatAsNested(tokens, options) {
+    const tokenTypes = this.collectTokenTypesFromEntries(tokens);
     const tree = this.buildTokenTree(tokens);
-    const tokenTypes = /* @__PURE__ */ new Set();
-    this.collectTokenTypes(tree, tokenTypes);
-    return this.buildFile(tokenTypes, options, (lines, vis) => {
+    return this.buildFile(tokenTypes, options, (lines) => {
       lines.push(`@Suppress("unused")`);
-      lines.push(`${vis}object ${options.objectName} {`);
+      lines.push(`${options.visPrefix}object ${options.objectName} {`);
       this.renderTreeChildren(lines, tree, 1, options);
       lines.push("}");
     });
   }
   formatAsFlat(tokens, options) {
-    const groups = this.groupTokensByType(tokens);
+    const groups = groupTokensByType(tokens, KOTLIN_TYPE_GROUP_MAP);
     const tokenTypes = this.collectTokenTypesFromEntries(tokens);
-    return this.buildFile(tokenTypes, options, (lines, vis) => {
+    return this.buildFile(tokenTypes, options, (lines) => {
       lines.push(`@Suppress("unused")`);
-      lines.push(`${vis}object ${options.objectName} {`);
+      lines.push(`${options.visPrefix}object ${options.objectName} {`);
       this.renderFlatGroups(lines, groups, 1, options);
       lines.push("}");
     });
@@ -6709,9 +6747,8 @@ var AndroidRenderer = class {
    */
   buildFile(tokenTypes, options, renderBody) {
     const imports = this.collectImports(tokenTypes, options);
-    const vis = options.visibility ? `${options.visibility} ` : "";
     const lines = [];
-    lines.push(this.buildFileHeader());
+    lines.push(buildGeneratedFileHeader());
     lines.push("");
     lines.push(`package ${options.packageName}`);
     lines.push("");
@@ -6722,19 +6759,18 @@ var AndroidRenderer = class {
       lines.push("");
     }
     if (tokenTypes.has("shadow")) {
-      lines.push(...this.buildShadowTokenClass(vis, options));
+      lines.push(...this.buildShadowTokenClass(options));
       lines.push("");
     }
-    renderBody(lines, vis);
+    renderBody(lines);
     lines.push("");
     return lines.join("\n");
   }
   renderFlatGroups(lines, groups, baseDepth, options) {
-    const vis = options.visibility ? `${options.visibility} ` : "";
-    const groupIndent = indent(options.indent, baseDepth);
-    const valIndent = indent(options.indent, baseDepth + 1);
+    const groupIndent = indentStr(options.indent, baseDepth);
+    const valIndent = indentStr(options.indent, baseDepth + 1);
     for (const group of groups) {
-      lines.push(`${groupIndent}${vis}object ${group.name} {`);
+      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);
@@ -6742,23 +6778,24 @@ var AndroidRenderer = class {
         if (token.$description) {
           lines.push(`${valIndent}/** ${escapeKDoc(token.$description)} */`);
         }
-        lines.push(`${valIndent}${vis}val ${kotlinName}${annotation} = ${kotlinValue}`);
+        lines.push(
+          `${valIndent}${options.visPrefix}val ${kotlinName}${annotation} = ${kotlinValue}`
+        );
       }
       lines.push(`${groupIndent}}`);
       lines.push("");
     }
   }
   renderTreeChildren(lines, node, depth, options) {
-    const vis = options.visibility ? `${options.visibility} ` : "";
-    const pad = indent(options.indent, depth);
+    const 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 = toPascalCase(key);
-        lines.push(`${pad}${vis}object ${objectName} {`);
+        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) {
@@ -6771,30 +6808,23 @@ var AndroidRenderer = class {
     }
   }
   renderLeaf(lines, key, token, depth, options) {
-    const vis = options.visibility ? `${options.visibility} ` : "";
-    const pad = indent(options.indent, depth);
-    const kotlinName = toKotlinIdentifier(key);
+    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);
     if (token.$description) {
       lines.push(`${pad}/** ${escapeKDoc(token.$description)} */`);
     }
-    lines.push(`${pad}${vis}val ${kotlinName}${annotation} = ${kotlinValue}`);
-  }
-  buildFileHeader() {
-    return [
-      "// Generated by Dispersa - do not edit manually",
-      "// https://github.com/timges/dispersa"
-    ].join("\n");
+    lines.push(`${pad}${options.visPrefix}val ${kotlinName}${annotation} = ${kotlinValue}`);
   }
   // -----------------------------------------------------------------------
   // Shadow data class
   // -----------------------------------------------------------------------
-  buildShadowTokenClass(vis, options) {
-    const i1 = indent(options.indent, 1);
+  buildShadowTokenClass(options) {
+    const i1 = indentStr(options.indent, 1);
     return [
       "@Immutable",
-      `${vis}data class ShadowToken(`,
+      `${options.visPrefix}data class ShadowToken(`,
       `${i1}val color: Color,`,
       `${i1}val elevation: Dp,`,
       `${i1}val offsetX: Dp,`,
@@ -6845,14 +6875,6 @@ var AndroidRenderer = class {
     }
     return Array.from(imports).sort();
   }
-  collectTokenTypes(node, types) {
-    if (node.token?.$type) {
-      types.add(node.token.$type);
-    }
-    for (const child of node.children.values()) {
-      this.collectTokenTypes(child, types);
-    }
-  }
   collectTokenTypesFromEntries(tokens) {
     const types = /* @__PURE__ */ new Set();
     for (const [, token] of Object.entries(tokens)) {
@@ -7079,9 +7101,8 @@ var AndroidRenderer = class {
     return map[name.toLowerCase()];
   }
   formatDurationValue(value) {
-    if (typeof value === "object" && value !== null && "value" in value && "unit" in value) {
-      const dur = value;
-      return dur.unit === "ms" ? `${dur.value}.milliseconds` : `${dur.value}.seconds`;
+    if (isDurationObject(value)) {
+      return value.unit === "ms" ? `${value.value}.milliseconds` : `${value.value}.seconds`;
     }
     return typeof value === "number" ? `${value}.milliseconds` : "0.milliseconds";
   }
@@ -7099,8 +7120,8 @@ var AndroidRenderer = class {
     const elevation = isDimensionObject(shadow.blur) ? this.formatDimensionValue(shadow.blur) : "0.dp";
     const offsetX = isDimensionObject(shadow.offsetX) ? this.formatDimensionValue(shadow.offsetX) : "0.dp";
     const offsetY = isDimensionObject(shadow.offsetY) ? this.formatDimensionValue(shadow.offsetY) : "0.dp";
-    const propIndent = indent(options.indent, depth + 1);
-    const closeIndent = indent(options.indent, depth);
+    const propIndent = indentStr(options.indent, depth + 1);
+    const closeIndent = indentStr(options.indent, depth);
     return [
       "ShadowToken(",
       `${propIndent}color = ${color},`,
@@ -7149,8 +7170,8 @@ var AndroidRenderer = class {
     if (parts.length === 0) {
       return "TextStyle()";
     }
-    const propIndent = indent(options.indent, depth + 1);
-    const closeIndent = indent(options.indent, depth);
+    const propIndent = indentStr(options.indent, depth + 1);
+    const closeIndent = indentStr(options.indent, depth);
     return `TextStyle(
 ${parts.map((p) => `${propIndent}${p}`).join(",\n")},
 ${closeIndent})`;
@@ -7159,12 +7180,12 @@ ${closeIndent})`;
   // Output: standalone
   // -----------------------------------------------------------------------
   async formatStandalone(context, options) {
-    const requiresFile = context.buildPath !== void 0 && context.buildPath !== "";
-    if (!context.output.file && requiresFile) {
-      throw new ConfigurationError(
-        `Output "${context.output.name}": file is required for standalone Android output`
-      );
-    }
+    assertFileRequired(
+      context.buildPath,
+      context.output.file,
+      context.output.name,
+      "standalone Android"
+    );
     const files = {};
     for (const { tokens, modifierInputs } of context.permutations) {
       const processedTokens = stripInternalMetadata(tokens);
@@ -7184,12 +7205,12 @@ ${closeIndent})`;
   // Output: bundle
   // -----------------------------------------------------------------------
   async formatBundle(context, options) {
-    const requiresFile = context.buildPath !== void 0 && context.buildPath !== "";
-    if (!context.output.file && requiresFile) {
-      throw new ConfigurationError(
-        `Output "${context.output.name}": file is required for bundle Android output`
-      );
-    }
+    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,
@@ -7202,15 +7223,15 @@ ${closeIndent})`;
   }
   formatBundleContent(context, options) {
     const allTokenTypes = this.collectAllPermutationTypes(context);
-    return this.buildFile(allTokenTypes, options, (lines, vis) => {
-      const i1 = indent(options.indent, 1);
+    return this.buildFile(allTokenTypes, options, (lines) => {
+      const i1 = indentStr(options.indent, 1);
       lines.push(`@Suppress("unused")`);
-      lines.push(`${vis}object ${options.objectName} {`);
+      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}${vis}object ${permName} {`);
+        lines.push(`${i1}${options.visPrefix}object ${permName} {`);
         this.renderBundleTokens(lines, processedTokens, options, 2);
         lines.push(`${i1}}`);
         if (idx < context.permutations.length - 1) {
@@ -7221,20 +7242,17 @@ ${closeIndent})`;
     });
   }
   collectAllPermutationTypes(context) {
-    const allTokenTypes = /* @__PURE__ */ new Set();
+    const types = /* @__PURE__ */ new Set();
     for (const { tokens } of context.permutations) {
-      const processed = stripInternalMetadata(tokens);
-      for (const [, token] of Object.entries(processed)) {
-        if (token.$type) {
-          allTokenTypes.add(token.$type);
-        }
+      for (const t of this.collectTokenTypesFromEntries(stripInternalMetadata(tokens))) {
+        types.add(t);
       }
     }
-    return allTokenTypes;
+    return types;
   }
   renderBundleTokens(lines, tokens, options, baseDepth) {
     if (options.structure === "flat") {
-      const groups = this.groupTokensByType(tokens);
+      const groups = groupTokensByType(tokens, KOTLIN_TYPE_GROUP_MAP);
       this.renderFlatGroups(lines, groups, baseDepth, options);
       return;
     }
@@ -7246,7 +7264,7 @@ ${closeIndent})`;
     if (values.length === 0) {
       return "Default";
     }
-    return values.map((v) => toPascalCase(v)).join("");
+    return values.map((v) => toSafeIdentifier(v, KOTLIN_KEYWORDS, true)).join("");
   }
 };
 function androidRenderer() {
@@ -7266,19 +7284,19 @@ 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;
   }
-  const maybe = token;
-  return typeof maybe._sourceSet === "string" ? maybe._sourceSet : 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;
   }
-  const maybe = token;
-  return typeof maybe._sourceModifier === "string" ? maybe._sourceModifier : 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);
@@ -7363,6 +7381,15 @@ async function formatModifierPermutation({ tokens, modifierInputs }, baseItem, o
   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)) {
@@ -7393,75 +7420,67 @@ function collectRemainder(tokens, included) {
 function buildSetLayerBlocks(tokens, resolver) {
   const blocks = [];
   const included = /* @__PURE__ */ new Set();
-  const addBlock = (key, blockTokens, description) => {
-    if (Object.keys(blockTokens).length === 0) {
-      return;
-    }
-    for (const k of Object.keys(blockTokens)) {
-      included.add(k);
-    }
-    blocks.push({ key, description, tokens: blockTokens });
-  };
   for (const item of resolver.resolutionOrder) {
     const ref = item.$ref;
-    if (typeof ref !== "string" || !ref.startsWith("#/sets/")) {
+    if (typeof ref !== "string" || !ref.startsWith(REF_PREFIX_SETS)) {
       continue;
     }
-    const setName = ref.slice("#/sets/".length);
-    addBlock(
+    const setName = ref.slice(REF_PREFIX_SETS.length);
+    addLayerBlock(
+      blocks,
+      included,
       `Set: ${setName}`,
       collectSetTokens(tokens, setName, included),
       resolver.sets?.[setName]?.description
     );
   }
-  addBlock("Unattributed", collectRemainder(tokens, included));
+  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);
-  const addBlock = (key, blockTokens, description) => {
-    if (Object.keys(blockTokens).length === 0) {
-      return;
-    }
-    for (const k of Object.keys(blockTokens)) {
-      included.add(k);
-    }
-    blocks.push({ key, description, tokens: blockTokens });
-  };
   for (const item of resolver.resolutionOrder) {
     const ref = item.$ref;
     if (typeof ref !== "string") {
       continue;
     }
-    if (ref.startsWith("#/sets/")) {
-      const setName = ref.slice("#/sets/".length);
-      addBlock(
-        `Set: ${setName}`,
-        collectSetTokens(tokens, setName, included),
-        resolver.sets?.[setName]?.description
-      );
-      continue;
-    }
-    if (ref.startsWith("#/modifiers/")) {
-      const modifierName = ref.slice("#/modifiers/".length);
-      const modifier = resolver.modifiers?.[modifierName];
-      const selectedContext = baseInputs[modifierName.toLowerCase()];
-      if (!modifier || !selectedContext) {
-        continue;
-      }
-      const expectedSource = `${modifierName}-${selectedContext}`.toLowerCase();
-      addBlock(
-        `Modifier: ${modifierName}=${selectedContext} (default)`,
-        collectModifierTokens(tokens, expectedSource, included),
-        modifier.description
-      );
-    }
+    processResolutionOrderRef(ref, tokens, blocks, included, baseInputs, resolver);
   }
-  addBlock("Unattributed", collectRemainder(tokens, included));
+  addLayerBlock(blocks, included, "Unattributed", collectRemainder(tokens, included));
   return blocks;
 }
+function processResolutionOrderRef(ref, tokens, blocks, included, baseInputs, resolver) {
+  if (ref.startsWith(REF_PREFIX_SETS)) {
+    const setName = ref.slice(REF_PREFIX_SETS.length);
+    addLayerBlock(
+      blocks,
+      included,
+      `Set: ${setName}`,
+      collectSetTokens(tokens, setName, included),
+      resolver.sets?.[setName]?.description
+    );
+    return;
+  }
+  if (!ref.startsWith(REF_PREFIX_MODIFIERS)) {
+    return;
+  }
+  const modifierName = ref.slice(REF_PREFIX_MODIFIERS.length);
+  const modifier = resolver.modifiers?.[modifierName];
+  const selectedContext = baseInputs[modifierName.toLowerCase()];
+  if (!modifier || !selectedContext) {
+    return;
+  }
+  const expectedSource = `${modifierName}-${selectedContext}`.toLowerCase();
+  addLayerBlock(
+    blocks,
+    included,
+    `Modifier: ${modifierName}=${selectedContext} (default)`,
+    collectModifierTokens(tokens, expectedSource, included),
+    modifier.description
+  );
+}
 function findSingleDiffPermutation(bundleData, modifierName, context, baseInputs) {
   const normalizedModifier = modifierName.toLowerCase();
   const normalizedContext = context.toLowerCase();
@@ -7476,6 +7495,36 @@ function findSingleDiffPermutation(bundleData, modifierName, context, baseInputs
     return Object.entries(baseInputs).every(([k, v]) => k === normalizedModifier || inputs[k] === v);
   });
 }
+function pushUniqueBundleItem(ordered, includedKeys, item) {
+  if (!item) {
+    return;
+  }
+  const key = stableInputsKey(item.modifierInputs);
+  if (includedKeys.has(key)) {
+    return;
+  }
+  includedKeys.add(key);
+  ordered.push(item);
+}
+function appendModifierPermutations(bundleData, modifiers, orderedNames, baseInputs, ordered, includedKeys) {
+  for (const modifierName of orderedNames) {
+    const modifierDef = modifiers[modifierName];
+    if (!modifierDef) {
+      continue;
+    }
+    const defaultValue = baseInputs[modifierName.toLowerCase()] ?? "";
+    for (const ctx of Object.keys(modifierDef.contexts)) {
+      if (defaultValue === ctx.toLowerCase()) {
+        continue;
+      }
+      pushUniqueBundleItem(
+        ordered,
+        includedKeys,
+        findSingleDiffPermutation(bundleData, modifierName, ctx, baseInputs)
+      );
+    }
+  }
+}
 function orderBundleData(bundleData, resolver, baseItem) {
   const modifiers = resolver.modifiers;
   if (!modifiers) {
@@ -7492,31 +7541,15 @@ function orderBundleData(bundleData, resolver, baseItem) {
   }
   const includedKeys = /* @__PURE__ */ new Set();
   const ordered = [];
-  const pushUnique = (item) => {
-    if (!item) {
-      return;
-    }
-    const key = stableInputsKey(item.modifierInputs);
-    if (includedKeys.has(key)) {
-      return;
-    }
-    includedKeys.add(key);
-    ordered.push(item);
-  };
-  pushUnique(baseItem);
-  for (const modifierName of orderedModifierNames) {
-    const modifierDef = modifiers[modifierName];
-    if (!modifierDef) {
-      continue;
-    }
-    const defaultValue = baseInputs[modifierName.toLowerCase()] ?? "";
-    for (const ctx of Object.keys(modifierDef.contexts)) {
-      if (defaultValue === ctx.toLowerCase()) {
-        continue;
-      }
-      pushUnique(findSingleDiffPermutation(bundleData, modifierName, ctx, baseInputs));
-    }
-  }
+  pushUniqueBundleItem(ordered, includedKeys, baseItem);
+  appendModifierPermutations(
+    bundleData,
+    modifiers,
+    orderedModifierNames,
+    baseInputs,
+    ordered,
+    includedKeys
+  );
   return ordered.length > 0 ? ordered : bundleData;
 }
 function getOrderedModifierNames(resolver) {
@@ -7528,10 +7561,10 @@ function getOrderedModifierNames(resolver) {
     if (typeof ref !== "string") {
       continue;
     }
-    if (!ref.startsWith("#/modifiers/")) {
+    if (!ref.startsWith(REF_PREFIX_MODIFIERS)) {
       continue;
     }
-    const name = ref.slice("#/modifiers/".length);
+    const name = ref.slice(REF_PREFIX_MODIFIERS.length);
     if (seen.has(name)) {
       continue;
     }
@@ -7602,24 +7635,22 @@ var CssRenderer = class _CssRenderer {
       ...options,
       referenceTokens: options?.referenceTokens ?? tokens
     };
-    const groups = this.groupTokens(tokens, opts);
+    const sortedTokens = getSortedTokenEntries(tokens).map(([, token]) => token);
     const referenceTokens = opts.referenceTokens;
     const lines = [];
-    for (const [selector, groupTokens] of Object.entries(groups)) {
-      this.buildCssBlock(lines, groupTokens, selector, tokens, referenceTokens, opts);
-    }
+    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 indent2 = opts.minify ? "" : "  ";
+    const indent = opts.minify ? "" : "  ";
     const newline = opts.minify ? "" : "\n";
     const space = opts.minify ? "" : " ";
     const hasMediaQuery = opts.mediaQuery != null && opts.mediaQuery !== "";
-    const tokenIndent = hasMediaQuery ? indent2 + indent2 : indent2;
+    const tokenIndent = hasMediaQuery ? indent + indent : indent;
     if (hasMediaQuery) {
       lines.push(`@media ${opts.mediaQuery}${space}{${newline}`);
-      lines.push(`${indent2}${selector}${space}{${newline}`);
+      lines.push(`${indent}${selector}${space}{${newline}`);
     } else {
       lines.push(`${selector}${space}{${newline}`);
     }
@@ -7636,21 +7667,21 @@ var CssRenderer = class _CssRenderer {
       );
     }
     if (hasMediaQuery) {
-      lines.push(`${indent2}}${newline}`);
+      lines.push(`${indent}}${newline}`);
     }
     lines.push(`}${newline}${newline}`);
   }
-  pushTokenLines(lines, token, tokens, referenceTokens, preserveReferences, indent2, newline, space) {
+  pushTokenLines(lines, token, tokens, referenceTokens, preserveReferences, indent, newline, space) {
     const entries = this.buildCssEntries(token, tokens, referenceTokens, preserveReferences);
     if (token.$deprecated != null && token.$deprecated !== false) {
       const deprecationMsg = formatDeprecationMessage(token, "", "comment");
-      lines.push(`${indent2}/* ${this.sanitizeCssCommentText(deprecationMsg)} */${newline}`);
+      lines.push(`${indent}/* ${this.sanitizeCssCommentText(deprecationMsg)} */${newline}`);
     }
     if (token.$description && token.$description !== "") {
-      lines.push(`${indent2}/* ${this.sanitizeCssCommentText(token.$description)} */${newline}`);
+      lines.push(`${indent}/* ${this.sanitizeCssCommentText(token.$description)} */${newline}`);
     }
     for (const entry of entries) {
-      lines.push(`${indent2}--${entry.name}:${space}${entry.value};${newline}`);
+      lines.push(`${indent}--${entry.name}:${space}${entry.value};${newline}`);
     }
   }
   async formatWithPrettier(css2) {
@@ -7665,15 +7696,6 @@ var CssRenderer = class _CssRenderer {
       return css2;
     }
   }
-  /**
-   * Group tokens by selector (for theme support)
-   */
-  groupTokens(tokens, options) {
-    const sortedTokens = getSortedTokenEntries(tokens).map(([, token]) => token);
-    return {
-      [options.selector]: sortedTokens
-    };
-  }
   buildCssEntries(token, tokens, referenceTokens, preserveReferences) {
     if (preserveReferences) {
       const refName = getPureAliasReferenceName(token.originalValue);
@@ -7815,7 +7837,7 @@ var CssRenderer = class _CssRenderer {
       leaves.push({ path: path7, value });
       return;
     }
-    if (isColorObject(value) || isDimensionObject(value) || this.isDurationObject(value)) {
+    if (isColorObject(value) || isDimensionObject(value) || isDurationObject(value)) {
       leaves.push({ path: path7, value });
       return;
     }
@@ -7858,8 +7880,8 @@ var CssRenderer = class _CssRenderer {
     if (isDimensionObject(value)) {
       return dimensionObjectToString(value);
     }
-    if (this.isDurationObject(value)) {
-      return this.formatDurationValue(value);
+    if (isDurationObject(value)) {
+      return durationObjectToString(value);
     }
     if (typeof value === "string") {
       return value;
@@ -7922,15 +7944,6 @@ var CssRenderer = class _CssRenderer {
   isPrimitiveValue(value) {
     return typeof value === "string" || typeof value === "number" || typeof value === "boolean";
   }
-  isDurationObject(value) {
-    return typeof value === "object" && value !== null && "value" in value && "unit" in value && value.unit !== void 0;
-  }
-  formatDurationValue(value) {
-    if (typeof value === "string") {
-      return value;
-    }
-    return `${value.value}${value.unit}`;
-  }
   /**
    * Format token value for CSS
    * Handles DTCG 2025.10 object formats for colors and dimensions
@@ -7951,8 +7964,8 @@ var CssRenderer = class _CssRenderer {
       return typeof value === "string" ? value : dimensionObjectToString(value);
     }
     if (type === "duration") {
-      if (this.isDurationObject(value)) {
-        return this.formatDurationValue(value);
+      if (isDurationObject(value)) {
+        return durationObjectToString(value);
       }
       if (typeof value === "string") {
         return value;
@@ -8042,16 +8055,16 @@ var CssRenderer = class _CssRenderer {
    */
   formatTransition(value) {
     const parts = [];
-    if (this.isDurationObject(value.duration)) {
-      parts.push(this.formatDurationValue(value.duration));
+    if (isDurationObject(value.duration)) {
+      parts.push(durationObjectToString(value.duration));
     } else if (value.duration != null) {
       parts.push(String(value.duration));
     }
     if (Array.isArray(value.timingFunction) && value.timingFunction.length === 4) {
       parts.push(`cubic-bezier(${value.timingFunction.join(", ")})`);
     }
-    if (this.isDurationObject(value.delay)) {
-      parts.push(this.formatDurationValue(value.delay));
+    if (isDurationObject(value.delay)) {
+      parts.push(durationObjectToString(value.delay));
     } else if (value.delay != null) {
       parts.push(String(value.delay));
     }
@@ -8061,7 +8074,7 @@ var CssRenderer = class _CssRenderer {
     const bundleData = context.permutations.map(({ tokens, modifierInputs }) => ({
       tokens,
       modifierInputs,
-      isBase: this.isBasePermutation(modifierInputs, context.meta.defaults)
+      isBase: isBasePermutation(modifierInputs, context.meta.defaults)
     }));
     return await bundleAsCss(bundleData, context.resolver, options, async (tokens, resolved) => {
       return await this.formatTokens(tokens, {
@@ -8071,12 +8084,12 @@ var CssRenderer = class _CssRenderer {
     });
   }
   async formatStandalone(context, options) {
-    const requiresFile = context.buildPath !== void 0 && context.buildPath !== "";
-    if (!context.output.file && requiresFile) {
-      throw new ConfigurationError(
-        `Output "${context.output.name}": file is required for standalone CSS output`
-      );
-    }
+    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(
@@ -8090,7 +8103,7 @@ var CssRenderer = class _CssRenderer {
     return { kind: "outputTree", files };
   }
   async buildStandaloneFile(tokens, modifierInputs, context, options) {
-    const isBase = this.isBasePermutation(modifierInputs, context.meta.defaults);
+    const isBase = isBasePermutation(modifierInputs, context.meta.defaults);
     const { modifierName, modifierContext } = this.resolveModifierContext(
       modifierInputs,
       context,
@@ -8127,12 +8140,7 @@ var CssRenderer = class _CssRenderer {
     return { fileName, content };
   }
   async formatModifier(context, options) {
-    const requiresFile = context.buildPath !== void 0 && context.buildPath !== "";
-    if (!context.output.file && requiresFile) {
-      throw new ConfigurationError(
-        `Output "${context.output.name}": file is required for modifier CSS output`
-      );
-    }
+    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");
     }
@@ -8158,7 +8166,7 @@ var CssRenderer = class _CssRenderer {
   }
   async buildModifierBaseFile(context, options) {
     const basePermutation = context.permutations.find(
-      ({ modifierInputs }) => this.isBasePermutation(modifierInputs, context.meta.defaults)
+      ({ modifierInputs }) => isBasePermutation(modifierInputs, context.meta.defaults)
     );
     if (!basePermutation) {
       return void 0;
@@ -8171,25 +8179,40 @@ var CssRenderer = class _CssRenderer {
     if (setBlocks.length === 0) {
       return void 0;
     }
+    const { selector, mediaQuery } = this.resolveBaseModifierContext(context, options);
+    const content = await this.formatSetBlocksCss(
+      setBlocks,
+      basePermutation.tokens,
+      selector,
+      mediaQuery,
+      options
+    );
+    const fileName = context.output.file ? resolveBaseFileName(context.output.file, context.meta.defaults) : `${context.output.name}-base.css`;
+    return { fileName, content };
+  }
+  resolveBaseModifierContext(context, options) {
     const modifiers = context.resolver.modifiers;
     const firstModifierName = Object.keys(modifiers)[0] ?? "";
     const firstModifierContext = context.meta.defaults[firstModifierName] ?? "";
     const baseModifierInputs = { ...context.meta.defaults };
-    const selector = resolveSelector(
-      options.selector,
-      firstModifierName,
-      firstModifierContext,
-      true,
-      baseModifierInputs
-    );
-    const mediaQuery = resolveMediaQuery(
-      options.mediaQuery,
-      firstModifierName,
-      firstModifierContext,
-      true,
-      baseModifierInputs
-    );
-    const referenceTokens = basePermutation.tokens;
+    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);
@@ -8205,9 +8228,7 @@ var CssRenderer = class _CssRenderer {
       cssBlocks.push(`${header}
 ${css2}`);
     }
-    const content = cssBlocks.join("\n");
-    const fileName = context.output.file ? resolveBaseFileName(context.output.file, context.meta.defaults) : `${context.output.name}-base.css`;
-    return { fileName, content };
+    return cssBlocks.join("\n");
   }
   collectTokensForModifierContext(modifierName, contextValue, permutations) {
     const expectedSource = `${modifierName}-${contextValue}`;
@@ -8284,13 +8305,6 @@ ${css2}`);
     }
     return { modifierName: "", modifierContext: "" };
   }
-  isBasePermutation(modifierInputs, defaults) {
-    const normalizedInputs = normalizeModifierInputs(modifierInputs);
-    const normalizedDefaults = normalizeModifierInputs(defaults);
-    return Object.entries(normalizedDefaults).every(
-      ([key, value]) => normalizedInputs[key] === value
-    );
-  }
 };
 function cssRenderer() {
   const rendererInstance = new CssRenderer();
@@ -8303,8 +8317,6 @@ function cssRenderer() {
 }
 
 // src/renderers/ios.ts
-init_errors();
-init_token_utils();
 init_utils();
 var toSRGB2 = converter("rgb");
 var toP32 = converter("p3");
@@ -8393,94 +8405,68 @@ var IosRenderer = class {
     return await this.formatStandalone(context, opts);
   }
   formatTokens(tokens, options) {
-    if (options.structure === "grouped") {
-      return this.formatAsGrouped(tokens, options);
-    }
-    return this.formatAsEnum(tokens, options);
-  }
-  formatAsEnum(tokens, options) {
     const access3 = options.accessLevel;
-    const groups = this.groupTokensByType(tokens);
+    const groups = groupTokensByType(tokens, SWIFT_TYPE_GROUP_MAP);
     const imports = this.collectImports(tokens);
-    const i1 = this.indentStr(options.indent, 1);
-    const i2 = this.indentStr(options.indent, 2);
     const staticPrefix = this.staticLetPrefix(options);
     const frozen = this.frozenPrefix(options);
     const lines = [];
-    lines.push(this.buildFileHeader());
+    lines.push(buildGeneratedFileHeader());
     lines.push("");
     for (const imp of imports) {
       lines.push(`import ${imp}`);
     }
     lines.push(...this.buildStructDefinitions(tokens, access3, options));
+    this.pushTokenLayout(lines, groups, options, access3, staticPrefix, frozen);
+    lines.push(...this.buildViewExtensions(tokens, access3, options));
+    if (options.structure !== "grouped") {
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  pushTokenLayout(lines, groups, options, access3, staticPrefix, frozen) {
+    const i1 = indentStr(options.indent, 1);
+    const i2 = indentStr(options.indent, 2);
+    if (options.structure === "grouped") {
+      this.pushGroupedLayout(lines, groups, options, access3, i1, i2, staticPrefix, frozen);
+      return;
+    }
     lines.push("");
     lines.push(`${frozen}${access3} enum ${options.enumName} {`);
     for (const group of groups) {
       lines.push(`${i1}${frozen}${access3} enum ${group.name} {`);
-      for (const token of group.tokens) {
-        const swiftName = this.buildQualifiedSwiftName(token);
-        const swiftValue = this.formatSwiftValue(token, options);
-        const typeAnnotation = this.getTypeAnnotation(token);
-        const annotation = typeAnnotation ? `: ${typeAnnotation}` : "";
-        const docComment = this.buildDocComment(token, i2);
-        if (docComment) {
-          lines.push(docComment);
-        }
-        lines.push(`${i2}${access3} ${staticPrefix}${swiftName}${annotation} = ${swiftValue}`);
-      }
+      this.pushTokenDeclarations(lines, group.tokens, options, access3, i2, staticPrefix);
       lines.push(`${i1}}`);
       lines.push("");
     }
     lines.push("}");
-    lines.push(...this.buildViewExtensions(tokens, access3, options));
-    lines.push("");
-    return lines.join("\n");
   }
-  formatAsGrouped(tokens, options) {
-    const access3 = options.accessLevel;
+  pushGroupedLayout(lines, groups, options, access3, i1, i2, staticPrefix, frozen) {
     const namespace = options.extensionNamespace;
-    const groups = this.groupTokensByType(tokens);
-    const imports = this.collectImports(tokens);
-    const i1 = this.indentStr(options.indent, 1);
-    const i2 = this.indentStr(options.indent, 2);
-    const staticPrefix = this.staticLetPrefix(options);
-    const frozen = this.frozenPrefix(options);
-    const lines = [];
-    lines.push(this.buildFileHeader());
-    lines.push("");
-    for (const imp of imports) {
-      lines.push(`import ${imp}`);
-    }
-    lines.push(...this.buildStructDefinitions(tokens, access3, options));
     lines.push("");
     lines.push(`${frozen}${access3} enum ${namespace} {}`);
     lines.push("");
     for (const group of groups) {
       lines.push(`${access3} extension ${namespace} {`);
       lines.push(`${i1}${frozen}enum ${group.name} {`);
-      for (const token of group.tokens) {
-        const swiftName = this.buildQualifiedSwiftName(token);
-        const swiftValue = this.formatSwiftValue(token, options);
-        const typeAnnotation = this.getTypeAnnotation(token);
-        const annotation = typeAnnotation ? `: ${typeAnnotation}` : "";
-        const docComment = this.buildDocComment(token, i2);
-        if (docComment) {
-          lines.push(docComment);
-        }
-        lines.push(`${i2}${access3} ${staticPrefix}${swiftName}${annotation} = ${swiftValue}`);
-      }
+      this.pushTokenDeclarations(lines, group.tokens, options, access3, i2, staticPrefix);
       lines.push(`${i1}}`);
       lines.push("}");
       lines.push("");
     }
-    lines.push(...this.buildViewExtensions(tokens, access3, options));
-    return lines.join("\n");
   }
-  buildFileHeader() {
-    return [
-      "// Generated by Dispersa - do not edit manually",
-      "// https://github.com/timges/dispersa"
-    ].join("\n");
+  pushTokenDeclarations(lines, tokens, options, access3, indent, staticPrefix) {
+    for (const token of tokens) {
+      const swiftName = this.buildQualifiedSwiftName(token);
+      const swiftValue = this.formatSwiftValue(token, options);
+      const typeAnnotation = this.getTypeAnnotation(token);
+      const annotation = typeAnnotation ? `: ${typeAnnotation}` : "";
+      const docComment = this.buildDocComment(token, indent);
+      if (docComment) {
+        lines.push(docComment);
+      }
+      lines.push(`${indent}${access3} ${staticPrefix}${swiftName}${annotation} = ${swiftValue}`);
+    }
   }
   collectImports(tokens) {
     const imports = /* @__PURE__ */ new Set();
@@ -8495,24 +8481,11 @@ var IosRenderer = class {
   /**
    * Builds a `///` doc comment from a token's `$description`, if present.
    */
-  buildDocComment(token, indent2) {
+  buildDocComment(token, indent) {
     if (!token.$description) {
       return void 0;
     }
-    return `${indent2}/// ${token.$description}`;
-  }
-  groupTokensByType(tokens) {
-    const groupMap = /* @__PURE__ */ new Map();
-    for (const [, token] of getSortedTokenEntries(tokens)) {
-      const groupName = SWIFT_TYPE_GROUP_MAP[token.$type ?? ""] ?? "Other";
-      const existing = groupMap.get(groupName) ?? [];
-      existing.push(token);
-      groupMap.set(groupName, existing);
-    }
-    return Array.from(groupMap.entries()).map(([name, groupTokens]) => ({
-      name,
-      tokens: groupTokens
-    }));
+    return `${indent}/// ${token.$description}`;
   }
   /**
    * Builds a qualified Swift name from a token's path, preserving parent
@@ -8525,43 +8498,40 @@ var IosRenderer = class {
     const path7 = token.path;
     const withoutTypePrefix = path7.length > 1 ? path7.slice(1) : path7;
     const joined = withoutTypePrefix.join("_");
-    return this.toSwiftIdentifier(joined);
+    return toSafeIdentifier(joined, SWIFT_KEYWORDS, false);
   }
   formatSwiftValue(token, options) {
-    const value = token.$value;
-    if (token.$type === "color") {
-      return this.formatColorValue(value, options);
-    }
-    if (token.$type === "dimension") {
-      return this.formatDimensionValue(value);
-    }
-    if (token.$type === "fontFamily") {
-      return this.formatFontFamilyValue(value);
-    }
-    if (token.$type === "fontWeight") {
-      return this.formatFontWeightValue(value);
-    }
-    if (token.$type === "duration") {
-      return this.formatDurationValue(value);
-    }
-    if (token.$type === "shadow") {
-      return this.formatShadowValue(value, options);
-    }
-    if (token.$type === "typography") {
-      return this.formatTypographyValue(value);
-    }
-    if (token.$type === "border") {
-      return this.formatBorderValue(value, options);
-    }
-    if (token.$type === "gradient") {
-      return this.formatGradientValue(value, options);
-    }
-    if (token.$type === "number") {
-      return String(value);
-    }
-    if (token.$type === "cubicBezier" && Array.isArray(value) && value.length === 4) {
-      return `UnitCurve.bezier(startControlPoint: UnitPoint(x: ${value[0]}, y: ${value[1]}), endControlPoint: UnitPoint(x: ${value[2]}, y: ${value[3]}))`;
+    const { $type, $value: value } = token;
+    switch ($type) {
+      case "color":
+        return this.formatColorValue(value, options);
+      case "dimension":
+        return this.formatDimensionValue(value);
+      case "fontFamily":
+        return this.formatFontFamilyValue(value);
+      case "fontWeight":
+        return this.formatFontWeightValue(value);
+      case "duration":
+        return this.formatDurationValue(value);
+      case "shadow":
+        return this.formatShadowValue(value, options);
+      case "typography":
+        return this.formatTypographyValue(value);
+      case "border":
+        return this.formatBorderValue(value, options);
+      case "gradient":
+        return this.formatGradientValue(value, options);
+      case "number":
+        return String(value);
+      case "cubicBezier":
+        if (Array.isArray(value) && value.length === 4) {
+          return `UnitCurve.bezier(startControlPoint: UnitPoint(x: ${value[0]}, y: ${value[1]}), endControlPoint: UnitPoint(x: ${value[2]}, y: ${value[3]}))`;
+        }
+        break;
     }
+    return this.formatSwiftPrimitive(value);
+  }
+  formatSwiftPrimitive(value) {
     if (typeof value === "string") {
       return `"${this.escapeSwiftString(value)}"`;
     }
@@ -8594,9 +8564,7 @@ var IosRenderer = class {
   }
   formatDimensionValue(value) {
     if (isDimensionObject(value)) {
-      const dim = value;
-      const ptValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
-      return String(ptValue);
+      return this.dimensionToPoints(value);
     }
     return String(value);
   }
@@ -8663,7 +8631,7 @@ var IosRenderer = class {
     return map[name.toLowerCase()];
   }
   formatDurationValue(value) {
-    if (typeof value === "object" && value !== null && "value" in value && "unit" in value) {
+    if (isDurationObject(value)) {
       const dur = value;
       const seconds = dur.unit === "ms" ? dur.value / 1e3 : dur.value;
       return String(seconds);
@@ -8712,9 +8680,7 @@ var IosRenderer = class {
     if (!isDimensionObject(typo.letterSpacing)) {
       return "0";
     }
-    const dim = typo.letterSpacing;
-    const ptValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
-    return String(ptValue);
+    return this.dimensionToPoints(typo.letterSpacing);
   }
   extractLineSpacing(typo) {
     if (typo.lineHeight == null || typeof typo.lineHeight !== "number") {
@@ -8723,18 +8689,19 @@ var IosRenderer = class {
     if (!isDimensionObject(typo.fontSize)) {
       return "0";
     }
-    const dim = typo.fontSize;
-    const basePt = dim.unit === "rem" ? dim.value * 16 : dim.value;
+    const basePt = this.dimensionToNumericPoints(typo.fontSize);
     const lineHeightPt = Math.round(basePt * typo.lineHeight * 100) / 100;
     return String(lineHeightPt - basePt);
   }
+  dimensionToNumericPoints(dim) {
+    return dim.unit === "rem" ? dim.value * 16 : dim.value;
+  }
   dimensionToPoints(dim) {
-    const ptValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
-    return String(ptValue);
+    return String(this.dimensionToNumericPoints(dim));
   }
   /** Formats a dimension as a CGFloat literal (appends `.0` for integers). */
   dimensionToCGFloat(dim) {
-    const ptValue = dim.unit === "rem" ? dim.value * 16 : dim.value;
+    const ptValue = this.dimensionToNumericPoints(dim);
     return Number.isInteger(ptValue) ? `${ptValue}.0` : String(ptValue);
   }
   getTypeAnnotation(token) {
@@ -8753,21 +8720,12 @@ var IosRenderer = class {
         return void 0;
     }
   }
-  toSwiftIdentifier(name) {
-    const camel = name.replace(/[-._]+(.)/g, (_, c) => c.toUpperCase()).replace(/[-._]+$/g, "").replace(/^[-._]+/g, "");
-    const identifier = camel.charAt(0).toLowerCase() + camel.slice(1);
-    const safe = /^\d/.test(identifier) ? `_${identifier}` : identifier;
-    return SWIFT_KEYWORDS.has(safe) ? `\`${safe}\`` : safe;
-  }
   escapeSwiftString(str) {
     return str.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n");
   }
   roundComponent(value) {
     return Math.round(value * 1e4) / 1e4;
   }
-  indentStr(width, level) {
-    return " ".repeat(width * level);
-  }
   /**
    * Returns the prefix for `static let` declarations.
    * Swift 6 requires `nonisolated(unsafe)` on global stored properties.
@@ -8783,34 +8741,25 @@ var IosRenderer = class {
   structConformances(options) {
     return options.swiftVersion === "6.0" ? ": Sendable" : "";
   }
-  hasShadowTokens(tokens) {
-    return Object.values(tokens).some((t) => t.$type === "shadow");
-  }
-  hasTypographyTokens(tokens) {
-    return Object.values(tokens).some((t) => t.$type === "typography");
-  }
-  hasBorderTokens(tokens) {
-    return Object.values(tokens).some((t) => t.$type === "border");
-  }
   /** Emits all struct definitions needed by the token set. */
   buildStructDefinitions(tokens, access3, options) {
     const lines = [];
-    if (this.hasShadowTokens(tokens)) {
+    if (Object.values(tokens).some(isShadowToken)) {
       lines.push("");
       lines.push(...this.buildShadowStyleStruct(access3, options));
     }
-    if (this.hasTypographyTokens(tokens)) {
+    if (Object.values(tokens).some(isTypographyToken)) {
       lines.push("");
       lines.push(...this.buildTypographyStyleStruct(access3, options));
     }
-    if (this.hasBorderTokens(tokens)) {
+    if (Object.values(tokens).some(isBorderToken)) {
       lines.push("");
       lines.push(...this.buildBorderStyleStruct(access3, options));
     }
     return lines;
   }
   buildShadowStyleStruct(access3, options) {
-    const i1 = this.indentStr(options.indent, 1);
+    const i1 = indentStr(options.indent, 1);
     const conformances = this.structConformances(options);
     const frozen = this.frozenPrefix(options);
     return [
@@ -8824,7 +8773,7 @@ var IosRenderer = class {
     ];
   }
   buildTypographyStyleStruct(access3, options) {
-    const i1 = this.indentStr(options.indent, 1);
+    const i1 = indentStr(options.indent, 1);
     const conformances = this.structConformances(options);
     const frozen = this.frozenPrefix(options);
     return [
@@ -8836,7 +8785,7 @@ var IosRenderer = class {
     ];
   }
   buildBorderStyleStruct(access3, options) {
-    const i1 = this.indentStr(options.indent, 1);
+    const i1 = indentStr(options.indent, 1);
     const conformances = this.structConformances(options);
     const frozen = this.frozenPrefix(options);
     return [
@@ -8849,9 +8798,9 @@ var IosRenderer = class {
   /** Emits convenience View extensions for shadow and typography application. */
   buildViewExtensions(tokens, access3, options) {
     const lines = [];
-    const i1 = this.indentStr(options.indent, 1);
-    const i2 = this.indentStr(options.indent, 2);
-    if (this.hasShadowTokens(tokens)) {
+    const i1 = indentStr(options.indent, 1);
+    const i2 = indentStr(options.indent, 2);
+    if (Object.values(tokens).some(isShadowToken)) {
       lines.push("");
       lines.push(`${access3} extension View {`);
       lines.push(`${i1}func shadowStyle(_ style: ShadowStyle) -> some View {`);
@@ -8861,7 +8810,7 @@ var IosRenderer = class {
       lines.push(`${i1}}`);
       lines.push("}");
     }
-    if (this.hasTypographyTokens(tokens)) {
+    if (Object.values(tokens).some(isTypographyToken)) {
       lines.push("");
       lines.push(`${access3} extension View {`);
       lines.push(`${i1}func typographyStyle(_ style: TypographyStyle) -> some View {`);
@@ -8893,12 +8842,12 @@ var IosRenderer = class {
     return `Gradient(stops: [${stops.join(", ")}])`;
   }
   async formatStandalone(context, options) {
-    const requiresFile = context.buildPath !== void 0 && context.buildPath !== "";
-    if (!context.output.file && requiresFile) {
-      throw new ConfigurationError(
-        `Output "${context.output.name}": file is required for standalone iOS output`
-      );
-    }
+    assertFileRequired(
+      context.buildPath,
+      context.output.file,
+      context.output.name,
+      "standalone iOS"
+    );
     const files = {};
     for (const { tokens, modifierInputs } of context.permutations) {
       const processedTokens = stripInternalMetadata(tokens);
@@ -8927,7 +8876,6 @@ function iosRenderer() {
 
 // src/renderers/js-module.ts
 init_utils();
-init_errors();
 init_token_utils();
 var JsModuleRenderer = class {
   async format(context, options) {
@@ -8943,18 +8891,13 @@ var JsModuleRenderer = class {
       const bundleData = context.permutations.map(({ tokens, modifierInputs }) => ({
         tokens: stripInternalMetadata(tokens),
         modifierInputs,
-        isBase: this.isBasePermutation(modifierInputs, context.meta.defaults)
+        isBase: isBasePermutation(modifierInputs, context.meta.defaults)
       }));
       return await bundleAsJsModule2(bundleData, context.resolver, opts, async (tokens) => {
         return await this.formatTokens(tokens, opts);
       });
     }
-    const requiresFile = context.buildPath !== void 0 && context.buildPath !== "";
-    if (!context.output.file && requiresFile) {
-      throw new ConfigurationError(
-        `Output "${context.output.name}": file is required for JS module output`
-      );
-    }
+    assertFileRequired(context.buildPath, context.output.file, context.output.name, "JS module");
     const files = {};
     for (const { tokens, modifierInputs } of context.permutations) {
       const cleanTokens = stripInternalMetadata(tokens);
@@ -9008,42 +8951,18 @@ var JsModuleRenderer = class {
     lines.push(`export default ${varName}`);
     return lines;
   }
-  /**
-   * Convert tokens to plain object with flat or nested structure
-   */
   tokensToPlainObject(tokens, structure) {
+    if (structure === "nested") {
+      return buildNestedTokenObject(tokens, (token) => token.$value);
+    }
     const result = {};
-    if (structure === "flat") {
-      for (const [name, token] of getSortedTokenEntries(tokens)) {
-        result[name] = token.$value;
-      }
-    } else {
-      for (const [, token] of getSortedTokenEntries(tokens)) {
-        const parts = token.path;
-        let current = result;
-        for (let i = 0; i < parts.length - 1; i++) {
-          const part = parts[i];
-          if (part == null) {
-            continue;
-          }
-          if (!(part in current)) {
-            current[part] = {};
-          }
-          current = current[part];
-        }
-        const lastPart = parts[parts.length - 1];
-        if (lastPart != null) {
-          current[lastPart] = token.$value;
-        }
-      }
+    for (const [name, token] of getSortedTokenEntries(tokens)) {
+      result[name] = token.$value;
     }
     return result;
   }
-  /**
-   * Add object properties to lines
-   */
-  addObjectProperties(lines, obj, indent2) {
-    const indentStr = "  ".repeat(indent2);
+  addObjectProperties(lines, obj, 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];
@@ -9052,14 +8971,16 @@ var JsModuleRenderer = class {
       }
       const [key, value] = entry;
       const isLast = i === entries.length - 1;
-      if (typeof value === "object" && value !== null && !Array.isArray(value)) {
-        lines.push(`${indentStr}${this.quoteKey(key)}: {`);
-        this.addObjectProperties(lines, value, indent2 + 1);
-        lines.push(`${indentStr}}${isLast ? "" : ","}`);
-      } else {
-        const valueStr = JSON.stringify(value);
-        lines.push(`${indentStr}${this.quoteKey(key)}: ${valueStr}${isLast ? "" : ","}`);
+      const isNestedObject = typeof value === "object" && value !== null && !Array.isArray(value);
+      if (!isNestedObject) {
+        lines.push(
+          `${indentStr2}${this.quoteKey(key)}: ${JSON.stringify(value)}${isLast ? "" : ","}`
+        );
+        continue;
       }
+      lines.push(`${indentStr2}${this.quoteKey(key)}: {`);
+      this.addObjectProperties(lines, value, indent + 1);
+      lines.push(`${indentStr2}}${isLast ? "" : ","}`);
     }
   }
   /**
@@ -9071,9 +8992,6 @@ var JsModuleRenderer = class {
     }
     return `"${key}"`;
   }
-  isBasePermutation(modifierInputs, defaults) {
-    return Object.entries(modifierInputs).every(([key, value]) => value === defaults[key]);
-  }
 };
 function jsRenderer() {
   const rendererInstance = new JsModuleRenderer();
@@ -9087,7 +9005,6 @@ function jsRenderer() {
 
 // src/renderers/json.ts
 init_utils();
-init_errors();
 init_token_utils();
 var JsonRenderer = class {
   async format(context, options) {
@@ -9102,18 +9019,13 @@ var JsonRenderer = class {
       const bundleData = context.permutations.map(({ tokens, modifierInputs }) => ({
         tokens: stripInternalMetadata(tokens),
         modifierInputs,
-        isBase: this.isBasePermutation(modifierInputs, context.meta.defaults)
+        isBase: isBasePermutation(modifierInputs, context.meta.defaults)
       }));
       return await bundleAsJson2(bundleData, context.resolver, async (tokens) => {
         return await this.formatTokens(tokens, opts);
       });
     }
-    const requiresFile = context.buildPath !== void 0 && context.buildPath !== "";
-    if (!context.output.file && requiresFile) {
-      throw new ConfigurationError(
-        `Output "${context.output.name}": file is required for JSON output`
-      );
-    }
+    assertFileRequired(context.buildPath, context.output.file, context.output.name, "JSON");
     const files = {};
     for (const { tokens, modifierInputs } of context.permutations) {
       const processedTokens = stripInternalMetadata(tokens);
@@ -9173,55 +9085,11 @@ var JsonRenderer = class {
     }
     return result;
   }
-  /**
-   * Nest tokens by path (values only)
-   */
   nestValues(tokens) {
-    const result = {};
-    for (const [, token] of getSortedTokenEntries(tokens)) {
-      const parts = token.path;
-      let current = result;
-      for (let i = 0; i < parts.length - 1; i++) {
-        const part = parts[i];
-        if (part === null || part === void 0) {
-          continue;
-        }
-        if (!(part in current)) {
-          current[part] = {};
-        }
-        current = current[part];
-      }
-      const lastPart = parts[parts.length - 1];
-      if (lastPart !== null && lastPart !== void 0) {
-        current[lastPart] = token.$value;
-      }
-    }
-    return result;
+    return buildNestedTokenObject(tokens, (token) => token.$value);
   }
-  /**
-   * Nest tokens by path (with metadata)
-   */
   nestTokens(tokens) {
-    const result = {};
-    for (const [, token] of getSortedTokenEntries(tokens)) {
-      const parts = token.path;
-      let current = result;
-      for (let i = 0; i < parts.length - 1; i++) {
-        const part = parts[i];
-        if (part === null || part === void 0) {
-          continue;
-        }
-        if (!(part in current)) {
-          current[part] = {};
-        }
-        current = current[part];
-      }
-      const lastPart = parts[parts.length - 1];
-      if (lastPart !== null && lastPart !== void 0) {
-        current[lastPart] = this.serializeToken(token);
-      }
-    }
-    return result;
+    return buildNestedTokenObject(tokens, (token) => this.serializeToken(token));
   }
   serializeToken(token) {
     return {
@@ -9232,9 +9100,6 @@ var JsonRenderer = class {
       ...token.$extensions != null && { $extensions: token.$extensions }
     };
   }
-  isBasePermutation(modifierInputs, defaults) {
-    return Object.entries(modifierInputs).every(([key, value]) => value === defaults[key]);
-  }
 };
 function jsonRenderer() {
   const rendererInstance = new JsonRenderer();
@@ -9247,7 +9112,6 @@ function jsonRenderer() {
 }
 
 // src/renderers/tailwind.ts
-init_errors();
 init_token_utils();
 
 // src/renderers/bundlers/tailwind.ts
@@ -9276,6 +9140,13 @@ async function bundleAsTailwind(bundleData, options, formatThemeTokens, formatOv
   }
   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) {
@@ -9288,19 +9159,11 @@ async function formatModifierOverride({ tokens, modifierInputs }, baseItem, opti
   const expectedSource = getExpectedSource(modifierInputs, baseItem.modifierInputs);
   const [modifier, context] = parseModifierSource(expectedSource);
   const cleanTokens = stripInternalMetadata(tokensToInclude);
-  const selector = resolveSelector(
-    options.selector,
-    modifier,
-    context,
-    false,
-    normalizeModifierInputs(modifierInputs)
-  );
-  const mediaQuery = resolveMediaQuery(
-    options.mediaQuery,
+  const { selector, mediaQuery } = resolveModifierSelectorAndMedia(
+    options,
     modifier,
     context,
-    false,
-    normalizeModifierInputs(modifierInputs)
+    modifierInputs
   );
   const css2 = await formatOverrideBlock(cleanTokens, selector, mediaQuery, options.minify);
   return `/* Modifier: ${modifier}=${context} */
@@ -9389,7 +9252,7 @@ var TailwindRenderer = class {
    */
   async formatTokens(tokens, options) {
     const lines = [];
-    const indent2 = options.minify ? "" : "  ";
+    const indent = options.minify ? "" : "  ";
     const newline = options.minify ? "" : "\n";
     const space = options.minify ? "" : " ";
     if (options.includeImport) {
@@ -9411,7 +9274,7 @@ var TailwindRenderer = class {
     for (const [, token] of getSortedTokenEntries(tokens)) {
       const varName = this.buildVariableName(token);
       const varValue = this.formatValue(token);
-      lines.push(`${indent2}--${varName}:${space}${varValue};${newline}`);
+      lines.push(`${indent}--${varName}:${space}${varValue};${newline}`);
     }
     lines.push(`}${newline}`);
     const cssString = lines.join("");
@@ -9422,15 +9285,15 @@ var TailwindRenderer = class {
    * Used for modifier overrides (e.g., dark mode) appended after the @theme block.
    */
   async formatOverrideBlock(tokens, selector, mediaQuery, minify) {
-    const indent2 = minify ? "" : "  ";
+    const indent = minify ? "" : "  ";
     const newline = minify ? "" : "\n";
     const space = minify ? "" : " ";
     const hasMediaQuery = mediaQuery !== "";
-    const tokenIndent = hasMediaQuery ? indent2 + indent2 : indent2;
+    const tokenIndent = hasMediaQuery ? indent + indent : indent;
     const lines = [];
     if (hasMediaQuery) {
       lines.push(`@media ${mediaQuery}${space}{${newline}`);
-      lines.push(`${indent2}${selector}${space}{${newline}`);
+      lines.push(`${indent}${selector}${space}{${newline}`);
     } else {
       lines.push(`${selector}${space}{${newline}`);
     }
@@ -9440,7 +9303,7 @@ var TailwindRenderer = class {
       lines.push(`${tokenIndent}--${varName}:${space}${varValue};${newline}`);
     }
     if (hasMediaQuery) {
-      lines.push(`${indent2}}${newline}`);
+      lines.push(`${indent}}${newline}`);
       lines.push(`}${newline}`);
     } else {
       lines.push(`}${newline}`);
@@ -9467,8 +9330,8 @@ var TailwindRenderer = class {
     if (token.$type === "dimension" && isDimensionObject(value)) {
       return dimensionObjectToString(value);
     }
-    if (token.$type === "duration" && this.isDurationObject(value)) {
-      return `${value.value}${value.unit}`;
+    if (token.$type === "duration" && isDurationObject(value)) {
+      return durationObjectToString(value);
     }
     if (token.$type === "fontFamily") {
       if (Array.isArray(value)) {
@@ -9523,9 +9386,6 @@ var TailwindRenderer = class {
     }
     return parts.join(" ");
   }
-  isDurationObject(value) {
-    return typeof value === "object" && value !== null && "value" in value && "unit" in value && value.unit !== void 0;
-  }
   async formatWithPrettier(css2) {
     try {
       return await prettier.format(css2, {
@@ -9542,7 +9402,7 @@ var TailwindRenderer = class {
     const bundleData = context.permutations.map(({ tokens, modifierInputs }) => ({
       tokens,
       modifierInputs,
-      isBase: this.isBasePermutation(modifierInputs, context.meta.defaults)
+      isBase: isBasePermutation(modifierInputs, context.meta.defaults)
     }));
     return await bundleAsTailwind(
       bundleData,
@@ -9552,12 +9412,12 @@ var TailwindRenderer = class {
     );
   }
   async formatStandalone(context, options) {
-    const requiresFile = context.buildPath !== void 0 && context.buildPath !== "";
-    if (!context.output.file && requiresFile) {
-      throw new ConfigurationError(
-        `Output "${context.output.name}": file is required for standalone Tailwind output`
-      );
-    }
+    assertFileRequired(
+      context.buildPath,
+      context.output.file,
+      context.output.name,
+      "standalone Tailwind"
+    );
     const files = {};
     for (const { tokens, modifierInputs } of context.permutations) {
       const processedTokens = stripInternalMetadata(tokens);
@@ -9573,11 +9433,6 @@ var TailwindRenderer = class {
     }
     return outputTree(files);
   }
-  isBasePermutation(modifierInputs, defaults) {
-    return Object.entries(defaults).every(
-      ([key, value]) => modifierInputs[key]?.toLowerCase() === value.toLowerCase()
-    );
-  }
 };
 function tailwindRenderer() {
   const rendererInstance = new TailwindRenderer();
@@ -9710,11 +9565,6 @@ function defineRenderer(renderer) {
 
 // src/index.ts
 init_errors();
-/**
- * @license
- * Copyright (c) 2025 Dispersa Contributors
- * SPDX-License-Identifier: MIT
- */
 /**
  * @license MIT
  * Copyright (c) 2025-present Dispersa Contributors
@@ -9722,6 +9572,11 @@ init_errors();
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  */
+/**
+ * @license
+ * Copyright (c) 2025 Dispersa Contributors
+ * SPDX-License-Identifier: MIT
+ */
 
 export { BasePermutationError, CircularReferenceError, ConfigurationError, Dispersa, DispersaError, FileOperationError, ModifierError, TokenReferenceError, ValidationError, android, css, defineRenderer, ios, isBorderToken, isColorToken, isDimensionToken, isDurationToken, isGradientToken, isOutputTree, isShadowToken, isTransitionToken, isTypographyToken, js, json, outputTree, tailwind };
 //# sourceMappingURL=index.js.map