@digdir/designsystemet 1.13.1 → 1.13.3

package/dist/bin/designsystemet.js

@@ -1,4498 +1,19 @@
 #!/usr/bin/env node
-
-// bin/designsystemet.ts
-import path4 from "path";
-import { Argument, createCommand, program } from "@commander-js/extra-typings";
-import pc11 from "picocolors";
-import * as R28 from "ramda";
-
-// src/colors/colorMetadata.ts
-import * as R from "ramda";
-var baseColors = {
-  info: "#0A71C0",
-  success: "#068718",
-  warning: "#EA9B1B",
-  danger: "#C01B1B"
-};
-var dsLinkColor = "#663299";
-var colorMetadata = {
-  "background-default": {
-    number: 1,
-    name: "background-default",
-    group: "background",
-    displayName: "Background Default",
-    description: {
-      long: "Background Default er den mest n\xF8ytrale bakgrunnsfargen.",
-      short: "Standard bakgrunnsfarge."
-    },
-    luminance: {
-      light: 1,
-      dark: 9e-3,
-      contrast: 1e-3
-    }
-  },
-  "background-tinted": {
-    number: 2,
-    name: "background-tinted",
-    group: "background",
-    displayName: "Background Tinted",
-    description: {
-      long: "Background Tinted er en bakgrunnsfarge som har et hint av farge i seg.",
-      short: "Bakgrunn med et hint av farge i seg."
-    },
-    luminance: {
-      light: 0.9,
-      dark: 0.014,
-      contrast: 65e-4
-    }
-  },
-  "surface-default": {
-    number: 3,
-    name: "surface-default",
-    group: "surface",
-    displayName: "Surface Default",
-    description: {
-      long: "Surface Default brukes p\xE5 flater som ligger opp\xE5 bakgrunnsfargene. Dette er den mest n\xF8ytrale surface fargen.",
-      short: "Standardfarge for overflater / komponenter."
-    },
-    luminance: {
-      light: 1,
-      dark: 0.021,
-      contrast: 0.015
-    }
-  },
-  "surface-tinted": {
-    number: 4,
-    name: "surface-tinted",
-    group: "surface",
-    displayName: "Surface Tinted",
-    description: {
-      long: "Surface Tinted brukes p\xE5 flater som ligger opp\xE5 bakgrunnsfargene. Denne har et hint av farge i seg.",
-      short: "Overflater / komponenter med et hint av farge i seg."
-    },
-    luminance: {
-      light: 0.81,
-      dark: 0.027,
-      contrast: 0.015
-    }
-  },
-  "surface-hover": {
-    number: 5,
-    name: "surface-hover",
-    group: "surface",
-    displayName: "Surface Hover",
-    description: {
-      long: "Surface Hover brukes p\xE5 interaktive flater som ligger opp\xE5 bakgrunnsfargene i en hover state.",
-      short: "Hover-farge til overflater / komponenter."
-    },
-    luminance: {
-      light: 0.7,
-      dark: 0.036,
-      contrast: 0.028
-    }
-  },
-  "surface-active": {
-    number: 6,
-    name: "surface-active",
-    group: "surface",
-    displayName: "Surface Active",
-    description: {
-      long: "Surface Active brukes p\xE5 interaktive flater som ligger opp\xE5 bakgrunnsfargene i en active state.",
-      short: "Active-farge til overflater / komponenter."
-    },
-    luminance: {
-      light: 0.59,
-      dark: 0.056,
-      contrast: 0.045
-    }
-  },
-  "border-subtle": {
-    number: 7,
-    name: "border-subtle",
-    group: "border",
-    displayName: "Border Subtle",
-    description: {
-      long: "Border Subtle er den lyseste border-fargen og brukes for \xE5 skille elementer fra hverandre.",
-      short: "Border-farge med lav kontrast til dekorativ bruk (skillelinjer)."
-    },
-    luminance: {
-      light: 0.5,
-      dark: 0.08,
-      contrast: 0.26
-    }
-  },
-  "border-default": {
-    number: 8,
-    name: "border-default",
-    group: "border",
-    displayName: "Border Default",
-    description: {
-      long: "Border Default er en border-farge som brukes n\xE5r man \xF8nsker god kontrast mot bakgrunnsfargene.",
-      short: "Standard border-farge til skjemakomponenter og meningsb\xE6rende elementer."
-    },
-    luminance: {
-      light: 0.19,
-      dark: 0.22,
-      contrast: 0.4
-    }
-  },
-  "border-strong": {
-    number: 9,
-    name: "border-strong",
-    group: "border",
-    displayName: "Border Strong",
-    description: {
-      long: "Border Strong er den m\xF8rkeste border-fargen og brukes n\xE5r man \xF8nsker en veldig tydelig og sterk border.",
-      short: "Border-farge med h\xF8y kontrast for ekstra synlighet."
-    },
-    luminance: {
-      light: 0.11,
-      dark: 0.39,
-      contrast: 0.6
-    }
-  },
-  "text-subtle": {
-    number: 10,
-    name: "text-subtle",
-    group: "text",
-    displayName: "Text Subtle",
-    description: {
-      long: "Text Subtle er den lyseste tekstfargen og brukes p\xE5 tekst som skal v\xE6re litt mindre synlig eller for \xE5 skape variasjon i typografien.",
-      short: "Tekst- og ikonfarge med lavere kontrast."
-    },
-    luminance: {
-      light: 0.11,
-      dark: 0.39,
-      contrast: 0.57
-    }
-  },
-  "text-default": {
-    number: 11,
-    name: "text-default",
-    group: "text",
-    displayName: "Text Default",
-    description: {
-      long: "Text Default er den m\xF8rkeste tekstfargen og brukes p\xE5 tekst som skal v\xE6re mest synlig. Denne fargen b\xF8r brukes p\xE5 mesteparten av teksten p\xE5 en side.",
-      short: "Tekst- og ikonfarge med h\xF8y kontrast og god synlighet."
-    },
-    luminance: {
-      light: 0.0245,
-      dark: 0.84,
-      contrast: 0.86
-    }
-  },
-  "base-default": {
-    number: 12,
-    name: "base-default",
-    group: "base",
-    displayName: "Base Default",
-    description: {
-      long: "Base Default fargen f\xE5r den samme hex koden som fargen som er valgt i verkt\xF8yet. Brukes ofte som farge p\xE5 viktige elementer og p\xE5 flater som skal fange brukerens oppmerksomhet.",
-      short: "Standardfarge for solide bakgrunner."
-    },
-    luminance: {
-      light: 1,
-      dark: 1,
-      contrast: 1
-    }
-  },
-  "base-hover": {
-    number: 13,
-    name: "base-hover",
-    group: "base",
-    displayName: "Base Hover",
-    description: {
-      long: "Base Hover brukes som hover farge p\xE5 elementer som bruker Base Default fargen.",
-      short: "Hover-farge for solide bakgrunner."
-    },
-    luminance: {
-      light: 1,
-      dark: 1,
-      contrast: 1
-    }
-  },
-  "base-active": {
-    number: 14,
-    name: "base-active",
-    group: "base",
-    displayName: "Base Active",
-    description: {
-      long: "Base Active brukes som active farge p\xE5 elementer som bruker Base Default fargen.",
-      short: "Active-farge for solide bakgrunner."
-    },
-    luminance: {
-      light: 1,
-      dark: 1,
-      contrast: 1
-    }
-  },
-  "base-contrast-subtle": {
-    number: 15,
-    name: "base-contrast-subtle",
-    group: "base",
-    displayName: "Contrast Subtle",
-    description: {
-      long: "Contrast Subtle brukes som en viktig meningsb\xE6rende farge opp\xE5 Base Default fargen.",
-      short: "Farge med god kontrast mot Base-default."
-    },
-    luminance: {
-      light: 1,
-      dark: 1,
-      contrast: 1
-    }
-  },
-  "base-contrast-default": {
-    number: 16,
-    name: "base-contrast-default",
-    group: "base",
-    displayName: "Contrast Default",
-    description: {
-      long: "Contrast Default brukes som en viktig meningsb\xE6rende farge opp\xE5 alle Base fargane.",
-      short: "Farge med god kontrast mot Base-default og Base-hover."
-    },
-    luminance: {
-      light: 1,
-      dark: 1,
-      contrast: 1
-    }
-  }
-};
-var colorMetadataByNumber = R.indexBy((metadata) => metadata.number, Object.values(colorMetadata));
-var colorNames = Object.keys(colorMetadata);
-var baseColorNames = Object.keys(baseColors);
-
-// src/colors/theme.ts
-import chroma2 from "chroma-js";
-import * as R2 from "ramda";
-
-// src/colors/utils.ts
-import chroma from "chroma-js";
-import Colorjs from "colorjs.io";
-import { Hsluv } from "hsluv";
-var getLuminanceFromLightness = (lightness) => {
-  const conv = new Hsluv();
-  conv.hsluv_l = lightness;
-  conv.hsluvToHex();
-  return chroma(conv.hex).luminance();
-};
-var getLightnessFromHex = (hex) => {
-  const conv = new Hsluv();
-  conv.hex = hex;
-  conv.hexToHsluv();
-  return conv.hsluv_l;
-};
-var convertToHex = (color) => {
-  if (!color) {
-    return "#000000";
-  }
-  if (/^#[0-9A-Fa-f]{6}$/.test(color)) {
-    return color;
-  }
-  return chroma(color).hex();
-};
-
-// src/colors/theme.ts
-var RESERVED_COLORS = ["neutral", "success", "warning", "danger", "info"];
-var generateColorScale = (color, colorScheme2) => {
-  let interpolationColor = color;
-  if (colorScheme2 === "dark") {
-    const [L, C, H] = chroma2(color).oklch();
-    const chromaModifier = 0.7;
-    interpolationColor = chroma2(L, C * chromaModifier, H, "oklch").hex();
-  }
-  const colors2 = R2.mapObjIndexed((colorData) => {
-    const luminance = colorData.luminance[colorScheme2];
-    return {
-      ...colorData,
-      hex: chroma2(interpolationColor).luminance(luminance).hex()
-    };
-  }, colorMetadata);
-  const baseColors2 = generateBaseColors(color, colorScheme2);
-  colors2["base-default"] = { ...colors2["base-default"], hex: baseColors2.default };
-  colors2["base-hover"] = { ...colors2["base-hover"], hex: baseColors2.hover };
-  colors2["base-active"] = { ...colors2["base-active"], hex: baseColors2.active };
-  colors2["base-contrast-subtle"] = {
-    ...colors2["base-contrast-subtle"],
-    hex: generateColorContrast(baseColors2.default, "subtle")
-  };
-  colors2["base-contrast-default"] = {
-    ...colors2["base-contrast-default"],
-    hex: generateColorContrast(baseColors2.default, "default")
-  };
-  return Object.values(colors2);
-};
-var generateBaseColors = (color, colorScheme2) => {
-  let colorLightness = getLightnessFromHex(color);
-  if (colorScheme2 !== "light") {
-    colorLightness = colorLightness <= 30 ? 70 : 100 - colorLightness;
-  }
-  const modifier = colorLightness <= 30 || colorLightness >= 49 && colorLightness <= 65 ? -8 : 8;
-  const calculateLightness = (base, mod) => base - mod;
-  return {
-    default: colorScheme2 === "light" ? color : chroma2(color).luminance(getLuminanceFromLightness(colorLightness)).hex(),
-    hover: chroma2(color).luminance(getLuminanceFromLightness(calculateLightness(colorLightness, modifier))).hex(),
-    active: chroma2(color).luminance(getLuminanceFromLightness(calculateLightness(colorLightness, modifier * 2))).hex()
-  };
-};
-var generateColorContrast = (color, type) => {
-  if (type === "default") {
-    return chroma2.contrast(color, "#ffffff") >= chroma2.contrast(color, "#000000") ? "#ffffff" : "#000000";
-  }
-  if (type === "subtle") {
-    const contrastWhite = chroma2.contrast(color, "#ffffff");
-    const contrastBlack = chroma2.contrast(color, "#000000");
-    const lightness = getLightnessFromHex(color);
-    const modifier = lightness <= 40 || lightness >= 60 ? 60 : 50;
-    const targetLightness = contrastWhite >= contrastBlack ? lightness + modifier : lightness - modifier;
-    return chroma2(color).luminance(getLuminanceFromLightness(targetLightness)).hex();
-  }
-  return color;
-};
-
-// src/colors/types.ts
-import * as R3 from "ramda";
-var semanticColorMap = {
-  "background-default": 1,
-  "background-tinted": 2,
-  "surface-default": 3,
-  "surface-tinted": 4,
-  "surface-hover": 5,
-  "surface-active": 6,
-  "border-subtle": 7,
-  "border-default": 8,
-  "border-strong": 9,
-  "text-subtle": 10,
-  "text-default": 11,
-  "base-default": 12,
-  "base-hover": 13,
-  "base-active": 14,
-  "base-contrast-subtle": 15,
-  "base-contrast-default": 16
-};
-var semanticColorNames = R3.keys(semanticColorMap);
-var semanticColorNumbers = R3.values(semanticColorMap);
-
-// src/migrations/codemods/css/plugins.ts
-import hash from "object-hash";
+import { convertToHex } from "../src/colors/utils.js";
+import "../src/colors/index.js";
+import { cliOptions, createTokens } from "../src/tokens/create.js";
+import { dsfs } from "../src/utils/filesystem.js";
+import { parseCreateConfig, readConfigFile } from "./config.js";
+import migrations_default from "../src/migrations/index.js";
+import { buildTokens } from "../src/tokens/build.js";
+import { createTokenFiles } from "../src/tokens/create/files.js";
+import { generateConfigFromTokens } from "../src/tokens/generate-config.js";
 import pc from "picocolors";
