@vived/component-abb-6700 1.0.0

package/dist/flowGraphFunctionReferenceBlock-D8X5TFsO.js

@@ -0,0 +1,20 @@
+import { O as o, aU as u, aM as s, aK as c } from "./index-CS3Icp_r.js";
+class r extends o {
+  constructor(t) {
+    super(t), this.functionName = this.registerDataInput("functionName", u), this.object = this.registerDataInput("object", s), this.context = this.registerDataInput("context", s, null), this.output = this.registerDataOutput("output", s);
+  }
+  _updateOutputs(t) {
+    const n = this.functionName.getValue(t), a = this.object.getValue(t), i = this.context.getValue(t);
+    if (a && n) {
+      const e = a[n];
+      e && typeof e == "function" && this.output.setValue(e.bind(i), t);
+    }
+  }
+  getClassName() {
+    return "FlowGraphFunctionReference";
+  }
+}
+c("FlowGraphFunctionReference", r);
+export {
+  r as FlowGraphFunctionReferenceBlock
+};

package/dist/flowGraphGLTFDataProvider-C4j7nPQv.js

@@ -0,0 +1,16 @@
+import { O as e, aM as s } from "./index-CS3Icp_r.js";
+class m extends e {
+  constructor(o) {
+    super(o);
+    const t = o.glTF, r = t?.animations?.map((a) => a._babylonAnimationGroup) || [];
+    this.animationGroups = this.registerDataOutput("animationGroups", s, r);
+    const n = t?.nodes?.map((a) => a._babylonTransformNode) || [];
+    this.nodes = this.registerDataOutput("nodes", s, n);
+  }
+  getClassName() {
+    return "FlowGraphGLTFDataProvider";
+  }
+}
+export {
+  m as FlowGraphGLTFDataProvider
+};

package/dist/flowGraphGetAngularVelocityBlock-Cq-yTQ4D.js

@@ -0,0 +1,31 @@
+import { aW as o, aM as r, bf as l, aK as i } from "./index-CS3Icp_r.js";
+import { F as s } from "./flowGraphCachedOperationBlock-CP1ZiuIB.js";
+class c extends s {
+  /**
+   * Constructs a new FlowGraphGetAngularVelocityBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(e) {
+    super(o, e), this.body = this.registerDataInput("body", r);
+  }
+  /**
+   * @internal
+   */
+  _doOperation(e) {
+    const a = this.body.getValue(e);
+    if (!a)
+      return;
+    let t = e._getExecutionVariable(this, "_cachedVelocity", null);
+    return t || (t = new l(), e._setExecutionVariable(this, "_cachedVelocity", t)), a.getAngularVelocityToRef(t), t;
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphGetAngularVelocityBlock";
+  }
+}
+i("FlowGraphGetAngularVelocityBlock", c);
+export {
+  c as FlowGraphGetAngularVelocityBlock
+};

package/dist/flowGraphGetAssetBlock-B36eioor.js

@@ -0,0 +1,21 @@
+import { O as p, aM as t, T as l, bT as s, Y as u, aK as h } from "./index-CS3Icp_r.js";
+class n extends p {
+  constructor(e) {
+    super(e), this.config = e, this.type = this.registerDataInput("type", t, e.type), this.value = this.registerDataOutput("value", t), this.index = this.registerDataInput("index", t, new l(s(e.index ?? -1)));
+  }
+  _updateOutputs(e) {
+    const a = this.type.getValue(e), i = this.index.getValue(e), r = u(e.assetsContext, a, s(i), this.config.useIndexAsUniqueId);
+    this.value.setValue(r, e);
+  }
+  /**
+   * Gets the class name of this block
+   * @returns the class name
+   */
+  getClassName() {
+    return "FlowGraphGetAssetBlock";
+  }
+}
+h("FlowGraphGetAssetBlock", n);
+export {
+  n as FlowGraphGetAssetBlock
+};

package/dist/flowGraphGetLinearVelocityBlock-MdrV0eUD.js

