@isopodlabs/utilities 1.5.8 → 1.6.0

package/dist/bits.js

@@ -1,30 +1,70 @@
 "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;
 exports.lowestSet = lowestSet;
 exports.countSet = countSet;
+exports.nthSet = nthSet;
 exports.highestClear = highestClear;
 exports.lowestClear = lowestClear;
 exports.countClear = countClear;
-const algorithm_1 = require("./algorithm");
-//-----------------------------------------------------------------------------
-// Bit twiddling functions
-//-----------------------------------------------------------------------------
+exports.clearLowest = clearLowest;
+// 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);
 }
+// Returns the index (1-32) of the highest set bit, or 0 if none
 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);
     x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
     return ((x + (x >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
 }
+// Returns the index (0-31) of the nth set bit, or 32 if none
+function nthSet32(x, i) {
+    let b2 = x - ((x >> 1) & 0x55555555);
+    let b4 = (b2 & 0x33333333) + ((b2 >> 2) & 0x33333333);
+    let b8 = (b4 + (b4 >> 4) & 0xF0F0F0F);
+    let b16 = (b8 + (b8 >> 8)) & 0xff;
+    let n = 0;
+    if (i >= b16) {
+        i -= b16;
+        n += 16;
+    }
+    b8 = (b8 >> n) & 0xff;
+    if (i >= b8) {
+        i -= b8;
+        n += 8;
+    }
+    b4 = (b4 >> n) & 0x0f;
+    if (i >= b4) {
+        i -= b4;
+        n += 4;
+    }
+    b2 = (b2 >> n) & 0x03;
+    if (i >= b2) {
+        i -= b2;
+        n += 2;
+    }
+    if (i >= ((x >> n) & 1))
+        ++n;
+    return n;
+}
 /*
 const testersShift: bigint[] = [];	//32 << i
 const testers:		bigint[] = [];	//1 << (32 << i)
@@ -85,42 +125,59 @@ export function bitcountCached(x: bigint): number {
     return Number(x & 0xFFFFFFFFn);
 }
 */
-function highestSet(x) {
-    if (x < 0)
-        x = ~x;
-    if (x < 0x100000000)
-        return highestSet32(Number(x));
-    // For numbers within safe float range, use log2
-    if (x <= Number.MAX_VALUE) {
-        const b = Math.floor(Math.log2(Number(x)));
-        return (1n << BigInt(b)) <= x ? b + 1 : b;
-    }
-    // For arbitrarily large bigints, use bit-shifting method
-    let y = BigInt(x);
+/*
+function highestSetBig32(x: bigint): number {
     let s = 0;
     let k = 0;
-    for (let t = y >> 32n; t; t >>= BigInt(s)) {
+
+    for (let t = x >> 32n; t; t >>= BigInt(s)) {
         s = 32 << k++;
-        y = t;
+        x = t;
+    }
+
+    if (k) {
+        while (--k) {
+            const b = x >> BigInt(16 << k);
+            if (b) {
+                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) {
-        // determine length by bisection
-        k--;
-        while (k--) {
-            const b = y >> BigInt(32 << k);
+        while (--k) {
+            const b = x >> BigInt(512 << k);
             if (b) {
-                s += 32 << k;
-                y = b;
+                s += 512 << k;
+                x = b;
             }
         }
     }
-    return (s + 32) - Math.clz32(Number(y));
+    return highestSet1024(Number(x)) + s;
+}
+function highestSet(x) {
+    if (x < 0)
+        x = ~x;
+    return x < 0x100000000 ? highestSet32(Number(x))
+        : x <= Number.MAX_VALUE ? highestSet1024(Number(x))
+            : highestSetBig1024(BigInt(x));
 }
 function lowestSet(x) {
-    if (x < 0x100000000)
-        return lowestSet32(Number(x));
-    const xb = BigInt(x < 0 ? ~x : x);
-    return highestSet(xb & -xb) - 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)
@@ -133,9 +190,9 @@ function countSet(x) {
         t >>= BigInt(1 << k++);
     const n = 1 << k;
     const limit = 1n << BigInt(n);
-    let i = 1;
-    for (; i < k; i <<= 1) {
-        const bi = BigInt(i);
+    let s = 1;
+    for (; s < k; s <<= 1) {
+        const bi = BigInt(s);
         const mask = limit / ((1n << bi) + 1n);
         x = (x & mask) + ((x >> bi) & mask);
     }
@@ -143,475 +200,688 @@ function countSet(x) {
     //const mask = limit / ((1n << bi) - 1n);
     //x = (x * mask) >> BigInt(n - i);
     //we can skip the masking when the total can fit
-    for (; i < n; i <<= 1)
-        x += x >> BigInt(i);
-    return Number(x & 0xffffffffn);
+    for (; s < n; s <<= 1)
+        x += x >> BigInt(s);
+    return Number(x & ((1n << BigInt(k)) - 1n));
 }
+function nthSet(x, i) {
+    if (x < 0)
+        x = ~x;
+    if (x < 0x100000000)
+        return nthSet32(Number(x), i);
+    x = BigInt(x);
+    let k = 5;
+    for (let t = x >> 32n; t;)
+        t >>= BigInt(1 << k++);
+    const limit = 1n << BigInt(1 << k);
+    const counts = [];
+    counts.push(x);
+    let s = 1;
+    for (; s < k; s <<= 1) {
+        const bi = BigInt(s);
+        const mask = limit / ((1n << bi) + 1n);
+        x = (x & mask) + ((x >> bi) & mask);
+        counts.push(x);
+    }
+    while (counts.length < k) {
+        x += x >> BigInt(s);
+        counts.push(x);
+        s <<= 1;
+    }
+    let n = 0;
+    for (let j = k; j--;) {
+        const s = 1 << j;
+        const b = Number((counts[j] >> BigInt(n)) & 0xffffffffn) & (s * 2 - 1);
+        if (i >= b) {
+            i -= b;
+            n += s;
+        }
+    }
+    return n;
+}
+// Returns the index of the highest clear bit
 function highestClear(x) {
     return highestSet(~x);
 }
+// Returns the index of the lowest clear bit
 function lowestClear(x) {
     return lowestSet(~x);
 }
+// Returns the number of clear bits
 function countClear(x) {
     return countSet(~x);
 }
+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);
-                }
-                ++k;
-                if (k === keys.length)
-                    return;
-                v = bits[keys[k]] ^ undef;
-            }
-        }
-        else {
-            let i = from >> 5;
-            let v = ((bits[i] ?? undef) ^ ~undef) & -(1 << (from & 0x1f));
-            for (;;) {
-                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);
+class ImmutableDenseBits {
+    bits;
+    constructor(bits = 0n) {
+        this.bits = bits;
     }
-    copyUndefined(other) {
-        for (const i in other.bits) {
-            if (this.bits[i] === undefined)
-                this.bits[i] = other.bits[i];
-        }
-        return this;
+    create(bits) {
+        return new this.constructor(bits);
     }
-    flipUndefined(other) {
-        for (const i in other.bits) {
-            if (this.bits[i] === undefined)
-                this.bits[i] = ~other.bits[i];
-        }
-        return this;
+    get length() {
+        return highestSet(this.bits);
     }
-    static fromEntries(entries, initial = false) {
-        const r = new this(initial);
-        if (Array.isArray(entries)) {
-            for (const [k, v] of entries)
-                r.bits[k] = v;
-        }
-        else {
-            for (const [k, v] of Object.entries(entries))
-                r.bits[+k] = v;
-        }
-        return r;
+    test(a) {
+        return !!(this.bits & (1n << BigInt(a)));
     }
-    keys() {
-        return Object.keys(this.bits).map(k => +k);
+    countSet() {
+        return countSet(this.bits);
     }
-    entries() {
-        //return this.bits;
-        return Object.entries(this.bits).map(([k, v]) => [+k, v]);
+    nthSet(a) {
+        return nthSet(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 this.create(~this.bits);
     }
     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(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(this.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);
-    }
-    clean() {
-        for (const i in this.bits) {
-            if (this.bits[i] === this.undef)
-                delete this.bits[i];
-        }
-        return this;
+        return this.create(this.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;
-    }
-    test(a) {
-        return !!((this.bits[a >> 5] ?? this.undef) & (1 << (a & 0x1f)));
-    }
-    countSet() {
-        let count = 0;
-        for (const i in this.bits)
-            count += countSet32(this.bits[i]);
-        return count;
+        return (this.bits & other.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);
-        }
-    }
-    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);
+        let s = this.bits >> BigInt(a + 1);
+        s = set ? s & -s : (s + 1n) & ~s;
+        return s ? a + highestSet(s) : -1;
     }
-    where(set, from = -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]: () => ImmutableSparseBits.whereGenerator(this.bits, this.undef, set, from)
+            *[Symbol.iterator]() {
+                while (bits) {
+                    const i = highestSet(set ? bits & -bits : (bits + 1n) & ~bits);
+                    from += i;
+                    yield from;
+                    bits >>= BigInt(i);
+                }
+            }
         };
     }
     ranges() {
-        const bits = this.bits;
-        const undef = this.undef;
+        let bits = this.bits;
         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;
-                    }
+                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;
                 }
-                if (undef)
-                    yield [end, Infinity];
             }
         };
     }
     *[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* 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.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;
+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.undef = ~this.undef;
-        for (const i in this.bits)
-            this.bits[i] = ~this.bits[i];
+        this.bits = ~this.bits;
         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;
+        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;
+        this.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;
+        this.bits ^= other.bits;
         return this;
     }
-    set(a) {
-        this.setMask(a >> 5, 1 << (a & 0x1f));
+}
+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;
     }
-    clear(a) {
-        this.clearMask(a >> 5, 1 << (a & 0x1f));
+    else {
+        for (const [k, v] of Object.entries(entries))
+            dest[+k] = v;
     }
-    test(a) {
-        const i = a >> 5;
-        return !!((this.bits[i] ?? this.undef) & (1 << (a & 0x1f)));
+    return dest;
+}
+function sparseCopyUndefined(bits, other, xor = 0) {
+    for (const i in other) {
+        if (bits[i] === undefined)
+            bits[i] = other[i] ^ xor;
     }
-    setRange(a, b) {
-        let i = a >> 5, j = b >> 5;
-        if (i === j) {
-            this.setMask(i, (1 << (b & 0x1f)) - (1 << (a & 0x1f)));
+    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 {
-            this.setMask(i++, -(1 << (a & 0x1f)));
-            if (this.undef) {
-                while (i < j)
-                    delete this.bits[i++];
+            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);
             }
-            else {
-                while (i < j)
-                    this.bits[i++] = -1;
+        }
+        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);
+                }
             }
-            this.setMask(i, (1 << (b & 0x1f)) - 1);
         }
-        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 {
+        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);
         }
-        else {
-            this.clearMask(i++, -(1 << (a & 0x1f)));
-            if (!this.undef) {
-                while (i < j)
-                    delete this.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);
+        }
+    }
+}
+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 {
-                while (i < j)
-                    this.bits[i++] = 0;
+                end = c0 + lowestSet32(~b);
+                if (!undef)
+                    yield [start, end];
+                start = -1;
+                b = b & (b + 1);
             }
-            this.clearMask(i, (1 << (b & 0x1f)) - 1);
         }
-        return this;
+        if (start >= 0 && bits[+i + 1] === undefined) {
+            if (!undef)
+                yield [start, c0 + 32];
+            start = -1;
+        }
     }
+    if (undef)
+        yield [end, Infinity];
 }
-exports.SparseBits = SparseBits;
-;
-//-----------------------------------------------------------------------------
-// DenseBits - a dense bitset implementation using bigint
-//-----------------------------------------------------------------------------
-class ImmutableDenseBits {
+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 = 0n) {
+    constructor(bits = []) {
         this.bits = bits;
     }
-    create(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 Object.entries(this.bits).map(([k, v]) => [+k, v]);
+    }
+    test(a) {
+        return sparseTest(this.bits, a);
+    }
+    countSet() {
+        return sparseCountSet(this.bits);
+    }
+    nthSet(a) {
+        return sparseNthSet(this.bits, a);
+    }
     complement() {
-        return this.create(~this.bits);
+        return new ImmutableSparseBits2(sparseComplement(this.bits), true);
     }
     intersect(other) {
-        return this.create(this.bits & other.bits);
+        return this.create(sparseIntersect(this.bits, other.bits));
     }
     union(other) {
-        return this.create(this.bits | other.bits);
+        return this.create(sparseCopyUndefined(sparseUnion(this.bits, other.bits), other.bits));
     }
     xor(other) {
-        return this.create(this.bits ^ other.bits);
-    }
-    test(a) {
-        return !!(this.bits & (1n << BigInt(a)));
+        return this.create(sparseCopyUndefined(sparseXor(this.bits, other.bits), other.bits));
     }
     contains(other) {
-        return (this.bits & other.bits) === other.bits;
+        return sparseContains(this.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;
-    }
-    countSet() {
-        return countSet(this.bits);
-    }
-    get length() {
-        return highestSet(this.bits);
+    next(from, set = true) {
+        return sparseNext(this.bits, from, set);
     }
-    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)
         };
-        */
     }
     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)
         };
     }
     *[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);
     }
