@nil-/xit 0.1.26 → 0.1.28

package/assets/svelte/motion.js

@@ -1,195 +1,461 @@
-import { w as P } from "./store.js";
-import { linear as z } from "./easing.js";
-const C = () => performance.now(), p = {
+var et = (e) => {
+  throw TypeError(e);
+};
+var W = (e, t, s) => t.has(e) || et("Cannot " + s);
+var r = (e, t, s) => (W(e, t, "read from private field"), s ? s.call(e) : t.get(e)), c = (e, t, s) => t.has(e) ? et("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, s), h = (e, t, s, i) => (W(e, t, "write to private field"), i ? i.call(e, s) : t.set(e, s), s), st = (e, t, s) => (W(e, t, "access private method"), s);
+import "./internal/client.js";
+import { o as ht, c as O, b as rt, a as g, f as ut, n as dt, g as _ } from "./index.js";
+import { c as lt, w as nt } from "./store.js";
+import { linear as it } from "./easing.js";
+const mt = () => performance.now(), l = {
   // don't access requestAnimationFrame eagerly outside method
   // this allows basic testing of user code without JSDOM
   // bunder will eval and remove ternary when the user's app is built
   tick: (
     /** @param {any} _ */
-    (t) => requestAnimationFrame(t)
+    (e) => requestAnimationFrame(e)
   ),
-  now: () => C(),
+  now: () => mt(),
   tasks: /* @__PURE__ */ new Set()
 };
-function O(t) {
-  p.tasks.forEach((r) => {
-    r.c(t) || (p.tasks.delete(r), r.f());
-  }), p.tasks.size !== 0 && p.tick(O);
+function ot() {
+  const e = l.now();
+  l.tasks.forEach((t) => {
+    t.c(e) || (l.tasks.delete(t), t.f());
+  }), l.tasks.size !== 0 && l.tick(ot);
 }
-function M(t) {
-  let r;
-  return p.tasks.size === 0 && p.tick(O), {
-    promise: new Promise((e) => {
-      p.tasks.add(r = { c: t, f: e });
+function N(e) {
+  let t;
+  return l.tasks.size === 0 && l.tick(ot), {
+    promise: new Promise((s) => {
+      l.tasks.add(t = { c: e, f: s });
     }),
     abort() {
-      p.tasks.delete(r);
+      l.tasks.delete(t);
     }
   };
 }
-function h(t) {
-  return Object.prototype.toString.call(t) === "[object Date]";
+var Q, V;
+class pt {
+  /**
+   *
+   * @param {() => T} fn
+   * @param {(update: () => void) => void} onsubscribe
+   */
+  constructor(t, s) {
+    c(this, Q);
+    c(this, V);
+    h(this, Q, t), h(this, V, lt(s));
+  }
+  get current() {
+    return r(this, V).call(this), r(this, Q).call(this);
+  }
+}
+Q = new WeakMap(), V = new WeakMap();
+const gt = /\(.+\)/;
+class bt extends pt {
+  /**
+   * @param {string} query A media query string
+   * @param {boolean} [fallback] Fallback value for the server
+   */
+  constructor(t, s) {
+    let i = gt.test(t) ? t : `(${t})`;
+    const o = window.matchMedia(i);
+    super(
+      () => o.matches,
+      (n) => ht(o, "change", n)
+    );
+  }
+}
+function I(e) {
+  return Object.prototype.toString.call(e) === "[object Date]";
 }
-function j(t, r, e, i) {
-  if (typeof e == "number" || h(e)) {
-    const n = i - e, s = (e - r) / (t.dt || 1 / 60), o = t.opts.stiffness * n, f = t.opts.damping * s, c = (o - f) * t.inv_mass, l = (s + c) * t.dt;
-    return Math.abs(l) < t.opts.precision && Math.abs(n) < t.opts.precision ? i : (t.settled = !1, h(e) ? new Date(e.getTime() + l) : e + l);
+function J(e, t, s, i) {
+  if (typeof s == "number" || I(s)) {
+    const o = i - s, n = (s - t) / (e.dt || 1 / 60), f = e.opts.stiffness * o, a = e.opts.damping * n, u = (f - a) * e.inv_mass, m = (n + u) * e.dt;
+    return Math.abs(m) < e.opts.precision && Math.abs(o) < e.opts.precision ? i : (e.settled = !1, I(s) ? new Date(s.getTime() + m) : s + m);
   } else {
-    if (Array.isArray(e))
-      return e.map(
-        (n, s) => (
+    if (Array.isArray(s))
+      return s.map(
+        (o, n) => (
           // @ts-ignore
-          j(t, r[s], e[s], i[s])
+          J(e, t[n], s[n], i[n])
         )
       );
-    if (typeof e == "object") {
-      const n = {};
-      for (const s in e)
-        n[s] = j(t, r[s], e[s], i[s]);
-      return n;
+    if (typeof s == "object") {
+      const o = {};
+      for (const n in s)
+        o[n] = J(e, t[n], s[n], i[n]);
+      return o;
     } else
-      throw new Error(`Cannot spring ${typeof e} values`);
+      throw new Error(`Cannot spring ${typeof s} values`);
   }
 }
-function D(t, r = {}) {
-  const e = P(t), { stiffness: i = 0.15, damping: n = 0.8, precision: s = 0.01 } = r;
-  let o, f, c, l = (
+function yt(e, t = {}) {
+  const s = nt(e), { stiffness: i = 0.15, damping: o = 0.8, precision: n = 0.01 } = t;
+  let f, a, u, m = (
     /** @type {T} */
-    t
-  ), u = (
+    e
+  ), b = (
     /** @type {T | undefined} */
-    t
-  ), a = 1, w = 0, b = !1;
-  function k(y, m = {}) {
-    u = y;
-    const S = c = {};
-    return t == null || m.hard || d.stiffness >= 1 && d.damping >= 1 ? (b = !0, o = p.now(), l = y, e.set(t = u), Promise.resolve()) : (m.soft && (w = 1 / ((m.soft === !0 ? 0.5 : +m.soft) * 60), a = 0), f || (o = p.now(), b = !1, f = M((g) => {
-      if (b)
-        return b = !1, f = null, !1;
-      a = Math.min(a + w, 1);
-      const A = {
-        inv_mass: a,
-        opts: d,
+    e
+  ), d = 1, j = 0, y = !1;
+  function x(P, w = {}) {
+    b = P;
+    const at = u = {};
+    return e == null || w.hard || E.stiffness >= 1 && E.damping >= 1 ? (y = !0, f = l.now(), m = P, s.set(e = b), Promise.resolve()) : (w.soft && (j = 1 / ((w.soft === !0 ? 0.5 : +w.soft) * 60), d = 0), a || (f = l.now(), y = !1, a = N((F) => {
+      if (y)
+        return y = !1, a = null, !1;
+      d = Math.min(d + j, 1);
+      const U = {
+        inv_mass: d,
+        opts: E,
         settled: !0,
-        dt: (g - o) * 60 / 1e3
-      }, T = j(A, l, t, u);
-      return o = g, l = /** @type {T} */
-      t, e.set(t = /** @type {T} */
-      T), A.settled && (f = null), !A.settled;
-    })), new Promise((g) => {
-      f.promise.then(() => {
-        S === c && g();
+        dt: (F - f) * 60 / 1e3
+      }, ct = J(U, m, e, b);
+      return f = F, m = /** @type {T} */
+      e, s.set(e = /** @type {T} */
+      ct), U.settled && (a = null), !U.settled;
+    })), new Promise((F) => {
+      a.promise.then(() => {
+        at === u && F();
       });
     }));
   }
-  const d = {
-    set: k,
-    update: (y, m) => k(y(
+  const E = {
+    set: x,
+    update: (P, w) => x(P(
       /** @type {T} */
-      u,
+      b,
       /** @type {T} */
-      t
-    ), m),
-    subscribe: e.subscribe,
+      e
+    ), w),
+    subscribe: s.subscribe,
     stiffness: i,
-    damping: n,
-    precision: s
+    damping: o,
+    precision: n
   };
-  return d;
+  return E;
+}
+var S, z, C, p, M, D, $, T, B, k, R, L, ft;
+const Z = class Z {
+  /**
+   * @param {T} value
+   * @param {SpringOpts} [options]
+   */
+  constructor(t, s = {}) {
+    c(this, L);
+    c(this, S, O(0.15));
+    c(this, z, O(0.8));
+    c(this, C, O(0.01));
+    c(this, p, O(
+      /** @type {T} */
+      void 0
+    ));
+    c(this, M, O(
+      /** @type {T} */
+      void 0
+    ));
+    c(this, D);
+    c(this, $, 0);
+    c(this, T, 1);
+    c(this, B, 0);
+    /** @type {import('../internal/client/types').Task | null} */
+    c(this, k, null);
+    /** @type {ReturnType<typeof deferred> | null} */
+    c(this, R, null);
+    r(this, p).v = r(this, M).v = t, typeof s.stiffness == "number" && (r(this, S).v = H(s.stiffness, 0, 1)), typeof s.damping == "number" && (r(this, z).v = H(s.damping, 0, 1)), typeof s.precision == "number" && (r(this, C).v = s.precision);
+  }
+  /**
+   * Create a spring whose value is bound to the return value of `fn`. This must be called
+   * inside an effect root (for example, during component initialisation).
+   *
+   * ```svelte
+   * <script>
+   * 	import { Spring } from 'svelte/motion';
+   *
+   * 	let { number } = $props();
+   *
+   * 	const spring = Spring.of(() => number);
+   * <\/script>
+   * ```
+   * @template U
+   * @param {() => U} fn
+   * @param {SpringOpts} [options]
+   */
+  static of(t, s) {
+    const i = new Z(t(), s);
+    return rt(() => {
+      i.set(t());
+    }), i;
+  }
+  /**
+   * Sets `spring.target` to `value` and returns a `Promise` that resolves if and when `spring.current` catches up to it.
+   *
+   * If `options.instant` is `true`, `spring.current` immediately matches `spring.target`.
+   *
+   * If `options.preserveMomentum` is provided, the spring will continue on its current trajectory for
+   * the specified number of milliseconds. This is useful for things like 'fling' gestures.
+   *
+   * @param {T} value
+   * @param {SpringUpdateOpts} [options]
+   */
+  set(t, s) {
+    var o, n;
+    if ((o = r(this, R)) == null || o.reject(new Error("Aborted")), s != null && s.instant || r(this, p).v === void 0)
+      return (n = r(this, k)) == null || n.abort(), h(this, k, null), g(r(this, p), g(r(this, M), t)), h(this, D, t), Promise.resolve();
+    s != null && s.preserveMomentum && (h(this, T, 0), h(this, B, s.preserveMomentum));
+    var i = h(this, R, ut());
+    return i.promise.catch(dt), st(this, L, ft).call(this, t).then(() => {
+      i === r(this, R) && i.resolve(void 0);
+    }), i.promise;
+  }
+  get current() {
+    return _(r(this, p));
+  }
+  get damping() {
+    return _(r(this, z));
+  }
+  set damping(t) {
+    g(r(this, z), H(t, 0, 1));
+  }
+  get precision() {
+    return _(r(this, C));
+  }
+  set precision(t) {
+    g(r(this, C), t);
+  }
+  get stiffness() {
+    return _(r(this, S));
+  }
+  set stiffness(t) {
+    g(r(this, S), H(t, 0, 1));
+  }
+  get target() {
+    return _(r(this, M));
+  }
+  set target(t) {
+    this.set(t);
+  }
+};
+S = new WeakMap(), z = new WeakMap(), C = new WeakMap(), p = new WeakMap(), M = new WeakMap(), D = new WeakMap(), $ = new WeakMap(), T = new WeakMap(), B = new WeakMap(), k = new WeakMap(), R = new WeakMap(), L = new WeakSet(), /** @param {T} value */
+ft = function(t) {
+  var i;
+  if (g(r(this, M), t), (i = r(this, p)).v ?? (i.v = t), r(this, D) ?? h(this, D, r(this, p).v), !r(this, k)) {
+    h(this, $, l.now());
+    var s = 1e3 / (r(this, B) * 60);
+    r(this, k) ?? h(this, k, N((o) => {
+      h(this, T, Math.min(r(this, T) + s, 1));
+      const n = {
+        inv_mass: r(this, T),
+        opts: {
+          stiffness: r(this, S).v,
+          damping: r(this, z).v,
+          precision: r(this, C).v
+        },
+        settled: !0,
+        dt: (o - r(this, $)) * 60 / 1e3
+      };
+      var f = J(n, r(this, D), r(this, p).v, r(this, M).v);
+      return h(this, D, r(this, p).v), h(this, $, o), g(r(this, p), f), n.settled && h(this, k, null), !n.settled;
+    }));
+  }
+  return r(this, k).promise;
+};
+let X = Z;
+function H(e, t, s) {
+  return Math.max(t, Math.min(s, e));
 }
-function E(t, r) {
-  if (t === r || t !== t) return () => t;
-  const e = typeof t;
-  if (e !== typeof r || Array.isArray(t) !== Array.isArray(r))
+function K(e, t) {
+  if (e === t || e !== e) return () => e;
+  const s = typeof e;
+  if (s !== typeof t || Array.isArray(e) !== Array.isArray(t))
     throw new Error("Cannot interpolate values of different type");
-  if (Array.isArray(t)) {
+  if (Array.isArray(e)) {
     const i = (
       /** @type {Array<any>} */
-      r.map((n, s) => E(
+      t.map((o, n) => K(
         /** @type {Array<any>} */
-        t[s],
-        n
+        e[n],
+        o
       ))
     );
-    return (n) => i.map((s) => s(n));
+    return (o) => i.map((n) => n(o));
   }
-  if (e === "object") {
-    if (!t || !r)
+  if (s === "object") {
+    if (!e || !t)
       throw new Error("Object cannot be null");
-    if (h(t) && h(r)) {
-      const s = t.getTime(), f = r.getTime() - s;
-      return (c) => new Date(s + c * f);
+    if (I(e) && I(t)) {
+      const n = e.getTime(), a = t.getTime() - n;
+      return (u) => new Date(n + u * a);
     }
-    const i = Object.keys(r), n = {};
-    return i.forEach((s) => {
-      n[s] = E(t[s], r[s]);
-    }), (s) => {
-      const o = {};
-      return i.forEach((f) => {
-        o[f] = n[f](s);
-      }), o;
+    const i = Object.keys(t), o = {};
+    return i.forEach((n) => {
+      o[n] = K(e[n], t[n]);
+    }), (n) => {
+      const f = {};
+      return i.forEach((a) => {
+        f[a] = o[a](n);
+      }), f;
     };
   }
-  if (e === "number") {
+  if (s === "number") {
     const i = (
       /** @type {number} */
-      r - /** @type {number} */
-      t
+      t - /** @type {number} */
+      e
     );
-    return (n) => t + n * i;
+    return (o) => e + o * i;
   }
-  throw new Error(`Cannot interpolate ${e} values`);
+  throw new Error(`Cannot interpolate ${s} values`);
 }
-function $(t, r = {}) {
-  const e = P(t);
-  let i, n = t;
-  function s(o, f) {
-    if (n = o, t == null)
-      return e.set(t = o), Promise.resolve();
-    let c = i, l = !1, {
-      delay: u = 0,
-      duration: a = 400,
-      easing: w = z,
-      interpolate: b = E
-    } = { ...r, ...f };
-    if (a === 0)
-      return c && (c.abort(), c = null), e.set(t = n), Promise.resolve();
-    const k = p.now() + u;
-    let d;
-    return i = M((y) => {
-      if (y < k) return !0;
-      l || (d = b(
+function wt(e, t = {}) {
+  const s = nt(e);
+  let i, o = e;
+  function n(f, a) {
+    if (o = f, e == null)
+      return s.set(e = f), Promise.resolve();
+    let u = i, m = !1, {
+      delay: b = 0,
+      duration: d = 400,
+      easing: j = it,
+      interpolate: y = K
+    } = { ...t, ...a };
+    if (d === 0)
+      return u && (u.abort(), u = null), s.set(e = o), Promise.resolve();
+    const x = l.now() + b;
+    let E;
+    return i = N((P) => {
+      if (P < x) return !0;
+      m || (E = y(
         /** @type {any} */
-        t,
-        o
-      ), typeof a == "function" && (a = a(
+        e,
+        f
+      ), typeof d == "function" && (d = d(
         /** @type {any} */
-        t,
-        o
-      )), l = !0), c && (c.abort(), c = null);
-      const m = y - k;
-      return m > /** @type {number} */
-      a ? (e.set(t = o), !1) : (e.set(t = d(w(m / a))), !0);
+        e,
+        f
+      )), m = !0), u && (u.abort(), u = null);
+      const w = P - x;
+      return w > /** @type {number} */
+      d ? (s.set(e = f), !1) : (s.set(e = E(j(w / d))), !0);
     }), i.promise;
   }
   return {
-    set: s,
-    update: (o, f) => s(o(
+    set: n,
+    update: (f, a) => n(f(
       /** @type {any} */
-      n,
+      o,
       /** @type {any} */
-      t
-    ), f),
-    subscribe: e.subscribe
+      e
+    ), a),
+    subscribe: s.subscribe
   };
 }
-const B = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+var A, q, G, v;
+const tt = class tt {
+  /**
+   * @param {T} value
+   * @param {TweenedOptions<T>} options
+   */
+  constructor(t, s = {}) {
+    c(this, A, O(
+      /** @type {T} */
+      void 0
+    ));
+    c(this, q, O(
+      /** @type {T} */
+      void 0
+    ));
+    /** @type {TweenedOptions<T>} */
+    c(this, G);
+    /** @type {import('../internal/client/types').Task | null} */
+    c(this, v, null);
+    r(this, A).v = r(this, q).v = t, h(this, G, s);
+  }
+  /**
+   * Create a tween whose value is bound to the return value of `fn`. This must be called
+   * inside an effect root (for example, during component initialisation).
+   *
+   * ```svelte
+   * <script>
+   * 	import { Tween } from 'svelte/motion';
+   *
+   * 	let { number } = $props();
+   *
+   * 	const tween = Tween.of(() => number);
+   * <\/script>
+   * ```
+   * @template U
+   * @param {() => U} fn
+   * @param {TweenedOptions<U>} [options]
+   */
+  static of(t, s) {
+    const i = new tt(t(), s);
+    return rt(() => {
+      i.set(t());
+    }), i;
+  }
+  /**
+   * Sets `tween.target` to `value` and returns a `Promise` that resolves if and when `tween.current` catches up to it.
+   *
+   * If `options` are provided, they will override the tween's defaults.
+   * @param {T} value
+   * @param {TweenedOptions<T>} [options]
+   * @returns
+   */
+  set(t, s) {
+    g(r(this, q), t);
+    let i = r(this, A).v, o = r(this, v), n = !1, {
+      delay: f = 0,
+      duration: a = 400,
+      easing: u = it,
+      interpolate: m = K
+    } = { ...r(this, G), ...s };
+    const b = l.now() + f;
+    let d;
+    return h(this, v, N((j) => {
+      if (j < b)
+        return !0;
+      n || (n = !0, d = m(
+        /** @type {any} */
+        i,
+        t
+      ), typeof a == "function" && (a = a(
+        /** @type {any} */
+        i,
+        t
+      )), o == null || o.abort());
+      const y = j - b;
+      return y > /** @type {number} */
+      a ? (g(r(this, A), t), !1) : (g(r(this, A), d(u(y / /** @type {number} */
+      a))), !0);
+    })), r(this, v).promise;
+  }
+  get current() {
+    return _(r(this, A));
+  }
+  get target() {
+    return _(r(this, q));
+  }
+  set target(t) {
+    this.set(t);
+  }
+};
+A = new WeakMap(), q = new WeakMap(), G = new WeakMap(), v = new WeakMap();
+let Y = tt;
+const kt = /* @__PURE__ */ new bt(
+  "(prefers-reduced-motion: reduce)"
+), Ot = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   __proto__: null,
-  spring: D,
-  tweened: $
+  Spring: X,
+  Tween: Y,
+  prefersReducedMotion: kt,
+  spring: yt,
+  tweened: wt
 }, Symbol.toStringTag, { value: "Module" }));
 export {
-  B as i,
-  M as l,
-  p as r
+  Ot as i,
+  N as l,
+  l as r
 };