@onetokenfe/coinselect 3.1.16

package/third-party/utils/createDeferred.d.ts

@@ -0,0 +1,14 @@
+export interface Deferred<Resolve = void, Arg = string | number | undefined> {
+    id: Arg;
+    promise: Promise<Resolve>;
+    resolve: (t: Resolve) => void;
+    reject: (e: Error) => void;
+}
+export type DeferredResponse<D> = D extends Deferred<infer R> ? R : never;
+interface CreateDeferred {
+    <Resolve = void, Arg = undefined>(id?: Arg): Deferred<Resolve, Arg>;
+    <Resolve = void, Arg = string | number>(id: Arg): Deferred<Resolve, Arg>;
+}
+export declare const createDeferred: CreateDeferred;
+export {};
+//# sourceMappingURL=createDeferred.d.ts.map

package/third-party/utils/createDeferred.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeferred = void 0;
+const createDeferred = (id) => {
+    let localResolve = () => { };
+    let localReject = () => { };
+    const promise = new Promise((resolve, reject) => {
+        localResolve = resolve;
+        localReject = reject;
+    });
+    return {
+        id,
+        resolve: localResolve,
+        reject: localReject,
+        promise,
+    };
+};
+exports.createDeferred = createDeferred;
+//# sourceMappingURL=createDeferred.js.map

package/third-party/utils/createDeferredManager.d.ts

@@ -0,0 +1,19 @@
+type DeferredManagerOptions = {
+    timeout?: number;
+    onTimeout?: (promiseId: number) => void;
+    initialId?: number;
+};
+export type DeferredManager<T> = {
+    length: () => number;
+    nextId: () => number;
+    create: (timeout?: number) => {
+        promiseId: number;
+        promise: Promise<T>;
+    };
+    resolve: (promiseId: number, value: T) => boolean;
+    reject: (promiseId: number, error: Error) => boolean;
+    rejectAll: (error: Error) => void;
+};
+export declare const createDeferredManager: <T = any>(options?: DeferredManagerOptions) => DeferredManager<T>;
+export {};
+//# sourceMappingURL=createDeferredManager.d.ts.map

package/third-party/utils/createDeferredManager.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDeferredManager = void 0;
+const createDeferred_1 = require("./createDeferred");
+const createDeferredManager = (options) => {
+    const { initialId = 0, timeout: defaultTimeout = 0, onTimeout } = options !== null && options !== void 0 ? options : {};
+    const promises = [];
+    let ID = initialId;
+    let timeoutHandle;
+    const length = () => promises.length;
+    const nextId = () => ID;
+    const replanTimeout = () => {
+        const now = Date.now();
+        const nearestDeadline = promises.reduce((prev, { deadline }) => (prev && deadline ? Math.min : Math.max)(prev, deadline), 0);
+        if (timeoutHandle)
+            clearTimeout(timeoutHandle);
+        timeoutHandle = nearestDeadline
+            ?
+                setTimeout(timeoutCallback, Math.max(nearestDeadline - now, 0))
+            : undefined;
+    };
+    const timeoutCallback = () => {
+        const now = Date.now();
+        promises
+            .filter(promise => promise.deadline && promise.deadline <= now)
+            .forEach(promise => {
+            onTimeout === null || onTimeout === void 0 ? void 0 : onTimeout(promise.id);
+            promise.deadline = 0;
+        });
+        replanTimeout();
+    };
+    const create = (timeout = defaultTimeout) => {
+        const promiseId = ID++;
+        const deferred = (0, createDeferred_1.createDeferred)(promiseId);
+        const deadline = timeout && Date.now() + timeout;
+        promises.push(Object.assign(Object.assign({}, deferred), { deadline }));
+        if (timeout)
+            replanTimeout();
+        return { promiseId, promise: deferred.promise };
+    };
+    const extract = (promiseId) => {
+        const index = promises.findIndex(({ id }) => id === promiseId);
+        const [promise] = index >= 0 ? promises.splice(index, 1) : [undefined];
+        if (promise === null || promise === void 0 ? void 0 : promise.deadline)
+            replanTimeout();
+        return promise;
+    };
+    const resolve = (promiseId, value) => {
+        const promise = extract(promiseId);
+        promise === null || promise === void 0 ? void 0 : promise.resolve(value);
+        return !!promise;
+    };
+    const reject = (promiseId, error) => {
+        const promise = extract(promiseId);
+        promise === null || promise === void 0 ? void 0 : promise.reject(error);
+        return !!promise;
+    };
+    const rejectAll = (error) => {
+        promises.forEach(promise => promise.reject(error));
+        const deleted = promises.splice(0, promises.length);
+        if (deleted.length)
+            replanTimeout();
+    };
+    return { length, nextId, create, resolve, reject, rejectAll };
+};
+exports.createDeferredManager = createDeferredManager;
+//# sourceMappingURL=createDeferredManager.js.map

