@the-w1zard/dx 1.0.13 → 1.0.14

package/dist/iterator.d.ts

@@ -0,0 +1,51 @@
+export declare class I2I<T = A> implements I2<T> {
+    private source;
+    private index;
+    private buffer;
+    private done;
+    constructor(source: Iterable<T> | Iterator<T>);
+    n: () => IteratorResult<T>;
+    r: (value?: A) => IteratorResult<T>;
+    f: (error?: A) => IteratorResult<T>;
+    next(): IteratorResult<T>;
+    return(value?: A): IteratorResult<T>;
+    throw(error?: A): IteratorResult<T>;
+    [Symbol.iterator](): this;
+    toArray(): AR<T>;
+    first(): T | UD;
+    last(): T | UD;
+    at(index: N): T | UD;
+    peek(): T | UD;
+    nextValue(): T | UD;
+    nextOr(value: T): T;
+    nextOrM(make: () => T): T;
+    nextOrThrow(error?: Error): T;
+    map<G>(fn: (value: T, index: N) => G): I2I<G>;
+    filter<S extends T>(pred: (value: T, index: N) => value is S): I2I<S>;
+    filter(pred: (value: T, index: N) => B): I2I<T>;
+    flatMap<G>(fn: (value: T, index: N) => Iterable<G> | Iterator<G>): I2I<G>;
+    flat<G>(this: I2I<Iterable<G> | Iterator<G>>): I2I<G>;
+    take(limit: N): I2I<T>;
+    drop(limit: N): I2I<T>;
+    unique<G = T>(fn?: (value: T, index: N) => G): I2I<T>;
+    chunk<G>(size: N): I2I<AR<T>>;
+    zip<G>(other: Iterable<G> | Iterator<G>): I2I<[T, G]>;
+    concat(...others: (Iterable<T> | Iterator<T>)[]): I2I<T>;
+    enumerate<G>(): I2I<[N, T]>;
+    find(pred: (value: T, index: N) => B): T | UD;
+    findIndex(pred: (value: T, index: N) => B): N;
+    some(pred: (value: T, index: N) => B): B;
+    every(pred: (value: T, index: N) => B): B;
+    reduce<G>(fn: (acc: G, value: T, index: N) => G, initial: G): G;
+    forEach(fn: (value: T, index: N) => void): void;
+    count(): N;
+    sum(fn?: (value: T) => N): N;
+    join(separator?: S): S;
+    partition(pred: (value: T, index: N) => B): [AR<T>, AR<T>];
+    group<G>(fn: (value: T, index: N) => G): Map<G, AR<T>>;
+    toSet(): Set<T>;
+    toMap<K, V = T>(keyFn: (value: T, index: N) => K, valueFn?: (value: T, index: N) => V): Map<K, V>;
+    isEmpty(): B;
+    exhaust(): void;
+    clone(): I2I<T>;
+}

package/dist/map.d.ts

