@math.gl/core 3.5.6 → 3.6.0-alpha.2

package/dist/classes/base/math-array.d.ts

@@ -0,0 +1,66 @@
+import { NumericArray } from '@math.gl/types';
+import { ConfigurationOptions } from '../../lib/common';
+/** Base class for vectors and matrices */
+export default abstract class MathArray extends Array<number> {
+    /** Number of elements (values) in this array */
+    abstract get ELEMENTS(): number;
+    abstract copy(vector: Readonly<NumericArray>): this;
+    abstract fromObject(object: object): this;
+    /**
+     * Clone the current object
+     * @returns a new copy of this object
+     */
+    clone(): this;
+    fromArray(array: Readonly<NumericArray>, offset?: number): this;
+    toArray<TypedArray>(targetArray: TypedArray, offset?: number): TypedArray;
+    toArray(targetArray?: number[], offset?: number): NumericArray;
+    from(arrayOrObject: Readonly<NumericArray> | object): this;
+    to<T extends NumericArray | object>(arrayOrObject: T): T;
+    toTarget(target: any): any;
+    /** @deprecated */
+    toFloat32Array(): Float32Array;
+    toString(): string;
+    /** Formats string according to options */
+    formatString(opts: ConfigurationOptions): string;
+    equals(array: Readonly<NumericArray>): boolean;
+    exactEquals(array: Readonly<NumericArray>): boolean;
+    /** Negates all values in this object */
+    negate(): this;
+    /** Linearly interpolates between two values */
+    lerp(a: Readonly<NumericArray>, t: number): this;
+    lerp(a: Readonly<NumericArray>, b: Readonly<NumericArray>, t: number): this;
+    /** Minimal */
+    min(vector: Readonly<NumericArray>): this;
+    /** Maximal */
+    max(vector: Readonly<NumericArray>): this;
+    clamp(minVector: Readonly<NumericArray>, maxVector: Readonly<NumericArray>): this;
+    add(...vectors: Readonly<NumericArray>[]): this;
+    subtract(...vectors: Readonly<NumericArray>[]): this;
+    scale(scale: number | Readonly<NumericArray>): this;
+    /**
+     * Multiplies all elements by `scale`
+     * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
+     */
+    multiplyByScalar(scalar: number): this;
+    /** Throws an error if array length is incorrect or contains illegal values */
+    check(): this;
+    /** Returns false if the array length is incorrect or contains illegal values */
+    validate(): boolean;
+    /** @deprecated */
+    sub(a: Readonly<NumericArray>): this;
+    /** @deprecated */
+    setScalar(a: number): this;
+    /** @deprecated */
+    addScalar(a: number): this;
+    /** @deprecated */
+    subScalar(a: number): this;
+    /** @deprecated */
+    multiplyScalar(scalar: number): this;
+    /** @deprecated */
+    divideScalar(a: number): this;
+    /** @deprecated */
+    clampScalar(min: number, max: number): this;
+    /** @deprecated */
+    get elements(): NumericArray;
+}
+//# sourceMappingURL=math-array.d.ts.map

package/dist/classes/base/math-array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"math-array.d.ts","sourceRoot":"","sources":["../../../src/classes/base/math-array.ts"],"names":[],"mappings":"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"}

package/dist/classes/base/math-array.js

