@digdir/designsystemet 1.0.3 → 1.0.5

package/dist/src/tokens/index.js

@@ -1,5 +1,3545 @@
-import { createTokens, cliOptions } from "./create.js";
+// src/tokens/create/defaults.ts
+import * as R 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(R.pick(tokenSets, defaultTokens));
+var getDefaultToken = (tokenPath) => {
+  return [tokenPath, defaultTokens[tokenPath]];
+};
+
+// src/tokens/create/generators/color.ts
+import * as R4 from "ramda";
+
+// 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;
+};
+
+// src/colors/theme.ts
+import chroma2 from "chroma-js";
+import * as R3 from "ramda";
+
+// src/colors/colorMetadata.ts
+import * as R2 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 = R2.indexBy((metadata) => metadata.number, Object.values(colorMetadata));
+
+// src/colors/theme.ts
+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 colors = R3.mapObjIndexed((colorData) => {
+    const luminance = colorData.luminance[colorScheme2];
+    return {
+      ...colorData,
+      hex: chroma2(interpolationColor).luminance(luminance).hex()
+    };
+  }, colorMetadata);
+  const baseColors2 = generateBaseColors(color, colorScheme2);
+  colors["base-default"] = { ...colors["base-default"], hex: baseColors2.default };
+  colors["base-hover"] = { ...colors["base-hover"], hex: baseColors2.hover };
+  colors["base-active"] = { ...colors["base-active"], hex: baseColors2.active };
+  colors["base-contrast-subtle"] = {
+    ...colors["base-contrast-subtle"],
+    hex: generateColorContrast(baseColors2.default, "subtle")
+  };
+  colors["base-contrast-default"] = {
+    ...colors["base-contrast-default"],
+    hex: generateColorContrast(baseColors2.default, "default")
+  };
+  return Object.values(colors);
+};
+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/tokens/create/generators/color.ts
+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, colors) => {
+  const main = R4.map((color) => generateColor(generateColorScale(color, colorScheme2)), colors.main);
+  const support = R4.map((color) => generateColor(generateColorScale(color, colorScheme2)), colors.support);
+  const neutral = generateColor(generateColorScale(colors.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 = (colors) => {
+  const mainColorNames = Object.keys(colors.main);
+  const supportColorNames = Object.keys(colors.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 = (colors, themeName, borderRadius) => {
+  const mainColorNames = Object.keys(colors.main);
+  const supportColorNames = Object.keys(colors.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, typography: typography2, name, borderRadius } = opts;
+  const colorSchemes = ["light", "dark"];
+  const semantic2 = generateSemantic(colors);
+  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, colors)]
+    ]),
+    [`themes/${name}`, generateTheme(colors, 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, colors2]) => Object.entries(colors2).map(([key, colorSet]) => [`semantic/modes/${mode}/${key}`, colorSet])
+    ),
+    getDefaultToken("semantic/style")
+  ]);
+  return { tokenSets };
+};
+
+// src/tokens/format.ts
+import * as R20 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/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, colors) {
+  return [
+    ...generateSizeGroup(),
+    ...await generateThemesGroup(themes),
+    ...generateTypographyGroup(themes),
+    ...generateColorSchemesGroup(colorSchemes, themes),
+    generateSemanticGroup(),
+    ...await generateColorGroup("main", colors),
+    ...await generateColorGroup("support", colors)
+  ];
+}
+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, colors) {
+  return Promise.all(
+    Object.entries(colors[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/process/platform.ts
+import chalk2 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";
+
+// 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((path) => R7.startsWith([path], 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((path) => path.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 formatTokens2 = 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, formatTokens2, 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 chalk 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(chalk.cyan(`\u{1F50E} Finding theme permutations for ${dimensions}`));
+    console.log(chalk.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"] },
+  "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, $themes } = options;
+  const platform = "css";
+  const tokenSets = process === "format" ? options.tokenSets : void 0;
+  const tokensDir = process === "build" ? options.tokensDir : void 0;
+  buildOptions = options;
+  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 = R18.head(customColors);
+    buildOptions.rootColor = firstMainColor;
+    console.log(`Using first main color; ${chalk2.blue(firstMainColor)}, as ${chalk2.green(`":root"`)} color`);
+  }
+  const buildAndSdConfigs = R18.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 R18.toPairs(buildAndSdConfigs)) {
+      if (!(buildConfig.enabled?.() ?? true)) {
+        continue;
+      }
+      if (sdConfigs.length > 0) {
+        console.log(`
+\u{1F371} Building ${chalk2.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 = R18.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(colors) {
+  console.log(`
+\u{1F371} Building ${chalk2.green("type declarations")}`);
+  const typeDeclaration = `
+import type {} from '@digdir/designsystemet-react/colors';
+
+declare module '@digdir/designsystemet-react/colors' {
+  export interface MainAndSupportColors {
+${colors.map((color) => `    ${color}: never;`).join("\n")}
+  }
+}
+`.trimStart();
+  return typeDeclaration;
+}
+
+// src/tokens/process/theme.ts
+import * as R19 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(R19.dissoc("types", processedBuilds))) {
+    for (const buildResult of buildResults) {
+      const themeName = buildResult.permutation.theme;
+      const newOutputs = buildResult.formatted;
+      if (R19.isNotEmpty(newOutputs)) {
+        const currentOutputs = groupedByTheme[themeName] ?? [];
+        groupedByTheme[themeName] = R19.concat(currentOutputs, newOutputs);
+      }
+    }
+  }
+  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(
+        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 = 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/format.ts
+var formatTokens = async (options) => {
+  const processedBuilds = await processPlatform({
+    process: "format",
+    ...options
+  });
+  return processedBuilds;
+};
+var formatTheme = async (themeConfig) => {
+  const { tokenSets } = await createTokens(themeConfig);
+  const $themes = await generate$Themes(["dark", "light"], [themeConfig.name], themeConfig.colors);
+  const processedBuilds = await formatTokens({
+    tokenSets,
+    $themes,
+    verbose: false,
+    preview: false
+  });
+  return processedBuilds;
+};
+var formatThemeCSS = async (themeConfig) => {
+  const processedBuilds = await formatTheme(themeConfig);
+  const themeCSSFiles = createThemeCSSFiles({ processedBuilds });
+  return R20.head(themeCSSFiles)?.output ?? "";
+};
 export {
   cliOptions,
-  createTokens
+  createTokens,
+  formatThemeCSS,
+  formatTokens
 };