@woosh/meep-engine 2.105.0 → 2.106.1

package/build/meep.cjs

@@ -251,7 +251,9 @@ class InMemoryDescriptor extends BaseDescription {
 
 function equal(a, b, m) {
     if (a !== b) {
-        const message = m !== undefined ? m : `${a} !== ${b}`;
+        const details = `${a} !== ${b}`;
+
+        const message = (m !== undefined && m !== "") ? `${m}. ${details}` : details;
         throw new Error(message);
     }
 }
@@ -2106,10 +2108,23 @@ let Vector3$1 = class Vector3 {
      * @constructor
      */
     constructor(x = 0, y = 0, z = 0) {
+        /**
+         * @type {number}
+         */
         this.x = x;
+        /**
+         * @type {number}
+         */
         this.y = y;
+        /**
+         * @type {number}
+         */
         this.z = z;
 
+        /**
+         * @readonly
+         * @type {Signal<number,number,number,number,number,number>}
+         */
         this.onChanged = new Signal();
     }
 
@@ -2407,7 +2422,11 @@ let Vector3$1 = class Vector3 {
         const ax = first.x, ay = first.y, az = first.z;
         const bx = second.x, by = second.y, bz = second.z;
 
-        this._crossVectors(ax, ay, az, bx, by, bz);
+        this._crossVectors(
+            ax, ay, az,
+            bx, by, bz
+        );
+
     }
 
     /**
@@ -2619,6 +2638,7 @@ let Vector3$1 = class Vector3 {
     /**
      *
      * @param {THREE.Matrix4} matrix4
+     * @deprecated use {@link @applyMatrix4} directly instead, pass `mat.elements`
      */
     applyMatrix4_three(matrix4) {
         this.applyMatrix4(matrix4.elements);
@@ -2647,7 +2667,9 @@ let Vector3$1 = class Vector3 {
      * @param {ArrayLike<number>|number[]|Float32Array} m4
      */
     applyDirectionMatrix4(m4) {
-        const x = this.x, y = this.y, z = this.z;
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
 
         const _x = m4[0] * x + m4[4] * y + m4[8] * z;
         const _y = m4[1] * x + m4[5] * y + m4[9] * z;
@@ -2678,25 +2700,34 @@ let Vector3$1 = class Vector3 {
     }
 
     /**
-     *
+     * @deprecated use non-three.js version instead
      * @param {THREE.Matrix3} m
      * @returns {Vector3}
      */
     applyMatrix3_three(m) {
+        this.applyMatrix3(m.elements);
 
-        const x = this.x, y = this.y, z = this.z;
-        const e = m.elements;
+        return this;
+    }
 
-        const _x = e[0] * x + e[3] * y + e[6] * z;
-        const _y = e[1] * x + e[4] * y + e[7] * z;
-        const _z = e[2] * x + e[5] * y + e[8] * z;
+    /**
+     *
+     * @param {number[]|Float32Array} mat
+     */
+    applyMatrix3(mat) {
+        const x = this.x;
+        const y = this.y;
+        const z = this.z;
 
-        return this.set(_x, _y, _z);
+        const _x = mat[0] * x + mat[3] * y + mat[6] * z;
+        const _y = mat[1] * x + mat[4] * y + mat[7] * z;
+        const _z = mat[2] * x + mat[5] * y + mat[8] * z;
 
+        this.set(_x, _y, _z);
     }
 
     /**
-     *
+     * @deprecated use non-three.js version instead
      * @param {THREE.Matrix4} matrix4
      */
     threejs_setFromMatrixPosition(matrix4) {
@@ -2781,17 +2812,7 @@ let Vector3$1 = class Vector3 {
         const y1 = other.y;
         const z1 = other.z;
 
-        const d = v3_dot(x0, y0, z0, x1, y1, z1);
-
-        const mag2 = (x1 * x1 + y1 * y1 + z1 * z1);
-
-        const m = d / mag2;
-
-        const x = x1 * m;
-        const y = y1 * m;
-        const z = z1 * m;
-
-        this.set(x, y, z);
+        this._projectVectors(x0, y0, z0, x1, y1, z1);
     }
 
     /**
@@ -2828,7 +2849,10 @@ let Vector3$1 = class Vector3 {
      * @param {number} y1
      * @param {number} z1
      */
-    _projectVectors(x0, y0, z0, x1, y1, z1) {
+    _projectVectors(
+        x0, y0, z0,
+        x1, y1, z1
+    ) {
 
         const d = v3_dot(x0, y0, z0, x1, y1, z1);
 
@@ -2851,11 +2875,15 @@ let Vector3$1 = class Vector3 {
      */
     setFromSphericalCoords(radius, phi, theta) {
 
-        const sinPhiRadius = Math.sin(phi) * radius;
+        const sin_phi = Math.sin(phi);
+        const cos_phi = Math.cos(phi);
+
+        const sin_theta = Math.sin(theta);
+        const cos_theta = Math.cos(theta);
 
-        const _x = sinPhiRadius * Math.sin(theta);
-        const _y = Math.cos(phi) * radius;
-        const _z = sinPhiRadius * Math.cos(theta);
+        const _x = radius * sin_phi * sin_theta;
+        const _y = radius * cos_phi;
+        const _z = radius * sin_phi * cos_theta;
 
         this.set(_x, _y, _z);
     }
@@ -2863,11 +2891,15 @@ let Vector3$1 = class Vector3 {
     /**
      *
      * @param {function} processor
+     * @param {*} [thisArg]
      * @returns {Vector3}
      */
-    process(processor) {
-        processor(this.x, this.y, this.z);
-        this.onChanged.add(processor);
+    process(processor, thisArg) {
+
+        processor.call(thisArg, this.x, this.y, this.z);
+
+        this.onChanged.add(processor, thisArg);
+
         return this;
     }
 
@@ -2881,6 +2913,7 @@ let Vector3$1 = class Vector3 {
      */
     fromJSON(json) {
         if (typeof json === 'number') {
+            // special case where input is a number
             this.setScalar(json);
         } else {
             this.copy(json);
@@ -2894,6 +2927,7 @@ let Vector3$1 = class Vector3 {
     /**
      *
      * @param {BinaryBuffer} buffer
+     * @deprecated
      */
     toBinaryBuffer(buffer) {
         buffer.writeFloat64(this.x);
@@ -2904,6 +2938,7 @@ let Vector3$1 = class Vector3 {
     /**
      *
      * @param {BinaryBuffer} buffer
+     * @deprecated
      */
     fromBinaryBuffer(buffer) {
         const x = buffer.readFloat64();
@@ -2916,6 +2951,7 @@ let Vector3$1 = class Vector3 {
     /**
      *
      * @param {BinaryBuffer} buffer
+     * @deprecated
      */
     toBinaryBufferFloat32(buffer) {
         buffer.writeFloat32(this.x);
@@ -2926,6 +2962,7 @@ let Vector3$1 = class Vector3 {
     /**
      *
      * @param {BinaryBuffer} buffer
+     * @deprecated
      */
     fromBinaryBufferFloat32(buffer) {
         const x = buffer.readFloat32();
@@ -3045,12 +3082,6 @@ Vector3$1.prototype.fromArray = Vector3$1.prototype.readFromArray;
 Vector3$1.prototype.toArray = Vector3$1.prototype.writeToArray;
 
 
-/**
- * @readonly
- * @type {boolean}
- */
-Vector3$1.prototype.isVector3 = true;
-
 /**
  * @readonly
  * @type {Vector3}
@@ -3107,10 +3138,20 @@ Vector3$1.forward = Object.freeze(new Vector3$1(0, 0, 1));
  */
 Vector3$1.back = Object.freeze(new Vector3$1(0, 0, -1));
 
+/**
+ * @readonly
+ * @type {boolean}
+ */
+Vector3$1.prototype.isVector3 = true;
+
+/**
+ * @readonly
+ * @type {string}
+ */
 Vector3$1.typeName = "Vector3";
 
 /**
- *
+ * @deprecated use {@link v3_dot} directly instead
  * @param {number} x0
  * @param {number} y0
  * @param {number} z0
@@ -60141,6 +60182,8 @@ class HashMap {
         this.#bin_count = 2 ** this.#bin_count_power_of_two;
         this.#bin_count_mask = this.#bin_count - 1;
 
+        const old_entry_allocation_count = this.#entries_allocated_count;
+
         this.#entries_allocated_count = 2 ** this.#entries_count_power_of_two;
 
         const BinsArray = UintArrayForCount(this.#entries_allocated_count + ENTRY_BASE);
@@ -60152,7 +60195,7 @@ class HashMap {
 
         this.#entries = new_entries;
 
-        array_copy(old_entries, 0, new_entries, 0, min2(old_entries.length, this.#entries_allocated_count));
+        array_copy(old_entries, 0, new_entries, 0, min2(old_entry_allocation_count, this.#entries_allocated_count));
 
         if (this.#size > 0) {
             // re-hash
@@ -60221,12 +60264,21 @@ class HashMap {
         this.#entries_bound++;
 
         if (this.#entries[i] !== undefined) {
+
+            // entry exists, let's reuse it
+
             const entry = this.#entries[i];
+
             entry.hash = hash;
             entry.key = k;
             entry.value = v;
+
         } else {
+
+            // entry slot is empty
+
             this.#entries[i] = new HashMapEntry(k, v, hash);
+
         }
 
         return i;
@@ -60298,7 +60350,9 @@ class HashMap {
 
                 const entry_index = this.#allocate_entry(key, value, raw_hash);
 
-                this.#bins[bin_index] = entry_index + ENTRY_BASE;
+                const bin_value = entry_index + ENTRY_BASE;
+
+                this.#bins[bin_index] = bin_value;
 
                 break;
 
@@ -60373,6 +60427,7 @@ class HashMap {
      * @return {V}
      */
     getOrCompute(key, compute, compute_context) {
+
         const existing = this.get(key);
 
         if (existing !== undefined) {
@@ -60528,7 +60583,11 @@ class HashMap {
 
         let written_entries = 0;
 
-        for (let existing_entry_index = this.#entries_start; existing_entry_index < entries_bound; existing_entry_index++) {
+        for (
+            let existing_entry_index = this.#entries_start;
+            existing_entry_index < entries_bound;
+            existing_entry_index++
+        ) {
             const entry = entries[existing_entry_index];
 
             const hash = entry.hash;
@@ -60582,6 +60641,7 @@ class HashMap {
     }
 
     forEach(callback, thisArg) {
+
         const count = this.#bin_count;
         const entries = this.#entries;
         const bins = this.#bins;
@@ -61082,6 +61142,22 @@ class Cache {
         let element = this.data.get(key);
 
         if (element === undefined) {
+            //compute weight
+            const elementWeight = this.computeElementWeight(key, value);
+
+            /**
+             * It's possible that element being added is larger than cache's capacity,
+             * in which case entire cache will be evicted, but there still won't be enough space
+             * @type {number}
+             */
+            const weightTarget = this.#maxWeight - elementWeight;
+
+            if (weightTarget < 0) {
+                // Special case
+                // element does not fit into cache, attempting to insert it forcibly would result in a full flush and overflow
+                return;
+            }
+
             element = new CacheElement();
 
             element.key = key;
@@ -61099,25 +61175,8 @@ class Cache {
                 this.__last = element;
             }
 
-            //compute weight
-            const elementWeight = this.computeElementWeight(key, value);
-
             element.weight = elementWeight;
 
-
-            /**
-             * It's possible that element being added is larger than cache's capacity,
-             * in which case entire cache will be evicted, but there still won't be enough space
-             * @type {number}
-             */
-            const weightTarget = this.#maxWeight - elementWeight;
-
-            if (weightTarget < 0) {
-                // Special case
-                // element does not fit into cache, attempting to insert it forcibly would result in a full flush and overflow
-                return;
-            }
-
             //evict elements until there is enough space for the element
             this.evictUntilWeight(weightTarget);
 
@@ -61130,9 +61189,14 @@ class Cache {
             // check if value is the same
             if (value === element.value) ; else {
                 // replace value, adjust weight
-                this.#weight -= this.valueWeigher(element.value);
-                this.#weight += this.valueWeigher(value);
+                this.#weight -= element.weight;
 
+                const elementWeight = this.computeElementWeight(key, value);
+
+                this.#weight += elementWeight;
+
+                // assign new values
+                element.weight = elementWeight;
                 element.value = value;
             }
 
@@ -61432,18 +61496,27 @@ class List {
         removed: new Signal()
     };
 
+    /**
+     *
+     * @type {T[]}
+     */
+    data = []
+
     /**
      * @param {[]} [array]
      * @constructor
      */
     constructor(array) {
 
-        /**
-         * @private
-         * @readonly
-         * @type {T[]}
-         */
-        this.data = array !== undefined ? array.slice() : [];
+        if (array !== undefined) {
+
+            /**
+             * @private
+             * @readonly
+             * @type {T[]}
+             */
+            this.data = array.slice();
+        }
 
         /**
          * Number of elements in the list
@@ -61532,9 +61605,11 @@ class List {
 
         if (index > this.length) {
             this.length = index;
-        }
 
-        this.data.splice(index, 0, el);
+            this.data[index] = el;
+        } else {
+            this.data.splice(index, 0, el);
+        }
 
         this.length++;
 
@@ -61672,11 +61747,11 @@ class List {
     addAllUnique(elements) {
         const data = this.data;
 
-        const unique = elements.filter(function (e, i) {
-            return data.indexOf(e) === -1 && elements.indexOf(e, i + 1) === -1;
-        });
+        const length = data.length;
 
-        this.addAll(unique);
+        for (let i = 0; i < length; i++) {
+            this.addUnique(data[i]);
+        }
     }
 
     /**
@@ -61687,21 +61762,23 @@ class List {
      */
     removeMany(index, removeCount) {
 
-        const els = this.data.splice(index, removeCount);
+        const removed_elements = this.data.splice(index, removeCount);
 
-        const removedCount = els.length;
+        const removedCount = removed_elements.length;
 
         this.length -= removedCount;
 
-        if (this.on.removed.hasHandlers()) {
+        const onRemoved = this.on.removed;
+
+        if (onRemoved.hasHandlers()) {
             for (let i = 0; i < removedCount; i++) {
-                const element = els[i];
+                const element = removed_elements[i];
 
-                this.on.removed.send2(element, index + i);
+                onRemoved.send2(element, index + i);
             }
         }
 
-        return els;
+        return removed_elements;
     }
 
     /**
@@ -61780,8 +61857,13 @@ class List {
         }
     }
 
-    sort() {
-        Array.prototype.sort.apply(this.data, arguments);
+    /**
+     *
+     * @param {function(a:T, b:T):number} [compare_function]
+     * @returns {List}
+     */
+    sort(compare_function) {
+        Array.prototype.sort.call(this.data, compare_function);
         return this;
     }
 
@@ -61945,18 +62027,24 @@ class List {
      *
      * @param {function(el:T):boolean} matcher
      * @param {function(el:T, index:number):*} callback
+     * @returns {boolean}
      */
     visitFirstMatch(matcher, callback) {
-        const data = this.data;
-        let i = 0;
-        const l = this.length;
-        for (; i < l; i++) {
-            const el = data[i];
-            if (matcher(el)) {
-                callback(el, i);
-                return;
-            }
+        const index = this.findIndex(matcher);
+
+        if (index === -1) {
+            return false;
         }
+
+        const el = this.data[index];
+
+        if (matcher(el)) {
+            callback(el, index);
+            return true;
+        } else {
+            return false;
+        }
+
     }
 
     /**
@@ -84558,15 +84646,25 @@ class BinaryHeap {
  * @template K,V
  */
 class ObservedMap {
+    /**
+     * @readonly
+     */
+    on = {
+        /**
+         * @type {Signal}
+         */
+        set: new Signal(),
+        /**
+         * @type {Signal}
+         */
+        deleted: new Signal()
+    };
+
     /**
      * @template K,V
      * @constructor
      */
     constructor(source = new Map()) {
-        this.on = {
-            set: new Signal(),
-            deleted: new Signal()
-        };
 
         /**
          *
@@ -84636,11 +84734,42 @@ const STATUS_FULL = 0;
 const STATUS_EMPTY = 1;
 const STATUS_NORMAL = 2;
 
+const EMPTY_ARRAY = new Array(0);
+
 /**
  * Double-ended queue backed by an array
  * @template T
  */
 class Deque {
+
+    /**
+     * Using static array allocator to preserve data locality.
+     * Initialization via "[]" would give us a dynamically sized array,
+     * but it would have unpredictable locality as array may or may not have it's elements stored next to each other in memory
+     * @type {T[]}
+     * @private
+     */
+    #data=EMPTY_ARRAY;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    #head = 0;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    #tail = 0;
+
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    #status = STATUS_EMPTY;
+
     /**
      * @template T
      * @param {number} [min_size]
@@ -84649,34 +84778,8 @@ class Deque {
 
         const size = ceilPowerOfTwo(max2(1, min_size));
 
-        /**
-         * Using static array allocator to preserve data locality.
-         * Initialization via "[]" would give us a dynamically sized array,
-         * but it would have unpredictable locality as array may or may not have it's elements stored next to each other in memory
-         * @type {T[]}
-         * @private
-         */
-        this.__data = new Array(size);
-
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__head = 0;
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__tail = 0;
+        this.#data = new Array(size);
 
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.__status = STATUS_EMPTY;
     }
 
     /**
@@ -84684,14 +84787,14 @@ class Deque {
      * @param {boolean} adding
      * @private
      */
-    resetStatus(adding) {
-        const head = this.__head;
-        const tail = this.__tail;
+    #reset_status(adding) {
+        const head = this.#head;
+        const tail = this.#tail;
 
         if (head === tail) {
-            this.__status = adding ? STATUS_FULL : STATUS_EMPTY;
+            this.#status = adding ? STATUS_FULL : STATUS_EMPTY;
         } else {
-            this.__status = STATUS_NORMAL;
+            this.#status = STATUS_NORMAL;
         }
     }
 
@@ -84701,10 +84804,10 @@ class Deque {
      * @returns {number}
      * @private
      */
-    __circular_next_position(current) {
+    #circular_next_position(current) {
         const next = current + 1;
 
-        const length = this.__data.length;
+        const length = this.#data.length;
 
         return (next >= length) ? 0 : next;
     }
@@ -84715,20 +84818,20 @@ class Deque {
      * @returns {number}
      * @private
      */
-    __circular_previous_position(current) {
+    #circular_previous_position(current) {
         const prev = current - 1;
-        return (prev < 0) ? (this.__data.length - 1) : prev;
+        return (prev < 0) ? (this.#data.length - 1) : prev;
     }
 
-    __check_and_expand() {
-        const status = this.__status;
+    #check_and_expand() {
+        const status = this.#status;
 
         if (status !== STATUS_FULL) {
             // queue still has space, we're done
             return;
         }
 
-        const length = this.__data.length;
+        const length = this.#data.length;
 
         if (UINT32_MAX === length) {
             throw new Error('Maximum array size exceeded');
@@ -84747,19 +84850,19 @@ class Deque {
          */
         const new_data = new Array(new_length);
 
-        const head = this.__head;
+        const head = this.#head;
 
         // copy the front portion
-        array_copy(this.__data, head, new_data, 0, length - head);
+        array_copy(this.#data, head, new_data, 0, length - head);
         // copy the remainder
-        array_copy(this.__data, 0, new_data, length - head, head);
+        array_copy(this.#data, 0, new_data, length - head, head);
 
-        this.__head = 0;
-        this.__tail = length;
+        this.#head = 0;
+        this.#tail = length;
 
-        this.__status = STATUS_NORMAL;
+        this.#status = STATUS_NORMAL;
 
-        this.__data = new_data;
+        this.#data = new_data;
     }
 
     /**
@@ -84771,34 +84874,34 @@ class Deque {
     }
 
     clear() {
-        if (this.__status !== STATUS_EMPTY) {
-            let cursor = this.__head;
-            const tail = this.__tail;
+        if (this.#status !== STATUS_EMPTY) {
+            let cursor = this.#head;
+            const tail = this.#tail;
 
             do {
-                this.__data[cursor] = undefined;
-                cursor = this.__circular_next_position(cursor);
+                this.#data[cursor] = undefined;
+                cursor = this.#circular_next_position(cursor);
             } while (cursor !== tail);
 
-            this.__status = STATUS_EMPTY;
+            this.#status = STATUS_EMPTY;
         }
 
-        this.__head = 0;
-        this.__tail = 0;
+        this.#head = 0;
+        this.#tail = 0;
     }
 
     /**
      * @returns {number}
      */
     size() {
-        const data = this.__data;
+        const data = this.#data;
 
-        if (this.__status === STATUS_FULL) {
+        if (this.#status === STATUS_FULL) {
             return data.length;
         }
 
-        const head = this.__head;
-        const tail = this.__tail;
+        const head = this.#head;
+        const tail = this.#tail;
 
         return (head <= tail) ? (tail - head) : (tail + data.length - head);
     }
@@ -84809,43 +84912,43 @@ class Deque {
      * @param {boolean} shift_front should we shift elements before the removed element or after?
      * @private
      */
-    __remove_internal(current, shift_front) {
+    #remove_internal(current, shift_front) {
         let cursor = current;
 
         if (shift_front) {
 
             // shift towards tail
 
-            const head = this.__head;
+            const head = this.#head;
 
             while (cursor !== head) {
-                const next = this.__circular_previous_position(cursor);
-                this.__data[cursor] = this.__data[next];
+                const next = this.#circular_previous_position(cursor);
+                this.#data[cursor] = this.#data[next];
                 cursor = next;
             }
 
-            this.__head = this.__circular_next_position(head);
+            this.#head = this.#circular_next_position(head);
 
         } else {
 
             // shift towards head
 
-            const tail = this.__tail;
+            const tail = this.#tail;
 
             while (cursor !== tail) {
-                const next = this.__circular_next_position(cursor);
-                this.__data[cursor] = this.__data[next];
+                const next = this.#circular_next_position(cursor);
+                this.#data[cursor] = this.#data[next];
                 cursor = next;
             }
 
-            this.__tail = this.__circular_previous_position(tail);
+            this.#tail = this.#circular_previous_position(tail);
 
         }
 
         // fill in slot of last moved element
-        this.__data[cursor] = undefined;
+        this.#data[cursor] = undefined;
 
-        this.resetStatus(false);
+        this.#reset_status(false);
     }
 
     /**
@@ -84854,13 +84957,13 @@ class Deque {
      * @returns {boolean}
      */
     remove(e) {
-        const i = this.__index_of(e);
+        const i = this.#index_of(e);
 
         if (i === -1) {
             return false;
         }
 
-        this.__remove_internal(i, true);
+        this.#remove_internal(i, true);
 
         return true;
     }
@@ -84871,14 +84974,14 @@ class Deque {
      * @returns {number}
      * @private
      */
-    __index_of(e) {
+    #index_of(e) {
         const size = this.size();
 
-        const data = this.__data;
+        const data = this.#data;
         const capacity = data.length;
 
         for (let i = 0; i < size; i++) {
-            const index = (this.__head + i) % capacity;
+            const index = (this.#head + i) % capacity;
 
             const el = data[index];
 
@@ -84896,7 +84999,7 @@ class Deque {
      * @returns {boolean}
      */
     has(e) {
-        return this.__index_of(e) !== -1;
+        return this.#index_of(e) !== -1;
     }
 
     /**
@@ -84904,10 +85007,10 @@ class Deque {
      * @param {T} e
      */
     addFirst(e) {
-        this.__check_and_expand();
-        this.__head = this.__circular_previous_position(this.__head);
-        this.__data[this.__head] = e;
-        this.resetStatus(true);
+        this.#check_and_expand();
+        this.#head = this.#circular_previous_position(this.#head);
+        this.#data[this.#head] = e;
+        this.#reset_status(true);
     }
 
     /**
@@ -84915,10 +85018,10 @@ class Deque {
      * @returns {T|undefined}
      */
     removeFirst() {
-        const element = this.__data[this.__head];
-        this.__data[this.__head] = undefined;
-        this.__head = this.__circular_next_position(this.__head);
-        this.resetStatus(false);
+        const element = this.#data[this.#head];
+        this.#data[this.#head] = undefined;
+        this.#head = this.#circular_next_position(this.#head);
+        this.#reset_status(false);
         return element;
     }
 
@@ -84927,7 +85030,7 @@ class Deque {
      * @returns {T|undefined}
      */
     getFirst() {
-        return this.__data[this.__head];
+        return this.#data[this.#head];
     }
 
     /**
@@ -84935,10 +85038,10 @@ class Deque {
      * @param {T} e
      */
     addLast(e) {
-        this.__check_and_expand();
-        this.__data[this.__tail] = e;
-        this.__tail = this.__circular_next_position(this.__tail);
-        this.resetStatus(true);
+        this.#check_and_expand();
+        this.#data[this.#tail] = e;
+        this.#tail = this.#circular_next_position(this.#tail);
+        this.#reset_status(true);
     }
 
     /**
@@ -84946,11 +85049,11 @@ class Deque {
      * @returns {T}
      */
     removeLast() {
-        const last = this.__circular_previous_position(this.__tail);
-        const element = this.__data[last];
-        this.__data[last] = undefined;
-        this.__tail = last;
-        this.resetStatus(false);
+        const last = this.#circular_previous_position(this.#tail);
+        const element = this.#data[last];
+        this.#data[last] = undefined;
+        this.#tail = last;
+        this.#reset_status(false);
         return element;
     }
 
@@ -84960,8 +85063,8 @@ class Deque {
      * @returns {T|undefined}
      */
     getLast() {
-        const last = this.__circular_previous_position(this.__tail);
-        return this.__data[last];
+        const last = this.#circular_previous_position(this.#tail);
+        return this.#data[last];
     }
 }
 
@@ -98774,6 +98877,38 @@ class Rectangle {
         this.size = new Vector2(width, height);
     }
 
+    /**
+     *
+     * @return {number}
+     */
+    get x0() {
+        return this.position.x;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get x1() {
+        return this.position.x + this.size.x;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get y0() {
+        return this.position.y;
+    }
+
+    /**
+     *
+     * @return {number}
+     */
+    get y1() {
+        return this.position.y + this.size.y;
+    }
+
     /**
      *
      * @param {number} x
@@ -98791,7 +98926,13 @@ class Rectangle {
      * @returns {Rectangle}
      */
     clone() {
-        return new Rectangle(this.position.x, this.position.y, this.size.x, this.size.y);
+        const position = this.position;
+        const size = this.size;
+
+        return new Rectangle(
+            position.x, position.y,
+            size.x, size.y
+        );
     }
 
     /**
@@ -98852,6 +98993,11 @@ class Rectangle {
         return overlap1D(x0, x1, _x0, s.x + _x0) && overlap1D(y0, y1, _y0, _y0 + s.y);
     }
 
+    /**
+     *
+     * @param {Rectangle} other
+     * @returns {boolean}
+     */
     overlaps(other) {
         const x0 = other.position.x;
         const y0 = other.position.y;
@@ -98860,6 +99006,13 @@ class Rectangle {
         return this._overlaps(x0, y0, x1, y1);
     }
 
+    /**
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     */
     _resizeToFit(x0, y0, x1, y1) {
         const size = this.size;
 
@@ -98885,6 +99038,10 @@ class Rectangle {
         size.set(nX1 - nX0, nY1 - nY0);
     }
 
+    /**
+     *
+     * @param {Rectangle} other
+     */
     resizeToFit(other) {
         const x0 = other.position.x;
         const y0 = other.position.y;
@@ -98894,6 +99051,14 @@ class Rectangle {
         return this._resizeToFit(x0, y0, x1, y1);
     }
 
+    /**
+     *
+     * @param {number} x0
+     * @param {number} y0
+     * @param {number} x1
+     * @param {number} y1
+     * @returns {boolean}
+     */
     _contains(x0, y0, x1, y1) {
         const size = this.size;
 
@@ -98906,6 +99071,11 @@ class Rectangle {
         return x0 >= _x0 && x1 <= _x1 && y0 >= _y0 && y1 <= _y1;
     }
 
+    /**
+     *
+     * @param {Rectangle} other
+     * @returns {boolean}
+     */
     contains(other) {
         const x0 = other.position.x;
         const y0 = other.position.y;