@@ -0,0 +1,31 @@
+import { aW as o, aM as r, bf as i, aK as s } from "./index-CS3Icp_r.js";
+import { F as c } from "./flowGraphCachedOperationBlock-CP1ZiuIB.js";
+class l extends c {
+  /**
+   * Constructs a new FlowGraphGetLinearVelocityBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(e) {
+    super(o, e), this.body = this.registerDataInput("body", r);
+  }
+  /**
+   * @internal
+   */
+  _doOperation(e) {
+    const a = this.body.getValue(e);
+    if (!a)
+      return;
+    let t = e._getExecutionVariable(this, "_cachedVelocity", null);
+    return t || (t = new i(), e._setExecutionVariable(this, "_cachedVelocity", t)), a.getLinearVelocityToRef(t), t;
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphGetLinearVelocityBlock";
+  }
+}
+s("FlowGraphGetLinearVelocityBlock", l);
+export {
+  l as FlowGraphGetLinearVelocityBlock
+};

package/dist/flowGraphGetPhysicsMassPropertiesBlock-wXDZP1wM.js

@@ -0,0 +1,30 @@
+import { O as i, aM as r, aS as h, aW as a, aK as p } from "./index-CS3Icp_r.js";
+class o extends i {
+  /**
+   * Constructs a new FlowGraphGetPhysicsMassPropertiesBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(s) {
+    super(s), this.body = this.registerDataInput("body", r), this.mass = this.registerDataOutput("mass", h), this.centerOfMass = this.registerDataOutput("centerOfMass", a), this.inertia = this.registerDataOutput("inertia", a);
+  }
+  /**
+   * @internal
+   */
+  _updateOutputs(s) {
+    const t = this.body.getValue(s);
+    if (!t)
+      return;
+    const e = t.getMassProperties();
+    e.mass !== void 0 && this.mass.setValue(e.mass, s), e.centerOfMass && this.centerOfMass.setValue(e.centerOfMass, s), e.inertia && this.inertia.setValue(e.inertia, s);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphGetPhysicsMassPropertiesBlock";
+  }
+}
+p("FlowGraphGetPhysicsMassPropertiesBlock", o);
+export {
+  o as FlowGraphGetPhysicsMassPropertiesBlock
+};

package/dist/flowGraphGetPropertyBlock-eP0badwf.js

@@ -0,0 +1,46 @@
+import { aM as s, aU as p, aK as i } from "./index-CS3Icp_r.js";
+import { F as u } from "./flowGraphCachedOperationBlock-CP1ZiuIB.js";
+class l extends u {
+  /**
+   * Constructs a new FlowGraphGetPropertyBlock.
+   * @param config - the configuration of the block
+   */
+  constructor(t) {
+    super(s, t), this.config = t, this.object = this.registerDataInput("object", s, t.object), this.propertyName = this.registerDataInput("propertyName", p, t.propertyName), this.customGetFunction = this.registerDataInput("customGetFunction", s);
+  }
+  /**
+   * Retrieves the property value from the target object.
+   * @param context - the flow graph context
+   * @returns the property value, or undefined if the target or property name is not set
+   */
+  _doOperation(t) {
+    const a = this.customGetFunction.getValue(t);
+    let r;
+    if (a)
+      r = a(this.object.getValue(t), this.propertyName.getValue(t), t);
+    else {
+      const e = this.object.getValue(t), o = this.propertyName.getValue(t);
+      r = e && o ? this._getPropertyValue(e, o) : void 0;
+    }
+    return r;
+  }
+  _getPropertyValue(t, a) {
+    const r = a.split(".");
+    let e = t;
+    for (const o of r)
+      if (e = e[o], e === void 0)
+        return;
+    return e;
+  }
+  /**
+   * Returns the class name of this block.
+   * @returns the class name
+   */
+  getClassName() {
+    return "FlowGraphGetPropertyBlock";
+  }
+}
+i("FlowGraphGetPropertyBlock", l);
+export {
+  l as FlowGraphGetPropertyBlock
+};

package/dist/flowGraphGetSoundVolumeBlock-D3gXGHXa.js

