@primer/primitives 9.1.2 → 10.0.0-rc.1bc5b670

package/dist/build/transformers/cubicBezierToCss.js

@@ -0,0 +1,23 @@
+import { isCubicBezier } from '../filters/isCubicBezier.js';
+/**
+ * @description converts cubicBezeir tokens array value to a css cubic-bezier
+ * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
+ * @matcher matches all tokens of $type `duration`
+ * @transformer returns a css cubic-bezier function
+ */
+export const cubicBezierToCss = {
+    name: 'cubicBezeir/css',
+    type: 'value',
+    transitive: true,
+    filter: isCubicBezier,
+    transform: (token, _config) => {
+        var _a;
+        const value = (_a = token.$value) !== null && _a !== void 0 ? _a : token.value;
+        // throw value of more or less than 4 items in array
+        if (value.length !== 4 || value.some((item) => typeof item !== 'number')) {
+            throw new Error(`Invalid cubicBezier token ${token.path.join('.')}, must be an array with 4 numbers, but got this instead: ${JSON.stringify(value)}`);
+        }
+        // return value
+        return `cubic-bezier(${value.join(',')})`;
+    },
+};

package/dist/build/transformers/dimensionToPixelUnitless.d.ts

@@ -1,8 +1,8 @@
-import type StyleDictionary from 'style-dictionary';
+import type { Transform } from 'style-dictionary/types';
 /**
  * @description converts dimension tokens value to pixel value without unit, ignores `em` as they are relative to the font size of the parent element
  * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
  * @matcher matches all tokens of $type `dimension`
  * @transformer returns a float number
  */
-export declare const dimensionToPixelUnitless: StyleDictionary.Transform;
+export declare const dimensionToPixelUnitless: Transform;

package/dist/build/transformers/dimensionToPixelUnitless.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dimensionToPixelUnitless = void 0;
-const filters_1 = require("../filters");
+import { isDimension } from '../filters/index.js';
 /**
  * @description base font size from options or 16
  * @param options
@@ -26,25 +23,27 @@ const hasUnit = (value, unit) => {
  * @matcher matches all tokens of $type `dimension`
  * @transformer returns a float number
  */
