@vived/component-abb-6700 1.0.0

package/dist/flowGraphApplyForceBlock-6e8-wcaw.js

@@ -0,0 +1,32 @@
+import { S as r, aM as s, aW as a, aK as c } from "./index-CS3Icp_r.js";
+class l extends r {
+  /**
+   * Constructs a new FlowGraphApplyForceBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(t) {
+    super(t), this.body = this.registerDataInput("body", s), this.force = this.registerDataInput("force", a), this.location = this.registerDataInput("location", a);
+  }
+  /**
+   * @internal
+   */
+  _execute(t, h) {
+    const o = this.body.getValue(t);
+    if (!o) {
+      this._reportError(t, "No physics body provided"), this.out._activateSignal(t);
+      return;
+    }
+    const e = this.force.getValue(t), i = this.location.getValue(t);
+    o.applyForce(e, i), this.out._activateSignal(t);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphApplyForceBlock";
+  }
+}
+c("FlowGraphApplyForceBlock", l);
+export {
+  l as FlowGraphApplyForceBlock
+};

package/dist/flowGraphApplyImpulseBlock-B27EZQow.js

@@ -0,0 +1,32 @@
+import { S as l, aM as o, aW as i, aK as p } from "./index-CS3Icp_r.js";
+class r extends l {
+  /**
+   * Constructs a new FlowGraphApplyImpulseBlock.
+   * @param config - optional configuration for the block
+   */
+  constructor(s) {
+    super(s), this.body = this.registerDataInput("body", o), this.impulse = this.registerDataInput("impulse", i), this.location = this.registerDataInput("location", i);
+  }
+  /**
+   * @internal
+   */
+  _execute(s, c) {
+    const t = this.body.getValue(s);
+    if (!t) {
+      this._reportError(s, "No physics body provided"), this.out._activateSignal(s);
+      return;
+    }
+    const a = this.impulse.getValue(s), e = this.location.getValue(s);
+    t.applyImpulse(a, e), this.out._activateSignal(s);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphApplyImpulseBlock";
+  }
+}
+p("FlowGraphApplyImpulseBlock", r);
+export {
+  r as FlowGraphApplyImpulseBlock
+};

package/dist/flowGraphArrayIndexBlock-DIUn5e4i.js

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

package/dist/flowGraphBezierCurveEasingBlock-BJmiHk40.js

@@ -0,0 +1,25 @@
+import { a as r } from "./easing-BAt0SO-B.js";
+import { O as u, aS as c, aV as a, aM as h, aK as g } from "./index-CS3Icp_r.js";
+class l extends u {
+  constructor(t) {
+    super(t), this.config = t, this._easingFunctions = {}, this.mode = this.registerDataInput("mode", c, 0), this.controlPoint1 = this.registerDataInput("controlPoint1", a), this.controlPoint2 = this.registerDataInput("controlPoint2", a), this.easingFunction = this.registerDataOutput("easingFunction", h);
+  }
+  _updateOutputs(t) {
+    const e = this.mode.getValue(t), s = this.controlPoint1.getValue(t), i = this.controlPoint2.getValue(t);
+    if (e === void 0)
+      return;
+    const n = `${e}-${s.x}-${s.y}-${i.x}-${i.y}`;
+    if (!this._easingFunctions[n]) {
+      const o = new r(s.x, s.y, i.x, i.y);
+      o.setEasingMode(e), this._easingFunctions[n] = o;
+    }
+    this.easingFunction.setValue(this._easingFunctions[n], t);
+  }
+  getClassName() {
+    return "FlowGraphBezierCurveEasing";
+  }
+}
+g("FlowGraphBezierCurveEasing", l);
+export {
+  l as FlowGraphBezierCurveEasingBlock
+};

package/dist/flowGraphBinaryOperationBlock-Bj7TANCc.js

@@ -0,0 +1,25 @@
+import { F as o } from "./flowGraphCachedOperationBlock-CP1ZiuIB.js";
+class p extends o {
+  constructor(t, a, s, e, r, i) {
+    super(s, i), this._operation = e, this._className = r, this.a = this.registerDataInput("a", t), this.b = this.registerDataInput("b", a);
+  }
+  /**
+   * the operation performed by this block
+   * @param context the graph context
+   * @returns the result of the operation
+   */
+  _doOperation(t) {
+    const a = this.a.getValue(t), s = this.b.getValue(t);
+    return this._operation(a, s);
+  }
+  /**
+   * Gets the class name of this block
+   * @returns the class name
+   */
+  getClassName() {
+    return this._className;
+  }
+}
+export {
+  p as F
+};

