@babylonjs/viewer 7.40.1-alpha → 7.40.1

package/dist/chunks/KHR_interactivity-ClHXW_8S.esm.js

@@ -1,4033 +0,0 @@
-import { aT as RandomGUID, T as Tools, R as RegisterClass, u as Vector2, v as Vector3, ac as Vector4, a4 as Matrix, s as Color3, ab as Quaternion, m as Color4, am as __decorate, aq as serialize, aU as Observable, l as AbstractMesh, aV as PointerEventTypes, L as Logger, aP as unregisterGLTFExtension, aQ as registerGLTFExtension } from './index-CtkZLm9J.esm.js';
-import { G as GLTFPathToObjectConverter } from './gltfPathToObjectConverter-GcUmfOyo.esm.js';
-
-/**
- * @experimental
- * The type of a connection point - inpput or output.
- */
-var FlowGraphConnectionType;
-(function (FlowGraphConnectionType) {
-    FlowGraphConnectionType[FlowGraphConnectionType["Input"] = 0] = "Input";
-    FlowGraphConnectionType[FlowGraphConnectionType["Output"] = 1] = "Output";
-})(FlowGraphConnectionType || (FlowGraphConnectionType = {}));
-/**
- * @experimental
- * The base connection class.
- */
-class FlowGraphConnection {
-    constructor(name, _connectionType, 
-    /* @internal */ _ownerBlock) {
-        this._ownerBlock = _ownerBlock;
-        /** @internal */
-        this._connectedPoint = [];
-        /**
-         * A uniquely identifying string for the connection.
-         */
-        this.uniqueId = RandomGUID();
-        /**
-         * Used for parsing connections.
-         * @internal
-         */
-        // disable warning as this is used for parsing
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        this.connectedPointIds = [];
-        this.name = name;
-        this._connectionType = _connectionType;
-    }
-    /**
-     * The type of the connection
-     */
-    get connectionType() {
-        return this._connectionType;
-    }
-    /**
-     * @internal
-     * Override this to indicate if a point can connect to more than one point.
-     */
-    _isSingularConnection() {
-        return true;
-    }
-    /**
-     * Returns if a point is connected to any other point.
-     * @returns boolean indicating if the point is connected.
-     */
-    isConnected() {
-        return this._connectedPoint.length > 0;
-    }
-    /**
-     * Connects two connections together.
-     * @param point the connection to connect to.
-     */
-    connectTo(point) {
-        if (this._connectionType === point._connectionType) {
-            throw new Error(`Cannot connect two points of type ${this.connectionType}`);
-        }
-        if ((this._isSingularConnection() && this._connectedPoint.length > 0) || (point._isSingularConnection() && point._connectedPoint.length > 0)) {
-            throw new Error("Max number of connections for point reached");
-        }
-        this._connectedPoint.push(point);
-        point._connectedPoint.push(this);
-    }
-    /**
-     * Saves the connection to a JSON object.
-     * @param serializationObject the object to serialize to.
-     */
-    serialize(serializationObject = {}) {
-        serializationObject.uniqueId = this.uniqueId;
-        serializationObject.name = this.name;
-        serializationObject._connectionType = this._connectionType;
-        serializationObject.connectedPointIds = [];
-        serializationObject.className = this.getClassName();
-        for (const point of this._connectedPoint) {
-            serializationObject.connectedPointIds.push(point.uniqueId);
-        }
-    }
-    /**
-     * @returns class name of the connection.
-     */
-    getClassName() {
-        return "FGConnection";
-    }
-    /**
-     * Deserialize from a object into this
-     * @param serializationObject the object to deserialize from.
-     */
-    deserialize(serializationObject) {
-        this.uniqueId = serializationObject.uniqueId;
-        this.name = serializationObject.name;
-        this._connectionType = serializationObject._connectionType;
-        this.connectedPointIds = serializationObject.connectedPointIds;
-    }
-    /**
-     * Parses a connection from an object
-     * @param serializationObject the object to parse from.
-     * @param ownerBlock the block that owns the connection.
-     * @returns the parsed connection.
-     */
-    static Parse(serializationObject = {}, ownerBlock) {
-        const type = Tools.Instantiate(serializationObject.className);
-        const connection = new type(serializationObject.name, serializationObject._connectionType, ownerBlock);
-        connection.deserialize(serializationObject);
-        return connection;
-    }
-}
-
-/**
- * @experimental
- * Class that represents an integer value.
- */
-class FlowGraphInteger {
-    constructor(value) {
-        this.value = this._toInt(value);
-    }
-    /**
-     * Converts a float to an integer.
-     * @param n the float to convert
-     * @returns the result of n | 0 - converting it to a int
-     */
-    _toInt(n) {
-        return n | 0;
-    }
-    /**
-     * Adds two integers together.
-     * @param other the other integer to add
-     * @returns a FlowGraphInteger with the result of the addition
-     */
-    add(other) {
-        return new FlowGraphInteger(this.value + other.value);
-    }
-    /**
-     * Subtracts two integers.
-     * @param other the other integer to subtract
-     * @returns a FlowGraphInteger with the result of the subtraction
-     */
-    subtract(other) {
-        return new FlowGraphInteger(this.value - other.value);
-    }
-    /**
-     * Multiplies two integers.
-     * @param other the other integer to multiply
-     * @returns a FlowGraphInteger with the result of the multiplication
-     */
-    multiply(other) {
-        return new FlowGraphInteger(Math.imul(this.value, other.value));
-    }
-    /**
-     * Divides two integers.
-     * @param other the other integer to divide
-     * @returns a FlowGraphInteger with the result of the division
-     */
-    divide(other) {
-        return new FlowGraphInteger(this.value / other.value);
-    }
-    /**
-     * The class name of this type.
-     * @returns
-     */
-    getClassName() {
-        return FlowGraphInteger.ClassName;
-    }
-    /**
-     * Compares two integers for equality.
-     * @param other the other integer to compare
-     * @returns
-     */
-    equals(other) {
-        return this.value === other.value;
-    }
-    /**
-     * Parses a FlowGraphInteger from a serialization object.
-     * @param serializationObject
-     * @returns
-     */
-    static Parse(serializationObject) {
-        return new FlowGraphInteger(serializationObject.value);
-    }
-}
-FlowGraphInteger.ClassName = "FlowGraphInteger";
-RegisterClass("FlowGraphInteger", FlowGraphInteger);
-
-/**
- * A rich type represents extra information about a type,
- * such as its name and a default value constructor.
- * @experimental
- */
-class RichType {
-    constructor(
-    /**
-     * The name given to the type.
-     */
-    typeName, 
-    /**
-     * The default value of the type.
-     */
-    defaultValue) {
-        this.typeName = typeName;
-        this.defaultValue = defaultValue;
-    }
-    /**
-     * Serializes this rich type into a serialization object.
-     * @param serializationObject the object to serialize to
-     */
-    serialize(serializationObject) {
-        serializationObject.typeName = this.typeName;
-        serializationObject.defaultValue = this.defaultValue;
-    }
-    /**
-     * Parses a rich type from a serialization object.
-     * @param serializationObject a serialization object
-     * @returns the parsed rich type
-     */
-    static Parse(serializationObject) {
-        return new RichType(serializationObject.typeName, serializationObject.defaultValue);
-    }
-}
-const RichTypeAny = new RichType("any", undefined);
-const RichTypeNumber = new RichType("number", 0);
-const RichTypeBoolean = new RichType("boolean", false);
-const RichTypeVector2 = new RichType("Vector2", Vector2.Zero());
-const RichTypeVector3 = new RichType("Vector3", Vector3.Zero());
-new RichType("Vector4", Vector4.Zero());
-const RichTypeMatrix = new RichType("Matrix", Matrix.Identity());
-new RichType("Color3", Color3.Black());
-new RichType("Quaternion", Quaternion.Identity());
-const RichTypeFlowGraphInteger = new RichType("FlowGraphInteger", new FlowGraphInteger(0));
-
-/**
- * @experimental
- * Represents a connection point for data.
- * An unconnected input point can have a default value.
- * An output point will only have a value if it is connected to an input point. Furthermore,
- * if the point belongs to a "function" node, the node will run its function to update the value.
- */
-class FlowGraphDataConnection extends FlowGraphConnection {
-    /**
-     * Create a new data connection point.
-     * @param name
-     * @param connectionType
-     * @param ownerBlock
-     * @param richType
-     */
-    constructor(name, connectionType, ownerBlock, 
-    /**
-     * the type of the data in this block
-     */
-    richType) {
-        super(name, connectionType, ownerBlock);
-        this.richType = richType;
-    }
-    /**
-     * An output data block can connect to multiple input data blocks,
-     * but an input data block can only connect to one output data block.
-     * @returns true if the connection is singular
-     */
-    _isSingularConnection() {
-        return this.connectionType === 0 /* FlowGraphConnectionType.Input */;
-    }
-    /**
-     * Set the value of the connection in a specific context.
-     * @param value the value to set
-     * @param context the context to which the value is set
-     */
-    setValue(value, context) {
-        context._setConnectionValue(this, value);
-    }
-    /**
-     * Connect this point to another point.
-     * @param point the point to connect to.
-     */
-    connectTo(point) {
-        super.connectTo(point);
-    }
-    _getValueOrDefault(context) {
-        if (context._hasConnectionValue(this)) {
-            return context._getConnectionValue(this);
-        }
-        else {
-            return this.richType.defaultValue;
-        }
-    }
-    /**
-     * Gets the value of the connection in a specific context.
-     * @param context the context from which the value is retrieved
-     * @returns the value of the connection
-     */
-    getValue(context) {
-        if (this.connectionType === 1 /* FlowGraphConnectionType.Output */) {
-            context._notifyExecuteNode(this._ownerBlock);
-            this._ownerBlock._updateOutputs(context);
-            return this._getValueOrDefault(context);
-        }
-        if (!this.isConnected()) {
-            return this._getValueOrDefault(context);
-        }
-        else {
-            return this._connectedPoint[0].getValue(context);
-        }
-    }
-    /**
-     * @returns class name of the object.
-     */
-    getClassName() {
-        return "FGDataConnection";
-    }
-    /**
-     * Serializes this object.
-     * @param serializationObject the object to serialize to
-     */
-    serialize(serializationObject = {}) {
-        super.serialize(serializationObject);
-        serializationObject.richType = {};
-        this.richType.serialize(serializationObject.richType);
-    }
-    /**
-     * Parses a data connection from a serialized object.
-     * @param serializationObject the object to parse from
-     * @param ownerBlock the block that owns the connection
-     * @returns the parsed connection
-     */
-    static Parse(serializationObject, ownerBlock) {
-        const obj = FlowGraphConnection.Parse(serializationObject, ownerBlock);
-        obj.richType = RichType.Parse(serializationObject.richType);
-        return obj;
-    }
-}
-RegisterClass("FGDataConnection", FlowGraphDataConnection);
-
-function isMeshClassName(className) {
-    return (className === "Mesh" ||
-        className === "AbstractMesh" ||
-        className === "GroundMesh" ||
-        className === "InstanceMesh" ||
-        className === "LinesMesh" ||
-        className === "GoldbergMesh" ||
-        className === "GreasedLineMesh" ||
-        className === "TrailMesh");
-}
-function isVectorClassName(className) {
-    return className === "Vector2" || className === "Vector3" || className === "Vector4" || className === "Quaternion" || className === "Color3" || className === "Color4";
-}
-function parseVector(className, value) {
-    if (className === "Vector2") {
-        return Vector2.FromArray(value);
-    }
-    else if (className === "Vector3") {
-        return Vector3.FromArray(value);
-    }
-    else if (className === "Vector4") {
-        return Vector4.FromArray(value);
-    }
-    else if (className === "Quaternion") {
-        return Quaternion.FromArray(value);
-    }
-    else if (className === "Color3") {
-        return new Color3(value[0], value[1], value[2]);
-    }
-    else if (className === "Color4") {
-        return new Color4(value[0], value[1], value[2], value[3]);
-    }
-    else {
-        throw new Error(`Unknown vector class name ${className}`);
-    }
-}
-/**
- * The default function that serializes values in a context object to a serialization object
- * @param key the key where the value should be stored in the serialization object
- * @param value the value to store
- * @param serializationObject the object where the value will be stored
- */
-function defaultValueSerializationFunction(key, value, serializationObject) {
-    const className = value?.getClassName?.() ?? "";
-    if (isMeshClassName(className)) {
-        serializationObject[key] = {
-            name: value.name,
-            className,
-        };
-    }
-    else if (isVectorClassName(className)) {
-        serializationObject[key] = {
-            value: value.asArray(),
-            className,
-        };
-    }
-    else {
-        serializationObject[key] = value;
-    }
-}
-/**
- * The default function that parses values stored in a serialization object
- * @param key the key to the value that will be parsed
- * @param serializationObject the object that will be parsed
- * @param scene
- * @returns
- */
-function defaultValueParseFunction(key, serializationObject, scene) {
-    const intermediateValue = serializationObject[key];
-    let finalValue;
-    const className = intermediateValue?.className;
-    if (isMeshClassName(className)) {
-        finalValue = scene.getMeshByName(intermediateValue.name);
-    }
-    else if (isVectorClassName(className)) {
-        finalValue = parseVector(className, intermediateValue.value);
-    }
-    else if (className === "Matrix") {
-        finalValue = Matrix.FromArray(intermediateValue.value);
-    }
-    else if (className === FlowGraphInteger.ClassName) {
-        finalValue = FlowGraphInteger.Parse(intermediateValue);
-    }
-    else if (intermediateValue && intermediateValue.value !== undefined) {
-        finalValue = intermediateValue.value;
-    }
-    else {
-        finalValue = intermediateValue;
-    }
-    return finalValue;
-}
-/**
- * Given a name of a flow graph block class, return if this
- * class needs to be created with a path converter. Used in
- * parsing.
- * @param className the name of the flow graph block class
- * @returns a boolean indicating if the class needs a path converter
- */
-function needsPathConverter(className) {
-    // I am not using the ClassName property here because it was causing a circular dependency
-    // that jest didn't like!
-    return className === "FGSetPropertyBlock" || className === "FGGetPropertyBlock" || className === "FGPlayAnimationBlock" || className === "FGMeshPickEventBlock";
-}
-
-/**
- * @experimental
- * A block in a flow graph. The most basic form
- * of a block has inputs and outputs that contain
- * data.
- */
-class FlowGraphBlock {
-    /** Constructor is protected so only subclasses can be instantiated
-     * @param config optional configuration for this block
-     */
-    constructor(
-    /**
-     * the configuration of the block
-     */
-    config) {
-        this.config = config;
-        /**
-         * A randomly generated GUID for each block.
-         */
-        this.uniqueId = RandomGUID();
-        this.name = this.config?.name ?? this.getClassName();
-        this.dataInputs = [];
-        this.dataOutputs = [];
-    }
-    /**
-     * @internal
-     */
-    _updateOutputs(_context) {
-        // empty by default, overriden in data blocks
-    }
-    /**
-     * Registers a data input on the block.
-     * @param name the name of the input
-     * @param richType the type of the input
-     * @returns the created connection
-     */
-    registerDataInput(name, richType) {
-        const input = new FlowGraphDataConnection(name, 0 /* FlowGraphConnectionType.Input */, this, richType);
-        this.dataInputs.push(input);
-        return input;
-    }
-    /**
-     * Registers a data output on the block.
-     * @param name the name of the input
-     * @param richType the type of the input
-     * @returns the created connection
-     */
-    registerDataOutput(name, richType) {
-        const output = new FlowGraphDataConnection(name, 1 /* FlowGraphConnectionType.Output */, this, richType);
-        this.dataOutputs.push(output);
-        return output;
-    }
-    /**
-     * Given the name of a data input, returns the connection if it exists
-     * @param name the name of the input
-     * @returns the connection if it exists, undefined otherwise
-     */
-    getDataInput(name) {
-        return this.dataInputs.find((i) => i.name === name);
-    }
-    /**
-     * Given the name of a data output, returns the connection if it exists
-     * @param name the name of the output
-     * @returns the connection if it exists, undefined otherwise
-     */
-    getDataOutput(name) {
-        return this.dataOutputs.find((i) => i.name === name);
-    }
-    /**
-     * Serializes this block
-     * @param serializationObject the object to serialize to
-     * @param _valueSerializeFunction a function that serializes a specific value
-     */
-    serialize(serializationObject = {}, _valueSerializeFunction = defaultValueSerializationFunction) {
-        serializationObject.uniqueId = this.uniqueId;
-        serializationObject.config = {};
-        if (this.config) {
-            serializationObject.config["name"] = this.config.name;
-        }
-        serializationObject.dataInputs = [];
-        serializationObject.dataOutputs = [];
-        serializationObject.className = this.getClassName();
-        for (const input of this.dataInputs) {
-            const serializedInput = {};
-            input.serialize(serializedInput);
-            serializationObject.dataInputs.push(serializedInput);
-        }
-        for (const output of this.dataOutputs) {
-            const serializedOutput = {};
-            output.serialize(serializedOutput);
-            serializationObject.dataOutputs.push(serializedOutput);
-        }
-    }
-    /**
-     * Gets the class name of this block
-     * @returns the class name
-     */
-    getClassName() {
-        return "FGBlock";
-    }
-    /**
-     * Parses a block from a serialization object
-     * @param serializationObject the object to parse from
-     * @param parseOptions options for parsing the block
-     * @returns the parsed block
-     */
-    static Parse(serializationObject, parseOptions) {
-        const classType = Tools.Instantiate(serializationObject.className);
-        const parsedConfig = {};
-        const valueParseFunction = parseOptions.valueParseFunction ?? defaultValueParseFunction;
-        if (serializationObject.config) {
-            for (const key in serializationObject.config) {
-                parsedConfig[key] = valueParseFunction(key, serializationObject.config, parseOptions.scene);
-            }
-        }
-        if (needsPathConverter(serializationObject.className)) {
-            parsedConfig.pathConverter = parseOptions.pathConverter;
-        }
-        const obj = new classType(parsedConfig);
-        obj.uniqueId = serializationObject.uniqueId;
-        for (let i = 0; i < serializationObject.dataInputs.length; i++) {
-            const dataInput = obj.getDataInput(serializationObject.dataInputs[i].name);
-            if (dataInput) {
-                dataInput.deserialize(serializationObject.dataInputs[i]);
-            }
-            else {
-                throw new Error("Could not find data input with name " + serializationObject.dataInputs[i].name + " in block " + serializationObject.className);
-            }
-        }
-        for (let i = 0; i < serializationObject.dataOutputs.length; i++) {
-            const dataOutput = obj.getDataOutput(serializationObject.dataOutputs[i].name);
-            if (dataOutput) {
-                dataOutput.deserialize(serializationObject.dataOutputs[i]);
-            }
-            else {
-                throw new Error("Could not find data output with name " + serializationObject.dataOutputs[i].name + " in block " + serializationObject.className);
-            }
-        }
-        obj.metadata = serializationObject.metadata;
-        obj.deserialize && obj.deserialize(serializationObject);
-        return obj;
-    }
-}
-
-/**
- * @experimental
- * Represents a connection point for a signal.
- * When an output point is activated, it will activate the connected input point.
- * When an input point is activated, it will execute the block it belongs to.
- */
-class FlowGraphSignalConnection extends FlowGraphConnection {
-    /**
-     * @internal
-     * A signal input can be connected to more than one signal output,
-     * but a signal output can only connect to one signal input
-     * @returns true if the connection is singular
-     */
-    _isSingularConnection() {
-        return this.connectionType === 1 /* FlowGraphConnectionType.Output */;
-    }
-    /**
-     * @internal
-     */
-    _activateSignal(context) {
-        if (this.connectionType === 0 /* FlowGraphConnectionType.Input */) {
-            context._notifyExecuteNode(this._ownerBlock);
-            this._ownerBlock._execute(context, this);
-            context._increaseExecutionId();
-        }
-        else {
-            this._connectedPoint[0]?._activateSignal(context);
-        }
-    }
-}
-RegisterClass("FlowGraphSignalConnection", FlowGraphSignalConnection);
-
-/**
- * @experimental
- * A block that executes some action. Always has an input signal (which is not used by event blocks).
- * Can have one or more output signals.
- */
-class FlowGraphExecutionBlock extends FlowGraphBlock {
-    constructor(config) {
-        super(config);
-        this.signalInputs = [];
-        this.signalOutputs = [];
-        this.in = this._registerSignalInput("in");
-    }
-    _registerSignalInput(name) {
-        const input = new FlowGraphSignalConnection(name, 0 /* FlowGraphConnectionType.Input */, this);
-        this.signalInputs.push(input);
-        return input;
-    }
-    _registerSignalOutput(name) {
-        const output = new FlowGraphSignalConnection(name, 1 /* FlowGraphConnectionType.Output */, this);
-        this.signalOutputs.push(output);
-        return output;
-    }
-    /**
-     * Given a name of a signal input, return that input if it exists
-     * @param name the name of the input
-     * @returns if the input exists, the input. Otherwise, undefined.
-     */
-    getSignalInput(name) {
-        return this.signalInputs.find((input) => input.name === name);
-    }
-    /**
-     * Given a name of a signal output, return that input if it exists
-     * @param name the name of the input
-     * @returns if the input exists, the input. Otherwise, undefined.
-     */
-    getSignalOutput(name) {
-        return this.signalOutputs.find((output) => output.name === name);
-    }
-    /**
-     * Serializes this block
-     * @param serializationObject the object to serialize in
-     */
-    serialize(serializationObject = {}) {
-        super.serialize(serializationObject);
-        serializationObject.signalInputs = [];
-        serializationObject.signalOutputs = [];
-        for (const input of this.signalInputs) {
-            const serializedInput = {};
-            input.serialize(serializedInput);
-            serializationObject.signalInputs.push(serializedInput);
-        }
-        for (const output of this.signalOutputs) {
-            const serializedOutput = {};
-            output.serialize(serializedOutput);
-            serializationObject.signalOutputs.push(serializedOutput);
-        }
-    }
-    /**
-     * Deserializes from an object
-     * @param serializationObject the object to deserialize from
-     */
-    deserialize(serializationObject) {
-        for (let i = 0; i < serializationObject.signalInputs.length; i++) {
-            const signalInput = this.getSignalInput(serializationObject.signalInputs[i].name);
-            if (signalInput) {
-                signalInput.deserialize(serializationObject.signalInputs[i]);
-            }
-            else {
-                throw new Error("Could not find signal input with name " + serializationObject.signalInputs[i].name + " in block " + serializationObject.className);
-            }
-        }
-        for (let i = 0; i < serializationObject.signalOutputs.length; i++) {
-            const signalOutput = this.getSignalOutput(serializationObject.signalOutputs[i].name);
-            if (signalOutput) {
-                signalOutput.deserialize(serializationObject.signalOutputs[i]);
-            }
-            else {
-                throw new Error("Could not find signal output with name " + serializationObject.signalOutputs[i].name + " in block " + serializationObject.className);
-            }
-        }
-    }
-    /**
-     * @returns the class name
-     */
-    getClassName() {
-        return "FGExecutionBlock";
-    }
-}
-
-/**
- * An async execution block can start tasks that will be executed asynchronously.
- * It should also be responsible for clearing it in _cancelPendingTasks.
- * @experimental
- */
-class FlowGraphAsyncExecutionBlock extends FlowGraphExecutionBlock {
-    constructor(config) {
-        super(config);
-        this.out = this._registerSignalOutput("out");
-        this.done = this._registerSignalOutput("done");
-    }
-    /**
-     * @internal
-     * @param context
-     */
-    _startPendingTasks(context) {
-        this._preparePendingTasks(context);
-        context._addPendingBlock(this);
-    }
-}
-
-/**
- * @experimental
- * A type of block that listens to an event observable and activates
- * its output signal when the event is triggered.
- */
-class FlowGraphEventBlock extends FlowGraphAsyncExecutionBlock {
-    /**
-     * @internal
-     */
-    _execute(context) {
-        context._notifyExecuteNode(this);
-        this.out._activateSignal(context);
-    }
-}
-
-/**
- * @experimental
- * The context represents the current state and execution of the flow graph.
- * It contains both user-defined variables, which are derived from
- * a more general variable definition, and execution variables that
- * are set by the blocks.
- */
-class FlowGraphContext {
-    constructor(params) {
-        /**
-         * A randomly generated GUID for each context.
-         */
-        this.uniqueId = RandomGUID();
-        /**
-         * These are the variables defined by a user.
-         */
-        this._userVariables = {};
-        /**
-         * These are the variables set by the blocks.
-         */
-        this._executionVariables = {};
-        /**
-         * These are the values for the data connection points
-         */
-        this._connectionValues = {};
-        /**
-         * These are blocks that have currently pending tasks/listeners that need to be cleaned up.
-         */
-        this._pendingBlocks = [];
-        /**
-         * A monotonically increasing ID for each execution.
-         * Incremented for every block executed.
-         */
-        this._executionId = 0;
-        /**
-         * Observable that is triggered when a node is executed.
-         */
-        this.onNodeExecutedObservable = new Observable();
-        this._configuration = params;
-    }
-    /**
-     * Check if a user-defined variable is defined.
-     * @param name the name of the variable
-     * @returns true if the variable is defined
-     */
-    hasVariable(name) {
-        return name in this._userVariables;
-    }
-    /**
-     * Set a user-defined variable.
-     * @param name the name of the variable
-     * @param value the value of the variable
-     */
-    setVariable(name, value) {
-        this._userVariables[name] = value;
-    }
-    /**
-     * Get a user-defined variable.
-     * @param name the name of the variable
-     * @returns the value of the variable
-     */
-    getVariable(name) {
-        return this._userVariables[name];
-    }
-    /**
-     * Gets all user variables map
-     */
-    get userVariables() {
-        return this._userVariables;
-    }
-    _getUniqueIdPrefixedName(obj, name) {
-        return `${obj.uniqueId}_${name}`;
-    }
-    /**
-     * Set an internal execution variable
-     * @internal
-     * @param name
-     * @param value
-     */
-    _setExecutionVariable(block, name, value) {
-        this._executionVariables[this._getUniqueIdPrefixedName(block, name)] = value;
-    }
-    /**
-     * Get an internal execution variable
-     * @internal
-     * @param name
-     * @returns
-     */
-    _getExecutionVariable(block, name, defaultValue) {
-        if (this._hasExecutionVariable(block, name)) {
-            return this._executionVariables[this._getUniqueIdPrefixedName(block, name)];
-        }
-        else {
-            return defaultValue;
-        }
-    }
-    /**
-     * Delete an internal execution variable
-     * @internal
-     * @param block
-     * @param name
-     */
-    _deleteExecutionVariable(block, name) {
-        delete this._executionVariables[this._getUniqueIdPrefixedName(block, name)];
-    }
-    /**
-     * Check if an internal execution variable is defined
-     * @internal
-     * @param block
-     * @param name
-     * @returns
-     */
-    _hasExecutionVariable(block, name) {
-        return this._getUniqueIdPrefixedName(block, name) in this._executionVariables;
-    }
-    /**
-     * Check if a connection value is defined
-     * @internal
-     * @param connectionPoint
-     * @returns
-     */
-    _hasConnectionValue(connectionPoint) {
-        return connectionPoint.uniqueId in this._connectionValues;
-    }
-    /**
-     * Set a connection value
-     * @internal
-     * @param connectionPoint
-     * @param value
-     */
-    _setConnectionValue(connectionPoint, value) {
-        this._connectionValues[connectionPoint.uniqueId] = value;
-    }
-    /**
-     * Get a connection value
-     * @internal
-     * @param connectionPoint
-     * @returns
-     */
-    _getConnectionValue(connectionPoint) {
-        return this._connectionValues[connectionPoint.uniqueId];
-    }
-    /**
-     * Get the configuration
-     * @internal
-     * @param name
-     * @param value
-     */
-    get configuration() {
-        return this._configuration;
-    }
-    /**
-     * Add a block to the list of blocks that have pending tasks.
-     * @internal
-     * @param block
-     */
-    _addPendingBlock(block) {
-        this._pendingBlocks.push(block);
-    }
-    /**
-     * Remove a block from the list of blocks that have pending tasks.
-     * @internal
-     * @param block
-     */
-    _removePendingBlock(block) {
-        const index = this._pendingBlocks.indexOf(block);
-        if (index !== -1) {
-            this._pendingBlocks.splice(index, 1);
-        }
-    }
-    /**
-     * Clear all pending blocks.
-     * @internal
-     */
-    _clearPendingBlocks() {
-        for (const block of this._pendingBlocks) {
-            block._cancelPendingTasks(this);
-        }
-        this._pendingBlocks.length = 0;
-    }
-    /**
-     * @internal
-     * Function that notifies the node executed observable
-     * @param node
-     */
-    _notifyExecuteNode(node) {
-        this.onNodeExecutedObservable.notifyObservers(node);
-    }
-    /**
-     * @internal
-     */
-    _increaseExecutionId() {
-        this._executionId++;
-    }
-    /**
-     * A monotonically increasing ID for each execution.
-     * Incremented for every block executed.
-     */
-    get executionId() {
-        return this._executionId;
-    }
-    /**
-     * Serializes a context
-     * @param serializationObject the object to write the values in
-     * @param valueSerializationFunction a function to serialize complex values
-     */
-    serialize(serializationObject = {}, valueSerializationFunction = defaultValueSerializationFunction) {
-        serializationObject.uniqueId = this.uniqueId;
-        serializationObject._userVariables = {};
-        for (const key in this._userVariables) {
-            valueSerializationFunction(key, this._userVariables[key], serializationObject._userVariables);
-        }
-        serializationObject._connectionValues = {};
-        for (const key in this._connectionValues) {
-            valueSerializationFunction(key, this._connectionValues[key], serializationObject._connectionValues);
-        }
-    }
-    /**
-     * @returns the class name of the object.
-     */
-    getClassName() {
-        return "FGContext";
-    }
-    /**
-     * Parses a context
-     * @param serializationObject the object containing the context serialization values
-     * @param options the options for parsing the context
-     * @returns
-     */
-    static Parse(serializationObject, options) {
-        const result = options.graph.createContext();
-        const valueParseFunction = options.valueParseFunction ?? defaultValueParseFunction;
-        result.uniqueId = serializationObject.uniqueId;
-        for (const key in serializationObject._userVariables) {
-            const value = valueParseFunction(key, serializationObject._userVariables, result._configuration.scene);
-            result._userVariables[key] = value;
-        }
-        for (const key in serializationObject._connectionValues) {
-            const value = valueParseFunction(key, serializationObject._connectionValues, result._configuration.scene);
-            result._connectionValues[key] = value;
-        }
-        return result;
-    }
-}
-__decorate([
-    serialize()
-], FlowGraphContext.prototype, "uniqueId", void 0);
-
-/**
- * @internal
- * Returns if mesh1 is a descendant of mesh2
- * @param mesh1
- * @param mesh2
- * @returns
- */
-function _isADescendantOf(mesh1, mesh2) {
-    return !!(mesh1.parent && (mesh1.parent === mesh2 || _isADescendantOf(mesh1.parent, mesh2)));
-}
-
-/**
- * @experimental
- * A block that activates when a mesh is picked.
- */
-class FlowGraphMeshPickEventBlock extends FlowGraphEventBlock {
-    constructor(
-    /**
-     * the configuration of the block
-     */
-    config) {
-        super(config);
-        this.config = config;
-    }
-    _getReferencedMesh() {
-        const iAccessor = this.config.pathConverter.convert(this.config.path);
-        const mesh = iAccessor.info.getObject(iAccessor.object);
-        if (!mesh || !(mesh instanceof AbstractMesh)) {
-            throw new Error("Mesh pick event block requires a valid mesh");
-        }
-        return mesh;
-    }
-    /**
-     * @internal
-     */
-    _preparePendingTasks(context) {
-        let pickObserver = context._getExecutionVariable(this, "meshPickObserver");
-        if (!pickObserver) {
-            const mesh = this._getReferencedMesh();
-            context._setExecutionVariable(this, "mesh", mesh);
-            pickObserver = mesh.getScene().onPointerObservable.add((pointerInfo) => {
-                if (pointerInfo.type === PointerEventTypes.POINTERPICK &&
-                    pointerInfo.pickInfo?.pickedMesh &&
-                    (pointerInfo.pickInfo?.pickedMesh === mesh || _isADescendantOf(pointerInfo.pickInfo?.pickedMesh, mesh))) {
-                    this._execute(context);
-                }
-            });
-            const disposeObserver = mesh.onDisposeObservable.add(() => this._onDispose);
-            context._setExecutionVariable(this, "meshPickObserver", pickObserver);
-            context._setExecutionVariable(this, "meshDisposeObserver", disposeObserver);
-        }
-    }
-    _onDispose(context) {
-        this._cancelPendingTasks(context);
-        context._removePendingBlock(this);
-    }
-    /**
-     * @internal
-     */
-    _cancelPendingTasks(context) {
-        const mesh = context._getExecutionVariable(this, "mesh");
-        const pickObserver = context._getExecutionVariable(this, "meshPickObserver");
-        const disposeObserver = context._getExecutionVariable(this, "meshDisposeObserver");
-        mesh.getScene().onPointerObservable.remove(pickObserver);
-        mesh.onDisposeObservable.remove(disposeObserver);
-        context._deleteExecutionVariable(this, "mesh");
-        context._deleteExecutionVariable(this, "meshPickObserver");
-        context._deleteExecutionVariable(this, "meshDisposeObserver");
-    }
-    /**
-     * @returns class name of the block.
-     */
-    getClassName() {
-        return FlowGraphMeshPickEventBlock.ClassName;
-    }
-    /**
-     * Serializes the block to a JSON object.
-     * @param serializationObject the object to serialize to.
-     */
-    serialize(serializationObject) {
-        super.serialize(serializationObject);
-        serializationObject.config.path = this.config.path;
-    }
-}
-/**
- * Class name of the block.
- */
-FlowGraphMeshPickEventBlock.ClassName = "FGMeshPickEventBlock";
-RegisterClass(FlowGraphMeshPickEventBlock.ClassName, FlowGraphMeshPickEventBlock);
-
-var FlowGraphState;
-(function (FlowGraphState) {
-    /**
-     * The graph is stopped
-     */
-    FlowGraphState[FlowGraphState["Stopped"] = 0] = "Stopped";
-    /**
-     * The graph is running
-     */
-    FlowGraphState[FlowGraphState["Started"] = 1] = "Started";
-})(FlowGraphState || (FlowGraphState = {}));
-/**
- * @experimental
- * Class used to represent a flow graph.
- * A flow graph is a graph of blocks that can be used to create complex logic.
- * Blocks can be added to the graph and connected to each other.
- * The graph can then be started, which will init and start all of its event blocks.
- */
-class FlowGraph {
-    /**
-     * Construct a Flow Graph
-     * @param params construction parameters. currently only the scene
-     */
-    constructor(params) {
-        /** @internal */
-        this._eventBlocks = [];
-        this._executionContexts = [];
-        /**
-         * The state of the graph
-         */
-        this.state = 0 /* FlowGraphState.Stopped */;
-        this._scene = params.scene;
-        this._coordinator = params.coordinator;
-        this._sceneDisposeObserver = this._scene.onDisposeObservable.add(() => this.dispose());
-    }
-    /**
-     * Create a context. A context represents one self contained execution for the graph, with its own variables.
-     * @returns the context, where you can get and set variables
-     */
-    createContext() {
-        const context = new FlowGraphContext({ scene: this._scene, coordinator: this._coordinator });
-        this._executionContexts.push(context);
-        return context;
-    }
-    /**
-     * Returns the execution context at a given index
-     * @param index the index of the context
-     * @returns the execution context at that index
-     */
-    getContext(index) {
-        return this._executionContexts[index];
-    }
-    /**
-     * Add an event block. When the graph is started, it will start listening to events
-     * from the block and execute the graph when they are triggered.
-     * @param block the event block to be added
-     */
-    addEventBlock(block) {
-        this._eventBlocks.push(block);
-    }
-    /**
-     * Starts the flow graph. Initializes the event blocks and starts listening to events.
-     */
-    start() {
-        if (this.state === 1 /* FlowGraphState.Started */) {
-            return;
-        }
-        this.state = 1 /* FlowGraphState.Started */;
-        if (this._executionContexts.length === 0) {
-            this.createContext();
-        }
-        for (const context of this._executionContexts) {
-            const contextualOrder = this._getContextualOrder();
-            for (const block of contextualOrder) {
-                block._startPendingTasks(context);
-            }
-        }
-    }
-    _getContextualOrder() {
-        const order = [];
-        for (const block1 of this._eventBlocks) {
-            // If the block is a mesh pick, guarantee that picks of children meshes come before picks of parent meshes
-            if (block1.getClassName() === FlowGraphMeshPickEventBlock.ClassName) {
-                const mesh1 = block1._getReferencedMesh();
-                let i = 0;
-                for (; i < order.length; i++) {
-                    const block2 = order[i];
-                    const mesh2 = block2._getReferencedMesh();
-                    if (mesh1 && mesh2 && _isADescendantOf(mesh1, mesh2)) {
-                        break;
-                    }
-                }
-                order.splice(i, 0, block1);
-            }
-            else {
-                order.push(block1);
-            }
-        }
-        return order;
-    }
-    /**
-     * Disposes of the flow graph. Cancels any pending tasks and removes all event listeners.
-     */
-    dispose() {
-        if (this.state === 0 /* FlowGraphState.Stopped */) {
-            return;
-        }
-        this.state = 0 /* FlowGraphState.Stopped */;
-        for (const context of this._executionContexts) {
-            context._clearPendingBlocks();
-        }
-        this._executionContexts.length = 0;
-        this._eventBlocks.length = 0;
-        this._scene.onDisposeObservable.remove(this._sceneDisposeObserver);
-        this._sceneDisposeObserver = null;
-    }
-    /**
-     * Executes a function in all blocks of a flow graph, starting with the event blocks.
-     * @param visitor the function to execute.
-     */
-    visitAllBlocks(visitor) {
-        const visitList = [];
-        const idsAddedToVisitList = new Set();
-        for (const block of this._eventBlocks) {
-            visitList.push(block);
-            idsAddedToVisitList.add(block.uniqueId);
-        }
-        while (visitList.length > 0) {
-            const block = visitList.pop();
-            visitor(block);
-            for (const dataIn of block.dataInputs) {
-                for (const connection of dataIn._connectedPoint) {
-                    if (!idsAddedToVisitList.has(connection._ownerBlock.uniqueId)) {
-                        visitList.push(connection._ownerBlock);
-                        idsAddedToVisitList.add(connection._ownerBlock.uniqueId);
-                    }
-                }
-            }
-            if (block instanceof FlowGraphExecutionBlock) {
-                for (const signalOut of block.signalOutputs) {
-                    for (const connection of signalOut._connectedPoint) {
-                        if (!idsAddedToVisitList.has(connection._ownerBlock.uniqueId)) {
-                            visitList.push(connection._ownerBlock);
-                            idsAddedToVisitList.add(connection._ownerBlock.uniqueId);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    /**
-     * Serializes a graph
-     * @param serializationObject the object to write the values in
-     * @param valueSerializeFunction a function to serialize complex values
-     */
-    serialize(serializationObject = {}, valueSerializeFunction) {
-        serializationObject.allBlocks = [];
-        this.visitAllBlocks((block) => {
-            const serializedBlock = {};
-            block.serialize(serializedBlock);
-            serializationObject.allBlocks.push(serializedBlock);
-        });
-        serializationObject.executionContexts = [];
-        for (const context of this._executionContexts) {
-            const serializedContext = {};
-            context.serialize(serializedContext, valueSerializeFunction);
-            serializationObject.executionContexts.push(serializedContext);
-        }
-    }
-    /**
-     * Given a list of blocks, find an output data connection that has a specific unique id
-     * @param blocks a list of flow graph blocks
-     * @param uniqueId the unique id of a connection
-     * @returns the connection that has this unique id. throws an error if none was found
-     */
-    static GetDataOutConnectionByUniqueId(blocks, uniqueId) {
-        for (const block of blocks) {
-            for (const dataOut of block.dataOutputs) {
-                if (dataOut.uniqueId === uniqueId) {
-                    return dataOut;
-                }
-            }
-        }
-        throw new Error("Could not find data out connection with unique id " + uniqueId);
-    }
-    /**
-     * Given a list of blocks, find an input signal connection that has a specific unique id
-     * @param blocks a list of flow graph blocks
-     * @param uniqueId the unique id of a connection
-     * @returns the connection that has this unique id. throws an error if none was found
-     */
-    static GetSignalInConnectionByUniqueId(blocks, uniqueId) {
-        for (const block of blocks) {
-            if (block instanceof FlowGraphExecutionBlock) {
-                for (const signalIn of block.signalInputs) {
-                    if (signalIn.uniqueId === uniqueId) {
-                        return signalIn;
-                    }
-                }
-            }
-        }
-        throw new Error("Could not find signal in connection with unique id " + uniqueId);
-    }
-    /**
-     * Parses a graph from a given serialization object
-     * @param serializationObject the object where the values are written
-     * @param options options for parsing the graph
-     * @returns the parsed graph
-     */
-    static Parse(serializationObject, options) {
-        const graph = options.coordinator.createGraph();
-        const blocks = [];
-        const valueParseFunction = options.valueParseFunction ?? defaultValueParseFunction;
-        // Parse all blocks
-        for (const serializedBlock of serializationObject.allBlocks) {
-            const block = FlowGraphBlock.Parse(serializedBlock, { scene: options.coordinator.config.scene, pathConverter: options.pathConverter, valueParseFunction });
-            blocks.push(block);
-            if (block instanceof FlowGraphEventBlock) {
-                graph.addEventBlock(block);
-            }
-        }
-        // After parsing all blocks, connect them
-        for (const block of blocks) {
-            for (const dataIn of block.dataInputs) {
-                for (const serializedConnection of dataIn.connectedPointIds) {
-                    const connection = FlowGraph.GetDataOutConnectionByUniqueId(blocks, serializedConnection);
-                    dataIn.connectTo(connection);
-                }
-            }
-            if (block instanceof FlowGraphExecutionBlock) {
-                for (const signalOut of block.signalOutputs) {
-                    for (const serializedConnection of signalOut.connectedPointIds) {
-                        const connection = FlowGraph.GetSignalInConnectionByUniqueId(blocks, serializedConnection);
-                        signalOut.connectTo(connection);
-                    }
-                }
-            }
-        }
-        for (const serializedContext of serializationObject.executionContexts) {
-            FlowGraphContext.Parse(serializedContext, { graph, valueParseFunction });
-        }
-        return graph;
-    }
-}
-
-/**
- * This class holds all of the existing flow graphs and is responsible for creating new ones.
- * It also handles starting/stopping multiple graphs and communication between them through an Event Coordinator
- */
-class FlowGraphCoordinator {
-    constructor(
-    /**
-     * the configuration of the block
-     */
-    config) {
-        this.config = config;
-        this._flowGraphs = [];
-        this._customEventsMap = new Map();
-        // When the scene is disposed, dispose all graphs currently running on it.
-        this.config.scene.onDisposeObservable.add(() => {
-            this.dispose();
-        });
-        // Add itself to the SceneCoordinators list for the Inspector.
-        const coordinators = FlowGraphCoordinator.SceneCoordinators.get(this.config.scene) ?? [];
-        coordinators.push(this);
-    }
-    /**
-     * Creates a new flow graph and adds it to the list of existing flow graphs
-     * @returns a new flow graph
-     */
-    createGraph() {
-        const graph = new FlowGraph({ scene: this.config.scene, coordinator: this });
-        this._flowGraphs.push(graph);
-        return graph;
-    }
-    /**
-     * Removes a flow graph from the list of existing flow graphs and disposes it
-     * @param graph the graph to remove
-     */
-    removeGraph(graph) {
-        const index = this._flowGraphs.indexOf(graph);
-        if (index !== -1) {
-            graph.dispose();
-            this._flowGraphs.splice(index, 1);
-        }
-    }
-    /**
-     * Starts all graphs
-     */
-    start() {
-        this._flowGraphs.forEach((graph) => graph.start());
-    }
-    /**
-     * Disposes all graphs
-     */
-    dispose() {
-        this._flowGraphs.forEach((graph) => graph.dispose());
-        this._flowGraphs.length = 0;
-        // Remove itself from the SceneCoordinators list for the Inspector.
-        const coordinators = FlowGraphCoordinator.SceneCoordinators.get(this.config.scene) ?? [];
-        const index = coordinators.indexOf(this);
-        if (index !== -1) {
-            coordinators.splice(index, 1);
-        }
-    }
-    /**
-     * Serializes this coordinator to a JSON object.
-     * @param serializationObject the object to serialize to
-     * @param valueSerializeFunction the function to use to serialize the value
-     */
-    serialize(serializationObject, valueSerializeFunction) {
-        serializationObject._flowGraphs = [];
-        this._flowGraphs.forEach((graph) => {
-            const serializedGraph = {};
-            graph.serialize(serializedGraph, valueSerializeFunction);
-            serializationObject._flowGraphs.push(serializedGraph);
-        });
-    }
-    /**
-     * Parses a serialized coordinator.
-     * @param serializedObject the object to parse
-     * @param options the options to use when parsing
-     * @returns the parsed coordinator
-     */
-    static Parse(serializedObject, options) {
-        const valueParseFunction = options.valueParseFunction ?? defaultValueParseFunction;
-        const coordinator = new FlowGraphCoordinator({ scene: options.scene });
-        serializedObject._flowGraphs?.forEach((serializedGraph) => {
-            FlowGraph.Parse(serializedGraph, { coordinator, valueParseFunction, pathConverter: options.pathConverter });
-        });
-        return coordinator;
-    }
-    /**
-     * Gets the list of flow graphs
-     */
-    get flowGraphs() {
-        return this._flowGraphs;
-    }
-    /**
-     * Get an observable that will be notified when the event with the given id is fired.
-     * @param id the id of the event
-     * @returns the observable for the event
-     */
-    getCustomEventObservable(id) {
-        let observable = this._customEventsMap.get(id);
-        if (!observable) {
-            observable = new Observable();
-            this._customEventsMap.set(id, observable);
-        }
-        return observable;
-    }
-    /**
-     * Notifies the observable for the given event id with the given data.
-     * @param id the id of the event
-     * @param data the data to send with the event
-     */
-    notifyCustomEvent(id, data) {
-        const observable = this._customEventsMap.get(id);
-        if (observable) {
-            observable.notifyObservers(data);
-        }
-    }
-}
-/**
- * @internal
- * A list of all the coordinators per scene. Will be used by the inspector
- */
-FlowGraphCoordinator.SceneCoordinators = new Map();
-
-/**
- * @experimental
- * Block that triggers when a scene is ready.
- */
-class FlowGraphSceneReadyEventBlock extends FlowGraphEventBlock {
-    /**
-     * @internal
-     */
-    _preparePendingTasks(context) {
-        if (!context._getExecutionVariable(this, "sceneReadyObserver")) {
-            const scene = context.configuration.scene;
-            const contextObserver = scene.onReadyObservable.add(() => {
-                this._execute(context);
-            });
-            context._setExecutionVariable(this, "sceneReadyObserver", contextObserver);
-        }
-    }
-    /**
-     * @internal
-     */
-    _cancelPendingTasks(context) {
-        const contextObserver = context._getExecutionVariable(this, "sceneReadyObserver");
-        const scene = context.configuration.scene;
-        scene.onReadyObservable.remove(contextObserver);
-        context._deleteExecutionVariable(this, "sceneReadyObserver");
-    }
-    /**
-     * @returns class name of the block.
-     */
-    getClassName() {
-        return FlowGraphSceneReadyEventBlock.ClassName;
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphSceneReadyEventBlock.ClassName = "FGSceneReadyEventBlock";
-RegisterClass("FGSceneReadyEventBlock", FlowGraphSceneReadyEventBlock);
-
-/**
- * @experimental
- * Block that triggers on scene tick (before each render).
- */
-class FlowGraphSceneTickEventBlock extends FlowGraphEventBlock {
-    /**
-     * @internal
-     */
-    _preparePendingTasks(context) {
-        if (!context._getExecutionVariable(this, "sceneBeforeRender")) {
-            const scene = context.configuration.scene;
-            const contextObserver = scene.onBeforeRenderObservable.add(() => {
-                this._execute(context);
-            });
-            context._setExecutionVariable(this, "sceneBeforeRender", contextObserver);
-        }
-    }
-    /**
-     * @internal
-     */
-    _cancelPendingTasks(context) {
-        const contextObserver = context._getExecutionVariable(this, "sceneBeforeRender");
-        const scene = context.configuration.scene;
-        scene.onBeforeRenderObservable.remove(contextObserver);
-        context._deleteExecutionVariable(this, "sceneBeforeRender");
-    }
-    /**
-     * @returns class name of the block.
-     */
-    getClassName() {
-        return FlowGraphSceneTickEventBlock.ClassName;
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphSceneTickEventBlock.ClassName = "FGSceneTickEventBlock";
-RegisterClass(FlowGraphSceneTickEventBlock.ClassName, FlowGraphSceneTickEventBlock);
-
-/**
- * @experimental
- * An execution block that has an out signal. This signal is triggered when the synchronous execution of this block is done.
- * Most execution blocks will inherit from this, except for the ones that have multiple signals to be triggered.
- * (such as if blocks)
- */
-class FlowGraphExecutionBlockWithOutSignal extends FlowGraphExecutionBlock {
-    constructor(config) {
-        super(config);
-        this.out = this._registerSignalOutput("out");
-    }
-}
-
-/**
- * @experimental
- * Block that logs a message to the console.
- */
-class FlowGraphConsoleLogBlock extends FlowGraphExecutionBlockWithOutSignal {
-    constructor(config) {
-        super(config);
-        this.message = this.registerDataInput("message", RichTypeAny);
-    }
-    /**
-     * @internal
-     */
-    _execute(context) {
-        const messageValue = this.message.getValue(context);
-        Logger.Log(messageValue);
-        // activate the output flow block
-        this.out._activateSignal(context);
-    }
-    /**
-     * @returns class name of the block.
-     */
-    getClassName() {
-        return FlowGraphConsoleLogBlock.ClassName;
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphConsoleLogBlock.ClassName = "FGConsoleLogBlock";
-RegisterClass(FlowGraphConsoleLogBlock.ClassName, FlowGraphConsoleLogBlock);
-
-/**
- * The current state of the timer
- */
-var TimerState;
-(function (TimerState) {
-    /**
-     * Timer initialized, not yet started
-     */
-    TimerState[TimerState["INIT"] = 0] = "INIT";
-    /**
-     * Timer started and counting
-     */
-    TimerState[TimerState["STARTED"] = 1] = "STARTED";
-    /**
-     * Timer ended (whether aborted or time reached)
-     */
-    TimerState[TimerState["ENDED"] = 2] = "ENDED";
-})(TimerState || (TimerState = {}));
-/**
- * An advanced implementation of a timer class
- */
-class AdvancedTimer {
-    /**
-     * Will construct a new advanced timer based on the options provided. Timer will not start until start() is called.
-     * @param options construction options for this advanced timer
-     */
-    constructor(options) {
-        /**
-         * Will notify each time the timer calculates the remaining time
-         */
-        this.onEachCountObservable = new Observable();
-        /**
-         * Will trigger when the timer was aborted due to the break condition
-         */
-        this.onTimerAbortedObservable = new Observable();
-        /**
-         * Will trigger when the timer ended successfully
-         */
-        this.onTimerEndedObservable = new Observable();
-        /**
-         * Will trigger when the timer state has changed
-         */
-        this.onStateChangedObservable = new Observable();
-        this._observer = null;
-        this._breakOnNextTick = false;
-        this._tick = (payload) => {
-            const now = Date.now();
-            this._timer = now - this._startTime;
-            const data = {
-                startTime: this._startTime,
-                currentTime: now,
-                deltaTime: this._timer,
-                completeRate: this._timer / this._timeToEnd,
-                payload,
-            };
-            const shouldBreak = this._breakOnNextTick || this._breakCondition(data);
-            if (shouldBreak || this._timer >= this._timeToEnd) {
-                this._stop(data, shouldBreak);
-            }
-            else {
-                this.onEachCountObservable.notifyObservers(data);
-            }
-        };
-        this._setState(0 /* TimerState.INIT */);
-        this._contextObservable = options.contextObservable;
-        this._observableParameters = options.observableParameters ?? {};
-        this._breakCondition = options.breakCondition ?? (() => false);
-        this._timeToEnd = options.timeout;
-        if (options.onEnded) {
-            this.onTimerEndedObservable.add(options.onEnded);
-        }
-        if (options.onTick) {
-            this.onEachCountObservable.add(options.onTick);
-        }
-        if (options.onAborted) {
-            this.onTimerAbortedObservable.add(options.onAborted);
-        }
-    }
-    /**
-     * set a breaking condition for this timer. Default is to never break during count
-     * @param predicate the new break condition. Returns true to break, false otherwise
-     */
-    set breakCondition(predicate) {
-        this._breakCondition = predicate;
-    }
-    /**
-     * Reset ALL associated observables in this advanced timer
-     */
-    clearObservables() {
-        this.onEachCountObservable.clear();
-        this.onTimerAbortedObservable.clear();
-        this.onTimerEndedObservable.clear();
-        this.onStateChangedObservable.clear();
-    }
-    /**
-     * Will start a new iteration of this timer. Only one instance of this timer can run at a time.
-     *
-     * @param timeToEnd how much time to measure until timer ended
-     */
-    start(timeToEnd = this._timeToEnd) {
-        if (this._state === 1 /* TimerState.STARTED */) {
-            throw new Error("Timer already started. Please stop it before starting again");
-        }
-        this._timeToEnd = timeToEnd;
-        this._startTime = Date.now();
-        this._timer = 0;
-        this._observer = this._contextObservable.add(this._tick, this._observableParameters.mask, this._observableParameters.insertFirst, this._observableParameters.scope);
-        this._setState(1 /* TimerState.STARTED */);
-    }
-    /**
-     * Will force a stop on the next tick.
-     */
-    stop() {
-        if (this._state !== 1 /* TimerState.STARTED */) {
-            return;
-        }
-        this._breakOnNextTick = true;
-    }
-    /**
-     * Dispose this timer, clearing all resources
-     */
-    dispose() {
-        if (this._observer) {
-            this._contextObservable.remove(this._observer);
-        }
-        this.clearObservables();
-    }
-    _setState(newState) {
-        this._state = newState;
-        this.onStateChangedObservable.notifyObservers(this._state);
-    }
-    _stop(data, aborted = false) {
-        this._contextObservable.remove(this._observer);
-        this._setState(2 /* TimerState.ENDED */);
-        if (aborted) {
-            this.onTimerAbortedObservable.notifyObservers(data);
-        }
-        else {
-            this.onTimerEndedObservable.notifyObservers(data);
-        }
-    }
-}
-
-/**
- * @experimental
- * Block that provides two different output flows. One is started immediately once the block is executed,
- * and the other is executed after a set time. The timer for this block runs based on the scene's render loop.
- */
-class FlowGraphTimerBlock extends FlowGraphAsyncExecutionBlock {
-    constructor(config) {
-        super(config);
-        this.timeout = this.registerDataInput("timeout", RichTypeNumber);
-    }
-    _preparePendingTasks(context) {
-        const currentTimeout = this.timeout.getValue(context);
-        if (currentTimeout !== undefined && currentTimeout >= 0) {
-            const timers = context._getExecutionVariable(this, "runningTimers") || [];
-            const scene = context.configuration.scene;
-            const timer = new AdvancedTimer({
-                timeout: currentTimeout,
-                contextObservable: scene.onBeforeRenderObservable,
-                onEnded: () => this._onEnded(timer, context),
-            });
-            timer.start();
-            timers.push(timer);
-            context._setExecutionVariable(this, "runningTimers", timers);
-        }
-    }
-    /**
-     * @internal
-     */
-    _execute(context) {
-        this._startPendingTasks(context);
-        this.out._activateSignal(context);
-    }
-    _onEnded(timer, context) {
-        const timers = context._getExecutionVariable(this, "runningTimers") || [];
-        const index = timers.indexOf(timer);
-        if (index !== -1) {
-            timers.splice(index, 1);
-        }
-        else {
-            Tools.Warn("FlowGraphTimerBlock: Timer ended but was not found in the running timers list");
-        }
-        context._removePendingBlock(this);
-        this.done._activateSignal(context);
-    }
-    _cancelPendingTasks(context) {
-        const timers = context._getExecutionVariable(this, "runningTimers") || [];
-        for (const timer of timers) {
-            timer.dispose();
-        }
-        context._deleteExecutionVariable(this, "runningTimers");
-    }
-    /**
-     * @returns class name of the block.
-     */
-    getClassName() {
-        return FlowGraphTimerBlock.ClassName;
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphTimerBlock.ClassName = "FGTimerBlock";
-RegisterClass("FGTimerBlock", FlowGraphTimerBlock);
-
-/**
- * @experimental
- */
-class FlowGraphSendCustomEventBlock extends FlowGraphExecutionBlockWithOutSignal {
-    constructor(
-    /**
-     * the configuration of the block
-     */
-    config) {
-        super(config);
-        this.config = config;
-        for (let i = 0; i < this.config.eventData.length; i++) {
-            const dataName = this.config.eventData[i];
-            this.registerDataInput(dataName, RichTypeAny);
-        }
-    }
-    _execute(context) {
-        const eventId = this.config.eventId;
-        const eventDatas = this.dataInputs.map((port) => port.getValue(context));
-        context.configuration.coordinator.notifyCustomEvent(eventId, eventDatas);
-        this.out._activateSignal(context);
-    }
-    /**
-     * @returns class name of the block.
-     */
-    getClassName() {
-        return FlowGraphSendCustomEventBlock.ClassName;
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphSendCustomEventBlock.ClassName = "FGSendCustomEventBlock";
-RegisterClass("FGSendCustomEventBlock", FlowGraphSendCustomEventBlock);
-
-/**
- * @experimental
- * A block that receives a custom event. It saves the data sent in the eventData output.
- */
-class FlowGraphReceiveCustomEventBlock extends FlowGraphEventBlock {
-    constructor(
-    /**
-     * the configuration of the block
-     */
-    config) {
-        super(config);
-        this.config = config;
-        for (let i = 0; i < this.config.eventData.length; i++) {
-            const dataName = this.config.eventData[i];
-            this.registerDataOutput(dataName, RichTypeAny);
-        }
-    }
-    _preparePendingTasks(context) {
-        const observable = context.configuration.coordinator.getCustomEventObservable(this.config.eventId);
-        this._eventObserver = observable.add((eventDatas) => {
-            for (let i = 0; i < eventDatas.length; i++) {
-                this.dataOutputs[i].setValue(eventDatas[i], context);
-            }
-            this._execute(context);
-        });
-    }
-    _cancelPendingTasks(context) {
-        const observable = context.configuration.coordinator.getCustomEventObservable(this.config.eventId);
-        if (observable) {
-            observable.remove(this._eventObserver);
-        }
-        else {
-            Tools.Warn(`FlowGraphReceiveCustomEventBlock: Missing observable for event ${this.config.eventId}`);
-        }
-    }
-    /**
-     * @returns class name of the block.
-     */
-    getClassName() {
-        return FlowGraphReceiveCustomEventBlock.ClassName;
-    }
-    /**
-     * Serializes this block
-     * @param serializationObject the object to serialize to
-     */
-    serialize(serializationObject) {
-        super.serialize(serializationObject);
-        serializationObject.eventId = this.config.eventId;
-        serializationObject.eventData = this.config.eventData;
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphReceiveCustomEventBlock.ClassName = "FGReceiveCustomEventBlock";
-RegisterClass(FlowGraphReceiveCustomEventBlock.ClassName, FlowGraphReceiveCustomEventBlock);
-
-/**
- * @experimental
- * A block that executes its output flows in sequence.
- */
-class FlowGraphSequenceBlock extends FlowGraphExecutionBlock {
-    constructor(
-    /**
-     * the configuration of the block
-     */
-    config) {
-        super(config);
-        this.config = config;
-        this.outFlows = [];
-        for (let i = 0; i < this.config.numberOutputFlows; i++) {
-            this.outFlows.push(this._registerSignalOutput(`${i}`));
-        }
-    }
-    _execute(context) {
-        for (let i = 0; i < this.config.numberOutputFlows; i++) {
-            this.outFlows[i]._activateSignal(context);
-        }
-    }
-    /**
-     * @returns class name of the block.
-     */
-    getClassName() {
-        return FlowGraphSequenceBlock.ClassName;
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphSequenceBlock.ClassName = "FGSequenceBlock";
-RegisterClass(FlowGraphSequenceBlock.ClassName, FlowGraphSequenceBlock);
-
-const pathHasTemplatesRegex = new RegExp(/\{(\w+)\}/g);
-/**
- * @experimental
- * A component that converts a path to an object accessor.
- */
-class FlowGraphPathConverterComponent {
-    constructor(path, ownerBlock) {
-        this.path = path;
-        this.ownerBlock = ownerBlock;
-        /**
-         * The templated inputs for the provided path.
-         */
-        this.templatedInputs = [];
-        let match = pathHasTemplatesRegex.exec(path);
-        while (match) {
-            const [, matchGroup] = match;
-            this.templatedInputs.push(ownerBlock.registerDataInput(matchGroup, RichTypeFlowGraphInteger));
-            match = pathHasTemplatesRegex.exec(path);
-        }
-    }
-    getAccessor(pathConverter, context) {
-        let finalPath = this.path;
-        for (const templatedInput of this.templatedInputs) {
-            const valueToReplace = templatedInput.getValue(context).value;
-            finalPath = finalPath.replace(`{${templatedInput.name}}`, valueToReplace.toString());
-        }
-        return pathConverter.convert(finalPath);
-    }
-}
-
-/**
- * @experimental
- */
-class FlowGraphGetPropertyBlock extends FlowGraphBlock {
-    constructor(
-    /**
-     * the configuration of the block
-     */
-    config) {
-        super(config);
-        this.config = config;
-        this.value = this.registerDataOutput("value", RichTypeAny);
-        this.templateComponent = new FlowGraphPathConverterComponent(config.path, this);
-    }
-    _updateOutputs(context) {
-        const accessorContainer = this.templateComponent.getAccessor(this.config.pathConverter, context);
-        const value = accessorContainer.info.get(accessorContainer.object);
-        this.value.setValue(value, context);
-    }
-    /**
-     * Gets the class name of this block
-     * @returns the class name
-     */
-    getClassName() {
-        return FlowGraphGetPropertyBlock.ClassName;
-    }
-    /**
-     * Serializes this block
-     * @param serializationObject the object to serialize to
-     */
-    serialize(serializationObject = {}) {
-        super.serialize(serializationObject);
-        serializationObject.config.path = this.config.path;
-    }
-}
-/**
- * Class name of the block.
- */
-FlowGraphGetPropertyBlock.ClassName = "FGGetPropertyBlock";
-RegisterClass(FlowGraphGetPropertyBlock.ClassName, FlowGraphGetPropertyBlock);
-
-/**
- * @experimental
- * Block that sets a property on a target object.
- */
-class FlowGraphSetPropertyBlock extends FlowGraphExecutionBlockWithOutSignal {
-    constructor(
-    /**
-     * the configuration of the block
-     */
-    config) {
-        super(config);
-        this.config = config;
-        this.a = this.registerDataInput("a", RichTypeAny);
-        this.templateComponent = new FlowGraphPathConverterComponent(config.path, this);
-    }
-    _execute(context) {
-        const value = this.a.getValue(context);
-        const accessor = this.templateComponent.getAccessor(this.config.pathConverter, context);
-        accessor.info.set(value, accessor.object);
-        this.out._activateSignal(context);
-    }
-    /**
-     * Serializes the block to a JSON object.
-     * @param serializationObject the object to serialize to.
-     */
-    serialize(serializationObject = {}) {
-        super.serialize(serializationObject);
-        serializationObject.config.path = this.config.path;
-    }
-    /**
-     * @returns class name of the block.
-     */
-    getClassName() {
-        return FlowGraphSetPropertyBlock.ClassName;
-    }
-}
-/**
- * Class name of the block.
- */
-FlowGraphSetPropertyBlock.ClassName = "FGSetPropertyBlock";
-RegisterClass("FGSetPropertyBlock", FlowGraphSetPropertyBlock);
-
-const cacheName = "cachedOperationValue";
-const cacheExecIdName = "cachedExecutionId";
-/**
- * @experimental
- */
-class FlowGraphCachedOperationBlock extends FlowGraphBlock {
-    constructor(outputRichType, config) {
-        super(config);
-        this.value = this.registerDataOutput("value", outputRichType);
-    }
-    _updateOutputs(context) {
-        const cachedExecutionId = context._getExecutionVariable(this, cacheExecIdName);
-        const cachedValue = context._getExecutionVariable(this, cacheName);
-        if (cachedValue !== undefined && cachedExecutionId === context.executionId) {
-            this.value.setValue(cachedValue, context);
-        }
-        else {
-            const calculatedValue = this._doOperation(context);
-            context._setExecutionVariable(this, cacheName, calculatedValue);
-            context._setExecutionVariable(this, cacheExecIdName, context.executionId);
-            this.value.setValue(calculatedValue, context);
-        }
-    }
-}
-
-/**
- * @experimental
- * The base block for all binary operation blocks. Receives an input of type
- * LeftT, one of type RightT, and outputs a value of type ResultT.
- */
-class FlowGraphBinaryOperationBlock extends FlowGraphCachedOperationBlock {
-    constructor(leftRichType, rightRichType, resultRichType, _operation, _className, config) {
-        super(resultRichType, config);
-        this._operation = _operation;
-        this._className = _className;
-        this.a = this.registerDataInput("a", leftRichType);
-        this.b = this.registerDataInput("b", rightRichType);
-    }
-    /**
-     * the operation performed by this block
-     * @param context the graph context
-     * @returns the result of the operation
-     */
-    _doOperation(context) {
-        return this._operation(this.a.getValue(context), this.b.getValue(context));
-    }
-    /**
-     * Gets the class name of this block
-     * @returns the class name
-     */
-    getClassName() {
-        return this._className;
-    }
-}
-
-/**
- * @experimental
- * Block that outputs a value of type ResultT, resulting of an operation with no inputs.
- */
-class FlowGraphConstantOperationBlock extends FlowGraphCachedOperationBlock {
-    constructor(richType, _operation, _className, config) {
-        super(richType, config);
-        this._operation = _operation;
-        this._className = _className;
-    }
-    /**
-     * the operation performed by this block
-     * @param _context the graph context
-     * @returns the result of the operation
-     */
-    _doOperation(_context) {
-        return this._operation();
-    }
-    /**
-     * Gets the class name of this block
-     * @returns the class name
-     */
-    getClassName() {
-        return this._className;
-    }
-}
-
-/**
- * @experimental
- * The base block for all unary operation blocks. Receives an input of type InputT, and outputs a value of type ResultT.
- */
-class FlowGraphUnaryOperationBlock extends FlowGraphCachedOperationBlock {
-    constructor(inputRichType, resultRichType, _operation, _className, config) {
-        super(resultRichType, config);
-        this._operation = _operation;
-        this._className = _className;
-        this.a = this.registerDataInput("a", inputRichType);
-    }
-    /**
-     * the operation performed by this block
-     * @param context the graph context
-     * @returns the result of the operation
-     */
-    _doOperation(context) {
-        return this._operation(this.a.getValue(context));
-    }
-    /**
-     * Gets the class name of this block
-     * @returns the class name
-     */
-    getClassName() {
-        return this._className;
-    }
-}
-
-/**
- * @experimental
- * The base block for all ternary operation blocks.
- */
-class FlowGraphTernaryOperationBlock extends FlowGraphCachedOperationBlock {
-    constructor(t1Type, t2Type, t3Type, resultRichType, _operation, _className, config) {
-        super(resultRichType, config);
-        this._operation = _operation;
-        this._className = _className;
-        this.a = this.registerDataInput("a", t1Type);
-        this.b = this.registerDataInput("b", t2Type);
-        this.c = this.registerDataInput("c", t3Type);
-    }
-    /**
-     * the operation performed by this block
-     * @param context the graph context
-     * @returns the result of the operation
-     */
-    _doOperation(context) {
-        return this._operation(this.a.getValue(context), this.b.getValue(context), this.c.getValue(context));
-    }
-    /**
-     * Gets the class name of this block
-     * @returns the class name
-     */
-    getClassName() {
-        return this._className;
-    }
-}
-
-/**
- * @internal
- */
-function _getClassNameOf(v) {
-    if (v.getClassName) {
-        return v.getClassName();
-    }
-    return "";
-}
-/**
- * @internal
- * @returns
- */
-function _areSameVectorClass(className, className2) {
-    return (className === "Vector2" && className2 === "Vector2") || (className === "Vector3" && className2 === "Vector3") || (className === "Vector4" && className2 === "Vector4");
-}
-/**
- * @internal
- * @returns
- */
-function _areSameMatrixClass(className, className2) {
-    return className === "Matrix" && className2 === "Matrix";
-}
-/**
- * @internal
- * @returns
- */
-function _areSameIntegerClass(className, className2) {
-    return className === "FlowGraphInteger" && className2 === "FlowGraphInteger";
-}
-/**
- * @experimental
- * Polymorphic add block.
- */
-class FlowGraphAddBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicAdd(a, b), FlowGraphAddBlock.ClassName, config);
-    }
-    _polymorphicAdd(a, b) {
-        const aClassName = _getClassNameOf(a);
-        const bClassName = _getClassNameOf(b);
-        if (_areSameVectorClass(aClassName, bClassName) || _areSameMatrixClass(aClassName, bClassName) || _areSameIntegerClass(aClassName, bClassName)) {
-            return a.add(b);
-        }
-        else {
-            return a + b;
-        }
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphAddBlock.ClassName = "FGAddBlock";
-RegisterClass(FlowGraphAddBlock.ClassName, FlowGraphAddBlock);
-/**
- * @experimental
- * Polymorphic add block.
- */
-class FlowGraphSubtractBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicAdd(a, b), FlowGraphSubtractBlock.ClassName, config);
-    }
-    _polymorphicAdd(a, b) {
-        const aClassName = _getClassNameOf(a);
-        const bClassName = _getClassNameOf(b);
-        if (_areSameVectorClass(aClassName, bClassName) || _areSameIntegerClass(aClassName, bClassName)) {
-            return a.subtract(b);
-        }
-        else if (_areSameMatrixClass(aClassName, bClassName)) {
-            return a.add(b.scale(-1));
-        }
-        else {
-            return a - b;
-        }
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphSubtractBlock.ClassName = "FGSubBlock";
-RegisterClass(FlowGraphSubtractBlock.ClassName, FlowGraphSubtractBlock);
-/**
- * @experimental
- * Polymorphic multiply block.
- * In case of matrix, it is a component wise multiplication.
- */
-class FlowGraphMultiplyBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicMultiply(a, b), FlowGraphMultiplyBlock.ClassName, config);
-    }
-    _polymorphicMultiply(a, b) {
-        const aClassName = _getClassNameOf(a);
-        const bClassName = _getClassNameOf(b);
-        if (_areSameVectorClass(aClassName, bClassName) || _areSameIntegerClass(aClassName, bClassName)) {
-            return a.multiply(b);
-        }
-        else if (_areSameMatrixClass(aClassName, bClassName)) {
-            return Matrix.FromValues(a.m[0] * b.m[0], a.m[4] * b.m[4], a.m[8] * b.m[8], a.m[12] * b.m[12], a.m[1] * b.m[1], a.m[5] * b.m[5], a.m[9] * b.m[9], a.m[13] * b.m[13], a.m[2] * b.m[2], a.m[6] * b.m[6], a.m[10] * b.m[10], a.m[14] * b.m[14], a.m[3] * b.m[3], a.m[7] * b.m[7], a.m[11] * b.m[11], a.m[15] * b.m[15]);
-        }
-        else {
-            return a * b;
-        }
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphMultiplyBlock.ClassName = "FGMultiplyBlock";
-RegisterClass(FlowGraphMultiplyBlock.ClassName, FlowGraphMultiplyBlock);
-/**
- * @experimental
- * Polymorphic division block.
- */
-class FlowGraphDivideBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicDivide(a, b), FlowGraphDivideBlock.ClassName, config);
-    }
-    _polymorphicDivide(a, b) {
-        const aClassName = _getClassNameOf(a);
-        const bClassName = _getClassNameOf(b);
-        if (_areSameVectorClass(aClassName, bClassName) || _areSameIntegerClass(aClassName, bClassName)) {
-            return a.divide(b);
-        }
-        else if (_areSameMatrixClass(aClassName, bClassName)) {
-            return Matrix.FromValues(a.m[0] / b.m[0], a.m[4] / b.m[4], a.m[8] / b.m[8], a.m[12] / b.m[12], a.m[1] / b.m[1], a.m[5] / b.m[5], a.m[9] / b.m[9], a.m[13] / b.m[13], a.m[2] / b.m[2], a.m[6] / b.m[6], a.m[10] / b.m[10], a.m[14] / b.m[14], a.m[3] / b.m[3], a.m[7] / b.m[7], a.m[11] / b.m[11], a.m[15] / b.m[15]);
-        }
-        else {
-            return a / b;
-        }
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphDivideBlock.ClassName = "FGDivideBlock";
-RegisterClass(FlowGraphDivideBlock.ClassName, FlowGraphDivideBlock);
-/**
- * @experimental
- * Random number between 0 and 1.
- */
-class FlowGraphRandomBlock extends FlowGraphConstantOperationBlock {
-    constructor(config) {
-        super(RichTypeNumber, () => Math.random(), FlowGraphRandomBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphRandomBlock.ClassName = "FGRandomBlock";
-RegisterClass(FlowGraphRandomBlock.ClassName, FlowGraphRandomBlock);
-/**
- * @experimental
- * Dot product block.
- */
-class FlowGraphDotBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeNumber, (a, b) => this._polymorphicDot(a, b), FlowGraphDotBlock.ClassName, config);
-    }
-    _polymorphicDot(a, b) {
-        const className = _getClassNameOf(a);
-        switch (className) {
-            case "Vector2":
-                return Vector2.Dot(a, b);
-            case "Vector3":
-                return Vector3.Dot(a, b);
-            case "Vector4":
-                return Vector4.Dot(a, b);
-            default:
-                throw new Error(`Cannot get dot product of ${a} and ${b}`);
-        }
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphDotBlock.ClassName = "FGDotBlock";
-RegisterClass(FlowGraphDotBlock.ClassName, FlowGraphDotBlock);
-/**
- * @experimental
- * E constant.
- */
-class FlowGraphEBlock extends FlowGraphConstantOperationBlock {
-    constructor(config) {
-        super(RichTypeNumber, () => Math.E, FlowGraphEBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphEBlock.ClassName = "FGEBlock";
-RegisterClass(FlowGraphEBlock.ClassName, FlowGraphEBlock);
-/**
- * @experimental
- * Pi constant.
- */
-class FlowGraphPiBlock extends FlowGraphConstantOperationBlock {
-    constructor(config) {
-        super(RichTypeNumber, () => Math.PI, FlowGraphPiBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphPiBlock.ClassName = "FGPIBlock";
-RegisterClass(FlowGraphPiBlock.ClassName, FlowGraphPiBlock);
-/**
- * @experimental
- * Positive inf constant.
- */
-class FlowGraphInfBlock extends FlowGraphConstantOperationBlock {
-    constructor(config) {
-        super(RichTypeNumber, () => Number.POSITIVE_INFINITY, FlowGraphInfBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphInfBlock.ClassName = "FGInfBlock";
-RegisterClass(FlowGraphInfBlock.ClassName, FlowGraphInfBlock);
-/**
- * @experimental
- * NaN constant.
- */
-class FlowGraphNaNBlock extends FlowGraphConstantOperationBlock {
-    constructor(config) {
-        super(RichTypeNumber, () => Number.NaN, FlowGraphNaNBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphNaNBlock.ClassName = "FGNaNBlock";
-RegisterClass(FlowGraphNaNBlock.ClassName, FlowGraphNaNBlock);
-function _componentWiseUnaryOperation(a, op) {
-    const aClassName = _getClassNameOf(a);
-    switch (aClassName) {
-        case "FlowGraphInteger":
-            return new FlowGraphInteger(op(a.value));
-        case "Vector2":
-            return new Vector2(op(a.x), op(a.y));
-        case "Vector3":
-            return new Vector3(op(a.x), op(a.y), op(a.z));
-        case "Vector4":
-            return new Vector4(op(a.x), op(a.y), op(a.z), op(a.w));
-        case "Matrix":
-            return Matrix.FromValues(op(a.m[0]), op(a.m[4]), op(a.m[8]), op(a.m[12]), op(a.m[1]), op(a.m[5]), op(a.m[9]), op(a.m[13]), op(a.m[2]), op(a.m[6]), op(a.m[10]), op(a.m[14]), op(a.m[3]), op(a.m[7]), op(a.m[11]), op(a.m[15]));
-        default:
-            return op(a);
-    }
-}
-/**
- * @experimental
- * Absolute value block.
- */
-class FlowGraphAbsBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicAbs(a), FlowGraphAbsBlock.ClassName, config);
-    }
-    _polymorphicAbs(a) {
-        return _componentWiseUnaryOperation(a, Math.abs);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphAbsBlock.ClassName = "FGAbsBlock";
-RegisterClass(FlowGraphAbsBlock.ClassName, FlowGraphAbsBlock);
-/**
- * @experimental
- * Sign block.
- */
-class FlowGraphSignBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicSign(a), FlowGraphSignBlock.ClassName, config);
-    }
-    _polymorphicSign(a) {
-        return _componentWiseUnaryOperation(a, Math.sign);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphSignBlock.ClassName = "FGSignBlock";
-RegisterClass(FlowGraphSignBlock.ClassName, FlowGraphSignBlock);
-/**
- * @experimental
- * Truncation block.
- */
-class FlowGraphTruncBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicTrunc(a), FlowGraphTruncBlock.ClassName, config);
-    }
-    _polymorphicTrunc(a) {
-        return _componentWiseUnaryOperation(a, Math.trunc);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphTruncBlock.ClassName = "FGTruncBlock";
-RegisterClass(FlowGraphTruncBlock.ClassName, FlowGraphTruncBlock);
-/**
- * @experimental
- * Floor block.
- */
-class FlowGraphFloorBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicFloor(a), FlowGraphFloorBlock.ClassName, config);
-    }
-    _polymorphicFloor(a) {
-        return _componentWiseUnaryOperation(a, Math.floor);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphFloorBlock.ClassName = "FGFloorBlock";
-RegisterClass(FlowGraphFloorBlock.ClassName, FlowGraphFloorBlock);
-/**
- * @experimental
- * Ceiling block.
- */
-class FlowGraphCeilBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicCeiling(a), FlowGraphCeilBlock.ClassName, config);
-    }
-    _polymorphicCeiling(a) {
-        return _componentWiseUnaryOperation(a, Math.ceil);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphCeilBlock.ClassName = "FGCeilBlock";
-RegisterClass(FlowGraphCeilBlock.ClassName, FlowGraphCeilBlock);
-/**
- * @experimental
- * Fract block.
- */
-class FlowGraphFractBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicFract(a), FlowGraphFractBlock.ClassName, config);
-    }
-    _polymorphicFract(a) {
-        return _componentWiseUnaryOperation(a, (a) => a - Math.floor(a));
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphFractBlock.ClassName = "FGFractBlock";
-RegisterClass(FlowGraphFractBlock.ClassName, FlowGraphFractBlock);
-/**
- * @experimental
- * Negation block.
- */
-class FlowGraphNegBlock extends FlowGraphUnaryOperationBlock {
-    /**
-     * construct a new negation block.
-     * @param config optional configuration
-     */
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicNeg(a), FlowGraphNegBlock.ClassName, config);
-    }
-    _polymorphicNeg(a) {
-        return _componentWiseUnaryOperation(a, (a) => -a);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphNegBlock.ClassName = "FGNegBlock";
-RegisterClass(FlowGraphNegBlock.ClassName, FlowGraphNegBlock);
-function _componentWiseBinaryOperation(a, b, op) {
-    const aClassName = _getClassNameOf(a);
-    switch (aClassName) {
-        case "FlowGraphInteger":
-            return new FlowGraphInteger(op(a.value, b.value));
-        case "Vector2":
-            return new Vector2(op(a.x, b.x), op(a.y, b.y));
-        case "Vector3":
-            return new Vector3(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z));
-        case "Vector4":
-            return new Vector4(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z), op(a.w, b.w));
-        case "Matrix":
-            return Matrix.FromValues(op(a.m[0], b.m[0]), op(a.m[4], b.m[4]), op(a.m[8], b.m[8]), op(a.m[12], b.m[12]), op(a.m[1], b.m[1]), op(a.m[5], b.m[5]), op(a.m[9], b.m[9]), op(a.m[13], b.m[13]), op(a.m[2], b.m[2]), op(a.m[6], b.m[6]), op(a.m[10], b.m[10]), op(a.m[14], b.m[14]), op(a.m[3], b.m[3]), op(a.m[7], b.m[7]), op(a.m[11], b.m[11]), op(a.m[15], b.m[15]));
-        default:
-            return op(a, b);
-    }
-}
-/**
- * @experimental
- * Remainder block.
- */
-class FlowGraphRemainderBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicRemainder(a, b), FlowGraphRemainderBlock.ClassName, config);
-    }
-    _polymorphicRemainder(a, b) {
-        return _componentWiseBinaryOperation(a, b, (a, b) => a % b);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphRemainderBlock.ClassName = "FGRemainderBlock";
-RegisterClass(FlowGraphRemainderBlock.ClassName, FlowGraphRemainderBlock);
-/**
- * @experimental
- * Min block.
- */
-class FlowGraphMinBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicMin(a, b), FlowGraphMinBlock.ClassName, config);
-    }
-    _polymorphicMin(a, b) {
-        return _componentWiseBinaryOperation(a, b, Math.min);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphMinBlock.ClassName = "FGMinBlock";
-RegisterClass(FlowGraphMinBlock.ClassName, FlowGraphMinBlock);
-/**
- * @experimental
- * Max block
- */
-class FlowGraphMaxBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicMax(a, b), FlowGraphMaxBlock.ClassName, config);
-    }
-    _polymorphicMax(a, b) {
-        return _componentWiseBinaryOperation(a, b, Math.max);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphMaxBlock.ClassName = "FGMaxBlock";
-RegisterClass(FlowGraphMaxBlock.ClassName, FlowGraphMaxBlock);
-function _clamp(a, b, c) {
-    return Math.min(Math.max(a, Math.min(b, c)), Math.max(b, c));
-}
-function _componentWiseTernaryOperation(a, b, c, op) {
-    const aClassName = _getClassNameOf(a);
-    switch (aClassName) {
-        case "FlowGraphInteger":
-            return new FlowGraphInteger(op(a.value, b.value, c.value));
-        case "Vector2":
-            return new Vector2(op(a.x, b.x, c.x), op(a.y, b.y, c.y));
-        case "Vector3":
-            return new Vector3(op(a.x, b.x, c.x), op(a.y, b.y, c.y), op(a.z, b.z, c.z));
-        case "Vector4":
-            return new Vector4(op(a.x, b.x, c.x), op(a.y, b.y, c.y), op(a.z, b.z, c.z), op(a.w, b.w, c.w));
-        case "Matrix":
-            return Matrix.FromValues(op(a.m[0], b.m[0], c.m[0]), op(a.m[4], b.m[4], c.m[4]), op(a.m[8], b.m[8], c.m[8]), op(a.m[12], b.m[12], c.m[12]), op(a.m[1], b.m[1], c.m[1]), op(a.m[5], b.m[5], c.m[5]), op(a.m[9], b.m[9], c.m[9]), op(a.m[13], b.m[13], c.m[13]), op(a.m[2], b.m[2], c.m[2]), op(a.m[6], b.m[6], c.m[6]), op(a.m[10], b.m[10], c.m[10]), op(a.m[14], b.m[14], c.m[14]), op(a.m[3], b.m[3], c.m[3]), op(a.m[7], b.m[7], c.m[7]), op(a.m[11], b.m[11], c.m[11]), op(a.m[15], b.m[15], c.m[15]));
-        default:
-            return op(a, b, c);
-    }
-}
-/**
- * @experimental
- * Clamp block.
- */
-class FlowGraphClampBlock extends FlowGraphTernaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeAny, RichTypeAny, (a, b, c) => this._polymorphicClamp(a, b, c), FlowGraphClampBlock.ClassName, config);
-    }
-    _polymorphicClamp(a, b, c) {
-        return _componentWiseTernaryOperation(a, b, c, _clamp);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphClampBlock.ClassName = "FGClampBlock";
-RegisterClass(FlowGraphClampBlock.ClassName, FlowGraphClampBlock);
-function _saturate(a) {
-    return Math.min(Math.max(a, 0), 1);
-}
-/**
- * @experimental
- * Saturate block.
- */
-class FlowGraphSaturateBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicSaturate(a), FlowGraphSaturateBlock.ClassName, config);
-    }
-    _polymorphicSaturate(a) {
-        return _componentWiseUnaryOperation(a, _saturate);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphSaturateBlock.ClassName = "FGSaturateBlock";
-RegisterClass(FlowGraphSaturateBlock.ClassName, FlowGraphSaturateBlock);
-/**
- * @experimental
- * Interpolate block.
- */
-class FlowGraphInterpolateBlock extends FlowGraphTernaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeAny, RichTypeAny, (a, b, c) => this._polymorphicInterpolate(a, b, c), FlowGraphInterpolateBlock.ClassName, config);
-    }
-    _interpolate(a, b, c) {
-        return (1 - c) * a + c * b;
-    }
-    _polymorphicInterpolate(a, b, c) {
-        return _componentWiseTernaryOperation(a, b, c, this._interpolate);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphInterpolateBlock.ClassName = "FGInterpolateBlock";
-RegisterClass(FlowGraphInterpolateBlock.ClassName, FlowGraphInterpolateBlock);
-/**
- * @experimental
- * Equals block.
- */
-class FlowGraphEqBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeBoolean, (a, b) => this._polymorphicEq(a, b), FlowGraphEqBlock.ClassName, config);
-    }
-    _polymorphicEq(a, b) {
-        const aClassName = _getClassNameOf(a);
-        const bClassName = _getClassNameOf(b);
-        if (_areSameVectorClass(aClassName, bClassName) || _areSameMatrixClass(aClassName, bClassName) || _areSameIntegerClass(aClassName, bClassName)) {
-            return a.equals(b);
-        }
-        else {
-            return a === b;
-        }
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphEqBlock.ClassName = "FGEqBlock";
-RegisterClass(FlowGraphEqBlock.ClassName, FlowGraphEqBlock);
-function _comparisonOperators(a, b, op) {
-    const aClassName = _getClassNameOf(a);
-    const bClassName = _getClassNameOf(b);
-    if (aClassName === bClassName) {
-        // float
-        if (aClassName === "") {
-            return op(a, b);
-        }
-        else if (aClassName === "FlowGraphInteger") {
-            return op(a.value, b.value);
-        }
-        else {
-            throw new Error(`Cannot compare ${a} and ${b}`);
-        }
-    }
-    throw new Error(`${a} and ${b} are of different types.`);
-}
-/**
- * @experimental
- * Less than block.
- */
-class FlowGraphLessThanBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeBoolean, (a, b) => this._polymorphicLessThan(a, b), FlowGraphLessThanBlock.ClassName, config);
-    }
-    _polymorphicLessThan(a, b) {
-        return _comparisonOperators(a, b, (a, b) => a < b);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphLessThanBlock.ClassName = "FGLessThanBlock";
-RegisterClass(FlowGraphLessThanBlock.ClassName, FlowGraphLessThanBlock);
-/**
- * @experimental
- * Less than or equal block.
- */
-class FlowGraphLessThanOrEqualBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeBoolean, (a, b) => this._polymorphicLessThanOrEqual(a, b), FlowGraphLessThanOrEqualBlock.ClassName, config);
-    }
-    _polymorphicLessThanOrEqual(a, b) {
-        return _comparisonOperators(a, b, (a, b) => a <= b);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphLessThanOrEqualBlock.ClassName = "FGLessThanOrEqualBlock";
-/**
- * @experimental
- * Greater than block.
- */
-class FlowGraphGreaterThanBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeBoolean, (a, b) => this._polymorphicGreaterThan(a, b), FlowGraphGreaterThanBlock.ClassName, config);
-    }
-    _polymorphicGreaterThan(a, b) {
-        return _comparisonOperators(a, b, (a, b) => a > b);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphGreaterThanBlock.ClassName = "FGGreaterThanBlock";
-RegisterClass(FlowGraphGreaterThanBlock.ClassName, FlowGraphGreaterThanBlock);
-/**
- * @experimental
- * Greater than or equal block.
- */
-class FlowGraphGreaterThanOrEqualBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeBoolean, (a, b) => this._polymorphicGreaterThanOrEqual(a, b), FlowGraphGreaterThanOrEqualBlock.ClassName, config);
-    }
-    _polymorphicGreaterThanOrEqual(a, b) {
-        return _comparisonOperators(a, b, (a, b) => a >= b);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphGreaterThanOrEqualBlock.ClassName = "FGGreaterThanOrEqualBlock";
-RegisterClass(FlowGraphGreaterThanOrEqualBlock.ClassName, FlowGraphGreaterThanOrEqualBlock);
-/**
- * @experimental
- * Is NaN block.
- */
-class FlowGraphIsNanBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeBoolean, (a) => this._polymorphicIsNan(a), FlowGraphIsNanBlock.ClassName, config);
-    }
-    _polymorphicIsNan(a) {
-        const aClassName = _getClassNameOf(a);
-        if (aClassName === "") {
-            return isNaN(a);
-        }
-        else if (aClassName === "FlowGraphInteger") {
-            return isNaN(a.value);
-        }
-        else {
-            throw new Error(`Cannot get NaN of ${a}`);
-        }
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphIsNanBlock.ClassName = "FGIsNanBlock";
-RegisterClass(FlowGraphIsNanBlock.ClassName, FlowGraphIsNanBlock);
-/**
- * @experimental
- * Is Inf block.
- */
-class FlowGraphIsInfBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeBoolean, (a) => this._polymorphicIsInf(a), FlowGraphIsInfBlock.ClassName, config);
-    }
-    _polymorphicIsInf(a) {
-        const aClassName = _getClassNameOf(a);
-        if (aClassName === "") {
-            return !isFinite(a);
-        }
-        else if (aClassName === "FlowGraphInteger") {
-            return !isFinite(a.value);
-        }
-        else {
-            throw new Error(`Cannot get isInf of ${a}`);
-        }
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphIsInfBlock.ClassName = "FGIsInfBlock";
-/**
- * @experimental
- * Convert degrees to radians block.
- */
-class FlowGraphDegToRadBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicDegToRad(a), FlowGraphDegToRadBlock.ClassName, config);
-    }
-    _degToRad(a) {
-        return (a * Math.PI) / 180;
-    }
-    _polymorphicDegToRad(a) {
-        return _componentWiseUnaryOperation(a, this._degToRad);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphDegToRadBlock.ClassName = "FGDegToRadBlock";
-RegisterClass(FlowGraphDegToRadBlock.ClassName, FlowGraphDegToRadBlock);
-/**
- * @experimental
- * Convert radians to degrees block.
- */
-class FlowGraphRadToDegBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicRadToDeg(a), FlowGraphRadToDegBlock.ClassName, config);
-    }
-    _radToDeg(a) {
-        return (a * 180) / Math.PI;
-    }
-    _polymorphicRadToDeg(a) {
-        return _componentWiseUnaryOperation(a, this._radToDeg);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphRadToDegBlock.ClassName = "FGRadToDegBlock";
-RegisterClass(FlowGraphRadToDegBlock.ClassName, FlowGraphRadToDegBlock);
-/**
- * @experimental
- * Sin block.
- */
-class FlowGraphSinBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicSin(a), FlowGraphSinBlock.ClassName, config);
-    }
-    _polymorphicSin(a) {
-        return _componentWiseUnaryOperation(a, Math.sin);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphSinBlock.ClassName = "FGSinBlock";
-RegisterClass(FlowGraphSinBlock.ClassName, FlowGraphSinBlock);
-/**
- * @experimental
- * Cos block.
- */
-class FlowGraphCosBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicCos(a), FlowGraphCosBlock.ClassName, config);
-    }
-    _polymorphicCos(a) {
-        return _componentWiseUnaryOperation(a, Math.cos);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphCosBlock.ClassName = "FGCosBlock";
-RegisterClass(FlowGraphCosBlock.ClassName, FlowGraphCosBlock);
-/**
- * @experimental
- * Tan block.
- */
-class FlowGraphTanBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicTan(a), FlowGraphTanBlock.ClassName, config);
-    }
-    _polymorphicTan(a) {
-        return _componentWiseUnaryOperation(a, Math.tan);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphTanBlock.ClassName = "FGTanBlock";
-RegisterClass(FlowGraphTanBlock.ClassName, FlowGraphTanBlock);
-/**
- * @experimental
- * Arcsin block.
- */
-class FlowGraphAsinBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicAsin(a), FlowGraphAsinBlock.ClassName, config);
-    }
-    _polymorphicAsin(a) {
-        return _componentWiseUnaryOperation(a, Math.asin);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphAsinBlock.ClassName = "FGAsinBlock";
-RegisterClass(FlowGraphAsinBlock.ClassName, FlowGraphAsinBlock);
-/**
- * @experimental
- * Arccos block.
- */
-class FlowGraphAcosBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicAcos(a), FlowGraphAcosBlock.ClassName, config);
-    }
-    _polymorphicAcos(a) {
-        return _componentWiseUnaryOperation(a, Math.acos);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphAcosBlock.ClassName = "FGAcosBlock";
-RegisterClass(FlowGraphAcosBlock.ClassName, FlowGraphAcosBlock);
-/**
- * @experimental
- * Arctan block.
- */
-class FlowGraphAtanBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicAtan(a), FlowGraphAtanBlock.ClassName, config);
-    }
-    _polymorphicAtan(a) {
-        return _componentWiseUnaryOperation(a, Math.atan);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphAtanBlock.ClassName = "FGAtanBlock";
-RegisterClass(FlowGraphAtanBlock.ClassName, FlowGraphAtanBlock);
-/**
- * @experimental
- * Arctan2 block.
- */
-class FlowGraphAtan2Block extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, RichTypeAny, (a, b) => this._polymorphicAtan2(a, b), FlowGraphAtan2Block.ClassName, config);
-    }
-    _polymorphicAtan2(a, b) {
-        return _componentWiseBinaryOperation(a, b, Math.atan2);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphAtan2Block.ClassName = "FGAtan2Block";
-RegisterClass(FlowGraphAtan2Block.ClassName, FlowGraphAtan2Block);
-/**
- * @experimental
- * Hyperbolic sin block.
- */
-class FlowGraphSinhBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicSinh(a), FlowGraphSinhBlock.ClassName, config);
-    }
-    _polymorphicSinh(a) {
-        return _componentWiseUnaryOperation(a, Math.sinh);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphSinhBlock.ClassName = "FGSinhBlock";
-RegisterClass(FlowGraphSinhBlock.ClassName, FlowGraphSinhBlock);
-/**
- * @experimental
- * Hyperbolic cos block.
- */
-class FlowGraphCoshBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicCosh(a), FlowGraphCoshBlock.ClassName, config);
-    }
-    _polymorphicCosh(a) {
-        return _componentWiseUnaryOperation(a, Math.cosh);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphCoshBlock.ClassName = "FGCoshBlock";
-RegisterClass(FlowGraphCoshBlock.ClassName, FlowGraphCoshBlock);
-/**
- * @experimental
- * Hyperbolic tan block.
- */
-class FlowGraphTanhBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicTanh(a), FlowGraphTanhBlock.ClassName, config);
-    }
-    _polymorphicTanh(a) {
-        return _componentWiseUnaryOperation(a, Math.tanh);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphTanhBlock.ClassName = "FGTanhBlock";
-RegisterClass(FlowGraphTanhBlock.ClassName, FlowGraphTanhBlock);
-/**
- * @experimental
- * Hyperbolic arcsin block.
- */
-class FlowGraphAsinhBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicAsinh(a), FlowGraphAsinhBlock.ClassName, config);
-    }
-    _polymorphicAsinh(a) {
-        return _componentWiseUnaryOperation(a, Math.asinh);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphAsinhBlock.ClassName = "FGAsinhBlock";
-RegisterClass(FlowGraphAsinhBlock.ClassName, FlowGraphAsinhBlock);
-/**
- * @experimental
- * Hyperbolic arccos block.
- */
-class FlowGraphAcoshBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicAcosh(a), FlowGraphAcoshBlock.ClassName, config);
-    }
-    _polymorphicAcosh(a) {
-        return _componentWiseUnaryOperation(a, Math.acosh);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphAcoshBlock.ClassName = "FGAcoshBlock";
-RegisterClass(FlowGraphAcoshBlock.ClassName, FlowGraphAcoshBlock);
-/**
- * @experimental
- * Hyperbolic arctan block.
- */
-class FlowGraphAtanhBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicAtanh(a), FlowGraphAtanhBlock.ClassName, config);
-    }
-    _polymorphicAtanh(a) {
-        return _componentWiseUnaryOperation(a, Math.atanh);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphAtanhBlock.ClassName = "FGAtanhBlock";
-RegisterClass(FlowGraphAtanhBlock.ClassName, FlowGraphAtanhBlock);
-/**
- * @experimental
- * Exponential block.
- */
-class FlowGraphExpBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicExp(a), FlowGraphExpBlock.ClassName, config);
-    }
-    _polymorphicExp(a) {
-        return _componentWiseUnaryOperation(a, Math.exp);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphExpBlock.ClassName = "FGExpBlock";
-RegisterClass(FlowGraphExpBlock.ClassName, FlowGraphExpBlock);
-/**
- * @experimental
- * Logarithm block.
- */
-class FlowGraphLogBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicLog(a), FlowGraphLogBlock.ClassName, config);
-    }
-    _polymorphicLog(a) {
-        return _componentWiseUnaryOperation(a, Math.log);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphLogBlock.ClassName = "FGLogBlock";
-RegisterClass(FlowGraphLogBlock.ClassName, FlowGraphLogBlock);
-/**
- * @experimental
- * Base 2 logarithm block.
- */
-class FlowGraphLog2Block extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicLog2(a), FlowGraphLog2Block.ClassName, config);
-    }
-    _polymorphicLog2(a) {
-        return _componentWiseUnaryOperation(a, Math.log2);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphLog2Block.ClassName = "FGLog2Block";
-RegisterClass(FlowGraphLog2Block.ClassName, FlowGraphLog2Block);
-/**
- * @experimental
- * Base 10 logarithm block.
- */
-class FlowGraphLog10Block extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicLog10(a), FlowGraphLog10Block.ClassName, config);
-    }
-    _polymorphicLog10(a) {
-        return _componentWiseUnaryOperation(a, Math.log10);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphLog10Block.ClassName = "FGLog10Block";
-RegisterClass(FlowGraphLog10Block.ClassName, FlowGraphLog10Block);
-/**
- * @experimental
- * Square root block.
- */
-class FlowGraphSqrtBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicSqrt(a), FlowGraphSqrtBlock.ClassName, config);
-    }
-    _polymorphicSqrt(a) {
-        return _componentWiseUnaryOperation(a, Math.sqrt);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphSqrtBlock.ClassName = "FGSqrtBlock";
-RegisterClass(FlowGraphSqrtBlock.ClassName, FlowGraphSqrtBlock);
-/**
- * @experimental
- * Cube root block.
- */
-class FlowGraphCubeRootBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicCubeRoot(a), FlowGraphCubeRootBlock.ClassName, config);
-    }
-    _polymorphicCubeRoot(a) {
-        return _componentWiseUnaryOperation(a, Math.cbrt);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphCubeRootBlock.ClassName = "FGCubeRootBlock";
-RegisterClass(FlowGraphCubeRootBlock.ClassName, FlowGraphCubeRootBlock);
-/**
- * @experimental
- * Power block.
- */
-class FlowGraphPowBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeNumber, RichTypeNumber, (a, b) => this._polymorphicPow(a, b), FlowGraphPowBlock.ClassName, config);
-    }
-    _polymorphicPow(a, b) {
-        return _componentWiseBinaryOperation(a, b, Math.pow);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphPowBlock.ClassName = "FGPowBlock";
-RegisterClass(FlowGraphPowBlock.ClassName, FlowGraphPowBlock);
-/**
- * @experimental
- * Vector length block.
- */
-class FlowGraphLengthBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeNumber, (a) => this._polymorphicLength(a), FlowGraphLengthBlock.ClassName, config);
-    }
-    _polymorphicLength(a) {
-        const aClassName = _getClassNameOf(a);
-        switch (aClassName) {
-            case "Vector2":
-            case "Vector3":
-            case "Vector4":
-                return a.length();
-            default:
-                throw new Error(`Cannot compute length of value ${a}`);
-        }
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphLengthBlock.ClassName = "FGLengthBlock";
-RegisterClass(FlowGraphLengthBlock.ClassName, FlowGraphLengthBlock);
-/**
- * @experimental
- * Vector normalize block.
- */
-class FlowGraphNormalizeBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeAny, RichTypeAny, (a) => this._polymorphicNormalize(a), FlowGraphNormalizeBlock.ClassName, config);
-    }
-    _polymorphicNormalize(a) {
-        const aClassName = _getClassNameOf(a);
-        switch (aClassName) {
-            case "Vector2":
-            case "Vector3":
-            case "Vector4":
-                return a.normalize();
-            default:
-                throw new Error(`Cannot normalize value ${a}`);
-        }
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphNormalizeBlock.ClassName = "FGNormalizeBlock";
-RegisterClass(FlowGraphNormalizeBlock.ClassName, FlowGraphNormalizeBlock);
-/**
- * @experimental
- * Cross product block.
- */
-class FlowGraphCrossBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeVector3, RichTypeVector3, RichTypeVector3, (a, b) => Vector3.Cross(a, b), FlowGraphCrossBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphCrossBlock.ClassName = "FGCrossBlock";
-RegisterClass(FlowGraphCrossBlock.ClassName, FlowGraphCrossBlock);
-/**
- * @experimental
- * 2D rotation block.
- */
-class FlowGraphRotate2DBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeVector2, RichTypeNumber, RichTypeVector2, (a, b) => Vector2.Transform(a, Matrix.RotationZ(b)), FlowGraphRotate2DBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphRotate2DBlock.ClassName = "FGRotate2DBlock";
-RegisterClass(FlowGraphRotate2DBlock.ClassName, FlowGraphRotate2DBlock);
-/**
- * @experimental
- * 3D rotation block.
- */
-class FlowGraphRotate3DBlock extends FlowGraphTernaryOperationBlock {
-    constructor(config) {
-        super(RichTypeVector3, RichTypeVector3, RichTypeNumber, RichTypeVector3, (a, b, c) => Vector3.TransformCoordinates(a, Matrix.RotationAxis(b, c)), FlowGraphRotate3DBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphRotate3DBlock.ClassName = "FGRotate3DBlock";
-RegisterClass(FlowGraphRotate3DBlock.ClassName, FlowGraphRotate3DBlock);
-/**
- * @experimental
- * Transposes a matrix.
- */
-class FlowGraphTransposeBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeMatrix, RichTypeMatrix, (a) => Matrix.Transpose(a), FlowGraphTransposeBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphTransposeBlock.ClassName = "FGTransposeBlock";
-RegisterClass(FlowGraphTransposeBlock.ClassName, FlowGraphTransposeBlock);
-/**
- * @experimental
- * Gets the determinant of a matrix.
- */
-class FlowGraphDeterminantBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeMatrix, RichTypeNumber, (a) => a.determinant(), FlowGraphDeterminantBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphDeterminantBlock.ClassName = "FGDeterminantBlock";
-RegisterClass(FlowGraphDeterminantBlock.ClassName, FlowGraphDeterminantBlock);
-/**
- * @experimental
- * Inverts a matrix.
- */
-class FlowGraphInvertMatrixBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeMatrix, RichTypeMatrix, (a) => Matrix.Invert(a), FlowGraphInvertMatrixBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphInvertMatrixBlock.ClassName = "FGInvertMatrixBlock";
-RegisterClass(FlowGraphInvertMatrixBlock.ClassName, FlowGraphInvertMatrixBlock);
-/**
- * @experimental
- * Multiplies two matrices.
- */
-class FlowGraphMatMulBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeMatrix, RichTypeMatrix, RichTypeMatrix, (a, b) => b.multiply(a), FlowGraphMatMulBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphMatMulBlock.ClassName = "FGMatMulBlock";
-RegisterClass(FlowGraphMatMulBlock.ClassName, FlowGraphMatMulBlock);
-/**
- * @experimental
- * Bitwise NOT operation
- */
-class FlowGraphBitwiseNotBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, (a) => new FlowGraphInteger(~a.value), FlowGraphBitwiseNotBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphBitwiseNotBlock.ClassName = "FGBitwiseNotBlock";
-RegisterClass(FlowGraphBitwiseNotBlock.ClassName, FlowGraphBitwiseNotBlock);
-/**
- * @experimental
- * Bitwise AND operation
- */
-class FlowGraphBitwiseAndBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, (a, b) => new FlowGraphInteger(a.value & b.value), FlowGraphBitwiseAndBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphBitwiseAndBlock.ClassName = "FGBitwiseAndBlock";
-RegisterClass(FlowGraphBitwiseAndBlock.ClassName, FlowGraphBitwiseAndBlock);
-/**
- * @experimental
- * Bitwise OR operation
- */
-class FlowGraphBitwiseOrBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, (a, b) => new FlowGraphInteger(a.value | b.value), FlowGraphBitwiseOrBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphBitwiseOrBlock.ClassName = "FGBitwiseOrBlock";
-RegisterClass(FlowGraphBitwiseOrBlock.ClassName, FlowGraphBitwiseOrBlock);
-/**
- * @experimental
- * Bitwise XOR operation
- */
-class FlowGraphBitwiseXorBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, (a, b) => new FlowGraphInteger(a.value ^ b.value), FlowGraphBitwiseXorBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphBitwiseXorBlock.ClassName = "FGBitwiseXorBlock";
-RegisterClass(FlowGraphBitwiseXorBlock.ClassName, FlowGraphBitwiseXorBlock);
-/**
- * @experimental
- * Bitwise left shift operation
- */
-class FlowGraphBitwiseLeftShiftBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, (a, b) => new FlowGraphInteger(a.value << b.value), FlowGraphBitwiseLeftShiftBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphBitwiseLeftShiftBlock.ClassName = "FGBitwiseLeftShiftBlock";
-RegisterClass(FlowGraphBitwiseLeftShiftBlock.ClassName, FlowGraphBitwiseLeftShiftBlock);
-/**
- * @experimental
- * Bitwise right shift operation
- */
-class FlowGraphBitwiseRightShiftBlock extends FlowGraphBinaryOperationBlock {
-    constructor(config) {
-        super(RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, (a, b) => new FlowGraphInteger(a.value >> b.value), FlowGraphBitwiseRightShiftBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphBitwiseRightShiftBlock.ClassName = "FGBitwiseRightShiftBlock";
-RegisterClass(FlowGraphBitwiseRightShiftBlock.ClassName, FlowGraphBitwiseRightShiftBlock);
-/**
- * @experimental
- * Count leading zeros operation
- */
-class FlowGraphCountLeadingZerosBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, (a) => new FlowGraphInteger(Math.clz32(a.value)), FlowGraphCountLeadingZerosBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphCountLeadingZerosBlock.ClassName = "FGCountLeadingZerosBlock";
-RegisterClass(FlowGraphCountLeadingZerosBlock.ClassName, FlowGraphCountLeadingZerosBlock);
-/**
- * @experimental
- * Count trailing zeros operation
- */
-class FlowGraphCountTrailingZerosBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, (a) => new FlowGraphInteger(a.value ? 31 - Math.clz32(a.value & -a.value) : 32), FlowGraphCountTrailingZerosBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphCountTrailingZerosBlock.ClassName = "FGCountTrailingZerosBlock";
-RegisterClass(FlowGraphCountTrailingZerosBlock.ClassName, FlowGraphCountTrailingZerosBlock);
-/**
- * Given a number (which is converted to a 32-bit integer), return the
- * number of bits set to one on that number.
- * @internal
- * @param n
- */
-function _countOnes(n) {
-    let result = 0;
-    while (n) {
-        // This zeroes out all bits except for the least significant one.
-        // So if the bit is set, it will be 1, otherwise it will be 0.
-        result += n & 1;
-        // This shifts n's bits to the right by one
-        n >>= 1;
-    }
-    return result;
-}
-/**
- * @experimental
- * Count one bits operation
- */
-class FlowGraphCountOneBitsBlock extends FlowGraphUnaryOperationBlock {
-    constructor(config) {
-        super(RichTypeFlowGraphInteger, RichTypeFlowGraphInteger, (a) => new FlowGraphInteger(_countOnes(a.value)), FlowGraphCountOneBitsBlock.ClassName, config);
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphCountOneBitsBlock.ClassName = "FGCountOneBitsBlock";
-RegisterClass(FlowGraphCountOneBitsBlock.ClassName, FlowGraphCountOneBitsBlock);
-
-/**
- * A block that executes a branch a set number of times.
- * @experimental
- */
-class FlowGraphDoNBlock extends FlowGraphExecutionBlockWithOutSignal {
-    constructor(
-    /**
-     * [Object] the configuration of the block
-     */
-    config = { startIndex: new FlowGraphInteger(0) }) {
-        super(config);
-        this.config = config;
-        this.reset = this._registerSignalInput("reset");
-        this.n = this.registerDataInput("n", RichTypeFlowGraphInteger);
-        this.value = this.registerDataOutput("value", RichTypeFlowGraphInteger);
-    }
-    _execute(context, callingSignal) {
-        if (callingSignal === this.reset) {
-            this.value.setValue(this.config.startIndex, context);
-        }
-        else {
-            const currentCountValue = this.value.getValue(context);
-            if (currentCountValue.value < this.n.getValue(context).value) {
-                this.value.setValue(new FlowGraphInteger(currentCountValue.value + 1), context);
-                this.out._activateSignal(context);
-            }
-        }
-    }
-    /**
-     * @returns class name of the block.
-     */
-    getClassName() {
-        return FlowGraphDoNBlock.ClassName;
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphDoNBlock.ClassName = "FGDoNBlock";
-RegisterClass(FlowGraphDoNBlock.ClassName, FlowGraphDoNBlock);
-
-/**
- * A block that gets the value of a variable.
- * @experimental
- */
-class FlowGraphGetVariableBlock extends FlowGraphBlock {
-    /**
-     * Construct a FlowGraphGetVariableBlock.
-     * @param config construction parameters
-     */
-    constructor(config) {
-        super(config);
-        this.config = config;
-        // The output connection has to have the name of the variable.
-        this.output = this.registerDataOutput(config.variableName, RichTypeAny);
-    }
-    /**
-     * @internal
-     */
-    _updateOutputs(context) {
-        const variableNameValue = this.config.variableName;
-        if (context.hasVariable(variableNameValue)) {
-            this.output.setValue(context.getVariable(variableNameValue), context);
-        }
-    }
-    /**
-     * Gets the class name of this block
-     * @returns the class name
-     */
-    getClassName() {
-        return FlowGraphGetVariableBlock.ClassName;
-    }
-    /**
-     * Serializes this block
-     * @param serializationObject the object to serialize to
-     */
-    serialize(serializationObject) {
-        super.serialize(serializationObject);
-        serializationObject.config.variableName = this.config.variableName;
-    }
-}
-/**
- * Class name of the block.
- */
-FlowGraphGetVariableBlock.ClassName = "FGGetVariableBlock";
-RegisterClass(FlowGraphGetVariableBlock.ClassName, FlowGraphGetVariableBlock);
-
-/**
- * Block to set a variable.
- * @experimental
- */
-class FlowGraphSetVariableBlock extends FlowGraphExecutionBlockWithOutSignal {
-    constructor(
-    /**
-     * the configuration of the block
-     */
-    config) {
-        super(config);
-        this.config = config;
-        this.input = this.registerDataInput(config.variableName, RichTypeAny);
-    }
-    _execute(context) {
-        const variableNameValue = this.config.variableName;
-        const inputValue = this.input.getValue(context);
-        context.setVariable(variableNameValue, inputValue);
-        this.out._activateSignal(context);
-    }
-    /**
-     * @returns class name of the block.
-     */
-    getClassName() {
-        return FlowGraphSetVariableBlock.ClassName;
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphSetVariableBlock.ClassName = "FGSetVariableBlock";
-RegisterClass(FlowGraphSetVariableBlock.ClassName, FlowGraphSetVariableBlock);
-
-/**
- * @experimental
- * A block that executes a branch while a condition is true.
- */
-class FlowGraphWhileLoopBlock extends FlowGraphExecutionBlockWithOutSignal {
-    constructor(
-    /**
-     * the configuration of the block
-     */
-    config) {
-        super(config);
-        this.config = config;
-        this.condition = this.registerDataInput("condition", RichTypeBoolean);
-        this.loopBody = this._registerSignalOutput("loopBody");
-    }
-    _execute(context, _callingSignal) {
-        let conditionValue = this.condition.getValue(context);
-        if (this.config?.isDo && !conditionValue) {
-            this.loopBody._activateSignal(context);
-        }
-        while (conditionValue) {
-            this.loopBody._activateSignal(context);
-            conditionValue = this.condition.getValue(context);
-        }
-        this.out._activateSignal(context);
-    }
-    /**
-     * @returns class name of the block.
-     */
-    getClassName() {
-        return FlowGraphWhileLoopBlock.ClassName;
-    }
-    /**
-     * Serializes the block to a JSON object.
-     * @param serializationObject the object to serialize to.
-     */
-    serialize(serializationObject) {
-        super.serialize(serializationObject);
-        serializationObject.isDo = this.config?.isDo;
-    }
-}
-/**
- * the class name of the block.
- */
-FlowGraphWhileLoopBlock.ClassName = "FGWhileLoopBlock";
-RegisterClass(FlowGraphWhileLoopBlock.ClassName, FlowGraphWhileLoopBlock);
-
-/* eslint-disable @typescript-eslint/naming-convention */
-const gltfToFlowGraphTypeMap = {
-    "lifecycle/onStart": FlowGraphSceneReadyEventBlock.ClassName,
-    "lifecycle/onTick": FlowGraphSceneTickEventBlock.ClassName,
-    log: FlowGraphConsoleLogBlock.ClassName,
-    "flow/delay": FlowGraphTimerBlock.ClassName,
-    "customEvent/send": FlowGraphSendCustomEventBlock.ClassName,
-    "customEvent/receive": FlowGraphReceiveCustomEventBlock.ClassName,
-    "flow/sequence": FlowGraphSequenceBlock.ClassName,
-    "world/get": FlowGraphGetPropertyBlock.ClassName,
-    "world/set": FlowGraphSetPropertyBlock.ClassName,
-    "flow/doN": FlowGraphDoNBlock.ClassName,
-    "variable/get": FlowGraphGetVariableBlock.ClassName,
-    "variable/set": FlowGraphSetVariableBlock.ClassName,
-    "flow/whileLoop": FlowGraphWhileLoopBlock.ClassName,
-    "math/random": FlowGraphRandomBlock.ClassName,
-    "math/e": FlowGraphEBlock.ClassName,
-    "math/pi": FlowGraphPiBlock.ClassName,
-    "math/inf": FlowGraphInfBlock.ClassName,
-    "math/nan": FlowGraphNaNBlock.ClassName,
-    "math/abs": FlowGraphAbsBlock.ClassName,
-    "math/sign": FlowGraphSignBlock.ClassName,
-    "math/trunc": FlowGraphTruncBlock.ClassName,
-    "math/floor": FlowGraphFloorBlock.ClassName,
-    "math/ceil": FlowGraphCeilBlock.ClassName,
-    "math/fract": FlowGraphFractBlock.ClassName,
-    "math/neg": FlowGraphNegBlock.ClassName,
-    "math/add": FlowGraphAddBlock.ClassName,
-    "math/sub": FlowGraphSubtractBlock.ClassName,
-    "math/mul": FlowGraphMultiplyBlock.ClassName,
-    "math/div": FlowGraphDivideBlock.ClassName,
-    "math/rem": FlowGraphRemainderBlock.ClassName,
-    "math/min": FlowGraphMinBlock.ClassName,
-    "math/max": FlowGraphMaxBlock.ClassName,
-    "math/clamp": FlowGraphClampBlock.ClassName,
-    "math/saturate": FlowGraphSaturateBlock.ClassName,
-    "math/mix": FlowGraphInterpolateBlock.ClassName,
-    "math/eq": FlowGraphEqBlock.ClassName,
-    "math/lt": FlowGraphLessThanBlock.ClassName,
-    "math/le": FlowGraphLessThanOrEqualBlock.ClassName,
-    "math/gt": FlowGraphGreaterThanBlock.ClassName,
-    "math/ge": FlowGraphGreaterThanOrEqualBlock.ClassName,
-    "math/isnan": FlowGraphIsNanBlock.ClassName,
-    "math/isinf": FlowGraphIsInfBlock.ClassName,
-    "math/rad": FlowGraphDegToRadBlock.ClassName,
-    "math/deg": FlowGraphRadToDegBlock.ClassName,
-    "math/sin": FlowGraphSinBlock.ClassName,
-    "math/cos": FlowGraphCosBlock.ClassName,
-    "math/tan": FlowGraphTanBlock.ClassName,
-    "math/asin": FlowGraphAsinBlock.ClassName,
-    "math/acos": FlowGraphAcosBlock.ClassName,
-    "math/atan": FlowGraphAtanBlock.ClassName,
-    "math/atan2": FlowGraphAtan2Block.ClassName,
-    "math/sinh": FlowGraphSinhBlock.ClassName,
-    "math/cosh": FlowGraphCoshBlock.ClassName,
-    "math/tanh": FlowGraphTanhBlock.ClassName,
-    "math/asinh": FlowGraphAsinhBlock.ClassName,
-    "math/acosh": FlowGraphAcoshBlock.ClassName,
-    "math/atanh": FlowGraphAtanhBlock.ClassName,
-    "math/exp": FlowGraphExpBlock.ClassName,
-    "math/log": FlowGraphLogBlock.ClassName,
-    "math/log2": FlowGraphLog2Block.ClassName,
-    "math/log10": FlowGraphLog10Block.ClassName,
-    "math/sqrt": FlowGraphSqrtBlock.ClassName,
-    "math/cbrt": FlowGraphCubeRootBlock.ClassName,
-    "math/pow": FlowGraphPowBlock.ClassName,
-    "math/length": FlowGraphLengthBlock.ClassName,
-    "math/normalize": FlowGraphNormalizeBlock.ClassName,
-    "math/dot": FlowGraphDotBlock.ClassName,
-    "math/cross": FlowGraphCrossBlock.ClassName,
-    "math/rotate2d": FlowGraphRotate2DBlock.ClassName,
-    "math/rotate3d": FlowGraphRotate3DBlock.ClassName,
-    "math/transpose": FlowGraphTransposeBlock.ClassName,
-    "math/determinant": FlowGraphDeterminantBlock.ClassName,
-    "math/inverse": FlowGraphInvertMatrixBlock.ClassName,
-    "math/matmul": FlowGraphMatMulBlock.ClassName,
-    "math/not": FlowGraphBitwiseNotBlock.ClassName,
-    "math/and": FlowGraphBitwiseAndBlock.ClassName,
-    "math/or": FlowGraphBitwiseOrBlock.ClassName,
-    "math/xor": FlowGraphBitwiseXorBlock.ClassName,
-    "math/asr": FlowGraphBitwiseRightShiftBlock.ClassName,
-    "math/lsl": FlowGraphBitwiseLeftShiftBlock.ClassName,
-    "math/clz": FlowGraphCountLeadingZerosBlock.ClassName,
-    "math/ctz": FlowGraphCountTrailingZerosBlock.ClassName,
-    "math/popcnt": FlowGraphCountOneBitsBlock.ClassName,
-};
-const gltfTypeToBabylonType = {
-    float2: "Vector2",
-    float3: "Vector3",
-    float4: "Vector4",
-    float4x4: "Matrix",
-    int: "FlowGraphInteger",
-};
-
-function convertValueWithType(configObject, definition, context) {
-    if (configObject.type !== undefined) {
-        // get the type on the gltf definition
-        const type = definition.types && definition.types[configObject.type];
-        if (!type) {
-            throw new Error(`${context}: Unknown type: ${configObject.type}`);
-        }
-        const signature = type.signature;
-        if (!signature) {
-            throw new Error(`${context}: Type ${configObject.type} has no signature`);
-        }
-        const convertedType = gltfTypeToBabylonType[signature];
-        return {
-            value: configObject.value,
-            className: convertedType,
-        };
-    }
-    else {
-        return configObject.value;
-    }
-}
-function convertConfiguration(gltfBlock, definition, id) {
-    const converted = {};
-    const configurationList = gltfBlock.configuration ?? [];
-    for (const configObject of configurationList) {
-        if (configObject.id === "customEvent") {
-            const customEvent = definition.customEvents && definition.customEvents[configObject.value];
-            if (!customEvent) {
-                throw new Error(`/extensions/KHR_interactivity/nodes/${id}: Unknown custom event: ${configObject.value}`);
-            }
-            converted.eventId = customEvent.id;
-            converted.eventData = customEvent.values.map((v) => v.id);
-        }
-        else if (configObject.id === "variable") {
-            const variable = definition.variables && definition.variables[configObject.value];
-            if (!variable) {
-                throw new Error(`/extensions/KHR_interactivity/nodes/${id}: Unknown variable: ${configObject.value}`);
-            }
-            converted.variableName = variable.id;
-        }
-        else if (configObject.id === "path") {
-            // Convert from a GLTF path to a reference to the Babylon.js object
-            const pathValue = configObject.value;
-            converted.path = pathValue;
-        }
-        else {
-            converted[configObject.id] = convertValueWithType(configObject, definition, `/extensions/KHR_interactivity/nodes/${id}`);
-        }
-    }
-    return converted;
-}
-function convertBlock(id, gltfBlock, definition) {
-    const className = gltfToFlowGraphTypeMap[gltfBlock.type];
-    if (!className) {
-        throw new Error(`/extensions/KHR_interactivity/nodes/${id}: Unknown block type: ${gltfBlock.type}`);
-    }
-    const uniqueId = id.toString();
-    const config = convertConfiguration(gltfBlock, definition, uniqueId);
-    const metadata = gltfBlock.metadata;
-    const dataInputs = [];
-    const dataOutputs = [];
-    const signalInputs = [];
-    const signalOutputs = [];
-    return {
-        className,
-        config,
-        uniqueId,
-        metadata,
-        dataInputs,
-        dataOutputs,
-        signalInputs,
-        signalOutputs,
-    };
-}
-/**
- * @internal
- * Converts a glTF Interactivity Extension to a serialized flow graph.
- * @param gltf the interactivity data
- * @returns a serialized flow graph
- */
-function convertGLTFToSerializedFlowGraph(gltf) {
-    // create an empty serialized context to store the values of the connections
-    const context = {
-        uniqueId: RandomGUID(),
-        _userVariables: {},
-        _connectionValues: {},
-    };
-    const executionContexts = [context];
-    // Blocks converted to the flow graph json format
-    const flowGraphJsonBlocks = [];
-    for (let i = 0; i < gltf.nodes.length; i++) {
-        const gltfBlock = gltf.nodes[i];
-        const flowGraphJsonBlock = convertBlock(i, gltfBlock, gltf);
-        flowGraphJsonBlocks.push(flowGraphJsonBlock);
-    }
-    // Parse the connections
-    for (let i = 0; i < gltf.nodes.length; i++) {
-        const gltfBlock = gltf.nodes[i];
-        // get the block that was created in the previous step
-        const fgBlock = flowGraphJsonBlocks[i];
-        const gltfFlows = gltfBlock.flows ?? [];
-        // for each output flow of the gltf block
-        for (const flow of gltfFlows) {
-            const socketOutName = flow.id;
-            // create an output connection for the flow graph block
-            const socketOut = {
-                uniqueId: RandomGUID(),
-                name: socketOutName,
-                _connectionType: 1 /* FlowGraphConnectionType.Output */, // Output
-                connectedPointIds: [],
-            };
-            fgBlock.signalOutputs.push(socketOut);
-            // get the input node of this flow
-            const nodeInId = flow.node;
-            const nodeInSocketName = flow.socket;
-            // find the corresponding flow graph node
-            const nodeIn = flowGraphJsonBlocks[nodeInId];
-            if (!nodeIn) {
-                throw new Error(`/extensions/KHR_interactivity/nodes/${i}: Could not find node with id ${nodeInId} that connects its input with with node ${i}'s output ${socketOutName}`);
-            }
-            // in all of the flow graph input connections, find the one with the same name as the socket
-            let socketIn = nodeIn.signalInputs.find((s) => s.name === nodeInSocketName);
-            // if the socket doesn't exist, create the input socket for the connection
-            if (!socketIn) {
-                socketIn = {
-                    uniqueId: RandomGUID(),
-                    name: nodeInSocketName,
-                    _connectionType: 0 /* FlowGraphConnectionType.Input */, // Input
-                    connectedPointIds: [],
-                };
-                nodeIn.signalInputs.push(socketIn);
-            }
-            // connect the sockets
-            socketIn.connectedPointIds.push(socketOut.uniqueId);
-            socketOut.connectedPointIds.push(socketIn.uniqueId);
-        }
-        // for each input value of the gltf block
-        const gltfValues = gltfBlock.values ?? [];
-        for (const value of gltfValues) {
-            const socketInName = value.id;
-            // create an input data connection for the flow graph block
-            const socketIn = {
-                uniqueId: RandomGUID(),
-                name: socketInName,
-                _connectionType: 0 /* FlowGraphConnectionType.Input */,
-                connectedPointIds: [],
-            };
-            fgBlock.dataInputs.push(socketIn);
-            if (value.value !== undefined) {
-                // if the value is set on the socket itself, store it in the context
-                const convertedValue = convertValueWithType(value, gltf, `/extensions/KHR_interactivity/nodes/${i}`);
-                // convertBlockInputType(gltfBlock, value, convertedValue, `/extensions/KHR_interactivity/nodes/${i}`);
-                context._connectionValues[socketIn.uniqueId] = convertedValue;
-            }
-            else if (value.node !== undefined && value.socket !== undefined) {
-                // if the value is connected with the output data of another socket, connect the two
-                const nodeOutId = value.node;
-                const nodeOutSocketName = value.socket;
-                // find the flow graph node that owns that output socket
-                const nodeOut = flowGraphJsonBlocks[nodeOutId];
-                if (!nodeOut) {
-                    throw new Error(`/extensions/KHR_interactivity/nodes/${i}: Could not find node with id ${nodeOutId} that connects its output with node${i}'s input ${socketInName}`);
-                }
-                let socketOut = nodeOut.dataOutputs.find((s) => s.name === nodeOutSocketName);
-                // if the socket doesn't exist, create it
-                if (!socketOut) {
-                    socketOut = {
-                        uniqueId: RandomGUID(),
-                        name: nodeOutSocketName,
-                        _connectionType: 1 /* FlowGraphConnectionType.Output */,
-                        connectedPointIds: [],
-                    };
-                    nodeOut.dataOutputs.push(socketOut);
-                }
-                // connect the sockets
-                socketIn.connectedPointIds.push(socketOut.uniqueId);
-                socketOut.connectedPointIds.push(socketIn.uniqueId);
-            }
-            else {
-                throw new Error(`/extensions/KHR_interactivity/nodes/${i}: Invalid socket ${socketInName} in node ${i}`);
-            }
-        }
-    }
-    const variables = gltf.variables ?? [];
-    // Parse variables
-    for (let i = 0; i < variables.length; i++) {
-        const variable = variables[i];
-        const variableName = variable.id;
-        context._userVariables[variableName] = convertValueWithType(variable, gltf, `/extensions/KHR_interactivity/variables/${i}`);
-    }
-    return {
-        allBlocks: flowGraphJsonBlocks,
-        executionContexts,
-    };
-}
-
-/**
- * Class to convert an interactivity pointer path to a smart object
- */
-class InteractivityPathToObjectConverter extends GLTFPathToObjectConverter {
-    constructor(gltf) {
-        super(gltf, gltfTree);
-    }
-}
-const nodesTree = {
-    __array__: {
-        __target__: true,
-        translation: {
-            type: "Vector3",
-            get: (node) => {
-                const babylonObject = node._babylonTransformNode;
-                return babylonObject.position;
-            },
-            set: (value, node) => {
-                const babylonObject = node._babylonTransformNode;
-                babylonObject.position = value;
-            },
-            getObject(node) {
-                return node._babylonTransformNode;
-            },
-        },
-    },
-};
-const gltfTree = {
-    nodes: nodesTree,
-};
-
-const NAME = "KHR_interactivity";
-/**
- * Loader extension for KHR_interactivity
- */
-class KHR_interactivity {
-    /**
-     * @internal
-     * @param _loader
-     */
-    constructor(_loader) {
-        this._loader = _loader;
-        /**
-         * The name of this extension.
-         */
-        this.name = NAME;
-        this.enabled = this._loader.isExtensionUsed(NAME);
-        this._pathConverter = new InteractivityPathToObjectConverter(this._loader.gltf);
-    }
-    dispose() {
-        this._loader = null;
-        delete this._pathConverter;
-    }
-    onReady() {
-        if (!this._loader.babylonScene || !this._pathConverter) {
-            return;
-        }
-        const scene = this._loader.babylonScene;
-        const interactivityDefinition = this._loader.gltf.extensions?.KHR_interactivity;
-        const json = convertGLTFToSerializedFlowGraph(interactivityDefinition);
-        const coordinator = new FlowGraphCoordinator({ scene });
-        FlowGraph.Parse(json, { coordinator, pathConverter: this._pathConverter });
-        coordinator.start();
-    }
-}
-unregisterGLTFExtension(NAME);
-registerGLTFExtension(NAME, true, (loader) => new KHR_interactivity(loader));
-
-export { KHR_interactivity };
-//# sourceMappingURL=KHR_interactivity-ClHXW_8S.esm.js.map