@@ -0,0 +1,216 @@
+import { config, formatValue, equals, isArray } from '../../lib/common';
+/** Base class for vectors and matrices */
+export default class MathArray extends Array {
+    // Common methods
+    /**
+     * Clone the current object
+     * @returns a new copy of this object
+     */
+    clone() {
+        // @ts-expect-error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
+        return new this.constructor().copy(this); // eslint-disable-line
+    }
+    fromArray(array, offset = 0) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = array[i + offset];
+        }
+        return this.check();
+    }
+    toArray(targetArray = [], offset = 0) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            targetArray[offset + i] = this[i];
+        }
+        return targetArray;
+    }
+    from(arrayOrObject) {
+        return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+    }
+    to(arrayOrObject) {
+        // @ts-ignore
+        if (arrayOrObject === this) {
+            return this;
+        }
+        // @ts-expect-error TS2339: Property 'toObject' does not exist on type 'MathArray'.
+        return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
+    }
+    toTarget(target) {
+        return target ? this.to(target) : this;
+    }
+    /** @deprecated */
+    toFloat32Array() {
+        return new Float32Array(this);
+    }
+    toString() {
+        return this.formatString(config);
+    }
+    /** Formats string according to options */
+    formatString(opts) {
+        let string = '';
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            string += (i > 0 ? ', ' : '') + formatValue(this[i], opts);
+        }
+        return `${opts.printTypes ? this.constructor.name : ''}[${string}]`;
+    }
+    equals(array) {
+        if (!array || this.length !== array.length) {
+            return false;
+        }
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            if (!equals(this[i], array[i])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    exactEquals(array) {
+        if (!array || this.length !== array.length) {
+            return false;
+        }
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            if (this[i] !== array[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // Modifiers
+    /** Negates all values in this object */
+    negate() {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = -this[i];
+        }
+        return this.check();
+    }
+    lerp(a, b, t) {
+        if (t === undefined) {
+            return this.lerp(this, a, b);
+        }
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            const ai = a[i];
+            this[i] = ai + t * (b[i] - ai);
+        }
+        return this.check();
+    }
+    /** Minimal */
+    min(vector) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = Math.min(vector[i], this[i]);
+        }
+        return this.check();
+    }
+    /** Maximal */
+    max(vector) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = Math.max(vector[i], this[i]);
+        }
+        return this.check();
+    }
+    clamp(minVector, maxVector) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]);
+        }
+        return this.check();
+    }
+    add(...vectors) {
+        for (const vector of vectors) {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] += vector[i];
+            }
+        }
+        return this.check();
+    }
+    subtract(...vectors) {
+        for (const vector of vectors) {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] -= vector[i];
+            }
+        }
+        return this.check();
+    }
+    scale(scale) {
+        if (typeof scale === 'number') {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] *= scale;
+            }
+        }
+        else {
+            for (let i = 0; i < this.ELEMENTS && i < scale.length; ++i) {
+                this[i] *= scale[i];
+            }
+        }
+        return this.check();
+    }
+    /**
+     * Multiplies all elements by `scale`
+     * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
+     */
+    multiplyByScalar(scalar) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] *= scalar;
+        }
+        return this.check();
+    }
+    // Debug checks
+    /** Throws an error if array length is incorrect or contains illegal values */
+    check() {
+        if (config.debug && !this.validate()) {
+            throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
+        }
+        return this;
+    }
+    /** Returns false if the array length is incorrect or contains illegal values */
+    validate() {
+        let valid = this.length === this.ELEMENTS;
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            valid = valid && Number.isFinite(this[i]);
+        }
+        return valid;
+    }
+    // three.js compatibility
+    /** @deprecated */
+    sub(a) {
+        return this.subtract(a);
+    }
+    /** @deprecated */
+    setScalar(a) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = a;
+        }
+        return this.check();
+    }
+    /** @deprecated */
+    addScalar(a) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] += a;
+        }
+        return this.check();
+    }
+    /** @deprecated */
+    subScalar(a) {
+        return this.addScalar(-a);
+    }
+    /** @deprecated */
+    multiplyScalar(scalar) {
+        // Multiplies all elements
+        // `Matrix4.scale` only scales its 3x3 "minor"
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] *= scalar;
+        }
+        return this.check();
+    }
+    /** @deprecated */
+    divideScalar(a) {
+        return this.multiplyByScalar(1 / a);
+    }
+    /** @deprecated */
+    clampScalar(min, max) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            this[i] = Math.min(Math.max(this[i], min), max);
+        }
+        return this.check();
+    }
+    /** @deprecated */
+    get elements() {
+        return this;
+    }
+}

package/dist/classes/base/matrix.d.ts

@@ -0,0 +1,14 @@
+import { NumericArray } from '@math.gl/types';
+import MathArray from './math-array';
+/** Base class for matrices */
+export default abstract class Matrix extends MathArray {
+    abstract get RANK(): number;
+    toString(): string;
+    getElementIndex(row: number, col: number): number;
+    getElement(row: number, col: number): number;
+    setElement(row: number, col: number, value: number): this;
+    getColumn<NumArrayT>(columnIndex: number, result: NumArrayT): NumArrayT;
+    getColumn(columnIndex: number): number[];
+    setColumn(columnIndex: number, columnVector: Readonly<NumericArray>): this;
+}
+//# sourceMappingURL=matrix.d.ts.map