package/dist/flowGraphBranchBlock-7CRvIKWc.js

@@ -0,0 +1,19 @@
+import { R as a, aN as e, aK as i } from "./index-CS3Icp_r.js";
+class s extends a {
+  constructor(t) {
+    super(t), this.condition = this.registerDataInput("condition", e), this.onTrue = this._registerSignalOutput("onTrue"), this.onFalse = this._registerSignalOutput("onFalse");
+  }
+  _execute(t) {
+    this.condition.getValue(t) ? this.onTrue._activateSignal(t) : this.onFalse._activateSignal(t);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphBranchBlock";
+  }
+}
+i("FlowGraphBranchBlock", s);
+export {
+  s as FlowGraphBranchBlock
+};

package/dist/flowGraphCachedOperationBlock-CP1ZiuIB.js

@@ -0,0 +1,26 @@
+import { O as u, aN as h } from "./index-CS3Icp_r.js";
+const l = "cachedOperationValue", t = "cachedExecutionId";
+class c extends u {
+  constructor(e, i) {
+    super(i), this.value = this.registerDataOutput("value", e), this.isValid = this.registerDataOutput("isValid", h);
+  }
+  _updateOutputs(e) {
+    const i = e._getExecutionVariable(this, t, -1), s = e._getExecutionVariable(this, l, null);
+    if (s != null && i === e.executionId)
+      this.isValid.setValue(!0, e), this.value.setValue(s, e);
+    else
+      try {
+        const a = this._doOperation(e);
+        if (a == null) {
+          this.isValid.setValue(!1, e);
+          return;
+        }
+        e._setExecutionVariable(this, l, a), e._setExecutionVariable(this, t, e.executionId), this.value.setValue(a, e), this.isValid.setValue(!0, e);
+      } catch {
+        this.isValid.setValue(!1, e);
+      }
+  }
+}
+export {
+  c as F
+};

package/dist/flowGraphCancelDelayBlock-DqtgzBGm.js

@@ -0,0 +1,20 @@
+import { S as t, aO as i, bT as s, aK as r } from "./index-CS3Icp_r.js";
+class n extends t {
+  constructor(e) {
+    super(e), this.delayIndex = this.registerDataInput("delayIndex", i);
+  }
+  _execute(e, c) {
+    const a = s(this.delayIndex.getValue(e));
+    if (a <= 0 || isNaN(a) || !isFinite(a))
+      return this._reportError(e, "Invalid delay index");
+    const l = e._getGlobalContextVariable("pendingDelays", [])[a];
+    l && l.dispose(), this.out._activateSignal(e);
+  }
+  getClassName() {
+    return "FlowGraphCancelDelayBlock";
+  }
+}
+r("FlowGraphCancelDelayBlock", n);
+export {
+  n as FlowGraphCancelDelayBlock
+};

package/dist/flowGraphCodeExecutionBlock-CaYXCGqo.js

@@ -0,0 +1,23 @@
+import { O as a, aM as e } from "./index-CS3Icp_r.js";
+class o extends a {
+  /**
+   * Construct a FlowGraphCodeExecutionBlock.
+   * @param config construction parameters
+   */
+  constructor(t) {
+    super(t), this.config = t, this.executionFunction = this.registerDataInput("function", e), this.value = this.registerDataInput("value", e), this.result = this.registerDataOutput("result", e);
+  }
+  /**
+   * @internal
+   */
+  _updateOutputs(t) {
+    const s = this.executionFunction.getValue(t), u = this.value.getValue(t);
+    s && this.result.setValue(s(u, t), t);
+  }
+  getClassName() {
+    return "FlowGraphCodeExecutionBlock";
+  }
+}
+export {
+  o as FlowGraphCodeExecutionBlock
+};

package/dist/flowGraphConditionalDataBlock-DJ7evX8_.js

