@koine/utils 2.0.0-beta.13 → 2.0.0-beta.15

package/cjs/quaranteneProps.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quaranteneProps = void 0;
+function quaranteneProps(props, propsKeysToQuarantene) {
+    var healthyProps = {
+        _: {},
+    };
+    for (var key in props) {
+        var prop = props[key];
+        if (propsKeysToQuarantene.includes(key)) {
+            healthyProps._[key] = prop;
+        }
+        else {
+            healthyProps[key] = prop;
+        }
+    }
+    return healthyProps;
+}
+exports.quaranteneProps = quaranteneProps;
+exports.default = quaranteneProps;

package/cjs/randomInt.d.ts

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

package/cjs/randomInt.js

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

package/cjs/randomKey.d.ts

@@ -0,0 +1,2 @@
+export declare function randomKey<T extends Record<string | number, unknown>>(obj: T): keyof T;
+export default randomKey;

package/cjs/randomKey.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.randomKey = void 0;
+function randomKey(obj) {
+    var keys = Object.keys(obj);
+    return keys[(keys.length * Math.random()) << 0];
+}
+exports.randomKey = randomKey;
+exports.default = randomKey;

package/cjs/readCookie.d.ts

@@ -0,0 +1,3 @@
+export declare function readCookie<T extends Record<string, unknown> = Record<string, string>>(name?: null): T;
+export declare function readCookie<T extends Record<string, unknown> = Record<string, string>, N extends keyof T = keyof T>(name: N): T[N];
+export default readCookie;

package/cjs/readCookie.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCookie = void 0;
+function converterRead(value) {
+    if (value[0] === '"') {
+        value = value.slice(1, -1);
+    }
+    return value.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+}
+function readCookie(name) {
+    if (typeof document === "undefined") {
+        if (process.env["NODE_ENV"] !== "production") {
+            console.warn("[@koine/utils:readCookie] document is undefined");
+        }
+        return name ? "" : {};
+    }
+    var cookies = document.cookie ? document.cookie.split("; ") : [];
+    var all = {};
+    for (var i = 0; i < cookies.length; i++) {
+        var parts = cookies[i].split("=");
+        var value = parts.slice(1).join("=");
+        try {
+            var found = decodeURIComponent(parts[0]);
+            all[found] = converterRead(value);
+            if (name === found) {
+                break;
+            }
+        }
+        catch (e) {
+            if (process.env["NODE_ENV"] !== "production") {
+                console.warn("[@koine/utils:readCookie] failed to decode", value);
+            }
+        }
+    }
+    return name ? all[name] : all;
+}
+exports.readCookie = readCookie;
+exports.default = readCookie;

package/cjs/removeAccents.d.ts

@@ -0,0 +1,3 @@
+import { type AccentsSet } from "./accentSets";
+export declare function removeAccents(text?: string, sets?: AccentsSet[]): string;
+export default removeAccents;

package/cjs/removeAccents.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeAccents = void 0;
+var accentSets_1 = require("./accentSets");
+function removeAccents(text, sets) {
+    if (text === void 0) { text = ""; }
+    if (sets === void 0) { sets = accentSets_1.accentsSets; }
+    var len = sets.length;
+    while (len--) {
+        var _a = sets[len], to = _a[0], from = _a[1];
+        text = text.replace(new RegExp("[".concat(from, "]"), "gi"), to);
+    }
+    return text;
+}
+exports.removeAccents = removeAccents;
+exports.default = removeAccents;

package/cjs/removeCookie.d.ts

@@ -0,0 +1,3 @@
+import { type CookieAttributesClient } from "./cookie";
+export declare function removeCookie(name: string, attributes?: CookieAttributesClient): void;
+export default removeCookie;

package/cjs/removeCookie.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeCookie = void 0;
+var tslib_1 = require("tslib");
+var cookie_1 = require("./cookie");
+var setCookie_1 = require("./setCookie");
+function removeCookie(name, attributes) {
+    if (attributes === void 0) { attributes = {}; }
+    (0, setCookie_1.setCookie)(name, "", tslib_1.__assign(tslib_1.__assign(tslib_1.__assign({}, cookie_1.defaultAttributesClient), attributes), { expires: -1 }));
+}
+exports.removeCookie = removeCookie;
+exports.default = removeCookie;

package/cjs/removeDuplicates.js

@@ -0,0 +1 @@
+"use strict";

package/cjs/removeDuplicatesByKey.d.ts

@@ -0,0 +1,2 @@
+export declare function removeDuplicatesByKey<T extends Record<string | number | symbol, any>>(array: T[] | undefined, key: keyof T): T[];
+export default removeDuplicatesByKey;

