@digdir/designsystemet 1.1.3 → 1.1.5

package/dist/src/tokens/process/utils/getMultidimensionalThemes.js

@@ -164,11 +164,11 @@ var TypographyValues;
 // src/tokens/process/utils/getMultidimensionalThemes.ts
 import chalk2 from "chalk";
 import { kebabCase } from "change-case";
-import * as R12 from "ramda";
+import * as R10 from "ramda";
 
 // src/tokens/process/platform.ts
 import chalk from "chalk";
-import * as R11 from "ramda";
+import * as R9 from "ramda";
 import StyleDictionary2 from "style-dictionary";
 
 // src/tokens/types.ts
@@ -179,7 +179,7 @@ var colorCategories = {
 
 // src/tokens/process/configs.ts
 import { register } from "@tokens-studio/sd-transforms";
-import * as R10 from "ramda";
+import * as R8 from "ramda";
 import StyleDictionary from "style-dictionary";
 
 // src/tokens/utils.ts
@@ -278,7 +278,11 @@ var colorScheme = {
         (t) => !isColorCategoryToken(t)
       ])
     );
-    const formattedTokens = filteredAllTokens.map(format).join("\n");
+    const formattedMap = filteredAllTokens.map((token) => ({
+      token,
+      formatted: format(token)
+    }));
+    const formattedTokens = formattedMap.map(R2.view(R2.lensProp("formatted"))).join("\n");
     const content = `{
 ${formattedTokens}
 ${colorSchemeProperty}}
@@ -296,7 +300,8 @@ var colorCategory = {
   name: "ds/css-colorcategory",
   format: async ({ dictionary, options, platform }) => {
     const { outputReferences, usesDtcg } = options;
-    const { selector, layer } = platform;
+    const { selector, layer, files } = platform;
+    const destination = files?.[0]?.destination;
     const format = R2.compose(
       createPropertyFormatter({
         outputReferences,
@@ -313,7 +318,12 @@ var colorCategory = {
         }
       })
     );
-    const formattedTokens = dictionary.allTokens.map(format).join("\n");
+    const formattedMap = dictionary.allTokens.map((token) => ({
+      token,
+      formatted: format(token)
+    }));
+    buildOptions.buildTokenFormats[destination] = formattedMap;
+    const formattedTokens = formattedMap.map(R2.view(R2.lensProp("formatted"))).join("\n");
     const content = `{
 ${formattedTokens}
 }
@@ -344,30 +354,30 @@ var overrideSizingFormula = (format, token) => {
     calc
   };
 };
