@woosh/meep-engine 2.106.1 → 2.107.0

package/src/core/binary/BitSet.js

@@ -59,570 +59,569 @@ const SHRINK_FACTOR = 0.5;
  */
 const RESIZE_COUNT_THRESHOLD = 128;
 
-/**
- * Dynamically sized bit field
- * @constructor
- */
-function BitSet() {
+export class BitSet {
     /**
-     * Number of bits currently in use
-     * @private
-     * @type {number}
+     * Dynamically sized bit field
+     * @constructor
      */
-    this.__length = 0;
+    constructor() {
+        /**
+         * Number of bits currently in use
+         * @private
+         * @type {number}
+         */
+        this.__length = 0;
+
+        /**
+         * Current capacity in bits, this is at least equal to length
+         * @private
+         * @type {number}
+         */
+        this.__capacity = 64;
+
+        /**
+         * Uint32-backed storage
+         * @type {Uint32Array}
+         * @private
+         */
+        this.__data_uint32 = new Uint32Array(this.__capacity >> 5);
+
+        /**
+         * @type {number}
+         */
+        this.__shrinkFactor = SHRINK_FACTOR;
+    }
 
-    /**
-     * Current capacity in bits, this is at least equal to length
-     * @private
-     * @type {number}
-     */
-    this.__capacity = 64;
+    preventShrink() {
+        this.__shrinkFactor = 0;
+    }
 
     /**
-     * Uint32-backed storage
-     * @type {Uint32Array}
-     * @private
+     *
+     * @param {number} x
      */
-    this.__data_uint32 = new Uint32Array(this.__capacity >> 5);
+    setShrinkFactor(x) {
+        assert.greaterThanOrEqual(x, 0, 'x >= 0');
+        assert.lessThan(x, 1, 'x < 1');
+
+        this.__shrinkFactor = x;
+    }
 
     /**
-     * @type {number}
+     *
+     * @param {number} bit_count
      */
-    this.__shrinkFactor = SHRINK_FACTOR;
-}
+    setCapacity(bit_count) {
+        assert.isNonNegativeInteger(bit_count, "bit_count");
 
-BitSet.prototype.preventShrink = function () {
-    this.__shrinkFactor = 0;
-}
-
-/**
- *
- * @param {number} x
- */
-BitSet.prototype.setShrinkFactor = function (x) {
-    assert.greaterThanOrEqual(x, 0, 'x >= 0');
-    assert.lessThan(x, 1, 'x < 1');
-
-    this.__shrinkFactor = x;
-}
+        if (this.__length > bit_count) {
+            throw  new Error(`Current length(=${this.__length}) is greater than requested size(=${bit_count})`);
+        }
 
-/**
- *
- * @param {number} bit_count
- */
-BitSet.prototype.setCapacity = function (bit_count) {
-    assert.isNonNegativeInteger(bit_count, "bit_count");
+        this.__resize(bit_count);
+    }
 
-    if (this.__length > bit_count) {
-        throw  new Error(`Current length(=${this.__length}) is greater than requested size(=${bit_count})`);
+    /**
+     * Number of bits currently used for flags.
+     * @returns {number}
+     */
+    size() {
+        return this.__length;
     }
 
-    this.__resize(bit_count);
-};
+    /**
+     * Number of bits reserved for the field, note that not all of these bits are typically being used.
+     * @returns {number}
+     */
+    capacity() {
+        return this.__capacity;
+    }
 
-/**
- * Number of bits currently used for flags.
- * @returns {number}
- */
-BitSet.prototype.size = function () {
-    return this.__length;
-};
+    /**
+     *
+     * @param {int} bitCapacity
+     * @private
+     */
+    __resize(bitCapacity) {
+        assert.isNonNegativeInteger(bitCapacity, 'bitCapacity');
 
-/**
- * Number of bits reserved for the field, note that not all of these bits are typically being used.
- * @returns {number}
- */
-BitSet.prototype.capacity = function () {
-    return this.__capacity;
-};
+        const uint32_capacity = Math.ceil(bitCapacity / 32);
 
-/**
- *
- * @param {int} bitCapacity
- * @private
- */
-BitSet.prototype.__resize = function (bitCapacity) {
-    assert.isNonNegativeInteger(bitCapacity, 'bitCapacity');
+        const oldData = this.__data_uint32;
+        const newData = new Uint32Array(uint32_capacity);
 
-    const uint32_capacity = Math.ceil(bitCapacity / 32);
+        //copy data from old container
 
-    const oldData = this.__data_uint32;
-    const newData = new Uint32Array(uint32_capacity);
+        const oldDataSize = oldData.length;
 
-    //copy data from old container
+        if (oldDataSize < uint32_capacity) {
+            newData.set(oldData);
+        } else {
+            //creating a sub-array is using heap memory, so we prefer to avoid it
+            newData.set(oldData.subarray(0, uint32_capacity));
+        }
 
-    const oldDataSize = oldData.length;
+        this.__data_uint32 = newData;
 
-    if (oldDataSize < uint32_capacity) {
-        newData.set(oldData);
-    } else {
-        //creating a sub-array is using heap memory, so we prefer to avoid it
-        newData.set(oldData.subarray(0, uint32_capacity));
+        this.__capacity = uint32_capacity * 32;
     }
 
-    this.__data_uint32 = newData;
-
-    this.__capacity = uint32_capacity * 32;
-};
+    __updateLength() {
+        const found_length = this.previousSetBit(this.__length) + 1;
 
-BitSet.prototype.__updateLength = function () {
-    const found_length = this.previousSetBit(this.__length) + 1;
-
-    if (found_length < this.__length) {
-        this.__setLength(found_length);
+        if (found_length < this.__length) {
+            this.__setLength(found_length);
+        }
     }
-}
 
-/**
- *
- * @param {int} new_length
- * @private
- */
-BitSet.prototype.__setLength = function (new_length) {
-    this.__length = new_length;
+    /**
+     *
+     * @param {int} new_length
+     * @private
+     */
+    __setLength(new_length) {
+        this.__length = new_length;
 
-    const capacity = this.__capacity;
+        const capacity = this.__capacity;
 
-    if (new_length > capacity) {
+        if (new_length > capacity) {
 
-        const growSize = Math.ceil(max3(
-            new_length,
-            capacity + RESIZE_COUNT_THRESHOLD,
-            capacity * GROW_FACTOR
-        ));
+            const growSize = Math.ceil(max3(
+                new_length,
+                capacity + RESIZE_COUNT_THRESHOLD,
+                capacity * GROW_FACTOR
+            ));
 
-        this.__resize(growSize);
+            this.__resize(growSize);
 
-    } else {
-        if (
-            new_length < capacity - RESIZE_COUNT_THRESHOLD
-            && new_length < capacity * this.__shrinkFactor
-        ) {
+        } else {
+            if (
+                new_length < capacity - RESIZE_COUNT_THRESHOLD
+                && new_length < capacity * this.__shrinkFactor
+            ) {
 
-            this.__resize(new_length);
+                this.__resize(new_length);
 
+            }
         }
     }
-};
 
-/**
- * Returns the index of the nearest bit that is set to true that occurs on or before the specified starting index
- * @param {int} fromIndex
- * @returns {int} Index of previous set bit, or -1 if no set bit found
- */
-BitSet.prototype.previousSetBit = function (fromIndex) {
-    assert.isNonNegativeInteger(fromIndex, `fromIndex`);
+    /**
+     * Returns the index of the nearest bit that is set to true that occurs on or before the specified starting index
+     * @param {int} fromIndex
+     * @returns {int} Index of previous set bit, or -1 if no set bit found
+     */
+    previousSetBit(fromIndex) {
+        assert.isNonNegativeInteger(fromIndex, `fromIndex`);
 
-    const index = min2(fromIndex, this.__length - 1);
+        const index = min2(fromIndex, this.__length - 1);
 
-    let word_index = index >> 5;
-    let bit_index = index & 31; // modulo operation is slow, bitwise and is fast, this is the same as %8
+        let word_index = index >> 5;
+        let bit_index = index & 31; // modulo operation is slow, bitwise and is fast, this is the same as %8
 
-    const data = this.__data_uint32;
+        const data = this.__data_uint32;
 
-    let word = data[word_index];
+        let word = data[word_index];
 
-    //handle first byte separately due to potential partial traversal
-    for (; bit_index >= 0; bit_index--) {
-        if ((word & (1 << bit_index)) !== 0) {
-            return word_index * 32 + bit_index;
+        //handle first byte separately due to potential partial traversal
+        for (; bit_index >= 0; bit_index--) {
+            if ((word & (1 << bit_index)) !== 0) {
+                return word_index * 32 + bit_index;
+            }
         }
-    }
 
-    //unwind first byte
-    word_index--;
+        //unwind first byte
+        word_index--;
 
-    //scan the rest
-    for (; word_index >= 0; word_index--) {
+        //scan the rest
+        for (; word_index >= 0; word_index--) {
 
-        word = data[word_index];
+            word = data[word_index];
 
-        for (bit_index = 31; bit_index >= 0; bit_index--) {
+            for (bit_index = 31; bit_index >= 0; bit_index--) {
 
-            if ((word & (1 << bit_index)) !== 0) {
-                return word_index * 32 + bit_index;
-            }
+                if ((word & (1 << bit_index)) !== 0) {
+                    return word_index * 32 + bit_index;
+                }
 
+            }
         }
-    }
 
-    return -1;
-};
-
-/**
- * Returns the index of the first bit that is set to false that occurs on or after the specified starting index.
- * @param {int} fromIndex
- * @returns {number} index of the next set bit, or -1 if no bits are set beyond supplied index
- */
-BitSet.prototype.nextSetBit = function (fromIndex) {
-    // assert.ok(fromIndex >= 0, `fromIndex must be greater or equal to 0, instead was ${fromIndex}`);
-    // assert.ok(Number.isInteger(fromIndex), `fromIndex must be an integer, instead was ${fromIndex}`);
-
-    const bit_length = this.__length;
-    if (fromIndex >= bit_length) {
-        //index is out of bounds, return -1
         return -1;
     }
 
-    const data = this.__data_uint32;
+    /**
+     * Returns the index of the first bit that is set to false that occurs on or after the specified starting index.
+     * @param {int} fromIndex
+     * @returns {number} index of the next set bit, or -1 if no bits are set beyond supplied index
+     */
+    nextSetBit(fromIndex) {
+        // assert.ok(fromIndex >= 0, `fromIndex must be greater or equal to 0, instead was ${fromIndex}`);
+        // assert.ok(Number.isInteger(fromIndex), `fromIndex must be an integer, instead was ${fromIndex}`);
+
+        const bit_length = this.__length;
+        if (fromIndex >= bit_length) {
+            //index is out of bounds, return -1
+            return -1;
+        }
+
+        const data = this.__data_uint32;
 
-    let word_index = fromIndex >> 5;
-    let word;
-    let bit_address;
+        let word_index = fromIndex >> 5;
+        let word;
+        let bit_address;
 
-    let bit_index = fromIndex & 31;
+        let bit_index = fromIndex & 31;
 
-    if (bit_index !== 0) {
-        // bit offset boundary in inside the word, we need to mask part of the word
+        if (bit_index !== 0) {
+            // bit offset boundary in inside the word, we need to mask part of the word
 
-        const fill_mask = ~((1 << bit_index) - 1);
+            const fill_mask = ~((1 << bit_index) - 1);
 
-        const masked_word = data[word_index] & fill_mask;
+            const masked_word = data[word_index] & fill_mask;
 
-        if (masked_word !== 0) {
-            bit_index = lsb_32(masked_word);
-            return (word_index << 5) + bit_index;
+            if (masked_word !== 0) {
+                bit_index = lsb_32(masked_word);
+                return (word_index << 5) + bit_index;
+            }
+
+            word_index++;
         }
 
-        word_index++;
-    }
 
+        //scan the rest of the words
+        const word_count = (bit_length + 31) >> 5; // Math.ceil(x /32)
+        for (; word_index < word_count; word_index++) {
+            word = data[word_index];
 
-    //scan the rest of the words
-    const word_count = (bit_length + 31) >> 5; // Math.ceil(x /32)
-    for (; word_index < word_count; word_index++) {
-        word = data[word_index];
+            if (word === 0) {
+                // all 0s
+                continue;
+            }
 
-        if (word === 0) {
-            // all 0s
-            continue;
-        }
+            bit_index = lsb_32(word);
+
+            bit_address = (word_index << 5) + bit_index;
 
-        bit_index = lsb_32(word);
+            return bit_address;
+        }
 
-        bit_address = (word_index << 5) + bit_index;
 
-        return bit_address;
+        return -1;
     }
 
+    /**
+     * Returns the index of the first bit that is set to false that occurs on or after the specified starting index.
+     * @param {int} fromIndex
+     * @returns {number}
+     */
+    nextClearBit(fromIndex) {
+        //assert.ok(fromIndex >= 0, `fromIndex must be greater or equal to 0, instead was ${fromIndex}`);
+        //assert.ok(Number.isInteger(fromIndex), `fromIndex must be an integer, instead was ${fromIndex}`);
 
-    return -1;
-};
-
-/**
- * Returns the index of the first bit that is set to false that occurs on or after the specified starting index.
- * @param {int} fromIndex
- * @returns {number}
- */
-BitSet.prototype.nextClearBit = function (fromIndex) {
-    //assert.ok(fromIndex >= 0, `fromIndex must be greater or equal to 0, instead was ${fromIndex}`);
-    //assert.ok(Number.isInteger(fromIndex), `fromIndex must be an integer, instead was ${fromIndex}`);
+        let word_index = fromIndex >> 5;
 
-    let word_index = fromIndex >> 5;
+        let word;
 
-    let word;
+        // treat first word specially, as we may need to mask out portion of a word to skip certain number of bits
+        let bit_index = fromIndex & 31;
 
-    // treat first word specially, as we may need to mask out portion of a word to skip certain number of bits
-    let bit_index = fromIndex & 31;
+        const data = this.__data_uint32;
 
-    const data = this.__data_uint32;
+        if (bit_index !== 0) {
+            // bit offset boundary in inside the word, we need to mask part of the word
 
-    if (bit_index !== 0) {
-        // bit offset boundary in inside the word, we need to mask part of the word
+            word = data[word_index];
 
-        word = data[word_index];
+            const fill_mask = (1 << bit_index) - 1;
 
-        const fill_mask = (1 << bit_index) - 1;
+            // apply mask and convert to uint32 via shift
+            const masked_word = (word | fill_mask) >>> 0;
 
-        // apply mask and convert to uint32 via shift
-        const masked_word = (word | fill_mask) >>> 0;
+            if (masked_word !== 4294967295) {
+                bit_index = lsb_32(~masked_word);
+                return bit_index + word_index * 32;
+            }
 
-        if (masked_word !== 4294967295) {
-            bit_index = lsb_32(~masked_word);
-            return bit_index + word_index * 32;
+            word_index++;
         }
+        const set_length = this.__length;
+        const word_count = (set_length + 31) >> 5; // Math.ceil(x /32)
 
-        word_index++;
-    }
-    const set_length = this.__length;
-    const word_count = (set_length + 31) >> 5; // Math.ceil(x /32)
+        //scan the rest
+        for (; word_index < word_count; word_index++) {
+            word = data[word_index];
 
-    //scan the rest
-    for (; word_index < word_count; word_index++) {
-        word = data[word_index];
+            if (word === 4294967295) {
+                // no 0s
+                continue;
+            }
 
-        if (word === 4294967295) {
-            // no 0s
-            continue;
-        }
+            bit_index = lsb_32(~word);
+            return bit_index + word_index * 32;
 
-        bit_index = lsb_32(~word);
-        return bit_index + word_index * 32;
+        }
 
+        return set_length;
     }
 
-    return set_length;
-};
+    /**
+     *
+     * @param {int} bitIndex
+     * @param {boolean} value
+     */
+    set(bitIndex, value) {
+        //assert.ok(typeof bitIndex, 'number', `bitIndex must be a number, instead was '${typeof bitIndex}'`);
+        //assert.ok(typeof value, 'boolean', `value must be a boolean, instead was '${typeof bitIndex}'`);
 
-/**
- *
- * @param {int} bitIndex
- * @param {boolean} value
- */
-BitSet.prototype.set = function (bitIndex, value) {
-    //assert.ok(typeof bitIndex, 'number', `bitIndex must be a number, instead was '${typeof bitIndex}'`);
-    //assert.ok(typeof value, 'boolean', `value must be a boolean, instead was '${typeof bitIndex}'`);
+        const word_offset = bitIndex >> 5;
+        const bit_offset = bitIndex & 31;
 
-    const word_offset = bitIndex >> 5;
-    const bit_offset = bitIndex & 31;
+        //const oldLength = this.__length;
 
-    //const oldLength = this.__length;
+        const word_mask = 1 << bit_offset;
 
-    const word_mask = 1 << bit_offset;
+        if (value) {
+            const bitIndexInc = bitIndex + 1;
 
-    if (value) {
-        const bitIndexInc = bitIndex + 1;
+            if (bitIndexInc > this.__length) {
+                // ensure capacity
+                this.__setLength(bitIndexInc);
+            }
 
-        if (bitIndexInc > this.__length) {
-            // ensure capacity
-            this.__setLength(bitIndexInc);
-        }
+            //set
+            this.__data_uint32[word_offset] |= word_mask;
 
-        //set
-        this.__data_uint32[word_offset] |= word_mask;
 
+        } else if (bitIndex < this.__length) {
+            //clear
+            this.__data_uint32[word_offset] &= ~word_mask;
 
-    } else if (bitIndex < this.__length) {
-        //clear
-        this.__data_uint32[word_offset] &= ~word_mask;
+            // trim down set size potentially
+            this.__updateLength();
+        }
 
-        // trim down set size potentially
-        this.__updateLength();
+        //DEBUG validate firstClearBit value
+        //assert.ok(this.__firstClearBitIndex === -1 || this.__firstClearBitIndex === scanToFirstClearBit(this), `Invalid first clear bit index, oldLength=${oldLength}, bitIndex=${bitIndex}`);
     }
 
-    //DEBUG validate firstClearBit value
-    //assert.ok(this.__firstClearBitIndex === -1 || this.__firstClearBitIndex === scanToFirstClearBit(this), `Invalid first clear bit index, oldLength=${oldLength}, bitIndex=${bitIndex}`);
-};
+    /**
+     * Sets the bit specified by the index to false.
+     * @param {int} bitIndex
+     */
+    clear(bitIndex) {
+        this.set(bitIndex, false);
+    }
 
-/**
- * Sets the bit specified by the index to false.
- * @param {int} bitIndex
- */
-BitSet.prototype.clear = function (bitIndex) {
-    this.set(bitIndex, false);
-};
+    /**
+     * Set all bits in a given range
+     * @param {number} startIndex first bit to be set
+     * @param {number} endIndex last bit to be set
+     */
+    setRange(startIndex, endIndex) {
+        assert.greaterThanOrEqual(startIndex, 0, "invalid start index");
+        assert.greaterThanOrEqual(endIndex, 0, "invalid end index");
 
-/**
- * Set all bits in a given range
- * @param {number} startIndex first bit to be set
- * @param {number} endIndex last bit to be set
- */
-BitSet.prototype.setRange = function (startIndex, endIndex) {
-    assert.greaterThanOrEqual(startIndex, 0, "invalid start index");
-    assert.greaterThanOrEqual(endIndex, 0, "invalid end index");
 
+        for (let i = startIndex; i <= endIndex; i++) {
+            this.set(i, true);
+        }
 
-    for (let i = startIndex; i <= endIndex; i++) {
-        this.set(i, true);
     }
 
-};
-
-/**
- * Clears bit values in a given (inclusive) range
- * @param {number} startIndex first bit to be cleared
- * @param {number} endIndex clear up to here, excluding this position
- */
-BitSet.prototype.clearRange = function (startIndex, endIndex) {
-    assert.greaterThanOrEqual(startIndex, 0, "invalid start index");
-    assert.greaterThanOrEqual(endIndex, 0, "invalid end index");
+    /**
+     * Clears bit values in a given (inclusive) range
+     * @param {number} startIndex first bit to be cleared
+     * @param {number} endIndex clear up to here, excluding this position
+     */
+    clearRange(startIndex, endIndex) {
+        assert.greaterThanOrEqual(startIndex, 0, "invalid start index");
+        assert.greaterThanOrEqual(endIndex, 0, "invalid end index");
 
-    for (let i = startIndex; i < endIndex; i++) {
-        this.set(i, false);
+        for (let i = startIndex; i < endIndex; i++) {
+            this.set(i, false);
+        }
     }
-};
 
+    /**
+     *
+     * @param {BitSet} set
+     */
+    and(set) {
+        throw new Error("NIY");
+    }
 
-/**
- *
- * @param {BitSet} set
- */
-BitSet.prototype.and = function (set) {
-    throw new Error("NIY");
-};
+    /**
+     * Returns the value of the bit with the specified index.
+     * @param {int} bitIndex
+     * @returns {boolean}
+     */
+    get(bitIndex) {
+        assert.isNonNegativeInteger(bitIndex, "bitIndex");
 
-/**
- * Returns the value of the bit with the specified index.
- * @param {int} bitIndex
- * @returns {boolean}
- */
-BitSet.prototype.get = function (bitIndex) {
-    assert.isNonNegativeInteger(bitIndex, "bitIndex");
+        if (bitIndex >= this.__length) {
+            //bit is outside the recorded region
+            return false;
+        }
 
-    if (bitIndex >= this.__length) {
-        //bit is outside the recorded region
-        return false;
-    }
+        const byteOffset = bitIndex >> 5;
+        const bitOffset = bitIndex & 31;
 
-    const byteOffset = bitIndex >> 5;
-    const bitOffset = bitIndex & 31;
+        const word = this.__data_uint32[byteOffset];
 
-    const word = this.__data_uint32[byteOffset];
+        const masked_word = word & (1 << bitOffset);
 
-    const masked_word = word & (1 << bitOffset);
+        return masked_word !== 0;
+    }
 
-    return masked_word !== 0;
-};
+    /**
+     * Set a bit at the specified index and return its previous value
+     * @param {number} index
+     * @returns {boolean}
+     */
+    getAndSet(index) {
+        const v = this.get(index);
 
-/**
- * Set a bit at the specified index and return its previous value
- * @param {number} index
- * @returns {boolean}
- */
-BitSet.prototype.getAndSet = function (index) {
-    const v = this.get(index);
+        if (!v) {
+            this.set(index, true);
+        }
 
-    if (!v) {
-        this.set(index, true);
+        return v;
     }
 
-    return v;
-};
+    /**
+     * Clear a bit at the specified index and return its previous value
+     * @param {number} index
+     * @returns {boolean}
+     */
+    getAndClear(index) {
+        const v = this.get(index);
 
-/**
- * Clear a bit at the specified index and return its previous value
- * @param {number} index
- * @returns {boolean}
- */
-BitSet.prototype.getAndClear = function (index) {
-    const v = this.get(index);
+        if (v) {
+            this.set(index, false);
+        }
 
-    if (v) {
-        this.set(index, false);
+        return v;
     }
 
-    return v;
-};
-
-/**
- *
- * @param {number} distance
- * @param {number} start_index
- * @param {number} end_index
- */
-BitSet.prototype.shift_right = function (distance, start_index, end_index) {
-    assert.isNonNegativeInteger(distance, 'distance');
+    /**
+     *
+     * @param {number} distance
+     * @param {number} start_index
+     * @param {number} end_index
+     */
+    shift_right(distance, start_index, end_index) {
+        assert.isNonNegativeInteger(distance, 'distance');
 
-    for (let i = end_index; i >= start_index; i--) {
-        const v = this.get(i);
-        this.set(i + distance, v);
+        for (let i = end_index; i >= start_index; i--) {
+            const v = this.get(i);
+            this.set(i + distance, v);
+        }
     }
-}
 
-/**
- *
- * @param {number} distance
- * @param {number} start_index
- * @param {number} end_index
- */
-BitSet.prototype.shift_left = function (distance, start_index, end_index) {
-    assert.isNonNegativeInteger(distance, 'distance');
+    /**
+     *
+     * @param {number} distance
+     * @param {number} start_index
+     * @param {number} end_index
+     */
+    shift_left(distance, start_index, end_index) {
+        assert.isNonNegativeInteger(distance, 'distance');
 
-    for (let i = start_index; i <= end_index; i++) {
-        const v = this.get(i);
-        this.set(i - distance, v);
+        for (let i = start_index; i <= end_index; i++) {
+            const v = this.get(i);
+            this.set(i - distance, v);
+        }
     }
-}
 
-/**
- *
- * @param {number} distance
- * @param {number} start_index
- * @param {number} end_index
- */
-BitSet.prototype.shift = function (distance, start_index, end_index) {
-    if (distance > 0) {
-        this.shift_right(distance, start_index, end_index);
-    } else {
-        this.shift_right(-distance, start_index, end_index);
+    /**
+     *
+     * @param {number} distance
+     * @param {number} start_index
+     * @param {number} end_index
+     */
+    shift(distance, start_index, end_index) {
+        if (distance > 0) {
+            this.shift_right(distance, start_index, end_index);
+        } else {
+            this.shift_right(-distance, start_index, end_index);
+        }
     }
-};
 
-/**
- * Sets all the bits in this BitSet to false.
- */
-BitSet.prototype.reset = function () {
-    const current_length = this.__length;
+    /**
+     * Sets all the bits in this BitSet to false.
+     */
+    reset() {
+        const current_length = this.__length;
 
-    if (current_length <= 0) {
-        // no action required
-        return;
-    }
+        if (current_length <= 0) {
+            // no action required
+            return;
+        }
+
+        if (current_length <= 32) {
+            // one word, set first word to 0 manually
+            this.__data_uint32[0] = 0;
+        } else {
+            this.__data_uint32.fill(0, 0, Math.ceil(current_length / 32));
+        }
 
-    if (current_length <= 32) {
-        // one word, set first word to 0 manually
-        this.__data_uint32[0] = 0;
-    } else {
-        this.__data_uint32.fill(0, 0, Math.ceil(current_length / 32));
+        this.__length = 0;
     }
 
-    this.__length = 0;
-};
+    /**
+     * Copy contents of another bit set into this one
+     * @param {BitSet} other
+     */
+    copy(other) {
+        const length = other.__length;
 
-/**
- * Copy contents of another bit set into this one
- * @param {BitSet} other
- */
-BitSet.prototype.copy = function (other) {
-    const length = other.__length;
+        const uint32_size = length >> 5;
 
-    const uint32_size = length >> 5;
+        const old_length = this.__length;
 
-    const old_length = this.__length;
 
+        if (old_length !== length) {
 
-    if (old_length !== length) {
+            if (old_length < length) {
+                this.__resize(length);
+            } else {
+                // clear everything past the target region
+                this.__data_uint32.fill(0, uint32_size);
+            }
 
-        if (old_length < length) {
-            this.__resize(length);
-        } else {
-            // clear everything past the target region
-            this.__data_uint32.fill(0, uint32_size);
+            this.__length = length;
         }
 
-        this.__length = length;
-    }
-
 
-    for (let i = 0; i < uint32_size; i++) {
-        this.__data_uint32[i] = other.__data_uint32[i];
-    }
+        for (let i = 0; i < uint32_size; i++) {
+            this.__data_uint32[i] = other.__data_uint32[i];
+        }
 
-    const byte_aligned_bit_size = uint32_size << 5;
+        const byte_aligned_bit_size = uint32_size << 5;
 
-    const overflow_bits = length - byte_aligned_bit_size;
+        const overflow_bits = length - byte_aligned_bit_size;
 
-    for (let i = 0; i < overflow_bits; i++) {
-        const bitIndex = byte_aligned_bit_size + i;
+        for (let i = 0; i < overflow_bits; i++) {
+            const bitIndex = byte_aligned_bit_size + i;
 
-        this.set(bitIndex, other.get(bitIndex));
+            this.set(bitIndex, other.get(bitIndex));
+        }
     }
-};
 
-/**
- *
- * @param {number} x
- * @returns {BitSet}
- */
-BitSet.fixedSize = function (x) {
-    const r = new BitSet();
+    /**
+     *
+     * @param {number} x
+     * @returns {BitSet}
+     */
+    static fixedSize(x) {
+        const r = new BitSet();
 
-    r.setCapacity(x);
+        r.setCapacity(x);
 
-    //prevent resizing
-    r.__shrinkFactor = 0;
+        //prevent resizing
+        r.__shrinkFactor = 0;
 
-    return r;
+        return r;
+    }
 }
-
-export { BitSet };