@babylonjs/viewer/dist/chunks/flowGraphMathBlocks-DBYkqOgX.esm.min.js

The Babylon Viewer aims to simplify a specific but common Babylon.js use case: loading, viewing, and interacting with a 3D model.

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