@flemo/core 1.0.0

package/dist/index.mjs

@@ -0,0 +1,965 @@
+import { create as D } from "zustand";
+import { pathToRegexp as w, match as H } from "path-to-regexp";
+class U {
+  tasks = /* @__PURE__ */ new Map();
+  instanceId = Date.now().toString();
+  isLocked = !1;
+  currentTaskId = null;
+  taskQueue = Promise.resolve();
+  signalListeners = /* @__PURE__ */ new Map();
+  pendingTaskQueue = [];
+  isProcessingPending = !1;
+  async acquireLock(t) {
+    for (let a = 0; a < 10; a++) {
+      if (!this.isLocked)
+        return this.isLocked = !0, this.currentTaskId = t, !0;
+      await new Promise((r) => setTimeout(r, 100));
+    }
+    return !1;
+  }
+  releaseLock(t) {
+    this.currentTaskId === t && (this.isLocked = !1, this.currentTaskId = null);
+  }
+  generateTaskId() {
+    return `${this.instanceId}-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  emitSignal(t) {
+    const e = this.signalListeners.get(t);
+    e && (e.forEach((s) => {
+      this.resolveTask(s);
+    }), this.signalListeners.delete(t));
+  }
+  // 대기 중인 태스크들을 처리하는 메서드
+  async processPendingTasks() {
+    if (!(this.isProcessingPending || this.pendingTaskQueue.length === 0)) {
+      this.isProcessingPending = !0;
+      try {
+        for (; this.pendingTaskQueue.length > 0; ) {
+          const t = this.pendingTaskQueue[0];
+          if (t.status === "COMPLETED" || t.status === "FAILED" || t.status === "ROLLEDBACK") {
+            this.pendingTaskQueue.shift();
+            continue;
+          }
+          if (t.status === "MANUAL_PENDING" || t.status === "SIGNAL_PENDING" || t.status === "PROCESSING" || t.status === "PENDING")
+            break;
+        }
+      } finally {
+        this.isProcessingPending = !1;
+      }
+    }
+  }
+  // 모든 대기 중인 태스크가 완료될 때까지 대기
+  async waitForPendingTasks() {
+    return new Promise((t) => {
+      const e = () => {
+        this.pendingTaskQueue.filter(
+          (a) => a.status === "MANUAL_PENDING" || a.status === "SIGNAL_PENDING"
+        ).length === 0 ? t() : setTimeout(e, 100);
+      };
+      e();
+    });
+  }
+  // 태스크 상태 변경 시 대기 큐 처리
+  async onTaskStatusChange(t, e) {
+    (e === "COMPLETED" || e === "FAILED" || e === "ROLLEDBACK") && (this.pendingTaskQueue = this.pendingTaskQueue.filter((s) => s.id !== t), await this.processPendingTasks());
+  }
+  async addTask(t, e = {}) {
+    const s = e.id || this.generateTaskId();
+    return new Promise((a, r) => {
+      this.taskQueue = this.taskQueue.then(async () => {
+        try {
+          const { control: i, validate: c, rollback: l, dependencies: u = [], delay: d } = e, h = new AbortController(), o = {
+            id: s,
+            execute: t,
+            timestamp: Date.now(),
+            retryCount: 0,
+            status: "PENDING",
+            dependencies: u,
+            instanceId: this.instanceId,
+            validate: c,
+            rollback: l,
+            control: i,
+            abortController: h
+          };
+          this.tasks.set(o.id, o), this.pendingTaskQueue.length > 0 && (this.pendingTaskQueue.push(o), await this.waitForPendingTasks(), this.pendingTaskQueue = this.pendingTaskQueue.filter((P) => P.id !== o.id));
+          try {
+            if (!await this.acquireLock(o.id))
+              throw o.status = "FAILED", new Error("FAILED");
+            try {
+              o.status = "PROCESSING";
+              for (const f of o.dependencies) {
+                const y = this.tasks.get(f);
+                if (!y || y.status !== "COMPLETED")
+                  throw o.status = "FAILED", new Error("FAILED");
+              }
+              if (o.validate && !await o.validate())
+                throw o.status = "FAILED", new Error("FAILED");
+              d && d > 0 && await new Promise((f) => setTimeout(f, d));
+              const m = await o.execute(o.abortController);
+              if (o.abortController.signal.aborted) {
+                o.status = "COMPLETED", await this.onTaskStatusChange(o.id, "COMPLETED"), a({
+                  success: !0,
+                  result: void 0,
+                  taskId: o.id,
+                  timestamp: Date.now(),
+                  instanceId: this.instanceId
+                });
+                return;
+              }
+              if (e.control) {
+                const f = e.control;
+                if (f.delay && f.delay > 0 && await new Promise((y) => setTimeout(y, f.delay)), f.manual) {
+                  o.status = "MANUAL_PENDING", o.manualResolver = { resolve: a, reject: r, result: m }, this.pendingTaskQueue.push(o), await this.onTaskStatusChange(o.id, "MANUAL_PENDING");
+                  return;
+                }
+                if (f.signal) {
+                  o.status = "SIGNAL_PENDING", o.manualResolver = { resolve: a, reject: r, result: m }, this.signalListeners.has(f.signal) || this.signalListeners.set(f.signal, /* @__PURE__ */ new Set()), this.signalListeners.get(f.signal).add(o.id), this.pendingTaskQueue.push(o), await this.onTaskStatusChange(o.id, "SIGNAL_PENDING");
+                  return;
+                }
+                if (f.condition && !await f.condition()) {
+                  o.status = "MANUAL_PENDING", o.manualResolver = { resolve: a, reject: r, result: m }, this.pendingTaskQueue.push(o), await this.onTaskStatusChange(o.id, "MANUAL_PENDING");
+                  return;
+                }
+              }
+              o.status = "COMPLETED", await this.onTaskStatusChange(o.id, "COMPLETED"), a({
+                success: !0,
+                result: m,
+                taskId: o.id,
+                timestamp: Date.now(),
+                instanceId: this.instanceId
+              });
+            } catch (m) {
+              if (o.status = "FAILED", o.rollback)
+                try {
+                  await o.rollback(), o.status = "ROLLEDBACK";
+                } catch {
+                }
+              throw await this.onTaskStatusChange(o.id, o.status), m;
+            } finally {
+              this.releaseLock(o.id);
+            }
+          } catch (P) {
+            r(P);
+          }
+        } catch (i) {
+          r(i);
+        }
+      }).catch(r);
+    });
+  }
+  async resolveTask(t) {
+    const e = this.tasks.get(t);
+    if (!e || e.status !== "MANUAL_PENDING" && e.status !== "SIGNAL_PENDING")
+      return !1;
+    if (e.manualResolver) {
+      if (e.control?.condition && !await e.control.condition())
+        return !1;
+      e.status = "COMPLETED";
+      const s = e.manualResolver;
+      return s.resolve({
+        success: !0,
+        result: s.result,
+        taskId: e.id,
+        timestamp: Date.now(),
+        instanceId: this.instanceId
+      }), delete e.manualResolver, await this.onTaskStatusChange(t, "COMPLETED"), !0;
+    }
+    return !1;
+  }
+  async resolveAllPending() {
+    const t = Array.from(this.tasks.values()).filter(
+      (e) => ["PENDING", "MANUAL_PENDING", "SIGNAL_PENDING"].includes(e.status)
+    );
+    await Promise.all(t.map((e) => this.resolveTask(e.id)));
+  }
+}
+const ut = new U(), lt = D((n) => ({
+  index: -1,
+  histories: [],
+  addHistory: (t) => n((e) => ({
+    index: e.index + 1,
+    histories: e.histories.concat(t)
+  })),
+  replaceHistory: (t) => n((e) => (e.histories.splice(t, 1), {
+    index: e.index - 1,
+    histories: e.histories
+  })),
+  popHistory: (t) => n((e) => ({
+    index: e.index - 1,
+    histories: e.histories.filter((s, a) => a !== t)
+  }))
+})), ft = D((n) => ({
+  status: "IDLE",
+  transitionTaskId: null,
+  setStatus: (t) => n({ status: t }),
+  setTransitionTaskId: (t) => n({ transitionTaskId: t })
+}));
+let N = 0;
+function dt() {
+  N += 1;
+}
+function ht() {
+  return N > 0 ? (N -= 1, !0) : !1;
+}
+function k({
+  name: n,
+  initial: t,
+  idle: e,
+  enter: s,
+  enterBack: a,
+  exit: r,
+  exitBack: i,
+  options: c
+}) {
+  return {
+    name: n,
+    initial: t,
+    variants: {
+      "IDLE-true": e,
+      "IDLE-false": e,
+      "PUSHING-false": r,
+      "PUSHING-true": s,
+      "REPLACING-false": r,
+      "REPLACING-true": s,
+      "POPPING-false": i,
+      "POPPING-true": a,
+      "COMPLETED-false": r,
+      "COMPLETED-true": s
+    },
+    ...c
+  };
+}
+function mt({
+  name: n,
+  initial: t,
+  idle: e,
+  pushOnEnter: s,
+  pushOnExit: a,
+  replaceOnEnter: r,
+  replaceOnExit: i,
+  popOnEnter: c,
+  popOnExit: l,
+  completedOnExit: u,
+  completedOnEnter: d,
+  options: h
+}) {
+  return {
+    name: n,
+    initial: t,
+    variants: {
+      "IDLE-true": e,
+      "IDLE-false": e,
+      "PUSHING-false": a,
+      "PUSHING-true": s,
+      "REPLACING-false": i,
+      "REPLACING-true": r,
+      "POPPING-false": l,
+      "POPPING-true": c,
+      "COMPLETED-false": u,
+      "COMPLETED-true": d
+    },
+    ...h
+  };
+}
+const Y = (n, t, e) => {
+  const [s, a] = t, [r, i] = e;
+  if (a === s) return r;
+  const c = (n - s) / (a - s);
+  return r + c * (i - r);
+}, B = k({
+  name: "cupertino",
+  initial: {
+    x: "100%"
+  },
+  idle: {
+    value: {
+      x: 0
+    },
+    options: {
+      duration: 0
+    }
+  },
+  enter: {
+    value: {
+      x: 0
+    },
+    options: {
+      duration: 0.7,
+      ease: [0.32, 0.72, 0, 1]
+    }
+  },
+  enterBack: {
+    value: {
+      x: "100%"
+    },
+    options: {
+      duration: 0.6,
+      ease: [0.32, 0.72, 0, 1]
+    }
+  },
+  exit: {
+    value: {
+      x: -100
+    },
+    options: {
+      duration: 0.7,
+      ease: [0.32, 0.72, 0, 1]
+    }
+  },
+  exitBack: {
+    value: {
+      x: 0
+    },
+    options: {
+      duration: 0.6,
+      ease: [0.32, 0.72, 0, 1]
+    }
+  },
+  options: {
+    decoratorName: "overlay",
+    swipeDirection: "x",
+    onSwipeStart: async () => !0,
+    onSwipe: (n, t, { animate: e, currentScreen: s, prevScreen: a, onProgress: r }) => {
+      const { offset: i } = t, c = i.x, l = Y(c, [0, window.innerWidth], [0, 100]);
+      return r?.(!0, l), e(
+        s,
+        {
+          x: Math.max(0, c)
+        },
+        {
+          duration: 0
+        }
+      ), e(
+        a,
+        {
+          x: -100 + l
+        },
+        {
+          duration: 0
+        }
+      ), l;
+    },
+    onSwipeEnd: async (n, t, { animate: e, currentScreen: s, prevScreen: a, onStart: r }) => {
+      const { offset: i, velocity: c } = t, u = i.x > 50 || c.x > 20;
+      return r?.(u), await Promise.all([
+        e(
+          s,
+          {
+            x: u ? "100%" : 0
+          },
+          {
+            duration: 0.3,
+            ease: [0.32, 0.72, 0, 1]
+          }
+        ),
+        e(
+          a,
+          {
+            x: u ? 0 : -100
+          },
+          {
+            duration: 0.3,
+            ease: [0.32, 0.72, 0, 1]
+          }
+        )
+      ]), u;
+    }
+  }
+}), Q = (n, t, e) => {
+  const [s, a] = t, [r, i] = e;
+  if (a === s) return r;
+  const c = (n - s) / (a - s);
+  return r + c * (i - r);
+}, X = k({
+  name: "layout",
+  initial: {
+    opacity: 0.97
+  },
+  idle: {
+    value: {
+      opacity: 1
+    },
+    options: {
+      duration: 0.3
+    }
+  },
+  enter: {
+    value: {
+      opacity: 1
+    },
+    options: {
+      duration: 0.3
+    }
+  },
+  enterBack: {
+    value: {
+      opacity: 0.97
+    },
+    options: {
+      duration: 0.3
+    }
+  },
+  exit: {
+    value: {
+      opacity: 0.97
+    },
+    options: {
+      duration: 0.3
+    }
+  },
+  exitBack: {
+    value: {
+      opacity: 1
+    },
+    options: {
+      duration: 0.3
+    }
+  },
+  options: {
+    decoratorName: "overlay",
+    swipeDirection: "y",
+    onSwipeStart: async () => !0,
+    onSwipe: (n, t, { animate: e, currentScreen: s, onProgress: a }) => {
+      const { offset: r } = t, i = r.y, c = Math.max(0, Math.min(56, i)), l = Q(c, [0, 56], [1, 0.96]), u = Math.max(0, i - 56), d = Math.min(1, u / 160), h = Math.sqrt(d) * 12, o = Math.max(0, c + h), p = Math.min(56, o);
+      return a?.(!0, 100), e(
+        s,
+        {
+          y: o,
+          opacity: l
+        },
+        {
+          duration: 0
+        }
+      ), p;
+    },
+    onSwipeEnd: async (n, t, { animate: e, currentScreen: s, prevScreen: a, onStart: r }) => {
+      const { offset: i, velocity: c } = t, u = i.y > 56 || c.y > 20;
+      return r?.(u), await Promise.all([
+        e(
+          s,
+          {
+            y: u ? "100%" : 0,
+            opacity: u ? 0.96 : 1
+          },
+          {
+            duration: 0.3
+          }
+        ),
+        e(
+          a,
+          {
+            y: 0,
+            opacity: u ? 1 : 0.97
+          },
+          {
+            duration: 0.3
+          }
+        )
+      ]), u;
+    }
+  }
+}), F = k({
+  name: "material",
+  initial: {
+    y: "100%"
+  },
+  idle: {
+    value: {
+      y: 0
+    },
+    options: {
+      duration: 0
+    }
+  },
+  enter: {
+    value: {
+      y: 0
+    },
+    options: {
+      duration: 0.35,
+      ease: [0, 0, 0.2, 1]
+    }
+  },
+  enterBack: {
+    value: {
+      y: "100%"
+    },
+    options: {
+      duration: 0.25,
+      ease: [0.4, 0, 1, 1]
+    }
+  },
+  exit: {
+    value: {
+      y: -56
+    },
+    options: {
+      duration: 0.35,
+      ease: [0.4, 0, 1, 1]
+    }
+  },
+  exitBack: {
+    value: {
+      y: 0
+    },
+    options: {
+      duration: 0.25,
+      ease: [0, 0, 0.2, 1]
+    }
+  },
+  options: {
+    swipeDirection: "y",
+    onSwipeStart: async () => !0,
+    onSwipe: (n, t, { animate: e, currentScreen: s, prevScreen: a, onProgress: r }) => {
+      const { offset: i } = t, c = i.y, l = Math.max(0, Math.min(56, c)), u = Math.max(0, c - 56), d = Math.min(1, u / 160), h = Math.sqrt(d) * 12, o = Math.max(0, l + h), p = Math.min(56, o);
+      return r?.(!0, p), e(
+        s,
+        {
+          y: o
+        },
+        {
+          duration: 0
+        }
+      ), e(
+        a,
+        {
+          y: -56 + p
+        },
+        { duration: 0 }
+      ), p;
+    },
+    onSwipeEnd: async (n, t, { animate: e, currentScreen: s, prevScreen: a, onStart: r }) => {
+      const { offset: i, velocity: c } = t, u = i.y > 56 || c.y > 20;
+      return r?.(u), await Promise.all([
+        e(
+          s,
+          {
+            y: u ? "100%" : 0
+          },
+          {
+            duration: u ? 0.22 : 0.24,
+            ease: u ? [0.4, 0, 1, 1] : [0, 0, 0.2, 1]
+          }
+        ),
+        e(
+          a,
+          {
+            y: u ? 0 : -56
+          },
+          {
+            duration: u ? 0.22 : 0.24,
+            ease: u ? [0, 0, 0.2, 1] : [0.4, 0, 1, 1]
+          }
+        )
+      ]), u;
+    }
+  }
+}), V = k({
+  name: "none",
+  initial: {},
+  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
+    }
+  }
+}), pt = /* @__PURE__ */ new Map([
+  ["none", V],
+  ["cupertino", B],
+  ["material", F],
+  ["layout", X]
+]), yt = D((n) => ({
+  defaultTransitionName: "cupertino",
+  setDefaultTransitionName: (t) => n({ defaultTransitionName: t })
+}));
+function j({
+  name: n,
+  initial: t,
+  enter: e,
+  exit: s,
+  options: a
+}) {
+  return {
+    name: n,
+    initial: t,
+    variants: {
+      "IDLE-true": e,
+      "IDLE-false": e,
+      "PUSHING-false": s,
+      "PUSHING-true": e,
+      "REPLACING-false": s,
+      "REPLACING-true": e,
+      "POPPING-false": e,
+      "POPPING-true": e,
+      "COMPLETED-false": s,
+      "COMPLETED-true": e
+    },
+    ...a
+  };
+}
+function Pt({
+  name: n,
+  initial: t,
+  idle: e,
+  pushOnEnter: s,
+  pushOnExit: a,
+  replaceOnEnter: r,
+  replaceOnExit: i,
+  popOnEnter: c,
+  popOnExit: l,
+  completedOnEnter: u,
+  completedOnExit: d,
+  options: h
+}) {
+  return {
+    name: n,
+    initial: t,
+    variants: {
+      "IDLE-true": e,
+      "IDLE-false": e,
+      "PUSHING-false": a,
+      "PUSHING-true": s,
+      "REPLACING-false": i,
+      "REPLACING-true": r,
+      "POPPING-false": l,
+      "POPPING-true": c,
+      "COMPLETED-false": d,
+      "COMPLETED-true": u
+    },
+    ...h
+  };
+}
+const z = j({
+  name: "overlay",
+  initial: {
+    opacity: 0,
+    backgroundColor: "rgba(0, 0, 0, 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: {
+    onSwipeStart: (n, { animate: t, prevDecorator: e }) => t(
+      e,
+      {
+        opacity: n ? 1 : 0
+      },
+      {
+        duration: 0.3
+      }
+    ),
+    onSwipe: (n, t, { animate: e, prevDecorator: s }) => e(
+      s,
+      {
+        opacity: Math.max(0, 1 - t / 100)
+      },
+      {
+        duration: 0
+      }
+    ),
+    onSwipeEnd: (n, { animate: t, prevDecorator: e }) => t(
+      e,
+      {
+        opacity: n ? 0 : 1
+      },
+      {
+        duration: 0.3
+      }
+    )
+  }
+}), gt = /* @__PURE__ */ new Map([["overlay", z]]), I = {
+  "IDLE-true": "self",
+  "IDLE-false": "self",
+  "PUSHING-true": "initial",
+  "PUSHING-false": "IDLE-true",
+  "REPLACING-true": "initial",
+  "REPLACING-false": "IDLE-true",
+  "POPPING-true": "IDLE-true",
+  "POPPING-false": "PUSHING-false",
+  "COMPLETED-true": "self",
+  "COMPLETED-false": "self"
+}, G = Object.keys(I), Z = G, K = (n) => n.replace(/[^a-zA-Z0-9_-]/g, "_"), C = (n) => typeof n == "object" && n !== null && !Array.isArray(n), q = (n, t) => t === "opacity" || t === "scale" || t === "scaleX" || t === "scaleY" ? `${n}` : t === "rotate" || t === "rotateX" || t === "rotateY" || t === "rotateZ" ? `${n}deg` : `${n}px`, O = (n, t) => typeof t == "number" ? q(t, n) : typeof t == "string" ? t : "", b = (n) => n.replace(/[A-Z]/g, (t) => `-${t.toLowerCase()}`), $ = /* @__PURE__ */ new Set([
+  "x",
+  "y",
+  "z",
+  "scale",
+  "scaleX",
+  "scaleY",
+  "rotate",
+  "rotateX",
+  "rotateY",
+  "rotateZ"
+]), W = /^-?0(\.0+)?(px|%|em|rem|vh|vw|vmin|vmax)?$/, J = /^-?0(\.0+)?(deg|rad|grad|turn)?$/, tt = /^1(\.0+)?$/, et = (n, t) => n === "scale" || n === "scaleX" || n === "scaleY" ? t === 1 ? !0 : typeof t == "string" ? tt.test(t.trim()) : !1 : n === "rotate" || n === "rotateX" || n === "rotateY" || n === "rotateZ" ? t === 0 ? !0 : typeof t == "string" ? J.test(t.trim()) : !1 : t === 0 ? !0 : typeof t == "string" ? W.test(t.trim()) : !1, nt = (n, t) => {
+  switch (n) {
+    case "x":
+      return `translateX(${t})`;
+    case "y":
+      return `translateY(${t})`;
+    case "z":
+      return `translateZ(${t})`;
+    case "scale":
+      return `scale(${t})`;
+    case "scaleX":
+      return `scaleX(${t})`;
+    case "scaleY":
+      return `scaleY(${t})`;
+    case "rotate":
+    case "rotateZ":
+      return `rotate(${t})`;
+    case "rotateX":
+      return `rotateX(${t})`;
+    case "rotateY":
+      return `rotateY(${t})`;
+    default:
+      return "";
+  }
+}, Et = (n) => {
+  const t = /* @__PURE__ */ new Set();
+  let e = !1;
+  const s = (a) => {
+    if (C(a))
+      for (const r of Object.keys(a)) {
+        const i = a[r];
+        O(r, i) !== "" && ($.has(r) ? e = !0 : t.add(b(r)));
+      }
+  };
+  s(n.initial);
+  for (const a of Object.values(n.variants))
+    s(a.value);
+  return e && t.add("transform"), Array.from(t);
+}, g = (n) => {
+  if (!C(n)) return [];
+  const t = [];
+  let e = !0;
+  const s = [];
+  for (const a of Object.keys(n)) {
+    const r = n[a], i = O(a, r);
+    i !== "" && ($.has(a) ? (t.push(nt(a, i)), et(a, r) || (e = !1)) : s.push({ property: b(a), value: i }));
+  }
+  return t.length > 0 && s.push({
+    property: "transform",
+    value: e ? "none" : t.join(" ")
+  }), s;
+}, E = (n) => n.map((t) => `  ${t.property}: ${t.value};`).join(`
+`), st = (n) => Array.isArray(n) ? n.length === 4 && n.every((t) => typeof t == "number") ? `cubic-bezier(${n.join(", ")})` : "linear" : typeof n == "string" ? {
+  linear: "linear",
+  easeIn: "ease-in",
+  easeOut: "ease-out",
+  easeInOut: "ease-in-out",
+  circIn: "cubic-bezier(0, 0.55, 0.45, 1)",
+  circOut: "cubic-bezier(0.55, 0, 1, 0.45)",
+  backIn: "cubic-bezier(0.31, 0.01, 0.66, -0.59)",
+  backOut: "cubic-bezier(0.33, 1.53, 0.69, 0.99)",
+  anticipate: "cubic-bezier(0.36, 0, 0.66, -0.56)"
+}[n] ?? "ease" : "ease", R = (n) => {
+  if (!n) return 0;
+  const t = n.duration;
+  return typeof t == "number" && t >= 0 ? t : 0;
+}, _ = (n) => n && typeof n.delay == "number" && n.delay > 0 ? n.delay : 0, v = (n, t) => {
+  const [e, s] = t.split("-");
+  return `[data-flemo-screen][data-flemo-transition="${n}"][data-flemo-status="${e}"][data-flemo-active="${s}"]`;
+}, A = (n, t) => {
+  const [e, s] = t.split("-");
+  return `[data-flemo-decorator][data-flemo-decorator-name="${n}"][data-flemo-status="${e}"][data-flemo-active="${s}"]`;
+}, at = (n, t, e) => `flemo-${n}-${K(t)}-${e}`, M = (n, t, e, s, a, r) => {
+  const i = g(s), c = g(a.value), l = R(a.options), u = _(a.options), d = st(a.options?.ease), h = r(t, e);
+  if (c.length === 0 && i.length === 0)
+    return "";
+  if (l <= 0 && u <= 0)
+    return c.length === 0 ? "" : `${h} {
+${E(c)}
+  animation: none;
+}`;
+  const o = at(n, t, e), p = [
+    `@keyframes ${o} {`,
+    "  from {",
+    E(i).replace(/^/gm, "  "),
+    "  }",
+    "  to {",
+    E(c).replace(/^/gm, "  "),
+    "  }",
+    "}"
+  ].join(`
+`), P = [
+    `${o}`,
+    `${l}s`,
+    d,
+    u > 0 ? `${u}s` : null,
+    "both"
+  ].filter(Boolean).join(" "), m = Array.from(
+    /* @__PURE__ */ new Set([...i.map((T) => T.property), ...c.map((T) => T.property)])
+  ), f = m.length > 0 ? `  will-change: ${m.join(", ")};
+` : "", y = `${h} {
+  animation: ${P};
+${f}}`;
+  return `${p}
+${y}`;
+}, S = (n, t, e, s) => {
+  const a = g(s.value);
+  return a.length === 0 ? "" : `${n(t, e)} {
+${E(a)}
+}`;
+}, It = (n, t) => {
+  const e = [];
+  for (const s of n) {
+    const a = s.name;
+    for (const r of G) {
+      const i = s.variants[r], c = I[r];
+      if (c === "self") {
+        e.push(S(v, a, r, i));
+        continue;
+      }
+      const l = c === "initial" ? s.initial : s.variants[c].value;
+      e.push(
+        M("screen", a, r, l, i, v)
+      );
+    }
+  }
+  for (const s of t) {
+    const a = s.name;
+    for (const r of Z) {
+      const i = s.variants[r], c = I[r];
+      if (c === "self") {
+        e.push(S(A, a, r, i));
+        continue;
+      }
+      const l = c === "initial" ? s.initial : s.variants[c].value;
+      e.push(
+        M(
+          "decorator",
+          a,
+          r,
+          l,
+          i,
+          A
+        )
+      );
+    }
+  }
+  return e.filter((s) => s.length > 0).join(`
+
+`);
+}, kt = (n, t) => {
+  const e = I[t];
+  if (e === "self") return !1;
+  const s = n.variants[t], a = R(s.options), r = _(s.options);
+  if (a <= 0 && r <= 0) return !1;
+  const i = e === "initial" ? n.initial : n.variants[e].value, c = g(i), l = g(s.value);
+  return c.length > 0 || l.length > 0;
+};
+function Tt() {
+  return typeof document > "u";
+}
+function rt(n, t) {
+  return Array.isArray(n) ? n.find((e) => w(e).regexp.test(t)) ?? "" : w(n).regexp.test(t) ? n : "";
+}
+function Nt(n, t, e) {
+  const s = rt(n, t), a = H(s)(t), r = new URLSearchParams(e), i = Object.fromEntries(r.entries());
+  return a ? { ...a.params, ...i } : {};
+}
+function Lt(n, t) {
+  const {
+    direction: e = "x",
+    markerSelector: s = "[data-swipe-at-edge]",
+    depthLimit: a = 24,
+    verifyByScroll: r = !1
+  } = t ?? {}, i = it(n);
+  if (!i) return { element: null, hasMarker: !1 };
+  const c = i.closest?.(s);
+  if (c instanceof HTMLElement && L(c, e) && (!r || x(c, e)))
+    return { element: c, hasMarker: !0 };
+  let l = i, u = 0;
+  for (; l && u < a; ) {
+    if (L(l, e) && (!r || x(l, e)))
+      return { element: l, hasMarker: !1 };
+    l = l.parentElement, u++;
+  }
+  return { element: null, hasMarker: !1 };
+}
+function it(n) {
+  if (!n) return null;
+  const t = n, e = typeof t.composedPath == "function" ? t.composedPath() : void 0;
+  if (e && e.length) {
+    for (const s of e)
+      if (s instanceof HTMLElement) return s;
+  }
+  return n instanceof HTMLElement ? n : null;
+}
+function L(n, t) {
+  return t === "y" ? n.scrollHeight - n.clientHeight > 1 : n.scrollWidth - n.clientWidth > 1;
+}
+function x(n, t) {
+  if (!L(n, t) || typeof window > "u") return !1;
+  const e = window.getComputedStyle(n), s = t === "y" ? e.overflowY : e.overflowX;
+  return s === "auto" || s === "scroll" || s === "overlay";
+}
+export {
+  ut as TaskManger,
+  at as animationName,
+  x as canProgrammaticallyScroll,
+  Et as collectAnimatedProperties,
+  It as compileTransitionStyles,
+  ht as consumeSelfInducedPop,
+  j as createDecorator,
+  Pt as createRawDecorator,
+  mt as createRawTransition,
+  k as createTransition,
+  B as cupertino,
+  gt as decoratorMap,
+  st as easingToCss,
+  Lt as findScrollable,
+  rt as getMatchedPathPattern,
+  Nt as getParams,
+  Tt as isServer,
+  X as layout,
+  dt as markSelfInducedPop,
+  F as material,
+  V as none,
+  L as overflowsAxis,
+  z as overlay,
+  g as targetToDecls,
+  pt as transitionMap,
+  lt as useHistoryStore,
+  ft as useNavigateStore,
+  yt as useTransitionStore,
+  kt as variantHasAnimation
+};