@digdir/designsystemet 1.0.3 → 1.0.4

package/dist/src/tokens/process/formats/css/color.d.ts

@@ -0,0 +1,4 @@
+import type { Format } from 'style-dictionary/types';
+export declare const colorScheme: Format;
+export declare const colorCategory: Format;
+//# sourceMappingURL=color.d.ts.map

package/dist/src/tokens/process/formats/css/color.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"color.d.ts","sourceRoot":"","sources":["../../../../../../src/tokens/process/formats/css/color.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAYrD,eAAO,MAAM,WAAW,EAAE,MA0CzB,CAAC;AAEF,eAAO,MAAM,aAAa,EAAE,MA+B3B,CAAC"}

package/dist/src/tokens/process/formats/css/color.js

@@ -0,0 +1,128 @@
+// src/tokens/process/formats/css/color.ts
+import * as R2 from "ramda";
+import { createPropertyFormatter } from "style-dictionary/utils";
+
+// src/tokens/types.ts
+var colorCategories = {
+  main: "main",
+  support: "support"
+};
+
+// src/tokens/utils.ts
+import * as R from "ramda";
+var mapToLowerCase = R.map(R.toLower);
+var hasAnyTruth = R.any(R.equals(true));
+var getType = (token) => (token.$type ?? token.type) || "";
+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 isSemanticToken(token) {
+  return token.filePath.includes("semantic/");
+}
+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 R.startsWith(["color", category], token.path);
+}
+
+// src/tokens/process/formats/css/color.ts
+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(
+      R2.allPass([
+        R2.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 = R2.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 = R2.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 = R2.isNotNil(layer) ? `@layer ${layer} {
+${selector} ${content}
+}
+` : `${selector} ${content}
+`;
+    return body;
+  }
+};
+export {
+  colorCategory,
+  colorScheme
+};

package/dist/src/tokens/process/formats/css/semantic.d.ts

@@ -0,0 +1,17 @@
+import type { TransformedToken } from 'style-dictionary';
+import type { Format } from 'style-dictionary/types';
+export declare const isInlineTokens: (t: TransformedToken) => boolean;
+/**
+ * Overrides the default sizing formula with a custom one that supports [round()](https://developer.mozilla.org/en-US/docs/Web/CSS/round) if supported.
+ *
+ * @param format - Function to format a token into a CSS property string.
+ * @param tokens - Array of transformed tokens to format.
+ * @returns Object with formatted CSS strings for calc and round.
+ */
+export declare const overrideSizingFormula: (format: (t: TransformedToken) => string, token: TransformedToken) => {
+    name: string;
+    round: string;
+    calc: string;
+};
+export declare const semantic: Format;
+//# sourceMappingURL=semantic.d.ts.map

package/dist/src/tokens/process/formats/css/semantic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"semantic.d.ts","sourceRoot":"","sources":["../../../../../../src/tokens/process/formats/css/semantic.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAC;AACzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAQrD,eAAO,MAAM,cAAc,MAJY,gBAAgB,YAI+C,CAAC;AAEvG;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,GAAI,QAAQ,CAAC,CAAC,EAAE,gBAAgB,KAAK,MAAM,EAAE,OAAO,gBAAgB;;;;CAYrG,CAAC;AA8BF,eAAO,MAAM,QAAQ,EAAE,MA0BtB,CAAC"}

package/dist/src/tokens/process/formats/css/semantic.js

@@ -0,0 +1,109 @@
+// src/tokens/process/formats/css/semantic.ts
+import * as R2 from "ramda";
+import { createPropertyFormatter } from "style-dictionary/utils";
+
+// src/tokens/utils.ts
+import * as R from "ramda";
+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);
+});
+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/css/semantic.ts
+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}, 0.0625rem)`;
+  return {
+    name,
+    round,
+    calc
+  };
+};
+var formatSizingTokens = (format, tokens) => {
+  const { round, calc } = R2.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 = createPropertyFormatter({
+      outputReferences,
+      dictionary,
+      format: "css",
+      usesDtcg
+    });
+    const tokens = inlineTokens(isInlineTokens, dictionary.allTokens);
+    const filteredTokens = R2.reject((token) => token.name.includes("ds-size-mode-font-size"), tokens);
+    const [sizingTokens, restTokens] = R2.partition(
+      (t) => pathStartsWithOneOf(["_size"], t) && isDigit(t.path[1]),
+      filteredTokens
+    );
+    const formattedTokens = [R2.map(format, restTokens).join("\n"), formatSizingTokens(format, sizingTokens)];
+    const content = `{
+${formattedTokens.join("\n")}
+}
+`;
+    const body = R2.isNotNil(layer) ? `@layer ${layer} {
+${selector} ${content}
+}
+` : `${selector} ${content}
+`;
+    return body;
+  }
+};
+export {
+  isInlineTokens,
+  overrideSizingFormula,
+  semantic
+};

package/dist/src/tokens/process/formats/css/typography.d.ts

@@ -0,0 +1,3 @@
+import type { Format } from 'style-dictionary/types';
+export declare const typography: Format;
+//# sourceMappingURL=typography.d.ts.map

package/dist/src/tokens/process/formats/css/typography.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typography.d.ts","sourceRoot":"","sources":["../../../../../../src/tokens/process/formats/css/typography.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AASrD,eAAO,MAAM,UAAU,EAAE,MAsBxB,CAAC"}

package/dist/src/tokens/process/formats/css/typography.js

@@ -0,0 +1,32 @@
+// src/tokens/process/formats/css/typography.ts
+import * as R from "ramda";
+import { createPropertyFormatter } from "style-dictionary/utils";
+var typographyFontFamilyPredicate = R.allPass([
+  R.pathSatisfies(R.includes("typography"), ["path"]),
+  R.pathSatisfies(R.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 = createPropertyFormatter({
+      outputReferences,
+      dictionary,
+      format: "css",
+      usesDtcg
+    });
+    const filteredTokens = R.reject(typographyFontFamilyPredicate, dictionary.allTokens);
+    const formattedTokens = R.pipe(R.map(format), R.join("\n"))(filteredTokens);
+    const content = selector ? `${selector} {
+${formattedTokens}
+}` : formattedTokens;
+    const body = R.isNotNil(layer) ? `@layer ${layer} {
+${content}
+}` : content;
+    return body;
+  }
+};
+export {
+  typography
+};

package/dist/src/tokens/process/formats/css.d.ts

@@ -0,0 +1,8 @@
+import type { Format } from 'style-dictionary/types';
+export declare const formats: {
+    colorScheme: Format;
+    colorCategory: Format;
+    semantic: Format;
+    typography: Format;
+};
+//# sourceMappingURL=css.d.ts.map

package/dist/src/tokens/process/formats/css.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"css.d.ts","sourceRoot":"","sources":["../../../../../src/tokens/process/formats/css.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAMrD,eAAO,MAAM,OAAO;;;;;CAKc,CAAC"}

package/dist/src/tokens/{build → process}/formats/css.js

@@ -1,16 +1,48 @@
+// src/tokens/process/formats/css/color.ts
+import * as R2 from "ramda";
+import { createPropertyFormatter } from "style-dictionary/utils";
+
+// src/tokens/types.ts
+var colorCategories = {
+  main: "main",
+  support: "support"
+};
+
+// src/tokens/utils.ts
 import * as R from "ramda";
-import { createPropertyFormatter, fileHeader } from "style-dictionary/utils";
-import {
-  getValue,
-  isColorCategoryToken,
-  isDigit,
-  isGlobalColorToken,
-  isSemanticToken,
-  pathStartsWithOneOf
-} from "../../utils.js";
-import { colorCategories } from "../types.js";
-function squashTokens(shouldSquash, tokens) {
-  const [inlineableTokens, otherTokens] = R.partition(shouldSquash, tokens);
+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 isSemanticToken(token) {
+  return token.filePath.includes("semantic/");
+}
+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 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) {
@@ -23,19 +55,20 @@ function squashTokens(shouldSquash, tokens) {
     return tokenWithInlinedRefs;
   });
 }
-const prefersColorScheme = (colorScheme2, content) => `
+
+// src/tokens/process/formats/css/color.ts
+var prefersColorScheme = (colorScheme2, content) => `
 @media (prefers-color-scheme: ${colorScheme2}) {
   [data-color-scheme="auto"] ${content}
 }
 `;