-import * as R4 from "ramda";
-var printDelete = (text) => console.log(`${pc.red("Deleted:")} ${text}`.replace(/"|'/g, ""));
-var deleteMsg = (decl, from) => `${pc.yellow(from)} @ ${pc.gray(`${JSON.stringify(decl.source?.input.file)}:${decl.source?.start?.line}:${decl.source?.start?.column}`)}`;
-var cssClassRename = (dictionary) => ({
-  postcssPlugin: `Renames CSS classes ${hash(dictionary)}`,
-  Rule(rule) {
-    const selector = rule.selector;
-    if (!selector) return;
-    for (const [from, to] of Object.entries(dictionary)) {
-      if (!selector.includes(from)) return;
-      const newSelector = selector.replace(new RegExp(from, "g"), to);
-      rule.selector = newSelector;
-    }
-  }
-});
-var cssVarRename = (dictionary) => ({
-  postcssPlugin: `Replaces CSS variables ${hash(dictionary)}`,
-  Declaration(decl) {
-    const { value, prop: prop3 } = decl;
-    const deleted = /* @__PURE__ */ new Set();
-    for (const [from, to] of Object.entries(dictionary)) {
-      if (R4.isNotEmpty(to)) {
-        if (to === "[delete]") {
-          deleted.add(deleteMsg(decl, from));
-        }
-        if (R4.includes(from, value)) {
-          decl.value = value.replace(from, to);
-          continue;
-        }
-        if (R4.includes(from, prop3) && decl.variable) {
-          decl.prop = prop3.replace(from, to);
-        }
-      }
-    }
-    if (deleted.size > 0) {
-      Array.from(deleted).forEach(printDelete);
-    }
-  }
-});
-
-// src/migrations/codemods/css/run.ts
-import glob from "fast-glob";
-import postcss from "postcss";
-
-// src/utils/filesystem.ts
-import fs from "fs/promises";
-import path from "path";
-import pc2 from "picocolors";
-var FileSystem = class {
-  isInitialized = false;
-  dry = false;
-  verbose = false;
-  /** Default working directory is where the process was started */
-  workingDir = process.cwd();
-  outDir = this.workingDir;
-  /** Initialize the file system */
-  init({ dry, outdir, verbose }) {
-    if (this.isInitialized) {
-      console.warn(pc2.yellow("FileSystem is already initialized. Ignoring subsequent init call."));
-      return;
-    }
-    if (dry) {
-      console.log(pc2.blue("Initializing FileSystem in dry-run mode. No files will be written."));
-    }
-    this.dry = dry ?? false;
-    this.verbose = verbose ?? false;
-    this.outDir = outdir ? path.isAbsolute(outdir) ? outdir : path.join(this.workingDir, outdir) : this.workingDir;
-    if (this.verbose) {
-      console.log(
-        `FileSystem initialized with workingDir: ${pc2.green(this.workingDir)}, outDir: ${pc2.green(this.outDir)}`
-      );
-    }
-    this.isInitialized = true;
-  }
-  /**
-   * Creates a directory if it does not already exist.
-   *
-   * @param dir - The path of the directory to create.
-   *
-   * @returns A promise that resolves when the operation is complete.
-   * If the directory already exists or `dry` is `true`, the promise resolves immediately.
-   */
-  mkdir = async (dir) => {
-    if (this.dry) {
-      console.log(`${pc2.blue("mkdir")} ${dir}`);
-      return Promise.resolve();
-    }
-    const exists = await fs.access(dir, fs.constants.F_OK).then(() => true).catch(() => false);
-    if (exists) {
-      return Promise.resolve();
-    }
-    return fs.mkdir(dir, { recursive: true });
-  };
-  writeFile = async (path5, data) => {
-    if (this.dry) {
-      console.log(`${pc2.blue("writeFile")} ${path5}`);
-      return Promise.resolve();
-    }
-    return fs.writeFile(path5, data, { encoding: "utf-8" }).catch((error) => {
-      console.error(pc2.red(`Error writing file: ${path5}`));
-      console.error(pc2.red(error));
-      throw error;
-    });
-  };
-  cp = async (src, dest, filter) => {
-    if (this.dry) {
-      console.log(`${pc2.blue("cp")} ${src} ${dest}`);
-      return Promise.resolve();
-    }
-    return fs.cp(src, dest, { recursive: true, filter });
-  };
-  copyFile = async (src, dest) => {
-    if (this.dry) {
-      console.log(`${pc2.blue("copyFile")} ${src} to ${dest}`);
-      return Promise.resolve();
-    }
-    return fs.copyFile(src, dest);
-  };
-  cleanDir = async (dir) => {
-    if (this.dry) {
-      console.log(`${pc2.blue("cleanDir")} ${dir}`);
-      return Promise.resolve();
-    }
-    console.log(`
-\u{1F525} Cleaning dir ${pc2.red(`${dir.trim()}`)} `);
-    return fs.rm(dir, { recursive: true, force: true });
-  };
-  readFile = async (path5, allowFileNotFound) => {
-    if (this.dry) {
-      console.log(`${pc2.blue("readFile")} ${path5}`);
-    }
-    try {
-      return await fs.readFile(path5, "utf-8");
-    } catch (error) {
-      if (allowFileNotFound && error.code === "ENOENT") {
-        return "";
-      }
-      throw error;
-    }
-  };
-  readdir = async (path5) => {
-    if (this.dry) {
-      console.log(`${pc2.blue("readdir")} ${path5}`);
-    }
-    try {
-      return await fs.readdir(path5);
-    } catch (error) {
-      if (error.code === "ENOENT") {
-        return [];
-      }
-      throw error;
-    }
-  };
-  writeFiles = async (files, outDir, log) => {
-    for (const { destination: filename, output } of files) {
-      if (filename) {
-        const filePath = path.join(outDir, filename);
-        const fileDir = path.dirname(filePath);
-        if (log) {
-          console.log(filename);
-        }
-        await this.mkdir(fileDir);
-        await this.writeFile(filePath, output);
-      }
-    }
-  };
-};
-var dsfs = new FileSystem();
-
-// src/migrations/codemods/css/run.ts
-var runCssCodemod = async ({ plugins = [], globPattern = "./**/*.css" }) => {
-  const processor = postcss(plugins);
-  const transform = async () => {
-    console.log(`Running migration in ${globPattern}`);
-    const files = await glob([globPattern], {
-      ignore: ["**/node_modules/**", "**/dist/**"],
-      // TODO: Not working as expected
-      absolute: true
-    });
-    const filePromises = files.map(async (file) => {
-      if (file.includes("node_modules") || file.includes("dist")) {
-        return;
-      }
-      const contents = await dsfs.readFile(file);
-      const result = await processor.process(contents.toString(), { from: file });
-      await dsfs.writeFile(file, result.css);
-    });
-    await Promise.all(filePromises);
-  };
-  return transform();
-};
-
-// src/migrations/beta-to-v1.ts
-var beta_to_v1_default = (glob2) => runCssCodemod({
-  globPattern: glob2,
-  plugins: [
-    cssClassRename({
-      ".fds-": ".ds-"
-    }),
-    // New component token prefixes
-    cssVarRename({
-      "--fds-accordion": "--dsc-accordion",
-      "--fds-alert": "--dsc-alert",
-      "--fds-btn": "--dsc-btn",
-      "--fds-checkbox": "--dsc-checkbox",
-      "--fdsc-chip": "--dsc-chip",
-      "--fdsc-gap": "--dsc-chip-group-gap",
-      "--fdsc-removable": "--dsc-removable",
-      "--fdsc-bottom": "--dsc-bottom",
-      "--fds-pagination": "--dsc-pagination",
-      "--fds-popover": "--dsc-popover",
-      "--fds-radio": "--dsc-radio",
-      "--f-search": "--dsc-search",
-      "--fds-skeleton": "--dsc-skeleton",
-      "--fds-switch--transition": "--dsc-switch-transition",
-      "--fds-switch": "--dsc-switch",
-      "--table-padding": "--dsc-table-padding",
-      "--border-radius": "--dsc-table-border-radius",
-      "--fds-tabs": "--dsc-tabs",
-      "--fds-tag": "--dsc-tag",
-      "--fds-focus-border-width": "--ds-border-width-focus"
-    }),
-    // New tokens
-    cssVarRename({
-      "--fds-semantic-surface-first-light": "--ds-color-brand1-surface-default",
-      "--fds-semantic-surface-first-light-hover": "--ds-color-brand1-surface-hover",
-      "--fds-semantic-surface-first-light-active": "--ds-color-brand1-surface-active",
-      "--fds-semantic-surface-first-dark": "[delete]",
-      "--fds-semantic-surface-second-light": "--ds-color-brand2-surface-default",
-      "--fds-semantic-surface-second-light-hover": "--ds-color-brand2-surface-hover",
-      "--fds-semantic-surface-second-light-active": "--ds-color-brand2-surface-active",
-      "--fds-semantic-surface-second-dark": "[delete]",
-      "--fds-semantic-surface-third-light": "--ds-color-brand3-surface-default",
-      "--fds-semantic-surface-third-light-hover": "--ds-color-brand3-surface-hover",
-      "--fds-semantic-surface-third-light-active": "--ds-color-brand3-surface-active",
-      "--fds-semantic-surface-third-dark": "[delete]",
-      "--fds-semantic-surface-action-first-subtle": "--ds-color-accent-surface-default",
-      "--fds-semantic-surface-action-first-subtle-hover": "--ds-color-accent-surface-hover",
-      "--fds-semantic-surface-action-first-default": "--ds-color-accent-base-default",
-      "--fds-semantic-surface-action-first-hover": "--ds-color-accent-base-hover",
-      "--fds-semantic-surface-action-first-active": "--ds-color-accent-base-active",
-      "--fds-semantic-surface-action-first-no_fill": "--ds-color-accent-background-default",
-      "--fds-semantic-surface-action-first-no_fill-hover": "--ds-color-accent-surface-default",
-      "--fds-semantic-surface-action-first-no_fill-active": "--ds-color-accent-surface-hover",
-      "--fds-semantic-surface-action-second-subtle": "--ds-color-neutral-surface-default",
-      "--fds-semantic-surface-action-second-subtle-hover": "--ds-color-neutral-surface-hover",
-      "--fds-semantic-surface-action-second-default": "--ds-color-neutral-base-default",
-      "--fds-semantic-surface-action-second-hover": "--ds-color-neutral-base-hover",
-      "--fds-semantic-surface-action-second-active": "--ds-color-neutral-base-active",
-      "--fds-semantic-surface-action-second-no_fill": "--ds-color-neutral-background-default",
-      "--fds-semantic-surface-action-second-no_fill-hover": "--ds-color-neutral-surface-default",
-      "--fds-semantic-surface-action-second-no_fill-active": "--ds-color-neutral-surface-hover",
-      "--fds-semantic-surface-action-subtle": "--ds-color-accent-surface-default",
-      "--fds-semantic-surface-action-subtle-hover": "--ds-color-accent-surface-hover",
-      "--fds-semantic-surface-action-default": "--ds-color-accent-base-default",
-      "--fds-semantic-surface-action-hover": "--ds-color-accent-base-hover",
-      "--fds-semantic-surface-action-active": "--ds-color-accent-base-active",
-      "--fds-semantic-surface-action-no_fill": "--ds-color-accent-background-default",
-      "--fds-semantic-surface-action-no_fill-hover": "--ds-color-accent-surface-default",
-      "--fds-semantic-surface-action-no_fill-active": "--ds-color-accent-surface-hover",
-      "--fds-semantic-surface-action-checked": "--ds-color-accent-base-default",
-      "--fds-semantic-surface-neutral-default": "--ds-color-neutral-background-default",
-      "--fds-semantic-surface-neutral-selected": "[delete]",
-      "--fds-semantic-surface-neutral-subtle": "--ds-color-neutral-background-subtle",
-      "--fds-semantic-surface-neutral-subtle-hover": "--ds-color-neutral-surface-default",
-      "--fds-semantic-surface-neutral-dark": "[delete]",
-      "--fds-semantic-surface-neutral-dark-hover": "[delete]",
-      "--fds-semantic-surface-neutral-inverted": "[delete]",
-      "--fds-semantic-surface-success-subtle": "--ds-color-success-surface-default",
-      "--fds-semantic-surface-success-subtle-hover": "--ds-color-success-surface-hover",
-      "--fds-semantic-surface-success-default": "--ds-color-success-base-default",
-      "--fds-semantic-surface-success-hover": "--ds-color-success-base-hover",
-      "--fds-semantic-surface-success-active": "--ds-color-success-base-active",
-      "--fds-semantic-surface-success-no_fill": "--ds-color-success-background-default",
-      "--fds-semantic-surface-success-no_fill-hover": "--ds-color-success-surface-default",
-      "--fds-semantic-surface-success-no_fill-active": "--ds-color-success-surface-hover",
-      "--fds-semantic-surface-warning-subtle": "--ds-color-warning-surface-default",
-      "--fds-semantic-surface-warning-subtle-hover": "--ds-color-warning-surface-default",
-      "--fds-semantic-surface-warning-default": "--ds-color-warning-surface-default",
-      "--fds-semantic-surface-warning-default-hover": "--ds-color-warning-surface-hover",
-      "--fds-semantic-surface-danger-subtle": "--ds-color-danger-surface-default",
-      "--fds-semantic-surface-danger-subtle-hover": "--ds-color-danger-surface-hover",
-      "--fds-semantic-surface-danger-default": "--ds-color-danger-base-default",
-      "--fds-semantic-surface-danger-hover": "--ds-color-danger-base-hover",
-      "--fds-semantic-surface-danger-active": "--ds-color-danger-base-active",
-      "--fds-semantic-surface-danger-no_fill": "--ds-color-danger-background-default",
-      "--fds-semantic-surface-danger-no_fill-hover": "--ds-color-danger-surface-default",
-      "--fds-semantic-surface-danger-no_fill-active": "--ds-color-danger-surface-hover",
-      "--fds-semantic-surface-info-subtle": "--ds-color-info-surface-default",
-      "--fds-semantic-surface-info-subtle-hover": "[delete]",
-      "--fds-semantic-surface-on_inverted-default": "[delete]",
-      "--fds-semantic-surface-on_inverted-hover": "[delete]",
-      "--fds-semantic-surface-on_inverted-active": "[delete]",
-      "--fds-semantic-surface-on_inverted-no_fill": "[delete]",
-      "--fds-semantic-surface-on_inverted-no_fill-hover": "[delete]",
-      "--fds-semantic-surface-on_inverted-no_fill-active": "[delete]",
-      "--fds-semantic-surface-focus-default": "[delete]",
-      "--fds-semantic-border-first-default": "--ds-color-brand1-base-default",
-      "--fds-semantic-border-first-hover": "--ds-color-brand1-base-hover",
-      "--fds-semantic-border-first-active": "--ds-color-brand1-base-active",
-      "--fds-semantic-border-second-default": "--ds-color-brand2-base-default",
-      "--fds-semantic-border-second-hover": "--ds-color-brand2-base-hover",
-      "--fds-semantic-border-second-active": "--ds-color-brand2-base-active",
-      "--fds-semantic-border-third-default": "--ds-color-brand3-base-default",
-      "--fds-semantic-border-third-hover": "--ds-color-brand3-base-hover",
-      "--fds-semantic-border-third-active": "--ds-color-brand3-base-active",
-      "--fds-semantic-border-action-first-subtle": "--ds-color-accent-border-subtle",
-      "--fds-semantic-border-action-first-subtle-hover": "--ds-color-accent-border-default",
-      "--fds-semantic-border-action-first-default": "--ds-color-accent-base-default",
-      "--fds-semantic-border-action-first-hover": "--ds-color-accent-base-hover",
-      "--fds-semantic-border-action-first-active": "--ds-color-accent-base-active",
-      "--fds-semantic-border-action-second-subtle": "--ds-color-neutral-border-subtle",
-      "--fds-semantic-border-action-second-subtle-hover": "--ds-color-neutral-border-default",
-      "--fds-semantic-border-action-second-default": "--ds-color-neutral-base-default",
-      "--fds-semantic-border-action-second-hover": "--ds-color-neutral-base-hover",
-      "--fds-semantic-border-action-second-active": "--ds-color-neutral-base-active",
-      "--fds-semantic-border-action-subtle": "--ds-color-accent-border-subtle",
-      "--fds-semantic-border-action-subtle-hover": "--ds-color-accent-border-default",
-      "--fds-semantic-border-action-default": "--ds-color-accent-base-default",
-      "--fds-semantic-border-action-hover": "--ds-color-accent-base-hover",
-      "--fds-semantic-border-action-active": "--ds-color-accent-base-active",
-      "--fds-semantic-border-action-dark": "[delete]",
-      "--fds-semantic-border-action-dark-hover": "[delete]",
-      "--fds-semantic-border-info-default": "--ds-color-info-border-strong",
-      "--fds-semantic-border-neutral-default": "--ds-color-neutral-border-strong",
-      "--fds-semantic-border-neutral-subtle": "--ds-color-neutral-border-subtle",
-      "--fds-semantic-border-neutral-strong": "--ds-color-neutral-base-default",
-      "--fds-semantic-border-success-default": "--ds-color-success-border-default",
-      "--fds-semantic-border-success-hover": "[delete]",
-      "--fds-semantic-border-success-active": "[delete]",
-      "--fds-semantic-border-warning-default": "--ds-color-warning-border-default",
-      "--fds-semantic-border-warning-hover": "[delete]",
-      "--fds-semantic-border-warning-active": "[delete]",
-      "--fds-semantic-border-danger-default": "--ds-color-danger-border-default",
-      "--fds-semantic-border-danger-hover": "--ds-color-danger-border-strong",
-      "--fds-semantic-border-danger-active": "--ds-color-danger-border-strong",
-      "--fds-semantic-border-focus-outline": "--ds-color-neutral-text-default",
-      "--fds-semantic-border-focus-boxshadow": "--ds-color-neutral-background-default",
-      "--fds-semantic-border-on_inverted-default": "[delete]",
-      "--fds-semantic-border-input-default": "--ds-color-neutral-border-default",
-      "--fds-semantic-border-input-hover": "--ds-color-accent-border-strong",
-      "--fds-semantic-border-divider-default": "--ds-color-neutral-border-subtle",
-      "--fds-semantic-border-divider-subtle": "--ds-color-neutral-border-subtle",
-      "--fds-semantic-border-divider-strong": "--ds-color-neutral-border-default",
-      "--fds-semantic-text-action-first-default": "--ds-color-accent-base-default",
-      "--fds-semantic-text-action-first-hover": "--ds-color-accent-base-hover",
-      "--fds-semantic-text-action-first-active": "--ds-color-accent-base-active",
-      "--fds-semantic-text-action-first-on_action": "--ds-color-accent-contrast-default",
-      "--fds-semantic-text-action-second-default": "--ds-color-neutral-base-default",
-      "--fds-semantic-text-action-second-hover": "--ds-color-neutral-base-hover",
-      "--fds-semantic-text-action-second-active": "--ds-color-neutral-base-active",
-      "--fds-semantic-text-action-second-on_action": "--ds-color-neutral-contrast-default",
-      "--fds-semantic-text-action-default": "--ds-color-accent-base-default",
-      "--fds-semantic-text-action-hover": "--ds-color-accent-base-hover",
-      "--fds-semantic-text-action-active": "--ds-color-accent-base-active",
-      "--fds-semantic-text-action-on_action": "--ds-color-accent-contrast-default",
-      "--fds-semantic-text-success-default": "--ds-color-success-base-default",
-      "--fds-semantic-text-success-hover": "--ds-color-success-base-default",
-      "--fds-semantic-text-success-active": "--ds-color-success-base-default",
-      "--fds-semantic-text-success-on_success": "--ds-color-success-contrast-default",
-      "--fds-semantic-text-success-on_success_subtle": "--ds-color-success-text-default",
-      "--fds-semantic-text-neutral-default": "--ds-color-neutral-text-default",
-      "--fds-semantic-text-neutral-subtle": "--ds-color-neutral-text-subtle",
-      "--fds-semantic-text-neutral-on_inverted": "--ds-color-neutral-contrast-default",
-      "--fds-semantic-text-warning-default": "[delete]",
-      "--fds-semantic-text-warning-icon_warning": "--ds-color-warning-base-default",
-      "--fds-semantic-text-warning-on_warning": "--ds-color-neutral-text-default",
-      "--fds-semantic-text-danger-default": "--ds-color-danger-text-default",
-      "--fds-semantic-text-danger-hover": "--ds-color-danger-text-default",
-      "--fds-semantic-text-danger-active": "--ds-color-danger-text-default",
-      "--fds-semantic-text-danger-on_danger": "--ds-color-danger-contrast-default",
-      "--fds-semantic-text-danger-on_danger_subtle": "--ds-color-danger-text-default",
-      "--fds-semantic-text-visited-default": "--ds-global-purple-13",
-      "--fds-semantic-background-default": "--ds-color-neutral-background-default",
-      "--fds-semantic-background-subtle": "--ds-color-neutral-background-subtle",
-      "--fds-typography-heading-3xlarge": "[delete]",
-      "--fds-typography-heading-2xlarge": "--ds-typography-heading-2xl",
-      "--fds-typography-heading-xlarge": "--ds-typography-heading-xl",
-      "--fds-typography-heading-large": "--ds-typography-heading-lg",
-      "--fds-typography-heading-medium": "--ds-typography-heading-md",
-      "--fds-typography-heading-small": "--ds-typography-heading-sm",
-      "--fds-typography-heading-xsmall": "--ds-typography-heading-xs",
-      "--fds-typography-heading-xxsmall": "--ds-typography-heading-2xs",
-      "--fds-typography-ingress-large": "--ds-typography-ingress-lg",
-      "--fds-typography-ingress-medium": "--ds-typography-ingress-md",
-      "--fds-typography-ingress-small": "--ds-typography-ingress-sm",
-      "--fds-typography-ingress-xsmall": "--ds-typography-ingress-xs",
-      "--fds-typography-paragraph-large": "--ds-typography-paragraph-lg",
-      "--fds-typography-paragraph-medium": "--ds-typography-paragraph-md",
-      "--fds-typography-paragraph-small": "--ds-typography-paragraph-sm",
-      "--fds-typography-paragraph-xsmall": "--ds-typography-paragraph-xs",
-      "--fds-typography-paragraph-short-large": "--ds-typography-paragraph-short-lg",
-      "--fds-typography-paragraph-short-medium": "--ds-typography-paragraph-short-md",
-      "--fds-typography-paragraph-short-small": "--ds-typography-paragraph-short-sm",
-      "--fds-typography-paragraph-short-xsmall": "--ds-typography-paragraph-short-xs",
-      "--fds-typography-paragraph-long-large": "--ds-typography-paragraph-long-lg",
-      "--fds-typography-paragraph-long-medium": "--ds-typography-paragraph-long-md",
-      "--fds-typography-paragraph-long-small": "--ds-typography-paragraph-long-sm",
-      "--fds-typography-paragraph-long-xsmall": "--ds-typography-paragraph-long-xs",
-      "--fds-typography-label-large": "--ds-typography-label-lg",
-      "--fds-typography-label-medium": "--ds-typography-label-md",
-      "--fds-typography-label-small": "--ds-typography-label-sm",
-      "--fds-typography-label-xsmall": "--ds-typography-label-xs",
-      "--fds-typography-error_message-large": "--ds-typography-error_message-lg",
-      "--fds-typography-error_message-medium": "--ds-typography-error_message-md",
-      "--fds-typography-error_message-small": "--ds-typography-error_message-sm",
-      "--fds-typography-error_message-xsmall": "--ds-typography-error_message-xs",
-      "--fds-typography-interactive-large": "--ds-typography-paragraph-short-lg",
-      "--fds-typography-interactive-medium": "--ds-typography-paragraph-short-md",
-      "--fds-typography-interactive-small": "--ds-typography-paragraph-short-sm",
-      "--fds-border_radius-interactive": "--ds-border-radius-md",
-      "--fds-border_radius-small": "--ds-border-radius-sm",
-      "--fds-border_radius-medium": "--ds-border-radius-md",
-      "--fds-border_radius-large": "--ds-border-radius-lg",
-      "--fds-border_radius-xlarge": "--ds-border-radius-lg",
-      "--fds-border_radius-xxlarge": "--ds-border-radius-lg",
-      "--fds-border_radius-xxxlarge": "--ds-border-radius-lg",
-      "--fds-border_radius-xxxxlarge": "--ds-border-radius-lg",
-      "--fds-border_radius-full": "--ds-border-radius-full",
-      "--fds-base_spacing": "[delete]",
-      "--fds-base_sizing": "[delete]",
-      "--fds-border_width-default": "--ds-border-width-default",
-      "--fds-border_width-active": "--ds-border-width-highlight",
-      "--fds-border_width-tab_focus": "--ds-border-width-highlight",
-      "--fds-shadow-xsmall": "--ds-shadow-xs",
-      "--fds-shadow-small": "--ds-shadow-sm",
-      "--fds-shadow-medium": "--ds-shadow-md",
-      "--fds-shadow-large": "--ds-shadow-lg",
-      "--fds-shadow-xlarge": "--ds-shadow-xl",
-      "--fds-spacing-0": "--ds-size-0",
-      "--fds-spacing-1": "--ds-size-1",
-      "--fds-spacing-2": "--ds-size-2",
-      "--fds-spacing-3": "--ds-size-3",
-      "--fds-spacing-4": "--ds-size-4",
-      "--fds-spacing-5": "--ds-size-5",
-      "--fds-spacing-6": "--ds-size-6",
-      "--fds-spacing-7": "--ds-size-7",
-      "--fds-spacing-8": "--ds-size-8",
-      "--fds-spacing-9": "--ds-size-9",
-      "--fds-spacing-10": "--ds-size-10",
-      "--fds-spacing-11": "--ds-size-11",
-      "--fds-spacing-12": "--ds-size-12",
-      "--fds-spacing-13": "--ds-size-13",
-      "--fds-spacing-14": "--ds-size-14",
-      "--fds-spacing-15": "--ds-size-15",
-      "--fds-spacing-18": "--ds-size-18",
-      "--fds-spacing-22": "--ds-size-22",
-      "--fds-spacing-26": "--ds-size-26",
-      "--fds-spacing-30": "--ds-size-30",
-      "--fds-sizing-0": "--ds-size-0",
-      "--fds-sizing-1": "--ds-size-1",
-      "--fds-sizing-2": "--ds-size-2",
-      "--fds-sizing-3": "--ds-size-3",
-      "--fds-sizing-4": "--ds-size-4",
-      "--fds-sizing-5": "--ds-size-5",
-      "--fds-sizing-6": "--ds-size-6",
-      "--fds-sizing-7": "--ds-size-7",
-      "--fds-sizing-8": "--ds-size-8",
-      "--fds-sizing-9": "--ds-size-9",
-      "--fds-sizing-10": "--ds-size-10",
-      "--fds-sizing-11": "--ds-size-11",
-      "--fds-sizing-12": "--ds-size-12",
-      "--fds-sizing-13": "--ds-size-13",
-      "--fds-sizing-14": "--ds-size-14",
-      "--fds-sizing-15": "--ds-size-15",
-      "--fds-sizing-18": "--ds-size-18",
-      "--fds-sizing-22": "--ds-size-22",
-      "--fds-sizing-26": "--ds-size-26",
-      "--fds-sizing-30": "--ds-size-30",
-      "--fds-opacity-disabled": "--ds-opacity-disabled",
-      "--fds-colors-blue-100": "--ds-global-blue-1",
-      "--fds-colors-blue-200": "--ds-global-blue-2",
-      "--fds-colors-blue-700": "--ds-global-blue-7",
-      "--fds-colors-blue-800": "--ds-global-blue-8",
-      "--fds-colors-blue-900": "--ds-global-blue-9",
-      "--fds-colors-grey-100": "--ds-color-neutral-1",
-      "--fds-colors-grey-200": "--ds-color-neutral-2",
-      "--fds-colors-grey-400": "--ds-color-neutral-4",
-      "--fds-colors-grey-600": "--ds-color-neutral-6",
-      "--fds-colors-grey-700": "--ds-color-neutral-7",
-      "--fds-colors-grey-800": "--ds-color-neutral-8",
-      "--fds-colors-green-200": "--ds-global-green-2",
-      "--fds-colors-green-300": "--ds-global-green-3",
-      "--fds-colors-green-700": "--ds-global-green-7",
-      "--fds-colors-green-800": "--ds-global-green-8",
-      "--fds-colors-green-900": "--ds-global-green-9",
-      "--fds-colors-yellow-100": "--ds-global-yellow-1",
-      "--fds-colors-yellow-200": "--ds-global-yellow-2",
-      "--fds-colors-yellow-300": "--ds-global-yellow-3",
-      "--fds-colors-yellow-500": "--ds-global-yellow-5",
-      "--fds-colors-blue-400": "--ds-global-blue-4",
-      "--fds-colors-grey-300": "--ds-global-grey-3",
-      "--fds-colors-orange-600": "--ds-global-orange-6",
-      "--fds-colors-orange-700": "--ds-global-orange-7",
-      "--fds-colors-orange-800": "--ds-global-orange-8",
-      "--fds-colors-red-800": "--ds-global-red-8",
-      "--fds-colors-purple-700": "--ds-global-purple-7",
-      "--fds-colors-red-100": "--ds-global-red-1",
-      "--fds-colors-red-200": "--ds-global-red-2",
-      "--fds-colors-red-500": "--ds-global-red-5",
-      "--fds-colors-red-600": "--ds-global-red-6",
-      "--fds-colors-red-700": "--ds-global-red-7",
-      "--fds-brand-alt1-100": "--ds-color-brand1-1",
-      "--fds-brand-alt1-200": "--ds-color-brand1-2",
-      "--fds-brand-alt1-300": "--ds-color-brand1-3",
-      "--fds-brand-alt1-400": "--ds-color-brand1-4",
-      "--fds-brand-alt1-500": "--ds-color-brand1-5",
-      "--fds-brand-alt1-600": "--ds-color-brand1-6",
-      "--fds-brand-alt1-700": "--ds-color-brand1-7",
-      "--fds-brand-alt1-800": "--ds-color-brand1-8",
-      "--fds-brand-alt1-900": "--ds-color-brand1-9",
-      "--fds-brand-alt2-100": "--ds-color-brand2-1",
-      "--fds-brand-alt2-200": "--ds-color-brand2-2",
-      "--fds-brand-alt2-300": "--ds-color-brand2-3",
-      "--fds-brand-alt2-400": "--ds-color-brand2-4",
-      "--fds-brand-alt2-500": "--ds-color-brand2-5",
-      "--fds-brand-alt2-600": "--ds-color-brand2-6",
-      "--fds-brand-alt2-700": "--ds-color-brand2-7",
-      "--fds-brand-alt2-800": "--ds-color-brand2-8",
-      "--fds-brand-alt2-900": "--ds-color-brand2-9",
-      "--fds-brand-alt3-100": "--ds-color-brand3-1",
-      "--fds-brand-alt3-200": "--ds-color-brand3-2",
-      "--fds-brand-alt3-300": "--ds-color-brand3-3",
-      "--fds-brand-alt3-400": "--ds-color-brand3-4",
-      "--fds-brand-alt3-500": "--ds-color-brand3-5",
-      "--fds-brand-alt3-600": "--ds-color-brand3-6",
-      "--fds-brand-alt3-700": "--ds-color-brand3-7",
-      "--fds-brand-alt3-800": "--ds-color-brand3-8",
-      "--fds-brand-alt3-900": "--ds-color-brand3-9"
-    })
-  ]
-});
-
-// src/migrations/color-rename-next49.ts
-import * as R5 from "ramda";
-var replace = (oldTemplate, newTemplate, colors2, placeholder = "[color]") => R5.reduce(
-  (acc, color) => {
-    acc[oldTemplate.replace(placeholder, color)] = newTemplate.replace(placeholder, color);
-    return acc;
-  },
-  {},
-  colors2
-);
-var colors = ["neutral", "accent", "brand1", "brand2", "brand3", "danger", "warning", "success", "info"];
-var color_rename_next49_default = (glob2) => {
-  const renames = {
-    // Background
-    "--ds-color-background-subtle": "--ds-color-background-tinted",
-    ...replace("--ds-color-[color]-background-subtle", "--ds-color-[color]-background-tinted", colors),
-    // Surface
-    "--ds-color-surface-default": "--ds-color-surface-tinted",
-    ...replace("--ds-color-[color]-surface-default", "--ds-color-[color]-surface-tinted", colors),
-    // Contrast
-    "--ds-color-contrast-default": "--ds-color-base-contrast-default",
-    "--ds-color-contrast-subtle": "--ds-color-base-contrast-subtle",
-    ...replace("--ds-color-[color]-contrast-default", "--ds-color-[color]-base-contrast-default", colors),
-    ...replace("--ds-color-[color]-contrast-subtle", "--ds-color-[color]-base-contrast-subtle", colors)
-  };
-  console.log(`Renaming ${Object.keys(renames).length} variables`, renames);
-  return runCssCodemod({
-    globPattern: glob2,
-    plugins: [
-      // https://github.com/digdir/designsystemet/issues/3046
-      cssVarRename(renames)
-    ]
-  });
-};
-
-// src/migrations/index.ts
-var migrations_default = {
-  "css-beta-to-v1": beta_to_v1_default,
-  "css-renames-next48-to-next49": color_rename_next49_default
-};
-
-// src/tokens/build.ts
-import pc7 from "picocolors";
-import * as R22 from "ramda";
-
-// src/tokens/process/output/declarations.ts
-import pc5 from "picocolors";
-
-// package.json
-var package_default = {
-  name: "@digdir/designsystemet",
-  version: "1.13.1",
-  description: "CLI for Designsystemet",
-  author: "Designsystemet team",
-  engines: {
-    node: ">=20.20.1"
-  },
-  repository: {
-    type: "git",
-    url: "git+https://github.com/digdir/designsystemet.git"
-  },
-  homepage: "https://github.com/digdir/designsystemet/tree/main/packages/cli",
-  license: "MIT",
-  type: "module",
-  main: "./dist/src/index.js",
-  files: [
-    "./dist/**",
-    "./configs/**"
-  ],
-  bin: "dist/bin/designsystemet.js",
-  exports: {
-    ".": {
-      import: "./dist/src/index.js"
-    },
-    "./color": {
-      import: "./dist/src/colors/index.js"
-    },
-    "./tokens": {
-      import: "./dist/src/tokens/index.js"
-    },
-    "./types": {
-      import: "./dist/src/types.js"
-    }
-  },
-  publishConfig: {
-    access: "public"
-  },
-  scripts: {
-    designsystemet: "tsx ./bin/designsystemet.ts",
-    "designsystemet:inspect": "tsx --inspect-brk ./bin/designsystemet.ts",
-    build: "tsup && pnpm build:types && pnpm build:json-schema",
-    "build:types": "tsc --emitDeclarationOnly --declaration",
-    "build:json-schema": "tsx ./src/scripts/createJsonSchema.ts",
-    types: "tsc --noEmit",
-    "test:tokens-create-options": 'pnpm run designsystemet tokens create -m dominant:"#007682" -n "#003333" -b 99 -o ./temp/options/design-tokens --theme options --clean',
-    "test:tokens-create-config": "pnpm run designsystemet tokens create --config ./configs/test-tokens.config.json",
-    "test:tokens-build": "pnpm run designsystemet tokens build -t ./temp/options/design-tokens -o ./temp/options/build --clean",
-    "test:tokens-build-tailwind": "pnpm run designsystemet tokens build -t ./temp/options/design-tokens -o ./temp/options/build --clean --experimental-tailwind",
-    "test:tokens-build-config": "pnpm run designsystemet tokens build -t ./temp/config/design-tokens -o ./temp/config/build --clean",
-    "test:tokens-build-config:inspect": "pnpm run designsystemet:inspect tokens build -t ./temp/config/design-tokens -o ./temp/config/build --clean",
-    "test:tokens-build-config-tailwind": "pnpm run designsystemet tokens build -t ./temp/config/design-tokens -o ./temp/config/build --clean --experimental-tailwind",
-    "test:tokens-create-and-build-options": "pnpm test:tokens-create-options && pnpm test:tokens-build",
-    "test:tokens-create-and-build-config": "pnpm test:tokens-create-config && pnpm test:tokens-build-config",
-    "test:generate-config-from-tokens": "pnpm run designsystemet generate-config-from-tokens -d ../../design-tokens --dry",
-    test: "node -v && pnpm test:tokens-create-and-build-options && pnpm test:generate-config-from-tokens && pnpm test:tokens-create-and-build-config",
-    "update:preview-tokens": "tsx ./src/scripts/update-preview-tokens.ts",
-    verify: "pnpm test && pnpm update:template && pnpm --filter @internal/digdir update:theme-digdir"
-  },
-  dependencies: {
-    "@commander-js/extra-typings": "^14.0.0",
-    "@digdir/designsystemet-types": "workspace:^",
-    "@tokens-studio/sd-transforms": "2.0.3",
-    "chroma-js": "^3.2.0",
-    "colorjs.io": "^0.6.1",
-    commander: "^14.0.3",
-    "fast-glob": "^3.3.3",
-    hsluv: "^1.0.1",
-    "object-hash": "^3.0.0",
-    picocolors: "^1.1.1",
-    postcss: "^8.5.8",
-    ramda: "^0.32.0",
-    "style-dictionary": "^5.3.3",
-    zod: "^4.3.6",
-    "zod-validation-error": "^5.0.0"
-  },
-  devDependencies: {
-    "@tokens-studio/types": "0.5.2",
-    "@types/chroma-js": "^3.1.2",
-    "@types/node": "^24.12.0",
-    "@types/object-hash": "^3.0.6",
-    "@types/ramda": "^0.31.1",
-    tsup: "^8.5.1",
-    tsx: "^4.21.0",
-    typescript: "^5.9.3"
-  }
-};
-
-// src/tokens/process/platform.ts
-import pc4 from "picocolors";
-import * as R20 from "ramda";
-import StyleDictionary2 from "style-dictionary";
-
-// src/tokens/types.ts
-var colorCategories = {
-  main: "main",
-  support: "support"
-};
-
-// src/tokens/process/configs.ts
-import { register } from "@tokens-studio/sd-transforms";
-import * as R19 from "ramda";
-import StyleDictionary from "style-dictionary";
-
-// src/tokens/utils.ts
-import * as R6 from "ramda";
-var mapToLowerCase = R6.map(R6.toLower);
-var hasAnyTruth = R6.any(R6.equals(true));
-var getType = (token) => (token.$type ?? token.type) || "";
-var getValue = (token) => token.$value ?? token.value;
-var typeEquals = R6.curry(
-  (types, token) => {
-    if (R6.isNil(token)) {
-      return false;
-    }
-    return R6.includes(R6.toLower(getType(token)), R6.map(R6.toLower, Array.isArray(types) ? types : [types]));
-  }
-);
-var pathStartsWithOneOf = R6.curry(
-  (paths, token) => {
-    if (R6.isNil(token)) {
-      return false;
-    }
-    const tokenPath = mapToLowerCase(token.path);
-    const matchPathsStartingWith = R6.map((pathOrString) => {
-      const path5 = typeof pathOrString === "string" ? [pathOrString] : pathOrString;
-      return R6.startsWith(mapToLowerCase(path5), tokenPath);
-    }, paths);
-    return hasAnyTruth(matchPathsStartingWith);
-  }
-);
-function isSemanticToken(token) {
-  return token.filePath.includes("semantic/");
-}
-function isSemanticColorToken(token, color) {
-  return token.filePath.includes("semantic/") && R6.startsWith(["color", color], token.path);
-}
-function isGlobalColorToken(token) {
-  return typeEquals("color", token) && pathStartsWithOneOf(["global"], token);
-}
-function isColorCategoryToken(token, category) {
-  if (!category) {
-    return Object.keys(colorCategories).some(
-      (colorCategory2) => isColorCategoryToken(token, colorCategory2)
-    );
-  }
-  return R6.startsWith(["color", category], token.path);
-}
-var isDigit = (s) => /^\d+$/.test(s);
-function traverseObj(obj, fn) {
-  for (const key in obj) {
-    const prop3 = obj[key];
-    if (prop3 != null) {
-      fn.apply(null, [obj, key, prop3]);
-      if (typeof prop3 === "object") {
-        traverseObj(prop3, fn);
-      }
-    }
-  }
-  return obj;
-}
-function inlineTokens(shouldInline, tokens) {
-  const [inlineableTokens, otherTokens] = R6.partition(shouldInline, tokens);
-  return otherTokens.map((token) => {
-    let transformed = getValue(token.original);
-    for (const ref of inlineableTokens) {
-      const refName = ref.path.join(".");
-      if (typeof transformed === "string") {
-        transformed = transformed.replaceAll(`{${refName}}`, getValue(ref.original));
-      }
-    }
-    const tokenWithInlinedRefs = R6.set(R6.lensPath(["original", "$value"]), transformed, token);
-    return tokenWithInlinedRefs;
-  });
-}
-var sizeMap = {
-  xsmall: "xs",
-  small: "sm",
-  medium: "md",
-  large: "lg",
-  xlarge: "xl"
-};
-function shortSizeName(size2) {
-  return sizeMap[size2] ?? size2;
-}
-var sizeComparator = (size2) => {
-  const sortIndex = Object.entries(sizeMap).findIndex(([key, val]) => key === size2 || val === size2);
-  return sortIndex ?? 0;
-};
-function orderBySize(sizes) {
-  return R6.sortBy(sizeComparator, sizes);
-}
-
-// src/tokens/process/configs/color.ts
-import * as R14 from "ramda";
-
-// src/tokens/process/formats/css/color.ts
-import * as R7 from "ramda";
-import { createPropertyFormatter } from "style-dictionary/utils";
-var prefersColorScheme = (colorScheme2, content) => `
-@media (prefers-color-scheme: ${colorScheme2}) {
-  [data-color-scheme="auto"] ${content}
-}
-`;
-var colorScheme = {
-  name: "ds/css-colorscheme",
-  format: async ({ dictionary, options, platform }) => {
-    const { allTokens } = dictionary;
-    const { outputReferences, usesDtcg } = options;
-    const { selector, colorScheme: colorScheme2, layer } = platform;
-    const colorScheme_ = colorScheme2;
-    const format = createPropertyFormatter({
-      outputReferences,
-      dictionary,
-      format: "css",
-      usesDtcg
-    });
-    const colorSchemeProperty = colorScheme_ === "dark" || colorScheme_ === "light" ? `
-  color-scheme: ${colorScheme_};
-` : "";
-    const filteredAllTokens = allTokens.filter(
-      R7.allPass([
-        R7.anyPass([
-          // Include semantic tokens in the output
-          isSemanticToken,
-          // Include global color tokens
-          isGlobalColorToken
-        ]),
-        // Don't include color category tokens -- they are exported separately
-        (t) => !isColorCategoryToken(t)
-      ])
-    );
-    const formattedMap = filteredAllTokens.map((token) => ({
-      token,
-      formatted: format(token)
-    }));
-    const formattedTokens = formattedMap.map(R7.view(R7.lensProp("formatted"))).join("\n");
-    const content = `{
-${formattedTokens}
-${colorSchemeProperty}}
-`;
-    const autoSelectorContent = ["light", "dark"].includes(colorScheme_) ? prefersColorScheme(colorScheme_, content) : "";
-    const body = R7.isNotNil(layer) ? `@layer ${layer} {
-${selector} ${content} ${autoSelectorContent}
-}
-` : `${selector} ${content} ${autoSelectorContent}
-`;
-    return body;
-  }
-};
-var colorCategory = {
-  name: "ds/css-colorcategory",
-  format: async ({ dictionary, file, options, platform }) => {
-    const { outputReferences, usesDtcg } = options;
-    const { selector, layer } = platform;
-    const destination = file.destination;
-    const format = R7.compose(
-      createPropertyFormatter({
-        outputReferences,
-        dictionary,
-        format: "css",
-        usesDtcg
-      }),
-      (token) => ({
-        ...token,
-        name: token.name.replace(/color-\w+-/, "color-"),
-        original: {
-          ...token.original,
-          $value: new RegExp(`color-(${colorCategories.main}|${colorCategories.support})-`).test(token.name) ? token.original.$value : `{${token.path.join(".")}}`
-        }
-      })
-    );
-    const formattedMap = dictionary.allTokens.map((token) => ({
-      token,
-      formatted: format(token)
-    }));
-    buildOptions.buildTokenFormats[destination] = formattedMap;
-    const formattedTokens = formattedMap.map(R7.view(R7.lensProp("formatted"))).join("\n");
-    const content = `{
-${formattedTokens}
-}
-`;
-    const body = R7.isNotNil(layer) ? `@layer ${layer} {
-${selector} ${content}
-}
-` : `${selector} ${content}
-`;
-    return body;
-  }
-};
-
-// src/tokens/process/formats/css/semantic.ts
-import * as R9 from "ramda";
-import { createPropertyFormatter as createPropertyFormatter3 } from "style-dictionary/utils";
-
-// src/tokens/process/formats/css/size.ts
-import * as R8 from "ramda";
-import { createPropertyFormatter as createPropertyFormatter2 } from "style-dictionary/utils";
-var isNumericBorderRadiusToken = (t) => t.path[0] === "border-radius" && isDigit(t.path[1]);
-var isNumericSizeToken = (t) => pathStartsWithOneOf(["size"], t) && isDigit(t.path[1]);
-var isSizeToken = (t) => pathStartsWithOneOf(["size"], t);
-var isInlineTokens = R8.anyPass([isNumericBorderRadiusToken, isNumericSizeToken, isSizeToken]);
-var overrideSizingFormula = (format, token) => {
-  const [name, value] = format(token).replace(/;$/, "").split(": ");
-  let calc;
-  let round;
-  if (token.path[1] === "unit") {
-    calc = `calc(1rem * ${value})`;
-  } else if (value.startsWith("floor")) {
-    calc = value.replace(/^floor\((.*)\)$/, "calc($1)");
-    round = `round(down, ${calc}, 1px)`;
-  } else {
-    calc = value.includes("*") ? `calc(${value})` : value;
-  }
-  return {
-    name,
-    round: round ?? calc,
-    calc
-  };
-};
-var formatSizingTokens = (format, tokens) => R8.reduce(
-  (acc, token) => {
-    const { round, calc, name } = overrideSizingFormula(format, token);
-    return {
-      tokens: [...acc.tokens, token],
-      round: [...acc.round, `${name}: ${round};`],
-      calc: [...acc.calc, `${name}: ${calc};`]
-    };
-  },
-  { tokens: [], round: [], calc: [] },
-  tokens
-);
-var sizingTemplate = ({ round, calc }) => {
-  const usesRounding = round.filter((val, i) => val !== calc[i]);
-  return `
-${calc.join("\n")}
-
-  @supports (width: round(down, .1em, 1px)) {
-  ${usesRounding.join("\n  ")}
-  }`;
-};
-var size = {
-  name: "ds/css-size",
-  format: async ({ dictionary, file, options, platform }) => {
-    const { outputReferences, usesDtcg } = options;
-    const { selector, layer } = platform;
-    const destination = file.destination;
-    const format = createPropertyFormatter2({
-      outputReferences,
-      dictionary,
-      format: "css",
-      usesDtcg
-    });
-    const tokens = inlineTokens(isInlineTokens, dictionary.allTokens);
-    const filteredTokens = R8.reject((token) => R8.equals(["_size", "mode-font-size"], token.path), tokens);
-    const [sizingTokens, restTokens] = R8.partition(
-      (t) => pathStartsWithOneOf(["_size"], t) && (isDigit(t.path[1]) || t.path[1] === "unit"),
-      filteredTokens
-    );
-    const formattedSizingTokens = formatSizingTokens(format, sizingTokens);
-    const formattedMap = restTokens.map((token) => ({
-      token,
-      formatted: format(token)
-    }));
-    const formattedSizingMap = formattedSizingTokens.round.map((t, i) => ({
-      token: formattedSizingTokens.tokens[i],
-      formatted: t
-    }));
-    buildOptions.buildTokenFormats[destination] = [...formattedMap, ...formattedSizingMap];
-    const formattedTokens = [formattedMap.map(R8.prop("formatted")).join("\n"), sizingTemplate(formattedSizingTokens)];
-    const content = `${selector} {
-${formattedTokens.join("\n")}
-}
-`;
-    const body = R8.isNotNil(layer) ? `@layer ${layer} {
-${content}
-}
-` : `${content}
-`;
-    return body;
-  }
-};
-
-// src/tokens/process/formats/css/semantic.ts
-var semantic = {
-  name: "ds/css-semantic",
-  format: async ({ dictionary, file, options, platform }) => {
-    const { outputReferences, usesDtcg } = options;
-    const { selector, layer } = platform;
-    const destination = file.destination;
-    const format = createPropertyFormatter3({
-      outputReferences,
-      dictionary,
-      format: "css",
-      usesDtcg
-    });
-    const tokens = inlineTokens(isInlineTokens, dictionary.allTokens);
-    const formattedMap = tokens.map((token) => ({
-      token,
-      formatted: format(token)
-    }));
-    buildOptions.buildTokenFormats[destination] = formattedMap;
-    const formattedTokens = formattedMap.map(R9.prop("formatted")).join("\n");
-    const content = `${selector} {
-${formattedTokens}
-}
-`;
-    const body = R9.isNotNil(layer) ? `@layer ${layer} {
-${content}
-}
-` : `${content}
-`;
-    return body;
-  }
-};
-
-// src/tokens/process/formats/css/size-mode.ts
-import * as R11 from "ramda";
-import { createPropertyFormatter as createPropertyFormatter4 } from "style-dictionary/utils";
-
-// src/tokens/process/transformers.ts
-import { checkAndEvaluateMath } from "@tokens-studio/sd-transforms";
-import * as R10 from "ramda";
-var isPx = R10.test(/\b\d+px\b/g);
-var sizeRem = {
-  name: "ds/size/toRem",
-  type: "value",
-  transitive: true,
-  filter: (token) => {
-    const hasWantedType = typeEquals(["dimension", "fontsize"], token);
-    const hasWantedPath = pathStartsWithOneOf([
-      "border-radius",
-      "font-size"
-      /*, ['_size', 'mode-font-size']*/
-    ], token);
-    return hasWantedType && hasWantedPath;
-  },
-  transform: (token, config) => {
-    const value = getValue(token);
-    if (isPx(value)) {
-      const baseFont = config.basePxFontSize || 16;
-      const size2 = parseInt(value, 10);
-      if (size2 === 0) {
-        return "0";
-      }
-      return `${size2 / baseFont}rem`;
-    }
-    return value;
-  }
-};
-var typographyName = {
-  name: "name/typography",
-  type: "name",
-  transitive: true,
-  // expanded tokens have different type so we match on path instead
-  filter: (token) => pathStartsWithOneOf(["typography"], token),
-  transform: (token) => {
-    return token.name.replace("-typography", "");
-  }
-};
-var resolveMath = {
-  name: "ds/resolveMath",
-  type: "value",
-  transitive: true,
-  filter: (token) => {
-    const isValidValue = ["string", "object"].includes(typeof getValue(token));
-    const isTokenOfInterest = !pathStartsWithOneOf(["border-radius"], token);
-    return isValidValue && isTokenOfInterest;
-  },
-  transform: (token, platformCfg) => checkAndEvaluateMath(token, platformCfg.mathFractionDigits)
-};
-var unitless = {
-  name: "ds/unitless",
-  type: "value",
-  transitive: true,
-  filter: (token) => pathStartsWithOneOf(["size", "_size"], token),
-  transform: (token) => parseInt(getValue(token), 10)
-};
-
-// src/tokens/process/configs/shared.ts
-var prefix = "ds";
-var basePxFontSize = 16;
-var dsTransformers = [
-  "name/kebab",
-  resolveMath.name,
-  "ts/size/px",
-  sizeRem.name,
-  unitless.name,
-  "ts/typography/fontWeight",
-  typographyName.name,
-  "ts/color/modifiers",
-  "ts/color/css/hexrgba",
-  "ts/size/lineheight",
-  "shadow/css/shorthand"
-];
-
-// src/tokens/process/formats/css/size-mode.ts
-var formatBaseSizeToken = (size2) => (token) => ({
-  ...token,
-  originalName: token.name,
-  name: `${token.name}--${shortSizeName(size2)}`,
-  $value: token.$value / basePxFontSize
-});
-var sizeMode = {
-  name: "ds/css-size-mode",
-  format: async ({ dictionary, file, options, platform }) => {
-    const { outputReferences, usesDtcg } = options;
-    const { selector, layer, size: size2 } = platform;
-    const destination = file.destination;
-    const format = createPropertyFormatter4({
-      outputReferences,
-      dictionary,
-      format: "css",
-      usesDtcg
-    });
-    const sizeSpecificTokens = dictionary.allTokens.map(formatBaseSizeToken(size2));
-    const sizeSpecificVariables = sizeSpecificTokens.map(format).join("\n");
-    const formattedMap = sizeSpecificTokens.map((token) => ({
-      token,
-      formatted: format({
-        ...token,
-        // Remove the `--<size>` suffix for the token listing, since that is the only token we actually use
-        name: token.originalName
-      })
-    }));
-    buildOptions.buildTokenFormats[destination] = formattedMap;
-    const content = `${selector} /* ${size2} */ {
-${sizeSpecificVariables}
-}`;
-    const body = wrapInLayer(content, layer);
-    const sizes = orderBySize(buildOptions?.sizeModes ?? []).map(shortSizeName);
-    const defaultSize = shortSizeName(buildOptions?.defaultSize ?? "");
-    const sizingToggles = `:root, [data-size] {
-  --ds-size: var(--ds-size--${defaultSize});
-${sizes.map((size3) => `  --ds-size--${size3}: var(--ds-size,);`).join("\n")}
-  --ds-size-mode-font-size:
-${sizes.map((size3) => `    var(--ds-size--${size3}, var(--ds-size-mode-font-size--${size3}))`).join("\n")};
-}`;
-    const sizingHelpers = sizes.map((size3) => `[data-size='${size3}'] { --ds-size: var(--ds-size--${size3}); }`).join("\n");
-    const sharedContent = `${sizingToggles}
-
-${sizingHelpers}`;
-    const sharedBody = shortSizeName(size2) === R11.last(sizes) ? `
-${wrapInLayer(sharedContent, layer)}` : "";
-    return body + sharedBody;
-  }
-};
-function wrapInLayer(content, layer) {
-  return R11.isNotNil(layer) ? `@layer ${layer} {
-${content}
-}
-` : `${content}
-`;
-}
-
-// src/tokens/process/formats/css/typography.ts
-import * as R12 from "ramda";
-import { createPropertyFormatter as createPropertyFormatter5 } from "style-dictionary/utils";
-var typographyFontFamilyPredicate = R12.allPass([
-  R12.pathSatisfies(R12.includes("typography"), ["path"]),
-  R12.pathSatisfies(R12.includes("fontFamily"), ["path"])
-]);
-var typography = {
-  name: "ds/css-typography",
-  format: async ({ dictionary, file, options, platform }) => {
-    const { outputReferences, usesDtcg } = options;
-    const { selector, layer } = platform;
-    const destination = file.destination;
-    const format = createPropertyFormatter5({
-      outputReferences,
-      dictionary,
-      format: "css",
-      usesDtcg
-    });
-    const filteredTokens = R12.reject(typographyFontFamilyPredicate, dictionary.allTokens);
-    const formattedMap = filteredTokens.map((token) => ({
-      token,
-      formatted: format(token)
-    }));
-    buildOptions.buildTokenFormats[destination] = formattedMap;
-    const formattedTokens = formattedMap.map(R12.view(R12.lensProp("formatted"))).join("\n");
-    const content = selector ? `${selector} {
-${formattedTokens}
-}` : formattedTokens;
-    const body = R12.isNotNil(layer) ? `@layer ${layer} {
-${content}
-}` : content;
-    return body;
-  }
-};
-
-// src/tokens/process/formats/css/type-scale.ts
-import * as R13 from "ramda";
-import { createPropertyFormatter as createPropertyFormatter6 } from "style-dictionary/utils";
-var isTypographyFontFamilyToken = R13.allPass([
-  R13.pathSatisfies(R13.includes("typography"), ["path"]),
-  R13.pathSatisfies(R13.includes("fontFamily"), ["path"])
-]);
-var formatTypographySizeToken = (format, token) => {
-  const [name, value] = format(token).replace(/;$/, "").split(": ");
-  let calc;
-  let round;
-  if (R13.startsWith(["font-size"], token.path)) {
-    calc = `calc(${value} * var(--_ds-font-size-factor))`;
-    round = `round(${calc}, 1px)`;
-  } else {
-    calc = value;
-  }
-  return { name, calc, round: round ?? calc };
-};
-var formatTypographySizeTokens = (format, tokens) => R13.reduce(
-  (acc, token) => {
-    const { name, calc, round } = formatTypographySizeToken(format, token);
-    acc.tokens.push(token);
-    acc.calc.push(`${name}: ${calc};`);
-    acc.round.push(`${name}: ${round};`);
-    return acc;
-  },
-  { tokens: [], calc: [], round: [] },
-  tokens
-);
-var typeScale = {
-  name: "ds/css-type-scale",
-  format: async ({ dictionary, file, options, platform }) => {
-    const { outputReferences, usesDtcg } = options;
-    const { selector, layer } = platform;
-    const destination = file.destination;
-    const format = createPropertyFormatter6({
-      outputReferences,
-      dictionary,
-      format: "css",
-      usesDtcg
-    });
-    const filteredTokens = R13.reject(R13.anyPass([isTypographyFontFamilyToken]), dictionary.allTokens);
-    const formattedTokens = formatTypographySizeTokens(format, filteredTokens);
-    const formattedMap = formattedTokens.round.map((t, i) => ({
-      token: formattedTokens.tokens[i],
-      formatted: t
-    }));
-    buildOptions.buildTokenFormats[destination] = formattedMap;
-    const sizeFactor = `  --_ds-font-size-factor: calc(var(--ds-size-mode-font-size) / (var(--ds-size-base) / ${basePxFontSize}));`;
-    const content = `${selector} {
-${sizeFactor}${sizingTemplate(formattedTokens)}
-}`;
-    const body = R13.isNotNil(layer) ? `@layer ${layer} {
-${content}
-}` : content;
-    return body;
-  }
-};
-
-// src/tokens/process/formats/css.ts
-var formats = {
-  colorScheme,
-  colorCategory,
-  semantic,
-  sizeMode,
-  size,
-  typography,
-  typeScale
-};
-
-// src/tokens/process/configs/color.ts
-var colorSchemeVariables = ({ "color-scheme": colorScheme2 = "light", theme }) => {
-  const selector = `${colorScheme2 === "light" ? ":root, " : ""}[data-color-scheme="${colorScheme2}"]`;
-  const layer = `ds.theme.color-scheme.${colorScheme2}`;
-  return {
-    preprocessors: ["tokens-studio"],
-    platforms: {
-      css: {
-        // custom
-        colorScheme: colorScheme2,
-        theme,
-        selector,
-        layer,
-        //
-        prefix,
-        buildPath: `${theme}/`,
-        transforms: dsTransformers,
-        files: [
-          {
-            destination: `color-scheme/${colorScheme2}.css`,
-            format: formats.colorScheme.name,
-            filter: (token) => typeEquals("color", token) && !R14.startsWith(["global"], token.path)
-          }
-        ],
-        options: {
-          outputReferences: false
-        }
-      }
-    }
-  };
-};
-var colorCategoryVariables = (opts) => ({ "color-scheme": colorScheme2, theme, ...permutation }) => {
-  const category = opts.category;
-  const color = category === "builtin" ? opts.color : permutation[`${category}-color`];
-  if (!color) {
-    throw new Error(
-      category === "builtin" ? `Missing color for built-in color ${opts.color}` : `Missing color for category ${category}`
-    );
-  }
-  const layer = `ds.theme.color`;
-  const isRootColor = color === buildOptions?.defaultColor;
-  const selector = isRootColor ? `:root, [data-color-scheme], [data-color="${color}"]` : `[data-color="${color}"], [data-color-scheme][data-color="${color}"]`;
-  const config = {
-    preprocessors: ["tokens-studio"],
-    platforms: {
-      css: {
-        // custom
-        colorScheme: colorScheme2,
-        theme,
-        selector,
-        layer,
-        //
-        prefix,
-        buildPath: `${theme}/`,
-        transforms: dsTransformers,
-        files: [
-          {
-            destination: `color/${color}.css`,
-            format: formats.colorCategory.name,
-            filter: (token) => category === "builtin" ? isSemanticColorToken(token, color) : isColorCategoryToken(token, category)
-          }
-        ],
-        options: {
-          outputReferences: true
-        }
-      }
-    }
-  };
-  return config;
-};
-
-// src/tokens/process/configs/semantic.ts
-import * as R15 from "ramda";
-import { outputReferencesFilter } from "style-dictionary/utils";
-var semanticVariables = ({ theme }) => {
-  const selector = `:root`;
-  const layer = `ds.theme.semantic`;
-  return {
-    preprocessors: ["tokens-studio"],
-    platforms: {
-      css: {
-        // custom
-        theme,
-        basePxFontSize,
-        selector,
-        layer,
-        //
-        prefix,
-        buildPath: `${theme}/`,
-        transforms: dsTransformers,
-        files: [
-          {
-            destination: `semantic.css`,
-            format: formats.semantic.name,
-            filter: (token) => {
-              const isUwantedToken = R15.anyPass([R15.includes("primitives/global")])(token.filePath);
-              const isPrivateToken = R15.includes("_", token.path);
-              const unwantedPaths = pathStartsWithOneOf(
-                ["size", "_size", "font-size", "line-height", "letter-spacing"],
-                token
-              );
-              const unwantedTypes = typeEquals(["color", "fontWeight", "fontFamily", "typography"], token);
-              const unwantedTokens = !(unwantedPaths || unwantedTypes || isPrivateToken || isUwantedToken);
-              return unwantedTokens;
-            }
-          }
-        ],
-        options: {
-          outputReferences: (token, options) => {
-            const include = pathStartsWithOneOf(["border-radius"], token);
-            return include && outputReferencesFilter(token, options);
-          }
-        }
-      }
-    }
-  };
-};
-
-// src/tokens/process/configs/size.ts
-import * as R16 from "ramda";
-import { outputReferencesFilter as outputReferencesFilter2 } from "style-dictionary/utils";
-var sizeVariables = ({ theme }) => {
-  const selector = `:root, [data-size]`;
-  const layer = `ds.theme.size`;
-  return {
-    preprocessors: ["tokens-studio"],
-    platforms: {
-      css: {
-        // custom
-        theme,
-        basePxFontSize,
-        selector,
-        layer,
-        //
-        prefix,
-        buildPath: `${theme}/`,
-        transforms: dsTransformers,
-        files: [
-          {
-            destination: `size.css`,
-            format: formats.size.name,
-            filter: (token) => {
-              const isUwantedToken = R16.anyPass([R16.includes("primitives/global")])(token.filePath);
-              const isPrivateToken = R16.includes("_", token.path);
-              return pathStartsWithOneOf(["size", "_size"], token) && !(isUwantedToken || isPrivateToken);
-            }
-          }
-        ],
-        options: {
-          outputReferences: (token, options) => {
-            const isWantedSize = pathStartsWithOneOf(["size", "_size"], token) && (isDigit(token.path[1]) || token.path[1] === "unit");
-            return isWantedSize && outputReferencesFilter2(token, options);
-          }
-        }
-      }
-    }
-  };
-};
-
-// src/tokens/process/configs/size-mode.ts
-import * as R17 from "ramda";
-var sizeModeVariables = ({ theme, size: size2 }) => {
-  const selector = `:root`;
-  const layer = `ds.theme.size-mode`;
-  return {
-    preprocessors: ["tokens-studio"],
-    platforms: {
-      css: {
-        // custom
-        size: size2,
-        theme,
-        basePxFontSize,
-        selector,
-        layer,
-        //
-        prefix,
-        buildPath: `${theme}/`,
-        transforms: dsTransformers,
-        files: [
-          {
-            destination: `size-mode/${size2}.css`,
-            format: formats.sizeMode.name,
-            filter: (token) => {
-              return R17.equals(["_size", "mode-font-size"], token.path);
-            }
-          }
-        ]
-      }
-    }
-  };
-};
-
-// src/tokens/process/configs/type-scale.ts
-var typeScaleVariables = ({ theme }) => {
-  const selector = ":root, [data-size]";
-  const layer = `ds.theme.type-scale`;
-  return {
-    usesDtcg: true,
-    preprocessors: ["tokens-studio"],
-    expand: {
-      include: ["typography"]
-    },
-    platforms: {
-      css: {
-        prefix,
-        selector,
-        layer,
-        buildPath: `${theme}/`,
-        basePxFontSize,
-        transforms: [
-          "name/kebab",
-          "ts/size/px",
-          sizeRem.name,
-          "ts/size/lineheight",
-          "ts/typography/fontWeight",
-          typographyName.name
-        ],
-        files: [
-          {
-            destination: `type-scale.css`,
-            format: formats.typeScale.name,
-            filter: (token) => {
-              const included = typeEquals(["typography", "dimension", "fontsize"], token);
-              if (/primitives\/modes\/typography\/(primary|secondary)/.test(token.filePath)) return false;
-              return included && !pathStartsWithOneOf(["spacing", "sizing", "size", "border-width", "border-radius"], token) && (pathStartsWithOneOf(["font-size"], token) || token.path.includes("fontSize"));
-            }
-          }
-        ],
-        options: {
-          outputReferences: (token) => pathStartsWithOneOf(["typography"], token) && token.path.includes("fontSize")
-        }
-      }
-    }
-  };
-};
-
-// src/tokens/process/configs/typography.ts
-import { expandTypesMap } from "@tokens-studio/sd-transforms";
-var typographyVariables = ({ theme, typography: typography2 }) => {
-  const selector = `${typography2 === "primary" ? ":root, " : ""}[data-typography="${typography2}"]`;
-  const layer = `ds.theme.typography.${typography2}`;
-  return {
-    usesDtcg: true,
-    preprocessors: ["tokens-studio"],
-    expand: {
-      include: ["typography"],
-      typesMap: { ...expandTypesMap, typography: { ...expandTypesMap.typography, letterSpacing: "dimension" } }
-    },
-    platforms: {
-      css: {
-        prefix,
-        typography: typography2,
-        selector,
-        layer,
-        buildPath: `${theme}/`,
-        basePxFontSize,
-        transforms: [
-          "name/kebab",
-          "ts/size/px",
-          sizeRem.name,
-          "ts/size/lineheight",
-          "ts/typography/fontWeight",
-          "ts/size/css/letterspacing",
-          typographyName.name
-        ],
-        files: [
-          {
-            destination: `typography/${typography2}.css`,
-            format: formats.typography.name,
-            filter: (token) => {
-              const included = typeEquals(["fontweight", "fontFamily", "lineHeight", "dimension"], token);
-              if (/primitives\/modes\/typography\/(primary|secondary)/.test(token.filePath)) return false;
-              return included && !pathStartsWithOneOf(["spacing", "sizing", "size", "_size", "border-width", "border-radius"], token) && !(pathStartsWithOneOf(["typography"], token) && token.path.includes("fontSize"));
-            }
-          }
-        ]
-      }
-    }
-  };
-};
-
-// ../../node_modules/.pnpm/@tokens-studio+types@0.5.2/node_modules/@tokens-studio/types/dist/constants/BoxShadowTypes.js
-var BoxShadowTypes;
-(function(BoxShadowTypes2) {
-  BoxShadowTypes2["DROP_SHADOW"] = "dropShadow";
-  BoxShadowTypes2["INNER_SHADOW"] = "innerShadow";
-})(BoxShadowTypes || (BoxShadowTypes = {}));
-
-// ../../node_modules/.pnpm/@tokens-studio+types@0.5.2/node_modules/@tokens-studio/types/dist/constants/ColorModifierTypes.js
-var ColorModifierTypes;
-(function(ColorModifierTypes2) {
-  ColorModifierTypes2["LIGHTEN"] = "lighten";
-  ColorModifierTypes2["DARKEN"] = "darken";
-  ColorModifierTypes2["MIX"] = "mix";
-  ColorModifierTypes2["ALPHA"] = "alpha";
-})(ColorModifierTypes || (ColorModifierTypes = {}));
-
-// ../../node_modules/.pnpm/@tokens-studio+types@0.5.2/node_modules/@tokens-studio/types/dist/constants/ColorSpaceTypes.js
-var ColorSpaceTypes;
-(function(ColorSpaceTypes2) {
-  ColorSpaceTypes2["LCH"] = "lch";
-  ColorSpaceTypes2["SRGB"] = "srgb";
-  ColorSpaceTypes2["P3"] = "p3";
-  ColorSpaceTypes2["HSL"] = "hsl";
-})(ColorSpaceTypes || (ColorSpaceTypes = {}));
-
-// ../../node_modules/.pnpm/@tokens-studio+types@0.5.2/node_modules/@tokens-studio/types/dist/constants/Properties.js
-var Properties;
-(function(Properties2) {
-  Properties2["sizing"] = "sizing";
-  Properties2["height"] = "height";
-  Properties2["width"] = "width";
-  Properties2["spacing"] = "spacing";
-  Properties2["verticalPadding"] = "verticalPadding";
-  Properties2["horizontalPadding"] = "horizontalPadding";
-  Properties2["paddingTop"] = "paddingTop";
-  Properties2["paddingRight"] = "paddingRight";
-  Properties2["paddingBottom"] = "paddingBottom";
-  Properties2["paddingLeft"] = "paddingLeft";
-  Properties2["itemSpacing"] = "itemSpacing";
-  Properties2["fill"] = "fill";
-  Properties2["backgroundBlur"] = "backgroundBlur";
-  Properties2["border"] = "border";
-  Properties2["borderTop"] = "borderTop";
-  Properties2["borderRight"] = "borderRight";
-  Properties2["borderBottom"] = "borderBottom";
-  Properties2["borderLeft"] = "borderLeft";
-  Properties2["borderColor"] = "borderColor";
-  Properties2["borderRadius"] = "borderRadius";
-  Properties2["borderRadiusTopLeft"] = "borderRadiusTopLeft";
-  Properties2["borderRadiusTopRight"] = "borderRadiusTopRight";
-  Properties2["borderRadiusBottomRight"] = "borderRadiusBottomRight";
-  Properties2["borderRadiusBottomLeft"] = "borderRadiusBottomLeft";
-  Properties2["borderWidth"] = "borderWidth";
-  Properties2["borderWidthTop"] = "borderWidthTop";
-  Properties2["borderWidthRight"] = "borderWidthRight";
-  Properties2["borderWidthBottom"] = "borderWidthBottom";
-  Properties2["borderWidthLeft"] = "borderWidthLeft";
-  Properties2["boxShadow"] = "boxShadow";
-  Properties2["opacity"] = "opacity";
-  Properties2["fontFamilies"] = "fontFamilies";
-  Properties2["fontWeights"] = "fontWeights";
-  Properties2["fontSizes"] = "fontSizes";
-  Properties2["lineHeights"] = "lineHeights";
-  Properties2["typography"] = "typography";
-  Properties2["composition"] = "composition";
-  Properties2["letterSpacing"] = "letterSpacing";
-  Properties2["paragraphSpacing"] = "paragraphSpacing";
-  Properties2["textCase"] = "textCase";
-  Properties2["dimension"] = "dimension";
-  Properties2["textDecoration"] = "textDecoration";
-  Properties2["asset"] = "asset";
-  Properties2["tokenValue"] = "tokenValue";
-  Properties2["value"] = "value";
-  Properties2["tokenName"] = "tokenName";
-  Properties2["description"] = "description";
-})(Properties || (Properties = {}));
-
-// ../../node_modules/.pnpm/@tokens-studio+types@0.5.2/node_modules/@tokens-studio/types/dist/constants/TokenSetStatus.js
-var TokenSetStatus;
-(function(TokenSetStatus2) {
-  TokenSetStatus2["DISABLED"] = "disabled";
-  TokenSetStatus2["SOURCE"] = "source";
-  TokenSetStatus2["ENABLED"] = "enabled";
-})(TokenSetStatus || (TokenSetStatus = {}));
-
-// ../../node_modules/.pnpm/@tokens-studio+types@0.5.2/node_modules/@tokens-studio/types/dist/constants/TokenTypes.js
-var TokenTypes;
-(function(TokenTypes2) {
-  TokenTypes2["OTHER"] = "other";
-  TokenTypes2["COLOR"] = "color";
-  TokenTypes2["BORDER_RADIUS"] = "borderRadius";
-  TokenTypes2["SIZING"] = "sizing";
-  TokenTypes2["SPACING"] = "spacing";
-  TokenTypes2["TEXT"] = "text";
-  TokenTypes2["TYPOGRAPHY"] = "typography";
-  TokenTypes2["OPACITY"] = "opacity";
-  TokenTypes2["BORDER_WIDTH"] = "borderWidth";
-  TokenTypes2["STROKE_STYLE"] = "strokeStyle";
-  TokenTypes2["BOX_SHADOW"] = "boxShadow";
-  TokenTypes2["FONT_FAMILIES"] = "fontFamilies";
-  TokenTypes2["FONT_WEIGHTS"] = "fontWeights";
-  TokenTypes2["LINE_HEIGHTS"] = "lineHeights";
-  TokenTypes2["FONT_SIZES"] = "fontSizes";
-  TokenTypes2["LETTER_SPACING"] = "letterSpacing";
-  TokenTypes2["PARAGRAPH_SPACING"] = "paragraphSpacing";
-  TokenTypes2["PARAGRAPH_INDENT"] = "paragraphIndent";
-  TokenTypes2["TEXT_DECORATION"] = "textDecoration";
-  TokenTypes2["TEXT_CASE"] = "textCase";
-  TokenTypes2["COMPOSITION"] = "composition";
-  TokenTypes2["DIMENSION"] = "dimension";
-  TokenTypes2["BORDER"] = "border";
-  TokenTypes2["ASSET"] = "asset";
-  TokenTypes2["BOOLEAN"] = "boolean";
-  TokenTypes2["NUMBER"] = "number";
-})(TokenTypes || (TokenTypes = {}));
-
-// ../../node_modules/.pnpm/@tokens-studio+types@0.5.2/node_modules/@tokens-studio/types/dist/constants/BorderValues.js
-var BorderValues;
-(function(BorderValues2) {
-  BorderValues2["BORDER_COLOR"] = "color";
-  BorderValues2["BORDER_WIDTH"] = "width";
-  BorderValues2["BORDER_STYLE"] = "style";
-})(BorderValues || (BorderValues = {}));
-
-// ../../node_modules/.pnpm/@tokens-studio+types@0.5.2/node_modules/@tokens-studio/types/dist/constants/StrokeStyleValues.js
-var StrokeStyleValues;
-(function(StrokeStyleValues2) {
-  StrokeStyleValues2["SOLID"] = "solid";
-  StrokeStyleValues2["DASHED"] = "dashed";
-  StrokeStyleValues2["DOTTED"] = "dotted";
-  StrokeStyleValues2["DOUBLE"] = "double";
-  StrokeStyleValues2["GROOVE"] = "groove";
-  StrokeStyleValues2["RIDGE"] = "ridge";
-  StrokeStyleValues2["OUTSET"] = "outset";
-  StrokeStyleValues2["INSET"] = "inset";
-})(StrokeStyleValues || (StrokeStyleValues = {}));
-
-// ../../node_modules/.pnpm/@tokens-studio+types@0.5.2/node_modules/@tokens-studio/types/dist/constants/BoxShadowValues.js
-var BoxShadowValues;
-(function(BoxShadowValues2) {
-  BoxShadowValues2["TYPE"] = "type";
-  BoxShadowValues2["COLOR"] = "color";
-  BoxShadowValues2["X"] = "x";
-  BoxShadowValues2["Y"] = "y";
-  BoxShadowValues2["BLUR"] = "blur";
-  BoxShadowValues2["SPREAD"] = "spread";
-  BoxShadowValues2["BLEND_MODE"] = "blendMode";
-})(BoxShadowValues || (BoxShadowValues = {}));
-
-// ../../node_modules/.pnpm/@tokens-studio+types@0.5.2/node_modules/@tokens-studio/types/dist/constants/TypographyValues.js
-var TypographyValues;
-(function(TypographyValues2) {
-  TypographyValues2["FONT_FAMILY"] = "fontFamily";
-  TypographyValues2["FONT_WEIGHT"] = "fontWeight";
-  TypographyValues2["LINE_HEIGHT"] = "lineHeight";
-  TypographyValues2["FONT_SIZE"] = "fontSize";
-  TypographyValues2["LETTER_SPACING"] = "letterSpacing";
-  TypographyValues2["PARAGRAPH_SPACING"] = "paragraphSpacing";
-  TypographyValues2["PARAGRAPH_INDENT"] = "paragraphIndent";
-  TypographyValues2["TEXT_DECORATION"] = "textDecoration";
-  TypographyValues2["TEXT_CASE"] = "textCase";
-})(TypographyValues || (TypographyValues = {}));
-
-// src/tokens/process/utils/getMultidimensionalThemes.ts
-import pc3 from "picocolors";
-import * as R18 from "ramda";
-
-// src/tokens/process/utils/kebab-case.ts
-function kebabCase(str) {
-  return str.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
-}
-
-// src/tokens/process/utils/getMultidimensionalThemes.ts
-var getMultidimensionalThemes = (processed$themes, dimensions) => {
-  const verboseLogging = buildOptions?.verbose;
-  const grouped$themes = groupThemes(processed$themes);
-  const permutations = permutateThemes(grouped$themes);
-  const ALL_DEPENDENT_ON = ["theme"];
-  const keys4 = R18.keys(grouped$themes);
-  const nonDependentKeys = keys4.filter((x) => ![...ALL_DEPENDENT_ON, ...dimensions].includes(x));
-  if (verboseLogging) {
-    console.log(pc3.cyan(`\u{1F50E} Finding theme permutations for ${dimensions}`));
-    console.log(pc3.cyan(`   (ignoring permutations for ${nonDependentKeys})`));
-  }
-  return permutations.filter((val) => {
-    const filters = nonDependentKeys.map((x) => val.permutation[x] === grouped$themes[x][0].name);
-    return filters.every((x) => x);
-  });
-};
-var processed = Symbol("Type brand for ProcessedThemeObject");
-function isProcessed(theme) {
-  return Boolean(theme[processed]);
-}
-function processThemeObject(theme) {
-  if (isProcessed(theme)) {
-    return theme;
-  }
-  const result = { ...theme, [processed]: true };
-  if (result.group) {
-    result.group = kebabCase(result.group);
-  }
-  result.name = kebabCase(result.name);
-  return result;
-}
-function groupThemes(themes) {
-  const groups = {};
-  for (const theme of themes) {
-    if (theme.group) {
-      const groupKey = theme.group;
-      groups[groupKey] = [...groups[groupKey] ?? [], theme];
-    } else {
-      throw new Error(
-        `Theme ${theme.name} does not have a group property, which is required for multi-dimensional theming.`
-      );
-    }
-  }
-  return groups;
-}
-var hasUnknownProps = R18.pipe(R18.values, R18.none(R18.equals("unknown")), R18.not);
-function permutateThemes(groups) {
-  const separator = "_";
-  const permutations = cartesian(Object.values(groups));
-  const permutatedThemes = permutations.map((perm) => {
-    const permutatedTheme = perm.reduce(
-      (acc, theme) => {
-        const { group, name, selectedTokenSets } = theme;
-        let updatedPermutation = acc.permutation;
-        if (group) {
-          const groupProp = R18.lensProp(group);
-          updatedPermutation = R18.set(groupProp, name, updatedPermutation);
-        }
-        const updatedName = `${String(acc.name)}${acc ? separator : ""}${name}`;
-        const sets = [...acc.selectedTokenSets, ...filterTokenSets(selectedTokenSets)];
-        return {
-          permutation: updatedPermutation,
-          name: updatedName,
-          selectedTokenSets: sets
-        };
-      },
-      {
-        name: "",
-        selectedTokenSets: [],
-        permutation: {
-          "color-scheme": "unknown",
-          "main-color": "unknown",
-          "support-color": "unknown",
-          theme: "unknown",
-          semantic: "unknown",
-          size: "unknown",
-          typography: "unknown"
-        }
-      }
-    );
-    if (hasUnknownProps(permutatedTheme)) {
-      throw Error(`Theme ${permutatedTheme.name} has unknown props: ${JSON.stringify(permutatedTheme)}`);
-    }
-    const uniqueTokenSets = new Set(permutatedTheme.selectedTokenSets);
-    return { ...permutatedTheme, selectedTokenSets: Array.from(uniqueTokenSets) };
-  });
-  return permutatedThemes;
-}
-function filterTokenSets(tokensets) {
-  return Object.entries(tokensets).filter(([, val]) => val !== TokenSetStatus.DISABLED).sort((a, b) => {
-    if (a[1] === TokenSetStatus.SOURCE && b[1] === TokenSetStatus.ENABLED) {
-      return -1;
-    }
-    if (a[1] === TokenSetStatus.ENABLED && b[1] === TokenSetStatus.SOURCE) {
-      return 1;
-    }
-    return 0;
-  }).map((entry) => entry[0]);
-}
-function cartesian(a) {
-  return a.reduce((a2, b) => a2.flatMap((d) => b.map((e) => [d, e].flat())));
-}
-var getCustomColors = (processed$themes, colorGroups) => processed$themes.filter((x) => {
-  if (!x.group) {
-    return false;
-  }
-  return colorGroups.includes(x.group);
-}).map((x) => x.name);
-
-// src/tokens/process/configs.ts
-void register(StyleDictionary, { withSDBuiltins: false });
-StyleDictionary.registerTransform(sizeRem);
-StyleDictionary.registerTransform(typographyName);
-StyleDictionary.registerTransform(resolveMath);
-StyleDictionary.registerTransform(unitless);
-for (const format of Object.values(formats)) {
-  StyleDictionary.registerFormat(format);
-}
-var configs = {
-  colorSchemeVariables,
-  mainColorVariables: colorCategoryVariables({ category: "main" }),
-  supportColorVariables: colorCategoryVariables({ category: "support" }),
-  neutralColorVariables: colorCategoryVariables({ category: "builtin", color: "neutral" }),
-  successColorVariables: colorCategoryVariables({ category: "builtin", color: "success" }),
-  dangerColorVariables: colorCategoryVariables({ category: "builtin", color: "danger" }),
-  warningColorVariables: colorCategoryVariables({ category: "builtin", color: "warning" }),
-  infoColorVariables: colorCategoryVariables({ category: "builtin", color: "info" }),
-  sizeModeVariables,
-  sizeVariables,
-  typographyVariables,
-  typeScaleVariables,
-  semanticVariables
-};
-var getConfigsForThemeDimensions = (getConfig, processed$themes, dimensions, options) => {
-  const { tokensDir, tokenSets } = options;
-  const permutations = getMultidimensionalThemes(processed$themes, dimensions);
-  return permutations.flatMap(({ selectedTokenSets, permutation }) => {
-    const tokenSource = { source: void 0, tokens: {} };
-    if (tokenSets) {
-      for (const tokenSet of selectedTokenSets) {
-        const tokens = tokenSets.get(tokenSet);
-        if (tokens) {
-          const tokensWithFilePath = traverseObj(tokens, (obj) => {
-            if (Object.hasOwn(obj, `$value`) && !obj.filePath) {
-              obj.filePath = tokenSet;
-            }
-          });
-          tokenSource.tokens = R19.mergeDeepRight(tokenSource.tokens, tokensWithFilePath);
-        }
-      }
-    } else {
-      tokenSource.source = selectedTokenSets.map((x) => `${tokensDir}/${x}.json`);
-    }
-    const configOrConfigs = getConfig(permutation);
-    const configs_ = Array.isArray(configOrConfigs) ? configOrConfigs : [{ config: configOrConfigs }];
-    const configs2 = configs_.map(({ config, permutationOverrides }) => {
-      return {
-        permutation: { ...permutation, ...permutationOverrides },
-        config: {
-          ...config,
-          /** Use official W3C design token format
-          @see https://v4.styledictionary.com/info/dtcg/
-          @see https://design-tokens.github.io/community-group/format/ */
-          usesDtcg: true,
-          log: {
-            ...config?.log,
-            verbosity: buildOptions?.verbose ? "verbose" : "silent"
-          },
-          ...tokenSource
-        }
-      };
-    });
-    return configs2;
-  }).sort();
-};
-
-// src/tokens/process/platform.ts
-var initResult = {
-  formatted: [],
-  tokens: [],
-  permutation: {
-    "color-scheme": "",
-    "main-color": "",
-    "support-color": "",
-    semantic: "",
-    size: "",
-    theme: "",
-    typography: ""
-  }
-};
-var buildOptions = {
-  verbose: false,
-  processed$themes: [],
-  buildTokenFormats: {}
-};
-var sd = new StyleDictionary2();
-var buildConfigs = {
-  typography: { getConfig: configs.typographyVariables, dimensions: ["typography"] },
-  sizeMode: { getConfig: configs.sizeModeVariables, dimensions: ["size"] },
-  size: { getConfig: configs.sizeVariables, dimensions: ["semantic"] },
-  typeScale: { getConfig: configs.typeScaleVariables, dimensions: ["semantic"] },
-  "color-scheme": { getConfig: configs.colorSchemeVariables, dimensions: ["color-scheme"] },
-  "main-color": { getConfig: configs.mainColorVariables, dimensions: ["main-color"] },
-  "support-color": { getConfig: configs.supportColorVariables, dimensions: ["support-color"] },
-  "neutral-color": {
-    getConfig: configs.neutralColorVariables,
-    dimensions: ["semantic"],
-    log: ({ permutation: { theme } }) => `${theme} - neutral`
-  },
-  "success-color": {
-    getConfig: configs.successColorVariables,
-    dimensions: ["semantic"],
-    log: ({ permutation: { theme } }) => `${theme} - success`
-  },
-  "danger-color": {
-    getConfig: configs.dangerColorVariables,
-    dimensions: ["semantic"],
-    log: ({ permutation: { theme } }) => `${theme} - danger`
-  },
-  "warning-color": {
-    getConfig: configs.warningColorVariables,
-    dimensions: ["semantic"],
-    log: ({ permutation: { theme } }) => `${theme} - warning`
-  },
-  "info-color": {
-    getConfig: configs.infoColorVariables,
-    dimensions: ["semantic"],
-    log: ({ permutation: { theme } }) => `${theme} - info`
-  },
-  semantic: { getConfig: configs.semanticVariables, dimensions: ["semantic"] }
-};
-async function processPlatform(options) {
-  const { type, processed$themes } = options;
-  const platform = "css";
-  const tokenSets = type === "format" ? options.tokenSets : void 0;
-  const tokensDir = type === "build" ? options.tokensDir : void 0;
-  const UNSAFE_DEFAULT_COLOR = process.env.UNSAFE_DEFAULT_COLOR ?? "";
-  if (UNSAFE_DEFAULT_COLOR) {
-    console.warn(
-      pc4.yellow(
-        `
-\u26A0\uFE0F UNSAFE_DEFAULT_COLOR is set to ${pc4.blue(UNSAFE_DEFAULT_COLOR)}. This will override the default color.`
-      )
-    );
-  }
-  const UNSAFE_COLOR_GROUPS = Array.from(process.env.UNSAFE_COLOR_GROUPS?.split(",") ?? []);
-  if (UNSAFE_COLOR_GROUPS.length > 0) {
-    console.warn(
-      pc4.yellow(
-        `
-\u26A0\uFE0F UNSAFE_COLOR_GROUPS is set to ${pc4.blue(`[${UNSAFE_COLOR_GROUPS.join(", ")}]`)}. This will override the default color groups.`
-      )
-    );
-  }
-  const colorGroups = UNSAFE_COLOR_GROUPS.length > 0 ? UNSAFE_COLOR_GROUPS : [colorCategories.main, colorCategories.support].map((c) => `${c}-color`);
-  buildOptions = options;
-  buildOptions.defaultColor = UNSAFE_DEFAULT_COLOR;
-  buildOptions.colorGroups = colorGroups;
-  if (!buildOptions.defaultColor) {
-    const customColors = getCustomColors(processed$themes, colorGroups);
-    const firstMainColor = R20.head(customColors);
-    buildOptions.defaultColor = firstMainColor;
-  }
-  if (buildOptions.defaultColor) {
-    console.log(`
-\u{1F3A8} Using ${pc4.blue(buildOptions.defaultColor)} as default color`);
-  }
-  const sizeModes2 = processed$themes.filter((x) => x.group === "size").map((x) => x.name);
-  buildOptions.sizeModes = sizeModes2;
-  if (!buildOptions.defaultSize) {
-    const defaultSize = R20.head(sizeModes2);
-    buildOptions.defaultSize = defaultSize;
-  }
-  if (buildOptions.defaultSize) {
-    console.log(`
-\u{1F4CF} Using ${pc4.blue(buildOptions.defaultSize)} as default size`);
-  }
-  const buildAndSdConfigs = R20.map((buildConfig) => {
-    const sdConfigs = getConfigsForThemeDimensions(buildConfig.getConfig, processed$themes, buildConfig.dimensions, {
-      tokensDir,
-      tokenSets
-    });
-    const unknownConfigs = buildConfig.dimensions.map(
-      (dimension) => sdConfigs.filter((x) => x.permutation[dimension] === "unknown")
-    );
-    for (const unknowns of unknownConfigs) {
-      if (unknowns.length === sdConfigs.length) {
-        buildConfig.enabled = () => false;
-      }
-    }
-    return {
-      buildConfig,
-      sdConfigs
-    };
-  }, buildConfigs);
-  const processedBuilds = {
-    "color-scheme": [initResult],
-    "main-color": [initResult],
-    "support-color": [initResult],
-    "neutral-color": [initResult],
-    "success-color": [initResult],
-    "danger-color": [initResult],
-    "warning-color": [initResult],
-    "info-color": [initResult],
-    semantic: [initResult],
-    typography: [initResult],
-    sizeMode: [initResult],
-    size: [initResult],
-    typeScale: [initResult]
-  };
-  try {
-    for (const [buildName, { buildConfig, sdConfigs }] of R20.toPairs(buildAndSdConfigs)) {
-      if (!(buildConfig.enabled?.() ?? true)) {
-        continue;
-      }
-      if (sdConfigs.length > 0) {
-        console.log(`
-\u{1F371} Building ${pc4.green(buildConfig.name ?? buildName)}`);
-        const results = await Promise.all(
-          sdConfigs.map(async (sdConfig) => {
-            const { config, permutation } = sdConfig;
-            const modes = ["theme", ...buildConfig.dimensions];
-            const modeMessage = modes.map((x) => permutation[x]).join(" - ");
-            const logMessage = R20.isNil(buildConfig.log) ? modeMessage : buildConfig?.log(sdConfig);
-            console.log(logMessage);
-            const sdOptions = { cache: true };
-            const sdExtended = await sd.extend(config);
-            const formatted = await sdExtended.formatPlatform(platform, sdOptions);
-            const tokens = (await sdExtended.getPlatformTokens(platform, sdOptions)).allTokens;
-            const result = {
-              permutation,
-              formatted,
-              tokens
-            };
-            return Promise.resolve(result);
-          })
-        );
-        processedBuilds[buildName] = results;
-      }
-    }
-  } catch (err) {
-    if (err instanceof Error) {
-      err.message = err.message.replace('log.verbosity "verbose" or use ', "");
-    }
-    throw err;
-  }
-  return processedBuilds;
-}
-
-// src/tokens/process/output/declarations.ts
-var defaultFileHeader = `build: v${package_default.version}`;
-var createTypeDeclarationFiles = (processed$themes) => {
-  const colorGroups = buildOptions?.colorGroups || [];
-  const customColors = getCustomColors(processed$themes, colorGroups);
-  const typeDeclaration = createColorTypeDeclaration([...customColors, "neutral"]);
-  return [
-    {
-      output: `/* This file is deprecated and will be removed in a future release. Use types.d.ts instead */
-${typeDeclaration}`,
-      destination: "colors.d.ts"
-    },
-    {
-      output: typeDeclaration,
-      destination: "types.d.ts"
-    }
-  ];
-};
-function createColorTypeDeclaration(colors2) {
-  console.log(`
-\u{1F371} Building ${pc5.green("type declarations")}`);
-  const typeDeclaration = `
-/* ${defaultFileHeader} */
-import type {} from '@digdir/designsystemet-types';
-
-// Augment types based on theme
-declare module '@digdir/designsystemet-types' {
-  export interface ColorDefinitions {
-${colors2.map((color) => `    ${color.includes("-") ? `'${color}'` : color}: never;`).join("\n")}
-  }
-  export interface SeverityColorDefinitions {
-    info: never;
-    success: never;
-    warning: never;
-    danger: never;
-  }
-}
-`.trimStart();
-  return typeDeclaration;
-}
-
-// src/tokens/process/output/tailwind.ts
-var createTailwindCSSFiles = (cssFiles) => {
-  console.log("\n\u{1F371} Creating Tailwind Config");
-  return cssFiles.map((file) => {
-    if (file.destination) {
-      const tailwindConfig = generateTailwind(file.output);
-      const tailwindFile = {
-        destination: file.destination.replace(".css", ".tailwind.css"),
-        output: tailwindConfig
-      };
-      return tailwindFile;
-    }
-    return void 0;
-  }).filter((item) => item !== void 0);
-};
-var generateTailwind = (css) => {
-  const tailwind = ["--font-sans: var(--ds-font-family)"];
-  const tokens = Array.from(new Set(css.match(/--ds-[^:)]+/g)), (m) => m).sort(
-    (a, b) => a.localeCompare(b, void 0, { numeric: true, sensitivity: "base" })
-  );
-  for (const token of tokens) {
-    if (token.startsWith("--ds-color-") && !token.startsWith("--ds-color-focus")) {
-      tailwind.push(`--color-${token.replace("--ds-color-", "")}: var(${token})`);
-    } else if (token.startsWith("--ds-font-weight-")) {
-      tailwind.push(`--font-weight-${token.replace("--ds-font-weight-", "")}: var(${token})`);
-    } else if (token.match(/--ds-border-radius-(sm|md|lg|xl)/)) {
-      tailwind.push(`--radius-${token.replace("--ds-border-radius-", "")}: var(${token})`);
-    } else if (token.match(/--ds-body-(sm|mg|lg)-body-font-size/)) {
-      tailwind.push(`--text-${token.replace("--ds-body-", "").replace("-font-size", "")}: var(${token})`);
-    } else if (token.match(/^--ds-size-\d+$/)) {
-      tailwind.push(`--spacing-${token.replace("--ds-size-", "")}: var(${token})`);
-    }
-  }
-  const dynamicColors = `[data-color] {
-      --color-background-default: var(--ds-color-background-default);
-      --color-background-tinted: var(--ds-color-background-tinted);
-      --color-surface-default: var(--ds-color-surface-default);
-      --color-surface-tinted: var(--ds-color-surface-tinted);
-      --color-surface-hover: var(--ds-color-surface-hover);
-      --color-surface-active: var(--ds-color-surface-active);
-      --color-border-subtle: var(--ds-color-border-subtle);
-      --color-border-default: var(--ds-color-border-default);
-      --color-border-strong: var(--ds-color-border-strong);
-      --color-text-subtle: var(--ds-color-text-subtle);
-      --color-text-default: var(--ds-color-text-default);
-      --color-base-default: var(--ds-color-base-default);
-      --color-base-hover: var(--ds-color-base-hover);
-      --color-base-active: var(--ds-color-base-active);
-      --color-base-contrast-subtle: var(--ds-color-base-contrast-subtle);
-      --color-base-contrast-default: var(--ds-color-base-contrast-default);
-    }`;
-  return `@theme {${tailwind.map((str) => `
-  ${str};`).join("")}
-}
-${dynamicColors}`;
-};
-
-// src/tokens/process/output/theme.ts
-import pc6 from "picocolors";
-import * as R21 from "ramda";
-var defaultFileHeader2 = `build: v${package_default.version}`;
-var getFileNameWithoutExtension = (path5) => {
-  const pathSegments = path5.split("/");
-  return pathSegments[pathSegments.length - 1].split(".").slice(0, -1).join(".");
-};
-var createThemeCSSFiles = ({
-  processedBuilds,
-  fileHeader = defaultFileHeader2
-}) => {
-  const groupedByTheme = {};
-  for (const [_, buildResults] of Object.entries(processedBuilds)) {
-    for (const buildResult of buildResults) {
-      const themeName = buildResult.permutation.theme;
-      const newOutputs = buildResult.formatted;
-      if (R21.isNotEmpty(newOutputs)) {
-        const currentOutputs = groupedByTheme[themeName] ?? [];
-        groupedByTheme[themeName] = R21.concat(currentOutputs, newOutputs);
-      }
-    }
-  }
-  const sortOrder = [
-    "size-mode/",
-    "type-scale",
-    "color-scheme/light",
-    "typography/secondary",
-    "size",
-    "semantic",
-    "color-scheme/dark",
-    "color-scheme/contrast",
-    "typography/primary",
-    "color/"
-  ];
-  const sortByDefinedOrder = R21.sortBy((file) => {
-    const filePath = file.destination || "";
-    const sortIndex = sortOrder.findIndex((sortElement) => {
-      if (sortElement.endsWith("/")) {
-        return filePath.includes(sortElement);
-      }
-      return filePath.includes(`${sortElement}.css`);
-    });
-    if (sortIndex === -1) {
-      console.error(
-        pc6.yellow(`WARNING: CSS section does not have a defined sort order: ${filePath.replace(".css", "")}`)
-      );
-      console.log(
-        pc6.dim(
-          `
-The section will currently be added to the end of the entry file, but the exact
-order may change due to nondeterminism.`.trim()
-        )
-      );
-      return Infinity;
-    }
-    return sortIndex;
-  });
-  const header = `@charset "UTF-8";
-/*
-${fileHeader}
-*/
-
-`;
-  const sortAlphabetically = R21.sort(R21.ascend((x) => x.destination || ""));
-  const sortBySize = R21.sortBy(
-    R21.pipe((s) => getFileNameWithoutExtension(s.destination ?? ""), sizeComparator)
-  );
-  const pickOutputs = R21.map(R21.view(R21.lensProp("output")));
-  const themeCSSFile = R21.pipe(
-    sortAlphabetically,
-    sortBySize,
-    sortByDefinedOrder,
-    pickOutputs,
-    R21.join("\n"),
-    (content) => header + content
-  );
-  const themeCSSFiles = Object.entries(groupedByTheme).map(([theme, files]) => ({
-    destination: `${theme}.css`,
-    output: themeCSSFile(files)
-  }));
-  return themeCSSFiles;
-};
-
-// src/tokens/build.ts
-var buildTokens = async (options) => {
-  const tokensDir = options.tokensDir;
-  const $themes = JSON.parse(await dsfs.readFile(`${tokensDir}/$themes.json`));
-  const processed$themes = $themes.map(processThemeObject);
-  let $designsystemet;
-  try {
-    const $designsystemetContent = await dsfs.readFile(`${tokensDir}/$designsystemet.jsonc`);
-    $designsystemet = JSON.parse($designsystemetContent);
-  } catch (_error) {
-  }
-  console.log(`
-\u{1F3D7}\uFE0F Start building tokens in ${pc7.green(tokensDir)}`);
-  const processedBuilds = await processPlatform({
-    ...options,
-    tokensDir,
-    type: "build",
-    processed$themes,
-    buildTokenFormats: {}
-  });
-  const fileHeader = R22.join("")([
-    defaultFileHeader2,
-    $designsystemet ? `
-design-tokens: v${$designsystemet.version}` : ""
-  ]);
-  let files = [];
-  const declarationFiles = createTypeDeclarationFiles(processed$themes);
-  const cssFiles = createThemeCSSFiles({ processedBuilds, fileHeader });
-  files = [...declarationFiles, ...cssFiles];
-  if (options.tailwind) {
-    const tailwindFiles = createTailwindCSSFiles(cssFiles);
-    files = files.concat(tailwindFiles.filter(Boolean));
-  }
-  return files;
-};
-
-// src/tokens/create/generators/$designsystemet.ts
-function generate$Designsystemet() {
-  return {
-    name: package_default.name,
-    version: package_default.version
-  };
-}
-
-// src/tokens/create/generators/$metadata.ts
-function generate$Metadata(schemes, themes, colors2, sizeModes2) {
-  return {
-    tokenSetOrder: [
-      "primitives/globals",
-      ...sizeModes2.map((size2) => `primitives/modes/size/${size2}`),
-      "primitives/modes/size/global",
-      ...sizeModes2.map((size2) => `primitives/modes/typography/size/${size2}`),
-      ...themes.map((theme) => `primitives/modes/typography/primary/${theme}`),
-      ...themes.map((theme) => `primitives/modes/typography/secondary/${theme}`),
-      ...schemes.flatMap((scheme) => [...themes.map((theme) => `primitives/modes/color-scheme/${scheme}/${theme}`)]),
-      ...themes.map((theme) => `themes/${theme}`),
-      "semantic/color",
-      ...Object.entries(colors2.main).map(([color]) => `semantic/modes/main-color/${color}`),
-      ...Object.entries(colors2.support).map(([color]) => `semantic/modes/support-color/${color}`),
-      "semantic/style"
-    ]
-  };
-}
-
-// src/tokens/create/generators/$themes.ts
-var capitalize = (word) => word.charAt(0).toUpperCase() + word.slice(1);
-async function createHash(text, algo = "SHA-1") {
-  const crypto = globalThis.crypto;
-  return Array.from(
-    new Uint8Array(await crypto.subtle.digest(algo, new TextEncoder().encode(text))),
-    (byte) => byte.toString(16).padStart(2, "0")
-  ).join("");
-}
-async function generate$Themes(colorSchemes, themes, colors2, sizeModes2) {
-  return [
-    ...generateSizeGroup(sizeModes2),
-    ...await generateThemesGroup(themes),
-    ...generateTypographyGroup(themes),
-    ...generateColorSchemesGroup(colorSchemes, themes),
-    generateSemanticGroup(),
-    ...await generateColorGroup("main", colors2),
-    ...await generateColorGroup("support", colors2)
-  ];
-}
-function generateSizeGroup(_sizes) {
-  return [
-    {
-      id: "8b2c8cc86611a34b135cb22948666779361fd729",
-      name: "medium",
-      $figmaStyleReferences: {},
-      selectedTokenSets: {
-        "primitives/modes/size/medium": TokenSetStatus.SOURCE,
-        "primitives/modes/size/global": TokenSetStatus.ENABLED,
-        "primitives/modes/typography/size/medium": TokenSetStatus.ENABLED
-      },
-      $figmaCollectionId: "VariableCollectionId:36248:20757",
-      $figmaModeId: "41630:1",
-      group: "Size"
-    },
-    {
-      id: "d49b9eebeb48a4f165a74b7261733d0a73370f0e",
-      name: "large",
-      $figmaStyleReferences: {},
-      selectedTokenSets: {
-        "primitives/modes/size/large": TokenSetStatus.SOURCE,
-        "primitives/modes/size/global": TokenSetStatus.ENABLED,
-        "primitives/modes/typography/size/large": TokenSetStatus.ENABLED
-      },
-      $figmaCollectionId: "VariableCollectionId:36248:20757",
-      $figmaModeId: "41630:2",
-      group: "Size"
-    },
-    {
-      id: "fb11567729c298ca37c9da4e3a27716a23480824",
-      name: "small",
-      $figmaStyleReferences: {},
-      selectedTokenSets: {
-        "primitives/modes/size/small": TokenSetStatus.SOURCE,
-        "primitives/modes/size/global": TokenSetStatus.ENABLED,
-        "primitives/modes/typography/size/small": TokenSetStatus.ENABLED
-      },
-      $figmaCollectionId: "VariableCollectionId:36248:20757",
-      $figmaModeId: "41630:3",
-      group: "Size"
-    }
-  ];
-}
-var colorSchemeDefaults = {
-  light: {
-    name: "Light",
-    selectedTokenSets: {},
-    id: "0daa3ca0b427b9349da7e7dc00101b5668972926",
-    $figmaCollectionId: "VariableCollectionId:34811:5472",
-    $figmaModeId: "34811:0"
-  },
-  dark: {
-    name: "Dark",
-    selectedTokenSets: {},
-    id: "9ebd8aed52afbffc17e2666e8b4653a53498b257",
-    $figmaCollectionId: "VariableCollectionId:34811:5472",
-    $figmaModeId: "34811:1"
-  },
-  contrast: {
-    name: "Contrast",
-    selectedTokenSets: {},
-    id: "9ebd8aed52afbffc17e2666e8b4653a53498b123",
-    $figmaCollectionId: "VariableCollectionId:34811:5472",
-    $figmaModeId: "34811:2"
-  }
-};
-function generateColorSchemesGroup(colorSchemes, themes) {
-  return colorSchemes.map(
-    (scheme) => ({
-      ...colorSchemeDefaults[scheme],
-      selectedTokenSets: Object.fromEntries([
-        ...themes.map((theme) => [`primitives/modes/color-scheme/${scheme}/${theme}`, TokenSetStatus.ENABLED])
-      ]),
-      group: "Color scheme"
-    })
-  );
-}
-async function generateThemesGroup(themes) {
-  return Promise.all(
-    themes.map(
-      async (theme, index) => ({
-        id: await createHash(theme),
-        $figmaCollectionId: "VariableCollectionId:36528:61712",
-        $figmaModeId: `40960:${index + 6}`,
-        // Start on 6 in Token Studio and Community file for some reason
-        name: theme,
-        selectedTokenSets: {
-          [`themes/${theme}`]: TokenSetStatus.ENABLED
-        },
-        group: "Theme"
-      })
-    )
-  );
-}
-function generateSemanticGroup() {
-  return {
-    id: "541629445ef90ad5363f9e88f52a1ccb617e6f84",
-    name: "Semantic",
-    selectedTokenSets: {
-      "semantic/style": TokenSetStatus.ENABLED,
-      "semantic/color": TokenSetStatus.ENABLED,
-      "primitives/globals": TokenSetStatus.SOURCE
-    },
-    $figmaCollectionId: "VariableCollectionId:34811:5976",
-    $figmaModeId: "34811:5",
-    group: "Semantic"
-  };
-}
-async function generateColorGroup(group, colors2) {
-  return Promise.all(
-    Object.entries(colors2[group]).map(
-      async ([color]) => ({
-        id: await createHash(`${group}-${color}`),
-        name: color,
-        selectedTokenSets: {
-          [`semantic/modes/${group}-color/${color}`]: TokenSetStatus.ENABLED
-        },
-        group: `${capitalize(group)} color`
-      })
-    )
-  );
-}
-function generateTypographyGroup(themes) {
-  return [
-    {
-      id: "368d753fcac4455f289500eaa42e70dc0a03522f",
-      $figmaCollectionId: "VariableCollectionId:36248:20769",
-      $figmaModeId: "36248:2",
-      name: "Primary",
-      selectedTokenSets: Object.fromEntries(
-        themes.map((theme) => [`primitives/modes/typography/primary/${theme}`, TokenSetStatus.ENABLED])
-      ),
-      group: "Typography"
-    },
-    {
-      id: "264b8bd1d40b364e1ea3acf09e49795ddd4c513c",
-      $figmaCollectionId: "VariableCollectionId:36248:20769",
-      $figmaModeId: "36248:3",
-      name: "Secondary",
-      selectedTokenSets: Object.fromEntries(
-        themes.map((theme) => [`primitives/modes/typography/secondary/${theme}`, TokenSetStatus.ENABLED])
-      ),
-      group: "Typography"
-    }
-  ];
-}
-
-// src/tokens/create/files.ts
-var stringify = (data) => JSON.stringify(data, null, 2);
-var createTokenFiles = async (options) => {
-  const {
-    outDir,
-    tokenSets,
-    theme: { colors: colors2 },
-    themeNames
-  } = options;
-  const $themesPath = "$themes.json";
-  const $metadataPath = "$metadata.json";
-  const $designsystemetPath = "$designsystemet.jsonc";
-  const sizeModes2 = ["small", "medium", "large"];
-  await dsfs.mkdir(outDir);
-  const $themes = await generate$Themes(["dark", "light"], themeNames, colors2, sizeModes2);
-  const $metadata = generate$Metadata(["dark", "light"], themeNames, colors2, sizeModes2);
-  const $designsystemet = generate$Designsystemet();
-  const files = [];
-  files.push({ destination: $themesPath, output: stringify($themes) });
-  files.push({ destination: $metadataPath, output: stringify($metadata) });
-  files.push({ destination: $designsystemetPath, output: stringify($designsystemet) });
-  for (const [set4, tokens] of tokenSets) {
-    const filePath = `${set4}.json`;
-    files.push({ destination: filePath, output: stringify(tokens) });
-  }
-  return files;
-};
-
-// src/tokens/create/generators/primitives/color-scheme.ts
-import * as R23 from "ramda";
-var generateColor = (colorArray, overrides) => {
-  const obj = {};
-  const $type = "color";
-  for (const index in colorArray) {
-    const position = Number(index) + 1;
-    const overrideValue = overrides?.[position];
-    obj[position] = {
-      $type,
-      $value: overrideValue || colorArray[index].hex
-    };
-  }
-  return obj;
-};
-var generateColorScheme = (themeName, colorScheme2, colors2, overrides) => {
-  const createColorOverrides = (colorName) => {
-    if (!overrides?.colors || !(colorName in overrides.colors)) {
-      return void 0;
-    }
-    const colorOverrides = overrides.colors[colorName];
-    const positionOverrides = {};
-    Object.entries(colorOverrides).forEach(([semanticTokenName, modeOverrides]) => {
-      const position = colorMetadata[semanticTokenName].number;
-      if (position) {
-        let overrideValue;
-        if (colorScheme2 === "light" && modeOverrides.light) {
-          overrideValue = modeOverrides.light;
-        } else if (colorScheme2 === "dark" && modeOverrides.dark) {
-          overrideValue = modeOverrides.dark;
-        }
-        if (overrideValue) {
-          positionOverrides[position] = overrideValue;
-        }
-      }
-    });
-    return Object.keys(positionOverrides).length > 0 ? positionOverrides : void 0;
-  };
-  const main = R23.mapObjIndexed(
-    (color, colorName) => generateColor(generateColorScale(color, colorScheme2), createColorOverrides(colorName)),
-    colors2.main
-  );
-  const support = R23.mapObjIndexed(
-    (color, colorName) => generateColor(generateColorScale(color, colorScheme2), createColorOverrides(colorName)),
-    colors2.support
-  );
-  const neutralColorScale = generateColorScale(colors2.neutral, colorScheme2);
-  const neutral = generateColor(neutralColorScale, createColorOverrides("neutral"));
-  const baseColorsWithOverrides = {
-    ...baseColors,
-    ...overrides?.severity
-  };
-  const globalColors = R23.mapObjIndexed(
-    (color, colorName) => generateColor(generateColorScale(color, colorScheme2), createColorOverrides(colorName)),
-    baseColorsWithOverrides
-  );
-  const linkColor = generateColor(generateColorScale(dsLinkColor, colorScheme2));
-  const defaultLinkVisited = linkColor[12];
-  const linkOverride = overrides?.linkVisited?.[colorScheme2] ? { $type: "color", $value: overrides.linkVisited[colorScheme2] } : void 0;
-  const defaultFocusInner = neutralColorScale[0].hex;
-  const defaultFocusOuter = neutralColorScale[10].hex;
-  const focusInnerOverride = overrides?.focus?.inner?.[colorScheme2];
-  const focusOuterOverride = overrides?.focus?.outer?.[colorScheme2];
-  return {
-    [themeName]: {
-      ...main,
-      ...support,
-      neutral,
-      ...globalColors,
-      link: {
-        visited: linkOverride || defaultLinkVisited
-      },
-      focus: {
-        inner: {
-          $type: "color",
-          $value: focusInnerOverride || defaultFocusInner
-        },
-        outer: {
-          $type: "color",
-          $value: focusOuterOverride || defaultFocusOuter
-        }
-      }
-    }
-  };
-};
-
-// src/tokens/create/generators/primitives/globals.ts
-var globals = {
-  "border-width": {
-    "1": {
-      $type: "borderWidth",
-      $value: "1px"
-    },
-    "3": {
-      $type: "borderWidth",
-      $value: "3px"
-    }
-  },
-  shadow: {
-    "100": {
-      $type: "boxShadow",
-      $value: [
-        {
-          color: "rgba(0,0,0,0.16)",
-          x: "0",
-          y: "0",
-          blur: "1",
-          spread: "0"
-        },
-        {
-          x: "0",
-          y: "1",
-          blur: "2",
-          spread: "0",
-          color: "rgba(0,0,0,0.12)"
-        }
-      ]
-    },
-    "200": {
-      $type: "boxShadow",
-      $value: [
-        {
-          color: "rgba(0,0,0,0.15)",
-          x: "0",
-          y: "0",
-          blur: "1",
-          spread: "0"
-        },
-        {
-          color: "rgba(0,0,0,0.12)",
-          x: "0",
-          y: "1",
-          blur: "2",
-          spread: "0"
-        },
-        {
-          x: "0",
-          y: "2",
-          blur: "4",
-          spread: "0",
-          color: "rgba(0,0,0,0.1)"
-        }
-      ]
-    },
-    "300": {
-      $type: "boxShadow",
-      $value: [
-        {
-          color: "rgba(0,0,0,0.14)",
-          x: "0",
-          y: "0",
-          blur: "1",
-          spread: "0"
-        },
-        {
-          color: "rgba(0,0,0,0.12)",
-          x: "0",
-          y: "2",
-          blur: "4",
-          spread: "0"
-        },
-        {
-          x: "0",
-          y: "4",
-          blur: "8",
-          spread: "0",
-          color: "rgba(0,0,0,0.12)"
-        }
-      ]
-    },
-    "400": {
-      $type: "boxShadow",
-      $value: [
-        {
-          color: "rgba(0,0,0,0.13)",
-          x: "0",
-          y: "0",
-          blur: "1",
-          spread: "0"
-        },
-        {
-          color: "rgba(0,0,0,0.13)",
-          x: "0",
-          y: "3",
-          blur: "5",
-          spread: "0"
-        },
-        {
-          x: "0",
-          y: "6",
-          blur: "12",
-          spread: "0",
-          color: "rgba(0,0,0,0.14)"
-        }
-      ]
-    },
-    "500": {
-      $type: "boxShadow",
-      $value: [
-        {
-          color: "rgba(0,0,0,0.12)",
-          x: "0",
-          y: "0",
-          blur: "1",
-          spread: "0"
-        },
-        {
-          color: "rgba(0,0,0,0.16)",
-          x: "0",
-          y: "4",
-          blur: "8",
-          spread: "0"
-        },
-        {
-          x: "0",
-          y: "12",
-          blur: "24",
-          spread: "0",
-          color: "rgba(0,0,0,0.16)"
-        }
-      ]
-    }
-  },
-  opacity: {
-    "30": {
-      $type: "opacity",
-      $value: "30%"
-    }
-  }
-};
-var generateGlobals = () => globals;
-
-// src/tokens/create/generators/primitives/size.ts
-var global = {
-  _size: {
-    "0": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 0)"
-    },
-    "1": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 1)"
-    },
-    "2": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 2)"
-    },
-    "3": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 3)"
-    },
-    "4": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 4)"
-    },
-    "5": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 5)"
-    },
-    "6": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 6)"
-    },
-    "7": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 7)"
-    },
-    "8": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 8)"
-    },
-    "9": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 9)"
-    },
-    "10": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 10)"
-    },
-    "11": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 11)"
-    },
-    "12": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 12)"
-    },
-    "13": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 13)"
-    },
-    "14": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 14)"
-    },
-    "15": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 15)"
-    },
-    "18": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 18)"
-    },
-    "22": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 22)"
-    },
-    "26": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 26)"
-    },
-    "30": {
-      $type: "dimension",
-      $value: "floor({_size.unit} * 30)"
-    },
-    "mode-font-size": {
-      $type: "number",
-      $value: "{size._mode-font-size}"
-    },
-    base: {
-      $type: "number",
-      $value: "{size._base}"
-    },
-    step: {
-      $type: "number",
-      $value: "{size._step}"
-    },
-    unit: {
-      $type: "number",
-      $value: "{_size.step} / {_size.base} * {_size.mode-font-size}"
-    }
-  }
-};
-var sizeModes = {
-  large: {
-    size: {
-      "_mode-font-size": {
-        $type: "dimension",
-        $value: "21"
-      },
-      _base: {
-        $type: "dimension",
-        $value: "18"
-      },
-      _step: {
-        $type: "dimension",
-        $value: "4"
-      }
-    }
-  },
-  medium: {
-    size: {
-      "_mode-font-size": {
-        $type: "dimension",
-        $value: "18"
-      },
-      _base: {
-        $type: "dimension",
-        $value: "18"
-      },
-      _step: {
-        $type: "dimension",
-        $value: "4"
-      }
-    }
-  },
-  small: {
-    size: {
-      "_mode-font-size": {
-        $type: "dimension",
-        $value: "16"
-      },
-      _base: {
-        $type: "dimension",
-        $value: "18"
-      },
-      _step: {
-        $type: "dimension",
-        $value: "4"
-      }
-    }
-  }
-};
-var generateSize = (size2) => sizeModes[size2];
-var generateSizeGlobal = () => global;
-
-// src/tokens/create/generators/primitives/typography.ts
-var generateTypography = (themeName, { fontFamily }) => ({
-  [themeName]: {
-    "font-family": {
-      $type: "fontFamilies",
-      $value: fontFamily
-    },
-    "font-weight": {
-      medium: {
-        $type: "fontWeights",
-        $value: "Medium"
-      },
-      semibold: {
-        $type: "fontWeights",
-        $value: "Semi bold"
-      },
-      regular: {
-        $type: "fontWeights",
-        $value: "Regular"
-      }
-    }
-  }
-});
-var generateFontSizes = (size2) => fontSizes[size2];
-var lineHeights = {
-  sm: {
-    $type: "lineHeights",
-    $value: "130%"
-  },
-  md: {
-    $type: "lineHeights",
-    $value: "150%"
-  },
-  lg: {
-    $type: "lineHeights",
-    $value: "170%"
-  }
-};
-var letterSpacings = {
-  "1": {
-    $type: "letterSpacing",
-    $value: "-1%"
-  },
-  "2": {
-    $type: "letterSpacing",
-    $value: "-0.5%"
-  },
-  "3": {
-    $type: "letterSpacing",
-    $value: "-0.25%"
-  },
-  "4": {
-    $type: "letterSpacing",
-    $value: "-0.15%"
-  },
-  "5": {
-    $type: "letterSpacing",
-    $value: "0%"
-  },
-  "6": {
-    $type: "letterSpacing",
-    $value: "0.15%"
-  },
-  "7": {
-    $type: "letterSpacing",
-    $value: "0.25%"
-  },
-  "8": {
-    $type: "letterSpacing",
-    $value: "0.5%"
-  },
-  "9": {
-    $type: "letterSpacing",
-    $value: "1.5%"
-  }
-};
-var fontSizes = {
-  large: {
-    "line-height": lineHeights,
-    "font-size": {
-      "1": {
-        $type: "fontSizes",
-        $value: "13"
-      },
-      "2": {
-        $type: "fontSizes",
-        $value: "16"
-      },
-      "3": {
-        $type: "fontSizes",
-        $value: "18"
-      },
-      "4": {
-        $type: "fontSizes",
-        $value: "21"
-      },
-      "5": {
-        $type: "fontSizes",
-        $value: "24"
-      },
-      "6": {
-        $type: "fontSizes",
-        $value: "30"
-      },
-      "7": {
-        $type: "fontSizes",
-        $value: "36"
-      },
-      "8": {
-        $type: "fontSizes",
-        $value: "48"
-      },
-      "9": {
-        $type: "fontSizes",
-        $value: "60"
-      },
-      "10": {
-        $type: "fontSizes",
-        $value: "72"
-      }
-    },
-    "letter-spacing": letterSpacings
-  },
-  medium: {
-    "line-height": lineHeights,
-    "font-size": {
-      "1": {
-        $type: "fontSizes",
-        $value: "12"
-      },
-      "2": {
-        $type: "fontSizes",
-        $value: "14"
-      },
-      "3": {
-        $type: "fontSizes",
-        $value: "16"
-      },
-      "4": {
-        $type: "fontSizes",
-        $value: "18"
-      },
-      "5": {
-        $type: "fontSizes",
-        $value: "21"
-      },
-      "6": {
-        $type: "fontSizes",
-        $value: "24"
-      },
-      "7": {
-        $type: "fontSizes",
-        $value: "30"
-      },
-      "8": {
-        $type: "fontSizes",
-        $value: "36"
-      },
-      "9": {
-        $type: "fontSizes",
-        $value: "48"
-      },
-      "10": {
-        $type: "fontSizes",
-        $value: "60"
-      }
-    },
-    "letter-spacing": letterSpacings
-  },
-  small: {
-    "line-height": lineHeights,
-    "font-size": {
-      "1": {
-        $type: "fontSizes",
-        $value: "11"
-      },
-      "2": {
-        $type: "fontSizes",
-        $value: "13"
-      },
-      "3": {
-        $type: "fontSizes",
-        $value: "14"
-      },
-      "4": {
-        $type: "fontSizes",
-        $value: "16"
-      },
-      "5": {
-        $type: "fontSizes",
-        $value: "18"
-      },
-      "6": {
-        $type: "fontSizes",
-        $value: "21"
-      },
-      "7": {
-        $type: "fontSizes",
-        $value: "24"
-      },
-      "8": {
-        $type: "fontSizes",
-        $value: "30"
-      },
-      "9": {
-        $type: "fontSizes",
-        $value: "36"
-      },
-      "10": {
-        $type: "fontSizes",
-        $value: "48"
-      }
-    },
-    "letter-spacing": letterSpacings
-  }
-};
-
-// src/tokens/create/generators/semantic/color.ts
-import * as R24 from "ramda";
-var generateSemanticColors = (colors2, _themeName) => {
-  const mainColorNames = Object.keys(colors2.main);
-  const supportColorNames = Object.keys(colors2.support);
-  const customColors = [...mainColorNames, "neutral", ...supportColorNames];
-  const allColors = [...customColors, ...baseColorNames];
-  const semanticColorTokens = allColors.map((colorName) => [colorName, generateColorScaleTokens(colorName)]);
-  return {
-    ...baseColorTemplate,
-    color: {
-      ...Object.fromEntries(semanticColorTokens),
-      ...baseColorTemplate.color
-    }
-  };
-};
-var baseColorTemplate = {
-  color: {
-    focus: {
-      inner: {
-        $type: "color",
-        $value: "{color.focus.inner-color}"
-      },
-      outer: {
-        $type: "color",
-        $value: "{color.focus.outer-color}"
-      }
-    }
-  },
-  link: {
-    color: {
-      visited: {
-        $type: "color",
-        $value: "{color.link.visited}"
-      }
-    }
-  }
-};
-var generateColorScaleTokens = (colorName) => {
-  const colorScale = {};
-  for (const [colorSemantic, colorNumber] of R24.toPairs(semanticColorMap)) {
-    colorScale[colorSemantic] = {
-      $type: "color",
-      $value: `{color.${colorName}.${colorNumber}}`
-    };
-  }
-  return colorScale;
-};
-
-// src/tokens/create/generators/semantic/color-modes.ts
-var generateColorModes = (colors2, _themeName) => {
-  const mainColorNames = Object.keys(colors2.main);
-  const supportColorNames = Object.keys(colors2.support);
-  const modes = {
-    "main-color": {},
-    "support-color": {}
-  };
-  const categories = [
-    ["main-color", mainColorNames],
-    ["support-color", supportColorNames]
-  ];
-  for (const [colorCategory2, colorNames2] of categories) {
-    for (const colorName of colorNames2) {
-      const category = colorCategory2.replace("-color", "");
-      const customColorTokens = {
-        color: {
-          [category]: generateColorScaleTokens2(colorName)
-        }
-      };
-      modes[colorCategory2][colorName] = customColorTokens;
-    }
-  }
-  return modes;
-};
-var generateColorScaleTokens2 = (colorName) => {
-  const colorScale = {};
-  for (const colorSemantic of semanticColorNames) {
-    colorScale[colorSemantic] = {
-      $type: "color",
-      $value: `{color.${colorName}.${colorSemantic}}`
-    };
-  }
-  return colorScale;
-};
-
-// src/tokens/create/generators/semantic/style.ts
-function generateSemanticStyle() {
-  return {
-    typography: {
-      heading: {
-        "2xl": {
-          $type: "typography",
-          $value: {
-            fontFamily: "{font-family}",
-            fontWeight: "{font-weight.medium}",
-            lineHeight: "{line-height.sm}",
-            fontSize: "{font-size.10}",
-            letterSpacing: "{letter-spacing.1}"
-          }
-        },
-        xl: {
-          $type: "typography",
-          $value: {
-            fontFamily: "{font-family}",
-            fontWeight: "{font-weight.medium}",
-            lineHeight: "{line-height.sm}",
-            fontSize: "{font-size.9}",
-            letterSpacing: "{letter-spacing.1}"
-          }
-        },
-        lg: {
-          $type: "typography",
-          $value: {
-            fontFamily: "{font-family}",
-            fontWeight: "{font-weight.medium}",
-            lineHeight: "{line-height.sm}",
-            fontSize: "{font-size.8}",
-            letterSpacing: "{letter-spacing.2}"
-          }
-        },
-        md: {
-          $type: "typography",
-          $value: {
-            fontFamily: "{font-family}",
-            fontWeight: "{font-weight.medium}",
-            lineHeight: "{line-height.sm}",
-            fontSize: "{font-size.7}",
-            letterSpacing: "{letter-spacing.3}"
-          }
-        },
-        sm: {
-          $type: "typography",
-          $value: {
-            fontFamily: "{font-family}",
-            fontWeight: "{font-weight.medium}",
-            lineHeight: "{line-height.sm}",
-            fontSize: "{font-size.6}",
-            letterSpacing: "{letter-spacing.5}"
-          }
-        },
-        xs: {
-          $type: "typography",
-          $value: {
-            fontFamily: "{font-family}",
-            fontWeight: "{font-weight.medium}",
-            lineHeight: "{line-height.sm}",
-            fontSize: "{font-size.5}",
-            letterSpacing: "{letter-spacing.6}"
-          }
-        },
-        "2xs": {
-          $type: "typography",
-          $value: {
-            fontFamily: "{font-family}",
-            fontWeight: "{font-weight.medium}",
-            lineHeight: "{line-height.sm}",
-            fontSize: "{font-size.4}",
-            letterSpacing: "{letter-spacing.6}"
-          }
-        }
-      },
-      body: {
-        xl: {
-          $type: "typography",
-          $value: {
-            fontFamily: "{font-family}",
-            fontWeight: "{font-weight.regular}",
-            lineHeight: "{line-height.md}",
-            fontSize: "{font-size.6}",
-            letterSpacing: "{letter-spacing.8}"
-          }
-        },
-        lg: {
-          $type: "typography",
-          $value: {
-            fontFamily: "{font-family}",
-            fontWeight: "{font-weight.regular}",
-            lineHeight: "{line-height.md}",
-            fontSize: "{font-size.5}",
-            letterSpacing: "{letter-spacing.8}"
-          }
-        },
-        md: {
-          $type: "typography",
-          $value: {
-            fontFamily: "{font-family}",
-            fontWeight: "{font-weight.regular}",
-            lineHeight: "{line-height.md}",
-            fontSize: "{font-size.4}",
-            letterSpacing: "{letter-spacing.8}"
-          }
-        },
-        sm: {
-          $type: "typography",
-          $value: {
-            fontFamily: "{font-family}",
-            fontWeight: "{font-weight.regular}",
-            lineHeight: "{line-height.md}",
-            fontSize: "{font-size.3}",
-            letterSpacing: "{letter-spacing.7}"
-          }
-        },
-        xs: {
-          $type: "typography",
-          $value: {
-            fontFamily: "{font-family}",
-            fontWeight: "{font-weight.regular}",
-            lineHeight: "{line-height.md}",
-            fontSize: "{font-size.2}",
-            letterSpacing: "{letter-spacing.6}"
-          }
-        },
-        short: {
-          xl: {
-            $type: "typography",
-            $value: {
-              fontFamily: "{font-family}",
-              fontWeight: "{font-weight.regular}",
-              lineHeight: "{line-height.sm}",
-              fontSize: "{font-size.6}",
-              letterSpacing: "{letter-spacing.8}"
-            }
-          },
-          lg: {
-            $type: "typography",
-            $value: {
-              fontFamily: "{font-family}",
-              fontWeight: "{font-weight.regular}",
-              lineHeight: "{line-height.sm}",
-              fontSize: "{font-size.5}",
-              letterSpacing: "{letter-spacing.8}"
-            }
-          },
-          md: {
-            $type: "typography",
-            $value: {
-              fontFamily: "{font-family}",
-              fontWeight: "{font-weight.regular}",
-              lineHeight: "{line-height.sm}",
-              fontSize: "{font-size.4}",
-              letterSpacing: "{letter-spacing.8}"
-            }
-          },
-          sm: {
-            $type: "typography",
-            $value: {
-              fontFamily: "{font-family}",
-              fontWeight: "{font-weight.regular}",
-              lineHeight: "{line-height.sm}",
-              fontSize: "{font-size.3}",
-              letterSpacing: "{letter-spacing.7}"
-            }
-          },
-          xs: {
-            $type: "typography",
-            $value: {
-              fontFamily: "{font-family}",
-              fontWeight: "{font-weight.regular}",
-              lineHeight: "{line-height.sm}",
-              fontSize: "{font-size.2}",
-              letterSpacing: "{letter-spacing.6}"
-            }
-          }
-        },
-        long: {
-          xl: {
-            $type: "typography",
-            $value: {
-              fontFamily: "{font-family}",
-              fontWeight: "{font-weight.regular}",
-              lineHeight: "{line-height.lg}",
-              fontSize: "{font-size.6}",
-              letterSpacing: "{letter-spacing.8}"
-            }
-          },
-          lg: {
-            $type: "typography",
-            $value: {
-              fontFamily: "{font-family}",
-              fontWeight: "{font-weight.regular}",
-              lineHeight: "{line-height.lg}",
-              fontSize: "{font-size.5}",
-              letterSpacing: "{letter-spacing.8}"
-            }
-          },
-          md: {
-            $type: "typography",
-            $value: {
-              fontFamily: "{font-family}",
-              fontWeight: "{font-weight.regular}",
-              lineHeight: "{line-height.lg}",
-              fontSize: "{font-size.4}",
-              letterSpacing: "{letter-spacing.8}"
-            }
-          },
-          sm: {
-            $type: "typography",
-            $value: {
-              fontFamily: "{font-family}",
-              fontWeight: "{font-weight.regular}",
-              lineHeight: "{line-height.lg}",
-              fontSize: "{font-size.3}",
-              letterSpacing: "{letter-spacing.7}"
-            }
-          },
-          xs: {
-            $type: "typography",
-            $value: {
-              fontFamily: "{font-family}",
-              fontWeight: "{font-weight.regular}",
-              lineHeight: "{line-height.lg}",
-              fontSize: "{font-size.2}",
-              letterSpacing: "{letter-spacing.6}"
-            }
-          }
-        }
-      }
-    },
-    opacity: {
-      disabled: {
-        $type: "opacity",
-        $value: "{opacity.30}"
-      }
-    },
-    "border-width": {
-      default: {
-        $type: "borderWidth",
-        $value: "{border-width.1}"
-      },
-      focus: {
-        $type: "borderWidth",
-        $value: "{border-width.3}"
-      }
-    },
-    shadow: {
-      xs: {
-        $type: "boxShadow",
-        $value: "{shadow.100}"
-      },
-      sm: {
-        $type: "boxShadow",
-        $value: "{shadow.200}"
-      },
-      md: {
-        $type: "boxShadow",
-        $value: "{shadow.300}"
-      },
-      lg: {
-        $type: "boxShadow",
-        $value: "{shadow.400}"
-      },
-      xl: {
-        $type: "boxShadow",
-        $value: "{shadow.500}"
-      }
-    },
-    "border-radius": {
-      sm: {
-        $type: "dimension",
-        $value: "{border-radius.1}"
-      },
-      md: {
-        $type: "dimension",
-        $value: "{border-radius.2}"
-      },
-      lg: {
-        $type: "dimension",
-        $value: "{border-radius.3}"
-      },
-      xl: {
-        $type: "dimension",
-        $value: "{border-radius.4}"
-      },
-      default: {
-        $type: "dimension",
-        $value: "{border-radius.5}"
-      },
-      full: {
-        $type: "dimension",
-        $value: "{border-radius.6}"
-      }
-    },
-    size: {
-      "0": {
-        $type: "dimension",
-        $value: "{_size.0}"
-      },
-      "1": {
-        $type: "dimension",
-        $value: "{_size.1}"
-      },
-      "2": {
-        $type: "dimension",
-        $value: "{_size.2}"
-      },
-      "3": {
-        $type: "dimension",
-        $value: "{_size.3}"
-      },
-      "4": {
-        $type: "dimension",
-        $value: "{_size.4}"
-      },
-      "5": {
-        $type: "dimension",
-        $value: "{_size.5}"
-      },
-      "6": {
-        $type: "dimension",
-        $value: "{_size.6}"
-      },
-      "7": {
-        $type: "dimension",
-        $value: "{_size.7}"
-      },
-      "8": {
-        $type: "dimension",
-        $value: "{_size.8}"
-      },
-      "9": {
-        $type: "dimension",
-        $value: "{_size.9}"
-      },
-      "10": {
-        $type: "dimension",
-        $value: "{_size.10}"
-      },
-      "11": {
-        $type: "dimension",
-        $value: "{_size.11}"
-      },
-      "12": {
-        $type: "dimension",
-        $value: "{_size.12}"
-      },
-      "13": {
-        $type: "dimension",
-        $value: "{_size.13}"
-      },
-      "14": {
-        $type: "dimension",
-        $value: "{_size.14}"
-      },
-      "15": {
-        $type: "dimension",
-        $value: "{_size.15}"
-      },
-      "18": {
-        $type: "dimension",
-        $value: "{_size.18}"
-      },
-      "22": {
-        $type: "dimension",
-        $value: "{_size.22}"
-      },
-      "26": {
-        $type: "dimension",
-        $value: "{_size.26}"
-      },
-      "30": {
-        $type: "dimension",
-        $value: "{_size.30}"
-      }
-    }
-  };
-}
-
-// src/tokens/create/generators/themes/theme.ts
-import * as R25 from "ramda";
-var generateTheme = (colors2, themeName, borderRadius) => {
-  const mainColorNames = Object.keys(colors2.main);
-  const supportColorNames = Object.keys(colors2.support);
-  const customColors = [...mainColorNames, "neutral", ...supportColorNames, ...baseColorNames];
-  const themeColorTokens = Object.fromEntries(
-    customColors.map((colorName) => [colorName, generateColorScaleTokens3(colorName, themeName)])
-  );
-  const { color: themeBaseFileColor, ...remainingThemeFile } = generateBase(themeName);
-  const themeFile = {
-    color: {
-      ...themeColorTokens,
-      ...themeBaseFileColor,
-      link: {
-        visited: {
-          $type: "color",
-          $value: `{${themeName}.link.visited}`
-        }
-      },
-      focus: {
-        "inner-color": {
-          $type: "color",
-          $value: `{${themeName}.focus.inner}`
-        },
-        "outer-color": {
-          $type: "color",
-          $value: `{${themeName}.focus.outer}`
-        }
-      }
-    },
-    ...remainingThemeFile
-  };
-  const baseBorderRadius = R25.lensPath(["border-radius", "base", "$value"]);
-  const updatedThemeFile = R25.set(baseBorderRadius, String(borderRadius), themeFile);
-  const token = JSON.parse(
-    JSON.stringify(
-      updatedThemeFile,
-      (key, value) => {
-        if (key === "$value") {
-          return value.replace("<theme>", themeName);
-        }
-        return value;
-      },
-      2
-    )
-  );
-  return token;
-};
-var generateBase = (themeName) => ({
-  color: {},
-  "font-family": {
-    $type: "fontFamilies",
-    $value: `{${themeName}.font-family}`
-  },
-  "font-weight": {
-    medium: {
-      $type: "fontWeights",
-      $value: `{${themeName}.font-weight.medium}`
-    },
-    semibold: {
-      $type: "fontWeights",
-      $value: `{${themeName}.font-weight.semibold}`
-    },
-    regular: {
-      $type: "fontWeights",
-      $value: `{${themeName}.font-weight.regular}`
-    }
-  },
-  "border-radius": {
-    "1": {
-      $type: "dimension",
-      $value: "min({border-radius.base}*0.5,{border-radius.scale})"
-    },
-    "2": {
-      $type: "dimension",
-      $value: "min({border-radius.base},{border-radius.scale}*2)"
-    },
-    "3": {
-      $type: "dimension",
-      $value: "min({border-radius.base}*2,{border-radius.scale}*5)"
-    },
-    "4": {
-      $type: "dimension",
-      $value: "min({border-radius.base}*3,{border-radius.scale}*7)"
-    },
-    "5": {
-      $type: "dimension",
-      $value: "{border-radius.base}"
-    },
-    "6": {
-      $type: "dimension",
-      $value: "9999"
-    },
-    base: {
-      $type: "dimension",
-      $value: "4"
-    },
-    scale: {
-      $type: "dimension",
-      $value: "4"
-    }
-  }
-});
-var generateColorScaleTokens3 = (colorName, themeName) => {
-  const colorScale = {};
-  for (const [_, colorNumber] of R25.toPairs(semanticColorMap)) {
-    colorScale[colorNumber] = {
-      $type: "color",
-      $value: `{${themeName}.${colorName}.${colorNumber}}`
-    };
-  }
-  return colorScale;
-};
-
-// src/tokens/create.ts
-var cliOptions = {
-  outDir: "out-dir",
-  clean: "clean",
-  tailwind: "tailwind",
-  theme: {
-    colors: {
-      main: "main-colors",
-      support: "support-colors",
-      neutral: "neutral-color"
-    },
-    typography: {
-      fontFamily: "font-family"
-    },
-    borderRadius: "border-radius"
-  }
-};
-var createTokens = async (theme) => {
-  const { colors: colors2, typography: typography2, name, borderRadius, overrides } = theme;
-  const colorSchemes = ["light", "dark"];
-  const sizeModes2 = ["small", "medium", "large"];
-  const tokenSets = new Map([
-    ["primitives/globals", generateGlobals()],
-    ...sizeModes2.map((size2) => [`primitives/modes/size/${size2}`, generateSize(size2)]),
-    ["primitives/modes/size/global", generateSizeGlobal()],
-    ...sizeModes2.map((size2) => [
-      `primitives/modes/typography/size/${size2}`,
-      generateFontSizes(size2)
-    ]),
-    [`primitives/modes/typography/primary/${name}`, generateTypography(name, typography2)],
-    [`primitives/modes/typography/secondary/${name}`, generateTypography(name, typography2)],
-    ...colorSchemes.flatMap((scheme) => [
-      [`primitives/modes/color-scheme/${scheme}/${name}`, generateColorScheme(name, scheme, colors2, overrides)]
-    ]),
-    [`themes/${name}`, generateTheme(colors2, name, borderRadius)],
-    ["semantic/color", generateSemanticColors(colors2, name)],
-    // maps out semantic modes, ieg 'semantic/modes/main-color/accent', and 'semantic/modes/support-color/brand1'
-    ...Object.entries(generateColorModes(colors2, name)).flatMap(
-      ([mode, colors3]) => Object.entries(colors3).map(([key, colorSet]) => [`semantic/modes/${mode}/${key}`, colorSet])
-    ),
-    [`semantic/style`, generateSemanticStyle()]
-  ]);
-  return { tokenSets };
-};
-
-// src/tokens/generate-config.ts
-import path2 from "path";
-import pc8 from "picocolors";
-async function readJsonFile(filePath) {
-  try {
-    const content = await dsfs.readFile(filePath);
-    return JSON.parse(content);
-  } catch (err) {
-    throw new Error(`Failed to read token file at ${filePath}: ${err instanceof Error ? err.message : String(err)}`);
-  }
-}
-function extractBaseColor(colorScale) {
-  if ("12" in colorScale && typeof colorScale["12"] === "object" && "$value" in colorScale["12"]) {
-    const token = colorScale["12"];
-    if (token.$type === "color") {
-      return token.$value;
-    }
-  }
-  return null;
-}
-async function discoverThemes(tokensDir) {
-  const lightModePath = path2.join(tokensDir, "themes");
-  try {
-    const files = await dsfs.readdir(lightModePath);
-    const themes = files.filter((file) => file.endsWith(".json")).map((file) => file.replace(".json", ""));
-    return themes;
-  } catch {
-    throw new Error(`Could not find themes. Make sure ${pc8.blue(lightModePath)} exists and contains theme JSON files.`);
-  }
-}
-async function readThemeTokens(tokensDir, themeName) {
-  const themePath = path2.join(tokensDir, "primitives", "modes", "color-scheme", "light", `${themeName}.json`);
-  return readJsonFile(themePath);
-}
-async function readThemeConfig(tokensDir, themeName) {
-  const themeConfigPath = path2.join(tokensDir, "themes", `${themeName}.json`);
-  try {
-    return await readJsonFile(themeConfigPath);
-  } catch {
-    return null;
-  }
-}
-function extractBorderRadius(themeConfig) {
-  if (!themeConfig || !("border-radius" in themeConfig)) {
-    return void 0;
-  }
-  const borderRadius = themeConfig["border-radius"];
-  if ("base" in borderRadius && typeof borderRadius.base === "object" && "$value" in borderRadius.base) {
-    const token = borderRadius.base;
-    return Number(token.$value);
-  }
-  return void 0;
-}
-function extractFontFamily(themeConfig) {
-  if (!themeConfig || !("font-family" in themeConfig)) {
-    return void 0;
-  }
-  const fontFamily = themeConfig["font-family"];
-  if (typeof fontFamily === "object" && "$value" in fontFamily) {
-    const token = fontFamily;
-    const value = token.$value;
-    if (value.startsWith("{") && value.endsWith("}")) {
-      return void 0;
-    }
-    return value;
-  }
-  return void 0;
-}
-async function readTypographyConfig(tokensDir, themeName) {
-  const typographyConfigPath = path2.join(
-    tokensDir,
-    "primitives",
-    "modes",
-    "typography",
-    "primary",
-    `${themeName}.json`
-  );
-  try {
-    return await readJsonFile(typographyConfigPath);
-  } catch {
-    return null;
-  }
-}
-function extractFontFamilyFromPrimitives(typographyConfig, themeName) {
-  if (!typographyConfig) {
-    return void 0;
-  }
-  const themeTypography = typographyConfig[themeName];
-  if (!themeTypography || !("font-family" in themeTypography)) {
-    return void 0;
-  }
-  const fontFamily = themeTypography["font-family"];
-  if (typeof fontFamily === "object" && "$value" in fontFamily) {
-    const token = fontFamily;
-    return token.$value;
-  }
-  return void 0;
-}
-function categorizeColors(themeTokens, themeName) {
-  const main = {};
-  const support = {};
-  let neutral = null;
-  const builtInColors = ["neutral", "info", "success", "warning", "danger"];
-  const specialKeys = ["link"];
-  const themeColors = themeTokens[themeName];
-  if (!themeColors) {
-    return { main, support, neutral };
-  }
-  for (const [colorName, colorValue] of Object.entries(themeColors)) {
-    if (specialKeys.includes(colorName)) {
-      continue;
-    }
-    if (typeof colorValue === "object" && !("$value" in colorValue)) {
-      const baseColor = extractBaseColor(colorValue);
-      if (baseColor) {
-        if (colorName === "neutral") {
-          neutral = baseColor;
-        } else if (builtInColors.includes(colorName)) {
-        } else if (colorName === "accent") {
-          main[colorName] = baseColor;
-        } else {
-          support[colorName] = baseColor;
-        }
-      }
-    }
-  }
-  return { main, support, neutral };
-}
-async function generateConfigFromTokens(options) {
-  const { tokensDir } = options;
-  console.log(`
-Reading tokens from ${pc8.blue(tokensDir)}`);
-  const themes = await discoverThemes(tokensDir);
-  if (themes.length === 0) {
-    throw new Error(`
-No themes found in ${pc8.blue(tokensDir)}`);
-  }
-  console.log(`
-Found ${pc8.green(String(themes.length))} theme(s): ${themes.map((t) => pc8.cyan(t)).join(", ")}`);
-  const config = {
-    outDir: tokensDir,
-    themes: {}
-  };
-  for (const themeName of themes) {
-    console.log(`
-Processing theme ${pc8.cyan(themeName)}...`);
-    const themeTokens = await readThemeTokens(tokensDir, themeName);
-    const themeConfig = await readThemeConfig(tokensDir, themeName);
-    const typographyConfig = await readTypographyConfig(tokensDir, themeName);
-    const { main, support, neutral } = categorizeColors(themeTokens, themeName);
-    if (Object.keys(main).length === 0) {
-      console.warn(pc8.yellow(`
-Warning: No main colors found for theme ${themeName}`));
-    }
-    if (!neutral) {
-      console.warn(pc8.yellow(`
-Warning: No neutral color found for theme ${themeName}`));
-      continue;
-    }
-    const borderRadius = extractBorderRadius(themeConfig);
-    const fontFamily = extractFontFamily(themeConfig) ?? extractFontFamilyFromPrimitives(typographyConfig, themeName);
-    config.themes[themeName] = {
-      colors: {
-        main,
-        support,
-        neutral
-      },
-      borderRadius,
-      typography: fontFamily ? { fontFamily } : void 0
-    };
-    console.log(
-      `
-\u2705 Main colors: ${Object.keys(main).map((c) => pc8.cyan(c)).join(", ") || pc8.dim("none")}`
-    );
-    console.log(
-      `
-\u2705 Support colors: ${Object.keys(support).map((c) => pc8.cyan(c)).join(", ") || pc8.dim("none")}`
-    );
-    console.log(`
-\u2705 Neutral: ${pc8.cyan(neutral)}`);
-    if (borderRadius !== void 0) {
-      console.log(`
-\u2705 Border radius: ${pc8.cyan(String(borderRadius))}`);
-    }
-    if (fontFamily) {
-      console.log(`
-\u2705 Font family: ${pc8.cyan(fontFamily)}`);
-    }
-  }
-  return config;
-}
-
-// bin/config.ts
-import pc10 from "picocolors";
-import * as R27 from "ramda";
-
-// src/config.ts
-import pc9 from "picocolors";
-import * as R26 from "ramda";
-import { z } from "zod";
-import { fromError } from "zod-validation-error";
-function mapPathToOptionName(path5) {
-  const normalisedPath = path5[0] === "themes" ? ["theme", ...R26.drop(2, path5)] : path5;
-  const option = R26.path(normalisedPath, cliOptions);
-  if (typeof option !== "string") {
-    return;
-  }
-  return option;
-}
-function makeFriendlyError(err) {
-  try {
-    return fromError(err, {
-      messageBuilder: (issues) => issues.map((issue) => {
-        const issuePath = issue.path.join(".");
-        const optionName = mapPathToOptionName(issue.path);
-        const errorCode = `(error code: ${issue.code})`;
-        const optionMessage = optionName ? ` or CLI option --${optionName}` : "";
-        return `  - Error in JSON value ${pc9.red(issuePath)}${optionMessage}:
-      ${issue.message} ${pc9.dim(errorCode)}`;
-      }).join("\n")
-    });
-  } catch (_err2) {
-    console.error(pc9.red(err instanceof Error ? err.message : "Unknown error occurred while parsing config file"));
-    console.error(err instanceof Error ? err.stack : "No stack trace available");
-  }
-}
-function validateConfig(schema, unvalidatedConfig, configFilePath) {
-  try {
-    return schema.parse(unvalidatedConfig);
-  } catch (err) {
-    console.error(pc9.redBright(`Invalid config file at ${pc9.red(configFilePath)}`));
-    const validationError = makeFriendlyError(err);
-    console.error(validationError?.toString());
-    process.exit(1);
-  }
-}
-function parseConfig(configFile, configFilePath) {
-  if (!configFile) {
-    return {};
-  }
-  try {
-    return JSON.parse(configFile);
-  } catch (err) {
-    console.error(pc9.redBright(`Failed parsing config file at ${pc9.red(configFilePath)}`));
-    const validationError = makeFriendlyError(err);
-    console.error(validationError?.toString());
-    process.exit(1);
-  }
-}
-var hexPatterns = [
-  // Hex colors: #000, #0000, #000000, #00000000
-  `#[0-9a-fA-F]{3}`,
-  `#[0-9a-fA-F]{4}`,
-  `#[0-9a-fA-F]{6}`,
-  `#[0-9a-fA-F]{8}`
-];
-var reservedColorsPattern = `^(?!(?:${RESERVED_COLORS.join("|")})$)`;
-var colorRegex = new RegExp(`^${hexPatterns.join("|")}$`);
-var colorSchema = z.string().regex(colorRegex).transform(convertToHex).describe(
-  `A hex color, which is used for creating a color scale. Invalid color names: ${RESERVED_COLORS.join(", ")}`
-);
-var colorCategorySchema = z.record(
-  z.string().regex(new RegExp(reservedColorsPattern, "i"), {
-    error: `Color names cannot include reserved names: ${RESERVED_COLORS.join(", ")}`
-  }),
-  colorSchema,
-  {
-    error: "Color definitions must be hex color values"
-  }
-).refine((colors2) => !Object.keys(colors2).some((key) => RESERVED_COLORS.includes(key.toLowerCase())), {
-  error: `Color names cannot include reserved names: ${RESERVED_COLORS.join(", ")}`
-}).describe("An object with one or more color definitions. The property name is used as the color name.");
-var colorModeOverrideSchema = z.object({
-  light: colorSchema.optional().describe("A hex color that overrides light mode"),
-  dark: colorSchema.optional().describe("A hex color that overrides dark mode")
-}).describe('Override values for semantic color tokens like "background-subtle", "border-default", etc.');
-var colorWeightOverrideSchema = z.partialRecord(z.enum([...colorNames]), colorModeOverrideSchema).describe('The name of the color to add overrides for, e.g. "accent"');
-var semanticColorOverrideSchema = z.record(z.string(), colorWeightOverrideSchema).describe("An object with color names as keys");
-var severityColorOverrideSchema = z.partialRecord(z.enum(baseColorNames), colorSchema.describe("A hex color, which is used for creating a color scale")).optional().describe("An object with severity color names as keys");
-var linkVisitedOverrideSchema = z.object({
-  light: colorSchema.optional().describe("A hex color that overrides light mode"),
-  dark: colorSchema.optional().describe("A hex color that overrides dark mode")
-}).describe('Overrides for the "link-visited" color');
-var focusOverrideSchema = z.object({
-  inner: z.object({
-    light: colorSchema.optional().describe("A hex color that overrides light mode"),
-    dark: colorSchema.optional().describe("A hex color that overrides dark mode")
-  }).optional().describe('Overrides for the "focus-inner" color'),
-  outer: z.object({
-    light: colorSchema.optional().describe("A hex color that overrides light mode"),
-    dark: colorSchema.optional().describe("A hex color that overrides dark mode")
-  }).optional().describe('Overrides for the "focus-outer" color')
-}).describe("Overrides for the focus colors");
-var overridesSchema = z.object({
-  colors: semanticColorOverrideSchema.optional(),
-  severity: severityColorOverrideSchema.optional(),
-  linkVisited: linkVisitedOverrideSchema.optional(),
-  focus: focusOverrideSchema.optional()
-}).describe("Overrides for generated design tokens. Currently only supports colors defined in your theme").optional();
-var themeSchema = z.object({
-  colors: z.object({
-    main: colorCategorySchema,
-    support: colorCategorySchema.optional().default({}),
-    neutral: colorSchema.describe("A hex color, which is used for creating a color scale.")
-  }).meta({ description: "Defines the colors for this theme" }),
-  typography: z.object({
-    fontFamily: z.string().meta({ description: "Sets the font-family for this theme" })
-  }).describe("Defines the typography for a given theme").optional(),
-  borderRadius: z.number().meta({ description: "Defines the border-radius for this theme" }).optional(),
-  overrides: overridesSchema
-}).meta({ description: "An object defining a theme. The property name holding the object becomes the theme name." });
-var commonConfig = z.object({
-  clean: z.boolean().meta({ description: "Delete the output directory before building or creating tokens" }).optional()
-});
-var _configFileCreateSchema = z.object({
-  outDir: z.string().meta({ description: "Path to the output directory for the created design tokens" }),
-  themes: z.record(z.string(), themeSchema).meta({
-    description: "An object with one or more themes. Each property defines a theme, and the property name is used as the theme name."
-  })
-}).required();
-var configFileCreateSchema = _configFileCreateSchema.extend(commonConfig.shape);
-
-// bin/options.ts
-var getOptionIfMatchingSource = (...sources) => (command, option) => {
-  const source = command.getOptionValueSource(option);
-  if (sources.includes(source)) {
-    return command.getOptionValue(option);
-  }
-};
-var getSuppliedCliOption = getOptionIfMatchingSource("cli");
-var getDefaultCliOption = getOptionIfMatchingSource("default");
-var getCliOption = getOptionIfMatchingSource("cli", "default");
-
-// bin/config.ts
-async function readConfigFile(configFilePath, allowFileNotFound = true) {
-  let configFile;
-  try {
-    configFile = await dsfs.readFile(configFilePath, allowFileNotFound);
-  } catch (err) {
-    if (allowFileNotFound) {
-      return "";
-    }
-    console.error(pc10.redBright(`Could not read config file at ${pc10.blue(configFilePath)}`));
-    throw err;
-  }
-  if (configFile) {
-    console.log(`Found config file: ${pc10.green(configFilePath)}`);
-  }
-  return configFile;
-}
-async function parseCreateConfig(configFile, options) {
-  const { cmd, theme = "theme", configFilePath } = options;
-  const configParsed = parseConfig(configFile, configFilePath);
-  const themeColors = Object.values(configParsed?.themes ?? {}).map(
-    (x) => /* @__PURE__ */ new Set([...R27.keys(x.colors.main), ...R27.keys(x.colors.support)])
-  );
-  if (!R27.all(R27.equals(R27.__, themeColors[0]), themeColors)) {
-    console.error(pc10.redBright(`In config, all themes must have the same custom color names, but we found:`));
-    const themeNames = R27.keys(configParsed.themes ?? {});
-    themeColors.forEach((colors2, index) => {
-      const colorNames2 = Array.from(colors2);
-      console.log(`  - ${themeNames[index]}: ${colorNames2.join(", ")}`);
-    });
-    console.log();
-    process.exit(1);
-  }
-  const noUndefined = R27.reject(R27.isNil);
-  const getThemeOptions = (optionGetter) => noUndefined({
-    colors: noUndefined({
-      main: optionGetter(cmd, "mainColors"),
-      support: optionGetter(cmd, "supportColors"),
-      neutral: optionGetter(cmd, "neutralColor")
-    }),
-    typography: noUndefined({
-      fontFamily: optionGetter(cmd, "fontFamily")
-    }),
-    borderRadius: optionGetter(cmd, "borderRadius"),
-    defaultColor: optionGetter(cmd, "defaultColor")
-  });
-  const unvalidatedConfig = noUndefined({
-    outDir: configParsed?.outDir ?? getCliOption(cmd, "outDir"),
-    clean: configParsed?.clean ?? getCliOption(cmd, "clean"),
-    themes: configParsed?.themes ? R27.map((jsonThemeValues) => {
-      const defaultThemeValues = getThemeOptions(getDefaultCliOption);
-      const cliThemeValues = getThemeOptions(getSuppliedCliOption);
-      const mergedConfigs = R27.mergeDeepRight(defaultThemeValues, R27.mergeDeepRight(jsonThemeValues, cliThemeValues));
-      return mergedConfigs;
-    }, configParsed.themes) : (
-      // If there are no themes specified in the JSON config, we use both explicit
-      // and default theme options from the CLI.
-      {
-        [theme]: getThemeOptions(getCliOption)
-      }
-    )
-  });
-  return validateConfig(configFileCreateSchema, unvalidatedConfig, configFilePath);
-}
-
-// bin/designsystemet.ts
-var figletAscii = `
+import * as R from "ramda";
+import path from "node:path";
+import { Argument, createCommand, program } from "@commander-js/extra-typings";
+//#region bin/designsystemet.ts
+const figletAscii = `
  _____            _                           _                      _
 |  __ \\          (_)                         | |                    | |
 | |  | | ___  ___ _  __ _ _ __  ___ _   _ ___| |_ ___ _ __ ___   ___| |_
