@isopodlabs/utilities 1.8.0 → 1.10.0

package/README.md

@@ -1,27 +1,346 @@
-# @isopodlabs/utilities
-[![npm version](https://img.shields.io/npm/v/@isopodlabs/utilities.svg)](https://www.npmjs.com/package/@isopodlabs/utilities)
-[![GitHub stars](https://img.shields.io/github/stars/adrianstephens/ts-utilities.svg?style=social)](https://github.com/adrianstephens/ts-utilities)
-[![License](https://img.shields.io/npm/l/@isopodlabs/utilities.svg)](LICENSE.txt)
-
-This package provides a set of utilities for TypeScript.
-
-## ☕ Support My Work  
-If you use this package, consider [buying me a cup of tea](https://coff.ee/adrianstephens) to support future updates!  
-
-## Usage
-
-Here is a basic example of how to use the package:
-
-```typescript
-import * as utils from '@isopodlabs/utilities';
-````
-
-**Interfaces**:
-
-
-**Functions**:
-
-
-## License
-
-This project is licensed under the MIT License.
+# @isopodlabs/utilities
+[![npm version](https://img.shields.io/npm/v/@isopodlabs/utilities.svg)](https://www.npmjs.com/package/@isopodlabs/utilities)
+[![GitHub stars](https://img.shields.io/github/stars/adrianstephens/ts-utilities.svg?style=social)](https://github.com/adrianstephens/ts-utilities)
+[![License](https://img.shields.io/npm/l/@isopodlabs/utilities.svg)](LICENSE.txt)
+
+A comprehensive collection of TypeScript utilities for common programming tasks, including array/object manipulation, async operations, bit manipulation, string processing, and more.
+
+##  Support My Work  
+If you use this package, consider [buying me a cup of tea](https://coff.ee/adrianstephens) to support future updates!  
+
+## Installation
+
+```bash
+npm install @isopodlabs/utilities
+```
+
+## Usage
+
+```typescript
+import * as utils from '@isopodlabs/utilities';
+import { DeferredPromise, regex } from '@isopodlabs/utilities';
+import * as glob from '@isopodlabs/utilities/glob';
+import * as insensitive from '@isopodlabs/utilities/insensitive';
+```
+
+## Core Features
+
+### Async Utilities (`async`)
+
+Utilities for working with async operations on iterables:
+
+```typescript
+import { async } from '@isopodlabs/utilities';
+
+// Parallel async map
+const results = await async.map([1, 2, 3], async (n) => n * 2);
+
+// Serial async map (one at a time)
+const results = await async.mapSerial([1, 2, 3], async (n) => n * 2);
+
+// Async reduce
+const sum = await async.reduce([1, 2, 3], async (acc, n) => acc + n, 0);
+
+// Async filter
+const evens = await async.filter([1, 2, 3, 4], async (n) => n % 2 === 0);
+
+// Async map object
+const mapped = await async.mapObject(
+{ a: 1, b: 2 },
+async ([k, v]) => [k, v * 2]
+);
+```
+
+### Array Utilities (`array`)
+
+```typescript
+import { array } from '@isopodlabs/utilities';
+
+// Remove element from array
+const arr = [1, 2, 3, 2];
+array.remove(arr, 2); // returns true, arr is now [1, 3, 2]
+
+// Compare arrays
+array.compare([1, 2], [1, 3]); // returns -1
+
+// Check equality
+array.equal([1, 2, 3], [1, 2, 3]); // returns true
+
+// Reverse in place
+array.reverse(arr, 0, arr.length - 1);
+
+// Rotate elements
+array.rotate(arr, 0, arr.length, 1);
+
+// Create array of instances
+const instances = array.make(5, MyClass);
+
+// Lazy slice generator
+for (const item of array.lazySlice([1, 2, 3, 4, 5], 1, 4)) {
+console.log(item);
+}
+```
+
+### Algorithm Utilities
+
+```typescript
+import { partition, lowerBound, min, max, argmin, argmax } from '@isopodlabs/utilities';
+
+// Partition by predicate
+const { true: evens, false: odds } = partition([1, 2, 3, 4], n => n % 2 === 0);
+
+// Binary search lower bound
+const index = lowerBound([1, 2, 4, 5], 3);
+
+// Find minimum/maximum
+const minimum = min([3, 1, 4, 1, 5]);
+const maximum = max([3, 1, 4, 1, 5]);
+
+// Find index of min/max
+const minIndex = argmin([3, 1, 4, 1, 5]);
+const maxIndex = argmax([3, 1, 4, 1, 5]);
+```
+
+### Iterator Utilities
+
+```typescript
+import { map, filter, reduce, find, forEach } from '@isopodlabs/utilities';
+
+// Map over any iterable
+const doubled = map([1, 2, 3], n => n * 2);
+
+// Filter iterable
+const evens = filter([1, 2, 3, 4], n => n % 2 === 0);
+
+// Reduce iterable
+const sum = reduce([1, 2, 3], (acc, n) => acc + n, 0);
+
+// Find first match
+const first = find([1, 2, 3], n => n > 1); // returns 2
+
+// ForEach with index
+forEach([1, 2, 3], (n, i) => console.log(`${i}: ${n}`));
+```
+
+### Object Utilities
+
+```typescript
+import { obj } from '@isopodlabs/utilities';
+
+// Map object values
+const doubled = obj.map({ a: 1, b: 2 }, ([k, v]) => [k, v * 2]);
+
+// Filter object entries
+const filtered = obj.filter({ a: 1, b: 2, c: 3 }, ([k, v]) => v > 1);
+
+// Deep merge objects
+const merged = obj.merge({ a: 1, b: { c: 2 } }, { b: { d: 3 } });
+
+// Clone object with prototype
+const copy = obj.clone(original);
+```
+
+
+### String Utilities
+
+```typescript
+import { replace, async_replace, splitFirstOf, splitLastOf, StringParser } from '@isopodlabs/utilities';
+
+// Advanced replace with callback
+const result = replace('hello world', /\w+/g, m => m[0].toUpperCase());
+
+// Async replace
+const result = await async_replace('hello world', /\w+/g, async m => m[0].toUpperCase());
+
+// Split on first/last occurrence
+const [before, after] = splitFirstOf('a.b.c', '.');
+const [before, after] = splitLastOf('a.b.c', '.');
+
+// String parser
+const parser = new StringParser('hello world');
+parser.skip('hello '); // returns true
+parser.match(/\w+/); // returns 'world'
+```
+
+### Bit Manipulation (`bits`)
+
+```typescript
+import { bits } from '@isopodlabs/utilities';
+
+// Find lowest set bit index
+const index = bits.lowestSet32(0b1010); // returns 1
+
+// Find highest set bit index
+const index = bits.highestSet32(0b1010); // returns 4
+
+// Count set bits
+const count = bits.countSet32(0b1011); // returns 3
+
+// Find nth set bit
+const index = bits.nthSet32(0b10101, 2); // finds 3rd set bit
+
+// Works with BigInt too
+const high = bits.highestSet(12345678901234567890n);
+const count = bits.countSet(12345678901234567890n);
+```
+
+### Glob Patterns (`glob`)
+
+Convert glob patterns to regular expressions:
+
+```typescript
+import { glob } from '@isopodlabs/utilities';
+
+// Parse glob to regex string
+const pattern = glob.parse('src/**/*.ts');
+
+// Create regex from glob
+const re = glob.toRe('*.js');
+
+// Multiple globs
+const re = glob.toReMulti(['*.js', '*.ts']);
+```
+
+### Case-Insensitive Utilities (`insensitive`)
+
+```typescript
+import { insensitive } from '@isopodlabs/utilities';
+
+// Case-insensitive string
+const str = insensitive.String('Hello');
+str.includes('HELLO'); // true
+
+// Case-insensitive map
+const map = new insensitive.Map([['Key', 'value']]);
+map.get('key'); // 'value'
+map.get('KEY'); // 'value'
+
+// Case-insensitive set
+const set = new insensitive.Set(['Hello', 'World']);
+set.has('hello'); // true
+
+// Case-insensitive record
+const rec = insensitive.Record({ Name: 'John' });
+rec['name']; // 'John'
+
+// Preserve original case
+const rec2 = insensitive.Record2({ Name: 'John' });
+Object.keys(rec2); // ['Name']
+```
+
+### Additional Utilities
+
+#### `Lazy`
+
+```typescript
+import { Lazy, CallCombiner, makeCache } from '@isopodlabs/utilities';
+
+// Lazy evaluation
+const lazy = new Lazy(() => expensiveComputation());
+const value = lazy.value; // only computed once
+
+// Combine rapid calls
+const combiner = new CallCombiner(() => console.log('done'), 100);
+combiner.trigger(); // will only call after 100ms of no triggers
+
+```
+
+#### `Simple cache`
+
+```typescript
+import { makeCache } from '@isopodlabs/utilities';
+
+// Simple cache
+const cache = makeCache(key => loadExpensiveData(key));
+const data = cache.get('mykey');
+cache.remove('mykey');
+cache.clear();
+
+// Set operations
+const united = union(new Set([1, 2]), new Set([2, 3]));
+const [remaining, removed] = difference(new Set([1, 2, 3]), new Set([2, 4]));
+```
+
+#### `DeferredPromise`
+
+A promise that can be resolved/rejected externally:
+
+```typescript
+import { DeferredPromise } from '@isopodlabs/utilities';
+
+const deferred = new DeferredPromise<number>();
+deferred.then(value => console.log(value));
+
+// Later...
+deferred.resolve(42);
+
+// Reset and reuse
+deferred.reset();
+```
+
+#### Regex Template Tag
+
+Create readable regular expressions:
+
+```typescript
+import { regex } from '@isopodlabs/utilities';
+
+// Multi-line regex with comments
+const re = regex`
+\d+          # one or more digits
+\.           # decimal point
+\d{2}        # exactly 2 digits
+`;
+
+// With custom flags
+const re = regex('i')`hello|world`;
+```
+
+#### Parallel/Serial Execution
+
+```typescript
+import { parallel, serial } from '@isopodlabs/utilities';
+
+// Run functions in parallel
+const results = await parallel(
+() => fetchA(),
+() => fetchB(),
+() => fetchC()
+);
+
+// Run functions serially
+const results = await serial(
+() => fetchA(),
+() => fetchB(),
+() => fetchC()
+);
+```
+
+## API Reference
+
+### Exported Namespaces
+- `obj` - Object utilities
+- `glob` - Glob pattern utilities
+- `bits` - Bit manipulation utilities
+- `array` - Array utilities
+- `async` - Async iterator utilities
+- `insensitive` - Case-insensitive string/collection utilities
+
+### Exported Functions
+- Generic: `compare`, `reverse`, `union`, `difference`
+- Algorithm: `partition`, `lowerBound`, `min`, `max`, `argmin`, `argmax`
+- Iterator: `map`, `filter`, `reduce`, `find`, `forEach`
+- Object: `map`, `filter`, `merge`, `clone`,
+- String: `replace`, `async_replace`, `splitFirstOf`, `splitLastOf`, `trim0`, `previousChar`, `tag`
+- Execution: `parallel`, `serial`
+- Regex: `regex`, `reDup`
+
+### Exported Classes
+- `DeferredPromise` - Externally resolvable promise
+- `Lazy` - Lazy evaluation wrapper
+- `CallCombiner` - Debounce/combine rapid calls
+- `StringParser` - String parsing helper
+
+## License
+
+This project is licensed under the MIT License.

package/dist/array.d.ts

@@ -5,3 +5,8 @@ export declare function reverse<T>(array: T[], start: number, end: number): void
 export declare function rotate<T>(array: T[], start: number, end: number, shift: number): void;
 export declare function make<T>(n: number, constructor: new () => T): T[];
 export declare function lazySlice<T>(array: T[], start?: number, end?: number): Generator<T>;
+export declare function lowerBound<T>(array: T[], value: T, func?: (a: T, b: T, i: number) => boolean): number;
+export declare function argmin<T>(array: T[], func?: (a: T, b: T) => number): number;
+export declare function min<T>(array: T[], func?: (a: T, b: T) => number): T;
+export declare function argmax<T>(array: T[], func?: (a: T, b: T) => number): number;
+export declare function max<T>(array: T[], func?: (a: T, b: T) => number): T;

package/dist/array.js

@@ -7,7 +7,12 @@ exports.reverse = reverse;
 exports.rotate = rotate;
 exports.make = make;
 exports.lazySlice = lazySlice;
-const object_1 = require("./object");
+exports.lowerBound = lowerBound;
+exports.argmin = argmin;
+exports.min = min;
+exports.argmax = argmax;
+exports.max = max;
+const index_1 = require("./index");
 //-----------------------------------------------------------------------------
 //	array
 //-----------------------------------------------------------------------------
@@ -22,7 +27,7 @@ function remove(array, item) {
 function compare(arr1, arr2) {
     const length = Math.min(arr1.length, arr2.length);
     for (let i = 0; i < length; i++) {
-        const r = (0, object_1.compare)(arr1[i], arr2[i]);
+        const r = (0, index_1.compare)(arr1[i], arr2[i]);
         if (r)
             return r;
     }
@@ -54,7 +59,7 @@ function rotate(array, start, end, shift) {
     }
 }
 function make(n, constructor) {
-    return Array.from({ length: n }, () => new constructor);
+    return Array.from({ length: n }, () => new constructor());
 }
 function* lazySlice(array, start, end) {
     const len = array.length;
@@ -67,9 +72,45 @@ function* lazySlice(array, start, end) {
     if (end === undefined)
         end = len;
     else if (end < 0)
-        end = Math.max(len + start, 0);
+        end = Math.max(len + end, 0);
     else
         end = Math.min(end, len);
     for (let i = start; i < end; i++)
         yield array[i];
 }
+function lowerBound(array, value, func = index_1.less) {
+    let i = 0;
+    for (let n = array.length; n; n >>= 1) {
+        const mid = i + (n >> 1);
+        if (func(array[mid], value, mid)) {
+            i = mid + 1;
+            --n;
+        }
+    }
+    return i;
+}
+function argmin(array, func = index_1.compare) {
+    let mini = 0;
+    for (let i = 1; i < array.length; i++) {
+        const v = func(array[i], array[mini]);
+        if (v < 0)
+            mini = i;
+    }
+    return mini;
+}
+function min(array, func = index_1.compare) {
+    return array[argmin(array, func)];
+}
+function argmax(array, func = index_1.compare) {
+    let maxi = 0;
+    for (let i = 1; i < array.length; i++) {
+        const v = func(array[i], array[maxi]);
+        if (v > 0)
+            maxi = i;
+    }
+    return maxi;
+}
+function max(array, func = index_1.compare) {
+    return array[argmax(array, func)];
+}
+//# sourceMappingURL=array.js.map

package/dist/async.d.ts

@@ -1,4 +1,5 @@
 export declare function map<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => Promise<U>): Promise<U[]>;
+export declare function mapObject<T, U>(obj: Record<string, T>, func: (x: [k: string, v: T]) => Promise<[k: string, v: U]>): Promise<Record<string, U>>;
 export declare function mapSerial<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => Promise<U>): Promise<U[]>;
 export declare function reduce<T, U>(iterable: Iterable<T>, func: (acc: U, v: T, i: number, iterable: Iterable<T>) => Promise<U>, initialValue: U): Promise<U>;
 export declare function filter<T>(iterable: Iterable<T>, func: (v: T) => Promise<unknown>): Promise<T[]>;

package/dist/async.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.map = map;
+exports.mapObject = mapObject;
 exports.mapSerial = mapSerial;
 exports.reduce = reduce;
 exports.filter = filter;
@@ -45,6 +46,9 @@ const iterator = __importStar(require("./iterator"));
 async function map(iterable, func) {
     return Promise.all(iterator.map(iterable, func));
 }
+async function mapObject(obj, func) {
+    return Object.fromEntries(await Promise.all(Object.entries(obj).map(x => func(x))));
+}
 async function mapSerial(iterable, func) {
     const results = [];
     let i = 0;
@@ -63,3 +67,4 @@ async function filter(iterable, func) {
     const filters = await map(iterable, func);
     return iterator.filter(iterable, (_, i) => filters[i]);
 }
+//# sourceMappingURL=async.js.map

package/dist/bits.js

@@ -249,8 +249,9 @@ function nthSet(x, i) {
     return n;
 }
 function reverse(x) {
-    if (typeof x === 'number')
+    if (x < 0x100000000)
         return reverse32(Number(x));
+    x = BigInt(x);
     let k = 5;
     for (let t = x >> 32n; t;)
         t >>= BigInt(1 << k++);
@@ -1323,3 +1324,4 @@ class SparseBits2 extends SparseBits {
 }
 exports.SparseBits2 = SparseBits2;
 ;
+//# sourceMappingURL=bits.js.map

package/dist/glob.d.ts

@@ -1,4 +1,4 @@
-export declare function parseGlob(glob: string): string;
+export declare function parse(glob: string): string;
 export declare function anchoredRe(re: string): RegExp;
-export declare function globToRe(glob: string): RegExp;
-export declare function globToReMulti(globs: string[]): RegExp;
+export declare function toRe(glob: string): RegExp;
+export declare function toReMulti(globs: string[]): RegExp;

package/dist/glob.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseGlob = parseGlob;
+exports.parse = parse;
 exports.anchoredRe = anchoredRe;
-exports.globToRe = globToRe;
-exports.globToReMulti = globToReMulti;
+exports.toRe = toRe;
+exports.toReMulti = toReMulti;
 const posixClasses = {
     alnum: '\\p{L}\\p{Nl}\\p{Nd}',
     alpha: '\\p{L}\\p{Nl}',
@@ -23,7 +23,7 @@ const posixClasses = {
 //-----------------------------------------------------------------------------
 // Glob pattern to regex
 //-----------------------------------------------------------------------------
-function parseGlob(glob) {
+function parse(glob) {
     let result = '';
     let depth = 0;
     for (let i = 0; i < glob.length; ++i) {
@@ -104,9 +104,10 @@ function parseGlob(glob) {
 function anchoredRe(re) {
     return new RegExp(`^${re}$`);
 }
-function globToRe(glob) {
-    return anchoredRe(parseGlob(glob));
+function toRe(glob) {
+    return anchoredRe(parse(glob));
 }
-function globToReMulti(globs) {
-    return anchoredRe(globs.map(parseGlob).join('|'));
+function toReMulti(globs) {
+    return anchoredRe(globs.map(parse).join('|'));
 }
+//# sourceMappingURL=glob.js.map

package/dist/index.d.ts

@@ -1,11 +1,55 @@
-export * from './object';
 export * from './iterator';
 export * from './string';
-export * from './algorithm';
-export * from './glob';
+export { lowerBound, argmin, min, argmax, max } from './array';
+export { partition } from './iterator';
+export * as obj from './obj';
+export * as glob from './glob';
 export * as bits from './bits';
 export * as array from './array';
 export * as async from './async';
 export * as insensitive from './insensitive';
+export declare function compare<T>(a: T, b: T): number;
+export declare function less<T>(a: T, b: T): boolean;
+export declare function reverse_compare<T>(a: T, b: T): number;
+export declare function reverse<T, R>(func: (a: T, b: T) => R): (a: T, b: T) => R;
 export declare function parallel(...fns: (() => any)[]): Promise<any[]>;
 export declare function serial(...fns: (() => any)[]): Promise<any[]>;
+export declare function union<T>(a: Set<T>, b: Set<T>): Set<T>;
+export declare function difference<T>(a: Set<T>, b: Set<T>): [Set<T>, Set<T>];
+export declare function regex(strings: TemplateStringsArray, ...args: any[]): RegExp;
+export declare function regex(flags: string): (strings: TemplateStringsArray, ...args: any[]) => RegExp;
+export declare function reDup(re: RegExp): RegExp;
+export declare class DeferredPromise<T> {
+    private promise;
+    private resolver?;
+    private rejecter?;
+    constructor(t?: T);
+    resolve(value: T): void;
+    reset(): void;
+    then<T2 = void>(onfulfilled?: (t: T) => T2 | PromiseLike<T2>): Promise<T2>;
+    reject(error: any): void;
+}
+export declare class Lazy<T> {
+    private factory;
+    private _value;
+    constructor(factory: () => T);
+    get value(): T;
+    then<U>(this: T extends Promise<infer _R> ? Lazy<T> : never, onFulfilled: (value: T extends Promise<infer R> ? R : never) => U): Promise<U>;
+}
+export declare function Memoize<T>(func: () => T): () => T;
+export declare class CallCombiner0 {
+    private timeout?;
+    combine(delay: number, func: () => void): void;
+    pending(): boolean;
+}
+export declare class CallCombiner extends CallCombiner0 {
+    private func;
+    private delay;
+    constructor(func: () => void, delay: number);
+    trigger(): void;
+}
+export declare function makeCache<T>(load: (key: string) => T): {
+    get: (key: string) => T;
+    remove: (key: string) => boolean;
+    clear: () => void;
+};

package/dist/index.js

@@ -36,22 +36,178 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.insensitive = exports.async = exports.array = exports.bits = void 0;
+exports.CallCombiner = exports.CallCombiner0 = exports.Lazy = exports.DeferredPromise = exports.insensitive = exports.async = exports.array = exports.bits = exports.glob = exports.obj = exports.partition = exports.max = exports.argmax = exports.min = exports.argmin = exports.lowerBound = void 0;
+exports.compare = compare;
+exports.less = less;
+exports.reverse_compare = reverse_compare;
+exports.reverse = reverse;
 exports.parallel = parallel;
 exports.serial = serial;
+exports.union = union;
+exports.difference = difference;
+exports.regex = regex;
+exports.reDup = reDup;
+exports.Memoize = Memoize;
+exports.makeCache = makeCache;
 const async = __importStar(require("./async"));
-__exportStar(require("./object"), exports);
 __exportStar(require("./iterator"), exports);
 __exportStar(require("./string"), exports);
-__exportStar(require("./algorithm"), exports);
-__exportStar(require("./glob"), exports);
+var array_1 = require("./array");
+Object.defineProperty(exports, "lowerBound", { enumerable: true, get: function () { return array_1.lowerBound; } });
+Object.defineProperty(exports, "argmin", { enumerable: true, get: function () { return array_1.argmin; } });
+Object.defineProperty(exports, "min", { enumerable: true, get: function () { return array_1.min; } });
+Object.defineProperty(exports, "argmax", { enumerable: true, get: function () { return array_1.argmax; } });
+Object.defineProperty(exports, "max", { enumerable: true, get: function () { return array_1.max; } });
+var iterator_1 = require("./iterator");
+Object.defineProperty(exports, "partition", { enumerable: true, get: function () { return iterator_1.partition; } });
+exports.obj = __importStar(require("./obj"));
+exports.glob = __importStar(require("./glob"));
 exports.bits = __importStar(require("./bits"));
 exports.array = __importStar(require("./array"));
 exports.async = __importStar(require("./async"));
 exports.insensitive = __importStar(require("./insensitive"));
+//-----------------------------------------------------------------------------
+// handy generic functions
+//-----------------------------------------------------------------------------
+function compare(a, b) {
+    return a < b ? -1 : a > b ? 1 : 0;
+}
+function less(a, b) {
+    return a < b;
+}
+function reverse_compare(a, b) {
+    return compare(b, a);
+}
+function reverse(func) {
+    return (a, b) => func(b, a);
+}
 async function parallel(...fns) {
     return async.map(fns, f => f());
 }
 async function serial(...fns) {
     return async.mapSerial(fns, f => f());
 }
+//-----------------------------------------------------------------------------
+// set helpers
+//-----------------------------------------------------------------------------
+function union(a, b) {
+    return new Set([...a, ...b]);
+}
+function difference(a, b) {
+    const remaining = new Set(a);
+    const removed = new Set();
+    for (const item of b) {
+        if (remaining.delete(item))
+            removed.add(item);
+    }
+    return [remaining, removed];
+}
+function regex(param, ...args) {
+    const flags = typeof param === 'string' ? param : 'g';
+    if (typeof param === 'string')
+        return inner;
+    return inner(param, ...args);
+    function inner(strings, ...args) {
+        const s = strings.raw.reduce((s, str, i) => s + str + (args[i] || ''), '');
+        const lines = s.split('\n');
+        return new RegExp(lines.map(line => line.split('#')[0].trim()).join(''), flags);
+    }
+    ;
+}
+function reDup(re) { return new RegExp(re.source, re.flags); }
+//-----------------------------------------------------------------------------
+// handy classes and functions
+//-----------------------------------------------------------------------------
+class DeferredPromise {
+    promise;
+    resolver;
+    rejecter;
+    constructor(t) {
+        this.promise = t === undefined ? new Promise((resolve, reject) => {
+            this.resolver = resolve;
+            this.rejecter = reject;
+        }) : Promise.resolve(t);
+    }
+    resolve(value) {
+        if (this.resolver) {
+            this.resolver(value);
+            this.resolver = undefined;
+        }
+    }
+    reset() {
+        this.promise = new Promise((resolve, reject) => {
+            this.resolver = resolve;
+            this.rejecter = reject;
+        });
+    }
+    then(onfulfilled) {
+        return this.promise.then(onfulfilled);
+    }
+    reject(error) {
+        if (this.rejecter)
+            this.rejecter(error);
+    }
+}
+exports.DeferredPromise = DeferredPromise;
+class Lazy {
+    factory;
+    _value;
+    constructor(factory) {
+        this.factory = factory;
+    }
+    get value() {
+        if (this._value === undefined)
+            this._value = this.factory();
+        return this._value;
+    }
+    // Add 'then' method only when T is a Promise
+    then(onFulfilled) {
+        return this.value.then(onFulfilled);
+    }
+}
+exports.Lazy = Lazy;
+function Memoize(func) {
+    const lazy = new Lazy(func);
+    return () => lazy.value;
+}
+class CallCombiner0 {
+    timeout;
+    combine(delay, func) {
+        if (this.timeout)
+            clearTimeout(this.timeout);
+        this.timeout = setTimeout(() => {
+            this.timeout = undefined;
+            func();
+        }, delay);
+    }
+    pending() {
+        return !!this.timeout;
+    }
+}
+exports.CallCombiner0 = CallCombiner0;
+class CallCombiner extends CallCombiner0 {
+    func;
+    delay;
+    constructor(func, delay) {
+        super();
+        this.func = func;
+        this.delay = delay;
+    }
+    trigger() {
+        super.combine(this.delay, this.func);
+    }
+}
+exports.CallCombiner = CallCombiner;
+function makeCache(load) {
+    const cache = {};
+    return {
+        get: (key) => {
+            if (!cache[key])
+                cache[key] = load(key);
+            return cache[key];
+        },
+        remove: (key) => delete cache[key],
+        clear: () => Object.keys(cache).forEach(k => delete cache[k]),
+    };
+}
+//# sourceMappingURL=index.js.map

package/dist/insensitive.d.ts

@@ -1,25 +1,26 @@
-declare class CaseInsensitiveString {
+type string2 = string | istring;
+declare class istring {
     private value;
     constructor(value: string);
     get length(): number;
     toString(): string;
     toUpperCase(): string;
     toLowerCase(): string;
-    includes(searchString: string, position?: number): boolean;
-    startsWith(searchString: string, position?: number): boolean;
-    endsWith(searchString: string, position?: number): boolean;
-    indexOf(searchString: string, position?: number): number;
-    lastIndexOf(searchString: string, position?: number): number;
-    compare(other: string | CaseInsensitiveString): 0 | 1 | -1;
+    includes(searchString: string2, position?: number): boolean;
+    startsWith(searchString: string2, position?: number): boolean;
+    endsWith(searchString: string2, position?: number): boolean;
+    indexOf(searchString: string2, position?: number): number;
+    lastIndexOf(searchString: string2, position?: number): number;
+    compare(other: string2): 0 | 1 | -1;
 }
-declare class CaseInsensitiveString2 extends CaseInsensitiveString {
+declare class istring2 extends istring {
     private orig;
     constructor(orig: string);
     toString(): string;
 }
-export declare function String(value: string): CaseInsensitiveString;
-export declare function String2(value: string): CaseInsensitiveString2;
-export declare function compare(a: string | CaseInsensitiveString, b: string | CaseInsensitiveString): 0 | 1 | -1;
+export declare function String(value: string): istring;
+export declare function String2(value: string): istring2;
+export declare function compare(a: string2, b: string2): 0 | 1 | -1;
 export declare function Record<T>(obj: Record<string, T>): Record<string, T>;
 export declare function Record2<T>(obj: Record<string, T>): Record<string, T>;
 export declare class Map<T> extends globalThis.Map<string, T> {

package/dist/insensitive.js

@@ -6,7 +6,7 @@ exports.String2 = String2;
 exports.compare = compare;
 exports.Record = Record;
 exports.Record2 = Record2;
-class CaseInsensitiveString {
+class istring {
     value;
     constructor(value) { this.value = value.toUpperCase(); }
     get length() { return this.value.length; }
@@ -21,7 +21,7 @@ class CaseInsensitiveString {
     compare(other) { const bi = other.toUpperCase(); return this.value < bi ? -1 : this.value > bi ? 1 : 0; }
 }
 // keeps original string
-class CaseInsensitiveString2 extends CaseInsensitiveString {
+class istring2 extends istring {
     orig;
     constructor(orig) {
         super(orig);
@@ -30,10 +30,10 @@ class CaseInsensitiveString2 extends CaseInsensitiveString {
     toString() { return this.orig; }
 }
 function String(value) {
-    return new CaseInsensitiveString(value);
+    return new istring(value);
 }
 function String2(value) {
-    return new CaseInsensitiveString2(value);
+    return new istring2(value);
 }
 function compare(a, b) {
     const ai = a.toUpperCase(), bi = b.toUpperCase();
@@ -77,3 +77,4 @@ class Set extends globalThis.Set {
     has(value) { return super.has(value.toUpperCase()); }
 }
 exports.Set = Set;
+//# sourceMappingURL=insensitive.js.map

package/dist/iterator.d.ts

@@ -5,3 +5,6 @@ export declare function find<T>(iterable: Iterable<T> | undefined, func: (v: T)
 export declare function map<T, U>(iterable: Iterable<T> | undefined, func: (v: T, i: number) => U): U[];
 export declare function reduce<T, U>(iterable: Iterable<T>, func: (acc: U, v: T, i: number, iterable: Iterable<T>) => U, initialValue: U): U;
 export declare function filter<T>(iterable: Iterable<T>, func: (v: T, i: number) => unknown): T[];
+type PartitionIndex<U> = U extends boolean ? 'true' | 'false' : U;
+export declare function partition<T, U extends keyof any | boolean>(array: Iterable<T>, func: (v: T) => U): Record<PartitionIndex<U>, T[]>;
+export {};

package/dist/iterator.js

@@ -39,6 +39,7 @@ exports.find = find;
 exports.map = map;
 exports.reduce = reduce;
 exports.filter = filter;
+exports.partition = partition;
 const array = __importStar(require("./array"));
 function remove(iterable, item) {
     return array.remove(Array.from(iterable), item);
@@ -76,3 +77,10 @@ function filter(iterable, func) {
             array.push(v);
     return array;
 }
+function partition(array, func) {
+    const partitions = {};
+    for (const i of array)
+        (partitions[func(i)] ??= []).push(i);
+    return partitions;
+}
+//# sourceMappingURL=iterator.js.map

package/dist/obj.d.ts

@@ -0,0 +1,5 @@
+export declare function map<T, U>(obj: Record<string, T>, func: (x: [k: string, v: T]) => [k: string, v: U]): Record<string, U>;
+export declare function filter<T>(obj: Record<string, T>, func: (x: [k: string, v: T]) => boolean): Record<string, T>;
+export declare function merge(...list: Record<string, any>[]): Record<string, any>;
+export declare function isEmpty(obj: object): boolean;
+export declare function clone<T extends object>(obj: T): T;

package/dist/obj.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.map = map;
+exports.filter = filter;
+exports.merge = merge;
+exports.isEmpty = isEmpty;
+exports.clone = clone;
+function map(obj, func) {
+    return Object.fromEntries(Object.entries(obj).map(x => func(x)));
+}
+function filter(obj, func) {
+    return Object.fromEntries(Object.entries(obj).filter(x => func(x)));
+}
+function merge(...list) {
+    function isObject(value) {
+        return typeof value === 'object' && value !== null;
+    }
+    function recurse(target, source) {
+        for (const key in source) {
+            if (isObject(source[key]) && isObject(target[key]))
+                recurse(target[key], source[key]);
+            else
+                target[key] = source[key];
+        }
+        return target;
+    }
+    return list.reduce((merged, r) => recurse(merged, r), {});
+}
+function isEmpty(obj) {
+    return Object.keys(obj).length === 0;
+}
+function clone(obj) {
+    return Object.assign(Object.create(Object.getPrototypeOf(obj)), obj);
+}
+//# sourceMappingURL=obj.js.map

package/dist/string.d.ts

@@ -2,12 +2,13 @@ export declare function firstOf(value: string, find: string): number;
 export declare function lastOf(value: string, find: string): number;
 export declare function splitFirstOf(value: string, find: string): (string | undefined)[];
 export declare function splitLastOf(value: string, find: string): (string | undefined)[];
+export declare function splitEvery(s: string, n: number): string[];
 export declare function trim0(value: string): string;
 export declare function replace(value: string, re: RegExp, process: (match: RegExpExecArray) => string): string;
 export declare function async_replace(value: string, re: RegExp, process: (match: RegExpExecArray) => Promise<string>): Promise<string>;
+export declare function async_replace_async(value: string, re: RegExp, process: (match: RegExpExecArray) => Promise<string>): Promise<string>;
 export declare function replace_back(value: string, re: RegExp, process: (match: RegExpExecArray, right: string) => string): string;
 export declare function async_replace_back(value: string, re: RegExp, process: (match: RegExpExecArray, right: string) => Promise<string>): Promise<string>;
-export declare function splitEvery(s: string, n: number): string[];
 export declare function tag(strings: TemplateStringsArray, ...keys: any[]): (...values: any[]) => string;
 export declare function previousChar(str: string, pos: number): string;
 export declare function hasCustomToString(value: any): boolean;
@@ -23,6 +24,6 @@ export declare class StringParser {
     get(n: number): string;
     skip(c: string): boolean;
     expect(c: string): void;
-    match(re: RegExp): string | undefined;
     exec(re: RegExp): RegExpExecArray | undefined;
+    match(re: RegExp): string | undefined;
 }

package/dist/string.js

@@ -8,12 +8,13 @@ exports.firstOf = firstOf;
 exports.lastOf = lastOf;
 exports.splitFirstOf = splitFirstOf;
 exports.splitLastOf = splitLastOf;
+exports.splitEvery = splitEvery;
 exports.trim0 = trim0;
 exports.replace = replace;
 exports.async_replace = async_replace;
+exports.async_replace_async = async_replace_async;
 exports.replace_back = replace_back;
 exports.async_replace_back = async_replace_back;
-exports.splitEvery = splitEvery;
 exports.tag = tag;
 exports.previousChar = previousChar;
 exports.hasCustomToString = hasCustomToString;
@@ -40,6 +41,9 @@ function splitLastOf(value, find) {
     const index = lastOf(value, find);
     return index === -1 ? [value, undefined] : [value.substring(0, index), value.substring(index + 1)];
 }
+function splitEvery(s, n) {
+    return Array.from({ length: Math.ceil(s.length / n) }, (_, i) => s.slice(i * n, (i + 1) * n));
+}
 function trim0(value) {
     const index = value.indexOf('\0');
     return index === -1 ? value : value.substring(0, index);
@@ -54,17 +58,29 @@ function replace(value, re, process) {
     return result + value.substring(i);
 }
 /*
-export async function async_replace(value: string, re: RegExp, process: (match: RegExpExecArray)=>Promise<string>): Promise<string> {
+export async function async_replace<T = undefined>(value: string, re: RegExp, process: (match: RegExpExecArray, right: (context?: T)=>Promise<string>, context?: T)=>Promise<string>, context?: T): Promise<string> {
+    const right		= async (context?: T) => async_replace(value, re, process, context);
     let result = "";
-    let i = 0;
+    let i = re.lastIndex;
     for (let m; (m = re.exec(value));) {
-        result += value.substring(i, m.index) + await process(m);
+        result += value.substring(i, m.index) + await process(m, right, context);
         i = re.lastIndex;
     }
+    re.lastIndex = value.length;
     return result + value.substring(i);
 }
 */
 async function async_replace(value, re, process) {
+    let result = "";
+    let i = re.lastIndex;
+    for (let m; (m = re.exec(value));) {
+        result += value.substring(i, m.index) + await process(m);
+        i = re.lastIndex;
+    }
+    re.lastIndex = value.length;
+    return result + value.substring(i);
+}
+async function async_replace_async(value, re, process) {
     const combine = async (m) => value.substring(i, m.index) + await process(m);
     const promises = [];
     let i = 0;
@@ -94,9 +110,6 @@ async function async_replace_back(value, re, process) {
     re.lastIndex = value.length;
     return value.substring(start);
 }
-function splitEvery(s, n) {
-    return Array.from({ length: Math.ceil(s.length / n) }, (_, i) => s.slice(i * n, (i + 1) * n));
-}
 function tag(strings, ...keys) {
     return (...values) => {
         const dict = values.at(-1) || {};
@@ -145,13 +158,6 @@ class StringParser {
         if (!this.skip(c))
             throw new Error(`Expected '${c}'`);
     }
-    match(re) {
-        const m = re.exec(this.remainder());
-        if (m) {
-            this.pos += m.index + m[0].length;
-            return m[0];
-        }
-    }
     exec(re) {
         const m = re.exec(this.remainder());
         if (m) {
@@ -159,5 +165,9 @@ class StringParser {
             return m;
         }
     }
+    match(re) {
+        return this.exec(re)?.[0];
+    }
 }
 exports.StringParser = StringParser;
+//# sourceMappingURL=string.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@isopodlabs/utilities",
-	"version": "1.8.0",
+	"version": "1.10.0",
 	"description": "Various typescript helpers.",
 	"repository": {
 		"type": "git",
@@ -17,6 +17,7 @@
 	],
 	"scripts": {
 		"build": "tsc",
+		"watch": "tsc -watch -p ./",
 		"lint": "eslint \"src/**/*.ts\""
 	},
 	"keywords": [

package/dist/algorithm.d.ts

@@ -1,9 +0,0 @@
-type PartitionIndex<U> = U extends boolean ? 'true' | 'false' : U;
-export declare function partition<T, U extends keyof any | boolean>(array: Iterable<T>, func: (v: T) => U): Record<PartitionIndex<U>, T[]>;
-export declare function less<T>(a: T, b: T): boolean;
-export declare function lowerBound<T>(array: T[], value: T, func?: (a: T, b: T, i: number) => boolean): number;
-export declare function argmin<T>(array: T[], func?: (a: T, b: T) => number): number;
-export declare function min<T>(array: T[], func?: (a: T, b: T) => number): T;
-export declare function argmax<T>(array: T[], func?: (a: T, b: T) => number): number;
-export declare function max<T>(array: T[], func?: (a: T, b: T) => number): T;
-export {};

package/dist/algorithm.js

@@ -1,54 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.partition = partition;
-exports.less = less;
-exports.lowerBound = lowerBound;
-exports.argmin = argmin;
-exports.min = min;
-exports.argmax = argmax;
-exports.max = max;
-const object_1 = require("./object");
-function partition(array, func) {
-    const partitions = {};
-    for (const i of array)
-        (partitions[func(i)] ??= []).push(i);
-    return partitions;
-}
-function less(a, b) {
-    return a < b;
-}
-function lowerBound(array, value, func = less) {
-    let i = 0;
-    for (let n = array.length; n; n >>= 1) {
-        const mid = i + (n >> 1);
-        if (func(array[mid], value, mid)) {
-            i = mid + 1;
-            --n;
-        }
-    }
-    return i;
-}
-function argmin(array, func = object_1.compare) {
-    let mini = 0;
-    for (let i = 1; i < array.length; i++) {
-        const v = func(array[i], array[mini]);
-        if (v < 0)
-            mini = i;
-    }
-    return mini;
-}
-function min(array, func = object_1.compare) {
-    return array[argmin(array, func)];
-}
-function argmax(array, func = object_1.compare) {
-    let maxi = 0;
-    for (let i = 1; i < array.length; i++) {
-        const v = func(array[i], array[maxi]);
-        if (v > 0)
-            maxi = i;
-    }
-    return maxi;
-}
-function max(array, func = object_1.compare) {
-    return array[argmax(array, func)];
-}

package/dist/object.d.ts

@@ -1,33 +0,0 @@
-export declare function mapObject<T, U>(obj: Record<string, T>, func: (x: [k: string, v: T]) => [k: string, v: U]): Record<string, U>;
-export declare function filterObject<T>(obj: Record<string, T>, func: (x: [k: string, v: T]) => boolean): Record<string, T>;
-export declare function merge(...list: Record<string, any>[]): Record<string, any>;
-export declare function isEmpty(obj: object): boolean;
-export declare function clone<T extends object>(obj: T): T;
-export declare function compare<T>(a: T, b: T): number;
-export declare function reverse_compare<T>(a: T, b: T): number;
-export declare function reverse<T, R>(func: (a: T, b: T) => R): (a: T, b: T) => R;
-export declare class Lazy<T> {
-    private factory;
-    private _value;
-    constructor(factory: () => T);
-    get value(): T;
-    then<U>(this: T extends Promise<infer _R> ? Lazy<T> : never, onFulfilled: (value: T extends Promise<infer R> ? R : never) => U): Promise<U>;
-}
-export declare class CallCombiner0 {
-    private timeout?;
-    combine(delay: number, func: () => void): void;
-    pending(): boolean;
-}
-export declare class CallCombiner extends CallCombiner0 {
-    private func;
-    private delay;
-    constructor(func: () => void, delay: number);
-    trigger(): void;
-}
-export declare function makeCache<T>(load: (key: string) => T): {
-    get: (fullpath: string) => T;
-    remove: (fullpath: string) => boolean;
-    clear: () => void;
-};
-export declare function union<T>(a: Set<T>, b: Set<T>): Set<T>;
-export declare function difference<T>(a: Set<T>, b: Set<T>): [Set<T>, Set<T>];

package/dist/object.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CallCombiner = exports.CallCombiner0 = exports.Lazy = void 0;
-exports.mapObject = mapObject;
-exports.filterObject = filterObject;
-exports.merge = merge;
-exports.isEmpty = isEmpty;
-exports.clone = clone;
-exports.compare = compare;
-exports.reverse_compare = reverse_compare;
-exports.reverse = reverse;
-exports.makeCache = makeCache;
-exports.union = union;
-exports.difference = difference;
-function mapObject(obj, func) {
-    return Object.fromEntries(Object.entries(obj).map(x => func(x)));
-}
-function filterObject(obj, func) {
-    return Object.fromEntries(Object.entries(obj).filter(x => func(x)));
-}
-function merge(...list) {
-    function isObject(value) {
-        return typeof value === 'object' && value !== null;
-    }
-    function recurse(target, source) {
-        for (const key in source) {
-            if (isObject(source[key]) && isObject(target[key]))
-                recurse(target[key], source[key]);
-            else
-                target[key] = source[key];
-        }
-        return target;
-    }
-    return list.reduce((merged, r) => recurse(merged, r), {});
-}
-function isEmpty(obj) {
-    return Object.keys(obj).length === 0;
-}
-function clone(obj) {
-    return Object.assign(Object.create(Object.getPrototypeOf(obj)), obj);
-}
-function compare(a, b) {
-    return a < b ? -1 : a > b ? 1 : 0;
-}
-function reverse_compare(a, b) {
-    return compare(b, a);
-}
-function reverse(func) {
-    return (a, b) => func(b, a);
-}
-class Lazy {
-    factory;
-    _value;
-    constructor(factory) {
-        this.factory = factory;
-    }
-    get value() {
-        if (this._value === undefined)
-            this._value = this.factory();
-        return this._value;
-    }
-    // Add 'then' method only when T is a Promise
-    then(onFulfilled) {
-        return this.value.then(onFulfilled);
-    }
-}
-exports.Lazy = Lazy;
-class CallCombiner0 {
-    timeout;
-    combine(delay, func) {
-        if (this.timeout)
-            clearTimeout(this.timeout);
-        this.timeout = setTimeout(() => {
-            this.timeout = undefined;
-            func();
-        }, delay);
-    }
-    pending() {
-        return !!this.timeout;
-    }
-}
-exports.CallCombiner0 = CallCombiner0;
-class CallCombiner extends CallCombiner0 {
-    func;
-    delay;
-    constructor(func, delay) {
-        super();
-        this.func = func;
-        this.delay = delay;
-    }
-    trigger() {
-        super.combine(this.delay, this.func);
-    }
-}
-exports.CallCombiner = CallCombiner;
-function makeCache(load) {
-    const cache = {};
-    return {
-        get: (fullpath) => {
-            if (!cache[fullpath])
-                cache[fullpath] = load(fullpath);
-            return cache[fullpath];
-        },
-        remove: (fullpath) => delete cache[fullpath],
-        clear: () => Object.keys(cache).forEach(k => delete cache[k]),
-    };
-}
-function union(a, b) {
-    return new Set([...a, ...b]);
-}
-function difference(a, b) {
-    const remaining = new Set(a);
-    const removed = new Set();
-    for (const item of b) {
-        if (remaining.delete(item))
-            removed.add(item);
-    }
-    return [remaining, removed];
-}