@digdir/designsystemet 1.4.0 → 1.5.0

package/dist/src/tokens/process/configs/color.js

@@ -1,5 +1,5 @@
 // src/tokens/process/configs/color.ts
-import * as R10 from "ramda";
+import * as R15 from "ramda";
 
 // src/tokens/utils.ts
 import * as R from "ramda";
@@ -29,7 +29,10 @@ var pathStartsWithOneOf = R.curry(
       return false;
     }
     const tokenPath = mapToLowerCase(token.path);
-    const matchPathsStartingWith = R.map((path) => R.startsWith([path], tokenPath), mapToLowerCase(paths));
+    const matchPathsStartingWith = R.map((pathOrString) => {
+      const path = typeof pathOrString === "string" ? [pathOrString] : pathOrString;
+      return R.startsWith(mapToLowerCase(path), tokenPath);
+    }, paths);
     return hasAnyTruth(matchPathsStartingWith);
   }
 );
@@ -65,19 +68,36 @@ function inlineTokens(shouldInline, tokens) {
     return tokenWithInlinedRefs;
   });
 }
+var sizeMap = {
+  xsmall: "xs",
+  small: "sm",
+  medium: "md",
+  large: "lg",
+  xlarge: "xl"
+};
+function shortSizeName(size2) {
+  return sizeMap[size2] ?? size2;
+}
+var sizeComparator = (size2) => {
+  const sortIndex = Object.entries(sizeMap).findIndex(([key, val]) => key === size2 || val === size2);
+  return sortIndex ?? 0;
+};
+function orderBySize(sizes) {
+  return R.sortBy(sizeComparator, sizes);
+}
 
 // src/tokens/process/formats/css/color.ts
-import * as R7 from "ramda";
+import * as R9 from "ramda";
 import { createPropertyFormatter } from "style-dictionary/utils";
 
 // src/tokens/process/platform.ts
 import pc2 from "picocolors";
-import * as R6 from "ramda";
+import * as R8 from "ramda";
 import StyleDictionary2 from "style-dictionary";
 
 // src/tokens/process/configs.ts
 import { register } from "@tokens-studio/sd-transforms";
-import * as R5 from "ramda";
+import * as R7 from "ramda";
 import StyleDictionary from "style-dictionary";
 
 // src/tokens/process/configs/semantic.ts
@@ -94,18 +114,22 @@ var sizeRem = {
   transitive: true,
   filter: (token) => {
     const hasWantedType = typeEquals(["dimension", "fontsize"], token);
-    const hasWantedPath = pathStartsWithOneOf(["spacing", "sizing", "border-radius", "font-size"], token);
+    const hasWantedPath = pathStartsWithOneOf([
+      "border-radius",
+      "font-size"
+      /*, ['_size', 'mode-font-size']*/
+    ], token);
     return hasWantedType && hasWantedPath;
   },
   transform: (token, config) => {
     const value = getValue(token);
     if (isPx(value)) {
       const baseFont = config.basePxFontSize || 16;
-      const size = parseInt(value, 10);
-      if (size === 0) {
+      const size2 = parseInt(value, 10);
+      if (size2 === 0) {
         return "0";
       }
-      return `${size / baseFont}rem`;
+      return `${size2 / baseFont}rem`;
     }
     return value;
   }
@@ -180,7 +204,10 @@ var semanticVariables = ({ theme }) => {
             filter: (token) => {
               const isUwantedToken = R3.anyPass([R3.includes("primitives/global")])(token.filePath);
               const isPrivateToken = R3.includes("_", token.path);
-              const unwantedPaths = pathStartsWithOneOf(["font-size", "line-height", "letter-spacing"], token);
+              const unwantedPaths = pathStartsWithOneOf(
+                ["size", "_size", "font-size", "line-height", "letter-spacing"],
+                token
+              );
               const unwantedTypes = typeEquals(["color", "fontWeight", "fontFamily", "typography"], token);
               const unwantedTokens = !(unwantedPaths || unwantedTypes || isPrivateToken || isUwantedToken);
               return unwantedTokens;
@@ -190,8 +217,7 @@ var semanticVariables = ({ theme }) => {
         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);
+            return include && outputReferencesFilter(token, options);
           }
         }
       }
@@ -199,6 +225,124 @@ var semanticVariables = ({ theme }) => {
   };
 };
 
