@welshman/lib 0.1.1 → 0.2.0

package/{build/src → dist}/Tools.js

@@ -1,33 +1,12 @@
 import { bech32, utf8 } from "@scure/base";
-/** Checks if a value is null or undefined */
-export const isNil = (x) => [null, undefined].includes(x);
-/**
- * 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
- */
-export const ifLet = (x, f) => x === undefined ? undefined : f(x);
+export const isNil = (x, ...args) => x === undefined || x === null;
+export const isNotNil = (x, ...args) => x !== undefined && x !== null;
+export const assertNotNil = (x, ...args) => x;
+// ----------------------------------------------------------------------------
+// Basic functional programming utilities
+// ----------------------------------------------------------------------------
 /** Function that does nothing and returns undefined */
 export const noop = (...args) => undefined;
-/**
- * Returns the first element of an array
- * @param xs - The array
- * @returns First element or undefined
- */
-export const first = (xs, ...args) => xs[0];
-/**
- * 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
- */
-export const ffirst = (xs, ...args) => xs[0][0];
-/**
- * Returns the last element of an array
- * @param xs - The array
- * @returns Last element or undefined
- */
-export const last = (xs, ...args) => xs[xs.length - 1];
 /**
  * Returns the input value unchanged
  * @param x - Any value
@@ -46,9 +25,60 @@ export const always = (x, ...args) => () => x;
  * @returns !x
  */
 export const not = (x, ...args) => !x;