@@ -4503,146 +24,133 @@ var figletAscii = `
                     |___/           |___/
 `;
 program.name("designsystemet").description("CLI for working with Designsystemet").showHelpAfterError();
-var DEFAULT_TOKENS_CREATE_DIR = "./design-tokens";
-var DEFAULT_TOKENS_BUILD_DIR = "./design-tokens-build";
-var DEFAULT_FONT = "Inter";
-var DEFAULT_THEME_NAME = "theme";
-var DEFAULT_CONFIG_FILEPATH = "designsystemet.config.json";
+const DEFAULT_TOKENS_CREATE_DIR = "./design-tokens";
+const DEFAULT_TOKENS_BUILD_DIR = "./design-tokens-build";
+const DEFAULT_FONT = "Inter";
+const DEFAULT_THEME_NAME = "theme";
+const DEFAULT_CONFIG_FILEPATH = "designsystemet.config.json";
 function makeTokenCommands() {
-  const tokenCmd = createCommand("tokens");
-  tokenCmd.command("build").description("Build Designsystemet tokens").option("-t, --tokens <string>", `Path to ${pc11.blue("design-tokens")}`, DEFAULT_TOKENS_CREATE_DIR).option(
-    "-o, --out-dir <string>",
-    `Output directory for built ${pc11.blue("design-tokens")}`,
-    DEFAULT_TOKENS_BUILD_DIR
-  ).option(`--${cliOptions.clean} [boolean]`, "Clean output directory before building tokens", parseBoolean, false).option("--dry [boolean]", `Dry run for built ${pc11.blue("design-tokens")}`, parseBoolean, false).option("--verbose", "Enable verbose output", false).option("--config <string>", `Path to config file (default: "${DEFAULT_CONFIG_FILEPATH}")`).option("--experimental-tailwind", "Generate Tailwind CSS classes for tokens", false).action(async (opts) => {
-    console.log(figletAscii);
-    const { verbose, clean, dry, experimentalTailwind, tokens } = opts;
-    dsfs.init({ dry, outdir: opts.outDir, verbose });
-    const outDir = dsfs.outDir;
-    if (clean) {
-      await dsfs.cleanDir(outDir);
-    }
-    const files = await buildTokens({
-      tokensDir: tokens,
-      verbose,
-      tailwind: experimentalTailwind
-    });
-    console.log(`
-\u{1F4BE} Writing build to ${pc11.green(outDir)}`);
-    await dsfs.writeFiles(files, outDir, true);
-    console.log(`
-\u2705 Finished building tokens in ${pc11.green(outDir)}`);
-    return Promise.resolve();
-  });
-  tokenCmd.command("create").description("Create Designsystemet tokens").option(`-m, --${cliOptions.theme.colors.main} <name:hex...>`, `Main colors`, parseColorValues).option(`-s, --${cliOptions.theme.colors.support} <name:hex...>`, `Support colors`, parseColorValues).option(`-n, --${cliOptions.theme.colors.neutral} <hex>`, `Neutral hex color`, convertToHex).option(
-    `-o, --${cliOptions.outDir} <string>`,
-    `Output directory for created ${pc11.blue("design-tokens")}`,
-    DEFAULT_TOKENS_CREATE_DIR
-  ).option(`--${cliOptions.clean} [boolean]`, "Clean output directory before creating tokens", parseBoolean, false).option("--dry [boolean]", `Dry run for created ${pc11.blue("design-tokens")}`, parseBoolean, false).option(`-f, --${cliOptions.theme.typography.fontFamily} <string>`, `Font family (experimental)`, DEFAULT_FONT).option(
-    `-b, --${cliOptions.theme.borderRadius} <number>`,
-    `Unitless base border-radius in px`,
-    (radiusAsString) => Number(radiusAsString),
-    4
-  ).option("--theme <string>", "Theme name (ignored when using JSON config file)", DEFAULT_THEME_NAME).option("--config <string>", `Path to config file (default: "${DEFAULT_CONFIG_FILEPATH}")`).action(async (opts, cmd) => {
-    console.log(figletAscii);
-    if (opts.dry) {
-      console.log(`Performing dry run, no files will be written`);
-    }
-    const themeName = opts.theme;
-    const { configFile, configFilePath } = await getConfigFile(opts.config);
-    const config = await parseCreateConfig(configFile, {
-      theme: themeName,
-      cmd,
-      configFilePath
-    });
-    const themeNames = Object.keys(config.themes);
-    if (themeNames.length > 0) {
-      console.log(`Using themes from config file: ${pc11.blue(themeNames.join(", "))}`);
-    }
-    dsfs.init({ dry: opts.dry, outdir: config.outDir });
-    const outDir = dsfs.outDir;
-    if (config.clean) {
-      await dsfs.cleanDir(outDir);
-    }
-    let files = [];
-    if (config.themes) {
-      for (const [name, themeWithoutName] of Object.entries(config.themes)) {
-        const theme = { name, ...themeWithoutName };
-        const { tokenSets } = await createTokens(theme);
-        files = files.concat(await createTokenFiles({ outDir, theme, tokenSets, themeNames }));
-      }
-    }
-    await dsfs.writeFiles(files, outDir);
-    console.log(`
-\u2705 Finished creating tokens in ${pc11.green(outDir)} for themes: ${pc11.blue(themeNames.join(", "))}`);
-    return Promise.resolve();
-  });
-  return tokenCmd;
+	const tokenCmd = createCommand("tokens");
+	tokenCmd.command("build").description("Build Designsystemet tokens").option("-t, --tokens <string>", `Path to ${pc.blue("design-tokens")}`, DEFAULT_TOKENS_CREATE_DIR).option("-o, --out-dir <string>", `Output directory for built ${pc.blue("design-tokens")}`, DEFAULT_TOKENS_BUILD_DIR).option(`--${cliOptions.clean} [boolean]`, "Clean output directory before building tokens", parseBoolean, false).option("--dry [boolean]", `Dry run for built ${pc.blue("design-tokens")}`, parseBoolean, false).option("--verbose", "Enable verbose output", false).option("--config <string>", `Path to config file (default: "${DEFAULT_CONFIG_FILEPATH}")`).option("--experimental-tailwind", "Generate Tailwind CSS classes for tokens", false).action(async (opts) => {
+		console.log(figletAscii);
+		const { verbose, clean, dry, experimentalTailwind, tokens } = opts;
+		dsfs.init({
+			dry,
+			outdir: opts.outDir,
+			verbose
+		});
+		const outDir = dsfs.outDir;
+		if (clean) await dsfs.cleanDir(outDir);
+		const files = await buildTokens({
+			tokensDir: tokens,
+			verbose,
+			tailwind: experimentalTailwind
+		});
+		console.log(`\n💾 Writing build to ${pc.green(outDir)}`);
+		await dsfs.writeFiles(files, outDir, true);
+		console.log(`\n✅ Finished building tokens in ${pc.green(outDir)}`);
+		return Promise.resolve();
+	});
+	tokenCmd.command("create").description("Create Designsystemet tokens").option(`-m, --${cliOptions.theme.colors.main} <name:hex...>`, `Main colors`, parseColorValues).option(`-s, --${cliOptions.theme.colors.support} <name:hex...>`, `Support colors`, parseColorValues).option(`-n, --${cliOptions.theme.colors.neutral} <hex>`, `Neutral hex color`, convertToHex).option(`-o, --${cliOptions.outDir} <string>`, `Output directory for created ${pc.blue("design-tokens")}`, DEFAULT_TOKENS_CREATE_DIR).option(`--${cliOptions.clean} [boolean]`, "Clean output directory before creating tokens", parseBoolean, false).option("--dry [boolean]", `Dry run for created ${pc.blue("design-tokens")}`, parseBoolean, false).option(`-f, --${cliOptions.theme.typography.fontFamily} <string>`, `Font family (experimental)`, DEFAULT_FONT).option(`-b, --${cliOptions.theme.borderRadius} <number>`, `Unitless base border-radius in px`, (radiusAsString) => Number(radiusAsString), 4).option("--theme <string>", "Theme name (ignored when using JSON config file)", DEFAULT_THEME_NAME).option("--config <string>", `Path to config file (default: "${DEFAULT_CONFIG_FILEPATH}")`).action(async (opts, cmd) => {
+		console.log(figletAscii);
+		if (opts.dry) console.log(`Performing dry run, no files will be written`);
+		const themeName = opts.theme;
+		const { configFile, configFilePath } = await getConfigFile(opts.config);
+		const config = await parseCreateConfig(configFile, {
+			theme: themeName,
+			cmd,
+			configFilePath
+		});
+		const themeNames = Object.keys(config.themes);
+		if (themeNames.length > 0) console.log(`Using themes from config file: ${pc.blue(themeNames.join(", "))}`);
+		dsfs.init({
+			dry: opts.dry,
+			outdir: config.outDir
+		});
+		const outDir = dsfs.outDir;
+		if (config.clean) await dsfs.cleanDir(outDir);
+		let files = [];
+		if (config.themes) for (const [name, themeWithoutName] of Object.entries(config.themes)) {
+			const theme = {
+				name,
+				...themeWithoutName
+			};
+			const { tokenSets } = await createTokens(theme);
+			files = files.concat(await createTokenFiles({
+				outDir,
+				theme,
+				tokenSets,
+				themeNames
+			}));
+		}
+		await dsfs.writeFiles(files, outDir);
+		console.log(`\n✅ Finished creating tokens in ${pc.green(outDir)} for themes: ${pc.blue(themeNames.join(", "))}`);
+		return Promise.resolve();
+	});
+	return tokenCmd;
 }
 program.addCommand(makeTokenCommands());
 program.command("generate-config-from-tokens").description("Generate a config file from existing design tokens. Will not include overrides.").option("-d, --dir <string>", "Path to design tokens directory", DEFAULT_TOKENS_CREATE_DIR).option("-o, --out <string>", "Output path for config file", DEFAULT_CONFIG_FILEPATH).option("--dry [boolean]", "Dry run - show config without writing file", parseBoolean, false).action(async (opts) => {
-  console.log(figletAscii);
-  const { dry } = opts;
-  const tokensDir = path4.resolve(opts.dir);
-  const configFilePath = path4.resolve(opts.out);
-  dsfs.init({ dry, outdir: path4.dirname(configFilePath) });
-  try {
-    const config = await generateConfigFromTokens({
-      tokensDir,
-      outFile: configFilePath
-    });
-    if (dry) {
-      console.log();
-      console.log("Generated config (dry run):");
-      console.log(JSON.stringify(config, null, 2));
-    }
-    if (configFilePath) {
-      const configJson = JSON.stringify(config, null, 2);
-      await dsfs.writeFile(configFilePath, configJson);
-      console.log();
-      console.log(`
-\u2705 Config file written to ${pc11.blue(configFilePath)}`);
-    }
-  } catch (error) {
-    console.error(pc11.redBright("Error generating config:"));
-    console.error(error instanceof Error ? error.message : String(error));
-    process.exit(1);
-  }
+	console.log(figletAscii);
+	const { dry } = opts;
+	const tokensDir = path.resolve(opts.dir);
+	const configFilePath = path.resolve(opts.out);
+	dsfs.init({
+		dry,
+		outdir: path.dirname(configFilePath)
+	});
+	try {
+		const config = await generateConfigFromTokens({
+			tokensDir,
+			outFile: configFilePath
+		});
+		if (dry) {
+			console.log();
+			console.log("Generated config (dry run):");
+			console.log(JSON.stringify(config, null, 2));
+		}
+		if (configFilePath) {
+			const configJson = JSON.stringify(config, null, 2);
+			await dsfs.writeFile(configFilePath, configJson);
+			console.log();
+			console.log(`\n✅ Config file written to ${pc.blue(configFilePath)}`);
+		}
+	} catch (error) {
+		console.error(pc.redBright("Error generating config:"));
+		console.error(error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
 });
 program.command("migrate").description("run a Designsystemet migration").addArgument(new Argument("[migration]", "Available migrations").choices(Object.keys(migrations_default))).option("-l --list", "List available migrations").option("-g --glob <glob>", "Glob for files upon which to apply the migration", "./**/*.(tsx|css)").action((migrationKey, opts) => {
-  console.log(figletAscii);
-  const { glob: glob2, list } = opts;
-  if (list) {
-    for (const key of Object.keys(migrations_default)) {
-      console.log(key);
-    }
-  } else if (migrationKey) {
-    const migration = migrations_default[migrationKey];
-    if (!migration) {
-      console.error("Migration not found!");
-      throw "Aborting";
-    }
-    console.log(`Applying migration ${pc11.blue(migrationKey)} with glob: ${pc11.green(glob2)}`);
-    migration?.(glob2).then(() => console.log(`Migration ${pc11.blue(migrationKey)} finished`)).catch((error) => console.log(error));
-  } else {
-    console.log("Migrate: please specify a migration name or --list");
-  }
+	console.log(figletAscii);
+	const { glob, list } = opts;
+	if (list) for (const key of Object.keys(migrations_default)) console.log(key);
+	else if (migrationKey) {
+		const migration = migrations_default[migrationKey];
+		if (!migration) {
+			console.error("Migration not found!");
+			throw "Aborting";
+		}
+		console.log(`Applying migration ${pc.blue(migrationKey)} with glob: ${pc.green(glob)}`);
+		migration?.(glob).then(() => console.log(`Migration ${pc.blue(migrationKey)} finished`)).catch((error) => console.log(error));
+	} else console.log("Migrate: please specify a migration name or --list");
 });
 await program.parseAsync(process.argv);
 function parseColorValues(value, previous = {}) {
-  const [name, hex] = value.split(":");
-  previous[name] = convertToHex(hex);
-  return previous;
+	const [name, hex] = value.split(":");
+	previous[name] = convertToHex(hex);
+	return previous;
 }
 function parseBoolean(value) {
-  return value === "true" || value === true;
+	return value === "true" || value === true;
 }
 async function getConfigFile(userConfigFilePath) {
-  const allowFileNotFound = R28.isNil(userConfigFilePath) || userConfigFilePath === DEFAULT_CONFIG_FILEPATH;
-  const configFilePath = userConfigFilePath ?? DEFAULT_CONFIG_FILEPATH;
-  const configFile = await readConfigFile(configFilePath, allowFileNotFound);
-  return { configFile, configFilePath };
-}
-export {
-  figletAscii
-};
+	const allowFileNotFound = R.isNil(userConfigFilePath) || userConfigFilePath === DEFAULT_CONFIG_FILEPATH;
+	const configFilePath = userConfigFilePath ?? DEFAULT_CONFIG_FILEPATH;
+	return {
+		configFile: await readConfigFile(configFilePath, allowFileNotFound),
+		configFilePath
+	};
+}
+//#endregion
+export { figletAscii };