@pibit.ai/cure-design-system 0.6.41 → 0.6.43

package/dist/node_modules/react-is/cjs/react-is.production.min.js

@@ -0,0 +1,81 @@
+import { __exports as t } from "../../../_virtual/react-is.production.min.js";
+/** @license React v17.0.2
+ * react-is.production.min.js
+ *
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+var w;
+function k() {
+  if (w) return t;
+  w = 1;
+  var y = 60103, m = 60106, o = 60107, c = 60108, i = 60114, u = 60109, f = 60110, s = 60112, p = 60113, d = 60120, l = 60115, a = 60116, _ = 60121, b = 60122, v = 60117, C = 60129, g = 60131;
+  if (typeof Symbol == "function" && Symbol.for) {
+    var r = Symbol.for;
+    y = r("react.element"), m = r("react.portal"), o = r("react.fragment"), c = r("react.strict_mode"), i = r("react.profiler"), u = r("react.provider"), f = r("react.context"), s = r("react.forward_ref"), p = r("react.suspense"), d = r("react.suspense_list"), l = r("react.memo"), a = r("react.lazy"), _ = r("react.block"), b = r("react.server.block"), v = r("react.fundamental"), C = r("react.debug_trace_mode"), g = r("react.legacy_hidden");
+  }
+  function n(e) {
+    if (typeof e == "object" && e !== null) {
+      var $ = e.$$typeof;
+      switch ($) {
+        case y:
+          switch (e = e.type, e) {
+            case o:
+            case i:
+            case c:
+            case p:
+            case d:
+              return e;
+            default:
+              switch (e = e && e.$$typeof, e) {
+                case f:
+                case s:
+                case a:
+                case l:
+                case u:
+                  return e;
+                default:
+                  return $;
+              }
+          }
+        case m:
+          return $;
+      }
+    }
+  }
+  var S = u, h = y, M = s, P = o, F = a, R = l, q = m, z = i, E = c, I = p;
+  return t.ContextConsumer = f, t.ContextProvider = S, t.Element = h, t.ForwardRef = M, t.Fragment = P, t.Lazy = F, t.Memo = R, t.Portal = q, t.Profiler = z, t.StrictMode = E, t.Suspense = I, t.isAsyncMode = function() {
+    return !1;
+  }, t.isConcurrentMode = function() {
+    return !1;
+  }, t.isContextConsumer = function(e) {
+    return n(e) === f;
+  }, t.isContextProvider = function(e) {
+    return n(e) === u;
+  }, t.isElement = function(e) {
+    return typeof e == "object" && e !== null && e.$$typeof === y;
+  }, t.isForwardRef = function(e) {
+    return n(e) === s;
+  }, t.isFragment = function(e) {
+    return n(e) === o;
+  }, t.isLazy = function(e) {
+    return n(e) === a;
+  }, t.isMemo = function(e) {
+    return n(e) === l;
+  }, t.isPortal = function(e) {
+    return n(e) === m;
+  }, t.isProfiler = function(e) {
+    return n(e) === i;
+  }, t.isStrictMode = function(e) {
+    return n(e) === c;
+  }, t.isSuspense = function(e) {
+    return n(e) === p;
+  }, t.isValidElementType = function(e) {
+    return typeof e == "string" || typeof e == "function" || e === o || e === i || e === C || e === c || e === p || e === d || e === g || typeof e == "object" && e !== null && (e.$$typeof === a || e.$$typeof === l || e.$$typeof === u || e.$$typeof === f || e.$$typeof === s || e.$$typeof === v || e.$$typeof === _ || e[0] === b);
+  }, t.typeOf = n, t;
+}
+export {
+  k as __require
+};

package/dist/node_modules/react-is/index.js

@@ -0,0 +1,10 @@
+import { __module as e } from "../../_virtual/index4.js";
+import { __require as o } from "./cjs/react-is.production.min.js";
+import { __require as t } from "./cjs/react-is.development.js";
+var r;
+function p() {
+  return r ? e.exports : (r = 1, process.env.NODE_ENV === "production" ? e.exports = o() : e.exports = t(), e.exports);
+}
+export {
+  p as __require
+};

package/dist/node_modules/react-redux/dist/react-redux.js

@@ -0,0 +1,137 @@
+import * as c from "react";
+import "../../../_virtual/with-selector3.js";
+function E(t) {
+  t();
+}
+function w() {
+  let t = null, n = null;
+  return {
+    clear() {
+      t = null, n = null;
+    },
+    notify() {
+      E(() => {
+        let r = t;
+        for (; r; )
+          r.callback(), r = r.next;
+      });
+    },
+    get() {
+      const r = [];
+      let o = t;
+      for (; o; )
+        r.push(o), o = o.next;
+      return r;
+    },
+    subscribe(r) {
+      let o = !0;
+      const e = n = {
+        callback: r,
+        next: null,
+        prev: n
+      };
+      return e.prev ? e.prev.next = e : t = e, function() {
+        !o || t === null || (o = !1, e.next ? e.next.prev = e.prev : n = e.prev, e.prev ? e.prev.next = e.next : t = e.next);
+      };
+    }
+  };
+}
+const y = {
+  notify() {
+  },
+  get: () => []
+};
+function R(t, n) {
+  let r, o = y, e = 0, s = !1;
+  function u(C) {
+    l();
+    const N = o.subscribe(C);
+    let v = !1;
+    return () => {
+      v || (v = !0, N(), f());
+    };
+  }
+  function d() {
+    o.notify();
+  }
+  function i() {
+    p.onStateChange && p.onStateChange();
+  }
+  function a() {
+    return s;
+  }
+  function l() {
+    e++, r || (r = t.subscribe(i), o = w());
+  }
+  function f() {
+    e--, r && e === 0 && (r(), r = void 0, o.clear(), o = y);
+  }
+  function m() {
+    s || (s = !0, l());
+  }
+  function x() {
+    s && (s = !1, f());
+  }
+  const p = {
+    addNestedSub: u,
+    notifyNestedSubs: d,
+    handleChangeWrapper: i,
+    isSubscribed: a,
+    trySubscribe: m,
+    tryUnsubscribe: x,
+    getListeners: () => o
+  };
+  return p;
+}
+const O = () => typeof window < "u" && typeof window.document < "u" && typeof window.document.createElement < "u", k = /* @__PURE__ */ O(), L = () => typeof navigator < "u" && navigator.product === "ReactNative", M = /* @__PURE__ */ L(), U = () => k || M ? c.useLayoutEffect : c.useEffect, S = /* @__PURE__ */ U();
+function g(t, n) {
+  return t === n ? t !== 0 || n !== 0 || 1 / t === 1 / n : t !== t && n !== n;
+}
+function I(t, n) {
+  if (g(t, n)) return !0;
+  if (typeof t != "object" || t === null || typeof n != "object" || n === null) return !1;
+  const r = Object.keys(t), o = Object.keys(n);
+  if (r.length !== o.length) return !1;
+  for (let e = 0; e < r.length; e++) if (!Object.prototype.hasOwnProperty.call(n, r[e]) || !g(t[r[e]], n[r[e]])) return !1;
+  return !0;
+}
+const b = /* @__PURE__ */ Symbol.for("react-redux-context"), h = typeof globalThis < "u" ? globalThis : {};
+function D() {
+  if (!c.createContext) return {};
+  const t = h[b] ?? (h[b] = /* @__PURE__ */ new Map());
+  let n = t.get(c.createContext);
+  return n || (n = c.createContext(null), process.env.NODE_ENV !== "production" && (n.displayName = "ReactRedux"), t.set(c.createContext, n)), n;
+}
+const P = /* @__PURE__ */ D();
+function T(t) {
+  if (process.env.NODE_ENV !== "production" && typeof S != "function")
+    throw new Error('The React Redux `<Provider>` component requires React hooks that are not available in a React Server Component. This usually means you are rendering `<Provider>` in a Server Component. Add the `"use client"` directive to the top of the file that renders `<Provider>` (or a parent that ends up rendering it) so it is treated as a Client Component. See https://react.dev/reference/rsc/use-client for more information.');
+  const { children: n, context: r, serverState: o, store: e } = t, s = c.useMemo(() => {
+    const i = R(e), a = {
+      store: e,
+      subscription: i,
+      getServerState: o != null ? () => o : void 0
+    };
+    if (process.env.NODE_ENV === "production") return a;
+    {
+      const { identityFunctionCheck: l = "once", stabilityCheck: f = "once" } = t;
+      return /* @__PURE__ */ Object.assign(a, {
+        stabilityCheck: f,
+        identityFunctionCheck: l
+      });
+    }
+  }, [e, o]), u = c.useMemo(() => e.getState(), [e]);
+  S(() => {
+    const { subscription: i } = s;
+    return i.onStateChange = i.notifyNestedSubs, i.trySubscribe(), u !== e.getState() && i.notifyNestedSubs(), () => {
+      i.tryUnsubscribe(), i.onStateChange = void 0;
+    };
+  }, [s, u]);
+  const d = r || P;
+  return /* @__PURE__ */ c.createElement(d.Provider, { value: s }, n);
+}
+export {
+  T as Provider,
+  P as ReactReduxContext,
+  I as shallowEqual
+};

