hj-gis-sdk 1.0.0

package/dist/sdk.esm.js

@@ -0,0 +1,4143 @@
+import { Logger } from '@epicgames-ps/lib-pixelstreamingfrontend-ue5.5';
+
+/**
+ * UERPC wraps RPC-style interactions over Pixel Streaming's DataChannel.
+ * It mirrors the Web/script.js behavior: sends {Type:'RPC_CALL', Command, ReqId, ...payload}
+ * and expects UE to reply with {Type:'RPC_RESPONSE', ReqId, Status, Data|Message} via EmitJSEvent.
+ */
+class UERPC {
+    constructor(stream, responseEventName = 'handle_responses') {
+        this.stream = stream;
+        this.responseEventName = responseEventName;
+        this.pendingRequests = new Map();
+        this.timeoutMs = 30000;
+        try {
+            this.stream.addResponseEventListener(this.responseEventName, this.handleResponse.bind(this));
+        }
+        catch (e) {
+            // If the stream is not ready yet, user can call bind later.
+        }
+    }
+    getStream() {
+        return this.stream;
+    }
+    /**
+     * Bind the response listener explicitly if constructor binding failed or the stream changed.
+     */
+    bind(stream, responseEventName = this.responseEventName) {
+        this.stream = stream;
+        this.responseEventName = responseEventName;
+        this.stream.addResponseEventListener(this.responseEventName, this.handleResponse.bind(this));
+    }
+    emitCommand(playload) {
+        this.stream.emitCommand(playload);
+    }
+    /**
+     * Generic RPC call. Resolves when UE replies with matching ReqId.
+     */
+    call(command, payload = {}, timeoutMs) {
+        const reqId = this.generateUUID();
+        const message = {
+            Type: 'RPC_CALL',
+            Command: command,
+            ReqId: reqId,
+            ...payload
+        };
+        return new Promise((resolve, reject) => {
+            const timer = window.setTimeout(() => {
+                if (this.pendingRequests.has(reqId)) {
+                    this.pendingRequests.delete(reqId);
+                    reject(new Error(`UE RPC Timeout: ${command}`));
+                }
+            }, timeoutMs || this.timeoutMs);
+            this.pendingRequests.set(reqId, { resolve, reject, timer });
+            try {
+                this.stream.emitUIInteraction(message);
+            }
+            catch (e) {
+                window.clearTimeout(timer);
+                this.pendingRequests.delete(reqId);
+                reject(e);
+            }
+        });
+    }
+    /**
+     * Handle UE responses. Accepts stringified or object payloads.
+     */
+    handleResponse(raw) {
+        let json = raw;
+        try {
+            if (typeof raw === 'string') {
+                json = JSON.parse(raw);
+            }
+        }
+        catch {
+            return;
+        }
+        if (!json || json.Type !== 'RPC_RESPONSE')
+            return;
+        const reqId = json.ReqId;
+        if (!reqId)
+            return;
+        const pending = this.pendingRequests.get(reqId);
+        if (!pending)
+            return;
+        window.clearTimeout(pending.timer);
+        this.pendingRequests.delete(reqId);
+        const status = json.Status;
+        if (status === 'success') {
+            pending.resolve(json.Data);
+        }
+        else {
+            const msg = json.Message || 'Unknown UE Error';
+            pending.reject(new Error(msg));
+        }
+    }
+    callModule(moduleName, actionName, params = {}, timeoutMs = 30000) {
+        const reqId = this.generateUUID();
+        const message = {
+            Type: 'RPC_CALL',
+            ReqId: reqId,
+            ModuleName: moduleName,
+            ActionName: actionName,
+            Params: params
+        };
+        Logger.Info(JSON.stringify(message));
+        return new Promise((resolve, reject) => {
+            const timer = window.setTimeout(() => {
+                if (this.pendingRequests.has(reqId)) {
+                    this.pendingRequests.delete(reqId);
+                    reject(new Error(`UE Call Timeout: ${moduleName}/${actionName}`));
+                }
+            }, timeoutMs || this.timeoutMs);
+            this.pendingRequests.set(reqId, { resolve, reject, timer });
+            try {
+                this.stream.emitUIInteraction(message);
+            }
+            catch (e) {
+                window.clearTimeout(timer);
+                this.pendingRequests.delete(reqId);
+                reject(e);
+            }
+        });
+    }
+    // ---- Convenience helpers for Web-supported commands ----
+    // Level management
+    loadLevelByName(levelName) {
+        return this.call('LoadLevelByName', { LevelName: levelName });
+    }
+    unLoadMap(levelName) {
+        return this.call('UnLoadMap', { LevelName: levelName });
+    }
+    // Actor management
+    spawnStaticMeshActor(params) {
+        return this.call('SpawnStaticMeshActor', params);
+    }
+    // Blueprint management
+    spawnLocalBlueprintActor(params) {
+        return this.call('SpawnLocalBlueprintActor', params);
+    }
+    setActorTransformByHandle(handle, transform) {
+        return this.call('SetActorTransformByHandle', {
+            Handle: handle,
+            Transform: transform
+        });
+    }
+    destroyActorByHandle(handle) {
+        return this.call('DestroyActorByHandle', { Handle: handle });
+    }
+    // Picking
+    pickPointByScreen(x, y, maxDistance = 10000000, highlight = false) {
+        return this.call('PickPointByScreen', {
+            Screen: {
+                X: x,
+                Y: y
+            },
+            MaxDistance: maxDistance,
+            Highlight: highlight
+        });
+    }
+    // Camera lens and transform
+    getCameraTransform() {
+        return this.call('GetCameraTransform', {});
+    }
+    setCameraTransform(transform) {
+        return this.call('SetCameraTransform', { Transform: transform });
+    }
+    setCameraResetTransform(transform) {
+        return this.call('SetCameraResetTransform', { Transform: transform });
+    }
+    resetCameraToSavedTransform() {
+        return this.call('ResetCameraToSavedTransform', {});
+    }
+    generateUUID() {
+        return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+            const r = (Math.random() * 16) | 0;
+            const v = c === 'x' ? r : (r & 0x3) | 0x8;
+            return v.toString(16);
+        });
+    }
+}
+
+// math.gl
+const DEFAULT_CONFIG = {
+    EPSILON: 1e-12,
+    debug: false,
+    precision: 4,
+    printTypes: false,
+    printDegrees: false,
+    printRowMajor: true,
+    _cartographicRadians: false
+};
+// Configuration is truly global as of v3.6 to ensure single config even if multiple copies of math.gl
+// Multiple copies of config can be quite tricky to debug...
+globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
+const config = globalThis.mathgl.config;
+/**
+ * Formats a value into a string
+ * @param value
+ * @param param1
+ * @returns
+ */
+function formatValue(value, { precision = config.precision } = {}) {
+    value = round(value);
+    // get rid of trailing zeros
+    return `${parseFloat(value.toPrecision(precision))}`;
+}
+/**
+ * Check if value is an "array"
+ * Returns `true` if value is either an array or a typed array
+ * Note: returns `false` for `ArrayBuffer` and `DataView` instances
+ * @note isTypedArray and isNumericArray are often more useful in TypeScript
+ */
+function isArray(value) {
+    return Array.isArray(value) || (ArrayBuffer.isView(value) && !(value instanceof DataView));
+}
+function clamp(value, min, max) {
+    return map(value, (value) => Math.max(min, Math.min(max, value)));
+}
+/* eslint-disable */
+/**
+ * Compares any two math objects, using `equals` method if available.
+ * @param a
+ * @param b
+ * @param epsilon
+ * @returns
+ */
+function equals(a, b, epsilon) {
+    const oldEpsilon = config.EPSILON;
+    if (epsilon) {
+        config.EPSILON = epsilon;
+    }
+    try {
+        if (a === b) {
+            return true;
+        }
+        if (isArray(a) && isArray(b)) {
+            if (a.length !== b.length) {
+                return false;
+            }
+            for (let i = 0; i < a.length; ++i) {
+                // eslint-disable-next-line max-depth
+                if (!equals(a[i], b[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (a && a.equals) {
+            return a.equals(b);
+        }
+        if (b && b.equals) {
+            return b.equals(a);
+        }
+        if (typeof a === 'number' && typeof b === 'number') {
+            return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
+        }
+        return false;
+    }
+    finally {
+        config.EPSILON = oldEpsilon;
+    }
+}
+// HELPERS
+function round(value) {
+    return Math.round(value / config.EPSILON) * config.EPSILON;
+}
+// If the array has a clone function, calls it, otherwise returns a copy
+function duplicateArray(array) {
+    // @ts-expect-error We check for math.gl class methods
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-call
+    return array.clone ? array.clone() : new Array(array.length);
+}
+// If the argument value is an array, applies the func element wise,
+// otherwise applies func to the argument value
+function map(value, func, result) {
+    if (isArray(value)) {
+        const array = value;
+        result = result || duplicateArray(array);
+        for (let i = 0; i < result.length && i < array.length; ++i) {
+            const val = typeof value === 'number' ? value : value[i];
+            result[i] = func(val, i, result);
+        }
+        return result;
+    }
+    return func(value);
+}
+
+// math.gl
+/** Base class for vectors and matrices */
+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;
+    }
+    toObject(targetObject) {
+        return targetObject;
+    }
+    from(arrayOrObject) {
+        return Array.isArray(arrayOrObject)
+            ? this.copy(arrayOrObject)
+            : // @ts-ignore
+                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];
+            const endValue = typeof b === 'number' ? b : b[i];
+            this[i] = ai + t * (endValue - 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;
+    }
+}
+
+// math.gl
+function validateVector(v, length) {
+    if (v.length !== length) {
+        return false;
+    }
+    // Could be arguments "array" (v.every not availasble)
+    for (let i = 0; i < v.length; ++i) {
+        if (!Number.isFinite(v[i])) {
+            return false;
+        }
+    }
+    return true;
+}
+function checkNumber(value) {
+    if (!Number.isFinite(value)) {
+        throw new Error(`Invalid number ${JSON.stringify(value)}`);
+    }
+    return value;
+}
+function checkVector(v, length, callerName = '') {
+    if (config.debug && !validateVector(v, length)) {
+        throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
+    }
+    return v;
+}
+
+// math.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+function assert(condition, message) {
+    if (!condition) {
+        throw new Error(`math.gl assertion ${message}`);
+    }
+}
+
+// math.gl
+/** Base class for vectors with at least 2 elements */
+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));
+    }
+}
+
+// @eslint-disable
+// @ts-nocheck
+/**
+ * Common utilities
+ * @module glMatrix
+ */
+// Configuration Constants
+const EPSILON = 0.000001;
+let ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;
+
+// math.gl
+// vec3 additions
+// Transform as vector, only uses 3x3 minor matrix
+function vec3_transformMat4AsVector(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    const w = m[3] * x + m[7] * y + m[11] * z || 1.0;
+    out[0] = (m[0] * x + m[4] * y + m[8] * z) / w;
+    out[1] = (m[1] * x + m[5] * y + m[9] * z) / w;
+    out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;
+    return out;
+}
+function vec3_transformMat2(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    out[0] = m[0] * x + m[2] * y;
+    out[1] = m[1] * x + m[3] * y;
+    out[2] = a[2];
+    return out;
+}
+// vec4 additions
+function vec4_transformMat2(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    out[0] = m[0] * x + m[2] * y;
+    out[1] = m[1] * x + m[3] * y;
+    out[2] = a[2];
+    out[3] = a[3];
+    return out;
+}
+function vec4_transformMat3(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    out[0] = m[0] * x + m[3] * y + m[6] * z;
+    out[1] = m[1] * x + m[4] * y + m[7] * z;
+    out[2] = m[2] * x + m[5] * y + m[8] * z;
+    out[3] = a[3];
+    return out;
+}
+
+// @eslint-disable
+/**
+ * 3 Dimensional Vector
+ * @module vec3
+ */
+/**
+ * Creates a new, empty vec3
+ *
+ * @returns {vec3} a new 3D vector
+ */
+function create$3() {
+    const out = new ARRAY_TYPE(3);
+    if (ARRAY_TYPE != Float32Array) {
+        out[0] = 0;
+        out[1] = 0;
+        out[2] = 0;
+    }
+    return out;
+}
+/**
+ * Calculates the length of a vec3
+ *
+ * @param {ReadonlyVec3} a vector to calculate length of
+ * @returns {Number} length of a
+ */
+function length$2(a) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    return Math.sqrt(x * x + y * y + z * z);
+}
+/**
+ * Creates a new vec3 initialized with the given values
+ *
+ * @param {Number} x X component
+ * @param {Number} y Y component
+ * @param {Number} z Z component
+ * @returns {vec3} a new 3D vector
+ */
+function fromValues(x, y, z) {
+    const out = new ARRAY_TYPE(3);
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    return out;
+}
+/**
+ * Normalize a vec3
+ *
+ * @param {vec3} out the receiving vector
+ * @param {ReadonlyVec3} a vector to normalize
+ * @returns {vec3} out
+ */
+function normalize$2(out, a) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    let len = x * x + y * y + z * z;
+    if (len > 0) {
+        // TODO: evaluate use of glm_invsqrt here?
+        len = 1 / Math.sqrt(len);
+    }
+    out[0] = a[0] * len;
+    out[1] = a[1] * len;
+    out[2] = a[2] * len;
+    return out;
+}
+/**
+ * Calculates the dot product of two vec3's
+ *
+ * @param {ReadonlyVec3} a the first operand
+ * @param {ReadonlyVec3} b the second operand
+ * @returns {Number} dot product of a and b
+ */
+function dot$2(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+}
+/**
+ * Computes the cross product of two vec3's
+ *
+ * @param {vec3} out the receiving vector
+ * @param {ReadonlyVec3} a the first operand
+ * @param {ReadonlyVec3} b the second operand
+ * @returns {vec3} out
+ */
+function cross(out, a, b) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const bx = b[0];
+    const by = b[1];
+    const bz = b[2];
+    out[0] = ay * bz - az * by;
+    out[1] = az * bx - ax * bz;
+    out[2] = ax * by - ay * bx;
+    return out;
+}
+/**
+ * Transforms the vec3 with a mat4.
+ * 4th vector component is implicitly '1'
+ *
+ * @param {vec3} out the receiving vector
+ * @param {ReadonlyVec3} a the vector to transform
+ * @param {ReadonlyMat4} m matrix to transform with
+ * @returns {vec3} out
+ */
+function transformMat4(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    let w = m[3] * x + m[7] * y + m[11] * z + m[15];
+    w = w || 1.0;
+    out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+    out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+    out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+    return out;
+}
+/**
+ * Transforms the vec3 with a mat3.
+ *
+ * @param {vec3} out the receiving vector
+ * @param {ReadonlyVec3} a the vector to transform
+ * @param {ReadonlyMat3} m the 3x3 matrix to transform with
+ * @returns {vec3} out
+ */
+function transformMat3(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    out[0] = x * m[0] + y * m[3] + z * m[6];
+    out[1] = x * m[1] + y * m[4] + z * m[7];
+    out[2] = x * m[2] + y * m[5] + z * m[8];
+    return out;
+}
+/**
+ * Transforms the vec3 with a quat
+ * Can also be used for dual quaternions. (Multiply it with the real part)
+ *
+ * @param {vec3} out the receiving vector
+ * @param {ReadonlyVec3} a the vector to transform
+ * @param {ReadonlyQuat} q quaternion to transform with
+ * @returns {vec3} out
+ */
+function transformQuat$1(out, a, q) {
+    // benchmarks: https://jsperf.com/quaternion-transform-vec3-implementations-fixed
+    const qx = q[0];
+    const qy = q[1];
+    const qz = q[2];
+    const qw = q[3];
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    // var qvec = [qx, qy, qz];
+    // var uv = vec3.cross([], qvec, a);
+    let uvx = qy * z - qz * y;
+    let uvy = qz * x - qx * z;
+    let uvz = qx * y - qy * x;
+    // var uuv = vec3.cross([], qvec, uv);
+    let uuvx = qy * uvz - qz * uvy;
+    let uuvy = qz * uvx - qx * uvz;
+    let uuvz = qx * uvy - qy * uvx;
+    // vec3.scale(uv, uv, 2 * w);
+    const w2 = qw * 2;
+    uvx *= w2;
+    uvy *= w2;
+    uvz *= w2;
+    // vec3.scale(uuv, uuv, 2);
+    uuvx *= 2;
+    uuvy *= 2;
+    uuvz *= 2;
+    // return vec3.add(out, a, vec3.add(out, uv, uuv));
+    out[0] = x + uvx + uuvx;
+    out[1] = y + uvy + uuvy;
+    out[2] = z + uvz + uuvz;
+    return out;
+}
+/**
+ * Rotate a 3D vector around the x-axis
+ * @param {vec3} out The receiving vec3
+ * @param {ReadonlyVec3} a The vec3 point to rotate
+ * @param {ReadonlyVec3} b The origin of the rotation
+ * @param {Number} rad The angle of rotation in radians
+ * @returns {vec3} out
+ */
+function rotateX$1(out, a, b, rad) {
+    const p = [];
+    const r = [];
+    // Translate point to the origin
+    p[0] = a[0] - b[0];
+    p[1] = a[1] - b[1];
+    p[2] = a[2] - b[2];
+    // perform rotation
+    r[0] = p[0];
+    r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);
+    r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad);
+    // translate to correct position
+    out[0] = r[0] + b[0];
+    out[1] = r[1] + b[1];
+    out[2] = r[2] + b[2];
+    return out;
+}
+/**
+ * Rotate a 3D vector around the y-axis
+ * @param {vec3} out The receiving vec3
+ * @param {ReadonlyVec3} a The vec3 point to rotate
+ * @param {ReadonlyVec3} b The origin of the rotation
+ * @param {Number} rad The angle of rotation in radians
+ * @returns {vec3} out
+ */
+function rotateY$1(out, a, b, rad) {
+    const p = [];
+    const r = [];
+    // Translate point to the origin
+    p[0] = a[0] - b[0];
+    p[1] = a[1] - b[1];
+    p[2] = a[2] - b[2];
+    // perform rotation
+    r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);
+    r[1] = p[1];
+    r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad);
+    // translate to correct position
+    out[0] = r[0] + b[0];
+    out[1] = r[1] + b[1];
+    out[2] = r[2] + b[2];
+    return out;
+}
+/**
+ * Rotate a 3D vector around the z-axis
+ * @param {vec3} out The receiving vec3
+ * @param {ReadonlyVec3} a The vec3 point to rotate
+ * @param {ReadonlyVec3} b The origin of the rotation
+ * @param {Number} rad The angle of rotation in radians
+ * @returns {vec3} out
+ */
+function rotateZ$1(out, a, b, rad) {
+    const p = [];
+    const r = [];
+    // Translate point to the origin
+    p[0] = a[0] - b[0];
+    p[1] = a[1] - b[1];
+    p[2] = a[2] - b[2];
+    // perform rotation
+    r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);
+    r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);
+    r[2] = p[2];
+    // translate to correct position
+    out[0] = r[0] + b[0];
+    out[1] = r[1] + b[1];
+    out[2] = r[2] + b[2];
+    return out;
+}
+/**
+ * Get the angle between two 3D vectors
+ * @param {ReadonlyVec3} a The first operand
+ * @param {ReadonlyVec3} b The second operand
+ * @returns {Number} The angle in radians
+ */
+function angle(a, b) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const bx = b[0];
+    const by = b[1];
+    const bz = b[2];
+    const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz));
+    const cosine = mag && dot$2(a, b) / mag;
+    return Math.acos(Math.min(Math.max(cosine, -1), 1));
+}
+/**
+ * Alias for {@link vec3.length}
+ * @function
+ */
+const len = length$2;
+/**
+ * Perform some operation over an array of vec3s.
+ *
+ * @param {Array} a the array of vectors to iterate over
+ * @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed
+ * @param {Number} offset Number of elements to skip at the beginning of the array
+ * @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array
+ * @param {Function} fn Function to call for each vector in the array
+ * @param {Object} [arg] additional argument to pass to fn
+ * @returns {Array} a
+ * @function
+ */
+((function () {
+    const vec = create$3();
+    return function (a, stride, offset, count, fn, arg) {
+        let i;
+        let l;
+        if (!stride) {
+            stride = 3;
+        }
+        if (!offset) {
+            offset = 0;
+        }
+        if (count) {
+            l = Math.min(count * stride + offset, a.length);
+        }
+        else {
+            l = a.length;
+        }
+        for (i = offset; i < l; i += stride) {
+            vec[0] = a[i];
+            vec[1] = a[i + 1];
+            vec[2] = a[i + 2];
+            fn(vec, vec, arg);
+            a[i] = vec[0];
+            a[i + 1] = vec[1];
+            a[i + 2] = vec[2];
+        }
+        return a;
+    };
+}))();
+
+// math.gl
+const ORIGIN = [0, 0, 0];
+let ZERO$1;
+/**
+ * Three-element vector class with common linear algebra operations.
+ * Subclass of Array<number> meaning that it is highly compatible with other libraries
+ */
+class Vector3 extends Vector {
+    static get ZERO() {
+        if (!ZERO$1) {
+            ZERO$1 = new Vector3(0, 0, 0);
+            Object.freeze(ZERO$1);
+        }
+        return ZERO$1;
+    }
+    /**
+     * @class
+     * @param x
+     * @param y
+     * @param z
+     */
+    constructor(x = 0, y = 0, z = 0) {
+        // PERF NOTE: initialize elements as double precision numbers
+        super(-0, -0, -0);
+        if (arguments.length === 1 && isArray(x)) {
+            this.copy(x);
+        }
+        else {
+            // this.set(x, y, z);
+            if (config.debug) {
+                checkNumber(x);
+                checkNumber(y);
+                checkNumber(z);
+            }
+            // @ts-expect-error TS2412: Property '0' of type 'number | [number, number, number]' is not assignable to numeric index type 'number'
+            this[0] = x;
+            this[1] = y;
+            this[2] = z;
+        }
+    }
+    set(x, y, z) {
+        this[0] = x;
+        this[1] = y;
+        this[2] = z;
+        return this.check();
+    }
+    copy(array) {
+        this[0] = array[0];
+        this[1] = array[1];
+        this[2] = array[2];
+        return this.check();
+    }
+    fromObject(object) {
+        if (config.debug) {
+            checkNumber(object.x);
+            checkNumber(object.y);
+            checkNumber(object.z);
+        }
+        this[0] = object.x;
+        this[1] = object.y;
+        this[2] = object.z;
+        return this.check();
+    }
+    toObject(object) {
+        object.x = this[0];
+        object.y = this[1];
+        object.z = this[2];
+        return object;
+    }
+    // Getters/setters
+    get ELEMENTS() {
+        return 3;
+    }
+    get z() {
+        return this[2];
+    }
+    set z(value) {
+        this[2] = checkNumber(value);
+    }
+    // ACCESSORS
+    angle(vector) {
+        return angle(this, vector);
+    }
+    // MODIFIERS
+    cross(vector) {
+        cross(this, this, vector);
+        return this.check();
+    }
+    rotateX({ radians, origin = ORIGIN }) {
+        rotateX$1(this, this, origin, radians);
+        return this.check();
+    }
+    rotateY({ radians, origin = ORIGIN }) {
+        rotateY$1(this, this, origin, radians);
+        return this.check();
+    }
+    rotateZ({ radians, origin = ORIGIN }) {
+        rotateZ$1(this, this, origin, radians);
+        return this.check();
+    }
+    // Transforms
+    // transforms as point (4th component is implicitly 1)
+    transform(matrix4) {
+        return this.transformAsPoint(matrix4);
+    }
+    // transforms as point (4th component is implicitly 1)
+    transformAsPoint(matrix4) {
+        transformMat4(this, this, matrix4);
+        return this.check();
+    }
+    // transforms as vector  (4th component is implicitly 0, ignores translation. slightly faster)
+    transformAsVector(matrix4) {
+        vec3_transformMat4AsVector(this, this, matrix4);
+        return this.check();
+    }
+    transformByMatrix3(matrix3) {
+        transformMat3(this, this, matrix3);
+        return this.check();
+    }
+    transformByMatrix2(matrix2) {
+        vec3_transformMat2(this, this, matrix2);
+        return this.check();
+    }
+    transformByQuaternion(quaternion) {
+        transformQuat$1(this, this, quaternion);
+        return this.check();
+    }
+}
+
+// math.gl
+let ZERO;
+/**
+ * Four-element vector class with common linear algebra operations.
+ * Subclass of Array<number> meaning that it is highly compatible with other libraries
+ */
+class Vector4 extends Vector {
+    static get ZERO() {
+        if (!ZERO) {
+            ZERO = new Vector4(0, 0, 0, 0);
+            Object.freeze(ZERO);
+        }
+        return ZERO;
+    }
+    constructor(x = 0, y = 0, z = 0, w = 0) {
+        // PERF NOTE: initialize elements as double precision numbers
+        super(-0, -0, -0, -0);
+        if (isArray(x) && arguments.length === 1) {
+            this.copy(x);
+        }
+        else {
+            // this.set(x, y, z, w);
+            if (config.debug) {
+                checkNumber(x);
+                checkNumber(y);
+                checkNumber(z);
+                checkNumber(w);
+            }
+            this[0] = x;
+            this[1] = y;
+            this[2] = z;
+            this[3] = w;
+        }
+    }
+    set(x, y, z, w) {
+        this[0] = x;
+        this[1] = y;
+        this[2] = z;
+        this[3] = w;
+        return this.check();
+    }
+    copy(array) {
+        this[0] = array[0];
+        this[1] = array[1];
+        this[2] = array[2];
+        this[3] = array[3];
+        return this.check();
+    }
+    fromObject(object) {
+        if (config.debug) {
+            checkNumber(object.x);
+            checkNumber(object.y);
+            checkNumber(object.z);
+            checkNumber(object.w);
+        }
+        this[0] = object.x;
+        this[1] = object.y;
+        this[2] = object.z;
+        this[3] = object.w;
+        return this;
+    }
+    toObject(object) {
+        object.x = this[0];
+        object.y = this[1];
+        object.z = this[2];
+        object.w = this[3];
+        return object;
+    }
+    // Getters/setters
+    /* eslint-disable no-multi-spaces, brace-style, no-return-assign */
+    get ELEMENTS() {
+        return 4;
+    }
+    get z() {
+        return this[2];
+    }
+    set z(value) {
+        this[2] = checkNumber(value);
+    }
+    get w() {
+        return this[3];
+    }
+    set w(value) {
+        this[3] = checkNumber(value);
+    }
+    transform(matrix4) {
+        transformMat4(this, this, matrix4);
+        return this.check();
+    }
+    transformByMatrix3(matrix3) {
+        vec4_transformMat3(this, this, matrix3);
+        return this.check();
+    }
+    transformByMatrix2(matrix2) {
+        vec4_transformMat2(this, this, matrix2);
+        return this.check();
+    }
+    transformByQuaternion(quaternion) {
+        transformQuat$1(this, this, quaternion);
+        return this.check();
+    }
+    // three.js compatibility
+    applyMatrix4(m) {
+        m.transform(this, this);
+        return this;
+    }
+}
+
+/**
+ * 3x3 Matrix
+ * @module mat3
+ */
+/**
+ * Creates a new identity mat3
+ *
+ * @returns {mat3} a new 3x3 matrix
+ */
+function create$2() {
+    const out = new ARRAY_TYPE(9);
+    if (ARRAY_TYPE != Float32Array) {
+        out[1] = 0;
+        out[2] = 0;
+        out[3] = 0;
+        out[5] = 0;
+        out[6] = 0;
+        out[7] = 0;
+    }
+    out[0] = 1;
+    out[4] = 1;
+    out[8] = 1;
+    return out;
+}
+
+// @eslint-disable
+/**
+ * 4 Dimensional Vector
+ * @module vec4
+ */
+/**
+ * Creates a new, empty vec4
+ *
+ * @returns {vec4} a new 4D vector
+ */
+function create$1() {
+    const out = new ARRAY_TYPE(4);
+    if (ARRAY_TYPE != Float32Array) {
+        out[0] = 0;
+        out[1] = 0;
+        out[2] = 0;
+        out[3] = 0;
+    }
+    return out;
+}
+/**
+ * Adds two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @returns {vec4} out
+ */
+function add$1(out, a, b) {
+    out[0] = a[0] + b[0];
+    out[1] = a[1] + b[1];
+    out[2] = a[2] + b[2];
+    out[3] = a[3] + b[3];
+    return out;
+}
+/**
+ * Scales a vec4 by a scalar number
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the vector to scale
+ * @param {Number} b amount to scale the vector by
+ * @returns {vec4} out
+ */
+function scale$1(out, a, b) {
+    out[0] = a[0] * b;
+    out[1] = a[1] * b;
+    out[2] = a[2] * b;
+    out[3] = a[3] * b;
+    return out;
+}
+/**
+ * Calculates the length of a vec4
+ *
+ * @param {ReadonlyVec4} a vector to calculate length of
+ * @returns {Number} length of a
+ */
+function length$1(a) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    const w = a[3];
+    return Math.sqrt(x * x + y * y + z * z + w * w);
+}
+/**
+ * Calculates the squared length of a vec4
+ *
+ * @param {ReadonlyVec4} a vector to calculate squared length of
+ * @returns {Number} squared length of a
+ */
+function squaredLength$1(a) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    const w = a[3];
+    return x * x + y * y + z * z + w * w;
+}
+/**
+ * Normalize a vec4
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a vector to normalize
+ * @returns {vec4} out
+ */
+function normalize$1(out, a) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    const w = a[3];
+    let len = x * x + y * y + z * z + w * w;
+    if (len > 0) {
+        len = 1 / Math.sqrt(len);
+    }
+    out[0] = x * len;
+    out[1] = y * len;
+    out[2] = z * len;
+    out[3] = w * len;
+    return out;
+}
+/**
+ * Calculates the dot product of two vec4's
+ *
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @returns {Number} dot product of a and b
+ */
+function dot$1(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];
+}
+/**
+ * Performs a linear interpolation between two vec4's
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the first operand
+ * @param {ReadonlyVec4} b the second operand
+ * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
+ * @returns {vec4} out
+ */
+function lerp$1(out, a, b, t) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const aw = a[3];
+    out[0] = ax + t * (b[0] - ax);
+    out[1] = ay + t * (b[1] - ay);
+    out[2] = az + t * (b[2] - az);
+    out[3] = aw + t * (b[3] - aw);
+    return out;
+}
+/**
+ * Transforms the vec4 with a quat
+ *
+ * @param {vec4} out the receiving vector
+ * @param {ReadonlyVec4} a the vector to transform
+ * @param {ReadonlyQuat} q quaternion to transform with
+ * @returns {vec4} out
+ */
+function transformQuat(out, a, q) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    const qx = q[0];
+    const qy = q[1];
+    const qz = q[2];
+    const qw = q[3];
+    // calculate quat * vec
+    const ix = qw * x + qy * z - qz * y;
+    const iy = qw * y + qz * x - qx * z;
+    const iz = qw * z + qx * y - qy * x;
+    const iw = -qx * x - qy * y - qz * z;
+    // calculate result * inverse quat
+    out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;
+    out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;
+    out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+    out[3] = a[3];
+    return out;
+}
+/**
+ * Perform some operation over an array of vec4s.
+ *
+ * @param {Array} a the array of vectors to iterate over
+ * @param {Number} stride Number of elements between the start of each vec4. If 0 assumes tightly packed
+ * @param {Number} offset Number of elements to skip at the beginning of the array
+ * @param {Number} count Number of vec4s to iterate over. If 0 iterates over entire array
+ * @param {Function} fn Function to call for each vector in the array
+ * @param {Object} [arg] additional argument to pass to fn
+ * @returns {Array} a
+ * @function
+ */
+((function () {
+    const vec = create$1();
+    return function (a, stride, offset, count, fn, arg) {
+        let i;
+        let l;
+        if (!stride) {
+            stride = 4;
+        }
+        if (!offset) {
+            offset = 0;
+        }
+        if (count) {
+            l = Math.min(count * stride + offset, a.length);
+        }
+        else {
+            l = a.length;
+        }
+        for (i = offset; i < l; i += stride) {
+            vec[0] = a[i];
+            vec[1] = a[i + 1];
+            vec[2] = a[i + 2];
+            vec[3] = a[i + 3];
+            fn(vec, vec, arg);
+            a[i] = vec[0];
+            a[i + 1] = vec[1];
+            a[i + 2] = vec[2];
+            a[i + 3] = vec[3];
+        }
+        return a;
+    };
+}))();
+
+// @eslint-disable
+// const glMatrix: {EPSILON = 0.000001};
+/**
+ * Quaternion in the format XYZW
+ * @module quat
+ */
+/**
+ * Creates a new identity quat
+ *
+ * @returns {quat} a new quaternion
+ */
+function create() {
+    const out = new ARRAY_TYPE(4);
+    if (ARRAY_TYPE != Float32Array) {
+        out[0] = 0;
+        out[1] = 0;
+        out[2] = 0;
+    }
+    out[3] = 1;
+    return out;
+}
+/**
+ * Set a quat to the identity quaternion
+ *
+ * @param {quat} out the receiving quaternion
+ * @returns {quat} out
+ */
+function identity(out) {
+    out[0] = 0;
+    out[1] = 0;
+    out[2] = 0;
+    out[3] = 1;
+    return out;
+}
+/**
+ * Sets a quat from the given angle and rotation axis,
+ * then returns it.
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {ReadonlyVec3} axis the axis around which to rotate
+ * @param {Number} rad the angle in radians
+ * @returns {quat} out
+ **/
+function setAxisAngle(out, axis, rad) {
+    rad = rad * 0.5;
+    const s = Math.sin(rad);
+    out[0] = s * axis[0];
+    out[1] = s * axis[1];
+    out[2] = s * axis[2];
+    out[3] = Math.cos(rad);
+    return out;
+}
+/**
+ * Multiplies two quat's
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {ReadonlyQuat} a the first operand
+ * @param {ReadonlyQuat} b the second operand
+ * @returns {quat} out
+ */
+function multiply(out, a, b) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const aw = a[3];
+    const bx = b[0];
+    const by = b[1];
+    const bz = b[2];
+    const bw = b[3];
+    out[0] = ax * bw + aw * bx + ay * bz - az * by;
+    out[1] = ay * bw + aw * by + az * bx - ax * bz;
+    out[2] = az * bw + aw * bz + ax * by - ay * bx;
+    out[3] = aw * bw - ax * bx - ay * by - az * bz;
+    return out;
+}
+/**
+ * Rotates a quaternion by the given angle about the X axis
+ *
+ * @param {quat} out quat receiving operation result
+ * @param {ReadonlyQuat} a quat to rotate
+ * @param {number} rad angle (in radians) to rotate
+ * @returns {quat} out
+ */
+function rotateX(out, a, rad) {
+    rad *= 0.5;
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const aw = a[3];
+    const bx = Math.sin(rad);
+    const bw = Math.cos(rad);
+    out[0] = ax * bw + aw * bx;
+    out[1] = ay * bw + az * bx;
+    out[2] = az * bw - ay * bx;
+    out[3] = aw * bw - ax * bx;
+    return out;
+}
+/**
+ * Rotates a quaternion by the given angle about the Y axis
+ *
+ * @param {quat} out quat receiving operation result
+ * @param {ReadonlyQuat} a quat to rotate
+ * @param {number} rad angle (in radians) to rotate
+ * @returns {quat} out
+ */
+function rotateY(out, a, rad) {
+    rad *= 0.5;
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const aw = a[3];
+    const by = Math.sin(rad);
+    const bw = Math.cos(rad);
+    out[0] = ax * bw - az * by;
+    out[1] = ay * bw + aw * by;
+    out[2] = az * bw + ax * by;
+    out[3] = aw * bw - ay * by;
+    return out;
+}
+/**
+ * Rotates a quaternion by the given angle about the Z axis
+ *
+ * @param {quat} out quat receiving operation result
+ * @param {ReadonlyQuat} a quat to rotate
+ * @param {number} rad angle (in radians) to rotate
+ * @returns {quat} out
+ */
+function rotateZ(out, a, rad) {
+    rad *= 0.5;
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const aw = a[3];
+    const bz = Math.sin(rad);
+    const bw = Math.cos(rad);
+    out[0] = ax * bw + ay * bz;
+    out[1] = ay * bw - ax * bz;
+    out[2] = az * bw + aw * bz;
+    out[3] = aw * bw - az * bz;
+    return out;
+}
+/**
+ * Calculates the W component of a quat from the X, Y, and Z components.
+ * Assumes that quaternion is 1 unit in length.
+ * Any existing W component will be ignored.
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {ReadonlyQuat} a quat to calculate W component of
+ * @returns {quat} out
+ */
+function calculateW(out, a) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    out[0] = x;
+    out[1] = y;
+    out[2] = z;
+    out[3] = Math.sqrt(Math.abs(1.0 - x * x - y * y - z * z));
+    return out;
+}
+/**
+ * Performs a spherical linear interpolation between two quat
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {ReadonlyQuat} a the first operand
+ * @param {ReadonlyQuat} b the second operand
+ * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
+ * @returns {quat} out
+ */
+function slerp(out, a, b, t) {
+    // benchmarks:
+    //    http://jsperf.com/quaternion-slerp-implementations
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
+    const aw = a[3];
+    let bx = b[0];
+    let by = b[1];
+    let bz = b[2];
+    let bw = b[3];
+    let cosom;
+    let omega;
+    let scale0;
+    let scale1;
+    let sinom;
+    // calc cosine
+    cosom = ax * bx + ay * by + az * bz + aw * bw;
+    // adjust signs (if necessary)
+    if (cosom < 0.0) {
+        cosom = -cosom;
+        bx = -bx;
+        by = -by;
+        bz = -bz;
+        bw = -bw;
+    }
+    // calculate coefficients
+    if (1.0 - cosom > EPSILON) {
+        // standard case (slerp)
+        omega = Math.acos(cosom);
+        sinom = Math.sin(omega);
+        scale0 = Math.sin((1.0 - t) * omega) / sinom;
+        scale1 = Math.sin(t * omega) / sinom;
+    }
+    else {
+        // "from" and "to" quaternions are very close
+        //  ... so we can do a linear interpolation
+        scale0 = 1.0 - t;
+        scale1 = t;
+    }
+    // calculate final values
+    out[0] = scale0 * ax + scale1 * bx;
+    out[1] = scale0 * ay + scale1 * by;
+    out[2] = scale0 * az + scale1 * bz;
+    out[3] = scale0 * aw + scale1 * bw;
+    return out;
+}
+/**
+ * Generates a random unit quaternion
+ *
+ * @param {quat} out the receiving quaternion
+ * @returns {quat} out
+ */
+// export function random(out) {
+//   // Implementation of http://planning.cs.uiuc.edu/node198.html
+//   // TODO: Calling random 3 times is probably not the fastest solution
+//   let u1 = glMatrix.RANDOM();
+//   let u2 = glMatrix.RANDOM();
+//   let u3 = glMatrix.RANDOM();
+//   let sqrt1MinusU1 = Math.sqrt(1 - u1);
+//   let sqrtU1 = Math.sqrt(u1);
+//   out[0] = sqrt1MinusU1 * Math.sin(2.0 * Math.PI * u2);
+//   out[1] = sqrt1MinusU1 * Math.cos(2.0 * Math.PI * u2);
+//   out[2] = sqrtU1 * Math.sin(2.0 * Math.PI * u3);
+//   out[3] = sqrtU1 * Math.cos(2.0 * Math.PI * u3);
+//   return out;
+// }
+/**
+ * Calculates the inverse of a quat
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {ReadonlyQuat} a quat to calculate inverse of
+ * @returns {quat} out
+ */
+function invert(out, a) {
+    const a0 = a[0];
+    const a1 = a[1];
+    const a2 = a[2];
+    const a3 = a[3];
+    const dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;
+    const invDot = dot ? 1.0 / dot : 0;
+    // TODO: Would be faster to return [0,0,0,0] immediately if dot == 0
+    out[0] = -a0 * invDot;
+    out[1] = -a1 * invDot;
+    out[2] = -a2 * invDot;
+    out[3] = a3 * invDot;
+    return out;
+}
+/**
+ * Calculates the conjugate of a quat
+ * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {ReadonlyQuat} a quat to calculate conjugate of
+ * @returns {quat} out
+ */
+function conjugate(out, a) {
+    out[0] = -a[0];
+    out[1] = -a[1];
+    out[2] = -a[2];
+    out[3] = a[3];
+    return out;
+}
+/**
+ * Creates a quaternion from the given 3x3 rotation matrix.
+ *
+ * NOTE: The resultant quaternion is not normalized, so you should be sure
+ * to renormalize the quaternion yourself where necessary.
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {ReadonlyMat3} m rotation matrix
+ * @returns {quat} out
+ * @function
+ */
+function fromMat3(out, m) {
+    // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes
+    // article "Quaternion Calculus and Fast Animation".
+    const fTrace = m[0] + m[4] + m[8];
+    let fRoot;
+    if (fTrace > 0.0) {
+        // |w| > 1/2, may as well choose w > 1/2
+        fRoot = Math.sqrt(fTrace + 1.0); // 2w
+        out[3] = 0.5 * fRoot;
+        fRoot = 0.5 / fRoot; // 1/(4w)
+        out[0] = (m[5] - m[7]) * fRoot;
+        out[1] = (m[6] - m[2]) * fRoot;
+        out[2] = (m[1] - m[3]) * fRoot;
+    }
+    else {
+        // |w| <= 1/2
+        let i = 0;
+        if (m[4] > m[0])
+            i = 1;
+        if (m[8] > m[i * 3 + i])
+            i = 2;
+        const j = (i + 1) % 3;
+        const k = (i + 2) % 3;
+        fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1.0);
+        out[i] = 0.5 * fRoot;
+        fRoot = 0.5 / fRoot;
+        out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;
+        out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;
+        out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;
+    }
+    return out;
+}
+/**
+ * Adds two quat's
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {ReadonlyQuat} a the first operand
+ * @param {ReadonlyQuat} b the second operand
+ * @returns {quat} out
+ * @function
+ */
+const add = add$1;
+/**
+ * Scales a quat by a scalar number
+ *
+ * @param {quat} out the receiving vector
+ * @param {ReadonlyQuat} a the vector to scale
+ * @param {Number} b amount to scale the vector by
+ * @returns {quat} out
+ * @function
+ */
+const scale = scale$1;
+/**
+ * Calculates the dot product of two quat's
+ *
+ * @param {ReadonlyQuat} a the first operand
+ * @param {ReadonlyQuat} b the second operand
+ * @returns {Number} dot product of a and b
+ * @function
+ */
+const dot = dot$1;
+/**
+ * Performs a linear interpolation between two quat's
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {ReadonlyQuat} a the first operand
+ * @param {ReadonlyQuat} b the second operand
+ * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
+ * @returns {quat} out
+ * @function
+ */
+const lerp = lerp$1;
+/**
+ * Calculates the length of a quat
+ *
+ * @param {ReadonlyQuat} a vector to calculate length of
+ * @returns {Number} length of a
+ */
+const length = length$1;
+/**
+ * Calculates the squared length of a quat
+ *
+ * @param {ReadonlyQuat} a vector to calculate squared length of
+ * @returns {Number} squared length of a
+ * @function
+ */
+const squaredLength = squaredLength$1;
+/**
+ * Normalize a quat
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {ReadonlyQuat} a quaternion to normalize
+ * @returns {quat} out
+ * @function
+ */
+const normalize = normalize$1;
+/**
+ * Sets a quaternion to represent the shortest rotation from one
+ * vector to another.
+ *
+ * Both vectors are assumed to be unit length.
+ *
+ * @param {quat} out the receiving quaternion.
+ * @param {ReadonlyVec3} a the initial vector
+ * @param {ReadonlyVec3} b the destination vector
+ * @returns {quat} out
+ */
+const rotationTo = (function () {
+    const tmpvec3 = create$3();
+    const xUnitVec3 = fromValues(1, 0, 0);
+    const yUnitVec3 = fromValues(0, 1, 0);
+    return function (out, a, b) {
+        const dot = dot$2(a, b);
+        if (dot < -0.999999) {
+            cross(tmpvec3, xUnitVec3, a);
+            if (len(tmpvec3) < 0.000001)
+                cross(tmpvec3, yUnitVec3, a);
+            normalize$2(tmpvec3, tmpvec3);
+            setAxisAngle(out, tmpvec3, Math.PI);
+            return out;
+        }
+        else if (dot > 0.999999) {
+            out[0] = 0;
+            out[1] = 0;
+            out[2] = 0;
+            out[3] = 1;
+            return out;
+        }
+        cross(tmpvec3, a, b);
+        out[0] = tmpvec3[0];
+        out[1] = tmpvec3[1];
+        out[2] = tmpvec3[2];
+        out[3] = 1 + dot;
+        return normalize(out, out);
+    };
+})();
+/**
+ * Performs a spherical linear interpolation with two control points
+ *
+ * @param {quat} out the receiving quaternion
+ * @param {ReadonlyQuat} a the first operand
+ * @param {ReadonlyQuat} b the second operand
+ * @param {ReadonlyQuat} c the third operand
+ * @param {ReadonlyQuat} d the fourth operand
+ * @param {Number} t interpolation amount, in the range [0-1], between the two inputs
+ * @returns {quat} out
+ */
+((function () {
+    const temp1 = create();
+    const temp2 = create();
+    return function (out, a, b, c, d, t) {
+        slerp(temp1, a, d, t);
+        slerp(temp2, b, c, t);
+        slerp(out, temp1, temp2, 2 * t * (1 - t));
+        return out;
+    };
+}))();
+/**
+ * Sets the specified quaternion with values corresponding to the given
+ * axes. Each axis is a vec3 and is expected to be unit length and
+ * perpendicular to all other specified axes.
+ *
+ * @param {ReadonlyVec3} view  the vector representing the viewing direction
+ * @param {ReadonlyVec3} right the vector representing the local "right" direction
+ * @param {ReadonlyVec3} up    the vector representing the local "up" direction
+ * @returns {quat} out
+ */
+((function () {
+    const matr = create$2();
+    return function (out, view, right, up) {
+        matr[0] = right[0];
+        matr[3] = right[1];
+        matr[6] = right[2];
+        matr[1] = up[0];
+        matr[4] = up[1];
+        matr[7] = up[2];
+        matr[2] = -view[0];
+        matr[5] = -view[1];
+        matr[8] = -view[2];
+        return normalize(out, fromMat3(out, matr));
+    };
+}))();
+
+// math.gl
+const IDENTITY_QUATERNION = [0, 0, 0, 1];
+class Quaternion extends MathArray {
+    constructor(x = 0, y = 0, z = 0, w = 1) {
+        // PERF NOTE: initialize elements as double precision numbers
+        super(-0, -0, -0, -0);
+        // eslint-disable-next-line prefer-rest-params
+        if (Array.isArray(x) && arguments.length === 1) {
+            this.copy(x);
+        }
+        else {
+            this.set(x, y, z, w);
+        }
+    }
+    copy(array) {
+        this[0] = array[0];
+        this[1] = array[1];
+        this[2] = array[2];
+        this[3] = array[3];
+        return this.check();
+    }
+    set(x, y, z, w) {
+        this[0] = x;
+        this[1] = y;
+        this[2] = z;
+        this[3] = w;
+        return this.check();
+    }
+    fromObject(object) {
+        this[0] = object.x;
+        this[1] = object.y;
+        this[2] = object.z;
+        this[3] = object.w;
+        return this.check();
+    }
+    /**
+     * Creates a quaternion from the given 3x3 rotation matrix.
+     * NOTE: The resultant quaternion is not normalized, so you should
+     * be sure to renormalize the quaternion yourself where necessary.
+     * @param m
+     * @returns
+     */
+    fromMatrix3(m) {
+        fromMat3(this, m);
+        return this.check();
+    }
+    fromAxisRotation(axis, rad) {
+        setAxisAngle(this, axis, rad);
+        return this.check();
+    }
+    /** Set a quat to the identity quaternion */
+    identity() {
+        identity(this);
+        return this.check();
+    }
+    // Set the components of a quat to the given values
+    // set(i, j, k, l) {
+    //   quat_set(this, i, j, k, l);
+    //   return this.check();
+    // }
+    // Sets a quat from the given angle and rotation axis, then returns it.
+    setAxisAngle(axis, rad) {
+        return this.fromAxisRotation(axis, rad);
+    }
+    // Getters/setters
+    get ELEMENTS() {
+        return 4;
+    }
+    get x() {
+        return this[0];
+    }
+    set x(value) {
+        this[0] = checkNumber(value);
+    }
+    get y() {
+        return this[1];
+    }
+    set y(value) {
+        this[1] = checkNumber(value);
+    }
+    get z() {
+        return this[2];
+    }
+    set z(value) {
+        this[2] = checkNumber(value);
+    }
+    get w() {
+        return this[3];
+    }
+    set w(value) {
+        this[3] = checkNumber(value);
+    }
+    // Calculates the length of a quat
+    len() {
+        return length(this);
+    }
+    // Calculates the squared length of a quat
+    lengthSquared() {
+        return squaredLength(this);
+    }
+    // Calculates the dot product of two quat's
+    // @return {Number}
+    dot(a) {
+        return dot(this, a);
+    }
+    // Gets the rotation axis and angle for a given quaternion.
+    // If a quaternion is created with setAxisAngle, this method will
+    // return the same values as providied in the original parameter
+    // list OR functionally equivalent values.
+    // Example: The quaternion formed by axis [0, 0, 1] and angle -90
+    // is the same as the quaternion formed by [0, 0, 1] and 270.
+    // This method favors the latter.
+    // @return {{[x,y,z], Number}}
+    // getAxisAngle() {
+    //   const axis = [];
+    // //   const angle = quat_getAxisAngle(axis, this);
+    //   return {axis, angle};
+    // }
+    // MODIFIERS
+    // Sets a quaternion to represent the shortest rotation from one vector
+    // to another. Both vectors are assumed to be unit length.
+    rotationTo(vectorA, vectorB) {
+        rotationTo(this, vectorA, vectorB);
+        return this.check();
+    }
+    // Sets the specified quaternion with values corresponding to the given axes.
+    // Each axis is a vec3 and is expected to be unit length and perpendicular
+    // to all other specified axes.
+    // setAxes() {
+    //   Number
+    // }
+    // Performs a spherical linear interpolation with two control points
+    // sqlerp() {
+    //   Number;
+    // }
+    // Adds two quat's
+    add(a) {
+        add(this, this, a);
+        return this.check();
+    }
+    // Calculates the W component of a quat from the X, Y, and Z components.
+    // Any existing W component will be ignored.
+    calculateW() {
+        calculateW(this, this);
+        return this.check();
+    }
+    // Calculates the conjugate of a quat If the quaternion is normalized,
+    // this function is faster than quat_invert and produces the same result.
+    conjugate() {
+        conjugate(this, this);
+        return this.check();
+    }
+    // Calculates the inverse of a quat
+    invert() {
+        invert(this, this);
+        return this.check();
+    }
+    // Performs a linear interpolation between two quat's
+    lerp(a, b, t) {
+        if (t === undefined) {
+            return this.lerp(this, a, b);
+        }
+        lerp(this, a, b, t);
+        return this.check();
+    }
+    // Multiplies two quat's
+    multiplyRight(a) {
+        multiply(this, this, a);
+        return this.check();
+    }
+    multiplyLeft(a) {
+        multiply(this, a, this);
+        return this.check();
+    }
+    // Normalize a quat
+    normalize() {
+        // Handle 0 case
+        const length = this.len();
+        const l = length > 0 ? 1 / length : 0;
+        this[0] = this[0] * l;
+        this[1] = this[1] * l;
+        this[2] = this[2] * l;
+        this[3] = this[3] * l;
+        // Set to [0, 0, 0, 1] if length is 0
+        if (length === 0) {
+            this[3] = 1;
+        }
+        return this.check();
+    }
+    // Rotates a quaternion by the given angle about the X axis
+    rotateX(rad) {
+        rotateX(this, this, rad);
+        return this.check();
+    }
+    // Rotates a quaternion by the given angle about the Y axis
+    rotateY(rad) {
+        rotateY(this, this, rad);
+        return this.check();
+    }
+    // Rotates a quaternion by the given angle about the Z axis
+    rotateZ(rad) {
+        rotateZ(this, this, rad);
+        return this.check();
+    }
+    // Scales a quat by a scalar number
+    scale(b) {
+        scale(this, this, b);
+        return this.check();
+    }
+    // Performs a spherical linear interpolation between two quat
+    slerp(arg0, arg1, arg2) {
+        let start;
+        let target;
+        let ratio;
+        // eslint-disable-next-line prefer-rest-params
+        switch (arguments.length) {
+            case 1: // Deprecated signature ({start, target, ratio})
+                // eslint-disable-next-line prefer-rest-params
+                ({
+                    start = IDENTITY_QUATERNION,
+                    target,
+                    ratio
+                } = arg0);
+                break;
+            case 2: // THREE.js compatibility signature (target, ration)
+                start = this; // eslint-disable-line
+                target = arg0;
+                ratio = arg1;
+                break;
+            default:
+                // Default signature: (start, target, ratio)
+                start = arg0;
+                target = arg1;
+                ratio = arg2;
+        }
+        slerp(this, start, target, ratio);
+        return this.check();
+    }
+    transformVector4(vector, result = new Vector4()) {
+        transformQuat(result, vector, this);
+        return checkVector(result, 4);
+    }
+    // THREE.js Math API compatibility
+    lengthSq() {
+        return this.lengthSquared();
+    }
+    setFromAxisAngle(axis, rad) {
+        return this.setAxisAngle(axis, rad);
+    }
+    premultiply(a) {
+        return this.multiplyLeft(a);
+    }
+    multiply(a) {
+        return this.multiplyRight(a);
+    }
+}
+
+// math.gl
+// Internal constants
+const ERR_UNKNOWN_ORDER = 'Unknown Euler angle order';
+const ALMOST_ONE = 0.99999;
+// eslint-disable-next-line no-shadow
+var RotationOrder;
+(function (RotationOrder) {
+    RotationOrder[RotationOrder["ZYX"] = 0] = "ZYX";
+    RotationOrder[RotationOrder["YXZ"] = 1] = "YXZ";
+    RotationOrder[RotationOrder["XZY"] = 2] = "XZY";
+    RotationOrder[RotationOrder["ZXY"] = 3] = "ZXY";
+    RotationOrder[RotationOrder["YZX"] = 4] = "YZX";
+    RotationOrder[RotationOrder["XYZ"] = 5] = "XYZ";
+})(RotationOrder || (RotationOrder = {}));
+class Euler extends MathArray {
+    // Constants
+    static get ZYX() {
+        return RotationOrder.ZYX;
+    }
+    static get YXZ() {
+        return RotationOrder.YXZ;
+    }
+    static get XZY() {
+        return RotationOrder.XZY;
+    }
+    static get ZXY() {
+        return RotationOrder.ZXY;
+    }
+    static get YZX() {
+        return RotationOrder.YZX;
+    }
+    static get XYZ() {
+        return RotationOrder.XYZ;
+    }
+    static get RollPitchYaw() {
+        return RotationOrder.ZYX;
+    }
+    static get DefaultOrder() {
+        return RotationOrder.ZYX;
+    }
+    static get RotationOrders() {
+        return RotationOrder;
+    }
+    static rotationOrder(order) {
+        return RotationOrder[order];
+    }
+    get ELEMENTS() {
+        return 4;
+    }
+    /**
+     * @class
+     * @param {Number | Number[]} x
+     * @param {Number=} [y]
+     * @param {Number=} [z]
+     * @param {Number=} [order]
+     */
+    constructor(x = 0, y = 0, z = 0, order = Euler.DefaultOrder) {
+        // PERF NOTE: initialize elements as double precision numbers
+        super(-0, -0, -0, -0);
+        // eslint-disable-next-line prefer-rest-params
+        if (arguments.length > 0 && Array.isArray(arguments[0])) {
+            // @ts-expect-error
+            // eslint-disable-next-line prefer-rest-params
+            this.fromVector3(...arguments);
+        }
+        else {
+            this.set(x, y, z, order);
+        }
+    }
+    fromQuaternion(quaternion) {
+        const [x, y, z, w] = quaternion;
+        const ysqr = y * y;
+        const t0 = -2 * (ysqr + z * z) + 1;
+        const t1 = +2 * (x * y + w * z);
+        let t2 = -2 * (x * z - w * y);
+        const t3 = +2 * (y * z + w * x);
+        const t4 = -2 * (x * x + ysqr) + 1;
+        t2 = t2 > 1 ? 1 : t2;
+        t2 = t2 < -1 ? -1 : t2;
+        const roll = Math.atan2(t3, t4);
+        const pitch = Math.asin(t2);
+        const yaw = Math.atan2(t1, t0);
+        return this.set(roll, pitch, yaw, Euler.RollPitchYaw);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    fromObject(object) {
+        throw new Error('not implemented');
+        //  return this.set(object.x, object.y, object.z, object.order);
+    }
+    // fromQuaternion(q, order) {
+    //   this._fromRotationMat[-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
+    //   return this.check();
+    // }
+    // If copied array does contain fourth element, preserves currently set order
+    copy(array) {
+        this[0] = array[0];
+        this[1] = array[1];
+        this[2] = array[2];
+        // @ts-expect-error
+        this[3] = Number.isFinite(array[3]) || this.order;
+        return this.check();
+    }
+    // Sets the three angles, and optionally sets the rotation order
+    // If order is not specified, preserves currently set order
+    set(x = 0, y = 0, z = 0, order) {
+        this[0] = x;
+        this[1] = y;
+        this[2] = z;
+        this[3] = Number.isFinite(order) ? order : this[3];
+        return this.check();
+    }
+    validate() {
+        return (validateOrder(this[3]) &&
+            Number.isFinite(this[0]) &&
+            Number.isFinite(this[1]) &&
+            Number.isFinite(this[2]));
+    }
+    // Does not copy the orientation element
+    toArray(array = [], offset = 0) {
+        array[offset] = this[0];
+        array[offset + 1] = this[1];
+        array[offset + 2] = this[2];
+        return array;
+    }
+    // Copies the orientation element
+    toArray4(array = [], offset = 0) {
+        array[offset] = this[0];
+        array[offset + 1] = this[1];
+        array[offset + 2] = this[2];
+        array[offset + 3] = this[3];
+        return array;
+    }
+    toVector3(result = [-0, -0, -0]) {
+        result[0] = this[0];
+        result[1] = this[1];
+        result[2] = this[2];
+        return result;
+    }
+    /* eslint-disable no-multi-spaces, brace-style, no-return-assign */
+    // x, y, z angle notation (note: only corresponds to axis in XYZ orientation)
+    get x() {
+        return this[0];
+    }
+    set x(value) {
+        this[0] = checkNumber(value);
+    }
+    get y() {
+        return this[1];
+    }
+    set y(value) {
+        this[1] = checkNumber(value);
+    }
+    get z() {
+        return this[2];
+    }
+    set z(value) {
+        this[2] = checkNumber(value);
+    }
+    // alpha, beta, gamma angle notation
+    get alpha() {
+        return this[0];
+    }
+    set alpha(value) {
+        this[0] = checkNumber(value);
+    }
+    get beta() {
+        return this[1];
+    }
+    set beta(value) {
+        this[1] = checkNumber(value);
+    }
+    get gamma() {
+        return this[2];
+    }
+    set gamma(value) {
+        this[2] = checkNumber(value);
+    }
+    // phi, theta, psi angle notation
+    get phi() {
+        return this[0];
+    }
+    set phi(value) {
+        this[0] = checkNumber(value);
+    }
+    get theta() {
+        return this[1];
+    }
+    set theta(value) {
+        this[1] = checkNumber(value);
+    }
+    get psi() {
+        return this[2];
+    }
+    set psi(value) {
+        this[2] = checkNumber(value);
+    }
+    // roll, pitch, yaw angle notation
+    get roll() {
+        return this[0];
+    }
+    set roll(value) {
+        this[0] = checkNumber(value);
+    }
+    get pitch() {
+        return this[1];
+    }
+    set pitch(value) {
+        this[1] = checkNumber(value);
+    }
+    get yaw() {
+        return this[2];
+    }
+    set yaw(value) {
+        this[2] = checkNumber(value);
+    }
+    // rotation order, in all three angle notations
+    get order() {
+        return this[3];
+    }
+    set order(value) {
+        this[3] = checkOrder(value);
+    }
+    // Constructors
+    fromVector3(v, order) {
+        return this.set(v[0], v[1], v[2], Number.isFinite(order) ? order : this[3]);
+    }
+    // TODO - with and without 4th element
+    fromArray(array, offset = 0) {
+        this[0] = array[0 + offset];
+        this[1] = array[1 + offset];
+        this[2] = array[2 + offset];
+        if (array[3] !== undefined) {
+            this[3] = array[3];
+        }
+        return this.check();
+    }
+    // Common ZYX rotation order
+    fromRollPitchYaw(roll, pitch, yaw) {
+        return this.set(roll, pitch, yaw, RotationOrder.ZYX);
+    }
+    fromRotationMatrix(m, order = Euler.DefaultOrder) {
+        this._fromRotationMatrix(m, order);
+        return this.check();
+    }
+    // ACCESSORS
+    getRotationMatrix(m) {
+        return this._getRotationMatrix(m);
+    }
+    // TODO - move to Quaternion
+    getQuaternion() {
+        const q = new Quaternion();
+        switch (this[3]) {
+            case RotationOrder.XYZ:
+                return q.rotateX(this[0]).rotateY(this[1]).rotateZ(this[2]);
+            case RotationOrder.YXZ:
+                return q.rotateY(this[0]).rotateX(this[1]).rotateZ(this[2]);
+            case RotationOrder.ZXY:
+                return q.rotateZ(this[0]).rotateX(this[1]).rotateY(this[2]);
+            case RotationOrder.ZYX:
+                return q.rotateZ(this[0]).rotateY(this[1]).rotateX(this[2]);
+            case RotationOrder.YZX:
+                return q.rotateY(this[0]).rotateZ(this[1]).rotateX(this[2]);
+            case RotationOrder.XZY:
+                return q.rotateX(this[0]).rotateZ(this[1]).rotateY(this[2]);
+            default:
+                throw new Error(ERR_UNKNOWN_ORDER);
+        }
+    }
+    // INTERNAL METHODS
+    // Conversion from Euler to rotation matrix and from matrix to Euler
+    // Adapted from three.js under MIT license
+    // // WARNING: this discards revolution information -bhouston
+    // reorder(newOrder) {
+    //   const q = new Quaternion().setFromEuler(this);
+    //   return this.setFromQuaternion(q, newOrder);
+    /* eslint-disable complexity, max-statements, one-var */
+    _fromRotationMatrix(m, order = Euler.DefaultOrder) {
+        // assumes the upper 3x3 of m is a pure rotation matrix (i.e, unscaled)
+        const m11 = m[0], m12 = m[4], m13 = m[8];
+        const m21 = m[1], m22 = m[5], m23 = m[9];
+        const m31 = m[2], m32 = m[6], m33 = m[10];
+        order = order || this[3];
+        switch (order) {
+            case Euler.XYZ:
+                this[1] = Math.asin(clamp(m13, -1, 1));
+                if (Math.abs(m13) < ALMOST_ONE) {
+                    this[0] = Math.atan2(-m23, m33);
+                    this[2] = Math.atan2(-m12, m11);
+                }
+                else {
+                    this[0] = Math.atan2(m32, m22);
+                    this[2] = 0;
+                }
+                break;
+            case Euler.YXZ:
+                this[0] = Math.asin(-clamp(m23, -1, 1));
+                if (Math.abs(m23) < ALMOST_ONE) {
+                    this[1] = Math.atan2(m13, m33);
+                    this[2] = Math.atan2(m21, m22);
+                }
+                else {
+                    this[1] = Math.atan2(-m31, m11);
+                    this[2] = 0;
+                }
+                break;
+            case Euler.ZXY:
+                this[0] = Math.asin(clamp(m32, -1, 1));
+                if (Math.abs(m32) < ALMOST_ONE) {
+                    this[1] = Math.atan2(-m31, m33);
+                    this[2] = Math.atan2(-m12, m22);
+                }
+                else {
+                    this[1] = 0;
+                    this[2] = Math.atan2(m21, m11);
+                }
+                break;
+            case Euler.ZYX:
+                this[1] = Math.asin(-clamp(m31, -1, 1));
+                if (Math.abs(m31) < ALMOST_ONE) {
+                    this[0] = Math.atan2(m32, m33);
+                    this[2] = Math.atan2(m21, m11);
+                }
+                else {
+                    this[0] = 0;
+                    this[2] = Math.atan2(-m12, m22);
+                }
+                break;
+            case Euler.YZX:
+                this[2] = Math.asin(clamp(m21, -1, 1));
+                if (Math.abs(m21) < ALMOST_ONE) {
+                    this[0] = Math.atan2(-m23, m22);
+                    this[1] = Math.atan2(-m31, m11);
+                }
+                else {
+                    this[0] = 0;
+                    this[1] = Math.atan2(m13, m33);
+                }
+                break;
+            case Euler.XZY:
+                this[2] = Math.asin(-clamp(m12, -1, 1));
+                if (Math.abs(m12) < ALMOST_ONE) {
+                    this[0] = Math.atan2(m32, m22);
+                    this[1] = Math.atan2(m13, m11);
+                }
+                else {
+                    this[0] = Math.atan2(-m23, m33);
+                    this[1] = 0;
+                }
+                break;
+            default:
+                throw new Error(ERR_UNKNOWN_ORDER);
+        }
+        this[3] = order;
+        return this;
+    }
+    _getRotationMatrix(result) {
+        const te = result || [-0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0, -0];
+        const x = this.x, y = this.y, z = this.z;
+        const a = Math.cos(x);
+        const c = Math.cos(y);
+        const e = Math.cos(z);
+        const b = Math.sin(x);
+        const d = Math.sin(y);
+        const f = Math.sin(z);
+        switch (this[3]) {
+            case Euler.XYZ: {
+                const ae = a * e, af = a * f, be = b * e, bf = b * f;
+                te[0] = c * e;
+                te[4] = -c * f;
+                te[8] = d;
+                te[1] = af + be * d;
+                te[5] = ae - bf * d;
+                te[9] = -b * c;
+                te[2] = bf - ae * d;
+                te[6] = be + af * d;
+                te[10] = a * c;
+                break;
+            }
+            case Euler.YXZ: {
+                const ce = c * e, cf = c * f, de = d * e, df = d * f;
+                te[0] = ce + df * b;
+                te[4] = de * b - cf;
+                te[8] = a * d;
+                te[1] = a * f;
+                te[5] = a * e;
+                te[9] = -b;
+                te[2] = cf * b - de;
+                te[6] = df + ce * b;
+                te[10] = a * c;
+                break;
+            }
+            case Euler.ZXY: {
+                const ce = c * e, cf = c * f, de = d * e, df = d * f;
+                te[0] = ce - df * b;
+                te[4] = -a * f;
+                te[8] = de + cf * b;
+                te[1] = cf + de * b;
+                te[5] = a * e;
+                te[9] = df - ce * b;
+                te[2] = -a * d;
+                te[6] = b;
+                te[10] = a * c;
+                break;
+            }
+            case Euler.ZYX: {
+                const ae = a * e, af = a * f, be = b * e, bf = b * f;
+                te[0] = c * e;
+                te[4] = be * d - af;
+                te[8] = ae * d + bf;
+                te[1] = c * f;
+                te[5] = bf * d + ae;
+                te[9] = af * d - be;
+                te[2] = -d;
+                te[6] = b * c;
+                te[10] = a * c;
+                break;
+            }
+            case Euler.YZX: {
+                const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
+                te[0] = c * e;
+                te[4] = bd - ac * f;
+                te[8] = bc * f + ad;
+                te[1] = f;
+                te[5] = a * e;
+                te[9] = -b * e;
+                te[2] = -d * e;
+                te[6] = ad * f + bc;
+                te[10] = ac - bd * f;
+                break;
+            }
+            case Euler.XZY: {
+                const ac = a * c, ad = a * d, bc = b * c, bd = b * d;
+                te[0] = c * e;
+                te[4] = -f;
+                te[8] = d * e;
+                te[1] = ac * f + bd;
+                te[5] = a * e;
+                te[9] = ad * f - bc;
+                te[2] = bc * f - ad;
+                te[6] = b * e;
+                te[10] = bd * f + ac;
+                break;
+            }
+            default:
+                throw new Error(ERR_UNKNOWN_ORDER);
+        }
+        // last column
+        te[3] = 0;
+        te[7] = 0;
+        te[11] = 0;
+        // bottom row
+        te[12] = 0;
+        te[13] = 0;
+        te[14] = 0;
+        te[15] = 1;
+        return te;
+    }
+    toQuaternion() {
+        // Abbreviations for the various angular functions
+        const cy = Math.cos(this.yaw * 0.5);
+        const sy = Math.sin(this.yaw * 0.5);
+        const cr = Math.cos(this.roll * 0.5);
+        const sr = Math.sin(this.roll * 0.5);
+        const cp = Math.cos(this.pitch * 0.5);
+        const sp = Math.sin(this.pitch * 0.5);
+        const w = cy * cr * cp + sy * sr * sp;
+        const x = cy * sr * cp - sy * cr * sp;
+        const y = cy * cr * sp + sy * sr * cp;
+        const z = sy * cr * cp - cy * sr * sp;
+        return new Quaternion(x, y, z, w);
+    }
+}
+// HELPER FUNCTIONS
+function validateOrder(value) {
+    return value >= 0 && value < 6;
+}
+function checkOrder(value) {
+    if (value < 0 && value >= 6) {
+        throw new Error(ERR_UNKNOWN_ORDER);
+    }
+    return value;
+}
+
+/**
+ * 变换模块，提供变换相关的类和功能
+ * 用于表示对象的位置、旋转和缩放信息
+ */
+/**
+ * 变换基类，用于表示对象的位置、旋转和缩放
+ */
+class OTransform {
+    /**
+     * 构造函数
+     * @param position 位置向量
+     * @param rotation 旋转欧拉角
+     * @param scale 缩放向量
+     */
+    constructor(position, rotation, scale) {
+        this.position = position;
+        this.rotation = rotation;
+        this.scale = scale;
+    }
+    /**
+     * 创建默认的变换对象
+     * @param params 可选参数对象
+     * @param params.position 位置向量，默认值为新的Vector3实例
+     * @param params.rotation 旋转欧拉角，默认值为新的Euler实例
+     * @param params.scale 缩放向量，默认值为Vector3(1, 1, 1)
+     * @returns 默认的变换对象
+     */
+    static default(params) {
+        return new OTransform(params?.position || new Vector3(), params?.rotation || new Euler(), params?.scale || new Vector3(1, 1, 1));
+    }
+}
+/**
+ * 变换类，继承自OTransform，用于表示带有标识符的变换对象
+ */
+class Transform extends OTransform {
+    /**
+     * 构造函数
+   
+     * @param position 位置向量
+     * @param rotation 旋转欧拉角
+     * @param scale 缩放向量
+     */
+    constructor(position, rotation, scale) {
+        super(position, rotation, scale);
+    }
+    toRPCJSON() {
+        return {
+            Location: {
+                X: this.position.x,
+                Y: this.position.y,
+                Z: this.position.z
+            },
+            Rotation: {
+                Pitch: this.rotation.pitch,
+                Yaw: this.rotation.yaw,
+                Roll: this.rotation.roll
+            },
+            Scale: {
+                X: this.scale.x,
+                Y: this.scale.y,
+                Z: this.scale.z
+            }
+        };
+    }
+    /**
+     * 创建默认的变换对象
+     * @param handle 变换对象的唯一标识符
+     * @returns 默认的变换对象
+     */
+    static default() {
+        return new Transform(new Vector3(), new Euler(), new Vector3(1, 1, 1));
+    }
+    static fromRPCObject(obj) {
+        return new Transform(obj.Location
+            ? new Vector3(obj.Location.X, obj.Location.Y, obj.Location.Z)
+            : new Vector3(), obj.Rotation
+            ? new Euler(obj.Rotation.Pitch, obj.Rotation.Yaw, obj.Rotation.Roll)
+            : new Euler(), obj.Scale
+            ? new Vector3(obj.Scale.X, obj.Scale.Y, obj.Scale.Z)
+            : new Vector3(1, 1, 1));
+    }
+}
+
+/**
+ * 节点基类模块，提供节点树的基础实现
+ * 用于表示场景中的对象，支持父子关系、变换和数据存储
+ */
+/**
+ * 节点基类，用于表示场景中的对象
+ * 支持父子关系、变换、数据存储和节点查找
+ * @template T 节点数据类型
+ */
+class Node {
+    /**
+     * 构造函数
+     * @param key 节点唯一标识符
+     * @param data 节点附加数据
+     * @param transform 节点变换信息
+     */
+    constructor(key, data, transform) {
+        this._children = [];
+        this._key = key;
+        this.isRoot = true;
+        this.data = data;
+        if (transform) {
+            this._transform = new OTransform(new Vector3(), new Euler(), new Vector3(1, 1, 1));
+        }
+        else {
+            this._transform = OTransform.default();
+        }
+    }
+    /**
+     * 获取节点唯一标识符
+     */
+    get key() {
+        return this._key;
+    }
+    /**
+     * 获取节点变换信息
+     */
+    get transform() {
+        return this._transform;
+    }
+    /**
+     * 获取子节点列表
+     */
+    get children() {
+        return this._children;
+    }
+    /**
+     * 添加子节点
+     * @param child 要添加的子节点
+     */
+    add(child) {
+        // this.children.push(child)
+        child.parent = this;
+        this._children.push(child);
+        child.isRoot = false;
+    }
+    /**
+     * 脱离父节点
+     */
+    detach() {
+        if (this.parent) {
+            this.parent.removeChild(this);
+        }
+        this.isRoot = true;
+    }
+    remove() {
+        if (this.parent) {
+            this.detach();
+        }
+    }
+    /**
+     * 移除子节点
+     * @param child 要移除的子节点
+     */
+    removeChild(child) {
+        child.parent = undefined;
+        let index = this._children.findIndex((c) => c !== child);
+        if (index > -1) {
+            this._children.splice(index, 1);
+        }
+    }
+    /**
+     * 根据key查找子节点
+     * @param key 要查找的节点key
+     * @returns 找到的节点或undefined
+     */
+    findChild(key) {
+        if (this.key === key) {
+            return this;
+        }
+        for (let i = 0; i < this._children.length; i++) {
+            let child = this._children[i];
+            let found = child.findChild(key);
+            if (found) {
+                return found;
+            }
+        }
+    }
+}
+
+/**
+ * 代理模块，提供深度代理和变动收集功能
+ * 用于跟踪对象的属性变化并在事件循环结束后统一处理
+ */
+/**
+ * 收集器类，用于收集对象变动并在事件循环结束后触发回调
+ */
+class Collector {
+    /**
+     * 创建收集器实例
+     * @param callback 变动回调函数，在事件循环结束后调用
+     */
+    constructor(callback) {
+        /**
+         * 收集到的变动列表
+         */
+        this.changes = [];
+        /**
+         * 标志位，用于确保只有一个 setTimeout 在运行
+         */
+        this.isTimeoutSet = false;
+        this.callback = callback;
+    }
+    /**
+     * 添加变动
+     * @param change 变动对象
+     */
+    addChange(change) {
+        this.changes.push(change);
+        this.scheduleCallback();
+    }
+    /**
+     * 调度回调函数，确保在事件循环结束后执行
+     */
+    scheduleCallback() {
+        if (!this.isTimeoutSet) {
+            this.isTimeoutSet = true;
+            // setTimeout(() => {
+            Promise.resolve().then(() => this.triggerCallback());
+            // }, 0);
+        }
+    }
+    /**
+     * 触发回调函数
+     */
+    triggerCallback() {
+        if (this.changes.length > 0) {
+            this.callback([...this.changes]); // 传递变动的副本
+            this.changes = []; // 清空变动列表
+        }
+        this.isTimeoutSet = false;
+    }
+}
+/**
+ * 创建深度代理，递归地为对象及其所有子对象创建 Proxy
+ * @param target 要代理的目标对象
+ * @param handler 自定义处理器
+ * @param collector 变动收集器，用于收集对象变动
+ * @returns 代理后的对象
+ */
+function createDeepProxy(target, handler = {}, collector) {
+    // 递归创建 Proxy 的核心函数
+    const proxyHandler = {
+        // 拦截属性读取
+        get(target, prop, receiver) {
+            // 先调用自定义 handler 的 get（如果有）
+            if (handler.get) {
+                handler.get(target, prop, receiver);
+            }
+            // 获取属性值
+            const result = Reflect.get(target, prop, receiver);
+            // 如果读取的属性是对象/数组且不是 null，递归创建 Proxy
+            if (result !== null &&
+                (typeof result === 'object' || Array.isArray(result))) {
+                return createDeepProxy(result, handler, collector);
+            }
+            return result;
+        },
+        // 拦截属性赋值
+        set(target, prop, value, receiver) {
+            // 先调用自定义 handler 的 set（如果有）
+            if (handler.set) {
+                handler.set(target, prop, value, receiver);
+            }
+            // 赋值时，如果新值是对象/数组，也需要代理
+            const newValue = value !== null && (typeof value === 'object' || Array.isArray(value))
+                ? createDeepProxy(value, handler, collector)
+                : value;
+            // 如果有收集器，收集变动
+            if (collector) {
+                collector.addChange({
+                    target,
+                    prop,
+                    value: newValue,
+                    type: 'set'
+                });
+            }
+            return Reflect.set(target, prop, newValue, receiver);
+        },
+        // 拦截属性删除
+        deleteProperty(target, prop) {
+            // 先调用自定义 handler 的 deleteProperty（如果有）
+            if (handler.deleteProperty) {
+                handler.deleteProperty(target, prop);
+            }
+            // 如果有收集器，收集变动
+            if (collector) {
+                collector.addChange({
+                    target,
+                    prop,
+                    value: undefined,
+                    type: 'delete'
+                });
+            }
+            return Reflect.deleteProperty(target, prop);
+        },
+        // 可选：拦截其他操作（如 has 等）
+        ...handler // 合并自定义 handler 的其他拦截器
+    };
+    // 为目标对象创建 Proxy
+    return new Proxy(target, proxyHandler);
+}
+
+/**
+ * 资源类型枚举，用于标识不同类型的资源
+ */
+var AssetType;
+(function (AssetType) {
+    /** 其他类型资源 */
+    AssetType["Other"] = "other";
+    /** 地图资源 */
+    AssetType["Map"] = "map";
+    /** 蓝图资源 */
+    AssetType["Blueprint"] = "blueprint";
+    /** 静态网格资源 */
+    AssetType["StaticMesh"] = "static_mesh";
+    /** 骨骼网格资源 */
+    AssetType["SkeletalMesh"] = "skeletal_mesh";
+})(AssetType || (AssetType = {}));
+/**
+ * UE RPC 节点类，继承自 Node，用于与 Unreal Engine 通信
+ * 支持变换同步、远程更新和子节点管理
+ */
+class UERPCNode extends Node {
+    /**
+     * 构造函数
+     * @param rpc RPC 通信实例
+     * @param key 节点唯一标识符
+     * @param data 节点数据
+     * @param transform 节点变换信息
+     */
+    constructor(rpc, key, data, transform, tag) {
+        super(key, data);
+        this._rpc = rpc;
+        if (transform) {
+            this._transform = transform;
+        }
+        else {
+            this._transform = Transform.default();
+        }
+        this._remoteUpdateFlag = false;
+        this._collector = new Collector(this._triggerRemoteUpdate.bind(this));
+        this.tag = tag;
+    }
+    /**
+     * 获取变换信息的深度代理，用于跟踪属性变化
+     */
+    get transform() {
+        return createDeepProxy(this._transform, {}, this._collector);
+    }
+    set transform(transform) {
+        this._transform = transform;
+        this._triggerRemoteUpdate();
+    }
+    /**
+     * 添加子节点
+     * @param child 要添加的子节点
+     * @throws 非根节点添加子节点时抛出错误
+     */
+    add(child) {
+        // throw new Error("UERPCNode can't add child")
+        if (this.isRoot) {
+            super.add(child);
+            child.world = this.world;
+        }
+        else {
+            throw new Error("UERPCNode can't add child , except root node");
+        }
+    }
+    __dangerousRawAdd(child) {
+        super.add(child);
+    }
+    /**
+     * 脱离父节点
+     */
+    async detach() {
+        super.detach();
+    }
+    async remove() {
+        super.remove();
+        await this._rpc.destroyActorByHandle(this.key);
+    }
+    /**
+     * 移除子节点
+     * @param child 要移除的子节点
+     */
+    async removeChild(child) {
+        super.removeChild(child);
+        await this._rpc.destroyActorByHandle(this.key);
+    }
+    _triggerRemoteUpdate() {
+        if (!this._remoteUpdateFlag) {
+            this._remoteUpdateFlag = true;
+            Promise.resolve().then(() => this._remoteUpdate());
+        }
+    }
+    /**
+     * 远程更新节点变换到 UE
+     * 向 UE 发送变换数据，更新 Actor 的位置、旋转和缩放
+     */
+    _remoteUpdate() {
+        this._rpc.setActorTransformByHandle(this.key, this.transform.toRPCJSON());
+        this._remoteUpdateFlag = false;
+    }
+}
+
+class Tool {
+    constructor(rpc) {
+        this._rpc = rpc;
+    }
+    excute(params) {
+        throw new Error('Method not implemented.');
+    }
+}
+
+const maxView4K = (width, height) => {
+    const maxWidth = 3840;
+    const maxHeight = 2160;
+    // 如果宽或高任一超过4K限制
+    if (width > maxWidth || height > maxHeight) {
+        const ratio = Math.min(maxWidth / width, maxHeight / height);
+        return {
+            width: Math.ceil(width * ratio),
+            height: Math.ceil(height * ratio)
+        };
+    }
+    // 未超过限制，返回原尺寸
+    return { width, height };
+};
+class MatchView extends Tool {
+    constructor(rpc) {
+        super(rpc);
+    }
+    excute() {
+        this._rpc.emitCommand({
+            Command: 'MatchView',
+            'Resolution.Width': maxView4K(window.innerWidth, window.innerHeight)
+                .width,
+            'Resolution.Height': maxView4K(window.innerWidth, window.innerHeight)
+                .height
+        });
+    }
+}
+
+/**
+ * 天气类型枚举，定义了不同的天气状态
+ */
+var WeatherType;
+(function (WeatherType) {
+    /** 晴天 */
+    WeatherType["SUNNY"] = "Sunny";
+    /** 雾天 */
+    WeatherType["Foggy"] = "Foggy";
+    /** 雨天 */
+    WeatherType["RAIN"] = "Rain";
+    /** 雪天 */
+    WeatherType["SNOW"] = "Snow";
+})(WeatherType || (WeatherType = {}));
+/**
+ * 天气类，用于管理和控制场景中的天气
+ */
+class Weather {
+    /**
+     * 构造函数
+     */
+    constructor(rpc) {
+        this._rpc = rpc;
+    }
+    /**
+     * 设置天气类型
+     * @param type 天气类型
+     */
+    async setWeather(type) {
+        return this._rpc.callModule('Enviorment', 'SetWeather', {
+            Preset: type
+        });
+    }
+}
+
+/**
+ * 防抖函数 - 延迟执行函数，直到停止调用一段时间后才执行
+ * @param func 要执行的函数
+ * @param wait 等待时间（毫秒）
+ * @param immediate 是否立即执行
+ * @returns 防抖处理后的函数
+ */
+/**
+ * 节流函数 - 限制函数在一定时间内只能执行一次
+ * @param func 要执行的函数
+ * @param limit 时间限制（毫秒）
+ * @returns 节流处理后的函数
+ */
+function throttle(func, limit) {
+    let inThrottle = false;
+    return function (...args) {
+        const context = this;
+        if (!inThrottle) {
+            func.apply(context, args);
+            inThrottle = true;
+            setTimeout(() => (inThrottle = false), limit);
+        }
+    };
+}
+
+class PickCast extends Tool {
+    constructor(rpc) {
+        super(rpc);
+    }
+    hover(callback, maxDistance = 1000000, highlight = false) {
+        let stream = this._rpc.getStream();
+        let videoElementParent = stream.videoElementParent;
+        const onMousemove = throttle(async (event) => {
+            // console.log(event)
+            const offsetX = event.offsetX;
+            const offsetY = event.offsetY;
+            let response = await this._rpc.pickPointByScreen(offsetX, offsetY, maxDistance, highlight);
+            callback && callback(response);
+        }, 50);
+        videoElementParent.addEventListener('mousemove', onMousemove);
+        return function finish() {
+            videoElementParent.removeEventListener('mousemove', onMousemove);
+        };
+    }
+    pick(callback, maxDistance = 1000000, highlight = true) {
+        let videoElementParent = this._rpc.getStream().videoElementParent;
+        let rpc = this._rpc;
+        async function onPick(event) {
+            const offsetX = event.offsetX;
+            const offsetY = event.offsetY;
+            let response = await rpc.pickPointByScreen(offsetX, offsetY, maxDistance, highlight);
+            callback && callback(response);
+        }
+        videoElementParent.addEventListener('click', onPick);
+        return function finish() {
+            videoElementParent.removeEventListener('click', onPick);
+        };
+    }
+}
+
+/**
+ * 热力图工具类，用于创建热力图
+ */
+class HeatMap extends Tool {
+    constructor(rpc, world) {
+        super(rpc);
+        this._world = world;
+    }
+    async create(params) {
+        let _transform = params.transform || Transform.default();
+        let response = await this._rpc.callModule('HeatMap', 'Create', {
+            url: params.url,
+            X: _transform.position.x,
+            Y: _transform.position.y,
+            Z: _transform.position.z,
+            ScaleX: _transform.scale.x,
+            ScaleY: _transform.scale.y,
+            ScaleZ: _transform.scale.z,
+            Pitch: _transform.rotation.pitch,
+            Yaw: _transform.rotation.yaw,
+            Roll: _transform.rotation.roll,
+            Tag: params.tag,
+            MeshSize: params.meshSize,
+            MeshSegment: params.meshSegment,
+            LerpScale: params.lerpScale,
+            Opacity: params.opacity,
+            HeightScale: params.heightScale,
+            ZeroValueOpacity: params.zeroValueOpacity,
+            InfluenceSize: params.influenceSize,
+            EmissiveStrength: params.emissiveStrength,
+            HeatMapPoints: params.heatMapPoints
+        });
+        let _node = new UERPCNode(this._rpc, response.Handle, {
+            assetType: AssetType.Other
+        }, _transform, params.tag);
+        this._world.root.__dangerousRawAdd(_node);
+        return _node;
+    }
+}
+
+class Scatter extends Tool {
+    constructor(rpc) {
+        super(rpc);
+    }
+    async create(params) {
+        let response = await this._rpc.callModule('Point', 'Create', {
+            WidgetSpace: params.widgetSpace,
+            PointParams: params.pointParams.map((item) => {
+                return {
+                    Id: item.id,
+                    Location: item.location,
+                    Rotation: item.rotation,
+                    Scale: item.scale,
+                    Tag: item.tag,
+                    TextContent: item.textContent
+                };
+            })
+        });
+        let _params = [];
+        for (let i = 0; i < response.CreatedIDs.length; i++) {
+            let id = response.CreatedIDs[i];
+            let param = params.pointParams[i];
+            _params.push({
+                ...param,
+                id
+            });
+        }
+        return createScatterGroupHandler(this._rpc, _params);
+    }
+}
+class ScatterGroupHandler {
+    get pointsMap() {
+        return this.children.reduce((acc, cur) => {
+            acc[cur.id] = cur;
+            return acc;
+        }, {});
+    }
+    get tagMap() {
+        return this.children.reduce((acc, cur) => {
+            if (!acc[cur.tag]) {
+                acc[cur.tag] = [];
+            }
+            acc[cur.tag].push(cur);
+            return acc;
+        }, {});
+    }
+    constructor(rpc) {
+        this.children = [];
+        this._rpc = rpc;
+    }
+    getById(id) {
+        return this.pointsMap[id];
+    }
+    async removeById(id) {
+        let handle = this.getById(id);
+        if (handle) {
+            this.children = this.children.filter((child) => child.id !== id);
+            handle.group = undefined;
+            await handle.remove();
+        }
+    }
+    async removeAll() {
+        let childrenIds = this.children.map((child) => child.id);
+        this.children = [];
+        await this._rpc.callModule('Point', 'DeleteByIds', {
+            IDs: childrenIds
+        });
+    }
+    async removeByTag(tag) {
+        let childrenIds = this.tagMap[tag].map((child) => child.id);
+        this.children = this.children.filter((child) => child.tag !== tag);
+        await this._rpc.callModule('Point', 'DeleteByIds', {
+            IDs: childrenIds
+        });
+    }
+}
+class PointHandler {
+    constructor(id, params) {
+        this._id = id;
+        this._rpc = params.rpc;
+        this._transform = params.transform || Transform.default();
+        this._textContent = params.textContent;
+        this._tag = params.tag || '';
+        this._remoteUpdateFlag = false;
+        this._collector = new Collector(this._triggerRemoteUpdate.bind(this));
+        this.group = params.group;
+    }
+    get tag() {
+        return this._tag;
+    }
+    get id() {
+        return this._id;
+    }
+    get transform() {
+        return createDeepProxy(this._transform, {}, this._collector);
+    }
+    get textContent() {
+        return this._textContent;
+    }
+    set textContent(value) {
+        this._textContent = value;
+        this._triggerRemoteUpdate();
+    }
+    _triggerRemoteUpdate() {
+        if (!this._remoteUpdateFlag) {
+            this._remoteUpdateFlag = true;
+            this.remoteUpdate();
+        }
+    }
+    remoteUpdate() {
+        let transformObj = this.transform.toRPCJSON();
+        this._rpc.callModule('Point', 'Update', {
+            textContent: this.textContent,
+            Location: transformObj.Location,
+            Rotation: transformObj.Rotation,
+            Scale: transformObj.Scale
+        });
+        this._remoteUpdateFlag = false;
+    }
+    async remove() {
+        if (this.group) {
+            // this.group = undefined
+            return this.group.removeById(this.id);
+        }
+        await this._rpc.callModule('Point', 'DeleteByIds', {
+            IDs: [this.id]
+        });
+    }
+}
+function createScatterGroupHandler(rpc, params) {
+    let scatterhandler = new ScatterGroupHandler(rpc);
+    let phandler = params.map((param) => createPointHandler(rpc, {
+        ...param
+    }, scatterhandler));
+    scatterhandler.children = phandler;
+    return scatterhandler;
+}
+function createPointHandler(rpc, param, group) {
+    // return new PointHandlerQuery()
+    let handler = new PointHandler(param.id, {
+        rpc,
+        transform: Transform.fromRPCObject({}),
+        textContent: param.textContent,
+        tag: param.tag,
+        group: group
+    });
+    return handler;
+}
+
+/**
+ * 围栏工具类，用于创建和删除电子围栏
+ */
+class Fence extends Tool {
+    constructor(rpc) {
+        super(rpc);
+    }
+    async create(params) {
+        let response = this._rpc.callModule('Box', 'Create', {
+            VectorArray: params.vectorArray,
+            Height: params.height,
+            MaterialEnum: params.materialEnum,
+            Color: params.color
+        });
+        const { FenceID } = await response;
+        let handler = new FenceHandler(this._rpc, FenceID, FenceStatus.Created);
+        return handler;
+    }
+}
+var FenceStatus;
+(function (FenceStatus) {
+    FenceStatus["UnCreated"] = "UnCreated";
+    /** 围栏已创建 */
+    FenceStatus["Created"] = "Created";
+    /** 围栏已删除 */
+    FenceStatus["Removed"] = "Removed";
+})(FenceStatus || (FenceStatus = {}));
+class FenceHandler {
+    get id() {
+        return this._id;
+    }
+    constructor(rpc, id, status) {
+        this._id = id;
+        this._rpc = rpc;
+        this._status = status || FenceStatus.UnCreated;
+    }
+    get status() {
+        return this._status;
+    }
+    async remove() {
+        return this._rpc.callModule('Box', 'Delete', {
+            FenceID: this.id
+        });
+    }
+}
+
+class Building extends Tool {
+    constructor(rpc) {
+        super(rpc);
+    }
+    async expand(id, params) {
+        await this._rpc.callModule('Building', 'Expand', {
+            BuildingId: id,
+            Spacing: params.spacing,
+            Duration: params.duration || 2000
+        });
+        let handler = new BuildingHandler(id, this._rpc);
+        return handler;
+    }
+}
+var Status$1;
+(function (Status) {
+    Status["Expanded"] = "Expanded";
+    Status["ExpandFloor"] = "ExpandFloor";
+    Status["Collapsed"] = "Collapsed";
+})(Status$1 || (Status$1 = {}));
+class BuildingHandler {
+    constructor(id, rpc, status) {
+        this._id = id;
+        this._rpc = rpc;
+        this._status = status || Status$1.Collapsed;
+    }
+    get status() {
+        return this._status;
+    }
+    get id() {
+        return this._id;
+    }
+    async expand(params) {
+        await this._rpc.callModule('Building', 'ExpandFloor', {
+            BuildingId: this._id,
+            Spacing: params.spacing,
+            Duration: params.duration || 2
+        });
+    }
+    async expandFloor(params) {
+        let _params = {
+            BuildingId: this._id,
+            Distance: params.distance,
+            ExpandHeight: params.expandHeight,
+            Duration: params.duration || 2
+        };
+        if (params.direction) {
+            _params.Direction = {
+                X: params.direction.X,
+                Y: params.direction.Y,
+                Z: params.direction.Z
+            };
+        }
+        return this._rpc.callModule('Building', 'ExpandFloor', _params);
+    }
+    async collapse(duration = 2) {
+        return this._rpc.callModule('Building', 'Collapse', {
+            BuildingId: this._id,
+            duration: duration || 2
+        });
+    }
+}
+
+var MeasurementType;
+(function (MeasurementType) {
+    MeasurementType["Path"] = "Path";
+    MeasurementType["Height"] = "Height";
+    MeasurementType["Area"] = "Area";
+})(MeasurementType || (MeasurementType = {}));
+class Measurement extends Tool {
+    constructor(rpc) {
+        super(rpc);
+    }
+    draw(type) {
+        return this._rpc.callModule('Measurement', 'SetDrawType', {
+            Type: type
+        });
+    }
+    clean() {
+        return this._rpc.callModule('Measurement', 'SetDrawType', {
+            Type: 'Null'
+        });
+    }
+}
+
+class Daytime extends Tool {
+    constructor(rpc) {
+        super(rpc);
+    }
+    setDaytime(hh, mm) {
+        return this._rpc.callModule('Environment', 'SetDaytime', {
+            value: `${hh}${mm}`
+        });
+    }
+}
+
+// 虚化
+class Ghost extends Tool {
+    constructor(rpc) {
+        super(rpc);
+    }
+    async ghost(node) {
+        await this._rpc.callModule('Visual', 'Ghost', {
+            Ghost: true,
+            handle: node.key
+        });
+        return new GhostHandle(node, this._rpc);
+    }
+}
+class GhostHandle {
+    constructor(node, rpc) {
+        this._node = node;
+        this._rpc = rpc;
+    }
+    async restore() {
+        await this._rpc.callModule('Visual', 'Ghost', {
+            handle: this._node.key,
+            Ghost: false
+        });
+    }
+}
+
+var Tools = {
+    Tool,
+    MatchViewTool: MatchView,
+    WeatherTool: Weather,
+    PickCastTool: PickCast,
+    HeatMapTool: HeatMap,
+    ScatterTool: Scatter,
+    FenceTool: Fence,
+    BuildingTool: Building,
+    MeasurementTool: Measurement,
+    DaytimeTool: Daytime,
+    GhostTool: Ghost
+};
+
+/**
+ * 世界模块，提供世界场景的核心类
+ * 用于管理场景中的所有对象、天气和RPC通信
+ */
+/**
+ * 世界类，整个场景的根容器
+ * 管理场景中的所有对象、天气系统和RPC通信
+ */
+class World {
+    /**
+     * 构造函数
+     * @param pixelStream PixelStream实例，用于与远程渲染引擎通信
+     */
+    constructor(pixelStream) {
+        this._rpc = new UERPC(pixelStream);
+        this.root = new UERPCNode(this._rpc);
+        this.root.world = this;
+        this.tools = {
+            ghost: new Tools.GhostTool(this._rpc),
+            weather: new Tools.WeatherTool(this._rpc),
+            matchView: new Tools.MatchViewTool(this._rpc),
+            pickCast: new Tools.PickCastTool(this._rpc),
+            scatter: new Tools.ScatterTool(this._rpc),
+            heatMap: new Tools.HeatMapTool(this._rpc, this),
+            fence: new Tools.FenceTool(this._rpc),
+            building: new Tools.BuildingTool(this._rpc),
+            measurement: new Tools.MeasurementTool(this._rpc),
+            daytime: new Tools.DaytimeTool(this._rpc)
+        };
+    }
+    /**
+     * 获取RPC通信实例
+     */
+    get rpc() {
+        return this._rpc;
+    }
+    /**
+     * 加载关卡
+     * @param params 加载关卡的参数
+     * @returns 加载成功后返回关卡节点
+     */
+    async loadLevelByName(assetPath) {
+        let response = await this._rpc.loadLevelByName(assetPath);
+        // let response = await this._rpc.callModule('Mesh', 'Spawn', {
+        //   AssetPath: assetPath,
+        //   Transform: Transform.default().toRPCJSON()
+        // })
+        let handle = response.Handle || 'map';
+        let node = new UERPCNode(this._rpc, handle, { assetType: AssetType.Map });
+        node.data = { assetType: AssetType.Map };
+        this.root.add(node);
+        return node;
+    }
+    /**
+     * 生成含有骨骼动画的Mesh
+     */
+    async spawnSkeletalMesh(params) {
+        let _transform = params.transform || Transform.default();
+        let response = await this._rpc.callModule('Mesh', 'Spawn', {
+            Type: 'SkeletalMesh',
+            AssetPath: params.assetPath,
+            Transform: _transform.toRPCJSON(),
+            Tag: params.tag
+        });
+        let handle = response.Handle;
+        let node = new UERPCNode(this._rpc, handle, {
+            assetType: AssetType.SkeletalMesh
+        }, _transform);
+        this.root.add(node);
+        return node;
+    }
+    /**
+     * 生成静态网格体演员
+     * @param params 生成静态网格体的参数
+     * @returns 生成成功后返回演员节点
+     */
+    async spawnStaticMeshActor(params) {
+        let _transform = params.transform || Transform.default();
+        let response = await this._rpc.callModule('Mesh', 'Spawn', {
+            Type: 'StaticMesh',
+            AssetPath: params.assetPath,
+            Transform: _transform.toRPCJSON(),
+            Tag: params.tag
+        });
+        let handle = response.Handle;
+        let node = new UERPCNode(this._rpc, handle, {
+            assetType: AssetType.StaticMesh
+        }, _transform);
+        this.root.add(node);
+        return node;
+    }
+    /**
+     * 生成本地蓝图演员
+     * @param params 生成本地蓝图的参数
+     * @returns 生成成功后返回演员节点
+     */
+    async spawnLocalBlueprintActor(params) {
+        let _transform = params.transform || Transform.default();
+        let response = await this._rpc.callModule('Mesh', 'Spawn', {
+            Type: 'Blueprint',
+            AssetPath: params.assetPath,
+            Transform: _transform.toRPCJSON(),
+            Tag: params.tag
+        });
+        // let response = await this._rpc.spawnLocalBlueprintActor({
+        //   AssetPath: params.assetPath,
+        //   Transform: _transform.toRPCJSON(),
+        //   Tag: params.tag
+        // })
+        let handle = response.Handle;
+        let node = new UERPCNode(this._rpc, handle, {
+            assetType: AssetType.Blueprint
+        }, _transform);
+        this.root.add(node);
+        return node;
+    }
+}
+
+/**
+ * 相机基类，继承自UERPCNode
+ * 定义了相机的基本结构，所有具体相机类型的父类
+ */
+class Camera extends UERPCNode {
+    /**
+     * 相机基类构造函数
+     * @param rpc UERPC实例，用于与远程服务通信
+     * @param type 相机类型
+     */
+    constructor(rpc, type) {
+        super(rpc, type);
+    }
+}
+/**
+ * 透视相机类，用于表示3D场景中的透视相机
+ * 实现了透视相机的属性和变换管理
+ */
+class PerspectiveCamera extends Camera {
+    /**
+     * 构造函数
+     * @param rpc UERPC实例，用于与远程服务通信
+     */
+    constructor(rpc) {
+        super(rpc, 'camera');
+        // // 初始化相机默认属性
+        // this._fov = 75
+        // this._focalLength = 50
+        // this._aperture = 35
+        // this._focusDistance = 100
+        // 创建默认变换
+        this._transform = Transform.default();
+        // 初始化变换收集器
+        this._collector = new Collector(this._triggerRemoteUpdate.bind(this));
+        // 初始化远程更新标志
+        this._remoteUpdateFlag = false;
+    }
+    // /**
+    //  * 获取焦距值
+    //  * @returns {number} 焦距值，单位为毫米
+    //  */
+    // get focalLength() {
+    //   return this._focalLength
+    // }
+    // /**
+    //  * 设置焦距值
+    //  * @param focalLength 新的焦距值，单位为毫米
+    //  */
+    // set focalLength(focalLength: number) {
+    //   this._focalLength = focalLength
+    //   this._triggerRemoteUpdate()
+    // }
+    // /**
+    //  * 获取光圈值
+    //  * @returns {number} 光圈值
+    //  */
+    // get aperture() {
+    //   return this._aperture
+    // }
+    // /**
+    //  * 设置光圈值
+    //  * @param aperture 新的光圈值
+    //  */
+    // set aperture(aperture: number) {
+    //   this._aperture = aperture
+    //   this._triggerRemoteUpdate()
+    // }
+    // /**
+    //  * 获取视场角
+    //  * @returns {number} 视场角，单位为度
+    //  */
+    // get fov() {
+    //   return this._fov
+    // }
+    // /**
+    //  * 设置视场角
+    //  * @param fov 新的视场角，单位为度
+    //  */
+    // set fov(fov: number) {
+    //   this._fov = fov
+    //   this._triggerRemoteUpdate()
+    // }
+    // /**
+    //  * 获取焦距离
+    //  * @returns {number} 焦距离，单位为世界单位
+    //  */
+    // get focusDistance() {
+    //   return this._focusDistance
+    // }
+    // 同步远程相机参数到本地
+    async forceSyncRemoteToLocal() {
+        let response = await this._rpc.getCameraTransform();
+        console.log(response);
+        if (response.Transform) {
+            let transform = Transform.fromRPCObject(response.Transform);
+            this._transform = transform;
+        }
+    }
+    // /**
+    //  * 设置焦距离
+    //  * @param focusDistance 新的焦距离，单位为世界单位
+    //  */
+    // set focusDistance(focusDistance: number) {
+    //   this._focusDistance = focusDistance
+    //   this._triggerRemoteUpdate()
+    // }
+    /**
+     * 获取相机变换的代理对象
+     * 通过深度代理实现对变换属性的监听，当变换属性变化时自动触发远程更新
+     * @returns {Transform} 相机变换的代理对象
+     */
+    get transform() {
+        return createDeepProxy(this._transform, {}, this._collector);
+    }
+    /**
+     * 触发远程更新
+     * 该方法在相机属性或变换变化时被调用，用于标记相机需要同步到远程
+     */
+    _triggerRemoteUpdate() {
+        this._remoteUpdateFlag = true;
+        this._remoteUpdate();
+    }
+    /**
+     * 远程更新处理方法
+     * 用于将相机的属性和变换同步到远程服务器
+     * TODO: 实现具体的远程同步逻辑
+     */
+    _remoteUpdate() {
+        // TODO: 实现相机属性和变换的远程同步逻辑
+        this._rpc.setCameraTransform(this._transform.toRPCJSON());
+        this._remoteUpdateFlag = true;
+    }
+}
+
+class PresetAnimateClip {
+    constructor(animateName) {
+        this.animateName = animateName;
+    }
+    _clipCall() {
+        return new PresetAnimateClipCall(this);
+    }
+}
+class PresetAnimateClipCall {
+    constructor(clip) {
+        this.clip = clip;
+    }
+    _play(action, params) {
+        action.mixer?.rpc.callModule('Animation', 'Play', {
+            ...params,
+            Animation: this.clip.animateName
+        });
+    }
+    _pause(action, params) {
+        action.mixer?.rpc.callModule('Animation', 'Pause', {
+            handle: params.Handle
+        });
+    }
+    _resume(action, params) {
+        action.mixer?.rpc.callModule('Animation', 'Resume', {
+            handle: params.Handle
+        });
+    }
+}
+class KeyFrameAnimateClip {
+    constructor(params) {
+        this.startTransform = params.startTransform;
+        this.endTransform = params.endTransform;
+    }
+    _clipCall() {
+        return new KeyFrameAnimateClipCall(this);
+    }
+}
+class KeyFrameAnimateClipCall {
+    constructor(clip) {
+        this.clip = clip;
+    }
+    _play(action, params) {
+        action.mixer?.rpc.callModule('Animation', 'MoveBetweenTransforms', {
+            Handle: action.handle,
+            StartTransform: this.clip.startTransform?.toRPCJSON(),
+            EndTransform: this.clip.endTransform?.toRPCJSON(),
+            Duration: action.duration
+        });
+    }
+    _pause(action, params) {
+        action.mixer?.rpc.callModule('Animation', 'PauseMoveBetweenTransforms', {
+            Handle: action.handle
+        });
+    }
+    _resume(action, params) {
+        action.mixer?.rpc.callModule('Animation', 'ResumeMoveBetweenTransforms', {
+            Handle: action.handle
+        });
+    }
+}
+
+var Status;
+(function (Status) {
+    Status["Playing"] = "playing";
+    Status["Paused"] = "paused";
+    Status["Stopped"] = "stopped";
+})(Status || (Status = {}));
+var PlaybackType;
+(function (PlaybackType) {
+    PlaybackType["Loop"] = "loop";
+    PlaybackType["Once"] = "once";
+})(PlaybackType || (PlaybackType = {}));
+class AnimationAction {
+    constructor(handle, clip, mixer) {
+        this._status = Status.Stopped;
+        this._handle = handle;
+        this.type = PlaybackType.Once;
+        this.rate = 1;
+        this.clip = clip;
+        this.playDuration = 0;
+        this.mixer = mixer;
+    }
+    get duration() {
+        return this._duration;
+    }
+    set duration(duration) {
+        this._duration = duration;
+    }
+    get handle() {
+        return this._handle;
+    }
+    get status() {
+        return this._status;
+    }
+    async play() {
+        if (this._status == Status.Paused) {
+            let clipCall = this.clip._clipCall();
+            return clipCall._resume(this, {
+                Handle: this._handle
+            });
+        }
+        let obj = {
+            Handle: this._handle,
+            Rate: this.rate,
+            Loop: this.type == PlaybackType.Loop
+        };
+        let clipCall = this.clip._clipCall();
+        this.playDuration = 0;
+        this._status = Status.Playing;
+        clipCall._play(this, obj);
+        return;
+    }
+    pause() {
+        let obj = {
+            Handle: this._handle,
+            Rate: this.rate,
+            Loop: this.type == PlaybackType.Loop
+        };
+        let clipCall = this.clip._clipCall();
+        this._status = Status.Paused;
+        return clipCall._pause(this, obj);
+    }
+    update(delta) {
+        if (this.status != Status.Playing) {
+            return;
+        }
+        this.playDuration += delta;
+        if (this.type === PlaybackType.Once &&
+            this.duration &&
+            this.playDuration >= this.duration) {
+            this._status = Status.Stopped;
+        }
+    }
+}
+
+// 创建一个 Clock ， 计算每次的时间差 ， 同时保存开始的时间
+class Clock {
+    constructor() {
+        this.startTime = 0;
+        this.previousTime = 0;
+        this.elapsedTime = 0;
+        this.isRunning = false;
+    }
+    /**
+     * 开始计时
+     */
+    start() {
+        this.startTime = performance.now();
+        this.previousTime = this.startTime;
+        this.elapsedTime = 0;
+        this.isRunning = true;
+    }
+    /**
+     * 停止计时
+     */
+    stop() {
+        this.getDelta(); // 更新 elapsedTime
+        this.isRunning = false;
+    }
+    /**
+     * 获取自上次调用 getDelta() 以来经过的时间（时间差）
+     * @returns 时间差（毫秒）
+     */
+    getDelta() {
+        let currentTime = performance.now();
+        let delta = 0;
+        if (this.isRunning) {
+            delta = currentTime - this.previousTime;
+            this.elapsedTime += delta;
+            this.previousTime = currentTime;
+        }
+        return delta;
+    }
+    /**
+     * 获取自开始计时以来经过的总时间
+     * @returns 经过的总时间（毫秒）
+     */
+    getElapsedTime() {
+        if (this.isRunning) {
+            this.getDelta(); // 更新 elapsedTime
+        }
+        return this.elapsedTime;
+    }
+    /**
+     * 获取开始时间
+     * @returns 开始时间（毫秒）
+     */
+    getStartTime() {
+        return this.startTime;
+    }
+    /**
+     * 检查是否正在运行
+     * @returns 是否正在运行
+     */
+    isRunningState() {
+        return this.isRunning;
+    }
+    /**
+     * 重置计时器
+     */
+    reset() {
+        this.startTime = performance.now();
+        this.previousTime = this.startTime;
+        this.elapsedTime = 0;
+    }
+}
+
+class AnimationMixer {
+    constructor(rpc) {
+        this._actions = [];
+        this._rpc = rpc;
+        this._duration = 0;
+        this._actions = [];
+        this.init();
+    }
+    get rpc() {
+        return this._rpc;
+    }
+    init() {
+        this._clock = new Clock();
+        this._clock.start();
+        setTimeout(() => {
+            this._duration += this._clock.getDelta();
+            this.updateAction();
+        }, 1000 / 60);
+    }
+    get duration() {
+        return this._duration;
+    }
+    updateAction() {
+        this._actions.forEach((action) => {
+            action.update(this._duration);
+        });
+    }
+    clipAction(clip, node) {
+        return new AnimationAction(node.key, clip, this);
+    }
+    removeAction(action) {
+        // this._actions = this._actions.filter((item) => item !== action)
+        let index = this._actions.findIndex((item) => item === action);
+        if (index > -1) {
+            this._actions.splice(index, 1);
+        }
+    }
+}
+
+var Animation = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    AnimationMixer: AnimationMixer,
+    AnimationAction: AnimationAction,
+    PresetAnimateClip: PresetAnimateClip,
+    KeyFrameAnimateClip: KeyFrameAnimateClip
+});
+
+const Core = {
+    UERPC
+};
+const Addons = {
+    World,
+    Transform,
+    PerspectiveCamera,
+    UERPCNode,
+    WeatherType,
+    MeasurementType,
+    Animation: {
+        ...Animation
+    }
+};
+
+export { Addons, Core };
+//# sourceMappingURL=sdk.esm.js.map