@woosh/meep-engine 2.37.17 → 2.37.20

package/core/assert.js

@@ -1,5 +1,5 @@
-import { isTypedArray } from "./json/JsonUtils.js";
 import { isArrayEqualStrict } from "./collection/array/isArrayEqualStrict.js";
+import { isTypedArray } from "./collection/array/typed/isTypedArray.js";
 
 function equal(a, b, m) {
     assert(a === b, m) // eslint-disable-line eqeqeq

package/core/binary/float2uint8.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number} v
+ * @returns {number}
+ */
+export function float2uint8(v) {
+    return Math.round(v * 255);
+}

package/core/binary/uint82float.js

@@ -0,0 +1,8 @@
+/**
+ *
+ * @param {number} v
+ * @returns {number}
+ */
+export function uint82float(v) {
+    return v / 255;
+}

package/core/bvh2/bvh3/ExplicitBinaryBoundingVolumeHierarchy.js

@@ -619,20 +619,22 @@ export class ExplicitBinaryBoundingVolumeHierarchy {
         while (index !== NULL_NODE) {
             index = this.balance(index);
 
-            const child1 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_1];
-            const child2 = uint32[index * ELEMENT_WORD_COUNT + COLUMN_CHILD_2];
+            const node_address = index * ELEMENT_WORD_COUNT;
+
+            const child1 = uint32[node_address + COLUMN_CHILD_1];
+            const child2 = uint32[node_address + COLUMN_CHILD_2];
 
             assert.notEqual(child1, NULL_NODE, 'child1 is null');
             assert.notEqual(child2, NULL_NODE, 'child2 is null');
 
-            uint32[index * ELEMENT_WORD_COUNT + COLUMN_HEIGHT] = 1 + max2(
+            uint32[node_address + COLUMN_HEIGHT] = 1 + max2(
                 uint32[child1 * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
                 uint32[child2 * ELEMENT_WORD_COUNT + COLUMN_HEIGHT],
             );
 
             this.node_set_combined_aabb(index, child1, child2);
 
-            index = uint32[index * ELEMENT_WORD_COUNT + COLUMN_PARENT];
+            index = uint32[node_address + COLUMN_PARENT];
         }
     }
 

package/core/collection/array/typed/isTypedArray.js

@@ -0,0 +1,20 @@
+/**
+ *
+ * @param o
+ * @returns {boolean}
+ */
+function isTypedArray(o) {
+    return (
+        o instanceof Int8Array ||
+        o instanceof Uint8Array ||
+        o instanceof Uint8ClampedArray ||
+        o instanceof Int16Array ||
+        o instanceof Uint16Array ||
+        o instanceof Int32Array ||
+        o instanceof Uint32Array ||
+        o instanceof Float32Array ||
+        o instanceof Float64Array
+    );
+}
+
+export { isTypedArray };

package/core/collection/array/typedArrayToDataType.js

@@ -10,6 +10,7 @@ export function typedArrayToDataType(v) {
 
     switch (ctor) {
         case Uint8Array:
+        case Uint8ClampedArray:
             return DataType.Uint8;
         case Uint16Array:
             return DataType.Uint16;

package/core/collection/list/List.d.ts

@@ -5,7 +5,7 @@ export default class List<T> {
 
     on: {
         added: Signal<T>,
-        removed: Signal<T>
+        removed: Signal<T, number>
     }
 
     constructor(elements?: T[])

package/core/collection/table/RowFirstTable.js

@@ -6,6 +6,7 @@
 import { assert } from "../../assert.js";
 import Signal from "../../events/signal/Signal.js";
 import { max2 } from "../../math/max2.js";
+import { array_copy } from "../array/copyArray.js";
 
 /**
  *
@@ -414,6 +415,39 @@ RowFirstTable.prototype.setRow = function (index, record) {
     this.writeRowMethod(this.dataView, this.bytesPerRecord * index, record);
 }
 
+/**
+ * Reverse order of rows, row-0 will end up at and previously last row will become the first row etc.
+ */
+RowFirstTable.prototype.reverse_rows = function () {
+    const bpr = this.bytesPerRecord;
+    const copy_buffer = new Uint8Array(bpr);
+
+    const buffer = this.data;
+    const wrapper = new Uint8Array(buffer);
+
+    const length = this.length;
+
+    if (length <= 1) {
+        // need at least 2 rows for reversal to make any change
+        return;
+    }
+
+    const last_row_index = length - 1;
+
+
+    const traversal_limit = last_row_index >>> 1;
+    for (let i = 0; i <= traversal_limit; i++) {
+        const address = i * bpr;
+        array_copy(wrapper, address, copy_buffer, 0, bpr);
+
+        const swap_index = last_row_index - i;
+        const swap_address = swap_index * bpr;
+
+        wrapper.copyWithin(address, swap_address, swap_address + bpr)
+        wrapper.set(copy_buffer, swap_address);
+    }
+};
+
 /**
  * clear out all the data and free memory
  */

package/core/collection/table/RowFirstTable.spec.js

@@ -223,7 +223,65 @@ test('copy', () => {
     a.addRow([-11.3, 13]);
 
     const b = new RowFirstTable(spec);
-b.copy(a);
+    b.copy(a);
 
 
 });
+
+
+test('reverse_rows 3 rows (odd number)', () => {
+
+    const spec = new RowFirstTableSpec([DataType.Uint8]);
+
+    const a = new RowFirstTable(spec);
+    a.addRow([1]);
+    a.addRow([2]);
+    a.addRow([3]);
+
+    a.reverse_rows();
+
+    expect(a.readCellValue(0, 0)).toBeCloseTo(3);
+    expect(a.readCellValue(1, 0)).toBeCloseTo(2);
+    expect(a.readCellValue(2, 0)).toBeCloseTo(1);
+});
+
+test('reverse_rows 2 rows', () => {
+
+    const spec = new RowFirstTableSpec([DataType.Float64, DataType.Uint8]);
+
+    const a = new RowFirstTable(spec);
+    a.addRow([3.1, 7]);
+    a.addRow([-11.3, 13]);
+
+    a.reverse_rows();
+
+    expect(a.readCellValue(1, 0)).toBeCloseTo(3.1);
+    expect(a.readCellValue(1, 1)).toBeCloseTo(7);
+
+    expect(a.readCellValue(0, 0)).toBeCloseTo(-11.3);
+    expect(a.readCellValue(0, 1)).toBeCloseTo(13);
+});
+
+test('reverse_rows 1 row', () => {
+
+    const spec = new RowFirstTableSpec([DataType.Float64, DataType.Uint8]);
+
+    const a = new RowFirstTable(spec);
+
+    a.addRow([3.1, 7]);
+    a.reverse_rows();
+
+    expect(a.readCellValue(0, 0)).toBeCloseTo(3.1);
+    expect(a.readCellValue(0, 1)).toBeCloseTo(7);
+});
+
+test('reverse_rows empty', () => {
+
+    const spec = new RowFirstTableSpec([DataType.Float64, DataType.Uint8]);
+
+    const a = new RowFirstTable(spec);
+
+    a.reverse_rows();
+
+    expect(a.length).toBe(0);
+});

package/core/color/Color.js

@@ -9,6 +9,9 @@ import { computeHashFloat } from "../math/hash/computeHashFloat.js";
 import { rgb2hsv } from "./rgb2hsv.js";
 import { rgb2uint24 } from "./rgb2uint24.js";
 import { clamp01 } from "../math/clamp01.js";
+import { rgb2hex } from "./rgb2hex.js";
+import { linear_to_sRGB } from "./linear_to_sRGB.js";
+import { sRGB_to_linear } from "./sRGB_to_linear.js";
 
 /**
  * @class
@@ -346,6 +349,19 @@ export class Color {
         this.setRGB(r / 255, g / 255, b / 255);
     }
 
+    /**
+     * Returns color in CSS hex color format
+     * @example #FF0000
+     * @returns {string}
+     */
+    toHex() {
+        return '#' + rgb2hex(
+            Math.round(this.r),
+            Math.round(this.g),
+            Math.round(this.b)
+        );
+    }
+
     /**
      *
      * @param {Color} other
@@ -473,5 +489,71 @@ export class Color {
         r.parse(str);
 
         return r;
-    };
+    }
+
+    /**
+     *
+     * @param {Color} input
+     * @param {Color} output
+     */
+    static from_linear_to_sRGB(input, output) {
+        linear_to_sRGB(output, 0, input, 0);
+    }
+
+    /**
+     *
+     * @param {Color} input
+     * @param {Color} output
+     */
+    static from_sRGB_to_linear(input, output) {
+        sRGB_to_linear(output, 0, input, 0);
+    }
 }
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.red = Object.freeze(new Color(1, 0, 0));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.green = Object.freeze(new Color(0, 1, 0));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.blue = Object.freeze(new Color(0, 0, 1));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.yellow = Object.freeze(new Color(1, 1, 0));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.cyan = Object.freeze(new Color(0, 1, 1));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.magenta = Object.freeze(new Color(1, 0, 1));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.white = Object.freeze(new Color(1, 1, 1));
+
+/**
+ * @readonly
+ * @type {Readonly<Color>}
+ */
+Color.black = Object.freeze(new Color(0, 0, 0));

package/core/color/YCbCr_to_rgb_uint24.js

@@ -1,3 +1,5 @@
+import { rgb2uint24 } from "./rgb2uint24.js";
+
 /**
  * @see https://en.wikipedia.org/wiki/YUV
  * @param {number} Y
@@ -13,8 +15,5 @@ export function YCbCr_to_rgb_uint24(Y, Cb, Cr) {
     const g = Y - ((_Cb >> 2) + (_Cb >> 4) + (_Cb >> 5)) - ((_Cr >> 1) + (_Cr >> 3) + (_Cr >> 4) + (_Cr >> 5));
     const b = Y + _Cb + (_Cb >> 1) + (_Cb >> 2) + (_Cb >> 6);
 
-    return (b & 0xFF)
-        | (g & 0xFF) << 8
-        | (r & 0xFF) << 16
-        ;
+    return rgb2uint24(r, g, b);
 }

package/core/color/hsv2rgb.js

@@ -1,4 +1,5 @@
 import { clamp01 } from "../math/clamp01.js";
+import { float2uint8 } from "../binary/float2uint8.js";
 
 /**
  *
@@ -46,9 +47,9 @@ export function hsv2rgb(h, s, v) {
             break;
     }
     return {
-        r: Math.round(r * 255),
-        g: Math.round(g * 255),
-        b: Math.round(b * 255)
+        r: float2uint8(r),
+        g: float2uint8(g),
+        b: float2uint8(b)
     };
 }
 

package/core/color/linear_to_sRGB.js

@@ -1,13 +1,12 @@
-
-function convert(c){
-    return ( c < 0.0031308 ) ? c * 12.92 : 1.055 * ( Math.pow( c, 0.41666 ) ) - 0.055;
+function convert(c) {
+    return (c < 0.0031308) ? c * 12.92 : 1.055 * (Math.pow(c, 0.41666)) - 0.055;
 }
 
 /**
  *
- * @param {number[]} output
+ * @param {number[]|ArrayLike<number>} output
  * @param {number} output_offset
- * @param {number[]} input
+ * @param {number[]|ArrayLike<number>} input
  * @param {number} input_offset
  */
 export function linear_to_sRGB(output, output_offset, input, input_offset) {

package/core/color/rgb2hex.js

@@ -1,5 +1,5 @@
 function dec2hex(c) {
-    const hex = c.toString(16);
+    const hex = Math.round(c).toString(16);
     return hex.length === 1 ? "0" + hex : hex;
 }
 

package/core/color/rgb2uint24.js

@@ -1,3 +1,5 @@
+import { float2uint8 } from "../binary/float2uint8.js";
+
 /**
  *
  * @param {number} r
@@ -5,10 +7,10 @@
  * @param {number} b
  * @returns {number}
  */
-export function rgb2uint24(r,g,b){
-    const _r = Math.round(r * 255);
-    const _g = Math.round(g * 255);
-    const _b = Math.round(b * 255);
+export function rgb2uint24(r, g, b) {
+    const _r = float2uint8(r);
+    const _g = float2uint8(g);
+    const _b = float2uint8(b);
 
     return (_b & 0xFF)
         | (_g & 0xFF) << 8

package/core/color/rgb_to_YCbCr_uint24.js

@@ -1,18 +1,16 @@
-/**
- *
- * @see https://en.wikipedia.org/wiki/YUV
- * @param {number} r
- * @param {number} g
- * @param {number} b
- * @returns {number}
- */
+import { rgb2uint24 } from "./rgb2uint24.js";
+
 export function rgb_to_YCbCr_uint24(r, g, b) {
     const Y = 0.299 * r + 0.587 * g + 0.114 * b;
     const Cb = -0.169 * r - 0.331 * g + 0.499 * b + 128;
     const Cr = 0.499 * g - 0.418 * g - 0.0813 * b + 128;
-
-    return (Cr & 0xFF)
-        | (Cb & 0xFF) << 8
-        | (Y & 0xFF) << 16
-        ;
+    /**
+     *
+     * @see https://en.wikipedia.org/wiki/YUV
+     * @param {number} r
+     * @param {number} g
+     * @param {number} b
+     * @returns {number}
+     */
+    return rgb2uint24(Y,Cb,Cr);
 }

package/core/events/signal/Signal.d.ts

@@ -5,9 +5,9 @@ export default class Signal<A = any, B = any, C = any, D = any, E = any, F = any
     add(listener: (a: A, b: B, c: C) => any, thisArg?: any): void
     add(listener: (a: A, b: B, c: C, d: D) => any, thisArg?: any): void
     add(listener: (a: A, b: B, c: C, d: D, e: E) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E,f: F) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E,f: F, g: G) => any, thisArg?: any): void
-    add(listener: (a: A, b: B, c: C, d: D, e: E,f: F, g: G, h: H) => any, thisArg?: any): void
+    add(listener: (a: A, b: B, c: C, d: D, e: E, f: F) => any, thisArg?: any): void
+    add(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => any, thisArg?: any): void
+    add(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => any, thisArg?: any): void
 
     addOne(listener: () => any, thisArg?: any): void
     addOne(listener: (a: A) => any, thisArg?: any): void
@@ -15,9 +15,9 @@ export default class Signal<A = any, B = any, C = any, D = any, E = any, F = any
     addOne(listener: (a: A, b: B, c: C) => any, thisArg?: any): void
     addOne(listener: (a: A, b: B, c: C, d: D) => any, thisArg?: any): void
     addOne(listener: (a: A, b: B, c: C, d: D, e: E) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E,f: F) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E,f: F, g: G) => any, thisArg?: any): void
-    addOne(listener: (a: A, b: B, c: C, d: D, e: E,f: F, g: G, h: H) => any, thisArg?: any): void
+    addOne(listener: (a: A, b: B, c: C, d: D, e: E, f: F) => any, thisArg?: any): void
+    addOne(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => any, thisArg?: any): void
+    addOne(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => any, thisArg?: any): void
 
     remove(listener: () => any, thisArg?: any): void
     remove(listener: (a: A) => any, thisArg?: any): void
@@ -25,9 +25,9 @@ export default class Signal<A = any, B = any, C = any, D = any, E = any, F = any
     remove(listener: (a: A, b: B, c: C) => any, thisArg?: any): void
     remove(listener: (a: A, b: B, c: C, d: D) => any, thisArg?: any): void
     remove(listener: (a: A, b: B, c: C, d: D, e: E) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E,f: F) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E,f: F, g: G) => any, thisArg?: any): void