package/dist/node_modules/recharts/es6/animation/AnimatedItems.js

@@ -0,0 +1,78 @@
+import * as k from "react";
+import { useState as w, useCallback as h } from "react";
+import { JavascriptAnimate as U } from "./JavascriptAnimate.js";
+import { useAnimationId as j } from "../util/useAnimationId.js";
+import { matchAnimationItems as C, matchByIndex as D } from "./matchBy.js";
+import { useAnimationStartSnapshot as E } from "./useAnimationStartSnapshot.js";
+function M(t, n) {
+  return V(t) || O(t, n) || L(t, n) || F();
+}
+function F() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function L(t, n) {
+  if (t) {
+    if (typeof t == "string") return b(t, n);
+    var a = {}.toString.call(t).slice(8, -1);
+    return a === "Object" && t.constructor && (a = t.constructor.name), a === "Map" || a === "Set" ? Array.from(t) : a === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(a) ? b(t, n) : void 0;
+  }
+}
+function b(t, n) {
+  (n == null || n > t.length) && (n = t.length);
+  for (var a = 0, i = Array(n); a < n; a++) i[a] = t[a];
+  return i;
+}
+function O(t, n) {
+  var a = t == null ? null : typeof Symbol < "u" && t[Symbol.iterator] || t["@@iterator"];
+  if (a != null) {
+    var i, e, r, o, u = [], l = !0, c = !1;
+    try {
+      if (r = (a = a.call(t)).next, n !== 0) for (; !(l = (i = r.call(a)).done) && (u.push(i.value), u.length !== n); l = !0) ;
+    } catch (f) {
+      c = !0, e = f;
+    } finally {
+      try {
+        if (!l && a.return != null && (o = a.return(), Object(o) !== o)) return;
+      } finally {
+        if (c) throw e;
+      }
+    }
+    return u;
+  }
+}
+function V(t) {
+  if (Array.isArray(t)) return t;
+}
+function q(t, n) {
+  var a = w(!1), i = M(a, 2), e = i[0], r = i[1], o = h(() => {
+    typeof t == "function" && t(), r(!0);
+  }, [t]), u = h(() => {
+    typeof n == "function" && n(), r(!1);
+  }, [n]);
+  return {
+    isAnimating: e,
+    handleAnimationStart: o,
+    handleAnimationEnd: u
+  };
+}
+function z(t) {
+  var n, a = t.animationInput, i = t.animationIdPrefix, e = t.items, r = t.previousItemsRef, o = t.isAnimationActive, u = t.animationBegin, l = t.animationDuration, c = t.animationEasing, f = t.onAnimationStart, S = t.onAnimationEnd, g = t.animationInterpolateFn, s = t.animationMatchBy, d = t.shouldUpdatePreviousRef, _ = t.children, R = t.layout, v = j(a, i), A = E(v, r), I = (n = A.startValue) !== null && n !== void 0 ? n : null, x = C(I, e, s ?? D);
+  return /* @__PURE__ */ k.createElement(U, {
+    animationId: v,
+    begin: u,
+    duration: l,
+    isActive: o,
+    easing: c,
+    onAnimationEnd: S,
+    onAnimationStart: f,
+    key: v
+  }, (m) => {
+    var B = I == null, y = e == null ? e : g(x, m, R), P = d ? d(m) : m > 0;
+    return A.syncStepValue(y, m, P), y == null ? null : _(y, m, B);
+  });
+}
+export {
+  z as AnimatedItems,
+  q as useAnimationCallbacks
+};

