@vived/component-abb-6700 1.0.0

package/dist/flowGraphMathBlocks-CkvrN3VJ.js

@@ -0,0 +1,864 @@
+import { aO as G, T as y, bW as i, aM as l, aS as a, aN as B, bZ as I, bT as m, bm as F, bk as d, bj as x, bi as _, bg as k, U as f, V as M, ad as T, aJ as N, bf as S, be as v, aK as s } from "./index-CS3Icp_r.js";
+import { F as w } from "./flowGraphBinaryOperationBlock-Bj7TANCc.js";
+import { F as R } from "./flowGraphCachedOperationBlock-CP1ZiuIB.js";
+import { F as c } from "./flowGraphUnaryOperationBlock-B0Shf-lJ.js";
+class g extends R {
+  constructor(r, o, t, n) {
+    super(r, n), this._operation = o, this._className = t;
+  }
+  /**
+   * the operation performed by this block
+   * @param context the graph context
+   * @returns the result of the operation
+   */
+  _doOperation(r) {
+    return this._operation(r);
+  }
+  /**
+   * Gets the class name of this block
+   * @returns the class name
+   */
+  getClassName() {
+    return this._className;
+  }
+}
+class D extends R {
+  constructor(r, o, t, n, p, u, O) {
+    super(n, O), this._operation = p, this._className = u, this.a = this.registerDataInput("a", r), this.b = this.registerDataInput("b", o), this.c = this.registerDataInput("c", t);
+  }
+  /**
+   * the operation performed by this block
+   * @param context the graph context
+   * @returns the result of the operation
+   */
+  _doOperation(r) {
+    return this._operation(this.a.getValue(r), this.b.getValue(r), this.c.getValue(r));
+  }
+  /**
+   * Gets the class name of this block
+   * @returns the class name
+   */
+  getClassName() {
+    return this._className;
+  }
+}
+class L extends w {
+  /**
+   * Construct a new add block.
+   * @param config optional configuration
+   */
+  constructor(r) {
+    super(i(r?.type), i(r?.type), i(r?.type), (o, t) => this._polymorphicAdd(o, t), "FlowGraphAddBlock", r);
+  }
+  _polymorphicAdd(r, o) {
+    const t = F(r), n = F(o);
+    if (d(t, n) || x(t, n) || _(t, n))
+      return r.add(o);
+    if (t === "Quaternion" || n === "Vector4")
+      return new k(r.x, r.y, r.z, r.w).addInPlace(o);
+    if (t === "Vector4" || n === "Quaternion")
+      return r.add(o);
+    if (this.config?.preventIntegerFloatArithmetic && typeof r != typeof o)
+      throw new Error("Cannot add different types of numbers.");
+    return m(r) + m(o);
+  }
+}
+s("FlowGraphAddBlock", L);
+class V extends w {
+  /**
+   * Construct a new subtract block.
+   * @param config optional configuration
+   */
+  constructor(r) {
+    super(i(r?.type), i(r?.type), i(r?.type), (o, t) => this._polymorphicSubtract(o, t), "FlowGraphSubtractBlock", r);
+  }
+  _polymorphicSubtract(r, o) {
+    const t = F(r), n = F(o);
+    if (d(t, n) || _(t, n) || x(t, n))
+      return r.subtract(o);
+    if (t === "Quaternion" || n === "Vector4")
+      return new k(r.x, r.y, r.z, r.w).subtractInPlace(o);
+    if (t === "Vector4" || n === "Quaternion")
+      return r.subtract(o);
+    if (this.config?.preventIntegerFloatArithmetic && typeof r != typeof o)
+      throw new Error("Cannot add different types of numbers.");
+    return m(r) - m(o);
+  }
+}
+s("FlowGraphSubtractBlock", V);
+class z extends w {
+  constructor(r) {
+    super(i(r?.type), i(r?.type), i(r?.type), (o, t) => this._polymorphicMultiply(o, t), "FlowGraphMultiplyBlock", r);
+  }
+  _polymorphicMultiply(r, o) {
+    const t = F(r), n = F(o);
+    if (d(t, n) || _(t, n))
+      return r.multiply(o);
+    if (t === "Quaternion" || n === "Vector4")
+      return new k(r.x, r.y, r.z, r.w).multiplyInPlace(o);
+    if (t === "Vector4" || n === "Quaternion")
+      return r.multiply(o);
+    if (x(t, n))
+      if (this.config?.useMatrixPerComponent) {
+        const p = r.m;
+        for (let u = 0; u < p.length; u++)
+          p[u] *= o.m[u];
+        return t === "Matrix2D" ? new f(p) : t === "Matrix3D" ? new M(p) : T.FromArray(p);
+      } else
+        return r = r, o = o, o.multiply(r);
+    else {
+      if (this.config?.preventIntegerFloatArithmetic && typeof r != typeof o)
+        throw new Error("Cannot add different types of numbers.");
+      return m(r) * m(o);
+    }
+  }
+}
+s("FlowGraphMultiplyBlock", z);
+class q extends w {
+  /**
+   * Construct a new divide block.
+   * @param config - Optional configuration
+   */
+  constructor(r) {
+    super(i(r?.type), i(r?.type), i(r?.type), (o, t) => this._polymorphicDivide(o, t), "FlowGraphDivideBlock", r);
+  }
+  _polymorphicDivide(r, o) {
+    const t = F(r), n = F(o);
+    if (d(t, n) || _(t, n))
+      return r.divide(o);
+    if (t === "Quaternion" || n === "Quaternion") {
+      const p = r.clone();
+      return p.x /= o.x, p.y /= o.y, p.z /= o.z, p.w /= o.w, p;
+    } else {
+      if (t === "Quaternion" || n === "Vector4")
+        return new k(r.x, r.y, r.z, r.w).divideInPlace(o);
+      if (t === "Vector4" || n === "Quaternion")
+        return r.divide(o);
+      if (x(t, n))
+        if (this.config?.useMatrixPerComponent) {
+          const p = r.m;
+          for (let u = 0; u < p.length; u++)
+            p[u] /= o.m[u];
+          return t === "Matrix2D" ? new f(p) : t === "Matrix3D" ? new M(p) : T.FromArray(p);
+        } else
+          return r = r, o = o, r.divide(o);
+      else {
+        if (this.config?.preventIntegerFloatArithmetic && typeof r != typeof o)
+          throw new Error("Cannot add different types of numbers.");
+        return m(r) / m(o);
+      }
+    }
+  }
+}
+s("FlowGraphDivideBlock", q);
+class P extends g {
+  /**
+   * Construct a new random block.
+   * @param config optional configuration
+   */
+  constructor(r) {
+    super(a, (o) => this._random(o), "FlowGraphRandomBlock", r), this.min = this.registerDataInput("min", a, r?.min ?? 0), this.max = this.registerDataInput("max", a, r?.max ?? 1), r?.seed && (this._seed = r.seed);
+  }
+  _isSeed(r = this._seed) {
+    return r !== void 0;
+  }
+  _getRandomValue() {
+    if (this._isSeed(this._seed)) {
+      const r = Math.sin(this._seed++) * 1e4;
+      return r - Math.floor(r);
+    }
+    return Math.random();
+  }
+  _random(r) {
+    const o = this.min.getValue(r), t = this.max.getValue(r);
+    return this._getRandomValue() * (t - o) + o;
+  }
+}
+s("FlowGraphRandomBlock", P);
+class Q extends g {
+  constructor(r) {
+    super(a, () => Math.E, "FlowGraphEBlock", r);
+  }
+}
+s("FlowGraphEBlock", Q);
+class $ extends g {
+  constructor(r) {
+    super(a, () => Math.PI, "FlowGraphPIBlock", r);
+  }
+}
+s("FlowGraphPIBlock", $);
+class Z extends g {
+  constructor(r) {
+    super(a, () => Number.POSITIVE_INFINITY, "FlowGraphInfBlock", r);
+  }
+}
+s("FlowGraphInfBlock", Z);
+class j extends g {
+  constructor(r) {
+    super(a, () => Number.NaN, "FlowGraphNaNBlock", r);
+  }
+}
+s("FlowGraphNaNBlock", j);
+function h(e, r) {
+  switch (F(e)) {
+    case "FlowGraphInteger":
+      return e = e, new y(r(e.value));
+    case "Vector2":
+      return e = e, new v(r(e.x), r(e.y));
+    case "Vector3":
+      return e = e, new S(r(e.x), r(e.y), r(e.z));
+    case "Vector4":
+      return e = e, new k(r(e.x), r(e.y), r(e.z), r(e.w));
+    case "Quaternion":
+      return e = e, new N(r(e.x), r(e.y), r(e.z), r(e.w));
+    case "Matrix":
+      return e = e, T.FromArray(e.m.map(r));
+    case "Matrix2D":
+      return e = e, new f(e.m.map(r));
+    case "Matrix3D":
+      return e = e, new M(e.m.map(r));
+    default:
+      return e = e, r(e);
+  }
+}
+class W extends c {
+  constructor(r) {
+    super(a, a, (o) => this._polymorphicAbs(o), "FlowGraphAbsBlock", r);
+  }
+  _polymorphicAbs(r) {
+    return h(r, Math.abs);
+  }
+}
+s("FlowGraphAbsBlock", W);
+class X extends c {
+  constructor(r) {
+    super(a, a, (o) => this._polymorphicSign(o), "FlowGraphSignBlock", r);
+  }
+  _polymorphicSign(r) {
+    return h(r, Math.sign);
+  }
+}
+s("FlowGraphSignBlock", X);
+class U extends c {
+  constructor(r) {
+    super(a, a, (o) => this._polymorphicTrunc(o), "FlowGraphTruncBlock", r);
+  }
+  _polymorphicTrunc(r) {
+    return h(r, Math.trunc);
+  }
+}
+s("FlowGraphTruncBlock", U);
+class H extends c {
+  constructor(r) {
+    super(a, a, (o) => this._polymorphicFloor(o), "FlowGraphFloorBlock", r);
+  }
+  _polymorphicFloor(r) {
+    return h(r, Math.floor);
+  }
+}
+s("FlowGraphFloorBlock", H);
+class J extends c {
+  constructor(r) {
+    super(l, l, (o) => this._polymorphicCeiling(o), "FlowGraphCeilBlock", r);
+  }
+  _polymorphicCeiling(r) {
+    return h(r, Math.ceil);
+  }
+}
+s("FlowGraphCeilBlock", J);
+class K extends c {
+  constructor(r) {
+    super(l, l, (o) => this._polymorphicRound(o), "FlowGraphRoundBlock", r);
+  }
+  _polymorphicRound(r) {
+    return h(r, (o) => o < 0 && this.config?.roundHalfAwayFromZero ? -Math.round(-o) : Math.round(o));
+  }
+}
+s("FlowGraphRoundBlock", K);
+class Y extends c {
+  constructor(r) {
+    super(l, l, (o) => this._polymorphicFraction(o), "FlowGraphFractBlock", r);
+  }
+  _polymorphicFraction(r) {
+    return h(r, (o) => o - Math.floor(o));
+  }
+}
+s("FlowGraphFractBlock", Y);
+class b extends c {
+  /**
+   * construct a new negation block.
+   * @param config optional configuration
+   */
+  constructor(r) {
+    super(l, l, (o) => this._polymorphicNeg(o), "FlowGraphNegationBlock", r);
+  }
+  _polymorphicNeg(r) {
+    return h(r, (o) => -o);
+  }
+}
+s("FlowGraphNegationBlock", b);
+function C(e, r, o) {
+  switch (F(e)) {
+    case "FlowGraphInteger":
+      return e = e, r = r, new y(o(e.value, r.value));
+    case "Vector2":
+      return e = e, r = r, new v(o(e.x, r.x), o(e.y, r.y));
+    case "Vector3":
+      return e = e, r = r, new S(o(e.x, r.x), o(e.y, r.y), o(e.z, r.z));
+    case "Vector4":
+      return e = e, r = r, new k(o(e.x, r.x), o(e.y, r.y), o(e.z, r.z), o(e.w, r.w));
+    case "Quaternion":
+      return e = e, r = r, new N(o(e.x, r.x), o(e.y, r.y), o(e.z, r.z), o(e.w, r.w));
+    case "Matrix":
+      return e = e, T.FromArray(e.m.map((n, p) => o(n, r.m[p])));
+    case "Matrix2D":
+      return e = e, new f(e.m.map((n, p) => o(n, r.m[p])));
+    case "Matrix3D":
+      return e = e, new M(e.m.map((n, p) => o(n, r.m[p])));
+    default:
+      return o(m(e), m(r));
+  }
+}
+class rr extends w {
+  constructor(r) {
+    super(l, l, l, (o, t) => this._polymorphicRemainder(o, t), "FlowGraphModuloBlock", r);
+  }
+  _polymorphicRemainder(r, o) {
+    return C(r, o, (t, n) => t % n);
+  }
+}
+s("FlowGraphModuloBlock", rr);
+class or extends w {
+  constructor(r) {
+    super(l, l, l, (o, t) => this._polymorphicMin(o, t), "FlowGraphMinBlock", r);
+  }
+  _polymorphicMin(r, o) {
+    return C(r, o, Math.min);
+  }
+}
+s("FlowGraphMinBlock", or);
+class er extends w {
+  constructor(r) {
+    super(l, l, l, (o, t) => this._polymorphicMax(o, t), "FlowGraphMaxBlock", r);
+  }
+  _polymorphicMax(r, o) {
+    return C(r, o, Math.max);
+  }
+}
+s("FlowGraphMaxBlock", er);
+function tr(e, r, o) {
+  return Math.min(Math.max(e, Math.min(r, o)), Math.max(r, o));
+}
+function E(e, r, o, t) {
+  switch (F(e)) {
+    case "FlowGraphInteger":
+      return e = e, r = r, o = o, new y(t(e.value, r.value, o.value));
+    case "Vector2":
+      return e = e, r = r, o = o, new v(t(e.x, r.x, o.x), t(e.y, r.y, o.y));
+    case "Vector3":
+      return e = e, r = r, o = o, new S(t(e.x, r.x, o.x), t(e.y, r.y, o.y), t(e.z, r.z, o.z));
+    case "Vector4":
+      return e = e, r = r, o = o, new k(t(e.x, r.x, o.x), t(e.y, r.y, o.y), t(e.z, r.z, o.z), t(e.w, r.w, o.w));
+    case "Quaternion":
+      return e = e, r = r, o = o, new N(t(e.x, r.x, o.x), t(e.y, r.y, o.y), t(e.z, r.z, o.z), t(e.w, r.w, o.w));
+    case "Matrix":
+      return T.FromArray(e.m.map((p, u) => t(p, r.m[u], o.m[u])));
+    case "Matrix2D":
+      return new f(e.m.map((p, u) => t(p, r.m[u], o.m[u])));
+    case "Matrix3D":
+      return new M(e.m.map((p, u) => t(p, r.m[u], o.m[u])));
+    default:
+      return t(m(e), m(r), m(o));
+  }
+}
+class lr extends D {
+  constructor(r) {
+    super(l, l, l, l, (o, t, n) => this._polymorphicClamp(o, t, n), "FlowGraphClampBlock", r);
+  }
+  _polymorphicClamp(r, o, t) {
+    return E(r, o, t, tr);
+  }
+}
+s("FlowGraphClampBlock", lr);
+function sr(e) {
+  return Math.min(Math.max(e, 0), 1);
+}
+class nr extends c {
+  constructor(r) {
+    super(l, l, (o) => this._polymorphicSaturate(o), "FlowGraphSaturateBlock", r);
+  }
+  _polymorphicSaturate(r) {
+    return h(r, sr);
+  }
+}
+s("FlowGraphSaturateBlock", nr);
+function ar(e, r, o) {
+  return (1 - o) * e + o * r;
+}
+class cr extends D {
+  constructor(r) {
+    super(l, l, l, l, (o, t, n) => this._polymorphicInterpolate(o, t, n), "FlowGraphMathInterpolationBlock", r);
+  }
+  _polymorphicInterpolate(r, o, t) {
+    return E(r, o, t, ar);
+  }
+}
+s("FlowGraphMathInterpolationBlock", cr);
+class pr extends w {
+  constructor(r) {
+    super(l, l, B, (o, t) => this._polymorphicEq(o, t), "FlowGraphEqualityBlock", r);
+  }
+  _polymorphicEq(r, o) {
+    const t = F(r), n = F(o);
+    return typeof r != typeof o ? !1 : d(t, n) || x(t, n) || _(t, n) ? r.equals(o) : r === o;
+  }
+}
+s("FlowGraphEqualityBlock", pr);
+function A(e, r, o) {
+  if (I(e) && I(r))
+    return o(m(e), m(r));
+  throw new Error(`Cannot compare ${e} and ${r}`);
+}
+class hr extends w {
+  constructor(r) {
+    super(l, l, B, (o, t) => this._polymorphicLessThan(o, t), "FlowGraphLessThanBlock", r);
+  }
+  _polymorphicLessThan(r, o) {
+    return A(r, o, (t, n) => t < n);
+  }
+}
+s("FlowGraphLessThanBlock", hr);
+class ir extends w {
+  constructor(r) {
+    super(l, l, B, (o, t) => this._polymorphicLessThanOrEqual(o, t), "FlowGraphLessThanOrEqualBlock", r);
+  }
+  _polymorphicLessThanOrEqual(r, o) {
+    return A(r, o, (t, n) => t <= n);
+  }
+}
+s("FlowGraphLessThanOrEqualBlock", ir);
+class ur extends w {
+  constructor(r) {
+    super(l, l, B, (o, t) => this._polymorphicGreaterThan(o, t), "FlowGraphGreaterThanBlock", r);
+  }
+  _polymorphicGreaterThan(r, o) {
+    return A(r, o, (t, n) => t > n);
+  }
+}
+s("FlowGraphGreaterThanBlock", ur);
+class wr extends w {
+  constructor(r) {
+    super(l, l, B, (o, t) => this._polymorphicGreaterThanOrEqual(o, t), "FlowGraphGreaterThanOrEqualBlock", r);
+  }
+  _polymorphicGreaterThanOrEqual(r, o) {
+    return A(r, o, (t, n) => t >= n);
+  }
+}
+s("FlowGraphGreaterThanOrEqualBlock", wr);
+class mr extends c {
+  constructor(r) {
+    super(l, B, (o) => this._polymorphicIsNan(o), "FlowGraphIsNaNBlock", r);
+  }
+  _polymorphicIsNan(r) {
+    if (I(r, !0))
+      return isNaN(m(r));
+    throw new Error(`Cannot get NaN of ${r}`);
+  }
+}
+s("FlowGraphIsNaNBlock", mr);
+class Fr extends c {
+  constructor(r) {
+    super(l, B, (o) => this._polymorphicIsInf(o), "FlowGraphIsInfBlock", r);
+  }
+  _polymorphicIsInf(r) {
+    if (I(r))
+      return !isFinite(m(r));
+    throw new Error(`Cannot get isInf of ${r}`);
+  }
+}
+s("FlowGraphIsInfBlock", Fr);
+class Gr extends c {
+  /**
+   * Constructs a new instance of the flow graph math block.
+   * @param config - Optional configuration for the flow graph block.
+   */
+  constructor(r) {
+    super(l, l, (o) => this._polymorphicDegToRad(o), "FlowGraphDegToRadBlock", r);
+  }
+  _degToRad(r) {
+    return r * Math.PI / 180;
+  }
+  _polymorphicDegToRad(r) {
+    return h(r, this._degToRad);
+  }
+}
+s("FlowGraphDegToRadBlock", Gr);
+class yr extends c {
+  constructor(r) {
+    super(l, l, (o) => this._polymorphicRadToDeg(o), "FlowGraphRadToDegBlock", r);
+  }
+  _radToDeg(r) {
+    return r * 180 / Math.PI;
+  }
+  _polymorphicRadToDeg(r) {
+    return h(r, this._radToDeg);
+  }
+}
+s("FlowGraphRadToDegBlock", yr);
+class Hr extends c {
+  constructor(r) {
+    super(a, a, (o) => this._polymorphicSin(o), "FlowGraphSinBlock", r);
+  }
+  _polymorphicSin(r) {
+    return h(r, Math.sin);
+  }
+}
+class Jr extends c {
+  constructor(r) {
+    super(a, a, (o) => this._polymorphicCos(o), "FlowGraphCosBlock", r);
+  }
+  _polymorphicCos(r) {
+    return h(r, Math.cos);
+  }
+}
+class Kr extends c {
+  constructor(r) {
+    super(a, a, (o) => this._polymorphicTan(o), "FlowGraphTanBlock", r);
+  }
+  _polymorphicTan(r) {
+    return h(r, Math.tan);
+  }
+}
+class Br extends c {
+  constructor(r) {
+    super(a, a, (o) => this._polymorphicAsin(o), "FlowGraphASinBlock", r);
+  }
+  _polymorphicAsin(r) {
+    return h(r, Math.asin);
+  }
+}
+s("FlowGraphASinBlock", Br);
+class kr extends c {
+  constructor(r) {
+    super(a, a, (o) => this._polymorphicAcos(o), "FlowGraphACosBlock", r);
+  }
+  _polymorphicAcos(r) {
+    return h(r, Math.acos);
+  }
+}
+s("FlowGraphACosBlock", kr);
+class dr extends c {
+  constructor(r) {
+    super(a, a, (o) => this._polymorphicAtan(o), "FlowGraphATanBlock", r);
+  }
+  _polymorphicAtan(r) {
+    return h(r, Math.atan);
+  }
+}
+s("FlowGraphATanBlock", dr);
+class xr extends w {
+  constructor(r) {
+    super(l, l, l, (o, t) => this._polymorphicAtan2(o, t), "FlowGraphATan2Block", r);
+  }
+  _polymorphicAtan2(r, o) {
+    return C(r, o, Math.atan2);
+  }
+}
+s("FlowGraphATan2Block", xr);
+class _r extends c {
+  constructor(r) {
+    super(l, l, (o) => this._polymorphicSinh(o), "FlowGraphSinhBlock", r);
+  }
+  _polymorphicSinh(r) {
+    return h(r, Math.sinh);
+  }
+}
+s("FlowGraphSinhBlock", _r);
+class fr extends c {
+  constructor(r) {
+    super(l, l, (o) => this._polymorphicCosh(o), "FlowGraphCoshBlock", r);
+  }
+  _polymorphicCosh(r) {
+    return h(r, Math.cosh);
+  }
+}
+s("FlowGraphCoshBlock", fr);
+class Mr extends c {
+  constructor(r) {
+    super(l, l, (o) => this._polymorphicTanh(o), "FlowGraphTanhBlock", r);
+  }
+  _polymorphicTanh(r) {
+    return h(r, Math.tanh);
+  }
+}
+s("FlowGraphTanhBlock", Mr);
+class Tr extends c {
+  constructor(r) {
+    super(l, a, (o) => this._polymorphicAsinh(o), "FlowGraphASinhBlock", r);
+  }
+  _polymorphicAsinh(r) {
+    return h(r, Math.asinh);
+  }
+}
+s("FlowGraphASinhBlock", Tr);
+class gr extends c {
+  constructor(r) {
+    super(l, a, (o) => this._polymorphicAcosh(o), "FlowGraphACoshBlock", r);
+  }
+  _polymorphicAcosh(r) {
+    return h(r, Math.acosh);
+  }
+}
+s("FlowGraphACoshBlock", gr);
+class Cr extends c {
+  constructor(r) {
+    super(l, a, (o) => this._polymorphicAtanh(o), "FlowGraphATanhBlock", r);
+  }
+  _polymorphicAtanh(r) {
+    return h(r, Math.atanh);
+  }
+}
+s("FlowGraphATanhBlock", Cr);
+class Ir extends c {
+  constructor(r) {
+    super(l, a, (o) => this._polymorphicExp(o), "FlowGraphExponentialBlock", r);
+  }
+  _polymorphicExp(r) {
+    return h(r, Math.exp);
+  }
+}
+s("FlowGraphExponentialBlock", Ir);
+class Ar extends c {
+  constructor(r) {
+    super(l, a, (o) => this._polymorphicLog(o), "FlowGraphLogBlock", r);
+  }
+  _polymorphicLog(r) {
+    return h(r, Math.log);
+  }
+}
+s("FlowGraphLogBlock", Ar);
+class Nr extends c {
+  constructor(r) {
+    super(l, a, (o) => this._polymorphicLog2(o), "FlowGraphLog2Block", r);
+  }
+  _polymorphicLog2(r) {
+    return h(r, Math.log2);
+  }
+}
+s("FlowGraphLog2Block", Nr);
+class Sr extends c {
+  constructor(r) {
+    super(l, a, (o) => this._polymorphicLog10(o), "FlowGraphLog10Block", r);
+  }
+  _polymorphicLog10(r) {
+    return h(r, Math.log10);
+  }
+}
+s("FlowGraphLog10Block", Sr);
+class vr extends c {
+  constructor(r) {
+    super(l, a, (o) => this._polymorphicSqrt(o), "FlowGraphSquareRootBlock", r);
+  }
+  _polymorphicSqrt(r) {
+    return h(r, Math.sqrt);
+  }
+}
+s("FlowGraphSquareRootBlock", vr);
+class Rr extends c {
+  constructor(r) {
+    super(l, a, (o) => this._polymorphicCubeRoot(o), "FlowGraphCubeRootBlock", r);
+  }
+  _polymorphicCubeRoot(r) {
+    return h(r, Math.cbrt);
+  }
+}
+s("FlowGraphCubeRootBlock", Rr);
+class Dr extends w {
+  constructor(r) {
+    super(l, a, a, (o, t) => this._polymorphicPow(o, t), "FlowGraphPowerBlock", r);
+  }
+  _polymorphicPow(r, o) {
+    return C(r, o, Math.pow);
+  }
+}
+s("FlowGraphPowerBlock", Dr);
+class Er extends c {
+  constructor(r) {
+    super(i(
+      r?.valueType || "FlowGraphInteger"
+      /* FlowGraphTypes.Integer */
+    ), i(
+      r?.valueType || "FlowGraphInteger"
+      /* FlowGraphTypes.Integer */
+    ), (o) => typeof o == "boolean" ? !o : typeof o == "number" ? ~o : new y(~o.value), "FlowGraphBitwiseNotBlock", r);
+  }
+}
+s("FlowGraphBitwiseNotBlock", Er);
+class Or extends w {
+  constructor(r) {
+    super(i(
+      r?.valueType || "FlowGraphInteger"
+      /* FlowGraphTypes.Integer */
+    ), i(
+      r?.valueType || "FlowGraphInteger"
+      /* FlowGraphTypes.Integer */
+    ), i(
+      r?.valueType || "FlowGraphInteger"
+      /* FlowGraphTypes.Integer */
+    ), (o, t) => {
+      if (typeof o == "boolean" && typeof t == "boolean")
+        return o && t;
+      if (typeof o == "number" && typeof t == "number")
+        return o & t;
+      if (typeof o == "object" && typeof t == "object")
+        return new y(o.value & t.value);
+      throw new Error(`Cannot perform bitwise AND on ${o} and ${t}`);
+    }, "FlowGraphBitwiseAndBlock", r);
+  }
+}
+s("FlowGraphBitwiseAndBlock", Or);
+class Lr extends w {
+  constructor(r) {
+    super(i(
+      r?.valueType || "FlowGraphInteger"
+      /* FlowGraphTypes.Integer */
+    ), i(
+      r?.valueType || "FlowGraphInteger"
+      /* FlowGraphTypes.Integer */
+    ), i(
+      r?.valueType || "FlowGraphInteger"
+      /* FlowGraphTypes.Integer */
+    ), (o, t) => {
+      if (typeof o == "boolean" && typeof t == "boolean")
+        return o || t;
+      if (typeof o == "number" && typeof t == "number")
+        return o | t;
+      if (typeof o == "object" && typeof t == "object")
+        return new y(o.value | t.value);
+      throw new Error(`Cannot perform bitwise OR on ${o} and ${t}`);
+    }, "FlowGraphBitwiseOrBlock", r);
+  }
+}
+s("FlowGraphBitwiseOrBlock", Lr);
+class Vr extends w {
+  constructor(r) {
+    super(i(
+      r?.valueType || "FlowGraphInteger"
+      /* FlowGraphTypes.Integer */
+    ), i(
+      r?.valueType || "FlowGraphInteger"
+      /* FlowGraphTypes.Integer */
+    ), i(
+      r?.valueType || "FlowGraphInteger"
+      /* FlowGraphTypes.Integer */
+    ), (o, t) => {
+      if (typeof o == "boolean" && typeof t == "boolean")
+        return o !== t;
+      if (typeof o == "number" && typeof t == "number")
+        return o ^ t;
+      if (typeof o == "object" && typeof t == "object")
+        return new y(o.value ^ t.value);
+      throw new Error(`Cannot perform bitwise XOR on ${o} and ${t}`);
+    }, "FlowGraphBitwiseXorBlock", r);
+  }
+}
+s("FlowGraphBitwiseXorBlock", Vr);
+class zr extends w {
+  constructor(r) {
+    super(G, G, G, (o, t) => new y(o.value << t.value), "FlowGraphBitwiseLeftShiftBlock", r);
+  }
+}
+s("FlowGraphBitwiseLeftShiftBlock", zr);
+class qr extends w {
+  constructor(r) {
+    super(G, G, G, (o, t) => new y(o.value >> t.value), "FlowGraphBitwiseRightShiftBlock", r);
+  }
+}
+s("FlowGraphBitwiseRightShiftBlock", qr);
+class Pr extends c {
+  constructor(r) {
+    super(G, G, (o) => new y(Math.clz32(o.value)), "FlowGraphLeadingZerosBlock", r);
+  }
+}
+s("FlowGraphLeadingZerosBlock", Pr);
+class Qr extends c {
+  constructor(r) {
+    super(G, G, (o) => new y(o.value ? 31 - Math.clz32(o.value & -o.value) : 32), "FlowGraphTrailingZerosBlock", r);
+  }
+}
+s("FlowGraphTrailingZerosBlock", Qr);
+function $r(e) {
+  let r = 0;
+  for (; e; )
+    r += e & 1, e >>= 1;
+  return r;
+}
+class Zr extends c {
+  constructor(r) {
+    super(G, G, (o) => new y($r(o.value)), "FlowGraphOneBitsCounterBlock", r);
+  }
+}
+s("FlowGraphOneBitsCounterBlock", Zr);
+export {
+  W as FlowGraphAbsBlock,
+  kr as FlowGraphAcosBlock,
+  gr as FlowGraphAcoshBlock,
+  L as FlowGraphAddBlock,
+  Br as FlowGraphAsinBlock,
+  Tr as FlowGraphAsinhBlock,
+  xr as FlowGraphAtan2Block,
+  dr as FlowGraphAtanBlock,
+  Cr as FlowGraphAtanhBlock,
+  Or as FlowGraphBitwiseAndBlock,
+  zr as FlowGraphBitwiseLeftShiftBlock,
+  Er as FlowGraphBitwiseNotBlock,
+  Lr as FlowGraphBitwiseOrBlock,
+  qr as FlowGraphBitwiseRightShiftBlock,
+  Vr as FlowGraphBitwiseXorBlock,
+  J as FlowGraphCeilBlock,
+  lr as FlowGraphClampBlock,
+  Jr as FlowGraphCosBlock,
+  fr as FlowGraphCoshBlock,
+  Rr as FlowGraphCubeRootBlock,
+  Gr as FlowGraphDegToRadBlock,
+  q as FlowGraphDivideBlock,
+  Q as FlowGraphEBlock,
+  pr as FlowGraphEqualityBlock,
+  Ir as FlowGraphExpBlock,
+  H as FlowGraphFloorBlock,
+  Y as FlowGraphFractionBlock,
+  ur as FlowGraphGreaterThanBlock,
+  wr as FlowGraphGreaterThanOrEqualBlock,
+  Z as FlowGraphInfBlock,
+  Fr as FlowGraphIsInfinityBlock,
+  mr as FlowGraphIsNanBlock,
+  Pr as FlowGraphLeadingZerosBlock,
+  hr as FlowGraphLessThanBlock,
+  ir as FlowGraphLessThanOrEqualBlock,
+  Sr as FlowGraphLog10Block,
+  Nr as FlowGraphLog2Block,
+  Ar as FlowGraphLogBlock,
+  cr as FlowGraphMathInterpolationBlock,
+  er as FlowGraphMaxBlock,
+  or as FlowGraphMinBlock,
+  rr as FlowGraphModuloBlock,
+  z as FlowGraphMultiplyBlock,
+  j as FlowGraphNaNBlock,
+  b as FlowGraphNegationBlock,
+  Zr as FlowGraphOneBitsCounterBlock,
+  $ as FlowGraphPiBlock,
+  Dr as FlowGraphPowerBlock,
+  yr as FlowGraphRadToDegBlock,
+  P as FlowGraphRandomBlock,
+  K as FlowGraphRoundBlock,
+  nr as FlowGraphSaturateBlock,
+  X as FlowGraphSignBlock,
+  Hr as FlowGraphSinBlock,
+  _r as FlowGraphSinhBlock,
+  vr as FlowGraphSquareRootBlock,
+  V as FlowGraphSubtractBlock,
+  Kr as FlowGraphTanBlock,
+  Mr as FlowGraphTanhBlock,
+  Qr as FlowGraphTrailingZerosBlock,
+  U as FlowGraphTruncBlock
+};