@@ -0,0 +1,69 @@
+export declare const rv: <T>(v: UF<T>) => T;
+export declare const sameValue: (a: A, b: A) => B;
+export declare class M2I<H = A, T = A> extends Map<H, T> implements M2<H, T> {
+    #private;
+    f: (callbackfn: (value: T, key: H, map: Map<H, T>) => void, thisArg?: any) => void;
+    [Symbol.iterator](): MapIterator<[H, T]>;
+    on(fn: Sub<H, T>): () => V;
+    off(fn: Sub<H, T>): V;
+    batch(fn: () => V): this;
+    s(v: UF<T>, k: H): this;
+    mutate(k: H, fn: (old: T, has: true) => T): T | UD;
+    d(k: H): B;
+    c(): V;
+    dv(k: H, deps: AR<H>, fn: (...vals: AR<T>) => T): this;
+    dirty(...keys: AR<H>): this;
+    g(k: H): T | UD;
+    h(k: H): B;
+    $debug(limit?: N): this;
+    $strict(): this;
+    $history(): AR<M2Event<H, T>>;
+    $why(k: H): M2Event<H, T> | UD;
+    $diff(other: M2I<H, T>): {
+        add: AR<[H, T]>;
+        del: AR<H>;
+        chg: AR<[H, T, T]>;
+    };
+    entries(): MapIterator<[H, T]>;
+    keys(): MapIterator<H>;
+    values(): MapIterator<T>;
+    swap(value: UF<T>, key: H): T | UD;
+    take(k: H): T | UD;
+    peek(k: H): T | false;
+    getOrI(value: UF<T>, k: H): T;
+    getOrM(make: () => T, k: H): T;
+    update(k: H, fn: (old: T, has: B) => T, initial?: UF<T>): T;
+    setIfAbsent(value: UF<T>, k: H): B;
+    setIfPresent(value: UF<T>, k: H): B;
+    replace(value: UF<T>, k: H): B;
+    inc(key: H, by?: N): N;
+    touch(k: H): B;
+    mapValues<G>(fn: (v: T, k: H) => G): M2<H, G>;
+    mapKeys<G>(fn: (v: T, k: H) => G): M2<G, T>;
+    filterKV(pred: (v: T, k: H) => B): this;
+    filterKeys(pred: (v: T, k: H) => B): this;
+    partition(pred: (v: T, k: H) => B): [M2<H, T>, M2<H, T>];
+    find(pred: (v: T, k: H) => B): [H, T] | UD;
+    findKey(pred: (v: T, k: H) => B): H | UD;
+    findValue(pred: (v: T, k: H) => B): T | UD;
+    some(pred: (v: T, k: H) => B): B;
+    every(pred: (v: T, k: H) => B): B;
+    reduce<G>(fn: (acc: G, v: T, k: H) => G, initial: G): G;
+    forEachKV(fn: (v: T, k: H, map: this) => void): void;
+    invert(): M2<T, H>;
+    unique<G>(fn?: (v: T, k: H) => G): M2<G, T>;
+    pick(keys: Iterable<H>): M2<H, T>;
+    omit(keys: Iterable<H>): M2<H, T>;
+    merge(other: Iterable<readonly [H, T]>): this;
+    clearAndSet(entries: Iterable<readonly [H, T]>): this;
+    toObject(): OB<T>;
+    toValues(): A2I<T>;
+    toKeys(): A2I<H>;
+    toArray(): A2I<[H, T]>;
+    group<G>(fn: (v: T, k: H) => G): M2<G, A2<T>>;
+    clone(): this;
+    equals(other: M2I<H, T>): B;
+    static fromObject<X extends Record<S, A>>(obj: X): M2I<S, X[keyof X]>;
+    static fromEntries<H, T>(entries: I<readonly [H, T]>): M2I<H, T>;
+    static from<H, T>(map: RM<H, T>): M2I<H, T>;
+}

package/dist/map_bin.d.ts

@@ -0,0 +1,34 @@
+export declare class M2BINI<K = N, V = N> {
+    #private;
+    constructor(capacity?: number);
+    get size(): number;
+    get capacity(): number;
+    /** live backing buffer: floating-point value of slot i is buffer[i] */
+    get buffer(): Float64Array;
+    get(k: K): V | undefined;
+    has(k: K): boolean;
+    set(k: K, v: V): this;
+    delete(k: K): boolean;
+    clear(): void;
+    keys(): MapIterator<K>;
+    values(): MapIterator<V>;
+    entries(): MapIterator<[K, V]>;
+    [Symbol.iterator](): MapIterator<[K, V]>;
+    forEach(fn: (v: V, k: K, m: M2BINI<K, V>) => V, thisArg?: unknown): void;
+    /** read by pid */
+    g(pid: number): V | undefined;
+    /** write by pid */
+    s(v: number, pid: number): this;
+    /** read with fallback — the accumulator primitive */
+    getOr(pid: number, dflt?: number): number;
+    /** pid += delta, returns the new value */
+    add(pid: number, delta: number): number;
+    in(pid: number): boolean;
+    d(pid: number): boolean;
+    /** walk (pid, slot) without allocating an iterator */
+    forEachRaw(fn: (pid: number, slot: number) => void): void;
+    /** values for a list of pids, NaN where absent */
+    gather(pids: ArrayLike<number>, out?: Float64Array<ArrayBuffer>): Float64Array;
+}
+export interface M2BIN<K, V> extends M2BINI {
+}

package/dist/map_byte.d.ts

