@isopodlabs/utilities 1.5.4 → 1.5.6

package/dist/bits.js

@@ -0,0 +1,605 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DenseBits = exports.ImmutableDenseBits = exports.SparseBits = exports.ImmutableSparseBits = void 0;
+exports.lowestSet32 = lowestSet32;
+exports.highestSet32 = highestSet32;
+exports.countSet32 = countSet32;
+exports.highestSet = highestSet;
+exports.lowestSet = lowestSet;
+exports.countSet = countSet;
+exports.highestClear = highestClear;
+exports.lowestClear = lowestClear;
+exports.countClear = countClear;
+const algorithm_1 = require("./algorithm");
+//-----------------------------------------------------------------------------
+// Bit twiddling functions
+//-----------------------------------------------------------------------------
+function lowestSet32(x) {
+    return x === 0 ? 32 : 31 - Math.clz32(x & -x);
+}
+function highestSet32(x) {
+    return x ? 32 - Math.clz32(x) : 0;
+}
+function countSet32(x) {
+    x = x - ((x >> 1) & 0x55555555);
+    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
+    return ((x + (x >> 4) & 0xF0F0F0F) * 0x1010101) >> 24;
+}
+/*
+const testersShift: bigint[] = [];	//32 << i
+const testers:		bigint[] = [];	//1 << (32 << i)
+const masks:		bigint[][] = [];
+
+export function highestSetCached(x: bigint): number {
+    if (x < 0n)
+        x = ~x;
+
+    let k = 0
+    for (;;) {
+        if (!testers[k]) {
+            testersShift[k]	= BigInt(32 << k);
+            testers[k]		= 1n << testersShift[k];
+        }
+        if (x < testers[k])
+            break
+        k++
+    }
+
+    if (k === 0)
+        return highestSet32(Number(x));
+
+    // determine length by bisection
+    k--
+    let i = 1 << k;
+    let a = x >> testersShift[k];
+    while (k--) {
+        let b = a >> testersShift[k]
+        if (b) {
+            i += 1 << k;
+            a = b;
+        }
+    }
+
+    return (i + 1) * 32 - Math.clz32(Number(a));
+}
+
+
+export function bitcountCached(x: bigint): number {
+    let k = 0;
+    for (let t = x >> 32n; t;)
+        t >>= BigInt(32 << k++);
+
+    if (!masks[k]) {
+        const limit = 1n << BigInt(32 << k);
+        const nmasks = highestSet32(k + 5);
+        masks[k] = Array.from({ length: nmasks }, (_, j) => limit / ((1n << BigInt(1 << j)) + 1n));
+    }
+
+    masks[k].forEach((mask, j) =>
+        x = (x & mask) + ((x >> BigInt(1 << j)) & mask)
+    );
+
+    for (let i = masks[k].length; i < k + 5; ++i)
+        x += x >> BigInt(1 << i);
+
+    return Number(x & 0xFFFFFFFFn);
+}
+*/
+function highestSet(x) {
+    if (x < 0)
+        x = ~x;
+    if (x < 0x100000000)
+        return highestSet32(Number(x));
+    // For numbers within safe float range, use log2
+    if (x <= Number.MAX_VALUE) {
+        const b = Math.floor(Math.log2(Number(x)));
+        return (1n << BigInt(b)) <= x ? b + 1 : b;
+    }
+    // For arbitrarily large bigints, use bit-shifting method
+    let y = BigInt(x);
+    let s = 0;
+    let k = 0;
+    for (let t = y >> 32n; t; t >>= BigInt(s)) {
+        s = 32 << k++;
+        y = t;
+    }
+    if (k) {
+        // determine length by bisection
+        k--;
+        while (k--) {
+            const b = y >> BigInt(32 << k);
+            if (b) {
+                s += 32 << k;
+                y = b;
+            }
+        }
+    }
+    return (s + 32) - Math.clz32(Number(y));
+}
+function lowestSet(x) {
+    if (x < 0x100000000)
+        return lowestSet32(Number(x));
+    const xb = BigInt(x < 0 ? ~x : x);
+    return highestSet(xb & -xb) - 1;
+}
+function countSet(x) {
+    if (x < 0)
+        x = ~x;
+    if (x < 0x100000000)
+        return countSet32(Number(x));
+    x = BigInt(x);
+    let k = 5;
+    for (let t = x >> 32n; t;)
+        t >>= BigInt(1 << k++);
+    const n = 1 << k;
+    const limit = 1n << BigInt(n);
+    let i = 1;
+    for (; i < k; i <<= 1) {
+        const bi = BigInt(i);
+        const mask = limit / ((1n << bi) + 1n);
+        x = (x & mask) + ((x >> bi) & mask);
+    }
+    //we can add the rest with a multiply and shift (which turns out to be slower)
+    //const mask = limit / ((1n << bi) - 1n);
+    //x = (x * mask) >> BigInt(n - i);
+    //we can skip the masking when the total can fit
+    for (; i < n; i <<= 1)
+        x += x >> BigInt(i);
+    return Number(x & 0xffffffffn);
+}
+function highestClear(x) {
+    return highestSet(~x);
+}
+function lowestClear(x) {
+    return lowestSet(~x);
+}
+function countClear(x) {
+    return countSet(~x);
+}
+//-----------------------------------------------------------------------------
+// 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
+//-----------------------------------------------------------------------------
+class ImmutableSparseBits {
+    bits = []; //each entry represents 32 bits
+    undef;
+    static *whereGenerator(bits, undef, set, from = -1) {
+        ++from;
+        if (undef ? !set : set) {
+            const keys = Object.keys(bits).map(k => +k);
+            if (keys.length === 0)
+                return;
+            const i = from >> 5;
+            let k = (0, algorithm_1.lowerBound)(keys, i);
+            let v = bits[keys[k]] ^ undef;
+            if (keys[k] === i)
+                v &= -(1 << (from & 0x1f));
+            for (;;) {
+                const i = keys[k];
+                while (v) {
+                    yield (i << 5) + lowestSet32(v);
+                    v = v & (v - 1);
+                }
+                ++k;
+                if (k === keys.length)
+                    return;
+                v = bits[keys[k]] ^ undef;
+            }
+        }
+        else {
+            let i = from >> 5;
+            let v = ((bits[i] ?? undef) ^ ~undef) & -(1 << (from & 0x1f));
+            for (;;) {
+                while (v) {
+                    yield (i << 5) + lowestSet32(v);
+                    v = v & (v - 1);
+                }
+                ++i;
+                v = ((bits[i] ?? undef) ^ ~undef);
+            }
+        }
+    }
+    constructor(initial = false) {
+        this.undef = initial ? -1 : 0;
+    }
+    create(init) {
+        return new this.constructor(init);
+    }
+    copyUndefined(other) {
+        for (const i in other.bits) {
+            if (this.bits[i] === undefined)
+                this.bits[i] = other.bits[i];
+        }
+        return this;
+    }
+    flipUndefined(other) {
+        for (const i in other.bits) {
+            if (this.bits[i] === undefined)
+                this.bits[i] = ~other.bits[i];
+        }
+        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;
+    }
+    keys() {
+        return Object.keys(this.bits).map(k => +k);
+    }
+    entries() {
+        //return this.bits;
+        return Object.entries(this.bits).map(([k, v]) => [+k, v]);
+    }
+    complement() {
+        const result = this.create(this.undef === 0);
+        for (const i in this.bits)
+            result.bits[i] = ~this.bits[i];
+        return result;
+    }
+    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;
+    }
+    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);
+    }
+    xor(other) {
+        const result = this.create(!!(this.undef ^ other.undef));
+        for (const i in this.bits)
+            result.bits[i] = this.bits[i] ^ other.bits[i];
+        return this.undef ? result.flipUndefined(other) : result.copyUndefined(other);
+    }
+    clean() {
+        for (const i in this.bits) {
+            if (this.bits[i] === this.undef)
+                delete this.bits[i];
+        }
+        return this;
+    }
+    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;
+    }
+    has(a) {
+        return !!((this.bits[a >> 5] ?? this.undef) & (1 << (a & 0x1f)));
+    }
+    next(a, set = true) {
+        ++a;
+        const xor = this.undef;
+        if (xor)
+            set = !set;
+        if (set) {
+            const keys = Object.keys(this.bits).map(k => +k);
+            if (keys.length === 0)
+                return -1;
+            const ai = a >> 5;
+            let i = (0, algorithm_1.lowerBound)(keys, ai);
+            let v = this.bits[keys[i]] ^ xor;
+            if (keys[i] === ai)
+                v &= -(1 << (a & 0x1f));
+            while (!v) {
+                ++i;
+                if (i === keys.length)
+                    return -1;
+                v = this.bits[keys[i]] ^ xor;
+            }
+            return (keys[i] << 5) + lowestSet32(v);
+        }
+        else {
+            let i = a >> 5;
+            if (this.bits[i] === undefined)
+                return a;
+            let v = (this.bits[i] ^ xor) | ((1 << (a & 0x1f)) - 1);
+            while (!v) {
+                ++i;
+                if (this.bits[i] === undefined)
+                    break;
+                v = this.bits[i] ^ xor;
+            }
+            return (i << 5) + lowestSet32(~v);
+        }
+    }
+    toDense() {
+        let bits = 0n;
+        if (this.undef) {
+            for (const i in this.bits)
+                bits |= BigInt(~this.bits[i]) << BigInt(+i * 32);
+            bits = ~bits;
+        }
+        else {
+            for (const i in this.bits)
+                bits |= BigInt(this.bits[i]) << BigInt(+i * 32);
+        }
+        return new DenseBits(bits);
+    }
+    where(set, from = -1) {
+        return {
+            [Symbol.iterator]: () => ImmutableSparseBits.whereGenerator(this.bits, this.undef, set, from)
+        };
+    }
+    ranges() {
+        const bits = this.bits;
+        const undef = this.undef;
+        return {
+            *[Symbol.iterator]() {
+                let start = -1, end = 0;
+                for (const i in bits) {
+                    let b = bits[i] ^ undef;
+                    const c0 = +i * 32;
+                    while ((start < 0 ? b : ~b) !== 0) {
+                        if (start === -1) {
+                            start = c0 + lowestSet32(b);
+                            if (undef)
+                                yield [end, start];
+                            end = -1;
+                            b = b | (b - 1);
+                        }
+                        else {
+                            end = c0 + lowestSet32(~b);
+                            if (!undef)
+                                yield [start, end];
+                            start = -1;
+                            b = b & (b + 1);
+                        }
+                    }
+                    if (start >= 0 && bits[+i + 1] === undefined) {
+                        if (!undef)
+                            yield [start, c0 + 32];
+                        start = -1;
+                    }
+                }
+                if (undef)
+                    yield [end, Infinity];
+            }
+        };
+    }
+    *[Symbol.iterator]() {
+        yield* ImmutableSparseBits.whereGenerator(this.bits, this.undef, true, -1);
+        //for (let i = this.next(-1); i !== -1; i = this.next(i))
+        //	yield i;
+    }
+}
+exports.ImmutableSparseBits = ImmutableSparseBits;
+class SparseBits extends ImmutableSparseBits {
+    setMask(i, m) {
+        if (this.bits[i] !== undefined)
+            this.bits[i] |= m;
+        else if (!this.undef)
+            this.bits[i] = m;
+    }
+    clearMask(i, m) {
+        if (this.bits[i] !== undefined)
+            this.bits[i] &= ~m;
+        else if (this.undef)
+            this.bits[i] = ~m;
+    }
+    selfComplement() {
+        this.undef = ~this.undef;
+        for (const i in this.bits)
+            this.bits[i] = ~this.bits[i];
+        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;
+        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;
+        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;
+        return this;
+    }
+    set(a) {
+        this.setMask(a >> 5, 1 << (a & 0x1f));
+    }
+    clear(a) {
+        this.clearMask(a >> 5, 1 << (a & 0x1f));
+    }
+    has(a) {
+        const i = a >> 5;
+        return !!((this.bits[i] ?? this.undef) & (1 << (a & 0x1f)));
+    }
+    setRange(a, b) {
+        let i = a >> 5, j = b >> 5;
+        if (i === j) {
+            this.setMask(i, (1 << (b & 0x1f)) - (1 << (a & 0x1f)));
+        }
+        else {
+            this.setMask(i++, -(1 << (a & 0x1f)));
+            if (this.undef) {
+                while (i < j)
+                    delete this.bits[i++];
+            }
+            else {
+                while (i < j)
+                    this.bits[i++] = -1;
+            }
+            this.setMask(i, (1 << (b & 0x1f)) - 1);
+        }
+        return this;
+    }
+    clearRange(a, b) {
+        let i = a >> 5, j = b >> 5;
+        if (i === j) {
+            this.clearMask(i, (1 << (b & 0x1f)) - (1 << (a & 0x1f)));
+        }
+        else {
+            this.clearMask(i++, -(1 << (a & 0x1f)));
+            if (!this.undef) {
+                while (i < j)
+                    delete this.bits[i++];
+            }
+            else {
+                while (i < j)
+                    this.bits[i++] = 0;
+            }
+            this.clearMask(i, (1 << (b & 0x1f)) - 1);
+        }
+        return this;
+    }
+}
+exports.SparseBits = SparseBits;
+;
+//-----------------------------------------------------------------------------
+// DenseBits - a dense bitset implementation using bigint
+//-----------------------------------------------------------------------------
+class ImmutableDenseBits {
+    bits;
+    constructor(bits = 0n) {
+        this.bits = bits;
+    }
+    create(bits) {
+        return new this.constructor(bits);
+    }
+    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);
+    }
+    has(a) {
+        return !!(this.bits & (1n << BigInt(a)));
+    }
+    next(a, set = true) {
+        let s = this.bits >> BigInt(a + 1);
+        s = set ? s & -s : (s + 1n) & ~s;
+        return s ? a + highestSet(s) : -1;
+    }
+    get length() {
+        return highestSet(this.bits);
+    }
+    where(set, from = -1) {
+        let bits = this.bits >> BigInt(from + 1);
+        return {
+            *[Symbol.iterator]() {
+                while (bits) {
+                    const i = highestSet(set ? bits & -bits : (bits + 1n) & ~bits);
+                    from += i;
+                    yield from;
+                    bits >>= BigInt(i);
+                }
+            }
+        };
+        /*
+        const self = this;
+        return {
+            *[Symbol.iterator](): Generator<number> {
+                for (let i = self.next(-1, set); i !== -1; i = self.next(i, set))
+                    yield i;
+            }
+        };
+        */
+    }
+    ranges() {
+        let bits = this.bits;
+        return {
+            *[Symbol.iterator]() {
+                let offset = 0;
+                while (bits) {
+                    const i = highestSet(bits & -bits);
+                    bits >>= BigInt(i);
+                    const j = highestSet(~bits & (bits + 1n));
+                    bits >>= BigInt(j);
+                    yield [offset + i - 1, offset + i + j - 1];
+                    offset += i + j;
+                }
+            }
+        };
+    }
+    *[Symbol.iterator]() {
+        yield* this.where(true);
+        //for (let i = this.next(-1); i !== -1; i = this.next(i))
+        //	yield i;
+    }
+    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);
+    }
+}
+exports.ImmutableDenseBits = ImmutableDenseBits;
+;
+class DenseBits extends ImmutableDenseBits {
+    setMask(m) {
+        this.bits |= m;
+    }
+    clearMask(m) {
+        this.bits &= ~m;
+    }
+    selfComplement() {
+        this.bits = ~this.bits;
+        return this;
+    }
+    selfIntersect(other) {
+        this.bits &= other.bits;
+        return this;
+    }
+    selfUnion(other) {
+        this.bits |= other.bits;
+        return this;
+    }
+    selfXor(other) {
+        this.bits ^= other.bits;
+        return this;
+    }
+    set(a) {
+        this.setMask(1n << BigInt(a));
+    }
+    clear(a) {
+        this.clearMask(1n << BigInt(a));
+    }
+    setRange(a, b) {
+        this.setMask((1n << BigInt(b)) - (1n << BigInt(a)));
+        return this;
+    }
+    clearRange(a, b) {
+        this.clearMask((1n << BigInt(b)) - (1n << BigInt(a)));
+        return this;
+    }
+}
+exports.DenseBits = DenseBits;
+;

package/dist/glob.d.ts

@@ -0,0 +1,4 @@
+export declare function parseGlob(glob: string): string;
+export declare function anchoredRe(re: string): RegExp;
+export declare function globToRe(glob: string): RegExp;
+export declare function globToReMulti(globs: string[]): RegExp;