@picked/svelte 0.0.0-chore-version-and-release-packages.1733366498981-3517ab4

package/dist/App.svelte.d.ts

@@ -0,0 +1 @@
+export { SvelteComponent as default } from 'svelte';

package/dist/adapter.d.ts

@@ -0,0 +1,3 @@
+import { AdaptedBlock } from '@picked/client';
+import { BlockComponent } from './types';
+export declare const adapter: (id: string, component: BlockComponent) => AdaptedBlock<"svelte", BlockComponent>;

package/dist/components/ShadowRoot/ShadowRoot.svelte.d.ts

@@ -0,0 +1 @@
+export { SvelteComponent as default } from 'svelte';

package/dist/components/Zone/Zone.svelte.d.ts

@@ -0,0 +1 @@
+export { SvelteComponent as default } from 'svelte';

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { mount } from './mount';
+export { default as Zone } from './components/Zone/Zone.svelte';
+export { adapter } from './adapter';
+export { default as App } from './App.svelte';

package/dist/index.js

@@ -0,0 +1,1001 @@
+import { addEventListener as yt } from "@picked/client";
+const on = !1;
+var fn = Array.isArray, sn = Array.from, an = Object.defineProperty, z = Object.getOwnPropertyDescriptor, cn = Object.getOwnPropertyDescriptors, _n = Object.getPrototypeOf;
+function vn(t) {
+  return t();
+}
+function Q(t) {
+  for (var n = 0; n < t.length; n++)
+    t[n]();
+}
+const S = 2, Nt = 4, G = 8, ft = 16, x = 32, I = 64, C = 128, W = 256, y = 512, D = 1024, L = 2048, Ct = 4096, j = 8192, dn = 16384, pn = 65536, hn = 1 << 18, Rt = 1 << 19, X = Symbol("$state");
+function At(t) {
+  return t === this.v;
+}
+function wn(t, n) {
+  return t != t ? n == n : t !== n || t !== null && typeof t == "object" || typeof t == "function";
+}
+function qt(t) {
+  return !wn(t, this.v);
+}
+function En(t) {
+  throw new Error("effect_in_teardown");
+}
+function yn() {
+  throw new Error("effect_in_unowned_derived");
+}
+function mn(t) {
+  throw new Error("effect_orphan");
+}
+function gn() {
+  throw new Error("effect_update_depth_exceeded");
+}
+function bn(t) {
+  throw new Error("props_invalid_value");
+}
+function kn() {
+  throw new Error("state_unsafe_local_read");
+}
+function Sn() {
+  throw new Error("state_unsafe_mutation");
+}
+function Ft(t) {
+  return {
+    f: 0,
+    // TODO ideally we could skip this altogether, but it causes type errors
+    v: t,
+    reactions: null,
+    equals: At,
+    version: 0
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function xn(t, n = !1) {
+  var e;
+  const r = Ft(t);
+  return n || (r.equals = qt), d !== null && d.l !== null && ((e = d.l).s ?? (e.s = [])).push(r), r;
+}
+function Pt(t, n = !1) {
+  return /* @__PURE__ */ Tn(/* @__PURE__ */ xn(t, n));
+}
+// @__NO_SIDE_EFFECTS__
+function Tn(t) {
+  return _ !== null && _.f & S && (k === null ? Yn([t]) : k.push(t)), t;
+}
+function Mt(t, n) {
+  return _ !== null && vt() && _.f & (S | ft) && // If the source was created locally within the current derived, then
+  // we allow the mutation.
+  (k === null || !k.includes(t)) && Sn(), On(t, n);
+}
+function On(t, n) {
+  return t.equals(n) || (t.v = n, t.version = Qt(), It(t, D), vt() && a !== null && a.f & y && !(a.f & x) && (w !== null && w.includes(t) ? (T(a, D), Z(a)) : O === null ? $n([t]) : O.push(t))), n;
+}
+function It(t, n) {
+  var r = t.reactions;
+  if (r !== null)
+    for (var e = vt(), u = r.length, l = 0; l < u; l++) {
+      var o = r[l], i = o.f;
+      i & D || !e && o === a || (T(o, n), i & (y | C) && (i & S ? It(
+        /** @type {Derived} */
+        o,
+        L
+      ) : Z(
+        /** @type {Effect} */
+        o
+      )));
+    }
+}
+const Dn = 1, Nn = 2, Cn = 2;
+var mt, Lt, jt;
+function Rn() {
+  if (mt === void 0) {
+    mt = window;
+    var t = Element.prototype, n = Node.prototype;
+    Lt = z(n, "firstChild").get, jt = z(n, "nextSibling").get, t.__click = void 0, t.__className = "", t.__attributes = null, t.__styles = null, t.__e = void 0, Text.prototype.__t = void 0;
+  }
+}
+function An(t = "") {
+  return document.createTextNode(t);
+}
+// @__NO_SIDE_EFFECTS__
+function Vt(t) {
+  return Lt.call(t);
+}
+// @__NO_SIDE_EFFECTS__
+function Bt(t) {
+  return jt.call(t);
+}
+function H(t, n) {
+  return /* @__PURE__ */ Vt(t);
+}
+function gt(t, n = 1, r = !1) {
+  let e = t;
+  for (; n--; )
+    e = /** @type {TemplateNode} */
+    /* @__PURE__ */ Bt(e);
+  return e;
+}
+// @__NO_SIDE_EFFECTS__
+function st(t) {
+  var n = S | D;
+  a === null ? n |= C : a.f |= Rt;
+  const r = {
+    children: null,
+    ctx: d,
+    deps: null,
+    equals: At,
+    f: n,
+    fn: t,
+    reactions: null,
+    v: (
+      /** @type {V} */
+      null
+    ),
+    version: 0,
+    parent: a
+  };
+  if (_ !== null && _.f & S) {
+    var e = (
+      /** @type {Derived} */
+      _
+    );
+    (e.children ?? (e.children = [])).push(r);
+  }
+  return r;
+}
+// @__NO_SIDE_EFFECTS__
+function qn(t) {
+  const n = /* @__PURE__ */ st(t);
+  return n.equals = qt, n;
+}
+function Ut(t) {
+  var n = t.children;
+  if (n !== null) {
+    t.children = null;
+    for (var r = 0; r < n.length; r += 1) {
+      var e = n[r];
+      e.f & S ? at(
+        /** @type {Derived} */
+        e
+      ) : B(
+        /** @type {Effect} */
+        e
+      );
+    }
+  }
+}
+function Yt(t) {
+  var n, r = a;
+  N(t.parent);
+  try {
+    Ut(t), n = Xt(t);
+  } finally {
+    N(r);
+  }
+  return n;
+}
+function $t(t) {
+  var n = Yt(t), r = (A || t.f & C) && t.deps !== null ? L : y;
+  T(t, r), t.equals(n) || (t.v = n, t.version = Qt());
+}
+function at(t) {
+  Ut(t), M(t, 0), T(t, j), t.v = t.children = t.deps = t.ctx = t.reactions = null;
+}
+function Ht(t) {
+  a === null && _ === null && mn(), _ !== null && _.f & C && yn(), _t && En();
+}
+function Fn(t, n) {
+  var r = n.last;
+  r === null ? n.last = n.first = t : (r.next = t, t.prev = r, n.last = t);
+}
+function V(t, n, r, e = !0) {
+  var u = (t & I) !== 0, l = a, o = {
+    ctx: d,
+    deps: null,
+    deriveds: null,
+    nodes_start: null,
+    nodes_end: null,
+    f: t | D,
+    first: null,
+    fn: n,
+    last: null,
+    next: null,
+    parent: u ? null : l,
+    prev: null,
+    teardown: null,
+    transitions: null,
+    version: 0
+  };
+  if (r) {
+    var i = q;
+    try {
+      kt(!0), dt(o), o.f |= dn;
+    } catch (v) {
+      throw B(o), v;
+    } finally {
+      kt(i);
+    }
+  } else n !== null && Z(o);
+  var f = r && o.deps === null && o.first === null && o.nodes_start === null && o.teardown === null && (o.f & Rt) === 0;
+  if (!f && !u && e && (l !== null && Fn(o, l), _ !== null && _.f & S)) {
+    var s = (
+      /** @type {Derived} */
+      _
+    );
+    (s.children ?? (s.children = [])).push(o);
+  }
+  return o;
+}
+function tt(t) {
+  Ht();
+  var n = a !== null && (a.f & x) !== 0 && d !== null && !d.m;
+  if (n) {
+    var r = (
+      /** @type {ComponentContext} */
+      d
+    );
+    (r.e ?? (r.e = [])).push({
+      fn: t,
+      effect: a,
+      reaction: _
+    });
+  } else {
+    var e = ct(t);
+    return e;
+  }
+}
+function Pn(t) {
+  return Ht(), Wt(t);
+}
+function Mn(t) {
+  const n = V(I, t, !0);
+  return () => {
+    B(n);
+  };
+}
+function ct(t) {
+  return V(Nt, t, !1);
+}
+function Wt(t) {
+  return V(G, t, !0);
+}
+function bt(t) {
+  return In(t);
+}
+function In(t, n = 0) {
+  return V(G | ft | n, t, !0);
+}
+function Ln(t, n = !0) {
+  return V(G | x, t, !0, n);
+}
+function Kt(t) {
+  var n = t.teardown;
+  if (n !== null) {
+    const r = _t, e = _;
+    St(!0), F(null);
+    try {
+      n.call(null);
+    } finally {
+      St(r), F(e);
+    }
+  }
+}
+function Gt(t) {
+  var n = t.deriveds;
+  if (n !== null) {
+    t.deriveds = null;
+    for (var r = 0; r < n.length; r += 1)
+      at(n[r]);
+  }
+}
+function Jt(t, n = !1) {
+  var r = t.first;
+  for (t.first = t.last = null; r !== null; ) {
+    var e = r.next;
+    B(r, n), r = e;
+  }
+}
+function jn(t) {
+  for (var n = t.first; n !== null; ) {
+    var r = n.next;
+    n.f & x || B(n), n = r;
+  }
+}
+function B(t, n = !0) {
+  var r = !1;
+  if ((n || t.f & hn) && t.nodes_start !== null) {
+    for (var e = t.nodes_start, u = t.nodes_end; e !== null; ) {
+      var l = e === u ? null : (
+        /** @type {TemplateNode} */
+        /* @__PURE__ */ Bt(e)
+      );
+      e.remove(), e = l;
+    }
+    r = !0;
+  }
+  Jt(t, n && !r), Gt(t), M(t, 0), T(t, j);
+  var o = t.transitions;
+  if (o !== null)
+    for (const f of o)
+      f.stop();
+  Kt(t);
+  var i = t.parent;
+  i !== null && i.first !== null && Zt(t), t.next = t.prev = t.teardown = t.ctx = t.deps = t.parent = t.fn = t.nodes_start = t.nodes_end = null;
+}
+function Zt(t) {
+  var n = t.parent, r = t.prev, e = t.next;
+  r !== null && (r.next = e), e !== null && (e.prev = r), n !== null && (n.first === t && (n.first = e), n.last === t && (n.last = r));
+}
+let nt = !1, rt = [];
+function Vn() {
+  nt = !1;
+  const t = rt.slice();
+  rt = [], Q(t);
+}
+function Bn(t) {
+  nt || (nt = !0, queueMicrotask(Vn)), rt.push(t);
+}
+function Un(t) {
+  throw new Error("lifecycle_outside_component");
+}
+let K = !1, q = !1, _t = !1;
+function kt(t) {
+  q = t;
+}
+function St(t) {
+  _t = t;
+}
+let et = [], P = 0;
+let _ = null;
+function F(t) {
+  _ = t;
+}
+let a = null;
+function N(t) {
+  a = t;
+}
+let k = null;
+function Yn(t) {
+  k = t;
+}
+let w = null, E = 0, O = null;
+function $n(t) {
+  O = t;
+}
+let zt = 0, A = !1, d = null;
+function Qt() {
+  return ++zt;
+}
+function vt() {
+  return d !== null && d.l === null;
+}
+function J(t) {
+  var o, i;
+  var n = t.f;
+  if (n & D)
+    return !0;
+  if (n & L) {
+    var r = t.deps, e = (n & C) !== 0;
+    if (r !== null) {
+      var u;
+      if (n & W) {
+        for (u = 0; u < r.length; u++)
+          ((o = r[u]).reactions ?? (o.reactions = [])).push(t);
+        t.f ^= W;
+      }
+      for (u = 0; u < r.length; u++) {
+        var l = r[u];
+        if (J(
+          /** @type {Derived} */
+          l
+        ) && $t(
+          /** @type {Derived} */
+          l
+        ), e && a !== null && !A && !((i = l == null ? void 0 : l.reactions) != null && i.includes(t)) && (l.reactions ?? (l.reactions = [])).push(t), l.version > t.version)
+          return !0;
+      }
+    }
+    e || T(t, y);
+  }
+  return !1;
+}
+function Hn(t, n, r) {
+  throw t;
+}
+function Xt(t) {
+  var p;
+  var n = w, r = E, e = O, u = _, l = A, o = k, i = d, f = t.f;
+  w = /** @type {null | Value[]} */
+  null, E = 0, O = null, _ = f & (x | I) ? null : t, A = !q && (f & C) !== 0, k = null, d = t.ctx;
+  try {
+    var s = (
+      /** @type {Function} */
+      (0, t.fn)()
+    ), v = t.deps;
+    if (w !== null) {
+      var c;
+      if (M(t, E), v !== null && E > 0)
+        for (v.length = E + w.length, c = 0; c < w.length; c++)
+          v[E + c] = w[c];
+      else
+        t.deps = v = w;
+      if (!A)
+        for (c = E; c < v.length; c++)
+          ((p = v[c]).reactions ?? (p.reactions = [])).push(t);
+    } else v !== null && E < v.length && (M(t, E), v.length = E);
+    return s;
+  } finally {
+    w = n, E = r, O = e, _ = u, A = l, k = o, d = i;
+  }
+}
+function Wn(t, n) {
+  let r = n.reactions;
+  if (r !== null) {
+    var e = r.indexOf(t);
+    if (e !== -1) {
+      var u = r.length - 1;
+      u === 0 ? r = n.reactions = null : (r[e] = r[u], r.pop());
+    }
+  }
+  r === null && n.f & S && // Destroying a child effect while updating a parent effect can cause a dependency to appear
+  // to be unused, when in fact it is used by the currently-updating parent. Checking `new_deps`
+  // allows us to skip the expensive work of disconnecting and immediately reconnecting it
+  (w === null || !w.includes(n)) && (T(n, L), n.f & (C | W) || (n.f ^= W), M(
+    /** @type {Derived} **/
+    n,
+    0
+  ));
+}
+function M(t, n) {
+  var r = t.deps;
+  if (r !== null)
+    for (var e = n; e < r.length; e++)
+      Wn(t, r[e]);
+}
+function dt(t) {
+  var n = t.f;
+  if (!(n & j)) {
+    T(t, y);
+    var r = a;
+    a = t;
+    try {
+      n & ft ? jn(t) : Jt(t), Gt(t), Kt(t);
+      var e = Xt(t);
+      t.teardown = typeof e == "function" ? e : null, t.version = zt;
+    } catch (u) {
+      Hn(
+        /** @type {Error} */
+        u
+      );
+    } finally {
+      a = r;
+    }
+  }
+}
+function Kn() {
+  P > 1e3 && (P = 0, gn()), P++;
+}
+function Gn(t) {
+  var n = t.length;
+  if (n !== 0) {
+    Kn();
+    var r = q;
+    q = !0;
+    try {
+      for (var e = 0; e < n; e++) {
+        var u = t[e];
+        u.f & y || (u.f ^= y);
+        var l = [];
+        tn(u, l), Jn(l);
+      }
+    } finally {
+      q = r;
+    }
+  }
+}
+function Jn(t) {
+  var n = t.length;
+  if (n !== 0)
+    for (var r = 0; r < n; r++) {
+      var e = t[r];
+      !(e.f & (j | Ct)) && J(e) && (dt(e), e.deps === null && e.first === null && e.nodes_start === null && (e.teardown === null ? Zt(e) : e.fn = null));
+    }
+}
+function Zn() {
+  if (K = !1, P > 1001)
+    return;
+  const t = et;
+  et = [], Gn(t), K || (P = 0);
+}
+function Z(t) {
+  K || (K = !0, queueMicrotask(Zn));
+  for (var n = t; n.parent !== null; ) {
+    n = n.parent;
+    var r = n.f;
+    if (r & (I | x)) {
+      if (!(r & y)) return;
+      n.f ^= y;
+    }
+  }
+  et.push(n);
+}
+function tn(t, n) {
+  var r = t.first, e = [];
+  t: for (; r !== null; ) {
+    var u = r.f, l = (u & x) !== 0, o = l && (u & y) !== 0;
+    if (!o && !(u & Ct))
+      if (u & G) {
+        l ? r.f ^= y : J(r) && dt(r);
+        var i = r.first;
+        if (i !== null) {
+          r = i;
+          continue;
+        }
+      } else u & Nt && e.push(r);
+    var f = r.next;
+    if (f === null) {
+      let c = r.parent;
+      for (; c !== null; ) {
+        if (t === c)
+          break t;
+        var s = c.next;
+        if (s !== null) {
+          r = s;
+          continue t;
+        }
+        c = c.parent;
+      }
+    }
+    r = f;
+  }
+  for (var v = 0; v < e.length; v++)
+    i = e[v], n.push(i), tn(i, n);
+}
+function g(t) {
+  var i;
+  var n = t.f, r = (n & S) !== 0;
+  if (r && n & j) {
+    var e = Yt(
+      /** @type {Derived} */
+      t
+    );
+    return at(
+      /** @type {Derived} */
+      t
+    ), e;
+  }
+  if (_ !== null) {
+    k !== null && k.includes(t) && kn();
+    var u = _.deps;
+    w === null && u !== null && u[E] === t ? E++ : w === null ? w = [t] : w.push(t), O !== null && a !== null && a.f & y && !(a.f & x) && O.includes(t) && (T(a, D), Z(a));
+  } else if (r && /** @type {Derived} */
+  t.deps === null) {
+    var l = (
+      /** @type {Derived} */
+      t
+    ), o = l.parent;
+    o !== null && !((i = o.deriveds) != null && i.includes(l)) && (o.deriveds ?? (o.deriveds = [])).push(l);
+  }
+  return r && (l = /** @type {Derived} */
+  t, J(l) && $t(l)), t.v;
+}
+function pt(t) {
+  const n = _;
+  try {
+    return _ = null, t();
+  } finally {
+    _ = n;
+  }
+}
+const zn = ~(D | L | y);
+function T(t, n) {
+  t.f = t.f & zn | n;
+}
+function ht(t, n = !1, r) {
+  d = {
+    p: d,
+    c: null,
+    e: null,
+    m: !1,
+    s: t,
+    x: null,
+    l: null
+  }, n || (d.l = {
+    s: null,
+    u: null,
+    r1: [],
+    r2: Ft(!1)
+  });
+}
+function wt(t) {
+  const n = d;
+  if (n !== null) {
+    const o = n.e;
+    if (o !== null) {
+      var r = a, e = _;
+      n.e = null;
+      try {
+        for (var u = 0; u < o.length; u++) {
+          var l = o[u];
+          N(l.effect), F(l.reaction), ct(l.fn);
+        }
+      } finally {
+        N(r), F(e);
+      }
+    }
+    d = n.p, n.m = !0;
+  }
+  return (
+    /** @type {T} */
+    {}
+  );
+}
+function Qn(t) {
+  if (!(typeof t != "object" || !t || t instanceof EventTarget)) {
+    if (X in t)
+      lt(t);
+    else if (!Array.isArray(t))
+      for (let n in t) {
+        const r = t[n];
+        typeof r == "object" && r && X in r && lt(r);
+      }
+  }
+}
+function lt(t, n = /* @__PURE__ */ new Set()) {
+  if (typeof t == "object" && t !== null && // We don't want to traverse DOM elements
+  !(t instanceof EventTarget) && !n.has(t)) {
+    n.add(t), t instanceof Date && t.getTime();
+    for (let e in t)
+      try {
+        lt(t[e], n);
+      } catch {
+      }
+    const r = _n(t);
+    if (r !== Object.prototype && r !== Array.prototype && r !== Map.prototype && r !== Set.prototype && r !== Date.prototype) {
+      const e = cn(r);
+      for (let u in e) {
+        const l = e[u].get;
+        if (l)
+          try {
+            l.call(t);
+          } catch {
+          }
+      }
+    }
+  }
+}
+const Xn = /* @__PURE__ */ new Set(), xt = /* @__PURE__ */ new Set();
+function Y(t) {
+  var Et;
+  var n = this, r = (
+    /** @type {Node} */
+    n.ownerDocument
+  ), e = t.type, u = ((Et = t.composedPath) == null ? void 0 : Et.call(t)) || [], l = (
+    /** @type {null | Element} */
+    u[0] || t.target
+  ), o = 0, i = t.__root;
+  if (i) {
+    var f = u.indexOf(i);
+    if (f !== -1 && (n === document || n === /** @type {any} */
+    window)) {
+      t.__root = n;
+      return;
+    }
+    var s = u.indexOf(n);
+    if (s === -1)
+      return;
+    f <= s && (o = f);
+  }
+  if (l = /** @type {Element} */
+  u[o] || t.target, l !== n) {
+    an(t, "currentTarget", {
+      configurable: !0,
+      get() {
+        return l || r;
+      }
+    });
+    var v = _, c = a;
+    F(null), N(null);
+    try {
+      for (var p, h = []; l !== null; ) {
+        var m = l.assignedSlot || l.parentNode || /** @type {any} */
+        l.host || null;
+        try {
+          var b = l["__" + e];
+          if (b !== void 0 && !/** @type {any} */
+          l.disabled)
+            if (fn(b)) {
+              var [ln, ...un] = b;
+              ln.apply(l, [t, ...un]);
+            } else
+              b.call(l, t);
+        } catch (U) {
+          p ? h.push(U) : p = U;
+        }
+        if (t.cancelBubble || m === n || m === null)
+          break;
+        l = m;
+      }
+      if (p) {
+        for (let U of h)
+          queueMicrotask(() => {
+            throw U;
+          });
+        throw p;
+      }
+    } finally {
+      t.__root = n, delete t.currentTarget, F(v), N(c);
+    }
+  }
+}
+function tr(t) {
+  var n = document.createElement("template");
+  return n.innerHTML = t, n.content;
+}
+function nr(t, n) {
+  var r = (
+    /** @type {Effect} */
+    a
+  );
+  r.nodes_start === null && (r.nodes_start = t, r.nodes_end = n);
+}
+// @__NO_SIDE_EFFECTS__
+function nn(t, n) {
+  var r = (n & Cn) !== 0, e, u = !t.startsWith("<!>");
+  return () => {
+    e === void 0 && (e = tr(u ? t : "<!>" + t), e = /** @type {Node} */
+    /* @__PURE__ */ Vt(e));
+    var l = (
+      /** @type {TemplateNode} */
+      r ? document.importNode(e, !0) : e.cloneNode(!0)
+    );
+    return nr(l, l), l;
+  };
+}
+function rn(t, n) {
+  t !== null && t.before(
+    /** @type {Node} */
+    n
+  );
+}
+const rr = ["touchstart", "touchmove"];
+function er(t) {
+  return rr.includes(t);
+}
+function Tt(t, n) {
+  var r = n == null ? "" : typeof n == "object" ? n + "" : n;
+  r !== (t.__t ?? (t.__t = t.nodeValue)) && (t.__t = r, t.nodeValue = r == null ? "" : r + "");
+}
+function lr(t, n) {
+  return ur(t, n);
+}
+const R = /* @__PURE__ */ new Map();
+function ur(t, { target: n, anchor: r, props: e = {}, events: u, context: l, intro: o = !0 }) {
+  Rn();
+  var i = /* @__PURE__ */ new Set(), f = (c) => {
+    for (var p = 0; p < c.length; p++) {
+      var h = c[p];
+      if (!i.has(h)) {
+        i.add(h);
+        var m = er(h);
+        n.addEventListener(h, Y, { passive: m });
+        var b = R.get(h);
+        b === void 0 ? (document.addEventListener(h, Y, { passive: m }), R.set(h, 1)) : R.set(h, b + 1);
+      }
+    }
+  };
+  f(sn(Xn)), xt.add(f);
+  var s = void 0, v = Mn(() => {
+    var c = r ?? n.appendChild(An());
+    return Ln(() => {
+      if (l) {
+        ht({});
+        var p = (
+          /** @type {ComponentContext} */
+          d
+        );
+        p.c = l;
+      }
+      u && (e.$$events = u), s = t(c, e) || {}, l && wt();
+    }), () => {
+      var m;
+      for (var p of i) {
+        n.removeEventListener(p, Y);
+        var h = (
+          /** @type {number} */
+          R.get(p)
+        );
+        --h === 0 ? (document.removeEventListener(p, Y), R.delete(p)) : R.set(p, h);
+      }
+      xt.delete(f), ut.delete(s), c !== r && ((m = c.parentNode) == null || m.removeChild(c));
+    };
+  });
+  return ut.set(s, v), s;
+}
+let ut = /* @__PURE__ */ new WeakMap();
+function or(t) {
+  const n = ut.get(t);
+  n && n();
+}
+function ir(t, n, r, e, u) {
+  var i;
+  var l = (i = n.$$slots) == null ? void 0 : i[r], o = !1;
+  l === !0 && (l = n.children, o = !0), l === void 0 || l(t, o ? () => e : e);
+}
+function Ot(t, n) {
+  return t === n || (t == null ? void 0 : t[X]) === n;
+}
+function fr(t = {}, n, r, e) {
+  return ct(() => {
+    var u, l;
+    return Wt(() => {
+      u = l, l = [], pt(() => {
+        t !== r(...l) && (n(t, ...l), u && Ot(r(...u), t) && n(null, ...u));
+      });
+    }), () => {
+      Bn(() => {
+        l && Ot(r(...l), t) && n(null, ...l);
+      });
+    };
+  }), t;
+}
+function en(t = !1) {
+  const n = (
+    /** @type {ComponentContextLegacy} */
+    d
+  ), r = n.l.u;
+  if (!r) return;
+  let e = () => Qn(n.s);
+  if (t) {
+    let u = 0, l = (
+      /** @type {Record<string, any>} */
+      {}
+    );
+    const o = /* @__PURE__ */ st(() => {
+      let i = !1;
+      const f = n.s;
+      for (const s in f)
+        f[s] !== l[s] && (l[s] = f[s], i = !0);
+      return i && u++, u;
+    });
+    e = () => g(o);
+  }
+  r.b.length && Pn(() => {
+    Dt(n, e), Q(r.b);
+  }), tt(() => {
+    const u = pt(() => r.m.map(vn));
+    return () => {
+      for (const l of u)
+        typeof l == "function" && l();
+    };
+  }), r.a.length && tt(() => {
+    Dt(n, e), Q(r.a);
+  });
+}
+function Dt(t, n) {
+  if (t.l.s)
+    for (const r of t.l.s) g(r);
+  n();
+}
+let $ = !1;
+function sr(t) {
+  var n = $;
+  try {
+    return $ = !1, [t(), $];
+  } finally {
+    $ = n;
+  }
+}
+function ar(t) {
+  for (var n = a, r = a; n !== null && !(n.f & (x | I)); )
+    n = n.parent;
+  try {
+    return N(n), t();
+  } finally {
+    N(r);
+  }
+}
+function ot(t, n, r, e) {
+  var m;
+  var u = (r & Dn) !== 0, l = (r & Nn) !== 0, o = !1, i;
+  [i, o] = sr(() => (
+    /** @type {V} */
+    t[n]
+  ));
+  var f = (m = z(t, n)) == null ? void 0 : m.set, s = (
+    /** @type {V} */
+    e
+  ), v = !0, c = () => (v && (v = !1, s = /** @type {V} */
+  e), s);
+  i === void 0 && e !== void 0 && (f && l && bn(), i = c(), f && f(i));
+  var p;
+  {
+    var h = ar(
+      () => (u ? st : qn)(() => (
+        /** @type {V} */
+        t[n]
+      ))
+    );
+    h.f |= pn, p = () => {
+      var b = g(h);
+      return b !== void 0 && (s = /** @type {V} */
+      void 0), b === void 0 ? s : b;
+    };
+  }
+  return p;
+}
+function it(t) {
+  d === null && Un(), d.l !== null ? cr(d).m.push(t) : tt(() => {
+    const n = pt(t);
+    if (typeof n == "function") return (
+      /** @type {() => void} */
+      n
+    );
+  });
+}
+function cr(t) {
+  var n = (
+    /** @type {ComponentContextLegacy} */
+    t.l
+  );
+  return n.u ?? (n.u = { a: [], b: [], m: [] });
+}
+const _r = "5";
+typeof window < "u" && (window.__svelte || (window.__svelte = { v: /* @__PURE__ */ new Set() })).v.add(_r);
+var vr = /* @__PURE__ */ nn("<div><!></div>");
+function dr(t, n) {
+  ht(n, !1);
+  let r = ot(n, "delegatesFocus", 8, !1), e = ot(n, "mode", 8, "open"), u = Pt(), l;
+  const o = typeof window < "u" && window.Element && Object.prototype.hasOwnProperty.call(window.Element.prototype, "attachShadow");
+  it(() => {
+    if (g(u) && o && typeof g(u).attachShadow == "function")
+      for (l = g(u).attachShadow({
+        delegatesFocus: r(),
+        mode: e()
+      }); g(u).firstChild; )
+        l.appendChild(g(u).firstChild);
+  }), en();
+  var i = vr(), f = H(i);
+  ir(f, n, "default", {}), fr(i, (s) => Mt(u, s), () => g(u)), rn(t, i), wt();
+}
+var pr = /* @__PURE__ */ nn("<div><h1>Hello from Svelte!</h1> <p> </p> <pre> </pre></div>");
+function hr(t, n) {
+  ht(n, !1);
+  let r = ot(n, "experience", 8), e = Pt(r());
+  function u(l) {
+    var o;
+    ((o = l.experience) == null ? void 0 : o.id) === g(e).id && Mt(e, l.experience);
+  }
+  it(() => yt("experienceload", u)), it(() => yt("editor:update", u)), en(), dr(t, {
+    mode: "open",
+    children: (l, o) => {
+      var i = pr(), f = gt(H(i), 2), s = H(f), v = gt(f, 2), c = H(v);
+      bt(() => Tt(c, JSON.stringify(g(e), null, 2))), bt(() => Tt(s, `Experience ID: ${g(e).id ?? ""}`)), rn(l, i);
+    },
+    $$slots: { default: !0 }
+  }), wt();
+}
+function wr(t, n, r = hr) {
+  console.log("MOUNT");
+  const e = lr(r, {
+    target: t,
+    props: n
+  });
+  return function() {
+    or(e);
+  };
+}
+function yr(t) {
+}
+const mr = (t, n) => ({
+  id: t,
+  framework: "svelte",
+  mount: wr,
+  component: n
+});
+export {
+  hr as App,
+  yr as Zone,
+  mr as adapter,
+  wr as mount
+};

package/dist/mount.d.ts

@@ -0,0 +1,2 @@
+import { BlockComponentProps } from '@repo/types';
+export declare function mount(el: Element, props: BlockComponentProps, Component?: any): () => void;

package/dist/types.d.ts

@@ -0,0 +1,3 @@
+import { BlockComponentProps } from '@repo/types';
+import { SvelteComponent } from 'svelte';
+export type BlockComponent = SvelteComponent<BlockComponentProps>;

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@picked/svelte",
+  "version": "0.0.0-chore-version-and-release-packages.1733366498981-3517ab4",
+  "devDependencies": {
+    "@picked/client": "workspace:*",
+    "@repo/eslint-config": "workspace:*",
+    "@repo/types": "workspace:*",
+    "@repo/typescript-config": "workspace:*",
+    "@sveltejs/package": "^2.3.7",
+    "@sveltejs/vite-plugin-svelte": "^4.0.0",
+    "@tsconfig/svelte": "^5.0.4",
+    "@types/eslint": "^8.56.5",
+    "@types/node": "^20.11.24",
+    "svelte": "^5.1.3",
+    "svelte-check": "^4.0.5",
+    "vite": "^5.4.10",
+    "vite-plugin-dts": "^4.3.0"
+  },
+  "files": [
+    "dist"
+  ],
+  "main": "dist",
+  "peerDependencies": {
+    "@picked/client": "0.0.0-chore-version-and-release-packages.1733366498981-3517ab4",
+    "svelte": "^5.1.3"
+  },
+  "private": false,
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "lint": "eslint .",
+    "lint:format": "eslint . --fix",
+    "lint:report": "eslint . -o './.reports/eslint.json' -f json || true",
+    "type-check": "tsc -p . --noEmit"
+  },
+  "type": "module"
+}