@woosh/meep-engine 2.113.4 → 2.113.7

package/build/meep.cjs

@@ -48669,6 +48669,7 @@ function SplatMaterial(
 /**
  * Adapted from https://github.com/beatgammit/base64-js
  * @author Jameson Little
+ * @author Alex Goldring
  */
 
 /**
@@ -48676,12 +48677,12 @@ function SplatMaterial(
  * @type {string[]}
  */
 const lookup = [];
+
 /**
  *
  * @type {number[]}
  */
 const revLookup = [];
-const Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array;
 
 const code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 
@@ -48701,7 +48702,7 @@ revLookup['_'.charCodeAt(0)] = 63;
  * @return {number[]}
  */
 function getLens(b64) {
-    var len = b64.length;
+    const len = b64.length;
 
     if (len % 4 > 0) {
         throw new Error('Invalid string. Length must be a multiple of 4');
@@ -48709,63 +48710,88 @@ function getLens(b64) {
 
     // Trim off extra bytes after placeholder bytes are found
     // See: https://github.com/beatgammit/base64-js/issues/42
-    var validLen = b64.indexOf('=');
+    let validLen = b64.indexOf('=');
+
     if (validLen === -1) {
         validLen = len;
     }
 
-    var placeHoldersLen = validLen === len
+    const placeHoldersLen = validLen === len
         ? 0
         : 4 - (validLen % 4);
 
     return [validLen, placeHoldersLen];
 }
 
-// base64 is 4/3 + up to two characters of the original data
-
-function _byteLength(b64, validLen, placeHoldersLen) {
+/**
+ * base64 is 4/3 + up to two characters of the original data
+ * @param {number} validLen
+ * @param {number} placeHoldersLen
+ */
+function _byteLength(validLen, placeHoldersLen) {
     return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen;
 }
 
+/**
+ *
+ * @param {string} b64
+ * @return {Uint8Array}
+ */
 function toByteArray(b64) {
-    var tmp;
-    var lens = getLens(b64);
-    var validLen = lens[0];
-    var placeHoldersLen = lens[1];
+    let tmp;
+    const lens = getLens(b64);
+    const validLen = lens[0];
+    const placeHoldersLen = lens[1];
 
-    var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+    const arr = new Uint8Array(_byteLength(validLen, placeHoldersLen));
 
-    var curByte = 0;
+    let curByte = 0;
 
     // if there are placeholders, only get up to the last complete 4 chars
-    var len = placeHoldersLen > 0
+    const len = placeHoldersLen > 0
         ? validLen - 4
         : validLen;
 
-    var i;
-    for (i = 0; i < len; i += 4) {
+    let i = 0;
+
+    for (; i < len; i += 4) {
+        const char_0 = b64.charCodeAt(i);
+        const char_1 = b64.charCodeAt(i + 1);
+        const char_2 = b64.charCodeAt(i + 2);
+        const char_3 = b64.charCodeAt(i + 3);
+
         tmp =
-            (revLookup[b64.charCodeAt(i)] << 18) |
-            (revLookup[b64.charCodeAt(i + 1)] << 12) |
-            (revLookup[b64.charCodeAt(i + 2)] << 6) |
-            revLookup[b64.charCodeAt(i + 3)];
+            (revLookup[char_0] << 18) |
+            (revLookup[char_1] << 12) |
+            (revLookup[char_2] << 6) |
+            revLookup[char_3];
+
         arr[curByte++] = (tmp >> 16) & 0xFF;
         arr[curByte++] = (tmp >> 8) & 0xFF;
         arr[curByte++] = tmp & 0xFF;
     }
 
     if (placeHoldersLen === 2) {
+        const char_0 = b64.charCodeAt(i);
+        const char_1 = b64.charCodeAt(i + 1);
+
         tmp =
-            (revLookup[b64.charCodeAt(i)] << 2) |
-            (revLookup[b64.charCodeAt(i + 1)] >> 4);
+            (revLookup[char_0] << 2) |
+            (revLookup[char_1] >> 4);
+
         arr[curByte++] = tmp & 0xFF;
     }
 
     if (placeHoldersLen === 1) {
+        const char_0 = b64.charCodeAt(i);
+        const char_1 = b64.charCodeAt(i + 1);
+        const char_2 = b64.charCodeAt(i + 2);
+
         tmp =
-            (revLookup[b64.charCodeAt(i)] << 10) |
-            (revLookup[b64.charCodeAt(i + 1)] << 4) |
-            (revLookup[b64.charCodeAt(i + 2)] >> 2);
+            (revLookup[char_0] << 10) |
+            (revLookup[char_1] << 4) |
+            (revLookup[char_2] >> 2);
+
         arr[curByte++] = (tmp >> 8) & 0xFF;
         arr[curByte++] = tmp & 0xFF;
     }
@@ -48773,6 +48799,11 @@ function toByteArray(b64) {
     return arr;
 }
 
+/**
+ *
+ * @param {number} num
+ * @return {string}
+ */
 function tripletToBase64(num) {
     return lookup[num >> 18 & 0x3F]
         + lookup[num >> 12 & 0x3F]
@@ -48803,24 +48834,29 @@ function encodeChunk(uint8, start, end) {
     return output.join('');
 }
 
+/**
+ * must be multiple of 3
+ */
+const MAX_CHUNK_LENGTH = 16383;
+
 /**
  *
  * @param {Uint8Array} uint8
  * @return {string}
  */
 function fromByteArray(uint8) {
-    let tmp;
 
     const len = uint8.length;
+
     const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+
     const parts = [];
-    const maxChunkLength = 16383; // must be multiple of 3
 
     // go through the array every three bytes, we'll deal with trailing stuff later
     const len2 = len - extraBytes;
 
-    for (let i = 0; i < len2; i += maxChunkLength) {
-        const end = (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength);
+    for (let i = 0; i < len2; i += MAX_CHUNK_LENGTH) {
+        const end = (i + MAX_CHUNK_LENGTH) > len2 ? len2 : (i + MAX_CHUNK_LENGTH);
 
         const chunk = encodeChunk(uint8, i, end);
 
@@ -48829,20 +48865,26 @@ function fromByteArray(uint8) {
 
     // pad the end with zeros, but make sure to not forget the extra bytes
     if (extraBytes === 1) {
-        tmp = uint8[len - 1];
+
+        const tmp = uint8[len - 1];
+
         parts.push(
             lookup[tmp >> 2] +
             lookup[(tmp << 4) & 0x3F] +
             '=='
         );
+
     } else if (extraBytes === 2) {
-        tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+
+        const tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+
         parts.push(
             lookup[tmp >> 10] +
             lookup[(tmp >> 4) & 0x3F] +
             lookup[(tmp << 2) & 0x3F] +
             '='
         );
+
     }
 
     return parts.join('');
@@ -50929,16 +50971,21 @@ function computeStringHash(string) {
 
     const length = string.length;
 
-    let hash = 0;
+    let hash = length;
 
     for (let i = 0; i < length; i++) {
-        const charCode = string.charCodeAt(i);
+        const code_point = string.charCodeAt(i);
 
-        hash = (31 * hash + charCode) | 0;
+        /*
+         * Avoiding potentially expensive multiplication operation by using 2 cheaper operation instead
+         * (h<<5) - h ===  h*31
+         */
+        hash = ((hash << 5) - hash) + code_point;
 
     }
 
-    return hash;
+    // force uint32
+    return hash >>> 0;
 }
 
 /**
@@ -53281,11 +53328,12 @@ function min3(a, b, c) {
 
 /**
  * Convert a decimal value to hex
- * @param {number} c generally expects b byte value, 0-255
+ * @param {number} x generally expects b byte value, 0-255
  * @returns {string} zero-padded value, for example instead of "0", will return "00" and instead of "F" will return "0F"
  */
-function dec2hex(c) {
-    const hex = Math.round(c).toString(16);
+function dec2hex(x) {
+
+    const hex = Math.round(x).toString(16);
     return hex.length === 1 ? "0" + hex : hex;
 }
 
@@ -59812,9 +59860,9 @@ function array_swap_one(array, index0, index1) {
 }
 
 /**
- *
+ * @example `const my_array = new ( UintArrayForCount(x) )(length);`
  * @param {number} max_value maximum value to be contained in the array
- * @returns {function} constructor
+ * @returns {function} TypedArray constructor
  */
 function UintArrayForCount(max_value) {
 
@@ -61310,7 +61358,7 @@ function objectsEqual(a, b) {
  * @param {T[]} array
  * @param {T} element
  * @param {function(a:T,b:T):boolean} equals
- * @returns {number}
+ * @returns {number} index of first match or -1 if no matches found
  */
 function arrayIndexByEquality(array, element, equals) {
     const n = array.length;
@@ -61388,17 +61436,19 @@ class List {
      */
     on = {
         /**
+         * @readonly
          * @type {Signal<T,number>}
          */
         added: new Signal(),
         /**
+         * @readonly
          * @type {Signal<T,number>}
          */
         removed: new Signal()
     };
 
     /**
-     *
+     * @readonly
      * @type {T[]}
      */
     data = []
@@ -61465,6 +61515,7 @@ class List {
     /**
      *
      * @param {T} el
+     * @returns {this}
      */
     add(el) {
         this.data.push(el);
@@ -61482,7 +61533,7 @@ class List {
      * Note that this operation is rather slow as it triggers a linear scan
      * If the list gets large - consider using a {@link Set} class instead
      * @param {T} el
-     * @return {boolean}
+     * @return {boolean} true if element was added, false if element already existed in the list
      */
     addUnique(el) {
         if (this.contains(el)) {
@@ -62249,7 +62300,9 @@ class List {
 
         for (let i = 0; i < length; i++) {
             const datum = this.data[i];
+
             const singleValue = datum.hash();
+
             hash = ((hash << 5) - hash) + singleValue;
             hash |= 0; // Convert to 32bit integer
         }
@@ -63180,12 +63233,24 @@ class Line {
      *
      * @param {string} text
      * @param {number} indent
-     * @constructor
      */
     constructor(text, indent) {
+
+        /**
+         *
+         * @type {string}
+         */
         this.text = text;
+        /**
+         *
+         * @type {number}
+         */
         this.indentation = indent;
     }
+
+    toString() {
+        return `Line{ indentation=${this.indentation}, text="${this.text}" }`
+    }
 }
 
 const DEFAULT_INDENT_SPACES = 4;
@@ -63202,13 +63267,13 @@ class LineBuilder {
     #lines = [];
 
     /**
-     *
+     * Current indent level
      * @type {number}
      */
     #indentation = 0;
 
     /**
-     *
+     * TODO replace with indent string, that is tab, space or any combination or something else entirely
      * @type {number}
      */
     indentSpaces = DEFAULT_INDENT_SPACES;
@@ -63227,8 +63292,10 @@ class LineBuilder {
      * @param {string} term
      */
     containsSubstring(term) {
+
         const lines = this.#lines;
         const n = lines.length;
+
         for (let i = 0; i < n; i++) {
             const line = lines[i];
 
@@ -63256,6 +63323,7 @@ class LineBuilder {
      * @returns {LineBuilder}
      */
     dedent() {
+
         this.#indentation--;
         return this;
     }
@@ -63326,14 +63394,15 @@ class LineBuilder {
     }
 
     /**
-     *
      * @param {string} text
+     * @param {string} [line_separator] defaults to new-line character
      * @returns {LineBuilder}
      */
-    static fromText(text) {
+    static fromText(text, line_separator = '\n') {
+
         const r = new LineBuilder();
 
-        const lines = text.split('\n');
+        const lines = text.split(line_separator);
 
         const n = lines.length;
 
@@ -63349,6 +63418,10 @@ class LineBuilder {
 
         return r;
     }
+
+    toString() {
+        return this.build();
+    }
 }
 
 /**
@@ -63909,6 +63982,7 @@ class OffsetScaleTransform2D {
  * @return {boolean}
  */
 function array_push_if_unique(array, element) {
+
     const i = array.indexOf(element);
 
     if (i === -1) {
@@ -69154,7 +69228,8 @@ class ResourceAccessSpecification {
      * @param {number|ResourceAccessKind} access
      * @returns {ResourceAccessSpecification<R>}
      */
-    static from(resource, access = DEFAULT_ACCESS){
+    static from(resource, access = DEFAULT_ACCESS) {
+
         const r = new ResourceAccessSpecification();
 
         r.access = access;
@@ -70806,11 +70881,12 @@ const EntityFlags = {
 
 /**
  * Align to the nearest number divisible by 32, rounding up
- * @param {number} n
+ * @param {number} x must be a non-negative integer
  * @returns {number}
  */
-function align_32(n) {
-    return ((n + 31) >>> 5) << 5
+function align_32(x) {
+
+    return ((x + 31) >>> 5) << 5
 }
 
 /**
@@ -71165,22 +71241,20 @@ class BitSet {
 
     /**
      *
-     * @param {int} bitIndex
+     * @param {int} bit_index
      * @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}'`);
+    set(bit_index, value) {
 
-        const word_offset = bitIndex >> 5;
-        const bit_offset = bitIndex & 31;
+        const word_offset = bit_index >> 5;
+        const bit_offset = bit_index & 31;
 
         //const oldLength = this.__length;
 
         const word_mask = 1 << bit_offset;
 
         if (value) {
-            const bitIndexInc = bitIndex + 1;
+            const bitIndexInc = bit_index + 1;
 
             if (bitIndexInc > this.__length) {
                 // ensure capacity
@@ -71191,7 +71265,7 @@ class BitSet {
             this.__data_uint32[word_offset] |= word_mask;
 
 
-        } else if (bitIndex < this.__length) {
+        } else if (bit_index < this.__length) {
             //clear
             this.__data_uint32[word_offset] &= ~word_mask;
 
@@ -83654,44 +83728,48 @@ class Localization {
     }
 }
 
+/**
+ * @template T
+ */
 class ModuleRegistry {
 
     /**
      *
-     * @type {Map<string, *>}
+     * @type {Map<string, T>}
      */
     #modules = new Map();
     /**
      *
-     * @type {Map<*,Array<string>>}
+     * @type {Map<T,Array<string>>}
      */
     #reverse_lookup = new Map();
 
-    constructor() {
-
-        this.proxy = new Proxy(this, {
-            /**
-             *
-             * @param target
-             * @param {string} p
-             * @param receiver
-             * @returns {Class}
-             */
-            get(target, p, receiver) {
-                const module = target.get(p);
-
-                if (module === undefined) {
-                    throw new Error(`Module '${p}' not found in the registry`);
-                }
+    /**
+     * @readonly
+     * @type {ModuleRegistry}
+     */
+    proxy = new Proxy(this, {
+        /**
+         *
+         * @param target
+         * @param {string} p
+         * @param receiver
+         * @returns {Class}
+         */
+        get(target, p, receiver) {
+            const module = target.get(p);
 
-                return module;
+            if (module === undefined) {
+                throw new Error(`Module '${p}' not found in the registry`);
             }
-        });
-    }
+
+            return module;
+        }
+    });
 
     /**
      *
-     * @param {function(name:string,module:*):void} visitor
+     * @param {function(name:string,module:T):void} visitor
      */
     traverse(visitor) {
         this.#modules.forEach((klass, name) => visitor(name, klass));
@@ -83699,9 +83777,9 @@ class ModuleRegistry {
 
 
     /**
-     * @template T
+     * @template {T} M
      * @param {String} name
-     * @returns {T}
+     * @returns {M}
      */
     get(name) {
         return this.#modules.get(name);
@@ -83717,9 +83795,9 @@ class ModuleRegistry {
     }
 
     /**
-     * @template T
+     * @template {T} M
      * @param {string} name
-     * @param {T} module
+     * @param {M} module
      * @returns {boolean}
      */
     add(name, module) {
@@ -83747,8 +83825,8 @@ class ModuleRegistry {
 
     /**
      * Find all names associated with the given module
-     * @template T
-     * @param {T} module
+     * @template {T} M
+     * @param {M} module
      * @returns {string[]}
      * @throws if module is not registered
      */
@@ -97456,6 +97534,13 @@ class SimpleLifecycle {
 }
 
 class LinearValue {
+
+    /**
+     * @readonly
+     * @type {Signal}
+     */
+    onChanged = new Signal();
+
     /**
      *
      * @param {number} [x = 0]
@@ -97463,24 +97548,24 @@ class LinearValue {
      * @param {number} [b = 1]
      * @constructor
      */
-    constructor(x, a, b) {
+    constructor(x = 0, a = 0, b = 1) {
+
         /**
          *
          * @type {number}
          */
-        this.x = x !== undefined ? x : 0;
+        this.x = x;
         /**
          *
          * @type {number}
          */
-        this.a = a !== undefined ? a : 0;
+        this.a = a;
         /**
          *
          * @type {number}
          */
-        this.b = b !== undefined ? b : 1;
+        this.b = b;
 
-        this.onChanged = new Signal();
     }
 
     /**