+// src/tokens/process/configs/size.ts
+import * as R4 from "ramda";
+import { outputReferencesFilter as outputReferencesFilter2 } from "style-dictionary/utils";
+var sizeVariables = ({ theme }) => {
+  const selector = `:root, [data-size]`;
+  const layer = `ds.theme.size`;
+  return {
+    preprocessors: ["tokens-studio"],
+    platforms: {
+      css: {
+        // custom
+        theme,
+        basePxFontSize,
+        selector,
+        layer,
+        //
+        prefix,
+        buildPath: `${theme}/`,
+        transforms: dsTransformers,
+        files: [
+          {
+            destination: `size.css`,
+            format: formats.size.name,
+            filter: (token) => {
+              const isUwantedToken = R4.anyPass([R4.includes("primitives/global")])(token.filePath);
+              const isPrivateToken = R4.includes("_", token.path);
+              return pathStartsWithOneOf(["size", "_size"], token) && !(isUwantedToken || isPrivateToken);
+            }
+          }
+        ],
+        options: {
+          outputReferences: (token, options) => {
+            const isWantedSize = pathStartsWithOneOf(["size", "_size"], token) && (isDigit(token.path[1]) || token.path[1] === "unit");
+            return isWantedSize && outputReferencesFilter2(token, options);
+          }
+        }
+      }
+    }
+  };
+};
+
+// src/tokens/process/configs/size-mode.ts
+import * as R5 from "ramda";
+var sizeModeVariables = ({ theme, size: size2 }) => {
+  const selector = `:root`;
+  const layer = `ds.theme.size-mode`;
+  return {
+    preprocessors: ["tokens-studio"],
+    platforms: {
+      css: {
+        // custom
+        size: size2,
+        theme,
+        basePxFontSize,
+        selector,
+        layer,
+        //
+        prefix,
+        buildPath: `${theme}/`,
+        transforms: dsTransformers,
+        files: [
+          {
+            destination: `size-mode/${size2}.css`,
+            format: formats.sizeMode.name,
+            filter: (token) => {
+              return R5.equals(["_size", "mode-font-size"], token.path);
+            }
+          }
+        ]
+      }
+    }
+  };
+};
+
+// src/tokens/process/configs/type-scale.ts
+var typeScaleVariables = ({ theme, size: size2 }) => {
+  const selector = ":root, [data-size]";
+  const layer = `ds.theme.type-scale`;
+  return {
+    usesDtcg: true,
+    preprocessors: ["tokens-studio"],
+    expand: {
+      include: ["typography"]
+    },
+    platforms: {
+      css: {
+        prefix,
+        selector,
+        layer,
+        buildPath: `${theme}/`,
+        basePxFontSize,
+        transforms: [
+          "name/kebab",
+          "ts/size/px",
+          sizeRem.name,
+          "ts/size/lineheight",
+          "ts/typography/fontWeight",
+          typographyName.name
+        ],
+        files: [
+          {
+            destination: `type-scale.css`,
+            format: formats.typeScale.name,
+            filter: (token) => {
+              const included = typeEquals(["typography", "dimension", "fontsize"], token);
+              if (/primitives\/modes\/typography\/(primary|secondary)/.test(token.filePath)) return false;
+              return included && !pathStartsWithOneOf(["spacing", "sizing", "size", "border-width", "border-radius"], token) && (pathStartsWithOneOf(["font-size"], token) || token.path.includes("fontSize"));
+            }
+          }
+        ],
+        options: {
+          outputReferences: (token) => pathStartsWithOneOf(["typography"], token) && token.path.includes("fontSize")
+        }
+      }
+    }
+  };
+};
+
 // src/tokens/process/configs/typography.ts
 import { expandTypesMap } from "@tokens-studio/sd-transforms";
 var typographyVariables = ({ theme, typography: typography2 }) => {
@@ -233,12 +377,9 @@ var typographyVariables = ({ theme, typography: typography2 }) => {
             destination: `typography/${typography2}.css`,
             format: formats.typography.name,
             filter: (token) => {
-              const included = typeEquals(
-                ["typography", "fontweight", "fontFamily", "lineHeight", "dimension", "font", "fontsize"],
-                token
-              );
+              const included = typeEquals(["fontweight", "fontFamily", "lineHeight", "dimension"], token);
               if (/primitives\/modes\/typography\/(primary|secondary)/.test(token.filePath)) return false;
-              return included && !pathStartsWithOneOf(["spacing", "sizing", "size", "_size", "border-width", "border-radius"], token);
+              return included && !pathStartsWithOneOf(["spacing", "sizing", "size", "_size", "border-width", "border-radius"], token) && !(pathStartsWithOneOf(["typography"], token) && token.path.includes("fontSize"));
             }
           }
         ]