@@ -0,0 +1,28 @@
+import { O as s, aN as i, aM as a, aK as e } from "./index-CS3Icp_r.js";
+class n extends s {
+  /**
+   * Creates a new instance of the block
+   * @param config optional configuration for this block
+   */
+  constructor(t) {
+    super(t), this.condition = this.registerDataInput("condition", i), this.onTrue = this.registerDataInput("onTrue", a), this.onFalse = this.registerDataInput("onFalse", a), this.output = this.registerDataOutput("output", a);
+  }
+  /**
+   * @internal
+   */
+  _updateOutputs(t) {
+    const o = this.condition.getValue(t);
+    this.output.setValue(o ? this.onTrue.getValue(t) : this.onFalse.getValue(t), t);
+  }
+  /**
+   * Gets the class name of this block
+   * @returns the class name
+   */
+  getClassName() {
+    return "FlowGraphConditionalBlock";
+  }
+}
+e("FlowGraphConditionalBlock", n);
+export {
+  n as FlowGraphConditionalDataBlock
+};

package/dist/flowGraphConsoleLogBlock-cMkpqLzO.js

@@ -0,0 +1,68 @@
+import { S as c, aM as n, aU as h, a7 as g, aK as u } from "./index-CS3Icp_r.js";
+class p extends c {
+  /**
+   * Creates a new console log block.
+   * @param config optional configuration
+   */
+  constructor(e) {
+    if (super(e), this.message = this.registerDataInput("message", n), this.logType = this.registerDataInput("logType", h, "log"), e?.messageTemplate) {
+      const t = this._getTemplateMatches(e.messageTemplate);
+      for (const s of t)
+        this.registerDataInput(s, n);
+    }
+  }
+  /**
+   * @internal
+   */
+  _execute(e) {
+    const t = this.logType.getValue(e), s = this._getMessageValue(e);
+    t === "warn" ? g.Warn(s) : t === "error" ? g.Error(s) : g.Log(s), this.out._activateSignal(e);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphConsoleLogBlock";
+  }
+  _serializeValue(e) {
+    if (e == null)
+      return String(e);
+    if (typeof e == "object") {
+      const t = e.toString();
+      if (t === "[object Object]")
+        try {
+          return JSON.stringify(e);
+        } catch {
+          return t;
+        }
+      return t;
+    }
+    return String(e);
+  }
+  _getMessageValue(e) {
+    if (this.config?.messageTemplate) {
+      let t = this.config.messageTemplate;
+      const s = this._getTemplateMatches(t), a = this.message.getValue(e), i = a != null && typeof a == "object" ? a : null;
+      for (const r of s) {
+        let l;
+        if (i !== null && r in i ? l = i[r] : l = this.getDataInput(r)?.getValue(e), l !== void 0) {
+          const o = r.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          t = t.replace(new RegExp(`\\{${o}\\}`, "g"), this._serializeValue(l));
+        }
+      }
+      return t;
+    } else
+      return this.message.getValue(e);
+  }
+  _getTemplateMatches(e) {
+    const t = /\{([^}]+)\}/g, s = [];
+    let a;
+    for (; (a = t.exec(e)) !== null; )
+      s.push(a[1]);
+    return s;
+  }
+}
+u("FlowGraphConsoleLogBlock", p);
+export {
+  p as FlowGraphConsoleLogBlock
+};

package/dist/flowGraphConstantBlock-JWybwT0A.js

@@ -0,0 +1,28 @@
+import { O as s, bX as e, bQ as u, aK as o } from "./index-CS3Icp_r.js";
+class l extends s {
+  constructor(t) {
+    super(t), this.config = t, this.output = this.registerDataOutput("output", e(t.value));
+  }
+  _updateOutputs(t) {
+    this.output.setValue(this.config.value, t);
+  }
+  /**
+   * Gets the class name of this block
+   * @returns the class name
+   */
+  getClassName() {
+    return "FlowGraphConstantBlock";
+  }
+  /**
+   * Serializes this block
+   * @param serializationObject the object to serialize to
+   * @param valueSerializeFunction the function to use to serialize the value
+   */
+  serialize(t = {}, a = u) {
+    super.serialize(t), a("value", this.config.value, t.config);
+  }
+}
+o("FlowGraphConstantBlock", l);
+export {
+  l as FlowGraphConstantBlock
+};

package/dist/flowGraphContextBlock-CFDXHcbn.js

