@isopodlabs/utilities 1.5.9 → 1.7.0

package/dist/bits.js

@@ -1,22 +1,24 @@
 "use strict";
+//-----------------------------------------------------------------------------
+// Bit twiddling functions
+//-----------------------------------------------------------------------------
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DenseBits = exports.ImmutableDenseBits = exports.SparseBits = exports.ImmutableSparseBits = void 0;
+exports.SparseBits2 = exports.SparseBits = exports.DenseBits32 = exports.DenseBits = void 0;
 exports.lowestSet32 = lowestSet32;
 exports.highestSet32 = highestSet32;
+exports.highestSet1024 = highestSet1024;
 exports.countSet32 = countSet32;
 exports.nthSet32 = nthSet32;
+exports.reverse32 = reverse32;
 exports.highestSet = highestSet;
 exports.lowestSet = lowestSet;
 exports.countSet = countSet;
 exports.nthSet = nthSet;
+exports.reverse = reverse;
 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 +27,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);
@@ -61,6 +67,13 @@ function nthSet32(x, i) {
         ++n;
     return n;
 }
+function reverse32(x) {
+    x = ((x >> 1) & 0x55555555) | ((x & 0x55555555) << 1);
+    x = ((x >> 2) & 0x33333333) | ((x & 0x33333333) << 2);
+    x = ((x >> 4) & 0x0F0F0F0F) | ((x & 0x0F0F0F0F) << 4);
+    x = ((x >> 8) & 0x00FF00FF) | ((x & 0x00FF00FF) << 8);
+    return (x >> 16) | (x << 16);
+}
 /*
 const testersShift: bigint[] = [];	//32 << i
 const testers:		bigint[] = [];	//1 << (32 << i)
@@ -121,45 +134,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)
@@ -221,6 +248,38 @@ function nthSet(x, i) {
     }
     return n;
 }
+function reverse(x) {
+    if (typeof x === 'number')
+        return reverse32(Number(x));
+    let k = 5;
+    for (let t = x >> 32n; t;)
+        t >>= BigInt(1 << k++);
+    let n = 1 << k;
+    let s = 0;
+    if (k === 5) {
+        s += highestSet32(Number(x));
+    }
+    else {
+        let t = x;
+        while (k >= 10) {
+            --k;
+            const b = t >> BigInt(1 << k);
+            if (b) {
+                s += 1 << k;
+                t = b;
+            }
+        }
+        s += highestSet1024(Number(t));
+    }
+    const shift = n - s;
+    let mask = (1n << BigInt(n)) - 1n;
+    while (n >>= 1) {
+        const nb = BigInt(n);
+        mask ^= (mask << nb);
+        x = ((x >> nb) & mask) | ((x << nb) & ~mask);
+    }
+    return x >> BigInt(shift);
+}
 // Returns the index of the highest clear bit
 function highestClear(x) {
     return highestSet(~x);
@@ -237,487 +296,1030 @@ 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 DenseBits {
+    bits;
+    constructor(bits = 0n) {
+        this.bits = bits;
+    }
+    create(bits) {
+        return new this.constructor(bits);
+    }
+    static fromIndices(...indices) {
+        let bits = 0n;
+        for (const i of indices)
+            bits |= 1n << BigInt(i);
+        return new this(bits);
+    }
+    get length() {
+        return highestSet(this.bits);
+    }
+    test(a) {
+        return !!(this.bits & (1n << BigInt(a)));
+    }
+    equals(other) {
+        return this.bits === other.bits;
+    }
+    contains(other) {
+        return (this.bits & other.bits) === other.bits;
+    }
+    intersects(other) {
+        return (this.bits & other.bits) !== 0n;
+    }
+    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);
+    }
+    difference(other) {
+        return this.create(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;
+    }
+    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;
             }
-        }
-        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);
+        };
+    }
+    ranges(set = true) {
+        let bits = this.bits;
+        return {
+            *[Symbol.iterator]() {
+                let offset = 0;
+                while (bits) {
+                    const i = highestSet(bits & -bits);
+                    if (!set && offset + i > 1)
+                        yield [offset ? offset - 1 : 0, offset + i - 1];
+                    bits >>= BigInt(i);
+                    const j = highestSet(~bits & (bits + 1n));
+                    bits >>= BigInt(j);
+                    if (set)
+                        yield [offset + i - 1, offset + i + j - 1];
+                    offset += i + j;
                 }
-                ++i;
-                v = ((bits[i] ?? undef) ^ ~undef);
             }
+        };
+    }
+    *[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 new SparseBits(sparse);
     }
-    constructor(initial = false) {
-        this.undef = initial ? -1 : 0;
+    slice(from, to) {
+        return to === undefined
+            ? this.create(this.bits >> BigInt(from))
+            : this.create(this.bits >> BigInt(from) & ((1n << BigInt(to - from)) - 1n));
     }
-    create(init) {
-        return new this.constructor(init);
+    // mutating methods
+    setMask(m) {
+        this.bits |= m;
     }
-    copyUndefined(other) {
-        for (const i in other.bits) {
-            if (this.bits[i] === undefined)
-                this.bits[i] = other.bits[i];
-        }
+    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;
     }
-    flipUndefined(other) {
-        for (const i in other.bits) {
-            if (this.bits[i] === undefined)
-                this.bits[i] = ~other.bits[i];
-        }
+    clearRange(a, b) {
+        this.clearMask((1n << BigInt(b)) - (1n << BigInt(a)));
         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;
-        }
-        else {
-            for (const [k, v] of Object.entries(entries))
-                r.bits[+k] = v;
-        }
-        return r;
+    selfComplement() {
+        this.bits = ~this.bits;
+        return this;
     }
-    keys() {
-        return Object.keys(this.bits).map(k => +k);
+    selfIntersect(other) {
+        this.bits &= other.bits;
+        return this;
     }
-    entries() {
-        //return this.bits;
-        return Object.entries(this.bits).map(([k, v]) => [+k, v]);
+    selfUnion(other) {
+        this.bits |= other.bits;
+        return this;
+    }
+    selfXor(other) {
+        this.bits ^= other.bits;
+        return this;
+    }
+    selfDifference(other) {
+        this.bits &= ~other.bits;
+        return this;
+    }
+}
+exports.DenseBits = DenseBits;
+;
+//-----------------------------------------------------------------------------
+// DenseBits32 - a dense bitset implementation using Uint32Array
+//-----------------------------------------------------------------------------
+class DenseBits32 {
+    bits;
+    constructor(bits = new Uint32Array(1)) {
+        this.bits = bits;
+    }
+    create(bits) {
+        return new this.constructor(bits);
+    }
+    static fromIndices(...indices) {
+        const max = Math.max(...indices);
+        const bits = new Uint32Array(Math.ceil((max + 1) / 32));
+        for (const i of indices)
+            bits[i >>> 5] |= 1 << (i & 31);
+        return new this(bits);
+    }
+    get length() {
+        const n = this.bits.length;
+        return highestSet32(this.bits[n - 1]) + (n - 1) * 32;
     }
     test(a) {
-        return !!((this.bits[a >> 5] ?? this.undef) & (1 << (a & 0x1f)));
+        return !!(this.bits[a >>> 5] & (1 << (a & 31)));
+    }
+    equals(other) {
+        if (this.bits.length !== other.bits.length)
+            return false;
+        for (let i = 0; i < this.bits.length; i++) {
+            if (this.bits[i] !== other.bits[i])
+                return false;
+        }
+        return true;
+    }
+    contains(other) {
+        return other.bits.every((b, i) => (b & this.bits[i]) === b);
+    }
+    intersects(other) {
+        return this.bits.some((b, i) => (b & other.bits[i]) !== 0);
     }
     countSet() {
-        let count = 0;
-        for (const i in this.bits)
-            count += countSet32(this.bits[i]);
-        return count;
+        return this.bits.reduce((a, b) => a + countSet32(b), 0);
     }
     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;
-            }
+        for (let i = 0; i < this.bits.length; i++) {
+            const c = countSet32(this.bits[i]);
+            if (a < c)
+                return i * 32 + nthSet32(this.bits[i], a);
+            a -= c;
         }
         return -1;
     }
     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.map(b => ~b));
     }
     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.map((b, i) => b & other.bits[i]));
     }
     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);
+        if (other.bits.length > this.bits.length)
+            return this.create(other.bits.map((b, i) => b | this.bits[i]));
+        return this.create(this.bits.map((b, i) => b | other.bits[i]));
     }
     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);
+        if (other.bits.length > this.bits.length)
+            return this.create(other.bits.map((b, i) => b ^ this.bits[i]));
+        return this.create(this.bits.map((b, i) => b ^ other.bits[i]));
     }
-    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;
+    difference(other) {
+        return this.create(this.bits.map((b, i) => b & ~other.bits[i]));
     }
     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;
+        const xor = set ? 0 : -1;
+        for (let i = a >>> 5; i < this.bits.length; i++) {
+            let b = this.bits[i] ^ xor;
+            if (b) {
+                if (i === (a >>> 5)) {
+                    b &= -(1 << (a & 31));
+                    if (!b)
+                        continue;
+                }
+                return i * 32 + lowestSet32(b);
             }
-            return (i << 5) + lowestSet32(~v);
         }
+        return -1;
     }
-    where(set, from = -1) {
+    where(set, from = -1, to) {
+        const bits = this.bits;
+        ++from;
+        to = to === undefined ? bits.length * 32 : Math.min(to, bits.length * 32);
         return {
-            [Symbol.iterator]: () => ImmutableSparseBits.whereGenerator(this.bits, this.undef, set, from)
+            *[Symbol.iterator]() {
+                const xor = set ? 0 : -1;
+                const end = (to + 31) >>> 5;
+                for (let i = from >>> 5; i < end; i++) {
+                    let b = bits[i] ^ xor;
+                    if (i === (from >>> 5))
+                        b &= -(1 << (from & 31));
+                    if (i === end - 1)
+                        b &= (1 << (to & 31)) - 1;
+                    while (b) {
+                        yield i * 32 + lowestSet32(b);
+                        b = b & (b - 1);
+                    }
+                }
+            }
         };
     }
-    ranges() {
+    ranges(set = true) {
         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;
+                for (let i = 0; i < bits.length; i++) {
+                    let b = bits[i];
                     const c0 = +i * 32;
                     while ((start < 0 ? b : ~b) !== 0) {
                         if (start === -1) {
                             start = c0 + lowestSet32(b);
-                            if (undef)
+                            if (!set && end != start)
                                 yield [end, start];
                             end = -1;
                             b = b | (b - 1);
                         }
                         else {
                             end = c0 + lowestSet32(~b);
-                            if (!undef)
+                            if (set)
                                 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)
+                if (set) {
+                    if (start >= 0)
+                        yield [start, bits.length * 32];
+                }
+                else {
                     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;
-    }
-    clean() {
-        for (const i in this.bits) {
-            if (this.bits[i] === this.undef)
-                delete this.bits[i];
-        }
-        return this;
+        yield* this.where(true);
     }
-    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);
+    toSparse() {
+        const sparse = [];
+        for (let i = 0; i < this.bits.length; i++) {
+            const v = this.bits[i];
+            if (v)
+                sparse[i] = v;
         }
-        return new DenseBits(bits);
-    }
-}
-exports.ImmutableSparseBits = ImmutableSparseBits;
-class SparseBits extends ImmutableSparseBits {
+        return new SparseBits(sparse);
+    }
+    slice(from, to) {
+        to = to === undefined ? this.bits.length * 32 : Math.min(to, this.bits.length * 32);
+        const fromi = from >>> 5, toi = (to + 31) >>> 5;
+        const shift = from & 31;
+        const bits = shift === 0
+            ? this.bits.slice(fromi, toi)
+            : this.bits.subarray(fromi, toi).map((b, i) => (b >>> shift) | (this.bits[fromi + i + 1] << (32 - shift)));
+        const maskBits = (to - from) & 31;
+        if (maskBits)
+            bits[bits.length - 1] &= (1 << maskBits) - 1;
+        return this.create(bits);
+    }
+    // mutating methods
     setMask(i, m) {
-        if (this.bits[i] !== undefined)
-            this.bits[i] |= m;
-        else if (!this.undef)
-            this.bits[i] = m;
+        if (i >= this.bits.length) {
+            const bits = new Uint32Array(i + 1);
+            bits.set(this.bits);
+            this.bits = bits;
+        }
+        this.bits[i] |= m;
     }
     clearMask(i, m) {
-        if (this.bits[i] !== undefined)
+        if (i < this.bits.length)
             this.bits[i] &= ~m;
-        else if (this.undef)
-            this.bits[i] = ~m;
     }
     set(a) {
-        this.setMask(a >> 5, 1 << (a & 0x1f));
+        this.setMask(a >>> 5, 1 << (a & 31));
     }
     clear(a) {
-        this.clearMask(a >> 5, 1 << (a & 0x1f));
+        this.clearMask(a >>> 5, 1 << (a & 31));
     }
     setRange(a, b) {
-        let i = a >> 5, j = b >> 5;
-        if (i === j) {
-            this.setMask(i, (1 << (b & 0x1f)) - (1 << (a & 0x1f)));
+        const ai = a >>> 5, bi = b >>> 5;
+        if (ai === bi) {
+            this.setMask(ai, (1 << (b & 31)) - (1 << (a & 31)));
         }
         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);
+            this.setMask(bi, (1 << (b & 31)) - 1);
+            this.setMask(ai, -(1 << (a & 31)));
+            for (let i = ai + 1; i < bi; i++)
+                this.bits[i] = -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 {
-            this.clearMask(i++, -(1 << (a & 0x1f)));
-            if (!this.undef) {
-                while (i < j)
-                    delete this.bits[i++];
+        const ai = a >>> 5, bi = b >>> 5;
+        if (ai < this.bits.length) {
+            if (ai === bi) {
+                this.clearMask(ai, (1 << (b & 31)) - (1 << (a & 31)));
             }
             else {
-                while (i < j)
-                    this.bits[i++] = 0;
+                this.clearMask(ai, -(1 << (a & 31)));
+                if (bi >= this.bits.length) {
+                    this.bits = this.bits.slice(0, ai + 1);
+                }
+                else {
+                    for (let i = ai + 1; i < bi; i++)
+                        this.bits[i] = 0;
+                    this.clearMask(bi, (1 << (b & 31)) - 1);
+                }
             }
-            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];
+        this.bits = this.bits.map(b => ~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;
+        this.bits = this.bits.map((b, i) => b & other.bits[i]);
         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.length > this.bits.length
+            ? other.bits.map((b, i) => b | this.bits[i])
+            : this.bits.map((b, i) => b | other.bits[i]);
         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.length > this.bits.length
+            ? other.bits.map((b, i) => b ^ this.bits[i])
+            : this.bits.map((b, i) => b ^ other.bits[i]);
+        return this;
+    }
+    selfDifference(other) {
+        this.bits = this.bits.map((b, i) => b & ~other.bits[i]);
+        return this;
+    }
+    clean() {
+        let i = this.bits.length;
+        while (i-- && this.bits[i] === 0)
+            ;
+        this.bits = this.bits.slice(0, i + 1);
         return this;
     }
 }
-exports.SparseBits = SparseBits;
+exports.DenseBits32 = DenseBits32;
 ;
 //-----------------------------------------------------------------------------
-// DenseBits - a dense bitset implementation using bigint
+// SparseBits - a sparse bitset where each entry in the 'bits' array represents 32 bits
 //-----------------------------------------------------------------------------
-class ImmutableDenseBits {
+function sparseFromIndices(indices) {
+    const bits = [];
+    for (const i of indices)
+        bits[i >> 5] |= 1 << (i & 0x1f);
+    return bits;
+}
+function sparseCopyUndefined(bits, other, xor = 0) {
+    for (const i in other) {
+        if (bits[i] === undefined)
+            bits[i] = other[i] ^ xor;
+    }
+    return bits;
+}
+function sparseDeleteUndefined(bits, other) {
+    for (const i in bits) {
+        if (other[i] === undefined)
+            delete bits[i];
+    }
+    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 {
+            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) {
+    const result = [];
+    for (const i in bits) {
+        if (other[i] !== undefined) {
+            result[i] = bits[i] & other[i];
+        }
+    }
+    return result;
+}
+function sparseUnion(bits, other) {
+    const result = [];
+    for (const i in bits) {
+        if (other[i] !== undefined) {
+            result[i] = bits[i] | other[i];
+        }
+    }
+    return result;
+}
+function sparseXor(bits, other) {
+    const result = [];
+    for (const i in bits) {
+        if (other[i] !== undefined) {
+            result[i] = bits[i] ^ other[i];
+        }
+    }
+    return result;
+}
+function sparseDifference(bits, other) {
+    const result = [];
+    for (const i in bits) {
+        if (other[i] !== undefined) {
+            result[i] = bits[i] & ~other[i];
+        }
+    }
+    return result;
+}
+function sparseSelfComplement(bits) {
+    for (const i in bits)
+        bits[i] = ~bits[i];
+    return bits;
+}
+function sparseSelfIntersect(bits, other) {
+    for (const i in bits)
+        if (other[i] !== undefined)
+            bits[i] &= other[i];
+    return bits;
+}
+function sparseSelfUnion(bits, other) {
+    for (const i in bits)
+        if (other[i] !== undefined)
+            bits[i] |= other[i];
+    return bits;
+}
+function sparseSelfXor(bits, other) {
+    for (const i in bits)
+        if (other[i] !== undefined)
+            bits[i] ^= other[i];
+    return bits;
+}
+function sparseSelfDifference(bits, other) {
+    for (const i in bits)
+        if (other[i] !== undefined)
+            bits[i] &= ~other[i];
+    return bits;
+}
+function sparseEquals(bits, other) {
+    const ka = Object.keys(bits), kb = Object.keys(other);
+    if (ka.length !== kb.length)
+        return false;
+    for (const k of ka) {
+        if (bits[+k] !== other[+k])
+            return false;
+    }
+    return true;
+}
+function sparseIntersects(bits, other, undef = 0) {
+    for (const i in bits) {
+        if ((bits[i] & (other[i] ?? undef)))
+            return true;
+    }
+    return false;
+}
+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;
+    const from32 = from >> 5;
+    const fromM = 1 << (from & 0x1f);
+    if (undef ? !set : set) {
+        for (const i in bits) {
+            if (+i >= from32) {
+                const v = (bits[i] ^ undef) & (+i === from32 ? -fromM : -1);
+                if (v)
+                    return (+i << 5) + lowestSet32(v);
+            }
+        }
+        return -1;
+    }
+    else {
+        if (bits[from32] === undefined)
+            return from;
+        let i = from32;
+        let v = (bits[i] ^ undef) | (fromM - 1);
+        while (!v) {
+            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);
+    function* block(i, v) {
+        while (v) {
+            yield (i << 5) + lowestSet32(v);
+            v &= v - 1;
+        }
+    }
+    if (undef ? !set : set) {
+        for (const k in bits) {
+            const i = +k;
+            if (i >= from32) {
+                if (i >= to32)
+                    break;
+                let v = bits[i] ^ undef;
+                if (i === from32)
+                    v &= -fromM;
+                if (i === to32)
+                    v &= (toM - 1);
+                yield* block(i, v);
+            }
+        }
+    }
+    else {
+        if (to32 > from32) {
+            yield* block(from32, ((bits[from32] ?? undef) ^ ~undef) & -fromM);
+            for (let i = from32 + 1; i < to32; i++)
+                yield* block(i, (bits[i] ?? undef) ^ ~undef);
+            yield* block(to32, ((bits[to32] ?? undef) ^ ~undef) & (toM - 1));
+        }
+        else if (to32 === from32) {
+            yield* block(from32, ((bits[from32] ?? undef) ^ ~undef) & (-fromM & (toM - 1)));
+        }
+    }
+}
+function* sparseRanges(bits, set, undef = 0) {
+    let start = -1, end = 0;
+    let other = undef ? set : !set;
+    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 (other && end != start)
+                    yield [end, start];
+                end = -1;
+                b = b | (b - 1);
+            }
+            else {
+                end = c0 + lowestSet32(~b);
+                if (!other)
+                    yield [start, end];
+                start = -1;
+                b = b & (b + 1);
+            }
+        }
+        if (start >= 0 && bits[+i + 1] === undefined) {
+            if (!other)
+                yield [start, c0 + 32];
+            start = -1;
+        }
+    }
+    if (other)
+        yield [end, Infinity];
+}
+function sparseSlice(bits, from, to) {
+    const from32 = from >> 5;
+    const fromM = 1 << (from & 0x1f);
+    const to32 = to !== undefined ? to >> 5 : Infinity;
+    const toM = to !== undefined ? 1 << (to & 0x1f) : 0;
+    const result = [];
+    for (const k in bits) {
+        const i = +k;
+        if (i >= from32) {
+            if (i > to32)
+                break;
+            let b = bits[k];
+            if (i === from32)
+                b &= -fromM;
+            if (i === to32)
+                b &= toM - 1;
+            if (b !== 0)
+                result[k] = b;
+        }
+    }
+    return result;
+}
+class SparseBits {
     bits;
-    constructor(bits = 0n) {
+    constructor(bits = []) {
         this.bits = bits;
     }
-    create(bits) {
+    create(bits = []) {
         return new this.constructor(bits);
     }
-    get length() {
-        return highestSet(this.bits);
+    static fromEntries(entries, ...extra) {
+        return new this(Array.isArray(entries) ? Object.fromEntries(entries) : entries, ...extra);
+    }
+    static fromIndices(indicesOrFirst, ...rest) {
+        return Array.isArray(indicesOrFirst)
+            ? new this(sparseFromIndices(indicesOrFirst), ...rest)
+            : new this(sparseFromIndices([indicesOrFirst, ...rest]));
+    }
+    copy() {
+        return this.create({ ...this.bits });
+    }
+    empty() {
+        for (const i in this.bits) {
+            if (this.bits[i] !== 0)
+                return false;
+        }
+        return true;
+    }
+    keys() {
+        return Object.keys(this.bits).map(k => +k);
+    }
+    entries() {
+        return Object.entries(this.bits).map(([k, v]) => [+k, v]);
     }
     test(a) {
-        return !!(this.bits & (1n << BigInt(a)));
+        return sparseTest(this.bits, a);
+    }
+    equals(other) {
+        return sparseEquals(this.bits, other.bits);
+    }
+    contains(other) {
+        return sparseContains(this.bits, other.bits);
+    }
+    intersects(other) {
+        return sparseIntersects(this.bits, other.bits);
     }
     countSet() {
-        return countSet(this.bits);
+        return sparseCountSet(this.bits);
     }
     nthSet(a) {
-        return nthSet(this.bits, a);
+        return sparseNthSet(this.bits, a);
     }
     complement() {
-        return this.create(~this.bits);
+        return new SparseBits2(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(sparseCopyUndefined(sparseUnion(this.bits, other.bits), other.bits), this.bits));
     }
     xor(other) {
-        return this.create(this.bits ^ other.bits);
+        return this.create(sparseCopyUndefined(sparseCopyUndefined(sparseXor(this.bits, other.bits), other.bits, -1), this.bits, -1));
     }
-    contains(other) {
-        return (this.bits & other.bits) === other.bits;
+    difference(other) {
+        return this.create(sparseCopyUndefined(sparseDifference(this.bits, other.bits), this.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;
+    next(from, set = true) {
+        return sparseNext(this.bits, from, set);
     }
-    where(set, from = -1) {
-        let bits = this.bits >> BigInt(from + 1);
+    where(set, from = -1, to) {
         return {
-            *[Symbol.iterator]() {
-                while (bits) {
-                    const i = highestSet(set ? bits & -bits : (bits + 1n) & ~bits);
-                    from += i;
-                    yield from;
-                    bits >>= BigInt(i);
-                }
-            }
-        };
-        /*
-        const self = this;
-        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;
+    ranges(set = true) {
         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, set)
         };
     }
     *[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)); // ?? this.bits.length * 32));
+    }
+    //mutating methods
+    set(a) {
+        sparseSetMask(this.bits, a >> 5, 1 << (a & 0x1f));
+    }
+    clear(a) {
+        sparseClearMask(this.bits, a >> 5, 1 << (a & 0x1f));
+    }
+    setRange(a, b) {
+        sparseSetRange(this.bits, a, b);
+        return this;
+    }
+    clearRange(a, b) {
+        sparseClearRange(this.bits, a, b);
+        return this;
+    }
+    selfIntersect(other) {
+        sparseSelfIntersect(this.bits, other.bits);
+        sparseDeleteUndefined(this.bits, other.bits);
+        return this;
+    }
+    selfUnion(other) {
+        sparseCopyUndefined(sparseSelfUnion(this.bits, other.bits), other.bits);
+        return this;
+    }
+    selfXor(other) {
+        sparseCopyUndefined(sparseSelfXor(this.bits, other.bits), other.bits);
+        return this;
+    }
+    selfDifference(other) {
+        sparseSelfDifference(this.bits, other.bits);
+        return this;
     }
 }
-exports.ImmutableDenseBits = ImmutableDenseBits;
+exports.SparseBits = SparseBits;
 ;
-class DenseBits extends ImmutableDenseBits {
-    setMask(m) {
-        this.bits |= m;
+//-----------------------------------------------------------------------------
+// SparseBits2 as above, with 'undef' indicating whether undefined entries are treated as 0 or 0xffffffff
+//-----------------------------------------------------------------------------
+class SparseBits2 extends SparseBits {
+    undef;
+    constructor(bits = [], initial = false) {
+        super(bits);
+        this.undef = initial ? -1 : 0;
     }
-    clearMask(m) {
-        this.bits &= ~m;
+    create(bits = [], initial = false) {
+        return new this.constructor(bits, initial);
+    }
+    copy() {
+        return this.create({ ...this.bits }, !!this.undef);
+    }
+    empty() {
+        return !this.undef && super.empty();
+    }
+    test(a) {
+        return sparseTest(this.bits, a, this.undef);
+    }
+    equals(other) {
+        return this.undef === other.undef && sparseEquals(this.bits, other.bits);
+    }
+    contains(other) {
+        if (other.undef && !this.undef)
+            return false;
+        return sparseContains(this.bits, other.bits, this.undef);
+    }
+    intersects(other) {
+        if (this.undef)
+            return !!other.undef || sparseIntersects(other.bits, this.bits, this.undef);
+        return sparseIntersects(this.bits, other.bits, other.undef);
+    }
+    nthSet(a) {
+        return sparseNthSet(this.bits, a, this.undef);
+    }
+    complement() {
+        return this.create(sparseComplement(this.bits), this.undef === 0);
+    }
+    intersect(other) {
+        const bits = sparseIntersect(this.bits, other.bits);
+        if (other.undef)
+            sparseCopyUndefined(bits, this.bits);
+        if (this.undef)
+            return this.create(sparseCopyUndefined(bits, other.bits), !!other.undef);
+        return this.create(bits, false);
+    }
+    union(other) {
+        const bits = sparseUnion(this.bits, other.bits);
+        if (!other.undef)
+            sparseCopyUndefined(bits, this.bits);
+        if (this.undef)
+            return this.create(bits, true);
+        return this.create(sparseCopyUndefined(bits, other.bits), !!other.undef);
+    }
+    xor(other) {
+        return this.create(sparseCopyUndefined(sparseCopyUndefined(sparseXor(this.bits, other.bits), other.bits, this.undef), this.bits, other.undef), !!(this.undef ^ other.undef));
     }
+    difference(other) {
+        const bits = sparseDifference(this.bits, other.bits);
+        if (!other.undef) {
+            sparseCopyUndefined(bits, this.bits);
+            return this.create(bits, !!this.undef);
+        }
+        if (this.undef)
+            sparseCopyUndefined(bits, other.bits, -1);
+        return this.create(bits, false);
+    }
+    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(set = true) {
+        return {
+            [Symbol.iterator]: () => sparseRanges(this.bits, set, 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) {
+        //to ??= this.bits.length * 32;
+        return this.undef
+            ? this.create(sparseSelfComplement(sparseSlice(sparseComplement(this.bits), from, to)), true)
+            : this.create(sparseSlice(this.bits, from, to), false);
+    }
+    //mutating methods
     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;
+        sparseSelfComplement(this.bits);
+        this.undef = ~this.undef;
         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;
+        }
+        else if (!other.undef) {
+            sparseDeleteUndefined(this.bits, other.bits);
+        }
         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;
+        }
+        else if (other.undef) {
+            sparseDeleteUndefined(this.bits, other.bits);
+        }
         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;
+    }
+    selfDifference(other) {
+        sparseSelfDifference(this.bits, other.bits);
+        if (other.undef) {
+            if (this.undef)
+                sparseCopyUndefined(this.bits, other.bits, -1);
+            this.undef = 0;
+        }
         return this;
     }
 }
-exports.DenseBits = DenseBits;
+exports.SparseBits2 = SparseBits2;
 ;