@photoroom/ui 0.1.1

package/index738.mjs

@@ -0,0 +1,256 @@
+import { invariant as L } from "./index489.mjs";
+import { PanSession as M } from "./index739.mjs";
+import { getGlobalLock as V } from "./index586.mjs";
+import { isRefObject as P } from "./index513.mjs";
+import { addPointerEvent as S } from "./index587.mjs";
+import { applyConstraints as b, calcRelativeConstraints as B, resolveDragElastic as k, calcViewportConstraints as j, defaultElastic as T, rebaseAxisConstraints as w, calcOrigin as G } from "./index802.mjs";
+import { createBox as R } from "./index512.mjs";
+import { eachAxis as u } from "./index756.mjs";
+import { measurePageBox as _ } from "./index735.mjs";
+import { extractEventInfo as O } from "./index589.mjs";
+import { convertBoxToBoundingBox as W, convertBoundingBoxToBox as U } from "./index801.mjs";
+import { addDomEvent as z } from "./index588.mjs";
+import { calcLength as I } from "./index581.mjs";
+import { mix as y } from "./index559.mjs";
+import { percent as F } from "./index549.mjs";
+import { animateMotionValue as K } from "./index652.mjs";
+import { getContextWindow as q } from "./index740.mjs";
+import { frame as x } from "./index528.mjs";
+const H = /* @__PURE__ */ new WeakMap();
+class gt {
+  constructor(t) {
+    this.openGlobalLock = null, this.isDragging = !1, this.currentDirection = null, this.originPoint = { x: 0, y: 0 }, this.constraints = !1, this.hasMutatedConstraints = !1, this.elastic = R(), this.visualElement = t;
+  }
+  start(t, { snapToCursor: s = !1 } = {}) {
+    const { presenceContext: i } = this.visualElement;
+    if (i && i.isPresent === !1)
+      return;
+    const n = (e) => {
+      const { dragSnapToOrigin: a } = this.getProps();
+      a ? this.pauseAnimation() : this.stopAnimation(), s && this.snapToCursor(O(e, "page").point);
+    }, r = (e, a) => {
+      const { drag: f, dragPropagation: d, onDragStart: m } = this.getProps();
+      if (f && !d && (this.openGlobalLock && this.openGlobalLock(), this.openGlobalLock = V(f), !this.openGlobalLock))
+        return;
+      this.isDragging = !0, this.currentDirection = null, this.resolveConstraints(), this.visualElement.projection && (this.visualElement.projection.isAnimationBlocked = !0, this.visualElement.projection.target = void 0), u((g) => {
+        let E = this.getAxisMotionValue(g).get() || 0;
+        if (F.test(E)) {
+          const { projection: C } = this.visualElement;
+          if (C && C.layout) {
+            const D = C.layout.layoutBox[g];
+            D && (E = I(D) * (parseFloat(E) / 100));
+          }
+        }
+        this.originPoint[g] = E;
+      }), m && x.update(() => m(e, a), !1, !0);
+      const { animationState: v } = this.visualElement;
+      v && v.setActive("whileDrag", !0);
+    }, o = (e, a) => {
+      const { dragPropagation: f, dragDirectionLock: d, onDirectionLock: m, onDrag: v } = this.getProps();
+      if (!f && !this.openGlobalLock)
+        return;
+      const { offset: g } = a;
+      if (d && this.currentDirection === null) {
+        this.currentDirection = J(g), this.currentDirection !== null && m && m(this.currentDirection);
+        return;
+      }
+      this.updateAxis("x", a.point, g), this.updateAxis("y", a.point, g), this.visualElement.render(), v && v(e, a);
+    }, l = (e, a) => this.stop(e, a), c = () => u((e) => {
+      var a;
+      return this.getAnimationState(e) === "paused" && ((a = this.getAxisMotionValue(e).animation) === null || a === void 0 ? void 0 : a.play());
+    }), { dragSnapToOrigin: h } = this.getProps();
+    this.panSession = new M(t, {
+      onSessionStart: n,
+      onStart: r,
+      onMove: o,
+      onSessionEnd: l,
+      resumeAnimation: c
+    }, {
+      transformPagePoint: this.visualElement.getTransformPagePoint(),
+      dragSnapToOrigin: h,
+      contextWindow: q(this.visualElement)
+    });
+  }
+  stop(t, s) {
+    const i = this.isDragging;
+    if (this.cancel(), !i)
+      return;
+    const { velocity: n } = s;
+    this.startAnimation(n);
+    const { onDragEnd: r } = this.getProps();
+    r && x.update(() => r(t, s));
+  }
+  cancel() {
+    this.isDragging = !1;
+    const { projection: t, animationState: s } = this.visualElement;
+    t && (t.isAnimationBlocked = !1), this.panSession && this.panSession.end(), this.panSession = void 0;
+    const { dragPropagation: i } = this.getProps();
+    !i && this.openGlobalLock && (this.openGlobalLock(), this.openGlobalLock = null), s && s.setActive("whileDrag", !1);
+  }
+  updateAxis(t, s, i) {
+    const { drag: n } = this.getProps();
+    if (!i || !A(t, n, this.currentDirection))
+      return;
+    const r = this.getAxisMotionValue(t);
+    let o = this.originPoint[t] + i[t];
+    this.constraints && this.constraints[t] && (o = b(o, this.constraints[t], this.elastic[t])), r.set(o);
+  }
+  resolveConstraints() {
+    var t;
+    const { dragConstraints: s, dragElastic: i } = this.getProps(), n = this.visualElement.projection && !this.visualElement.projection.layout ? this.visualElement.projection.measure(!1) : (t = this.visualElement.projection) === null || t === void 0 ? void 0 : t.layout, r = this.constraints;
+    s && P(s) ? this.constraints || (this.constraints = this.resolveRefConstraints()) : s && n ? this.constraints = B(n.layoutBox, s) : this.constraints = !1, this.elastic = k(i), r !== this.constraints && n && this.constraints && !this.hasMutatedConstraints && u((o) => {
+      this.getAxisMotionValue(o) && (this.constraints[o] = w(n.layoutBox[o], this.constraints[o]));
+    });
+  }
+  resolveRefConstraints() {
+    const { dragConstraints: t, onMeasureDragConstraints: s } = this.getProps();
+    if (!t || !P(t))
+      return !1;
+    const i = t.current;
+    L(i !== null, "If `dragConstraints` is set as a React ref, that ref must be passed to another component's `ref` prop.");
+    const { projection: n } = this.visualElement;
+    if (!n || !n.layout)
+      return !1;
+    const r = _(i, n.root, this.visualElement.getTransformPagePoint());
+    let o = j(n.layout.layoutBox, r);
+    if (s) {
+      const l = s(W(o));
+      this.hasMutatedConstraints = !!l, l && (o = U(l));
+    }
+    return o;
+  }
+  startAnimation(t) {
+    const { drag: s, dragMomentum: i, dragElastic: n, dragTransition: r, dragSnapToOrigin: o, onDragTransitionEnd: l } = this.getProps(), c = this.constraints || {}, h = u((e) => {
+      if (!A(e, s, this.currentDirection))
+        return;
+      let a = c && c[e] || {};
+      o && (a = { min: 0, max: 0 });
+      const f = n ? 200 : 1e6, d = n ? 40 : 1e7, m = {
+        type: "inertia",
+        velocity: i ? t[e] : 0,
+        bounceStiffness: f,
+        bounceDamping: d,
+        timeConstant: 750,
+        restDelta: 1,
+        restSpeed: 10,
+        ...r,
+        ...a
+      };
+      return this.startAxisValueAnimation(e, m);
+    });
+    return Promise.all(h).then(l);
+  }
+  startAxisValueAnimation(t, s) {
+    const i = this.getAxisMotionValue(t);
+    return i.start(K(t, i, 0, s));
+  }
+  stopAnimation() {
+    u((t) => this.getAxisMotionValue(t).stop());
+  }
+  pauseAnimation() {
+    u((t) => {
+      var s;
+      return (s = this.getAxisMotionValue(t).animation) === null || s === void 0 ? void 0 : s.pause();
+    });
+  }
+  getAnimationState(t) {
+    var s;
+    return (s = this.getAxisMotionValue(t).animation) === null || s === void 0 ? void 0 : s.state;
+  }
+  /**
+   * Drag works differently depending on which props are provided.
+   *
+   * - If _dragX and _dragY are provided, we output the gesture delta directly to those motion values.
+   * - Otherwise, we apply the delta to the x/y motion values.
+   */
+  getAxisMotionValue(t) {
+    const s = "_drag" + t.toUpperCase(), i = this.visualElement.getProps(), n = i[s];
+    return n || this.visualElement.getValue(t, (i.initial ? i.initial[t] : void 0) || 0);
+  }
+  snapToCursor(t) {
+    u((s) => {
+      const { drag: i } = this.getProps();
+      if (!A(s, i, this.currentDirection))
+        return;
+      const { projection: n } = this.visualElement, r = this.getAxisMotionValue(s);
+      if (n && n.layout) {
+        const { min: o, max: l } = n.layout.layoutBox[s];
+        r.set(t[s] - y(o, l, 0.5));
+      }
+    });
+  }
+  /**
+   * When the viewport resizes we want to check if the measured constraints
+   * have changed and, if so, reposition the element within those new constraints
+   * relative to where it was before the resize.
+   */
+  scalePositionWithinConstraints() {
+    if (!this.visualElement.current)
+      return;
+    const { drag: t, dragConstraints: s } = this.getProps(), { projection: i } = this.visualElement;
+    if (!P(s) || !i || !this.constraints)
+      return;
+    this.stopAnimation();
+    const n = { x: 0, y: 0 };
+    u((o) => {
+      const l = this.getAxisMotionValue(o);
+      if (l) {
+        const c = l.get();
+        n[o] = G({ min: c, max: c }, this.constraints[o]);
+      }
+    });
+    const { transformTemplate: r } = this.visualElement.getProps();
+    this.visualElement.current.style.transform = r ? r({}, "") : "none", i.root && i.root.updateScroll(), i.updateLayout(), this.resolveConstraints(), u((o) => {
+      if (!A(o, t, null))
+        return;
+      const l = this.getAxisMotionValue(o), { min: c, max: h } = this.constraints[o];
+      l.set(y(c, h, n[o]));
+    });
+  }
+  addListeners() {
+    if (!this.visualElement.current)
+      return;
+    H.set(this.visualElement, this);
+    const t = this.visualElement.current, s = S(t, "pointerdown", (c) => {
+      const { drag: h, dragListener: e = !0 } = this.getProps();
+      h && e && this.start(c);
+    }), i = () => {
+      const { dragConstraints: c } = this.getProps();
+      P(c) && (this.constraints = this.resolveRefConstraints());
+    }, { projection: n } = this.visualElement, r = n.addEventListener("measure", i);
+    n && !n.layout && (n.root && n.root.updateScroll(), n.updateLayout()), i();
+    const o = z(window, "resize", () => this.scalePositionWithinConstraints()), l = n.addEventListener("didUpdate", (({ delta: c, hasLayoutChanged: h }) => {
+      this.isDragging && h && (u((e) => {
+        const a = this.getAxisMotionValue(e);
+        a && (this.originPoint[e] += c[e].translate, a.set(a.get() + c[e].translate));
+      }), this.visualElement.render());
+    }));
+    return () => {
+      o(), s(), r(), l && l();
+    };
+  }
+  getProps() {
+    const t = this.visualElement.getProps(), { drag: s = !1, dragDirectionLock: i = !1, dragPropagation: n = !1, dragConstraints: r = !1, dragElastic: o = T, dragMomentum: l = !0 } = t;
+    return {
+      ...t,
+      drag: s,
+      dragDirectionLock: i,
+      dragPropagation: n,
+      dragConstraints: r,
+      dragElastic: o,
+      dragMomentum: l
+    };
+  }
+}
+function A(p, t, s) {
+  return (t === !0 || t === p) && (s === null || s === p);
+}
+function J(p, t = 10) {
+  let s = null;
+  return Math.abs(p.y) > t ? s = "y" : Math.abs(p.x) > t && (s = "x"), s;
+}
+export {
+  gt as VisualElementDragControls,
+  H as elementDragControls
+};
+//# sourceMappingURL=index738.mjs.map