-    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);
+        return this;
+    }
+    toDense() {
+        let bits = 0n;
+        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.ImmutableDenseBits = ImmutableDenseBits;
-;
-class DenseBits extends ImmutableDenseBits {
-    setMask(m) {
-        this.bits |= m;
+exports.ImmutableSparseBits = ImmutableSparseBits;
+class SparseBits extends ImmutableSparseBits {
+    set(a) {
+        sparseSetMask(this.bits, a >> 5, 1 << (a & 0x1f));
     }
-    clearMask(m) {
-        this.bits &= ~m;
+    clear(a) {
+        sparseClearMask(this.bits, a >> 5, 1 << (a & 0x1f));
     }
-    selfComplement() {
-        this.bits = ~this.bits;
+    setRange(a, b) {
+        sparseSetRange(this.bits, a, b);
+        return this;
+    }
+    clearRange(a, b) {
+        sparseClearRange(this.bits, a, b);
         return this;
     }
     selfIntersect(other) {
-        this.bits &= other.bits;
+        sparseSelfIntersect(this.bits, other.bits);
         return this;
     }
     selfUnion(other) {
-        this.bits |= other.bits;
+        sparseCopyUndefined(sparseSelfUnion(this.bits, other.bits), other.bits);
         return this;
     }
     selfXor(other) {
-        this.bits ^= other.bits;
+        sparseCopyUndefined(sparseSelfXor(this.bits, other.bits), other.bits);
+        return this;
+    }
+}
+exports.SparseBits = SparseBits;
+;
+//-----------------------------------------------------------------------------
+// SparseBits2 as above, with an 'undef' member indicating whether undefined entries are treated as 0 or 0xffffffff
+//-----------------------------------------------------------------------------
+class ImmutableSparseBits2 extends ImmutableSparseBits {
+    undef;
+    constructor(bits = [], initial = false) {
+        super(bits);
+        this.undef = initial ? -1 : 0;
+    }
+    create(bits = [], init) {
+        return new this.constructor(bits, init);
+    }
+    test(a) {
+        return sparseTest(this.bits, a, this.undef);
+    }
+    nthSet(a) {
+        return sparseNthSet(this.bits, a, this.undef);
+    }
+    complement() {
+        return this.create(sparseComplement(this.bits), this.undef === 0);
+    }
+    intersect(other) {
+        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) {
+        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(sparseCopyUndefined(sparseXor(this.bits, other.bits), other.bits, this.undef), !!(this.undef ^ other.undef));
+    }
+    contains(other) {
+        if (other.undef && !this.undef)
+            return false;
+        return sparseContains(this.bits, other.bits, this.undef);
+    }
+    next(from, set = true) {
+        return sparseNext(this.bits, from, set, this.undef);
+    }
+    where(set, from = -1, to) {
+        return {
+            [Symbol.iterator]: () => sparseWhere(this.bits, set, from, to, this.undef)
+        };
+    }
+    ranges() {
+        return {
+            [Symbol.iterator]: () => sparseRanges(this.bits, this.undef)
+        };
+    }
+    *[Symbol.iterator]() {
+        yield* sparseWhere(this.bits, true, -1, undefined, this.undef);
+    }
+    clean() {
+        sparseClean(this.bits, this.undef);
         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);
+        }
+        return new DenseBits(bits);
+    }
+    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.undef = ~this.undef;
+        sparseSelfComplement(this.bits);
+        return this;
+    }
+    selfIntersect(other) {
+        sparseSelfIntersect(this.bits, other.bits);
+        if (this.undef) {
+            sparseCopyUndefined(this.bits, other.bits);
+            this.undef = other.undef;
+        }
+        return this;
+    }
+    selfUnion(other) {
+        sparseSelfUnion(this.bits, other.bits);
+        if (!this.undef) {
+            sparseCopyUndefined(this.bits, other.bits);
+            this.undef = other.undef;
+        }
+        return this;
+    }
+    selfXor(other) {
+        sparseSelfXor(this.bits, other.bits);
+        sparseCopyUndefined(this.bits, other.bits, this.undef);
+        this.undef ^= other.undef;
         return this;
     }
 }
-exports.DenseBits = DenseBits;
+exports.SparseBits2 = SparseBits2;
 ;