@onetokenfe/coinselect 3.1.16

package/third-party/utils/isUrl.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isUrl = void 0;
+const URL_REGEXP = /^(http|ws)s?:\/\/[a-z0-9]([a-z0-9.-]+)?(:[0-9]{1,5})?((\/)?(([a-z0-9-_])+(\/)?)+)$/i;
+const isUrl = (value) => URL_REGEXP.test(value);
+exports.isUrl = isUrl;
+//# sourceMappingURL=isUrl.js.map

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

@@ -0,0 +1,32 @@
+export type LogMessage = {
+    level: string;
+    prefix: string;
+    message: any[];
+    timestamp: number;
+};
+export type LogWriter = {
+    add: (message: LogMessage) => void;
+};
+export declare class Log {
+    prefix: string;
+    enabled: boolean;
+    css: string;
+    messages: LogMessage[];
+    logWriter: LogWriter | undefined;
+    MAX_ENTRIES: number;
+    constructor(prefix: string, enabled: boolean, logWriter?: LogWriter);
+    setColors(colors: Record<string, string>): void;
+    addMessage({ level, prefix, timestamp }: {
+        level: string;
+        prefix: string;
+        timestamp?: number;
+    }, ...args: any[]): void;
+    setWriter(logWriter: any): void;
+    log(...args: any[]): void;
+    error(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    debug(...args: any[]): void;
+    getLog(): LogMessage[];
+}
+//# sourceMappingURL=logs.d.ts.map

package/third-party/utils/logs.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Log = void 0;
+class Log {
+    constructor(prefix, enabled, logWriter) {
+        this.css = '';
+        this.MAX_ENTRIES = 100;
+        this.prefix = prefix;
+        this.enabled = enabled;
+        this.messages = [];
+        if (logWriter) {
+            this.logWriter = logWriter;
+        }
+    }
+    setColors(colors) {
+        this.css = typeof window !== 'undefined' && colors[this.prefix] ? colors[this.prefix] : '';
+    }
+    addMessage({ level, prefix, timestamp }, ...args) {
+        const message = {
+            level,
+            prefix,
+            css: this.css,
+            message: args,
+            timestamp: timestamp || Date.now(),
+        };
+        this.messages.push(message);
+        if (this.logWriter) {
+            try {
+                this.logWriter.add(message);
+            }
+            catch (err) {
+                console.error('There was an error adding log message', err, message);
+            }
+        }
+        if (this.messages.length > this.MAX_ENTRIES) {
+            this.messages.shift();
+        }
+    }
+    setWriter(logWriter) {
+        this.logWriter = logWriter;
+    }
+    log(...args) {
+        this.addMessage({ level: 'log', prefix: this.prefix }, ...args);
+        if (this.enabled) {
+            console.log(`%c${this.prefix}`, this.css, ...args);
+        }
+    }
+    error(...args) {
+        this.addMessage({ level: 'error', prefix: this.prefix }, ...args);
+        if (this.enabled) {
+            console.error(`%c${this.prefix}`, this.css, ...args);
+        }
+    }
+    info(...args) {
+        this.addMessage({ level: 'info', prefix: this.prefix }, ...args);
+        if (this.enabled) {
+            console.info(`%c${this.prefix}`, this.css, ...args);
+        }
+    }
+    warn(...args) {
+        this.addMessage({ level: 'warn', prefix: this.prefix }, ...args);
+        if (this.enabled) {
+            console.warn(`%c${this.prefix}`, this.css, ...args);
+        }
+    }
+    debug(...args) {
+        this.addMessage({ level: 'debug', prefix: this.prefix }, ...args);
+        if (this.enabled) {
+            if (this.css) {
+                console.log(`%c${this.prefix}`, this.css, ...args);
+            }
+            else {
+                console.log(this.prefix, ...args);
+            }
+        }
+    }
+    getLog() {
+        return this.messages;
+    }
+}
+exports.Log = Log;
+//# sourceMappingURL=logs.js.map

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

@@ -0,0 +1,17 @@
+import { LogWriter, Log, LogMessage } from './logs';
+export declare class LogsManager {
+    logs: {
+        [k: string]: Log;
+    };
+    writer: LogWriter | undefined;
+    colors?: Record<string, string>;
+    constructor({ colors }: {
+        colors?: Record<string, string>;
+    });
+    initLog(prefix: string, enabled?: boolean, logWriter?: LogWriter): Log;
+    setLogWriter(logWriterFactory: () => LogWriter | undefined): void;
+    enableLog(enabled?: boolean): void;
+    enableLogByPrefix(prefix: string, enabled: boolean): void;
+    getLog(): LogMessage[];
+}
+//# sourceMappingURL=logsManager.d.ts.map

package/third-party/utils/logsManager.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogsManager = void 0;
+const logs_1 = require("./logs");
+class LogsManager {
+    constructor({ colors }) {
+        this.logs = {};
+        this.colors = {};
+        this.colors = colors;
+    }
+    initLog(prefix, enabled, logWriter) {
+        const instanceWriter = logWriter || this.writer;
+        const instance = new logs_1.Log(prefix, !!enabled, instanceWriter);
+        if (this.colors) {
+            instance.setColors(this.colors);
+        }
+        this.logs[prefix] = instance;
+        return instance;
+    }
+    setLogWriter(logWriterFactory) {
+        Object.keys(this.logs).forEach(key => {
+            this.writer = logWriterFactory();
+            if (this.writer) {
+                this.logs[key].setWriter(this.writer);
+                const { messages } = this.logs[key];
+                messages.forEach(message => {
+                    var _a;
+                    (_a = this.writer) === null || _a === void 0 ? void 0 : _a.add(message);
+                });
+            }
+        });
+    }
+    enableLog(enabled) {
+        Object.keys(this.logs).forEach(key => {
+            this.logs[key].enabled = !!enabled;
+        });
+    }
+    enableLogByPrefix(prefix, enabled) {
+        if (this.logs[prefix]) {
+            this.logs[prefix].enabled = enabled;
+        }
+    }
+    getLog() {
+        let logs = [];
+        Object.keys(this.logs).forEach(key => {
+            logs = logs.concat(this.logs[key].messages);
+        });
+        logs.sort((a, b) => a.timestamp - b.timestamp);
+        return logs;
+    }
+}
+exports.LogsManager = LogsManager;
+//# sourceMappingURL=logsManager.js.map

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

@@ -0,0 +1,26 @@
+type TAllKeys<T> = T extends any ? keyof T : never;
+type TIndexValue<T, K extends PropertyKey, D = never> = T extends any ? K extends keyof T ? T[K] : D : never;
+type TPartialKeys<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>> extends infer O ? {
+    [P in keyof O]: O[P];
+} : never;
+type TFunction = (...a: any[]) => any;
+type TPrimitives = string | number | boolean | bigint | symbol | Date | TFunction;
+type TMerged<T> = [T] extends [Array<any>] ? {
+    [K in keyof T]: TMerged<T[K]>;
+} : [T] extends [TPrimitives] ? T : [T] extends [object] ? TPartialKeys<{
+    [K in TAllKeys<T>]: TMerged<TIndexValue<T, K>>;
+}, never> : T;
+interface IObject {
+    [key: string]: any;
+}
+export declare const mergeDeepObject: {
+    <T extends IObject[]>(...objects: T): TMerged<T[number]>;
+    options: IOptions;
+    withOptions<T extends IObject[]>(options: Partial<IOptions>, ...objects: T): TMerged<T[number]>;
+};
+interface IOptions {
+    mergeArrays: boolean;
+    dotNotation: boolean;
+}
+export {};
+//# sourceMappingURL=mergeDeepObject.d.ts.map

package/third-party/utils/mergeDeepObject.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeDeepObject = void 0;
+const isObject = (obj) => {
+    if (typeof obj === 'object' && obj !== null) {
+        if (typeof Object.getPrototypeOf === 'function') {
+            const prototype = Object.getPrototypeOf(obj);
+            return prototype === Object.prototype || prototype === null;
+        }
+        return Object.prototype.toString.call(obj) === '[object Object]';
+    }
+    return false;
+};
+const mergeValuesWithPath = (target, value, [key, ...rest]) => {
+    if (key === undefined) {
+        return mergeValues(target, value);
+    }
+    else if (!isObject(target)) {
+        return { [key]: mergeValuesWithPath({}, value, rest) };
+    }
+    else {
+        return Object.assign(Object.assign({}, target), { [key]: mergeValuesWithPath(target[key], value, rest) });
+    }
+};
+const mergeValues = (target, value) => {
+    if (Array.isArray(target) && Array.isArray(value)) {
+        return exports.mergeDeepObject.options.mergeArrays
+            ? Array.from(new Set(target.concat(value)))
+            : value;
+    }
+    else if (isObject(target) && isObject(value)) {
+        return (0, exports.mergeDeepObject)(target, value);
+    }
+    else {
+        return value;
+    }
+};
+const mergeDeepObject = (...objects) => objects.reduce((result, current) => {
+    if (Array.isArray(current)) {
+        throw new TypeError('Arguments provided to ts-deepmerge must be objects, not arrays.');
+    }
+    Object.keys(current).forEach(key => {
+        if (['__proto__', 'constructor', 'prototype'].includes(key)) {
+            return;
+        }
+        if (exports.mergeDeepObject.options.dotNotation) {
+            const [first, ...rest] = key.split('.');
+            result[first] = mergeValuesWithPath(result[first], current[key], rest);
+        }
+        else {
+            result[key] = mergeValues(result[key], current[key]);
+        }
+    });
+    return result;
+}, {});
+exports.mergeDeepObject = mergeDeepObject;
+const defaultOptions = {
+    mergeArrays: true,
+    dotNotation: false,
+};
+exports.mergeDeepObject.options = defaultOptions;
+exports.mergeDeepObject.withOptions = (options, ...objects) => {
+    exports.mergeDeepObject.options = Object.assign(Object.assign({}, defaultOptions), options);
+    const result = (0, exports.mergeDeepObject)(...objects);
+    exports.mergeDeepObject.options = defaultOptions;
+    return result;
+};
+//# sourceMappingURL=mergeDeepObject.js.map

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

@@ -0,0 +1,6 @@
+type Obj<T> = {
+    [key: string]: T;
+};
+export declare const objectPartition: <T>(obj: Obj<T>, keys: string[]) => [Obj<T>, Obj<T>];
+export {};
+//# sourceMappingURL=objectPartition.d.ts.map

package/third-party/utils/objectPartition.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectPartition = void 0;
+const tslib_1 = require("tslib");
+const objectPartition = (obj, keys) => keys.reduce(([included, excluded], key) => {
+    const _a = excluded, _b = key, value = _a[_b], rest = tslib_1.__rest(_a, [typeof _b === "symbol" ? _b : _b + ""]);
+    return typeof value !== 'undefined'
+        ? [Object.assign(Object.assign({}, included), { [key]: value }), rest]
+        : [included, excluded];
+}, [{}, obj]);
+exports.objectPartition = objectPartition;
+//# sourceMappingURL=objectPartition.js.map

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

@@ -0,0 +1,6 @@
+export declare const parseElectrumUrl: (url: string) => {
+    host: string;
+    port: number;
+    protocol: "t" | "s";
+} | undefined;
+//# sourceMappingURL=parseElectrumUrl.d.ts.map

package/third-party/utils/parseElectrumUrl.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseElectrumUrl = void 0;
+const ELECTRUM_URL_REGEX = /^(?:([a-zA-Z0-9.-]+)|\[([a-f0-9:]+)\]):([0-9]{1,5}):([ts])$/;
+const parseElectrumUrl = (url) => {
+    var _a;
+    const match = url.match(ELECTRUM_URL_REGEX);
+    if (!match)
+        return undefined;
+    return {
+        host: (_a = match[1]) !== null && _a !== void 0 ? _a : match[2],
+        port: Number.parseInt(match[3], 10),
+        protocol: match[4],
+    };
+};
+exports.parseElectrumUrl = parseElectrumUrl;
+//# sourceMappingURL=parseElectrumUrl.js.map

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

@@ -0,0 +1,2 @@
+export declare const parseHostname: (url: string) => string | undefined;
+//# sourceMappingURL=parseHostname.d.ts.map

package/third-party/utils/parseHostname.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHostname = void 0;
+const HOSTNAME_REGEX = /^([a-z0-9.+-]+:\/\/)?([a-z0-9.-]+)([:/][^:/]+)*\/?$/i;
+const parseHostname = (url) => { var _a, _b; return (_b = (_a = url.match(HOSTNAME_REGEX)) === null || _a === void 0 ? void 0 : _a[2]) === null || _b === void 0 ? void 0 : _b.toLowerCase(); };
+exports.parseHostname = parseHostname;
+//# sourceMappingURL=parseHostname.js.map

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

@@ -0,0 +1,2 @@
+export declare const promiseAllSequence: <Fn extends () => PromiseLike<any>, R = Awaited<ReturnType<Fn>>>(actions: Fn[]) => Promise<R[]>;
+//# sourceMappingURL=promiseAllSequence.d.ts.map

package/third-party/utils/promiseAllSequence.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promiseAllSequence = void 0;
+const tslib_1 = require("tslib");
+const promiseAllSequence = (actions) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const results = [];
+    for (let i = 0; i < actions.length; ++i) {
+        const result = yield actions[i]();
+        results.push(result);
+    }
+    return results;
+});
+exports.promiseAllSequence = promiseAllSequence;
+//# sourceMappingURL=promiseAllSequence.js.map

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