package/index739.mjs

@@ -0,0 +1,85 @@
+import { extractEventInfo as w } from "./index589.mjs";
+import { secondsToMilliseconds as S, millisecondsToSeconds as D } from "./index538.mjs";
+import { addPointerEvent as d } from "./index587.mjs";
+import { pipe as T } from "./index560.mjs";
+import { distance2D as W } from "./index570.mjs";
+import { isPrimaryPointer as L } from "./index590.mjs";
+import { frameData as x, frame as U, cancelFrame as O } from "./index528.mjs";
+class B {
+  constructor(n, o, { transformPagePoint: e, contextWindow: r, dragSnapToOrigin: h = !1 } = {}) {
+    if (this.startEvent = null, this.lastMoveEvent = null, this.lastMoveEventInfo = null, this.handlers = {}, this.contextWindow = window, this.updatePoint = () => {
+      if (!(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const i = p(this.lastMoveEventInfo, this.history), a = this.startEvent !== null, c = W(i.offset, { x: 0, y: 0 }) >= 3;
+      if (!a && !c)
+        return;
+      const { point: f } = i, { timestamp: m } = x;
+      this.history.push({ ...f, timestamp: m });
+      const { onStart: l, onMove: E } = this.handlers;
+      a || (l && l(this.lastMoveEvent, i), this.startEvent = this.lastMoveEvent), E && E(this.lastMoveEvent, i);
+    }, this.handlePointerMove = (i, a) => {
+      this.lastMoveEvent = i, this.lastMoveEventInfo = v(a, this.transformPagePoint), U.update(this.updatePoint, !0);
+    }, this.handlePointerUp = (i, a) => {
+      this.end();
+      const { onEnd: c, onSessionEnd: f, resumeAnimation: m } = this.handlers;
+      if (this.dragSnapToOrigin && m && m(), !(this.lastMoveEvent && this.lastMoveEventInfo))
+        return;
+      const l = p(i.type === "pointercancel" ? this.lastMoveEventInfo : v(a, this.transformPagePoint), this.history);
+      this.startEvent && c && c(i, l), f && f(i, l);
+    }, !L(n))
+      return;
+    this.dragSnapToOrigin = h, this.handlers = o, this.transformPagePoint = e, this.contextWindow = r || window;
+    const s = w(n), u = v(s, this.transformPagePoint), { point: g } = u, { timestamp: I } = x;
+    this.history = [{ ...g, timestamp: I }];
+    const { onSessionStart: P } = o;
+    P && P(n, p(u, this.history)), this.removeListeners = T(d(this.contextWindow, "pointermove", this.handlePointerMove), d(this.contextWindow, "pointerup", this.handlePointerUp), d(this.contextWindow, "pointercancel", this.handlePointerUp));
+  }
+  updateHandlers(n) {
+    this.handlers = n;
+  }
+  end() {
+    this.removeListeners && this.removeListeners(), O(this.updatePoint);
+  }
+}
+function v(t, n) {
+  return n ? { point: n(t.point) } : t;
+}
+function y(t, n) {
+  return { x: t.x - n.x, y: t.y - n.y };
+}
+function p({ point: t }, n) {
+  return {
+    point: t,
+    delta: y(t, M(n)),
+    offset: y(t, V(n)),
+    velocity: b(n, 0.1)
+  };
+}
+function V(t) {
+  return t[0];
+}
+function M(t) {
+  return t[t.length - 1];
+}
+function b(t, n) {
+  if (t.length < 2)
+    return { x: 0, y: 0 };
+  let o = t.length - 1, e = null;
+  const r = M(t);
+  for (; o >= 0 && (e = t[o], !(r.timestamp - e.timestamp > S(n))); )
+    o--;
+  if (!e)
+    return { x: 0, y: 0 };
+  const h = D(r.timestamp - e.timestamp);
+  if (h === 0)
+    return { x: 0, y: 0 };
+  const s = {
+    x: (r.x - e.x) / h,
+    y: (r.y - e.y) / h
+  };
+  return s.x === 1 / 0 && (s.x = 0), s.y === 1 / 0 && (s.y = 0), s;
+}
+export {
+  B as PanSession
+};
+//# sourceMappingURL=index739.mjs.map

package/index74.mjs

@@ -0,0 +1,70 @@
+import { jsxs as w, jsx as o } from "react/jsx-runtime";
+import { clsx as v } from "./index296.mjs";
+import { useMemo as a, cloneElement as i } from "react";
+import { ColorSwatch as j } from "./index75.mjs";
+import { Bone as y } from "./index186.mjs";
+const R = () => Array.from({ length: 7 }).map((t, n) => /* @__PURE__ */ o(y, { className: "h-10 w-10 shrink-0 rounded-full" }, `color-${n}`)), $ = ({
+  colors: t,
+  colorPicker: n,
+  eyeDropper: e,
+  loading: l = !1,
+  onSelectColor: x,
+  selectedColor: f,
+  additionalPalettes: p = [],
+  showAdditionalPalettes: u = !1,
+  previewFirstAdditionalPalette: h = !1,
+  showAdditionalPalettesFooter: N,
+  gridColumns: s = 7
+}) => {
+  const E = a(() => {
+    if (!h || p.length === 0)
+      return null;
+    const r = p[0], m = r.props.colors;
+    if (!m || !Array.isArray(m))
+      return null;
+    let c = m.slice(0, s - 2);
+    return r.props.preElement && r.props.postElement && (c = m.slice(0, s - 3)), !r.props.preElement && !r.props.postElement && (c = m.slice(0, s - 1)), i(p[0], {
+      ...p[0].props,
+      colors: c
+    });
+  }, [h, p, s]), L = a(() => n ? i(n, {
+    className: "shrink-0"
+  }) : null, [n]), S = a(() => e ? i(e, {
+    className: "shrink-0"
+  }) : null, [e]), k = a(() => e && n ? t.slice(0, s - 2) : !e && !n ? t.slice(0, s) : t.slice(0, s - 1), [e, n, t, s]);
+  return /* @__PURE__ */ w("div", { className: "flex flex-col gap-3 py-3", children: [
+    /* @__PURE__ */ w(
+      "div",
+      {
+        className: v("grid grid-rows-1 gap-2", {
+          "grid-cols-6": s === 6,
+          "grid-cols-7": s === 7
+        }),
+        role: "radiogroup",
+        children: [
+          l ? /* @__PURE__ */ o(R, {}) : k.map((r) => /* @__PURE__ */ o(
+            j,
+            {
+              className: "shrink-0",
+              color: r,
+              onClick: () => x(r),
+              selected: (f == null ? void 0 : f.toLowerCase()) === r.toLowerCase(),
+              role: "radio",
+              "aria-checked": (f == null ? void 0 : f.toLowerCase()) === r.toLowerCase()
+            },
+            r
+          )),
+          L,
+          S
+        ]
+      }
+    ),
+    h && !u && E,
+    u && p,
+    p.length > 0 && N
+  ] });
+};
+export {
+  $ as ColorRow
+};
+//# sourceMappingURL=index74.mjs.map

package/index740.mjs

@@ -0,0 +1,5 @@
+const t = ({ current: e }) => e ? e.ownerDocument.defaultView : null;
+export {
+  t as getContextWindow
+};
+//# sourceMappingURL=index740.mjs.map

package/index741.mjs

@@ -0,0 +1,16 @@
+const e = {
+  /**
+   * Global flag as to whether the tree has animated since the last time
+   * we resized the window
+   */
+  hasAnimatedSinceResize: !0,
+  /**
+   * We set this to true once, on the first update. Any nodes added to the tree beyond that
+   * update will be given a `data-projection-id` attribute.
+   */
+  hasEverUpdated: !1
+};
+export {
+  e as globalProjectionState
+};
+//# sourceMappingURL=index741.mjs.map

package/index742.mjs

@@ -0,0 +1,22 @@
+import { px as c } from "./index549.mjs";
+function e(r, n) {
+  return n.max === n.min ? 0 : r / (n.max - n.min) * 100;
+}
+const f = {
+  correct: (r, n) => {
+    if (!n.target)
+      return r;
+    if (typeof r == "string")
+      if (c.test(r))
+        r = parseFloat(r);
+      else
+        return r;
+    const o = e(r, n.target.x), t = e(r, n.target.y);
+    return `${o}% ${t}%`;
+  }
+};
+export {
+  f as correctBorderRadius,
+  e as pixelsToPercent
+};
+//# sourceMappingURL=index742.mjs.map

package/index743.mjs

@@ -0,0 +1,17 @@
+import { mix as i } from "./index559.mjs";
+import { complex as m } from "./index545.mjs";
+const l = {
+  correct: (e, { treeScale: c, projectionDelta: t }) => {
+    const a = e, o = m.parse(e);
+    if (o.length > 5)
+      return a;
+    const p = m.createTransformer(e), r = typeof o[0] != "number" ? 1 : 0, n = t.x.scale * c.x, s = t.y.scale * c.y;
+    o[0 + r] /= n, o[1 + r] /= s;
+    const f = i(n, s, 0.5);
+    return typeof o[2 + r] == "number" && (o[2 + r] /= f), typeof o[3 + r] == "number" && (o[3 + r] /= f), p(o);
+  }
+};
+export {
+  l as correctBoxShadow
+};
+//# sourceMappingURL=index743.mjs.map

package/index744.mjs

@@ -0,0 +1,108 @@
+import { animateStyle as k } from "./index659.mjs";
+import { isWaapiSupportedEasing as w } from "./index660.mjs";
+import { getFinalKeyframe as F } from "./index803.mjs";
+import { animateValue as S } from "./index531.mjs";
+import { millisecondsToSeconds as b, secondsToMilliseconds as C } from "./index538.mjs";
+import { memo as D } from "./index762.mjs";
+import { noop as K } from "./index547.mjs";
+import { frame as V, cancelFrame as W } from "./index528.mjs";
+const x = D(() => Object.hasOwnProperty.call(Element.prototype, "animate")), E = /* @__PURE__ */ new Set([
+  "opacity",
+  "clipPath",
+  "filter",
+  "transform",
+  "backgroundColor"
+]), c = 10, O = 2e4, R = (i, n) => n.type === "spring" || i === "backgroundColor" || !w(n.ease);
+function L(i, n, { onUpdate: j, onComplete: u, ...a }) {
+  if (!(x() && E.has(n) && !a.repeatDelay && a.repeatType !== "mirror" && a.damping !== 0 && a.type !== "inertia"))
+    return !1;
+  let f = !1, d, y, s = !1;
+  const h = () => {
+    y = new Promise((e) => {
+      d = e;
+    });
+  };
+  h();
+  let { keyframes: l, duration: m = 300, ease: g, times: A } = a;
+  if (R(n, a)) {
+    const e = S({
+      ...a,
+      repeat: 0,
+      delay: 0
+    });
+    let r = { done: !1, value: l[0] };
+    const T = [];
+    let o = 0;
+    for (; !r.done && o < O; )
+      r = e.sample(o), T.push(r.value), o += c;
+    A = void 0, l = T, m = o - c, g = "linear";
+  }
+  const t = k(i.owner.current, n, l, {
+    ...a,
+    duration: m,
+    /**
+     * This function is currently not called if ease is provided
+     * as a function so the cast is safe.
+     *
+     * However it would be possible for a future refinement to port
+     * in easing pregeneration from Motion One for browsers that
+     * support the upcoming `linear()` easing function.
+     */
+    ease: g,
+    times: A
+  }), P = () => {
+    s = !1, t.cancel();
+  }, p = () => {
+    s = !0, V.update(P), d(), h();
+  };
+  return t.onfinish = () => {
+    s || (i.set(F(l, a)), u && u(), p());
+  }, {
+    then(e, r) {
+      return y.then(e, r);
+    },
+    attachTimeline(e) {
+      return t.timeline = e, t.onfinish = null, K;
+    },
+    get time() {
+      return b(t.currentTime || 0);
+    },
+    set time(e) {
+      t.currentTime = C(e);
+    },
+    get speed() {
+      return t.playbackRate;
+    },
+    set speed(e) {
+      t.playbackRate = e;
+    },
+    get duration() {
+      return b(m);
+    },
+    play: () => {
+      f || (t.play(), W(P));
+    },
+    pause: () => t.pause(),
+    stop: () => {
+      if (f = !0, t.playState === "idle")
+        return;
+      const { currentTime: e } = t;
+      if (e) {
+        const r = S({
+          ...a,
+          autoplay: !1
+        });
+        i.setWithVelocity(r.sample(e - c).value, r.sample(e).value, c);
+      }
+      p();
+    },
+    complete: () => {
+      s || t.finish();
+    },
+    cancel: p
+  };
+}
+export {
+  L as createAcceleratedAnimation
+};
+//# sourceMappingURL=index744.mjs.map

package/index745.mjs

@@ -0,0 +1,25 @@
+import { animateValue as m } from "./index531.mjs";
+import { noop as e } from "./index547.mjs";
+function s({ keyframes: t, delay: n, onUpdate: r, onComplete: o }) {
+  const a = () => (r && r(t[t.length - 1]), o && o(), {
+    time: 0,
+    speed: 1,
+    duration: 0,
+    play: e,
+    pause: e,
+    stop: e,
+    then: (i) => (i(), Promise.resolve()),
+    cancel: e,
+    complete: e
+  });
+  return n ? m({
+    keyframes: [0, 1],
+    duration: 0,
+    delay: n,
+    onComplete: a
+  }) : a();
+}
+export {
+  s as createInstantAnimation
+};
+//# sourceMappingURL=index745.mjs.map

package/index746.mjs

@@ -0,0 +1,23 @@
+import { transformProps as s } from "./index519.mjs";
+const r = {
+  type: "spring",
+  stiffness: 500,
+  damping: 25,
+  restSpeed: 10
+}, n = (t) => ({
+  type: "spring",
+  stiffness: 550,
+  damping: t === 0 ? 2 * Math.sqrt(550) : 30,
+  restSpeed: 10
+}), i = {
+  type: "keyframes",
+  duration: 0.8
+}, a = {
+  type: "keyframes",
+  ease: [0.25, 0.1, 0.35, 1],
+  duration: 0.3
+}, o = (t, { keyframes: e }) => e.length > 2 ? i : s.has(t) ? t.startsWith("scale") ? n(e[1]) : r : a;
+export {
+  o as getDefaultTransition
+};
+//# sourceMappingURL=index746.mjs.map

package/index747.mjs

@@ -0,0 +1,8 @@
+import { complex as e } from "./index545.mjs";
+const n = (t, r) => t === "zIndex" ? !1 : !!(typeof r == "number" || Array.isArray(r) || typeof r == "string" && // It's animatable if we have a string
+(e.test(r) || r === "0") && // And it contains numbers and/or colors
+!r.startsWith("url("));
+export {
+  n as isAnimatable
+};
+//# sourceMappingURL=index747.mjs.map

package/index748.mjs

@@ -0,0 +1,23 @@
+import { getAnimatableNone as u } from "./index579.mjs";
+import { isAnimatable as d } from "./index747.mjs";
+import { isNone as p } from "./index804.mjs";
+function A(l, o, i, r) {
+  const m = d(o, i);
+  let n;
+  Array.isArray(i) ? n = [...i] : n = [null, i];
+  const s = r.from !== void 0 ? r.from : l.get();
+  let f;
+  const t = [];
+  for (let e = 0; e < n.length; e++)
+    n[e] === null && (n[e] = e === 0 ? s : n[e - 1]), p(n[e]) && t.push(e), typeof n[e] == "string" && n[e] !== "none" && n[e] !== "0" && (f = n[e]);
+  if (m && t.length && f)
+    for (let e = 0; e < t.length; e++) {
+      const a = t[e];
+      n[a] = u(o, f);
+    }
+  return n;
+}
+export {
+  A as getKeyframes
+};
+//# sourceMappingURL=index748.mjs.map