@blackglory/structures 0.10.11 → 0.10.14

package/dist/es2015/index.umd.js

@@ -16504,6 +16504,9 @@
         values() {
             return this.indexToValue.values();
         }
+        getInternalIndexOfKey(key) {
+            return this.keyToIndex[key];
+        }
         has(key) {
             // 跟一般的稀疏集实现不同, 不需要访问values数组.
             return key in this.keyToIndex;
@@ -16540,7 +16543,7 @@
                     const index = this.keyToIndex[key];
                     this.indexToKey[index] = lastKey;
                     this.indexToValue[index] = lastValue;
-                    this.keyToIndex[key] = index;
+                    this.keyToIndex[lastKey] = index;
                     delete this.keyToIndex[key];
                 }
             }
@@ -16579,6 +16582,9 @@
                 yield this.indexToValue.internalTypedArray[i];
             }
         }
+        getInternalIndexOfKey(key) {
+            return this.keyToIndex[key];
+        }
         has(key) {
             const index = this.keyToIndex[key];
             return this.indexToKey[index] === key;
@@ -16986,8 +16992,100 @@
     }
 
     class BitSet {
-        constructor() {
-            this.array = new DynamicTypedArray(Uint8Array);
+        constructor(bitsPerElement = 8) {
+            this.bitsPerElement = bitsPerElement;
+            this.array = [];
+            this.length = 0;
+        }
+        get [Symbol.toStringTag]() {
+            return this.constructor.name;
+        }
+        get size() {
+            return this.length;
+        }
+        [Symbol.iterator]() {
+            return this.values();
+        }
+        *values() {
+            if (this.length > 0) {
+                const maxArrayLength = Math.ceil(this.length / this.bitsPerElement);
+                const remainder = this.bitsPerElement
+                    - (maxArrayLength * this.bitsPerElement - this.length);
+                const lastIndex = maxArrayLength - 1;
+                for (let index = 0; index < lastIndex; index++) {
+                    const element = this.array[index];
+                    for (let bit = 0; bit < this.bitsPerElement; bit++) {
+                        const mask = this.getMask(bit);
+                        if ((element & mask) === mask) {
+                            yield index * this.bitsPerElement + bit;
+                        }
+                    }
+                }
+                const lastElement = this.array[maxArrayLength - 1];
+                for (let bit = 0; bit < remainder; bit++) {
+                    const mask = this.getMask(bit);
+                    if ((lastElement & mask) === mask) {
+                        yield lastIndex * this.bitsPerElement + bit;
+                    }
+                }
+            }
+        }
+        _dumpBinaryStrings() {
+            const result = [];
+            for (let i = 0; i < this.array.length; i++) {
+                const binary = this.array[i].toString(2);
+                if (binary.length < this.bitsPerElement) {
+                    result.push('0'.repeat(this.bitsPerElement - binary.length) + binary);
+                }
+                else {
+                    result.push(binary);
+                }
+            }
+            return result;
+        }
+        has(value) {
+            var _a;
+            const [index, mask] = this.getPosition(value);
+            return (((_a = this.array[index]) !== null && _a !== void 0 ? _a : 0) & mask) === mask;
+        }
+        add(value) {
+            var _a;
+            es2018$p.assert(value >= 0, 'value must be greater than or equal to 0');
+            if (value >= this.length) {
+                this.length = value + 1;
+            }
+            const [index, mask] = this.getPosition(value);
+            this.array[index] = ((_a = this.array[index]) !== null && _a !== void 0 ? _a : 0) | mask;
+        }
+        delete(value) {
+            var _a;
+            const [index, mask] = this.getPosition(value);
+            const element = ((_a = this.array[index]) !== null && _a !== void 0 ? _a : 0);
+            this.array[index] = element & ~mask;
+            return (element & mask) === mask;
+        }
+        clear() {
+            for (let i = this.array.length; i--;) {
+                this.array[i] = 0;
+            }
+        }
+        getPosition(value) {
+            const remainder = value % this.bitsPerElement;
+            const quotient = (value - remainder) / this.bitsPerElement;
+            const index = quotient;
+            const mask = this.getMask(remainder);
+            return [index, mask];
+        }
+        // 输入一定是一个小于bitsPerElement的值, 取值范围是[0, bitsPerElement)
+        getMask(value) {
+            return Math.pow(2, value);
+        }
+    }
+
+    class TypedBitSet {
+        constructor(array) {
+            this.array = array;
+            this.bitsPerElement = this.array.internalTypedArray.BYTES_PER_ELEMENT * 8;
             this.length = 0;
         }
         get [Symbol.toStringTag]() {
@@ -17001,15 +17099,16 @@
         }
         *values() {
             if (this.length > 0) {
-                const maxArrayLength = Math.ceil(this.length / BitSet.bitsPerElement);
-                const remainder = BitSet.bitsPerElement - (maxArrayLength * BitSet.bitsPerElement - this.length);
+                const maxArrayLength = Math.ceil(this.length / this.bitsPerElement);
+                const remainder = this.bitsPerElement
+                    - (maxArrayLength * this.bitsPerElement - this.length);
                 const lastIndex = maxArrayLength - 1;
                 for (let index = 0; index < lastIndex; index++) {
                     const element = this.array.internalTypedArray[index];
-                    for (let bit = 0; bit < BitSet.bitsPerElement; bit++) {
+                    for (let bit = 0; bit < this.bitsPerElement; bit++) {
                         const mask = this.getMask(bit);
                         if ((element & mask) === mask) {
-                            yield index * BitSet.bitsPerElement + bit;
+                            yield index * this.bitsPerElement + bit;
                         }
                     }
                 }
@@ -17017,7 +17116,7 @@
                 for (let bit = 0; bit < remainder; bit++) {
                     const mask = this.getMask(bit);
                     if ((lastElement & mask) === mask) {
-                        yield lastIndex * BitSet.bitsPerElement + bit;
+                        yield lastIndex * this.bitsPerElement + bit;
                     }
                 }
             }
@@ -17026,8 +17125,8 @@
             const result = [];
             for (let i = 0; i < this.array.length; i++) {
                 const binary = this.array.internalTypedArray[i].toString(2);
-                if (binary.length < BitSet.bitsPerElement) {
-                    result.push('0'.repeat(BitSet.bitsPerElement - binary.length) + binary);
+                if (binary.length < this.bitsPerElement) {
+                    result.push('0'.repeat(this.bitsPerElement - binary.length) + binary);
                 }
                 else {
                     result.push(binary);
@@ -17062,8 +17161,8 @@
             }
         }
         getPosition(value) {
-            const remainder = value % BitSet.bitsPerElement;
-            const quotient = (value - remainder) / BitSet.bitsPerElement;
+            const remainder = value % this.bitsPerElement;
+            const quotient = (value - remainder) / this.bitsPerElement;
             const index = quotient;
             const mask = this.getMask(remainder);
             return [index, mask];
@@ -17073,7 +17172,6 @@
             return Math.pow(2, value);
         }
     }
-    BitSet.bitsPerElement = Uint8Array.BYTES_PER_ELEMENT * 8;
 
     exports.BadEventError = BadEventError;
     exports.BitSet = BitSet;
@@ -17092,6 +17190,7 @@
     exports.SparseSet = SparseSet;
     exports.TLRUMap = TLRUMap;
     exports.TrieMap = TrieMap;
+    exports.TypedBitSet = TypedBitSet;
     exports.TypedSparseMap = TypedSparseMap;
     exports.TypedSparseSet = TypedSparseSet;
     exports.convertArrayToCons = convertArrayToCons;