@@ -413,9 +554,9 @@ var TypographyValues;
 // src/tokens/process/utils/getMultidimensionalThemes.ts
 import { kebabCase } from "change-case";
 import pc from "picocolors";
-import * as R4 from "ramda";
+import * as R6 from "ramda";
 var processed = Symbol("Type brand for ProcessedThemeObject");
-var hasUnknownProps = R4.pipe(R4.values, R4.none(R4.equals("unknown")), R4.not);
+var hasUnknownProps = R6.pipe(R6.values, R6.none(R6.equals("unknown")), R6.not);
 
 // src/tokens/process/configs.ts
 void register(StyleDictionary, { withSDBuiltins: false });
@@ -435,7 +576,10 @@ var configs = {
   dangerColorVariables: colorCategoryVariables({ category: "builtin", color: "danger" }),
   warningColorVariables: colorCategoryVariables({ category: "builtin", color: "warning" }),
   infoColorVariables: colorCategoryVariables({ category: "builtin", color: "info" }),
+  sizeModeVariables,
+  sizeVariables,
   typographyVariables,
+  typeScaleVariables,
   semanticVariables
 };
 
@@ -448,6 +592,9 @@ var buildOptions = {
 var sd = new StyleDictionary2();
 var buildConfigs = {
   typography: { getConfig: configs.typographyVariables, dimensions: ["typography"] },
+  sizeMode: { getConfig: configs.sizeModeVariables, dimensions: ["size"] },
+  size: { getConfig: configs.sizeVariables, dimensions: ["semantic"] },
+  typeScale: { getConfig: configs.typeScaleVariables, dimensions: ["semantic"] },
   "color-scheme": { getConfig: configs.colorSchemeVariables, dimensions: ["color-scheme"] },
   "main-color": { getConfig: configs.mainColorVariables, dimensions: ["main-color"] },
   "support-color": { getConfig: configs.supportColorVariables, dimensions: ["support-color"] },
@@ -502,8 +649,8 @@ var colorScheme = {
   color-scheme: ${colorScheme_};
 ` : "";
     const filteredAllTokens = allTokens.filter(
-      R7.allPass([
-        R7.anyPass([
+      R9.allPass([
+        R9.anyPass([
           // Include semantic tokens in the output
           isSemanticToken,
           // Include global color tokens
@@ -517,13 +664,13 @@ var colorScheme = {
       token,
       formatted: format(token)
     }));
-    const formattedTokens = formattedMap.map(R7.view(R7.lensProp("formatted"))).join("\n");
+    const formattedTokens = formattedMap.map(R9.view(R9.lensProp("formatted"))).join("\n");
     const content = `{
 ${formattedTokens}
 ${colorSchemeProperty}}
 `;
     const autoSelectorContent = ["light", "dark"].includes(colorScheme_) ? prefersColorScheme(colorScheme_, content) : "";
-    const body = R7.isNotNil(layer) ? `@layer ${layer} {
+    const body = R9.isNotNil(layer) ? `@layer ${layer} {
 ${selector} ${content} ${autoSelectorContent}
 }
 ` : `${selector} ${content} ${autoSelectorContent}
@@ -533,11 +680,11 @@ ${selector} ${content} ${autoSelectorContent}
 };
 var colorCategory = {
   name: "ds/css-colorcategory",
-  format: async ({ dictionary, options, platform }) => {
+  format: async ({ dictionary, file, options, platform }) => {
     const { outputReferences, usesDtcg } = options;
-    const { selector, layer, files } = platform;
-    const destination = files?.[0]?.destination;
-    const format = R7.compose(
+    const { selector, layer } = platform;
+    const destination = file.destination;
+    const format = R9.compose(
       createPropertyFormatter({
         outputReferences,
         dictionary,
@@ -558,12 +705,12 @@ var colorCategory = {
       formatted: format(token)
     }));
     buildOptions.buildTokenFormats[destination] = formattedMap;
-    const formattedTokens = formattedMap.map(R7.view(R7.lensProp("formatted"))).join("\n");
+    const formattedTokens = formattedMap.map(R9.view(R9.lensProp("formatted"))).join("\n");
     const content = `{
 ${formattedTokens}
 }
 `;
-    const body = R7.isNotNil(layer) ? `@layer ${layer} {
+    const body = R9.isNotNil(layer) ? `@layer ${layer} {
 ${selector} ${content}
 }
 ` : `${selector} ${content}
@@ -573,23 +720,35 @@ ${selector} ${content}
 };
 
 // src/tokens/process/formats/css/semantic.ts
-import * as R8 from "ramda";
+import * as R11 from "ramda";
+import { createPropertyFormatter as createPropertyFormatter3 } from "style-dictionary/utils";
+
+// src/tokens/process/formats/css/size.ts
+import * as R10 from "ramda";
 import { createPropertyFormatter as createPropertyFormatter2 } from "style-dictionary/utils";
 var isNumericBorderRadiusToken = (t) => t.path[0] === "border-radius" && isDigit(t.path[1]);
 var isNumericSizeToken = (t) => pathStartsWithOneOf(["size"], t) && isDigit(t.path[1]);
 var isSizeToken = (t) => pathStartsWithOneOf(["size"], t);
-var isInlineTokens = R8.anyPass([isNumericBorderRadiusToken, isNumericSizeToken, isSizeToken]);
+var isInlineTokens = R10.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}, 1px)`;
+  const [name, value] = format(token).replace(/;$/, "").split(": ");
+  let calc;
+  let round;
+  if (token.path[1] === "unit") {
+    calc = `calc(1rem * ${value})`;
+  } else if (value.startsWith("floor")) {
+    calc = value.replace(/^floor\((.*)\)$/, "calc($1)");
+    round = `round(down, ${calc}, 1px)`;
+  } else {
+    calc = value.includes("*") ? `calc(${value})` : value;
+  }
   return {
     name,
-    round,
+    round: round ?? calc,
     calc
   };
 };
-var formatSizingTokens = (format, tokens) => R8.reduce(
+var formatSizingTokens = (format, tokens) => R10.reduce(
   (acc, token) => {
     const { round, calc, name } = overrideSizingFormula(format, token);
     return {
@@ -601,18 +760,21 @@ var formatSizingTokens = (format, tokens) => R8.reduce(
   { tokens: [], round: [], calc: [] },
   tokens
 );
-var sizingTemplate = ({ round, calc }) => `
+var sizingTemplate = ({ round, calc }) => {
+  const usesRounding = round.filter((val, i) => val !== calc[i]);
+  return `
 ${calc.join("\n")}
 
   @supports (width: round(down, .1em, 1px)) {
-${round.join("\n")}
+  ${usesRounding.join("\n  ")}
   }`;
-var semantic = {
-  name: "ds/css-semantic",
-  format: async ({ dictionary, options, platform }) => {
+};
+var size = {
+  name: "ds/css-size",
+  format: async ({ dictionary, file, options, platform }) => {
     const { outputReferences, usesDtcg } = options;
-    const { selector, layer, files } = platform;
-    const destination = files?.[0]?.destination;
+    const { selector, layer } = platform;
+    const destination = file.destination;
     const format = createPropertyFormatter2({
       outputReferences,
       dictionary,
@@ -620,9 +782,9 @@ var semantic = {
       usesDtcg
     });
     const tokens = inlineTokens(isInlineTokens, dictionary.allTokens);
-    const filteredTokens = R8.reject((token) => token.name.includes("ds-size-mode-font-size"), tokens);
-    const [sizingTokens, restTokens] = R8.partition(
-      (t) => pathStartsWithOneOf(["_size"], t) && isDigit(t.path[1]),
+    const filteredTokens = R10.reject((token) => R10.equals(["_size", "mode-font-size"], token.path), tokens);
+    const [sizingTokens, restTokens] = R10.partition(
+      (t) => pathStartsWithOneOf(["_size"], t) && (isDigit(t.path[1]) || t.path[1] === "unit"),
       filteredTokens
     );
     const formattedSizingTokens = formatSizingTokens(format, sizingTokens);
@@ -635,51 +797,186 @@ var semantic = {
       formatted: t
     }));
     buildOptions.buildTokenFormats[destination] = [...formattedMap, ...formattedSizingMap];
-    const sizingSnippet = sizingTemplate(formattedSizingTokens);
-    const formattedTokens = formattedMap.map(R8.view(R8.lensProp("formatted"))).concat(sizingSnippet);
-    const content = `{
+    const formattedTokens = [formattedMap.map(R10.prop("formatted")).join("\n"), sizingTemplate(formattedSizingTokens)];
+    const content = `${selector} {
 ${formattedTokens.join("\n")}
 }
 `;
-    const body = R8.isNotNil(layer) ? `@layer ${layer} {
-${selector} ${content}
+    const body = R10.isNotNil(layer) ? `@layer ${layer} {
+${content}
 }
-` : `${selector} ${content}
+` : `${content}
+`;
+    return body;
+  }
+};
+
+// src/tokens/process/formats/css/semantic.ts
+var semantic = {
+  name: "ds/css-semantic",
+  format: async ({ dictionary, file, options, platform }) => {
+    const { outputReferences, usesDtcg } = options;
+    const { selector, layer } = platform;
+    const destination = file.destination;
+    const format = createPropertyFormatter3({
+      outputReferences,
+      dictionary,
+      format: "css",
+      usesDtcg
+    });
+    const tokens = inlineTokens(isInlineTokens, dictionary.allTokens);
+    const formattedMap = tokens.map((token) => ({
+      token,
+      formatted: format(token)
+    }));
+    buildOptions.buildTokenFormats[destination] = formattedMap;
+    const formattedTokens = formattedMap.map(R11.prop("formatted")).join("\n");
+    const content = `${selector} {
+${formattedTokens}
+}
+`;
+    const body = R11.isNotNil(layer) ? `@layer ${layer} {
+${content}
+}
+` : `${content}
 `;
     return body;
   }
 };
 
+// src/tokens/process/formats/css/size-mode.ts
+import * as R12 from "ramda";
+import { createPropertyFormatter as createPropertyFormatter4 } from "style-dictionary/utils";
+var formatBaseSizeToken = (size2) => (token) => ({
+  ...token,
+  originalName: token.name,
+  name: `${token.name}--${shortSizeName(size2)}`,
+  $value: token.$value / basePxFontSize
+});
+var sizeMode = {
+  name: "ds/css-size-mode",
+  format: async ({ dictionary, file, options, platform }) => {
+    const { outputReferences, usesDtcg } = options;
+    const { selector, layer, size: size2 } = platform;
+    const destination = file.destination;
+    const format = createPropertyFormatter4({
+      outputReferences,
+      dictionary,
+      format: "css",
+      usesDtcg
+    });
+    const sizeSpecificTokens = dictionary.allTokens.map(formatBaseSizeToken(size2));
+    const sizeSpecificVariables = sizeSpecificTokens.map(format).join("\n");
+    const formattedMap = sizeSpecificTokens.map((token) => ({
+      token,
+      formatted: format({
+        ...token,
+        // Remove the `--<size>` suffix for the token listing, since that is the only token we actually use
+        name: token.originalName
+      })
+    }));
+    buildOptions.buildTokenFormats[destination] = formattedMap;
+    const content = `${selector} /* ${size2} */ {
+${sizeSpecificVariables}
+}`;
+    const body = wrapInLayer(content, layer);
+    const sizes = orderBySize(buildOptions?.sizeModes ?? []).map(shortSizeName);
+    const defaultSize = shortSizeName(buildOptions?.defaultSize ?? "");
+    const sizingToggles = `:root, [data-size] {
+  --ds-size: var(--ds-size--${defaultSize});
+${sizes.map((size3) => `  --ds-size--${size3}: var(--ds-size,);`).join("\n")}
+  --ds-size-mode-font-size:
+${sizes.map((size3) => `    var(--ds-size--${size3}, var(--ds-size-mode-font-size--${size3}))`).join("\n")};
+}`;
+    const sizingHelpers = sizes.map((size3) => `[data-size='${size3}'] { --ds-size: var(--ds-size--${size3}); }`).join("\n");
+    const sharedContent = `${sizingToggles}
+
+${sizingHelpers}`;
+    const sharedBody = shortSizeName(size2) === R12.last(sizes) ? `
+${wrapInLayer(sharedContent, layer)}` : "";
+    return body + sharedBody;
+  }
+};
+function wrapInLayer(content, layer) {
+  return R12.isNotNil(layer) ? `@layer ${layer} {
+${content}
+}
+` : `${content}
+`;
+}
+
 // src/tokens/process/formats/css/typography.ts
-import * as R9 from "ramda";
-import { createPropertyFormatter as createPropertyFormatter3 } from "style-dictionary/utils";
-var typographyFontFamilyPredicate = R9.allPass([
-  R9.pathSatisfies(R9.includes("typography"), ["path"]),
-  R9.pathSatisfies(R9.includes("fontFamily"), ["path"])
+import * as R13 from "ramda";
+import { createPropertyFormatter as createPropertyFormatter5 } from "style-dictionary/utils";
+var typographyFontFamilyPredicate = R13.allPass([
+  R13.pathSatisfies(R13.includes("typography"), ["path"]),
+  R13.pathSatisfies(R13.includes("fontFamily"), ["path"])
 ]);
 var typography = {
   name: "ds/css-typography",
-  format: async ({ dictionary, options, platform }) => {
+  format: async ({ dictionary, file, options, platform }) => {
     const { outputReferences, usesDtcg } = options;
-    const { selector, layer, files } = platform;
-    const destination = files?.[0]?.destination;
-    const format = createPropertyFormatter3({
+    const { selector, layer } = platform;
+    const destination = file.destination;
+    const format = createPropertyFormatter5({
       outputReferences,
       dictionary,
       format: "css",
       usesDtcg
     });
-    const filteredTokens = R9.reject(typographyFontFamilyPredicate, dictionary.allTokens);
+    const filteredTokens = R13.reject(typographyFontFamilyPredicate, dictionary.allTokens);
     const formattedMap = filteredTokens.map((token) => ({
       token,
       formatted: format(token)
     }));
     buildOptions.buildTokenFormats[destination] = formattedMap;
-    const formattedTokens = formattedMap.map(R9.view(R9.lensProp("formatted"))).join("\n");
+    const formattedTokens = formattedMap.map(R13.view(R13.lensProp("formatted"))).join("\n");
     const content = selector ? `${selector} {
 ${formattedTokens}
 }` : formattedTokens;
-    const body = R9.isNotNil(layer) ? `@layer ${layer} {
+    const body = R13.isNotNil(layer) ? `@layer ${layer} {
+${content}
+}` : content;
+    return body;
+  }
+};
+
+// src/tokens/process/formats/css/type-scale.ts
+import * as R14 from "ramda";
+import { createPropertyFormatter as createPropertyFormatter6 } from "style-dictionary/utils";
+var typographyFontFamilyPredicate2 = R14.allPass([
+  R14.pathSatisfies(R14.includes("typography"), ["path"]),
+  R14.pathSatisfies(R14.includes("fontFamily"), ["path"])
+]);
+function formatTypographySizeToken(token) {
+  return { ...token, $value: `calc(${token.$value} * var(--_ds-font-size-factor))` };
+}
+var typeScale = {
+  name: "ds/css-type-scale",
+  format: async ({ dictionary, file, options, platform }) => {
+    const { outputReferences, usesDtcg } = options;
+    const { selector, layer } = platform;
+    const destination = file.destination;
+    const format = createPropertyFormatter6({
+      outputReferences,
+      dictionary,
+      format: "css",
+      usesDtcg
+    });
+    const filteredTokens = R14.reject(typographyFontFamilyPredicate2, dictionary.allTokens);
+    const tokens = R14.map(formatTypographySizeToken, filteredTokens);
+    const formattedMap = tokens.map((token) => ({
+      token,
+      formatted: format(token)
+    }));
+    buildOptions.buildTokenFormats[destination] = formattedMap;
+    const formattedTokens = formattedMap.map(R14.prop("formatted")).join("\n");
+    const sizeFactor = `  --_ds-font-size-factor: calc(var(--ds-size-mode-font-size) / (var(--ds-size-base) / ${basePxFontSize}));`;
+    const content = `${selector} {
+${sizeFactor}
+${formattedTokens}
+}`;
+    const body = R14.isNotNil(layer) ? `@layer ${layer} {
 ${content}
 }` : content;
     return body;
@@ -691,7 +988,10 @@ var formats = {
   colorScheme,
   colorCategory,
   semantic,
-  typography
+  sizeMode,
+  size,
+  typography,
+  typeScale
 };
 
 // src/tokens/process/configs/color.ts
@@ -715,7 +1015,7 @@ var colorSchemeVariables = ({ "color-scheme": colorScheme2 = "light", theme }) =
           {
             destination: `color-scheme/${colorScheme2}.css`,
             format: formats.colorScheme.name,
-            filter: (token) => typeEquals("color", token) && !R10.startsWith(["global"], token.path)
+            filter: (token) => typeEquals("color", token) && !R15.startsWith(["global"], token.path)
           }
         ],
         options: {

package/dist/src/tokens/process/configs/semantic.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/process/configs/semantic.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkC,KAAK,wBAAwB,EAAU,MAAM,aAAa,CAAC;AAEpG,eAAO,MAAM,iBAAiB,EAAE,wBA0C/B,CAAC"}
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/process/configs/semantic.ts"],"names":[],"mappings":"AAKA,OAAO,EAAkC,KAAK,wBAAwB,EAAU,MAAM,aAAa,CAAC;AAEpG,eAAO,MAAM,iBAAiB,EAAE,wBA4C/B,CAAC"}