// Module ID: 1635
// Function ID: 18296
// Name: calcBezier
// Dependencies: []

// Module 1635 (calcBezier)
let closure_2 = { code: "function A_Pnpm_BezierTs1(aA1,aA2){return 1.0-3.0*aA2+3.0*aA1;}" };
let closure_3 = () => {
  class A {
    constructor(arg0, arg1) {
      return 1 - 3 * arg1 + 3 * arg0;
    }
  }
  A.__closure = {};
  A.__workletHash = 6646411187233;
  A.__initData = closure_2;
  return A;
}();
let closure_4 = { code: "function B_Pnpm_BezierTs2(aA1,aA2){return 3.0*aA2-6.0*aA1;}" };
let closure_5 = () => {
  class B {
    constructor(arg0, arg1) {
      return 3 * arg1 - 6 * arg0;
    }
  }
  B.__closure = {};
  B.__workletHash = 4657056619296;
  B.__initData = closure_4;
  return B;
}();
let closure_6 = { code: "function C_Pnpm_BezierTs3(aA1){return 3.0*aA1;}" };
let closure_7 = () => {
  class C {
    constructor(arg0) {
      return 3 * arg0;
    }
  }
  C.__closure = {};
  C.__workletHash = 10558087844899;
  C.__initData = closure_6;
  return C;
}();
let closure_8 = { code: "function calcBezier_Pnpm_BezierTs4(aT,aA1,aA2){const{A,B,C}=this.__closure;return((A(aA1,aA2)*aT+B(aA1,aA2))*aT+C(aA1))*aT;}" };
let closure_9 = () => {
  function calcBezier(arg0, arg1, arg2) {
    const result = callback(arg1, arg2) * arg0;
    const result1 = (result + callback2(arg1, arg2)) * arg0;
    return (result1 + callback3(arg1)) * arg0;
  }
  calcBezier.__closure = { A: closure_3, B: closure_5, C: closure_7 };
  calcBezier.__workletHash = 6436686649451;
  calcBezier.__initData = closure_8;
  return calcBezier;
}();
let closure_10 = { code: "function getSlope_Pnpm_BezierTs5(aT,aA1,aA2){const{A,B,C}=this.__closure;return 3.0*A(aA1,aA2)*aT*aT+2.0*B(aA1,aA2)*aT+C(aA1);}" };
let closure_11 = () => {
  function getSlope(arg0, arg1, arg2) {
    const result = 3 * callback(arg1, arg2) * arg0 * arg0;
    const result1 = 2 * callback2(arg1, arg2) * arg0;
    return result + result1 + callback3(arg1);
  }
  getSlope.__closure = { A: closure_3, B: closure_5, C: closure_7 };
  getSlope.__workletHash = 7144143660854;
  getSlope.__initData = closure_10;
  return getSlope;
}();
let closure_12 = { code: "function binarySubdivide_Pnpm_BezierTs6(aX,aA,aB,mX1,mX2){const{calcBezier,SUBDIVISION_PRECISION,SUBDIVISION_MAX_ITERATIONS}=this.__closure;let currentX;let currentT;let i=0;do{currentT=aA+(aB-aA)/2.0;currentX=calcBezier(currentT,mX1,mX2)-aX;if(currentX>0.0){aB=currentT;}else{aA=currentT;}}while(Math.abs(currentX)>SUBDIVISION_PRECISION&&++i<SUBDIVISION_MAX_ITERATIONS);return currentT;}" };
let closure_13 = () => {
  function binarySubdivide(arg0, arg1, arg2, arg3, arg4) {
    let sum;
    let tmp = arg1;
    let tmp2 = arg2;
    let num = 0;
    while (true) {
      let tmp3 = callback;
      sum = tmp + (tmp2 - tmp) / 2;
      let diff = callback(sum, arg3, arg4) - arg0;
      let tmp6 = sum;
      if (diff > 0) {
        tmp6 = tmp;
        tmp2 = sum;
      }
      let _Math = Math;
      if (Math.abs(diff) <= 0.0000001) {
        break;
      } else {
        num = num + 1;
        tmp = tmp6;
        if (num >= 10) {
          break;
        }
      }
    }
    return sum;
  }
  binarySubdivide.__closure = { calcBezier: closure_9 };
  binarySubdivide.__workletHash = 16502327865282;
  binarySubdivide.__initData = closure_12;
  return binarySubdivide;
}();
let closure_14 = { code: "function newtonRaphsonIterate_Pnpm_BezierTs7(aX,aGuessT,mX1,mX2){const{NEWTON_ITERATIONS,getSlope,calcBezier}=this.__closure;for(let i=0;i<NEWTON_ITERATIONS;++i){const currentSlope=getSlope(aGuessT,mX1,mX2);if(currentSlope===0.0){return aGuessT;}const currentX=calcBezier(aGuessT,mX1,mX2)-aX;aGuessT-=currentX/currentSlope;}return aGuessT;}" };
let closure_15 = () => {
  function newtonRaphsonIterate(arg0, arg1, arg2, arg3) {
    let tmp = arg1;
    let num = 0;
    const tmp2 = callback2(tmp, arg2, arg3);
    while (0 !== tmp2) {
      let tmp3 = callback;
      let diff = tmp - (callback(tmp, arg2, arg3) - arg0) / tmp2;
      num = num + 1;
      tmp = diff;
      if (num < 4) {
        continue;
      } else {
        return diff;
      }
    }
    return tmp;
  }
  newtonRaphsonIterate.__closure = { NEWTON_ITERATIONS: 4, getSlope: closure_11, calcBezier: closure_9 };
  newtonRaphsonIterate.__workletHash = 13998382484908;
  newtonRaphsonIterate.__initData = closure_14;
  return newtonRaphsonIterate;
}();
let closure_16 = { code: "function Bezier_Pnpm_BezierTs8(mX1,mY1,mX2,mY2){const{kSplineTableSize,calcBezier,kSampleStepSize,getSlope,NEWTON_MIN_SLOPE,newtonRaphsonIterate,binarySubdivide}=this.__closure;function LinearEasing(x){'worklet';return x;}if(!(mX1>=0&&mX1<=1&&mX2>=0&&mX2<=1)){throw new ReanimatedError('Bezier x values must be in [0, 1] range.');}if(mX1===mY1&&mX2===mY2){return LinearEasing;}const sampleValues=new Array(kSplineTableSize);for(let i=0;i<kSplineTableSize;++i){sampleValues[i]=calcBezier(i*kSampleStepSize,mX1,mX2);}function getTForX(aX){'worklet';let intervalStart=0.0;let currentSample=1;const lastSample=kSplineTableSize-1;for(;currentSample!==lastSample&&sampleValues[currentSample]<=aX;++currentSample){intervalStart+=kSampleStepSize;}--currentSample;const dist=(aX-sampleValues[currentSample])/(sampleValues[currentSample+1]-sampleValues[currentSample]);const guessForT=intervalStart+dist*kSampleStepSize;const initialSlope=getSlope(guessForT,mX1,mX2);if(initialSlope>=NEWTON_MIN_SLOPE){return newtonRaphsonIterate(aX,guessForT,mX1,mX2);}else if(initialSlope===0.0){return guessForT;}else{return binarySubdivide(aX,intervalStart,intervalStart+kSampleStepSize,mX1,mX2);}}return function Bezier_Pnpm_BezierTs8(x){'worklet';if(mX1===mY1&&mX2===mY2){return x;}if(x===0){return 0;}if(x===1){return 1;}return calcBezier(getTForX(x),mY1,mY2);};}" };
let closure_17 = { code: "function LinearEasing_Pnpm_BezierTs9(x){return x;}" };
let closure_18 = { code: "function getTForX_Pnpm_BezierTs10(aX){const{kSplineTableSize,sampleValues,kSampleStepSize,getSlope,mX1,mX2,NEWTON_MIN_SLOPE,newtonRaphsonIterate,binarySubdivide}=this.__closure;let intervalStart=0.0;let currentSample=1;const lastSample=kSplineTableSize-1;for(;currentSample!==lastSample&&sampleValues[currentSample]<=aX;++currentSample){intervalStart+=kSampleStepSize;}--currentSample;const dist=(aX-sampleValues[currentSample])/(sampleValues[currentSample+1]-sampleValues[currentSample]);const guessForT=intervalStart+dist*kSampleStepSize;const initialSlope=getSlope(guessForT,mX1,mX2);if(initialSlope>=NEWTON_MIN_SLOPE){return newtonRaphsonIterate(aX,guessForT,mX1,mX2);}else if(initialSlope===0.0){return guessForT;}else{return binarySubdivide(aX,intervalStart,intervalStart+kSampleStepSize,mX1,mX2);}}" };
let closure_19 = { code: "function BezierEasing_Pnpm_BezierTs11(x){const{mX1,mY1,mX2,mY2,calcBezier,getTForX}=this.__closure;if(mX1===mY1&&mX2===mY2){return x;}if(x===0){return 0;}if(x===1){return 1;}return calcBezier(getTForX(x),mY1,mY2);}" };
arg5.Bezier = () => {
  class Bezier {
    constructor(arg0, arg1, arg2, arg3) {
      arg0 = arg0;
      arg1 = arg1;
      arg2 = arg2;
      arg3 = arg3;
      if (arg0 >= 0) {
        num = 1;
        if (arg0 <= 1) {
          if (arg2 >= 0) {
            if (arg2 <= 1) {
              if (arg0 === arg1) {
                if (arg2 === arg3) {
                  return tmp;
                }
              }
              tmp3 = globalThis;
              _Array = Array;
              prototype = Array.prototype;
              tmp4 = new.target;
              num2 = 11;
              tmp5 = new.target;
              num3 = 11;
              array = new Array(11);
              tmp7 = array;
              Array = array;
              num4 = 0.1;
              num5 = 0;
              do {
                tmp8 = closure_9;
                array[num5] = closure_9(num5 * 0.1, arg0, arg2);
                num5 = num5 + 1;
              } while (num5 < 11);
              tmp9 = () => {
                function getTForX(arg0) {
                  let num = 0;
                  let num2 = 1;
                  let num3 = 0;
                  let num4 = 1;
                  if (closure_4[1] <= arg0) {
                    const sum = num + 0.1;
                    const sum1 = num2 + 1;
                    num3 = sum;
                    num4 = sum1;
                    while (10 !== sum1) {
                      let tmp3 = closure_4;
                      num = sum;
                      num2 = sum1;
                      num3 = sum;
                      num4 = sum1;
                      if (closure_4[sum1] > arg0) {
                        break;
                      }
                    }
                  }
                  const diff = num4 - 1;
                  const sum2 = num3 + (arg0 - closure_4[diff]) / (closure_4[diff + 1] - closure_4[diff]) * 0.1;
                  const tmp6 = callback(sum2, closure_0, closure_2);
                  if (tmp6 >= 0.001) {
                    let tmp7 = callback3(arg0, sum2, closure_0, closure_2);
                  } else {
                    tmp7 = sum2;
                    if (0 !== tmp6) {
                      tmp7 = callback2(arg0, num3, num3 + 0.1, closure_0, closure_2);
                    }
                  }
                  return tmp7;
                }
                const obj = { 0: 241979899612687240000000000000000000000000000000000000000000000000000000000000000000, 0: 0.00000000000000000000000000000000000000000000000000000000000004667261426588806, 0: 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003670235409085834, sampleValues: array, getSlope: closure_11, mX1: arg0, mX2: arg2, NEWTON_MIN_SLOPE: 0.001, newtonRaphsonIterate: closure_15, binarySubdivide: closure_13 };
                getTForX.__closure = obj;
                getTForX.__workletHash = 8576728300710;
                getTForX.__initData = closure_18;
                return getTForX;
              }();
              closure_5 = tmp9;
              class BezierEasing {
                constructor(arg0) {
                  if (arg0 !== arg1) {
                    num = 0;
                    if (0 !== arg0) {
                      num2 = 1;
                      if (1 !== arg0) {
                        tmp4 = closure_9;
                        tmp5 = closure_5;
                        tmp6 = arg1;
                        tmp7 = arg3;
                        num2 = closure_9(closure_5(arg0), arg1, arg3);
                      }
                      num = num2;
                    }
                    tmp3 = num;
                  } else {
                    tmp = arg2;
                    tmp2 = arg3;
                    tmp3 = arg0;
                  }
                  return tmp3;
                }
              }
              obj = {};
              obj.mX1 = arg0;
              obj.mY1 = arg1;
              obj.mX2 = arg2;
              obj.mY2 = arg3;
              tmp10 = closure_9;
              obj.calcBezier = closure_9;
              obj.getTForX = tmp9;
              BezierEasing.__closure = obj;
              num6 = 4633198201234;
              BezierEasing.__workletHash = 4633198201234;
              tmp11 = closure_19;
              BezierEasing.__initData = closure_19;
              return BezierEasing;
            }
          }
        }
      }
      reanimatedError = new arg0(arg1[0]).ReanimatedError("Bezier x values must be in [0, 1] range.");
      throw reanimatedError;
    }
  }
  const obj = { -9223372036854775808: 241979899612687240000000000000000000000000000000000000000000000000000000000000000000, 0: 0.00000000000000000000000000000000000000000000000000000000000004667261426588806, 0: 0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000003670235409085834, 0: 0.3, 0: "500px", calcBezier: closure_9, getSlope: closure_11, newtonRaphsonIterate: closure_15, binarySubdivide: closure_13 };
  Bezier.__closure = obj;
  Bezier.__workletHash = 1707642440340;
  Bezier.__initData = closure_16;
  return Bezier;
}();