package/dist/classes/base/matrix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"matrix.d.ts","sourceRoot":"","sources":["../../../src/classes/base/matrix.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,SAAS,MAAM,cAAc,CAAC;AAIrC,8BAA8B;AAC9B,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,MAAO,SAAQ,SAAS;IACpD,QAAQ,KAAK,IAAI,IAAI,MAAM,CAAC;IAa5B,QAAQ,IAAI,MAAM;IAmBlB,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAKjD,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,MAAM;IAK5C,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAIzD,SAAS,CAAC,SAAS,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,SAAS;IACvE,SAAS,CAAC,WAAW,EAAE,MAAM,GAAG,MAAM,EAAE;IAUxC,SAAS,CAAC,WAAW,EAAE,MAAM,EAAE,YAAY,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;CAO3E"}

package/dist/classes/base/matrix.js

@@ -0,0 +1,61 @@
+import MathArray from './math-array';
+import { checkNumber } from '../../lib/validators';
+import { config } from '../../lib/common';
+/** Base class for matrices */
+export default class Matrix extends MathArray {
+    // fromObject(object) {
+    //   const array = object.elements;
+    //   return this.fromRowMajor(array);
+    // }
+    // toObject(object) {
+    //   const array = object.elements;
+    //   this.toRowMajor(array);
+    //   return object;
+    // }
+    // TODO better override formatString?
+    toString() {
+        let string = '[';
+        if (config.printRowMajor) {
+            string += 'row-major:';
+            for (let row = 0; row < this.RANK; ++row) {
+                for (let col = 0; col < this.RANK; ++col) {
+                    string += ` ${this[col * this.RANK + row]}`;
+                }
+            }
+        }
+        else {
+            string += 'column-major:';
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                string += ` ${this[i]}`;
+            }
+        }
+        string += ']';
+        return string;
+    }
+    getElementIndex(row, col) {
+        return col * this.RANK + row;
+    }
+    // By default assumes row major indices
+    getElement(row, col) {
+        return this[col * this.RANK + row];
+    }
+    // By default assumes row major indices
+    setElement(row, col, value) {
+        this[col * this.RANK + row] = checkNumber(value);
+        return this;
+    }
+    getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) {
+        const firstIndex = columnIndex * this.RANK;
+        for (let i = 0; i < this.RANK; ++i) {
+            result[i] = this[firstIndex + i];
+        }
+        return result;
+    }
+    setColumn(columnIndex, columnVector) {
+        const firstIndex = columnIndex * this.RANK;
+        for (let i = 0; i < this.RANK; ++i) {
+            this[firstIndex + i] = columnVector[i];
+        }
+        return this;
+    }
+}

package/dist/classes/base/vector.d.ts

@@ -0,0 +1,44 @@
+import { NumericArray } from '@math.gl/types';
+import MathArray from './math-array';
+/** Base class for vectors with at least 2 elements */
+export default abstract class Vector extends MathArray {
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     *
+     * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements
+     * Instead we provide `len` and `magnitude`
+     */
+    len(): number;
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     */
+    magnitude(): number;
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
+    lengthSquared(): number;
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
+    magnitudeSquared(): number;
+    distance(mathArray: Readonly<NumericArray>): number;
+    distanceSquared(mathArray: Readonly<NumericArray>): number;
+    dot(mathArray: Readonly<NumericArray>): number;
+    normalize(): this;
+    multiply(...vectors: Readonly<NumericArray>[]): this;
+    divide(...vectors: Readonly<NumericArray>[]): this;
+    lengthSq(): number;
+    distanceTo(vector: Readonly<NumericArray>): number;
+    distanceToSquared(vector: Readonly<NumericArray>): number;
+    getComponent(i: number): number;
+    setComponent(i: number, value: number): this;
+    addVectors(a: Readonly<NumericArray>, b: Readonly<NumericArray>): this;
+    subVectors(a: Readonly<NumericArray>, b: Readonly<NumericArray>): this;
+    multiplyVectors(a: Readonly<NumericArray>, b: Readonly<NumericArray>): this;
+    addScaledVector(a: Readonly<NumericArray>, b: number): this;
+}
+//# sourceMappingURL=vector.d.ts.map

