@isopodlabs/utilities 1.6.0 → 1.7.0

package/dist/bits.d.ts

@@ -3,36 +3,40 @@ 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 reverse32(x: number): number;
 export declare function highestSet(x: bigint | number): number;
 export declare function lowestSet(x: number | bigint): number;
 export declare function countSet(x: bigint | number): number;
 export declare function nthSet(x: bigint | number, i: number): number;
+export declare function reverse(x: number): number;
+export declare function reverse(x: bigint): bigint;
 export declare function highestClear(x: number | bigint): number;
 export declare function lowestClear(x: number | bigint): number;
 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 BitSet {
     test(a: number): boolean;
+    equals(other: this): boolean;
+    contains(other: this): boolean;
+    intersects(other: this): boolean;
     countSet(): number;
     nthSet(a: number): number;
-    complement(): ImmutableBitSet;
-    intersect(other: this): ImmutableBitSet;
-    union(other: this): ImmutableBitSet;
-    xor(other: this): ImmutableBitSet;
-    contains(other: this): boolean;
+    complement(): BitSet;
+    intersect(other: this): BitSet;
+    union(other: this): BitSet;
+    xor(other: this): BitSet;
+    difference(other: this): BitSet;
     next(a: number, set: boolean): number;
     where(set: boolean, from?: number, to?: number): {
         [Symbol.iterator](): Generator<number>;
     };
-    ranges(): {
-        [Symbol.iterator](): Generator<number[]>;
+    ranges(set?: boolean): {
+        [Symbol.iterator](): Generator<[number, number]>;
     };
-    slice(from: number, to?: number): ImmutableBitSet;
+    slice(from: number, to?: number): BitSet;
     [Symbol.iterator](): Generator<number>;
-}
-export interface BitSet extends ImmutableBitSet {
     set(a: number): void;
     clear(a: number): void;
     setRange(a: number, b: number): this;
@@ -41,32 +45,35 @@ export interface BitSet extends ImmutableBitSet {
     selfIntersect(other: this): this;
     selfUnion(other: this): this;
     selfXor(other: this): this;
+    selfDifference(other: this): this;
 }
-export declare class ImmutableDenseBits implements ImmutableBitSet {
+export declare class DenseBits implements BitSet {
     protected bits: bigint;
     constructor(bits?: bigint);
     protected create(bits?: bigint): this;
+    static fromIndices<C extends new (bits: bigint, ...args: any[]) => any>(this: C, ...indices: number[]): InstanceType<C>;
     get length(): number;
     test(a: number): boolean;
+    equals(other: this): boolean;
+    contains(other: this): boolean;
+    intersects(other: this): 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;
+    intersect(other: DenseBits): this;
+    union(other: DenseBits): this;
+    xor(other: DenseBits): this;
+    difference(other: DenseBits): this;
     next(a: number, set?: boolean): number;
     where(set: boolean, from?: number, to?: number): {
         [Symbol.iterator](): Generator<number>;
     };
-    ranges(): {
-        [Symbol.iterator](): Generator<number[]>;
+    ranges(set?: boolean): {
+        [Symbol.iterator](): Generator<[number, number]>;
     };
     [Symbol.iterator](): Generator<number>;
-    toSparse(): SparseBits2;
-    slice(from: number, to?: number): ImmutableBitSet;
-}
-export declare class DenseBits extends ImmutableDenseBits implements BitSet {
+    toSparse(): SparseBits;
+    slice(from: number, to?: number): BitSet;
     protected setMask(m: bigint): void;
     protected clearMask(m: bigint): void;
     set(a: number): void;
@@ -77,35 +84,83 @@ export declare class DenseBits extends ImmutableDenseBits implements BitSet {
     selfIntersect(other: DenseBits): this;
     selfUnion(other: DenseBits): this;
     selfXor(other: DenseBits): this;
+    selfDifference(other: DenseBits): this;
 }
-export declare class ImmutableSparseBits implements ImmutableBitSet {
+export declare class DenseBits32 implements BitSet {
+    protected bits: Uint32Array;
+    constructor(bits?: Uint32Array);
+    protected create(bits?: Uint32Array): this;
+    static fromIndices<C extends new (bits: Uint32Array, ...args: any[]) => any>(this: C, ...indices: number[]): InstanceType<C>;
+    get length(): number;
+    test(a: number): boolean;
+    equals(other: this): boolean;
+    contains(other: this): boolean;
+    intersects(other: this): boolean;
+    countSet(): number;
+    nthSet(a: number): number;
+    complement(): this;
+    intersect(other: DenseBits32): this;
+    union(other: DenseBits32): this;
+    xor(other: DenseBits32): this;
+    difference(other: DenseBits32): this;
+    next(a: number, set?: boolean): number;
+    where(set: boolean, from?: number, to?: number): {
+        [Symbol.iterator](): Generator<number>;
+    };
+    ranges(set?: boolean): {
+        [Symbol.iterator](): Generator<[number, number]>;
+    };
+    [Symbol.iterator](): Generator<number>;
+    toSparse(): SparseBits;
+    slice(from: number, to?: number): BitSet;
+    protected setMask(i: number, m: number): void;
+    protected clearMask(i: number, m: number): 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: DenseBits32): this;
+    selfUnion(other: DenseBits32): this;
+    selfXor(other: DenseBits32): this;
+    selfDifference(other: DenseBits32): this;
+    clean(): this;
+}
+type SparseNumberArray = number[] | Record<number, number>;
+type ExtraParams<T> = T extends new (bits: SparseNumberArray, ...args: infer P) => any ? P : never;
+export declare class SparseBits implements BitSet {
     protected bits: number[];
-    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;
+    constructor(bits?: SparseNumberArray);
+    protected create(bits?: SparseNumberArray): this;
+    static fromEntries<C extends new (bits: SparseNumberArray, ...args: any[]) => any>(this: C, entries: Record<number, number> | [number, number][], ...extra: ExtraParams<C>): InstanceType<C>;
+    static fromIndices<C extends new (bits: SparseNumberArray, ...args: any[]) => any>(this: C, ...indices: number[]): InstanceType<C>;
+    static fromIndices<C extends new (bits: SparseNumberArray, ...args: any[]) => any>(this: C, indices: number[], ...extra: ExtraParams<C>): InstanceType<C>;
+    copy(): this;
+    empty(): boolean;
     keys(): number[];
     entries(): [number, number][];
     test(a: number): boolean;
+    equals(other: this): boolean;
+    contains(other: SparseBits): boolean;
+    intersects(other: SparseBits): boolean;
     countSet(): number;
     nthSet(a: number): number;
-    complement(): ImmutableSparseBits2;
-    intersect(other: ImmutableSparseBits): this;
-    union(other: ImmutableSparseBits): this;
-    xor(other: ImmutableSparseBits): this;
-    contains(other: ImmutableSparseBits): boolean;
+    complement(): SparseBits2;
+    intersect(other: SparseBits): this;
+    union(other: SparseBits): this;
+    xor(other: SparseBits): this;
+    difference(other: this): BitSet;
     next(from: number, set?: boolean): number;
     where(set: boolean, from?: number, to?: number): {
         [Symbol.iterator]: () => Generator<number, void, unknown>;
     };
-    ranges(): {
-        [Symbol.iterator]: () => Generator<number[], void, unknown>;
+    ranges(set?: boolean): {
+        [Symbol.iterator]: () => Generator<[number, number], any, any>;
     };
     [Symbol.iterator](): Generator<number>;
     clean(): this;
     toDense(): DenseBits;
-    slice(from: number, to?: number): ImmutableBitSet;
-}
-export declare class SparseBits extends ImmutableSparseBits implements BitSet {
+    slice(from: number, to?: number): BitSet;
     set(a: number): void;
     clear(a: number): void;
     setRange(a: number, b: number): this;
@@ -113,31 +168,35 @@ export declare class SparseBits extends ImmutableSparseBits implements BitSet {
     selfIntersect(other: SparseBits): this;
     selfUnion(other: SparseBits): this;
     selfXor(other: SparseBits): this;
+    selfDifference(other: this): this;
 }
-export declare class ImmutableSparseBits2 extends ImmutableSparseBits {
+export declare class SparseBits2 extends SparseBits {
     protected undef: number;
-    constructor(bits?: number[], initial?: boolean);
-    protected create(bits?: number[], init?: boolean): this;
+    constructor(bits?: SparseNumberArray, initial?: boolean);
+    protected create(bits?: SparseNumberArray, initial?: boolean): this;
+    copy(): this;
+    empty(): boolean;
     test(a: number): boolean;
+    equals(other: this): boolean;
+    contains(other: SparseBits2): boolean;
+    intersects(other: SparseBits2): boolean;
     nthSet(a: number): number;
     complement(): this;
-    intersect(other: ImmutableSparseBits2): this;
-    union(other: ImmutableSparseBits2): this;
-    xor(other: ImmutableSparseBits2): this;
-    contains(other: ImmutableSparseBits2): boolean;
+    intersect(other: SparseBits2): this;
+    union(other: SparseBits2): this;
+    xor(other: SparseBits2): this;
+    difference(other: SparseBits2): BitSet;
     next(from: number, set?: boolean): number;
     where(set: boolean, from?: number, to?: number): {
         [Symbol.iterator]: () => Generator<number, void, unknown>;
     };
-    ranges(): {
-        [Symbol.iterator]: () => Generator<number[], void, unknown>;
+    ranges(set?: boolean): {
+        [Symbol.iterator]: () => Generator<[number, number], any, any>;
     };
     [Symbol.iterator](): Generator<number>;
     clean(): this;
     toDense(): DenseBits;
-    slice(from: number, to?: number): ImmutableBitSet;
-}
-export declare class SparseBits2 extends ImmutableSparseBits2 implements BitSet {
+    slice(from: number, to?: number): BitSet;
     set(a: number): void;
     clear(a: number): void;
     setRange(a: number, b: number): this;
@@ -146,4 +205,6 @@ export declare class SparseBits2 extends ImmutableSparseBits2 implements BitSet
     selfIntersect(other: SparseBits2): this;
     selfUnion(other: SparseBits2): this;
     selfXor(other: SparseBits2): this;
+    selfDifference(other: this): this;
 }
+export {};

package/dist/bits.js

@@ -3,16 +3,18 @@
 // Bit twiddling functions
 //-----------------------------------------------------------------------------
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SparseBits2 = exports.ImmutableSparseBits2 = exports.SparseBits = exports.ImmutableSparseBits = exports.DenseBits = exports.ImmutableDenseBits = 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;
@@ -65,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)
@@ -239,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);
@@ -257,7 +298,7 @@ function clearLowest(x) {
 //-----------------------------------------------------------------------------
 // DenseBits - a dense bitset implementation using bigint
 //-----------------------------------------------------------------------------
-class ImmutableDenseBits {
+class DenseBits {
     bits;
     constructor(bits = 0n) {
         this.bits = bits;
@@ -265,12 +306,27 @@ class ImmutableDenseBits {
     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);
     }
@@ -289,8 +345,8 @@ class ImmutableDenseBits {
     xor(other) {
         return this.create(this.bits ^ other.bits);
     }
-    contains(other) {
-        return (this.bits & other.bits) === other.bits;
+    difference(other) {
+        return this.create(this.bits & ~other.bits);
     }
     next(a, set = true) {
         let s = this.bits >> BigInt(a + 1);
@@ -312,17 +368,20 @@ class ImmutableDenseBits {
             }
         };
     }
-    ranges() {
+    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);
-                    yield [offset + i - 1, offset + i + j - 1];
+                    if (set)
+                        yield [offset + i - 1, offset + i + j - 1];
                     offset += i + j;
                 }
             }
@@ -332,23 +391,20 @@ class ImmutableDenseBits {
         yield* this.where(true);
     }
     toSparse() {
-        const sparse = {};
+        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);
+        return new SparseBits(sparse);
     }
     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 {
+    // mutating methods
     setMask(m) {
         this.bits |= m;
     }
@@ -385,23 +441,275 @@ class DenseBits extends ImmutableDenseBits {
         this.bits ^= other.bits;
         return this;
     }
+    selfDifference(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
+// DenseBits32 - a dense bitset implementation using Uint32Array
 //-----------------------------------------------------------------------------
-function sparseFromEntries(entries) {
-    const dest = [];
-    if (Array.isArray(entries)) {
-        for (const [k, v] of entries)
-            dest[k] = v;
+class DenseBits32 {
+    bits;
+    constructor(bits = new Uint32Array(1)) {
+        this.bits = bits;
     }
-    else {
-        for (const [k, v] of Object.entries(entries))
-            dest[+k] = v;
+    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] & (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() {
+        return this.bits.reduce((a, b) => a + countSet32(b), 0);
+    }
+    nthSet(a) {
+        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() {
+        return this.create(this.bits.map(b => ~b));
+    }
+    intersect(other) {
+        return this.create(this.bits.map((b, i) => b & other.bits[i]));
+    }
+    union(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) {
+        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]));
+    }
+    difference(other) {
+        return this.create(this.bits.map((b, i) => b & ~other.bits[i]));
+    }
+    next(a, set = true) {
+        ++a;
+        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 -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]() {
+                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(set = true) {
+        const bits = this.bits;
+        return {
+            *[Symbol.iterator]() {
+                let start = -1, end = 0;
+                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 (!set && end != start)
+                                yield [end, start];
+                            end = -1;
+                            b = b | (b - 1);
+                        }
+                        else {
+                            end = c0 + lowestSet32(~b);
+                            if (set)
+                                yield [start, end];
+                            start = -1;
+                            b = b & (b + 1);
+                        }
+                    }
+                }
+                if (set) {
+                    if (start >= 0)
+                        yield [start, bits.length * 32];
+                }
+                else {
+                    yield [end, Infinity];
+                }
+            }
+        };
+    }
+    *[Symbol.iterator]() {
+        yield* this.where(true);
+    }
+    toSparse() {
+        const sparse = [];
+        for (let i = 0; i < this.bits.length; i++) {
+            const v = this.bits[i];
+            if (v)
+                sparse[i] = v;
+        }
+        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 (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 (i < this.bits.length)
+            this.bits[i] &= ~m;
+    }
+    set(a) {
+        this.setMask(a >>> 5, 1 << (a & 31));
+    }
+    clear(a) {
+        this.clearMask(a >>> 5, 1 << (a & 31));
+    }
+    setRange(a, b) {
+        const ai = a >>> 5, bi = b >>> 5;
+        if (ai === bi) {
+            this.setMask(ai, (1 << (b & 31)) - (1 << (a & 31)));
+        }
+        else {
+            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) {
+        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 {
+                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);
+                }
+            }
+        }
+        return this;
     }
-    return dest;
+    selfComplement() {
+        this.bits = this.bits.map(b => ~b);
+        return this;
+    }
+    selfIntersect(other) {
+        this.bits = this.bits.map((b, i) => b & other.bits[i]);
+        return this;
+    }
+    selfUnion(other) {
+        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) {
+        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.DenseBits32 = DenseBits32;
+;
+//-----------------------------------------------------------------------------
+// SparseBits - a sparse bitset where each entry in the 'bits' array represents 32 bits
+//-----------------------------------------------------------------------------
+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) {
@@ -410,6 +718,13 @@ function sparseCopyUndefined(bits, other, xor = 0) {
     }
     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)
@@ -503,14 +818,41 @@ function sparseNthSet(bits, a, undef = 0) {
 function sparseComplement(bits) {
     return bits.map(b => ~b);
 }
-function sparseIntersect(bits, other, undef = 0) {
-    return bits.map((b, i) => b & (other[i] ?? undef));
+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, undef = 0) {
-    return bits.map((b, i) => b | (other[i] ?? undef));
+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, undef = 0) {
-    return bits.map((b, i) => b ^ (other[i] ?? undef));
+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)
@@ -519,19 +861,45 @@ function sparseSelfComplement(bits) {
 }
 function sparseSelfIntersect(bits, other) {
     for (const i in bits)
-        bits[i] &= other[i];
+        if (other[i] !== undefined)
+            bits[i] &= other[i];
     return bits;
 }
 function sparseSelfUnion(bits, other) {
     for (const i in bits)
-        bits[i] |= other[i];
+        if (other[i] !== undefined)
+            bits[i] |= other[i];
     return bits;
 }
 function sparseSelfXor(bits, other) {
     for (const i in bits)
-        bits[i] ^= other[i];
+        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))
@@ -541,11 +909,12 @@ function sparseContains(bits, other, undef = 0) {
 }
 function sparseNext(bits, from, set = true, undef = 0) {
     ++from;
+    const from32 = from >> 5;
+    const fromM = 1 << (from & 0x1f);
     if (undef ? !set : set) {
-        const ai = from >> 5;
         for (const i in bits) {
-            if (+i >= ai) {
-                const v = bits[i] ^ undef;
+            if (+i >= from32) {
+                const v = (bits[i] ^ undef) & (+i === from32 ? -fromM : -1);
                 if (v)
                     return (+i << 5) + lowestSet32(v);
             }
@@ -553,13 +922,12 @@ function sparseNext(bits, from, set = true, undef = 0) {
         return -1;
     }
     else {
-        let i = from >> 5;
-        if (bits[i] === undefined)
+        if (bits[from32] === undefined)
             return from;
-        let v = (bits[i] ^ undef) | ((1 << (from & 0x1f)) - 1);
+        let i = from32;
+        let v = (bits[i] ^ undef) | (fromM - 1);
         while (!v) {
-            ++i;
-            if (bits[i] === undefined)
+            if (bits[++i] === undefined)
                 break;
             v = bits[i] ^ undef;
         }
@@ -572,94 +940,93 @@ function* sparseWhere(bits, set, from = -1, to, undef = 0) {
     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 >= to32)
-                break;
             if (i >= from32) {
+                if (i >= to32)
+                    break;
                 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);
-                }
+                yield* block(i, v);
             }
         }
     }
     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);
+            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) {
-            for (let v = ((bits[from32] ?? undef) ^ ~undef) & (toM - fromM); v; v = v & (v - 1))
-                yield (from32 << 5) + lowestSet32(v);
+            yield* block(from32, ((bits[from32] ?? undef) ^ ~undef) & (-fromM & (toM - 1)));
         }
     }
 }
-function* sparseRanges(bits, undef = 0) {
+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 (undef)
+                if (other && end != start)
                     yield [end, start];
                 end = -1;
                 b = b | (b - 1);
             }
             else {
                 end = c0 + lowestSet32(~b);
-                if (!undef)
+                if (!other)
                     yield [start, end];
                 start = -1;
                 b = b & (b + 1);
             }
         }
         if (start >= 0 && bits[+i + 1] === undefined) {
-            if (!undef)
+            if (!other)
                 yield [start, c0 + 32];
             start = -1;
         }
     }
-    if (undef)
+    if (other)
         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 fromM = 1 << (from & 0x1f);
+    const to32 = to !== undefined ? to >> 5 : Infinity;
+    const toM = to !== undefined ? 1 << (to & 0x1f) : 0;
     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;
+    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 ImmutableSparseBits {
+class SparseBits {
     bits;
     constructor(bits = []) {
         this.bits = bits;
@@ -667,10 +1034,23 @@ class ImmutableSparseBits {
     create(bits = []) {
         return new this.constructor(bits);
     }
-    static fromEntries(entries, ...args) {
-        const r = new this(...args);
-        r.bits = sparseFromEntries(entries);
-        return r;
+    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);
@@ -681,6 +1061,15 @@ class ImmutableSparseBits {
     test(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 sparseCountSet(this.bits);
     }
@@ -688,19 +1077,19 @@ class ImmutableSparseBits {
         return sparseNthSet(this.bits, a);
     }
     complement() {
-        return new ImmutableSparseBits2(sparseComplement(this.bits), true);
+        return new SparseBits2(sparseComplement(this.bits), true);
     }
     intersect(other) {
         return this.create(sparseIntersect(this.bits, other.bits));
     }
     union(other) {
-        return this.create(sparseCopyUndefined(sparseUnion(this.bits, other.bits), other.bits));
+        return this.create(sparseCopyUndefined(sparseCopyUndefined(sparseUnion(this.bits, other.bits), other.bits), this.bits));
     }
     xor(other) {
-        return this.create(sparseCopyUndefined(sparseXor(this.bits, other.bits), other.bits));
+        return this.create(sparseCopyUndefined(sparseCopyUndefined(sparseXor(this.bits, other.bits), other.bits, -1), this.bits, -1));
     }
-    contains(other) {
-        return sparseContains(this.bits, other.bits);
+    difference(other) {
+        return this.create(sparseCopyUndefined(sparseDifference(this.bits, other.bits), this.bits));
     }
     next(from, set = true) {
         return sparseNext(this.bits, from, set);
@@ -710,9 +1099,9 @@ class ImmutableSparseBits {
             [Symbol.iterator]: () => sparseWhere(this.bits, set, from, to)
         };
     }
-    ranges() {
+    ranges(set = true) {
         return {
-            [Symbol.iterator]: () => sparseRanges(this.bits)
+            [Symbol.iterator]: () => sparseRanges(this.bits, set)
         };
     }
     *[Symbol.iterator]() {
@@ -729,11 +1118,9 @@ class ImmutableSparseBits {
         return new DenseBits(bits);
     }
     slice(from, to) {
-        return this.create(sparseSlice(this.bits, from, to));
+        return this.create(sparseSlice(this.bits, from, to)); // ?? this.bits.length * 32));
     }
-}
-exports.ImmutableSparseBits = ImmutableSparseBits;
-class SparseBits extends ImmutableSparseBits {
+    //mutating methods
     set(a) {
         sparseSetMask(this.bits, a >> 5, 1 << (a & 0x1f));
     }
@@ -750,6 +1137,7 @@ class SparseBits extends ImmutableSparseBits {
     }
     selfIntersect(other) {
         sparseSelfIntersect(this.bits, other.bits);
+        sparseDeleteUndefined(this.bits, other.bits);
         return this;
     }
     selfUnion(other) {
@@ -760,24 +1148,47 @@ class SparseBits extends ImmutableSparseBits {
         sparseCopyUndefined(sparseSelfXor(this.bits, other.bits), other.bits);
         return this;
     }
+    selfDifference(other) {
+        sparseSelfDifference(this.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
+// SparseBits2 as above, with 'undef' indicating whether undefined entries are treated as 0 or 0xffffffff
 //-----------------------------------------------------------------------------
-class ImmutableSparseBits2 extends ImmutableSparseBits {
+class SparseBits2 extends SparseBits {
     undef;
     constructor(bits = [], initial = false) {
         super(bits);
         this.undef = initial ? -1 : 0;
     }
-    create(bits = [], init) {
-        return new this.constructor(bits, init);
+    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);
     }
@@ -785,22 +1196,33 @@ class ImmutableSparseBits2 extends ImmutableSparseBits {
         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(sparseIntersect(this.bits, other.bits, other.undef), other.bits), !!other.undef);
-        return this.create(sparseIntersect(this.bits, other.bits), false);
+            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(sparseUnion(this.bits, other.bits), true);
-        return this.create(sparseCopyUndefined(sparseUnion(this.bits, other.bits), other.bits), !!other.undef);
+            return this.create(bits, true);
+        return this.create(sparseCopyUndefined(bits, other.bits), !!other.undef);
     }
     xor(other) {
-        return this.create(sparseCopyUndefined(sparseXor(this.bits, other.bits), other.bits, this.undef), !!(this.undef ^ other.undef));
+        return this.create(sparseCopyUndefined(sparseCopyUndefined(sparseXor(this.bits, other.bits), other.bits, this.undef), this.bits, other.undef), !!(this.undef ^ other.undef));
     }
-    contains(other) {
-        if (other.undef && !this.undef)
-            return false;
-        return sparseContains(this.bits, other.bits, this.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);
@@ -810,9 +1232,9 @@ class ImmutableSparseBits2 extends ImmutableSparseBits {
             [Symbol.iterator]: () => sparseWhere(this.bits, set, from, to, this.undef)
         };
     }
-    ranges() {
+    ranges(set = true) {
         return {
-            [Symbol.iterator]: () => sparseRanges(this.bits, this.undef)
+            [Symbol.iterator]: () => sparseRanges(this.bits, set, this.undef)
         };
     }
     *[Symbol.iterator]() {
@@ -836,11 +1258,12 @@ class ImmutableSparseBits2 extends ImmutableSparseBits {
         return new DenseBits(bits);
     }
     slice(from, to) {
-        return this.create(sparseSlice(this.bits, from, to), !!this.undef);
+        //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);
     }
-}
-exports.ImmutableSparseBits2 = ImmutableSparseBits2;
-class SparseBits2 extends ImmutableSparseBits2 {
+    //mutating methods
     set(a) {
         sparseSetMask(this.bits, a >> 5, 1 << (a & 0x1f), this.undef);
     }
@@ -856,8 +1279,8 @@ class SparseBits2 extends ImmutableSparseBits2 {
         return this;
     }
     selfComplement() {
-        this.undef = ~this.undef;
         sparseSelfComplement(this.bits);
+        this.undef = ~this.undef;
         return this;
     }
     selfIntersect(other) {
@@ -866,6 +1289,9 @@ class SparseBits2 extends ImmutableSparseBits2 {
             sparseCopyUndefined(this.bits, other.bits);
             this.undef = other.undef;
         }
+        else if (!other.undef) {
+            sparseDeleteUndefined(this.bits, other.bits);
+        }
         return this;
     }
     selfUnion(other) {
@@ -874,6 +1300,9 @@ class SparseBits2 extends ImmutableSparseBits2 {
             sparseCopyUndefined(this.bits, other.bits);
             this.undef = other.undef;
         }
+        else if (other.undef) {
+            sparseDeleteUndefined(this.bits, other.bits);
+        }
         return this;
     }
     selfXor(other) {
@@ -882,6 +1311,15 @@ class SparseBits2 extends ImmutableSparseBits2 {
         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.SparseBits2 = SparseBits2;
 ;

package/package.json

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