@@ -0,0 +1,91 @@
+type F64 = Float64Array;
+type V128 = N | F64;
+export type M2BEvent = {
+    op: "set" | "upd" | "del" | "dirty";
+    pid: N;
+    v?: V128;
+    prev?: V128;
+    has: B;
+    batch?: B;
+};
+type Sub = (e: M2BEvent) => V;
+export declare class M2BI {
+    #private;
+    readonly cap: N;
+    readonly stride: N;
+    readonly pidToSlot: I32;
+    readonly slotToPid: I32;
+    readonly vals: F64;
+    constructor(maxParticles?: N, stride?: N, seed?: I<readonly [N, V128]>);
+    get size(): N;
+    on(fn: Sub): () => V;
+    off(fn: Sub): V;
+    batch(fn: () => V): this;
+    s(v: V128, pid: N): this;
+    mutate(pid: N, fn: (old: V128, has: true) => V128): V128 | UD;
+    d(pid: N): B;
+    c(): V;
+    dv(pid: N, deps: AR<N>, fn: (...vals: AR<V128>) => V128): this;
+    dirty(...pids: AR<N>): this;
+    g(pid: N): V128 | UD;
+    h(pid: N): B;
+    $debug(limit?: N): this;
+    $strict(): this;
+    $history(): AR<M2BEvent>;
+    $why(pid: N): M2BEvent | UD;
+    $diff(other: M2BI): {
+        add: AR<[number, V128]>;
+        del: AR<number>;
+        chg: AR<[number, V128, V128]>;
+    };
+    entries(): Generator<[N, V128]>;
+    keys(): Generator<N>;
+    values(): Generator<V128>;
+    [Symbol.iterator](): Generator<[N, V128]>;
+    has: (pid: N) => B;
+    get: (pid: N) => V128 | UD;
+    delete: (pid: N) => B;
+    clear: () => V;
+    f: (fn: (v: V128, pid: N, map: this) => V) => V;
+    forEach(fn: (v: V128, pid: N, map: this) => V): V;
+    swap(value: V128, pid: N): V128 | UD;
+    take(pid: N): V128 | UD;
+    peek(pid: N): V128 | false;
+    getOrI(value: V128, pid: N): V128;
+    getOrM(make: () => V128, pid: N): V128;
+    update(pid: N, fn: (old: V128, has: B) => V128, initial?: V128): V128;
+    setIfAbsent(value: V128, pid: N): B;
+    setIfPresent(value: V128, pid: N): B;
+    replace(value: V128, pid: N): B;
+    inc(pid: N, by?: N): N;
+    touch(pid: N): B;
+    mapValues(fn: (v: V128, pid: N) => V128): M2BI;
+    mapKeys(fn: (v: V128, pid: N) => N): M2BI;
+    filterKV(pred: (v: V128, pid: N) => B): this;
+    filterKeys(pred: (v: V128, pid: N) => B): this;
+    partition(pred: (v: V128, pid: N) => B): [M2BI, M2BI];
+    find(pred: (v: V128, pid: N) => B): [N, V128] | UD;
+    findKey(pred: (v: V128, pid: N) => B): N | UD;
+    findValue(pred: (v: V128, pid: N) => B): V128 | UD;
+    some(pred: (v: V128, pid: N) => B): B;
+    every(pred: (v: V128, pid: N) => B): B;
+    reduce<G>(fn: (acc: G, v: V128, pid: N) => G, initial: G): G;
+    forEachKV(fn: (v: V128, pid: N, map: this) => V): V;
+    invert(): M2<V128, N>;
+    unique(fn?: (v: V128, pid: N) => N): M2BI;
+    pick(pids: Iterable<N>): M2BI;
+    omit(pids: Iterable<N>): M2BI;
+    merge(other: Iterable<readonly [N, V128]>): this;
+    clearAndSet(entries: Iterable<readonly [N, V128]>): this;
+    toObject(): OB<V128>;
+    toValues(): AR<V128>;
+    toKeys(): AR<N>;
+    toArray(): AR<[N, V128]>;
+    group<G>(fn: (v: V128, pid: N) => G): Map<G, AR<V128>>;
+    clone(): this;
+    equals(other: M2BI): B;
+    static fromObject(obj: Record<N, V128>, maxParticles: N, stride?: N): M2BI;
+    static fromEntries(entries: I<readonly [N, V128]>, maxParticles: N, stride?: N): M2BI;
+    static from(map: RM<N, V128>, maxParticles: N, stride?: N): M2BI;
+}
+export {};

