@nil-/xit 0.2.3 → 0.2.5

package/assets/svelte/internal/disclose-version.js

@@ -0,0 +1,3 @@
+const d = "5";
+var e;
+typeof window < "u" && ((e = window.__svelte ?? (window.__svelte = {})).v ?? (e.v = /* @__PURE__ */ new Set())).add(d);

package/assets/svelte/motion.js

@@ -0,0 +1,460 @@
+var et = (e) => {
+  throw TypeError(e);
+};
+var X = (e, t, s) => t.has(e) || et("Cannot " + s);
+var r = (e, t, s) => (X(e, t, "read from private field"), s ? s.call(e) : t.get(e)), a = (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, n) => (X(e, t, "write to private field"), n ? n.call(e, s) : t.set(e, s), s), st = (e, t, s) => (X(e, t, "access private method"), s);
+import "./internal/client.js";
+import { o as dt, b as S, c as rt, a as g, k as ut, n as lt, g as _ } from "./index.js";
+import { c as mt, w as nt } from "./store.js";
+import { linear as it } from "./easing.js";
+const pt = () => 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} _ */
+    (e) => requestAnimationFrame(e)
+  ),
+  now: () => pt(),
+  tasks: /* @__PURE__ */ new Set()
+};
+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 U(e) {
+  let t;
+  return l.tasks.size === 0 && l.tick(ot), {
+    promise: new Promise((s) => {
+      l.tasks.add(t = { c: e, f: s });
+    }),
+    abort() {
+      l.tasks.delete(t);
+    }
+  };
+}
+var V, B;
+class gt {
+  /**
+   *
+   * @param {() => T} fn
+   * @param {(update: () => void) => void} onsubscribe
+   */
+  constructor(t, s) {
+    a(this, V);
+    a(this, B);
+    h(this, V, t), h(this, B, mt(s));
+  }
+  get current() {
+    return r(this, B).call(this), r(this, V).call(this);
+  }
+}
+V = new WeakMap(), B = new WeakMap();
+const bt = /\(.+\)/;
+class yt extends gt {
+  /**
+   * @param {string} query A media query string
+   * @param {boolean} [fallback] Fallback value for the server
+   */
+  constructor(t, s) {
+    let n = bt.test(t) ? t : `(${t})`;
+    const o = window.matchMedia(n);
+    super(
+      () => o.matches,
+      (i) => dt(o, "change", i)
+    );
+  }
+}
+function J(e) {
+  return Object.prototype.toString.call(e) === "[object Date]";
+}
+function K(e, t, s, n) {
+  if (typeof s == "number" || J(s)) {
+    const o = n - s, i = (s - t) / (e.dt || 1 / 60), f = e.opts.stiffness * o, c = e.opts.damping * i, d = (f - c) * e.inv_mass, m = (i + d) * e.dt;
+    return Math.abs(m) < e.opts.precision && Math.abs(o) < e.opts.precision ? n : (e.settled = !1, J(s) ? new Date(s.getTime() + m) : s + m);
+  } else {
+    if (Array.isArray(s))
+      return s.map(
+        (o, i) => (
+          // @ts-ignore
+          K(e, t[i], s[i], n[i])
+        )
+      );
+    if (typeof s == "object") {
+      const o = {};
+      for (const i in s)
+        o[i] = K(e, t[i], s[i], n[i]);
+      return o;
+    } else
+      throw new Error(`Cannot spring ${typeof s} values`);
+  }
+}
+function wt(e, t = {}) {
+  const s = nt(e), { stiffness: n = 0.15, damping: o = 0.8, precision: i = 0.01 } = t;
+  let f, c, d, m = (
+    /** @type {T} */
+    e
+  ), b = (
+    /** @type {T | undefined} */
+    e
+  ), u = 1, P = 0, y = !1;
+  function A(O, w = {}) {
+    b = O;
+    const ct = d = {};
+    return e == null || w.hard || E.stiffness >= 1 && E.damping >= 1 ? (y = !0, f = l.now(), m = O, s.set(e = b), Promise.resolve()) : (w.soft && (P = 1 / ((w.soft === !0 ? 0.5 : +w.soft) * 60), u = 0), c || (f = l.now(), y = !1, c = U((Q) => {
+      if (y)
+        return y = !1, c = null, !1;
+      u = Math.min(u + P, 1);
+      const at = Math.min(Q - f, 1e3 / 30), W = {
+        inv_mass: u,
+        opts: E,
+        settled: !0,
+        dt: at * 60 / 1e3
+      }, ht = K(W, m, e, b);
+      return f = Q, m = /** @type {T} */
+      e, s.set(e = /** @type {T} */
+      ht), W.settled && (c = null), !W.settled;
+    })), new Promise((Q) => {
+      c.promise.then(() => {
+        ct === d && Q();
+      });
+    }));
+  }
+  const E = {
+    set: A,
+    update: (O, w) => A(O(
+      /** @type {T} */
+      b,
+      /** @type {T} */
+      e
+    ), w),
+    subscribe: s.subscribe,
+    stiffness: n,
+    damping: o,
+    precision: i
+  };
+  return E;
+}
+var z, D, T, p, j, C, q, R, G, k, x, N, ft;
+const v = class v {
+  /**
+   * @param {T} value
+   * @param {SpringOpts} [options]
+   */
+  constructor(t, s = {}) {
+    a(this, N);
+    a(this, z, S(0.15));
+    a(this, D, S(0.8));
+    a(this, T, S(0.01));
+    a(this, p, S(
+      /** @type {T} */
+      void 0
+    ));
+    a(this, j, S(
+      /** @type {T} */
+      void 0
+    ));
+    a(this, C);
+    a(this, q, 0);
+    a(this, R, 1);
+    a(this, G, 0);
+    /** @type {import('../internal/client/types').Task | null} */
+    a(this, k, null);
+    /** @type {ReturnType<typeof deferred> | null} */
+    a(this, x, null);
+    r(this, p).v = r(this, j).v = t, typeof s.stiffness == "number" && (r(this, z).v = I(s.stiffness, 0, 1)), typeof s.damping == "number" && (r(this, D).v = I(s.damping, 0, 1)), typeof s.precision == "number" && (r(this, T).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 n = new v(t(), s);
+    return rt(() => {
+      n.set(t());
+    }), n;
+  }
+  /**
+   * 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, i;
+    if ((o = r(this, x)) == null || o.reject(new Error("Aborted")), s != null && s.instant || r(this, p).v === void 0)
+      return (i = r(this, k)) == null || i.abort(), h(this, k, null), g(r(this, p), g(r(this, j), t)), h(this, C, t), Promise.resolve();
+    s != null && s.preserveMomentum && (h(this, R, 0), h(this, G, s.preserveMomentum));
+    var n = h(this, x, ut());
+    return n.promise.catch(lt), st(this, N, ft).call(this, t).then(() => {
+      n === r(this, x) && n.resolve(void 0);
+    }), n.promise;
+  }
+  get current() {
+    return _(r(this, p));
+  }
+  get damping() {
+    return _(r(this, D));
+  }
+  set damping(t) {
+    g(r(this, D), I(t, 0, 1));
+  }
+  get precision() {
+    return _(r(this, T));
+  }
+  set precision(t) {
+    g(r(this, T), t);
+  }
+  get stiffness() {
+    return _(r(this, z));
+  }
+  set stiffness(t) {
+    g(r(this, z), I(t, 0, 1));
+  }
+  get target() {
+    return _(r(this, j));
+  }
+  set target(t) {
+    this.set(t);
+  }
+};
+z = new WeakMap(), D = new WeakMap(), T = new WeakMap(), p = new WeakMap(), j = new WeakMap(), C = new WeakMap(), q = new WeakMap(), R = new WeakMap(), G = new WeakMap(), k = new WeakMap(), x = new WeakMap(), N = new WeakSet(), /** @param {T} value */
+ft = function(t) {
+  var n;
+  if (g(r(this, j), t), (n = r(this, p)).v ?? (n.v = t), r(this, C) ?? h(this, C, r(this, p).v), !r(this, k)) {
+    h(this, q, l.now());
+    var s = 1e3 / (r(this, G) * 60);
+    r(this, k) ?? h(this, k, U((o) => {
+      h(this, R, Math.min(r(this, R) + s, 1));
+      const i = Math.min(o - r(this, q), 1e3 / 30), f = {
+        inv_mass: r(this, R),
+        opts: {
+          stiffness: r(this, z).v,
+          damping: r(this, D).v,
+          precision: r(this, T).v
+        },
+        settled: !0,
+        dt: i * 60 / 1e3
+      };
+      var c = K(f, r(this, C), r(this, p).v, r(this, j).v);
+      return h(this, C, r(this, p).v), h(this, q, o), g(r(this, p), c), f.settled && h(this, k, null), !f.settled;
+    }));
+  }
+  return r(this, k).promise;
+};
+let Y = v;
+function I(e, t, s) {
+  return Math.max(t, Math.min(s, e));
+}
+function L(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(e)) {
+    const n = (
+      /** @type {Array<any>} */
+      t.map((o, i) => L(
+        /** @type {Array<any>} */
+        e[i],
+        o
+      ))
+    );
+    return (o) => n.map((i) => i(o));
+  }
+  if (s === "object") {
+    if (!e || !t)
+      throw new Error("Object cannot be null");
+    if (J(e) && J(t)) {
+      const i = e.getTime(), c = t.getTime() - i;
+      return (d) => new Date(i + d * c);
+    }
+    const n = Object.keys(t), o = {};
+    return n.forEach((i) => {
+      o[i] = L(e[i], t[i]);
+    }), (i) => {
+      const f = {};
+      return n.forEach((c) => {
+        f[c] = o[c](i);
+      }), f;
+    };
+  }
+  if (s === "number") {
+    const n = (
+      /** @type {number} */
+      t - /** @type {number} */
+      e
+    );
+    return (o) => e + o * n;
+  }
+  return () => t;
+}
+function kt(e, t = {}) {
+  const s = nt(e);
+  let n, o = e;
+  function i(f, c) {
+    if (o = f, e == null)
+      return s.set(e = f), Promise.resolve();
+    let d = n, m = !1, {
+      delay: b = 0,
+      duration: u = 400,
+      easing: P = it,
+      interpolate: y = L
+    } = { ...t, ...c };
+    if (u === 0)
+      return d && (d.abort(), d = null), s.set(e = o), Promise.resolve();
+    const A = l.now() + b;
+    let E;
+    return n = U((O) => {
+      if (O < A) return !0;
+      m || (E = y(
+        /** @type {any} */
+        e,
+        f
+      ), typeof u == "function" && (u = u(
+        /** @type {any} */
+        e,
+        f
+      )), m = !0), d && (d.abort(), d = null);
+      const w = O - A;
+      return w > /** @type {number} */
+      u ? (s.set(e = f), !1) : (s.set(e = E(P(w / u))), !0);
+    }), n.promise;
+  }
+  return {
+    set: i,
+    update: (f, c) => i(f(
+      /** @type {any} */
+      o,
+      /** @type {any} */
+      e
+    ), c),
+    subscribe: s.subscribe
+  };
+}
+var M, F, H, $;
+const tt = class tt {
+  /**
+   * @param {T} value
+   * @param {TweenedOptions<T>} options
+   */
+  constructor(t, s = {}) {
+    a(this, M, S(
+      /** @type {T} */
+      void 0
+    ));
+    a(this, F, S(
+      /** @type {T} */
+      void 0
+    ));
+    /** @type {TweenedOptions<T>} */
+    a(this, H);
+    /** @type {import('../internal/client/types').Task | null} */
+    a(this, $, null);
+    r(this, M).v = r(this, F).v = t, h(this, H, 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 n = new tt(t(), s);
+    return rt(() => {
+      n.set(t());
+    }), n;
+  }
+  /**
+   * 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) {
+    var u;
+    g(r(this, F), t);
+    let {
+      delay: n = 0,
+      duration: o = 400,
+      easing: i = it,
+      interpolate: f = L
+    } = { ...r(this, H), ...s };
+    if (o === 0)
+      return (u = r(this, $)) == null || u.abort(), g(r(this, M), t), Promise.resolve();
+    const c = l.now() + n;
+    let d, m = !1, b = r(this, $);
+    return h(this, $, U((P) => {
+      if (P < c)
+        return !0;
+      if (!m) {
+        m = !0;
+        const A = r(this, M).v;
+        d = f(A, t), typeof o == "function" && (o = o(A, t)), b == null || b.abort();
+      }
+      const y = P - c;
+      return y > /** @type {number} */
+      o ? (g(r(this, M), t), !1) : (g(r(this, M), d(i(y / /** @type {number} */
+      o))), !0);
+    })), r(this, $).promise;
+  }
+  get current() {
+    return _(r(this, M));
+  }
+  get target() {
+    return _(r(this, F));
+  }
+  set target(t) {
+    this.set(t);
+  }
+};
+M = new WeakMap(), F = new WeakMap(), H = new WeakMap(), $ = new WeakMap();
+let Z = tt;
+const Mt = /* @__PURE__ */ new yt(
+  "(prefers-reduced-motion: reduce)"
+), St = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Spring: Y,
+  Tween: Z,
+  prefersReducedMotion: Mt,
+  spring: wt,
+  tweened: kt
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  St as i,
+  U as l,
+  l as r
+};