-exports.dimensionToPixelUnitless = {
-    type: `value`,
+export const dimensionToPixelUnitless = {
+    name: 'dimension/pixelUnitless',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isDimension,
-    transformer: (token, options) => {
-        const baseFont = getBasePxFontSize(options);
-        const floatVal = parseFloat(token.value);
+    filter: isDimension,
+    transform: (token, config, options) => {
+        const valueProp = options.usesDtcg ? '$value' : 'value';
+        const baseFont = getBasePxFontSize(config);
+        const floatVal = parseFloat(token[valueProp]);
         if (isNaN(floatVal)) {
-            throw new Error(`Invalid dimension token: '${token.name}: ${token.value}' is not valid and cannot be transform to 'float' \n`);
+            throw new Error(`Invalid dimension token: '${token.path.join('.')}: ${token[valueProp]}' is not valid and cannot be transform to 'float' \n`);
         }
         if (floatVal === 0) {
             return 0;
         }
-        if (hasUnit(token.value, 'rem')) {
+        if (hasUnit(token[valueProp], 'rem')) {
             return floatVal * baseFont;
         }
-        if (hasUnit(token.value, 'px')) {
+        if (hasUnit(token[valueProp], 'px')) {
             return floatVal;
         }
-        return token.value;
+        return token[valueProp];
     },
 };

package/dist/build/transformers/dimensionToRem.d.ts

@@ -1,8 +1,8 @@
-import type StyleDictionary from 'style-dictionary';
+import type { Transform } from 'style-dictionary/types';
 /**
  * @description converts dimension tokens value to `rem`, ignores `em` as they are relative to the font size of the parent element
  * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
  * @matcher matches all tokens of $type `dimension`
  * @transformer returns a `rem` string
  */
-export declare const dimensionToRem: StyleDictionary.Transform;
+export declare const dimensionToRem: Transform;

package/dist/build/transformers/dimensionToRem.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dimensionToRem = void 0;
-const filters_1 = require("../filters");
+import { isDimension } from '../filters/index.js';
 /**
  * @description base font size from options or 16
  * @param options
@@ -26,21 +23,23 @@ const hasUnit = (value, unit) => {
  * @matcher matches all tokens of $type `dimension`
  * @transformer returns a `rem` string
  */
-exports.dimensionToRem = {
-    type: `value`,
+export const dimensionToRem = {
+    name: 'dimension/rem',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isDimension,
-    transformer: (token, options) => {
-        const baseFont = getBasePxFontSize(options);
-        const floatVal = parseFloat(token.value);
+    filter: isDimension,
+    transform: (token, config, options) => {
+        const valueProp = options.usesDtcg ? '$value' : 'value';
+        const baseFont = getBasePxFontSize(config);
+        const floatVal = parseFloat(token[valueProp]);
         if (isNaN(floatVal)) {
-            throw new Error(`Invalid dimension token: '${token.name}: ${token.value}' is not valid and cannot be transform to 'rem' \n`);
+            throw new Error(`Invalid dimension token: '${token.name}: ${token[valueProp]}' is not valid and cannot be transform to 'rem' \n`);
         }
         if (floatVal === 0) {
             return '0';
         }
-        if (hasUnit(token.value, 'rem') || hasUnit(token.value, 'em')) {
-            return token.value;
+        if (hasUnit(token[valueProp], 'rem') || hasUnit(token[valueProp], 'em')) {
+            return token[valueProp];
         }
         return `${floatVal / baseFont}rem`;
     },

package/dist/build/transformers/dimensionToRemPxArray.d.ts

@@ -1,8 +1,8 @@
-import type StyleDictionary from 'style-dictionary';
+import type { Transform } from 'style-dictionary/types';
 /**
  * @description converts dimension tokens value to `rem`, ignores `em` as they are relative to the font size of the parent element
  * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
  * @matcher matches all tokens of $type `dimension`
  * @transformer returns an array with the `rem` and `pixel` string
  */
-export declare const dimensionToRemPxArray: StyleDictionary.Transform;
+export declare const dimensionToRemPxArray: Transform;

package/dist/build/transformers/dimensionToRemPxArray.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.dimensionToRemPxArray = void 0;
-const filters_1 = require("../filters");
+import { isDimension } from '../filters/index.js';
 /**
  * @description base font size from options or 16
  * @param options
@@ -26,20 +23,22 @@ const hasUnit = (value, unit) => {
  * @matcher matches all tokens of $type `dimension`
  * @transformer returns an array with the `rem` and `pixel` string
  */
-exports.dimensionToRemPxArray = {
-    type: `value`,
+export const dimensionToRemPxArray = {
+    name: 'dimension/remPxArray',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isDimension,
-    transformer: (token, options) => {
-        const baseFont = getBasePxFontSize(options);
-        const floatVal = parseFloat(token.value);
+    filter: isDimension,
+    transform: (token, config, options) => {
+        const valueProp = options.usesDtcg ? '$value' : 'value';
+        const baseFont = getBasePxFontSize(config);
+        const floatVal = parseFloat(token[valueProp]);
         if (isNaN(floatVal)) {
-            throw new Error(`Invalid dimension token: '${token.name}: ${token.value}' is not valid and cannot be transform to 'rem' \n`);
+            throw new Error(`Invalid dimension token: '${token.name}: ${token[valueProp]}' is not valid and cannot be transform to 'rem' \n`);
         }
         if (floatVal === 0) {
             return ['0', '0'];
         }
-        if (hasUnit(token.value, 'rem') || hasUnit(token.value, 'em')) {
+        if (hasUnit(token[valueProp], 'rem') || hasUnit(token[valueProp], 'em')) {
             return [token.value, `${floatVal * baseFont}px`];
         }
         return [`${floatVal / baseFont}rem`, `${floatVal}px`];

package/dist/build/transformers/durationToCss.d.ts

@@ -1,8 +1,8 @@
-import type StyleDictionary from 'style-dictionary';
+import type { Transform } from 'style-dictionary/types';
 /**
  * @description converts duration tokens string value to number with `ms` unit
  * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
  * @matcher matches all tokens of $type `duration`
  * @transformer returns a css duration
  */
-export declare const durationToCss: StyleDictionary.Transform;
+export declare const durationToCss: Transform;

package/dist/build/transformers/durationToCss.js

@@ -1,24 +1,23 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.durationToCss = void 0;
-const isDuration_1 = require("../filters/isDuration");
+import { isDuration } from '../filters/index.js';
 /**
  * @description converts duration tokens string value to number with `ms` unit
  * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
  * @matcher matches all tokens of $type `duration`
  * @transformer returns a css duration
  */
-exports.durationToCss = {
-    type: `value`,
+export const durationToCss = {
+    name: 'duration/css',
+    type: 'value',
     transitive: true,
-    matcher: isDuration_1.isDuration,
-    transformer: (token, _options) => {
+    filter: isDuration,
+    transform: (token, _config, options) => {
+        const valueProp = options.usesDtcg ? '$value' : 'value';
         // throw an error if token value is not a string or does not end with `ms`
-        if (typeof token.value !== `string` || !token.value.endsWith(`ms`)) {
-            throw new Error(`duration token value must be a string with an "ms" unit`);
+        if (typeof token[valueProp] !== `string` || !(token[valueProp].endsWith(`ms`) || token[valueProp].endsWith(`s`))) {
+            throw new Error(`duration token value must be a string with an "ms" || "s" unit, invalid token: ${token.name} with value: ${token[valueProp]}`);
         }
         // get value
-        let value = parseInt(token.value.replace('ms', ''));
+        let value = parseInt(token[valueProp].replace('ms', ''));
         let unit = `ms`;
         if (value >= 1000) {
             value = value / 1000;

package/dist/build/transformers/figmaAttributes.d.ts

@@ -1,8 +1,8 @@
-import type StyleDictionary from 'style-dictionary';
+import type { Transform } from 'style-dictionary/types';
 /**
  * @description retrieves figma attributes from token and adds them to attributes
  * @type attribute transformer — [StyleDictionary.AttributeTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
  * @matcher matches all tokens
  * @transformer returns ab object of figma attributes
  */
-export declare const figmaAttributes: StyleDictionary.Transform;
+export declare const figmaAttributes: Transform;

package/dist/build/transformers/figmaAttributes.js

@@ -1,6 +1,3 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.figmaAttributes = void 0;
 const figmaScopes = {
     all: ['ALL_SCOPES'],
     radius: ['CORNER_RADIUS'],
@@ -41,9 +38,10 @@ const getScopes = (scopes) => {
  * @matcher matches all tokens
  * @transformer returns ab object of figma attributes
  */
-exports.figmaAttributes = {
+export const figmaAttributes = {
+    name: 'figma/attributes',
     type: `attribute`,
-    transformer: (token, platform = {}) => {
+    transform: (token, platform = {}) => {
         var _a, _b;
         const { mode, collection, scopes, group, codeSyntax } = ((_a = token.$extensions) === null || _a === void 0 ? void 0 : _a['org.primer.figma']) || {};
         return {

package/dist/build/transformers/floatToPixel.d.ts

@@ -1,15 +1,15 @@
-import type StyleDictionary from 'style-dictionary';
+import type { Transform, TransformedToken } from 'style-dictionary/types';
 /**
  * takes a value and returns it if its a px string if it is a float and the token has a fontSize value in extensions['org.primer.data']
  * @param value
  * @returns string
  */
-export declare const convertFloatToPixel: (token: StyleDictionary.TransformedToken, unitless?: boolean) => any;
+export declare const convertFloatToPixel: (token: TransformedToken, unitless?: boolean) => any;
 /**
  * @description converts a float value to a pixel value based on the provided fontSize on the tokersn extension
  * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
  * @matcher matches all tokens of $type `isNumber`
  * @transformer returns a pixel string
  */
-export declare const floatToPixel: StyleDictionary.Transform;
-export declare const floatToPixelUnitless: StyleDictionary.Transform;
+export declare const floatToPixel: Transform;
+export declare const floatToPixelUnitless: Transform;

package/dist/build/transformers/floatToPixel.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.floatToPixelUnitless = exports.floatToPixel = exports.convertFloatToPixel = void 0;
-const filters_1 = require("../filters");
+import { isNumber } from '../filters/index.js';
 /**
  * takes a value and returns it if its a px string if it is a float and the token has a fontSize value in extensions['org.primer.data']
  * @param value
  * @returns string
  */
-const convertFloatToPixel = (token, unitless = false) => {
+export const convertFloatToPixel = (token, unitless = false) => {
     var _a, _b, _c, _d, _e, _f;
     // short circut if value is not a number
     if (typeof token.value !== 'number' ||
@@ -20,22 +17,23 @@ const convertFloatToPixel = (token, unitless = false) => {
     // return converted value
     return convertedValue === 0 ? 0 : unitless ? Math.round(convertedValue) : `${Math.round(convertedValue)}px`;
 };
-exports.convertFloatToPixel = convertFloatToPixel;
 /**
  * @description converts a float value to a pixel value based on the provided fontSize on the tokersn extension
  * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
  * @matcher matches all tokens of $type `isNumber`
  * @transformer returns a pixel string
  */
-exports.floatToPixel = {
-    type: `value`,
+export const floatToPixel = {
+    name: 'float/pixel',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isNumber,
-    transformer: (token) => (0, exports.convertFloatToPixel)(token),
+    filter: isNumber,
+    transform: (token) => convertFloatToPixel(token),
 };
-exports.floatToPixelUnitless = {
-    type: `value`,
+export const floatToPixelUnitless = {
+    name: 'float/pixelUnitless',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isNumber,
-    transformer: (token) => (0, exports.convertFloatToPixel)(token, true),
+    filter: isNumber,
+    transform: (token) => convertFloatToPixel(token, true),
 };

package/dist/build/transformers/fontFamilyToCss.d.ts

@@ -1,4 +1,4 @@
-import type StyleDictionary from 'style-dictionary';
+import type { Transform } from 'style-dictionary/types';
 /**
  * takes a value and returns it if its a string or concats strings in an array quoting strings with spaces
  * @param value
@@ -11,4 +11,4 @@ export declare const parseFontFamily: (value: unknown) => string;
  * @matcher matches all tokens of $type `fontFamily`
  * @transformer returns a string
  */
-export declare const fontFamilyToCss: StyleDictionary.Transform;
+export declare const fontFamilyToCss: Transform;

package/dist/build/transformers/fontFamilyToCss.js

@@ -1,15 +1,12 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fontFamilyToCss = exports.parseFontFamily = void 0;
-const filters_1 = require("../filters");
-const getTokenValue_1 = require("./utilities/getTokenValue");
-const hasSpaceInString_1 = require("./utilities/hasSpaceInString");
+import { isFontFamily } from '../filters/index.js';
+import { getTokenValue } from './utilities/getTokenValue.js';
+import { hasSpaceInString } from './utilities/hasSpaceInString.js';
 /**
  * takes a value and returns it if its a string or concats strings in an array quoting strings with spaces
  * @param value
  * @returns string
  */
-const parseFontFamily = (value) => {
+export const parseFontFamily = (value) => {
     if (typeof value === 'string') {
         return value;
     }
@@ -19,22 +16,22 @@ const parseFontFamily = (value) => {
             if (typeof string !== 'string') {
                 throw new Error(`Invalid value in array ${string}, must be a string`);
             }
-            return (0, hasSpaceInString_1.hasSpaceInString)(string) ? `'${string}'` : string;
+            return hasSpaceInString(string) ? `'${string}'` : string;
         })
             .join(', ');
     }
     throw new Error(`Invalid value ${value}, should be a string or array of strings`);
 };
-exports.parseFontFamily = parseFontFamily;
 /**
  * @description converts fontFamily tokens value to string
  * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
  * @matcher matches all tokens of $type `fontFamily`
  * @transformer returns a string
  */
-exports.fontFamilyToCss = {
-    type: `value`,
+export const fontFamilyToCss = {
+    name: 'fontFamily/css',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isFontFamily,
-    transformer: (token) => (0, exports.parseFontFamily)((0, getTokenValue_1.getTokenValue)(token)),
+    filter: isFontFamily,
+    transform: (token) => parseFontFamily(getTokenValue(token)),
 };

package/dist/build/transformers/fontFamilyToFigma.d.ts

@@ -1,14 +1,14 @@
-import type StyleDictionary from 'style-dictionary';
+import type { Config, Transform, TransformedToken } from 'style-dictionary/types';
 /**
  * takes a value and returns it if its a string or concats strings in an array quoting strings with spaces
  * @param value
  * @returns string
  */
-export declare const parseFontFamily: (token: StyleDictionary.TransformedToken, fontFamilies?: Record<string, string>) => string;
+export declare const parseFontFamily: (token: TransformedToken, fontFamilies: Record<string, string> | undefined, options: Config) => string;
 /**
  * @description converts fontFamily tokens value to string
  * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
  * @matcher matches all tokens of $type `fontFamily`
  * @transformer returns a string
  */
-export declare const fontFamilyToFigma: StyleDictionary.Transform;
+export declare const fontFamilyToFigma: Transform;

package/dist/build/transformers/fontFamilyToFigma.js

@@ -1,46 +1,44 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fontFamilyToFigma = exports.parseFontFamily = void 0;
-const filters_1 = require("../filters");
-const hasSpaceInString_1 = require("./utilities/hasSpaceInString");
+import { isFontFamily } from '../filters/index.js';
+import { hasSpaceInString } from './utilities/hasSpaceInString.js';
 /**
  * takes a value and returns it if its a string or concats strings in an array quoting strings with spaces
  * @param value
  * @returns string
  */
-const parseFontFamily = (token, fontFamilies = {}) => {
+export const parseFontFamily = (token, fontFamilies = {}, options) => {
+    const valueProp = options.usesDtcg ? '$value' : 'value';
     // return value from fontFamilies
     if (token.name in fontFamilies) {
         return fontFamilies[token.name];
     }
     // return string
-    if (typeof token.value === 'string') {
-        return token.value;
+    if (typeof token[valueProp] === 'string') {
+        return token[valueProp];
     }
     // return stringified array
-    if (Array.isArray(token.value)) {
-        return token.value
+    if (Array.isArray(token[valueProp])) {
+        return token[valueProp]
             .map((string) => {
             if (typeof string !== 'string') {
                 throw new Error(`Invalid value in array ${string}, must be a string`);
             }
-            return (0, hasSpaceInString_1.hasSpaceInString)(string) ? `'${string}'` : string;
+            return hasSpaceInString(string) ? `'${string}'` : string;
         })
             .join(', ');
     }
     // invalid value
-    throw new Error(`Invalid value ${token.value}, should be a string or array of strings`);
+    throw new Error(`Invalid value ${token[valueProp]}, should be a string or array of strings`);
 };
-exports.parseFontFamily = parseFontFamily;
 /**
  * @description converts fontFamily tokens value to string
  * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
  * @matcher matches all tokens of $type `fontFamily`
  * @transformer returns a string
  */
-exports.fontFamilyToFigma = {
-    type: `value`,
+export const fontFamilyToFigma = {
+    name: 'fontFamily/figma',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isFontFamily,
-    transformer: (token, platform) => { var _a; return (0, exports.parseFontFamily)(token, (_a = platform.options) === null || _a === void 0 ? void 0 : _a.fontFamilies); },
+    filter: isFontFamily,
+    transform: (token, platform, options) => { var _a; return parseFontFamily(token, (_a = platform.options) === null || _a === void 0 ? void 0 : _a.fontFamilies, options); },
 };

package/dist/build/transformers/fontWeightToNumber.d.ts

@@ -1,4 +1,4 @@
-import type StyleDictionary from 'style-dictionary';
+import type { Transform } from 'style-dictionary/types';
 export declare const parseFontWeight: (value: unknown) => number;
 /**
  * @description converts fontWeight tokens value to numeric value
@@ -6,4 +6,4 @@ export declare const parseFontWeight: (value: unknown) => number;
  * @matcher matches all tokens of $type `fontWeight`
  * @transformer returns a number
  */
-export declare const fontWeightToNumber: StyleDictionary.Transform;
+export declare const fontWeightToNumber: Transform;

package/dist/build/transformers/fontWeightToNumber.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.fontWeightToNumber = exports.parseFontWeight = void 0;
-const filters_1 = require("../filters");
-const getTokenValue_1 = require("./utilities/getTokenValue");
+import { isFontWeight } from '../filters/index.js';
+import { getTokenValue } from './utilities/getTokenValue.js';
 const fontWeightMatrix = {
     '100': ['thin', 'hairline'],
     '200': ['extra-light', 'ultra-light'],
@@ -15,7 +12,7 @@ const fontWeightMatrix = {
     '900': ['black', 'heavy'],
     '950': ['extra-black', 'ultra-black'],
 };
-const parseFontWeight = (value) => {
+export const parseFontWeight = (value) => {
     // throw on anything but string and number
     if (typeof value !== 'string' && typeof value !== 'number') {
         throw new Error(`Invalid value ${value}, should be a number or fontWeight string`);
@@ -38,16 +35,16 @@ const parseFontWeight = (value) => {
     // invalid value
     throw new Error(`Invalid value ${value}, should be a number or fontWeight string`);
 };
-exports.parseFontWeight = parseFontWeight;
 /**
  * @description converts fontWeight tokens value to numeric value
  * @type value transformer — [StyleDictionary.ValueTransform](https://github.com/amzn/style-dictionary/blob/main/types/Transform.d.ts)
  * @matcher matches all tokens of $type `fontWeight`
  * @transformer returns a number
  */
-exports.fontWeightToNumber = {
-    type: `value`,
+export const fontWeightToNumber = {
+    name: 'fontWeight/number',
+    type: 'value',
     transitive: true,
-    matcher: filters_1.isFontWeight,
-    transformer: (token) => (0, exports.parseFontWeight)((0, getTokenValue_1.getTokenValue)(token)),
+    filter: isFontWeight,
+    transform: (token) => parseFontWeight(getTokenValue(token)),
 };

package/dist/build/transformers/index.d.ts

@@ -1,24 +1,25 @@
-export { borderToCss } from './borderToCss';
-export { colorToHex } from './colorToHex';
-export { colorToHexMix } from './colorToHexMix';
-export { colorToRgbAlpha } from './colorToRgbAlpha';
-export { colorToRgbaFloat } from './colorToRgbaFloat';
-export { floatToPixel } from './floatToPixel';
-export { floatToPixelUnitless } from './floatToPixel';
-export { dimensionToRem } from './dimensionToRem';
-export { dimensionToRemPxArray } from './dimensionToRemPxArray';
-export { dimensionToPixelUnitless } from './dimensionToPixelUnitless';
-export { durationToCss } from './durationToCss';
-export { figmaAttributes } from './figmaAttributes';
-export { fontFamilyToCss } from './fontFamilyToCss';
-export { fontFamilyToFigma } from './fontFamilyToFigma';
-export { fontWeightToNumber } from './fontWeightToNumber';
-export { jsonDeprecated } from './jsonDeprecated';
-export { namePathToCamelCase } from './namePathToCamelCase';
-export { namePathToPascalCase } from './namePathToPascalCase';
-export { namePathToDotNotation } from './namePathToDotNotation';
-export { namePathToFigma } from './namePathToFigma';
-export { namePathToKebabCase } from './namePathToKebabCase';
-export { namePathToSlashNotation } from './namePathToSlashNotation';
-export { shadowToCss } from './shadowToCss';
-export { typographyToCss } from './typographyToCss';
+export { borderToCss } from './borderToCss.js';
+export { colorToHex } from './colorToHex.js';
+export { colorToHexMix } from './colorToHexMix.js';
+export { colorToRgbAlpha } from './colorToRgbAlpha.js';
+export { colorToRgbaFloat } from './colorToRgbaFloat.js';
+export { cubicBezierToCss } from './cubicBezierToCss.js';
+export { floatToPixel } from './floatToPixel.js';
+export { floatToPixelUnitless } from './floatToPixel.js';
+export { dimensionToRem } from './dimensionToRem.js';
+export { dimensionToRemPxArray } from './dimensionToRemPxArray.js';
+export { dimensionToPixelUnitless } from './dimensionToPixelUnitless.js';
+export { durationToCss } from './durationToCss.js';
+export { figmaAttributes } from './figmaAttributes.js';
+export { fontFamilyToCss } from './fontFamilyToCss.js';
+export { fontFamilyToFigma } from './fontFamilyToFigma.js';
+export { fontWeightToNumber } from './fontWeightToNumber.js';
+export { jsonDeprecated } from './jsonDeprecated.js';
+export { namePathToCamelCase } from './namePathToCamelCase.js';
+export { namePathToPascalCase } from './namePathToPascalCase.js';
+export { namePathToDotNotation } from './namePathToDotNotation.js';
+export { namePathToFigma } from './namePathToFigma.js';
+export { namePathToKebabCase } from './namePathToKebabCase.js';
+export { namePathToSlashNotation } from './namePathToSlashNotation.js';
+export { shadowToCss } from './shadowToCss.js';
+export { typographyToCss } from './typographyToCss.js';