package/cjs/removeDuplicatesByKey.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDuplicatesByKey = void 0;
+function removeDuplicatesByKey(array, key) {
+    if (array === void 0) { array = []; }
+    var keysMap = {};
+    var output = [];
+    for (var i = 0; i < array.length; i++) {
+        var item = array[i];
+        if (!keysMap[item[key]]) {
+            output.push(item);
+            keysMap[item[key]] = true;
+        }
+    }
+    return output;
+}
+exports.removeDuplicatesByKey = removeDuplicatesByKey;
+exports.default = removeDuplicatesByKey;

package/cjs/removeDuplicatesComparing.d.ts

@@ -0,0 +1,2 @@
+export declare function removeDuplicatesComparing<T>(from: any[], to: T[]): T[];
+export default removeDuplicatesComparing;

package/cjs/removeDuplicatesComparing.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeDuplicatesComparing = void 0;
+var findDuplicatedIndexes_1 = require("./findDuplicatedIndexes");
+var removeIndexesFromArray_1 = require("./removeIndexesFromArray");
+function removeDuplicatesComparing(from, to) {
+    var indexes = (0, findDuplicatedIndexes_1.findDuplicatedIndexes)(from);
+    return (0, removeIndexesFromArray_1.removeIndexesFromArray)(to, indexes);
+}
+exports.removeDuplicatesComparing = removeDuplicatesComparing;
+exports.default = removeDuplicatesComparing;

package/cjs/removeIndexesFromArray.d.ts

@@ -0,0 +1,2 @@
+export declare function removeIndexesFromArray<T>(arr: T[], indexes: Record<number, true>): T[];
+export default removeIndexesFromArray;

package/cjs/removeIndexesFromArray.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeIndexesFromArray = void 0;
+function removeIndexesFromArray(arr, indexes) {
+    var output = [];
+    for (var i = 0; i < arr.length; i++) {
+        if (!indexes.hasOwnProperty(i)) {
+            output.push(arr[i]);
+        }
+    }
+    return output;
+}
+exports.removeIndexesFromArray = removeIndexesFromArray;
+exports.default = removeIndexesFromArray;

package/cjs/removeTrailingSlash.d.ts

@@ -0,0 +1,2 @@
+export declare function removeTralingSlash(urlLike?: string): string;
+export default removeTralingSlash;