@@ -0,0 +1,3 @@
+export declare const startOfUserPathRegex: RegExp;
+export declare const redactUserPathFromString: (text: string) => string;
+//# sourceMappingURL=redactUserPath.d.ts.map

package/third-party/utils/redactUserPath.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.redactUserPathFromString = exports.startOfUserPathRegex = void 0;
+exports.startOfUserPathRegex = /([/\\][Uu]sers[/\\]{1,4})([^"^'^[^\]^/^\\]*)/g;
+const redactUserPathFromString = (text) => text.replace(exports.startOfUserPathRegex, '$1[*]');
+exports.redactUserPathFromString = redactUserPathFromString;
+//# sourceMappingURL=redactUserPath.js.map

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

@@ -0,0 +1,15 @@
+export type ScheduledAction<T> = (signal?: AbortSignal) => Promise<T>;
+type AttemptParams = {
+    timeout?: number;
+    gap?: number;
+};
+export type ScheduleActionParams = {
+    delay?: number;
+    deadline?: number;
+    attempts?: number | readonly AttemptParams[];
+    signal?: AbortSignal;
+    attemptFailureHandler?: (error: Error) => Error | void;
+} & AttemptParams;
+export declare const scheduleAction: <T>(action: ScheduledAction<T>, params: ScheduleActionParams) => Promise<T>;
+export {};
+//# sourceMappingURL=scheduleAction.d.ts.map

package/third-party/utils/scheduleAction.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduleAction = void 0;
+const tslib_1 = require("tslib");
+const isArray = (attempts) => Array.isArray(attempts);
+const abortedBySignal = () => new Error('Aborted by signal');
+const abortedByDeadline = () => new Error('Aborted by deadline');
+const abortedByTimeout = () => new Error('Aborted by timeout');
+const resolveAfterMs = (ms, clear) => new Promise((resolve, reject) => {
+    if (clear.aborted)
+        return reject();
+    if (ms === undefined)
+        return resolve();
+    let timeout;
+    const onClear = () => {
+        clearTimeout(timeout);
+        clear.removeEventListener('abort', onClear);
+        reject();
+    };
+    timeout = setTimeout(() => {
+        clear.removeEventListener('abort', onClear);
+        resolve();
+    }, ms);
+    clear.addEventListener('abort', onClear);
+});
+const rejectAfterMs = (ms, reason, clear) => new Promise((_, reject) => {
+    if (clear.aborted)
+        return reject();
+    let timeout;
+    const onClear = () => {
+        clearTimeout(timeout);
+        clear.removeEventListener('abort', onClear);
+        reject();
+    };
+    timeout = setTimeout(() => {
+        clear.removeEventListener('abort', onClear);
+        reject(reason());
+    }, ms);
+    clear.addEventListener('abort', onClear);
+});
+const maybeRejectAfterMs = (ms, reason, clear) => ms === undefined ? [] : [rejectAfterMs(ms, reason, clear)];
+const rejectWhenAborted = (signal, clear) => new Promise((_, reject) => {
+    if (clear.aborted)
+        return reject();
+    if (signal === null || signal === void 0 ? void 0 : signal.aborted)
+        return reject(abortedBySignal());
+    const onAbort = () => reject(abortedBySignal());
+    signal === null || signal === void 0 ? void 0 : signal.addEventListener('abort', onAbort);
+    const onClear = () => {
+        signal === null || signal === void 0 ? void 0 : signal.removeEventListener('abort', onAbort);
+        clear.removeEventListener('abort', onClear);
+        reject();
+    };
+    clear.addEventListener('abort', onClear);
+});
+const resolveAction = (action, clear) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const aborter = new AbortController();
+    if (clear.aborted)
+        aborter.abort();
+    const onClear = () => {
+        clear.removeEventListener('abort', onClear);
+        aborter.abort();
+    };
+    clear.addEventListener('abort', onClear);
+    try {
+        return yield new Promise(resolve => resolve(action(aborter.signal)));
+    }
+    finally {
+        if (!clear.aborted)
+            clear.removeEventListener('abort', onClear);
+    }
+});
+const attemptLoop = (attempts, attempt, failure, clear) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    for (let a = 0; a < attempts - 1; a++) {
+        if (clear.aborted)
+            break;
+        const aborter = new AbortController();
+        const onClear = () => aborter.abort();
+        clear.addEventListener('abort', onClear);
+        try {
+            return yield attempt(a, aborter.signal);
+        }
+        catch (error) {
+            onClear();
+            yield failure(a, error);
+        }
+        finally {
+            clear.removeEventListener('abort', onClear);
+        }
+    }
+    return clear.aborted ? Promise.reject() : attempt(attempts - 1, clear);
+});
+const scheduleAction = (action, params) => tslib_1.__awaiter(void 0, void 0, void 0, function* () {
+    const { signal, delay, attempts, timeout, deadline, gap, attemptFailureHandler } = params;
+    const deadlineMs = deadline && deadline - Date.now();
+    const attemptCount = isArray(attempts)
+        ? attempts.length
+        : attempts !== null && attempts !== void 0 ? attempts : (deadline ? Infinity : 1);
+    const clearAborter = new AbortController();
+    const clear = clearAborter.signal;
+    const getParams = isArray(attempts)
+        ? (attempt) => attempts[attempt]
+        : () => ({ timeout, gap });
+    try {
+        return yield Promise.race([
+            rejectWhenAborted(signal, clear),
+            ...maybeRejectAfterMs(deadlineMs, abortedByDeadline, clear),
+            resolveAfterMs(delay, clear).then(() => attemptLoop(attemptCount, (attempt, abort) => Promise.race([
+                ...maybeRejectAfterMs(getParams(attempt).timeout, abortedByTimeout, clear),
+                resolveAction(action, abort),
+            ]), (attempt, error) => {
+                var _a;
+                const errorHandlerResult = attemptFailureHandler === null || attemptFailureHandler === void 0 ? void 0 : attemptFailureHandler(error);
+                return errorHandlerResult
+                    ? Promise.reject(errorHandlerResult)
+                    : resolveAfterMs((_a = getParams(attempt).gap) !== null && _a !== void 0 ? _a : 0, clear);
+            }, clear)),
+        ]);
+    }
+    finally {
+        clearAborter.abort();
+    }
+});
+exports.scheduleAction = scheduleAction;
+//# sourceMappingURL=scheduleAction.js.map

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

