@hanzogui/react-native-web-lite 2.0.0-rc.41-hanzoai.5

package/dist/cjs/vendor/react-native/Animated/animations/Animation.cjs

@@ -0,0 +1,72 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var Animation_exports = {};
+__export(Animation_exports, {
+  Animation: () => Animation,
+  default: () => Animation_default
+});
+module.exports = __toCommonJS(Animation_exports);
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+let startNativeAnimationNextId = 1;
+class Animation {
+  __active;
+  __isInteraction;
+  __nativeId;
+  __onEnd;
+  __iterations;
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {}
+  stop() {
+    if (this.__nativeId) {
+      import_NativeAnimatedHelper.NativeAnimatedHelper.API.stopAnimation(this.__nativeId);
+    }
+  }
+  __getNativeAnimationConfig() {
+    throw new Error("This animation type cannot be offloaded to native");
+  }
+  // Helper function for subclasses to make sure onEnd is only called once.
+  __debouncedOnEnd(result) {
+    const onEnd = this.__onEnd;
+    this.__onEnd = null;
+    onEnd && onEnd(result);
+  }
+  __startNativeAnimation(animatedValue) {
+    const startNativeAnimationWaitId = `${startNativeAnimationNextId}:startAnimation`;
+    startNativeAnimationNextId += 1;
+    import_NativeAnimatedHelper.NativeAnimatedHelper.API.setWaitingForIdentifier(startNativeAnimationWaitId);
+    try {
+      const config = this.__getNativeAnimationConfig();
+      animatedValue.__makeNative(config.platformConfig);
+      this.__nativeId = import_NativeAnimatedHelper.NativeAnimatedHelper.generateNewAnimationId();
+      import_NativeAnimatedHelper.NativeAnimatedHelper.API.startAnimatingNode(this.__nativeId, animatedValue.__getNativeTag(), config,
+      // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+      this.__debouncedOnEnd.bind(this));
+    } catch (e) {
+      throw e;
+    } finally {
+      import_NativeAnimatedHelper.NativeAnimatedHelper.API.unsetWaitingForIdentifier(startNativeAnimationWaitId);
+    }
+  }
+}
+var Animation_default = Animation;

package/dist/cjs/vendor/react-native/Animated/animations/DecayAnimation.cjs

@@ -0,0 +1,95 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var DecayAnimation_exports = {};
+__export(DecayAnimation_exports, {
+  DecayAnimation: () => DecayAnimation,
+  default: () => DecayAnimation_default
+});
+module.exports = __toCommonJS(DecayAnimation_exports);
+var import_Animation = require("./Animation.cjs");
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+class DecayAnimation extends import_Animation.Animation {
+  _startTime;
+  _lastValue;
+  _fromValue;
+  _deceleration;
+  _velocity;
+  _onUpdate;
+  _animationFrame;
+  _useNativeDriver;
+  constructor(config) {
+    super();
+    this._deceleration = config.deceleration ?? 0.998;
+    this._velocity = config.velocity;
+    this._useNativeDriver = (0, import_NativeAnimatedHelper.shouldUseNativeDriver)(config);
+    this.__isInteraction = config.isInteraction ?? !this._useNativeDriver;
+    this.__iterations = config.iterations ?? 1;
+  }
+  __getNativeAnimationConfig() {
+    return {
+      type: "decay",
+      deceleration: this._deceleration,
+      velocity: this._velocity,
+      iterations: this.__iterations
+    };
+  }
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+    this.__active = true;
+    this._lastValue = fromValue;
+    this._fromValue = fromValue;
+    this._onUpdate = onUpdate;
+    this.__onEnd = onEnd;
+    this._startTime = Date.now();
+    if (this._useNativeDriver) {
+      this.__startNativeAnimation(animatedValue);
+    } else {
+      this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+    }
+  }
+  onUpdate() {
+    const now = Date.now();
+    const value = this._fromValue + this._velocity / (1 - this._deceleration) * (1 - Math.exp(-(1 - this._deceleration) * (now - this._startTime)));
+    this._onUpdate(value);
+    if (Math.abs(this._lastValue - value) < 0.1) {
+      this.__debouncedOnEnd({
+        finished: true
+      });
+      return;
+    }
+    this._lastValue = value;
+    if (this.__active) {
+      this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+    }
+  }
+  stop() {
+    super.stop();
+    this.__active = false;
+    global.cancelAnimationFrame(this._animationFrame);
+    this.__debouncedOnEnd({
+      finished: false
+    });
+  }
+}
+var DecayAnimation_default = DecayAnimation;