@@ -0,0 +1,19 @@
+import { O as s, aM as a, aS as t, aK as r } from "./index-CS3Icp_r.js";
+class i extends s {
+  constructor(e) {
+    super(e), this.userVariables = this.registerDataOutput("userVariables", a), this.executionId = this.registerDataOutput("executionId", t);
+  }
+  _updateOutputs(e) {
+    this.userVariables.setValue(e.userVariables, e), this.executionId.setValue(e.executionId, e);
+  }
+  serialize(e) {
+    super.serialize(e);
+  }
+  getClassName() {
+    return "FlowGraphContextBlock";
+  }
+}
+r("FlowGraphContextBlock", i);
+export {
+  i as FlowGraphContextBlock
+};

package/dist/flowGraphCounterBlock-B0uPkgw9.js

@@ -0,0 +1,24 @@
+import { S as a, aS as i, aK as r } from "./index-CS3Icp_r.js";
+class u extends a {
+  constructor(t) {
+    super(t), this.count = this.registerDataOutput("count", i), this.reset = this._registerSignalInput("reset");
+  }
+  _execute(t, s) {
+    if (s === this.reset) {
+      t._setExecutionVariable(this, "count", 0), this.count.setValue(0, t);
+      return;
+    }
+    const e = t._getExecutionVariable(this, "count", 0) + 1;
+    t._setExecutionVariable(this, "count", e), this.count.setValue(e, t), this.out._activateSignal(t);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphCallCounterBlock";
+  }
+}
+r("FlowGraphCallCounterBlock", u);
+export {
+  u as FlowGraphCallCounterBlock
+};

package/dist/flowGraphDataSwitchBlock-B0GSifvJ.js

@@ -0,0 +1,27 @@
+import { O as u, aM as a, bT as i, bZ as r, aK as l } from "./index-CS3Icp_r.js";
+class h extends u {
+  constructor(e) {
+    super(e), this.config = e, this._inputCases = /* @__PURE__ */ new Map(), this.case = this.registerDataInput("case", a, NaN), this.default = this.registerDataInput("default", a), this.value = this.registerDataOutput("value", a);
+    const s = this.config.cases || [];
+    for (let t of s) {
+      if (t = i(t), this.config.treatCasesAsIntegers && (t = t | 0, this._inputCases.has(t)))
+        return;
+      this._inputCases.set(t, this.registerDataInput(`in_${t}`, a));
+    }
+  }
+  _updateOutputs(e) {
+    const s = this.case.getValue(e);
+    let t;
+    r(s) && (t = this._getOutputValueForCase(i(s), e)), t || (t = this.default.getValue(e)), this.value.setValue(t, e);
+  }
+  _getOutputValueForCase(e, s) {
+    return this._inputCases.get(e)?.getValue(s);
+  }
+  getClassName() {
+    return "FlowGraphDataSwitchBlock";
+  }
+}
+l("FlowGraphDataSwitchBlock", h);
+export {
+  h as FlowGraphDataSwitchBlock
+};

package/dist/flowGraphDebounceBlock-CSw8zKym.js

@@ -0,0 +1,24 @@
+import { S as n, aS as u, aK as o } from "./index-CS3Icp_r.js";
+class i extends n {
+  constructor(t) {
+    super(t), this.count = this.registerDataInput("count", u), this.reset = this._registerSignalInput("reset"), this.currentCount = this.registerDataOutput("currentCount", u);
+  }
+  _execute(t, s) {
+    if (s === this.reset) {
+      t._setExecutionVariable(this, "debounceCount", 0);
+      return;
+    }
+    const r = this.count.getValue(t), e = t._getExecutionVariable(this, "debounceCount", 0) + 1;
+    this.currentCount.setValue(e, t), t._setExecutionVariable(this, "debounceCount", e), e >= r && (this.out._activateSignal(t), t._setExecutionVariable(this, "debounceCount", 0));
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphDebounceBlock";
+  }
+}
+o("FlowGraphDebounceBlock", i);
+export {
+  i as FlowGraphDebounceBlock
+};

package/dist/flowGraphDebugBlock-DiSR6Ahn.js