package/dist/classes/base/vector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../../../src/classes/base/vector.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,YAAY,EAAC,MAAM,gBAAgB,CAAC;AAC5C,OAAO,SAAS,MAAM,cAAc,CAAC;AAIrC,sDAAsD;AACtD,MAAM,CAAC,OAAO,CAAC,QAAQ,OAAO,MAAO,SAAQ,SAAS;IAGpD,IAAI,CAAC,IAAI,MAAM,CAEd;IAED,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,EAElB;IAED,IAAI,CAAC,IAAI,MAAM,CAEd;IAED,IAAI,CAAC,CAAC,KAAK,EAAE,MAAM,EAElB;IAED;;;;;OAKG;IACH,GAAG,IAAI,MAAM;IAIb;;OAEG;IACH,SAAS,IAAI,MAAM;IAInB;;OAEG;IACH,aAAa,IAAI,MAAM;IAQvB;;OAEG;IACH,gBAAgB,IAAI,MAAM;IAI1B,QAAQ,CAAC,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,MAAM;IAInD,eAAe,CAAC,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,MAAM;IAS1D,GAAG,CAAC,SAAS,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,MAAM;IAU9C,SAAS,IAAI,IAAI;IAUjB,QAAQ,CAAC,GAAG,OAAO,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,GAAG,IAAI;IASpD,MAAM,CAAC,GAAG,OAAO,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,GAAG,IAAI;IAWlD,QAAQ,IAAI,MAAM;IAGlB,UAAU,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,MAAM;IAGlD,iBAAiB,CAAC,MAAM,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,MAAM;IAIzD,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM;IAK/B,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAM5C,UAAU,CAAC,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAItE,UAAU,CAAC,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAItE,eAAe,CAAC,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,GAAG,IAAI;IAI3E,eAAe,CAAC,CAAC,EAAE,QAAQ,CAAC,YAAY,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;CAI5D"}

package/dist/classes/base/vector.js

@@ -0,0 +1,126 @@
+import MathArray from './math-array';
+import { checkNumber } from '../../lib/validators';
+import assert from '../../lib/assert';
+/** Base class for vectors with at least 2 elements */
+export default class Vector extends MathArray {
+    // ACCESSORS
+    get x() {
+        return this[0];
+    }
+    set x(value) {
+        this[0] = checkNumber(value);
+    }
+    get y() {
+        return this[1];
+    }
+    set y(value) {
+        this[1] = checkNumber(value);
+    }
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     *
+     * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements
+     * Instead we provide `len` and `magnitude`
+     */
+    len() {
+        return Math.sqrt(this.lengthSquared());
+    }
+    /**
+     * Returns the length of the vector from the origin to the point described by this vector
+     */
+    magnitude() {
+        return this.len();
+    }
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
+    lengthSquared() {
+        let length = 0;
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            length += this[i] * this[i];
+        }
+        return length;
+    }
+    /**
+     * Returns the squared length of the vector from the origin to the point described by this vector
+     */
+    magnitudeSquared() {
+        return this.lengthSquared();
+    }
+    distance(mathArray) {
+        return Math.sqrt(this.distanceSquared(mathArray));
+    }
+    distanceSquared(mathArray) {
+        let length = 0;
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            const dist = this[i] - mathArray[i];
+            length += dist * dist;
+        }
+        return checkNumber(length);
+    }
+    dot(mathArray) {
+        let product = 0;
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+            product += this[i] * mathArray[i];
+        }
+        return checkNumber(product);
+    }
+    // MODIFIERS
+    normalize() {
+        const length = this.magnitude();
+        if (length !== 0) {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] /= length;
+            }
+        }
+        return this.check();
+    }
+    multiply(...vectors) {
+        for (const vector of vectors) {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] *= vector[i];
+            }
+        }
+        return this.check();
+    }
+    divide(...vectors) {
+        for (const vector of vectors) {
+            for (let i = 0; i < this.ELEMENTS; ++i) {
+                this[i] /= vector[i];
+            }
+        }
+        return this.check();
+    }
+    // THREE.js compatibility
+    lengthSq() {
+        return this.lengthSquared();
+    }
+    distanceTo(vector) {
+        return this.distance(vector);
+    }
+    distanceToSquared(vector) {
+        return this.distanceSquared(vector);
+    }
+    getComponent(i) {
+        assert(i >= 0 && i < this.ELEMENTS, 'index is out of range');
+        return checkNumber(this[i]);
+    }
+    setComponent(i, value) {
+        assert(i >= 0 && i < this.ELEMENTS, 'index is out of range');
+        this[i] = value;
+        return this.check();
+    }
+    addVectors(a, b) {
+        return this.copy(a).add(b);
+    }
+    subVectors(a, b) {
+        return this.copy(a).subtract(b);
+    }
+    multiplyVectors(a, b) {
+        return this.copy(a).multiply(b);
+    }
+    addScaledVector(a, b) {
+        // @ts-expect-error error TS2351: Cannot use 'new' with an expression whose type lacks a call or construct signature.
+        return this.add(new this.constructor(a).multiplyScalar(b));
+    }
+}