package/dist/map_dense.d.ts

@@ -0,0 +1,33 @@
+export declare class M2DI<Key = A, V = number> {
+    #private;
+    constructor(capacity?: number);
+    get size(): N;
+    get capacity(): N;
+    /** live backing buffer: value of pid p is buffer[p], valid where live[p] === 1 */
+    get buffer(): F64;
+    get live(): U8;
+    get(k: number): V | UD;
+    has(k: number): boolean;
+    set(k: number, v: V): this;
+    delete(k: number): B;
+    clear(): void;
+    keys(): MapIterator<N>;
+    values(): MapIterator<V>;
+    entries(): MapIterator<[N, V]>;
+    [Symbol.iterator](): MapIterator<[N, V]>;
+    forEach(fn: (v: V, k: N, m: M<N, V>) => V, thisArg?: U): void;
+    /** read by pid — no typeof guard: pids are numbers */
+    g(pid: N): V | UD;
+    /** write by pid */
+    s(v: N, pid: N): this;
+    getOr(pid: N, dflt?: number): N;
+    /** pid += delta, returns the new value */
+    add(pid: N, delta: N): N;
+    in(pid: N): B;
+    /** walk live pids without allocating an iterator */
+    forEachRaw(fn: (pid: N, value: N) => V): void;
+    /** values for a list of pids, NaN where absent */
+    gather(pids: ArrayLike<N>, out?: Float64Array<ArrayBuffer>): Float64Array;
+}
+export interface M2D<K, V> extends M2DI<K, V> {
+}

package/dist/map_rows.d.ts

@@ -0,0 +1,33 @@
+export declare class M2RI<K = N> {
+    #private;
+    readonly stride: N;
+    constructor(capacity?: number, stride?: number);
+    get size(): N;
+    get capacity(): N;
+    get buffer(): Float64Array;
+    get(pid: N): Float64Array | UD;
+    has(pid: N): boolean;
+    set(pid: N, v: Float64Array | ArrayLike<N>): this;
+    delete(pid: N): boolean;
+    clear(): void;
+    /** copy a row in, no validation per component */
+    write(pid: N, v: Float64Array | ArrayLike<N>): V;
+    /** single component: row[c] = v */
+    put(pid: N, c: N, v: N): V;
+    /** single component: row[c] */
+    at(pid: N, c: N): N;
+    /** pid -> slot, or -1 */
+    slotOf(pid: N): N;
+    /** zero-copy row view you can write through */
+    row(pid: N): F64 | UD;
+    /** view over the live prefix of the whole table — feed straight to a shader/worker */
+    live(): F64;
+    keys(): MapIterator<K>;
+    values(): MapIterator<F64>;
+    entries(): MapIterator<[K, F64]>;
+    [Symbol.iterator](): MapIterator<[K, F64]>;
+    forEach(fn: (v: F64, k: K, m: M2RI<K>) => V, thisArg?: U): V;
+    forEachRaw(fn: (pid: N, slot: N) => V): V;
+}
+export interface M2R<K> extends M2RI {
+}

package/dist/number.d.ts

@@ -0,0 +1,44 @@
+export declare class N2I extends Number implements N2 {
+    abs(): N2I;
+    sign(): N2I;
+    neg(): N2I;
+    inv(): N2I;
+    clamp(min: N, max: N): N2I;
+    wrap(min: N, max: N): N2I;
+    lerp(to: N, t: N): N2I;
+    map(inMin: N, inMax: N, outMin: N, outMax: N): N2I;
+    remap(inMin: N, inMax: N, outMin: N, outMax: N): N2I;
+    roundTo(precision?: N): N2I;
+    floorTo(precision?: N): N2I;
+    ceilTo(precision?: N): N2I;
+    truncTo(precision?: N): N2I;
+    isFinite(): B;
+    isInteger(): B;
+    isSafeInteger(): B;
+    isNaN(): B;
+    isBetween(min: N, max: N, inclusive?: B): B;
+    isPositive(): B;
+    isNegative(): B;
+    isZero(): B;
+    isEven(): B;
+    isOdd(): B;
+    squared(): N2I;
+    cubed(): N2I;
+    sqrt(): N2I;
+    cbrt(): N2I;
+    pow(exponent: N): N2I;
+    root(degree: N): N2I;
+    mod(divisor: N): N2I;
+    percentOf(total: N): N2I;
+    percentChange(from: N): N2I;
+    toRadians(): N2I;
+    toDegrees(): N2I;
+    toOrdinal(): S;
+    toBytes(unit?: N, decimals?: N): S;
+    toCompact(locales?: Intl.LocalesArgument): S;
+    toCurrency(currency?: S, locales?: Intl.LocalesArgument): S;
+    toPercent(decimals?: N, locales?: Intl.LocalesArgument): S;
+    times(fn: (index: N) => void): this;
+    upTo(end: N, step?: N): AR<N>;
+    downTo(end: N, step?: N): AR<N>;
+}