-const colorScheme = {
+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 header = await fileHeader({ file });
     const format = createPropertyFormatter({
       outputReferences,
       dictionary,
@@ -46,8 +79,8 @@ const colorScheme = {
   color-scheme: ${colorScheme_};
 ` : "";
     const filteredAllTokens = allTokens.filter(
-      R.allPass([
-        R.anyPass([
+      R2.allPass([
+        R2.anyPass([
           // Include semantic tokens in the output
           isSemanticToken,
           // Include global color tokens
@@ -63,21 +96,20 @@ ${formattedTokens}
 ${colorSchemeProperty}}
 `;
     const autoSelectorContent = ["light", "dark"].includes(colorScheme_) ? prefersColorScheme(colorScheme_, content) : "";
-    const body = R.isNotNil(layer) ? `@layer ${layer} {
+    const body = R2.isNotNil(layer) ? `@layer ${layer} {
 ${selector} ${content} ${autoSelectorContent}
 }
 ` : `${selector} ${content} ${autoSelectorContent}
 `;
-    return header + body;
+    return body;
   }
 };
-const colorCategory = {
+var colorCategory = {
   name: "ds/css-colorcategory",
   format: async ({ dictionary, file, options, platform }) => {
-    const { outputReferences, usesDtcg, replaceCategoryWith = "" } = options;
+    const { outputReferences, usesDtcg } = options;
     const { selector, layer } = platform;
-    const header = await fileHeader({ file });
-    const format = R.compose(
+    const format = R2.compose(
       createPropertyFormatter({
         outputReferences,
         dictionary,
@@ -98,18 +130,23 @@ const colorCategory = {
 ${formattedTokens}
 }
 `;
-    const body = R.isNotNil(layer) ? `@layer ${layer} {
+    const body = R2.isNotNil(layer) ? `@layer ${layer} {
 ${selector} ${content}
 }
 ` : `${selector} ${content}
 `;
-    return header + body;
+    return body;
   }
 };
-const isNumericBorderRadiusToken = (t) => t.path[0] === "border-radius" && isDigit(t.path[1]);
-const isNumericSizeToken = (t) => pathStartsWithOneOf(["_size"], t) && isDigit(t.path[1]);
-const isSquashTokens = R.anyPass([isNumericBorderRadiusToken, isNumericSizeToken]);
-const overrideSizingFormula = (format, token) => {
+
+// src/tokens/process/formats/css/semantic.ts
+import * as R3 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 = R3.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)`;
@@ -119,8 +156,8 @@ const overrideSizingFormula = (format, token) => {
     calc
   };
 };
-const formatSizingTokens = (format, tokens) => {
-  const { round, calc } = R.reduce(
+var formatSizingTokens = (format, tokens) => {
+  const { round, calc } = R3.reduce(
     (acc, token) => {
       const { round: round2, calc: calc2, name } = overrideSizingFormula(format, token);
       return {
@@ -138,74 +175,74 @@ ${calc.join("\n")}
 ${round.join("\n")}
   }`;
 };
-const semantic = {
+var semantic = {
   name: "ds/css-semantic",
   format: async ({ dictionary, file, options, platform }) => {
     const { outputReferences, usesDtcg } = options;
     const { selector, layer } = platform;
-    const header = await fileHeader({ file });
-    const format = createPropertyFormatter({
+    const format = createPropertyFormatter2({
       outputReferences,
       dictionary,
       format: "css",
       usesDtcg
     });
-    const tokens = squashTokens(isSquashTokens, dictionary.allTokens);
-    const filteredTokens = R.reject((token) => token.name.includes("ds-size-mode-font-size"), tokens);
-    const [sizingTokens, restTokens] = R.partition(
-      (t) => pathStartsWithOneOf(["size", "_size"], t) && isDigit(t.path[1]),
+    const tokens = inlineTokens(isInlineTokens, dictionary.allTokens);
+    const filteredTokens = R3.reject((token) => token.name.includes("ds-size-mode-font-size"), tokens);
+    const [sizingTokens, restTokens] = R3.partition(
+      (t) => pathStartsWithOneOf(["_size"], t) && isDigit(t.path[1]),
       filteredTokens
     );
-    const formattedTokens = [R.map(format, restTokens).join("\n"), formatSizingTokens(format, sizingTokens)];
+    const formattedTokens = [R3.map(format, restTokens).join("\n"), formatSizingTokens(format, sizingTokens)];
     const content = `{
 ${formattedTokens.join("\n")}
 }
 `;
-    const body = R.isNotNil(layer) ? `@layer ${layer} {
+    const body = R3.isNotNil(layer) ? `@layer ${layer} {
 ${selector} ${content}
 }
 ` : `${selector} ${content}
 `;
-    return header + body;
+    return body;
   }
 };
-const typographyFontFamilyPredicate = R.allPass([
-  R.pathSatisfies(R.includes("typography"), ["path"]),
-  R.pathSatisfies(R.includes("fontFamily"), ["path"])
+
+// src/tokens/process/formats/css/typography.ts
+import * as R4 from "ramda";
+import { createPropertyFormatter as createPropertyFormatter3 } from "style-dictionary/utils";
+var typographyFontFamilyPredicate = R4.allPass([
+  R4.pathSatisfies(R4.includes("typography"), ["path"]),
+  R4.pathSatisfies(R4.includes("fontFamily"), ["path"])
 ]);
-const typography = {
+var typography = {
   name: "ds/css-typography",
   format: async ({ dictionary, file, options, platform }) => {
     const { outputReferences, usesDtcg } = options;
     const { selector, layer } = platform;
-    const header = await fileHeader({ file });
-    const format = createPropertyFormatter({
+    const format = createPropertyFormatter3({
       outputReferences,
       dictionary,
       format: "css",
       usesDtcg
     });
-    const filteredTokens = R.reject(typographyFontFamilyPredicate, dictionary.allTokens);
-    const formattedTokens = R.pipe(R.map(format), R.join("\n"))(filteredTokens);
+    const filteredTokens = R4.reject(typographyFontFamilyPredicate, dictionary.allTokens);
+    const formattedTokens = R4.pipe(R4.map(format), R4.join("\n"))(filteredTokens);
     const content = selector ? `${selector} {
 ${formattedTokens}
 }` : formattedTokens;
-    const body = R.isNotNil(layer) ? `@layer ${layer} {
+    const body = R4.isNotNil(layer) ? `@layer ${layer} {
 ${content}
 }` : content;
-    return header + body;
+    return body;
   }
 };
-const formats = {
+
+// src/tokens/process/formats/css.ts
+var formats = {
   colorScheme,
   colorCategory,
   semantic,
   typography
 };
 export {
-  formats,
-  isNumericSizeToken,
-  isSquashTokens,
-  overrideSizingFormula,
-  squashTokens
+  formats
 };

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

@@ -0,0 +1 @@
+{"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"}