@@ -0,0 +1,65 @@
+import { O as r, aM as n, aK as s } from "./index-CS3Icp_r.js";
+const g = 100;
+class o extends r {
+  constructor(t) {
+    super(t), this.log = [], this._isDebug = !0, this.input = this.registerDataInput("input", n), this.output = this.registerDataOutput("output", n);
+  }
+  /**
+   * @internal
+   */
+  _updateOutputs(t) {
+    const i = this.input.getValue(t);
+    this.output.setValue(i, t), this._logValue(i);
+  }
+  /**
+   * Format and store a value in the log.
+   * @param value
+   */
+  _logValue(t) {
+    if (t == null)
+      this.log.push(["null", "null"]);
+    else {
+      const i = o._FormatValue(t);
+      this.log.push([i, String(t)]);
+    }
+    this.log.length > g && this.log.shift();
+  }
+  /**
+   * Type-aware value formatting.
+   * @param value the value to format
+   * @returns a human-readable string
+   */
+  static _FormatValue(t) {
+    if (typeof t == "number")
+      return Number.isInteger(t) ? t.toString() : t.toFixed(4);
+    if (typeof t == "boolean" || typeof t == "string")
+      return String(t);
+    if (t && typeof t == "object") {
+      if ("w" in t && "x" in t && "y" in t && "z" in t)
+        return `(${t.x.toFixed(3)}, ${t.y.toFixed(3)}, ${t.z.toFixed(3)}, ${t.w.toFixed(3)})`;
+      if ("z" in t && "x" in t && "y" in t)
+        return `(${t.x.toFixed(3)}, ${t.y.toFixed(3)}, ${t.z.toFixed(3)})`;
+      if ("x" in t && "y" in t)
+        return `(${t.x.toFixed(3)}, ${t.y.toFixed(3)})`;
+      if ("r" in t && "g" in t && "b" in t) {
+        const i = "a" in t ? `, ${t.a.toFixed(3)}` : "";
+        return `(${t.r.toFixed(3)}, ${t.g.toFixed(3)}, ${t.b.toFixed(3)}${i})`;
+      }
+      if (typeof t.toString == "function" && t.toString !== Object.prototype.toString)
+        return t.toString();
+    }
+    try {
+      const i = JSON.stringify(t);
+      return i.length > 64 ? i.substring(0, 61) + "..." : i;
+    } catch {
+      return String(t);
+    }
+  }
+  getClassName() {
+    return "FlowGraphDebugBlock";
+  }
+}
+s("FlowGraphDebugBlock", o);
+export {
+  o as FlowGraphDebugBlock
+};

package/dist/flowGraphDoNBlock-C-48oQ2H.js

@@ -0,0 +1,24 @@
+import { S as u, T as e, aO as a, aK as o } from "./index-CS3Icp_r.js";
+class r extends u {
+  constructor(t = {}) {
+    super(t), this.config = t, this.config.startIndex = t.startIndex ?? new e(0), this.reset = this._registerSignalInput("reset"), this.maxExecutions = this.registerDataInput("maxExecutions", a), this.executionCount = this.registerDataOutput("executionCount", a, new e(0));
+  }
+  _execute(t, i) {
+    if (i === this.reset)
+      this.executionCount.setValue(this.config.startIndex, t);
+    else {
+      const s = this.executionCount.getValue(t);
+      s.value < this.maxExecutions.getValue(t).value && (this.executionCount.setValue(new e(s.value + 1), t), this.out._activateSignal(t));
+    }
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphDoNBlock";
+  }
+}
+o("FlowGraphDoNBlock", r);
+export {
+  r as FlowGraphDoNBlock
+};

package/dist/flowGraphEasingBlock-DKUaE7Rp.js

