@digdir/designsystemet 1.0.3 → 1.0.4

package/dist/src/tokens/build.js

@@ -1,18 +1,1356 @@
-import fs from "node:fs/promises";
+// src/tokens/build.ts
 import path from "node:path";
+import chalk5 from "chalk";
+
+// src/utils.ts
+import fs from "node:fs/promises";
 import chalk from "chalk";
+var mkdir = async (dir, dry) => {
+  if (dry) {
+    console.log(`${chalk.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 (path2, data, dry) => {
+  if (dry) {
+    console.log(`${chalk.blue("writeFile")} ${path2}`);
+    return Promise.resolve();
+  }
+  return fs.writeFile(path2, data, { encoding: "utf-8" }).catch((error) => {
+    console.error(chalk.red(`Error writing file: ${path2}`));
+    console.error(chalk.red(error));
+    throw error;
+  });
+};
+var cleanDir = async (dir, dry) => {
+  if (dry) {
+    console.log(`${chalk.blue("cleanDir")} ${dir}`);
+    return Promise.resolve();
+  }
+  console.log(`
+\u{1F525} Cleaning dir ${chalk.red(`${dir.trim()}`)} `);
+  return fs.rm(dir, { recursive: true, force: true });
+};
+var readFile = async (path2, dry) => {
+  if (dry) {
+    console.log(`${chalk.blue("readFile")} ${path2}`);
+    return Promise.resolve("");
+  }
+  return fs.readFile(path2, "utf-8");
+};
+
+// src/tokens/format.ts
+import * as R19 from "ramda";
+import chalk4 from "chalk";
+
+// package.json
+var package_default = {
+  name: "@digdir/designsystemet",
+  version: "1.0.4",
+  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-create --theme options-test --clean",
+    "test:tokens-create-config": "yarn designsystemet tokens create --config ./test-tokens-create-complex.config.json",
+    "test:tokens-build": "yarn designsystemet tokens build -t ./test-tokens-create -o ./test-tokens-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",
+    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/create/defaults.ts
 import * as R from "ramda";
+
+// src/tokens/create/generators/color.ts
+import * as R4 from "ramda";
+
+// src/colors/utils.ts
+import chroma from "chroma-js";
+import { Hsluv } from "hsluv";
+
+// src/colors/theme.ts
+import chroma2 from "chroma-js";
+import * as R3 from "ramda";
+
+// src/colors/colorMetadata.ts
+import * as R2 from "ramda";
+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 = R2.indexBy((metadata) => metadata.number, Object.values(colorMetadata));
+
+// src/tokens/create/generators/semantic.ts
+import * as R5 from "ramda";
+
+// src/tokens/create/generators/theme.ts
+import * as R6 from "ramda";
+
+// ../../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/platform.ts
+import chalk3 from "chalk";
+import * as R18 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 R17 from "ramda";
 import StyleDictionary from "style-dictionary";
-import { configs, getConfigsForThemeDimensions } from "./build/configs.js";
-import {
-  colorCategories
-} from "./build/types.js";
-import { makeEntryFile } from "./build/utils/entryfile.js";
-import { processThemeObject } from "./build/utils/getMultidimensionalThemes.js";
-import { cleanDir, writeFile } from "./utils.js";
-let buildOptions;
-const sd = new StyleDictionary();
-const buildConfigs = {
+
+// src/tokens/utils.ts
+import * as R7 from "ramda";
+var mapToLowerCase = R7.map(R7.toLower);
+var hasAnyTruth = R7.any(R7.equals(true));
+var getType = (token) => (token.$type ?? token.type) || "";
+var getValue = (token) => token.$value ?? token.value;
+var typeEquals = R7.curry((types, token) => {
+  if (R7.isNil(token)) {
+    return false;
+  }
+  return R7.includes(R7.toLower(getType(token)), R7.map(R7.toLower, Array.isArray(types) ? types : [types]));
+});
+var pathStartsWithOneOf = R7.curry((paths, token) => {
+  if (R7.isNil(token)) {
+    return false;
+  }
+  const tokenPath = mapToLowerCase(token.path);
+  const matchPathsStartingWith = R7.map((path2) => R7.startsWith([path2], tokenPath), mapToLowerCase(paths));
+  return hasAnyTruth(matchPathsStartingWith);
+});
+function isSemanticToken(token) {
+  return token.filePath.includes("semantic/");
+}
+function isSemanticColorToken(token, color) {
+  return token.filePath.includes("semantic/") && R7.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 R7.startsWith(["color", category], token.path);
+}
+var isDigit = (s) => /^\d+$/.test(s);
+function traverseObj(obj, fn) {
+  for (const key in obj) {
+    const prop = obj[key];
+    if (prop != null) {
+      fn.apply(null, [obj, key, prop]);
+      if (typeof prop === "object") {
+        traverseObj(prop, fn);
+      }
+    }
+  }
+  return obj;
+}
+function inlineTokens(shouldInline, tokens) {
+  const [inlineableTokens, otherTokens] = R7.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 = R7.set(R7.lensPath(["original", "$value"]), transformed, token);
+    return tokenWithInlinedRefs;
+  });
+}
+
+// src/tokens/process/configs/color.ts
+import * as R12 from "ramda";
+
+// src/tokens/process/formats/css/color.ts
+import * as R8 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(
+      R8.allPass([
+        R8.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 = R8.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 = R8.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 = R8.isNotNil(layer) ? `@layer ${layer} {
+${selector} ${content}
+}
+` : `${selector} ${content}
+`;
+    return body;
+  }
+};
+
+// src/tokens/process/formats/css/semantic.ts
+import * as R9 from "ramda";
+import { createPropertyFormatter as 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 = R9.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 } = R9.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 = R9.reject((token) => token.name.includes("ds-size-mode-font-size"), tokens);
+    const [sizingTokens, restTokens] = R9.partition(
+      (t) => pathStartsWithOneOf(["_size"], t) && isDigit(t.path[1]),
+      filteredTokens
+    );
+    const formattedTokens = [R9.map(format, restTokens).join("\n"), formatSizingTokens(format, sizingTokens)];
+    const content = `{
+${formattedTokens.join("\n")}
+}
+`;
+    const body = R9.isNotNil(layer) ? `@layer ${layer} {
+${selector} ${content}
+}
+` : `${selector} ${content}
+`;
+    return body;
+  }
+};
+
+// src/tokens/process/formats/css/typography.ts
+import * as R10 from "ramda";
+import { createPropertyFormatter as createPropertyFormatter3 } from "style-dictionary/utils";
+var typographyFontFamilyPredicate = R10.allPass([
+  R10.pathSatisfies(R10.includes("typography"), ["path"]),
+  R10.pathSatisfies(R10.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 = R10.reject(typographyFontFamilyPredicate, dictionary.allTokens);
+    const formattedTokens = R10.pipe(R10.map(format), R10.join("\n"))(filteredTokens);
+    const content = selector ? `${selector} {
+${formattedTokens}
+}` : formattedTokens;
+    const body = R10.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 R11 from "ramda";
+var isPx = R11.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) && !R12.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 R13 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 = R13.anyPass([R13.includes("primitives/global")])(token.filePath);
+              const isPrivateToken = R13.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 R15 from "ramda";
+import { outputReferencesFilter as outputReferencesFilter2 } from "style-dictionary/utils";
+
+// src/tokens/process/formats/js-tokens.ts
+import * as R14 from "ramda";
+import { createPropertyFormatter as createPropertyFormatter4, fileHeader } from "style-dictionary/utils";
+var groupByType = R14.groupBy((token) => getType(token));
+var removeUnwatedTokens = R14.pipe(
+  R14.reject((token) => isColorCategoryToken(token)),
+  R14.reject((token) => R14.any((path2) => path2.startsWith("_"))(token.path))
+);
+var dissocExtensions = R14.pipe(R14.dissoc("$extensions"), R14.dissocPath(["original", "$extensions"]));
+var removeUnwatedProps = R14.map((token) => dissocExtensions(token));
+var toCssVarName = R14.pipe(R14.split(":"), R14.head, R14.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 = R14.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 = R14.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) && !R15.includes("semantic", token.filePath))
+                return false;
+              const isSemanticColor = R15.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);
+            }
+          }
+        ]
+      }
+    }
+  };
+};
+
+// src/tokens/process/utils/getMultidimensionalThemes.ts
+import chalk2 from "chalk";
+import { kebabCase } from "change-case";
+import * as R16 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 keys2 = R16.keys(grouped$themes);
+  const nonDependentKeys = keys2.filter((x) => ![...ALL_DEPENDENT_ON, ...dimensions].includes(x));
+  if (verboseLogging) {
+    console.log(chalk2.cyan(`\u{1F50E} Finding theme permutations for ${dimensions}`));
+    console.log(chalk2.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 = R16.pipe(R16.values, R16.none(R16.equals("unknown")), R16.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 = R16.lensProp(group);
+          updatedPermutation = R16.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 = R17.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"] },
@@ -42,45 +1380,32 @@ const buildConfigs = {
     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
-  },
-  entryFiles: {
-    name: "Concatenated CSS file",
-    getConfig: configs.semanticVariables,
-    dimensions: ["semantic"],
-    log: ({ permutation: { theme } }) => `${theme}.css`,
-    build: async (sdConfigs, { outPath, dry }) => {
-      await Promise.all(
-        sdConfigs.map(async ({ permutation: { theme } }) => {
-          return makeEntryFile({ theme, outPath, buildPath: path.resolve(outPath, theme), dry });
-        })
-      );
-    }
-  }
+  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 buildTokens(options) {
-  const { dry, clean } = options;
-  const tokensDir = options.tokens;
-  const targetDir = path.resolve(options.outDir);
+async function processPlatform(options) {
+  const { dry, process, $themes } = options;
+  const platform = "css";
+  const tokenSets = process === "format" ? options.tokenSets : void 0;
+  const tokensDir = process === "build" ? options.tokensDir : void 0;
   buildOptions = options;
-  const $themes = JSON.parse(await fs.readFile(path.resolve(`${tokensDir}/$themes.json`), "utf-8")).map(processThemeObject);
-  const relevant$themes = $themes.filter((theme) => R.not(theme.group === "size" && theme.name !== "medium"));
+  const processed$themes = $themes.map(processThemeObject).filter((theme) => R18.not(theme.group === "size" && theme.name !== "medium"));
+  const customColors = getCustomColors(processed$themes);
   if (!buildOptions.rootColor) {
-    const firstMainColor = relevant$themes.find((theme) => theme.group === "main-color");
-    buildOptions.rootColor = firstMainColor?.name;
-    console.log(`Using first main color; ${chalk.blue(firstMainColor?.name)}, as ${chalk.green(`":root"`)} color`);
+    const firstMainColor = R18.head(customColors);
+    buildOptions.rootColor = firstMainColor;
+    console.log(`Using first main color; ${chalk3.blue(firstMainColor)}, as ${chalk3.green(`":root"`)} color`);
   }
-  const buildAndSdConfigs = R.map((buildConfig) => {
-    const sdConfigs = getConfigsForThemeDimensions(buildConfig.getConfig, relevant$themes, buildConfig.dimensions, {
-      outPath: targetDir,
+  const buildAndSdConfigs = R18.map((buildConfig) => {
+    const sdConfigs = getConfigsForThemeDimensions(buildConfig.getConfig, processed$themes, buildConfig.dimensions, {
       tokensDir,
-      ...buildConfig.options
+      tokenSets
     });
     const unknownConfigs = buildConfig.dimensions.map(
       (dimension) => sdConfigs.filter((x) => x.permutation[dimension] === "unknown")
@@ -95,33 +1420,44 @@ async function buildTokens(options) {
       sdConfigs
     };
   }, buildConfigs);
-  if (clean) {
-    await cleanDir(targetDir, dry);
-  }
+  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 [key, { buildConfig, sdConfigs }] of R.toPairs(buildAndSdConfigs)) {
+    for (const [buildName, { buildConfig, sdConfigs }] of R18.toPairs(buildAndSdConfigs)) {
       if (!(buildConfig.enabled?.() ?? true)) {
         continue;
       }
       if (sdConfigs.length > 0) {
         console.log(`
-\u{1F371} Building ${chalk.green(buildConfig.name ?? key)}`);
-        if (buildConfig.build) {
-          await buildConfig.build(sdConfigs, { outPath: targetDir, tokensDir, ...buildConfig.options, dry });
-        }
-        await Promise.all(
+\u{1F371} Building ${chalk3.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 = R.isNil(buildConfig.log) ? modeMessage : buildConfig?.log(sdConfig);
+            const logMessage = R18.isNil(buildConfig.log) ? modeMessage : buildConfig?.log(sdConfig);
             console.log(logMessage);
-            if (!dry) {
-              return (await sd.extend(config)).buildAllPlatforms();
-            }
-            return Promise.resolve();
+            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) {
@@ -130,28 +1466,133 @@ async function buildTokens(options) {
     }
     throw err;
   }
-  await writeColorTypeDeclaration($themes, targetDir, dry);
-}
-async function writeColorTypeDeclaration($themes, outPath, dry) {
   const colorsFileName = "colors.d.ts";
+  const reactColorTypes = await createColorTypeDeclaration(customColors);
+  processedBuilds.types = [
+    {
+      ...initResult,
+      formatted: [{ output: reactColorTypes, destination: colorsFileName }]
+    }
+  ];
+  return processedBuilds;
+}
+async function createColorTypeDeclaration(colors) {
   console.log(`
-\u{1F371} Building ${chalk.green("type declarations")}`);
-  console.log(colorsFileName);
-  const mainAndSupportColors = $themes.filter(
-    (x) => x.group && [colorCategories.main, colorCategories.support].map((c) => `${c}-color`).includes(x.group)
-  ).map((x) => x.name);
+\u{1F371} Building ${chalk3.green("type declarations")}`);
   const typeDeclaration = `
 import type {} from '@digdir/designsystemet-react/colors';
 
 declare module '@digdir/designsystemet-react/colors' {
   export interface MainAndSupportColors {
-${mainAndSupportColors.map((color) => `    ${color}: never;`).join("\n")}
+${colors.map((color) => `    ${color}: never;`).join("\n")}
   }
 }
 `.trimStart();
-  await writeFile(path.resolve(outPath, colorsFileName), typeDeclaration, dry);
+  return typeDeclaration;
 }
+
+// src/tokens/format.ts
+var createThemeCSSFiles = (processedBuilds) => {
+  const groupedByTheme = {};
+  for (const [_, buildResults] of Object.entries(R19.dissoc("types", processedBuilds))) {
+    for (const buildResult of buildResults) {
+      const previous = groupedByTheme[buildResult.permutation.theme] ?? [];
+      groupedByTheme[buildResult.permutation.theme] = R19.concat(previous, buildResult.formatted);
+    }
+  }
+  const sortOrder = [
+    "color-scheme/light",
+    "typography/secondary",
+    "semantic",
+    "color-scheme/dark",
+    "color-scheme/contrast",
+    "typography/primary",
+    "color/"
+  ];
+  const sortByDefinedOrder = R19.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(
+        chalk4.yellow("WARNING: CSS section does not have a defined sort order:", filePath.replace(".css", ""))
+      );
+      console.log(
+        chalk4.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;
+
+/* This file is generated by ${package_default.name}@${package_default.version} */
+
+`;
+  const sortAlphabetically = R19.sort(R19.ascend((x) => x.destination || ""));
+  const pickOutputs = R19.map(R19.view(R19.lensProp("output")));
+  const themeCSSFile = R19.pipe(
+    sortAlphabetically,
+    sortByDefinedOrder,
+    pickOutputs,
+    R19.join("\n"),
+    (content) => header + content
+  );
+  const themeCSSFiles = Object.entries(groupedByTheme).map(([theme, files]) => ({
+    destination: `${theme}.css`,
+    output: themeCSSFile(files)
+  }));
+  return themeCSSFiles;
+};
+
+// src/tokens/build.ts
+async function write(files, outDir, dry) {
+  for (const { destination, output } of files) {
+    if (destination) {
+      const filePath = path.join(outDir, destination);
+      const fileDir = path.dirname(filePath);
+      console.log(destination);
+      await mkdir(fileDir, dry);
+      await writeFile(filePath, output, dry);
+    }
+  }
+}
+var buildTokens = async (options) => {
+  const outDir = path.resolve(options.outDir);
+  const tokensDir = path.resolve(options.tokensDir);
+  const $themes = JSON.parse(await readFile(`${tokensDir}/$themes.json`));
+  console.log(`
+\u{1F3D7}\uFE0F Start building tokens in ${chalk5.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 ${chalk5.green(outDir)}`);
+  for (const { formatted } of processedBuilds.types) {
+    await write(formatted, outDir, options.dry);
+  }
+  await write(createThemeCSSFiles(processedBuilds), outDir, options.dry);
+  console.log(`
+\u2705 Finished building tokens!`);
+  return processedBuilds;
+};
 export {
-  buildOptions,
   buildTokens
 };