@directivegames/genesys.js 3.1.24

package/dist/src/actors/Actor.js

@@ -0,0 +1,1180 @@
+/**
+ * Actor - base class for any object that can be placed in a Genesys world.
+ *
+ * Detailed explanation:
+ * - Wraps a root `SceneComponent` to anchor visuals, physics, and child components.
+ * - Interacts with the world lifecycle by dispatching begin/end play and tick events.
+ * - Supports serialization via `WorldSerializer` so instances can be saved as prefabs.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Extend this class to create new actor types with custom components.
+ * - Override `tickBeforePhysics` or `tickAfterPhysics` for per-frame behavior.
+ * - Register subclasses with `ClassRegistry` if you want them loadable from data.
+ * - Include serializable fields in `toJSON` when state should persist across sessions.
+ */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var _a;
+var Actor_1;
+import 'reflect-metadata';
+import * as THREE from 'three';
+import { PrimitiveComponent } from '../components/PrimitiveComponent.js';
+import { SceneComponent } from '../components/SceneComponent.js';
+import { Playable } from '../game/Playable.js';
+import { PlayState } from '../game/Playable.js';
+import { NetMovementPredictor } from '../multiplayer/MovementPrediction.js';
+import { NetWorld } from '../multiplayer/NetWorld.js';
+import { ClassRegistry, EngineClass } from '../systems/ClassRegistry.js';
+import { ObjectNamingSystem } from '../systems/ObjectNamingSystem.js';
+import { isLegacyData, WorldSerializer } from '../systems/WorldSerialization.js';
+import { Delegate } from '../utils/Delegate.js';
+import { DescriptionHelper } from '../utils/DescriptionHelpers.js';
+import { isAsyncLoadable } from '../utils/IAsyncLoadable.js';
+import { getPropertyMetadata } from '../utils/serialization/decorator.js';
+import { property } from '../utils/serialization/decorator.js';
+import { instantiatePrefab } from '../utils/serialization/prefab.js';
+import { ISerializableObjectTag } from '../utils/serialization/serializable.js';
+import { ensure, shortUUID } from '../utils/Utils.js';
+/**
+ * Base class for all actors in the scene
+ * An actor is an object that can be placed in the world and has components attached to it
+ */
+let Actor = Actor_1 = class Actor extends Playable {
+    static get DEFAULT_OPTIONS() {
+        return {
+            actorTags: []
+        };
+    }
+    /**
+       * Creates a new Actor instance
+       * @param options Configuration options for the actor
+       */
+    constructor(options = {}) {
+        super();
+        Object.defineProperty(this, "options", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: options
+        });
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "editorData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "uuid", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: shortUUID()
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "_rootComponent", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "world", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "lifeSpan", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 0
+        });
+        Object.defineProperty(this, "remoteNetClientId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "remoteNetDeviceId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "netRelevant", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "movementPredictor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        // deprecate in favor of $$prefab
+        Object.defineProperty(this, "prefabName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "prefabData", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "prefabInheritanceChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "ctorArgOptions", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // make it protected/private later
+        Object.defineProperty(this, "$prefab", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "transient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "actorTags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "hiddenInGame", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        Object.defineProperty(this, "editorOnly", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
+        /** Invoked when this actor is added to a world */
+        Object.defineProperty(this, "onAddedToWorld", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Invoked during tick before physics simulation */
+        Object.defineProperty(this, "onTickPrePhysics", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Invoked during tick after physics simulation */
+        Object.defineProperty(this, "onTickPostPhysics", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Invoked when this actor begins play */
+        Object.defineProperty(this, "onBeginPlay", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Invoked when this actor ends play */
+        Object.defineProperty(this, "onEndPlay", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Invoked right before this actor starts end play, so it's still in `playing` state */
+        Object.defineProperty(this, "onPreEndPlay", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /** Invoked when this actor is clicked */
+        Object.defineProperty(this, "onClicked", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /**
+         * Invoked when this actor collides with another actor
+         * Parameters: [thisActor, thisActorComponent, otherActor, otherActorComponent, collisionEvent]
+         */
+        Object.defineProperty(this, "onCollideWith", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /**
+         * Invoked when this actor overlaps with another actor
+         * Parameters: [thisActor, thisActorComponent, otherActor, otherActorComponent, collisionEvent]
+         */
+        Object.defineProperty(this, "onOverlapWith", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /**
+         * Invoked when this actor stops colliding with another actor
+         * Parameters: [thisActor, thisActorComponent, otherActor, otherActorComponent, collisionEvent]
+         */
+        Object.defineProperty(this, "onStopCollidingWith", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        /**
+         * Invoked when this actor stops overlapping with another actor
+         * Parameters: [thisActor, thisActorComponent, otherActor, otherActorComponent, collisionEvent]
+         */
+        Object.defineProperty(this, "onStopOverlappingWith", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: new Delegate()
+        });
+        this.ctorArgOptions = options;
+        options = { ...Actor_1.DEFAULT_OPTIONS, ...options, };
+        this.name = ObjectNamingSystem.generateName(this);
+        this.actorTags = options.actorTags ? [...options.actorTags] : [];
+        let rootComponent = options.rootComponent;
+        if (rootComponent && !ensure(rootComponent.getActor() === null)) {
+            rootComponent = undefined;
+        }
+        if (rootComponent) {
+            this._rootComponent = rootComponent;
+            if (options.position) {
+                this.rootComponent.position.copy(options.position);
+            }
+            if (options.rotation) {
+                this.rootComponent.rotation.copy(options.rotation);
+            }
+            if (options.scale) {
+                this.rootComponent.scale.copy(options.scale);
+            }
+        }
+        else {
+            this._rootComponent = new SceneComponent({
+                position: options.position,
+                rotation: options.rotation,
+                scale: options.scale
+            });
+        }
+        this.rootComponent.setActor(this);
+        for (const component of options.sceneComponents ?? []) {
+            if (component instanceof SceneComponent) {
+                this.rootComponent.add(component);
+            }
+            else {
+                console.trace(`${component} is not a SceneComponent`);
+            }
+        }
+        this.rootComponent.updateMatrixWorld(true);
+        const legacyPrefabName = options.prefabName;
+        if (legacyPrefabName) {
+            this.prefabName = legacyPrefabName;
+        }
+    }
+    /**
+     * Gets the prefab name of this actor
+     * @returns The prefab name or null if not set
+     */
+    getPrefabName() {
+        return this.prefabName ?? this.$prefab?.$path ?? null;
+    }
+    /**
+     * Gets the prefab data of this actor
+     * @returns The prefab data or null if not set
+     */
+    getPrefabData() {
+        return this.prefabData;
+    }
+    /**
+     * Gets the prefab inheritance chain of this actor
+     * @returns The prefab inheritance chain or null if not set
+     */
+    getPrefabInheritanceChain() {
+        return this.prefabInheritanceChain;
+    }
+    /**
+     * Sets the prefab name and data of this actor
+     * @param name The prefab name
+     * @param data The prefab data
+     * @param inheritanceChain The full prefab inheritance chain (optional)
+     * @returns This actor instance for method chaining
+     */
+    setPrefab(name, data, inheritanceChain) {
+        this.prefabName = name;
+        this.prefabData = data;
+        this.prefabInheritanceChain = inheritanceChain ?? null;
+        return this;
+    }
+    /**
+     * Clears the prefab name and data of this actor
+     * @returns This actor instance for method chaining
+     */
+    clearPrefab() {
+        this.prefabName = null;
+        this.prefabData = null;
+        this.prefabInheritanceChain = null;
+        return this;
+    }
+    /**
+     * Gets all tags of this actor
+     * @returns Array of tags (empty array if no tags)
+     */
+    getActorTags() {
+        return [...this.actorTags]; // Return a copy to prevent external mutation
+    }
+    /**
+     * Sets the tags of this actor
+     * @param tags The tags to set
+     * @returns This actor instance for method chaining
+     */
+    setActorTags(tags) {
+        this.actorTags = [...tags]; // Store a copy to prevent external mutation
+        return this;
+    }
+    /**
+     * Adds a tag to this actor (if not already present)
+     * @param tag The tag to add
+     * @returns This actor instance for method chaining
+     */
+    addActorTag(tag) {
+        if (!this.actorTags.includes(tag)) {
+            this.actorTags.push(tag);
+        }
+        return this;
+    }
+    /**
+     * Removes a tag from this actor
+     * @param tag The tag to remove
+     * @returns This actor instance for method chaining
+     */
+    removeActorTag(tag) {
+        const index = this.actorTags.indexOf(tag);
+        if (index !== -1) {
+            this.actorTags.splice(index, 1);
+        }
+        return this;
+    }
+    /**
+     * Checks if this actor has the specified tag
+     * @param tag The tag to check for
+     * @returns True if the actor has the specified tag, false otherwise
+     */
+    hasActorTag(tag) {
+        return this.actorTags.includes(tag);
+    }
+    /**
+     * Checks if this actor has any of the specified tags
+     * @param tags The tags to check for
+     * @returns True if the actor has at least one of the specified tags, false otherwise
+     */
+    hasAnyActorTag(tags) {
+        return tags.some(tag => this.actorTags.includes(tag));
+    }
+    /**
+     * Checks if this actor has all of the specified tags
+     * @param tags The tags to check for
+     * @returns True if the actor has all of the specified tags, false otherwise
+     */
+    hasAllActorTags(tags) {
+        return tags.every(tag => this.actorTags.includes(tag));
+    }
+    /**
+     * Sets whether this actor is transient (excluded from serialization)
+     * @param transient Whether this actor is transient
+     */
+    setTransient(transient) {
+        this.transient = transient;
+    }
+    /**
+     * Gets whether this actor is transient
+     * @returns Whether this actor is transient
+     */
+    isTransient() {
+        return this.transient;
+    }
+    /**
+     * Spawns a prefab actor
+     * @param prefabName The name of the prefab
+     * @param transform The transform of the actor
+     * @param prefabs The prefabs to use
+     * @returns The spawned actor
+     */
+    static async spawnPrefabActor(prefabName, transform, prefabs = {}, isEditor) {
+        const prefabData = prefabs[prefabName];
+        if (isLegacyData(prefabData)) {
+            return await WorldSerializer.loadActor({
+                ctor: {
+                    position: transform?.position,
+                    rotation: transform?.rotation,
+                    scale: transform?.scale,
+                },
+                prefabName,
+            }, prefabs, isEditor);
+        }
+        return instantiatePrefab(prefabName, prefabs, { ctorArgsOverrides: {
+                position: transform?.position,
+                rotation: transform?.rotation,
+                scale: transform?.scale,
+            } });
+    }
+    getDefaultOptions() {
+        return this.constructor.DEFAULT_OPTIONS;
+    }
+    /**
+     * Exports the actor to a serializable format
+     * @param context The serialization context
+     * @param includeDefaults Whether to include default values
+     * @returns The serialized data
+     */
+    export(context, includeDefaults) {
+        const properties = {
+            editorData: this.editorData,
+            actorTags: this.actorTags?.length > 0 ? [...this.actorTags] : undefined,
+            hiddenInGame: this.hiddenInGame ? true : undefined,
+            editorOnly: this.editorOnly ? true : undefined,
+        };
+        // Include @property decorated properties
+        const metadata = getPropertyMetadata(this.constructor);
+        for (const propName of Object.keys(metadata)) {
+            if (propName in this) {
+                properties[propName] = this[propName];
+            }
+        }
+        const data = {
+            uuid: this.uuid,
+            class: ClassRegistry.getClassNameChecked(this),
+            properties
+        };
+        data.ctor = context.exportObject({
+            ...this.getExportedConstructor(),
+            rootComponent: this.rootComponent,
+        }, includeDefaults);
+        data.prefabName = this.prefabName ?? undefined;
+        // Include parent prefab name if this is a prefab with inheritance
+        if (this.prefabData?.parentPrefabName) {
+            data.parentPrefabName = this.prefabData.parentPrefabName;
+        }
+        return data;
+    }
+    /**
+       * Triggers the click event on this actor
+       * @param intersection The intersection data from raycasting
+       */
+    clicked(intersection) {
+        this.onClicked.invoke(this, intersection);
+    }
+    /**
+     * Readonly access to the root scene component of this actor
+     * @returns The root scene component
+     */
+    get rootComponent() {
+        return this._rootComponent;
+    }
+    /**
+       * Sets the root scene component of this actor
+       * @param newRootComponent The new root scene component
+       * @param copyTransform Whether to copy the transform from the existing root component
+       */
+    setRootComponent(newRootComponent, copyTransform) {
+        if (!ensure(!this.isPlayEnded())) {
+            return this;
+        }
+        if (!ensure(newRootComponent.getActor() === null)) {
+            return this;
+        }
+        if (copyTransform) {
+            newRootComponent.position.copy(this.rootComponent.position);
+            newRootComponent.rotation.copy(this.rootComponent.rotation);
+            newRootComponent.scale.copy(this.rootComponent.scale);
+        }
+        const oldRootComponent = this.rootComponent;
+        oldRootComponent.removeFromParent();
+        oldRootComponent.setActor(null);
+        this._rootComponent = newRootComponent;
+        this.rootComponent.setActor(this);
+        this.rootComponent.updateMatrixWorld(true);
+        if (this.isPlaying()) {
+            this.rootComponent.beginPlay();
+        }
+        if (this.world) {
+            this.world.scene.add(newRootComponent);
+        }
+        return this;
+    }
+    /**
+     * If the root component is a scene component and it has a single child, replace the root component with the child
+     * @returns True if the root component was collapsed, false otherwise
+     */
+    collapseRootComponent() {
+        if (ensure(this.getPlayState() === PlayState.NotStarted)) {
+            // don't use "instanceof SceneComponent" as we want pure equality check
+            if (ClassRegistry.getClassOrConstructorName(this.rootComponent) === 'SceneComponent' && this.rootComponent.children.length === 1) {
+                const child = this.rootComponent.children[0];
+                if (ensure(child instanceof SceneComponent)) {
+                    child.removeFromParent();
+                    this.setRootComponent(child, true);
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+       * Sets the world this actor belongs to
+       * @param world The world to set, or null to remove from current world
+       */
+    setWorld(world) {
+        if (!ensure(!this.world || !world)) {
+            return;
+        }
+        this.world = world;
+        if (world) {
+            this.onAddedToWorld.invoke(this, world);
+        }
+    }
+    /**
+       * Gets the world this actor belongs to
+       * @returns The world or null if not in a world
+       */
+    getWorld() {
+        return this.world;
+    }
+    /**
+       * Updates this actor before physics simulation
+       * @param deltaTime Time in seconds since the last tick
+       */
+    tickPrePhysics(deltaTime) {
+        if (this.lifeSpan > 0) {
+            this.lifeSpan -= deltaTime;
+            if (this.lifeSpan <= 0) {
+                this.destroy();
+                return;
+            }
+        }
+        if (this.movementPredictor) {
+            const predictedTransform = this.movementPredictor.predictCurrentTransform();
+            if (predictedTransform) {
+                const lerpedTransform = NetMovementPredictor.lerpTransform({
+                    position: this.rootComponent.position,
+                    rotation: this.rootComponent.quaternion,
+                    scale: this.rootComponent.scale,
+                }, predictedTransform, NetMovementPredictor.LerpAlpha);
+                this.setWorldTransform({
+                    position: lerpedTransform.position,
+                    rotation: new THREE.Euler().setFromQuaternion(lerpedTransform.rotation),
+                    scale: lerpedTransform.scale,
+                });
+            }
+        }
+        this.rootComponent.tickPrePhysics(deltaTime);
+        this.onTickPrePhysics.invoke(this, deltaTime);
+    }
+    /**
+       * Updates this actor after physics simulation
+       * @param deltaTime Time in seconds since the last tick
+       */
+    tickPostPhysics(deltaTime) {
+        this.rootComponent.tickPostPhysics(deltaTime);
+        this.onTickPostPhysics.invoke(this, deltaTime);
+        if (this.movementPredictor) {
+            this.movementPredictor.addLocalTransform({
+                timestamp: NetMovementPredictor.currentTime(),
+                position: this.rootComponent.position.clone(),
+                rotation: this.rootComponent.quaternion.clone(),
+                scale: this.rootComponent.scale.clone(),
+            });
+        }
+    }
+    /**
+       * Gets the forward direction vector of this actor
+       * @returns Normalized forward direction vector
+       */
+    forwardDirection() {
+        return new THREE.Vector3(0, 0, -1).applyQuaternion(this.rootComponent.quaternion).normalize();
+    }
+    /**
+       * Gets the right direction vector of this actor
+       * @returns Normalized right direction vector
+       */
+    rightDirection() {
+        return new THREE.Vector3(1, 0, 0).applyQuaternion(this.rootComponent.quaternion).normalize();
+    }
+    /**
+       * Gets the up direction vector of this actor
+       * @returns Normalized up direction vector
+       */
+    upDirection() {
+        return new THREE.Vector3(0, 1, 0).applyQuaternion(this.rootComponent.quaternion).normalize();
+    }
+    /**
+       * Gets the physics engine from the world this actor belongs to
+       * @returns The physics engine or null if not in a world or world has no physics engine
+       */
+    getPhysicsEngine() {
+        return this.world ? this.world.getPhysicsEngine() : null;
+    }
+    /**
+       * Sets whether this actor is hidden in the scene
+       * @param hidden True to hide the actor, false to show it
+       * @returns This actor instance for method chaining
+       */
+    setHidden(hidden) {
+        if (this.isHidden() !== hidden) {
+            this.rootComponent.setHidden(hidden, true);
+        }
+        return this;
+    }
+    /**
+       * Checks if this actor is currently hidden
+       * @returns True if the actor is hidden, false otherwise
+       */
+    isHidden() {
+        return this.rootComponent.isHidden();
+    }
+    /**
+     * Replaces the physics options for this actor
+     * @param newOptions The new physics options
+     * @param propagateToChildren Whether to propagate the new options to child components
+     * @returns This actor instance for method chaining
+     */
+    replacePhysicsOptions(newOptions, propagateToChildren = false) {
+        this.rootComponent.replacePhysicsOptions(newOptions, propagateToChildren);
+        return this;
+    }
+    /**
+     * Overrides the physics options for this actor
+     * @param newOptions The new physics options
+     * @param propagateToChildren Whether to propagate the new options to child components
+     * @returns This actor instance for method chaining
+     */
+    overridePhysicsOptions(newOptions, propagateToChildren = false) {
+        this.rootComponent.overridePhysicsOptions(newOptions, propagateToChildren);
+        return this;
+    }
+    /**
+       * Sets whether physics simulation is enabled for this actor
+       * @param enable True to enable physics, false to disable
+       * @param propagateToChildren Whether to propagate the change to child components
+       * @returns This actor instance for method chaining
+       */
+    setPhysicsEnabled(enable, propagateToChildren = false) {
+        this.rootComponent.setPhysicsEnabled(enable, propagateToChildren);
+        return this;
+    }
+    /**
+       * Checks if physics simulation is enabled for this actor
+       * @returns True if physics is enabled, false otherwise
+       */
+    isPhysicsEnabled() {
+        return (this.rootComponent instanceof PrimitiveComponent) && this.rootComponent.isPhysicsEnabled();
+    }
+    /**
+     * Generates a debug node for the actor
+     * @returns A debug node for the actor
+     */
+    generateDebugNode() {
+        const children = [];
+        children.push(this.rootComponent.generateDebugNode());
+        return {
+            title: this.name,
+            children,
+            data: {
+                uuid: this.uuid,
+            }
+        };
+    }
+    /**
+     * Gets the life span of this actor
+     * @returns The life span in seconds
+     */
+    getLifeSpan() {
+        return this.lifeSpan;
+    }
+    /**
+     * Sets the life span of this actor
+     * @param lifeSpan The life span in seconds
+     * @returns This actor instance for method chaining
+     */
+    setLifeSpan(lifeSpan) {
+        this.lifeSpan = lifeSpan;
+        return this;
+    }
+    /**
+     * Adds a component to the actor root component
+     * @param component The component to add
+     * @returns This actor instance for method chaining
+     */
+    addComponent(component) {
+        return this.addComponents(component);
+    }
+    /**
+     * Adds multiple components to the actor root component
+     * @param components The components to add
+     * @returns This actor instance for method chaining
+     */
+    addComponents(...components) {
+        components.forEach(component => {
+            this.rootComponent.add(component);
+        });
+        return this;
+    }
+    /**
+     * Gets the first component/child object of a specified type
+     * @param type - The type of component/child object to search for
+     * @returns The first component/child object of the specified type or null if no such component exists
+     */
+    getComponent(type = SceneComponent) {
+        return this.rootComponent.getComponent(type);
+    }
+    /**
+     * Gets all components/child objects of a specified type
+     * @param type - The type of component/child object to search for
+     * @returns An array of all components/child objects of the specified type
+     */
+    getComponents(type = SceneComponent) {
+        return this.rootComponent.getComponents(type);
+    }
+    /**
+     * Gets the path name of this actor
+     * @returns The path name of this actor
+     */
+    getPathName() {
+        return this.world ? `${this.world.getPathName()}.${this.name}` : this.name;
+    }
+    /**
+     * Destroys this actor
+     */
+    destroy() {
+        if (this.world) {
+            this.world.removeActors(this);
+        }
+    }
+    /**
+     * Handles the death of this actor
+     * @param hitInfo The hit information
+     */
+    handleDeath(hitInfo) {
+        this.destroy();
+    }
+    /**
+     * Returns an exported object representation of this actor
+     * @param includeDefaults Whether to include default values
+     * @returns An exported object representation of this actor
+     */
+    asExportedObject(includeDefaults = false) {
+        return WorldSerializer.exportObject(this, includeDefaults);
+    }
+    asExportedPrefabData() {
+        return WorldSerializer.exportAsPrefab(this);
+    }
+    /**
+     * Sets the world transform of this actor
+     * @param transform The transform to set
+     */
+    setWorldTransform(transform) {
+        this.rootComponent.setWorldTransform(transform);
+    }
+    /**
+     * Sets the world position of this actor
+     * @param position The position to set
+     */
+    setWorldPosition(position) {
+        this.setWorldTransform({ position });
+    }
+    /**
+     * Sets the world rotation of this actor
+     * @param rotation The rotation to set
+     */
+    setWorldRotation(rotation) {
+        this.setWorldTransform({ rotation });
+    }
+    /**
+     * Sets the world scale of this actor
+     * @param scale The scale to set
+     */
+    setWorldScale(scale) {
+        this.setWorldTransform({ scale });
+    }
+    /**
+     * Sets the world quaternion of this actor
+     * @param quat The quaternion to set
+     */
+    setWorldQuaternion(quaternion) {
+        this.setWorldTransform({ rotation: new THREE.Euler().setFromQuaternion(quaternion) });
+    }
+    /**
+     * Gets the world position of this actor
+     * @returns The world position of this actor
+     */
+    getWorldPosition() {
+        return this.rootComponent.getWorldPosition();
+    }
+    /**
+     * Gets the world rotation of this actor
+     * @returns The world rotation of this actor
+     */
+    getWorldRotation() {
+        return this.rootComponent.getWorldRotation();
+    }
+    /**
+     * Gets the world scale of this actor
+     * @returns The world scale of this actor
+     */
+    getWorldScale() {
+        return this.rootComponent.getWorldScale();
+    }
+    /**
+     * Gets the world quaternion of this actor
+     * @returns The world quaternion of this actor
+     */
+    getWorldQuaternion() {
+        return this.rootComponent.getWorldQuaternion();
+    }
+    /**
+     * Gets the world transform of this actor
+     * @returns The world transform of this actor
+     */
+    getWorldTransform() {
+        return this.rootComponent.getWorldTransform();
+    }
+    setNetRelevant(relevant) {
+        this.netRelevant = relevant;
+    }
+    isNetRelevant() {
+        return this.netRelevant;
+    }
+    getNetObjectId() {
+        return `${ClassRegistry.getClassOrConstructorName(this)}'${this.uuid}'`;
+    }
+    setRemoteNetClientId(clientId) {
+        this.remoteNetClientId = clientId;
+    }
+    setRemoteNetDeviceId(deviceId) {
+        this.remoteNetDeviceId = deviceId;
+    }
+    getNetDeviceId() {
+        return this.remoteNetDeviceId ?? NetWorld.getDeviceId();
+    }
+    getNetClientId() {
+        if (this.remoteNetClientId) {
+            return this.remoteNetClientId;
+        }
+        const netWorld = this.getWorld()?.netWorld;
+        if (!netWorld) {
+            throw new Error('Failed to get net world when getting net client id');
+        }
+        return netWorld.clientId;
+    }
+    consumeLocalDynamicState() {
+        return false;
+    }
+    getNetConstructionData() {
+        return this.asExportedObject();
+    }
+    getNetDynamicState(lastReplicatedState) {
+        const lastState = lastReplicatedState ? lastReplicatedState : null;
+        const lastPosition = lastState?.position;
+        const lastRotation = lastState?.rotation;
+        const lastScale = lastState?.scale;
+        const currentPosition = this.rootComponent.position.toArray();
+        const currentRotation = this.rootComponent.rotation.toArray();
+        const currentScale = this.rootComponent.scale.toArray();
+        if (lastState &&
+            NetWorld.isVectorNearlyEqual(lastPosition, currentPosition) &&
+            NetWorld.isVectorNearlyEqual(lastRotation, currentRotation) &&
+            NetWorld.isVectorNearlyEqual(lastScale, currentScale)) {
+            return null;
+        }
+        return {
+            position: currentPosition,
+            rotation: currentRotation,
+            scale: currentScale,
+            timestamp: NetMovementPredictor.currentTime(),
+        };
+    }
+    setNetDynamicState(dynamicState) {
+        const { position, rotation, scale, timestamp } = dynamicState;
+        this.movementPredictor ??= new NetMovementPredictor();
+        this.movementPredictor.addRemoteTransform({
+            timestamp,
+            position: new THREE.Vector3(position[0], position[1], position[2]),
+            rotation: new THREE.Quaternion().setFromEuler(new THREE.Euler(rotation[0], rotation[1], rotation[2])),
+            scale: new THREE.Vector3(scale[0], scale[1], scale[2]),
+        });
+    }
+    setOverrideMaterial(material) {
+        this.rootComponent.setOverrideMaterial(material, true);
+        return this;
+    }
+    //====================================================================================================
+    /**
+     * Gets the constructor data for this actor
+     * @returns The constructor data for this actor
+     */
+    getExportedConstructor() {
+        const transientRoot = this.rootComponent.isTransient();
+        return {
+            ...this.options,
+            // if the root is transient then the actor transform needs to be saved in the ctor
+            position: transientRoot ? this.getWorldPosition() : undefined,
+            rotation: transientRoot ? this.getWorldRotation() : undefined,
+            scale: transientRoot ? this.getWorldScale() : undefined,
+            // scene components are serialized as part of the actor scene graph so no need to serialize them separately
+            sceneComponents: undefined,
+            __isDeserializing: undefined,
+            // this is merely used for clearing out the prefab name from the ctor for the legacy format
+            prefabName: undefined,
+        };
+    }
+    doBeginPlay() {
+        this.rootComponent.beginPlay();
+        this.onBeginPlay.invoke(this);
+        this.getWorld()?.netWorld.addNetObject(this);
+        if (this.isHiddenInGame()) {
+            this.getWorld()?.setActorHiddenInGame(this, true);
+        }
+    }
+    doPreEndPlay() {
+        this.onPreEndPlay.invoke(this);
+    }
+    doEndPlay() {
+        if (this.isHiddenInGame()) {
+            this.getWorld()?.setActorHiddenInGame(this, false);
+        }
+        this.getWorld()?.netWorld.removeNetObject(this);
+        this.rootComponent.endPlay();
+        this.onEndPlay.invoke(this);
+        this.world = null;
+    }
+    // calc all scene components for bounding boxes first
+    calcBoundingBox() {
+        this.rootComponent.updateMatrixWorld(true);
+        const sceneComponents = this.getComponents(SceneComponent);
+        for (const component of sceneComponents) {
+            component.calcBoundingBox();
+        }
+        return this.getBoundingBox();
+    }
+    // simply use the cached bounding box of scene components
+    getBoundingBox() {
+        const box = new THREE.Box3();
+        const sceneComponents = this.getComponents(SceneComponent);
+        for (const component of sceneComponents) {
+            const componentBox = component.boundingBox;
+            if (componentBox) {
+                box.union(componentBox);
+            }
+        }
+        return box;
+    }
+    /**
+     * Returns a description of this actor for a summary of this actor. Useful for AI assistants.
+     * @returns An object describing the actor's properties
+     */
+    describe(options) {
+        if (options?.omitDescription) {
+            const simpleDescription = {
+                name: this.name,
+                uuid: this.uuid
+            };
+            if (this.editorData?.displayName) {
+                simpleDescription.displayName = this.editorData.displayName;
+            }
+            return simpleDescription;
+        }
+        const description = {
+            name: this.name,
+            uuid: this.uuid,
+            className: ClassRegistry.getClassName(this) ?? this.constructor.name,
+            position: DescriptionHelper.dumpPosition(this.getWorldPosition()),
+            rotation: DescriptionHelper.dumpRotation(this.getWorldRotation()),
+            scale: DescriptionHelper.dumpScale(this.getWorldScale())
+        };
+        if (this.editorData?.displayName) {
+            description.displayName = this.editorData.displayName;
+        }
+        if (this.editorData?.description) {
+            description.description = this.editorData.description;
+        }
+        this.calcBoundingBox();
+        const boundingBox = this.getBoundingBox();
+        if (!boundingBox.isEmpty()) {
+            description.boundingBox = DescriptionHelper.dumpBoundingBox(this.getBoundingBox());
+        }
+        const describeSceneComponent = (component) => {
+            const componentDescription = component.describe({ recalculateBounds: false, includeDetails: options?.includeComponentsDetails });
+            if (component.children && component.children.length > 0) {
+                const children = component.children.map(describeSceneComponent).filter(child => child && Object.keys(child).length > 0);
+                if (children.length > 0) {
+                    componentDescription.children = children;
+                }
+            }
+            return componentDescription;
+        };
+        description.rootComponent = describeSceneComponent(this.rootComponent);
+        return description;
+    }
+    isHiddenInGame() {
+        return this.hiddenInGame;
+    }
+    setHiddenInGame(hidden) {
+        this.hiddenInGame = hidden;
+        if (this.world) {
+            this.world.setActorHiddenInGame(this, hidden);
+        }
+    }
+    isEditorOnly() {
+        return this.editorOnly;
+    }
+    setEditorOnly(editorOnly) {
+        this.editorOnly = editorOnly;
+    }
+    /**
+     * Gets the camera used for rendering when this actor is the view target
+     * @returns The camera found
+     */
+    getCamera() {
+        return this.getComponent(THREE.Camera) ?? null;
+    }
+    /**
+     * Gets the player controller that controls this actor
+     * @returns The current player controller or null if none
+     */
+    getPlayerController() {
+        return null;
+    }
+    /**
+     * Return if this actor is player controlled
+     */
+    isPlayerControlled() {
+        return !!this.getPlayerController();
+    }
+    async waitForComponentsToLoad() {
+        const components = this.getComponents(SceneComponent);
+        const asyncLoadables = components.filter(c => isAsyncLoadable(c));
+        const loadPromises = asyncLoadables.map(c => c.waitForLoad());
+        await Promise.all(loadPromises);
+    }
+    serialize(dumper) {
+        dumper.dumpValue('rootComponent', this.rootComponent, '_rootComponent');
+        dumper.dumpProperties(this);
+        if (this.isEditorOnly()) {
+            dumper.markEditorOnly();
+        }
+    }
+    deserialize(loader) {
+        const rootComponent = loader.loadValue('rootComponent', this.rootComponent);
+        if (rootComponent && rootComponent !== this.rootComponent) {
+            this.setRootComponent(rootComponent, false);
+        }
+        loader.loadProperties(this);
+    }
+    //====================================================================================================
+    // Editor Functions
+    //====================================================================================================
+    onEditorPropertyChanged(path, value, result) {
+        if (path === 'actorTags') {
+            this.setActorTags(value);
+        }
+    }
+    onEditorSelectedChanged(isSelected, selectedActors) {
+        this.getComponents(SceneComponent).forEach(sceneComponent => sceneComponent.onEditorSelectedChanged(isSelected, selectedActors));
+    }
+    onEditorAddToWorld() {
+        this.getComponents(SceneComponent).forEach(sceneComponent => sceneComponent.onEditorAddToWorld());
+    }
+    onEditorRemoveFromWorld() {
+        this.getComponents(SceneComponent).forEach(sceneComponent => sceneComponent.onEditorRemoveFromWorld());
+    }
+    getConfigurationWarnings() {
+        const warnings = [];
+        // Add any actor-specific warnings here
+        return warnings;
+    }
+    getEditorClassIcon() {
+        return 'Icon_Actor';
+    }
+};
+_a = ISerializableObjectTag;
+Object.defineProperty(Actor, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        actorTags: {
+            isTagProperty: true,
+        }
+    }
+});
+__decorate([
+    property({ editorOnly: true, hidden: true }),
+    __metadata("design:type", Object)
+], Actor.prototype, "editorData", void 0);
+__decorate([
+    property({ transientOnPrefab: true, readonly: true }),
+    __metadata("design:type", String)
+], Actor.prototype, "uuid", void 0);
+__decorate([
+    property({ ctorArg: 'ctorArgOnly' }),
+    __metadata("design:type", Object)
+], Actor.prototype, "ctorArgOptions", void 0);
+__decorate([
+    property({ default: false, category: 'Advanced' }),
+    __metadata("design:type", Boolean)
+], Actor.prototype, "hiddenInGame", void 0);
+__decorate([
+    property({ default: false, category: 'Advanced' }),
+    __metadata("design:type", Boolean)
+], Actor.prototype, "editorOnly", void 0);
+Actor = Actor_1 = __decorate([
+    EngineClass('Actor'),
+    __metadata("design:paramtypes", [Object])
+], Actor);
+export { Actor };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Actor.js","sourceRoot":"","sources":["../../../src/actors/Actor.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;;;;;;;;;;;;AAEH,OAAO,kBAAkB,CAAC;AAC1B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAC;AAE/B,OAAO,EAAE,kBAAkB,EAAE,MAAM,qCAAqC,CAAC;AACzE,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAChD,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAC5E,OAAO,EAAmB,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AACvE,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACjF,OAAO,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAC;AAChD,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,eAAe,EAAE,MAAM,4BAA4B,CAAC;AAC7D,OAAO,EAA8B,mBAAmB,EAAE,MAAM,qCAAqC,CAAC;AACtG,OAAO,EAAE,QAAQ,EAAE,MAAM,qCAAqC,CAAC;AAC/D,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,sBAAsB,EAAE,MAAM,wCAAwC,CAAC;AAChF,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AA8DtD;;;GAGG;AAEI,IAAM,KAAK,aAAX,MAAM,KAAoD,SAAQ,QAAQ;IAoF/E,MAAM,KAAK,eAAe;QACxB,OAAO;YACL,SAAS,EAAE,EAAE;SACL,CAAC;IACb,CAAC;IAED;;;SAGK;IACL,YAAqB,UAAoB,EAAc;QACrD,KAAK,EAAE,CAAC;QADE;;;;mBAAS,OAAO;WAA2B;QAlF9C;;;;mBAA2B,IAAI;WAAC;QAGlC;;;;mBAAkC,EAAE;WAAC;QAGnC;;;;mBAAe,SAAS,EAAE;WAAC;QAE3B;;;;;WAAa;QACd;;;;;WAA+B;QAC7B;;;;mBAAsB,IAAI;WAAC;QAC3B;;;;mBAAmB,CAAC;WAAC;QACrB;;;;mBAAmC,IAAI;WAAC;QACxC;;;;mBAAmC,IAAI;WAAC;QACxC;;;;mBAAuB,KAAK;WAAC;QAC7B;;;;mBAAiD,IAAI;WAAC;QAEhE,iCAAiC;QACvB;;;;mBAA4B,IAAI;WAAC;QACjC;;;;mBAAqC,IAAI;WAAC;QAC1C;;;;mBAAiE,IAAI;WAAC;QAGxE;;;;;WAAyB;QAEjC,kCAAkC;QAC3B;;;;mBAA6B,IAAI;WAAC;QAEjC;;;;mBAAqB,KAAK;WAAC;QACzB;;;;mBAAsB,EAAE;WAAC;QAG3B;;;;mBAAwB,KAAK;WAAC;QAE9B;;;;mBAAsB,KAAK;WAAC;QAEpC,kDAAkD;QAClC;;;;mBAA4C,IAAI,QAAQ,EAAwB;WAAC;QACjG,oDAAoD;QACpC;;;;mBAAsC,IAAI,QAAQ,EAAyB;WAAC;QAC5F,mDAAmD;QACnC;;;;mBAAuC,IAAI,QAAQ,EAAyB;WAAC;QAC7F,0CAA0C;QAC1B;;;;mBAAoC,IAAI,QAAQ,EAAiB;WAAC;QAClF,wCAAwC;QACxB;;;;mBAAkC,IAAI,QAAQ,EAAiB;WAAC;QAChF,wFAAwF;QACxE;;;;mBAAqC,IAAI,QAAQ,EAAiB;WAAC;QACnF,yCAAyC;QACzB;;;;mBAAgC,IAAI,QAAQ,EAAqC;WAAC;QAElG;;;WAGG;QACa;;;;mBAAwC,IAAI,QAAQ,EAAwE;WAAC;QAC7I;;;WAGG;QACa;;;;mBAAwC,IAAI,QAAQ,EAAwE;WAAC;QAC7I;;;WAGG;QACa;;;;mBAA8C,IAAI,QAAQ,EAAwE;WAAC;QACnJ;;;WAGG;QACa;;;;mBAAgD,IAAI,QAAQ,EAAwE;WAAC;QAcnJ,IAAI,CAAC,cAAc,GAAG,OAAO,CAAC;QAC9B,OAAO,GAAG,EAAE,GAAG,OAAK,CAAC,eAAe,EAAE,GAAG,OAAO,GAAG,CAAC;QACpD,IAAI,CAAC,IAAI,GAAG,kBAAkB,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAClD,IAAI,CAAC,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QACjE,IAAI,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;QAC1C,IAAI,aAAa,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,QAAQ,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;YAChE,aAAa,GAAG,SAAS,CAAC;QAC5B,CAAC;QACD,IAAI,aAAa,EAAE,CAAC;YAClB,IAAI,CAAC,cAAc,GAAG,aAAa,CAAC;YACpC,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;gBACrB,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YACrD,CAAC;YACD,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;gBACrB,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;YACrD,CAAC;YACD,IAAI,OAAO,CAAC,KAAK,EAAE,CAAC;gBAClB,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC;YAC/C,CAAC;QACH,CAAC;aAAM,CAAC;YACN,IAAI,CAAC,cAAc,GAAG,IAAI,cAAc,CAAC;gBACvC,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,QAAQ,EAAE,OAAO,CAAC,QAAQ;gBAC1B,KAAK,EAAE,OAAO,CAAC,KAAK;aACrB,CAAC,CAAC;QACL,CAAC;QACD,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAClC,KAAK,MAAM,SAAS,IAAI,OAAO,CAAC,eAAe,IAAI,EAAE,EAAE,CAAC;YACtD,IAAI,SAAS,YAAY,cAAc,EAAE,CAAC;gBACxC,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;YACpC,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,KAAK,CAAC,GAAG,SAAS,0BAA0B,CAAC,CAAC;YACxD,CAAC;QACH,CAAC;QAED,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAE3C,MAAM,gBAAgB,GAAI,OAAe,CAAC,UAAU,CAAC;QACrD,IAAI,gBAAgB,EAAE,CAAC;YACrB,IAAI,CAAC,UAAU,GAAG,gBAAgB,CAAC;QACrC,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,aAAa;QAClB,OAAO,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,OAAO,EAAE,KAAK,IAAI,IAAI,CAAC;IACxD,CAAC;IAED;;;OAGG;IACI,aAAa;QAClB,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED;;;OAGG;IACI,yBAAyB;QAC9B,OAAO,IAAI,CAAC,sBAAsB,CAAC;IACrC,CAAC;IAED;;;;;;OAMG;IACI,SAAS,CAAC,IAAY,EAAE,IAAqB,EAAE,gBAAkD;QACtG,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,sBAAsB,GAAG,gBAAgB,IAAI,IAAI,CAAC;QACvD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACI,WAAW;QAChB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC;QACvB,IAAI,CAAC,sBAAsB,GAAG,IAAI,CAAC;QACnC,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACI,YAAY;QACjB,OAAO,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,6CAA6C;IAC3E,CAAC;IAED;;;;OAIG;IACI,YAAY,CAAC,IAAc;QAChC,IAAI,CAAC,SAAS,GAAG,CAAC,GAAG,IAAI,CAAC,CAAC,CAAC,4CAA4C;QACxE,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,WAAW,CAAC,GAAW;QAC5B,IAAI,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAClC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC3B,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,cAAc,CAAC,GAAW;QAC/B,MAAM,KAAK,GAAG,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC;QAC1C,IAAI,KAAK,KAAK,CAAC,CAAC,EAAE,CAAC;YACjB,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;QAClC,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,WAAW,CAAC,GAAW;QAC5B,OAAO,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC;IACtC,CAAC;IAED;;;;OAIG;IACI,cAAc,CAAC,IAAc;QAClC,OAAO,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IACxD,CAAC;IAED;;;;OAIG;IACI,eAAe,CAAC,IAAc;QACnC,OAAO,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC;IACzD,CAAC;IAED;;;OAGG;IACI,YAAY,CAAC,SAAkB;QACpC,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;IAED;;;OAGG;IACI,WAAW;QAChB,OAAO,IAAI,CAAC,SAAS,CAAC;IACxB,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,KAAK,CAAC,gBAAgB,CAClC,UAAkB,EAClB,SAAuF,EACvF,UAA+B,EAAE,EACjC,QAAkB;QAElB,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;QACvC,IAAI,YAAY,CAAC,UAAU,CAAC,EAAE,CAAC;YAC7B,OAAO,MAAM,eAAe,CAAC,SAAS,CAAC;gBACrC,IAAI,EAAE;oBACJ,QAAQ,EAAE,SAAS,EAAE,QAAQ;oBAC7B,QAAQ,EAAE,SAAS,EAAE,QAAQ;oBAC7B,KAAK,EAAE,SAAS,EAAE,KAAK;iBACxB;gBACD,UAAU;aACX,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC;QACxB,CAAC;QAED,OAAO,iBAAiB,CAAC,UAAU,EAAE,OAAO,EAAE,EAAC,iBAAiB,EAAE;gBAChE,QAAQ,EAAE,SAAS,EAAE,QAAQ;gBAC7B,QAAQ,EAAE,SAAS,EAAE,QAAQ;gBAC7B,KAAK,EAAE,SAAS,EAAE,KAAK;aACxB,EAAC,CAAC,CAAC;IACN,CAAC;IAEM,iBAAiB;QACtB,OAAQ,IAAI,CAAC,WAA4B,CAAC,eAA2B,CAAC;IACxE,CAAC;IAED;;;;;OAKG;IACI,MAAM,CAAC,OAAkC,EAAE,eAAwB;QACxE,MAAM,UAAU,GAAwB;YACtC,UAAU,EAAE,IAAI,CAAC,UAAU;YAC3B,SAAS,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS;YACvE,YAAY,EAAE,IAAI,CAAC,YAAY,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;YAClD,UAAU,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS;SAC/C,CAAC;QAEF,yCAAyC;QACzC,MAAM,QAAQ,GAAG,mBAAmB,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC;QACvD,KAAK,MAAM,QAAQ,IAAI,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC;YAC7C,IAAI,QAAQ,IAAI,IAAI,EAAE,CAAC;gBACrB,UAAU,CAAC,QAAQ,CAAC,GAAI,IAAY,CAAC,QAAQ,CAAC,CAAC;YACjD,CAAC;QACH,CAAC;QAED,MAAM,IAAI,GAAoB;YAC5B,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,KAAK,EAAE,aAAa,CAAC,mBAAmB,CAAC,IAAI,CAAC;YAC9C,UAAU;SACX,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,OAAO,CAAC,YAAY,CAAC;YAC/B,GAAG,IAAI,CAAC,sBAAsB,EAAE;YAChC,aAAa,EAAE,IAAI,CAAC,aAAa;SAClC,EAAE,eAAe,CAAC,CAAC;QACpB,IAAI,CAAC,UAAU,GAAG,IAAI,CAAC,UAAU,IAAI,SAAS,CAAC;QAE/C,kEAAkE;QAClE,IAAI,IAAI,CAAC,UAAU,EAAE,gBAAgB,EAAE,CAAC;YACtC,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,UAAU,CAAC,gBAAgB,CAAC;QAC3D,CAAC;QAED,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;SAGK;IACE,OAAO,CAAC,YAAgC;QAC7C,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACH,IAAW,aAAa;QACtB,OAAO,IAAI,CAAC,cAAc,CAAC;IAC7B,CAAC;IAED;;;;SAIK;IACE,gBAAgB,CAAC,gBAAgC,EAAE,aAAsB;QAC9E,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;YACjC,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,CAAC,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,KAAK,IAAI,CAAC,EAAE,CAAC;YAClD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,IAAI,aAAa,EAAE,CAAC;YAClB,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YAC5D,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC;YAC5D,gBAAgB,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QACxD,CAAC;QAED,MAAM,gBAAgB,GAAG,IAAI,CAAC,aAAa,CAAC;QAC5C,gBAAgB,CAAC,gBAAgB,EAAE,CAAC;QACpC,gBAAgB,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAChC,IAAI,CAAC,cAAc,GAAG,gBAAgB,CAAC;QACvC,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAC3C,IAAI,IAAI,CAAC,SAAS,EAAE,EAAE,CAAC;YACrB,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC;QACjC,CAAC;QACD,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,gBAAgB,CAAC,CAAC;QACzC,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;OAGG;IACI,qBAAqB;QAC1B,IAAI,MAAM,CAAC,IAAI,CAAC,YAAY,EAAE,KAAK,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;YACzD,uEAAuE;YACvE,IAAI,aAAa,CAAC,yBAAyB,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,gBAAgB,IAAI,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;gBACjI,MAAM,KAAK,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;gBAC7C,IAAI,MAAM,CAAC,KAAK,YAAY,cAAc,CAAC,EAAE,CAAC;oBAC5C,KAAK,CAAC,gBAAgB,EAAE,CAAC;oBACzB,IAAI,CAAC,gBAAgB,CAAC,KAAuB,EAAE,IAAI,CAAC,CAAC;oBACrD,OAAO,IAAI,CAAC;gBACd,CAAC;YACH,CAAC;QACH,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC;IAED;;;SAGK;IACE,QAAQ,CAAC,KAAmB;QACjC,IAAI,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;YACnC,OAAO;QACT,CAAC;QACD,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC;QACnB,IAAI,KAAK,EAAE,CAAC;YACV,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC;IAED;;;SAGK;IACE,QAAQ;QACb,OAAO,IAAI,CAAC,KAAK,CAAC;IACpB,CAAC;IAED;;;SAGK;IACE,cAAc,CAAC,SAAiB;QACrC,IAAI,IAAI,CAAC,QAAQ,GAAG,CAAC,EAAE,CAAC;YACtB,IAAI,CAAC,QAAQ,IAAI,SAAS,CAAC;YAC3B,IAAI,IAAI,CAAC,QAAQ,IAAI,CAAC,EAAE,CAAC;gBACvB,IAAI,CAAC,OAAO,EAAE,CAAC;gBACf,OAAO;YACT,CAAC;QACH,CAAC;QAED,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,MAAM,kBAAkB,GAAG,IAAI,CAAC,iBAAiB,CAAC,uBAAuB,EAAE,CAAC;YAC5E,IAAI,kBAAkB,EAAE,CAAC;gBACvB,MAAM,eAAe,GAAG,oBAAoB,CAAC,aAAa,CAAC;oBACzD,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,QAAQ;oBACrC,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,UAAU;oBACvC,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC,KAAK;iBAChC,EAAE,kBAAkB,EAAE,oBAAoB,CAAC,SAAS,CAAC,CAAC;gBACvD,IAAI,CAAC,iBAAiB,CAAC;oBACrB,QAAQ,EAAE,eAAe,CAAC,QAAQ;oBAClC,QAAQ,EAAE,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC,iBAAiB,CAAC,eAAe,CAAC,QAAQ,CAAC;oBACvE,KAAK,EAAE,eAAe,CAAC,KAAK;iBAC7B,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,SAAS,CAAC,CAAC;QAC7C,IAAI,CAAC,gBAAgB,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;IAChD,CAAC;IAED;;;SAGK;IACE,eAAe,CAAC,SAAiB;QACtC,IAAI,CAAC,aAAa,CAAC,eAAe,CAAC,SAAS,CAAC,CAAC;QAC9C,IAAI,CAAC,iBAAiB,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,CAAC;QAC/C,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,IAAI,CAAC,iBAAiB,CAAC,iBAAiB,CAAC;gBACvC,SAAS,EAAE,oBAAoB,CAAC,WAAW,EAAE;gBAC7C,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,KAAK,EAAE;gBAC7C,QAAQ,EAAE,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,KAAK,EAAE;gBAC/C,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,KAAK,EAAE;aACxC,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED;;;SAGK;IACE,gBAAgB;QACrB,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,SAAS,EAAE,CAAC;IAChG,CAAC;IAED;;;SAGK;IACE,cAAc;QACnB,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,SAAS,EAAE,CAAC;IAC/F,CAAC;IAED;;;SAGK;IACE,WAAW;QAChB,OAAO,IAAI,KAAK,CAAC,OAAO,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAAC,eAAe,CAAC,IAAI,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC,SAAS,EAAE,CAAC;IAC/F,CAAC;IAED;;;SAGK;IACE,gBAAgB;QACrB,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC;IAC3D,CAAC;IAED;;;;SAIK;IACE,SAAS,CAAC,MAAe;QAC9B,IAAI,IAAI,CAAC,QAAQ,EAAE,KAAK,MAAM,EAAE,CAAC;YAC/B,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;QAC7C,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;SAGK;IACE,QAAQ;QACb,OAAO,IAAI,CAAC,aAAa,CAAC,QAAQ,EAAE,CAAC;IACvC,CAAC;IAED;;;;;OAKG;IACI,qBAAqB,CAAC,UAAmC,EAAE,sBAA+B,KAAK;QACpG,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,UAAU,EAAE,mBAAmB,CAAC,CAAC;QAC1E,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;OAKG;IACI,sBAAsB,CAAC,UAAmC,EAAE,sBAA+B,KAAK;QACrG,IAAI,CAAC,aAAa,CAAC,sBAAsB,CAAC,UAAU,EAAE,mBAAmB,CAAC,CAAC;QAC3E,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;;SAKK;IACE,iBAAiB,CAAC,MAAe,EAAE,sBAA+B,KAAK;QAC5E,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,MAAM,EAAE,mBAAmB,CAAC,CAAC;QAClE,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;SAGK;IACE,gBAAgB;QACrB,OAAO,CAAC,IAAI,CAAC,aAAa,YAAY,kBAAkB,CAAC,IAAI,IAAI,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC;IACrG,CAAC;IAED;;;OAGG;IACI,iBAAiB;QACtB,MAAM,QAAQ,GAAmC,EAAE,CAAC;QACpD,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC,CAAC;QACtD,OAAO;YACL,KAAK,EAAE,IAAI,CAAC,IAAI;YAChB,QAAQ;YACR,IAAI,EAAE;gBACJ,IAAI,EAAE,IAAI,CAAC,IAAI;aAChB;SACF,CAAC;IACJ,CAAC;IAED;;;OAGG;IACI,WAAW;QAChB,OAAO,IAAI,CAAC,QAAQ,CAAC;IACvB,CAAC;IAED;;;;OAIG;IACI,WAAW,CAAC,QAAgB;QACjC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,YAAY,CAAC,SAAyB;QAC3C,OAAO,IAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IAED;;;;OAIG;IACI,aAAa,CAAC,GAAG,UAA4B;QAClD,UAAU,CAAC,OAAO,CAAC,SAAS,CAAC,EAAE;YAC7B,IAAI,CAAC,aAAa,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACpC,CAAC,CAAC,CAAC;QACH,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;;;OAIG;IACI,YAAY,CAA2B,OAA2C,cAAqB;QAC5G,OAAO,IAAI,CAAC,aAAa,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;IAC/C,CAAC;IAGD;;;;OAIG;IACI,aAAa,CAA2B,OAA2C,cAAqB;QAC7G,OAAO,IAAI,CAAC,aAAa,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;IAChD,CAAC;IAED;;;OAGG;IACI,WAAW;QAChB,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,WAAW,EAAE,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;IAC7E,CAAC;IAED;;OAEG;IACI,OAAO;QACZ,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,KAAK,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAChC,CAAC;IACH,CAAC;IAED;;;OAGG;IACI,WAAW,CAAC,OAAuB;QACxC,IAAI,CAAC,OAAO,EAAE,CAAC;IACjB,CAAC;IAED;;;;OAIG;IACI,gBAAgB,CAAC,kBAA2B,KAAK;QACtD,OAAO,eAAe,CAAC,YAAY,CAAC,IAAI,EAAE,eAAe,CAAC,CAAC;IAC7D,CAAC;IAEM,oBAAoB;QACzB,OAAO,eAAe,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAC9C,CAAC;IAED;;;OAGG;IACI,iBAAiB,CAAC,SAAsF;QAC7G,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAC;IAClD,CAAC;IAED;;;OAGG;IACI,gBAAgB,CAAC,QAAuB;QAC7C,IAAI,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;IACvC,CAAC;IAED;;;OAGG;IACI,gBAAgB,CAAC,QAAqB;QAC3C,IAAI,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAC;IACvC,CAAC;IAED;;;OAGG;IACI,aAAa,CAAC,KAAoB;QACvC,IAAI,CAAC,iBAAiB,CAAC,EAAE,KAAK,EAAE,CAAC,CAAC;IACpC,CAAC;IAED;;;OAGG;IACI,kBAAkB,CAAC,UAA4B;QACpD,IAAI,CAAC,iBAAiB,CAAC,EAAE,QAAQ,EAAE,IAAI,KAAK,CAAC,KAAK,EAAE,CAAC,iBAAiB,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;IACxF,CAAC;IAED;;;OAGG;IACI,gBAAgB;QACrB,OAAO,IAAI,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC;IAC/C,CAAC;IAED;;;OAGG;IACI,gBAAgB;QACrB,OAAO,IAAI,CAAC,aAAa,CAAC,gBAAgB,EAAE,CAAC;IAC/C,CAAC;IAED;;;OAGG;IACI,aAAa;QAClB,OAAO,IAAI,CAAC,aAAa,CAAC,aAAa,EAAE,CAAC;IAC5C,CAAC;IAED;;;OAGG;IACI,kBAAkB;QACvB,OAAO,IAAI,CAAC,aAAa,CAAC,kBAAkB,EAAE,CAAC;IACjD,CAAC;IAED;;;OAGG;IACI,iBAAiB;QACtB,OAAO,IAAI,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;IAChD,CAAC;IAIM,cAAc,CAAC,QAAiB;QACrC,IAAI,CAAC,WAAW,GAAG,QAAQ,CAAC;IAC9B,CAAC;IAEM,aAAa;QAClB,OAAO,IAAI,CAAC,WAAW,CAAC;IAC1B,CAAC;IAEM,cAAc;QACnB,OAAO,GAAG,aAAa,CAAC,yBAAyB,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,GAAG,CAAC;IAC1E,CAAC;IAEM,oBAAoB,CAAC,QAAgB;QAC1C,IAAI,CAAC,iBAAiB,GAAG,QAAQ,CAAC;IACpC,CAAC;IAEM,oBAAoB,CAAC,QAAgB;QAC1C,IAAI,CAAC,iBAAiB,GAAG,QAAQ,CAAC;IACpC,CAAC;IAEM,cAAc;QACnB,OAAO,IAAI,CAAC,iBAAiB,IAAI,QAAQ,CAAC,WAAW,EAAE,CAAC;IAC1D,CAAC;IAEM,cAAc;QACnB,IAAI,IAAI,CAAC,iBAAiB,EAAE,CAAC;YAC3B,OAAO,IAAI,CAAC,iBAAiB,CAAC;QAChC,CAAC;QACD,MAAM,QAAQ,GAAG,IAAI,CAAC,QAAQ,EAAE,EAAE,QAAQ,CAAC;QAC3C,IAAI,CAAC,QAAQ,EAAE,CAAC;YACd,MAAM,IAAI,KAAK,CAAC,oDAAoD,CAAC,CAAC;QACxE,CAAC;QACD,OAAO,QAAQ,CAAC,QAAQ,CAAC;IAC3B,CAAC;IAEM,wBAAwB;QAC7B,OAAO,KAAK,CAAC;IACf,CAAC;IAEM,sBAAsB;QAC3B,OAAO,IAAI,CAAC,gBAAgB,EAAE,CAAC;IACjC,CAAC;IAEM,kBAAkB,CAAC,mBAAkC;QAC1D,MAAM,SAAS,GAAG,mBAAmB,CAAC,CAAC,CAAE,mBAAqC,CAAC,CAAC,CAAC,IAAI,CAAC;QACtF,MAAM,YAAY,GAAG,SAAS,EAAE,QAAQ,CAAC;QACzC,MAAM,YAAY,GAAG,SAAS,EAAE,QAAQ,CAAC;QACzC,MAAM,SAAS,GAAG,SAAS,EAAE,KAAK,CAAC;QACnC,MAAM,eAAe,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;QAC9D,MAAM,eAAe,GAAG,IAAI,CAAC,aAAa,CAAC,QAAQ,CAAC,OAAO,EAAE,CAAC;QAC9D,MAAM,YAAY,GAAG,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;QACxD,IAAI,SAAS;YACX,QAAQ,CAAC,mBAAmB,CAAC,YAAa,EAAE,eAAe,CAAC;YAC5D,QAAQ,CAAC,mBAAmB,CAAC,YAAa,EAAE,eAA2C,CAAC;YACxF,QAAQ,CAAC,mBAAmB,CAAC,SAAU,EAAE,YAAY,CAAC,EAAE,CAAC;YACzD,OAAO,IAAI,CAAC;QACd,CAAC;QACD,OAAO;YACL,QAAQ,EAAE,eAAe;YACzB,QAAQ,EAAE,eAAe;YACzB,KAAK,EAAE,YAAY;YACnB,SAAS,EAAE,oBAAoB,CAAC,WAAW,EAAE;SAC7B,CAAC;IACrB,CAAC;IAEM,kBAAkB,CAAC,YAAoB;QAC5C,MAAM,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,YAA6B,CAAC;QAC/E,IAAI,CAAC,iBAAiB,KAAK,IAAI,oBAAoB,EAAE,CAAC;QACtD,IAAI,CAAC,iBAAiB,CAAC,kBAAkB,CAAC;YACxC,SAAS;YACT,QAAQ,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC;YAClE,QAAQ,EAAE,IAAI,KAAK,CAAC,UAAU,EAAE,CAAC,YAAY,CAAC,IAAI,KAAK,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC;YACrG,KAAK,EAAE,IAAI,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC;SACvD,CAAC,CAAC;IACL,CAAC;IAEM,mBAAmB,CAAC,QAA+B;QACxD,IAAI,CAAC,aAAa,CAAC,mBAAmB,CAAC,QAAQ,EAAE,IAAI,CAAC,CAAC;QACvD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,sGAAsG;IAEtG;;;OAGG;IACO,sBAAsB;QAC9B,MAAM,aAAa,GAAG,IAAI,CAAC,aAAa,CAAC,WAAW,EAAE,CAAC;QACvD,OAAO;YACL,GAAG,IAAI,CAAC,OAAO;YACf,kFAAkF;YAClF,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,SAAS;YAC7D,QAAQ,EAAE,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC,CAAC,CAAC,SAAS;YAC7D,KAAK,EAAE,aAAa,CAAC,CAAC,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC,CAAC,CAAC,SAAS;YACvD,2GAA2G;YAC3G,eAAe,EAAE,SAAS;YAC1B,iBAAiB,EAAE,SAAS;YAC5B,2FAA2F;YAC3F,UAAU,EAAE,SAAS;SACtB,CAAC;IACJ,CAAC;IAEkB,WAAW;QAC5B,IAAI,CAAC,aAAa,CAAC,SAAS,EAAE,CAAC;QAC/B,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC9B,IAAI,CAAC,QAAQ,EAAE,EAAE,QAAQ,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC;QAC7C,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;YAC1B,IAAI,CAAC,QAAQ,EAAE,EAAE,oBAAoB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACpD,CAAC;IACH,CAAC;IAEkB,YAAY;QAC7B,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACjC,CAAC;IAEkB,SAAS;QAC1B,IAAI,IAAI,CAAC,cAAc,EAAE,EAAE,CAAC;YAC1B,IAAI,CAAC,QAAQ,EAAE,EAAE,oBAAoB,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACrD,CAAC;QACD,IAAI,CAAC,QAAQ,EAAE,EAAE,QAAQ,CAAC,eAAe,CAAC,IAAI,CAAC,CAAC;QAChD,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;QAC7B,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,CAAC,KAAK,GAAG,IAAI,CAAC;IACpB,CAAC;IAED,qDAAqD;IAC9C,eAAe;QACpB,IAAI,CAAC,aAAa,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;QAC3C,MAAM,eAAe,GAAG,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;QAC3D,KAAK,MAAM,SAAS,IAAI,eAAe,EAAE,CAAC;YACxC,SAAS,CAAC,eAAe,EAAE,CAAC;QAC9B,CAAC;QAED,OAAO,IAAI,CAAC,cAAc,EAAE,CAAC;IAC/B,CAAC;IAED,yDAAyD;IAClD,cAAc;QACnB,MAAM,GAAG,GAAG,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;QAC7B,MAAM,eAAe,GAAG,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;QAC3D,KAAK,MAAM,SAAS,IAAI,eAAe,EAAE,CAAC;YACxC,MAAM,YAAY,GAAG,SAAS,CAAC,WAAW,CAAC;YAC3C,IAAI,YAAY,EAAE,CAAC;gBACjB,GAAG,CAAC,KAAK,CAAC,YAAY,CAAC,CAAC;YAC1B,CAAC;QACH,CAAC;QACD,OAAO,GAAG,CAAC;IACb,CAAC;IAED;;;OAGG;IACI,QAAQ,CAAC,OAAiC;QAC/C,IAAI,OAAO,EAAE,eAAe,EAAE,CAAC;YAC7B,MAAM,iBAAiB,GAAQ;gBAC7B,IAAI,EAAE,IAAI,CAAC,IAAI;gBACf,IAAI,EAAE,IAAI,CAAC,IAAI;aAChB,CAAC;YAEF,IAAI,IAAI,CAAC,UAAU,EAAE,WAAW,EAAE,CAAC;gBACjC,iBAAiB,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC;YAC9D,CAAC;YAED,OAAO,iBAAiB,CAAC;QAC3B,CAAC;QAED,MAAM,WAAW,GAAQ;YACvB,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,SAAS,EAAE,aAAa,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,WAAW,CAAC,IAAI;YACpE,QAAQ,EAAE,iBAAiB,CAAC,YAAY,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACjE,QAAQ,EAAE,iBAAiB,CAAC,YAAY,CAAC,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACjE,KAAK,EAAE,iBAAiB,CAAC,SAAS,CAAC,IAAI,CAAC,aAAa,EAAE,CAAC;SACzD,CAAC;QAEF,IAAI,IAAI,CAAC,UAAU,EAAE,WAAW,EAAE,CAAC;YACjC,WAAW,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC;QACxD,CAAC;QAED,IAAI,IAAI,CAAC,UAAU,EAAE,WAAW,EAAE,CAAC;YACjC,WAAW,CAAC,WAAW,GAAG,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC;QACxD,CAAC;QAED,IAAI,CAAC,eAAe,EAAE,CAAC;QACvB,MAAM,WAAW,GAAG,IAAI,CAAC,cAAc,EAAE,CAAC;QAC1C,IAAI,CAAC,WAAW,CAAC,OAAO,EAAE,EAAE,CAAC;YAC3B,WAAW,CAAC,WAAW,GAAG,iBAAiB,CAAC,eAAe,CAAC,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;QACrF,CAAC;QAED,MAAM,sBAAsB,GAAG,CAAC,SAAyB,EAAE,EAAE;YAC3D,MAAM,oBAAoB,GAAG,SAAS,CAAC,QAAQ,CAAC,EAAE,iBAAiB,EAAE,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,wBAAwB,EAAE,CAAC,CAAC;YACjI,IAAI,SAAS,CAAC,QAAQ,IAAI,SAAS,CAAC,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;gBACxD,MAAM,QAAQ,GAAG,SAAS,CAAC,QAAQ,CAAC,GAAG,CAAC,sBAAsB,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,KAAK,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;gBACxH,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;oBACxB,oBAAoB,CAAC,QAAQ,GAAG,QAAQ,CAAC;gBAC3C,CAAC;YACH,CAAC;YACD,OAAO,oBAAoB,CAAC;QAC9B,CAAC,CAAC;QACF,WAAW,CAAC,aAAa,GAAG,sBAAsB,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;QAEvE,OAAO,WAAW,CAAC;IACrB,CAAC;IAEM,cAAc;QACnB,OAAO,IAAI,CAAC,YAAY,CAAC;IAC3B,CAAC;IACM,eAAe,CAAC,MAAe;QACpC,IAAI,CAAC,YAAY,GAAG,MAAM,CAAC;QAC3B,IAAI,IAAI,CAAC,KAAK,EAAE,CAAC;YACf,IAAI,CAAC,KAAK,CAAC,oBAAoB,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC;QAChD,CAAC;IACH,CAAC;IAEM,YAAY;QACjB,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAEM,aAAa,CAAC,UAAmB;QACtC,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC;IAC/B,CAAC;IAED;;;OAGG;IACI,SAAS;QACd,OAAO,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,IAAI,CAAC;IACjD,CAAC;IAED;;;OAGG;IACI,mBAAmB;QACxB,OAAO,IAAI,CAAC;IACd,CAAC;IAED;;OAEG;IACI,kBAAkB;QACvB,OAAO,CAAC,CAAC,IAAI,CAAC,mBAAmB,EAAE,CAAC;IACtC,CAAC;IAEM,KAAK,CAAC,uBAAuB;QAClC,MAAM,UAAU,GAAG,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC;QACtD,MAAM,cAAc,GAAG,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,eAAe,CAAC,CAAC,CAAC,CAAqB,CAAC;QACtF,MAAM,YAAY,GAAG,cAAc,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;QAC9D,MAAM,OAAO,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;IAClC,CAAC;IAEM,SAAS,CAAC,MAAc;QAC7B,MAAM,CAAC,SAAS,CAAC,eAAe,EAAE,IAAI,CAAC,aAAa,EAAE,gBAAgB,CAAC,CAAC;QACxE,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,IAAI,CAAC,YAAY,EAAE,EAAE,CAAC;YACxB,MAAM,CAAC,cAAc,EAAE,CAAC;QAC1B,CAAC;IACH,CAAC;IAEM,WAAW,CAAC,MAAc;QAC/B,MAAM,aAAa,GAAG,MAAM,CAAC,SAAS,CAAC,eAAe,EAAE,IAAI,CAAC,aAAa,CAAmB,CAAC;QAC9F,IAAI,aAAa,IAAI,aAAa,KAAK,IAAI,CAAC,aAAa,EAAE,CAAC;YAC1D,IAAI,CAAC,gBAAgB,CAAC,aAAa,EAAE,KAAK,CAAC,CAAC;QAC9C,CAAC;QACD,MAAM,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC;IAC9B,CAAC;IAED,sGAAsG;IACtG,mBAAmB;IACnB,sGAAsG;IAE/F,uBAAuB,CAAC,IAAY,EAAE,KAAU,EAAE,MAAmC;QAC1F,IAAI,IAAI,KAAK,WAAW,EAAE,CAAC;YACzB,IAAI,CAAC,YAAY,CAAC,KAAiB,CAAC,CAAC;QACvC,CAAC;IACH,CAAC;IAEM,uBAAuB,CAAC,UAAmB,EAAE,cAAuB;QACzE,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC,cAAc,CAAC,uBAAuB,CAAC,UAAU,EAAE,cAAc,CAAC,CAAC,CAAC;IACnI,CAAC;IAEM,kBAAkB;QACvB,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC,cAAc,CAAC,kBAAkB,EAAE,CAAC,CAAC;IACpG,CAAC;IAEM,uBAAuB;QAC5B,IAAI,CAAC,aAAa,CAAC,cAAc,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,CAAC,cAAc,CAAC,uBAAuB,EAAE,CAAC,CAAC;IACzG,CAAC;IAEM,wBAAwB;QAC7B,MAAM,QAAQ,GAAa,EAAE,CAAC;QAC9B,uCAAuC;QACvC,OAAO,QAAQ,CAAC;IAClB,CAAC;IAEM,kBAAkB;QACvB,OAAO,YAAY,CAAC;IACtB,CAAC;;KA5iCS,sBAAsB;AANhB;;;;WAAqC;QACnD,SAAS,EAAE;YACT,aAAa,EAAE,IAAI;SACpB;KACO;EAJuB,CAItB;AAKJ;IADN,QAAQ,CAAC,EAAC,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAC,CAAC;;yCACC;AAGnC;IADR,QAAQ,CAAC,EAAC,iBAAiB,EAAE,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAC,CAAC;;mCAChB;AAiB5B;IADP,QAAQ,CAAC,EAAE,OAAO,EAAE,aAAa,EAAE,CAAC;;6CACJ;AASzB;IADP,QAAQ,CAAC,EAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAC,CAAC;;2CACX;AAE9B;IADP,QAAQ,CAAC,EAAC,OAAO,EAAE,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAC,CAAC;;yCACb;AA9CzB,KAAK;IADjB,WAAW,CAAC,OAAO,CAAC;;GACR,KAAK,CAyjCjB"}