@isopodlabs/utilities 1.5.9 → 1.6.0

package/dist/bits.d.ts

@@ -1,5 +1,6 @@
 export declare function lowestSet32(x: number): number;
 export declare function highestSet32(x: number): number;
+export declare function highestSet1024(x: number): number;
 export declare function countSet32(x: number): number;
 export declare function nthSet32(x: number, i: number): number;
 export declare function highestSet(x: bigint | number): number;
@@ -12,108 +13,137 @@ export declare function countClear(x: bigint | number): number;
 export declare function clearLowest(x: bigint): bigint;
 export declare function clearLowest(x: number): number;
 export declare function clearLowest(x: bigint | number): bigint | number;
-export interface immutableBitSet {
+export interface ImmutableBitSet {
     test(a: number): boolean;
     countSet(): number;
     nthSet(a: number): number;
-    complement(): this;
-    intersect(other: this): this;
-    union(other: this): this;
-    xor(other: this): this;
+    complement(): ImmutableBitSet;
+    intersect(other: this): ImmutableBitSet;
+    union(other: this): ImmutableBitSet;
+    xor(other: this): ImmutableBitSet;
     contains(other: this): boolean;
     next(a: number, set: boolean): number;
-    where(set: boolean, from?: number): {
+    where(set: boolean, from?: number, to?: number): {
         [Symbol.iterator](): Generator<number>;
     };
     ranges(): {
         [Symbol.iterator](): Generator<number[]>;
     };
+    slice(from: number, to?: number): ImmutableBitSet;
     [Symbol.iterator](): Generator<number>;
 }
-export interface BitSet extends immutableBitSet {
+export interface BitSet extends ImmutableBitSet {
     set(a: number): void;
     clear(a: number): void;
     setRange(a: number, b: number): this;
     clearRange(a: number, b: number): this;
-    selfComplement(): this;
+    selfComplement?(): this;
     selfIntersect(other: this): this;
     selfUnion(other: this): this;
     selfXor(other: this): this;
 }
-export declare class ImmutableSparseBits implements immutableBitSet {
+export declare class ImmutableDenseBits implements ImmutableBitSet {
+    protected bits: bigint;
+    constructor(bits?: bigint);
+    protected create(bits?: bigint): this;
+    get length(): number;
+    test(a: number): boolean;
+    countSet(): number;
+    nthSet(a: number): number;
+    complement(): this;
+    intersect(other: ImmutableDenseBits): this;
+    union(other: ImmutableDenseBits): this;
+    xor(other: ImmutableDenseBits): this;
+    contains(other: this): boolean;
+    next(a: number, set?: boolean): number;
+    where(set: boolean, from?: number, to?: number): {
+        [Symbol.iterator](): Generator<number>;
+    };
+    ranges(): {
+        [Symbol.iterator](): Generator<number[]>;
+    };
+    [Symbol.iterator](): Generator<number>;
+    toSparse(): SparseBits2;
+    slice(from: number, to?: number): ImmutableBitSet;
+}
+export declare class DenseBits extends ImmutableDenseBits implements BitSet {
+    protected setMask(m: bigint): void;
+    protected clearMask(m: bigint): void;
+    set(a: number): void;
+    clear(a: number): void;
+    setRange(a: number, b: number): this;
+    clearRange(a: number, b: number): this;
+    selfComplement(): this;
+    selfIntersect(other: DenseBits): this;
+    selfUnion(other: DenseBits): this;
+    selfXor(other: DenseBits): this;
+}
+export declare class ImmutableSparseBits implements ImmutableBitSet {
     protected bits: number[];
-    protected undef: number;
-    static whereGenerator(bits: number[], undef: number, set: boolean, from?: number): Generator<number>;
-    constructor(initial?: boolean);
-    protected create(init?: boolean): this;
-    protected copyUndefined(other: ImmutableSparseBits): this;
-    protected flipUndefined(other: ImmutableSparseBits): this;
-    static fromEntries<T extends ImmutableSparseBits>(this: new (initial?: boolean) => T, entries: Record<number, number> | [number, number][], initial?: boolean): T;
+    constructor(bits?: number[]);
+    protected create(bits?: number[]): this;
+    static fromEntries<T extends ImmutableSparseBits>(this: new (...args: any[]) => T, entries: Record<number, number> | [number, number][], ...args: any[]): T;
     keys(): number[];
     entries(): [number, number][];
     test(a: number): boolean;
     countSet(): number;
     nthSet(a: number): number;
-    complement(): this;
+    complement(): ImmutableSparseBits2;
     intersect(other: ImmutableSparseBits): this;
     union(other: ImmutableSparseBits): this;
     xor(other: ImmutableSparseBits): this;
     contains(other: ImmutableSparseBits): boolean;
-    next(a: number, set?: boolean): number;
-    where(set: boolean, from?: number): {
-        [Symbol.iterator]: () => Generator<number, any, any>;
+    next(from: number, set?: boolean): number;
+    where(set: boolean, from?: number, to?: number): {
+        [Symbol.iterator]: () => Generator<number, void, unknown>;
     };
     ranges(): {
-        [Symbol.iterator](): Generator<number[]>;
+        [Symbol.iterator]: () => Generator<number[], void, unknown>;
     };
     [Symbol.iterator](): Generator<number>;
     clean(): this;
     toDense(): DenseBits;
+    slice(from: number, to?: number): ImmutableBitSet;
 }
 export declare class SparseBits extends ImmutableSparseBits implements BitSet {
-    private setMask;
-    private clearMask;
     set(a: number): void;
     clear(a: number): void;
     setRange(a: number, b: number): this;
     clearRange(a: number, b: number): this;
-    selfComplement(): this;
     selfIntersect(other: SparseBits): this;
     selfUnion(other: SparseBits): this;
     selfXor(other: SparseBits): this;
 }
-export declare class ImmutableDenseBits implements immutableBitSet {
-    protected bits: bigint;
-    constructor(bits?: bigint);
-    protected create(bits?: bigint): this;
-    get length(): number;
+export declare class ImmutableSparseBits2 extends ImmutableSparseBits {
+    protected undef: number;
+    constructor(bits?: number[], initial?: boolean);
+    protected create(bits?: number[], init?: boolean): this;
     test(a: number): boolean;
-    countSet(): number;
     nthSet(a: number): number;
     complement(): this;
-    intersect(other: ImmutableDenseBits): this;
-    union(other: ImmutableDenseBits): this;
-    xor(other: ImmutableDenseBits): this;
-    contains(other: this): boolean;
-    next(a: number, set?: boolean): number;
-    where(set: boolean, from?: number): {
-        [Symbol.iterator](): Generator<number>;
+    intersect(other: ImmutableSparseBits2): this;
+    union(other: ImmutableSparseBits2): this;
+    xor(other: ImmutableSparseBits2): this;
+    contains(other: ImmutableSparseBits2): boolean;
+    next(from: number, set?: boolean): number;
+    where(set: boolean, from?: number, to?: number): {
+        [Symbol.iterator]: () => Generator<number, void, unknown>;
     };
     ranges(): {
-        [Symbol.iterator](): Generator<number[]>;
+        [Symbol.iterator]: () => Generator<number[], void, unknown>;
     };
     [Symbol.iterator](): Generator<number>;
-    toSparse(): SparseBits;
+    clean(): this;
+    toDense(): DenseBits;
+    slice(from: number, to?: number): ImmutableBitSet;
 }
-export declare class DenseBits extends ImmutableDenseBits implements BitSet {
-    protected setMask(m: bigint): void;
-    protected clearMask(m: bigint): void;
+export declare class SparseBits2 extends ImmutableSparseBits2 implements BitSet {
     set(a: number): void;
     clear(a: number): void;
     setRange(a: number, b: number): this;
     clearRange(a: number, b: number): this;
     selfComplement(): this;
-    selfIntersect(other: DenseBits): this;
-    selfUnion(other: DenseBits): this;
-    selfXor(other: DenseBits): this;
+    selfIntersect(other: SparseBits2): this;
+    selfUnion(other: SparseBits2): this;
+    selfXor(other: SparseBits2): this;
 }

package/dist/bits.js

@@ -1,8 +1,12 @@
 "use strict";
+//-----------------------------------------------------------------------------
+// Bit twiddling functions
+//-----------------------------------------------------------------------------
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DenseBits = exports.ImmutableDenseBits = exports.SparseBits = exports.ImmutableSparseBits = void 0;
+exports.SparseBits2 = exports.ImmutableSparseBits2 = exports.SparseBits = exports.ImmutableSparseBits = exports.DenseBits = exports.ImmutableDenseBits = void 0;
 exports.lowestSet32 = lowestSet32;
 exports.highestSet32 = highestSet32;
+exports.highestSet1024 = highestSet1024;
 exports.countSet32 = countSet32;
 exports.nthSet32 = nthSet32;
 exports.highestSet = highestSet;
@@ -13,10 +17,6 @@ exports.highestClear = highestClear;
 exports.lowestClear = lowestClear;
 exports.countClear = countClear;
 exports.clearLowest = clearLowest;
-const algorithm_1 = require("./algorithm");
-//-----------------------------------------------------------------------------
-// Bit twiddling functions
-//-----------------------------------------------------------------------------
 // Returns the index (0-31) of the lowest set bit, or 32 if none
 function lowestSet32(x) {
     return x === 0 ? 32 : 31 - Math.clz32(x & -x);
@@ -25,6 +25,10 @@ function lowestSet32(x) {
 function highestSet32(x) {
     return x ? 32 - Math.clz32(x) : 0;
 }
+function highestSet1024(x) {
+    let b = Math.floor(Math.log2(x));
+    return 1n << BigInt(b) <= x ? b + 1 : b;
+}
 // Returns the number of set bits
 function countSet32(x) {
     x = x - ((x >> 1) & 0x55555555);
@@ -121,45 +125,59 @@ export function bitcountCached(x: bigint): number {
     return Number(x & 0xFFFFFFFFn);
 }
 */
-function highestSetBig(x) {
+/*
+function highestSetBig32(x: bigint): number {
     let s = 0;
     let k = 0;
+
     for (let t = x >> 32n; t; t >>= BigInt(s)) {
         s = 32 << k++;
         x = t;
     }
+
     if (k) {
-        // determine length by bisection
-        k--;
-        while (k--) {
-            const b = x >> BigInt(32 << k);
+        while (--k) {
+            const b = x >> BigInt(16 << k);
             if (b) {
-                s += 32 << k;
+                s += 16 << k;
                 x = b;
             }
         }
     }
     return (s + 32) - Math.clz32(Number(x));
 }
+*/
+function highestSetBig1024(x) {
+    let s = 0;
+    let k = 0;
+    for (let t = x >> 1024n; t; t >>= BigInt(s)) {
+        s = 1024 << k++;
+        x = t;
+    }
+    if (k) {
+        while (--k) {
+            const b = x >> BigInt(512 << k);
+            if (b) {
+                s += 512 << k;
+                x = b;
+            }
+        }
+    }
+    return highestSet1024(Number(x)) + s;
+}
 function highestSet(x) {
     if (x < 0)
         x = ~x;
-    if (x < 0x100000000)
-        return highestSet32(Number(x));
-    // For < 1024 bits, use log2
-    if (x <= Number.MAX_VALUE) {
-        const b = Math.floor(Math.log2(Number(x)));
-        return (1n << BigInt(b)) <= x ? b + 1 : b;
-    }
-    return highestSetBig(BigInt(x));
+    return x < 0x100000000 ? highestSet32(Number(x))
+        : x <= Number.MAX_VALUE ? highestSet1024(Number(x))
+            : highestSetBig1024(BigInt(x));
 }
 function lowestSet(x) {
-    if (x < 0)
-        x = ~x;
-    if (x < 0x100000000)
-        return lowestSet32(Number(x));
-    x = BigInt(x);
-    return highestSetBig(x & -x) - 1;
+    if (typeof x === 'number') {
+        x = x < 0 ? (~x & (x + 1)) : x & -x;
+        return (x < 0x100000000 ? highestSet32(x) : highestSet1024(x)) - 1;
+    }
+    return highestSetBig1024(x < 0 ? (~x & (x + 1n)) : x & -x) - 1;
 }
 function countSet(x) {
     if (x < 0)
@@ -237,487 +255,633 @@ function clearLowest(x) {
     return typeof x === 'bigint' ? x & (x - 1n) : x & (x - 1);
 }
 //-----------------------------------------------------------------------------
-// SparseBits - a sparse bitset implementation, where each entry in the 'bits' array represents 32 bits
-// The 'undef' member indicates whether undefined entries are treated as 0 or 0xffffffff
+// DenseBits - a dense bitset implementation using bigint
 //-----------------------------------------------------------------------------
-class ImmutableSparseBits {
-    bits = []; //each entry represents 32 bits
-    undef;
-    static *whereGenerator(bits, undef, set, from = -1) {
-        ++from;
-        if (undef ? !set : set) {
-            const keys = Object.keys(bits).map(k => +k);
-            if (keys.length === 0)
-                return;
-            const i = from >> 5;
-            let k = (0, algorithm_1.lowerBound)(keys, i);
-            let v = bits[keys[k]] ^ undef;
-            if (keys[k] === i)
-                v &= -(1 << (from & 0x1f));
-            for (;;) {
-                const i = keys[k];
-                while (v) {
-                    yield (i << 5) + lowestSet32(v);
-                    v = v & (v - 1);
+class ImmutableDenseBits {
+    bits;
+    constructor(bits = 0n) {
+        this.bits = bits;
+    }
+    create(bits) {
+        return new this.constructor(bits);
+    }
+    get length() {
+        return highestSet(this.bits);
+    }
+    test(a) {
+        return !!(this.bits & (1n << BigInt(a)));
+    }
+    countSet() {
+        return countSet(this.bits);
+    }
+    nthSet(a) {
+        return nthSet(this.bits, a);
+    }
+    complement() {
+        return this.create(~this.bits);
+    }
+    intersect(other) {
+        return this.create(this.bits & other.bits);
+    }
+    union(other) {
+        return this.create(this.bits | other.bits);
+    }
+    xor(other) {
+        return this.create(this.bits ^ other.bits);
+    }
+    contains(other) {
+        return (this.bits & other.bits) === other.bits;
+    }
+    next(a, set = true) {
+        let s = this.bits >> BigInt(a + 1);
+        s = set ? s & -s : (s + 1n) & ~s;
+        return s ? a + highestSet(s) : -1;
+    }
+    where(set, from = -1, to) {
+        let bits = this.bits >> BigInt(from + 1);
+        if (to !== undefined)
+            bits &= (1n << BigInt(to - from - 1)) - 1n;
+        return {
+            *[Symbol.iterator]() {
+                while (bits) {
+                    const i = highestSet(set ? bits & -bits : (bits + 1n) & ~bits);
+                    from += i;
+                    yield from;
+                    bits >>= BigInt(i);
                 }
-                ++k;
-                if (k === keys.length)
-                    return;
-                v = bits[keys[k]] ^ undef;
             }
+        };
+    }
+    ranges() {
+        let bits = this.bits;
+        return {
+            *[Symbol.iterator]() {
+                let offset = 0;
+                while (bits) {
+                    const i = highestSet(bits & -bits);
+                    bits >>= BigInt(i);
+                    const j = highestSet(~bits & (bits + 1n));
+                    bits >>= BigInt(j);
+                    yield [offset + i - 1, offset + i + j - 1];
+                    offset += i + j;
+                }
+            }
+        };
+    }
+    *[Symbol.iterator]() {
+        yield* this.where(true);
+    }
+    toSparse() {
+        const sparse = {};
+        for (let bits = this.bits, i = 0; bits; bits >>= 32n, i++) {
+            const v = Number(bits & 0xffffffffn);
+            if (v)
+                sparse[i] = v;
+        }
+        return SparseBits2.fromEntries(sparse, false);
+    }
+    slice(from, to) {
+        return to === undefined
+            ? this.create(this.bits >> BigInt(from))
+            : this.create(this.bits >> BigInt(from) & ((1n << BigInt(to - from)) - 1n));
+    }
+}
+exports.ImmutableDenseBits = ImmutableDenseBits;
+;
+class DenseBits extends ImmutableDenseBits {
+    setMask(m) {
+        this.bits |= m;
+    }
+    clearMask(m) {
+        this.bits &= ~m;
+    }
+    set(a) {
+        this.setMask(1n << BigInt(a));
+    }
+    clear(a) {
+        this.clearMask(1n << BigInt(a));
+    }
+    setRange(a, b) {
+        this.setMask((1n << BigInt(b)) - (1n << BigInt(a)));
+        return this;
+    }
+    clearRange(a, b) {
+        this.clearMask((1n << BigInt(b)) - (1n << BigInt(a)));
+        return this;
+    }
+    selfComplement() {
+        this.bits = ~this.bits;
+        return this;
+    }
+    selfIntersect(other) {
+        this.bits &= other.bits;
+        return this;
+    }
+    selfUnion(other) {
+        this.bits |= other.bits;
+        return this;
+    }
+    selfXor(other) {
+        this.bits ^= other.bits;
+        return this;
+    }
+}
+exports.DenseBits = DenseBits;
+;
+//-----------------------------------------------------------------------------
+// SparseBits - a sparse bitset implementation, where each entry in the 'bits' array represents 32 bits
+//-----------------------------------------------------------------------------
+function sparseFromEntries(entries) {
+    const dest = [];
+    if (Array.isArray(entries)) {
+        for (const [k, v] of entries)
+            dest[k] = v;
+    }
+    else {
+        for (const [k, v] of Object.entries(entries))
+            dest[+k] = v;
+    }
+    return dest;
+}
+function sparseCopyUndefined(bits, other, xor = 0) {
+    for (const i in other) {
+        if (bits[i] === undefined)
+            bits[i] = other[i] ^ xor;
+    }
+    return bits;
+}
+function sparseClean(bits, undef = 0) {
+    for (const i in bits) {
+        if (bits[i] === undef)
+            delete bits[i];
+    }
+}
+function sparseTest(bits, a, undef = 0) {
+    return !!((bits[a >> 5] ?? undef) & (1 << (a & 0x1f)));
+}
+function sparseSetMask(bits, i, m, undef = 0) {
+    if (bits[i] !== undefined)
+        bits[i] |= m;
+    else if (!undef)
+        bits[i] = m;
+}
+function sparseClearMask(bits, i, m, undef = 0) {
+    if (bits[i] !== undefined)
+        bits[i] &= ~m;
+    else if (undef)
+        bits[i] = ~m;
+}
+function sparseSetRange(bits, a, b, undef = 0) {
+    let i = a >> 5, j = b >> 5;
+    if (i === j) {
+        sparseSetMask(bits, i, (1 << (b & 0x1f)) - (1 << (a & 0x1f)), undef);
+    }
+    else {
+        sparseSetMask(bits, i++, -(1 << (a & 0x1f)), undef);
+        if (undef) {
+            while (i < j)
+                delete bits[i++];
+        }
+        else {
+            while (i < j)
+                bits[i++] = -1;
+        }
+        sparseSetMask(bits, i, (1 << (b & 0x1f)) - 1, undef);
+    }
+}
+function sparseClearRange(bits, a, b, undef = 0) {
+    let i = a >> 5, j = b >> 5;
+    if (i === j) {
+        sparseClearMask(bits, i, (1 << (b & 0x1f)) - (1 << (a & 0x1f)), undef);
+    }
+    else {
+        sparseClearMask(bits, i++, -(1 << (a & 0x1f)), undef);
+        if (!undef) {
+            while (i < j)
+                delete bits[i++];
         }
         else {
-            let i = from >> 5;
-            let v = ((bits[i] ?? undef) ^ ~undef) & -(1 << (from & 0x1f));
-            for (;;) {
+            while (i < j)
+                bits[i++] = 0;
+        }
+        sparseClearMask(bits, i, (1 << (b & 0x1f)) - 1, undef);
+    }
+}
+function sparseCountSet(bits) {
+    let count = 0;
+    for (const i in bits)
+        count += countSet32(bits[i]);
+    return count;
+}
+function sparseNthSet(bits, a, undef = 0) {
+    if (undef === 0) {
+        for (const i in bits) {
+            const v = bits[i];
+            const n = countSet32(v);
+            if (a < n)
+                return (+i << 5) + nthSet32(v, a);
+            a -= n;
+        }
+    }
+    else {
+        let prev = 0;
+        for (const i in bits) {
+            const m = (+i - prev) << 5;
+            if (a < m)
+                return (prev << 5) + a;
+            a -= m;
+            const v = bits[i];
+            const n = countSet32(v);
+            if (a < n)
+                return (+i << 5) + nthSet32(v, a);
+            a -= n;
+            prev = +i + 1;
+        }
+    }
+    return -1;
+}
+function sparseComplement(bits) {
+    return bits.map(b => ~b);
+}
+function sparseIntersect(bits, other, undef = 0) {
+    return bits.map((b, i) => b & (other[i] ?? undef));
+}
+function sparseUnion(bits, other, undef = 0) {
+    return bits.map((b, i) => b | (other[i] ?? undef));
+}
+function sparseXor(bits, other, undef = 0) {
+    return bits.map((b, i) => b ^ (other[i] ?? undef));
+}
+function sparseSelfComplement(bits) {
+    for (const i in bits)
+        bits[i] = ~bits[i];
+    return bits;
+}
+function sparseSelfIntersect(bits, other) {
+    for (const i in bits)
+        bits[i] &= other[i];
+    return bits;
+}
+function sparseSelfUnion(bits, other) {
+    for (const i in bits)
+        bits[i] |= other[i];
+    return bits;
+}
+function sparseSelfXor(bits, other) {
+    for (const i in bits)
+        bits[i] ^= other[i];
+    return bits;
+}
+function sparseContains(bits, other, undef = 0) {
+    for (const i in other) {
+        if (other[i] & ~(bits[i] ?? undef))
+            return false;
+    }
+    return true;
+}
+function sparseNext(bits, from, set = true, undef = 0) {
+    ++from;
+    if (undef ? !set : set) {
+        const ai = from >> 5;
+        for (const i in bits) {
+            if (+i >= ai) {
+                const v = bits[i] ^ undef;
+                if (v)
+                    return (+i << 5) + lowestSet32(v);
+            }
+        }
+        return -1;
+    }
+    else {
+        let i = from >> 5;
+        if (bits[i] === undefined)
+            return from;
+        let v = (bits[i] ^ undef) | ((1 << (from & 0x1f)) - 1);
+        while (!v) {
+            ++i;
+            if (bits[i] === undefined)
+                break;
+            v = bits[i] ^ undef;
+        }
+        return (i << 5) + lowestSet32(~v);
+    }
+}
+function* sparseWhere(bits, set, from = -1, to, undef = 0) {
+    ++from;
+    const from32 = from >> 5;
+    const to32 = to === undefined ? Infinity : to >> 5;
+    const fromM = 1 << (from & 0x1f);
+    const toM = to === undefined ? 0 : 1 << (to & 0x1f);
+    if (undef ? !set : set) {
+        for (const k in bits) {
+            const i = +k;
+            if (i >= to32)
+                break;
+            if (i >= from32) {
+                let v = bits[i] ^ undef;
+                if (i === from32)
+                    v &= -fromM;
+                if (i === to32)
+                    v &= (toM - 1);
                 while (v) {
                     yield (i << 5) + lowestSet32(v);
                     v = v & (v - 1);
                 }
-                ++i;
-                v = ((bits[i] ?? undef) ^ ~undef);
             }
         }
     }
-    constructor(initial = false) {
-        this.undef = initial ? -1 : 0;
-    }
-    create(init) {
-        return new this.constructor(init);
-    }
-    copyUndefined(other) {
-        for (const i in other.bits) {
-            if (this.bits[i] === undefined)
-                this.bits[i] = other.bits[i];
+    else {
+        if (to32 > from32) {
+            for (let v = ((bits[from32] ?? undef) ^ ~undef) & -fromM; v; v = v & (v - 1))
+                yield (from32 << 5) + lowestSet32(v);
+            for (let i = from32 + 1; i < to32; i++) {
+                for (let v = ((bits[i] ?? undef) ^ ~undef); v; v = v & (v - 1))
+                    yield (i << 5) + lowestSet32(v);
+            }
+            for (let v = ((bits[to32] ?? undef) ^ ~undef) & (toM - 1); v; v = v & (v - 1))
+                yield (to32 << 5) + lowestSet32(v);
         }
-        return this;
-    }
-    flipUndefined(other) {
-        for (const i in other.bits) {
-            if (this.bits[i] === undefined)
-                this.bits[i] = ~other.bits[i];
+        else if (to32 === from32) {
+            for (let v = ((bits[from32] ?? undef) ^ ~undef) & (toM - fromM); v; v = v & (v - 1))
+                yield (from32 << 5) + lowestSet32(v);
         }
-        return this;
     }
-    static fromEntries(entries, initial = false) {
-        const r = new this(initial);
-        if (Array.isArray(entries)) {
-            for (const [k, v] of entries)
-                r.bits[k] = v;
+}
+function* sparseRanges(bits, undef = 0) {
+    let start = -1, end = 0;
+    for (const i in bits) {
+        let b = bits[i] ^ undef;
+        const c0 = +i * 32;
+        while ((start < 0 ? b : ~b) !== 0) {
+            if (start === -1) {
+                start = c0 + lowestSet32(b);
+                if (undef)
+                    yield [end, start];
+                end = -1;
+                b = b | (b - 1);
+            }
+            else {
+                end = c0 + lowestSet32(~b);
+                if (!undef)
+                    yield [start, end];
+                start = -1;
+                b = b & (b + 1);
+            }
         }
-        else {
-            for (const [k, v] of Object.entries(entries))
-                r.bits[+k] = v;
+        if (start >= 0 && bits[+i + 1] === undefined) {
+            if (!undef)
+                yield [start, c0 + 32];
+            start = -1;
         }
+    }
+    if (undef)
+        yield [end, Infinity];
+}
+function sparseSlice(bits, from, to) {
+    const from32 = from >> 5;
+    const to32 = to === undefined ? Infinity : to >> 5;
+    const fromBit = from & 0x1f;
+    const toBit = to === undefined ? 0 : to & 0x1f;
+    const result = [];
+    for (const i in bits) {
+        const idx = +i;
+        if (idx < from32 || idx > to32)
+            continue;
+        let b = bits[i];
+        // Mask start bits
+        if (idx === from32)
+            b &= -(1 << fromBit);
+        // Mask end bits
+        if (idx === to32 && to !== undefined)
+            b &= (1 << toBit) - 1;
+        if (b !== 0)
+            result[i] = b;
+    }
+    return result;
+}
+class ImmutableSparseBits {
+    bits;
+    constructor(bits = []) {
+        this.bits = bits;
+    }
+    create(bits = []) {
+        return new this.constructor(bits);
+    }
+    static fromEntries(entries, ...args) {
+        const r = new this(...args);
+        r.bits = sparseFromEntries(entries);
         return r;
     }
     keys() {
         return Object.keys(this.bits).map(k => +k);
     }
     entries() {
-        //return this.bits;
         return Object.entries(this.bits).map(([k, v]) => [+k, v]);
     }
     test(a) {
-        return !!((this.bits[a >> 5] ?? this.undef) & (1 << (a & 0x1f)));
+        return sparseTest(this.bits, a);
     }
     countSet() {
-        let count = 0;
-        for (const i in this.bits)
-            count += countSet32(this.bits[i]);
-        return count;
+        return sparseCountSet(this.bits);
     }
     nthSet(a) {
-        if (this.undef === 0) {
-            for (const i in this.bits) {
-                const v = this.bits[i];
-                const n = countSet32(v);
-                if (a < n)
-                    return (+i << 5) + nthSet32(v, a);
-                a -= n;
-            }
-        }
-        else {
-            let prev = 0;
-            for (const i in this.bits) {
-                const m = (+i - prev) << 5;
-                if (a < m)
-                    return (prev << 5) + a;
-                a -= m;
-                const v = this.bits[i];
-                const n = countSet32(v);
-                if (a < n)
-                    return (+i << 5) + nthSet32(v, a);
-                a -= n;
-                prev = +i + 1;
-            }
-        }
-        return -1;
+        return sparseNthSet(this.bits, a);
     }
     complement() {
-        const result = this.create(this.undef === 0);
-        for (const i in this.bits)
-            result.bits[i] = ~this.bits[i];
-        return result;
+        return new ImmutableSparseBits2(sparseComplement(this.bits), true);
     }
     intersect(other) {
-        const result = this.create(!!(this.undef & other.undef));
-        for (const i in this.bits)
-            result.bits[i] = this.bits[i] & other.bits[i];
-        return this.undef ? result.copyUndefined(other) : result;
+        return this.create(sparseIntersect(this.bits, other.bits));
     }
     union(other) {
-        const result = this.create(!!(this.undef | other.undef));
-        for (const i in other.bits)
-            result.bits[i] = this.bits[i] | other.bits[i];
-        return this.undef ? result : result.copyUndefined(other);
+        return this.create(sparseCopyUndefined(sparseUnion(this.bits, other.bits), other.bits));
     }
     xor(other) {
-        const result = this.create(!!(this.undef ^ other.undef));
-        for (const i in this.bits)
-            result.bits[i] = this.bits[i] ^ other.bits[i];
-        return this.undef ? result.flipUndefined(other) : result.copyUndefined(other);
+        return this.create(sparseCopyUndefined(sparseXor(this.bits, other.bits), other.bits));
     }
     contains(other) {
-        if (other.undef && !this.undef)
-            return false;
-        for (const i in other.bits) {
-            if (other.bits[i] & ~(this.bits[i] ?? this.undef))
-                return false;
-        }
-        return true;
+        return sparseContains(this.bits, other.bits);
     }
-    next(a, set = true) {
-        ++a;
-        const xor = this.undef;
-        if (xor)
-            set = !set;
-        if (set) {
-            const keys = Object.keys(this.bits).map(k => +k);
-            if (keys.length === 0)
-                return -1;
-            const ai = a >> 5;
-            let i = (0, algorithm_1.lowerBound)(keys, ai);
-            let v = this.bits[keys[i]] ^ xor;
-            if (keys[i] === ai)
-                v &= -(1 << (a & 0x1f));
-            while (!v) {
-                ++i;
-                if (i === keys.length)
-                    return -1;
-                v = this.bits[keys[i]] ^ xor;
-            }
-            return (keys[i] << 5) + lowestSet32(v);
-        }
-        else {
-            let i = a >> 5;
-            if (this.bits[i] === undefined)
-                return a;
-            let v = (this.bits[i] ^ xor) | ((1 << (a & 0x1f)) - 1);
-            while (!v) {
-                ++i;
-                if (this.bits[i] === undefined)
-                    break;
-                v = this.bits[i] ^ xor;
-            }
-            return (i << 5) + lowestSet32(~v);
-        }
+    next(from, set = true) {
+        return sparseNext(this.bits, from, set);
     }
-    where(set, from = -1) {
+    where(set, from = -1, to) {
         return {
-            [Symbol.iterator]: () => ImmutableSparseBits.whereGenerator(this.bits, this.undef, set, from)
+            [Symbol.iterator]: () => sparseWhere(this.bits, set, from, to)
         };
     }
     ranges() {
-        const bits = this.bits;
-        const undef = this.undef;
         return {
-            *[Symbol.iterator]() {
-                let start = -1, end = 0;
-                for (const i in bits) {
-                    let b = bits[i] ^ undef;
-                    const c0 = +i * 32;
-                    while ((start < 0 ? b : ~b) !== 0) {
-                        if (start === -1) {
-                            start = c0 + lowestSet32(b);
-                            if (undef)
-                                yield [end, start];
-                            end = -1;
-                            b = b | (b - 1);
-                        }
-                        else {
-                            end = c0 + lowestSet32(~b);
-                            if (!undef)
-                                yield [start, end];
-                            start = -1;
-                            b = b & (b + 1);
-                        }
-                    }
-                    if (start >= 0 && bits[+i + 1] === undefined) {
-                        if (!undef)
-                            yield [start, c0 + 32];
-                        start = -1;
-                    }
-                }
-                if (undef)
-                    yield [end, Infinity];
-            }
+            [Symbol.iterator]: () => sparseRanges(this.bits)
         };
     }
     *[Symbol.iterator]() {
-        yield* ImmutableSparseBits.whereGenerator(this.bits, this.undef, true, -1);
-        //for (let i = this.next(-1); i !== -1; i = this.next(i))
-        //	yield i;
+        yield* sparseWhere(this.bits, true, -1);
     }
     clean() {
-        for (const i in this.bits) {
-            if (this.bits[i] === this.undef)
-                delete this.bits[i];
-        }
+        sparseClean(this.bits);
         return this;
     }
     toDense() {
         let bits = 0n;
-        if (this.undef) {
-            for (const i in this.bits)
-                bits |= BigInt(~this.bits[i]) << BigInt(+i * 32);
-            bits = ~bits;
-        }
-        else {
-            for (const i in this.bits)
-                bits |= BigInt(this.bits[i]) << BigInt(+i * 32);
-        }
+        for (const i in this.bits)
+            bits |= BigInt(this.bits[i]) << BigInt(+i * 32);
         return new DenseBits(bits);
     }
+    slice(from, to) {
+        return this.create(sparseSlice(this.bits, from, to));
+    }
 }
 exports.ImmutableSparseBits = ImmutableSparseBits;
 class SparseBits extends ImmutableSparseBits {
-    setMask(i, m) {
-        if (this.bits[i] !== undefined)
-            this.bits[i] |= m;
-        else if (!this.undef)
-            this.bits[i] = m;
-    }
-    clearMask(i, m) {
-        if (this.bits[i] !== undefined)
-            this.bits[i] &= ~m;
-        else if (this.undef)
-            this.bits[i] = ~m;
-    }
     set(a) {
-        this.setMask(a >> 5, 1 << (a & 0x1f));
+        sparseSetMask(this.bits, a >> 5, 1 << (a & 0x1f));
     }
     clear(a) {
-        this.clearMask(a >> 5, 1 << (a & 0x1f));
+        sparseClearMask(this.bits, a >> 5, 1 << (a & 0x1f));
     }
     setRange(a, b) {
-        let i = a >> 5, j = b >> 5;
-        if (i === j) {
-            this.setMask(i, (1 << (b & 0x1f)) - (1 << (a & 0x1f)));
-        }
-        else {
-            this.setMask(i++, -(1 << (a & 0x1f)));
-            if (this.undef) {
-                while (i < j)
-                    delete this.bits[i++];
-            }
-            else {
-                while (i < j)
-                    this.bits[i++] = -1;
-            }
-            this.setMask(i, (1 << (b & 0x1f)) - 1);
-        }
+        sparseSetRange(this.bits, a, b);
         return this;
     }
     clearRange(a, b) {
-        let i = a >> 5, j = b >> 5;
-        if (i === j) {
-            this.clearMask(i, (1 << (b & 0x1f)) - (1 << (a & 0x1f)));
-        }
-        else {
-            this.clearMask(i++, -(1 << (a & 0x1f)));
-            if (!this.undef) {
-                while (i < j)
-                    delete this.bits[i++];
-            }
-            else {
-                while (i < j)
-                    this.bits[i++] = 0;
-            }
-            this.clearMask(i, (1 << (b & 0x1f)) - 1);
-        }
-        return this;
-    }
-    selfComplement() {
-        this.undef = ~this.undef;
-        for (const i in this.bits)
-            this.bits[i] = ~this.bits[i];
+        sparseClearRange(this.bits, a, b);
         return this;
     }
     selfIntersect(other) {
-        for (const i in this.bits)
-            this.bits[i] &= other.bits[i];
-        if (this.undef)
-            this.copyUndefined(other);
-        this.undef &= other.undef;
+        sparseSelfIntersect(this.bits, other.bits);
         return this;
     }
     selfUnion(other) {
-        for (const i in other.bits)
-            this.bits[i] |= other.bits[i];
-        if (!this.undef)
-            this.copyUndefined(other);
-        this.undef |= other.undef;
+        sparseCopyUndefined(sparseSelfUnion(this.bits, other.bits), other.bits);
         return this;
     }
     selfXor(other) {
-        for (const i in this.bits)
-            this.bits[i] ^= other.bits[i];
-        if (this.undef)
-            this.flipUndefined(other);
-        else
-            this.copyUndefined(other);
-        this.undef &= other.undef;
+        sparseCopyUndefined(sparseSelfXor(this.bits, other.bits), other.bits);
         return this;
     }
 }
 exports.SparseBits = SparseBits;
 ;
 //-----------------------------------------------------------------------------
-// DenseBits - a dense bitset implementation using bigint
+// SparseBits2 as above, with an 'undef' member indicating whether undefined entries are treated as 0 or 0xffffffff
 //-----------------------------------------------------------------------------
-class ImmutableDenseBits {
-    bits;
-    constructor(bits = 0n) {
-        this.bits = bits;
-    }
-    create(bits) {
-        return new this.constructor(bits);
+class ImmutableSparseBits2 extends ImmutableSparseBits {
+    undef;
+    constructor(bits = [], initial = false) {
+        super(bits);
+        this.undef = initial ? -1 : 0;
     }
-    get length() {
-        return highestSet(this.bits);
+    create(bits = [], init) {
+        return new this.constructor(bits, init);
     }
     test(a) {
-        return !!(this.bits & (1n << BigInt(a)));
-    }
-    countSet() {
-        return countSet(this.bits);
+        return sparseTest(this.bits, a, this.undef);
     }
     nthSet(a) {
-        return nthSet(this.bits, a);
+        return sparseNthSet(this.bits, a, this.undef);
     }
     complement() {
-        return this.create(~this.bits);
+        return this.create(sparseComplement(this.bits), this.undef === 0);
     }
     intersect(other) {
-        return this.create(this.bits & other.bits);
+        if (this.undef)
+            return this.create(sparseCopyUndefined(sparseIntersect(this.bits, other.bits, other.undef), other.bits), !!other.undef);
+        return this.create(sparseIntersect(this.bits, other.bits), false);
     }
     union(other) {
-        return this.create(this.bits | other.bits);
+        if (this.undef)
+            return this.create(sparseUnion(this.bits, other.bits), true);
+        return this.create(sparseCopyUndefined(sparseUnion(this.bits, other.bits), other.bits), !!other.undef);
     }
     xor(other) {
-        return this.create(this.bits ^ other.bits);
+        return this.create(sparseCopyUndefined(sparseXor(this.bits, other.bits), other.bits, this.undef), !!(this.undef ^ other.undef));
     }
     contains(other) {
-        return (this.bits & other.bits) === other.bits;
+        if (other.undef && !this.undef)
+            return false;
+        return sparseContains(this.bits, other.bits, this.undef);
     }
-    next(a, set = true) {
-        let s = this.bits >> BigInt(a + 1);
-        s = set ? s & -s : (s + 1n) & ~s;
-        return s ? a + highestSet(s) : -1;
+    next(from, set = true) {
+        return sparseNext(this.bits, from, set, this.undef);
     }
-    where(set, from = -1) {
-        let bits = this.bits >> BigInt(from + 1);
-        return {
-            *[Symbol.iterator]() {
-                while (bits) {
-                    const i = highestSet(set ? bits & -bits : (bits + 1n) & ~bits);
-                    from += i;
-                    yield from;
-                    bits >>= BigInt(i);
-                }
-            }
-        };
-        /*
-        const self = this;
+    where(set, from = -1, to) {
         return {
-            *[Symbol.iterator](): Generator<number> {
-                for (let i = self.next(-1, set); i !== -1; i = self.next(i, set))
-                    yield i;
-            }
+            [Symbol.iterator]: () => sparseWhere(this.bits, set, from, to, this.undef)
         };
-        */
     }
     ranges() {
-        let bits = this.bits;
         return {
-            *[Symbol.iterator]() {
-                let offset = 0;
-                while (bits) {
-                    const i = highestSet(bits & -bits);
-                    bits >>= BigInt(i);
-                    const j = highestSet(~bits & (bits + 1n));
-                    bits >>= BigInt(j);
-                    yield [offset + i - 1, offset + i + j - 1];
-                    offset += i + j;
-                }
-            }
+            [Symbol.iterator]: () => sparseRanges(this.bits, this.undef)
         };
     }
     *[Symbol.iterator]() {
-        yield* this.where(true);
-        //for (let i = this.next(-1); i !== -1; i = this.next(i))
-        //	yield i;
+        yield* sparseWhere(this.bits, true, -1, undefined, this.undef);
     }
-    toSparse() {
-        const sparse = {};
-        for (let bits = this.bits, i = 0; bits; bits >>= 32n, i++) {
-            const v = Number(bits & 0xffffffffn);
-            if (v)
-                sparse[i] = v;
-        }
-        return SparseBits.fromEntries(sparse, false);
+    clean() {
+        sparseClean(this.bits, this.undef);
+        return this;
     }
-}
-exports.ImmutableDenseBits = ImmutableDenseBits;
-;
-class DenseBits extends ImmutableDenseBits {
-    setMask(m) {
-        this.bits |= m;
+    toDense() {
+        let bits = 0n;
+        if (this.undef) {
+            for (const i in this.bits)
+                bits |= BigInt(~this.bits[i]) << BigInt(+i * 32);
+            bits = ~bits;
+        }
+        else {
+            for (const i in this.bits)
+                bits |= BigInt(this.bits[i]) << BigInt(+i * 32);
+        }
+        return new DenseBits(bits);
     }
-    clearMask(m) {
-        this.bits &= ~m;
+    slice(from, to) {
+        return this.create(sparseSlice(this.bits, from, to), !!this.undef);
     }
+}
+exports.ImmutableSparseBits2 = ImmutableSparseBits2;
+class SparseBits2 extends ImmutableSparseBits2 {
     set(a) {
-        this.setMask(1n << BigInt(a));
+        sparseSetMask(this.bits, a >> 5, 1 << (a & 0x1f), this.undef);
     }
     clear(a) {
-        this.clearMask(1n << BigInt(a));
+        sparseClearMask(this.bits, a >> 5, 1 << (a & 0x1f), this.undef);
     }
     setRange(a, b) {
-        this.setMask((1n << BigInt(b)) - (1n << BigInt(a)));
+        sparseSetRange(this.bits, a, b, this.undef);
         return this;
     }
     clearRange(a, b) {
-        this.clearMask((1n << BigInt(b)) - (1n << BigInt(a)));
+        sparseClearRange(this.bits, a, b, this.undef);
         return this;
     }
     selfComplement() {
-        this.bits = ~this.bits;
+        this.undef = ~this.undef;
+        sparseSelfComplement(this.bits);
         return this;
     }
     selfIntersect(other) {
-        this.bits &= other.bits;
+        sparseSelfIntersect(this.bits, other.bits);
+        if (this.undef) {
+            sparseCopyUndefined(this.bits, other.bits);
+            this.undef = other.undef;
+        }
         return this;
     }
     selfUnion(other) {
-        this.bits |= other.bits;
+        sparseSelfUnion(this.bits, other.bits);
+        if (!this.undef) {
+            sparseCopyUndefined(this.bits, other.bits);
+            this.undef = other.undef;
+        }
         return this;
     }
     selfXor(other) {
-        this.bits ^= other.bits;
+        sparseSelfXor(this.bits, other.bits);
+        sparseCopyUndefined(this.bits, other.bits, this.undef);
+        this.undef ^= other.undef;
         return this;
     }
 }
-exports.DenseBits = DenseBits;
+exports.SparseBits2 = SparseBits2;
 ;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@isopodlabs/utilities",
-	"version": "1.5.9",
+	"version": "1.6.0",
 	"description": "Various typescript helpers.",
 	"repository": {
 		"type": "git",