-var formatSizingTokens = (format, tokens) => {
-  const { round, calc } = R3.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 `
+var formatSizingTokens = (format, tokens) => R3.reduce(
+  (acc, token) => {
+    const { round, calc, name } = overrideSizingFormula(format, token);
+    return {
+      tokens: [...acc.tokens, token],
+      round: [...acc.round, `${name}: ${round};`],
+      calc: [...acc.calc, `${name}: ${calc};`]
+    };
+  },
+  { tokens: [], round: [], calc: [] },
+  tokens
+);
+var sizingTemplate = ({ round, calc }) => `
 ${calc.join("\n")}
 
   @supports (width: round(down, .1em, 1px)) {
 ${round.join("\n")}
   }`;
-};
 var semantic = {
   name: "ds/css-semantic",
   format: async ({ dictionary, options, platform }) => {
     const { outputReferences, usesDtcg } = options;
-    const { selector, layer } = platform;
+    const { selector, layer, files } = platform;
+    const destination = files?.[0]?.destination;
     const format = createPropertyFormatter2({
       outputReferences,
       dictionary,
@@ -380,7 +390,18 @@ var semantic = {
       (t) => pathStartsWithOneOf(["_size"], t) && isDigit(t.path[1]),
       filteredTokens
     );
-    const formattedTokens = [R3.map(format, restTokens).join("\n"), formatSizingTokens(format, sizingTokens)];
+    const formattedSizingTokens = formatSizingTokens(format, sizingTokens);
+    const formattedMap = restTokens.map((token) => ({
+      token,
+      formatted: format(token)
+    }));
+    const formattedSizingMap = formattedSizingTokens.round.map((t, i) => ({
+      token: formattedSizingTokens.tokens[i],
+      formatted: t
+    }));
+    buildOptions.buildTokenFormats[destination] = [...formattedMap, ...formattedSizingMap];
+    const sizingSnippet = sizingTemplate(formattedSizingTokens);
+    const formattedTokens = formattedMap.map(R3.view(R3.lensProp("formatted"))).concat(sizingSnippet);
     const content = `{
 ${formattedTokens.join("\n")}
 }
@@ -405,7 +426,8 @@ var typography = {
   name: "ds/css-typography",
   format: async ({ dictionary, options, platform }) => {
     const { outputReferences, usesDtcg } = options;
-    const { selector, layer } = platform;
+    const { selector, layer, files } = platform;
+    const destination = files?.[0]?.destination;
     const format = createPropertyFormatter3({
       outputReferences,
       dictionary,
@@ -413,7 +435,12 @@ var typography = {
       usesDtcg
     });
     const filteredTokens = R4.reject(typographyFontFamilyPredicate, dictionary.allTokens);
-    const formattedTokens = R4.pipe(R4.map(format), R4.join("\n"))(filteredTokens);
+    const formattedMap = filteredTokens.map((token) => ({
+      token,
+      formatted: format(token)
+    }));
+    buildOptions.buildTokenFormats[destination] = formattedMap;
+    const formattedTokens = formattedMap.map(R4.view(R4.lensProp("formatted"))).join("\n");
     const content = selector ? `${selector} {
 ${formattedTokens}
 }` : formattedTokens;
@@ -620,90 +647,6 @@ var semanticVariables = ({ theme }) => {
   };
 };
 
-// src/tokens/process/configs/storefront.ts
-import * as R9 from "ramda";
-import { outputReferencesFilter as outputReferencesFilter2 } from "style-dictionary/utils";
-
-// src/tokens/process/formats/js-tokens.ts
-import * as R8 from "ramda";
-import { createPropertyFormatter as createPropertyFormatter4, fileHeader } from "style-dictionary/utils";
-var groupByType = R8.groupBy((token) => getType(token));
-var removeUnwatedTokens = R8.pipe(
-  R8.reject((token) => isColorCategoryToken(token)),
-  R8.reject((token) => R8.any((path) => path.startsWith("_"))(token.path))
-);
-var dissocExtensions = R8.pipe(R8.dissoc("$extensions"), R8.dissocPath(["original", "$extensions"]));
-var removeUnwatedProps = R8.map((token) => dissocExtensions(token));
-var toCssVarName = R8.pipe(R8.split(":"), R8.head, R8.trim);
-var jsTokens = {
-  name: "ds/js-tokens",
-  format: async ({ dictionary, file, options }) => {
-    const { usesDtcg, outputReferences } = options;
-    const format = createPropertyFormatter4({
-      outputReferences,
-      dictionary,
-      format: "css",
-      usesDtcg
-    });
-    const formatTokens = R8.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 = R8.pipe(removeUnwatedTokens, removeUnwatedProps, formatTokens, groupByType);
-    const tokens = processTokens(inlineTokens(isInlineTokens, dictionary.allTokens));
-    const content = Object.entries(tokens).map(
-      ([name, token]) => `export const  ${name} = ${JSON.stringify(token, null, 2).replace(/"([^"]+)":/g, "$1:")} 
-`
-    ).join("\n");
-    return fileHeader({ file }).then((fileHeaderText) => fileHeaderText + content);
-  }
-};
-
-// src/tokens/process/configs/storefront.ts
-var typescriptTokens = ({ "color-scheme": colorScheme2, theme }) => {
-  return {
-    preprocessors: ["tokens-studio"],
-    platforms: {
-      ts: {
-        prefix,
-        basePxFontSize,
-        transforms: dsTransformers,
-        buildPath: `${theme}/`,
-        files: [
-          {
-            destination: `${colorScheme2}.ts`,
-            format: jsTokens.name,
-            filter: (token) => {
-              if (pathStartsWithOneOf(["border-width", "letter-spacing", "border-radius"], token) && !R9.includes("semantic", token.filePath))
-                return false;
-              const isSemanticColor = R9.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 }) => {
@@ -730,6 +673,7 @@ var typographyVariables = ({ theme, typography: typography2 }) => {
           sizeRem.name,
           "ts/size/lineheight",
           "ts/typography/fontWeight",
+          "ts/size/css/letterspacing",
           typographyName.name
         ],
         files: [
@@ -757,7 +701,6 @@ 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);
 }
@@ -771,12 +714,15 @@ var configs = {
   warningColorVariables: colorCategoryVariables({ category: "builtin", color: "warning" }),
   infoColorVariables: colorCategoryVariables({ category: "builtin", color: "info" }),
   typographyVariables,
-  semanticVariables,
-  typescriptTokens
+  semanticVariables
 };
 
 // src/tokens/process/platform.ts
-var buildOptions;
+var buildOptions = {
+  verbose: false,
+  processed$themes: [],
+  buildTokenFormats: {}
+};
 var sd = new StyleDictionary2();
 var buildConfigs = {
   typography: { getConfig: configs.typographyVariables, dimensions: ["typography"] },
@@ -809,13 +755,6 @@ var buildConfigs = {
     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,
-  // },
 };
 
 // src/tokens/process/utils/getMultidimensionalThemes.ts
@@ -824,7 +763,7 @@ var getMultidimensionalThemes = (processed$themes, dimensions) => {
   const grouped$themes = groupThemes(processed$themes);
   const permutations = permutateThemes(grouped$themes);
   const ALL_DEPENDENT_ON = ["theme"];
-  const keys2 = R12.keys(grouped$themes);
+  const keys2 = R10.keys(grouped$themes);
   const nonDependentKeys = keys2.filter((x) => ![...ALL_DEPENDENT_ON, ...dimensions].includes(x));
   if (verboseLogging) {
     console.log(chalk2.cyan(`\u{1F50E} Finding theme permutations for ${dimensions}`));
@@ -864,7 +803,7 @@ function groupThemes(themes) {
   }
   return groups;
 }
-var hasUnknownProps = R12.pipe(R12.values, R12.none(R12.equals("unknown")), R12.not);
+var hasUnknownProps = R10.pipe(R10.values, R10.none(R10.equals("unknown")), R10.not);
 function permutateThemes(groups) {
   const separator = "_";
   const permutations = cartesian(Object.values(groups));
@@ -874,8 +813,8 @@ function permutateThemes(groups) {
         const { group, name, selectedTokenSets } = theme;
         let updatedPermutation = acc.permutation;
         if (group) {
-          const groupProp = R12.lensProp(group);
-          updatedPermutation = R12.set(groupProp, name, updatedPermutation);
+          const groupProp = R10.lensProp(group);
+          updatedPermutation = R10.set(groupProp, name, updatedPermutation);
         }
         const updatedName = `${String(acc.name)}${acc ? separator : ""}${name}`;
         const sets = [...acc.selectedTokenSets, ...filterTokenSets(selectedTokenSets)];

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@digdir/designsystemet",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "CLI for Designsystemet",
   "author": "Designsystemet team",
   "engines": {
-    "node": ">=22.16.0"
+    "node": ">=22.17.0"
   },
   "repository": {
     "type": "git",
@@ -47,8 +47,8 @@
     "object-hash": "^3.0.0",
     "postcss": "^8.5.6",
     "ramda": "^0.31.3",
-    "style-dictionary": "^5.0.0",
-    "zod": "^3.25.67",
+    "style-dictionary": "^5.0.1",
+    "zod": "^3.25.74",
     "zod-validation-error": "^3.5.2"
   },
   "devDependencies": {
@@ -56,8 +56,7 @@
     "@types/apca-w3": "^0.1.3",
     "@types/chroma-js": "^3.1.1",
     "@types/fs-extra": "^11.0.4",
-    "@types/glob": "^8.1.0",
-    "@types/node": "^22.15.32",
+    "@types/node": "^22.16.0",
     "@types/object-hash": "^3.0.6",
     "@types/ramda": "^0.30.2",
     "fs-extra": "^11.3.0",
@@ -86,6 +85,7 @@
     "digdir:tokens-build": "pnpm run designsystemet tokens build -t ../../internal/design-tokens -o ../../packages/theme/brand --clean --experimental-tailwind",
     "digdir:tokens-create": "pnpm run designsystemet tokens create --config ./configs/digdir.config.json",
     "update:template": "tsx ./src/scripts/update-template.ts",
+    "update:preview-tokens": "tsx ./src/scripts/update-preview-tokens.ts",
     "update:theme-digdir": "pnpm digdir:tokens-create && tsx ./src/scripts/update-design-tokens.ts && pnpm digdir:tokens-build",
     "verify": "pnpm test && pnpm update:template && pnpm update:theme-digdir && pnpm build:tokens"
   }

package/dist/src/tokens/process/configs/storefront.d.ts

@@ -1,3 +0,0 @@
-import { type GetStyleDictionaryConfig } from './shared.js';
-export declare const typescriptTokens: GetStyleDictionaryConfig;
-//# sourceMappingURL=storefront.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"storefront.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/process/configs/storefront.ts"],"names":[],"mappings":"AAMA,OAAO,EAAkC,KAAK,wBAAwB,EAAU,MAAM,aAAa,CAAC;AAEpG,eAAO,MAAM,gBAAgB,EAAE,wBAqC9B,CAAC"}

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

@@ -1,234 +0,0 @@
-// src/tokens/process/configs/storefront.ts
-import * as R5 from "ramda";
-import { outputReferencesFilter } from "style-dictionary/utils";
-
-// src/tokens/utils.ts
-import * as R from "ramda";
-
-// src/tokens/types.ts
-var colorCategories = {
-  main: "main",
-  support: "support"
-};
-
-// src/tokens/utils.ts
-var mapToLowerCase = R.map(R.toLower);
-var hasAnyTruth = R.any(R.equals(true));
-var getType = (token) => (token.$type ?? token.type) || "";
-var getValue = (token) => token.$value ?? token.value;
-var typeEquals = R.curry(
-  (types, token) => {
-    if (R.isNil(token)) {
-      return false;
-    }
-    return R.includes(R.toLower(getType(token)), R.map(R.toLower, Array.isArray(types) ? types : [types]));
-  }
-);
-var pathStartsWithOneOf = R.curry(
-  (paths, token) => {
-    if (R.isNil(token)) {
-      return false;
-    }
-    const tokenPath = mapToLowerCase(token.path);
-    const matchPathsStartingWith = R.map((path) => R.startsWith([path], tokenPath), mapToLowerCase(paths));
-    return hasAnyTruth(matchPathsStartingWith);
-  }
-);
-function isColorCategoryToken(token, category) {
-  if (!category) {
-    return Object.keys(colorCategories).some(
-      (colorCategory) => isColorCategoryToken(token, colorCategory)
-    );
-  }
-  return R.startsWith(["color", category], token.path);
-}
-var isDigit = (s) => /^\d+$/.test(s);
-function inlineTokens(shouldInline, tokens) {
-  const [inlineableTokens, otherTokens] = R.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 = R.set(R.lensPath(["original", "$value"]), transformed, token);
-    return tokenWithInlinedRefs;
-  });
-}
-
-// src/tokens/process/formats/js-tokens.ts
-import * as R3 from "ramda";
-import { createPropertyFormatter as createPropertyFormatter2, fileHeader } from "style-dictionary/utils";
-
-// src/tokens/process/formats/css/semantic.ts
-import * as R2 from "ramda";
-import { createPropertyFormatter } 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 = R2.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)`;
-  return {
-    name,
-    round,
-    calc
-  };
-};
-
-// src/tokens/process/formats/js-tokens.ts
-var groupByType = R3.groupBy((token) => getType(token));
-var removeUnwatedTokens = R3.pipe(
-  R3.reject((token) => isColorCategoryToken(token)),
-  R3.reject((token) => R3.any((path) => path.startsWith("_"))(token.path))
-);
-var dissocExtensions = R3.pipe(R3.dissoc("$extensions"), R3.dissocPath(["original", "$extensions"]));
-var removeUnwatedProps = R3.map((token) => dissocExtensions(token));
-var toCssVarName = R3.pipe(R3.split(":"), R3.head, R3.trim);
-var jsTokens = {
-  name: "ds/js-tokens",
-  format: async ({ dictionary, file, options }) => {
-    const { usesDtcg, outputReferences } = options;
-    const format = createPropertyFormatter2({
-      outputReferences,
-      dictionary,
-      format: "css",
-      usesDtcg
-    });
-    const formatTokens = R3.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 = R3.pipe(removeUnwatedTokens, removeUnwatedProps, formatTokens, groupByType);
-    const tokens = processTokens(inlineTokens(isInlineTokens, dictionary.allTokens));
-    const content = Object.entries(tokens).map(
-      ([name, token]) => `export const  ${name} = ${JSON.stringify(token, null, 2).replace(/"([^"]+)":/g, "$1:")} 
-`
-    ).join("\n");
-    return fileHeader({ file }).then((fileHeaderText) => fileHeaderText + content);
-  }
-};
-
-// src/tokens/process/transformers.ts
-import { checkAndEvaluateMath } from "@tokens-studio/sd-transforms";
-import * as R4 from "ramda";
-var isPx = R4.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/storefront.ts
-var typescriptTokens = ({ "color-scheme": colorScheme, theme }) => {
-  return {
-    preprocessors: ["tokens-studio"],
-    platforms: {
-      ts: {
-        prefix,
-        basePxFontSize,
-        transforms: dsTransformers,
-        buildPath: `${theme}/`,
-        files: [
-          {
-            destination: `${colorScheme}.ts`,
-            format: jsTokens.name,
-            filter: (token) => {
-              if (pathStartsWithOneOf(["border-width", "letter-spacing", "border-radius"], token) && !R5.includes("semantic", token.filePath))
-                return false;
-              const isSemanticColor = R5.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) && outputReferencesFilter(token, options);
-          }
-        }
-      }
-    }
-  };
-};
-export {
-  typescriptTokens
-};

package/dist/src/tokens/process/formats/js-tokens.d.ts

@@ -1,6 +0,0 @@
-import type { Format } from 'style-dictionary/types';
-/**
- * Format for displaying tokens in storefront
- */
-export declare const jsTokens: Format;
-//# sourceMappingURL=js-tokens.d.ts.map

package/dist/src/tokens/process/formats/js-tokens.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"js-tokens.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/process/formats/js-tokens.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAoB,MAAM,wBAAwB,CAAC;AAoBvE;;GAEG;AACH,eAAO,MAAM,QAAQ,EAAE,MAuCtB,CAAC"}