danholibraryjs 1.10.0 → 2.0.0

package/dist/Utils/ColorUtils.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColorUtils = exports.generateRandomColor = exports.convert = void 0;
+function convert(value, fromOrTo, to) {
+    const from = typeof value === 'string' ? fromOrTo : 'rgb';
+    const target = typeof value === 'string' ? to : fromOrTo;
+    if (from === target)
+        return value;
+    switch (from) {
+        case 'hsl': {
+            switch (target) {
+                case 'hex': return hslToHex(value);
+                case 'rgb': return hexToRgb(hslToHex(value));
+            }
+        }
+        case 'rgb': {
+            switch (target) {
+                case 'hex': return hslToHex(rgbToHsl(value));
+                case 'hsl': return rgbToHsl(value);
+            }
+        }
+        case 'hex': {
+            switch (target) {
+                case 'rgb': return hexToRgb(value);
+                case 'hsl': return rgbToHsl(hexToRgb(value));
+            }
+        }
+        default: return value;
+    }
+}
+exports.convert = convert;
+function generateRandomColor() {
+    return `#${Math.floor(Math.random() * 16777215).toString(16).padStart(6, '0')}`;
+}
+exports.generateRandomColor = generateRandomColor;
+exports.ColorUtils = {
+    convert,
+    generateRandomColor
+};
+exports.default = exports.ColorUtils;
+function hslToHex(value) {
+    if (!value)
+        return "#000000";
+    const match = value.match(/hsl\((\d+), (\d+)%, (\d+)%\)/);
+    if (!match)
+        return value;
+    let [_, h, s, l] = match.map(Number);
+    l /= 100;
+    const a = s * Math.min(l, 1 - l) / 100;
+    const format = (value) => {
+        const k = (value + h / 30) % 12;
+        const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
+        return Math.round(255 * color).toString(16).padStart(2, '0');
+    };
+    return `#${format(0)}${format(8)}${format(4)}`;
+}
+function hexToRgb(hex) {
+    if (!hex)
+        return [0, 0, 0];
+    const match = hex.match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
+    if (!match)
+        return [0, 0, 0];
+    let colorString = match[0];
+    if (match[0].length === 3)
+        colorString = colorString.split('').map(char => char + char).join('');
+    const integer = parseInt(colorString, 16);
+    const r = (integer >> 16) & 0xFF;
+    const g = (integer >> 8) & 0xFF;
+    const b = integer & 0xFF;
+    return [r, g, b];
+}
+function rgbToHsl(rgb) {
+    let [r, g, b] = rgb.map(x => x / 255);
+    const max = Math.max(r, g, b), min = Math.min(r, g, b);
+    let h = 0, s = 0, l = (max + min) / 2;
+    if (max !== min) {
+        const d = max - min;
+        s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+        switch (max) {
+            case r:
+                h = (g - b) / d + (g < b ? 6 : 0);
+                break;
+            case g:
+                h = (b - r) / d + 2;
+                break;
+            case b:
+                h = (r - g) / d + 4;
+                break;
+        }
+        h /= 6;
+    }
+    return `hsl(${Math.round(h * 360)}, ${Math.round(s * 100)}%, ${Math.round(l * 100)}%)`;
+}

package/dist/Utils/FormUtil.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Serialize a form into an object
+ * @param form The form to serialize
+ * @returns An object of type T from the form
+ */
+export declare function serializeForm<T extends object>(form: HTMLFormElement, log?: boolean): T;

package/dist/Utils/FormUtil.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeForm = void 0;
+/**
+ * Serialize a form into an object
+ * @param form The form to serialize
+ * @returns An object of type T from the form
+ */
+function serializeForm(form, log = false) {
+    const children = Array.from(form.children);
+    const formData = children.reduce((acc, child) => {
+        // Find inputs and selects
+        const elements = Array.from(child.querySelectorAll('input, select'));
+        if (['INPUT', 'SELECT'].includes(child.tagName))
+            elements.push(child);
+        for (const element of Array.from(elements)) {
+            if (element.type === 'submit')
+                continue; // Ignore submit buttons
+            const name = element.getAttribute('name');
+            if (!name) {
+                console.error('[DanhoLibraryRJS] [FormUtil]: name attribute is required', { element });
+                throw new Error('name attribute is required');
+            }
+            const value = element.value;
+            if (value === null)
+                console.warn(`${name}.value returned null`, { element });
+            if (log)
+                console.log(`[DanhoLibraryRJS] [FormUtil]`, { name, value });
+            acc[name] = /^\d$/.test(value) ? parseInt(value) : value;
+        }
+        return acc;
+    }, {});
+    return formData;
+}
+exports.serializeForm = serializeForm;