package/third-party/utils/createLazy.d.ts

@@ -0,0 +1,7 @@
+export declare const createLazy: <T, TArgs extends Array<any>>(initLazy: (...args: TArgs) => Promise<T>, disposeLazy?: (t: T) => void) => {
+    get: () => T | undefined;
+    getPending: () => Promise<T> | undefined;
+    getOrInit: (...args: TArgs) => Promise<T>;
+    dispose: () => void;
+};
+//# sourceMappingURL=createLazy.d.ts.map

package/third-party/utils/createLazy.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLazy = void 0;
+const createDeferred_1 = require("./createDeferred");
+const createLazy = (initLazy, disposeLazy) => {
+    let value;
+    let valuePromise;
+    const get = () => value;
+    const getPending = () => valuePromise === null || valuePromise === void 0 ? void 0 : valuePromise.promise;
+    const dispose = () => {
+        if (valuePromise) {
+            valuePromise.reject(new Error('Disposed during initialization'));
+            valuePromise = undefined;
+        }
+        if (value !== undefined) {
+            disposeLazy === null || disposeLazy === void 0 ? void 0 : disposeLazy(value);
+            value = undefined;
+        }
+    };
+    const getOrInit = (...args) => {
+        if (value !== undefined)
+            return Promise.resolve(value);
+        if (!valuePromise) {
+            const deferred = (0, createDeferred_1.createDeferred)();
+            valuePromise = deferred;
+            initLazy(...args)
+                .then(val => {
+                value = val;
+                valuePromise = undefined;
+                deferred.resolve(val);
+            })
+                .catch(err => {
+                valuePromise = undefined;
+                deferred.reject(err);
+            });
+        }
+        return valuePromise.promise;
+    };
+    return { get, getPending, getOrInit, dispose };
+};
+exports.createLazy = createLazy;
+//# sourceMappingURL=createLazy.js.map

package/third-party/utils/createTimeoutPromise.d.ts

@@ -0,0 +1,2 @@
+export declare const createTimeoutPromise: (timeout: number) => Promise<unknown>;
+//# sourceMappingURL=createTimeoutPromise.d.ts.map

package/third-party/utils/createTimeoutPromise.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTimeoutPromise = void 0;
+const createTimeoutPromise = (timeout) => new Promise(resolve => setTimeout(resolve, timeout));
+exports.createTimeoutPromise = createTimeoutPromise;
+//# sourceMappingURL=createTimeoutPromise.js.map

package/third-party/utils/enumUtils.d.ts

@@ -0,0 +1,6 @@
+type EnumValue = string | number;
+type EnumObject = Record<string, EnumValue>;
+export declare function getKeyByValue<E extends EnumObject>(obj: E, value: E[keyof E]): keyof E | undefined;
+export declare function getValueByKey<E extends EnumObject>(obj: E, enumKey: keyof E): E[keyof E] | undefined;
+export {};
+//# sourceMappingURL=enumUtils.d.ts.map

