@welshman/lib 0.0.34 → 0.0.35

package/build/src/Tools.cjs

@@ -1,1008 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.without = exports.remove = exports.difference = exports.intersection = exports.union = exports.append = exports.concat = exports.sleep = exports.displayDomain = exports.displayUrl = exports.stripProtocol = exports.randomId = exports.randomInt = exports.within = exports.between = exports.mergeRight = exports.mergeLeft = exports.mapVals = exports.mapKeys = exports.range = exports.pick = exports.omitVals = exports.omit = exports.take = exports.drop = exports.avg = exports.sum = exports.min = exports.max = exports.gte = exports.gt = exports.lte = exports.lt = exports.dec = exports.inc = exports.div = exports.mul = exports.sub = exports.add = exports.num = exports.complement = exports.not = exports.always = exports.identity = exports.last = exports.ffirst = exports.first = exports.noop = exports.ifLet = exports.isNil = void 0;
-exports.pushToMapKey = exports.addToMapKey = exports.pushToKey = exports.addToKey = exports.batcher = exports.batch = exports.throttleWithValue = exports.throttle = exports.memoize = exports.once = exports.chunks = exports.chunk = exports.initArray = exports.indexBy = exports.groupBy = exports.sortBy = exports.sort = exports.uniqBy = exports.uniq = exports.partition = exports.flatten = exports.fromPairs = exports.pluck = exports.ensureNumber = exports.ensurePlural = exports.toIterable = exports.isIterable = exports.sample = exports.shuffle = exports.choice = exports.insert = exports.splitAt = exports.hash = exports.assoc = exports.prop = exports.ne = exports.eq = exports.spec = exports.nthNe = exports.nthEq = exports.nth = exports.equals = exports.isPojo = exports.ellipsize = exports.tryCatch = exports.setJson = exports.getJson = exports.parseJson = exports.clamp = exports.toggle = void 0;
-exports.bech32ToHex = exports.hexToBech32 = exports.uploadFile = exports.postJson = exports.fetchJson = exports.ms = exports.ago = exports.now = exports.int = exports.YEAR = exports.QUARTER = exports.MONTH = exports.WEEK = exports.DAY = exports.HOUR = exports.MINUTE = exports.switcher = void 0;
-const base_1 = require("@scure/base");
-/** Checks if a value is null or undefined */
-const isNil = (x) => [null, undefined].includes(x);
-exports.isNil = isNil;
-/**
- * Executes a function if the value is defined
- * @param x - The value to check
- * @param f - Function to execute if x is defined
- * @returns Result of f(x) if x is defined, undefined otherwise
- */
-const ifLet = (x, f) => x === undefined ? undefined : f(x);
-exports.ifLet = ifLet;
-/** Function that does nothing and returns undefined */
-const noop = (...args) => undefined;
-exports.noop = noop;
-/**
- * Returns the first element of an array
- * @param xs - The array
- * @returns First element or undefined
- */
-const first = (xs, ...args) => xs[0];
-exports.first = first;
-/**
- * Returns the first element of the first array in a nested array
- * @param xs - Array of arrays
- * @returns First element of first array or undefined
- */
-const ffirst = (xs, ...args) => xs[0][0];
-exports.ffirst = ffirst;
-/**
- * Returns the last element of an array
- * @param xs - The array
- * @returns Last element or undefined
- */
-const last = (xs, ...args) => xs[xs.length - 1];
-exports.last = last;
-/**
- * Returns the input value unchanged
- * @param x - Any value
- * @returns The same value
- */
-const identity = (x, ...args) => x;
-exports.identity = identity;
-/**
- * Creates a function that always returns the same value
- * @param x - Value to return
- * @returns Function that returns x
- */
-const always = (x, ...args) => () => x;
-exports.always = always;
-/**
- * Returns the logical NOT of a value
- * @param x - Value to negate
- * @returns !x
- */
-const not = (x, ...args) => !x;
-exports.not = not;
-/** Returns a function that returns the boolean negation of the given function */
-const complement = (f) => (...args) => !f(...args);
-exports.complement = complement;
-/** Converts a Maybe<number> to a number, defaulting to 0 */
-const num = (x) => x || 0;
-exports.num = num;
-/** Adds two numbers, handling undefined values */
-const add = (x, y) => (0, exports.num)(x) + (0, exports.num)(y);
-exports.add = add;
-/** Subtracts two numbers, handling undefined values */
-const sub = (x, y) => (0, exports.num)(x) - (0, exports.num)(y);
-exports.sub = sub;
-/** Multiplies two numbers, handling undefined values */
-const mul = (x, y) => (0, exports.num)(x) * (0, exports.num)(y);
-exports.mul = mul;
-/** Divides two numbers, handling undefined values */
-const div = (x, y) => (0, exports.num)(x) / y;
-exports.div = div;
-/** Increments a number by 1, handling undefined values */
-const inc = (x) => (0, exports.add)(x, 1);
-exports.inc = inc;
-/** Decrements a number by 1, handling undefined values */
-const dec = (x) => (0, exports.sub)(x, 1);
-exports.dec = dec;
-/** Less than comparison, handling undefined values */
-const lt = (x, y) => (0, exports.num)(x) < (0, exports.num)(y);
-exports.lt = lt;
-/** Less than or equal comparison, handling undefined values */
-const lte = (x, y) => (0, exports.num)(x) <= (0, exports.num)(y);
-exports.lte = lte;
-/** Greater than comparison, handling undefined values */
-const gt = (x, y) => (0, exports.num)(x) > (0, exports.num)(y);
-exports.gt = gt;
-/** Greater than or equal comparison, handling undefined values */
-const gte = (x, y) => (0, exports.num)(x) >= (0, exports.num)(y);
-exports.gte = gte;
-/** Returns maximum value in array, handling undefined values */
-const max = (xs) => xs.reduce((a, b) => Math.max((0, exports.num)(a), (0, exports.num)(b)), 0);
-exports.max = max;
-/** Returns minimum value in array, handling undefined values */
-const min = (xs) => xs.reduce((a, b) => Math.min((0, exports.num)(a), (0, exports.num)(b)), 0);
-exports.min = min;
-/** Returns sum of array values, handling undefined values */
-const sum = (xs) => xs.reduce((a, b) => (0, exports.add)(a, b), 0);
-exports.sum = sum;
-/** Returns average of array values, handling undefined values */
-const avg = (xs) => (0, exports.sum)(xs) / xs.length;
-exports.avg = avg;
-/**
- * Returns array with first n elements removed
- * @param n - Number of elements to drop
- * @param xs - Input array
- * @returns Array with first n elements removed
- */
-const drop = (n, xs) => xs.slice(n);
-exports.drop = drop;
-/**
- * Returns first n elements of array
- * @param n - Number of elements to take
- * @param xs - Input array
- * @returns Array of first n elements
- */
-const take = (n, xs) => xs.slice(0, n);
-exports.take = take;
-/**
- * Creates new object with specified keys removed
- * @param ks - Keys to remove
- * @param x - Source object
- * @returns New object without specified keys
- */
-const omit = (ks, x) => {
-    const r = { ...x };
-    for (const k of ks) {
-        delete r[k];
-    }
-    return r;
-};
-exports.omit = omit;
-/**
- * Creates new object excluding entries with specified values
- * @param xs - Values to exclude
- * @param x - Source object
- * @returns New object without entries containing specified values
- */
-const omitVals = (xs, x) => {
-    const r = {};
-    for (const [k, v] of Object.entries(x)) {
-        if (!xs.includes(v)) {
-            r[k] = v;
-        }
-    }
-    return r;
-};
-exports.omitVals = omitVals;
-/**
- * Creates new object with only specified keys
- * @param ks - Keys to keep
- * @param x - Source object
- * @returns New object with only specified keys
- */
-const pick = (ks, x) => {
-    const r = { ...x };
-    for (const k of Object.keys(x)) {
-        if (!ks.includes(k)) {
-            delete r[k];
-        }
-    }
-    return r;
-};
-exports.pick = pick;
-/**
- * Generates sequence of numbers from a to b
- * @param a - Start number (inclusive)
- * @param b - End number (exclusive)
- * @param step - Increment between numbers
- * @yields Numbers in sequence
- */
-function* range(a, b, step = 1) {
-    for (let i = a; i < b; i += step) {
-        yield i;
-    }
-}
-exports.range = range;
-/**
- * Creates new object with transformed keys
- * @param f - Function to transform keys
- * @param x - Source object
- * @returns Object with transformed keys
- */
-const mapKeys = (f, x) => {
-    const r = {};
-    for (const [k, v] of Object.entries(x)) {
-        r[f(k)] = v;
-    }
-    return r;
-};
-exports.mapKeys = mapKeys;
-/**
- * Creates new object with transformed values
- * @param f - Function to transform values
- * @param x - Source object
- * @returns Object with transformed values
- */
-const mapVals = (f, x) => {
-    const r = {};
-    for (const [k, v] of Object.entries(x)) {
-        r[k] = f(v);
-    }
-    return r;
-};
-exports.mapVals = mapVals;
-/**
- * Merges two objects, with left object taking precedence
- * @param a - Left object
- * @param b - Right object
- * @returns Merged object with a's properties overriding b's
- */
-const mergeLeft = (a, b) => ({ ...b, ...a });
-exports.mergeLeft = mergeLeft;
-/**
- * Merges two objects, with right object taking precedence
- * @param a - Left object
- * @param b - Right object
- * @returns Merged object with b's properties overriding a's
- */
-const mergeRight = (a, b) => ({ ...a, ...b });
-exports.mergeRight = mergeRight;
-/**
- * Checks if a number is between two values (exclusive)
- * @param bounds - Lower and upper bounds
- * @param n - Number to check
- * @returns True if n is between low and high
- */
-const between = ([low, high], n) => n > low && n < high;
-exports.between = between;
-/**
- * Checks if a number is between two values (inclusive)
- * @param bounds - Lower and upper bounds
- * @param n - Number to check
- * @returns True if n is between low and high
- */
-const within = ([low, high], n) => n >= low && n <= high;
-exports.within = within;
-/**
- * Generates random integer between min and max (inclusive)
- * @param min - Minimum value
- * @param max - Maximum value
- * @returns Random integer
- */
-const randomInt = (min = 0, max = 9) => min + Math.round(Math.random() * (max - min));
-exports.randomInt = randomInt;
-/**
- * Generates random string ID
- * @returns Random string suitable for use as an ID
- */
-const randomId = () => Math.random().toString().slice(2);
-exports.randomId = randomId;
-/**
- * Removes protocol (http://, https://, etc) from URL
- * @param url - URL to process
- * @returns URL without protocol
- */
-const stripProtocol = (url) => url.replace(/.*:\/\//, "");
-exports.stripProtocol = stripProtocol;
-/**
- * Formats URL for display by removing protocol, www, and trailing slash
- * @param url - URL to format
- * @returns Formatted URL
- */
-const displayUrl = (url) => (0, exports.stripProtocol)(url).replace(/^(www\.)?/i, "").replace(/\/$/, "");
-exports.displayUrl = displayUrl;
-/**
- * Extracts and formats domain from URL
- * @param url - URL to process
- * @returns Formatted domain name
- */
-const displayDomain = (url) => (0, exports.displayUrl)((0, exports.first)(url.split(/[\/\?]/)));
-exports.displayDomain = displayDomain;
-/**
- * Creates a promise that resolves after specified time
- * @param t - Time in milliseconds
- * @returns Promise that resolves after t milliseconds
- */
-const sleep = (t) => new Promise(resolve => setTimeout(resolve, t));
-exports.sleep = sleep;
-/**
- * Concatenates multiple arrays, filtering out null/undefined
- * @param xs - Arrays to concatenate
- * @returns Combined array
- */
-const concat = (...xs) => xs.flatMap(x => (0, exports.isNil)(x) ? [] : x);
-exports.concat = concat;
-/**
- * Appends element to array
- * @param x - Element to append
- * @param xs - Array to append to
- * @returns New array with element appended
- */
-const append = (x, xs) => (0, exports.concat)(xs, [x]);
-exports.append = append;
-/**
- * Creates union of two arrays
- * @param a - First array
- * @param b - Second array
- * @returns Array containing unique elements from both arrays
- */
-const union = (a, b) => (0, exports.uniq)([...a, ...b]);
-exports.union = union;
-/**
- * Returns elements common to both arrays
- * @param a - First array
- * @param b - Second array
- * @returns Array of elements present in both inputs
- */
-const intersection = (a, b) => {
-    const s = new Set(b);
-    return a.filter(x => s.has(x));
-};
-exports.intersection = intersection;
-/**
- * Returns elements in first array not present in second
- * @param a - Source array
- * @param b - Array of elements to exclude
- * @returns Array containing elements unique to first array
- */
-const difference = (a, b) => {
-    const s = new Set(b);
-    return a.filter(x => !s.has(x));
-};
-exports.difference = difference;
-/**
- * Removes all instances of an element from array
- * @param a - Element to remove
- * @param xs - Source array
- * @returns New array with element removed
- */
-const remove = (a, xs) => xs.filter(x => x !== a);
-exports.remove = remove;
-/**
- * Returns elements from second array not present in first
- * @param a - Array of elements to exclude
- * @param b - Source array
- * @returns Filtered array
- */
-const without = (a, b) => b.filter(x => !a.includes(x));
-exports.without = without;
-/**
- * Toggles presence of element in array
- * @param x - Element to toggle
- * @param xs - Source array
- * @returns New array with element added or removed
- */
-const toggle = (x, xs) => xs.includes(x) ? (0, exports.remove)(x, xs) : (0, exports.append)(x, xs);
-exports.toggle = toggle;
-/**
- * Constrains number between min and max values
- * @param bounds - Minimum and maximum allowed values
- * @param n - Number to clamp
- * @returns Clamped value
- */
-const clamp = ([min, max], n) => Math.min(max, Math.max(min, n));
-exports.clamp = clamp;
-/**
- * Safely parses JSON string
- * @param json - JSON string to parse
- * @returns Parsed object or null if invalid
- */
-const parseJson = (json) => {
-    if (!json)
-        return undefined;
-    try {
-        return JSON.parse(json);
-    }
-    catch (e) {
-        return undefined;
-    }
-};
-exports.parseJson = parseJson;
-/**
- * Gets and parses JSON from localStorage
- * @param k - Storage key
- * @returns Parsed value or undefined if invalid/missing
- */
-const getJson = (k) => (0, exports.parseJson)(localStorage.getItem(k) || "");
-exports.getJson = getJson;
-/**
- * Stringifies and stores value in localStorage
- * @param k - Storage key
- * @param v - Value to store
- */
-const setJson = (k, v) => localStorage.setItem(k, JSON.stringify(v));
-exports.setJson = setJson;
-/**
- * Safely executes function and handles errors
- * @param f - Function to execute
- * @param onError - Optional error handler
- * @returns Function result or undefined if error
- */
-const tryCatch = (f, onError) => {
-    try {
-        const r = f();
-        if (r instanceof Promise) {
-            r.catch(e => onError === null || onError === void 0 ? void 0 : onError(e));
-        }
-        return r;
-    }
-    catch (e) {
-        onError === null || onError === void 0 ? void 0 : onError(e);
-    }
-    return undefined;
-};
-exports.tryCatch = tryCatch;
-/**
- * Truncates string to length, breaking at word boundaries
- * @param s - String to truncate
- * @param l - Maximum length
- * @param suffix - String to append if truncated
- * @returns Truncated string
- */
-const ellipsize = (s, l, suffix = '...') => {
-    if (s.length < l * 1.1) {
-        return s;
-    }
-    while (s.length > l && s.includes(' ')) {
-        s = s.split(' ').slice(0, -1).join(' ');
-    }
-    return s + suffix;
-};
-exports.ellipsize = ellipsize;
-/**
- * Checks if value is a plain object
- * @param obj - Value to check
- * @returns True if value is a plain object
- */
-const isPojo = (obj) => {
-    if (obj === null || typeof obj !== "object") {
-        return false;
-    }
-    return Object.getPrototypeOf(obj) === Object.prototype;
-};
-exports.isPojo = isPojo;
-/**
- * Deep equality comparison
- * @param a - First value
- * @param b - Second value
- * @returns True if values are deeply equal
- */
-const equals = (a, b) => {
-    if (a === b)
-        return true;
-    if (a instanceof Set && b instanceof Set) {
-        a = Array.from(a);
-        b = Array.from(b);
-    }
-    if (a instanceof Set) {
-        if (!(b instanceof Set) || a.size !== b.size) {
-            return false;
-        }
-        return Array.from(a).every(x => b.has(x));
-    }
-    if (Array.isArray(a)) {
-        if (!Array.isArray(b) || a.length !== b.length) {
-            return false;
-        }
-        for (let i = 0; i < a.length; i++) {
-            if (!(0, exports.equals)(a[i], b[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    if ((0, exports.isPojo)(a)) {
-        if (!(0, exports.isPojo)(b)) {
-            return false;
-        }
-        const aKeys = Object.keys(a);
-        const bKeys = Object.keys(b);
-        if (aKeys.length !== bKeys.length) {
-            return false;
-        }
-        for (const k of aKeys) {
-            if (!(0, exports.equals)(a[k], b[k])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    return false;
-};
-exports.equals = equals;
-// Curried utils
-/** Returns a function that gets the nth element of an array */
-const nth = (i) => (xs, ...args) => xs[i];
-exports.nth = nth;
-/** Returns a function that checks if nth element equals value */
-const nthEq = (i, v) => (xs, ...args) => xs[i] === v;
-exports.nthEq = nthEq;
-/** Returns a function that checks if nth element does not equal value */
-const nthNe = (i, v) => (xs, ...args) => xs[i] !== v;
-exports.nthNe = nthNe;
-/** Returns a function that checks if key/value pairs of x match all pairs in spec */
-const spec = (values) => (x) => {
-    for (const [k, v] of Object.entries(values)) {
-        if (x[k] !== v)
-            return false;
-    }
-    return true;
-};
-exports.spec = spec;
-/** Returns a function that checks equality with value */
-const eq = (v) => (x) => x === v;
-exports.eq = eq;
-/** Returns a function that checks inequality with value */
-const ne = (v) => (x) => x !== v;
-exports.ne = ne;
-/** Returns a function that gets property value from object */
-const prop = (k) => (x) => x[k];
-exports.prop = prop;
-/** Returns a function that adds/updates property on object */
-const assoc = (k, v) => (o) => ({ ...o, [k]: v });
-exports.assoc = assoc;
-/** Generates a hash string from input string */
-const hash = (s) => Math.abs(s.split("").reduce((a, b) => ((a << 5) - a + b.charCodeAt(0)) | 0, 0)).toString();
-exports.hash = hash;
-// Collections
-/** Splits array into two parts at index */
-const splitAt = (n, xs) => [xs.slice(0, n), xs.slice(n)];
-exports.splitAt = splitAt;
-/** Inserts element into array at index */
-const insert = (n, x, xs) => [...xs.slice(0, n), x, ...xs.slice(n)];
-exports.insert = insert;
-/** Returns random element from array */
-const choice = (xs) => xs[Math.floor(xs.length * Math.random())];
-exports.choice = choice;
-/** Returns shuffled copy of iterable */
-const shuffle = (xs) => Array.from(xs).sort(() => Math.random() > 0.5 ? 1 : -1);
-exports.shuffle = shuffle;
-/** Returns n random elements from array */
-const sample = (n, xs) => (0, exports.shuffle)(xs).slice(0, n);
-exports.sample = sample;
-/** Checks if value is iterable */
-const isIterable = (x) => Symbol.iterator in Object(x);
-exports.isIterable = isIterable;
-/** Ensures value is iterable by wrapping in array if needed */
-const toIterable = (x) => (0, exports.isIterable)(x) ? x : [x];
-exports.toIterable = toIterable;
-/** Ensures value is array by wrapping if needed */
-const ensurePlural = (x) => (x instanceof Array ? x : [x]);
-exports.ensurePlural = ensurePlural;
-/** Converts string or number to number */
-const ensureNumber = (x) => parseFloat(x);
-exports.ensureNumber = ensureNumber;
-/** Returns a function that gets property value from object */
-const pluck = (k, xs) => xs.map(x => x[k]);
-exports.pluck = pluck;
-/**
- * Creates object from array of key-value pairs
- * @param pairs - Array of [key, value] tuples
- * @returns Object with keys and values from pairs
- */
-const fromPairs = (pairs) => {
-    const r = {};
-    for (const [k, v] of pairs) {
-        if (k && v) {
-            r[k] = v;
-        }
-    }
-    return r;
-};
-exports.fromPairs = fromPairs;
-/**
- * Flattens array of arrays into single array
- * @param xs - Array of arrays to flatten
- * @returns Flattened array
- */
-const flatten = (xs) => xs.flatMap(exports.identity);
-exports.flatten = flatten;
-/**
- * Splits array into two arrays based on predicate
- * @param f - Function to test elements
- * @param xs - Array to partition
- * @returns Tuple of [matching, non-matching] arrays
- */
-const partition = (f, xs) => {
-    const a = [];
-    const b = [];
-    for (const x of xs) {
-        if (f(x)) {
-            a.push(x);
-        }
-        else {
-            b.push(x);
-        }
-    }
-    return [a, b];
-};
-exports.partition = partition;
-/**
- * Returns array with duplicate elements removed
- * @param xs - Array with possible duplicates
- * @returns Array with unique elements
- */
-const uniq = (xs) => Array.from(new Set(xs));
-exports.uniq = uniq;
-/**
- * Returns array with elements unique by key function
- * @param f - Function to generate key for each element
- * @param xs - Input array
- * @returns Array with elements unique by key
- */
-const uniqBy = (f, xs) => {
-    const s = new Set();
-    const r = [];
-    for (const x of xs) {
-        const k = f(x);
-        if (s.has(k)) {
-            continue;
-        }
-        s.add(k);
-        r.push(x);
-    }
-    return r;
-};
-exports.uniqBy = uniqBy;
-/**
- * Returns sorted copy of array
- * @param xs - Array to sort
- * @returns New sorted array
- */
-const sort = (xs) => [...xs].sort();
-exports.sort = sort;
-/**
- * Returns array sorted by key function
- * @param f - Function to generate sort key
- * @param xs - Array to sort
- * @returns Sorted array
- */
-const sortBy = (f, xs) => [...xs].sort((a, b) => {
-    const x = f(a);
-    const y = f(b);
-    return x < y ? -1 : x > y ? 1 : 0;
-});
-exports.sortBy = sortBy;
-/**
- * Groups array elements by key function
- * @param f - Function to generate group key
- * @param xs - Array to group
- * @returns Map of groups
- */
-const groupBy = (f, xs) => {
-    const r = new Map();
-    for (const x of xs) {
-        const k = f(x);
-        let v = r.get(k);
-        if (!v) {
-            v = [];
-            r.set(k, v);
-        }
-        v.push(x);
-    }
-    return r;
-};
-exports.groupBy = groupBy;
-/**
- * Creates map from array using key function
- * @param f - Function to generate key
- * @param xs - Array to index
- * @returns Map of values by key
- */
-const indexBy = (f, xs) => {
-    const r = new Map();
-    for (const x of xs) {
-        r.set(f(x), x);
-    }
-    return r;
-};
-exports.indexBy = indexBy;
-/**
- * Creates array of specified length using generator function
- * @param n - Length of array
- * @param f - Function to generate each element
- * @returns Generated array
- */
-const initArray = (n, f) => {
-    const result = [];
-    for (let i = 0; i < n; i++) {
-        result.push(f());
-    }
-    return result;
-};
-exports.initArray = initArray;
-/**
- * Splits array into chunks of specified length
- * @param chunkLength - Maximum length of each chunk
- * @param xs - Array to split
- * @returns Array of chunks
- */
-const chunk = (chunkLength, xs) => {
-    const result = [];
-    const current = [];
-    for (const item of xs) {
-        if (current.length < chunkLength) {
-            current.push(item);
-        }
-        else {
-            result.push(current.splice(0));
-        }
-    }
-    if (current.length > 0) {
-        result.push(current);
-    }
-    return result;
-};
-exports.chunk = chunk;
-/**
- * Splits array into specified number of chunks
- * @param n - Number of chunks
- * @param xs - Array to split
- * @returns Array of n chunks
- */
-const chunks = (n, xs) => {
-    const result = (0, exports.initArray)(n, () => []);
-    for (let i = 0; i < xs.length; i++) {
-        result[i % n].push(xs[i]);
-    }
-    return result;
-};
-exports.chunks = chunks;
-/**
- * Creates function that only executes once
- * @param f - Function to wrap
- * @returns Function that executes f only on first call
- */
-const once = (f) => {
-    let called = false;
-    return (...args) => {
-        if (!called) {
-            called = true;
-            f(...args);
-        }
-    };
-};
-exports.once = once;
-/**
- * Memoizes function results based on arguments
- * @param f - Function to memoize
- * @returns Memoized function
- */
-const memoize = (f) => {
-    let prevArgs;
-    let result;
-    return (...args) => {
-        if (!(0, exports.equals)(prevArgs, args)) {
-            prevArgs = args;
-            result = f(...args);
-        }
-        return result;
-    };
-};
-exports.memoize = memoize;
-/**
- * Creates throttled version of function
- * @param ms - Minimum time between calls
- * @param f - Function to throttle
- * @returns Throttled function
- */
-const throttle = (ms, f) => {
-    if (ms === 0) {
-        return f;
-    }
-    let paused = false;
-    let nextArgs;
-    const unpause = () => {
-        if (nextArgs) {
-            f(...nextArgs);
-            nextArgs = undefined;
-        }
-        paused = false;
-    };
-    return (...thisArgs) => {
-        if (!paused) {
-            f(...thisArgs);
-            paused = true;
-            setTimeout(unpause, ms);
-        }
-        else {
-            nextArgs = thisArgs;
-        }
-    };
-};
-exports.throttle = throttle;
-/**
- * Creates throttled function that returns cached value
- * @param ms - Minimum time between updates
- * @param f - Function to throttle
- * @returns Function returning latest value
- */
-const throttleWithValue = (ms, f) => {
-    let value;
-    const update = (0, exports.throttle)(ms, () => {
-        value = f();
-    });
-    return () => {
-        update();
-        return value;
-    };
-};
-exports.throttleWithValue = throttleWithValue;
-/**
- * Creates batching function that collects items
- * @param t - Time window for batching
- * @param f - Function to process batch
- * @returns Function that adds items to batch
- */
-const batch = (t, f) => {
-    const xs = [];
-    const cb = (0, exports.throttle)(t, () => xs.length > 0 && f(xs.splice(0)));
-    return (x) => {
-        xs.push(x);
-        cb();
-    };
-};
-exports.batch = batch;
-/**
- * Creates batching function that returns results
- * @param t - Time window for batching
- * @param execute - Function to process batch
- * @returns Function that returns promise of result
- */
-const batcher = (t, execute) => {
-    const queue = [];
-    const _execute = async () => {
-        const items = queue.splice(0);
-        const results = await execute(items.map(item => item.request));
-        if (results.length !== items.length) {
-            throw new Error("Execute must return a result for each request");
-        }
-        results.forEach(async (r, i) => items[i].resolve(await r));
-    };
-    return (request) => new Promise(resolve => {
-        if (queue.length === 0) {
-            setTimeout(_execute, t);
-        }
-        queue.push({ request, resolve });
-    });
-};
-exports.batcher = batcher;
-/**
- * Adds value to Set at key in object
- * @param m - Object mapping keys to Sets
- * @param k - Key to add to
- * @param v - Value to add
- */
-const addToKey = (m, k, v) => {
-    const s = m[k] || new Set();
-    s.add(v);
-    m[k] = s;
-};
-exports.addToKey = addToKey;
-/**
- * Pushes value to array at key in object
- * @param m - Object mapping keys to arrays
- * @param k - Key to push to
- * @param v - Value to push
- */
-const pushToKey = (m, k, v) => {
-    const a = m[k] || [];
-    a.push(v);
-    m[k] = a;
-};
-exports.pushToKey = pushToKey;
-/**
- * Adds value to Set at key in Map
- * @param m - Map of Sets
- * @param k - Key to add to
- * @param v - Value to add
- */
-const addToMapKey = (m, k, v) => {
-    const s = m.get(k) || new Set();
-    s.add(v);
-    m.set(k, s);
-};
-exports.addToMapKey = addToMapKey;
-/**
- * Pushes value to array at key in Map
- * @param m - Map of arrays
- * @param k - Key to push to
- * @param v - Value to push
- */
-const pushToMapKey = (m, k, v) => {
-    const a = m.get(k) || [];
-    a.push(v);
-    m.set(k, a);
-};
-exports.pushToMapKey = pushToMapKey;
-/**
- * Switches on key in object, with default fallback
- * @param k - Key to look up
- * @param m - Object with values and optional default
- * @returns Value at key or default value
- */
-const switcher = (k, m) => m[k] === undefined ? m.default : m[k];
-exports.switcher = switcher;
-/** One minute in seconds */
-exports.MINUTE = 60;
-/** One hour in seconds */
-exports.HOUR = 60 * exports.MINUTE;
-/** One day in seconds */
-exports.DAY = 24 * exports.HOUR;
-/** One week in seconds */
-exports.WEEK = 7 * exports.DAY;
-/** One month in seconds (approximate) */
-exports.MONTH = 30 * exports.DAY;
-/** One quarter in seconds (approximate) */
-exports.QUARTER = 90 * exports.DAY;
-/** One year in seconds (approximate) */
-exports.YEAR = 365 * exports.DAY;
-/**
- * Multiplies time unit by count
- * @param unit - Time unit in seconds
- * @param count - Number of units
- * @returns Total seconds
- */
-const int = (unit, count = 1) => unit * count;
-exports.int = int;
-/** Returns current Unix timestamp in seconds */
-const now = () => Math.round(Date.now() / 1000);
-exports.now = now;
-/**
- * Returns Unix timestamp from specified time ago
- * @param unit - Time unit in seconds
- * @param count - Number of units
- * @returns Timestamp in seconds
- */
-const ago = (unit, count = 1) => (0, exports.now)() - (0, exports.int)(unit, count);
-exports.ago = ago;
-/**
- * Converts seconds to milliseconds
- * @param seconds - Time in seconds
- * @returns Time in milliseconds
- */
-const ms = (seconds) => seconds * 1000;
-exports.ms = ms;
-/**
- * Fetches JSON from URL with options
- * @param url - URL to fetch from
- * @param opts - Fetch options
- * @returns Promise of parsed JSON response
- */
-const fetchJson = async (url, opts = {}) => {
-    if (!opts.headers) {
-        opts.headers = {};
-    }
-    opts.headers["Accept"] = "application/json";
-    const res = await fetch(url, opts);
-    const json = await res.json();
-    return json;
-};
-exports.fetchJson = fetchJson;
-/**
- * Posts JSON data to URL
- * @param url - URL to post to
- * @param data - Data to send
- * @param opts - Additional fetch options
- * @returns Promise of parsed JSON response
- */
-const postJson = async (url, data, opts = {}) => {
-    if (!opts.method) {
-        opts.method = "POST";
-    }
-    if (!opts.headers) {
-        opts.headers = {};
-    }
-    opts.headers["Content-Type"] = "application/json";
-    opts.body = JSON.stringify(data);
-    return (0, exports.fetchJson)(url, opts);
-};
-exports.postJson = postJson;
-/**
- * Uploads file to URL
- * @param url - Upload URL
- * @param file - File to upload
- * @returns Promise of parsed JSON response
- */
-const uploadFile = (url, file) => {
-    const body = new FormData();
-    body.append("file", file);
-    return (0, exports.fetchJson)(url, { method: "POST", body });
-};
-exports.uploadFile = uploadFile;
-/**
- * Converts hex string to bech32 format
- * @param prefix - Bech32 prefix
- * @param hex - Hex string to convert
- * @returns Bech32 encoded string
- */
-const hexToBech32 = (prefix, hex) => base_1.bech32.encode(prefix, base_1.bech32.toWords(base_1.utf8.decode(hex)), false);
-exports.hexToBech32 = hexToBech32;
-/**
- * Converts bech32 string to hex format
- * @param b32 - Bech32 string to convert
- * @returns Hex encoded string
- */
-const bech32ToHex = (b32) => base_1.utf8.encode(base_1.bech32.fromWords(base_1.bech32.decode(b32, false).words));
-exports.bech32ToHex = bech32ToHex;
-//# sourceMappingURL=Tools.cjs.map