@koine/utils 2.0.0-beta.2 → 2.0.0-beta.21

package/cjs/Defer.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Defer = void 0;
+function Defer() {
+    var self = this || {};
+    var p = (self.promise = new Promise(function (resolve, reject) {
+        self.resolve = resolve;
+        self.reject = reject;
+    }));
+    self.then = p.then.bind(p);
+    self.catch = p.catch.bind(p);
+    return self;
+}
+exports.Defer = Defer;
+exports.default = Defer;

package/cjs/Emitter.d.ts

@@ -0,0 +1,7 @@
+export declare function Emitter<EventMap extends {
+    [key: string]: any;
+}>(namespace: string): {
+    on<EventName extends keyof EventMap>(name: EventName, handler: (data?: EventMap[EventName] | undefined) => any): void;
+    emit<EventName_1 extends keyof EventMap>(name: EventName_1, data?: EventMap[EventName_1] | undefined): void;
+};
+export default Emitter;

package/{Emitter.mjs → cjs/Emitter.js}

@@ -1,21 +1,9 @@
-/**
- * Emitter super simple class
- *
- * Events will be prefixed with the given `namespace` plus a `.` so:
- * `{namespace}.myevent`
- *
- * Adapted from https://github.com/developit/mitt
- *
- * Regarding typescript support @see:
- * - https://stackoverflow.com/q/53299743/1938970
- * - https://github.com/Microsoft/TypeScript/pull/26349
- */
-export function Emitter(namespace) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Emitter = void 0;
+function Emitter(namespace) {
     var all = new Map();
     return {
-        /**
-         * Register an event handler for the given type.
-         */
         on: function (name, handler) {
             var handlers = all.get("".concat(namespace, ".").concat(String(name)));
             var added = handlers && handlers.push(handler);
@@ -23,9 +11,6 @@ export function Emitter(namespace) {
                 all.set("".concat(namespace, ".").concat(String(name)), [handler]);
             }
         },
-        /**
-         * Invoke all handlers for the given type.
-         */
         emit: function (name, data) {
             (all.get("".concat(namespace, ".").concat(String(name))) || [])
                 .slice()
@@ -35,4 +20,5 @@ export function Emitter(namespace) {
         },
     };
 }
-export default Emitter;
+exports.Emitter = Emitter;
+exports.default = Emitter;

package/cjs/accentSets.d.ts

@@ -0,0 +1,3 @@
+export type AccentsSet = [string, string];
+export declare const accentsSets: AccentsSet[];
+export default accentsSets;

package/{accentSets.mjs → cjs/accentSets.js}

@@ -1,12 +1,7 @@
-/**
- * Accent sets
- *
- * @category text
- * @see https://gist.github.com/mathewbyrne/1280286#gistcomment-3498021
- * @see https://gist.github.com/eek/9c4887e80b3ede05c0e39fee4dce3747 for usage
- * of [normalize](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/normalize)
- */
-export var accentsSets = [
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.accentsSets = void 0;
+exports.accentsSets = [
     ["a", "ÀÁÂÃÅÆĀĂĄẠẢẤẦẨẪẬẮẰẲẴẶ"],
     ["ae", "Ä"],
     ["c", "ÇĆĈČ"],
@@ -35,4 +30,4 @@ export var accentsSets = [
     ["y", "ÝŶŸỲỴỶỸ"],
     ["z", "ŹŻŽ"],
 ];
-export default accentsSets;
+exports.default = exports.accentsSets;

package/cjs/addOrReplaceAtIdx.d.ts

@@ -0,0 +1,2 @@
+export declare function addOrReplaceAtIdx<T>(list: T[], newItem: T, newIdx?: number): T[];
+export default addOrReplaceAtIdx;

package/cjs/addOrReplaceAtIdx.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addOrReplaceAtIdx = void 0;
+var tslib_1 = require("tslib");
+function addOrReplaceAtIdx(list, newItem, newIdx) {
+    if (list.length === 0) {
+        return [newItem];
+    }
+    if (typeof newIdx === "undefined" || list.length - 1 < newIdx) {
+        return tslib_1.__spreadArray(tslib_1.__spreadArray([], tslib_1.__read(list), false), [newItem], false);
+    }
+    return list.map(function (item, idx) {
+        if (idx === newIdx) {
+            return newItem;
+        }
+        return item;
+    });
+}
+exports.addOrReplaceAtIdx = addOrReplaceAtIdx;
+exports.default = addOrReplaceAtIdx;

package/cjs/areEqual.d.ts

@@ -0,0 +1,4 @@
+type ComparablePrimitive = string | number | boolean;
+type Comparable = ComparablePrimitive | object | Record<string, ComparablePrimitive> | Array<ComparablePrimitive>;
+export declare function areEqual(a: Comparable, b?: Comparable): boolean;
+export default areEqual;

package/cjs/areEqual.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.areEqual = void 0;
+var tslib_1 = require("tslib");
+var isArray_1 = require("./isArray");
+var isObject_1 = require("./isObject");
+function areEqualArrays(a, b) {
+    if (!b)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (var i = 0; i < a.length; i++) {
+        var aValue = a[i];
+        var bValue = b[i];
+        if (!areEqual(aValue, bValue))
+            return false;
+    }
+    return true;
+}
+function areEqualObjects(a, b) {
+    var e_1, _a;
+    if (!b)
+        return false;
+    var aKeys = Object.keys(a);
+    var bKeys = Object.keys(b);
+    if (aKeys.length !== bKeys.length) {
+        return false;
+    }
+    try {
+        for (var aKeys_1 = tslib_1.__values(aKeys), aKeys_1_1 = aKeys_1.next(); !aKeys_1_1.done; aKeys_1_1 = aKeys_1.next()) {
+            var _key = aKeys_1_1.value;
+            var key = _key;
+            var aValue = a[key];
+            var bValue = b[key];
+            if (!areEqual(aValue, bValue)) {
+                return false;
+            }
+        }
+    }
+    catch (e_1_1) { e_1 = { error: e_1_1 }; }
+    finally {
+        try {
+            if (aKeys_1_1 && !aKeys_1_1.done && (_a = aKeys_1.return)) _a.call(aKeys_1);
+        }
+        finally { if (e_1) throw e_1.error; }
+    }
+    return true;
+}
+function areEqual(a, b) {
+    if (!a && !b) {
+        return true;
+    }
+    if (!b && a !== b) {
+        return false;
+    }
+    var areObjects = (0, isObject_1.isObject)(a) && (0, isObject_1.isObject)(b);
+    if (areObjects && !areEqualObjects(a, b)) {
+        return false;
+    }
+    var areArrays = (0, isArray_1.isArray)(a) && (0, isArray_1.isArray)(b);
+    if (areArrays && !areEqualArrays(a, b)) {
+        return false;
+    }
+    if (!areObjects && !areArrays && a !== b) {
+        return false;
+    }
+    return true;
+}
+exports.areEqual = areEqual;
+exports.default = areEqual;

package/cjs/arrayOfAll.d.ts

@@ -0,0 +1,2 @@
+export declare const arrayOfAll: <T>() => <U extends T[]>(array: U & ([T] extends [U[number]] ? unknown : "Invalid")) => U & ([T] extends [U[number]] ? unknown : "Invalid");
+export default arrayOfAll;

package/cjs/arrayOfAll.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayOfAll = void 0;
+var arrayOfAll = function () {
+    return function (array) {
+        return array;
+    };
+};
+exports.arrayOfAll = arrayOfAll;
+exports.default = exports.arrayOfAll;

package/cjs/arraySum.d.ts

@@ -0,0 +1,2 @@
+export declare const arraySum: (numbers: number[]) => number;
+export default arraySum;

package/cjs/arraySum.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arraySum = void 0;
+var arraySum = function (numbers) {
+    return numbers.reduce(function (sum, current) { return sum + current; }, 0);
+};
+exports.arraySum = arraySum;
+exports.default = exports.arraySum;

package/cjs/arrayToLookup.d.ts

@@ -0,0 +1,2 @@
+export declare function arrayToLookup<T extends string | number | symbol>(array?: T[]): Record<T, 1>;
+export default arrayToLookup;

package/cjs/arrayToLookup.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayToLookup = void 0;
+function arrayToLookup(array) {
+    if (array === void 0) { array = []; }
+    return array.reduce(function (obj, item) {
+        obj[item] = 1;
+        return obj;
+    }, {});
+}
+exports.arrayToLookup = arrayToLookup;
+exports.default = arrayToLookup;

package/cjs/arrayUniqueByProperties.d.ts

@@ -0,0 +1,2 @@
+export declare const arrayUniqueByProperties: <T extends any[]>(array: T, keys: (keyof T[number])[]) => T;
+export default arrayUniqueByProperties;

package/cjs/arrayUniqueByProperties.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.arrayUniqueByProperties = void 0;
+var arrayUniqueByProperties = function (array, keys) {
+    return array.filter(function (item, idx, arr) {
+        return arr.findIndex(function (itemWith) {
+            return keys.every(function (k) { return itemWith[k] === item[k]; });
+        }) === idx;
+    });
+};
+exports.arrayUniqueByProperties = arrayUniqueByProperties;
+exports.default = exports.arrayUniqueByProperties;

package/cjs/buildUrlQueryString.d.ts

@@ -0,0 +1,3 @@
+import { type AnyQueryParams } from "./location";
+export declare function buildUrlQueryString<T extends AnyQueryParams>(params: T): string;
+export default buildUrlQueryString;

package/cjs/buildUrlQueryString.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildUrlQueryString = void 0;
+var isArray_1 = require("./isArray");
+var isNull_1 = require("./isNull");
+var isUndefined_1 = require("./isUndefined");
+function buildUrlQueryString(params) {
+    var output = "";
+    if (!params)
+        return output;
+    for (var key in params) {
+        var value = params[key];
+        if ((0, isArray_1.default)(value)) {
+            for (var i = 0; i < value.length; i++) {
+                output += "".concat(key, "=").concat(encodeURIComponent(value[i] + ""), "&");
+            }
+        }
+        else if (!(0, isNull_1.default)(value) && !(0, isUndefined_1.default)(value)) {
+            output += "".concat(key, "=").concat(encodeURIComponent(value + ""), "&");
+        }
+    }
+    return output ? "?".concat(output.replace(/&+$/, "")) : "";
+}
+exports.buildUrlQueryString = buildUrlQueryString;
+exports.default = buildUrlQueryString;

package/cjs/capitalize.d.ts

@@ -0,0 +1,2 @@
+export declare function capitalize<T extends string>(string?: null | T): Capitalize<T>;
+export default capitalize;

package/cjs/capitalize.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.capitalize = void 0;
+function capitalize(string) {
+    var ensuredString = string || "";
+    return (ensuredString.charAt(0).toUpperCase() +
+        ensuredString.slice(1));
+}
+exports.capitalize = capitalize;
+exports.default = capitalize;

package/cjs/changeUrlPath.d.ts

@@ -0,0 +1,2 @@
+export declare function changeUrlPath(pathname: string, state?: object, replace?: boolean): string;
+export default changeUrlPath;

package/cjs/changeUrlPath.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.changeUrlPath = void 0;
+var isBrowser_1 = require("./isBrowser");
+var normaliseUrlPathname_1 = require("./normaliseUrlPathname");
+function changeUrlPath(pathname, state, replace) {
+    var path = (0, normaliseUrlPathname_1.default)("/".concat(pathname, "/"));
+    if (isBrowser_1.default) {
+        history[replace ? "replaceState" : "pushState"](state, "", path);
+    }
+    return path;
+}
+exports.changeUrlPath = changeUrlPath;
+exports.default = changeUrlPath;

package/cjs/chunkByChunks.d.ts

@@ -0,0 +1,2 @@
+export declare function chunkByChunks<T>(arr: T[], nrOfChunks: number, balanced?: boolean): T[][];
+export default chunkByChunks;

package/{chunkByChunks.mjs → cjs/chunkByChunks.js}

@@ -1,9 +1,7 @@
-/**
- * TODO: untested
- * @category array
- * @see https://stackoverflow.com/a/8189268/1938970
- */
-export function chunkByChunks(arr, nrOfChunks, balanced) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkByChunks = void 0;
+function chunkByChunks(arr, nrOfChunks, balanced) {
     if (nrOfChunks < 2)
         return [arr];
     var len = arr.length;
@@ -34,4 +32,5 @@ export function chunkByChunks(arr, nrOfChunks, balanced) {
     }
     return output;
 }
-export default chunkByChunks;
+exports.chunkByChunks = chunkByChunks;
+exports.default = chunkByChunks;

package/cjs/chunkBySize.d.ts

@@ -0,0 +1,2 @@
+export declare function chunkBySize<T>(arr: T[], size: number): T[][];
+export default chunkBySize;

package/cjs/chunkBySize.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chunkBySize = void 0;
+function chunkBySize(arr, size) {
+    var output = [];
+    for (var i = 0; i < arr.length; i += size) {
+        output.push(arr.slice(i, i + size));
+    }
+    return output;
+}
+exports.chunkBySize = chunkBySize;
+exports.default = chunkBySize;

package/cjs/clamp.d.ts

@@ -0,0 +1,2 @@
+export declare function clamp(num: number, min: number, max: number): number;
+export default clamp;

package/cjs/clamp.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clamp = void 0;
+function clamp(num, min, max) {
+    return Math.min(Math.max(num, min), max);
+}
+exports.clamp = clamp;
+exports.default = clamp;

package/cjs/clsx.d.ts

@@ -0,0 +1,6 @@
+type ClassValue = ClassArray | ClassDictionary | string | number | null | boolean | undefined;
+type ClassDictionary = Record<string, any>;
+type ClassArray = ClassValue[];
+export type ClsxClassValue = ClassValue;
+export declare const clsx: (...args: ClassValue[]) => string;
+export default clsx;

package/{clsx.mjs → cjs/clsx.js}

@@ -1,5 +1,6 @@
-// import _clsx from "clsx";
-// export const clsx = _clsx;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clsx = void 0;
 function toVal(mix) {
     var k, y, str = "";
     if (typeof mix === "string" || typeof mix === "number") {
@@ -27,16 +28,9 @@ function toVal(mix) {
     }
     return str;
 }
-/**
- * Class names utility
- *
- * @borrows [lukeed/clsx](https://github.com/lukeed/clsx)
- * @license [MIT: Luke Edwards](https://github.com/lukeed/clsx/blob/master/license)
- */
-export var clsx = function () {
+var clsx = function () {
     var i = 0, tmp, x, str = "";
     while (i < arguments.length) {
-        // eslint-disable-next-line prefer-rest-params
         if ((tmp = arguments[i++])) {
             if ((x = toVal(tmp))) {
                 str && (str += " ");
@@ -46,4 +40,5 @@ export var clsx = function () {
     }
     return str;
 };
-export default clsx;
+exports.clsx = clsx;
+exports.default = exports.clsx;

package/cjs/convertRange.d.ts

@@ -0,0 +1,2 @@
+export declare function convertRange(num: number, r1: number[], r2: number[]): number;
+export default convertRange;

package/cjs/convertRange.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertRange = void 0;
+function convertRange(num, r1, r2) {
+    return ((num - r1[0]) * (r2[1] - r2[0])) / (r1[1] - r1[0]) + r2[0];
+}
+exports.convertRange = convertRange;
+exports.default = convertRange;

package/cjs/cookie.d.ts

@@ -0,0 +1,18 @@
+type CookieAttributes = {
+    expires?: number | Date | undefined;
+    path?: string | undefined;
+    domain?: string | undefined;
+    secure?: boolean | undefined;
+    sameSite?: "strict" | "Strict" | "lax" | "Lax" | "none" | "None" | undefined;
+};
+export type CookieAttributesServer = CookieAttributes & {
+    maxAge?: number;
+    httpOnly?: boolean;
+    encode?: (input: string) => string;
+    decode?: (input: string) => string;
+};
+export type CookieAttributesClient = CookieAttributes;
+export declare const defaultAttributesClient: {
+    path: string;
+};
+export {};

package/cjs/cookie.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultAttributesClient = void 0;
+exports.defaultAttributesClient = { path: "/" };

package/cjs/createPalette.d.ts

@@ -0,0 +1,10 @@
+type PaletteShade = readonly [number, string];
+type PaletteShades = readonly PaletteShade[];
+type PaletteMapPair<T extends PaletteShade> = {
+    [Pair in T as `${Pair[0]}`]: Pair[1];
+};
+type PaletteMap<T extends PaletteShades> = {
+    [PS in T[number] as keyof PaletteMapPair<PS>]: PaletteMapPair<PS>[keyof PaletteMapPair<PS>];
+};
+export declare const createPalette: <TName extends string, TShades extends PaletteShades, TColor = TShades[number][1], TMap = PaletteMap<TShades>>(name: TName, shades: TShades) => readonly [TMap, Record<`${TName}-${TShades[number][0]}`, string>, TColor[]];
+export default createPalette;

package/cjs/createPalette.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPalette = void 0;
+var createPalette = function (name, shades) {
+    var map = shades.reduce(function (map, def) {
+        map[def[0]] = def[1];
+        return map;
+    }, {});
+    var tailwindPalette = shades.reduce(function (map, def) {
+        map["".concat(name, "-").concat(def[0])] = def[1];
+        return map;
+    }, {});
+    return [map, tailwindPalette, Object.values(map)];
+};
+exports.createPalette = createPalette;
+exports.default = exports.createPalette;

package/cjs/debounce.d.ts

@@ -0,0 +1,2 @@
+export declare function debounce<T extends (...args: any[]) => any>(fn: T, wait?: number, immediate?: boolean): (this: unknown, ...args: Parameters<T>) => void;
+export default debounce;

package/{debounce.mjs → cjs/debounce.js}

@@ -1,17 +1,13 @@
-/**
- * Debounce function (with `setTimeout`)
- *
- * @category function
- * @borrows [davidwalsh/debounce](https://davidwalsh.name/javascript-debounce-function)
- */
-export function debounce(fn, wait, immediate) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = void 0;
+function debounce(fn, wait, immediate) {
     var timeout;
     return function () {
         var args = [];
         for (var _i = 0; _i < arguments.length; _i++) {
             args[_i] = arguments[_i];
         }
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
         var context = this;
         var later = function () {
             timeout = null;
@@ -26,4 +22,5 @@ export function debounce(fn, wait, immediate) {
             fn.apply(context, args);
     };
 }
-export default debounce;
+exports.debounce = debounce;
+exports.default = debounce;

package/cjs/debouncePromise.d.ts

@@ -0,0 +1,11 @@
+export type DebounceOptions<Result> = {
+    isImmediate?: boolean;
+    maxWait?: number;
+    callback?: (data: Result) => void;
+};
+export interface DebouncedFunction<Args extends any[], F extends (...args: Args) => any> {
+    (this: ThisParameterType<F>, ...args: Args & Parameters<F>): Promise<ReturnType<F>>;
+    cancel: (reason?: any) => void;
+}
+export declare function debouncePromise<Args extends any[], F extends (...args: Args) => any>(func: F, waitMilliseconds?: number, options?: DebounceOptions<ReturnType<F>>): DebouncedFunction<Args, F>;
+export default debouncePromise;

package/cjs/debouncePromise.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debouncePromise = void 0;
+function debouncePromise(func, waitMilliseconds, options) {
+    var _a, _b;
+    if (waitMilliseconds === void 0) { waitMilliseconds = 50; }
+    if (options === void 0) { options = {}; }
+    var timeoutId;
+    var isImmediate = (_a = options.isImmediate) !== null && _a !== void 0 ? _a : false;
+    var callback = (_b = options.callback) !== null && _b !== void 0 ? _b : false;
+    var maxWait = options.maxWait;
+    var lastInvokeTime = Date.now();
+    var promises = [];
+    function nextInvokeTimeout() {
+        if (maxWait !== undefined) {
+            var timeSinceLastInvocation = Date.now() - lastInvokeTime;
+            if (timeSinceLastInvocation + waitMilliseconds >= maxWait) {
+                return maxWait - timeSinceLastInvocation;
+            }
+        }
+        return waitMilliseconds;
+    }
+    var debouncedFunction = function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var context = this;
+        return new Promise(function (resolve, reject) {
+            var invokeFunction = function () {
+                timeoutId = undefined;
+                lastInvokeTime = Date.now();
+                if (!isImmediate) {
+                    var result_1 = func.apply(context, args);
+                    callback && callback(result_1);
+                    promises.forEach(function (_a) {
+                        var resolve = _a.resolve;
+                        return resolve(result_1);
+                    });
+                    promises = [];
+                }
+            };
+            var shouldCallNow = isImmediate && timeoutId === undefined;
+            if (timeoutId !== undefined) {
+                clearTimeout(timeoutId);
+            }
+            timeoutId = setTimeout(invokeFunction, nextInvokeTimeout());
+            if (shouldCallNow) {
+                var result = func.apply(context, args);
+                callback && callback(result);
+                return resolve(result);
+            }
+            promises.push({ resolve: resolve, reject: reject });
+        });
+    };
+    debouncedFunction.cancel = function (reason) {
+        if (timeoutId !== undefined) {
+            clearTimeout(timeoutId);
+        }
+        promises.forEach(function (_a) {
+            var reject = _a.reject;
+            return reject(reason);
+        });
+        promises = [];
+    };
+    return debouncedFunction;
+}
+exports.debouncePromise = debouncePromise;
+exports.default = debouncePromise;

package/cjs/debounceRaf.d.ts

@@ -0,0 +1,2 @@
+export declare function debounceRaf<T extends (...args: any[]) => any>(this: unknown, fn: T): (this: unknown, ...args: Parameters<T>) => void;
+export default debounceRaf;

package/cjs/debounceRaf.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounceRaf = void 0;
+function debounceRaf(fn) {
+    var timeout;
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var context = this;
+        if (timeout) {
+            window.cancelAnimationFrame(timeout);
+        }
+        timeout = window.requestAnimationFrame(function () {
+            fn.apply(context, args);
+        });
+    };
+}
+exports.debounceRaf = debounceRaf;
+exports.default = debounceRaf;

package/cjs/decode.d.ts

@@ -0,0 +1,2 @@
+export declare function decode<TReturn extends string>(str: string): TReturn;
+export default decode;