package/dist/Utils/FormUtils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Serialize a form into an object
+ * @param form The form to serialize
+ * @returns An object of type T from the form
+ */
+export declare function serializeForm<T extends object>(form: HTMLFormElement, log?: boolean): T;

package/dist/Utils/FormUtils.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeForm = void 0;
+/**
+ * Serialize a form into an object
+ * @param form The form to serialize
+ * @returns An object of type T from the form
+ */
+function serializeForm(form, log = false) {
+    const children = Array.from(form.children);
+    const formData = children.reduce((acc, child) => {
+        // Find inputs and selects
+        const elements = Array.from(child.querySelectorAll('input, select'));
+        if (['INPUT', 'SELECT'].includes(child.tagName))
+            elements.push(child);
+        for (const element of Array.from(elements)) {
+            if (element.type === 'submit')
+                continue; // Ignore submit buttons
+            const name = element.getAttribute('name');
+            if (!name) {
+                console.error('[DanhoLibraryJS] [FormUtil]: name attribute is required', { element });
+                throw new Error('name attribute is required');
+            }
+            const value = element.value;
+            if (value === null)
+                console.warn(`${name}.value returned null`, { element });
+            if (log)
+                console.log(`[DanhoLibraryJS] [FormUtil]`, { name, value });
+            acc[name] = /^\d$/.test(value) ? parseInt(value) : value;
+        }
+        return acc;
+    }, {});
+    return formData;
+}
+exports.serializeForm = serializeForm;

package/dist/Utils/NumberUtils.d.ts

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

package/dist/Utils/NumberUtils.js

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

package/dist/Utils/PatcherUtils.d.ts

@@ -0,0 +1,6 @@
+type PatchEvent = 'before' | 'instead' | 'after';
+type PatcherReplacement<TTarget extends object, TProperty extends keyof TTarget, TPatchEvent extends PatchEvent> = (TPatchEvent extends 'before' ? TTarget[TProperty] extends (...args: infer TArgs) => any ? (...args: TArgs) => TArgs | void : (current: TTarget[TProperty], update: TTarget[TProperty]) => TTarget[TProperty] | void : TPatchEvent extends 'instead' ? TTarget[TProperty] extends (...args: infer TArgs) => infer TReturn ? (...args: TArgs) => TReturn : (current: TTarget[TProperty], update: TTarget[TProperty]) => TTarget[TProperty] : TTarget[TProperty] extends (...args: infer TArgs) => any ? (...args: TArgs) => void : (previous: TTarget[TProperty], updated: TTarget[TProperty]) => void);
+export declare function patch<TTarget extends object, TProperty extends keyof TTarget, TPatchEvent extends PatchEvent, TPatchReplacement extends PatcherReplacement<TTarget, TProperty, TPatchEvent>>(target: TTarget, property: TProperty, event: TPatchEvent, replacement: TPatchReplacement): (() => TTarget[TProperty] & Function) | (() => TTarget) | undefined;
+export declare function unpatch<TTarget extends object, TProperty extends keyof TTarget>(target: TTarget, property: TProperty): void;
+export declare function unpatchAll(): void;
+export {};