@@ -0,0 +1,29 @@
+import { aS as r, aM as t, aK as s } from "./index-CS3Icp_r.js";
+import { F as a } from "./flowGraphCachedOperationBlock-CP1ZiuIB.js";
+class u extends a {
+  /**
+   * Constructs a new FlowGraphGetSoundVolumeBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(e) {
+    super(r, e), this.sound = this.registerDataInput("sound", t);
+  }
+  /**
+   * @internal
+   */
+  _doOperation(e) {
+    const o = this.sound.getValue(e);
+    if (o)
+      return o.volume;
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphGetSoundVolumeBlock";
+  }
+}
+s("FlowGraphGetSoundVolumeBlock", u);
+export {
+  u as FlowGraphGetSoundVolumeBlock
+};

package/dist/flowGraphGetVariableBlock-C7-qZAec.js

@@ -0,0 +1,31 @@
+import { O as l, aM as i, aK as r } from "./index-CS3Icp_r.js";
+class s extends l {
+  /**
+   * Construct a FlowGraphGetVariableBlock.
+   * @param config construction parameters
+   */
+  constructor(a) {
+    super(a), this.config = a, this.value = this.registerDataOutput("value", i, a.initialValue);
+  }
+  /**
+   * @internal
+   */
+  _updateOutputs(a) {
+    const e = this.config.variable;
+    a.hasVariable(e) && this.value.setValue(a.getVariable(e), a);
+  }
+  /**
+   * Serializes this block
+   * @param serializationObject the object to serialize to
+   */
+  serialize(a) {
+    super.serialize(a), a.config.variable = this.config.variable;
+  }
+  getClassName() {
+    return "FlowGraphGetVariableBlock";
+  }
+}
+r("FlowGraphGetVariableBlock", s);
+export {
+  s as FlowGraphGetVariableBlock
+};

package/dist/flowGraphIndexOfBlock-CC5l9n9P.js

@@ -0,0 +1,31 @@
+import { O as i, aM as t, aO as o, T as s, aK as h } from "./index-CS3Icp_r.js";
+class l extends i {
+  /**
+   * Construct a FlowGraphIndexOfBlock.
+   * @param config construction parameters
+   */
+  constructor(e) {
+    super(e), this.config = e, this.object = this.registerDataInput("object", t), this.array = this.registerDataInput("array", t), this.index = this.registerDataOutput("index", o, new s(-1));
+  }
+  /**
+   * @internal
+   */
+  _updateOutputs(e) {
+    const r = this.object.getValue(e), a = this.array.getValue(e);
+    a && this.index.setValue(new s(a.indexOf(r)), e);
+  }
+  /**
+   * Serializes this block
+   * @param serializationObject the object to serialize to
+   */
+  serialize(e) {
+    super.serialize(e);
+  }
+  getClassName() {
+    return "FlowGraphIndexOfBlock";
+  }
+}
+h("FlowGraphIndexOfBlock", l);
+export {
+  l as FlowGraphIndexOfBlock
+};

package/dist/flowGraphInterpolationBlock-B6922jzt.js

