flemo 1.1.2 → 1.1.4

package/dist/index.mjs

@@ -1,28 +1,29 @@
-import { jsx as P, jsxs as tt } from "react/jsx-runtime";
-import { useEffect as R, createContext as X, useReducer as gt, Children as et, useContext as q, Suspense as Pt, useImperativeHandle as yt, useRef as L } from "react";
-import { d as I, c as U } from "./vendor-C8cPYUOQ.js";
+import { jsx as w, jsxs as et } from "react/jsx-runtime";
+import { useEffect as G, createContext as X, useReducer as Pt, Children as nt, useContext as q, Suspense as Et, useImperativeHandle as St, useRef as I } from "react";
+import { d as x, c as _ } from "./vendor-C8cPYUOQ.js";
 import { animate as F } from "motion";
-import { animate as M, transform as nt, useAnimate as rt, motion as at, useDragControls as wt } from "motion/react";
-function St(n, e, t) {
-  const a = Array.isArray(n) ? n.find((i) => I.pathToRegexp(i).regexp.test(e)) || "" : I.pathToRegexp(n).regexp.test(e) ? n : "", r = I.match(a)(e), s = new URLSearchParams(t), o = Object.fromEntries(s.entries());
-  return r ? { ...r.params, ...o } : {};
+import { animate as A, transform as st, useAnimate as at, motion as rt, useDragControls as wt } from "motion/react";
+function yt(s, e, t) {
+  const a = Array.isArray(s) ? s.find((c) => x.pathToRegexp(c).regexp.test(e)) || "" : x.pathToRegexp(s).regexp.test(e) ? s : "", n = x.match(a)(e), i = new URLSearchParams(t), o = Object.fromEntries(i.entries());
+  return n ? { ...n.params, ...o } : {};
 }
-function J() {
+function Z() {
   return typeof document > "u";
 }
-class Et {
+class Lt {
   tasks = /* @__PURE__ */ new Map();
   instanceId = Date.now().toString();
   isLocked = !1;
   currentTaskId = null;
   taskQueue = Promise.resolve();
   signalListeners = /* @__PURE__ */ new Map();
-  // 신호 리스너
+  pendingTaskQueue = [];
+  isProcessingPending = !1;
   async acquireLock(e) {
-    for (let r = 0; r < 10; r++) {
+    for (let n = 0; n < 10; n++) {
       if (!this.isLocked)
         return this.isLocked = !0, this.currentTaskId = e, !0;
-      await new Promise((s) => setTimeout(s, 100));
+      await new Promise((i) => setTimeout(i, 100));
     }
     return !1;
   }
@@ -38,76 +39,122 @@ class Et {
       this.resolveTask(a);
     }), this.signalListeners.delete(e));
   }
+  // 대기 중인 태스크들을 처리하는 메서드
+  async processPendingTasks() {
+    if (!(this.isProcessingPending || this.pendingTaskQueue.length === 0)) {
+      this.isProcessingPending = !0;
+      try {
+        for (; this.pendingTaskQueue.length > 0; ) {
+          const e = this.pendingTaskQueue[0];
+          if (e.status === "COMPLETED" || e.status === "FAILED" || e.status === "ROLLEDBACK") {
+            this.pendingTaskQueue.shift();
+            continue;
+          }
+          if (e.status === "MANUAL_PENDING" || e.status === "SIGNAL_PENDING" || e.status === "PROCESSING" || e.status === "PENDING")
+            break;
+        }
+      } finally {
+        this.isProcessingPending = !1;
+      }
+    }
+  }
+  // 모든 대기 중인 태스크가 완료될 때까지 대기
+  async waitForPendingTasks() {
+    return new Promise((e) => {
+      const t = () => {
+        this.pendingTaskQueue.filter(
+          (n) => n.status === "MANUAL_PENDING" || n.status === "SIGNAL_PENDING"
+        ).length === 0 ? e() : setTimeout(t, 100);
+      };
+      t();
+    });
+  }
+  // 태스크 상태 변경 시 대기 큐 처리
+  async onTaskStatusChange(e, t) {
+    (t === "COMPLETED" || t === "FAILED" || t === "ROLLEDBACK") && (this.pendingTaskQueue = this.pendingTaskQueue.filter((a) => a.id !== e), await this.processPendingTasks());
+  }
   async addTask(e, t = {}) {
     const a = t.id || this.generateTaskId();
-    return new Promise((r, s) => {
+    return new Promise((n, i) => {
       this.taskQueue = this.taskQueue.then(async () => {
         try {
-          const { control: o, validate: i, rollback: c, dependencies: p = [] } = t, u = {
+          const { control: o, validate: c, rollback: u, dependencies: l = [], delay: p } = t, f = new AbortController(), r = {
             id: a,
             execute: e,
             timestamp: Date.now(),
             retryCount: 0,
             status: "PENDING",
-            dependencies: p,
+            dependencies: l,
             instanceId: this.instanceId,
-            validate: i,
-            rollback: c,
-            control: o
+            validate: c,
+            rollback: u,
+            control: o,
+            abortController: f
           };
-          this.tasks.set(u.id, u);
+          this.tasks.set(r.id, r), this.pendingTaskQueue.length > 0 && (this.pendingTaskQueue.push(r), await this.waitForPendingTasks(), this.pendingTaskQueue = this.pendingTaskQueue.filter((P) => P.id !== r.id));
           try {
-            if (!await this.acquireLock(u.id))
-              throw u.status = "FAILED", new Error("FAILED");
+            if (!await this.acquireLock(r.id))
+              throw r.status = "FAILED", new Error("FAILED");
             try {
-              u.status = "PROCESSING";
-              for (const l of u.dependencies) {
-                const w = this.tasks.get(l);
-                if (!w || w.status !== "COMPLETED")
-                  throw u.status = "FAILED", new Error("FAILED");
+              r.status = "PROCESSING";
+              for (const h of r.dependencies) {
+                const m = this.tasks.get(h);
+                if (!m || m.status !== "COMPLETED")
+                  throw r.status = "FAILED", new Error("FAILED");
+              }
+              if (r.validate && !await r.validate())
+                throw r.status = "FAILED", new Error("FAILED");
+              p && p > 0 && await new Promise((h) => setTimeout(h, p));
+              const E = await r.execute(r.abortController);
+              if (r.abortController.signal.aborted) {
+                r.status = "COMPLETED", await this.onTaskStatusChange(r.id, "COMPLETED"), n({
+                  success: !0,
+                  result: void 0,
+                  taskId: r.id,
+                  timestamp: Date.now(),
+                  instanceId: this.instanceId
+                });
+                return;
               }
-              if (u.validate && !await u.validate())
-                throw u.status = "FAILED", new Error("FAILED");
-              const d = await u.execute();
               if (t.control) {
-                const l = t.control;
-                if (l.delay && l.delay > 0 && await new Promise((w) => setTimeout(w, l.delay)), l.manual) {
-                  u.status = "MANUAL_PENDING", u.manualResolver = { resolve: r, reject: s, result: d };
+                const h = t.control;
+                if (h.delay && h.delay > 0 && await new Promise((m) => setTimeout(m, h.delay)), h.manual) {
+                  r.status = "MANUAL_PENDING", r.manualResolver = { resolve: n, reject: i, result: E }, this.pendingTaskQueue.push(r), await this.onTaskStatusChange(r.id, "MANUAL_PENDING");
                   return;
                 }
-                if (l.signal) {
-                  u.status = "MANUAL_PENDING", u.manualResolver = { resolve: r, reject: s, result: d }, this.signalListeners.has(l.signal) || this.signalListeners.set(l.signal, /* @__PURE__ */ new Set()), this.signalListeners.get(l.signal).add(u.id);
+                if (h.signal) {
+                  r.status = "SIGNAL_PENDING", r.manualResolver = { resolve: n, reject: i, result: E }, this.signalListeners.has(h.signal) || this.signalListeners.set(h.signal, /* @__PURE__ */ new Set()), this.signalListeners.get(h.signal).add(r.id), this.pendingTaskQueue.push(r), await this.onTaskStatusChange(r.id, "SIGNAL_PENDING");
                   return;
                 }
-                if (l.condition && !await l.condition()) {
-                  u.status = "MANUAL_PENDING", u.manualResolver = { resolve: r, reject: s, result: d };
+                if (h.condition && !await h.condition()) {
+                  r.status = "MANUAL_PENDING", r.manualResolver = { resolve: n, reject: i, result: E }, this.pendingTaskQueue.push(r), await this.onTaskStatusChange(r.id, "MANUAL_PENDING");
                   return;
                 }
               }
-              u.status = "COMPLETED", r({
+              r.status = "COMPLETED", await this.onTaskStatusChange(r.id, "COMPLETED"), n({
                 success: !0,
-                result: d,
-                taskId: u.id,
+                result: E,
+                taskId: r.id,
                 timestamp: Date.now(),
                 instanceId: this.instanceId
               });
-            } catch (d) {
-              if (u.status = "FAILED", u.rollback)
+            } catch (E) {
+              if (r.status = "FAILED", r.rollback)
                 try {
-                  await u.rollback(), u.status = "ROLLEDBACK";
+                  await r.rollback(), r.status = "ROLLEDBACK";
                 } catch {
                 }
-              throw d;
+              throw await this.onTaskStatusChange(r.id, r.status), E;
             } finally {
-              this.releaseLock(u.id);
+              this.releaseLock(r.id);
             }
-          } catch (h) {
-            s(h);
+          } catch (P) {
+            i(P);
           }
         } catch (o) {
-          s(o);
+          i(o);
         }
-      }).catch(s);
+      }).catch(i);
     });
   }
   async resolveTask(e) {
@@ -125,117 +172,102 @@ class Et {
         taskId: t.id,
         timestamp: Date.now(),
         instanceId: this.instanceId
-      }), delete t.manualResolver, !0;
+      }), delete t.manualResolver, await this.onTaskStatusChange(e, "COMPLETED"), !0;
     }
     return !1;
   }
   async resolveAllPending() {
     const e = Array.from(this.tasks.values()).filter(
-      (t) => ["PENDING", "MANUAL_PENDING"].includes(t.status)
+      (t) => ["PENDING", "MANUAL_PENDING", "SIGNAL_PENDING"].includes(t.status)
     );
     await Promise.all(e.map((t) => this.resolveTask(t.id)));
   }
-  getManualPendingTasks() {
-    return Array.from(this.tasks.values()).filter((e) => e.status === "MANUAL_PENDING");
-  }
 }
-const m = new Et(), x = U((n) => ({
+const N = new Lt(), R = _((s) => ({
   index: -1,
   histories: [],
-  addHistory: (e) => n((t) => ({
+  addHistory: (e) => s((t) => ({
     index: t.index + 1,
     histories: t.histories.concat(e)
   })),
-  replaceHistory: (e) => n((t) => (t.histories.splice(e, 1), {
+  replaceHistory: (e) => s((t) => (t.histories.splice(e, 1), {
     index: t.index - 1,
     histories: t.histories
   })),
-  popHistory: (e) => n((t) => ({
+  popHistory: (e) => s((t) => ({
     index: t.index - 1,
-    histories: t.histories.filter((a, r) => r !== e)
+    histories: t.histories.filter((a, n) => n !== e)
   }))
-})), C = U((n) => ({
+})), T = _((s) => ({
   status: "IDLE",
-  setStatus: (e) => n({ status: e })
+  setStatus: (e) => s({ status: e })
 }));
-function vt() {
-  return R(() => {
-    const n = async (e) => {
-      await m.resolveAllPending();
-      const { index: t, addHistory: a, popHistory: r } = x.getState(), s = C.getState().setStatus, o = e.state?.id, i = e.state?.index, c = e.state?.status, p = e.state?.params, u = e.state?.transitionName, h = i < t, d = c === "PUSHING" && i > t, l = c === "REPLACING" && i > t;
-      h ? (await m.addTask(
-        async () => (s("POPPING"), async () => {
-          r(i + 1), m.getManualPendingTasks().length || s("COMPLETED");
-        }),
-        {
-          id: o,
-          control: {
-            manual: !0
-          }
-        }
-      ))?.result?.() : d ? (await m.addTask(
-        async () => (s("PUSHING"), a({
-          id: o,
-          pathname: window.location.pathname,
-          params: p,
-          transitionName: u
-        }), async () => {
-          m.getManualPendingTasks().length || s("COMPLETED");
-        }),
-        {
-          id: o,
-          control: {
-            manual: !0
+function Tt() {
+  return G(() => {
+    const s = async (e) => {
+      const t = e.state?.id;
+      (await N.addTask(
+        async (a) => {
+          const n = e.state?.index, i = e.state?.status, o = e.state?.params, c = e.state?.transitionName, u = T.getState().setStatus, { index: l, addHistory: p, popHistory: f } = R.getState(), r = n < l, g = i === "PUSHING" && n > l, P = i === "REPLACING" && n > l, E = window.location.pathname;
+          if (!r && !g && !P) {
+            a.abort();
+            return;
           }
-        }
-      ))?.result?.() : l && (await m.addTask(
-        async () => (s("REPLACING"), a({
-          id: o,
-          pathname: window.location.pathname,
-          params: p,
-          transitionName: u
-        }), async () => {
-          m.getManualPendingTasks().length || s("COMPLETED");
-        }),
+          return r ? u("POPPING") : g ? (u("PUSHING"), p({
+            id: t,
+            pathname: E,
+            params: o,
+            transitionName: c
+          })) : P && (u("REPLACING"), p({
+            id: t,
+            pathname: E,
+            params: o,
+            transitionName: c
+          })), async () => {
+            r && f(n + 1), u("COMPLETED");
+          };
+        },
         {
-          id: o,
+          id: t,
           control: {
             manual: !0
           }
         }
-      ))?.result?.();
+      )).result?.();
     };
-    return window.addEventListener("popstate", n), () => {
-      window.removeEventListener("popstate", n);
+    return window.addEventListener("popstate", s), () => {
+      window.removeEventListener("popstate", s);
     };
   }, []), null;
 }
-const st = X({}), ot = X(() => {
+const it = X({}), ot = X(() => {
 });
-function Lt(n, e) {
+function Dt(s, e) {
   switch (e.type) {
     case "SET":
       return e.params;
     default:
-      return n;
+      return s;
   }
 }
-function Tt({
-  children: n,
+function It({
+  children: s,
   active: e,
   params: t
 }) {
-  const [a, r] = gt(Lt, t);
-  return R(() => {
-    const s = (o) => {
-      o.state?.step && r({ type: "SET", params: o.state?.params || {} });
+  const [a, n] = Pt(Dt, t);
+  return G(() => {
+    const i = async (o) => {
+      o.state?.step && await N.addTask(async () => {
+        n({ type: "SET", params: o.state?.params || {} });
+      });
     };
-    return e && window.addEventListener("popstate", s), () => {
-      window.removeEventListener("popstate", s);
+    return e && window.addEventListener("popstate", i), () => {
+      window.removeEventListener("popstate", i);
     };
-  }, [e, r]), /* @__PURE__ */ P(ot.Provider, { value: r, children: /* @__PURE__ */ P(st.Provider, { value: a, children: n }) });
+  }, [e, n]), /* @__PURE__ */ w(ot.Provider, { value: n, children: /* @__PURE__ */ w(it.Provider, { value: a, children: s }) });
 }
-const it = X({
+const ct = X({
   id: "",
   isActive: !1,
   isRoot: !0,
@@ -246,42 +278,42 @@ const it = X({
   transitionName: "none",
   prevTransitionName: "none"
 });
-function Dt({ children: n }) {
-  const e = x((a) => a.index), t = x((a) => a.histories);
+function Nt({ children: s }) {
+  const e = R((a) => a.index), t = R((a) => a.histories);
   return t.map(
-    (a) => et.toArray(n).filter(
-      (r) => I.pathToRegexp(r.props.path).regexp.test(
+    (a) => nt.toArray(s).filter(
+      (n) => x.pathToRegexp(n.props.path).regexp.test(
         a.pathname
       )
     )
-  ).map(([a], r) => /* @__PURE__ */ P(
-    it.Provider,
+  ).map(([a], n) => /* @__PURE__ */ w(
+    ct.Provider,
     {
       value: {
-        id: t[r].id,
-        isActive: r === e,
-        isRoot: r === 0,
-        isPrev: r < e - 1,
-        zIndex: r,
-        pathname: t[r].pathname,
-        params: t[r].params,
+        id: t[n].id,
+        isActive: n === e,
+        isRoot: n === 0,
+        isPrev: n < e - 1,
+        zIndex: n,
+        pathname: t[n].pathname,
+        params: t[n].params,
         transitionName: t[e].transitionName,
         prevTransitionName: t[e - 1]?.transitionName
       },
-      children: /* @__PURE__ */ P(Tt, { active: r === e, params: t[r].params, children: a })
+      children: /* @__PURE__ */ w(It, { active: n === e, params: t[n].params, children: a })
     },
-    t[r].id
+    t[n].id
   ));
 }
-function Nt({
-  name: n,
+function kt({
+  name: s,
   initial: e,
   enter: t,
   exit: a,
-  options: r
+  options: n
 }) {
   return {
-    name: n,
+    name: s,
     initial: e,
     variants: {
       "IDLE-true": t,
@@ -295,10 +327,10 @@ function Nt({
       "COMPLETED-false": a,
       "COMPLETED-true": t
     },
-    ...r
+    ...n
   };
 }
-const kt = Nt({
+const vt = kt({
   name: "overlay",
   initial: {
     opacity: 0,
@@ -326,16 +358,16 @@ const kt = Nt({
     }
   },
   options: {
-    onSwipeStart: (n, { prevDecorator: e }) => F(
+    onSwipeStart: (s, { prevDecorator: e }) => F(
       e,
       {
-        opacity: n ? 1 : 0
+        opacity: s ? 1 : 0
       },
       {
         duration: 0.3
       }
     ),
-    onSwipe: (n, e, { prevDecorator: t }) => F(
+    onSwipe: (s, e, { prevDecorator: t }) => F(
       t,
       {
         opacity: Math.max(0, 1 - e / 100)
@@ -344,49 +376,49 @@ const kt = Nt({
         duration: 0
       }
     ),
-    onSwipeEnd: (n, { prevDecorator: e }) => F(
+    onSwipeEnd: (s, { prevDecorator: e }) => F(
       e,
       {
-        opacity: n ? 0 : 1
+        opacity: s ? 0 : 1
       },
       {
         duration: 0.3
       }
     )
   }
-}), j = /* @__PURE__ */ new Map([["overlay", kt]]), _ = U((n) => ({
+}), K = /* @__PURE__ */ new Map([["overlay", vt]]), B = _((s) => ({
   defaultTransitionName: "cupertino",
-  setDefaultTransitionName: (e) => n({ defaultTransitionName: e })
+  setDefaultTransitionName: (e) => s({ defaultTransitionName: e })
 }));
-function K({
-  name: n,
+function j({
+  name: s,
   initial: e,
   idle: t,
   enter: a,
-  enterBack: r,
-  exit: s,
+  enterBack: n,
+  exit: i,
   exitBack: o,
-  options: i
+  options: c
 }) {
   return {
-    name: n,
+    name: s,
     initial: e,
     variants: {
       "IDLE-true": t,
       "IDLE-false": t,
-      "PUSHING-false": s,
+      "PUSHING-false": i,
       "PUSHING-true": a,
-      "REPLACING-false": s,
+      "REPLACING-false": i,
       "REPLACING-true": a,
       "POPPING-false": o,
-      "POPPING-true": r,
-      "COMPLETED-false": s,
+      "POPPING-true": n,
+      "COMPLETED-false": i,
       "COMPLETED-true": a
     },
-    ...i
+    ...c
   };
 }
-const It = K({
+const Mt = j({
   name: "cupertino",
   initial: {
     x: "100%",
@@ -442,9 +474,9 @@ const It = K({
     decoratorName: "overlay",
     swipeDirection: "x",
     onSwipeStart: async () => !0,
-    onSwipe: (n, e, { currentScreen: t, prevScreen: a, onProgress: r }) => {
-      const { offset: s } = e, o = s.x, i = nt(o, [0, window.innerWidth], [0, 100]);
-      return r?.(!0, i), M(
+    onSwipe: (s, e, { currentScreen: t, prevScreen: a, onProgress: n }) => {
+      const { offset: i } = e, o = i.x, c = st(o, [0, window.innerWidth], [0, 100]);
+      return n?.(!0, c), A(
         t,
         {
           x: Math.max(0, o)
@@ -452,43 +484,43 @@ const It = K({
         {
           duration: 0
         }
-      ), M(
+      ), A(
         a,
         {
-          x: -100 + i
+          x: -100 + c
         },
         {
           duration: 0
         }
-      ), i;
+      ), c;
     },
-    onSwipeEnd: async (n, e, { currentScreen: t, prevScreen: a, onStart: r }) => {
-      const { offset: s, velocity: o } = e, c = s.x > 50 || o.x > 20;
-      return r?.(c), await Promise.all([
-        M(
+    onSwipeEnd: async (s, e, { currentScreen: t, prevScreen: a, onStart: n }) => {
+      const { offset: i, velocity: o } = e, u = i.x > 50 || o.x > 20;
+      return n?.(u), await Promise.all([
+        A(
           t,
           {
-            x: c ? "100%" : 0
+            x: u ? "100%" : 0
           },
           {
             duration: 0.3,
             ease: [0.32, 0.72, 0, 1]
           }
         ),
-        M(
+        A(
           a,
           {
-            x: c ? 0 : -100
+            x: u ? 0 : -100
           },
           {
             duration: 0.3,
             ease: [0.32, 0.72, 0, 1]
           }
         )
-      ]), c;
+      ]), u;
     }
   }
-}), Mt = K({
+}), Ct = j({
   name: "material",
   initial: {
     y: "100%",
@@ -549,55 +581,55 @@ const It = K({
   options: {
     swipeDirection: "y",
     onSwipeStart: async () => !0,
-    onSwipe: (n, e, { currentScreen: t, prevScreen: a, onProgress: r }) => {
-      const { offset: s } = e, o = s.y, i = Math.max(0, Math.min(56, o)), c = nt(i, [0, 56], [1, 0.96]), p = Math.max(0, o - 56), u = Math.min(1, p / 160), h = Math.sqrt(u) * 12, d = Math.max(0, i + h), l = Math.min(56, d);
-      return r?.(!0, l), M(
+    onSwipe: (s, e, { currentScreen: t, prevScreen: a, onProgress: n }) => {
+      const { offset: i } = e, o = i.y, c = Math.max(0, Math.min(56, o)), u = st(c, [0, 56], [1, 0.96]), l = Math.max(0, o - 56), p = Math.min(1, l / 160), f = Math.sqrt(p) * 12, r = Math.max(0, c + f), g = Math.min(56, r);
+      return n?.(!0, g), A(
         t,
         {
-          y: d,
-          opacity: c
+          y: r,
+          opacity: u
         },
         {
           duration: 0
         }
-      ), M(
+      ), A(
         a,
         {
-          y: -56 + l,
-          opacity: l / 56
+          y: -56 + g,
+          opacity: g / 56
         },
         { duration: 0 }
-      ), l;
+      ), g;
     },
-    onSwipeEnd: async (n, e, { currentScreen: t, prevScreen: a, onStart: r }) => {
-      const { offset: s, velocity: o } = e, c = s.y > 56 || o.y > 20;
-      return r?.(c), await Promise.all([
-        M(
+    onSwipeEnd: async (s, e, { currentScreen: t, prevScreen: a, onStart: n }) => {
+      const { offset: i, velocity: o } = e, u = i.y > 56 || o.y > 20;
+      return n?.(u), await Promise.all([
+        A(
           t,
           {
-            y: c ? "100%" : 0,
-            opacity: c ? 0.96 : 1
+            y: u ? "100%" : 0,
+            opacity: u ? 0.96 : 1
           },
           {
-            duration: c ? 0.22 : 0.24,
-            ease: c ? [0.4, 0, 1, 1] : [0, 0, 0.2, 1]
+            duration: u ? 0.22 : 0.24,
+            ease: u ? [0.4, 0, 1, 1] : [0, 0, 0.2, 1]
           }
         ),
-        M(
+        A(
           a,
           {
-            y: c ? 0 : -56,
-            opacity: c ? 1 : 0.96
+            y: u ? 0 : -56,
+            opacity: u ? 1 : 0.96
           },
           {
-            duration: c ? 0.22 : 0.24,
-            ease: c ? [0, 0, 0.2, 1] : [0.4, 0, 1, 1]
+            duration: u ? 0.22 : 0.24,
+            ease: u ? [0, 0, 0.2, 1] : [0.4, 0, 1, 1]
           }
         )
-      ]), c;
+      ]), u;
     }
   }
-}), xt = K({
+}), xt = j({
   name: "none",
   initial: {
     transition: {
@@ -634,48 +666,48 @@ const It = K({
       duration: 0
     }
   }
-}), $ = /* @__PURE__ */ new Map([
+}), Q = /* @__PURE__ */ new Map([
   ["none", xt],
-  ["cupertino", It],
-  ["material", Mt]
-]), Rt = (() => {
-  const n = /* @__PURE__ */ Object.create(null), e = Object.prototype.hasOwnProperty;
-  for (const t of $.values()) {
+  ["cupertino", Mt],
+  ["material", Ct]
+]), At = (() => {
+  const s = /* @__PURE__ */ Object.create(null), e = Object.prototype.hasOwnProperty;
+  for (const t of Q.values()) {
     const a = t.variants["IDLE-true"].value;
-    for (const r in a)
-      e.call(a, r) && (n[r] = a[r]);
+    for (const n in a)
+      e.call(a, n) && (s[n] = a[n]);
   }
-  return n;
+  return s;
 })();
 function Yt({
-  children: n,
+  children: s,
   initPath: e = "/",
   defaultTransitionName: t = "cupertino",
   transitions: a = [],
-  decorators: r = []
+  decorators: n = []
 }) {
-  const s = J() ? e || "/" : window.location.pathname, o = J() ? s.split("?")[1] || "" : window.location.search;
-  return _.setState({
+  const i = Z() ? e || "/" : window.location.pathname, o = Z() ? i.split("?")[1] || "" : window.location.search;
+  return B.setState({
     defaultTransitionName: t
-  }), x.setState({
+  }), R.setState({
     index: 0,
     histories: [
       {
         id: "root",
-        pathname: s,
-        params: St(
-          et.toArray(n).map((i) => i.props.path).flat(),
-          s,
+        pathname: i,
+        params: yt(
+          nt.toArray(s).map((c) => c.props.path).flat(),
+          i,
           o
         ),
         transitionName: t
       }
     ]
-  }), R(() => {
-    a.forEach((i) => $.set(i.name, i));
-  }, [a]), R(() => {
-    r.forEach((i) => j.set(i.name, i));
-  }, [r]), /* @__PURE__ */ tt(
+  }), G(() => {
+    a.forEach((c) => Q.set(c.name, c));
+  }, [a]), G(() => {
+    n.forEach((c) => K.set(c.name, c));
+  }, [n]), /* @__PURE__ */ et(
     "div",
     {
       style: {
@@ -686,95 +718,97 @@ function Yt({
         height: "100%"
       },
       children: [
-        /* @__PURE__ */ P(vt, {}),
-        /* @__PURE__ */ P(Dt, { children: n })
+        /* @__PURE__ */ w(Tt, {}),
+        /* @__PURE__ */ w(Nt, { children: s })
       ]
     }
   );
 }
-function Xt({ element: n }) {
-  return n;
+function Xt({ element: s }) {
+  return s;
 }
 function qt() {
   return {
-    push: async (a, r, s = {}) => {
-      if (m.getManualPendingTasks().length)
+    push: async (a, n, i = {}) => {
+      const { status: o, setStatus: c } = T.getState();
+      if (o !== "COMPLETED" && o !== "IDLE")
         return;
-      const { index: o, addHistory: i } = x.getState(), c = C.getState().setStatus, p = _.getState().defaultTransitionName, { transitionName: u = p } = s, h = m.generateTaskId();
-      (await m.addTask(
+      const { index: u, addHistory: l } = R.getState(), p = B.getState().defaultTransitionName, { transitionName: f = p } = i, r = N.generateTaskId();
+      (await N.addTask(
         async () => {
           c("PUSHING");
-          const d = I.compile(a)(r), l = I.parse(a).tokens.filter((v) => v.type === "param").map((v) => v.name), w = Object.fromEntries(
-            Object.entries(r).filter(([v]) => !l.includes(v))
-          ), A = new URLSearchParams(w).toString(), S = `${d}${A ? `?${A}` : ""}`;
+          const g = x.compile(a)(n), P = x.parse(a).tokens.filter((D) => D.type === "param").map((D) => D.name), E = Object.fromEntries(
+            Object.entries(n).filter(([D]) => !P.includes(D))
+          ), h = new URLSearchParams(E).toString(), m = `${g}${h ? `?${h}` : ""}`;
           return window.history.state?.id || window.history.replaceState(
             {
               id: "root",
               index: 0,
               status: "IDLE",
               params: {},
-              transitionName: u
+              transitionName: f
             },
             "",
             window.location.pathname
           ), window.history.pushState(
             {
-              id: h,
-              index: o + 1,
+              id: r,
+              index: u + 1,
               status: "PUSHING",
-              params: r,
-              transitionName: u
+              params: n,
+              transitionName: f
             },
             "",
-            S
-          ), i({
-            id: h,
-            pathname: d,
-            params: r,
-            transitionName: u
+            m
+          ), l({
+            id: r,
+            pathname: g,
+            params: n,
+            transitionName: f
           }), () => {
-            m.getManualPendingTasks().length || c("COMPLETED");
+            c("COMPLETED");
           };
         },
         {
-          id: h,
+          id: r,
           control: {
             manual: !0
           }
         }
       )).result?.();
     },
-    replace: async (a, r, s = {}) => {
-      if (m.getManualPendingTasks().length)
+    replace: async (a, n, i = {}) => {
+      const { status: o, setStatus: c } = T.getState();
+      if (o !== "COMPLETED" && o !== "IDLE")
         return;
-      const { index: o, addHistory: i } = x.getState(), c = x.getState().replaceHistory, p = C.getState().setStatus, u = _.getState().defaultTransitionName, { transitionName: h = u } = s, d = m.generateTaskId();
-      (await m.addTask(
+      const { index: u, addHistory: l } = R.getState(), p = R.getState().replaceHistory, f = B.getState().defaultTransitionName, { transitionName: r = f } = i, g = N.generateTaskId();
+      (await N.addTask(
         async () => {
-          p("REPLACING");
-          const l = I.compile(a)(r), w = I.parse(a).tokens.filter((E) => E.type === "param").map((E) => E.name), A = Object.fromEntries(
-            Object.entries(r).filter(([E]) => !w.includes(E))
-          ), S = new URLSearchParams(A).toString(), v = `${l}${S ? `?${S}` : ""}`;
+          c("REPLACING");
+          const P = x.compile(a)(n), E = x.parse(a).tokens.filter((L) => L.type === "param").map((L) => L.name), h = Object.fromEntries(
+            Object.entries(n).filter(([L]) => !E.includes(L))
+          ), m = new URLSearchParams(h).toString(), D = `${P}${m ? `?${m}` : ""}`;
           return window.history.replaceState(
             {
-              id: d,
-              index: o,
+              id: g,
+              index: u,
               status: "REPLACING",
-              params: r,
-              transitionName: h
+              params: n,
+              transitionName: r
             },
             "",
-            v
-          ), i({
-            id: d,
-            pathname: l,
-            params: r,
-            transitionName: h
+            D
+          ), l({
+            id: g,
+            pathname: P,
+            params: n,
+            transitionName: r
           }), async () => {
-            await m.addTask(async () => c(o)), m.getManualPendingTasks().length || p("COMPLETED");
+            p(u), c("COMPLETED");
           };
         },
         {
-          id: d,
+          id: g,
           control: {
             manual: !0
           }
@@ -782,16 +816,18 @@ function qt() {
       )).result?.();
     },
     pop: () => {
-      m.getManualPendingTasks().length || window.history.back();
+      const a = T.getState().status;
+      a !== "COMPLETED" && a !== "IDLE" || window.history.back();
     }
   };
 }
-function jt() {
-  const n = q(ot);
+function Kt() {
+  const s = q(ot);
   return {
-    pushStep: async (r) => {
-      m.getManualPendingTasks().length || (await m.addTask(async () => {
-        const s = new URLSearchParams(r).toString(), o = `${window.location.pathname}${s ? `?${s}` : ""}`;
+    pushStep: async (n) => {
+      const i = T.getState().status;
+      i !== "COMPLETED" && i !== "IDLE" || (await N.addTask(async () => {
+        const o = new URLSearchParams(n).toString(), c = `${window.location.pathname}${o ? `?${o}` : ""}`;
         return window.history.state?.step || window.history.replaceState(
           {
             ...window.history.state,
@@ -803,177 +839,179 @@ function jt() {
           {
             ...window.history.state,
             step: !0,
-            params: r
+            params: n
           },
           "",
-          o
-        ), async () => n({ type: "SET", params: r });
+          c
+        ), async () => s({ type: "SET", params: n });
       })).result?.();
     },
-    replaceStep: async (r) => {
-      m.getManualPendingTasks().length || (await m.addTask(async () => {
-        const s = new URLSearchParams(r).toString(), o = `${window.location.pathname}${s ? `?${s}` : ""}`;
+    replaceStep: async (n) => {
+      const i = T.getState().status;
+      i !== "COMPLETED" && i !== "IDLE" || (await N.addTask(async () => {
+        const o = new URLSearchParams(n).toString(), c = `${window.location.pathname}${o ? `?${o}` : ""}`;
         return window.history.replaceState(
           {
             ...window.history.state,
             step: !0,
-            params: r
+            params: n
           },
           "",
-          o
-        ), async () => n({ type: "SET", params: r });
+          c
+        ), async () => s({ type: "SET", params: n });
       })).result?.();
     },
     popStep: () => {
-      m.getManualPendingTasks().length || window.history.back();
+      const n = T.getState().status;
+      n !== "COMPLETED" && n !== "IDLE" || window.history.back();
     }
   };
 }
-function Q() {
-  return q(it);
+function V() {
+  return q(ct);
 }
-function Kt() {
-  return q(st);
+function jt() {
+  return q(it);
 }
-function Qt({
-  name: n,
+function Vt({
+  name: s,
   initial: e,
   idle: t,
   pushOnEnter: a,
-  pushOnExit: r,
-  replaceOnEnter: s,
+  pushOnExit: n,
+  replaceOnEnter: i,
   replaceOnExit: o,
-  popOnEnter: i,
-  popOnExit: c,
-  completedOnExit: p,
-  completedOnEnter: u,
-  options: h
+  popOnEnter: c,
+  popOnExit: u,
+  completedOnExit: l,
+  completedOnEnter: p,
+  options: f
 }) {
   return {
-    name: n,
+    name: s,
     initial: e,
     variants: {
       "IDLE-true": t,
       "IDLE-false": t,
-      "PUSHING-false": r,
+      "PUSHING-false": n,
       "PUSHING-true": a,
       "REPLACING-false": o,
-      "REPLACING-true": s,
-      "POPPING-false": c,
-      "POPPING-true": i,
-      "COMPLETED-false": p,
-      "COMPLETED-true": u
+      "REPLACING-true": i,
+      "POPPING-false": u,
+      "POPPING-true": c,
+      "COMPLETED-false": l,
+      "COMPLETED-true": p
     },
-    ...h
+    ...f
   };
 }
-function Vt({
-  name: n,
+function Wt({
+  name: s,
   initial: e,
   idle: t,
   pushOnEnter: a,
-  pushOnExit: r,
-  replaceOnEnter: s,
+  pushOnExit: n,
+  replaceOnEnter: i,
   replaceOnExit: o,
-  popOnEnter: i,
-  popOnExit: c,
-  completedOnEnter: p,
-  completedOnExit: u,
-  options: h
+  popOnEnter: c,
+  popOnExit: u,
+  completedOnEnter: l,
+  completedOnExit: p,
+  options: f
 }) {
   return {
-    name: n,
+    name: s,
     initial: e,
     variants: {
       "IDLE-true": t,
       "IDLE-false": t,
-      "PUSHING-false": r,
+      "PUSHING-false": n,
       "PUSHING-true": a,
       "REPLACING-false": o,
-      "REPLACING-true": s,
-      "POPPING-false": c,
-      "POPPING-true": i,
-      "COMPLETED-false": u,
-      "COMPLETED-true": p
+      "REPLACING-true": i,
+      "POPPING-false": u,
+      "POPPING-true": c,
+      "COMPLETED-false": p,
+      "COMPLETED-true": l
     },
-    ...h
+    ...f
   };
 }
-const At = { then() {
+const Rt = { then() {
 } };
-function Ct({
-  freeze: n,
+function Gt({
+  freeze: s,
   children: e
 }) {
-  if (n)
-    throw At;
+  if (s)
+    throw Rt;
   return e;
 }
-function Gt({ freeze: n, children: e, placeholder: t }) {
-  return /* @__PURE__ */ P(Pt, { fallback: t, children: /* @__PURE__ */ P(Ct, { freeze: n, children: e }) });
+function bt({ freeze: s, children: e, placeholder: t }) {
+  return /* @__PURE__ */ w(Et, { fallback: t, children: /* @__PURE__ */ w(Gt, { freeze: s, children: e }) });
 }
-function Z(n, e) {
+function z(s, e) {
   const {
     direction: t = "x",
     markerSelector: a = "[data-swipe-at-edge]",
-    depthLimit: r = 24,
-    verifyByScroll: s = !1
-  } = e ?? {}, o = bt(n);
+    depthLimit: n = 24,
+    verifyByScroll: i = !1
+  } = e ?? {}, o = Ot(s);
   if (!o) return { element: null, hasMarker: !1 };
-  const i = o.closest?.(a);
-  if (i instanceof HTMLElement && B(i, t) && (!s || z(i, t)))
-    return { element: i, hasMarker: !0 };
-  let c = o, p = 0;
-  for (; c && c !== document.body && p < r; ) {
-    if (B(c, t) && (!s || z(c, t)))
-      return { element: c, hasMarker: !1 };
-    c = c.parentElement, p++;
+  const c = o.closest?.(a);
+  if (c instanceof HTMLElement && Y(c, t) && (!i || tt(c, t)))
+    return { element: c, hasMarker: !0 };
+  let u = o, l = 0;
+  for (; u && u !== document.body && l < n; ) {
+    if (Y(u, t) && (!i || tt(u, t)))
+      return { element: u, hasMarker: !1 };
+    u = u.parentElement, l++;
   }
   return { element: null, hasMarker: !1 };
 }
-function bt(n) {
-  if (!n) return null;
-  const e = n, t = typeof e.composedPath == "function" ? e.composedPath() : void 0;
+function Ot(s) {
+  if (!s) return null;
+  const e = s, t = typeof e.composedPath == "function" ? e.composedPath() : void 0;
   if (t && t.length) {
     for (const a of t)
       if (a instanceof HTMLElement) return a;
   }
-  return n;
+  return s;
 }
-function B(n, e) {
-  return e === "y" ? n.scrollHeight - n.clientHeight > 1 : n.scrollWidth - n.clientWidth > 1;
+function Y(s, e) {
+  return e === "y" ? s.scrollHeight - s.clientHeight > 1 : s.scrollWidth - s.clientWidth > 1;
 }
-function z(n, e) {
-  if (!B(n, e)) return !1;
+function tt(s, e) {
+  if (!Y(s, e)) return !1;
   if (e === "y") {
-    const t = n.scrollTop;
-    if (n.scrollTop = t + 1, n.scrollTop !== t)
-      return n.scrollTop = t, !0;
-    n.scrollTop = t - 1;
-    const r = n.scrollTop !== t;
-    return n.scrollTop = t, r;
+    const t = s.scrollTop;
+    if (s.scrollTop = t + 1, s.scrollTop !== t)
+      return s.scrollTop = t, !0;
+    s.scrollTop = t - 1;
+    const n = s.scrollTop !== t;
+    return s.scrollTop = t, n;
   } else {
-    const t = n.scrollLeft;
-    if (n.scrollLeft = t + 1, n.scrollLeft !== t)
-      return n.scrollLeft = t, !0;
-    n.scrollLeft = t - 1;
-    const r = n.scrollLeft !== t;
-    return n.scrollLeft = t, r;
+    const t = s.scrollLeft;
+    if (s.scrollLeft = t + 1, s.scrollLeft !== t)
+      return s.scrollLeft = t, !0;
+    s.scrollLeft = t - 1;
+    const n = s.scrollLeft !== t;
+    return s.scrollLeft = t, n;
   }
 }
-function Ot({ children: n, ref: e, ...t }) {
-  const { isActive: a, transitionName: r } = Q(), [s, o] = rt();
-  yt(e, () => s.current);
-  const i = C((d) => d.status), c = $.get(r), { decoratorName: p } = c, { initial: u, variants: h } = j.get(p);
-  return R(() => {
-    if (!s.current) return;
-    const { value: d, options: l } = h[`${i}-${a}`];
-    o(s.current, d, l);
-  }, [i, a, o, h, s]), /* @__PURE__ */ P(
-    at.div,
+function Ht({ children: s, ref: e, ...t }) {
+  const { isActive: a, transitionName: n } = V(), [i, o] = at();
+  St(e, () => i.current);
+  const c = T((r) => r.status), u = Q.get(n), { decoratorName: l } = u, { initial: p, variants: f } = K.get(l);
+  return G(() => {
+    if (!i.current) return;
+    const { value: r, options: g } = f[`${c}-${a}`];
+    o(i.current, r, g);
+  }, [c, a, o, f, i]), /* @__PURE__ */ w(
+    rt.div,
     {
-      ref: s,
-      initial: u,
+      ref: i,
+      initial: p,
       style: {
         position: "absolute",
         top: 0,
@@ -987,114 +1025,117 @@ function Ot({ children: n, ref: e, ...t }) {
     }
   );
 }
-const Y = U((n) => ({
-  transitionStatus: "IDLE",
-  setTransitionStatus: (e) => n({ transitionStatus: e })
+const O = _((s) => ({
+  dragStatus: "IDLE",
+  replaceTransitionStatus: "IDLE",
+  setDragStatus: (e) => s({ dragStatus: e }),
+  setReplaceTransitionStatus: (e) => s({ replaceTransitionStatus: e })
 }));
-function Ht({
-  children: n,
+function Ut({
+  children: s,
   ...e
 }) {
-  const [t, a] = rt(), { id: r, isActive: s, isRoot: o, transitionName: i, prevTransitionName: c } = Q(), p = wt(), u = C((f) => f.status), h = Y((f) => f.transitionStatus), d = Y.getState().setTransitionStatus, l = $.get(i), { variants: w, initial: A, swipeDirection: S, decoratorName: v } = l, E = j.get(v), b = L(null), O = L(null), H = L(null), T = L(!1), G = L(!1), D = L({
+  const [t, a] = at(), { id: n, isActive: i, isRoot: o, transitionName: c, prevTransitionName: u } = V(), l = wt(), p = T((d) => d.status), f = O((d) => d.dragStatus), r = O.getState().setDragStatus, g = O.getState().setReplaceTransitionStatus, P = Q.get(c), { variants: E, initial: h, swipeDirection: m, decoratorName: D } = P, L = K.get(D), H = I(null), U = I(null), $ = I(null), k = I(!1), b = I(!1), v = I({
     element: null,
     hasMarker: !1
-  }), N = L({ element: null, hasMarker: !1 }), V = L(0), W = L(0), ct = async (f, y) => {
-    if (!S)
+  }), M = I({ element: null, hasMarker: !1 }), W = I(0), J = I(0), ut = async (d, y) => {
+    if (!m)
       return;
-    b.current = t.current?.previousSibling, H.current = t.current?.previousSibling?.querySelector("[data-decorator]");
-    const g = await l?.onSwipeStart(f, y, {
+    H.current = t.current?.previousSibling, $.current = t.current?.previousSibling?.querySelector("[data-decorator]");
+    const S = await P?.onSwipeStart(d, y, {
       currentScreen: t.current,
-      prevScreen: b.current,
-      dragControls: p,
-      onStart: (k) => E?.onSwipeStart?.(k, {
-        currentDecorator: O.current,
-        prevDecorator: H.current
+      prevScreen: H.current,
+      dragControls: l,
+      onStart: (C) => L?.onSwipeStart?.(C, {
+        currentDecorator: U.current,
+        prevDecorator: $.current
       })
     });
-    d(g ? "PENDING" : "IDLE");
-  }, ut = (f, y) => {
-    !S || h !== "PENDING" || l?.onSwipe(f, y, {
+    r(S ? "PENDING" : "IDLE");
+  }, lt = (d, y) => {
+    !m || f !== "PENDING" || P?.onSwipe(d, y, {
       currentScreen: t.current,
-      prevScreen: b.current,
-      dragControls: p,
-      onProgress: (g, k) => E?.onSwipe?.(g, k, {
-        currentDecorator: O.current,
-        prevDecorator: H.current
+      prevScreen: H.current,
+      dragControls: l,
+      onProgress: (S, C) => L?.onSwipe?.(S, C, {
+        currentDecorator: U.current,
+        prevDecorator: $.current
       })
     });
-  }, lt = async (f, y) => {
-    if (!S || h !== "PENDING")
+  }, dt = async (d, y) => {
+    if (!m || f !== "PENDING")
       return;
-    await l?.onSwipeEnd(f, y, {
+    await P?.onSwipeEnd(d, y, {
       currentScreen: t.current,
-      prevScreen: b.current,
-      onStart: (k) => E?.onSwipeEnd?.(k, {
-        currentDecorator: O.current,
-        prevDecorator: H.current
+      prevScreen: H.current,
+      onStart: (C) => L?.onSwipeEnd?.(C, {
+        currentDecorator: U.current,
+        prevDecorator: $.current
       })
-    }) ? window.history.back() : d("IDLE");
-  }, dt = (f) => {
-    if (!(!o && s && u === "COMPLETED" && h === "IDLE" && !!S))
+    }) ? window.history.back() : r("IDLE");
+  }, pt = (d) => {
+    if (!(!o && i && p === "COMPLETED" && f === "IDLE" && !!m))
       return;
-    D.current = Z(f.target, {
+    v.current = z(d.target, {
       direction: "x"
-    }), N.current = Z(f.target, {
+    }), M.current = z(d.target, {
       direction: "y"
-    }), V.current = f.clientX, W.current = f.clientY, (!D.current.element && !N.current.element || D.current.element || N.current.element) && (T.current = !0);
-  }, pt = (f) => {
-    const y = !D.current.element && !N.current.element;
-    if (T.current && y)
-      T.current = !1, G.current = !0, p.start(f);
-    else if (T.current && !y) {
-      const g = f.clientX - V.current, k = f.clientY - W.current, ht = N.current.element && N.current.element.scrollTop <= 0 && N.current.hasMarker, mt = D.current.element && D.current.element.scrollLeft <= 0 && D.current.hasMarker;
-      (S === "y" && (ht || D.current.element) && k > 0 && Math.abs(g) < 4 || S === "x" && (mt || N.current.element) && g > 0 && Math.abs(k) < 4) && (T.current = !1, G.current = !0, p.start(f));
+    }), W.current = d.clientX, J.current = d.clientY, (!v.current.element && !M.current.element || v.current.element || M.current.element) && (k.current = !0);
+  }, ft = (d) => {
+    const y = !v.current.element && !M.current.element;
+    if (k.current && y)
+      k.current = !1, b.current = !0, l.start(d);
+    else if (k.current && !y) {
+      const S = d.clientX - W.current, C = d.clientY - J.current, gt = M.current.element && M.current.element.scrollTop <= 0 && M.current.hasMarker, mt = v.current.element && v.current.element.scrollLeft <= 0 && v.current.hasMarker;
+      (m === "y" && (gt || v.current.element) && C > 0 && Math.abs(S) < 4 || m === "x" && (mt || M.current.element) && S > 0 && Math.abs(C) < 4) && (k.current = !1, b.current = !0, l.start(d));
     }
-  }, ft = () => {
-    T.current = !1, G.current = !1;
+  }, ht = () => {
+    k.current = !1, b.current = !1;
   };
-  return R(() => {
-    const f = t.current;
-    if (!f) return;
-    const y = (g) => {
-      G.current && g.preventDefault(), g.target?.dataset.swipeAtEdgeBar === "true" && g.preventDefault();
+  return G(() => {
+    const d = t.current;
+    if (!d) return;
+    const y = (S) => {
+      b.current && S.preventDefault(), S.target?.dataset.swipeAtEdgeBar === "true" && S.preventDefault();
     };
-    return f.addEventListener("touchmove", y, {
+    return d.addEventListener("touchmove", y, {
       passive: !1
     }), () => {
-      f.removeEventListener("touchmove", y);
+      d.removeEventListener("touchmove", y);
     };
-  }, [t]), R(() => {
+  }, [t]), G(() => {
     t.current && (async () => {
-      const { value: f, options: y } = w[`${u}-${s}`], g = u === "REPLACING" && c !== i;
-      !s && g && (d("PENDING"), await a(t.current, Rt, {
-        duration: 0.01
-      })), await a(t.current, f, y), await m.resolveTask(r), !s && !g && d("IDLE");
+      const { value: d, options: y } = E[`${p}-${i}`], S = u !== c;
+      !i && p === "REPLACING" && S && (g("PENDING"), await a(t.current, At, {
+        duration: 0.1
+      })), await a(t.current, d, y), await N.resolveTask(n), !i && S && g("IDLE"), i && p === "COMPLETED" && r("IDLE");
     })();
   }, [
+    p,
+    i,
+    n,
     u,
-    s,
-    r,
     c,
-    i,
     a,
     t,
-    d,
-    w
-  ]), /* @__PURE__ */ tt(
-    at.div,
+    E,
+    r,
+    g
+  ]), /* @__PURE__ */ et(
+    rt.div,
     {
       ref: t,
       ...e,
-      initial: A,
-      drag: S,
+      initial: h,
+      drag: m,
       dragListener: !1,
-      dragControls: p,
-      onDragStart: ct,
-      onDrag: ut,
-      onDragEnd: lt,
-      onPointerDown: dt,
-      onPointerMove: pt,
-      onPointerUp: ft,
+      dragControls: l,
+      onDragStart: ut,
+      onDrag: lt,
+      onDragEnd: dt,
+      onPointerDown: pt,
+      onPointerMove: ft,
+      onPointerUp: ht,
       style: {
         position: "absolute",
         top: 0,
@@ -1108,10 +1149,11 @@ function Ht({
         touchAction: "none",
         isolation: "isolate",
         contain: "strict",
+        overscrollBehavior: "contain",
         ...e.style
       },
       children: [
-        /* @__PURE__ */ P(
+        /* @__PURE__ */ w(
           "div",
           {
             "data-swipe-at-edge-bar": !0,
@@ -1125,7 +1167,7 @@ function Ht({
             }
           }
         ),
-        /* @__PURE__ */ P(
+        /* @__PURE__ */ w(
           "div",
           {
             style: {
@@ -1135,11 +1177,11 @@ function Ht({
               width: "100%",
               height: "100%"
             },
-            children: n
+            children: s
           }
         ),
-        E && /* @__PURE__ */ P(Ot, { ref: O }),
-        /* @__PURE__ */ P(
+        L && /* @__PURE__ */ w(Ht, { ref: U }),
+        /* @__PURE__ */ w(
           "div",
           {
             "data-swipe-at-edge-bar": !0,
@@ -1157,23 +1199,23 @@ function Ht({
     }
   );
 }
-function Wt({
-  children: n,
+function Jt({
+  children: s,
   ...e
 }) {
-  const { isActive: t, isPrev: a } = Q(), r = C((c) => c.status), s = Y((c) => c.transitionStatus);
-  return /* @__PURE__ */ P(Gt, { freeze: !t && (r === "COMPLETED" && s === "IDLE" || a), children: /* @__PURE__ */ P(Ht, { ...e, children: n }) });
+  const { isActive: t, isPrev: a } = V(), n = T((l) => l.status), i = O((l) => l.dragStatus), o = O((l) => l.replaceTransitionStatus);
+  return /* @__PURE__ */ w(bt, { freeze: !t && (n === "COMPLETED" && i === "IDLE" && o === "IDLE" || a && o === "IDLE"), children: /* @__PURE__ */ w(Ut, { ...e, children: s }) });
 }
 export {
   Xt as Route,
   Yt as Router,
-  Wt as Screen,
-  Nt as createDecorator,
-  Vt as createRawDecorator,
-  Qt as createRawTransition,
-  K as createTransition,
+  Jt as Screen,
+  kt as createDecorator,
+  Wt as createRawDecorator,
+  Vt as createRawTransition,
+  j as createTransition,
   qt as useNavigate,
-  Kt as useParams,
-  Q as useScreen,
-  jt as useStep
+  jt as useParams,
+  V as useScreen,
+  Kt as useStep
 };