-/** Returns a function that returns the boolean negation of the given function */
-export const complement = (f) => (...args) => !f(...args);
-/** Converts a `Maybe<number>` to a number, defaulting to 0 */
+/**
+ * Deep equality comparison
+ * @param a - First value
+ * @param b - Second value
+ * @returns True if values are deeply equal
+ */
+export 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 (!equals(a[i], b[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    if (isPojo(a)) {
+        if (!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 (!equals(a[k], b[k])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+};
+// ----------------------------------------------------------------------------
+// Numbers
+// ----------------------------------------------------------------------------
+/** Converts string or number to number */
+export const ensureNumber = (x) => parseFloat(x);
+/** Converts a `number | undefined` to a number, defaulting to 0 */
 export const num = (x) => x || 0;
 /** Adds two numbers, handling undefined values */
 export const add = (x, y) => num(x) + num(y);
@@ -74,7 +104,7 @@ export const gte = (x, y) => num(x) >= num(y);
 export const max = (xs) => xs.reduce((a, b) => Math.max(num(a), num(b)), 0);
 /** Returns minimum value in array, handling undefined values */
 export const min = (xs) => {
-    const [head, ...tail] = xs.filter(x => !isNil(x));
+    const [head, ...tail] = xs.filter(x => x !== undefined);
     if (tail.length === 0)
         return head || 0;
     return tail.reduce((a, b) => Math.min(a, b), head);
@@ -84,217 +114,211 @@ export const sum = (xs) => xs.reduce((a, b) => add(a, b), 0);
 /** Returns average of array values, handling undefined values */
 export const avg = (xs) => sum(xs) / xs.length;
 /**
- * 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
+ * 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
  */
-export const drop = (n, xs) => xs.slice(n);
+export const between = ([low, high], n) => n > low && n < high;
 /**
- * Returns first n elements of array
- * @param n - Number of elements to take
- * @param xs - Input array
- * @returns Array of first n elements
+ * 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
  */
-export const take = (n, xs) => xs.slice(0, n);
+export const within = ([low, high], n) => n >= low && n <= high;
 /**
- * Creates new object with specified keys removed
- * @param ks - Keys to remove
- * @param x - Source object
- * @returns New object without specified keys
+ * Constrains number between min and max values
+ * @param bounds - Minimum and maximum allowed values
+ * @param n - Number to clamp
+ * @returns Clamped value
  */
-export const omit = (ks, x) => {
-    const r = { ...x };
-    for (const k of ks) {
-        delete r[k];
-    }
-    return r;
-};
+export const clamp = ([min, max], n) => Math.min(max, Math.max(min, n));
 /**
- * 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
+ * Round a number to the nearest float precision
+ * @param precision - Number of decimal places
+ * @param x - Number to round
+ * @returns Formatted number
  */
-export const omitVals = (xs, x) => {
-    const r = {};
-    for (const [k, v] of Object.entries(x)) {
-        if (!xs.includes(v)) {
-            r[k] = v;
-        }
-    }
-    return r;
-};
+export const round = (precision, x) => Math.round(x * Math.pow(10, precision)) / Math.pow(10, precision);
+// ----------------------------------------------------------------------------
+// Timestamps
+// ----------------------------------------------------------------------------
+/** One minute in seconds */
+export const MINUTE = 60;
+/** One hour in seconds */
+export const HOUR = 60 * MINUTE;
+/** One day in seconds */
+export const DAY = 24 * HOUR;
+/** One week in seconds */
+export const WEEK = 7 * DAY;
+/** One month in seconds (approximate) */
+export const MONTH = 30 * DAY;
+/** One quarter in seconds (approximate) */
+export const QUARTER = 90 * DAY;
+/** One year in seconds (approximate) */
+export const YEAR = 365 * DAY;
+/** User's default locale */
+export const LOCALE = new Intl.DateTimeFormat().resolvedOptions().locale;
+/** User's default timezone */
+export const TIMEZONE = new Date().toString().match(/GMT[^\s]+/)[0];
 /**
- * Creates new object with only specified keys
- * @param ks - Keys to keep
- * @param x - Source object
- * @returns New object with only specified keys
+ * Multiplies time unit by count
+ * @param unit - Time unit in seconds
+ * @param count - Number of units
+ * @returns Total seconds
  */
-export const pick = (ks, x) => {
-    const r = { ...x };
-    for (const k of Object.keys(x)) {
-        if (!ks.includes(k)) {
-            delete r[k];
-        }
-    }
-    return r;
-};
+export const int = (unit, count = 1) => unit * count;
+/** Returns current Unix timestamp in seconds */
+export const now = () => Math.round(Date.now() / 1000);
 /**
- * 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
+ * Returns Unix timestamp from specified time ago
+ * @param unit - Time unit in seconds
+ * @param count - Number of units
+ * @returns Timestamp in seconds
  */
-export function* range(a, b, step = 1) {
-    for (let i = a; i < b; i += step) {
-        yield i;
-    }
-}
+export const ago = (unit, count = 1) => now() - int(unit, count);
 /**
- * Yields indexed items
- * @param items - A collection of items
- * @yields tuples of [index, item]
+ * Converts seconds to milliseconds
+ * @param seconds - Time in seconds
+ * @returns Time in milliseconds
  */
-export function* enumerate(items) {
-    for (let i = 0; i < items.length; i += 1) {
-        yield [i, items[i]];
-    }
-}
+export const ms = (seconds) => seconds * 1000;
 /**
- * Creates new object with transformed keys
- * @param f - Function to transform keys
- * @param x - Source object
- * @returns Object with transformed keys
+ * Converts seconds to date
+ * @param seconds - Time in seconds
+ * @returns Date object
  */
-export const mapKeys = (f, x) => {
-    const r = {};
-    for (const [k, v] of Object.entries(x)) {
-        r[f(k)] = v;
-    }
-    return r;
-};
+export const secondsToDate = (seconds) => new Date(seconds * 1000);
 /**
- * Creates new object with transformed values
- * @param f - Function to transform values
- * @param x - Source object
- * @returns Object with transformed values
+ * Converts date object to seconds
+ * @param date - Date object
+ * @returns timestamp in seconds
  */
-export const mapVals = (f, x) => {
-    const r = {};
-    for (const [k, v] of Object.entries(x)) {
-        r[k] = f(v);
-    }
-    return r;
-};
+export const dateToSeconds = (date) => Math.round(date.valueOf() / 1000);
 /**
- * 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
+ * Creates a local date from a date string
+ * @param dateString - date string
+ * @param timezone - timezone string
+ * @returns timezone-aware Date object
  */
-export const mergeLeft = (a, b) => ({
-    ...b,
-    ...a,
+export const createLocalDate = (dateString, timezone = TIMEZONE) => new Date(`${dateString} ${timezone}`);
+/** Formatter for date+time */
+export const dateTimeFormatter = new Intl.DateTimeFormat(LOCALE, {
+    dateStyle: "short",
+    timeStyle: "short",
 });
 /**
- * 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
+ * Formats seconds as a datetime
+ * @param seconds - timestamp in seconds
+ * @returns datetime string
  */
-export const mergeRight = (a, b) => ({
-    ...a,
-    ...b,
+export const formatTimestamp = (seconds) => dateTimeFormatter.format(secondsToDate(seconds));
+/** Formatter for date */
+export const dateFormatter = new Intl.DateTimeFormat(LOCALE, {
+    year: "numeric",
+    month: "long",
+    day: "numeric",
 });
-/** Deep merge two objects, prioritizing the first argument. */
-export const deepMergeLeft = (a, b) => deepMergeRight(b, a);
-/** Deep merge two objects, prioritizing the second argument. */
-export const deepMergeRight = (a, b) => {
-    a = { ...a };
-    for (const [k, v] of Object.entries(b)) {
-        if (isPojo(v) && isPojo(a[k])) {
-            a[k] = deepMergeRight(a[k], v);
-        }
-        else {
-            a[k] = v;
-        }
-    }
-    return a;
-};
 /**
- * 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
+ * Formats seconds as a date
+ * @param seconds - timestamp in seconds
+ * @returns date string
  */
-export const between = ([low, high], n) => n > low && n < high;
+export const formatTimestampAsDate = (ts) => dateFormatter.format(secondsToDate(ts));
+/** Formatter for time */
+export const timeFormatter = new Intl.DateTimeFormat(LOCALE, {
+    timeStyle: "short",
+});
 /**
- * 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
+ * Formats seconds as a time
+ * @param seconds - timestamp in seconds
+ * @returns time string
  */
-export const within = ([low, high], n) => n >= low && n <= high;
+export const formatTimestampAsTime = (ts) => timeFormatter.format(secondsToDate(ts));
 /**
- * Generates random integer between min and max (inclusive)
- * @param min - Minimum value
- * @param max - Maximum value
- * @returns Random integer
+ * Formats seconds as a relative date (x minutes ago)
+ * @param seconds - timestamp in seconds
+ * @returns relative date string
  */
-export const randomInt = (min = 0, max = 9) => min + Math.round(Math.random() * (max - min));
+export const formatTimestampRelative = (ts) => {
+    let unit;
+    let delta = now() - ts;
+    if (delta < int(MINUTE)) {
+        unit = "second";
+    }
+    else if (delta < int(HOUR)) {
+        unit = "minute";
+        delta = Math.round(delta / int(MINUTE));
+    }
+    else if (delta < int(DAY, 2)) {
+        unit = "hour";
+        delta = Math.round(delta / int(HOUR));
+    }
+    else {
+        unit = "day";
+        delta = Math.round(delta / int(DAY));
+    }
+    const locale = new Intl.RelativeTimeFormat().resolvedOptions().locale;
+    const formatter = new Intl.RelativeTimeFormat(locale, {
+        numeric: "auto",
+    });
+    return formatter.format(-delta, unit);
+};
+// ----------------------------------------------------------------------------
+// Sequences
+// ----------------------------------------------------------------------------
 /**
- * Generates random string ID
- * @returns Random string suitable for use as an ID
+ * Returns the first element of an array
+ * @param xs - The array
+ * @returns First element or undefined
  */
-export const randomId = () => Math.random().toString().slice(2);
+export const first = (xs, ...args) => {
+    for (const x of xs) {
+        return x;
+    }
+};
 /**
- * Removes protocol (http://, https://, etc) from URL
- * @param url - URL to process
- * @returns URL without protocol
+ * 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
  */
-export const stripProtocol = (url) => url.replace(/.*:\/\//, "");
+export const ffirst = (xs, ...args) => {
+    for (const chunk of xs) {
+        for (const x of chunk) {
+            return x;
+        }
+    }
+};
 /**
- * Formats URL for display by removing protocol, www, and trailing slash
- * @param url - URL to format
- * @returns Formatted URL
+ * Returns the last element of an array
+ * @param xs - The array
+ * @returns Last element or undefined
  */
-export const displayUrl = (url) => stripProtocol(url)
-    .replace(/^(www\.)?/i, "")
-    .replace(/\/$/, "");
+export const last = (xs, ...args) => {
+    const a = Array.from(xs);
+    return a[a.length - 1];
+};
 /**
- * Extracts and formats domain from URL
- * @param url - URL to process
- * @returns Formatted domain name
+ * 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
  */
-export const displayDomain = (url) => displayUrl(first(url.split(/[\/\?]/)));
+export const drop = (n, xs) => Array.from(xs).slice(n);
 /**
- * Creates a promise that resolves after specified time
- * @param t - Time in milliseconds
- * @returns Promise that resolves after t milliseconds
+ * Returns first n elements of array
+ * @param n - Number of elements to take
+ * @param xs - Input array
+ * @returns Array of first n elements
  */
-export const sleep = (t) => new Promise(resolve => setTimeout(resolve, t));
-/**
- * Creates a microtask that yields to other tasks in the event loop
- * @returns Promise that resolves after yielding
- */
-export const yieldThread = () => {
-    if (typeof window !== "undefined" &&
-        "scheduler" in window &&
-        "yield" in window.scheduler) {
-        return window.scheduler.yield();
-    }
-    return new Promise(resolve => {
-        setTimeout(resolve, 0);
-    });
-};
+export const take = (n, xs) => Array.from(xs).slice(0, n);
 /**
  * Concatenates multiple arrays, filtering out null/undefined
  * @param xs - Arrays to concatenate
  * @returns Combined array
  */
-export const concat = (...xs) => xs.flatMap(x => (isNil(x) ? [] : x));
+export const concat = (...xs) => xs.flatMap(x => (x === undefined ? [] : x));
 /**
  * Appends element to array
  * @param x - Element to append
@@ -336,6 +360,13 @@ export const difference = (a, b) => {
  * @returns New array with element removed
  */
 export const remove = (a, xs) => xs.filter(x => x !== a);
+/**
+ * Removes element at index
+ * @param i - Index to remove
+ * @param xs - Source array
+ * @returns New array with element removed
+ */
+export const removeAt = (i, xs) => [...xs.slice(0, i), ...xs.slice(i + 1)];
 /**
  * Returns elements from second array not present in first
  * @param a - Array of elements to exclude
@@ -351,195 +382,27 @@ export const without = (a, b) => b.filter(x => !a.includes(x));
  */
 export const toggle = (x, xs) => (xs.includes(x) ? remove(x, xs) : append(x, xs));
 /**
- * Constrains number between min and max values
- * @param bounds - Minimum and maximum allowed values
- * @param n - Number to clamp
- * @returns Clamped value
- */
-export const clamp = ([min, max], n) => Math.min(max, Math.max(min, n));
-/**
- * Round a number to the nearest float precision
- * @param precision - Number of decimal places
- * @param x - Number to round
- * @returns Formatted number
- */
-export const round = (precision, x) => Math.round(x * Math.pow(10, precision)) / Math.pow(10, precision);
-/**
- * Safely parses JSON string
- * @param json - JSON string to parse
- * @returns Parsed object or null if invalid
- */
-export const parseJson = (json) => {
-    if (!json)
-        return undefined;
-    try {
-        return JSON.parse(json);
-    }
-    catch (e) {
-        return undefined;
-    }
-};
-/**
- * Gets and parses JSON from localStorage
- * @param k - Storage key
- * @returns Parsed value or undefined if invalid/missing
- */
-export const getJson = (k) => parseJson(localStorage.getItem(k) || "");
-/**
- * Stringifies and stores value in localStorage
- * @param k - Storage key
- * @param v - Value to store
- */
-export const setJson = (k, v) => localStorage.setItem(k, JSON.stringify(v));
-/**
- * Safely executes function and handles errors
- * @param f - Function to execute
- * @param onError - Optional error handler
- * @returns Function result or undefined if error
- */
-export const tryCatch = (f, onError) => {
-    try {
-        const r = f();
-        if (r instanceof Promise) {
-            r.catch(e => onError?.(e));
-        }
-        return r;
-    }
-    catch (e) {
-        onError?.(e);
-    }
-    return undefined;
-};
-/**
- * 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
- */
-export 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;
-};
-/**
- * Checks if value is a plain object
- * @param obj - Value to check
- * @returns True if value is a plain object
- */
-export const isPojo = (obj) => {
-    if (obj === null || typeof obj !== "object") {
-        return false;
-    }
-    return Object.getPrototypeOf(obj) === Object.prototype;
-};
-/**
- * Deep equality comparison
- * @param a - First value
- * @param b - Second value
- * @returns True if values are deeply equal
- */
-export 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 (!equals(a[i], b[i])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    if (isPojo(a)) {
-        if (!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 (!equals(a[k], b[k])) {
-                return false;
-            }
-        }
-        return true;
-    }
-    return false;
-};
-// Curried utils
-/** Returns a function that gets the nth element of an array */
-export const nth = (i) => (xs, ...args) => xs[i];
-/** Returns a function that checks if nth element equals value */
-export const nthEq = (i, v) => (xs, ...args) => xs[i] === v;
-/** Returns a function that checks if nth element does not equal value */
-export const nthNe = (i, v) => (xs, ...args) => xs[i] !== v;
-/** Returns a function that checks if key/value pairs of x match all pairs in spec */
-export const spec = (values) => (x, ...args) => {
-    if (Array.isArray(values)) {
-        for (let i = 0; i < values.length; i++) {
-            if (x[i] !== values[i]) {
-                return false;
-            }
-        }
-    }
-    else {
-        for (const [k, v] of Object.entries(values)) {
-            if (x[k] !== v)
-                return false;
-        }
-    }
-    return true;
-};
-/** Returns a function that checks equality with value */
-export const eq = (v) => (x) => x === v;
-/** Returns a function that checks inequality with value */
-export const ne = (v) => (x) => x !== v;
-/** Returns a function that gets property value from object */
-export const prop = (k) => (x) => x[k];
-/** Returns a function that adds/updates a property on object */
-export const assoc = (k, v) => (o) => ({ ...o, [k]: v });
-/** Returns a function that removes a property on object */
-export const dissoc = (k) => (o) => omit([k], o);
-/** Generates a hash string from input string */
-export const hash = (s) => Math.abs(s.split("").reduce((a, b) => ((a << 5) - a + b.charCodeAt(0)) | 0, 0)).toString();
-// Collections
-/** Splits array into two parts at index */
-export const splitAt = (n, xs) => [xs.slice(0, n), xs.slice(n)];
-/** Inserts element into array at index */
-export const insert = (n, x, xs) => [...xs.slice(0, n), x, ...xs.slice(n)];
-/** Returns random element from array */
-export const choice = (xs) => xs[Math.floor(xs.length * Math.random())];
-/** Returns shuffled copy of iterable */
-export const shuffle = (xs) => Array.from(xs).sort(() => (Math.random() > 0.5 ? 1 : -1));
-/** Returns n random elements from array */
-export const sample = (n, xs) => shuffle(xs).slice(0, n);
-/** Checks if value is iterable */
-export const isIterable = (x) => Symbol.iterator in Object(x);
-/** Ensures value is iterable by wrapping in array if needed */
-export const toIterable = (x) => (isIterable(x) ? x : [x]);
-/** Ensures value is array by wrapping if needed */
-export const ensurePlural = (x) => (x instanceof Array ? x : [x]);
-/** Converts string or number to number */
-export const ensureNumber = (x) => parseFloat(x);
+ * 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
+ */
+export function* range(a, b, step = 1) {
+    for (let i = a; i < b; i += step) {
+        yield i;
+    }
+}
+/**
+ * Yields indexed items
+ * @param items - A collection of items
+ * @yields tuples of [index, item]
+ */
+export function* enumerate(items) {
+    for (let i = 0; i < items.length; i += 1) {
+        yield [i, items[i]];
+    }
+}
 /** Returns a function that gets property value from object */
 export const pluck = (k, xs) => xs.map(x => x[k]);
 /**
@@ -556,21 +419,6 @@ export const fromPairs = (pairs) => {
     }
     return r;
 };
-/**
- * Filters object values based on predicate
- * @param f - Function to test values
- * @param x - Object to filter
- * @returns Object with only values that pass predicate
- */
-export const filterVals = (f, x) => {
-    const r = {};
-    for (const k in x) {
-        if (f(x[k])) {
-            r[k] = x[k];
-        }
-    }
-    return r;
-};
 /**
  * Flattens array of arrays into single array
  * @param xs - Array of arrays to flatten
@@ -657,6 +505,19 @@ export const groupBy = (f, xs) => {
     }
     return r;
 };
+/**
+ * Counts array elements by key function
+ * @param f - Function to generate group key
+ * @param xs - Array to count entries
+ * @returns Map of counts
+ */
+export const countBy = (f, xs) => {
+    const r = new Map();
+    for (const [k, items] of groupBy(f, xs)) {
+        r.set(k, items.length);
+    }
+    return r;
+};
 /**
  * Creates map from array using key function
  * @param f - Function to generate key
@@ -719,6 +580,190 @@ export const chunks = (n, xs) => {
     }
     return result;
 };
+/** Splits array into two parts at index */
+export const splitAt = (n, xs) => [xs.slice(0, n), xs.slice(n)];
+/** Inserts element into array at index */
+export const insertAt = (n, x, xs) => [...xs.slice(0, n), x, ...xs.slice(n)];
+/** Replaces array element at index */
+export const replaceAt = (n, x, xs) => [...xs.slice(0, n), x, ...xs.slice(n + 1)];
+/** Returns random element from array */
+export const choice = (xs) => xs[Math.floor(xs.length * Math.random())];
+/** Returns shuffled copy of iterable */
+export const shuffle = (xs) => Array.from(xs).sort(() => (Math.random() > 0.5 ? 1 : -1));
+/** Returns n random elements from array */
+export const sample = (n, xs) => shuffle(xs).slice(0, n);
+/** Checks if value is iterable */
+export const isIterable = (x) => Symbol.iterator in Object(x);
+/** Ensures value is iterable by wrapping in array if needed */
+export const toIterable = (x) => (isIterable(x) ? x : [x]);
+/** Ensures value is array by wrapping if needed */
+export const ensurePlural = (x) => (x instanceof Array ? x : [x]);
+/** Ensures values are not undefined */
+export const removeNil = (xs) => xs.filter(isNotNil).map(assertNotNil);
+// ----------------------------------------------------------------------------
+// Objects
+// ----------------------------------------------------------------------------
+/**
+ * Checks if value is a plain object
+ * @param obj - Value to check
+ * @returns True if value is a plain object
+ */
+export const isPojo = (obj) => {
+    if (obj === null || typeof obj !== "object") {
+        return false;
+    }
+    return Object.getPrototypeOf(obj) === Object.prototype;
+};
+/**
+ * Creates new object with only specified keys
+ * @param ks - Keys to keep
+ * @param x - Source object
+ * @returns New object with only specified keys
+ */
+export const pick = (ks, x) => {
+    const r = { ...x };
+    for (const k of Object.keys(x)) {
+        if (!ks.includes(k)) {
+            delete r[k];
+        }
+    }
+    return r;
+};
+/**
+ * Creates new object with specified keys removed
+ * @param ks - Keys to remove
+ * @param x - Source object
+ * @returns New object without specified keys
+ */
+export const omit = (ks, x) => {
+    const r = { ...x };
+    for (const k of ks) {
+        delete r[k];
+    }
+    return r;
+};
+/**
+ * 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
+ */
+export const omitVals = (xs, x) => {
+    const r = {};
+    for (const [k, v] of Object.entries(x)) {
+        if (!xs.includes(v)) {
+            r[k] = v;
+        }
+    }
+    return r;
+};
+/**
+ * Filters object values based on predicate
+ * @param f - Function to test values
+ * @param x - Object to filter
+ * @returns Object with only values that pass predicate
+ */
+export const filterVals = (f, x) => {
+    const r = {};
+    for (const k in x) {
+        if (f(x[k])) {
+            r[k] = x[k];
+        }
+    }
+    return r;
+};
+/**
+ * Creates new object with transformed keys
+ * @param f - Function to transform keys
+ * @param x - Source object
+ * @returns Object with transformed keys
+ */
+export const mapKeys = (f, x) => {
+    const r = {};
+    for (const [k, v] of Object.entries(x)) {
+        r[f(k)] = v;
+    }
+    return r;
+};
+/**
+ * Creates new object with transformed values
+ * @param f - Function to transform values
+ * @param x - Source object
+ * @returns Object with transformed values
+ */
+export const mapVals = (f, x) => {
+    const r = {};
+    for (const [k, v] of Object.entries(x)) {
+        r[k] = f(v);
+    }
+    return r;
+};
+/**
+ * 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
+ */
+export const mergeLeft = (a, b) => ({
+    ...b,
+    ...a,
+});
+/**
+ * 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
+ */
+export const mergeRight = (a, b) => ({
+    ...a,
+    ...b,
+});
+/** Deep merge two objects, prioritizing the first argument. */
+export const deepMergeLeft = (a, b) => deepMergeRight(b, a);
+/** Deep merge two objects, prioritizing the second argument. */
+export const deepMergeRight = (a, b) => {
+    a = { ...a };
+    for (const [k, v] of Object.entries(b)) {
+        if (isPojo(v) && isPojo(a[k])) {
+            a[k] = deepMergeRight(a[k], v);
+        }
+        else {
+            a[k] = v;
+        }
+    }
+    return a;
+};
+/**
+ * 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
+ */
+export const switcher = (k, m) => m[k] === undefined ? m.default : m[k];
+// ----------------------------------------------------------------------------
+// Combinators
+// ----------------------------------------------------------------------------
+/** Returns a function that returns the boolean negation of the given function */
+export const complement = (f) => (...args) => !f(...args);
+/**
+ * Safely executes function and handles errors
+ * @param f - Function to execute
+ * @param onError - Optional error handler
+ * @returns Function result or undefined if error
+ */
+export const tryCatch = (f, onError) => {
+    try {
+        const r = f();
+        if (r instanceof Promise) {
+            r.catch(e => onError?.(e));
+        }
+        return r;
+    }
+    catch (e) {
+        onError?.(e);
+    }
+    return undefined;
+};
 /**
  * Creates function that only executes once
  * @param f - Function to wrap
@@ -740,20 +785,82 @@ export const once = (f) => {
  */
 export const call = (f, ...args) => f();
 /**
- * Memoizes function results based on arguments
- * @param f - Function to memoize
- * @returns Memoized function
+ * Memoizes function results based on arguments
+ * @param f - Function to memoize
+ * @returns Memoized function
+ */
+export const memoize = (f) => {
+    let prevArgs;
+    let result;
+    return (...args) => {
+        if (!equals(prevArgs, args)) {
+            prevArgs = args;
+            result = f(...args);
+        }
+        return result;
+    };
+};
+/**
+ * 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
+ */
+export const ifLet = (x, f) => x === undefined ? undefined : f(x);
+// ----------------------------------------------------------------------------
+// Randomness
+// ----------------------------------------------------------------------------
+/**
+ * Generates random integer between min and max (inclusive)
+ * @param min - Minimum value
+ * @param max - Maximum value
+ * @returns Random integer
+ */
+export const randomInt = (min = 0, max = 9) => min + Math.round(Math.random() * (max - min));
+/**
+ * Generates random string ID
+ * @returns Random string suitable for use as an ID
+ */
+export const randomId = () => Math.random().toString().slice(2);
+// ----------------------------------------------------------------------------
+// Async
+// ----------------------------------------------------------------------------
+/**
+ * Creates a promise that resolves after specified time
+ * @param t - Time in milliseconds
+ * @returns Promise that resolves after t milliseconds
+ */
+export const sleep = (t) => new Promise(resolve => setTimeout(resolve, t));
+/**
+ * Creates a promise that resolves after the condition completes or timeout
+ * @param options - PollOptions
+ * @returns void Promise
  */
-export const memoize = (f) => {
-    let prevArgs;
-    let result;
-    return (...args) => {
-        if (!equals(prevArgs, args)) {
-            prevArgs = args;
-            result = f(...args);
+export const poll = ({ interval = 300, condition, signal }) => new Promise(resolve => {
+    const int = setInterval(() => {
+        if (condition()) {
+            resolve();
+            clearInterval(int);
         }
-        return result;
-    };
+    }, interval);
+    signal.addEventListener("abort", () => {
+        resolve();
+        clearInterval(int);
+    });
+});
+/**
+ * Creates a microtask that yields to other tasks in the event loop
+ * @returns Promise that resolves after yielding
+ */
+export const yieldThread = () => {
+    if (typeof window !== "undefined" &&
+        "scheduler" in window &&
+        "yield" in window.scheduler) {
+        return window.scheduler.yield();
+    }
+    return new Promise(resolve => {
+        setTimeout(resolve, 0);
+    });
 };
 /**
  * Creates throttled version of function
@@ -845,107 +952,80 @@ export const batcher = (t, execute) => {
     });
 };
 /**
- * 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
+ * Returns a promise that resolves after some proportion of promises complete
+ * @param threshold - number between 0 and 1 for how many promises to wait for
+ * @param promises - array of promises
+ * @returns promise
  */
-export const addToKey = (m, k, v) => {
-    const s = m[k] || new Set();
-    s.add(v);
-    m[k] = s;
+export const race = (threshold, promises) => {
+    let count = 0;
+    if (threshold === 0) {
+        return Promise.resolve();
+    }
+    return new Promise((resolve, reject) => {
+        promises.forEach(p => {
+            p.then(() => {
+                count++;
+                if (count >= threshold * promises.length) {
+                    resolve();
+                }
+            }).catch(reject);
+        });
+    });
 };
+// ----------------------------------------------------------------------------
+// URLs
+// ----------------------------------------------------------------------------
 /**
- * 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
+ * Removes protocol (http://, https://, etc) from URL
+ * @param url - URL to process
+ * @returns URL without protocol
  */
-export const pushToKey = (m, k, v) => {
-    const a = m[k] || [];
-    a.push(v);
-    m[k] = a;
-};
+export const stripProtocol = (url) => url.replace(/.*:\/\//, "");
 /**
- * Adds value to Set at key in Map
- * @param m - Map of Sets
- * @param k - Key to add to
- * @param v - Value to add
+ * Formats URL for display by removing protocol, www, and trailing slash
+ * @param url - URL to format
+ * @returns Formatted URL
  */
-export const addToMapKey = (m, k, v) => {
-    const s = m.get(k) || new Set();
-    s.add(v);
-    m.set(k, s);
-};
+export const displayUrl = (url) => stripProtocol(url)
+    .replace(/^(www\.)?/i, "")
+    .replace(/\/$/, "");
 /**
- * Pushes value to array at key in Map
- * @param m - Map of arrays
- * @param k - Key to push to
- * @param v - Value to push
+ * Extracts and formats domain from URL
+ * @param url - URL to process
+ * @returns Formatted domain name
  */
-export const pushToMapKey = (m, k, v) => {
-    const a = m.get(k) || [];
-    a.push(v);
-    m.set(k, a);
-};
+export const displayDomain = (url) => displayUrl(first(url.split(/[\/\?]/)) || "");
+// ----------------------------------------------------------------------------
+// JSON, localStorage, fetch, event emitters, etc
+// ----------------------------------------------------------------------------
 /**
- * A generic type-safe event listener function that auto-detects the appropriate methods
- * for adding and removing event listeners.
- *
- * @param target - The event target object with add/remove listener methods
- * @param eventName - The name of the event to listen for
- * @param callback - The callback function to execute when the event occurs
- * @returns A function that removes the event listener when called
+ * Safely parses JSON string
+ * @param json - JSON string to parse
+ * @returns Parsed object or null if invalid
  */
-export const on = (target, eventName, callback) => {
-    target.on(eventName, callback);
-    return () => {
-        target.off(eventName, callback);
-    };
+export const parseJson = (json) => {
+    if (!json)
+        return undefined;
+    try {
+        return JSON.parse(json);
+    }
+    catch (e) {
+        return undefined;
+    }
 };
 /**
- * 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
- */
-export const switcher = (k, m) => m[k] === undefined ? m.default : m[k];
-/** One minute in seconds */
-export const MINUTE = 60;
-/** One hour in seconds */
-export const HOUR = 60 * MINUTE;
-/** One day in seconds */
-export const DAY = 24 * HOUR;
-/** One week in seconds */
-export const WEEK = 7 * DAY;
-/** One month in seconds (approximate) */
-export const MONTH = 30 * DAY;
-/** One quarter in seconds (approximate) */
-export const QUARTER = 90 * DAY;
-/** One year in seconds (approximate) */
-export const YEAR = 365 * DAY;
-/**
- * Multiplies time unit by count
- * @param unit - Time unit in seconds
- * @param count - Number of units
- * @returns Total seconds
- */
-export const int = (unit, count = 1) => unit * count;
-/** Returns current Unix timestamp in seconds */
-export const now = () => Math.round(Date.now() / 1000);
-/**
- * Returns Unix timestamp from specified time ago
- * @param unit - Time unit in seconds
- * @param count - Number of units
- * @returns Timestamp in seconds
+ * Gets and parses JSON from localStorage
+ * @param k - Storage key
+ * @returns Parsed value or undefined if invalid/missing
  */
-export const ago = (unit, count = 1) => now() - int(unit, count);
+export const getJson = (k) => parseJson(localStorage.getItem(k) || "");
 /**
- * Converts seconds to milliseconds
- * @param seconds - Time in seconds
- * @returns Time in milliseconds
+ * Stringifies and stores value in localStorage
+ * @param k - Storage key
+ * @param v - Value to store
  */
-export const ms = (seconds) => seconds * 1000;
+export const setJson = (k, v) => localStorage.setItem(k, JSON.stringify(v));
 /**
  * Fetches JSON from URL with options
  * @param url - URL to fetch from
@@ -992,6 +1072,142 @@ export const uploadFile = (url, file) => {
     body.append("file", file);
     return fetchJson(url, { method: "POST", body });
 };
+/**
+ * A generic type-safe event listener function that works with event emitters.
+ *
+ * @param target - The event target object with add/remove listener methods
+ * @param eventName - The name of the event to listen for
+ * @param callback - The callback function to execute when the event occurs
+ * @returns A function that removes the event listener when called
+ */
+export const on = (target, eventName, callback) => {
+    target.on(eventName, callback);
+    return () => {
+        target.off(eventName, callback);
+    };
+};
+// ----------------------------------------------------------------------------
+// Strings
+// ----------------------------------------------------------------------------
+/**
+ * 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
+ */
+export 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;
+};
+/** Displays a list of items with oxford commas and a chosen conjunction */
+export const displayList = (xs, conj = "and", n = 6) => {
+    if (xs.length > n + 2) {
+        return `${xs.slice(0, n).join(", ")}, ${conj} ${xs.length - n} others`;
+    }
+    if (xs.length < 3) {
+        return xs.join(` ${conj} `);
+    }
+    return `${xs.slice(0, -1).join(", ")}, ${conj} ${xs.slice(-1).join("")}`;
+};
+/** Generates a hash string from input string */
+export const hash = (s) => Math.abs(s.split("").reduce((a, b) => ((a << 5) - a + b.charCodeAt(0)) | 0, 0)).toString();
+// ----------------------------------------------------------------------------
+// Curried utilities for working with collections
+// ----------------------------------------------------------------------------
+/** Returns a function that gets the nth element of an array */
+export const nth = (i) => (xs, ...args) => xs[i];
+/** Returns a function that checks if nth element equals value */
+export const nthEq = (i, v) => (xs, ...args) => xs[i] === v;
+/** Returns a function that checks if nth element does not equal value */
+export const nthNe = (i, v) => (xs, ...args) => xs[i] !== v;
+/** Returns a function that checks if key/value pairs of x match all pairs in spec */
+export const spec = (values) => (x, ...args) => {
+    if (Array.isArray(values)) {
+        for (let i = 0; i < values.length; i++) {
+            if (x[i] !== values[i]) {
+                return false;
+            }
+        }
+    }
+    else {
+        for (const [k, v] of Object.entries(values)) {
+            if (x[k] !== v)
+                return false;
+        }
+    }
+    return true;
+};
+/** Returns a function that checks equality with value */
+export const eq = (v) => (x, ...args) => x === v;
+/** Returns a function that checks inequality with value */
+export const ne = (v) => (x, ...args) => x !== v;
+/** Returns a function that gets property value from object */
+export const prop = (k) => (x) => x[k];
+/** Returns a function that adds/updates a property on object */
+export const assoc = (k, v) => (o) => ({ ...o, [k]: v });
+/** Returns a function that removes a property on object */
+export const dissoc = (k) => (o) => omit([k], o);
+/** Returns a function that checks whether a value is in the given sequence */
+export const member = (xs) => (x) => Array.from(xs).includes(x);
+// ----------------------------------------------------------------------------
+// Sets
+// ----------------------------------------------------------------------------
+/**
+ * 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
+ */
+export const addToKey = (m, k, v) => {
+    const s = m[k] || new Set();
+    s.add(v);
+    m[k] = s;
+};
+/**
+ * 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
+ */
+export const pushToKey = (m, k, v) => {
+    const a = m[k] || [];
+    a.push(v);
+    m[k] = a;
+};
+// ----------------------------------------------------------------------------
+// Maps
+// ----------------------------------------------------------------------------
+/**
+ * Adds value to Set at key in Map
+ * @param m - Map of Sets
+ * @param k - Key to add to
+ * @param v - Value to add
+ */
+export const addToMapKey = (m, k, v) => {
+    const s = m.get(k) || new Set();
+    s.add(v);
+    m.set(k, s);
+};
+/**
+ * Pushes value to array at key in Map
+ * @param m - Map of arrays
+ * @param k - Key to push to
+ * @param v - Value to push
+ */
+export const pushToMapKey = (m, k, v) => {
+    const a = m.get(k) || [];
+    a.push(v);
+    m.set(k, a);
+};
+// ----------------------------------------------------------------------------
+// Bech32 <-> hex encoding
+// ----------------------------------------------------------------------------
 /**
  * Converts hex string to bech32 format
  * @param prefix - Bech32 prefix