package/cjs/removeTrailingSlash.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeTralingSlash = void 0;
+function removeTralingSlash(urlLike) {
+    if (urlLike === void 0) { urlLike = ""; }
+    return urlLike.replace(/\/*$/, "");
+}
+exports.removeTralingSlash = removeTralingSlash;
+exports.default = removeTralingSlash;

package/cjs/removeUrlQueryParams.d.ts

@@ -0,0 +1,2 @@
+export declare function removeUrlQueryParams(url: string, paramsToRemove?: string[]): string;
+export default removeUrlQueryParams;

package/cjs/removeUrlQueryParams.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.removeUrlQueryParams = void 0;
+var buildUrlQueryString_1 = require("./buildUrlQueryString");
+var getUrlQueryParams_1 = require("./getUrlQueryParams");
+function removeUrlQueryParams(url, paramsToRemove) {
+    if (paramsToRemove === void 0) { paramsToRemove = []; }
+    var parts = url.split("?");
+    var allParams = (0, getUrlQueryParams_1.default)(url);
+    var params = {};
+    for (var key in allParams) {
+        if (!paramsToRemove.includes(key)) {
+            params[key] = allParams[key];
+        }
+    }
+    return parts[0] + (0, buildUrlQueryString_1.default)(params);
+}
+exports.removeUrlQueryParams = removeUrlQueryParams;
+exports.default = removeUrlQueryParams;

package/cjs/render.d.ts

@@ -0,0 +1,13 @@
+type DefinitionExtended = {
+    __exp?: {
+        [key: string]: number | boolean | string;
+    };
+    arg: string;
+    text: string;
+};
+type Definitions = {
+    [key: string]: DefinitionExtended;
+} & DefinitionExtended;
+type RenderFunction = (data: object) => string;
+export declare const render: (tmpl: string, def?: Definitions) => RenderFunction;
+export default render;

package/cjs/render.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.render = void 0;
+var varname = "data";
+var evaluate = /<%([\s\S]+?(\}?)+)%>/g;
+var interpolate = /<%=([\s\S]+?)%>/g;
+var conditional = /<%\?(\?)?\s*([\s\S]*?)\s*%>/g;
+var iterate = /<%~\s*(?:%>|([\s\S]+?)\s*:\s*([\w$]+)\s*(?::\s*([\w$]+))?\s*%>)/g;
+var use = /<%#([\s\S]+?)%>/g;
+var useParams = /(^|[^\w$])def(?:\.|\[['"])([\w$.]+)(?:['"]\])?\s*:\s*([\w$.]+|"[^"]+"|'[^']+'|\{[^}]+\})/g;
+var define = /<%##\s*([\w.$]+)\s*(:|=)([\s\S]+?)#%>/g;
+var defineParams = /^\s*([\w$]+):([\s\S]+)/;
+var start = "'+(";
+var end = ")+'";
+var skip = /$^/;
+var resolveDefs = function (block, def) {
+    return (typeof block === "string" ? block : block.toString())
+        .replace(define || skip, function (_, code, assign, value) {
+        if (code.indexOf("def.") === 0) {
+            code = code.substring(4);
+        }
+        if (!(code in def)) {
+            if (assign === ":") {
+                value.replace(defineParams, function (_, param, v) {
+                    def[code] = { arg: param, text: v };
+                });
+                if (!(code in def))
+                    def[code] = value;
+            }
+            else {
+                new Function("def", "def['" + code + "']=" + value)(def);
+            }
+        }
+        return "";
+    })
+        .replace(use || skip, function (_, code) {
+        code = code.replace(useParams, function (_, s, d, param) {
+            if (def[d] && def[d].arg && param) {
+                var rw = (d + ":" + param).replace(/'|\\/g, "_");
+                def.__exp = def.__exp || {};
+                def.__exp[rw] = def[d].text.replace(new RegExp("(^|[^\\w$])" + def[d].arg + "([^\\w$])", "g"), "$1" + param + "$2");
+                return s + "def.__exp['" + rw + "']";
+            }
+            return s;
+        });
+        var v = new Function("def", "return " + code)(def);
+        return v ? resolveDefs(v, def) : v;
+    });
+};
+var unescape = function (code) {
+    return code.replace(/\\('|\\)/g, "$1").replace(/[\r\t\n]/g, " ");
+};
+var render = function (tmpl, def) {
+    var sid = 0;
+    var indv;
+    var str = use || define ? resolveDefs(tmpl, def || {}) : tmpl;
+    str = ("var X='" +
+        str
+            .replace(/(^|\r|\n)\t* +| +\t*(\r|\n|$)/g, " ")
+            .replace(/\r|\n|\t|\/\*[\s\S]*?\*\//g, "")
+            .replace(/'|\\/g, "\\$&")
+            .replace(interpolate || skip, function (_, code) { return start + unescape(code) + end; })
+            .replace(conditional || skip, function (_, elseCase, code) {
+            return elseCase
+                ? code
+                    ? "';}else if(" + unescape(code) + "){X+='"
+                    : "';}else{X+='"
+                : code
+                    ? "';if(" + unescape(code) + "){X+='"
+                    : "';}X+='";
+        })
+            .replace(iterate || skip, function (_, arr, vName, iName) {
+            if (!arr)
+                return "';} } X+='";
+            sid++;
+            indv = iName || "i" + sid;
+            arr = unescape(arr);
+            return ("';var arr" +
+                sid +
+                "=" +
+                arr +
+                ";if(arr" +
+                sid +
+                "){var " +
+                vName +
+                "," +
+                indv +
+                "=-1,l" +
+                sid +
+                "=arr" +
+                sid +
+                ".length-1;while(" +
+                indv +
+                "<l" +
+                sid +
+                "){" +
+                vName +
+                "=arr" +
+                sid +
+                "[" +
+                indv +
+                "+=1];X+='");
+        })
+            .replace(evaluate || skip, function (_, code) { return "';" + unescape(code) + "X+='"; }) +
+        "';return X;")
+        .replace(/\n/g, "\\n")
+        .replace(/\t/g, "\\t")
+        .replace(/\r/g, "\\r")
+        .replace(/(\s|;|\}|^|\{)X\+='';/g, "$1")
+        .replace(/\+''/g, "");
+    try {
+        return new Function(varname, str);
+    }
+    catch (e) {
+        if (process.env["NODE_ENV"] !== "production") {
+            console.log("Could not create a template function: " + str);
+            throw e;
+        }
+    }
+    return function () { return ""; };
+};
+exports.render = render;
+exports.default = exports.render;

package/cjs/roundTo.d.ts

@@ -0,0 +1,2 @@
+export declare function roundTo(num: number, decimals?: number): string;
+export default roundTo;

package/cjs/roundTo.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roundTo = void 0;
+function roundTo(num, decimals) {
+    if (decimals === void 0) { decimals = 2; }
+    if (isFinite(num) && !isNaN(num)) {
+        var multiplicator = Math.pow(10, decimals);
+        return Math.round(num * multiplicator) / multiplicator + "";
+    }
+    if (process.env["NODE_ENV"] !== "production") {
+        console.warn("[@koine/utils] math:roundTo -> given not a finite number as first arg");
+    }
+    return "";
+}
+exports.roundTo = roundTo;
+exports.default = roundTo;

package/cjs/serializeCookie.d.ts

@@ -0,0 +1,3 @@
+import { type CookieAttributesServer } from "./cookie";
+export declare function serializeCookie(name: string, val: string, attributes?: CookieAttributesServer): string;
+export default serializeCookie;

package/cjs/serializeCookie.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeCookie = void 0;
+var isNumber_1 = require("./isNumber");
+var fieldContentRegExp = /^[\u0009\u0020-\u007e\u0080-\u00ff]+$/;
+function serializeCookie(name, val, attributes) {
+    if (attributes === void 0) { attributes = {}; }
+    var _a = attributes.encode, encode = _a === void 0 ? encodeURIComponent : _a, domain = attributes.domain, path = attributes.path, httpOnly = attributes.httpOnly, secure = attributes.secure, sameSite = attributes.sameSite;
+    var maxAge = attributes.maxAge, expires = attributes.expires;
+    var value = encode(val);
+    if (process.env["NODE_ENV"] !== "production") {
+        if (!fieldContentRegExp.test(name)) {
+            throw new TypeError("argument name is invalid");
+        }
+        if (typeof attributes.encode !== "function") {
+            throw new TypeError("option encode is invalid");
+        }
+        if (value && !fieldContentRegExp.test(value)) {
+            throw new TypeError("argument val is invalid");
+        }
+    }
+    var str = name + "=" + value;
+    if (null != maxAge) {
+        maxAge = maxAge - 0;
+        if (isNaN(maxAge) || !isFinite(maxAge)) {
+            throw new TypeError("option maxAge is invalid");
+        }
+        str += "; Max-Age=" + Math.floor(maxAge);
+    }
+    if (domain) {
+        if (process.env["NODE_ENV"] !== "production") {
+            if (!fieldContentRegExp.test(domain)) {
+                throw new TypeError("option domain is invalid");
+            }
+        }
+        str += "; Domain=" + domain;
+    }
+    if (path) {
+        if (process.env["NODE_ENV"] !== "production") {
+            if (!fieldContentRegExp.test(path)) {
+                throw new TypeError("option path is invalid");
+            }
+        }
+        str += "; Path=" + path;
+    }
+    if (expires) {
+        if ((0, isNumber_1.isNumber)(expires)) {
+            expires = new Date(Date.now() + expires * 864e5);
+        }
+        str += "; Expires=" + expires.toUTCString();
+    }
+    if (httpOnly) {
+        str += "; HttpOnly";
+    }
+    if (secure) {
+        str += "; Secure";
+    }
+    if (sameSite) {
+        switch (sameSite.toLowerCase()) {
+            case "lax":
+                str += "; SameSite=Lax";
+                break;
+            case "strict":
+                str += "; SameSite=Strict";
+                break;
+            case "none":
+                str += "; SameSite=None";
+                break;
+        }
+    }
+    return str;
+}
+exports.serializeCookie = serializeCookie;
+exports.default = serializeCookie;

package/cjs/setCookie.d.ts

@@ -0,0 +1,3 @@
+import { type CookieAttributesClient } from "./cookie";
+export declare function setCookie<T extends string = string>(name: string, value: string | T, attributes?: CookieAttributesClient): string | undefined;
+export default setCookie;

package/cjs/setCookie.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setCookie = void 0;
+var tslib_1 = require("tslib");
+var cookie_1 = require("./cookie");
+var isNumber_1 = require("./isNumber");
+var isUndefined_1 = require("./isUndefined");
+function converterWrite(value) {
+    return encodeURIComponent(value).replace(/%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g, decodeURIComponent);
+}
+function setCookie(name, value, attributes) {
+    if (attributes === void 0) { attributes = {}; }
+    var expires = attributes.expires, restAttrs = tslib_1.__rest(attributes, ["expires"]);
+    var cleanedAttrs = tslib_1.__assign(tslib_1.__assign({ expires: "" }, cookie_1.defaultAttributesClient), restAttrs);
+    if ((0, isUndefined_1.default)(document)) {
+        if (process.env["NODE_ENV"] !== "production") {
+            console.warn("[@koine/utils:setCookie] document is undefined");
+        }
+        return undefined;
+    }
+    if ((0, isNumber_1.default)(expires)) {
+        expires = new Date(Date.now() + expires * 864e5);
+    }
+    if (expires) {
+        cleanedAttrs.expires = expires.toUTCString();
+    }
+    name = encodeURIComponent(name)
+        .replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent)
+        .replace(/[()]/g, escape);
+    var stringifiedAttributes = "";
+    for (var name_1 in attributes) {
+        var attrName = name_1;
+        if (!attributes[attrName]) {
+            continue;
+        }
+        stringifiedAttributes += "; " + attrName;
+        if (attributes[attrName] === true) {
+            continue;
+        }
+        stringifiedAttributes +=
+            "=" + String(attributes[attrName]).split(";")[0];
+    }
+    return (document.cookie =
+        name + "=" + converterWrite(value) + stringifiedAttributes);
+}
+exports.setCookie = setCookie;
+exports.default = setCookie;

package/cjs/shuffle.d.ts

@@ -0,0 +1,2 @@
+export declare function shuffle<T>(array: T[]): T[];
+export default shuffle;

package/cjs/shuffle.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shuffle = void 0;
+var tslib_1 = require("tslib");
+function shuffle(array) {
+    var length = array == null ? 0 : array.length;
+    if (!length) {
+        return [];
+    }
+    var index = -1;
+    var lastIndex = length - 1;
+    var result = tslib_1.__spreadArray([], array, true);
+    while (++index < length) {
+        var rand = index + Math.floor(Math.random() * (lastIndex - index + 1));
+        var value = result[rand];
+        result[rand] = result[index];
+        result[index] = value;
+    }
+    return result;
+}
+exports.shuffle = shuffle;
+exports.default = shuffle;

package/cjs/slugify.d.ts

@@ -0,0 +1,2 @@
+export declare function slugify(text: string, separator?: string): string;
+export default slugify;

package/cjs/slugify.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugify = void 0;
+var accentSets_1 = require("./accentSets");
+var removeAccents_1 = require("./removeAccents");
+function slugify(text, separator) {
+    if (separator === void 0) { separator = "-"; }
+    return (0, removeAccents_1.removeAccents)(text.toString().toLowerCase().trim(), accentSets_1.accentsSets.concat([["-", "[·/_,:;']"]]))
+        .replace(/\s+/g, "-")
+        .replace(/&/g, "-and-")
+        .replace(/[^\w-]+/g, "")
+        .replace(/--+/g, "-")
+        .replace(/^-+/, "")
+        .replace(/-+$/, "")
+        .replace(/-/g, separator);
+}
+exports.slugify = slugify;
+exports.default = slugify;

package/cjs/split.d.ts

@@ -0,0 +1,3 @@
+export type Split<S extends string, D extends string> = string extends S ? string[] : S extends "" ? [] : S extends `${infer T}${D}${infer U}` ? [T, ...Split<U, D>] : [S];
+export declare function split<T extends string, D extends string>(str: T, delimiter: D): Split<T, D>;
+export default split;

package/cjs/split.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.split = void 0;
+function split(str, delimiter) {
+    return str.split(delimiter);
+}
+exports.split = split;
+exports.default = split;

package/cjs/swapMap.d.ts

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

package/cjs/swapMap.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swapMap = void 0;
+function swapMap(map) {
+    if (map === void 0) { map = {}; }
+    var output = {};
+    for (var key in map) {
+        output[map[key]] = key;
+    }
+    return output;
+}
+exports.swapMap = swapMap;
+exports.default = swapMap;

package/cjs/throttle.d.ts

@@ -0,0 +1,2 @@
+export declare function throttle<TFn extends Function, TContext>(fn: TFn, limit: number, context?: TContext): (this: TContext, ...args: any[]) => NodeJS.Timeout | undefined;
+export default throttle;

package/cjs/throttle.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throttle = void 0;
+var tslib_1 = require("tslib");
+function throttle(fn, limit, context) {
+    var wait;
+    return function () {
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        context = context || this;
+        if (!wait) {
+            fn.apply.apply(fn, tslib_1.__spreadArray([context], args, false));
+            wait = true;
+            return setTimeout(function () {
+                wait = false;
+            }, limit);
+        }
+        return;
+    };
+}
+exports.throttle = throttle;
+exports.default = throttle;

package/cjs/titleCase.d.ts

@@ -0,0 +1,2 @@
+export declare const titleCase: (input?: null | string) => string;
+export default titleCase;