package/dist/node_modules/recharts/es6/animation/AnimationControllerImpl.js

@@ -0,0 +1,21 @@
+var i = (v, e, g) => {
+  var t, c = (r) => {
+    var u = e.tick(r);
+    if (e.getState() === "active") {
+      if (g(e.getInterpolated()), e.getProgress() === 1) {
+        e.complete(), t = void 0;
+        return;
+      }
+      t = v.setTimeout(c, u);
+      return;
+    }
+    t = v.setTimeout(c, u);
+  };
+  return t = v.setTimeout(c, 0), () => {
+    var r;
+    return (r = t) === null || r === void 0 ? void 0 : r();
+  };
+};
+export {
+  i as animationControllerImpl
+};

package/dist/node_modules/recharts/es6/animation/AnimationHandle.js

@@ -0,0 +1,179 @@
+import { interpolate as h } from "../util/DataUtils.js";
+function m(i, t, e) {
+  return (t = u(t)) in i ? Object.defineProperty(i, t, { value: e, enumerable: !0, configurable: !0, writable: !0 }) : i[t] = e, i;
+}
+function u(i) {
+  var t = g(i, "string");
+  return typeof t == "symbol" ? t : t + "";
+}
+function g(i, t) {
+  if (typeof i != "object" || !i) return i;
+  var e = i[Symbol.toPrimitive];
+  if (e !== void 0) {
+    var n = e.call(i, t);
+    if (typeof n != "object") return n;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (t === "string" ? String : Number)(i);
+}
+var a = "init", o = "pending", s = "active", d = "completed";
+function r(i) {
+  return Math.max(0, i);
+}
+class l {
+  /**
+   * Returns the absolute time after the animationBegin delay has been completed,
+   * and when the animationDuration started ticking.
+   */
+  getAnimationStartedTime() {
+    return this.animationStartedTime;
+  }
+  /**
+   * Returns the absolute time of when the animation began - now it will wait for {animationBegin} ms before the transition starts
+   */
+  getBeginStartedTime() {
+    return this.beginStartedTime;
+  }
+  constructor(t) {
+    var e;
+    m(this, "state", a), this.animationId = t.animationId, this.onAnimationEnd = t.onAnimationEnd, this.animationDuration = r(t.animationDuration), this.animationBegin = r(t.animationBegin), this.progress = 0, this.from = t.from, this.to = t.to, this.easing = t.easing, (e = t.onAnimationStart) === null || e === void 0 || e.call(t);
+  }
+  /**
+   * Returns the state machine current state
+   * - `init`:       animation had just been created. It immediately calls `onAnimationStart`
+   * - `pending`:    animation is now paused for `animationBegin` milliseconds until the transition begins
+   * - `active`:     animation is transitioning items on screen
+   * - `completed`:  animation has completed its transition and executed `onAnimationEnd`.
+   *                 This state is final and the animation is no longer allowed to transition to other states.
+   */
+  getState() {
+    return this.state;
+  }
+  /**
+   * Returns the easing input or function
+   */
+  getEasing() {
+    return this.easing;
+  }
+  /**
+   * Returns the configuration - the duration of the transition.
+   * Does not change in time, does not change when state changes, this is a static value.
+   */
+  getAnimationDuration() {
+    return this.animationDuration;
+  }
+  /**
+   * Sets the current time of the animation. The animation sets its internal state and progress accordingly.
+   * This is current, absolute time; not additive!
+   * This allows you to essentially "travel back in time" based on the value you pass in here.
+   *
+   * Returns the (relative) time remaining until the current activity is over.
+   * Meaning: if the state is in a middle of a delay, returns the time left until the delay is finished.
+   * If the state is in the middle of a transition, returns time left until that transition is complete.
+   * This is useful because it's the same number you can take and put into setTimeout(fn, X)
+   * as that's how much time we need to wait until the next state transition happens.
+   */
+  tick(t) {
+    if (this.getState() === a)
+      return this.state = o, this.beginStartedTime = t, this.animationBegin;
+    if (this.getState() === o) {
+      if (this.beginStartedTime == null)
+        throw new Error();
+      var e = t - this.beginStartedTime;
+      return e >= this.animationBegin ? (this.state = s, this.animationStartedTime = t, this.nextAnimationUpdate(0)) : r(this.animationBegin - e);
+    }
+    if (this.getState() === s) {
+      if (this.animationStartedTime == null)
+        throw new Error();
+      var n = t - this.animationStartedTime;
+      return this.setProgress(n / this.animationDuration), this.nextAnimationUpdate(n);
+    }
+    return 0;
+  }
+  setProgress(t) {
+    this.progress = Math.min(1, Math.max(0, t));
+  }
+  /**
+   * Returns an abstract "progress" which is number between 0 and 1 which shows the distance of transition.
+   * This progress depends on the animation state:
+   * - `init`: 0
+   * - `pending`: 0
+   * - `active`: transitioning between [0, 1] based on the time elapsed
+   * - `completed`: 1
+   *
+   * The progress is hard-capped to be between 0 and 1 (inclusive) to avoid overshooting caused by coarse timers.
+   * For this reason, the easing function must be applied _after_ this animation state,
+   * so that one has a chance to construct dynamic "overshoot" animations.
+   *
+   * The progress is linear with time.
+   * If you wish for easing, use `getInterpolated()` instead.
+   */
+  getProgress() {
+    return this.progress;
+  }
+  /**
+   * Completes the animation. Completed animation:
+   * - cannot be manipulated anymore
+   * - its progress is set to 1
+   * - tick function doesn't do anything
+   * - getState() always returns 'completed'
+   */
+  complete() {
+    if (this.progress = 1, this.state === "active") {
+      var t;
+      (t = this.onAnimationEnd) === null || t === void 0 || t.call(this);
+    }
+    this.state = d;
+  }
+  /**
+   * Returns the starting value of the animation.
+   * Does not include progress, easing, interpolation, none of that - just the static starting value
+   */
+  getFrom() {
+    return this.from;
+  }
+  /**
+   * Returns the end value of the animation.
+   * Does not include progress, easing, interpolation, none of that - just the static end value
+   */
+  getTo() {
+    return this.to;
+  }
+  /**
+   * Unique identifier of an animation
+   */
+  getAnimationId() {
+    return this.animationId;
+  }
+  /**
+   * Returns the configuration - the duration of delay in between animation initialization, and transition.
+   * Does not change in time, does not change when state changes, this is a static value.
+   */
+  getAnimationBegin() {
+    return this.animationBegin;
+  }
+  /**
+   * Returns value of the transition at the current time.
+   * The exact details differ based on the animation type
+   */
+  /**
+   * Returns the duration of time of when the controller should ask for the next update
+   */
+}
+class v extends l {
+  // eslint-disable-next-line class-methods-use-this
+  nextAnimationUpdate() {
+    return 0;
+  }
+  /**
+   * Returns value of the animation after its easing function had been applied.
+   * This value, unlike getProgress(), can escape the [0..1] range
+   * because this is entirely within the easing function control. Spring typically does this.
+   */
+  getInterpolated() {
+    return this.easing(h(this.getFrom(), this.getTo(), this.getProgress()));
+  }
+}
+export {
+  v as JavascriptAnimation
+};

package/dist/node_modules/recharts/es6/animation/JavascriptAnimate.js

@@ -0,0 +1,84 @@
+import { useState as E, useEffect as y } from "react";
+import { noop as T } from "../util/DataUtils.js";
+import { resolveDefaultProps as w } from "../util/resolveDefaultProps.js";
+import { createEasingFunction as B } from "./easing.js";
+import { useAnimationController as P } from "./useAnimationController.js";
+import { Global as R } from "../util/Global.js";
+import { usePrefersReducedMotion as j } from "../util/usePrefersReducedMotion.js";
+import { JavascriptAnimation as F } from "./AnimationHandle.js";
+import { RequestAnimationFrameTimeoutController as J } from "./timeoutController.js";
+function M(t, r) {
+  return O(t) || L(t, r) || D(t, r) || x();
+}
+function x() {
+  throw new TypeError(`Invalid attempt to destructure non-iterable instance.
+In order to be iterable, non-array objects must have a [Symbol.iterator]() method.`);
+}
+function D(t, r) {
+  if (t) {
+    if (typeof t == "string") return g(t, r);
+    var n = {}.toString.call(t).slice(8, -1);
+    return n === "Object" && t.constructor && (n = t.constructor.name), n === "Map" || n === "Set" ? Array.from(t) : n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n) ? g(t, r) : void 0;
+  }
+}
+function g(t, r) {
+  (r == null || r > t.length) && (r = t.length);
+  for (var n = 0, e = Array(r); n < r; n++) e[n] = t[n];
+  return e;
+}
+function L(t, r) {
+  var n = t == null ? null : typeof Symbol < "u" && t[Symbol.iterator] || t["@@iterator"];
+  if (n != null) {
+    var e, l, u, i, o = [], a = !0, m = !1;
+    try {
+      if (u = (n = n.call(t)).next, r !== 0) for (; !(a = (e = u.call(n)).done) && (o.push(e.value), o.length !== r); a = !0) ;
+    } catch (c) {
+      m = !0, l = c;
+    } finally {
+      try {
+        if (!a && n.return != null && (i = n.return(), Object(i) !== i)) return;
+      } finally {
+        if (m) throw l;
+      }
+    }
+    return o;
+  }
+}
+function O(t) {
+  if (Array.isArray(t)) return t;
+}
+var k = {
+  begin: 0,
+  duration: 1e3,
+  easing: "ease",
+  isActive: !0,
+  canBegin: !0,
+  onAnimationEnd: () => {
+  },
+  onAnimationStart: () => {
+  }
+}, b = 0, f = 1;
+function Q(t) {
+  var r = w(t, k), n = r.animationId, e = r.isActive, l = r.canBegin, u = r.duration, i = r.easing, o = r.begin, a = r.onAnimationEnd, m = r.onAnimationStart, c = r.children, S = j(), s = e === "auto" ? !R.isSsr && !S : e, p = P(r.animationController), h = E(s ? b : f), v = M(h, 2), _ = v[0], d = v[1];
+  return y(() => {
+    s || d(f);
+  }, [s]), y(() => {
+    var A = B(i);
+    if (!s || !l || A == null)
+      return T;
+    var I = new J(), C = new F({
+      animationId: n,
+      easing: A,
+      animationDuration: u,
+      animationBegin: o,
+      onAnimationStart: m,
+      onAnimationEnd: a,
+      from: b,
+      to: f
+    });
+    return p(I, C, d);
+  }, [p, n, s, l, u, i, o, m, a]), c(Number(_));
+}
+export {
+  Q as JavascriptAnimate
+};