-    remove(listener: (a: A, b: B, c: C, d: D, e: E,f: F, g: G, h: H) => any, thisArg?: any): void
+    remove(listener: (a: A, b: B, c: C, d: D, e: E, f: F) => any, thisArg?: any): void
+    remove(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G) => any, thisArg?: any): void
+    remove(listener: (a: A, b: B, c: C, d: D, e: E, f: F, g: G, h: H) => any, thisArg?: any): void
 
     send0(): void
 
@@ -47,4 +47,6 @@ export default class Signal<A = any, B = any, C = any, D = any, E = any, F = any
      * @deprecated use strongly typed dispatch methods instead (send0, send1 etc)
      */
     dispatch(...params: any[]): void
+
+    removeAll(): void
 }

package/core/events/signal/Signal.js

@@ -240,7 +240,7 @@ export class Signal {
         // 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[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -292,7 +292,7 @@ export class Signal {
         // 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[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -343,7 +343,7 @@ export class Signal {
         // 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[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -395,7 +395,7 @@ export class Signal {
         // 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[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -448,7 +448,7 @@ export class Signal {
         // 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[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -503,7 +503,7 @@ export class Signal {
         // 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[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -560,7 +560,7 @@ export class Signal {
         // 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[i];
+            dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
         }
 
         // Dispatch phase