@@ -0,0 +1,50 @@
+import { O as c, bW as d, bV as g, aS as h, aM as p, aU as F, i as y, aK as V } from "./index-CS3Icp_r.js";
+class f extends c {
+  constructor(t = {}) {
+    super(t), this.keyFrames = [];
+    const e = typeof t?.animationType == "string" ? d(t.animationType) : g(t?.animationType ?? 0), i = t?.keyFramesCount ?? 1, n = this.registerDataInput("duration_0", h, 0), a = this.registerDataInput("value_0", e);
+    this.keyFrames.push({ duration: n, value: a });
+    for (let s = 1; s < i + 1; s++) {
+      const u = this.registerDataInput(`duration_${s}`, h, s === i ? t.duration : void 0), l = this.registerDataInput(`value_${s}`, e);
+      this.keyFrames.push({ duration: u, value: l });
+    }
+    this.initialValue = this.keyFrames[0].value, this.endValue = this.keyFrames[i].value, this.easingFunction = this.registerDataInput("easingFunction", p), this.animation = this.registerDataOutput("animation", p), this.propertyName = this.registerDataInput("propertyName", F, t?.propertyName), this.customBuildAnimation = this.registerDataInput("customBuildAnimation", p);
+  }
+  _updateOutputs(t) {
+    const e = t._getGlobalContextVariable("interpolationAnimations", []), i = this.propertyName.getValue(t), n = this.easingFunction.getValue(t), a = this._createAnimation(t, i, n);
+    if (this.animation.setValue(a, t), Array.isArray(a))
+      for (const s of a)
+        e.push(s.uniqueId);
+    else
+      e.push(a.uniqueId);
+    t._setGlobalContextVariable("interpolationAnimations", e);
+  }
+  _createAnimation(t, e, i) {
+    const n = this.initialValue.richType, a = [], s = this.initialValue.getValue(t) || n.defaultValue;
+    a.push({ frame: 0, value: s });
+    const u = this.config?.numberOfKeyFrames ?? 1;
+    for (let r = 1; r < u + 1; r++) {
+      const m = this.keyFrames[r].duration?.getValue(t);
+      let o = this.keyFrames[r].value?.getValue(t);
+      r === u - 1 && (o = o || n.defaultValue), m !== void 0 && o && a.push({ frame: m * 60, value: o });
+    }
+    const l = this.customBuildAnimation.getValue(t);
+    if (l)
+      return l(null, null, t)(a, 60, n.animationType, i);
+    if (typeof e == "string") {
+      const r = y.CreateAnimation(e, n.animationType, 60, i);
+      return r.setKeys(a), [r];
+    } else
+      return e.map((m) => {
+        const o = y.CreateAnimation(m, n.animationType, 60, i);
+        return o.setKeys(a), o;
+      });
+  }
+  getClassName() {
+    return "FlowGraphInterpolationBlock";
+  }
+}
+V("FlowGraphInterpolationBlock", f);
+export {
+  f as FlowGraphInterpolationBlock
+};

package/dist/flowGraphIsKeyPressedBlock-X_iuiUOX.js

@@ -0,0 +1,31 @@
+import { O as r, aU as l, aN as i, aK as o } from "./index-CS3Icp_r.js";
+class u extends r {
+  /**
+   * Creates a new FlowGraphIsKeyPressedBlock.
+   * @param config optional configuration
+   */
+  constructor(t) {
+    super(t), this.key = this.registerDataInput("key", l), this.withShift = this.registerDataInput("withShift", i), this.withCtrl = this.registerDataInput("withCtrl", i), this.withAlt = this.registerDataInput("withAlt", i), this.withMeta = this.registerDataInput("withMeta", i), this.withCommandOrCtrl = this.registerDataInput("withCommandOrCtrl", i), this.isPressed = this.registerDataOutput("isPressed", i);
+  }
+  /** @internal */
+  _updateOutputs(t) {
+    const a = t.configuration.sceneEventCoordinator;
+    if (!a) {
+      this.isPressed.setValue(!1, t);
+      return;
+    }
+    const e = a.pressedKeys, h = this.key.getValue(t);
+    let s = h ? e.has(h) : !0;
+    s && this.withShift.getValue(t) && (s = e.has("ShiftLeft") || e.has("ShiftRight")), s && this.withCtrl.getValue(t) && (s = e.has("ControlLeft") || e.has("ControlRight")), s && this.withAlt.getValue(t) && (s = e.has("AltLeft") || e.has("AltRight")), s && this.withMeta.getValue(t) && (s = e.has("MetaLeft") || e.has("MetaRight")), s && this.withCommandOrCtrl.getValue(t) && (s = e.has("CommandOrControl")), this.isPressed.setValue(s, t);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphIsKeyPressedBlock";
+  }
+}
+o("FlowGraphIsKeyPressedBlock", u);
+export {
+  u as FlowGraphIsKeyPressedBlock
+};

package/dist/flowGraphIsSoundPlayingBlock-DONQX8N8.js

@@ -0,0 +1,29 @@
+import { aN as s, aM as e, aK as t } from "./index-CS3Icp_r.js";
+import { F as n } from "./flowGraphCachedOperationBlock-CP1ZiuIB.js";
+class r extends n {
+  /**
+   * Constructs a new FlowGraphIsSoundPlayingBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(a) {
+    super(s, a), this.sound = this.registerDataInput("sound", e);
+  }
+  /**
+   * @internal
+   */
+  _doOperation(a) {
+    const o = this.sound.getValue(a);
+    if (o)
+      return o.state === 3 || o.state === 2;
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphIsSoundPlayingBlock";
+  }
+}
+t("FlowGraphIsSoundPlayingBlock", r);
+export {
+  r as FlowGraphIsSoundPlayingBlock
+};

