@woosh/meep-engine 2.104.0 → 2.106.0

package/build/meep.module.js

@@ -249,7 +249,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);
     }
 }
@@ -60003,28 +60005,6 @@ const RESERVED_HASH_SUBSTITUTE = 0;
 const UNDEFINED_BIN_INDEX = ~0;
 
 
-/**
- * @template K,V
- * @param {HashMapEntry<K,V>} record
- * @param {number} hash
- * @param {K} key
- * @param {function(a:K,b:K):boolean} equality_op
- */
-function entry_equality_check(record, hash, key, equality_op) {
-    if (record.hash !== hash) {
-        return false;
-    }
-
-    if (record.key === key) {
-        return true;
-    }
-
-    const result = equality_op(record.key, key);
-
-    return result;
-}
-
-
 const EMPTY_BINS = new Uint32Array(0);
 
 /**
@@ -60092,6 +60072,10 @@ class HashMap {
      */
     #load_factor = DEFAULT_LOAD_FACTOR;
 
+    /**
+     * Used to track modifications to prevent concurrent changes during iteration
+     * @type {number}
+     */
     #version = 0;
 
     /**
@@ -60157,6 +60141,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);
@@ -60168,7 +60154,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
@@ -60204,6 +60190,25 @@ class HashMap {
         return original === RESERVED_HASH ? RESERVED_HASH_SUBSTITUTE : original;
     }
 
+    /**
+     * @param {HashMapEntry<K,V>} record
+     * @param {number} hash
+     * @param {K} key
+     */
+    #entry_equality_check(record, hash, key) {
+        if (record.hash !== hash) {
+            return false;
+        }
+
+        if (record.key === key) {
+            return true;
+        }
+
+        const result = this.keyEqualityFunction(record.key, key);
+
+        return result;
+    }
+
     /**
      *
      * @param {K} k
@@ -60219,6 +60224,7 @@ class HashMap {
 
         if (this.#entries[i] !== undefined) {
             const entry = this.#entries[i];
+
             entry.hash = hash;
             entry.key = k;
             entry.value = v;
@@ -60279,11 +60285,12 @@ class HashMap {
                 // check if it's the entry that we're looking for
                 const entry = this.#entries[bin - ENTRY_BASE];
 
-                if (entry_equality_check(entry, raw_hash, key, this.keyEqualityFunction)) {
+                if (this.#entry_equality_check(entry, raw_hash, key)) {
                     // found the right entry
                     entry.value = value;
                     return;
                 }
+
             } else if (bin === BIN_RESERVED_VALUE_EMPTY) {
                 // bin is empty
 
@@ -60294,7 +60301,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;
 
@@ -60342,7 +60351,7 @@ class HashMap {
                 // check if the entry is what we're looking for
                 const entry = this.#entries[bin - ENTRY_BASE];
 
-                if (entry_equality_check(entry, raw_hash, key, this.keyEqualityFunction)) {
+                if (this.#entry_equality_check(entry, raw_hash, key)) {
                     // found the right entry
                     return entry.value;
                 }
@@ -60442,7 +60451,7 @@ class HashMap {
                 const entry_index = bin - ENTRY_BASE;
                 const entry = entries[entry_index];
 
-                if (entry_equality_check(entry, raw_hash, key, this.keyEqualityFunction)) {
+                if (this.#entry_equality_check(entry, raw_hash, key)) {
                     // found the right entry
 
                     // record entry as dead
@@ -60524,7 +60533,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;
@@ -60776,16 +60789,27 @@ class CacheElement {
             next.previous = previous;
         }
     }
+
+    toString() {
+        return `CacheElement{ hasNext:${this.next !== null}, hasPrevious:${this.previous !== null}, weight:${this.weight}, key:${this.key}, value:${this.value} }`;
+    }
 }
 
-// TODO validate hashes of held elements to keep them up to date. Keys are assumed to be immutable, but this assumption may be broken by users
-
 /**
  * Hash-based cache, uses LRU (least-recently-used) eviction policy
+ * Make sure that keys being used are truly immutable when it comes to hash and equality calculation, otherwise cache corruption is inevitable
  * @template Key, Value
  * @extends Map<Key,Value>
  */
 class Cache {
+    #maxWeight = Number.POSITIVE_INFINITY;
+    /**
+     *
+     * @type {number}
+     * @private
+     */
+    #weight = 0;
+
     /**
      * @param {number} [maxWeight=Number.POSITIVE_INFINITY]
      * @param {function(key:Key):number} [keyWeigher= key=>0]
@@ -60809,14 +60833,8 @@ class Cache {
          * @type {number}
          * @private
          */
-        this.maxWeight = maxWeight;
+        this.#maxWeight = maxWeight;
 
-        /**
-         *
-         * @type {number}
-         * @private
-         */
-        this.weight = 0;
 
         /**
          *
@@ -60917,18 +60935,37 @@ class Cache {
         return this.data.size;
     }
 
+    /**
+     * @deprecated use {@link maxWeight} directly instead
+     */
+    setMaxWeight(value) {
+        this.maxWeight = value;
+    }
+
+    /**
+     * Total weight of all elements currently in the cache
+     * @returns {number}
+     */
+    get weight() {
+        return this.#weight;
+    }
+
     /**
      * Will cause evictions if current weight is smaller than what we're setting
      * @param {number} value
      */
-    setMaxWeight(value) {
+    set maxWeight(value) {
         if (typeof value !== "number" || value < 0) {
             throw new Error(`Weight must be a non-negative number, instead was '${value}'`);
         }
 
-        this.maxWeight = value;
+        this.#maxWeight = value;
 
-        this.evictUntilWeight(this.maxWeight);
+        this.evictUntilWeight(this.#maxWeight);
+    }
+
+    get maxWeight() {
+        return this.#maxWeight;
     }
 
     /**
@@ -60947,7 +60984,8 @@ class Cache {
             result += weight;
         }
 
-        this.weight = result;
+        this.#weight = result;
+        this.evictUntilWeight(this.#maxWeight);
     }
 
     /**
@@ -60977,13 +61015,13 @@ class Cache {
 
         const delta_weight = new_weight - old_weight;
 
-        this.weight += delta_weight;
+        this.#weight += delta_weight;
 
         if (
-            this.weight > this.maxWeight
-            && new_weight <= this.maxWeight //make it less likely to drop entire cache
+            this.#weight > this.#maxWeight
+            && new_weight <= this.#maxWeight //make it less likely to drop entire cache
         ) {
-            this.evictUntilWeight(this.maxWeight);
+            this.evictUntilWeight(this.#maxWeight);
         }
 
         return true;
@@ -61039,7 +61077,7 @@ class Cache {
 
         const target = Math.max(targetWeight, 0);
 
-        while (this.weight > target) {
+        while (this.#weight > target) {
             this.evictOne();
         }
     }
@@ -61053,6 +61091,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;
@@ -61070,25 +61124,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);
 
@@ -61096,14 +61133,19 @@ class Cache {
             this.data.set(key, element);
 
             //update weight
-            this.weight += elementWeight;
+            this.#weight += elementWeight;
         } else {
             // 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;
             }
 
@@ -61188,7 +61230,7 @@ class Cache {
         this.data.delete(key);
 
         //update weight
-        this.weight -= element.weight;
+        this.#weight -= element.weight;
     }
 
     /**
@@ -61260,7 +61302,7 @@ class Cache {
         this.__first = null;
         this.__last = null;
 
-        this.weight = 0;
+        this.#weight = 0;
     }
 
     /**
@@ -63121,12 +63163,14 @@ class LineBuilder {
      *
      * @type {Line[]}
      */
-    lines = [];
+    #lines = [];
+
     /**
      *
      * @type {number}
      */
-    indentation = 0;
+    #indentation = 0;
+
     /**
      *
      * @type {number}
@@ -63138,7 +63182,7 @@ class LineBuilder {
      * @return {number}
      */
     get count() {
-        return this.lines.length;
+        return this.#lines.length;
     }
 
     /**
@@ -63147,7 +63191,7 @@ class LineBuilder {
      * @param {string} term
      */
     containsSubstring(term) {
-        const lines = this.lines;
+        const lines = this.#lines;
         const n = lines.length;
         for (let i = 0; i < n; i++) {
             const line = lines[i];
@@ -63167,7 +63211,7 @@ class LineBuilder {
      * @returns {LineBuilder}
      */
     indent() {
-        this.indentation++;
+        this.#indentation++;
         return this;
     }
 
@@ -63176,7 +63220,7 @@ class LineBuilder {
      * @returns {LineBuilder}
      */
     dedent() {
-        this.indentation--;
+        this.#indentation--;
         return this;
     }
 
@@ -63187,9 +63231,9 @@ class LineBuilder {
      */
     add(line_text) {
 
-        const line = new Line(line_text, this.indentation);
+        const line = new Line(line_text, this.#indentation);
 
-        this.lines.push(line);
+        this.#lines.push(line);
 
         return this;
     }
@@ -63200,23 +63244,23 @@ class LineBuilder {
      */
     addLines(lines) {
 
-        const other_lines = lines.lines;
+        const other_lines = lines.#lines;
 
         const other_line_count = other_lines.length;
 
         for (let i = 0; i < other_line_count; i++) {
             const otherLine = other_lines[i];
 
-            const line = new Line(otherLine.text, otherLine.indentation + this.indentation);
+            const line = new Line(otherLine.text, otherLine.indentation + this.#indentation);
 
-            this.lines.push(line);
+            this.#lines.push(line);
         }
 
     }
 
     clear() {
-        this.lines = [];
-        this.indentation = 0;
+        this.#lines = [];
+        this.#indentation = 0;
     }
 
     /**
@@ -63228,7 +63272,7 @@ class LineBuilder {
 
         let i, j, l;
 
-        const lines = this.lines;
+        const lines = this.#lines;
 
         for (i = 0, l = lines.length; i < l; i++) {
             const line = lines[i];
@@ -63261,7 +63305,9 @@ class LineBuilder {
 
         for (let i = 0; i < n; i++) {
 
-            r.add(lines[i]);
+            const line_text = lines[i];
+
+            r.add(line_text);
 
         }
 
@@ -66275,7 +66321,7 @@ class GeometrySpatialQueryAccelerator {
      * @param {number} value in bytes
      */
     set cache_size(value) {
-        this.cache.setMaxWeight(value);
+        this.cache.maxWeight = value;
     }
 
     /**

package/editor/tools/v2/BlenderCameraOrientationGizmo.js

@@ -208,7 +208,7 @@ export class BlenderCameraOrientationGizmo extends CanvasView {
                 direction: new Vector3(0, 0, -1),
                 size: this.options.bubbleSizeSecondary,
                 style: this.options.axisStyles.nz,
-                label: "-Y",
+                label: "-Z",
                 labelHideUnselected: true,
                 primary: false
             },

package/package.json

@@ -5,7 +5,7 @@
   "description": "Fully featured ECS game engine written in JavaScript",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "2.104.0",
+  "version": "2.106.0",
   "main": "build/meep.module.js",
   "module": "build/meep.module.js",
   "exports": {

package/src/core/assert.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/core/assert.js"],"names":[],"mappings":"AA6BA,6CAIC;;IAsJD;;;;;OAKG;IACH,kEAQC;;;;;;;;;;;;;;;IAmBD;;;;;;OAMG;IACH,uGAGC;IAGD;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,4DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,sEAMC;IAED;;;;OAIG;IACH,4DAKC;IAED;;;;OAIG;IACH,+EAKC;IAGD;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,wDAIC;IAED;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,2DAIC;IAED;;;;OAIG;IACH,mEAIC;IAED;;;;;OAKG;IACH,2EAgBC;;AA/ZD,wDAEC;AAED,6CAEC;AAbD,qDAKC;AAUD;;;;;GAKG;AACH,kCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAIhB;AAQD;;;;;GAKG;AACH,gCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,uCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AA5CD;;;;;GAKG;AACH,6BAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAKD;;;;;GAKG;AACH,0CAHW,MAAM,cACN,MAAM,QAehB;AAED;;;;;GAKG;AACH,iEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,mEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,+IAFW,MAAM,QAMhB"}
+{"version":3,"file":"assert.d.ts","sourceRoot":"","sources":["../../../src/core/assert.js"],"names":[],"mappings":"AA+BA,6CAIC;;IAsJD;;;;;OAKG;IACH,kEAQC;;;;;;;;;;;;;;;IAmBD;;;;;;OAMG;IACH,uGAGC;IAGD;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,4DAMC;IAED;;;;OAIG;IACH,0DAMC;IAED;;;;OAIG;IACH,2DAMC;IAED;;;;OAIG;IACH,sEAMC;IAED;;;;OAIG;IACH,4DAKC;IAED;;;;OAIG;IACH,+EAKC;IAGD;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,wDAIC;IAED;;;;OAIG;IACH,yDAMC;IAED;;;;OAIG;IACH,2DAIC;IAED;;;;OAIG;IACH,mEAIC;IAED;;;;;OAKG;IACH,2EAgBC;;AA/ZD,wDAEC;AAED,6CAEC;AAfD,qDAOC;AAUD;;;;;GAKG;AACH,kCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAIhB;AAQD;;;;;GAKG;AACH,gCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,uCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AA5CD;;;;;GAKG;AACH,6BAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAyBD;;;;;GAKG;AACH,oCAJW,MAAM,KACN,MAAM,MACN,MAAM,QAiBhB;AAKD;;;;;GAKG;AACH,0CAHW,MAAM,cACN,MAAM,QAehB;AAED;;;;;GAKG;AACH,iEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,mEAFW,MAAM,QAIhB;AAED;;;;;GAKG;AACH,+IAFW,MAAM,QAMhB"}

package/src/core/assert.js

@@ -4,7 +4,9 @@ import { InMemoryDescriptor } from "./debug/InMemoryDescriptor.js";
 
 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);
     }
 }

package/src/core/bvh2/bvh3/build_triangle_morton_codes.d.ts

@@ -1,6 +1,6 @@
 /**
  * Compute morton codes for each triangle
- * @param {number[]|Uint32Array} morton_codes
+ * @param {number[]|Uint32Array} morton_codes output where the morton codes are to be written to, matching order in {@link index_array}
  * @param {number} tri_count
  * @param {number[]|Uint8Array|Uint16Array|Uint32Array} index_array
  * @param {number[]|Float32Array} position_array

package/src/core/bvh2/bvh3/build_triangle_morton_codes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"build_triangle_morton_codes.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/build_triangle_morton_codes.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,0DAXW,MAAM,EAAE,GAAC,WAAW,aACpB,MAAM,eACN,MAAM,EAAE,GAAC,UAAU,GAAC,WAAW,GAAC,WAAW,kBAC3C,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,QA4DhB"}
+{"version":3,"file":"build_triangle_morton_codes.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/build_triangle_morton_codes.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,0DAXW,MAAM,EAAE,GAAC,WAAW,aACpB,MAAM,eACN,MAAM,EAAE,GAAC,UAAU,GAAC,WAAW,GAAC,WAAW,kBAC3C,MAAM,EAAE,GAAC,YAAY,WACrB,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,WACN,MAAM,QA8DhB"}

package/src/core/bvh2/bvh3/build_triangle_morton_codes.js

@@ -2,7 +2,7 @@ import morton from "../../geom/3d/morton/Morton.js";
 
 /**
  * Compute morton codes for each triangle
- * @param {number[]|Uint32Array} morton_codes
+ * @param {number[]|Uint32Array} morton_codes output where the morton codes are to be written to, matching order in {@link index_array}
  * @param {number} tri_count
  * @param {number[]|Uint8Array|Uint16Array|Uint32Array} index_array
  * @param {number[]|Float32Array} position_array
@@ -37,10 +37,12 @@ export function build_triangle_morton_codes(
 
         const i3 = i * 3;
 
+        // read indices
         const a = index_array[i3];
         const b = index_array[i3 + 1];
         const c = index_array[i3 + 2];
 
+        // read vertex positions
         const a_address = a * 3;
         const ax = position_array[a_address];
         const ay = position_array[a_address + 1];

package/src/core/bvh2/bvh3/ebvh_build_hierarchy.d.ts

@@ -1,4 +1,5 @@
 /**
+ * Given a set of leaves, build intermediate node hierarchy on top, all the way up to the root
  * Assumes nodes are spatially sorted
  * NOTE: {@link unprocessed_nodes} will be modified during execution to save memory
  * @param {BVH} bvh

package/src/core/bvh2/bvh3/ebvh_build_hierarchy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ebvh_build_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,kEANW,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,aACN,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,GACJ,MAAM,CAyDlB"}
+{"version":3,"file":"ebvh_build_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../src/core/bvh2/bvh3/ebvh_build_hierarchy.js"],"names":[],"mappings":"AAGA;;;;;;;;;;GAUG;AACH,kEANW,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,aACN,MAAM,EAAE,GAAC,WAAW,oBACpB,MAAM,GACJ,MAAM,CAyDlB"}

package/src/core/bvh2/bvh3/ebvh_build_hierarchy.js

@@ -2,6 +2,7 @@ import { assert } from "../../assert.js";
 import { max2 } from "../../math/max2.js";
 
 /**
+ * Given a set of leaves, build intermediate node hierarchy on top, all the way up to the root
  * Assumes nodes are spatially sorted
  * NOTE: {@link unprocessed_nodes} will be modified during execution to save memory
  * @param {BVH} bvh
@@ -19,8 +20,8 @@ export function ebvh_build_hierarchy(
     node_pool_offset
 ) {
 
-    assert.isNonNegativeInteger(input_node_count,'input_node_count');
-    assert.isNonNegativeInteger(node_pool_offset,'node_pool_offset');
+    assert.isNonNegativeInteger(input_node_count, 'input_node_count');
+    assert.isNonNegativeInteger(node_pool_offset, 'node_pool_offset');
 
     let used_index = node_pool_offset;
 

package/src/core/cache/Cache.d.ts

@@ -21,7 +21,8 @@ export class Cache<K, V> {
     readonly onRemoved: Signal<K, V>
 
     readonly weight: number
-    readonly maxWeight: number
+
+    maxWeight: number
 
     size(): number
 

package/src/core/cache/Cache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/Cache.js"],"names":[],"mappings":"AAWA;;;;GAIG;AACH;IACI;;;;;;;;OAQG;IACH,sGARW,MAAM,EA6FhB;IAtEG;;;;OAIG;IACH,kBAA0B;IAE1B;;;;OAIG;IACH,eAAe;IAEf;;;;OAIG;IACH,mBAA4B;IAE5B;;;;OAIG;IACH,qBAAgC;IAEhC;;;;OAIG;IACH,gBAAmB;IACnB;;;;OAIG;IACH,eAAkB;IAGlB;;;;OAIG;IACH,aAIE;IAEF;;;OAGG;IACH,WAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEE;IAE7B;;;OAGG;IACH,WAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEE;IAE7B;;;OAGG;IACH,OAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEF;IAG7B;;;;;OAKG;IACH,kBAyBC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,oBAFW,MAAM,QAUhB;IAED;;;;OAIG;IACH,wBAYC;IAED;;;;;;OAMG;IACH,yBAHW,GAAG,GACD,OAAO,CAgCnB;IAED;;;;;OAKG;IACH,6BAUC;IAED;;;OAGG;IACH,sBAFa,aAAa,GAAG,EAAC,KAAK,CAAC,GAAC,IAAI,CAIxC;IAED;;;OAGG;IACH,YAFa,OAAO,CAgBnB;IAED;;;OAGG;IACH,+BAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,SAHW,GAAG,SACH,KAAK,QAoEf;IAED;;;;OAIG;IACH,cAHW,GAAG,GACD,OAAO,CAInB;IAED;;;;OAIG;IACH,SAHW,GAAG,GACD,KAAK,GAAC,IAAI,CAYtB;IAGD;;;;;;OAMG;IACH,kBALW,GAAG,kBACM,GAAG,KAAE,KAAK,0BAElB,KAAK,CAchB;IAED;;;;OAIG;IACH,wBAqBC;IAED;;;;OAIG;IACH,YAHW,GAAG,GACD,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,kBAHW,GAAG,GACD,OAAO,CAanB;IAED;;OAEG;IACH,cAcC;IAED;;;OAGG;IACH,aAOC;IAED;;;;;OAKG;IACH,wCAFa,OAAO,CAMnB;IAGL;;;OAGG;IACH,6CAAmB;IAEnB;;;OAGG;IACH,+BA5FiB,OAAO,CA4FF;IAEtB;;;OAGG;IACH,4BA9KiB,OAAO,CA8KL;CAlBlB;mBApgBkB,4BAA4B;6BAIlB,mBAAmB"}
+{"version":3,"file":"Cache.d.ts","sourceRoot":"","sources":["../../../../src/core/cache/Cache.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH;IASI;;;;;;;;OAQG;IACH,sGARW,MAAM,EAuFhB;IAxDG;;;;OAIG;IACH,mBAA4B;IAE5B;;;;OAIG;IACH,qBAAgC;IAEhC;;;;OAIG;IACH,gBAAmB;IACnB;;;;OAIG;IACH,eAAkB;IAGlB;;;;OAIG;IACH,aAIE;IAEF;;;OAGG;IACH,WAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEE;IAE7B;;;OAGG;IACH,WAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEE;IAE7B;;;OAGG;IACH,OAFU,OAAO,GAAG,EAAC,KAAK,CAAC,CAEF;IAG7B;;;;;OAKG;IACH,kBAyBC;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;OAEG;IACH,+BAEC;IAUD;;;OAGG;IACH,2BAQC;IAED,wBAEC;IAxBD;;;OAGG;IACH,qBAEC;IAoBD;;;;OAIG;IACH,wBAaC;IAED;;;;;;OAMG;IACH,yBAHW,GAAG,GACD,OAAO,CAgCnB;IAED;;;;;OAKG;IACH,6BAUC;IAED;;;OAGG;IACH,sBAFa,aAAa,GAAG,EAAC,KAAK,CAAC,GAAC,IAAI,CAIxC;IAED;;;OAGG;IACH,YAFa,OAAO,CAkBnB;IAED;;;OAGG;IACH,+BAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,SAHW,GAAG,SACH,KAAK,QAwEf;IAED;;;;OAIG;IACH,cAHW,GAAG,GACD,OAAO,CAInB;IAED;;;;OAIG;IACH,SAHW,GAAG,GACD,KAAK,GAAC,IAAI,CAYtB;IAGD;;;;;;OAMG;IACH,kBALW,GAAG,kBACM,GAAG,KAAE,KAAK,0BAElB,KAAK,CAchB;IAED;;;;OAIG;IACH,wBAqBC;IAED;;;;OAIG;IACH,YAHW,GAAG,GACD,OAAO,CAgBnB;IAED;;;;;OAKG;IACH,kBAHW,GAAG,GACD,OAAO,CAanB;IAED;;OAEG;IACH,cAcC;IAED;;;OAGG;IACH,aAOC;IAED;;;;;OAKG;IACH,wCAFa,OAAO,CAMnB;IAGL;;;OAGG;IACH,6CAAmB;IAEnB;;;OAGG;IACH,+BA5FiB,OAAO,CA4FF;IAEtB;;;OAGG;IACH,4BA9KiB,OAAO,CA8KL;;CAlBlB;mBA/hBkB,4BAA4B;6BAIlB,mBAAmB"}