@woosh/meep-engine 2.110.15 → 2.111.1

package/build/meep.module.js

@@ -897,6 +897,36 @@ function m4_multiply(out, a, b) {
     out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;
 }
 
+/**
+ *
+ * @param {SignalHandler} first
+ * @param {function} handle
+ * @param {*} [thisArg]
+ */
+function signal_handler_list_find(first, handle, thisArg) {
+    let n = first;
+
+    for (; ;) {
+
+        if (n.handle === handle && n.context === thisArg) {
+            return n;
+        }
+
+        n = n.next;
+
+        if (n === null) {
+            return null;
+        }
+    }
+}
+
+const SignalFlags = {
+    /**
+     * If set - signal will not invoke handlers when dispatched
+     */
+    Silent: 1
+};
+
 /**
  *
  * @enum {number}
@@ -909,6 +939,18 @@ const SignalHandlerFlags = {
 };
 
 class SignalHandler {
+    /**
+     * Optional field. Used for forming linked lists of handlers
+     * @type {SignalHandler|null}
+     */
+    next = null;
+
+    /**
+     * @private
+     * @type {number|SignalHandlerFlags}
+     */
+    flags = 0;
+
     /**
      *
      * @param {function} handle
@@ -916,15 +958,9 @@ class SignalHandler {
      */
     constructor(handle, context) {
 
-
         this.handle = handle;
         this.context = context;
 
-        /**
-         * @private
-         * @type {number|SignalHandlerFlags}
-         */
-        this.flags = 0;
     }
 
     /**
@@ -975,137 +1011,19 @@ class SignalHandler {
  */
 SignalHandler.prototype.isSignalHandler = true;
 