package/dist/object.d.ts

@@ -0,0 +1,35 @@
+export declare class O2I {
+    static isEmpty(value: object): B;
+    static isNotEmpty(value: object): B;
+    static size(value: object): N;
+    static isPlainObject(value: unknown): B;
+    static isObject(value: unknown): B;
+    static get<X = unknown>(value: unknown, path: string | readonly PropertyKey[], fallback?: X): unknown | X;
+    static getOr<X>(value: unknown, path: string | readonly PropertyKey[], fallback: X): X;
+    static set<T extends object>(value: T, path: string | readonly PropertyKey[], next: unknown): T;
+    static unset(value: object, path: string | readonly PropertyKey[]): B;
+    static hasPath(value: unknown, path: string | readonly PropertyKey[]): B;
+    static clone<T>(value: T): T;
+    static deepClone<T>(value: T): T;
+    static deepMerge<T extends object, U extends object>(target: T, source: U): T & U;
+    static defaults<T extends object, U extends object>(target: T, defaults: U): T & U;
+    static getOrCreate<T extends object, K extends PropertyKey, X>(value: T, key: K, create: () => X): T & Record<K, X>;
+    static pick<T extends object, K extends keyof T>(value: T, keys: readonly K[]): Pick<T, K>;
+    static omit<T extends object, K extends keyof T>(value: T, keys: readonly K[]): Omit<T, K>;
+    static pickBy<T extends object>(value: T, predicate: (value: T[keyof T], key: keyof T) => B): Partial<T>;
+    static omitBy<T extends object>(value: T, predicate: (value: T[keyof T], key: keyof T) => B): Partial<T>;
+    static mapKeys<T extends object, K extends PropertyKey>(value: T, mapper: (key: keyof T, value: T[keyof T]) => K): Partial<Record<K, T[keyof T]>>;
+    static mapValues<T extends object, X>(value: T, mapper: (value: T[keyof T], key: keyof T) => X): {
+        [K in keyof T]: X;
+    };
+    static mapEntries<T extends object, K extends PropertyKey, X>(value: T, mapper: (entry: [keyof T, T[keyof T]]) => readonly [K, X]): Partial<Record<K, X>>;
+    static filter<T extends object>(value: T, predicate: (value: T[keyof T], key: keyof T) => B): Partial<T>;
+    static isEqual(first: unknown, second: unknown): B;
+    static isShallowEqual(first: object, second: object): B;
+    static hasAll<T extends object>(value: T, keys: readonly PropertyKey[]): B;
+    static hasAny<T extends object>(value: T, keys: readonly PropertyKey[]): B;
+    static assertKeys<T extends object>(value: T, keys: readonly PropertyKey[]): asserts value is T;
+    static with<T extends object, K extends keyof T>(value: T, key: K, next: T[K]): T;
+    static without<T extends object, K extends keyof T>(value: T, key: K): Omit<T, K>;
+    static update<T extends object, K extends keyof T>(value: T, key: K, updater: (current: T[K]) => T[K]): T;
+}

package/dist/promise.d.ts