package/dist/node_modules/recharts/es6/animation/easing.js

@@ -0,0 +1,89 @@
+var m = 1e-4, w = (r, e) => [0, 3 * r, 3 * e - 6 * r, 3 * r - 3 * e + 1], E = (r, e) => r.map((a, n) => a * e ** n).reduce((a, n) => a + n), x = (r, e) => (a) => {
+  var n = w(r, e);
+  return E(n, a);
+}, X = (r, e) => (a) => {
+  var n = w(r, e), t = [...n.map((s, c) => s * c).slice(1), 0];
+  return E(t, a);
+}, A = (r) => {
+  var e, a = r.split("(");
+  if (a.length !== 2 || a[0] !== "cubic-bezier")
+    return null;
+  var n = (e = a[1]) === null || e === void 0 || (e = e.split(")")[0]) === null || e === void 0 ? void 0 : e.split(",");
+  if (n == null || n.length !== 4)
+    return null;
+  var t = n.map((s) => parseFloat(s));
+  return [t[0], t[1], t[2], t[3]];
+}, S = function() {
+  for (var e = arguments.length, a = new Array(e), n = 0; n < e; n++)
+    a[n] = arguments[n];
+  if (a.length === 1)
+    switch (a[0]) {
+      case "linear":
+        return [0, 0, 1, 1];
+      case "ease":
+        return [0.25, 0.1, 0.25, 1];
+      case "ease-in":
+        return [0.42, 0, 1, 1];
+      case "ease-out":
+        return [0.42, 0, 0.58, 1];
+      case "ease-in-out":
+        return [0, 0, 0.58, 1];
+      default: {
+        var t = A(a[0]);
+        if (t)
+          return t;
+      }
+    }
+  return a.length === 4 ? a : [0, 0, 1, 1];
+}, I = (r, e, a, n) => {
+  var t = x(r, a), s = x(e, n), c = X(r, a), l = (i) => i > 1 ? 1 : i < 0 ? 0 : i, o = (i) => {
+    for (var v = i > 1 ? 1 : i, u = v, d = 0; d < 8; ++d) {
+      var f = t(u) - v, p = c(u);
+      if (Math.abs(f - v) < m || p < m)
+        return s(u);
+      u = l(u - f / p);
+    }
+    return s(u);
+  };
+  return o.isStepper = !1, o;
+}, $ = function() {
+  return I(...S(...arguments));
+}, Y = function() {
+  for (var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, a = e.stiff, n = a === void 0 ? 100 : a, t = e.damping, s = t === void 0 ? 8 : t, c = e.dt, l = c === void 0 ? 16.67 : c, o = 1, i = [0], v = 0, u = 0, d = 1e4, f = 0; f < d; ) {
+    var p = -(v - o) * n, F = u * s;
+    if (u += (p - F) * l / 1e3, v += u * l / 1e3, i.push(v), Math.abs(v - o) < m && Math.abs(u) < m)
+      break;
+    f++;
+  }
+  i[i.length - 1] = o;
+  var M = i.length - 1;
+  return (h) => {
+    var b, z, B;
+    if (h <= 0) return 0;
+    if (h >= 1) return o;
+    var C = h * M, g = Math.floor(C), P = C - g;
+    return ((b = i[g]) !== null && b !== void 0 ? b : 0) + (((z = i[g + 1]) !== null && z !== void 0 ? z : 0) - ((B = i[g]) !== null && B !== void 0 ? B : 0)) * P;
+  };
+}, _ = (r) => {
+  if (typeof r == "string")
+    switch (r) {
+      case "ease":
+      case "ease-in-out":
+      case "ease-out":
+      case "ease-in":
+      case "linear":
+        return $(r);
+      case "spring":
+        return Y();
+      default:
+        if (r.split("(")[0] === "cubic-bezier")
+          return $(r);
+    }
+  return typeof r == "function" ? r : null;
+};
+export {
+  m as ACCURACY,
+  $ as configBezier,
+  _ as createEasingFunction,
+  Y as createSpringEasing
+};