package/dist/cjs/vendor/react-native/Animated/animations/SpringAnimation.cjs

@@ -0,0 +1,233 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var SpringAnimation_exports = {};
+__export(SpringAnimation_exports, {
+  SpringAnimation: () => SpringAnimation,
+  default: () => SpringAnimation_default
+});
+module.exports = __toCommonJS(SpringAnimation_exports);
+var import_Animation = require("./Animation.cjs");
+var import_SpringConfig = require("../SpringConfig.cjs");
+var import_react_native_web_internals = require("@hanzogui/react-native-web-internals");
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+class SpringAnimation extends import_Animation.Animation {
+  _overshootClamping;
+  _restDisplacementThreshold;
+  _restSpeedThreshold;
+  _lastVelocity;
+  _startPosition;
+  _lastPosition;
+  _fromValue;
+  _toValue;
+  _stiffness;
+  _damping;
+  _mass;
+  _initialVelocity;
+  _delay;
+  _timeout;
+  _startTime;
+  _lastTime;
+  _frameTime;
+  _onUpdate;
+  _animationFrame;
+  _useNativeDriver;
+  _platformConfig;
+  constructor(config) {
+    super();
+    this._overshootClamping = config.overshootClamping ?? false;
+    this._restDisplacementThreshold = config.restDisplacementThreshold ?? 1e-3;
+    this._restSpeedThreshold = config.restSpeedThreshold ?? 1e-3;
+    this._initialVelocity = config.velocity ?? 0;
+    this._lastVelocity = config.velocity ?? 0;
+    this._toValue = config.toValue;
+    this._delay = config.delay ?? 0;
+    this._useNativeDriver = (0, import_NativeAnimatedHelper.shouldUseNativeDriver)(config);
+    this._platformConfig = config.platformConfig;
+    this.__isInteraction = config.isInteraction ?? !this._useNativeDriver;
+    this.__iterations = config.iterations ?? 1;
+    if (config.stiffness !== void 0 || config.damping !== void 0 || config.mass !== void 0) {
+      (0, import_react_native_web_internals.invariant)(config.bounciness === void 0 && config.speed === void 0 && config.tension === void 0 && config.friction === void 0, "You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one");
+      this._stiffness = config.stiffness ?? 100;
+      this._damping = config.damping ?? 10;
+      this._mass = config.mass ?? 1;
+    } else if (config.bounciness !== void 0 || config.speed !== void 0) {
+      (0, import_react_native_web_internals.invariant)(config.tension === void 0 && config.friction === void 0 && config.stiffness === void 0 && config.damping === void 0 && config.mass === void 0, "You can define one of bounciness/speed, tension/friction, or stiffness/damping/mass, but not more than one");
+      const springConfig = import_SpringConfig.SpringConfig.fromBouncinessAndSpeed(config.bounciness ?? 8, config.speed ?? 12);
+      this._stiffness = springConfig.stiffness;
+      this._damping = springConfig.damping;
+      this._mass = 1;
+    } else {
+      const springConfig = import_SpringConfig.SpringConfig.fromOrigamiTensionAndFriction(config.tension ?? 40, config.friction ?? 7);
+      this._stiffness = springConfig.stiffness;
+      this._damping = springConfig.damping;
+      this._mass = 1;
+    }
+    (0, import_react_native_web_internals.invariant)(this._stiffness > 0, "Stiffness value must be greater than 0");
+    (0, import_react_native_web_internals.invariant)(this._damping > 0, "Damping value must be greater than 0");
+    (0, import_react_native_web_internals.invariant)(this._mass > 0, "Mass value must be greater than 0");
+  }
+  __getNativeAnimationConfig() {
+    return {
+      type: "spring",
+      overshootClamping: this._overshootClamping,
+      restDisplacementThreshold: this._restDisplacementThreshold,
+      restSpeedThreshold: this._restSpeedThreshold,
+      stiffness: this._stiffness,
+      damping: this._damping,
+      mass: this._mass,
+      initialVelocity: this._initialVelocity ?? this._lastVelocity,
+      toValue: this._toValue,
+      iterations: this.__iterations,
+      platformConfig: this._platformConfig
+    };
+  }
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+    this.__active = true;
+    this._startPosition = fromValue;
+    this._lastPosition = this._startPosition;
+    this._onUpdate = onUpdate;
+    this.__onEnd = onEnd;
+    this._lastTime = Date.now();
+    this._frameTime = 0;
+    if (previousAnimation instanceof SpringAnimation) {
+      const internalState = previousAnimation.getInternalState();
+      this._lastPosition = internalState.lastPosition;
+      this._lastVelocity = internalState.lastVelocity;
+      this._initialVelocity = this._lastVelocity;
+      this._lastTime = internalState.lastTime;
+    }
+    const start = () => {
+      if (this._useNativeDriver) {
+        this.__startNativeAnimation(animatedValue);
+      } else {
+        this.onUpdate();
+      }
+    };
+    if (this._delay) {
+      this._timeout = setTimeout(start, this._delay);
+    } else {
+      start();
+    }
+  }
+  getInternalState() {
+    return {
+      lastPosition: this._lastPosition,
+      lastVelocity: this._lastVelocity,
+      lastTime: this._lastTime
+    };
+  }
+  /**
+   * This spring model is based off of a damped harmonic oscillator
+   * (https://en.wikipedia.org/wiki/Harmonic_oscillator#Damped_harmonic_oscillator).
+   *
+   * We use the closed form of the second order differential equation:
+   *
+   * x'' + (2ζ⍵_0)x' + ⍵^2x = 0
+   *
+   * where
+   *    ⍵_0 = √(k / m) (undamped angular frequency of the oscillator),
+   *    ζ = c / 2√mk (damping ratio),
+   *    c = damping constant
+   *    k = stiffness
+   *    m = mass
+   *
+   * The derivation of the closed form is described in detail here:
+   * http://planetmath.org/sites/default/files/texpdf/39745.pdf
+   *
+   * This algorithm happens to match the algorithm used by CASpringAnimation,
+   * a QuartzCore (iOS) API that creates spring animations.
+   */
+  onUpdate() {
+    const MAX_STEPS = 64;
+    let now = Date.now();
+    if (now > this._lastTime + MAX_STEPS) {
+      now = this._lastTime + MAX_STEPS;
+    }
+    const deltaTime = (now - this._lastTime) / 1e3;
+    this._frameTime += deltaTime;
+    const c = this._damping;
+    const m = this._mass;
+    const k = this._stiffness;
+    const v0 = -this._initialVelocity;
+    const zeta = c / (2 * Math.sqrt(k * m));
+    const omega0 = Math.sqrt(k / m);
+    const omega1 = omega0 * Math.sqrt(1 - zeta * zeta);
+    const x0 = this._toValue - this._startPosition;
+    let position = 0;
+    let velocity = 0;
+    const t = this._frameTime;
+    if (zeta < 1) {
+      const envelope = Math.exp(-zeta * omega0 * t);
+      position = this._toValue - envelope * ((v0 + zeta * omega0 * x0) / omega1 * Math.sin(omega1 * t) + x0 * Math.cos(omega1 * t));
+      velocity = zeta * omega0 * envelope * (Math.sin(omega1 * t) * (v0 + zeta * omega0 * x0) / omega1 + x0 * Math.cos(omega1 * t)) - envelope * (Math.cos(omega1 * t) * (v0 + zeta * omega0 * x0) - omega1 * x0 * Math.sin(omega1 * t));
+    } else {
+      const envelope = Math.exp(-omega0 * t);
+      position = this._toValue - envelope * (x0 + (v0 + omega0 * x0) * t);
+      velocity = envelope * (v0 * (t * omega0 - 1) + t * x0 * (omega0 * omega0));
+    }
+    this._lastTime = now;
+    this._lastPosition = position;
+    this._lastVelocity = velocity;
+    this._onUpdate(position);
+    if (!this.__active) {
+      return;
+    }
+    let isOvershooting = false;
+    if (this._overshootClamping && this._stiffness !== 0) {
+      if (this._startPosition < this._toValue) {
+        isOvershooting = position > this._toValue;
+      } else {
+        isOvershooting = position < this._toValue;
+      }
+    }
+    const isVelocity = Math.abs(velocity) <= this._restSpeedThreshold;
+    let isDisplacement = true;
+    if (this._stiffness !== 0) {
+      isDisplacement = Math.abs(this._toValue - position) <= this._restDisplacementThreshold;
+    }
+    if (isOvershooting || isVelocity && isDisplacement) {
+      if (this._stiffness !== 0) {
+        this._lastPosition = this._toValue;
+        this._lastVelocity = 0;
+        this._onUpdate(this._toValue);
+      }
+      this.__debouncedOnEnd({
+        finished: true
+      });
+      return;
+    }
+    this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+  }
+  stop() {
+    super.stop();
+    this.__active = false;
+    clearTimeout(this._timeout);
+    global.cancelAnimationFrame(this._animationFrame);
+    this.__debouncedOnEnd({
+      finished: false
+    });
+  }
+}
+var SpringAnimation_default = SpringAnimation;