package/dist/flowGraphJsonPointerParserBlock-DBH_gN8I.js

@@ -0,0 +1,95 @@
+import { aO as A, T as F, aM as c, y, z as w, bf as j, bg as I, aK as _ } from "./index-CS3Icp_r.js";
+import { F as N } from "./flowGraphCachedOperationBlock-CP1ZiuIB.js";
+const g = new RegExp(/\/\{(\w+)\}(?=\/|$)/g);
+class O {
+  constructor(r, s) {
+    this.path = r, this.ownerBlock = s, this.templatedInputs = [];
+    let n = g.exec(r);
+    const o = /* @__PURE__ */ new Set();
+    for (; n; ) {
+      const [, e] = n;
+      if (o.has(e))
+        throw new Error("Duplicate template variable detected.");
+      o.add(e), this.templatedInputs.push(s.registerDataInput(e, A, new F(0))), n = g.exec(r);
+    }
+  }
+  /**
+   * Get the accessor for the path.
+   * @param pathConverter the path converter to use to convert the path to an object accessor.
+   * @param context the context to use.
+   * @returns the accessor for the path.
+   * @throws if the value for a templated input is invalid.
+   */
+  getAccessor(r, s) {
+    let n = this.path;
+    for (const o of this.templatedInputs) {
+      const e = o.getValue(s).value;
+      if (typeof e != "number" || e < 0)
+        throw new Error("Invalid value for templated input.");
+      n = n.replace(`{${o.name}}`, e.toString());
+    }
+    return r.convert(n);
+  }
+}
+class V extends N {
+  constructor(r) {
+    super(c, r), this.config = r, this.object = this.registerDataOutput("object", c), this.propertyName = this.registerDataOutput("propertyName", c), this.setterFunction = this.registerDataOutput("setFunction", c, this._setPropertyValue.bind(this)), this.getterFunction = this.registerDataOutput("getFunction", c, this._getPropertyValue.bind(this)), this.generateAnimationsFunction = this.registerDataOutput("generateAnimationsFunction", c, this._getInterpolationAnimationPropertyInfo.bind(this)), this.templateComponent = new O(r.jsonPointer, this);
+  }
+  _doOperation(r) {
+    const s = this.templateComponent.getAccessor(this.config.pathConverter, r), n = s.info.get(s.object), o = s.info.getTarget?.(s.object), e = s.info.getPropertyName?.[0](s.object);
+    if (o)
+      this.object.setValue(o, r), e && this.propertyName.setValue(e, r);
+    else
+      throw new Error("Object is undefined");
+    return n;
+  }
+  _setPropertyValue(r, s, n, o) {
+    const e = this.templateComponent.getAccessor(this.config.pathConverter, o), i = e.info.type;
+    i.startsWith("Color") && (n = C(n, i)), e.info.set?.(n, e.object);
+  }
+  _getPropertyValue(r, s, n) {
+    const o = this.templateComponent.getAccessor(this.config.pathConverter, n), e = o.info.type, i = o.info.get(o.object);
+    return e.startsWith("Color") ? D(i) : i;
+  }
+  _getInterpolationAnimationPropertyInfo(r, s, n) {
+    const o = this.templateComponent.getAccessor(this.config.pathConverter, n);
+    return (e, i, b, h) => {
+      const l = [], m = o.info.type;
+      return m.startsWith("Color") && (e = e.map((p) => ({
+        frame: p.frame,
+        value: C(p.value, m)
+      }))), o.info.interpolation?.forEach((p, f) => {
+        const d = o.info.getPropertyName?.[f](o.object) || "Animation-interpolation-" + f;
+        let u = e;
+        b !== p.type && (u = e.map((a) => ({
+          frame: a.frame,
+          value: p.getValue(void 0, a.value.asArray ? a.value.asArray() : [a.value], 0, 1)
+        })));
+        const P = p.buildAnimations(o.object, d, 60, u);
+        for (const a of P)
+          h && a.babylonAnimation.setEasingFunction(h), l.push(a.babylonAnimation);
+      }), l;
+    };
+  }
+  /**
+   * Gets the class name of this block
+   * @returns the class name
+   */
+  getClassName() {
+    return "FlowGraphJsonPointerParserBlock";
+  }
+}
+function C(t, r) {
+  return t.getClassName().startsWith("Color") ? t : r === "Color3" ? new y(t.x, t.y, t.z) : r === "Color4" ? new w(t.x, t.y, t.z, t.w) : t;
+}
+function D(t) {
+  if (t instanceof y)
+    return new j(t.r, t.g, t.b);
+  if (t instanceof w)
+    return new I(t.r, t.g, t.b, t.a);
+  throw new Error("Invalid color type");
+}
+_("FlowGraphJsonPointerParserBlock", V);
+export {
+  V as FlowGraphJsonPointerParserBlock
+};