package/assets/svelte/store.js

@@ -0,0 +1,173 @@
+import { n as l, u as w, s as B, r as C, a as E, e as j, g as M, b as P, c as k, t as T, d as y, f as h, h as m, i as S, j as $ } from "./index.js";
+import "./internal/client.js";
+function q(e, r, n) {
+  if (e == null)
+    return r(void 0), n && n(void 0), l;
+  const t = w(
+    () => e.subscribe(
+      r,
+      // @ts-expect-error
+      n
+    )
+  );
+  return t.unsubscribe ? () => t.unsubscribe() : t;
+}
+const b = [];
+function x(e, r) {
+  return {
+    subscribe: v(e, r).subscribe
+  };
+}
+function v(e, r = l) {
+  let n = null;
+  const t = /* @__PURE__ */ new Set();
+  function i(u) {
+    if (B(e, u) && (e = u, n)) {
+      const a = !b.length;
+      for (const s of t)
+        s[1](), b.push(s, e);
+      if (a) {
+        for (let s = 0; s < b.length; s += 2)
+          b[s][0](b[s + 1]);
+        b.length = 0;
+      }
+    }
+  }
+  function c(u) {
+    i(u(
+      /** @type {T} */
+      e
+    ));
+  }
+  function o(u, a = l) {
+    const s = [u, a];
+    return t.add(s), t.size === 1 && (n = r(i, c) || l), u(
+      /** @type {T} */
+      e
+    ), () => {
+      t.delete(s), t.size === 0 && n && (n(), n = null);
+    };
+  }
+  return { set: i, update: c, subscribe: o };
+}
+function D(e, r, n) {
+  const t = !Array.isArray(e), i = t ? [e] : e;
+  if (!i.every(Boolean))
+    throw new Error("derived() expects stores as input, got a falsy value");
+  const c = r.length < 2;
+  return x(n, (o, u) => {
+    let a = !1;
+    const s = [];
+    let d = 0, _ = l;
+    const g = () => {
+      if (d)
+        return;
+      _();
+      const f = r(t ? s[0] : s, o, u);
+      c ? o(f) : _ = typeof f == "function" ? f : l;
+    }, A = i.map(
+      (f, p) => q(
+        f,
+        (O) => {
+          s[p] = O, d &= ~(1 << p), a && g();
+        },
+        () => {
+          d |= 1 << p;
+        }
+      )
+    );
+    return a = !0, g(), function() {
+      C(A), _(), a = !1;
+    };
+  });
+}
+function F(e) {
+  return {
+    // @ts-expect-error TODO i suspect the bind is unnecessary
+    subscribe: e.subscribe.bind(e)
+  };
+}
+function z(e) {
+  let r;
+  return q(e, (n) => r = n)(), r;
+}
+function G(e) {
+  E(e, e.v + 1);
+}
+function H(e) {
+  let r = 0, n = P(0), t;
+  return () => {
+    j() && (M(n), k(() => (r === 0 && (t = w(() => e(() => G(n)))), r += 1, () => {
+      T().then(() => {
+        r -= 1, r === 0 && (t == null || t(), t = void 0);
+      });
+    })));
+  };
+}
+function I(e, r) {
+  var n = S, t = h, i = e();
+  const c = v(i, (o) => {
+    var u = i !== e(), a, s = h, d = S;
+    y(t), m(n);
+    try {
+      a = $(() => {
+        k(() => {
+          const _ = e();
+          u && o(_);
+        });
+      });
+    } finally {
+      y(s), m(d);
+    }
+    return u = !0, a;
+  });
+  return r ? {
+    set: r,
+    update: (o) => r(o(e())),
+    subscribe: c.subscribe
+  } : {
+    subscribe: c.subscribe
+  };
+}
+function J(e) {
+  let r;
+  const n = H((i) => {
+    let c = !1;
+    const o = e.subscribe((u) => {
+      r = u, c && i();
+    });
+    return c = !0, o;
+  });
+  function t() {
+    return j() ? (n(), r) : z(e);
+  }
+  return "set" in e ? {
+    get current() {
+      return t();
+    },
+    set current(i) {
+      e.set(i);
+    }
+  } : {
+    get current() {
+      return t();
+    }
+  };
+}
+const N = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  derived: D,
+  fromStore: J,
+  get: z,
+  readable: x,
+  readonly: F,
+  toStore: I,
+  writable: v
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  H as c,
+  z as g,
+  N as i,
+  q as s,
+  v as w
+};