-/**
- * Common dispatch stack
- * @readonly
- * @type {SignalHandler[]}
- */
-const dispatch_stack$1 = [];
-let dispatch_stack_top$1 = 0;
-
-/**
- *
- * @param {function} f
- * @param {*} context
- * @param {Array} args
- */
-function dispatchCallback(f, context, args) {
-
-    try {
-        f.apply(context, args);
-    } catch (e) {
-    }
-}
-
-/**
- *
- * @param {SignalHandler[]} handlers
- * @param {Array} [args]
- */
-function dispatchViaProxy(handlers, args) {
-    const length = handlers.length;
-
-    const stack_pointer = dispatch_stack_top$1;
-    const stack_frame_end = stack_pointer + length;
-    dispatch_stack_top$1 = stack_frame_end;
-
-    let i, h;
-    for (i = 0; i < length; i++) {
-        //copy to proxy
-        dispatch_stack$1[stack_pointer + i] = handlers[length - (i + 1)];
-    }
-
-    for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-        h = dispatch_stack$1[i];
-
-        if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-            //handler should be cut
-            const p = handlers.indexOf(h);
-            handlers.splice(p, 1);
-        }
-
-        dispatchCallback(h.handle, h.context, args);
-    }
-
-    //drop stack frame
-    dispatch_stack_top$1 = stack_pointer;
-}
-
-/**
- *
- * @param {SignalHandler[]} handlers
- * @param {function} f
- * @param {*} [thisArg]
- * @returns {number} index of the handler, or -1 if not found
- */
-function findSignalHandlerIndexByHandle(handlers, f, thisArg) {
-    const l = handlers.length;
-
-    for (let i = 0; i < l; i++) {
-        const signalHandler = handlers[i];
-
-        if (signalHandler.handle === f) {
-
-            if (thisArg !== undefined && thisArg !== signalHandler.context) {
-                //context variable doesn't match
-                continue;
-            }
-
-            return i;
-        }
-    }
-
-    return -1;
-}
-
-/**
- *
- * @param {SignalHandler[]} handlers
- * @param {function} f
- * @param {*} ctx
- * @returns {number} index of the handler, or -1 if not found
- */
-function findSignalHandlerIndexByHandleAndContext(handlers, f, ctx) {
-    const l = handlers.length;
-
-    for (let i = 0; i < l; i++) {
-        const handler = handlers[i];
-
-        if (handler.handle === f && handler.context === ctx) {
-            return i;
-        }
-
-    }
-
-    return -1;
-}
-
-const SignalFlags = {
-    /**
-     * If set - signal will not invoke handlers when dispatched
-     */
-    Silent: 1
-};
-
-/**
- * Common dispatch stack
- * @readonly
- * @type {SignalHandler[]}
- */
-const dispatch_stack = [];
-let dispatch_stack_top = 0;
-
 /**
  * Signal is a type of event bus. You can subscribe to events using {@link add} method and dispatch using sendN method where N is the number of arguments you wish to pass
- * Signal is different from a normal event bus in that 1 signal corresponds to 1 event type. For example, in HTML you have `addEventListener` which lets you subscribe to any kind of event, let's use "mousedown" as a reference. Using a Signal you would instead have a signal corresponding to "mousedown" and dispatch this signal only for this event.
+ * Signal is different from a normal event bus in that 1 signal corresponds to 1 event type. For example, in HTML you have `addEventListener` which lets you subscribe to any kind of event, let's use "mousedown" as a reference.
+ * Using a Signal you would instead have a signal corresponding to "mousedown" and dispatch this signal only for this event.
  * @example `const mouseDown = new Signal<MouseEvent>(); mouseDown.send1(myMouseEvent);`
  */
 class Signal {
     /**
+     * Map is used to speed up lookup when removing handlers in case of large number of listeners.
      * @private
-     * @type {SignalHandler[]}
+     * @type {Map<function,SignalHandler>}
      */
-    handlers = [];
+    handlers = new Map();
 
     /**
      * Internal flag bitmask
@@ -1182,9 +1100,15 @@ class Signal {
     contains(handler, thisArg) {
         const handlers = this.handlers;
 
-        const i = findSignalHandlerIndexByHandle(handlers, handler, thisArg);
+        const sh = handlers.get(handler);
 
-        return i !== -1;
+        if (sh === undefined) {
+            return false;
+        }
+
+        const existing = signal_handler_list_find(sh, handler, thisArg);
+
+        return existing !== null;
     }
 
     mute() {
@@ -1200,7 +1124,7 @@ class Signal {
      * @returns {boolean}
      */
     hasHandlers() {
-        return this.handlers.length > 0;
+        return this.handlers.size > 0;
     }
 
     /**
@@ -1214,7 +1138,7 @@ class Signal {
 
         handler.setFlag(SignalHandlerFlags.RemoveAfterExecution);
 
-        this.handlers.push(handler);
+        this.#add_handler(handler);
     }
 
     /**
@@ -1224,15 +1148,36 @@ class Signal {
      */
     add(h, context) {
 
-        // if (!ENV_PRODUCTION) {
-        //     if (this.handlers.length + 1 === 100) {
-        //         console.error(`Number of handlers has is 100 now, possible leak detected`);
-        //     }
-        // }
-
         const handler = new SignalHandler(h, context);
 
-        this.handlers.push(handler);
+        this.#add_handler(handler);
+
+    }
+
+    /**
+     *
+     * @param {SignalHandler} handler
+     */
+    #add_handler(handler) {
+
+        const f = handler.handle;
+        const first = this.handlers.get(f);
+
+        if (first === undefined) {
+            this.handlers.set(f, handler);
+        } else {
+
+            handler.next = first;
+            this.handlers.set(f,handler);
+
+            // const last = signal_handler_list_last(first);
+
+            // last.next = handler;
+
+            // assert.ok(signal_handler_list_validate(first, console.error), 'invalid configuration');
+
+        }
+
     }
 
     /**
@@ -1243,11 +1188,44 @@ class Signal {
      */
     remove(h, thisArg) {
 
-        if (thisArg === undefined) {
-            return removeHandlerByHandler(this, h);
-        } else {
-            return removeHandlerByHandlerAndContext(this, h, thisArg);
+        const first = this.handlers.get(h);
+
+        if (first === undefined) {
+            return false;
+        }
+
+        if (first.handle === h && first.context === thisArg) {
+            if (first.next === null) {
+                this.handlers.delete(h);
+            } else {
+                this.handlers.set(h, first.next);
+                // assert.ok(signal_handler_list_validate(first.next, console.error), 'invalid configuration');
+            }
+
+            return true;
+        }
+
+        let previous = first;
+        let n = first.next;
+
+        while (n !== null) {
+
+            if (n.handle === h && n.context === thisArg) {
+
+                previous.next = n.next;
+
+                // assert.ok(signal_handler_list_validate(first, console.error), 'invalid configuration');
+
+                return true;
+
+            }
+
+            previous = n;
+            n = n.next;
+
         }
+
+        return false;
     }
 
     /**
@@ -1258,8 +1236,58 @@ class Signal {
      * @deprecated
      */
     removeAll() {
-        const handlers = this.handlers;
-        handlers.splice(0, handlers.length);
+        this.handlers.clear();
+    }
+
+    /**
+     *
+     * @param {SignalHandler} handler
+     */
+    #remove_handler_internal(handler) {
+
+        const first = this.handlers.get(handler.handle);
+
+        if (first === undefined) {
+            // nothing
+            return false;
+        }
+
+        // special case for first
+        if (first === handler) {
+
+            if (first.next === null) {
+                // was the only one
+                this.handlers.delete(handler.handle);
+            } else {
+                this.handlers.set(handler.handle, first.next);
+                // assert.ok(signal_handler_list_validate(first.next, console.error), 'invalid configuration');
+            }
+
+            return true;
+        }
+
+        let previous = first;
+        let n = first.next;
+
+        while (n !== null) {
+
+            const next = n.next;
+
+            if (n === handler) {
+                previous.next = next;
+
+                // assert.ok(signal_handler_list_validate(first, console.error), 'invalid configuration');
+
+                return true;
+            }
+
+            previous = n;
+            n = next;
+
+        }
+
+        // not found
+        return false;
     }
 
     /**
@@ -1272,10 +1300,38 @@ class Signal {
             return;
         }
 
-        dispatchViaProxy(this.handlers, args);
+        const handlers = this.handlers;
+
+        for (const handle of handlers.values()) {
+
+            let _h = handle;
+
+            do {
+
+                const next = _h.next;
+
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
+
+                const _f = _h.handle;
+
+                try {
+                    _f.apply(_h.context, args);
+                } catch (e) {
+                }
+
+                _h = next;
+
+            } while (_h !== null);
+
+
+        }
 
     }
 
+
     /**
      * dispatch without a value.
      * Allows JS engine to optimize for monomorphic call sites
@@ -1288,41 +1344,33 @@ class Signal {
 
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
-        let i, h;
+            do {
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                const next = _h.next;
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            h = dispatch_stack[i];
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-            if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(h);
-                handlers.splice(p, 1);
-            }
+                const _f = _h.handle;
+
+                try {
+                    _f.call(_h.context);
+                } catch (e) {
+                }
 
-            const f = h.handle;
+                _h = next;
+
+            } while (_h !== null);
 
-            try {
-                f.call(h.context);
-            } catch (e) {
-            }
 
         }
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
     }
 
     /**
@@ -1338,42 +1386,33 @@ class Signal {
 
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
+            do {
 
-        let i, h;
+                const next = _h.next;
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            h = dispatch_stack[i];
+                const _f = _h.handle;
 
-            if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(h);
-                handlers.splice(p, 1);
-            }
+                try {
+                    _f.call(_h.context, arg);
+                } catch (e) {
+                }
 
-            const f = h.handle;
+                _h = next;
+
+            } while (_h !== null);
 
-            try {
-                f.call(h.context, arg);
-            } catch (e) {
-            }
 
         }
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
     }
 
     /**
@@ -1389,41 +1428,32 @@ class Signal {
 
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
-        let i, h;
+            do {
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                const next = _h.next;
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            h = dispatch_stack[i];
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-            if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(h);
-                handlers.splice(p, 1);
-            }
+                const _f = _h.handle;
 
-            const f = h.handle;
+                try {
+                    _f.call(_h.context, a, b);
+                } catch (e) {
+                }
 
-            try {
-                f.call(h.context, a, b);
-            } catch (e) {
-            }
+                _h = next;
+
+            } while (_h !== null);
 
-        }
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
+        }
     }
 
     /**
@@ -1438,43 +1468,35 @@ class Signal {
             return;
         }
 
+
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
-        let i, h;
+            do {
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                const next = _h.next;
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            h = dispatch_stack[i];
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-            if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(h);
-                handlers.splice(p, 1);
-            }
+                const _f = _h.handle;
 
-            const f = h.handle;
+                try {
+                    _f.call(_h.context, a, b, c);
+                } catch (e) {
+                }
 
-            try {
-                f.call(h.context, a, b, c);
-            } catch (e) {
-            }
+                _h = next;
 
-        }
+            } while (_h !== null);
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
+
+        }
     }
 
     /**
@@ -1490,43 +1512,35 @@ class Signal {
             return;
         }
 
+
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
-        let i, h;
+            do {
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                const next = _h.next;
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            h = dispatch_stack[i];
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-            if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(h);
-                handlers.splice(p, 1);
-            }
+                const _f = _h.handle;
 
-            const f = h.handle;
+                try {
+                    _f.call(_h.context, a, b, c, d);
+                } catch (e) {
+                }
 
-            try {
-                f.call(h.context, a, b, c, d);
-            } catch (e) {
-            }
+                _h = next;
 
-        }
+            } while (_h !== null);
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
+
+        }
     }
 
     /**
@@ -1544,43 +1558,35 @@ class Signal {
             return;
         }
 
+
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
-        let i, h;
+            do {
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                const next = _h.next;
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            h = dispatch_stack[i];
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-            if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(h);
-                handlers.splice(p, 1);
-            }
+                const _f = _h.handle;
 
-            const handle = h.handle;
+                try {
+                    _f.call(_h.context, a, b, c, d, e, f);
+                } catch (e) {
+                }
 
-            try {
-                handle.call(h.context, a, b, c, d, e, f);
-            } catch (e) {
-            }
+                _h = next;
 
-        }
+            } while (_h !== null);
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
+
+        }
     }
 
     /**
@@ -1602,41 +1608,32 @@ class Signal {
 
         const handlers = this.handlers;
 
-        const length = handlers.length;
+        for (const handle of handlers.values()) {
 
-        const stack_pointer = dispatch_stack_top;
-        const stack_frame_end = stack_pointer + length;
-        dispatch_stack_top = stack_frame_end;
+            let _h = handle;
 
-        let i, handler;
+            do {
 
-        // Copy handlers into a temp storage to preserve state during dispatch
-        for (i = 0; i < length; i++) {
-            //copy to proxy
-            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
-        }
+                const next = _h.next;
 
-        // Dispatch phase
-        for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
-            handler = dispatch_stack[i];
+                if (_h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+                    //handler should be cut
+                    this.#remove_handler_internal(_h);
+                }
 
-            if (handler.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
-                //handler should be cut
-                const p = handlers.indexOf(handler);
-                handlers.splice(p, 1);
-            }
+                const _f = _h.handle;
 
-            const handle = handler.handle;
+                try {
+                    _f.call(_h.context, a, b, c, d, e, f, g, h);
+                } catch (e) {
+                }
 
-            try {
-                handle.call(handler.context, a, b, c, d, e, f, g, h);
-            } catch (e) {
-            }
+                _h = next;
+
+            } while (_h !== null);
 
-        }
 
-        //drop stack frame
-        dispatch_stack_top = stack_pointer;
+        }
     }
 
     /**
@@ -1663,44 +1660,7 @@ class Signal {
  * @readonly
  * @type {boolean}
  */
