flemo 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1041 @@
+import { jsx as P, jsxs as q, Fragment as tt } from "react/jsx-runtime";
+import { useEffect as I, createContext as O, useReducer as et, Children as Y, useContext as b, Suspense as nt, useImperativeHandle as at, useRef as R } from "react";
+import { d as N, c as M } from "./vendor-C8cPYUOQ.js";
+import { animate as st } from "motion";
+import { animate as w, transform as X, useAnimate as j, motion as K, useDragControls as rt } from "motion/react";
+function it(r, e, t) {
+  const a = Array.isArray(r) ? r.find((i) => N.pathToRegexp(i).regexp.test(e)) || "" : N.pathToRegexp(r).regexp.test(e) ? r : "", n = N.match(a)(e), s = new URLSearchParams(t), c = Object.fromEntries(s.entries());
+  return n ? { ...n.params, ...c } : {};
+}
+function B() {
+  return typeof document > "u";
+}
+class ot {
+  tasks = /* @__PURE__ */ new Map();
+  instanceId = Date.now().toString();
+  isLocked = !1;
+  currentTaskId = null;
+  taskQueue = Promise.resolve();
+  signalListeners = /* @__PURE__ */ new Map();
+  // 신호 리스너
+  async acquireLock(e) {
+    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));
+    }
+    return !1;
+  }
+  releaseLock(e) {
+    this.currentTaskId === e && (this.isLocked = !1, this.currentTaskId = null);
+  }
+  generateTaskId() {
+    return `${this.instanceId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  emitSignal(e) {
+    const t = this.signalListeners.get(e);
+    t && (t.forEach((a) => {
+      this.resolveTask(a);
+    }), this.signalListeners.delete(e));
+  }
+  async addTask(e, t = {}) {
+    const a = t.id || this.generateTaskId();
+    return new Promise((n, s) => {
+      this.taskQueue = this.taskQueue.then(async () => {
+        try {
+          const { control: c, validate: i, rollback: p, dependencies: h = [] } = t, o = {
+            id: a,
+            execute: e,
+            timestamp: Date.now(),
+            retryCount: 0,
+            status: "PENDING",
+            dependencies: h,
+            instanceId: this.instanceId,
+            validate: i,
+            rollback: p,
+            control: c
+          };
+          this.tasks.set(o.id, o);
+          try {
+            if (!await this.acquireLock(o.id))
+              throw o.status = "FAILED", new Error("FAILED");
+            try {
+              o.status = "PROCESSING";
+              for (const l of o.dependencies) {
+                const g = this.tasks.get(l);
+                if (!g || g.status !== "COMPLETED")
+                  throw o.status = "FAILED", new Error("FAILED");
+              }
+              if (o.validate && !await o.validate())
+                throw o.status = "FAILED", new Error("FAILED");
+              const u = await o.execute();
+              if (t.control) {
+                const l = t.control;
+                if (l.delay && l.delay > 0 && await new Promise((g) => setTimeout(g, l.delay)), l.manual) {
+                  o.status = "MANUAL_PENDING", o.manualResolver = { resolve: n, reject: s, result: u };
+                  return;
+                }
+                if (l.signal) {
+                  o.status = "MANUAL_PENDING", o.manualResolver = { resolve: n, reject: s, result: u }, this.signalListeners.has(l.signal) || this.signalListeners.set(l.signal, /* @__PURE__ */ new Set()), this.signalListeners.get(l.signal).add(o.id);
+                  return;
+                }
+                if (l.condition && !await l.condition()) {
+                  o.status = "MANUAL_PENDING", o.manualResolver = { resolve: n, reject: s, result: u };
+                  return;
+                }
+              }
+              o.status = "COMPLETED", n({
+                success: !0,
+                result: u,
+                taskId: o.id,
+                timestamp: Date.now(),
+                instanceId: this.instanceId
+              });
+            } catch (u) {
+              if (o.status = "FAILED", o.rollback)
+                try {
+                  await o.rollback(), o.status = "ROLLEDBACK";
+                } catch {
+                }
+              throw u;
+            } finally {
+              this.releaseLock(o.id);
+            }
+          } catch (d) {
+            s(d);
+          }
+        } catch (c) {
+          s(c);
+        }
+      }).catch(s);
+    });
+  }
+  async resolveTask(e) {
+    const t = this.tasks.get(e);
+    if (!t || t.status !== "MANUAL_PENDING")
+      return !1;
+    if (t.manualResolver) {
+      if (t.control?.condition && !await t.control.condition())
+        return !1;
+      t.status = "COMPLETED";
+      const a = t.manualResolver;
+      return a.resolve({
+        success: !0,
+        result: a.result,
+        taskId: t.id,
+        timestamp: Date.now(),
+        instanceId: this.instanceId
+      }), delete t.manualResolver, !0;
+    }
+    return !1;
+  }
+  async resolveAllPending() {
+    const e = Array.from(this.tasks.values()).filter(
+      (t) => ["PENDING", "MANUAL_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 f = new ot(), T = M((r) => ({
+  index: -1,
+  histories: [],
+  addHistory: (e) => r((t) => ({
+    index: t.index + 1,
+    histories: t.histories.concat(e)
+  })),
+  replaceHistory: (e) => r((t) => (t.histories.splice(e, 1), {
+    index: t.index - 1,
+    histories: t.histories
+  })),
+  popHistory: (e) => r((t) => ({
+    index: t.index - 1,
+    histories: t.histories.filter((a, n) => n !== e)
+  }))
+})), k = M((r) => ({
+  status: "IDLE",
+  setStatus: (e) => r({ status: e })
+}));
+function ct() {
+  return I(() => {
+    const r = async (e) => {
+      await f.resolveAllPending();
+      const { index: t, addHistory: a, popHistory: n } = T.getState(), s = k.getState().setStatus, c = e.state?.id, i = e.state?.index, p = e.state?.status, h = e.state?.params, o = e.state?.transitionName, d = i < t, u = p === "PUSHING" && i > t, l = p === "REPLACING" && i > t;
+      d ? (await f.addTask(
+        async () => (s("POPPING"), async () => {
+          n(i + 1), f.getManualPendingTasks().length || s("COMPLETED");
+        }),
+        {
+          id: c,
+          control: {
+            manual: !0
+          }
+        }
+      ))?.result?.() : u ? (await f.addTask(
+        async () => (s("PUSHING"), a({
+          id: c,
+          pathname: window.location.pathname,
+          params: h,
+          transitionName: o
+        }), async () => {
+          f.getManualPendingTasks().length || s("COMPLETED");
+        }),
+        {
+          id: c,
+          control: {
+            manual: !0
+          }
+        }
+      ))?.result?.() : l && (await f.addTask(
+        async () => (s("REPLACING"), a({
+          id: c,
+          pathname: window.location.pathname,
+          params: h,
+          transitionName: o
+        }), async () => {
+          f.getManualPendingTasks().length || s("COMPLETED");
+        }),
+        {
+          id: c,
+          control: {
+            manual: !0
+          }
+        }
+      ))?.result?.();
+    };
+    return window.addEventListener("popstate", r), () => {
+      window.removeEventListener("popstate", r);
+    };
+  }, []), null;
+}
+const Q = O({}), V = O(() => {
+});
+function ut(r, e) {
+  switch (e.type) {
+    case "SET":
+      return e.params;
+    default:
+      return r;
+  }
+}
+function lt({
+  children: r,
+  active: e,
+  params: t
+}) {
+  const [a, n] = et(ut, t);
+  return I(() => {
+    const s = (c) => {
+      c.state?.step && n({ type: "SET", params: c.state?.params || {} });
+    };
+    return e && window.addEventListener("popstate", s), () => {
+      window.removeEventListener("popstate", s);
+    };
+  }, [e, n]), /* @__PURE__ */ P(V.Provider, { value: n, children: /* @__PURE__ */ P(Q.Provider, { value: a, children: r }) });
+}
+const W = O({
+  id: "",
+  isActive: !1,
+  isRoot: !0,
+  isPrev: !1,
+  zIndex: 0,
+  pathname: "",
+  params: {},
+  transitionName: "none",
+  prevTransitionName: "none"
+});
+function dt({ children: r }) {
+  const e = T((a) => a.index), t = T((a) => a.histories);
+  return t.map(
+    (a) => Y.toArray(r).filter(
+      (n) => N.pathToRegexp(n.props.path).regexp.test(
+        a.pathname
+      )
+    )
+  ).map(([a], n) => /* @__PURE__ */ P(
+    W.Provider,
+    {
+      value: {
+        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(lt, { active: n === e, params: t[n].params, children: a })
+    },
+    t[n].id
+  ));
+}
+function pt({
+  name: r,
+  initial: e,
+  enter: t,
+  exit: a,
+  options: n
+}) {
+  return {
+    name: r,
+    initial: e,
+    variants: {
+      "IDLE-true": t,
+      "IDLE-false": t,
+      "PUSHING-false": a,
+      "PUSHING-true": t,
+      "REPLACING-false": a,
+      "REPLACING-true": t,
+      "POPPING-false": t,
+      "POPPING-true": t,
+      "COMPLETED-false": a,
+      "COMPLETED-true": t
+    },
+    ...n
+  };
+}
+const ft = pt({
+  name: "overlay",
+  initial: {
+    opacity: 0,
+    backgroundColor: "rgba(0, 0, 0, 0)",
+    transition: {
+      duration: 0
+    }
+  },
+  enter: {
+    value: {
+      opacity: 0,
+      backgroundColor: "rgba(0, 0, 0, 0.3)"
+    },
+    options: {
+      duration: 0.3
+    }
+  },
+  exit: {
+    value: {
+      opacity: 1,
+      backgroundColor: "rgba(0, 0, 0, 0.3)"
+    },
+    options: {
+      duration: 0.3
+    }
+  },
+  options: {
+    onSwipe: (r, { prevDecorator: e }) => st(
+      e,
+      {
+        opacity: Math.max(0, 1 - r / 100)
+      },
+      {
+        duration: 0
+      }
+    )
+  }
+}), H = /* @__PURE__ */ new Map([["overlay", ft]]), C = M((r) => ({
+  defaultTransitionName: "cupertino",
+  setDefaultTransitionName: (e) => r({ defaultTransitionName: e })
+}));
+function U({
+  name: r,
+  initial: e,
+  idle: t,
+  enter: a,
+  enterBack: n,
+  exit: s,
+  exitBack: c,
+  options: i
+}) {
+  return {
+    name: r,
+    initial: e,
+    variants: {
+      "IDLE-true": t,
+      "IDLE-false": t,
+      "PUSHING-false": s,
+      "PUSHING-true": a,
+      "REPLACING-false": s,
+      "REPLACING-true": a,
+      "POPPING-false": c,
+      "POPPING-true": n,
+      "COMPLETED-false": s,
+      "COMPLETED-true": a
+    },
+    ...i
+  };
+}
+const ht = U({
+  name: "cupertino",
+  initial: {
+    x: "100%",
+    transition: {
+      duration: 0
+    }
+  },
+  idle: {
+    value: {
+      x: 0
+    },
+    options: {
+      duration: 0
+    }
+  },
+  enter: {
+    value: {
+      x: 0
+    },
+    options: {
+      duration: 0.3,
+      ease: [0.32, 0.72, 0, 1]
+    }
+  },
+  enterBack: {
+    value: {
+      x: "100%"
+    },
+    options: {
+      duration: 0.3,
+      ease: [0.32, 0.72, 0, 1]
+    }
+  },
+  exit: {
+    value: {
+      x: -100
+    },
+    options: {
+      duration: 0.3,
+      ease: [0.32, 0.72, 0, 1]
+    }
+  },
+  exitBack: {
+    value: {
+      x: 0
+    },
+    options: {
+      duration: 0.3,
+      ease: [0.32, 0.72, 0, 1]
+    }
+  },
+  options: {
+    decoratorName: "overlay",
+    swipeDirection: "x",
+    onSwipeStart: async (r, e, { currentScreen: t, dragControls: a }) => {
+      const { offset: n } = e;
+      n.x < 0 && (a.stop(), w(
+        t,
+        {
+          x: 0
+        },
+        {
+          duration: 0.3
+        }
+      ));
+    },
+    onSwipe: (r, e, { currentScreen: t, prevScreen: a }) => {
+      const { offset: n } = e, s = n.x, c = X(s, [0, window.innerWidth], [0, 100]);
+      return w(
+        t,
+        {
+          x: Math.max(0, s)
+        },
+        {
+          duration: 0
+        }
+      ), w(
+        a,
+        {
+          x: -100 + c
+        },
+        {
+          duration: 0
+        }
+      ), c;
+    },
+    onSwipeEnd: async (r, e, { currentScreen: t, prevScreen: a }) => {
+      const { offset: n, velocity: s } = e, i = n.x > 50 || s.x > 20;
+      return w(
+        t,
+        {
+          x: i ? "100%" : 0
+        },
+        {
+          duration: 0.3,
+          ease: [0.32, 0.72, 0, 1]
+        }
+      ), w(
+        a,
+        {
+          x: i ? 0 : -100
+        },
+        {
+          duration: 0.3,
+          ease: [0.32, 0.72, 0, 1]
+        }
+      ), i;
+    }
+  }
+}), mt = U({
+  name: "material",
+  initial: {
+    y: "100%",
+    opacity: 0.96,
+    transition: {
+      duration: 0
+    }
+  },
+  idle: {
+    value: {
+      y: 0,
+      opacity: 1
+    },
+    options: {
+      duration: 0
+    }
+  },
+  enter: {
+    value: {
+      y: 0,
+      opacity: 1
+    },
+    options: {
+      duration: 0.24,
+      ease: [0, 0, 0.2, 1]
+    }
+  },
+  enterBack: {
+    value: {
+      y: "100%",
+      opacity: 0.96
+    },
+    options: {
+      duration: 0.22,
+      ease: [0.4, 0, 1, 1]
+    }
+  },
+  exit: {
+    value: {
+      y: -56,
+      opacity: 0.96
+    },
+    options: {
+      duration: 0.22,
+      ease: [0.4, 0, 1, 1]
+    }
+  },
+  exitBack: {
+    value: {
+      y: 0,
+      opacity: 1
+    },
+    options: {
+      duration: 0.24,
+      ease: [0, 0, 0.2, 1]
+    }
+  },
+  options: {
+    swipeDirection: "y",
+    onSwipeStart: async (r, e, { currentScreen: t, dragControls: a }) => {
+      const { offset: n } = e;
+      n.y < 0 && (a.stop(), w(
+        t,
+        {
+          y: 0,
+          opacity: 1
+        },
+        {
+          duration: 0.24
+        }
+      ));
+    },
+    onSwipe: (r, e, { currentScreen: t, prevScreen: a }) => {
+      const { offset: n } = e, s = n.y, c = Math.max(0, Math.min(56, s)), i = X(c, [0, 56], [1, 0.96]), p = Math.max(0, s - 56), h = Math.min(1, p / 160), o = Math.sqrt(h) * 12, d = Math.max(0, c + o), u = Math.min(56, d);
+      return w(
+        t,
+        {
+          y: d,
+          opacity: i
+        },
+        {
+          duration: 0
+        }
+      ), w(
+        a,
+        {
+          y: -56 + u,
+          opacity: u / 56
+        },
+        { duration: 0 }
+      ), u;
+    },
+    onSwipeEnd: async (r, e, { currentScreen: t, prevScreen: a }) => {
+      const { offset: n, velocity: s } = e, i = n.y > 56 || s.y > 20;
+      return await Promise.all([
+        w(
+          t,
+          {
+            y: i ? "100%" : 0,
+            opacity: i ? 0.96 : 1
+          },
+          {
+            duration: i ? 0.22 : 0.24,
+            ease: i ? [0.4, 0, 1, 1] : [0, 0, 0.2, 1]
+          }
+        ),
+        w(
+          a,
+          {
+            y: i ? 0 : -56,
+            opacity: i ? 1 : 0.96
+          },
+          {
+            duration: i ? 0.22 : 0.24,
+            ease: i ? [0, 0, 0.2, 1] : [0.4, 0, 1, 1]
+          }
+        )
+      ]), i;
+    }
+  }
+}), Pt = U({
+  name: "none",
+  initial: {
+    transition: {
+      duration: 0
+    }
+  },
+  idle: {
+    value: {},
+    options: {
+      duration: 0
+    }
+  },
+  enter: {
+    value: {},
+    options: {
+      duration: 0
+    }
+  },
+  enterBack: {
+    value: {},
+    options: {
+      duration: 0
+    }
+  },
+  exit: {
+    value: {},
+    options: {
+      duration: 0
+    }
+  },
+  exitBack: {
+    value: {},
+    options: {
+      duration: 0
+    }
+  }
+}), A = /* @__PURE__ */ new Map([
+  ["none", Pt],
+  ["cupertino", ht],
+  ["material", mt]
+]), gt = (() => {
+  const r = /* @__PURE__ */ Object.create(null), e = Object.prototype.hasOwnProperty;
+  for (const t of A.values()) {
+    const a = t.variants["IDLE-true"].value;
+    for (const n in a)
+      e.call(a, n) && (r[n] = a[n]);
+  }
+  return r;
+})();
+function kt({
+  children: r,
+  initPath: e = "/",
+  defaultTransitionName: t = "cupertino",
+  transitions: a = [],
+  decorators: n = []
+}) {
+  const s = B() ? e || "/" : window.location.pathname, c = B() ? s.split("?")[1] || "" : window.location.search;
+  return C.setState({
+    defaultTransitionName: t
+  }), T.setState({
+    index: 0,
+    histories: [
+      {
+        id: "root",
+        pathname: s,
+        params: it(
+          Y.toArray(r).map((i) => i.props.path).flat(),
+          s,
+          c
+        ),
+        transitionName: t
+      }
+    ]
+  }), I(() => {
+    a.forEach((i) => A.set(i.name, i));
+  }, [a]), I(() => {
+    n.forEach((i) => H.set(i.name, i));
+  }, [n]), /* @__PURE__ */ q(tt, { children: [
+    /* @__PURE__ */ P(ct, {}),
+    /* @__PURE__ */ P(dt, { children: r })
+  ] });
+}
+function xt({ element: r }) {
+  return r;
+}
+function Mt() {
+  return {
+    push: async (a, n, s = {}) => {
+      if (f.getManualPendingTasks().length)
+        return;
+      const { index: c, addHistory: i } = T.getState(), p = k.getState().setStatus, h = C.getState().defaultTransitionName, { transitionName: o = h } = s, d = f.generateTaskId();
+      (await f.addTask(
+        async () => {
+          p("PUSHING");
+          const u = N.compile(a)(n), l = N.parse(a).tokens.filter((E) => E.type === "param").map((E) => E.name), g = Object.fromEntries(
+            Object.entries(n).filter(([E]) => !l.includes(E))
+          ), D = new URLSearchParams(g).toString(), S = `${u}${D ? `?${D}` : ""}`;
+          return window.history.state?.id || window.history.replaceState(
+            {
+              id: "root",
+              index: 0,
+              status: "IDLE",
+              params: {},
+              transitionName: o
+            },
+            "",
+            window.location.pathname
+          ), window.history.pushState(
+            {
+              id: d,
+              index: c + 1,
+              status: "PUSHING",
+              params: n,
+              transitionName: o
+            },
+            "",
+            S
+          ), i({
+            id: d,
+            pathname: u,
+            params: n,
+            transitionName: o
+          }), () => {
+            f.getManualPendingTasks().length || p("COMPLETED");
+          };
+        },
+        {
+          id: d,
+          control: {
+            manual: !0
+          }
+        }
+      )).result?.();
+    },
+    replace: async (a, n, s = {}) => {
+      if (f.getManualPendingTasks().length)
+        return;
+      const { index: c, addHistory: i } = T.getState(), p = T.getState().replaceHistory, h = k.getState().setStatus, o = C.getState().defaultTransitionName, { transitionName: d = o } = s, u = f.generateTaskId();
+      (await f.addTask(
+        async () => {
+          h("REPLACING");
+          const l = N.compile(a)(n), g = N.parse(a).tokens.filter((v) => v.type === "param").map((v) => v.name), D = Object.fromEntries(
+            Object.entries(n).filter(([v]) => !g.includes(v))
+          ), S = new URLSearchParams(D).toString(), E = `${l}${S ? `?${S}` : ""}`;
+          return window.history.replaceState(
+            {
+              id: u,
+              index: c,
+              status: "REPLACING",
+              params: n,
+              transitionName: d
+            },
+            "",
+            E
+          ), i({
+            id: u,
+            pathname: l,
+            params: n,
+            transitionName: d
+          }), async () => {
+            await f.addTask(async () => p(c)), f.getManualPendingTasks().length || h("COMPLETED");
+          };
+        },
+        {
+          id: u,
+          control: {
+            manual: !0
+          }
+        }
+      )).result?.();
+    },
+    pop: () => {
+      f.getManualPendingTasks().length || window.history.back();
+    }
+  };
+}
+function At() {
+  const r = b(V);
+  return {
+    pushStep: async (n) => {
+      f.getManualPendingTasks().length || (await f.addTask(async () => {
+        const s = new URLSearchParams(n).toString(), c = `${window.location.pathname}${s ? `?${s}` : ""}`;
+        return window.history.state?.step || window.history.replaceState(
+          {
+            ...window.history.state,
+            step: !0
+          },
+          "",
+          window.location.pathname
+        ), window.history.pushState(
+          {
+            ...window.history.state,
+            step: !0,
+            params: n
+          },
+          "",
+          c
+        ), async () => r({ type: "SET", params: n });
+      })).result?.();
+    },
+    replaceStep: async (n) => {
+      f.getManualPendingTasks().length || (await f.addTask(async () => {
+        const s = new URLSearchParams(n).toString(), c = `${window.location.pathname}${s ? `?${s}` : ""}`;
+        return window.history.replaceState(
+          {
+            ...window.history.state,
+            step: !0,
+            params: n
+          },
+          "",
+          c
+        ), async () => r({ type: "SET", params: n });
+      })).result?.();
+    },
+    popStep: () => {
+      f.getManualPendingTasks().length || window.history.back();
+    }
+  };
+}
+function $() {
+  return b(W);
+}
+function Rt() {
+  return b(Q);
+}
+function Ct({
+  name: r,
+  initial: e,
+  idle: t,
+  pushOnEnter: a,
+  pushOnExit: n,
+  replaceOnEnter: s,
+  replaceOnExit: c,
+  popOnEnter: i,
+  popOnExit: p,
+  completedOnExit: h,
+  completedOnEnter: o,
+  options: d
+}) {
+  return {
+    name: r,
+    initial: e,
+    variants: {
+      "IDLE-true": t,
+      "IDLE-false": t,
+      "PUSHING-false": n,
+      "PUSHING-true": a,
+      "REPLACING-false": c,
+      "REPLACING-true": s,
+      "POPPING-false": p,
+      "POPPING-true": i,
+      "COMPLETED-false": h,
+      "COMPLETED-true": o
+    },
+    ...d
+  };
+}
+function Gt({
+  name: r,
+  initial: e,
+  idle: t,
+  pushOnEnter: a,
+  pushOnExit: n,
+  replaceOnEnter: s,
+  replaceOnExit: c,
+  popOnEnter: i,
+  popOnExit: p,
+  completedOnEnter: h,
+  completedOnExit: o,
+  options: d
+}) {
+  return {
+    name: r,
+    initial: e,
+    variants: {
+      "IDLE-true": t,
+      "IDLE-false": t,
+      "PUSHING-false": n,
+      "PUSHING-true": a,
+      "REPLACING-false": c,
+      "REPLACING-true": s,
+      "POPPING-false": p,
+      "POPPING-true": i,
+      "COMPLETED-false": o,
+      "COMPLETED-true": h
+    },
+    ...d
+  };
+}
+const yt = { then() {
+} };
+function wt({
+  freeze: r,
+  children: e
+}) {
+  if (r)
+    throw yt;
+  return e;
+}
+function St({ freeze: r, children: e, placeholder: t }) {
+  return /* @__PURE__ */ P(nt, { fallback: t, children: /* @__PURE__ */ P(wt, { freeze: r, children: e }) });
+}
+function Et({ children: r, ref: e, ...t }) {
+  const { isActive: a, transitionName: n } = $(), [s, c] = j();
+  at(e, () => s.current);
+  const i = k((u) => u.status), p = A.get(n), { decoratorName: h } = p, { initial: o, variants: d } = H.get(h);
+  return I(() => {
+    if (!s.current) return;
+    const { value: u, options: l } = d[`${i}-${a}`];
+    c(s.current, u, l);
+  }, [i, a, c, d, s]), /* @__PURE__ */ P(
+    K.div,
+    {
+      ref: s,
+      initial: o,
+      style: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width: "100%",
+        height: "100%",
+        pointerEvents: "none",
+        ...t.style
+      },
+      "data-decorator": !0
+    }
+  );
+}
+const G = M((r) => ({
+  transitionStatus: "IDLE",
+  setTransitionStatus: (e) => r({ transitionStatus: e })
+}));
+function vt({ children: r, ...e }) {
+  const [t, a] = j(), { id: n, isActive: s, isRoot: c, transitionName: i, prevTransitionName: p } = $(), h = rt(), o = k((m) => m.status), d = G((m) => m.transitionStatus), u = G.getState().setTransitionStatus, l = A.get(i), { variants: g, initial: D, swipeDirection: S, decoratorName: E } = l, v = H.get(E), x = R(null), _ = R(null), F = R(null), J = async (m, y) => {
+    S && (x.current = t.current?.previousSibling, F.current = t.current?.previousSibling?.querySelector("& > [data-decorator]"), l?.onSwipeStart(m, y, {
+      currentScreen: t.current,
+      prevScreen: x.current,
+      dragControls: h
+    }), u("PENDING"));
+  }, Z = (m, y) => {
+    if (!S || d !== "PENDING")
+      return;
+    const L = l?.onSwipe(m, y, {
+      currentScreen: t.current,
+      prevScreen: x.current,
+      dragControls: h
+    });
+    v?.onSwipe?.(L, {
+      currentDecorator: _.current,
+      prevDecorator: F.current
+    });
+  }, z = async (m, y) => {
+    if (!S || d !== "PENDING")
+      return;
+    await l?.onSwipeEnd(m, y, {
+      currentScreen: t.current,
+      prevScreen: x.current
+    }) ? window.history.back() : u("IDLE");
+  };
+  return I(() => {
+    const m = t.current;
+    if (!m) return;
+    const y = (L) => L.preventDefault();
+    return m.addEventListener("touchmove", y), () => {
+      m.removeEventListener("touchmove", y);
+    };
+  }, [t]), I(() => {
+    t.current && (async () => {
+      const { value: m, options: y } = g[`${o}-${s}`], L = o === "REPLACING" && p !== i;
+      !s && L && (u("PENDING"), await a(t.current, gt, {
+        duration: 0.01
+      })), await a(t.current, m, y), await f.resolveTask(n), !s && !L && u("IDLE");
+    })();
+  }, [
+    o,
+    s,
+    n,
+    p,
+    i,
+    a,
+    t,
+    u,
+    g
+  ]), /* @__PURE__ */ q(
+    K.div,
+    {
+      ref: t,
+      initial: D,
+      drag: S,
+      dragListener: !c && s && o === "COMPLETED" && d === "IDLE",
+      dragControls: h,
+      onDragStart: J,
+      onDrag: Z,
+      onDragEnd: z,
+      style: {
+        position: "absolute",
+        top: 0,
+        left: 0,
+        width: "100%",
+        height: "100%",
+        backgroundColor: "white",
+        ...e.style
+      },
+      children: [
+        /* @__PURE__ */ P(
+          "div",
+          {
+            style: {
+              position: "absolute",
+              top: 0,
+              left: 0,
+              width: "100%",
+              height: "100%"
+            },
+            children: r
+          }
+        ),
+        v && /* @__PURE__ */ P(Et, { ref: _ })
+      ]
+    }
+  );
+}
+function Ot({ children: r, ...e }) {
+  const { isActive: t, isPrev: a } = $(), n = k((p) => p.status), s = G((p) => p.transitionStatus);
+  return /* @__PURE__ */ P(St, { freeze: !t && (n === "COMPLETED" && s === "IDLE" || a), children: /* @__PURE__ */ P(vt, { ...e, children: r }) });
+}
+export {
+  xt as Route,
+  kt as Router,
+  Ot as Screen,
+  pt as createDecorator,
+  Gt as createRawDecorator,
+  Ct as createRawTransition,
+  U as createTransition,
+  Mt as useNavigate,
+  Rt as useParams,
+  $ as useScreen,
+  At as useStep
+};