@@ -0,0 +1,2 @@
+export declare function splitStringEveryNCharacters(value: string, n: number): string[];
+//# sourceMappingURL=splitStringEveryNCharacters.d.ts.map

package/third-party/utils/splitStringEveryNCharacters.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitStringEveryNCharacters = splitStringEveryNCharacters;
+function splitStringEveryNCharacters(value, n) {
+    var _a;
+    if (n === 0) {
+        return [];
+    }
+    const regex = new RegExp(`.{1,${n}}`, 'g');
+    return (_a = value.match(regex)) !== null && _a !== void 0 ? _a : [];
+}
+//# sourceMappingURL=splitStringEveryNCharacters.js.map

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

@@ -0,0 +1,11 @@
+export declare class Throttler {
+    private readonly delay;
+    private readonly intervals;
+    private readonly callbacks;
+    constructor(delay: number);
+    throttle(id: string, callback: () => void): void;
+    private tick;
+    cancel(id: string): void;
+    dispose(): void;
+}
+//# sourceMappingURL=throttler.d.ts.map

package/third-party/utils/throttler.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Throttler = void 0;
+class Throttler {
+    constructor(delay) {
+        this.delay = delay;
+        this.intervals = {};
+        this.callbacks = {};
+    }
+    throttle(id, callback) {
+        if (this.intervals[id]) {
+            this.callbacks[id] = callback;
+        }
+        else {
+            callback();
+            this.intervals[id] = setInterval(() => this.tick(id), this.delay);
+        }
+    }
+    tick(id) {
+        if (this.callbacks[id]) {
+            this.callbacks[id]();
+            delete this.callbacks[id];
+        }
+        else {
+            this.cancel(id);
+        }
+    }
+    cancel(id) {
+        clearInterval(this.intervals[id]);
+        delete this.intervals[id];
+        delete this.callbacks[id];
+    }
+    dispose() {
+        Object.keys(this.intervals).forEach(this.cancel, this);
+    }
+}
+exports.Throttler = Throttler;
+//# sourceMappingURL=throttler.js.map

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

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