@@ -0,0 +1,50 @@
+import { d as h, E, c as o, b as d, B as w, C as B, a as n } from "./easing-BAt0SO-B.js";
+import { O as C, aM as i, aS as m, aK as f } from "./index-CS3Icp_r.js";
+var l;
+(function(e) {
+  e[e.CircleEase = 0] = "CircleEase", e[e.BackEase = 1] = "BackEase", e[e.BounceEase = 2] = "BounceEase", e[e.CubicEase = 3] = "CubicEase", e[e.ElasticEase = 4] = "ElasticEase", e[e.ExponentialEase = 5] = "ExponentialEase", e[e.PowerEase = 6] = "PowerEase", e[e.QuadraticEase = 7] = "QuadraticEase", e[e.QuarticEase = 8] = "QuarticEase", e[e.QuinticEase = 9] = "QuinticEase", e[e.SineEase = 10] = "SineEase", e[e.BezierCurveEase = 11] = "BezierCurveEase";
+})(l || (l = {}));
+function k(e, ...s) {
+  switch (e) {
+    case 11:
+      return new n(...s);
+    case 0:
+      return new B();
+    case 1:
+      return new w(...s);
+    case 2:
+      return new d(...s);
+    case 3:
+      return new o();
+    case 4:
+      return new E(...s);
+    case 5:
+      return new h(...s);
+    default:
+      throw new Error("Easing type not yet implemented");
+  }
+}
+class Q extends C {
+  constructor(s) {
+    super(s), this.config = s, this._easingFunctions = {}, this.type = this.registerDataInput("type", i, 11), this.mode = this.registerDataInput("mode", m, 0), this.parameters = this.registerDataInput("parameters", i, [1, 0, 0, 1]), this.easingFunction = this.registerDataOutput("easingFunction", i);
+  }
+  _updateOutputs(s) {
+    const a = this.type.getValue(s), t = this.mode.getValue(s), u = this.parameters.getValue(s);
+    if (a === void 0 || t === void 0)
+      return;
+    const r = `${a}-${t}-${u.join("-")}`;
+    if (!this._easingFunctions[r]) {
+      const c = k(a, ...u);
+      c.setEasingMode(t), this._easingFunctions[r] = c;
+    }
+    this.easingFunction.setValue(this._easingFunctions[r], s);
+  }
+  getClassName() {
+    return "FlowGraphEasingBlock";
+  }
+}
+f("FlowGraphEasingBlock", Q);
+export {
+  l as EasingFunctionType,
+  Q as FlowGraphEasingBlock
+};

package/dist/flowGraphFlipFlopBlock-DX5BGhMV.js

@@ -0,0 +1,20 @@
+import { R as l, aN as t, aK as i } from "./index-CS3Icp_r.js";
+class s extends l {
+  constructor(a) {
+    super(a), this.onOn = this._registerSignalOutput("onOn"), this.onOff = this._registerSignalOutput("onOff"), this.value = this.registerDataOutput("value", t);
+  }
+  _execute(a, r) {
+    let e = a._getExecutionVariable(this, "value", typeof this.config?.startValue == "boolean" ? !this.config.startValue : !1);
+    e = !e, a._setExecutionVariable(this, "value", e), this.value.setValue(e, a), e ? this.onOn._activateSignal(a) : this.onOff._activateSignal(a);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphFlipFlopBlock";
+  }
+}
+i("FlowGraphFlipFlopBlock", s);
+export {
+  s as FlowGraphFlipFlopBlock
+};

package/dist/flowGraphForLoopBlock-Di-Qwg23.js

@@ -0,0 +1,27 @@
+import { S as h, aM as l, aS as u, aO as p, T as n, bT as t, aK as d } from "./index-CS3Icp_r.js";
+class s extends h {
+  constructor(e) {
+    super(e), this.startIndex = this.registerDataInput("startIndex", l, 0), this.endIndex = this.registerDataInput("endIndex", l), this.step = this.registerDataInput("step", u, 1), this.index = this.registerDataOutput("index", p, new n(t(e?.initialIndex ?? 0))), this.executionFlow = this._registerSignalOutput("executionFlow"), this.completed = this._registerSignalOutput("completed"), this._unregisterSignalOutput("out");
+  }
+  /**
+   * @internal
+   */
+  _execute(e) {
+    const o = t(this.startIndex.getValue(e)), a = this.step.getValue(e);
+    let r = t(this.endIndex.getValue(e));
+    for (let i = o; i < r && (this.index.setValue(new n(i), e), this.executionFlow._activateSignal(e), r = t(this.endIndex.getValue(e)), !(i > s.MaxLoopIterations * a)); i += a)
+      ;
+    this.config?.incrementIndexWhenLoopDone && this.index.setValue(new n(t(this.index.getValue(e)) + a), e), this.completed._activateSignal(e);
+  }
+  /**
+   * @returns class name of the block.
+   */
+  getClassName() {
+    return "FlowGraphForLoopBlock";
+  }
+}
+s.MaxLoopIterations = 1e3;
+d("FlowGraphForLoopBlock", s);
+export {
+  s as FlowGraphForLoopBlock
+};