package/dist/cjs/vendor/react-native/Animated/animations/TimingAnimation.cjs

@@ -0,0 +1,134 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var TimingAnimation_exports = {};
+__export(TimingAnimation_exports, {
+  TimingAnimation: () => TimingAnimation,
+  default: () => TimingAnimation_default
+});
+module.exports = __toCommonJS(TimingAnimation_exports);
+var import_Easing = require("../Easing.cjs");
+var import_Animation = require("./Animation.cjs");
+var import_NativeAnimatedHelper = require("../NativeAnimatedHelper.cjs");
+let _easeInOut;
+function easeInOut() {
+  if (!_easeInOut) {
+    _easeInOut = import_Easing.Easing.inOut(import_Easing.Easing.ease);
+  }
+  return _easeInOut;
+}
+class TimingAnimation extends import_Animation.Animation {
+  _startTime;
+  _fromValue;
+  _toValue;
+  _duration;
+  _delay;
+  _easing;
+  _onUpdate;
+  _animationFrame;
+  _timeout;
+  _useNativeDriver;
+  _platformConfig;
+  constructor(config) {
+    super();
+    this._toValue = config.toValue;
+    this._easing = config.easing ?? easeInOut();
+    this._duration = config.duration ?? 500;
+    this._delay = config.delay ?? 0;
+    this.__iterations = config.iterations ?? 1;
+    this._useNativeDriver = (0, import_NativeAnimatedHelper.shouldUseNativeDriver)(config);
+    this._platformConfig = config.platformConfig;
+    this.__isInteraction = config.isInteraction ?? !this._useNativeDriver;
+  }
+  __getNativeAnimationConfig() {
+    const frameDuration = 1e3 / 60;
+    const frames = [];
+    const numFrames = Math.round(this._duration / frameDuration);
+    for (let frame = 0; frame < numFrames; frame++) {
+      frames.push(this._easing(frame / numFrames));
+    }
+    frames.push(this._easing(1));
+    return {
+      type: "frames",
+      frames,
+      toValue: this._toValue,
+      iterations: this.__iterations,
+      platformConfig: this._platformConfig
+    };
+  }
+  start(fromValue, onUpdate, onEnd, previousAnimation, animatedValue) {
+    this.__active = true;
+    this._fromValue = fromValue;
+    this._onUpdate = onUpdate;
+    this.__onEnd = onEnd;
+    const start = () => {
+      if (this._duration === 0 && !this._useNativeDriver) {
+        this._onUpdate(this._toValue);
+        this.__debouncedOnEnd({
+          finished: true
+        });
+      } else {
+        this._startTime = Date.now();
+        if (this._useNativeDriver) {
+          this.__startNativeAnimation(animatedValue);
+        } else {
+          this._animationFrame = requestAnimationFrame(
+          // $FlowFixMe[method-unbinding] added when improving typing for this parameters
+          this.onUpdate.bind(this));
+        }
+      }
+    };
+    if (this._delay) {
+      this._timeout = setTimeout(start, this._delay);
+    } else {
+      start();
+    }
+  }
+  onUpdate() {
+    const now = Date.now();
+    if (now >= this._startTime + this._duration) {
+      if (this._duration === 0) {
+        this._onUpdate(this._toValue);
+      } else {
+        this._onUpdate(this._fromValue + this._easing(1) * (this._toValue - this._fromValue));
+      }
+      this.__debouncedOnEnd({
+        finished: true
+      });
+      return;
+    }
+    this._onUpdate(this._fromValue + this._easing((now - this._startTime) / this._duration) * (this._toValue - this._fromValue));
+    if (this.__active) {
+      this._animationFrame = requestAnimationFrame(this.onUpdate.bind(this));
+    }
+  }
+  stop() {
+    super.stop();
+    this.__active = false;
+    clearTimeout(this._timeout);
+    global.cancelAnimationFrame(this._animationFrame);
+    this.__debouncedOnEnd({
+      finished: false
+    });
+  }
+}
+var TimingAnimation_default = TimingAnimation;