package/dist/Utils/PatcherUtils.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.unpatchAll = exports.unpatch = exports.patch = void 0;
+const PATCHES = new Map();
+function patch(target, property, event, replacement) {
+    if (!target || !property || !replacement)
+        return;
+    else if (!(property in target))
+        throw Error(`Property "${String(property)}" does not exist on target`);
+    const original = target[property];
+    if (!PATCHES.has(target))
+        PATCHES.set(target, new Map());
+    const targetPatches = PATCHES.get(target);
+    if (!targetPatches.has(property))
+        targetPatches.set(property, []);
+    const unpatch = (() => {
+        if (typeof original === 'function') {
+            switch (event) {
+                case 'before': {
+                    target[property] = function (...args) {
+                        const updatedArgs = replacement.apply(target, args);
+                        return original.apply(target, updatedArgs || args);
+                    };
+                    break;
+                }
+                case 'instead': {
+                    target[property] = function (...args) {
+                        return replacement.apply(target, args);
+                    };
+                    break;
+                }
+                case 'after': {
+                    target[property] = function (...args) {
+                        const result = original.apply(target, args);
+                        replacement.apply(target, args);
+                        return result;
+                    };
+                    break;
+                }
+            }
+            return () => target[property] = original;
+        }
+        else {
+            let currentValue = target[property];
+            const propertyDescriptor = Object.getOwnPropertyDescriptor(target, property);
+            const valuePatch = (update) => {
+                update ??= currentValue;
+                const result = event !== 'after' ? replacement(currentValue, update) || currentValue : currentValue;
+                if (event === 'after')
+                    replacement(currentValue, update);
+                return result;
+            };
+            Object.defineProperty(target, property, {
+                get: () => valuePatch(),
+                set: valuePatch,
+            });
+            return () => Object.defineProperty(target, property, propertyDescriptor);
+        }
+    })();
+    targetPatches.get(property).push({ event, replacement, original, unpatch });
+    return unpatch;
+}
+exports.patch = patch;
+function unpatch(target, property) {
+    const targetPatches = PATCHES.get(target);
+    if (!targetPatches?.has(property))
+        return;
+    targetPatches.get(property).forEach(patch => patch.unpatch());
+    targetPatches.delete(property);
+}
+exports.unpatch = unpatch;
+function unpatchAll() {
+    PATCHES.forEach(properties => {
+        properties.forEach(patches => {
+            patches.forEach(patch => patch.unpatch());
+        });
+    });
+    PATCHES.clear();
+}
+exports.unpatchAll = unpatchAll;

package/dist/Utils/StringUtils.d.ts

@@ -0,0 +1,3 @@
+export declare function classNames(...args: Array<any>): string;
+export declare function randomId(length?: number): string;
+export declare function pluralize(countable: number | ArrayLike<any> | Map<any, any>, singular: string, plural?: string): string;

package/dist/Utils/StringUtils.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pluralize = exports.randomId = exports.classNames = void 0;
+function classNames(...args) {
+    return args.reduce((acc, arg) => {
+        if (!arg)
+            return acc;
+        switch (typeof arg) {
+            case 'string': {
+                acc += arg;
+                break;
+            }
+            case 'object': {
+                if (Array.isArray(arg)) {
+                    acc += classNames(...arg);
+                    break;
+                }
+                else {
+                    acc += Object.entries(arg).reduce((objAcc, [key, value]) => objAcc + (value ? key : ''), '');
+                    break;
+                }
+            }
+            default: {
+                acc += `${arg}`;
+                break;
+            }
+        }
+        return acc + ' ';
+    }, '').trim();
+}
+exports.classNames = classNames;
+function randomId(length = 16) {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    return Array.from({ length }, () => characters.charAt(Math.floor(Math.random() * characters.length))).join('');
+}
+exports.randomId = randomId;
+function pluralize(countable, singular, plural) {
+    const count = (typeof countable === 'number' ? countable
+        : countable instanceof Map ? countable.size
+            : countable.length);
+    if (count === 1)
+        return singular;
+    if (plural)
+        return plural;
+    return `${singular}s`;
+}
+exports.pluralize = pluralize;

package/dist/Utils/TimeUtils/debounce.util.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Delay running the callback until delay milliseconds have passed without the function being called again.
+ * If the function is called again before the delay has passed, the timer resets.
+ *
+ * @param debounceId A unique identifier for the debounce instance. Call with the same ID to reset the timer.
+ * @param callback The callback to run after the delay has passed without the function being called again
+ * @param delay The delay in milliseconds to wait before running the callback after the last call
+ * @param signal Optional AbortSignal to cancel the debounced operation
+ * @returns A promise that resolves to the result of the callback when it is eventually called, or rejects if aborted
+ */
+export declare function debounce<T>(debounceId: string, callback: () => T, delay: number, signal?: AbortSignal): Promise<T>;
+/**
+ * Wrap a callback in a debounce, allowing it to be called multiple times, but only run after the delay has passed without it being called again
+ * @param callback The callback to run after the delay has passed without the function being called again
+ * @param delay The delay in milliseconds to wait before running the callback after the last call
+ * @returns An object containing the debounced function, an AbortController to cancel operations, and the abort method for convenience
+ */
+export declare function wrapInDebounce<T>(callback: (...args: T[]) => void, delay: number): {
+    debounced: (...args: T[]) => Promise<void>;
+    controller: AbortController;
+    abort: () => void;
+};

