@kaizen/design-tokens 10.3.2-canary.40 → 10.3.3

package/CHANGELOG.md

@@ -3,6 +3,22 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [10.3.3](https://github.com/cultureamp/kaizen-design-system/compare/@kaizen/design-tokens@10.3.2...@kaizen/design-tokens@10.3.3) (2023-03-29)
+
+**Note:** Version bump only for package @kaizen/design-tokens
+
+
+
+
+
+## [10.3.2](https://github.com/cultureamp/kaizen-design-system/compare/@kaizen/design-tokens@10.3.1...@kaizen/design-tokens@10.3.2) (2023-03-23)
+
+**Note:** Version bump only for package @kaizen/design-tokens
+
+
+
+
+
 ## [10.3.1](https://github.com/cultureamp/kaizen-design-system/compare/@kaizen/design-tokens@10.3.0...@kaizen/design-tokens@10.3.1) (2023-02-21)
 
 **Note:** Version bump only for package @kaizen/design-tokens

package/dist/ThemeManager.d.ts

@@ -0,0 +1,26 @@
+import { Theme as BaseTheme } from "./types";
+/**
+ * Use this class to set and apply themes, and to access or subscribe to the currently active one.
+ * This class fulfills the idea of theming and runtime theme switching by relying on CSS variables,
+ * and the ability to update them in JavaScript - a framework agnostic method.
+ *
+ * It works by converting a Theme interface to a flattened map of CSS variable keys and values, then calling `document.documentElement.style.setProperty(key, value)`.
+ */
+export declare class ThemeManager<Theme extends BaseTheme = BaseTheme> {
+    private themeChangeListeners;
+    private theme;
+    private rootElement;
+    private rootElementId;
+    constructor(theme: Theme, rootElementId?: string, apply?: boolean);
+    getRootElement: () => HTMLElement | null;
+    getRootElementId: () => string;
+    getCurrentTheme: () => Theme;
+    setRootElement: (element: HTMLElement) => void;
+    setRootElementId: (rootElementId: string) => string;
+    setAndApplyTheme: (theme: Theme, force?: boolean) => void;
+    addThemeChangeListener: (listener: (theme: Theme) => void) => void;
+    removeThemeChangeListener: (listener: (theme: Theme) => void) => void;
+    applyCurrentTheme: () => void;
+    private notifyThemeChangeListeners;
+}
+//# sourceMappingURL=ThemeManager.d.ts.map

package/dist/ThemeManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThemeManager.d.ts","sourceRoot":"","sources":["../src/ThemeManager.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,IAAI,SAAS,EAAE,MAAM,SAAS,CAAA;AAC5C;;;;;;GAMG;AACH,qBAAa,YAAY,CAAC,KAAK,SAAS,SAAS,GAAG,SAAS;IAC3D,OAAO,CAAC,oBAAoB,CAAsC;IAClE,OAAO,CAAC,KAAK,CAAO;IACpB,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,aAAa,CAAQ;gBAG3B,KAAK,EAAE,KAAK,EACZ,aAAa,GAAE,MAAW,EAE1B,KAAK,GAAE,OAAc;IAWhB,cAAc,QAAO,WAAW,GAAG,IAAI,CAAoB;IAC3D,gBAAgB,QAAO,MAAM,CAAsB;IACnD,eAAe,QAAO,KAAK,CAAc;IAEzC,cAAc,YAAa,WAAW,KAAG,IAAI,CAEnD;IACM,gBAAgB,kBAAmB,MAAM,KAAG,MAAM,CACnB;IAC/B,gBAAgB,UAAW,KAAK,UAAU,OAAO,KAAG,IAAI,CAO9D;IAEM,sBAAsB,qBAAsB,KAAK,KAAK,IAAI,KAAG,IAAI,CAEvE;IACM,yBAAyB,qBACZ,KAAK,KAAK,IAAI,KAC/B,IAAI,CAIN;IACM,iBAAiB,QAAO,IAAI,CAUlC;IAED,OAAO,CAAC,0BAA0B,CAEjC;CACF"}

package/dist/ThemeManager.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThemeManager = void 0;
+var makeCssVariableDefinitionsMap_1 = require("./lib/makeCssVariableDefinitionsMap");
+/**
+ * Use this class to set and apply themes, and to access or subscribe to the currently active one.
+ * This class fulfills the idea of theming and runtime theme switching by relying on CSS variables,
+ * and the ability to update them in JavaScript - a framework agnostic method.
+ *
+ * It works by converting a Theme interface to a flattened map of CSS variable keys and values, then calling `document.documentElement.style.setProperty(key, value)`.
+ */
+var ThemeManager = /** @class */ (function () {
+    function ThemeManager(theme, rootElementId, 
+    /* This allows you to stop the  class from applying the theme automatically during construction. Defaults to true */
+    apply) {
+        if (rootElementId === void 0) { rootElementId = ""; }
+        if (apply === void 0) { apply = true; }
+        var _this = this;
+        this.themeChangeListeners = [];
+        this.rootElement = null;
+        this.getRootElement = function () { return _this.rootElement; };
+        this.getRootElementId = function () { return _this.rootElementId; };
+        this.getCurrentTheme = function () { return _this.theme; };
+        this.setRootElement = function (element) {
+            _this.rootElement = element;
+        };
+        this.setRootElementId = function (rootElementId) {
+            return (_this.rootElementId = rootElementId);
+        };
+        this.setAndApplyTheme = function (theme, force) {
+            if (!force) {
+                if (_this.theme === theme)
+                    return;
+            }
+            _this.theme = theme;
+            _this.applyCurrentTheme();
+            _this.notifyThemeChangeListeners(theme);
+        };
+        this.addThemeChangeListener = function (listener) {
+            _this.themeChangeListeners.push(listener);
+        };
+        this.removeThemeChangeListener = function (listener) {
+            _this.themeChangeListeners = _this.themeChangeListeners.filter(function (l) { return l !== listener; });
+        };
+        this.applyCurrentTheme = function () {
+            var _a;
+            if (typeof window !== "undefined") {
+                _this.setRootElement((_a = document.getElementById(_this.rootElementId)) !== null && _a !== void 0 ? _a : document.documentElement);
+                var cssVariableDefinitions = (0, makeCssVariableDefinitionsMap_1.makeCssVariableDefinitionsMap)(_this.theme);
+                Object.entries(cssVariableDefinitions).forEach(function (_a) {
+                    var _b;
+                    var key = _a[0], value = _a[1];
+                    (_b = _this.rootElement) === null || _b === void 0 ? void 0 : _b.style.setProperty(key, value);
+                });
+            }
+        };
+        this.notifyThemeChangeListeners = function (theme) {
+            _this.themeChangeListeners.forEach(function (listener) { return listener(theme); });
+        };
+        /*
+          For some reason, storybook likes this way of defining class properties better.
+          If you use `constructor( private theme: Theme, ...)` - theme becomes undefined within the class's methods.
+        */
+        this.theme = theme;
+        this.rootElementId = rootElementId;
+        if (apply)
+            this.applyCurrentTheme();
+    }
+    return ThemeManager;
+}());
+exports.ThemeManager = ThemeManager;
+// I would like to expose this, but instantiating ThemeManager in some situations or runtimes (such as nodejs) cause exceptions.
+// For now it is not exposed, but we might come back to it, as it makes sense to have a singleton ThemeManager in almost all cases
+/* export const defaultThemeManager = new ThemeManager(defaultTheme) */
+//# sourceMappingURL=ThemeManager.js.map

package/dist/ThemeManager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ThemeManager.js","sourceRoot":"","sources":["../src/ThemeManager.ts"],"names":[],"mappings":";;;AAAA,qFAAmF;AAEnF;;;;;;GAMG;AACH;IAME,sBACE,KAAY,EACZ,aAA0B;IAC1B,oHAAoH;IACpH,KAAqB;QAFrB,8BAAA,EAAA,kBAA0B;QAE1B,sBAAA,EAAA,YAAqB;QAJvB,iBAaC;QAlBO,yBAAoB,GAAG,EAAmC,CAAA;QAE1D,gBAAW,GAAuB,IAAI,CAAA;QAkBvC,mBAAc,GAAG,cAA0B,OAAA,KAAI,CAAC,WAAW,EAAhB,CAAgB,CAAA;QAC3D,qBAAgB,GAAG,cAAc,OAAA,KAAI,CAAC,aAAa,EAAlB,CAAkB,CAAA;QACnD,oBAAe,GAAG,cAAa,OAAA,KAAI,CAAC,KAAK,EAAV,CAAU,CAAA;QAEzC,mBAAc,GAAG,UAAC,OAAoB;YAC3C,KAAI,CAAC,WAAW,GAAG,OAAO,CAAA;QAC5B,CAAC,CAAA;QACM,qBAAgB,GAAG,UAAC,aAAqB;YAC9C,OAAA,CAAC,KAAI,CAAC,aAAa,GAAG,aAAa,CAAC;QAApC,CAAoC,CAAA;QAC/B,qBAAgB,GAAG,UAAC,KAAY,EAAE,KAAe;YACtD,IAAI,CAAC,KAAK,EAAE;gBACV,IAAI,KAAI,CAAC,KAAK,KAAK,KAAK;oBAAE,OAAM;aACjC;YACD,KAAI,CAAC,KAAK,GAAG,KAAK,CAAA;YAClB,KAAI,CAAC,iBAAiB,EAAE,CAAA;YACxB,KAAI,CAAC,0BAA0B,CAAC,KAAK,CAAC,CAAA;QACxC,CAAC,CAAA;QAEM,2BAAsB,GAAG,UAAC,QAAgC;YAC/D,KAAI,CAAC,oBAAoB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;QAC1C,CAAC,CAAA;QACM,8BAAyB,GAAG,UACjC,QAAgC;YAEhC,KAAI,CAAC,oBAAoB,GAAG,KAAI,CAAC,oBAAoB,CAAC,MAAM,CAC1D,UAAA,CAAC,IAAI,OAAA,CAAC,KAAK,QAAQ,EAAd,CAAc,CACpB,CAAA;QACH,CAAC,CAAA;QACM,sBAAiB,GAAG;;YACzB,IAAI,OAAO,MAAM,KAAK,WAAW,EAAE;gBACjC,KAAI,CAAC,cAAc,CACjB,MAAA,QAAQ,CAAC,cAAc,CAAC,KAAI,CAAC,aAAa,CAAC,mCAAI,QAAQ,CAAC,eAAe,CACxE,CAAA;gBACD,IAAM,sBAAsB,GAAG,IAAA,6DAA6B,EAAC,KAAI,CAAC,KAAK,CAAC,CAAA;gBACxE,MAAM,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC,OAAO,CAAC,UAAC,EAAY;;wBAAX,GAAG,QAAA,EAAE,KAAK,QAAA;oBACzD,MAAA,KAAI,CAAC,WAAW,0CAAE,KAAK,CAAC,WAAW,CAAC,GAAG,EAAE,KAAK,CAAC,CAAA;gBACjD,CAAC,CAAC,CAAA;aACH;QACH,CAAC,CAAA;QAEO,+BAA0B,GAAG,UAAC,KAAY;YAChD,KAAI,CAAC,oBAAoB,CAAC,OAAO,CAAC,UAAA,QAAQ,IAAI,OAAA,QAAQ,CAAC,KAAK,CAAC,EAAf,CAAe,CAAC,CAAA;QAChE,CAAC,CAAA;QAnDC;;;UAGE;QACF,IAAI,CAAC,KAAK,GAAG,KAAK,CAAA;QAClB,IAAI,CAAC,aAAa,GAAG,aAAa,CAAA;QAClC,IAAI,KAAK;YAAE,IAAI,CAAC,iBAAiB,EAAE,CAAA;IACrC,CAAC;IA6CH,mBAAC;AAAD,CAAC,AAhED,IAgEC;AAhEY,oCAAY;AAkEzB,gIAAgI;AAChI,kIAAkI;AAClI,uEAAuE"}

package/dist/index.d.ts

@@ -1,360 +1,8 @@
-import React, { CSSProperties } from 'react';
-
-/**
- * Use a custom type for CSS properties becauase we should eventually write a more strongly typed version using template literal types.
- * This could definitely be contributed back to the community too. An example starting point here https://github.com/ghoullier/awesome-template-literal-types#css-parser
- * For example:
- * ```ts
- * type Font = {
- *   fontSize: `${number}rem`,
- *
- *  }
- * type HexDigit = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | A | B | C | D | E | F ;
- * type Color = `rgba(${number}, ${number}, ${number}, ${number}) | #${HexDigit}${HexDigit}${HexDigit}` // You get the point
- *
- * ```
- * */
-type KaizenCSSProperties = CSSProperties;
-type Hex = string;
-type TypographyFont = {
-    fontFamily: KaizenCSSProperties["fontFamily"];
-    fontWeight: KaizenCSSProperties["fontWeight"];
-    fontSize: KaizenCSSProperties["fontSize"];
-    lineHeight: KaizenCSSProperties["lineHeight"];
-    letterSpacing: KaizenCSSProperties["letterSpacing"];
-};
-type ThemeKey = "heart" | "custom";
-type Theme = {
-    themeKey: ThemeKey;
-    border: {
-        solid: {
-            borderWidth: KaizenCSSProperties["borderWidth"];
-            borderRadius: KaizenCSSProperties["borderRadius"];
-            borderStyle: KaizenCSSProperties["borderStyle"];
-            borderColor: KaizenCSSProperties["borderColor"];
-        };
-        dashed: {
-            borderWidth: KaizenCSSProperties["borderWidth"];
-            borderRadius: KaizenCSSProperties["borderRadius"];
-            borderStyle: KaizenCSSProperties["borderStyle"];
-        };
-        borderless: {
-            borderWidth: KaizenCSSProperties["borderWidth"];
-            borderRadius: KaizenCSSProperties["borderRadius"];
-            borderStyle: KaizenCSSProperties["borderStyle"];
-            borderColor: KaizenCSSProperties["borderColor"];
-        };
-        focusRing: {
-            borderWidth: KaizenCSSProperties["borderWidth"];
-            borderRadius: KaizenCSSProperties["borderRadius"];
-            borderStyle: KaizenCSSProperties["borderStyle"];
-        };
-    };
-    animation: {
-        easingFunction: {
-            easeInOut: string;
-            easeIn: string;
-            easeOut: string;
-            linear: string;
-            bounceIn: string;
-            bounceOut: string;
-            bounceInOut: string;
-        };
-        duration: {
-            instant: string;
-            immediate: string;
-            rapid: string;
-            fast: string;
-            slow: string;
-            deliberate: string;
-        };
-    };
-    color: {
-        purple: {
-            "100": Hex;
-            "200": Hex;
-            "300": Hex;
-            "400": Hex;
-            "500": Hex;
-            "600": Hex;
-            "700": Hex;
-            "800": Hex;
-        };
-        blue: {
-            "100": Hex;
-            "200": Hex;
-            "300": Hex;
-            "400": Hex;
-            "500": Hex;
-            "600": Hex;
-            "700": Hex;
-        };
-        green: {
-            "100": Hex;
-            "200": Hex;
-            "300": Hex;
-            "400": Hex;
-            "500": Hex;
-            "600": Hex;
-            "700": Hex;
-        };
-        yellow: {
-            "100": Hex;
-            "200": Hex;
-            "300": Hex;
-            "400": Hex;
-            "500": Hex;
-            "600": Hex;
-            "700": Hex;
-        };
-        red: {
-            "100": Hex;
-            "200": Hex;
-            "300": Hex;
-            "400": Hex;
-            "500": Hex;
-            "600": Hex;
-            "700": Hex;
-        };
-        orange: {
-            "100": Hex;
-            "200": Hex;
-            "300": Hex;
-            "400": Hex;
-            "500": Hex;
-            "600": Hex;
-            "700": Hex;
-        };
-        gray: {
-            "100": Hex;
-            "200": Hex;
-            "300": Hex;
-            "400": Hex;
-            "500": Hex;
-            "600": Hex;
-        };
-        white: Hex;
-    };
-    dataViz: {
-        favorable: Hex;
-        unfavorable: Hex;
-    };
-    layout: {
-        contentMaxWidth: string;
-        contentMaxWidthWithSidebar: string;
-        contentSideMargin: string;
-        mobileActionsDrawerHeight: string;
-        navigationBarHeight: string;
-        breakpoints: {
-            medium: string;
-            large: string;
-        };
-    };
-    shadow: {
-        small: {
-            boxShadow: string;
-        };
-        large: {
-            boxShadow: string;
-        };
-    };
-    spacing: {
-        xs: string;
-        sm: string;
-        md: string;
-        lg: string;
-        xl: string;
-        xxl: string;
-        xxxl: string;
-        xxxxl: string;
-        xxxxxl: string;
-        0: string;
-        1: string;
-        2: string;
-        4: string;
-        6: string;
-        8: string;
-        12: string;
-        16: string;
-        24: string;
-        32: string;
-        40: string;
-        48: string;
-        56: string;
-        64: string;
-        72: string;
-        80: string;
-        96: string;
-        112: string;
-        128: string;
-        160: string;
-        200: string;
-        240: string;
-        280: string;
-        320: string;
-    };
-    typography: {
-        dataLarge: TypographyFont;
-        dataLargeUnits: TypographyFont;
-        dataMedium: TypographyFont;
-        dataMediumUnits: TypographyFont;
-        dataSmall: TypographyFont;
-        dataSmallUnits: TypographyFont;
-        display0: TypographyFont;
-        heading1: TypographyFont;
-        heading2: TypographyFont;
-        heading3: TypographyFont;
-        heading4: TypographyFont;
-        heading5: TypographyFont;
-        heading6: TypographyFont;
-        paragraphIntroLede: TypographyFont;
-        paragraphBody: TypographyFont;
-        paragraphSmall: TypographyFont;
-        paragraphExtraSmall: TypographyFont;
-        paragraphBold: {
-            fontWeight: KaizenCSSProperties["fontWeight"];
-        };
-        buttonPrimary: TypographyFont;
-        buttonSecondary: TypographyFont;
-    };
-};
-type DeepMapObjectLeafs<T, LeafType> = T extends string | number | bigint | boolean | symbol | null | undefined | ((...params: any[]) => any) ? LeafType : T extends Record<any, any> ? {
-    [Key in keyof T]: DeepMapObjectLeafs<T[Key], LeafType>;
-} : T;
-/**
- * Apologies for the complex types.
- * This type represents the Theme type but with every leaf value in the tree mapped strictly to a string, rather than a number or a more complex type such as a string union.
- * The reason for this is to have a more accurate type for the generated hierarchy of design tokens which are represented as CSS custom properties, e.g. `var(--color-purple-800)`.
- */
-type CSSVariableTheme = DeepMapObjectLeafs<Theme, string>;
-
-declare const heartTheme: Theme;
-
-declare const defaultTheme: Theme;
-
-/**
- * Use this class to set and apply themes, and to access or subscribe to the currently active one.
- * This class fulfills the idea of theming and runtime theme switching by relying on CSS variables,
- * and the ability to update them in JavaScript - a framework agnostic method.
- *
- * It works by converting a Theme interface to a flattened map of CSS variable keys and values, then calling `document.documentElement.style.setProperty(key, value)`.
- */
-declare class ThemeManager<Theme extends Theme = Theme> {
-    private themeChangeListeners;
-    private theme;
-    private rootElement;
-    private rootElementId;
-    constructor(theme: Theme, rootElementId?: string, apply?: boolean);
-    getRootElement: () => HTMLElement | null;
-    getRootElementId: () => string;
-    getCurrentTheme: () => Theme;
-    setRootElement: (element: HTMLElement) => void;
-    setRootElementId: (rootElementId: string) => string;
-    setAndApplyTheme: (theme: Theme, force?: boolean) => void;
-    addThemeChangeListener: (listener: (theme: Theme) => void) => void;
-    removeThemeChangeListener: (listener: (theme: Theme) => void) => void;
-    applyCurrentTheme: () => void;
-    private notifyThemeChangeListeners;
-}
-
-declare const ThemeContext: React.Context<Theme>;
-/**
- * Wrap your application in this provider using a ThemeManager, to synchronise it with a react context.
- * This allows child react elements to more easily use theme variables, using the {@link useTheme} hook.
- */
-/**
- * @deprecated ThemeProvider is deprecated. Please use KaizenProvider from "@kaizen/components" instead.
- */
-declare const ThemeProvider: ({ themeManager, ...props }: {
-    themeManager?: ThemeManager<Theme> | undefined;
-    children: React.ReactNode;
-}) => JSX.Element;
-declare const useTheme: () => Theme;
-
-/**
-
- * Make a map of CSS variables -> values in a consistent way.
- * Use this to, for example, create a CSS file that declares each theme variable on the `:root` pseudo element.
- * Or for example when you're defining CSS variables using `rootElement.style.setProperty` within ThemeManager.
- *
- * It is paramount that this function defines every variable that {@link makeCssVariableTheme} expects to be defined.
- * Otherwise, it's possible that a CSS variable token (something that looks like var(--color-purple-100-rgb)) won't have a matching defined
- * CSS variable like `--color-purple-100-rgb: 123, 123, 123;`
- *
- *
- * For example:
- * Input:
- * ```
- * {
- *      color: {
- *        whatever: {
- *          100: "#ff0022"
- *        }
- *      }
- * }
- * ```
- * Output:
- * ```
- * {
- *  "--color-whatever-100": "#ff0022"
- * }
- */
-declare function makeCssVariableDefinitionsMap(theme: Record<string | number, unknown>): Record<string, string>;
-
-/**
- * This function could use a new name during a breaking change
- *
- * Given a Theme (which is the source of truth and doesn't contain any computed properties), add extra necessary properties to the tree such as `-rgb` suffixed keys with R, G, B triple values, and
- * convert the leaf values of a theme to a value like `var(--parent1key-parent2key-leafkey)` - a CSS variable with an identifier that represents it's hierarchy.
- *
- * Example:
- * ```
- * {
- *    color: {
- *        purple: {
- *          100: "#f0f1f4"
- *        }
- *    }
- * }
- * ```
- * Transforms into:
- * ```
- * {
- *    color: {
- *        purple: {
- *          100: "var(--color-purple-100, "#f0f1f4")",
- *          "100-rgb": "var(--color-purple-100-rgb, 240, 241, 244)",
- *          "100-id": "--color-purple-100",
- *          "100-rgb-id": "--color-purple-100-rgb"
- *        }
- *    }
- * }
- * ```
- *
- * See {@link addExtraThemeEntries} for how these extra entries are added.
- */
-declare function makeCSSVariableTheme<ThemeType extends Record<string | number, unknown>>(theme: ThemeType, printValue?: (path: string[], value: unknown) => string): DeepMapObjectLeafs<ThemeType, string>;
-
-/**
- * This allows you to map the leaf nodes of an object, and you're provided the path to that leaf as well as the value as parameters to your mapper function.
- * This function was build to support mapping theme values to their respective CSS variable identifiers.
- * For example:
- * ```ts
- * mapLeafsOfObject({
- *  one: {
- *    two: 4
- *  }
- * }, (path, value) => value + 7)
- * ```
- * Results in:
- * ```
- * {
- *    one: {
- *      two: 11
- *    }
- * }
- * ```
- */
-declare function mapLeafsOfObject<Obj extends Record<string | number, unknown>, Value>(object: Obj, mapper: (pathToLeaf: string[], value: unknown) => Value): DeepMapObjectLeafs<Obj, Value>;
-
-export { CSSVariableTheme, DeepMapObjectLeafs, Theme, ThemeContext, ThemeKey, ThemeManager, ThemeProvider, TypographyFont, defaultTheme, heartTheme, makeCSSVariableTheme, makeCssVariableDefinitionsMap, mapLeafsOfObject, useTheme };
+export * from "./themes";
+export * from "./types";
+export * from "./ThemeManager";
+export * from "./react";
+export { makeCssVariableDefinitionsMap } from "./lib/makeCssVariableDefinitionsMap";
+export { makeCSSVariableTheme } from "./lib/makeCssVariableTheme";
+export { mapLeafsOfObject } from "./lib/mapLeafsOfObject";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,cAAc,UAAU,CAAA;AACxB,cAAc,SAAS,CAAA;AACvB,cAAc,gBAAgB,CAAA;AAC9B,cAAc,SAAS,CAAA;AAEvB,OAAO,EAAE,6BAA6B,EAAE,MAAM,qCAAqC,CAAA;AACnF,OAAO,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAA;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,wBAAwB,CAAA"}