package/third-party/utils/enumUtils.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getKeyByValue = getKeyByValue;
+exports.getValueByKey = getValueByKey;
+function getKeyByValue(obj, value) {
+    return obj && Object.keys(obj).find(x => obj[x] === value);
+}
+function getValueByKey(obj, enumKey) {
+    const key = obj && Object.keys(obj).find(x => x === enumKey);
+    return key && obj[key];
+}
+//# sourceMappingURL=enumUtils.js.map

package/third-party/utils/extractUrlsFromText.d.ts

@@ -0,0 +1,5 @@
+export declare const extractUrlsFromText: (text: string) => {
+    textParts: string[];
+    urls: string[];
+};
+//# sourceMappingURL=extractUrlsFromText.d.ts.map

package/third-party/utils/extractUrlsFromText.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractUrlsFromText = void 0;
+const URL_REGEX = /\b(?:https?:\/\/|www\.)[a-zA-Z0-9-._~:/?#[\]@!$&'()*+,;=%]+\b|(?:[a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}(?=\b|\s|$|\])/gi;
+const extractUrlsFromText = (text) => {
+    const urls = [];
+    const textParts = [];
+    let lastIndex = 0;
+    const matches = [...text.matchAll(URL_REGEX)];
+    matches.forEach(match => {
+        const url = match[0];
+        const index = match.index !== undefined ? match.index : -1;
+        if (lastIndex < index) {
+            textParts.push(text.slice(lastIndex, index));
+        }
+        urls.push(url);
+        lastIndex = index + url.length;
+    });
+    if (lastIndex < text.length) {
+        textParts.push(text.slice(lastIndex));
+    }
+    if (textParts.length === 0 && urls.length > 0) {
+        textParts.push('');
+    }
+    return { textParts, urls };
+};
+exports.extractUrlsFromText = extractUrlsFromText;
+//# sourceMappingURL=extractUrlsFromText.js.map

package/third-party/utils/getLocaleSeparators.d.ts

@@ -0,0 +1,5 @@
+export declare const getLocaleSeparators: (locale: string) => {
+    decimalSeparator: string;
+    thousandsSeparator: string;
+};
+//# sourceMappingURL=getLocaleSeparators.d.ts.map

package/third-party/utils/getLocaleSeparators.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocaleSeparators = void 0;
+const getLocaleSeparators = (locale) => {
+    var _a, _b;
+    const numberFormat = new Intl.NumberFormat(locale);
+    const parts = numberFormat.formatToParts(10000.1);
+    const decimalSeparator = (_a = parts.find(({ type }) => type === 'decimal')) === null || _a === void 0 ? void 0 : _a.value;
+    const thousandsSeparator = (_b = parts.find(({ type }) => type === 'group')) === null || _b === void 0 ? void 0 : _b.value;
+    return { decimalSeparator, thousandsSeparator };
+};
+exports.getLocaleSeparators = getLocaleSeparators;
+//# sourceMappingURL=getLocaleSeparators.js.map

package/third-party/utils/getLocaleSeparators.native.d.ts

@@ -0,0 +1,5 @@
+export declare function getLocaleSeparators(locale: string): {
+    decimalSeparator: string;
+    thousandsSeparator: string;
+};
+//# sourceMappingURL=getLocaleSeparators.native.d.ts.map

package/third-party/utils/getLocaleSeparators.native.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLocaleSeparators = getLocaleSeparators;
+function getLocaleSeparators(locale) {
+    const formattedNumber = new Intl.NumberFormat(locale).format(1234567.89);
+    let thousandsSeparator = ' ';
+    let decimalSeparator = '.';
+    for (let i = 0; i < formattedNumber.length; i++) {
+        if (!/\d/.test(formattedNumber[i])) {
+            thousandsSeparator = formattedNumber[i];
+            break;
+        }
+    }
+    decimalSeparator = formattedNumber[formattedNumber.length - 3];
+    return { decimalSeparator, thousandsSeparator };
+}
+//# sourceMappingURL=getLocaleSeparators.native.js.map

package/third-party/utils/getMutex.d.ts

@@ -0,0 +1,2 @@
+export declare const getMutex: () => (lockId?: keyof any) => Promise<() => void>;
+//# sourceMappingURL=getMutex.d.ts.map

package/third-party/utils/getMutex.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMutex = void 0;
+const tslib_1 = require("tslib");
+const getMutex = () => {
+    const DEFAULT_ID = Symbol();
+    const locks = {};
+    return (...args_1) => tslib_1.__awaiter(void 0, [...args_1], void 0, function* (lockId = DEFAULT_ID) {
+        while (locks[lockId]) {
+            yield locks[lockId];
+        }
+        let resolve = () => { };
+        locks[lockId] = new Promise(res => {
+            resolve = res;
+        }).finally(() => {
+            delete locks[lockId];
+        });
+        return resolve;
+    });
+};
+exports.getMutex = getMutex;
+//# sourceMappingURL=getMutex.js.map

package/third-party/utils/getNumberFromPixelString.d.ts

@@ -0,0 +1,2 @@
+export declare const getNumberFromPixelString: (size: string) => number;
+//# sourceMappingURL=getNumberFromPixelString.d.ts.map

package/third-party/utils/getNumberFromPixelString.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNumberFromPixelString = void 0;
+const getNumberFromPixelString = (size) => parseInt(size.replace('px', ''), 10);
+exports.getNumberFromPixelString = getNumberFromPixelString;
+//# sourceMappingURL=getNumberFromPixelString.js.map

package/third-party/utils/getRandomInt.d.ts

@@ -0,0 +1,2 @@
+export declare const getRandomInt: (min: number, max: number) => number;
+//# sourceMappingURL=getRandomInt.d.ts.map

package/third-party/utils/getRandomInt.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRandomInt = void 0;
+const crypto_1 = require("crypto");
+const getRandomInt = (min, max) => {
+    if (!Number.isSafeInteger(min)) {
+        throw new RangeError(`The "min" argument must be a safe integer. Received type ${typeof min} (${min})`);
+    }
+    if (!Number.isSafeInteger(max)) {
+        throw new RangeError(`The "max" argument must be a safe integer. Received type ${typeof max} (${max})`);
+    }
+    if (min >= max) {
+        throw new RangeError(`The value of "max" is out of range. It must be greater than the value of "min" (${min}). Received ${max}`);
+    }
+    const MAX_RANGE_32_BITS = 0xffffffff + 1;
+    const range = max - min;
+    if (range > MAX_RANGE_32_BITS) {
+        throw new RangeError(`This function only provide 32 bits of entropy, therefore range cannot be more then 2^32.`);
+    }
+    const getRandomValues = typeof window !== 'undefined'
+        ? (array) => {
+            try {
+                return window.crypto.getRandomValues(array);
+            } catch (e) {
+                console.error('Window crypto error:', e);
+                throw e;
+            }
+        }
+        : typeof self !== 'undefined'
+            ? (array) => {
+                try {
+                    return self.crypto.getRandomValues(array);
+                } catch (e) {
+                    console.error('Self crypto error:', e);
+                    throw e;
+                }
+            }
+            : (array) => {
+                try {
+                    return (0, crypto_1.getRandomValues)(array);
+                } catch (e) {
+                    console.error('Node crypto error:', e);
+                    throw e;
+                }
+            };
+    const array = new Uint32Array(1);
+    const maxRange = MAX_RANGE_32_BITS - (MAX_RANGE_32_BITS % range);
+    let randomValue;
+    do {
+        getRandomValues(array);
+        randomValue = array[0];
+    } while (randomValue >= maxRange);
+    return min + (randomValue % range);
+};
+exports.getRandomInt = getRandomInt;
+//# sourceMappingURL=getRandomInt.js.map

package/third-party/utils/getSynchronize.d.ts

@@ -0,0 +1,4 @@
+import { getMutex } from './getMutex';
+export declare const getSynchronize: (mutex?: ReturnType<typeof getMutex>) => <T>(action: () => T, lockId?: keyof any) => T extends Promise<unknown> ? T : Promise<T>;
+export type Synchronize = ReturnType<typeof getSynchronize>;
+//# sourceMappingURL=getSynchronize.d.ts.map

package/third-party/utils/getSynchronize.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSynchronize = void 0;
+const getMutex_1 = require("./getMutex");
+const getSynchronize = (mutex) => {
+    const lock = mutex !== null && mutex !== void 0 ? mutex : (0, getMutex_1.getMutex)();
+    return (action, lockId) => lock(lockId).then(unlock => Promise.resolve().then(action).finally(unlock));
+};
+exports.getSynchronize = getSynchronize;
+//# sourceMappingURL=getSynchronize.js.map

package/third-party/utils/getWeakRandomId.d.ts

@@ -0,0 +1,2 @@
+export declare const getWeakRandomId: (length: number) => string;
+//# sourceMappingURL=getWeakRandomId.d.ts.map

package/third-party/utils/getWeakRandomId.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWeakRandomId = void 0;
+const getWeakRandomId = (length) => {
+    let id = '';
+    const list = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    for (let i = 0; i < length; i++) {
+        id += list.charAt(Math.floor(Math.random() * list.length));
+    }
+    return id;
+};
+exports.getWeakRandomId = getWeakRandomId;
+//# sourceMappingURL=getWeakRandomId.js.map

package/third-party/utils/getWeakRandomInt.d.ts

@@ -0,0 +1,2 @@
+export declare const getWeakRandomInt: (min: number, max: number) => number;
+//# sourceMappingURL=getWeakRandomInt.d.ts.map

package/third-party/utils/getWeakRandomInt.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWeakRandomInt = void 0;
+const getWeakRandomInt = (min, max) => {
+    if (min >= max) {
+        throw new RangeError(`The value of "max" is out of range. It must be greater than the value of "min" (${min}). Received ${max}`);
+    }
+    return Math.floor(Math.random() * (max - min) + min);
+};
+exports.getWeakRandomInt = getWeakRandomInt;
+//# sourceMappingURL=getWeakRandomInt.js.map

package/third-party/utils/getWeakRandomNumberInRange.d.ts

@@ -0,0 +1,2 @@
+export declare const getWeakRandomNumberInRange: (min: number, max: number) => number;
+//# sourceMappingURL=getWeakRandomNumberInRange.d.ts.map

package/third-party/utils/getWeakRandomNumberInRange.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getWeakRandomNumberInRange = void 0;
+const getWeakRandomNumberInRange = (min, max) => Math.floor(Math.random() * (max - min + 1)) + min;
+exports.getWeakRandomNumberInRange = getWeakRandomNumberInRange;
+//# sourceMappingURL=getWeakRandomNumberInRange.js.map

package/third-party/utils/hasUppercaseLetter.d.ts

@@ -0,0 +1,2 @@
+export declare const hasUppercaseLetter: (value: string) => boolean;
+//# sourceMappingURL=hasUppercaseLetter.d.ts.map

package/third-party/utils/hasUppercaseLetter.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasUppercaseLetter = void 0;
+const HAS_UPPERCASE_LATER_REGEXP = new RegExp('^(.*[A-Z].*)$');
+const hasUppercaseLetter = (value) => HAS_UPPERCASE_LATER_REGEXP.test(value);
+exports.hasUppercaseLetter = hasUppercaseLetter;
+//# sourceMappingURL=hasUppercaseLetter.js.map

package/third-party/utils/index.d.ts

@@ -0,0 +1,52 @@
+export * as bufferUtils from './bufferUtils';
+export * as enumUtils from './enumUtils';
+export * as versionUtils from './versionUtils';
+export * as xssFilters from './xssFilters';
+export * from './addDashesToSpaces';
+export * from './arrayDistinct';
+export * from './arrayPartition';
+export * from './arrayShuffle';
+export * from './arrayToDictionary';
+export * from './bytesToHumanReadable';
+export * from './capitalizeFirstLetter';
+export * from './cloneObject';
+export * from './countBytesInString';
+export * from './createCooldown';
+export * from './createDeferred';
+export * from './createDeferredManager';
+export * from './createLazy';
+export * from './createTimeoutPromise';
+export * from './getLocaleSeparators';
+export * from './getMutex';
+export * from './getNumberFromPixelString';
+export * from './getWeakRandomNumberInRange';
+export * from './getSynchronize';
+export * from './getRandomInt';
+export * from './getWeakRandomId';
+export * from './getWeakRandomInt';
+export * from './hasUppercaseLetter';
+export * from './isArrayMember';
+export * from './isHex';
+export * from './isNotUndefined';
+export * from './isUrl';
+export * from './mergeDeepObject';
+export * from './objectPartition';
+export * from './parseElectrumUrl';
+export * from './parseHostname';
+export * from './promiseAllSequence';
+export * from './redactUserPath';
+export * from './scheduleAction';
+export * from './splitStringEveryNCharacters';
+export * from './throwError';
+export * from './topologicalSort';
+export * from './truncateMiddle';
+export * from './typedEventEmitter';
+export * from './urlToOnion';
+export * from './logs';
+export * from './logsManager';
+export * from './bigNumber';
+export * from './throttler';
+export * from './extractUrlsFromText';
+export * from './isFullPath';
+export * from './asciiUtils';
+//# sourceMappingURL=index.d.ts.map

package/third-party/utils/index.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.xssFilters = exports.versionUtils = exports.enumUtils = exports.bufferUtils = void 0;
+const tslib_1 = require("tslib");
+exports.bufferUtils = tslib_1.__importStar(require("./bufferUtils"));
+exports.enumUtils = tslib_1.__importStar(require("./enumUtils"));
+exports.versionUtils = tslib_1.__importStar(require("./versionUtils"));
+exports.xssFilters = tslib_1.__importStar(require("./xssFilters"));
+tslib_1.__exportStar(require("./addDashesToSpaces"), exports);
+tslib_1.__exportStar(require("./arrayDistinct"), exports);
+tslib_1.__exportStar(require("./arrayPartition"), exports);
+tslib_1.__exportStar(require("./arrayShuffle"), exports);
+tslib_1.__exportStar(require("./arrayToDictionary"), exports);
+tslib_1.__exportStar(require("./bytesToHumanReadable"), exports);
+tslib_1.__exportStar(require("./capitalizeFirstLetter"), exports);
+tslib_1.__exportStar(require("./cloneObject"), exports);
+tslib_1.__exportStar(require("./countBytesInString"), exports);
+tslib_1.__exportStar(require("./createCooldown"), exports);
+tslib_1.__exportStar(require("./createDeferred"), exports);
+tslib_1.__exportStar(require("./createDeferredManager"), exports);
+tslib_1.__exportStar(require("./createLazy"), exports);
+tslib_1.__exportStar(require("./createTimeoutPromise"), exports);
+tslib_1.__exportStar(require("./getLocaleSeparators"), exports);
+tslib_1.__exportStar(require("./getMutex"), exports);
+tslib_1.__exportStar(require("./getNumberFromPixelString"), exports);
+tslib_1.__exportStar(require("./getWeakRandomNumberInRange"), exports);
+tslib_1.__exportStar(require("./getSynchronize"), exports);
+tslib_1.__exportStar(require("./getRandomInt"), exports);
+tslib_1.__exportStar(require("./getWeakRandomId"), exports);
+tslib_1.__exportStar(require("./getWeakRandomInt"), exports);
+tslib_1.__exportStar(require("./hasUppercaseLetter"), exports);
+tslib_1.__exportStar(require("./isArrayMember"), exports);
+tslib_1.__exportStar(require("./isHex"), exports);
+tslib_1.__exportStar(require("./isNotUndefined"), exports);
+tslib_1.__exportStar(require("./isUrl"), exports);
+tslib_1.__exportStar(require("./mergeDeepObject"), exports);
+tslib_1.__exportStar(require("./objectPartition"), exports);
+tslib_1.__exportStar(require("./parseElectrumUrl"), exports);
+tslib_1.__exportStar(require("./parseHostname"), exports);
+tslib_1.__exportStar(require("./promiseAllSequence"), exports);
+tslib_1.__exportStar(require("./redactUserPath"), exports);
+tslib_1.__exportStar(require("./scheduleAction"), exports);
+tslib_1.__exportStar(require("./splitStringEveryNCharacters"), exports);
+tslib_1.__exportStar(require("./throwError"), exports);
+tslib_1.__exportStar(require("./topologicalSort"), exports);
+tslib_1.__exportStar(require("./truncateMiddle"), exports);
+tslib_1.__exportStar(require("./typedEventEmitter"), exports);
+tslib_1.__exportStar(require("./urlToOnion"), exports);
+tslib_1.__exportStar(require("./logs"), exports);
+tslib_1.__exportStar(require("./logsManager"), exports);
+tslib_1.__exportStar(require("./bigNumber"), exports);
+tslib_1.__exportStar(require("./throttler"), exports);
+tslib_1.__exportStar(require("./extractUrlsFromText"), exports);
+tslib_1.__exportStar(require("./isFullPath"), exports);
+tslib_1.__exportStar(require("./asciiUtils"), exports);
+//# sourceMappingURL=index.js.map

package/third-party/utils/isArrayMember.d.ts

@@ -0,0 +1,2 @@
+export declare const isArrayMember: <Value extends string, Subset extends Value>(value: Value, arr: readonly Subset[]) => value is Subset;
+//# sourceMappingURL=isArrayMember.d.ts.map

package/third-party/utils/isArrayMember.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isArrayMember = void 0;
+const isArrayMember = (value, arr) => arr.some(v => v === value);
+exports.isArrayMember = isArrayMember;
+//# sourceMappingURL=isArrayMember.js.map

package/third-party/utils/isFullPath.d.ts

@@ -0,0 +1,2 @@
+export declare const isFullPath: (path: string) => boolean;
+//# sourceMappingURL=isFullPath.d.ts.map

package/third-party/utils/isFullPath.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFullPath = void 0;
+const isFullPath = (path) => {
+    const fullPathPattern = /^(\/|([a-zA-Z]:\\))/;
+    return fullPathPattern.test(path);
+};
+exports.isFullPath = isFullPath;
+//# sourceMappingURL=isFullPath.js.map

package/third-party/utils/isHex.d.ts

@@ -0,0 +1,2 @@
+export declare const isHex: (str: string) => boolean;
+//# sourceMappingURL=isHex.d.ts.map

package/third-party/utils/isHex.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isHex = void 0;
+const isHex = (str) => {
+    const regExp = /^(0x|0X)?[0-9A-Fa-f]+$/g;
+    return regExp.test(str);
+};
+exports.isHex = isHex;
+//# sourceMappingURL=isHex.js.map

package/third-party/utils/isNotUndefined.d.ts

@@ -0,0 +1,2 @@
+export declare const isNotUndefined: <T>(item?: T) => item is T;
+//# sourceMappingURL=isNotUndefined.d.ts.map

package/third-party/utils/isNotUndefined.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNotUndefined = void 0;
+const isNotUndefined = (item) => typeof item !== 'undefined';
+exports.isNotUndefined = isNotUndefined;
+//# sourceMappingURL=isNotUndefined.js.map

package/third-party/utils/isUrl.d.ts

@@ -0,0 +1,2 @@
+export declare const isUrl: (value: string) => boolean;
+//# sourceMappingURL=isUrl.d.ts.map