@nil-/xit 0.4.15 → 0.4.16

package/assets/svelte/reactivity.js

@@ -0,0 +1,481 @@
+var le = Object.getPrototypeOf;
+var de = Reflect.get;
+var ee = (o) => {
+  throw TypeError(o);
+};
+var H = (o, a, e) => a.has(o) || ee("Cannot " + e);
+var s = (o, a, e) => (H(o, a, "read from private field"), e ? e.call(o) : a.get(o)), n = (o, a, e) => a.has(o) ? ee("Cannot add the same private member more than once") : a instanceof WeakSet ? a.add(o) : a.set(o, e), b = (o, a, e, t) => (H(o, a, "write to private field"), t ? t.call(o, e) : a.set(o, e), e), d = (o, a, e) => (H(o, a, "access private method"), e);
+var se = (o, a, e) => de(le(o), e, a);
+import { b as p, f as te, g as r, d as re, k as ve, a as u, o as me } from "./index.js";
+import "./internal/client.js";
+import { i as f, c as ge } from "./store.js";
+var ie = !1, k, N, Q, V, oe;
+const X = class X extends Date {
+  /** @param {any[]} params */
+  constructor(...e) {
+    super(...e);
+    n(this, V);
+    n(this, k, p(super.getTime()));
+    /** @type {Map<keyof Date, Source<unknown>>} */
+    n(this, N, /* @__PURE__ */ new Map());
+    n(this, Q, te);
+    ie || d(this, V, oe).call(this);
+  }
+};
+k = new WeakMap(), N = new WeakMap(), Q = new WeakMap(), V = new WeakSet(), oe = function() {
+  ie = !0;
+  var e = X.prototype, t = Date.prototype, i = (
+    /** @type {Array<keyof Date & string>} */
+    Object.getOwnPropertyNames(t)
+  );
+  for (const h of i)
+    (h.startsWith("get") || h.startsWith("to") || h === "valueOf") && (e[h] = function(...z) {
+      if (z.length > 0)
+        return r(s(this, k)), t[h].apply(this, z);
+      var _ = s(this, N).get(h);
+      if (_ === void 0) {
+        const M = te;
+        re(s(this, Q)), _ = ve(() => (r(s(this, k)), t[h].apply(this, z))), s(this, N).set(h, _), re(M);
+      }
+      return r(_);
+    }), h.startsWith("set") && (e[h] = function(...z) {
+      var _ = t[h].apply(this, z);
+      return u(s(this, k), t.getTime.call(this)), _;
+    });
+};
+let he = X;
+var we = ["forEach", "isDisjointFrom", "isSubsetOf", "isSupersetOf"], ze = ["difference", "intersection", "symmetricDifference", "union"], ue = !1, D, l, P, B, pe;
+const G = class G extends Set {
+  /**
+   * @param {Iterable<T> | null | undefined} [value]
+   */
+  constructor(e) {
+    super();
+    n(this, B);
+    /** @type {Map<T, Source<boolean>>} */
+    n(this, D, /* @__PURE__ */ new Map());
+    n(this, l, p(0));
+    n(this, P, p(0));
+    if (e) {
+      for (var t of e)
+        super.add(t);
+      s(this, P).v = super.size;
+    }
+    ue || d(this, B, pe).call(this);
+  }
+  /** @param {T} value */
+  has(e) {
+    var t = super.has(e), i = s(this, D), h = i.get(e);
+    if (h === void 0) {
+      if (!t)
+        return r(s(this, l)), !1;
+      h = p(!0), i.set(e, h);
+    }
+    return r(h), t;
+  }
+  /** @param {T} value */
+  add(e) {
+    return super.has(e) || (super.add(e), u(s(this, P), super.size), f(s(this, l))), this;
+  }
+  /** @param {T} value */
+  delete(e) {
+    var t = super.delete(e), i = s(this, D), h = i.get(e);
+    return h !== void 0 && (i.delete(e), u(h, !1)), t && (u(s(this, P), super.size), f(s(this, l))), t;
+  }
+  clear() {
+    if (super.size !== 0) {
+      super.clear();
+      var e = s(this, D);
+      for (var t of e.values())
+        u(t, !1);
+      e.clear(), u(s(this, P), 0), f(s(this, l));
+    }
+  }
+  keys() {
+    return this.values();
+  }
+  values() {
+    return r(s(this, l)), super.values();
+  }
+  entries() {
+    return r(s(this, l)), super.entries();
+  }
+  [Symbol.iterator]() {
+    return this.keys();
+  }
+  get size() {
+    return r(s(this, P));
+  }
+};
+D = new WeakMap(), l = new WeakMap(), P = new WeakMap(), B = new WeakSet(), // We init as part of the first instance so that we can treeshake this class
+pe = function() {
+  ue = !0;
+  var e = G.prototype, t = Set.prototype;
+  for (const i of we)
+    e[i] = function(...h) {
+      return r(s(this, l)), t[i].apply(this, h);
+    };
+  for (const i of ze)
+    e[i] = function(...h) {
+      r(s(this, l));
+      var z = (
+        /** @type {Set<T>} */
+        t[i].apply(this, h)
+      );
+      return new G(z);
+    };
+};
+let ae = G;
+var v, m, y, W, J;
+const Y = class Y extends Map {
+  /**
+   * @param {Iterable<readonly [K, V]> | null | undefined} [value]
+   */
+  constructor(e) {
+    super();
+    n(this, W);
+    /** @type {Map<K, Source<number>>} */
+    n(this, v, /* @__PURE__ */ new Map());
+    n(this, m, p(0));
+    n(this, y, p(0));
+    if (e) {
+      for (var [t, i] of e)
+        super.set(t, i);
+      s(this, y).v = super.size;
+    }
+  }
+  /** @param {K} key */
+  has(e) {
+    var t = s(this, v), i = t.get(e);
+    if (i === void 0) {
+      var h = super.get(e);
+      if (h !== void 0)
+        i = p(0), t.set(e, i);
+      else
+        return r(s(this, m)), !1;
+    }
+    return r(i), !0;
+  }
+  /**
+   * @param {(value: V, key: K, map: Map<K, V>) => void} callbackfn
+   * @param {any} [this_arg]
+   */
+  forEach(e, t) {
+    d(this, W, J).call(this), super.forEach(e, t);
+  }
+  /** @param {K} key */
+  get(e) {
+    var t = s(this, v), i = t.get(e);
+    if (i === void 0) {
+      var h = super.get(e);
+      if (h !== void 0)
+        i = p(0), t.set(e, i);
+      else {
+        r(s(this, m));
+        return;
+      }
+    }
+    return r(i), super.get(e);
+  }
+  /**
+   * @param {K} key
+   * @param {V} value
+   * */
+  set(e, t) {
+    var q;
+    var i = s(this, v), h = i.get(e), z = super.get(e), _ = super.set(e, t), M = s(this, m);
+    if (h === void 0)
+      i.set(e, p(0)), u(s(this, y), super.size), f(M);
+    else if (z !== t) {
+      f(h);
+      var Z = M.reactions === null ? null : new Set(M.reactions), ce = Z === null || !((q = h.reactions) != null && q.every(
+        (fe) => (
+          /** @type {NonNullable<typeof v_reactions>} */
+          Z.has(fe)
+        )
+      ));
+      ce && f(M);
+    }
+    return _;
+  }
+  /** @param {K} key */
+  delete(e) {
+    var t = s(this, v), i = t.get(e), h = super.delete(e);
+    return i !== void 0 && (t.delete(e), u(s(this, y), super.size), u(i, -1), f(s(this, m))), h;
+  }
+  clear() {
+    if (super.size !== 0) {
+      super.clear();
+      var e = s(this, v);
+      u(s(this, y), 0);
+      for (var t of e.values())
+        u(t, -1);
+      f(s(this, m)), e.clear();
+    }
+  }
+  keys() {
+    return r(s(this, m)), super.keys();
+  }
+  values() {
+    return d(this, W, J).call(this), super.values();
+  }
+  entries() {
+    return d(this, W, J).call(this), super.entries();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get size() {
+    return r(s(this, y)), super.size;
+  }
+};
+v = new WeakMap(), m = new WeakMap(), y = new WeakMap(), W = new WeakSet(), J = function() {
+  r(s(this, m));
+  var e = s(this, v);
+  if (s(this, y).v !== e.size)
+    for (var t of se(Y.prototype, this, "keys").call(this))
+      e.has(t) || e.set(t, p(0));
+  for (var [, i] of s(this, v))
+    r(i);
+};
+let ne = Y;
+const I = Symbol();
+var c, T, S, R, $;
+class ye extends URLSearchParams {
+  constructor() {
+    super(...arguments);
+    n(this, R);
+    n(this, c, p(0));
+    n(this, T, Se());
+    n(this, S, !1);
+  }
+  /**
+   * @param {URLSearchParams} params
+   * @internal
+   */
+  [I](e) {
+    if (!s(this, S)) {
+      b(this, S, !0);
+      for (const t of [...super.keys()])
+        super.delete(t);
+      for (const [t, i] of e)
+        super.append(t, i);
+      f(s(this, c)), b(this, S, !1);
+    }
+  }
+  /**
+   * @param {string} name
+   * @param {string} value
+   * @returns {void}
+   */
+  append(e, t) {
+    super.append(e, t), d(this, R, $).call(this), f(s(this, c));
+  }
+  /**
+   * @param {string} name
+   * @param {string=} value
+   * @returns {void}
+   */
+  delete(e, t) {
+    var i = super.has(e, t);
+    super.delete(e, t), i && (d(this, R, $).call(this), f(s(this, c)));
+  }
+  /**
+   * @param {string} name
+   * @returns {string|null}
+   */
+  get(e) {
+    return r(s(this, c)), super.get(e);
+  }
+  /**
+   * @param {string} name
+   * @returns {string[]}
+   */
+  getAll(e) {
+    return r(s(this, c)), super.getAll(e);
+  }
+  /**
+   * @param {string} name
+   * @param {string=} value
+   * @returns {boolean}
+   */
+  has(e, t) {
+    return r(s(this, c)), super.has(e, t);
+  }
+  keys() {
+    return r(s(this, c)), super.keys();
+  }
+  /**
+   * @param {string} name
+   * @param {string} value
+   * @returns {void}
+   */
+  set(e, t) {
+    var i = super.getAll(e).join("");
+    super.set(e, t), i !== super.getAll(e).join("") && (d(this, R, $).call(this), f(s(this, c)));
+  }
+  sort() {
+    super.sort(), d(this, R, $).call(this), f(s(this, c));
+  }
+  toString() {
+    return r(s(this, c)), super.toString();
+  }
+  values() {
+    return r(s(this, c)), super.values();
+  }
+  entries() {
+    return r(s(this, c)), super.entries();
+  }
+  [Symbol.iterator]() {
+    return this.entries();
+  }
+  get size() {
+    return r(s(this, c)), super.size;
+  }
+}
+c = new WeakMap(), T = new WeakMap(), S = new WeakMap(), R = new WeakSet(), $ = function() {
+  if (!s(this, T) || s(this, S)) return;
+  b(this, S, !0);
+  const e = this.toString();
+  s(this, T).search = e && `?${e}`, b(this, S, !1);
+};
+let K = null;
+function Se() {
+  return K;
+}
+var x, L, O, g, w, A, E, U, j;
+class Ae extends URL {
+  /**
+   * @param {string | URL} url
+   * @param {string | URL} [base]
+   */
+  constructor(e, t) {
+    e = new URL(e, t);
+    super(e);
+    n(this, x, p(super.protocol));
+    n(this, L, p(super.username));
+    n(this, O, p(super.password));
+    n(this, g, p(super.hostname));
+    n(this, w, p(super.port));
+    n(this, A, p(super.pathname));
+    n(this, E, p(super.hash));
+    n(this, U, p(super.search));
+    n(this, j);
+    K = this, b(this, j, new ye(e.searchParams)), K = null;
+  }
+  get hash() {
+    return r(s(this, E));
+  }
+  set hash(e) {
+    super.hash = e, u(s(this, E), super.hash);
+  }
+  get host() {
+    return r(s(this, g)), r(s(this, w)), super.host;
+  }
+  set host(e) {
+    super.host = e, u(s(this, g), super.hostname), u(s(this, w), super.port);
+  }
+  get hostname() {
+    return r(s(this, g));
+  }
+  set hostname(e) {
+    super.hostname = e, u(s(this, g), super.hostname);
+  }
+  get href() {
+    return r(s(this, x)), r(s(this, L)), r(s(this, O)), r(s(this, g)), r(s(this, w)), r(s(this, A)), r(s(this, E)), r(s(this, U)), super.href;
+  }
+  set href(e) {
+    super.href = e, u(s(this, x), super.protocol), u(s(this, L), super.username), u(s(this, O), super.password), u(s(this, g), super.hostname), u(s(this, w), super.port), u(s(this, A), super.pathname), u(s(this, E), super.hash), u(s(this, U), super.search), s(this, j)[I](super.searchParams);
+  }
+  get password() {
+    return r(s(this, O));
+  }
+  set password(e) {
+    super.password = e, u(s(this, O), super.password);
+  }
+  get pathname() {
+    return r(s(this, A));
+  }
+  set pathname(e) {
+    super.pathname = e, u(s(this, A), super.pathname);
+  }
+  get port() {
+    return r(s(this, w));
+  }
+  set port(e) {
+    super.port = e, u(s(this, w), super.port);
+  }
+  get protocol() {
+    return r(s(this, x));
+  }
+  set protocol(e) {
+    super.protocol = e, u(s(this, x), super.protocol);
+  }
+  get search() {
+    return r(s(this, U));
+  }
+  set search(e) {
+    super.search = e, u(s(this, U), e), s(this, j)[I](super.searchParams);
+  }
+  get username() {
+    return r(s(this, L));
+  }
+  set username(e) {
+    super.username = e, u(s(this, L), super.username);
+  }
+  get origin() {
+    return r(s(this, x)), r(s(this, g)), r(s(this, w)), super.origin;
+  }
+  get searchParams() {
+    return s(this, j);
+  }
+  toString() {
+    return this.href;
+  }
+  toJSON() {
+    return this.href;
+  }
+}
+x = new WeakMap(), L = new WeakMap(), O = new WeakMap(), g = new WeakMap(), w = new WeakMap(), A = new WeakMap(), E = new WeakMap(), U = new WeakMap(), j = new WeakMap();
+var C, F;
+class _e {
+  /**
+   *
+   * @param {() => T} fn
+   * @param {(update: () => void) => void} onsubscribe
+   */
+  constructor(a, e) {
+    n(this, C);
+    n(this, F);
+    b(this, C, a), b(this, F, ge(e));
+  }
+  get current() {
+    return s(this, F).call(this), s(this, C).call(this);
+  }
+}
+C = new WeakMap(), F = new WeakMap();
+const be = /\(.+\)/, Pe = /* @__PURE__ */ new Set(["all", "print", "screen", "and", "or", "not", "only"]);
+class Ee extends _e {
+  /**
+   * @param {string} query A media query string
+   * @param {boolean} [fallback] Fallback value for the server
+   */
+  constructor(a, e) {
+    let t = be.test(a) || // we need to use `some` here because technically this `window.matchMedia('random,screen')` still returns true
+    a.split(/[\s,]+/).some((h) => Pe.has(h.trim())) ? a : `(${a})`;
+    const i = window.matchMedia(t);
+    super(
+      () => i.matches,
+      (h) => me(i, "change", h)
+    );
+  }
+}
+export {
+  Ee as MediaQuery,
+  he as SvelteDate,
+  ne as SvelteMap,
+  ae as SvelteSet,
+  Ae as SvelteURL,
+  ye as SvelteURLSearchParams,
+  ge as createSubscriber
+};

package/assets/svelte/store.js

@@ -165,9 +165,10 @@ const N = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
   writable: v
 }, Symbol.toStringTag, { value: "Module" }));
 export {
+  N as a,
   H as c,
   z as g,
-  N as i,
+  G as i,
   q as s,
   v as w
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nil-/xit",
-  "version": "0.4.15",
+  "version": "0.4.16",
   "peerDependencies": {
     "svelte": "^5.7.1"
   },

package/test/Main.svelte

@@ -31,16 +31,16 @@
                     </Scrollable>
                 {/snippet}
                 {#snippet side_b()}
-                    <div class="combo">
-                        <select bind:value={selected}>
-                            {#each tags as id, i}
-                                <option value={i}>{id}</option>
-                            {/each}
-                        </select>
-                    </div>
-                    {#if 0 <= selected && selected < tags.length }
-                    {@render children?.(tags[selected])}
-                        <div style="display: flex; flex-direction: column;">
+                    <div style="display: flex; flex-direction: column;">
+                        <div class="combo">
+                            <select bind:value={selected}>
+                                {#each tags as id, i}
+                                    <option value={i}>{id}</option>
+                                {/each}
+                            </select>
+                        </div>
+                        {#if 0 <= selected && selected < tags.length }
+                            {@render children?.(tags[selected])}
                             {#each inputs as { name, url }}
                                 {#if input != null}
                                     {@render input({ name, url: url(tags[selected]) })}
@@ -48,8 +48,8 @@
                                     <a href={url(tags[selected])} target="_blank">{name}</a>
                                 {/if}
                             {/each}
-                        </div>
-                    {/if}
+                        {/if}
+                    </div>
                 {/snippet}
             </Split>
         </Scrollable>