package/dist/Utils/TimeUtils/debounce.util.js

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.wrapInDebounce = exports.debounce = void 0;
+const DebounceManager = {
+    timers: new Map(),
+    abortListeners: new Map(),
+};
+/**
+ * Delay running the callback until delay milliseconds have passed without the function being called again.
+ * If the function is called again before the delay has passed, the timer resets.
+ *
+ * @param debounceId A unique identifier for the debounce instance. Call with the same ID to reset the timer.
+ * @param callback The callback to run after the delay has passed without the function being called again
+ * @param delay The delay in milliseconds to wait before running the callback after the last call
+ * @param signal Optional AbortSignal to cancel the debounced operation
+ * @returns A promise that resolves to the result of the callback when it is eventually called, or rejects if aborted
+ */
+function debounce(debounceId, callback, delay, signal) {
+    const { timers, abortListeners } = DebounceManager;
+    // Clean up existing debounce with the same ID
+    if (timers.has(debounceId)) {
+        clearTimeout(timers.get(debounceId));
+        timers.delete(debounceId);
+        const existingListener = abortListeners.get(debounceId);
+        if (existingListener && signal) {
+            signal.removeEventListener('abort', existingListener);
+        }
+        abortListeners.delete(debounceId);
+    }
+    const promise = new Promise((resolve, reject) => {
+        // Check if already aborted
+        if (signal?.aborted) {
+            const error = new DOMException('Debounce aborted', 'AbortError');
+            reject(error);
+            return;
+        }
+        const timeoutId = setTimeout(() => {
+            timers.delete(debounceId);
+            abortListeners.delete(debounceId);
+            try {
+                resolve(callback());
+            }
+            catch (error) {
+                reject(error);
+            }
+        }, delay);
+        timers.set(debounceId, timeoutId);
+        // Set up abort listener
+        if (signal) {
+            const abortListener = () => {
+                clearTimeout(timeoutId);
+                timers.delete(debounceId);
+                abortListeners.delete(debounceId);
+                const error = new DOMException('Debounce aborted', 'AbortError');
+                reject(error);
+            };
+            signal.addEventListener('abort', abortListener, { once: true });
+            abortListeners.set(debounceId, abortListener);
+        }
+    });
+    return promise;
+}
+exports.debounce = debounce;
+/**
+ * Wrap a callback in a debounce, allowing it to be called multiple times, but only run after the delay has passed without it being called again
+ * @param callback The callback to run after the delay has passed without the function being called again
+ * @param delay The delay in milliseconds to wait before running the callback after the last call
+ * @returns An object containing the debounced function, an AbortController to cancel operations, and the abort method for convenience
+ */
+function wrapInDebounce(callback, delay) {
+    const controller = new AbortController();
+    return {
+        debounced: (...args) => debounce(Symbol().toString(), () => callback(...args), delay, controller.signal),
+        controller,
+        abort: () => controller.abort(),
+    };
+}
+exports.wrapInDebounce = wrapInDebounce;

package/dist/Utils/TimeUtils/functions.util.d.ts

@@ -0,0 +1,4 @@
+export declare function wait<T>(time: number): Promise<void>;
+export declare function wait<T>(callback: (...args: any[]) => T, time: number): Promise<T>;
+export declare function getUnixTime(date: Date | string): number;
+export declare function getUnixTime(timestamp: number): number;

package/dist/Utils/TimeUtils/functions.util.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUnixTime = exports.wait = void 0;
+function wait(callbackOrTime, time) {
+    const callback = typeof callbackOrTime === 'function' ? callbackOrTime : (() => undefined);
+    time ??= callbackOrTime;
+    return new Promise((resolve, reject) => {
+        try {
+            setTimeout(() => resolve(callback()), time);
+        }
+        catch (err) {
+            reject(err);
+        }
+    });
+}
+exports.wait = wait;
+function getUnixTime(arg) {
+    const timestamp = typeof arg === 'number' ? arg : new Date(arg).getTime();
+    return Math.floor(timestamp / 1000);
+}
+exports.getUnixTime = getUnixTime;

package/dist/Utils/TimeUtils/index.d.ts

