@digdir/designsystemet 1.0.3 → 1.0.5

package/dist/bin/designsystemet.js

@@ -1,18 +1,4260 @@
 #!/usr/bin/env node
-import fs from "node:fs/promises";
-import path from "node:path";
+
+// bin/designsystemet.ts
+import path4 from "node:path";
 import { Argument, createCommand, program } from "@commander-js/extra-typings";
-import chalk from "chalk";
-import * as R from "ramda";
+import chalk8 from "chalk";
+import * as R25 from "ramda";
 import { fromError } from "zod-validation-error";
-import { convertToHex } from "../src/colors/index.js";
-import migrations from "../src/migrations/index.js";
-import { buildTokens } from "../src/tokens/build.js";
-import { cliOptions, createTokens } from "../src/tokens/create.js";
-import { cleanDir } from "../src/tokens/utils.js";
-import { writeTokens } from "../src/tokens/write.js";
-import { combinedConfigSchema, configFileSchema, mapPathToOptionName } from "./config.js";
-import { getCliOption, getDefaultCliOption, getSuppliedCliOption } from "./options.js";
+
+// src/colors/utils.ts
+import chroma from "chroma-js";
+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
+import chroma2 from "chroma-js";
+import * as R2 from "ramda";
+
+// src/colors/colorMetadata.ts
+import * as R from "ramda";
+var baseColors = {
+  blue: "#0A71C0",
+  green: "#068718",
+  orange: "#EA9B1B",
+  purple: "#663299",
+  red: "#C01B1B"
+};
+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));
+
+// src/colors/theme.ts
+var RESERVED_COLORS = [
+  "neutral",
+  "success",
+  "warning",
+  "danger",
+  "info",
+  "blue",
+  "green",
+  "orange",
+  "purple",
+  "red"
+];
+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/config.ts
+import * as R7 from "ramda";
+import { z } from "zod";
+
+// src/tokens/create/defaults.ts
+import * as R3 from "ramda";
+
+// src/tokens/template/design-tokens/primitives/globals.json with { type: 'json' }
+var globals_default = {
+  "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%"
+    }
+  }
+};
+
+// src/tokens/template/design-tokens/primitives/modes/size/global.json with { type: 'json' }
+var global_default = {
+  _size: {
+    "0": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *0)"
+    },
+    "1": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *1)"
+    },
+    "2": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *2)"
+    },
+    "3": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *3)"
+    },
+    "4": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *4)"
+    },
+    "5": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *5)"
+    },
+    "6": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *6)"
+    },
+    "7": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *7)"
+    },
+    "8": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *8)"
+    },
+    "9": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *9)"
+    },
+    "10": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *10)"
+    },
+    "11": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *11)"
+    },
+    "12": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *12)"
+    },
+    "13": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *13)"
+    },
+    "14": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *14)"
+    },
+    "15": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *15)"
+    },
+    "18": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *18)"
+    },
+    "22": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *22)"
+    },
+    "26": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *26)"
+    },
+    "30": {
+      $type: "dimension",
+      $value: "floor({_size.step} / {_size.base} * {_size.mode-font-size} *30)"
+    },
+    "mode-font-size": {
+      $type: "dimension",
+      $value: "{size._mode-font-size}"
+    },
+    base: {
+      $type: "dimension",
+      $value: "{size._base}"
+    },
+    step: {
+      $type: "dimension",
+      $value: "{size._step}"
+    }
+  }
+};
+
+// src/tokens/template/design-tokens/primitives/modes/size/large.json with { type: 'json' }
+var large_default = {
+  size: {
+    "_mode-font-size": {
+      $type: "dimension",
+      $value: "21"
+    },
+    _base: {
+      $type: "dimension",
+      $value: "18"
+    },
+    _step: {
+      $type: "dimension",
+      $value: "4"
+    }
+  }
+};
+
+// src/tokens/template/design-tokens/primitives/modes/size/medium.json with { type: 'json' }
+var medium_default = {
+  size: {
+    "_mode-font-size": {
+      $type: "dimension",
+      $value: "18"
+    },
+    _base: {
+      $type: "dimension",
+      $value: "18"
+    },
+    _step: {
+      $type: "dimension",
+      $value: "4"
+    }
+  }
+};
+
+// src/tokens/template/design-tokens/primitives/modes/size/small.json with { type: 'json' }
+var small_default = {
+  size: {
+    "_mode-font-size": {
+      $type: "dimension",
+      $value: "16"
+    },
+    _base: {
+      $type: "dimension",
+      $value: "18"
+    },
+    _step: {
+      $type: "dimension",
+      $value: "4"
+    }
+  }
+};
+
+// src/tokens/template/design-tokens/primitives/modes/typography/size/large.json with { type: 'json' }
+var large_default2 = {
+  "line-height": {
+    sm: {
+      $type: "lineHeights",
+      $value: "130%"
+    },
+    md: {
+      $type: "lineHeights",
+      $value: "150%"
+    },
+    lg: {
+      $type: "lineHeights",
+      $value: "170%"
+    }
+  },
+  "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": {
+    "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%"
+    }
+  }
+};
+
+// src/tokens/template/design-tokens/primitives/modes/typography/size/medium.json with { type: 'json' }
+var medium_default2 = {
+  "line-height": {
+    sm: {
+      $type: "lineHeights",
+      $value: "130%"
+    },
+    md: {
+      $type: "lineHeights",
+      $value: "150%"
+    },
+    lg: {
+      $type: "lineHeights",
+      $value: "170%"
+    }
+  },
+  "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": {
+    "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%"
+    }
+  }
+};
+
+// src/tokens/template/design-tokens/primitives/modes/typography/size/small.json with { type: 'json' }
+var small_default2 = {
+  "line-height": {
+    sm: {
+      $type: "lineHeights",
+      $value: "130%"
+    },
+    md: {
+      $type: "lineHeights",
+      $value: "150%"
+    },
+    lg: {
+      $type: "lineHeights",
+      $value: "170%"
+    }
+  },
+  "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": {
+    "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%"
+    }
+  }
+};
+
+// src/tokens/template/design-tokens/semantic/style.json with { type: 'json' }
+var style_default = {
+  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/defaults.ts
+var defaultTokens = {
+  "primitives/globals": globals_default,
+  "primitives/modes/size/small": small_default,
+  "primitives/modes/size/medium": medium_default,
+  "primitives/modes/size/large": large_default,
+  "primitives/modes/size/global": global_default,
+  "primitives/modes/typography/size/small": small_default2,
+  "primitives/modes/typography/size/medium": medium_default2,
+  "primitives/modes/typography/size/large": large_default2,
+  "semantic/style": style_default
+};
+var getDefaultTokens = (tokenSets) => Object.entries(R3.pick(tokenSets, defaultTokens));
+var getDefaultToken = (tokenPath) => {
+  return [tokenPath, defaultTokens[tokenPath]];
+};
+
+// src/tokens/create/generators/color.ts
+import * as R4 from "ramda";
+var generateColor = (colorArray) => {
+  const obj = {};
+  const $type = "color";
+  for (const index in colorArray) {
+    obj[Number(index) + 1] = { $type, $value: colorArray[index].hex };
+  }
+  return obj;
+};
+var generateColorScheme = (themeName, colorScheme2, colors2) => {
+  const main = R4.map((color) => generateColor(generateColorScale(color, colorScheme2)), colors2.main);
+  const support = R4.map((color) => generateColor(generateColorScale(color, colorScheme2)), colors2.support);
+  const neutral = generateColor(generateColorScale(colors2.neutral, colorScheme2));
+  return {
+    [themeName]: {
+      ...main,
+      ...support,
+      neutral
+    }
+  };
+};
+var generateColorGlobal = (colorScheme2) => {
+  const blueScale = generateColorScale(baseColors.blue, colorScheme2);
+  const greenScale = generateColorScale(baseColors.green, colorScheme2);
+  const orangeScale = generateColorScale(baseColors.orange, colorScheme2);
+  const purpleScale = generateColorScale(baseColors.purple, colorScheme2);
+  const redScale = generateColorScale(baseColors.red, colorScheme2);
+  return {
+    global: {
+      blue: generateColor(blueScale),
+      green: generateColor(greenScale),
+      orange: generateColor(orangeScale),
+      purple: generateColor(purpleScale),
+      red: generateColor(redScale)
+    }
+  };
+};
+
+// src/tokens/create/generators/semantic.ts
+import * as R5 from "ramda";
+
+// src/tokens/template/design-tokens/semantic/color.base.template.json with { type: 'json' }
+var color_base_template_default = {
+  color: {
+    success: {
+      "background-default": {
+        $type: "color",
+        $value: "{global.green.1}"
+      },
+      "background-tinted": {
+        $type: "color",
+        $value: "{global.green.2}"
+      },
+      "surface-default": {
+        $type: "color",
+        $value: "{global.green.3}"
+      },
+      "surface-tinted": {
+        $type: "color",
+        $value: "{global.green.4}"
+      },
+      "surface-hover": {
+        $type: "color",
+        $value: "{global.green.5}"
+      },
+      "surface-active": {
+        $type: "color",
+        $value: "{global.green.6}"
+      },
+      "border-subtle": {
+        $type: "color",
+        $value: "{global.green.7}"
+      },
+      "border-default": {
+        $type: "color",
+        $value: "{global.green.8}"
+      },
+      "border-strong": {
+        $type: "color",
+        $value: "{global.green.9}"
+      },
+      "text-subtle": {
+        $type: "color",
+        $value: "{global.green.10}"
+      },
+      "text-default": {
+        $type: "color",
+        $value: "{global.green.11}"
+      },
+      "base-default": {
+        $type: "color",
+        $value: "{global.green.12}"
+      },
+      "base-hover": {
+        $type: "color",
+        $value: "{global.green.13}"
+      },
+      "base-active": {
+        $type: "color",
+        $value: "{global.green.14}"
+      },
+      "base-contrast-subtle": {
+        $type: "color",
+        $value: "{global.green.15}"
+      },
+      "base-contrast-default": {
+        $type: "color",
+        $value: "{global.green.16}"
+      }
+    },
+    danger: {
+      "background-default": {
+        $type: "color",
+        $value: "{global.red.1}"
+      },
+      "background-tinted": {
+        $type: "color",
+        $value: "{global.red.2}"
+      },
+      "surface-default": {
+        $type: "color",
+        $value: "{global.red.3}"
+      },
+      "surface-tinted": {
+        $type: "color",
+        $value: "{global.red.4}"
+      },
+      "surface-hover": {
+        $type: "color",
+        $value: "{global.red.5}"
+      },
+      "surface-active": {
+        $type: "color",
+        $value: "{global.red.6}"
+      },
+      "border-subtle": {
+        $type: "color",
+        $value: "{global.red.7}"
+      },
+      "border-default": {
+        $type: "color",
+        $value: "{global.red.8}"
+      },
+      "border-strong": {
+        $type: "color",
+        $value: "{global.red.9}"
+      },
+      "text-subtle": {
+        $type: "color",
+        $value: "{global.red.10}"
+      },
+      "text-default": {
+        $type: "color",
+        $value: "{global.red.11}"
+      },
+      "base-default": {
+        $type: "color",
+        $value: "{global.red.12}"
+      },
+      "base-hover": {
+        $type: "color",
+        $value: "{global.red.13}"
+      },
+      "base-active": {
+        $type: "color",
+        $value: "{global.red.14}"
+      },
+      "base-contrast-subtle": {
+        $type: "color",
+        $value: "{global.red.15}"
+      },
+      "base-contrast-default": {
+        $type: "color",
+        $value: "{global.red.16}"
+      }
+    },
+    info: {
+      "background-default": {
+        $type: "color",
+        $value: "{global.blue.1}"
+      },
+      "background-tinted": {
+        $type: "color",
+        $value: "{global.blue.2}"
+      },
+      "surface-default": {
+        $type: "color",
+        $value: "{global.blue.3}"
+      },
+      "surface-tinted": {
+        $type: "color",
+        $value: "{global.blue.4}"
+      },
+      "surface-hover": {
+        $type: "color",
+        $value: "{global.blue.5}"
+      },
+      "surface-active": {
+        $type: "color",
+        $value: "{global.blue.6}"
+      },
+      "border-subtle": {
+        $type: "color",
+        $value: "{global.blue.7}"
+      },
+      "border-default": {
+        $type: "color",
+        $value: "{global.blue.8}"
+      },
+      "border-strong": {
+        $type: "color",
+        $value: "{global.blue.9}"
+      },
+      "text-subtle": {
+        $type: "color",
+        $value: "{global.blue.10}"
+      },
+      "text-default": {
+        $type: "color",
+        $value: "{global.blue.11}"
+      },
+      "base-default": {
+        $type: "color",
+        $value: "{global.blue.12}"
+      },
+      "base-hover": {
+        $type: "color",
+        $value: "{global.blue.13}"
+      },
+      "base-active": {
+        $type: "color",
+        $value: "{global.blue.14}"
+      },
+      "base-contrast-subtle": {
+        $type: "color",
+        $value: "{global.blue.15}"
+      },
+      "base-contrast-default": {
+        $type: "color",
+        $value: "{global.blue.16}"
+      }
+    },
+    warning: {
+      "background-default": {
+        $type: "color",
+        $value: "{global.orange.1}"
+      },
+      "background-tinted": {
+        $type: "color",
+        $value: "{global.orange.2}"
+      },
+      "surface-default": {
+        $type: "color",
+        $value: "{global.orange.3}"
+      },
+      "surface-tinted": {
+        $type: "color",
+        $value: "{global.orange.4}"
+      },
+      "surface-hover": {
+        $type: "color",
+        $value: "{global.orange.5}"
+      },
+      "surface-active": {
+        $type: "color",
+        $value: "{global.orange.6}"
+      },
+      "border-subtle": {
+        $type: "color",
+        $value: "{global.orange.7}"
+      },
+      "border-default": {
+        $type: "color",
+        $value: "{global.orange.8}"
+      },
+      "border-strong": {
+        $type: "color",
+        $value: "{global.orange.9}"
+      },
+      "text-subtle": {
+        $type: "color",
+        $value: "{global.orange.10}"
+      },
+      "text-default": {
+        $type: "color",
+        $value: "{global.orange.11}"
+      },
+      "base-default": {
+        $type: "color",
+        $value: "{global.orange.12}"
+      },
+      "base-hover": {
+        $type: "color",
+        $value: "{global.orange.13}"
+      },
+      "base-active": {
+        $type: "color",
+        $value: "{global.orange.14}"
+      },
+      "base-contrast-subtle": {
+        $type: "color",
+        $value: "{global.orange.15}"
+      },
+      "base-contrast-default": {
+        $type: "color",
+        $value: "{global.orange.16}"
+      }
+    },
+    focus: {
+      inner: {
+        $type: "color",
+        $value: "{color.neutral.background-default}"
+      },
+      outer: {
+        $type: "color",
+        $value: "{color.neutral.text-default}"
+      }
+    }
+  },
+  link: {
+    color: {
+      visited: {
+        $type: "color",
+        $value: "{global.purple.12}"
+      }
+    }
+  }
+};
+
+// src/tokens/template/design-tokens/semantic/color.template.json with { type: 'json' }
+var color_template_default = {
+  "background-default": {
+    $type: "color",
+    $value: "{color.<color>.1}"
+  },
+  "background-tinted": {
+    $type: "color",
+    $value: "{color.<color>.2}"
+  },
+  "surface-default": {
+    $type: "color",
+    $value: "{color.<color>.3}"
+  },
+  "surface-tinted": {
+    $type: "color",
+    $value: "{color.<color>.4}"
+  },
+  "surface-hover": {
+    $type: "color",
+    $value: "{color.<color>.5}"
+  },
+  "surface-active": {
+    $type: "color",
+    $value: "{color.<color>.6}"
+  },
+  "border-subtle": {
+    $type: "color",
+    $value: "{color.<color>.7}"
+  },
+  "border-default": {
+    $type: "color",
+    $value: "{color.<color>.8}"
+  },
+  "border-strong": {
+    $type: "color",
+    $value: "{color.<color>.9}"
+  },
+  "text-subtle": {
+    $type: "color",
+    $value: "{color.<color>.10}"
+  },
+  "text-default": {
+    $type: "color",
+    $value: "{color.<color>.11}"
+  },
+  "base-default": {
+    $type: "color",
+    $value: "{color.<color>.12}"
+  },
+  "base-hover": {
+    $type: "color",
+    $value: "{color.<color>.13}"
+  },
+  "base-active": {
+    $type: "color",
+    $value: "{color.<color>.14}"
+  },
+  "base-contrast-subtle": {
+    $type: "color",
+    $value: "{color.<color>.15}"
+  },
+  "base-contrast-default": {
+    $type: "color",
+    $value: "{color.<color>.16}"
+  }
+};
+
+// src/tokens/template/design-tokens/semantic/modes/color.template.json with { type: 'json' }
+var color_template_default2 = {
+  "background-default": {
+    $type: "color",
+    $value: "{color.<color>.background-default}"
+  },
+  "background-tinted": {
+    $type: "color",
+    $value: "{color.<color>.background-tinted}"
+  },
+  "surface-default": {
+    $type: "color",
+    $value: "{color.<color>.surface-default}"
+  },
+  "surface-tinted": {
+    $type: "color",
+    $value: "{color.<color>.surface-tinted}"
+  },
+  "surface-hover": {
+    $type: "color",
+    $value: "{color.<color>.surface-hover}"
+  },
+  "surface-active": {
+    $type: "color",
+    $value: "{color.<color>.surface-active}"
+  },
+  "border-subtle": {
+    $type: "color",
+    $value: "{color.<color>.border-subtle}"
+  },
+  "border-default": {
+    $type: "color",
+    $value: "{color.<color>.border-default}"
+  },
+  "border-strong": {
+    $type: "color",
+    $value: "{color.<color>.border-strong}"
+  },
+  "text-subtle": {
+    $type: "color",
+    $value: "{color.<color>.text-subtle}"
+  },
+  "text-default": {
+    $type: "color",
+    $value: "{color.<color>.text-default}"
+  },
+  "base-default": {
+    $type: "color",
+    $value: "{color.<color>.base-default}"
+  },
+  "base-hover": {
+    $type: "color",
+    $value: "{color.<color>.base-hover}"
+  },
+  "base-active": {
+    $type: "color",
+    $value: "{color.<color>.base-active}"
+  },
+  "base-contrast-subtle": {
+    $type: "color",
+    $value: "{color.<color>.base-contrast-subtle}"
+  },
+  "base-contrast-default": {
+    $type: "color",
+    $value: "{color.<color>.base-contrast-default}"
+  }
+};
+
+// src/tokens/create/generators/semantic.ts
+var generateSemantic = (colors2) => {
+  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, colorNames] of categories) {
+    for (const colorName of colorNames) {
+      const category = colorCategory2.replace("-color", "");
+      const customColorTokens = {
+        color: {
+          [category]: JSON.parse(
+            JSON.stringify(
+              color_template_default2,
+              (key, value) => {
+                if (key === "$value") {
+                  return value.replace("<color>", colorName);
+                }
+                return value;
+              },
+              2
+            )
+          )
+        }
+      };
+      modes[colorCategory2][colorName] = customColorTokens;
+    }
+  }
+  const customColors = [...mainColorNames, "neutral", ...supportColorNames];
+  const semanticColorTokens = customColors.map(
+    (colorName) => [
+      colorName,
+      R5.map((x) => ({ ...x, $value: x.$value.replace("<color>", colorName) }), color_template_default)
+    ]
+  );
+  const color = {
+    ...color_base_template_default,
+    color: {
+      ...Object.fromEntries(semanticColorTokens),
+      ...color_base_template_default.color
+    }
+  };
+  return {
+    modes,
+    color
+  };
+};
+
+// src/tokens/create/generators/theme.ts
+import * as R6 from "ramda";
+
+// src/tokens/template/design-tokens/themes/theme.base.template.json with { type: 'json' }
+var theme_base_template_default = {
+  color: {},
+  "font-family": {
+    $type: "fontFamilies",
+    $value: "{<theme>.font-family}"
+  },
+  "font-weight": {
+    medium: {
+      $type: "fontWeights",
+      $value: "{<theme>.font-weight.medium}"
+    },
+    semibold: {
+      $type: "fontWeights",
+      $value: "{<theme>.font-weight.semibold}"
+    },
+    regular: {
+      $type: "fontWeights",
+      $value: "{<theme>.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"
+    }
+  }
+};
+
+// src/tokens/template/design-tokens/themes/theme.template.json with { type: 'json' }
+var theme_template_default = {
+  "1": {
+    $type: "color",
+    $value: "{<theme>.<color>.1}"
+  },
+  "2": {
+    $type: "color",
+    $value: "{<theme>.<color>.2}"
+  },
+  "3": {
+    $type: "color",
+    $value: "{<theme>.<color>.3}"
+  },
+  "4": {
+    $type: "color",
+    $value: "{<theme>.<color>.4}"
+  },
+  "5": {
+    $type: "color",
+    $value: "{<theme>.<color>.5}"
+  },
+  "6": {
+    $type: "color",
+    $value: "{<theme>.<color>.6}"
+  },
+  "7": {
+    $type: "color",
+    $value: "{<theme>.<color>.7}"
+  },
+  "8": {
+    $type: "color",
+    $value: "{<theme>.<color>.8}"
+  },
+  "9": {
+    $type: "color",
+    $value: "{<theme>.<color>.9}"
+  },
+  "10": {
+    $type: "color",
+    $value: "{<theme>.<color>.10}"
+  },
+  "11": {
+    $type: "color",
+    $value: "{<theme>.<color>.11}"
+  },
+  "12": {
+    $type: "color",
+    $value: "{<theme>.<color>.12}"
+  },
+  "13": {
+    $type: "color",
+    $value: "{<theme>.<color>.13}"
+  },
+  "14": {
+    $type: "color",
+    $value: "{<theme>.<color>.14}"
+  },
+  "15": {
+    $type: "color",
+    $value: "{<theme>.<color>.15}"
+  },
+  "16": {
+    $type: "color",
+    $value: "{<theme>.<color>.16}"
+  }
+};
+
+// src/tokens/create/generators/theme.ts
+var generateTheme = (colors2, themeName, borderRadius) => {
+  const mainColorNames = Object.keys(colors2.main);
+  const supportColorNames = Object.keys(colors2.support);
+  const customColors = [...mainColorNames, "neutral", ...supportColorNames];
+  const themeColorTokens = Object.fromEntries(
+    customColors.map(
+      (colorName) => [
+        colorName,
+        R6.map((x) => ({ ...x, $value: x.$value.replace("<color>", colorName) }), theme_template_default)
+      ]
+    )
+  );
+  const { color: themeBaseFileColor, ...remainingThemeFile } = theme_base_template_default;
+  const themeFile = {
+    color: {
+      ...themeColorTokens,
+      ...themeBaseFileColor
+    },
+    ...remainingThemeFile
+  };
+  const baseBorderRadius = R6.lensPath(["border-radius", "base", "$value"]);
+  const updatedThemeFile = R6.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;
+};
+
+// src/tokens/template/design-tokens/primitives/modes/typography/typography.template.json with { type: 'json' }
+var typography_template_default = {
+  "<theme>": {
+    "font-family": {
+      $type: "fontFamilies",
+      $value: "<font-family>"
+    },
+    "font-weight": {
+      medium: {
+        $type: "fontWeights",
+        $value: "Medium"
+      },
+      semibold: {
+        $type: "fontWeights",
+        $value: "Semi bold"
+      },
+      regular: {
+        $type: "fontWeights",
+        $value: "Regular"
+      }
+    }
+  }
+};
+
+// src/tokens/create/generators/typography.ts
+var generateTypography = (themeName, { fontFamily }) => {
+  return JSON.parse(
+    JSON.stringify(typography_template_default).replaceAll(/<font-family>/g, fontFamily).replaceAll(/<theme>/g, themeName)
+  );
+};
+
+// src/tokens/create.ts
+var cliOptions = {
+  outDir: "out-dir",
+  clean: "clean",
+  theme: {
+    colors: {
+      main: "main-colors",
+      support: "support-colors",
+      neutral: "neutral-color"
+    },
+    typography: {
+      fontFamily: "font-family"
+    },
+    borderRadius: "border-radius"
+  }
+};
+var createTokens = async (opts) => {
+  const { colors: colors2, typography: typography2, name, borderRadius } = opts;
+  const colorSchemes = ["light", "dark"];
+  const semantic2 = generateSemantic(colors2);
+  const tokenSets = new Map([
+    ...getDefaultTokens([
+      "primitives/globals",
+      "primitives/modes/size/small",
+      "primitives/modes/size/medium",
+      "primitives/modes/size/large",
+      "primitives/modes/size/global",
+      "primitives/modes/typography/size/small",
+      "primitives/modes/typography/size/medium",
+      "primitives/modes/typography/size/large"
+    ]),
+    [`primitives/modes/typography/primary/${name}`, generateTypography(name, typography2)],
+    [`primitives/modes/typography/secondary/${name}`, generateTypography(name, typography2)],
+    ...colorSchemes.flatMap((scheme) => [
+      [`primitives/modes/color-scheme/${scheme}/global`, generateColorGlobal(scheme)],
+      [`primitives/modes/color-scheme/${scheme}/${name}`, generateColorScheme(name, scheme, colors2)]
+    ]),
+    [`themes/${name}`, generateTheme(colors2, name, borderRadius)],
+    ["semantic/color", semantic2.color],
+    // maps out semantic modes, ieg 'semantic/modes/main-color/accent', and 'semantic/modes/support-color/brand1'
+    ...Object.entries(semantic2.modes).flatMap(
+      ([mode, colors3]) => Object.entries(colors3).map(([key, colorSet]) => [`semantic/modes/${mode}/${key}`, colorSet])
+    ),
+    getDefaultToken("semantic/style")
+  ]);
+  return { tokenSets };
+};
+
+// src/config.ts
+function mapPathToOptionName(path5) {
+  const normalisedPath = path5[0] === "themes" ? ["theme", ...R7.drop(2, path5)] : path5;
+  const option = R7.path(normalisedPath, cliOptions);
+  if (typeof option !== "string") {
+    return;
+  }
+  return option;
+}
+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({
+  description: `A hex color, which is used for creating a color scale. Invalid color names: ${RESERVED_COLORS.join(", ")}`
+}).regex(colorRegex).transform(convertToHex);
+var colorCategorySchema = z.record(
+  z.string().regex(new RegExp(reservedColorsPattern, "i"), {
+    message: `Color names cannot include reserved names: ${RESERVED_COLORS.join(", ")}`
+  }),
+  colorSchema,
+  {
+    description: "One or more color definitions",
+    invalid_type_error: "Color definitions must be hex color values"
+  }
+).refine((colors2) => !Object.keys(colors2).some((key) => RESERVED_COLORS.includes(key.toLowerCase())), {
+  message: `Color names cannot include reserved names: ${RESERVED_COLORS.join(", ")}`
+});
+var themeSchema = z.object(
+  {
+    colors: z.object(
+      {
+        main: colorCategorySchema,
+        support: colorCategorySchema.optional().default({}),
+        neutral: colorSchema
+      },
+      { description: "Defines the colors for this theme" }
+    ),
+    typography: z.object(
+      {
+        fontFamily: z.string({ description: "Sets the font-family for this theme" })
+      },
+      { description: "Defines the typography for a given theme" }
+    ).optional(),
+    borderRadius: z.number({ description: "Defines the border-radius for this theme" }).optional()
+  },
+  { description: "An object defining a theme. The property name holding the object becomes the theme name." }
+);
+var configFileSchema = z.object({
+  outDir: z.string({ description: "Path to the output directory for the created design tokens" }).optional(),
+  clean: z.boolean({ description: "Delete the output directory before building or creating tokens" }).optional(),
+  themes: z.record(themeSchema, {
+    description: "An object with one or more themes. Each property defines a theme, and the property name is used as the theme name."
+  })
+});
+var combinedConfigSchema = configFileSchema.required();
+
+// src/migrations/codemods/css/plugins.ts
+import chalk from "chalk";
+import hash from "object-hash";
+import * as R8 from "ramda";
+var printDelete = (text) => console.log(`${chalk.red("Deleted:")} ${text}`.replace(/"|'/g, ""));
+var deleteMsg = (decl, from) => `${chalk.yellow(from)} @ ${chalk.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: prop2 } = decl;
+    const deleted = /* @__PURE__ */ new Set();
+    for (const [from, to] of Object.entries(dictionary)) {
+      if (R8.isNotEmpty(to)) {
+        if (to === "[delete]") {
+          deleted.add(deleteMsg(decl, from));
+        }
+        if (R8.includes(from, value)) {
+          decl.value = value.replace(from, to);
+          continue;
+        }
+        if (R8.includes(from, prop2) && decl.variable) {
+          decl.prop = prop2.replace(from, to);
+        }
+      }
+    }
+    if (deleted.size > 0) {
+      Array.from(deleted).forEach(printDelete);
+    }
+  }
+});
+
+// src/migrations/codemods/css/run.ts
+import fs2 from "node:fs";
+import glob from "fast-glob";
+import postcss from "postcss";
+
+// src/utils.ts
+import fs from "node:fs/promises";
+import chalk2 from "chalk";
+var mkdir = async (dir, dry) => {
+  if (dry) {
+    console.log(`${chalk2.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 });
+};
+var writeFile = async (path5, data, dry) => {
+  if (dry) {
+    console.log(`${chalk2.blue("writeFile")} ${path5}`);
+    return Promise.resolve();
+  }
+  return fs.writeFile(path5, data, { encoding: "utf-8" }).catch((error) => {
+    console.error(chalk2.red(`Error writing file: ${path5}`));
+    console.error(chalk2.red(error));
+    throw error;
+  });
+};
+var cleanDir = async (dir, dry) => {
+  if (dry) {
+    console.log(`${chalk2.blue("cleanDir")} ${dir}`);
+    return Promise.resolve();
+  }
+  console.log(`
+\u{1F525} Cleaning dir ${chalk2.red(`${dir.trim()}`)} `);
+  return fs.rm(dir, { recursive: true, force: true });
+};
+var readFile = async (path5, dry) => {
+  if (dry) {
+    console.log(`${chalk2.blue("readFile")} ${path5}`);
+    return Promise.resolve("");
+  }
+  return fs.readFile(path5, "utf-8");
+};
+
+// 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 = readFile(file).toString();
+      const result = await processor.process(contents, { from: file });
+      fs2.writeFileSync(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 R9 from "ramda";
+var replace = (oldTemplate, newTemplate, colors2, placeholder = "[color]") => R9.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 path2 from "node:path";
+import chalk6 from "chalk";
+import * as R23 from "ramda";
+
+// src/tokens/process/theme.ts
+import * as R10 from "ramda";
+import chalk3 from "chalk";
+
+// package.json
+var package_default = {
+  name: "@digdir/designsystemet",
+  version: "1.0.5",
+  description: "CLI for Designsystemet",
+  author: "Designsystemet team",
+  engines: {
+    node: ">=22.14.0"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/digdir/designsystemet.git"
+  },
+  homepage: "https://github.com/digdir/designsystemet/tree/main/scripts/cli",
+  license: "MIT",
+  type: "module",
+  main: "./dist/src/index.js",
+  files: [
+    "./dist/**"
+  ],
+  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"
+    }
+  },
+  publishConfig: {
+    access: "public"
+  },
+  scripts: {
+    designsystemet: "tsx ./bin/designsystemet.ts",
+    "build:tokens": "yarn designsystemet tokens build -p -t ../../design-tokens -o ../../packages/theme/brand --clean",
+    "build:tokens:debug": "tsx --inspect-brk ./bin/designsystemet.ts tokens build -p -t ../../design-tokens -o ../../packages/theme/brand --clean",
+    build: "tsup && yarn build:types && yarn build:json-schema",
+    "build:types": "tsc --emitDeclarationOnly --declaration",
+    "build:json-schema": "tsx ./src/scripts/createJsonSchema.ts",
+    types: "tsc --noEmit",
+    "test:tokens-create-options": "yarn designsystemet tokens create -m dominant:#007682  -n #003333 -b 99 -o ./test-tokens/options --theme options --clean",
+    "test:tokens-create-config": "yarn designsystemet tokens create --config ./test/test-tokens.config.json",
+    "test:tokens-build": "yarn designsystemet tokens build -t ./test-tokens/options -o ./test-tokens/options-build --clean",
+    "test:tokens-build-config": "yarn designsystemet tokens build -t ./test-tokens/config -o ./test-tokens/config-build --clean",
+    "test:tokens-create-and-build-options": "yarn test:tokens-create-options && yarn test:tokens-build",
+    "test:tokens-create-and-build-config": "yarn test:tokens-create-config && yarn test:tokens-build-config",
+    test: "yarn test:tokens-create-and-build-options && yarn test:tokens-create-and-build-config",
+    "internal:tokens-create": "yarn designsystemet tokens create --config ./internal.config.json",
+    "update:template": "tsx ./src/scripts/update-template.ts",
+    "update:design-tokens": "yarn internal:tokens-create && tsx ./src/scripts/update-design-tokens.ts",
+    verify: "yarn test && yarn update:template && yarn update:design-tokens"
+  },
+  dependencies: {
+    "@commander-js/extra-typings": "^13.1.0",
+    "@tokens-studio/sd-transforms": "1.2.12",
+    "apca-w3": "^0.1.9",
+    chalk: "^5.4.1",
+    "change-case": "^5.4.4",
+    "chroma-js": "^3.1.2",
+    commander: "^13.1.0",
+    "fast-glob": "^3.3.3",
+    hsluv: "^1.0.1",
+    "object-hash": "^3.0.0",
+    postcss: "^8.5.3",
+    ramda: "^0.30.1",
+    "style-dictionary": "^4.3.3",
+    zod: "^3.24.2",
+    "zod-validation-error": "^3.4.0"
+  },
+  devDependencies: {
+    "@types/apca-w3": "^0.1.3",
+    "@types/chroma-js": "^3.1.1",
+    "@types/fs-extra": "^11.0.4",
+    "@types/glob": "^8.1.0",
+    "@types/jscodeshift": "^0.12.0",
+    "@types/node": "^22.14.0",
+    "@types/object-hash": "^3.0.6",
+    "@types/ramda": "^0.30.2",
+    "fs-extra": "^11.3.0",
+    "ts-toolbelt": "^9.6.0",
+    tslib: "^2.8.1",
+    tsup: "^8.4.0",
+    tsx: "^4.19.3",
+    typescript: "^5.8.2",
+    "zod-to-json-schema": "^3.24.5"
+  }
+};
+
+// src/tokens/process/theme.ts
+var defaultFileHeader = `build: v${package_default.version}`;
+var createThemeCSSFiles = ({
+  processedBuilds,
+  fileHeader: fileHeader2 = defaultFileHeader
+}) => {
+  const groupedByTheme = {};
+  for (const [_, buildResults] of Object.entries(R10.dissoc("types", processedBuilds))) {
+    for (const buildResult of buildResults) {
+      const themeName = buildResult.permutation.theme;
+      const newOutputs = buildResult.formatted;
+      if (R10.isNotEmpty(newOutputs)) {
+        const currentOutputs = groupedByTheme[themeName] ?? [];
+        groupedByTheme[themeName] = R10.concat(currentOutputs, newOutputs);
+      }
+    }
+  }
+  const sortOrder = [
+    "color-scheme/light",
+    "typography/secondary",
+    "semantic",
+    "color-scheme/dark",
+    "color-scheme/contrast",
+    "typography/primary",
+    "color/"
+  ];
+  const sortByDefinedOrder = R10.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(
+        chalk3.yellow("WARNING: CSS section does not have a defined sort order:", filePath.replace(".css", ""))
+      );
+      console.log(
+        chalk3.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";
+
+@layer ds.theme, ds.base, ds.utilities, ds.components;
+
+/*
+${fileHeader2}
+*/
+
+`;
+  const sortAlphabetically = R10.sort(R10.ascend((x) => x.destination || ""));
+  const pickOutputs = R10.map(R10.view(R10.lensProp("output")));
+  const themeCSSFile = R10.pipe(
+    sortAlphabetically,
+    sortByDefinedOrder,
+    pickOutputs,
+    R10.join("\n"),
+    (content) => header + content
+  );
+  const themeCSSFiles = Object.entries(groupedByTheme).map(([theme, files]) => ({
+    destination: `${theme}.css`,
+    output: themeCSSFile(files)
+  }));
+  return themeCSSFiles;
+};
+
+// src/tokens/process/platform.ts
+import chalk5 from "chalk";
+import * as R22 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 R21 from "ramda";
+import StyleDictionary from "style-dictionary";
+
+// src/tokens/utils.ts
+import * as R11 from "ramda";
+var mapToLowerCase = R11.map(R11.toLower);
+var hasAnyTruth = R11.any(R11.equals(true));
+var getType = (token) => (token.$type ?? token.type) || "";
+var getValue = (token) => token.$value ?? token.value;
+var typeEquals = R11.curry((types, token) => {
+  if (R11.isNil(token)) {
+    return false;
+  }
+  return R11.includes(R11.toLower(getType(token)), R11.map(R11.toLower, Array.isArray(types) ? types : [types]));
+});
+var pathStartsWithOneOf = R11.curry((paths, token) => {
+  if (R11.isNil(token)) {
+    return false;
+  }
+  const tokenPath = mapToLowerCase(token.path);
+  const matchPathsStartingWith = R11.map((path5) => R11.startsWith([path5], tokenPath), mapToLowerCase(paths));
+  return hasAnyTruth(matchPathsStartingWith);
+});
+function isSemanticToken(token) {
+  return token.filePath.includes("semantic/");
+}
+function isSemanticColorToken(token, color) {
+  return token.filePath.includes("semantic/") && R11.startsWith(["color", color], token.path);
+}
+function isGlobalColorToken(token) {
+  return typeEquals("color", token) && pathStartsWithOneOf(["global"], token);
+}
+function isColorCategoryToken(token, category) {
+  if (!category) {
+    return ["main", "support"].some((c) => isColorCategoryToken(token, c));
+  }
+  return R11.startsWith(["color", category], token.path);
+}
+var isDigit = (s) => /^\d+$/.test(s);
+function traverseObj(obj, fn) {
+  for (const key in obj) {
+    const prop2 = obj[key];
+    if (prop2 != null) {
+      fn.apply(null, [obj, key, prop2]);
+      if (typeof prop2 === "object") {
+        traverseObj(prop2, fn);
+      }
+    }
+  }
+  return obj;
+}
+function inlineTokens(shouldInline, tokens) {
+  const [inlineableTokens, otherTokens] = R11.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 = R11.set(R11.lensPath(["original", "$value"]), transformed, token);
+    return tokenWithInlinedRefs;
+  });
+}
+
+// src/tokens/process/configs/color.ts
+import * as R16 from "ramda";
+
+// src/tokens/process/formats/css/color.ts
+import * as R12 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, file, 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(
+      R12.allPass([
+        R12.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 formattedTokens = filteredAllTokens.map(format).join("\n");
+    const content = `{
+${formattedTokens}
+${colorSchemeProperty}}
+`;
+    const autoSelectorContent = ["light", "dark"].includes(colorScheme_) ? prefersColorScheme(colorScheme_, content) : "";
+    const body = R12.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 format = R12.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 formattedTokens = dictionary.allTokens.map(format).join("\n");
+    const content = `{
+${formattedTokens}
+}
+`;
+    const body = R12.isNotNil(layer) ? `@layer ${layer} {
+${selector} ${content}
+}
+` : `${selector} ${content}
+`;
+    return body;
+  }
+};
+
+// src/tokens/process/formats/css/semantic.ts
+import * as R13 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 = R13.anyPass([isNumericBorderRadiusToken, isNumericSizeToken, isSizeToken]);
+var overrideSizingFormula = (format, token) => {
+  const [name, value] = format(token).split(":");
+  const calc = value.replace(`var(--ds-size-mode-font-size)`, "1em").replace(/floor\((.*)\);/, "calc($1)");
+  const round = `round(down, ${calc}, 0.0625rem)`;
+  return {
+    name,
+    round,
+    calc
+  };
+};
+var formatSizingTokens = (format, tokens) => {
+  const { round, calc } = R13.reduce(
+    (acc, token) => {
+      const { round: round2, calc: calc2, name } = overrideSizingFormula(format, token);
+      return {
+        round: [...acc.round, `${name}: ${round2};`],
+        calc: [...acc.calc, `${name}: ${calc2};`]
+      };
+    },
+    { round: [], calc: [] },
+    tokens
+  );
+  return `
+${calc.join("\n")}
+
+  @supports (width: round(down, .1em, 1px)) {
+${round.join("\n")}
+  }`;
+};
+var semantic = {
+  name: "ds/css-semantic",
+  format: async ({ dictionary, file, options, platform }) => {
+    const { outputReferences, usesDtcg } = options;
+    const { selector, layer } = platform;
+    const format = createPropertyFormatter2({
+      outputReferences,
+      dictionary,
+      format: "css",
+      usesDtcg
+    });
+    const tokens = inlineTokens(isInlineTokens, dictionary.allTokens);
+    const filteredTokens = R13.reject((token) => token.name.includes("ds-size-mode-font-size"), tokens);
+    const [sizingTokens, restTokens] = R13.partition(
+      (t) => pathStartsWithOneOf(["_size"], t) && isDigit(t.path[1]),
+      filteredTokens
+    );
+    const formattedTokens = [R13.map(format, restTokens).join("\n"), formatSizingTokens(format, sizingTokens)];
+    const content = `{
+${formattedTokens.join("\n")}
+}
+`;
+    const body = R13.isNotNil(layer) ? `@layer ${layer} {
+${selector} ${content}
+}
+` : `${selector} ${content}
+`;
+    return body;
+  }
+};
+
+// src/tokens/process/formats/css/typography.ts
+import * as R14 from "ramda";
+import { createPropertyFormatter as createPropertyFormatter3 } from "style-dictionary/utils";
+var typographyFontFamilyPredicate = R14.allPass([
+  R14.pathSatisfies(R14.includes("typography"), ["path"]),
+  R14.pathSatisfies(R14.includes("fontFamily"), ["path"])
+]);
+var typography = {
+  name: "ds/css-typography",
+  format: async ({ dictionary, file, options, platform }) => {
+    const { outputReferences, usesDtcg } = options;
+    const { selector, layer } = platform;
+    const format = createPropertyFormatter3({
+      outputReferences,
+      dictionary,
+      format: "css",
+      usesDtcg
+    });
+    const filteredTokens = R14.reject(typographyFontFamilyPredicate, dictionary.allTokens);
+    const formattedTokens = R14.pipe(R14.map(format), R14.join("\n"))(filteredTokens);
+    const content = selector ? `${selector} {
+${formattedTokens}
+}` : formattedTokens;
+    const body = R14.isNotNil(layer) ? `@layer ${layer} {
+${content}
+}` : content;
+    return body;
+  }
+};
+
+// src/tokens/process/formats/css.ts
+var formats = {
+  colorScheme,
+  colorCategory,
+  semantic,
+  typography
+};
+
+// src/tokens/process/transformers.ts
+import { checkAndEvaluateMath } from "@tokens-studio/sd-transforms";
+import * as R15 from "ramda";
+var isPx = R15.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(["spacing", "sizing", "border-radius", "font-size"], token);
+    return hasWantedType && hasWantedPath;
+  },
+  transform: (token, config) => {
+    const value = getValue(token);
+    if (isPx(value)) {
+      const baseFont = config.basePxFontSize || 16;
+      const size = parseInt(value);
+      if (size === 0) {
+        return "0";
+      }
+      return `${size / 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))
+};
+
+// 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/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) && !R16.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?.rootColor;
+  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 R17 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 = R17.anyPass([R17.includes("primitives/global")])(token.filePath);
+              const isPrivateToken = R17.includes("_", token.path);
+              const unwantedPaths = pathStartsWithOneOf(["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);
+            const isWantedSize = pathStartsWithOneOf(["size", "_size"], token) && isDigit(token.path[1]);
+            return (include || isWantedSize) && outputReferencesFilter(token, options);
+          }
+        }
+      }
+    }
+  };
+};
+
+// src/tokens/process/configs/storefront.ts
+import * as R19 from "ramda";
+import { outputReferencesFilter as outputReferencesFilter2 } from "style-dictionary/utils";
+
+// src/tokens/process/formats/js-tokens.ts
+import * as R18 from "ramda";
+import { createPropertyFormatter as createPropertyFormatter4, fileHeader } from "style-dictionary/utils";
+var groupByType = R18.groupBy((token) => getType(token));
+var removeUnwatedTokens = R18.pipe(
+  R18.reject((token) => isColorCategoryToken(token)),
+  R18.reject((token) => R18.any((path5) => path5.startsWith("_"))(token.path))
+);
+var dissocExtensions = R18.pipe(R18.dissoc("$extensions"), R18.dissocPath(["original", "$extensions"]));
+var removeUnwatedProps = R18.map((token) => dissocExtensions(token));
+var toCssVarName = R18.pipe(R18.split(":"), R18.head, R18.trim);
+var jsTokens = {
+  name: "ds/js-tokens",
+  format: async ({ dictionary, file, options }) => {
+    const { usesDtcg, outputReferences } = options;
+    const format = createPropertyFormatter4({
+      outputReferences,
+      dictionary,
+      format: "css",
+      usesDtcg
+    });
+    const formatTokens = R18.map((token) => {
+      if (pathStartsWithOneOf(["size", "_size"], token)) {
+        const { calc, name } = overrideSizingFormula(format, token);
+        return {
+          ...token,
+          name: name.trim(),
+          $value: calc.trim()
+        };
+      }
+      return {
+        ...token,
+        name: toCssVarName(format(token))
+      };
+    });
+    const processTokens = R18.pipe(removeUnwatedTokens, removeUnwatedProps, formatTokens, groupByType);
+    const tokens = processTokens(inlineTokens(isInlineTokens, dictionary.allTokens));
+    const content = Object.entries(tokens).map(
+      ([name, token]) => `export const  ${name} = ${JSON.stringify(token, null, 2).replace(/"([^"]+)":/g, "$1:")} 
+`
+    ).join("\n");
+    return fileHeader({ file }).then((fileHeaderText) => fileHeaderText + content);
+  }
+};
+
+// src/tokens/process/configs/storefront.ts
+var typescriptTokens = ({ "color-scheme": colorScheme2, theme }) => {
+  return {
+    preprocessors: ["tokens-studio"],
+    platforms: {
+      ts: {
+        prefix,
+        basePxFontSize,
+        transforms: dsTransformers,
+        buildPath: `${theme}/`,
+        files: [
+          {
+            destination: `${colorScheme2}.ts`,
+            format: jsTokens.name,
+            filter: (token) => {
+              if (pathStartsWithOneOf(["border-width", "letter-spacing", "border-radius"], token) && !R19.includes("semantic", token.filePath))
+                return false;
+              const isSemanticColor = R19.includes("semantic", token.filePath) && typeEquals(["color"], token);
+              const wantedTypes = typeEquals(["shadow", "dimension", "typography", "opacity"], token);
+              return isSemanticColor || wantedTypes;
+            }
+          }
+        ],
+        options: {
+          outputReferences: (token, options) => {
+            const include = pathStartsWithOneOf(["border-radius"], token);
+            const isWantedSize = pathStartsWithOneOf(["size", "_size"], token) && isDigit(token.path[1]);
+            return (include || isWantedSize) && outputReferencesFilter2(token, options);
+          }
+        }
+      }
+    }
+  };
+};
+
+// 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",
+          typographyName.name
+        ],
+        files: [
+          {
+            destination: `typography/${typography2}.css`,
+            format: formats.typography.name,
+            filter: (token) => {
+              const included = typeEquals(
+                ["typography", "fontweight", "fontFamily", "lineHeight", "dimension", "font", "fontsize"],
+                token
+              );
+              if (/primitives\/modes\/typography\/(primary|secondary)/.test(token.filePath)) return false;
+              return included && !pathStartsWithOneOf(["spacing", "sizing", "size", "_size", "border-width", "border-radius"], token);
+            }
+          }
+        ]
+      }
+    }
+  };
+};
+
+// ../../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/@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/@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/@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/@tokens-studio/types/dist/constants/TokenSetStatus.js
+var TokenSetStatus;
+(function(TokenSetStatus2) {
+  TokenSetStatus2["DISABLED"] = "disabled";
+  TokenSetStatus2["SOURCE"] = "source";
+  TokenSetStatus2["ENABLED"] = "enabled";
+})(TokenSetStatus || (TokenSetStatus = {}));
+
+// ../../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/@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/@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/@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/@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 chalk4 from "chalk";
+import { kebabCase } from "change-case";
+import * as R20 from "ramda";
+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 keys3 = R20.keys(grouped$themes);
+  const nonDependentKeys = keys3.filter((x) => ![...ALL_DEPENDENT_ON, ...dimensions].includes(x));
+  if (verboseLogging) {
+    console.log(chalk4.cyan(`\u{1F50E} Finding theme permutations for ${dimensions}`));
+    console.log(chalk4.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 rawTheme of themes) {
+    const theme = processThemeObject(rawTheme);
+    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 = R20.pipe(R20.values, R20.none(R20.equals("unknown")), R20.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 = R20.lensProp(group);
+          updatedPermutation = R20.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())));
+}
+
+// src/tokens/process/configs.ts
+void register(StyleDictionary, { withSDBuiltins: false });
+StyleDictionary.registerTransform(sizeRem);
+StyleDictionary.registerTransform(typographyName);
+StyleDictionary.registerTransform(resolveMath);
+StyleDictionary.registerTransform(unitless);
+StyleDictionary.registerFormat(jsTokens);
+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" }),
+  typographyVariables,
+  semanticVariables,
+  typescriptTokens
+};
+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 = R21.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: [],
+  permutation: {
+    "color-scheme": "",
+    "main-color": "",
+    "support-color": "",
+    semantic: "",
+    size: "",
+    theme: "",
+    typography: ""
+  }
+};
+var buildOptions;
+var sd = new StyleDictionary2();
+var getCustomColors = (processed$themes) => processed$themes.filter(
+  (x) => x.group && [colorCategories.main, colorCategories.support].map((c) => `${c}-color`).includes(x.group)
+).map((x) => x.name);
+var buildConfigs = {
+  typography: { getConfig: configs.typographyVariables, dimensions: ["typography"] },
+  "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"] }
+  // storefront: {
+  //   name: 'Storefront preview tokens',
+  //   getConfig: configs.typescriptTokens,
+  //   dimensions: ['color-scheme'],
+  //   options: { outPath: path.resolve('../../apps/storefront/tokens') },
+  //   enabled: () => buildOptions?.preview ?? false,
+  // },
+};
+async function processPlatform(options) {
+  const { process: process2, $themes } = options;
+  const platform = "css";
+  const tokenSets = process2 === "format" ? options.tokenSets : void 0;
+  const tokensDir = process2 === "build" ? options.tokensDir : void 0;
+  buildOptions = options;
+  const processed$themes = $themes.map(processThemeObject).filter((theme) => R22.not(theme.group === "size" && theme.name !== "medium"));
+  const customColors = getCustomColors(processed$themes);
+  if (!buildOptions.rootColor) {
+    const firstMainColor = R22.head(customColors);
+    buildOptions.rootColor = firstMainColor;
+    console.log(`Using first main color; ${chalk5.blue(firstMainColor)}, as ${chalk5.green(`":root"`)} color`);
+  }
+  const buildAndSdConfigs = R22.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],
+    types: [initResult]
+  };
+  try {
+    for (const [buildName, { buildConfig, sdConfigs }] of R22.toPairs(buildAndSdConfigs)) {
+      if (!(buildConfig.enabled?.() ?? true)) {
+        continue;
+      }
+      if (sdConfigs.length > 0) {
+        console.log(`
+\u{1F371} Building ${chalk5.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 = R22.isNil(buildConfig.log) ? modeMessage : buildConfig?.log(sdConfig);
+            console.log(logMessage);
+            const sdOptions = { cache: true };
+            const sdExtended = await sd.extend(config);
+            const result = {
+              permutation,
+              formatted: await sdExtended.formatPlatform(platform, sdOptions)
+            };
+            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;
+  }
+  const colorsFileName = "colors.d.ts";
+  const reactColorTypes = await createColorTypeDeclaration(customColors);
+  processedBuilds.types = [
+    {
+      ...initResult,
+      formatted: [{ output: reactColorTypes, destination: colorsFileName }]
+    }
+  ];
+  return processedBuilds;
+}
+async function createColorTypeDeclaration(colors2) {
+  console.log(`
+\u{1F371} Building ${chalk5.green("type declarations")}`);
+  const typeDeclaration = `
+import type {} from '@digdir/designsystemet-react/colors';
+
+declare module '@digdir/designsystemet-react/colors' {
+  export interface MainAndSupportColors {
+${colors2.map((color) => `    ${color}: never;`).join("\n")}
+  }
+}
+`.trimStart();
+  return typeDeclaration;
+}
+
+// src/tokens/build.ts
+async function write(files, outDir, dry) {
+  for (const { destination, output } of files) {
+    if (destination) {
+      const filePath = path2.join(outDir, destination);
+      const fileDir = path2.dirname(filePath);
+      console.log(destination);
+      await mkdir(fileDir, dry);
+      await writeFile(filePath, output, dry);
+    }
+  }
+}
+var buildTokens = async (options) => {
+  const outDir = path2.resolve(options.outDir);
+  const tokensDir = path2.resolve(options.tokensDir);
+  const $themes = JSON.parse(await readFile(`${tokensDir}/$themes.json`));
+  let $designsystemet;
+  try {
+    const $designsystemetContent = await readFile(`${tokensDir}/$designsystemet.json`);
+    $designsystemet = JSON.parse($designsystemetContent);
+  } catch (error) {
+  }
+  console.log(`
+\u{1F3D7}\uFE0F Start building tokens in ${chalk6.green(tokensDir)}`);
+  const processedBuilds = await processPlatform({
+    ...options,
+    outDir,
+    tokensDir,
+    process: "build",
+    $themes
+  });
+  if (options.clean) {
+    await cleanDir(outDir, options.dry);
+  }
+  console.log(`
+\u{1F4BE} Writing build to ${chalk6.green(outDir)}`);
+  for (const { formatted } of processedBuilds.types) {
+    await write(formatted, outDir, options.dry);
+  }
+  const fileHeader2 = R23.join("")([
+    defaultFileHeader,
+    $designsystemet ? `
+design-tokens: v${$designsystemet.version} ` : ""
+  ]);
+  await write(createThemeCSSFiles({ processedBuilds, fileHeader: fileHeader2 }), outDir, options.dry);
+  console.log(`
+\u2705 Finished building tokens!`);
+  return processedBuilds;
+};
+
+// src/tokens/create/write.ts
+import path3 from "node:path";
+import chalk7 from "chalk";
+import * as R24 from "ramda";
+
+// 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) {
+  return {
+    tokenSetOrder: [
+      "primitives/globals",
+      "primitives/modes/size/small",
+      "primitives/modes/size/medium",
+      "primitives/modes/size/large",
+      "primitives/modes/size/global",
+      "primitives/modes/typography/size/small",
+      "primitives/modes/typography/size/medium",
+      "primitives/modes/typography/size/large",
+      ...themes.map((theme) => `primitives/modes/typography/primary/${theme}`),
+      ...themes.map((theme) => `primitives/modes/typography/secondary/${theme}`),
+      ...schemes.flatMap((scheme) => [
+        `primitives/modes/color-scheme/${scheme}/global`,
+        ...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) {
+  return [
+    ...generateSizeGroup(),
+    ...await generateThemesGroup(themes),
+    ...generateTypographyGroup(themes),
+    ...generateColorSchemesGroup(colorSchemes, themes),
+    generateSemanticGroup(),
+    ...await generateColorGroup("main", colors2),
+    ...await generateColorGroup("support", colors2)
+  ];
+}
+function generateSizeGroup() {
+  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([
+        [`primitives/modes/color-scheme/${scheme}/global`, TokenSetStatus.ENABLED],
+        ...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/write.ts
+var stringify = (data) => JSON.stringify(data, null, 2);
+var writeTokens = async (options) => {
+  const {
+    outDir,
+    tokenSets,
+    theme: { name: themeName, colors: colors2 },
+    dry
+  } = options;
+  const targetDir = path3.resolve(process.cwd(), String(outDir));
+  const $themesPath = path3.join(targetDir, "$themes.json");
+  const $metadataPath = path3.join(targetDir, "$metadata.json");
+  const $designsystemetPath = path3.join(targetDir, "$designsystemet.json");
+  let themeObjects = [];
+  await mkdir(targetDir, dry);
+  try {
+    const $themes2 = await readFile($themesPath);
+    if ($themes2) {
+      themeObjects = JSON.parse($themes2);
+    }
+  } catch (error) {
+  }
+  const concatThemeNames = R24.pipe(
+    R24.filter((obj) => R24.toLower(obj.group || "") === "theme"),
+    R24.map(R24.prop("name")),
+    // New theme is added to the end of the list so we keep the same order from config and Token Studio
+    R24.append(themeName),
+    R24.uniq
+  );
+  const themes = concatThemeNames(themeObjects);
+  console.log(`
+Themes: ${chalk7.blue(themes.join(", "))}`);
+  const $themes = await generate$Themes(["dark", "light"], themes, colors2);
+  const $metadata = generate$Metadata(["dark", "light"], themes, colors2);
+  const $designsystemet = generate$Designsystemet();
+  await writeFile($themesPath, stringify($themes), dry);
+  await writeFile($metadataPath, stringify($metadata), dry);
+  await writeFile($designsystemetPath, stringify($designsystemet), dry);
+  for (const [set4, tokens] of tokenSets) {
+    const fileDir = path3.join(targetDir, path3.dirname(set4));
+    await mkdir(fileDir, dry);
+    const filePath = path3.join(targetDir, `${set4}.json`);
+    await writeFile(filePath, stringify(tokens), dry);
+  }
+  console.log(
+    `Finished creating Designsystem design tokens in ${chalk7.green(outDir)} for theme ${chalk7.blue(themeName)}`
+  );
+};
+
+// 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/designsystemet.ts
 program.name("designsystemet").description("CLI for working with Designsystemet").showHelpAfterError();
 function makeTokenCommands() {
   const tokenCmd = createCommand("tokens");
@@ -21,25 +4263,25 @@ function makeTokenCommands() {
   const DEFAULT_FONT = "Inter";
   const DEFAULT_THEME_NAME = "theme";
   const DEFAULT_CONFIG_FILE = "designsystemet.config.json";
-  tokenCmd.command("build").description("Build Designsystemet tokens").option("-t, --tokens <string>", `Path to ${chalk.blue("design-tokens")}`, DEFAULT_TOKENS_CREATE_DIR).option(
+  tokenCmd.command("build").description("Build Designsystemet tokens").option("-t, --tokens <string>", `Path to ${chalk8.blue("design-tokens")}`, DEFAULT_TOKENS_CREATE_DIR).option(
     "-o, --out-dir <string>",
-    `Output directory for built ${chalk.blue("design-tokens")}`,
+    `Output directory for built ${chalk8.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 ${chalk.blue("design-tokens")}`, parseBoolean, false).option("-p, --preview", "Generate preview token.ts files", false).option("--verbose", "Enable verbose output", false).action((opts) => {
+  ).option(`--${cliOptions.clean} [boolean]`, "Clean output directory before building tokens", parseBoolean, false).option("--dry [boolean]", `Dry run for built ${chalk8.blue("design-tokens")}`, parseBoolean, false).option("-p, --preview", "Generate preview token.ts files", false).option("--verbose", "Enable verbose output", false).action(async (opts) => {
     const { preview, verbose, clean, dry } = opts;
-    const tokens = typeof opts.tokens === "string" ? opts.tokens : DEFAULT_TOKENS_CREATE_DIR;
+    const tokensDir = typeof opts.tokens === "string" ? opts.tokens : DEFAULT_TOKENS_CREATE_DIR;
     const outDir = typeof opts.outDir === "string" ? opts.outDir : "./dist/tokens";
-    console.log(`Building tokens in ${chalk.green(tokens)}`);
     if (dry) {
       console.log(`Performing dry run, no files will be written`);
     }
-    return buildTokens({ tokens, outDir, preview, verbose, dry, clean });
+    await buildTokens({ tokensDir, outDir, preview, verbose, dry, clean });
+    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 ${chalk.blue("design-tokens")}`,
+    `Output directory for created ${chalk8.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 ${chalk.blue("design-tokens")}`, parseBoolean, false).option(`-f, --${cliOptions.theme.typography.fontFamily} <string>`, `Font family (experimental)`, DEFAULT_FONT).option(
+  ).option(`--${cliOptions.clean} [boolean]`, "Clean output directory before creating tokens", parseBoolean, false).option("--dry [boolean]", `Dry run for created ${chalk8.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),
@@ -56,24 +4298,24 @@ function makeTokenCommands() {
     const propsFromJson = configFile?.config;
     if (propsFromJson) {
       const themeColors = Object.values(propsFromJson?.themes ?? {}).map(
-        (x) => /* @__PURE__ */ new Set([...R.keys(x.colors.main), ...R.keys(x.colors.support)])
+        (x) => /* @__PURE__ */ new Set([...R25.keys(x.colors.main), ...R25.keys(x.colors.support)])
       );
-      if (!R.all(R.equals(R.__, themeColors[0]), themeColors)) {
+      if (!R25.all(R25.equals(R25.__, themeColors[0]), themeColors)) {
         console.error(
-          chalk.redBright(
+          chalk8.redBright(
             `In config ${configFile.path}, all themes must have the same custom color names, but we found:`
           )
         );
-        const themeNames = R.keys(propsFromJson.themes ?? {});
-        themeColors.forEach((colors, index) => {
-          const colorNames = Array.from(colors);
+        const themeNames = R25.keys(propsFromJson.themes ?? {});
+        themeColors.forEach((colors2, index) => {
+          const colorNames = Array.from(colors2);
           console.log(`  - ${themeNames[index]}: ${colorNames.join(", ")}`);
         });
         console.log();
         process.exit(1);
       }
     }
-    const noUndefined = R.reject(R.isNil);
+    const noUndefined = R25.reject(R25.isNil);
     const getThemeOptions = (optionGetter) => noUndefined({
       colors: noUndefined({
         main: optionGetter(cmd, "mainColors"),
@@ -88,10 +4330,10 @@ function makeTokenCommands() {
     const unvalidatedConfig = noUndefined({
       outDir: propsFromJson?.outDir ?? getCliOption(cmd, "outDir"),
       clean: propsFromJson?.clean ?? getCliOption(cmd, "clean"),
-      themes: propsFromJson?.themes ? R.map((jsonThemeValues) => {
+      themes: propsFromJson?.themes ? R25.map((jsonThemeValues) => {
         const defaultThemeValues = getThemeOptions(getDefaultCliOption);
         const cliThemeValues = getThemeOptions(getSuppliedCliOption);
-        return R.mergeDeepRight(defaultThemeValues, R.mergeDeepRight(jsonThemeValues, cliThemeValues));
+        return R25.mergeDeepRight(defaultThemeValues, R25.mergeDeepRight(jsonThemeValues, cliThemeValues));
       }, propsFromJson.themes) : (
         // If there are no themes specified in the JSON config, we use both explicit
         // and default theme options from the CLI.
@@ -104,49 +4346,49 @@ function makeTokenCommands() {
     try {
       config = combinedConfigSchema.parse(unvalidatedConfig);
     } catch (err) {
-      console.error(chalk.redBright("Invalid config after combining config file and CLI options"));
+      console.error(chalk8.redBright("Invalid config after combining config file and CLI options"));
       const validationError = makeFriendlyError(err);
       console.error(validationError.toString());
       process.exit(1);
     }
-    console.log(`Creating tokens with configuration ${chalk.green(JSON.stringify(config, null, 2))}`);
+    console.log(`Creating tokens with configuration ${chalk8.green(JSON.stringify(config, null, 2))}`);
     if (config.clean) {
       await cleanDir(config.outDir, opts.dry);
     }
     for (const [name, themeWithoutName] of Object.entries(config.themes)) {
       const theme = { name, ...themeWithoutName };
-      const tokens = createTokens(theme);
-      await writeTokens({ outDir: config.outDir, tokens, theme, dry: opts.dry });
+      const { tokenSets } = await createTokens(theme);
+      await writeTokens({ outDir: config.outDir, theme, dry: opts.dry, tokenSets });
     }
   });
   return tokenCmd;
 }
 program.addCommand(makeTokenCommands());
-program.command("migrate").description("run a Designsystemet migration").addArgument(new Argument("[migration]", "Available migrations").choices(Object.keys(migrations))).option("-l --list", "List available migrations").option("-g --glob <glob>", "Glob for files upon which to apply the migration", "./**/*.(tsx|css)").action((migrationKey, opts) => {
-  const { glob, list } = opts;
+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) => {
+  const { glob: glob2, list } = opts;
   if (list) {
-    for (const key of Object.keys(migrations)) {
+    for (const key of Object.keys(migrations_default)) {
       console.log(key);
     }
   } else if (migrationKey) {
-    const migration = migrations[migrationKey];
+    const migration = migrations_default[migrationKey];
     if (!migration) {
       console.error("Migration not found!");
       throw "Aborting";
     }
-    console.log(`Applying migration ${chalk.blue(migrationKey)} with glob: ${chalk.green(glob)}`);
-    migration?.(glob).then(() => console.log(`Migration ${chalk.blue(migrationKey)} finished`)).catch((error) => console.log(error));
+    console.log(`Applying migration ${chalk8.blue(migrationKey)} with glob: ${chalk8.green(glob2)}`);
+    migration?.(glob2).then(() => console.log(`Migration ${chalk8.blue(migrationKey)} finished`)).catch((error) => console.log(error));
   } else {
     console.log("Migrate: please specify a migration name or --list");
   }
 });
 await program.parseAsync(process.argv);
 async function parseConfig(configPath, options) {
-  const resolvedPath = path.resolve(process.cwd(), configPath);
+  const resolvedPath = path4.resolve(process.cwd(), configPath);
   let configFile;
   try {
-    configFile = await fs.readFile(resolvedPath, { encoding: "utf-8" });
-    console.log(`Found config file: ${chalk.green(resolvedPath)}`);
+    configFile = await readFile(resolvedPath);
+    console.log(`Found config file: ${chalk8.green(resolvedPath)}`);
   } catch (err) {
     if (err instanceof Error) {
       const nodeErr = err;
@@ -162,7 +4404,7 @@ async function parseConfig(configPath, options) {
       config: await configFileSchema.parseAsync(JSON.parse(configFile))
     };
   } catch (err) {
-    console.error(chalk.redBright(`Invalid config in ${configPath}`));
+    console.error(chalk8.redBright(`Invalid config in ${configPath}`));
     const validationError = makeFriendlyError(err);
     console.error(validationError.toString());
     process.exit(1);
@@ -175,8 +4417,8 @@ function makeFriendlyError(err) {
       const optionName = mapPathToOptionName(issue.path);
       const errorCode = `(error code: ${issue.code})`;
       const optionMessage = optionName ? ` or CLI option --${optionName}` : "";
-      return `  - Error in JSON value ${chalk.red(issuePath)}${optionMessage}:
-    ${issue.message} ${chalk.dim(errorCode)}`;
+      return `  - Error in JSON value ${chalk8.red(issuePath)}${optionMessage}:
+    ${issue.message} ${chalk8.dim(errorCode)}`;
     }).join("\n")
   });
 }