package/dist/cjs/vendor/react-native/Animated/bezier.cjs

@@ -0,0 +1,124 @@
+"use strict";
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all) __defProp(target, name, {
+    get: all[name],
+    enumerable: true
+  });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from)) if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    });
+  }
+  return to;
+};
+var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
+  value: true
+}), mod);
+var bezier_exports = {};
+__export(bezier_exports, {
+  bezier: () => bezier,
+  default: () => bezier_default
+});
+module.exports = __toCommonJS(bezier_exports);
+const NEWTON_ITERATIONS = 4;
+const NEWTON_MIN_SLOPE = 1e-3;
+const SUBDIVISION_PRECISION = 1e-7;
+const SUBDIVISION_MAX_ITERATIONS = 10;
+const kSplineTableSize = 11;
+const kSampleStepSize = 1 / (kSplineTableSize - 1);
+const float32ArraySupported = typeof Float32Array === "function";
+function A(aA1, aA2) {
+  return 1 - 3 * aA2 + 3 * aA1;
+}
+function B(aA1, aA2) {
+  return 3 * aA2 - 6 * aA1;
+}
+function C(aA1) {
+  return 3 * aA1;
+}
+function calcBezier(aT, aA1, aA2) {
+  return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT;
+}
+function getSlope(aT, aA1, aA2) {
+  return 3 * A(aA1, aA2) * aT * aT + 2 * B(aA1, aA2) * aT + C(aA1);
+}
+function binarySubdivide(aX, _aA, _aB, mX1, mX2) {
+  let currentX,
+    currentT,
+    i = 0,
+    aA = _aA,
+    aB = _aB;
+  do {
+    currentT = aA + (aB - aA) / 2;
+    currentX = calcBezier(currentT, mX1, mX2) - aX;
+    if (currentX > 0) {
+      aB = currentT;
+    } else {
+      aA = currentT;
+    }
+  } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
+  return currentT;
+}
+function newtonRaphsonIterate(aX, _aGuessT, mX1, mX2) {
+  let aGuessT = _aGuessT;
+  for (let i = 0; i < NEWTON_ITERATIONS; ++i) {
+    const currentSlope = getSlope(aGuessT, mX1, mX2);
+    if (currentSlope === 0) {
+      return aGuessT;
+    }
+    const currentX = calcBezier(aGuessT, mX1, mX2) - aX;
+    aGuessT -= currentX / currentSlope;
+  }
+  return aGuessT;
+}
+function bezier(mX1, mY1, mX2, mY2) {
+  if (!(mX1 >= 0 && mX1 <= 1 && mX2 >= 0 && mX2 <= 1)) {
+    throw new Error("bezier x values must be in [0, 1] range");
+  }
+  const sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);
+  if (mX1 !== mY1 || mX2 !== mY2) {
+    for (let i = 0; i < kSplineTableSize; ++i) {
+      sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);
+    }
+  }
+  function getTForX(aX) {
+    let intervalStart = 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) {
+      return guessForT;
+    } else {
+      return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);
+    }
+  }
+  return function BezierEasing(x) {
+    if (mX1 === mY1 && mX2 === mY2) {
+      return x;
+    }
+    if (x === 0) {
+      return 0;
+    }
+    if (x === 1) {
+      return 1;
+    }
+    return calcBezier(getTForX(x), mY1, mY2);
+  };
+}
+var bezier_default = bezier;