@@ -0,0 +1,62 @@
+export declare class P2I<T = A> extends Promise<T> implements P2<T> {
+    #private;
+    constructor(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: A) => void) => void);
+    static get [Symbol.species](): PromiseConstructor;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): P2I<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): P2I<T | TResult>;
+    finally(onfinally?: (() => void) | null): P2I<T>;
+    status(): "pending" | "fulfilled" | "rejected";
+    isPending(): B;
+    isFulfilled(): B;
+    isRejected(): B;
+    value(): T | UD;
+    error(): A | UD;
+    elapsed(): N | UD;
+    static resolve(): P2I<void>;
+    static resolve<T>(value: T | PromiseLike<T>): P2I<Awaited<T>>;
+    static reject<T = never>(reason?: A): P2I<T>;
+    static all<T extends readonly unknown[] | []>(values: T): P2I<{
+        -readonly [P in keyof T]: Awaited<T[P]>;
+    }>;
+    static allSettled<T extends readonly unknown[] | []>(values: T): P2I<{
+        -readonly [P in keyof T]: PromiseSettledResult<Awaited<T[P]>>;
+    }>;
+    static race<T extends readonly unknown[] | []>(values: T): P2I<Awaited<T[number]>>;
+    static any<T extends readonly unknown[] | []>(values: T): P2I<Awaited<T[number]>>;
+    static retry<T>(fn: () => T | PromiseLike<T>, times?: N, delay?: N): P2I<Awaited<T>>;
+    static deferred<T = A>(): {
+        promise: P2I<T>;
+        resolve: (value: T | PromiseLike<T>) => void;
+        reject: (reason?: A) => void;
+    };
+    static try<T>(fn: () => T | PromiseLike<T>): P2I<Awaited<T>>;
+    static sleep(ms: N): P2I<void>;
+    static fromCallback<T>(fn: (cb: (err: A, value?: T) => void) => void): P2I<T>;
+    static mapLimit<T, G>(items: AR<T>, limit: N, fn: (item: T, index: N) => G | PromiseLike<G>): P2I<AR<G>>;
+    static series<T>(fns: AR<() => T | PromiseLike<T>>): P2I<AR<T>>;
+    tap(fn: (value: T) => unknown): P2I<T>;
+    tapError(fn: (error: A) => unknown): P2I<T>;
+    recover(fn: (error: A) => T | PromiseLike<T>): P2I<T>;
+    fallback(value: T | PromiseLike<T>): P2I<T>;
+    timeout(ms: N, error?: A): P2I<T>;
+    delay(ms: N): P2I<T>;
+    withDeadline(deadline: N, error?: A): P2I<T>;
+    map<G>(fn: (value: T) => G | PromiseLike<G>): P2I<Awaited<G>>;
+    flatMap<G>(fn: (value: T) => G | PromiseLike<G>): P2I<Awaited<G>>;
+    or<G>(other: G | PromiseLike<G>): P2I<T | Awaited<G>>;
+    and<G>(other: G | PromiseLike<G>): P2I<[T, Awaited<G>]>;
+    zip<G>(other: PromiseLike<G>): P2I<[T, Awaited<G>]>;
+    unwrap(): Promise<T>;
+    toResult(): P2I<{
+        ok: true;
+        value: T;
+    } | {
+        ok: false;
+        error: A;
+    }>;
+    onResolve(fn: (value: T) => unknown): P2I<T>;
+    onReject(fn: (error: A) => unknown): P2I<T>;
+    finallyDo(fn: () => unknown): P2I<T>;
+    $label(name: S): this;
+    $debug(): this;
+}

package/dist/reg_ex.d.ts