package/dist/classes/euler.d.ts

@@ -0,0 +1,77 @@
+import MathArray from './base/math-array';
+import Quaternion from './quaternion';
+import { NumericArray } from '@math.gl/types';
+declare enum RotationOrder {
+    ZYX = 0,
+    YXZ = 1,
+    XZY = 2,
+    ZXY = 3,
+    YZX = 4,
+    XYZ = 5
+}
+export default class Euler extends MathArray {
+    static get ZYX(): RotationOrder;
+    static get YXZ(): RotationOrder;
+    static get XZY(): RotationOrder;
+    static get ZXY(): RotationOrder;
+    static get YZX(): RotationOrder;
+    static get XYZ(): RotationOrder;
+    static get RollPitchYaw(): RotationOrder;
+    static get DefaultOrder(): RotationOrder;
+    static get RotationOrders(): typeof RotationOrder;
+    static rotationOrder(order: RotationOrder): string;
+    get ELEMENTS(): number;
+    /**
+     * @class
+     * @param {Number | Number[]} x
+     * @param {Number=} [y]
+     * @param {Number=} [z]
+     * @param {Number=} [order]
+     */
+    constructor(x?: number, y?: number, z?: number, order?: RotationOrder);
+    fromQuaternion(quaternion: Readonly<NumericArray>): this;
+    fromObject(object: object): this;
+    copy(array: Readonly<NumericArray>): this;
+    set(x: number, y: number, z: number, order: RotationOrder): this;
+    validate(): boolean;
+    toArray(array?: NumericArray, offset?: number): NumericArray;
+    toArray4(array?: NumericArray, offset?: number): NumericArray;
+    toVector3(result?: NumericArray): NumericArray;
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get z(): number;
+    set z(value: number);
+    get alpha(): number;
+    set alpha(value: number);
+    get beta(): number;
+    set beta(value: number);
+    get gamma(): number;
+    set gamma(value: number);
+    get phi(): number;
+    set phi(value: number);
+    get theta(): number;
+    set theta(value: number);
+    get psi(): number;
+    set psi(value: number);
+    get roll(): number;
+    set roll(value: number);
+    get pitch(): number;
+    set pitch(value: number);
+    get yaw(): number;
+    set yaw(value: number);
+    get order(): RotationOrder;
+    set order(value: RotationOrder);
+    fromVector3(v: Readonly<NumericArray>, order: RotationOrder): this;
+    fromArray(array: Readonly<NumericArray>, offset?: number): this;
+    fromRollPitchYaw(roll: number, pitch: number, yaw: number): this;
+    fromRotationMatrix(m: Readonly<NumericArray>, order?: RotationOrder): this;
+    getRotationMatrix(m: NumericArray): NumericArray;
+    getQuaternion(): Quaternion;
+    _fromRotationMatrix(m: Readonly<NumericArray>, order?: RotationOrder): this;
+    _getRotationMatrix(result: NumericArray): NumericArray;
+    toQuaternion(): Quaternion;
+}
+export {};
+//# sourceMappingURL=euler.d.ts.map

package/dist/classes/euler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"euler.d.ts","sourceRoot":"","sources":["../../src/classes/euler.ts"],"names":[],"mappings":"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"}