package/third-party/utils/throwError.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throwError = void 0;
+const throwError = (reason) => {
+    throw new Error(reason);
+};
+exports.throwError = throwError;
+//# sourceMappingURL=throwError.js.map

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

@@ -0,0 +1,2 @@
+export declare const topologicalSort: <T>(elements: T[], precedes: (pred: T, succ: T) => boolean, tie?: (a: T, b: T) => number) => T[];
+//# sourceMappingURL=topologicalSort.d.ts.map

package/third-party/utils/topologicalSort.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.topologicalSort = void 0;
+const arrayPartition_1 = require("./arrayPartition");
+const topologicalSort = (elements, precedes, tie) => {
+    const result = [];
+    const filterRoots = (verts) => (0, arrayPartition_1.arrayPartition)(verts, succ => !verts.some(pred => precedes(pred, succ)));
+    let elem = elements;
+    while (elem.length) {
+        const [roots, rest] = filterRoots(elem);
+        if (!roots.length)
+            throw new Error('Cycle detected');
+        result.push(...(tie ? roots.sort(tie) : roots));
+        elem = rest;
+    }
+    return result;
+};
+exports.topologicalSort = topologicalSort;
+//# sourceMappingURL=topologicalSort.js.map

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

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

package/third-party/utils/truncateMiddle.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.truncateMiddle = void 0;
+const truncateMiddle = (text, startChars, endChars) => {
+    if (text.length <= startChars + endChars)
+        return text;
+    const start = text.substring(0, startChars);
+    const end = text.substring(text.length - endChars, text.length);
+    return `${start}…${end}`;
+};
+exports.truncateMiddle = truncateMiddle;
+//# sourceMappingURL=truncateMiddle.js.map