package/dist/flowGraphKeyDownEventBlock-D5T1Uyfv.js

@@ -0,0 +1,26 @@
+import { aN as s, aK as a } from "./index-CS3Icp_r.js";
+import { F as o } from "./flowGraphKeyboardEventBlock-C49fx3TC.js";
+class n extends o {
+  /**
+   * Creates a new FlowGraphKeyDownEventBlock.
+   * @param config optional configuration
+   */
+  constructor(e) {
+    super(e), this.type = "KeyDown", this.isRepeat = this.registerDataOutput("isRepeat", s);
+  }
+  /** @internal */
+  _executeEvent(e, t) {
+    const r = t.event.repeat ?? !1;
+    return r && this.config?.ignoreRepeat ? !0 : (this.isRepeat.setValue(r, e), super._executeEvent(e, t));
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphKeyDownEventBlock";
+  }
+}
+a("FlowGraphKeyDownEventBlock", n);
+export {
+  n as FlowGraphKeyDownEventBlock
+};

package/dist/flowGraphKeyUpEventBlock-BPY_Kgkm.js

@@ -0,0 +1,21 @@
+import { aK as o } from "./index-CS3Icp_r.js";
+import { F as r } from "./flowGraphKeyboardEventBlock-C49fx3TC.js";
+class t extends r {
+  /**
+   * Creates a new FlowGraphKeyUpEventBlock.
+   * @param config optional configuration
+   */
+  constructor(e) {
+    super(e), this.type = "KeyUp";
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphKeyUpEventBlock";
+  }
+}
+o("FlowGraphKeyUpEventBlock", t);
+export {
+  t as FlowGraphKeyUpEventBlock
+};

package/dist/flowGraphKeyboardEventBlock-C49fx3TC.js

@@ -0,0 +1,20 @@
+import { Q as h, aU as a, aN as s, bq as u } from "./index-CS3Icp_r.js";
+class o extends h {
+  constructor(e) {
+    super(e), this.key = this.registerDataInput("key", a), this.keyCode = this.registerDataOutput("keyCode", a), this.keyValue = this.registerDataOutput("keyValue", a), this.shiftKey = this.registerDataOutput("shiftKey", s), this.ctrlKey = this.registerDataOutput("ctrlKey", s), this.altKey = this.registerDataOutput("altKey", s), this.metaKey = this.registerDataOutput("metaKey", s), this.commandOrCtrl = this.registerDataOutput("commandOrCtrl", s);
+  }
+  /** @internal */
+  _executeEvent(e, r) {
+    const t = r.event, i = this.key.getValue(e);
+    return i && i !== t.code ? !0 : (this.keyCode.setValue(t.code, e), this.keyValue.setValue(t.key, e), this.shiftKey.setValue(t.shiftKey, e), this.ctrlKey.setValue(t.ctrlKey, e), this.altKey.setValue(t.altKey, e), this.metaKey.setValue(t.metaKey, e), this.commandOrCtrl.setValue(u ? t.metaKey : t.ctrlKey, e), this._execute(e), !this.config?.stopPropagation);
+  }
+  /** @internal */
+  _preparePendingTasks(e) {
+  }
+  /** @internal */
+  _cancelPendingTasks(e) {
+  }
+}
+export {
+  o as F
+};