-Signal.prototype.isSignal = true;
-
-/**
- *
- * @param {Signal} signal
- * @param {function} h
- * @returns {boolean}
- */
-function removeHandlerByHandler(signal, h) {
-    const handlers = signal.handlers;
-    let i = findSignalHandlerIndexByHandle(handlers, h);
-
-    if (i >= 0) {
-        handlers.splice(i, 1);
-        return true;
-    }
-
-    return false;
-}
-
-/**
- *
- * @param {Signal} signal
- * @param {function} h
- * @param {*} ctx
- * @returns {boolean}
- */
-function removeHandlerByHandlerAndContext(signal, h, ctx) {
-    const handlers = signal.handlers;
-    const i = findSignalHandlerIndexByHandleAndContext(handlers, h, ctx);
-
-    if (i >= 0) {
-        handlers.splice(i, 1);
-        return true;
-    }
-
-    return false;
-}
+Signal.prototype.isSignal = true;
 
 /**
  * Constrain a value to lie between specified min/max values
@@ -69808,7 +69768,6 @@ function frustum_from_camera(camera, result, update_projection = true) {
     result.setFromProjectionMatrix(matrix4);
 }
 
-const m4_scratch = new Matrix4();
 const v3_scratch_0 = new Vector3$1();
 const v3_scratch_1 = new Vector3$1();
 
@@ -69817,7 +69776,7 @@ const v3_scratch_1 = new Vector3$1();
  * @param {Quaternion} output
  * @param {Quaternion} input
  */
