@koine/utils 2.0.0-beta.72 → 2.0.0-beta.74

package/Defer.d.ts

@@ -3,3 +3,4 @@ export type Deferred<T> = Promise<T> & {
     reject: PromiseConstructor["reject"];
 };
 export declare function Defer<T>(): Deferred<T>;
+export default Defer;

package/Defer.js

@@ -0,0 +1,11 @@
+export function Defer() {
+    const self = this || {};
+    const p = (self.promise = new Promise((resolve, reject) => {
+        self.resolve = resolve;
+        self.reject = reject;
+    }));
+    self.then = p.then.bind(p);
+    self.catch = p.catch.bind(p);
+    return self;
+}
+export default Defer;

package/Emitter.d.ts

@@ -4,3 +4,4 @@ export declare let Emitter: <EventMap extends {
     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.js

@@ -0,0 +1,20 @@
+export let Emitter = (namespace) => {
+    const all = new Map();
+    return {
+        on(name, handler) {
+            const handlers = all.get(`${namespace}.${String(name)}`);
+            const added = handlers && handlers.push(handler);
+            if (!added) {
+                all.set(`${namespace}.${String(name)}`, [handler]);
+            }
+        },
+        emit(name, data) {
+            (all.get(`${namespace}.${String(name)}`) || [])
+                .slice()
+                .map((handler) => {
+                handler(data);
+            });
+        },
+    };
+};
+export default Emitter;

package/accentSets.d.ts

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

package/accentSets.js

@@ -0,0 +1,30 @@
+export let accentsSets = [
+    ["a", "ÀÁÂÃÅÆĀĂĄẠẢẤẦẨẪẬẮẰẲẴẶ"],
+    ["ae", "Ä"],
+    ["c", "ÇĆĈČ"],
+    ["d", "ÐĎĐÞ"],
+    ["e", "ÈÉÊËĒĔĖĘĚẸẺẼẾỀỂỄỆ"],
+    ["g", "ĜĞĢǴ"],
+    ["h", "ĤḦ"],
+    ["i", "ÌÍÎÏĨĪĮİỈỊ"],
+    ["j", "Ĵ"],
+    ["ij", "IJ"],
+    ["k", "Ķ"],
+    ["l", "ĹĻĽŁ"],
+    ["m", "Ḿ"],
+    ["n", "ÑŃŅŇ"],
+    ["o", "ÒÓÔÕØŌŎŐỌỎỐỒỔỖỘỚỜỞỠỢǪǬƠ"],
+    ["oe", "΅"],
+    ["p", "ṕ"],
+    ["r", "ŔŖŘ"],
+    ["s", "ŚŜŞŠ"],
+    ["ss", "ß"],
+    ["t", "ŢŤ"],
+    ["u", "ÙÚÛŨŪŬŮŰŲỤỦỨỪỬỮỰƯ"],
+    ["ue", "Ü"],
+    ["w", "ẂŴẀẄ"],
+    ["x", "ẍ"],
+    ["y", "ÝŶŸỲỴỶỸ"],
+    ["z", "ŹŻŽ"],
+];
+export default accentsSets;

package/addOrReplaceAtIdx.d.ts

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

package/addOrReplaceAtIdx.js

@@ -0,0 +1,15 @@
+export let addOrReplaceAtIdx = (list, newItem, newIdx) => {
+    if (list.length === 0) {
+        return [newItem];
+    }
+    if (typeof newIdx === "undefined" || list.length - 1 < newIdx) {
+        return [...list, newItem];
+    }
+    return list.map((item, idx) => {
+        if (idx === newIdx) {
+            return newItem;
+        }
+        return item;
+    });
+};
+export default addOrReplaceAtIdx;

package/areEqual.d.ts

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

package/areEqual.js

@@ -0,0 +1,46 @@
+import { isArray } from "./isArray";
+import { isObject } from "./isObject";
+let areEqualArrays = (a, b) => {
+    if (!b)
+        return false;
+    if (a.length !== b.length)
+        return false;
+    for (let i = 0; i < a.length; i++) {
+        if (!areEqual(a[i], b[i]))
+            return false;
+    }
+    return true;
+};
+let areEqualObjects = (a, b) => {
+    if (!b)
+        return false;
+    const aKeys = Object.keys(a);
+    for (const _key of aKeys) {
+        const key = _key;
+        if (!areEqual(a[key], b[key])) {
+            return false;
+        }
+    }
+    return true;
+};
+export let areEqual = (a, b) => {
+    if (!a && !b) {
+        return true;
+    }
+    if (!b && a !== b) {
+        return false;
+    }
+    const areObjects = isObject(a) && isObject(b);
+    if (areObjects && !areEqualObjects(a, b)) {
+        return false;
+    }
+    const areArrays = isArray(a) && isArray(b);
+    if (areArrays && !areEqualArrays(a, b)) {
+        return false;
+    }
+    if (!areObjects && !areArrays && a !== b) {
+        return false;
+    }
+    return true;
+};
+export default areEqual;

package/arrayFilterFalsy.d.ts

@@ -1 +1,2 @@
 export declare let arrayFilterFalsy: <T extends unknown[]>(list?: T | null | undefined) => Exclude<NonNullable<T>[number], false | "" | 0 | undefined>[];
+export default arrayFilterFalsy;

package/arrayFilterFalsy.js

@@ -0,0 +1,2 @@
+export let arrayFilterFalsy = (list) => (list ? list.filter((r) => !!r) : []);
+export default arrayFilterFalsy;

package/arrayFindLastIndex.d.ts

@@ -1 +1,2 @@
 export declare let arrayFindLastIndex: <T>(array: T[], predicate: (value: T, index: number, obj: T[]) => boolean) => number;
+export default arrayFindLastIndex;

package/arrayFindLastIndex.js

@@ -0,0 +1,9 @@
+export let arrayFindLastIndex = (array, predicate) => {
+    let l = array.length;
+    while (l--) {
+        if (predicate(array[l], l, array))
+            return l;
+    }
+    return -1;
+};
+export default arrayFindLastIndex;

package/arrayOfAll.d.ts

@@ -1,2 +1,3 @@
 export declare let arrayOfAll: <T>() => <U extends T[]>(array: U & ([T] extends [U[number]] ? unknown : "Invalid")) => U & ([T] extends [U[number]] ? unknown : "Invalid");
 export type ArrayOfAll<List extends unknown[], Union> = List[number] extends Union ? Union extends List[number] ? true : "Incomplete" : "Incomplete";
+export default arrayOfAll;

package/arrayOfAll.js

@@ -0,0 +1,2 @@
+export let arrayOfAll = () => (array) => array;
+export default arrayOfAll;

package/arraySum.d.ts

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

package/arraySum.js

@@ -0,0 +1,2 @@
+export let arraySum = (numbers) => numbers.reduce((sum, current) => sum + current, 0);
+export default arraySum;

package/arrayToLookup.d.ts

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

package/arrayToLookup.js

@@ -0,0 +1,5 @@
+export let arrayToLookup = (array = []) => array.reduce((obj, item) => {
+    obj[item] = 1;
+    return obj;
+}, {});
+export default arrayToLookup;

package/arrayUniqueByProperties.d.ts

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

package/arrayUniqueByProperties.js

@@ -0,0 +1,2 @@
+export let arrayUniqueByProperties = (array, keys) => array.filter((item, idx, arr) => arr.findIndex((itemWith) => keys.every((k) => itemWith[k] === item[k])) === idx);
+export default arrayUniqueByProperties;

package/buildUrlQueryString.d.ts

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

package/buildUrlQueryString.js

@@ -0,0 +1,21 @@
+import { isArray } from "./isArray";
+import { isNull } from "./isNull";
+import { isUndefined } from "./isUndefined";
+export let buildUrlQueryString = (params) => {
+    let output = "";
+    if (!params)
+        return output;
+    for (const key in params) {
+        const value = params[key];
+        if (isArray(value)) {
+            for (let i = 0; i < value.length; i++) {
+                output += `${key}=${encodeURIComponent(value[i] + "")}&`;
+            }
+        }
+        else if (!isNull(value) && !isUndefined(value)) {
+            output += `${key}=${encodeURIComponent(value + "")}&`;
+        }
+    }
+    return output ? `?${output.replace(/&+$/, "")}` : "";
+};
+export default buildUrlQueryString;

package/capitalize.d.ts

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

package/capitalize.js

@@ -0,0 +1,3 @@
+export let capitalize = (string) => ((string || "").charAt(0).toUpperCase() +
+    (string || "").slice(1));
+export default capitalize;

package/changeCaseCamel.d.ts

@@ -1,2 +1,3 @@
 import { type PascalCaseOptions } from "./changeCaseHelpers";
 export declare let changeCaseCamel: (input: string, options?: PascalCaseOptions) => string;
+export default changeCaseCamel;

package/changeCaseCamel.js

@@ -0,0 +1,19 @@
+import { capitalCaseTransformFactory, lowerFactory, pascalCaseTransformFactory, splitPrefixSuffix, upperFactory, } from "./changeCaseHelpers";
+export let changeCaseCamel = (input, options) => {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = options?.mergeAmbiguousCharacters
+        ? capitalCaseTransformFactory(lower, upper)
+        : pascalCaseTransformFactory(lower, upper);
+    return (prefix +
+        words
+            .map((word, index) => {
+            if (index === 0)
+                return lower(word);
+            return transform(word, index);
+        })
+            .join(options?.delimiter ?? "") +
+        suffix);
+};
+export default changeCaseCamel;

package/changeCaseCapital.d.ts

@@ -1,2 +1,3 @@
 import { type Options } from "./changeCaseHelpers";
 export declare let changeCaseCapital: (input: string, options?: Options) => string;
+export default changeCaseCapital;

package/changeCaseCapital.js

@@ -0,0 +1,12 @@
+import { capitalCaseTransformFactory, lowerFactory, splitPrefixSuffix, upperFactory, } from "./changeCaseHelpers";
+export let changeCaseCapital = (input, options) => {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    return (prefix +
+        words
+            .map(capitalCaseTransformFactory(lower, upper))
+            .join(options?.delimiter ?? " ") +
+        suffix);
+};
+export default changeCaseCapital;

package/changeCaseConstant.d.ts

@@ -1,2 +1,3 @@
 import { type Options } from "./changeCaseHelpers";
 export declare let changeCaseConstant: (input: string, options?: Options) => string;
+export default changeCaseConstant;

package/changeCaseConstant.js

@@ -0,0 +1,8 @@
+import { splitPrefixSuffix, upperFactory, } from "./changeCaseHelpers";
+export let changeCaseConstant = (input, options) => {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    return (prefix +
+        words.map(upperFactory(options?.locale)).join(options?.delimiter ?? "_") +
+        suffix);
+};
+export default changeCaseConstant;

package/changeCaseDot.d.ts

@@ -1,2 +1,3 @@
 import type { Options } from "./changeCaseHelpers";
 export declare let changeCaseDot: (input: string, options?: Options) => string;
+export default changeCaseDot;

package/changeCaseDot.js

@@ -0,0 +1,3 @@
+import { changeCaseNone } from "./changeCaseNone";
+export let changeCaseDot = (input, options) => changeCaseNone(input, { delimiter: ".", ...options });
+export default changeCaseDot;

package/changeCaseHelpers.d.ts

@@ -12,8 +12,3 @@ export interface Options {
 }
 export declare let split: (value: string) => string[];
 export declare let splitSeparateNumbers: (value: string) => string[];
-export declare let lowerFactory: (locale: Locale) => (input: string) => string;
-export declare let upperFactory: (locale: Locale) => (input: string) => string;
-export declare let capitalCaseTransformFactory: (lower: (input: string) => string, upper: (input: string) => string) => (word: string) => string;
-export declare let pascalCaseTransformFactory: (lower: (input: string) => string, upper: (input: string) => string) => (word: string, index: number) => string;
-export declare let splitPrefixSuffix: (input: string, options?: Options) => [string, string[], string];

package/changeCaseHelpers.js

@@ -0,0 +1,71 @@
+let SPLIT_LOWER_UPPER_RE = /([\p{Ll}\d])(\p{Lu})/gu;
+let SPLIT_UPPER_UPPER_RE = /(\p{Lu})([\p{Lu}][\p{Ll}])/gu;
+let SPLIT_SEPARATE_NUMBER_RE = /(\d)\p{Ll}|(\p{L})\d/u;
+let DEFAULT_STRIP_REGEXP = /[^\p{L}\d]+/giu;
+let SPLIT_REPLACE_VALUE = "$1\0$2";
+let DEFAULT_PREFIX_SUFFIX_CHARACTERS = "";
+export let split = (value) => {
+    let result = value.trim();
+    result = result
+        .replace(SPLIT_LOWER_UPPER_RE, SPLIT_REPLACE_VALUE)
+        .replace(SPLIT_UPPER_UPPER_RE, SPLIT_REPLACE_VALUE);
+    result = result.replace(DEFAULT_STRIP_REGEXP, "\0");
+    let start = 0;
+    let end = result.length;
+    while (result.charAt(start) === "\0")
+        start++;
+    if (start === end)
+        return [];
+    while (result.charAt(end - 1) === "\0")
+        end--;
+    return result.slice(start, end).split(/\0/g);
+};
+export let splitSeparateNumbers = (value) => {
+    const words = split(value);
+    for (let i = 0; i < words.length; i++) {
+        const word = words[i];
+        const match = SPLIT_SEPARATE_NUMBER_RE.exec(word);
+        if (match) {
+            const offset = match.index + (match[1] ?? match[2]).length;
+            words.splice(i, 1, word.slice(0, offset), word.slice(offset));
+        }
+    }
+    return words;
+};
+export let lowerFactory = (locale) => locale === false
+    ? (input) => input.toLowerCase()
+    : (input) => input.toLocaleLowerCase(locale);
+export let upperFactory = (locale) => locale === false
+    ? (input) => input.toUpperCase()
+    : (input) => input.toLocaleUpperCase(locale);
+export let capitalCaseTransformFactory = (lower, upper) => (word) => `${upper(word[0])}${lower(word.slice(1))}`;
+export let pascalCaseTransformFactory = (lower, upper) => (word, index) => {
+    const char0 = word[0];
+    const initial = index > 0 && char0 >= "0" && char0 <= "9" ? "_" + char0 : upper(char0);
+    return initial + lower(word.slice(1));
+};
+export let splitPrefixSuffix = (input, options = {}) => {
+    const splitFn = options.split ?? (options.separateNumbers ? splitSeparateNumbers : split);
+    const prefixCharacters = options.prefixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+    const suffixCharacters = options.suffixCharacters ?? DEFAULT_PREFIX_SUFFIX_CHARACTERS;
+    let prefixIndex = 0;
+    let suffixIndex = input.length;
+    while (prefixIndex < input.length) {
+        const char = input.charAt(prefixIndex);
+        if (!prefixCharacters.includes(char))
+            break;
+        prefixIndex++;
+    }
+    while (suffixIndex > prefixIndex) {
+        const index = suffixIndex - 1;
+        const char = input.charAt(index);
+        if (!suffixCharacters.includes(char))
+            break;
+        suffixIndex = index;
+    }
+    return [
+        input.slice(0, prefixIndex),
+        splitFn(input.slice(prefixIndex, suffixIndex)),
+        input.slice(suffixIndex),
+    ];
+};

package/changeCaseKebab.d.ts

@@ -1,2 +1,3 @@
 import type { Options } from "./changeCaseHelpers";
 export declare let changeCaseKebab: (input: string, options?: Options) => string;
+export default changeCaseKebab;

package/changeCaseKebab.js

@@ -0,0 +1,3 @@
+import { changeCaseNone } from "./changeCaseNone";
+export let changeCaseKebab = (input, options) => changeCaseNone(input, { delimiter: "-", ...options });
+export default changeCaseKebab;

package/changeCaseNone.d.ts

@@ -1,2 +1,3 @@
 import { type Options } from "./changeCaseHelpers";
 export declare let changeCaseNone: (input: string, options?: Options) => string;
+export default changeCaseNone;

package/changeCaseNone.js

@@ -0,0 +1,8 @@
+import { lowerFactory, splitPrefixSuffix, } from "./changeCaseHelpers";
+export let changeCaseNone = (input, options) => {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    return (prefix +
+        words.map(lowerFactory(options?.locale)).join(options?.delimiter ?? " ") +
+        suffix);
+};
+export default changeCaseNone;

package/changeCasePascal.d.ts

@@ -1,2 +1,3 @@
 import { type PascalCaseOptions } from "./changeCaseHelpers";
 export declare let changeCasePascal: (input: string, options?: PascalCaseOptions) => string;
+export default changeCasePascal;

package/changeCasePascal.js

@@ -0,0 +1,11 @@
+import { capitalCaseTransformFactory, lowerFactory, pascalCaseTransformFactory, splitPrefixSuffix, upperFactory, } from "./changeCaseHelpers";
+export let changeCasePascal = (input, options) => {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = options?.mergeAmbiguousCharacters
+        ? capitalCaseTransformFactory(lower, upper)
+        : pascalCaseTransformFactory(lower, upper);
+    return prefix + words.map(transform).join(options?.delimiter ?? "") + suffix;
+};
+export default changeCasePascal;

package/changeCasePascalSnake.d.ts

@@ -1,2 +1,3 @@
 import type { Options } from "./changeCaseHelpers";
 export declare let changeCasePascalSnake: (input: string, options?: Options) => string;
+export default changeCasePascalSnake;

package/changeCasePascalSnake.js

@@ -0,0 +1,3 @@
+import { changeCaseCapital } from "./changeCaseCapital";
+export let changeCasePascalSnake = (input, options) => changeCaseCapital(input, { delimiter: "_", ...options });
+export default changeCasePascalSnake;

package/changeCasePath.d.ts

@@ -1,2 +1,3 @@
 import type { Options } from "./changeCaseHelpers";
 export declare let changeCasePath: (input: string, options?: Options) => string;
+export default changeCasePath;

package/changeCasePath.js

@@ -0,0 +1,3 @@
+import { changeCaseNone } from "./changeCaseNone";
+export let changeCasePath = (input, options) => changeCaseNone(input, { delimiter: "/", ...options });
+export default changeCasePath;

package/changeCaseSentence.d.ts

@@ -1,2 +1,3 @@
 import { type Options } from "./changeCaseHelpers";
 export declare let changeCaseSentence: (input: string, options?: Options) => string;
+export default changeCaseSentence;

package/changeCaseSentence.js

@@ -0,0 +1,17 @@
+import { capitalCaseTransformFactory, lowerFactory, splitPrefixSuffix, upperFactory, } from "./changeCaseHelpers";
+export let changeCaseSentence = (input, options) => {
+    const [prefix, words, suffix] = splitPrefixSuffix(input, options);
+    const lower = lowerFactory(options?.locale);
+    const upper = upperFactory(options?.locale);
+    const transform = capitalCaseTransformFactory(lower, upper);
+    return (prefix +
+        words
+            .map((word, index) => {
+            if (index === 0)
+                return transform(word);
+            return lower(word);
+        })
+            .join(options?.delimiter ?? " ") +
+        suffix);
+};
+export default changeCaseSentence;

package/changeCaseSnake.d.ts

@@ -1,2 +1,3 @@
 import type { Options } from "./changeCaseHelpers";
 export declare let changeCaseSnake: (input: string, options?: Options) => string;
+export default changeCaseSnake;

package/changeCaseSnake.js

@@ -0,0 +1,3 @@
+import { changeCaseNone } from "./changeCaseNone";
+export let changeCaseSnake = (input, options) => changeCaseNone(input, { delimiter: "_", ...options });
+export default changeCaseSnake;

package/changeCaseTrain.d.ts

@@ -1,2 +1,3 @@
 import type { Options } from "./changeCaseHelpers";
 export declare let changeCaseTrain: (input: string, options?: Options) => string;
+export default changeCaseTrain;

package/changeCaseTrain.js

@@ -0,0 +1,3 @@
+import { changeCaseCapital } from "./changeCaseCapital";
+export let changeCaseTrain = (input, options) => changeCaseCapital(input, { delimiter: "-", ...options });
+export default changeCaseTrain;

package/chunkByChunks.d.ts

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

package/chunkByChunks.js

@@ -0,0 +1,32 @@
+export let chunkByChunks = (arr, nrOfChunks, balanced) => {
+    if (nrOfChunks < 2)
+        return [arr];
+    const len = arr.length;
+    const output = [];
+    let i = 0;
+    let size;
+    if (len % nrOfChunks === 0) {
+        size = Math.floor(len / nrOfChunks);
+        while (i < len) {
+            output.push(arr.slice(i, (i += size)));
+        }
+    }
+    else if (balanced) {
+        while (i < len) {
+            size = Math.ceil((len - i) / nrOfChunks--);
+            output.push(arr.slice(i, (i += size)));
+        }
+    }
+    else {
+        nrOfChunks--;
+        size = Math.floor(len / nrOfChunks);
+        if (len % size === 0)
+            size--;
+        while (i < size * nrOfChunks) {
+            output.push(arr.slice(i, (i += size)));
+        }
+        output.push(arr.slice(size * nrOfChunks));
+    }
+    return output;
+};
+export default chunkByChunks;

package/chunkBySize.d.ts

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

package/chunkBySize.js

@@ -0,0 +1,8 @@
+export let chunkBySize = (arr, size) => {
+    const output = [];
+    for (let i = 0; i < arr.length; i += size) {
+        output.push(arr.slice(i, i + size));
+    }
+    return output;
+};
+export default chunkBySize;

package/clamp.d.ts

@@ -1 +1,2 @@
 export declare let clamp: (num: number, min: number, max: number) => number;
+export default clamp;

package/clamp.js

@@ -0,0 +1,2 @@
+export let clamp = (num, min, max) => Math.min(Math.max(num, min), max);
+export default clamp;

package/clsx.d.ts

@@ -3,4 +3,4 @@ type ClassDictionary = Record<string, any>;
 type ClassArray = ClassValue[];
 export type ClsxClassValue = ClassValue;
 export declare let clsx: (...args: ClassValue[]) => string;
-export {};
+export default clsx;

package/clsx.js

@@ -0,0 +1,40 @@
+let toVal = (mix) => {
+    let k, y, str = "";
+    if (typeof mix === "string" || typeof mix === "number") {
+        str += mix;
+    }
+    else if (typeof mix === "object") {
+        if (Array.isArray(mix)) {
+            for (k = 0; k < mix.length; k++) {
+                if (mix[k]) {
+                    if ((y = toVal(mix[k]))) {
+                        str && (str += " ");
+                        str += y;
+                    }
+                }
+            }
+        }
+        else {
+            for (k in mix) {
+                if (mix[k]) {
+                    str && (str += " ");
+                    str += k;
+                }
+            }
+        }
+    }
+    return str;
+};
+export let clsx = function () {
+    let i = 0, tmp, x, str = "";
+    while (i < arguments.length) {
+        if ((tmp = arguments[i++])) {
+            if ((x = toVal(tmp))) {
+                str && (str += " ");
+                str += x;
+            }
+        }
+    }
+    return str;
+};
+export default clsx;

package/convertRange.d.ts

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

package/convertRange.js

@@ -0,0 +1,2 @@
+export let convertRange = (num, r1, r2) => ((num - r1[0]) * (r2[1] - r2[0])) / (r1[1] - r1[0]) + r2[0];
+export default convertRange;