@@ -0,0 +1,15 @@
+export declare const TimeUtils: {
+    throttle<T>(throttleId: string, callback: () => T, cooldown: number): T;
+    wrapInThrottle<T_1>(callback: (...args: T_1[]) => void, cooldown: number): (...args: T_1[]) => void;
+    isThrottleOnCooldown(throttleId: string): boolean;
+    debounce<T_2>(debounceId: string, callback: () => T_2, delay: number, signal?: AbortSignal | undefined): Promise<T_2>;
+    wrapInDebounce<T_3>(callback: (...args: T_3[]) => void, delay: number): {
+        debounced: (...args: T_3[]) => Promise<void>;
+        controller: AbortController;
+        abort: () => void;
+    };
+    wait<T_4>(time: number): Promise<void>;
+    wait<T_5>(callback: (...args: any[]) => T_5, time: number): Promise<T_5>;
+    getUnixTime(date: string | Date): number;
+    getUnixTime(timestamp: number): number;
+};

package/dist/Utils/TimeUtils/index.js

@@ -0,0 +1,34 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeUtils = void 0;
+const Debounce = __importStar(require("./debounce.util"));
+const Functions = __importStar(require("./functions.util"));
+const Throttle = __importStar(require("./throttle.util"));
+exports.TimeUtils = {
+    ...Functions,
+    ...Debounce,
+    ...Throttle,
+};

package/dist/Utils/TimeUtils/throttle.util.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Allow callback to be run once every cooldown period, regardless of calls
+ * @param callback The callback to run
+ * @param cooldown The delay to wait before allowing the callback to be called again
+ * @returns A throttled version of the callback
+ */
+export declare function throttle<T>(throttleId: string, callback: () => T, cooldown: number): T;
+/**
+ * Wrap a callback in a throttle, allowing it to be called multiple times, but only run once every cooldown period
+ * @param callback The callback to run
+ * @param cooldown The delay to wait before allowing the callback to be called again
+ * @returns A throttled version of the callback that can be called multiple times, but will only run once every cooldown period
+ */
+export declare function wrapInThrottle<T>(callback: (...args: T[]) => void, cooldown: number): (...args: T[]) => void;
+export declare function isThrottleOnCooldown(throttleId: string): boolean;

package/dist/Utils/TimeUtils/throttle.util.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isThrottleOnCooldown = exports.wrapInThrottle = exports.throttle = void 0;
+const ThrottleManager = {
+    cooldowns: new Map(),
+    results: new Map(),
+};
+/**
+ * Allow callback to be run once every cooldown period, regardless of calls
+ * @param callback The callback to run
+ * @param cooldown The delay to wait before allowing the callback to be called again
+ * @returns A throttled version of the callback
+ */
+function throttle(throttleId, callback, cooldown) {
+    const { cooldowns, results } = ThrottleManager;
+    const isCooldown = cooldowns.get(throttleId) ?? false;
+    if (isCooldown)
+        return results.get(throttleId);
+    const result = callback();
+    setTimeout(() => {
+        cooldowns.delete(throttleId);
+        results.delete(throttleId);
+    }, cooldown);
+    cooldowns.set(throttleId, true);
+    results.set(throttleId, result);
+    return result;
+}
+exports.throttle = throttle;
+/**
+ * Wrap a callback in a throttle, allowing it to be called multiple times, but only run once every cooldown period
+ * @param callback The callback to run
+ * @param cooldown The delay to wait before allowing the callback to be called again
+ * @returns A throttled version of the callback that can be called multiple times, but will only run once every cooldown period
+ */
+function wrapInThrottle(callback, cooldown) {
+    const throttleId = Symbol().toString();
+    return (...args) => throttle(throttleId, () => callback(...args), cooldown);
+}
+exports.wrapInThrottle = wrapInThrottle;
+function isThrottleOnCooldown(throttleId) {
+    return ThrottleManager.cooldowns.get(throttleId) ?? false;
+}
+exports.isThrottleOnCooldown = isThrottleOnCooldown;

package/dist/Utils/index.d.ts

@@ -0,0 +1,7 @@
+export * from './ApiUtils';
+export * from './TimeUtils';
+export * from './ColorUtils';
+export * from './FormUtils';
+export * from './NumberUtils';
+export * from './PatcherUtils';
+export * from './StringUtils';

package/dist/Utils/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./ApiUtils"), exports);
+__exportStar(require("./TimeUtils"), exports);
+__exportStar(require("./ColorUtils"), exports);
+__exportStar(require("./FormUtils"), exports);
+__exportStar(require("./NumberUtils"), exports);
+__exportStar(require("./PatcherUtils"), exports);
+__exportStar(require("./StringUtils"), exports);

package/package.json

@@ -1,7 +1,9 @@
 {
   "name": "danholibraryjs",
-  
-  "version": "1.10.0",
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/"
+  },
+  "version": "2.0.0",
   "description": "Library for Javascript.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",