-function invertQuaternionOrientation(output, input) {
+function quaternion_invert_orientation(output, input) {
     const forward = v3_scratch_0;
     const up = v3_scratch_1;
 
@@ -69827,9 +69786,12 @@ function invertQuaternionOrientation(output, input) {
     forward.applyQuaternion(input);
     up.applyQuaternion(input);
 
-    m4_scratch.lookAt(Vector3$1.zero, forward, up);
+    // point in the opposite direction
+    forward.negate();
 
-    output.setFromRotationMatrix(m4_scratch);
+    output.lookRotation(
+        forward, up
+    );
 }
 
 //
@@ -69905,7 +69867,7 @@ class Camera {
      * @param {Quaternion} input
      */
     getReciprocalRotation(output, input) {
-        invertQuaternionOrientation(output, input);
+        quaternion_invert_orientation(output, input);
     }
 
     get clip_far() {
@@ -70184,6 +70146,8 @@ function update_camera_transform(camera) {
     threeUpdateTransform(three_camera);
 }
 
+const scratch_quat = new Quaternion$1();
+
 /**
  *
  * @param {THREE.Camera} object
@@ -70196,7 +70160,11 @@ function three_camera_set_transform_rotation(object, rotation) {
     See: https://github.com/mrdoob/three.js/blob/412b99a7f26e117ea97f40eb53d010ab81aa3279/src/core/Object3D.js#L282
      */
 
-    invertQuaternionOrientation(object.quaternion, rotation);
+    quaternion_invert_orientation(scratch_quat, rotation);
+
+    object.quaternion.set(
+        scratch_quat.x, scratch_quat.y, scratch_quat.z, scratch_quat.w
+    );
 
     object.rotation.setFromQuaternion(object.quaternion);
 
@@ -93737,6 +93705,55 @@ function promiseTask(promise, name) {
     });
 }
 
+/**
+ *
+ * @param {SignalHandler[]} handlers
+ * @param {function} f
+ * @param {*} [thisArg]
+ * @returns {number} index of the handler, or -1 if not found
+ */
+function findSignalHandlerIndexByHandle(handlers, f, thisArg) {
+    const l = handlers.length;
+
+    for (let i = 0; i < l; i++) {
+        const signalHandler = handlers[i];
+
+        if (signalHandler.handle === f) {
+
+            if (thisArg !== undefined && thisArg !== signalHandler.context) {
+                //context variable doesn't match
+                continue;
+            }
+
+            return i;
+        }
+    }
+
+    return -1;
+}
+
+/**
+ *
+ * @param {SignalHandler[]} handlers
+ * @param {function} f
+ * @param {*} ctx
+ * @returns {number} index of the handler, or -1 if not found
+ */
+function findSignalHandlerIndexByHandleAndContext(handlers, f, ctx) {
+    const l = handlers.length;
+
+    for (let i = 0; i < l; i++) {
+        const handler = handlers[i];
+
+        if (handler.handle === f && handler.context === ctx) {
+            return i;
+        }
+
+    }
+
+    return -1;
+}
+
 /**
  * Matches a supplies component mask against a larger set
  * @param {BitSet} componentOccupancy
@@ -96841,6 +96858,62 @@ class SoundEngine {
     }
 }
 
+/**
+ * Common dispatch stack
+ * @readonly
+ * @type {SignalHandler[]}
+ */
+const dispatch_stack = [];
+let dispatch_stack_top = 0;
+
+/**
+ *
+ * @param {function} f
+ * @param {*} context
+ * @param {Array} args
+ */
+function dispatchCallback(f, context, args) {
+
+    try {
+        f.apply(context, args);
+    } catch (e) {
+    }
+}
+
+/**
+ *
+ * @param {SignalHandler[]} handlers
+ * @param {Array} [args]
+ */
+function dispatchViaProxy(handlers, args) {
+    const length = handlers.length;
+
+    const stack_pointer = dispatch_stack_top;
+    const stack_frame_end = stack_pointer + length;
+    dispatch_stack_top = stack_frame_end;
+
+    let i, h;
+    for (i = 0; i < length; i++) {
+        //copy to proxy
+        dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
+    }
+
+    for (i = stack_frame_end - 1; i >= stack_pointer; i--) {
+        h = dispatch_stack[i];
+
+        if (h.getFlag(SignalHandlerFlags.RemoveAfterExecution)) {
+            //handler should be cut
+            const p = handlers.indexOf(h);
+            handlers.splice(p, 1);
+        }
+
+        dispatchCallback(h.handle, h.context, args);
+    }
+
+    //drop stack frame
+    dispatch_stack_top = stack_pointer;
+}
+
 class SimpleStateMachineDescription {
     constructor() {
         this.__states = new BitSet();