@@ -731,7 +731,7 @@ export function dispatchViaProxy(handlers, args) {
     let i, h;
     for (i = 0; i < length; i++) {
         //copy to proxy
-        dispatch_stack[stack_pointer + i] = handlers[i];
+        dispatch_stack[stack_pointer + i] = handlers[length - (i + 1)];
     }
 
     for (i = stack_frame_end - 1; i >= stack_pointer; i--) {

package/core/events/signal/Signal.spec.js

@@ -147,3 +147,19 @@ test("handler context is properly setup during dispatch", () => {
 
     expect(handler).toHaveBeenCalled();
 });
+
+test("handlers should be executed in the order in which they are added", () => {
+    const signal = new Signal();
+
+    const marks = [];
+
+    const write_1 = jest.fn(() => marks.push(1));
+    const write_2 = jest.fn(() => marks.push(2));
+
+    signal.add(write_1);
+    signal.add(write_2);
+
+    signal.send0();
+
+    expect(marks).toEqual([1, 2]);
+});

package/core/geom/2d/quad-tree/qt_collect_by_circle.js

@@ -0,0 +1,67 @@
+import { aabb2_sqrDistanceToPoint } from "../AABB2Math.js";
+
+/**
+ *
+ * @type {QuadTreeNode[]}
+ */
+const node_stack = [];
+
+/**
+ * @template T
+ * @param {QuadTreeDatum<T>[]} result
+ * @param {number} result_offset
+ * @param {QuadTreeNode<T>} tree
+ * @param {number} x
+ * @param {number} y
+ * @param {number} radius
+ * @returns {number}
+ */
+export function qt_collect_by_circle(
+    result, result_offset,
+    tree,
+    x, y, radius
+) {
+    let result_cursor = result_offset;
+
+    let stack_pointer = 0;
+
+    const r2 = radius * radius;
+
+    node_stack[stack_pointer] = tree;
+    stack_pointer++;
+
+    while (stack_pointer > 0) {
+
+        --stack_pointer;
+        const node = node_stack[stack_pointer];
+
+        const d2 = aabb2_sqrDistanceToPoint(node.x0, node.y0, node.x1, node.y1, x, y);
+
+        if (d2 > r2) {
+            // not a match
+            continue;
+        }
+
+        const data = node.data;
+        const data_count = data.length;
+
+        for (let i = 0; i < data_count; i++) {
+            const datum = data[i];
+
+            const d2_to_datum = aabb2_sqrDistanceToPoint(datum.x0, datum.y0, datum.x1, datum.y1, x, y);
+
+            if (d2_to_datum <= r2) {
+                result[result_cursor++] = datum;
+            }
+        }
+
+        if (node.isSplit()) {
+            node_stack[stack_pointer++] = node.topLeft;
+            node_stack[stack_pointer++] = node.bottomLeft;
+            node_stack[stack_pointer++] = node.topRight;
+            node_stack[stack_pointer++] = node.bottomRight;
+        }
+    }
+
+    return result_cursor - result_offset;
+}

package/core/geom/Quaternion.d.ts

@@ -1,5 +1,6 @@
 import Signal from "../events/signal/Signal";
 import {Matrix4, Quaternion as ThreeQuaternion} from "three";
+import Vector3 from "./Vector3";
 
 export default class Quaternion {
     public x: number
@@ -7,7 +8,7 @@ export default class Quaternion {
     public z: number
     public w: number
 
-    public get onChanged(): Signal;
+    readonly onChanged: Signal<number, number, number, number, number, number, number, number>;
 
     set(x: number, y: number, z: number, w: number): void
 
@@ -15,6 +16,10 @@ export default class Quaternion {
     copy(other: ThreeQuaternion): void
     copy(other: { x: number, y: number, z: number, w: number }): void
 
+    equals(other: { x: number, y: number, z: number, w: number }): boolean
+
+    normalize(): void
+
     __setThreeEuler(threeEuler: any): void
 
     __setFromEuler(x: number, y: number, z: number, order?: string): void
@@ -24,4 +29,19 @@ export default class Quaternion {
     setFromRotationMatrix(m: Matrix4): void
 
     decodeFromUint32(uint: number): void
+
+
+    toEulerAnglesXYZ(v3: { set(x: number, y: number, z: number): any }): void
+
+    fromEulerAnglesXYZ(x: number, y: number, z: number): void
+
+    fromAxisAngle(axis: Vector3 | { x: number, y: number, z: number }, angle: number): void
+
+    computeTwistAngle(axis: Vector3): number
+
+    multiplyQuaternions(a: Quaternion, b: Quaternion): void
+
+    toJSON(): any
+
+    fromJSON(j: any): void
 }