@@ -0,0 +1,72 @@
+export declare class REC2 implements RE2_IF {
+    #private;
+    constructor(source: S, flags?: S);
+    get source(): S;
+    get flags(): S;
+    get global(): B;
+    get ignoreCase(): B;
+    get multiline(): B;
+    get sticky(): B;
+    get unicode(): B;
+    get dotAll(): B;
+    get hasIndices(): B;
+    toRegExp(): RegExp;
+    test(str: S): B;
+    h(str: S): B;
+    exec(str: S): RegExpExecArray | null;
+    g(str: S): S | UD;
+    at(str: S, n: N): S | UD;
+    groups(str: S): OB<S> | UD;
+    group(str: S, name: S | N): S | UD;
+    index(str: S): N;
+    lastIndexOf(str: S): N;
+    span(str: S): [N, N] | UD;
+    all(str: S): AR<S>;
+    matches(str: S): AR<RE2Match>;
+    allGroups(str: S): AR<OB<S>>;
+    allSpans(str: S): AR<[N, N]>;
+    count(str: S): N;
+    positions(str: S): AR<N>;
+    replace(str: S, fn: S | RE2ReplaceFn): S;
+    replaceFirst(str: S, fn: S | RE2ReplaceFn): S;
+    replaceAt(str: S, n: N, fn: S | RE2ReplaceFn): S;
+    remove(str: S): S;
+    removeFirst(str: S): S;
+    split(str: S, limit?: N): AR<S>;
+    splitKeep(str: S): AR<S>;
+    withFlags(flags: S): RE2_IF;
+    addFlag(flag: RE2Flag): RE2_IF;
+    removeFlag(flag: RE2Flag): RE2_IF;
+    toggleFlag(flag: RE2Flag): RE2_IF;
+    withSource(src: S): RE2_IF;
+    and(...parts: AR<RE2Input>): RE2_IF;
+    or(...parts: AR<RE2Input>): RE2_IF;
+    cap(expr?: RE2Input): RE2_IF;
+    namedGroup(name: S, expr: RE2Input): RE2_IF;
+    nonCap(expr: RE2Input): RE2_IF;
+    lookahead(expr: RE2Input): RE2_IF;
+    notLookahead(expr: RE2Input): RE2_IF;
+    lookbehind(expr: RE2Input): RE2_IF;
+    notLookbehind(expr: RE2Input): RE2_IF;
+    optional(expr?: RE2Input): RE2_IF;
+    many(expr?: RE2Input): RE2_IF;
+    maybeMany(expr?: RE2Input): RE2_IF;
+    repeat(n: N, max?: N, expr?: RE2Input): RE2_IF;
+    /**
+     * [BEST-EFFORT] Appends `?` after a trailing `*`/`+`/`?`/`{n,m}` to make it lazy.
+     * Only looks at the END of the source — it's not a regex parser, it won't find
+     * quantifiers buried mid-pattern. Meant to be chained right after .optional()/
+     * .many()/.maybeMany()/.repeat(), where the quantifier IS the last token.
+     * If no trailing quantifier is found, returns an unchanged clone.
+     */
+    lazy(): RE2_IF;
+    $trace(str: S): AR<RE2Match>;
+    $explain(): AR<S>;
+    $risky(): B;
+    $bench(str: S, iterations?: N): N;
+    toString(): S;
+    equals(other: RE2Input): B;
+    clone(): RE2_IF;
+    static fromRegExp(re: RegExp): REC2;
+}
+export declare const RECC2: RE2Static;

package/dist/set.d.ts

@@ -0,0 +1,41 @@
+import { M2I } from "./map";
+export declare class SET2I<T = A> extends Set<T> implements SET2<T> {
+    s: (value: T) => this;
+    take(value: T): T | UD;
+    peek(value: T): T | false;
+    toggle(value: T): B;
+    first(): T | UD;
+    last(): T | UD;
+    union(other: Iterable<T>): SET2I<T>;
+    intersection(other: Iterable<T>): SET2I<T>;
+    difference(other: Iterable<T>): SET2I<T>;
+    symmetricDifference(other: Iterable<T>): SET2I<T>;
+    isSubsetOf(other: Iterable<T>): B;
+    isSupersetOf(other: Iterable<T>): B;
+    isDisjointFrom(other: Iterable<T>): B;
+    equals(other: Iterable<T>): B;
+    filter(fn: (v: T, set: this) => B): SET2I<T>;
+    map<R>(fn: (v: T, set: this) => R): SET2I<R>;
+    partition(fn: (v: T, set: this) => B): [SET2I<T>, SET2I<T>];
+    differenceBy<K>(other: Iterable<T>, fn: (v: T) => K): SET2I<T>;
+    uniqueBy<K>(fn: (v: T) => K): SET2I<T>;
+    find(fn: (v: T, set: this) => B): T | UD;
+    every(fn: (v: T, set: this) => B): B;
+    some(fn: (v: T, set: this) => B): B;
+    reduce<R>(fn: (acc: R, v: T, set: this) => R, initial: R): R;
+    addAll(values: Iterable<T>): this;
+    deleteAll(values: Iterable<T>): N;
+    retainAll(values: Iterable<T>): this;
+    update(values: Iterable<T>): this;
+    replace(values: Iterable<T>): this;
+    swap(a: T, b: T): B;
+    clone(): this;
+    toArray(): T[];
+    toMap<K, R>(fn: (v: T) => readonly [K, R]): M2I<K, R>;
+    toObject(fn?: (v: T) => S): OB<T>;
+    toJSON(): T[];
+    static fromArray<T>(values: T[]): SET2I<T>;
+    static fromObject<O extends Record<string, A>>(obj: O): SET2I<O[keyof O]>;
+    static fromEntries<T>(entries: Iterable<readonly [unknown, T]>): SET2I<T>;
+    static from<T>(values: Iterable<T>): SET2I<T>;
+}

package/dist/set_byte.d.ts

@@ -0,0 +1,55 @@
+export declare class SET2BI {
+    #private;
+    readonly cap: N;
+    readonly flags: Uint8Array;
+    readonly slots: I32;
+    readonly pidToIdx: I32;
+    constructor(maxParticles?: N, seed?: Iterable<N>);
+    get size(): N;
+    s: (pid: N) => this;
+    add(pid: N): this;
+    has(pid: N): B;
+    delete(pid: N): B;
+    clear(): V;
+    [Symbol.iterator](): Generator<N>;
+    values(): Generator<N>;
+    keys(): Generator<N>;
+    entries(): Generator<[N, N]>;
+    take(pid: N): N | UD;
+    peek(pid: N): N | false;
+    toggle(pid: N): B;
+    first(): N | UD;
+    last(): N | UD;
+    union(other: Iterable<N>): SET2BI;
+    intersection(other: Iterable<N>): SET2BI;
+    difference(other: Iterable<N>): SET2BI;
+    symmetricDifference(other: Iterable<N>): SET2BI;
+    isSubsetOf(other: Iterable<N>): B;
+    isSupersetOf(other: Iterable<N>): B;
+    isDisjointFrom(other: Iterable<N>): B;
+    equals(other: Iterable<N>): B;
+    filter(fn: (pid: N, set: this) => B): SET2BI;
+    map(fn: (pid: N, set: this) => N): SET2BI;
+    partition(fn: (pid: N, set: this) => B): [SET2BI, SET2BI];
+    differenceBy<G>(other: Iterable<N>, fn: (pid: N) => G): SET2BI;
+    uniqueBy<G>(fn: (pid: N) => G): SET2BI;
+    find(fn: (pid: N, set: this) => B): N | UD;
+    every(fn: (pid: N, set: this) => B): B;
+    some(fn: (pid: N, set: this) => B): B;
+    reduce<G>(fn: (acc: G, pid: N, set: this) => G, initial: G): G;
+    addAll(pids: Iterable<N>): this;
+    deleteAll(pids: Iterable<N>): N;
+    retainAll(pids: Iterable<N>): this;
+    update(pids: Iterable<N>): this;
+    replace(pids: Iterable<N>): this;
+    swap(a: N, b: N): B;
+    clone(): SET2BI;
+    toArray(): AR<N>;
+    toMap<K, T>(fn: (pid: N) => [K, T]): Map<K, T>;
+    toObject(fn?: (pid: N) => S): OB<N>;
+    toJSON(): AR<N>;
+    static fromArray(pids: AR<N>, maxParticles?: N): SET2BI;
+    static fromObject(obj: Record<S, N>, maxParticles?: N): SET2BI;
+    static fromEntries(entries: I<readonly [A, N]>, maxParticles?: N): SET2BI;
+    static from(pids: Iterable<N>, maxParticles?: N): SET2BI;
+}

package/dist/soa_codec.d.ts

@@ -0,0 +1,12 @@
+export declare class SOA_CODEC {
+    readonly maxPids: number;
+    readonly channelMap: Int32Array;
+    readonly subChannelMap: Int32Array;
+    readonly tripChannelMap: Int32Array;
+    readonly keyMap: Int32Array;
+    readonly listeners: Array<((pid: number, val?: number) => void) | undefined>;
+    nextPid: number;
+    constructor(maxPids?: number);
+    allocatePid(rId: number, mId: number, sId: number, kId: number): number;
+}
+export declare const soa_codeci: SOA_CODEC;