@picked/client 0.0.38-next.3 → 0.0.39-next.1

package/dist/experience-instance-CKiUCMCP.js

@@ -0,0 +1,815 @@
+import { createDomain as xt, createEvent as k, combine as D, createApi as ut, createEffect as M, attach as B, sample as m, split as Et } from "effector";
+import { createFactory as ft, invoke as lt } from "@withease/factories";
+import { j as kt, s as dt, a as At } from "./supports-8YT4QKI7.js";
+import { l as I } from "./logger-C9a75KZn.js";
+import { i as bt } from "./object-JwZ58NOH.js";
+function vt(t) {
+  return typeof t == "number" && !isNaN(t);
+}
+function j(t) {
+  return typeof t == "string";
+}
+function N(t) {
+  return Array.isArray(t);
+}
+function pt(t) {
+  return t instanceof Promise;
+}
+function ot(t) {
+  return typeof t == "object" && t !== null && !Array.isArray(t) && Object.keys(t).length === 1;
+}
+function g(t) {
+  if (vt(t)) return t;
+  const e = parseFloat(`${t}`);
+  return isNaN(e) ? 0 : e;
+}
+function R(t) {
+  return `${t}`;
+}
+const Ot = {
+  // eslint-disable-next-line eqeqeq
+  "==": (t, e) => t == e,
+  "===": (t, e) => t === e,
+  // eslint-disable-next-line eqeqeq
+  "!=": (t, e) => t != e,
+  "!==": (t, e) => t !== e,
+  ">": (t, e) => g(t) > g(e),
+  ">=": (t, e) => g(t) >= g(e),
+  "<": (t, e, r) => {
+    const n = g(t), i = g(e);
+    if (r === void 0) return n < i;
+    const a = g(r);
+    return n < i && i < a;
+  },
+  "<=": (t, e, r) => {
+    const n = g(t), i = g(e);
+    if (r === void 0) return n <= i;
+    const a = g(r);
+    return n <= i && i <= a;
+  },
+  "!!": async (t) => await v(t),
+  "!": async (t) => !await v(t),
+  "%": (t, e) => g(t) % g(e),
+  // eslint-disable-next-line sonarjs/function-return-type
+  log: (t) => (console.log(t), t),
+  in: (t, e) => e ? j(e) ? e.indexOf(R(t)) !== -1 : N(e) ? e.includes(t) : !1 : !1,
+  cat: (...t) => t.map(R).join(""),
+  /* eslint-disable sonarjs/deprecation */
+  substr: (t, e, r) => {
+    const n = R(t), i = g(e);
+    if (r === void 0) return n.substr(i);
+    const a = g(r);
+    if (a < 0) {
+      const o = n.substr(i);
+      return o.substr(0, o.length + a);
+    }
+    return n.substr(i, a);
+  },
+  /* eslint-enable sonarjs/deprecation */
+  "+": (...t) => t.reduce((e, r) => g(e) + g(r), 0),
+  "*": (...t) => t.reduce((e, r) => g(e) * g(r), 1),
+  "-": (t, e) => {
+    const r = g(t);
+    return e === void 0 ? -r : r - g(e);
+  },
+  "/": (t, e) => g(t) / g(e),
+  min: (...t) => Math.min(...t.map(g)),
+  max: (...t) => Math.max(...t.map(g)),
+  merge: (...t) => t.reduce((e, r) => N(r) ? e.concat(r) : e.concat([r]), []),
+  var(t, e) {
+    const r = arguments.length > 1 ? e : null;
+    if (t === "" || t === "." || t === null || t === void 0)
+      return this;
+    if (typeof t == "number" && Array.isArray(this))
+      return t >= 0 && t < this.length ? this[t] : r;
+    const n = R(t);
+    if (n === "" || n === ".")
+      return this;
+    const i = n.split(".");
+    let a = this;
+    for (const o of i) {
+      if (a == null)
+        return r;
+      if (Array.isArray(a)) {
+        const c = parseInt(o, 10);
+        isNaN(c) ? a = a[o] : a = a[c];
+      } else
+        a = a[o];
+    }
+    return a !== void 0 ? a : r;
+  },
+  async missing(...t) {
+    const e = N(t[0]) ? t[0] : t, r = [];
+    for (const n of e) {
+      const i = await p({ var: n }, this);
+      (i === null || i === "") && r.push(`${n}`);
+    }
+    return r;
+  },
+  async missing_some(t, e) {
+    const r = await p({ missing: e }, this);
+    if (!N(r) || !N(e)) return [];
+    const n = r.filter(j);
+    return e.filter(j).length - n.length >= g(t) ? [] : n;
+  },
+  /**
+   * Invoke operator - executes a function with optional arguments
+   *
+   * Object format (no arguments):
+   * { "invoke": { "var": "functionName" } }
+   *
+   * Array format (with arguments):
+   * { "invoke": [{ "var": "functionName" }, arg1, arg2, ...] }
+   *
+   * Arguments are evaluated as JSONLogic expressions before being passed to the function.
+   */
+  // eslint-disable-next-line sonarjs/function-return-type
+  invoke(...t) {
+    const [e, ...r] = t;
+    return typeof e != "function" ? null : Reflect.apply(e, null, r);
+  },
+  regexp_matches(t, e) {
+    let r = t, n = "";
+    if (N(t)) {
+      const [a, o] = t;
+      r = a, n = o;
+    }
+    return !j(r) || !j(n) ? !1 : new RegExp(r, n).test(R(e));
+  },
+  throw(t) {
+    throw new Error(R(t));
+  }
+};
+async function p(t, e) {
+  if (!t) return t;
+  if (pt(t))
+    return p(await t, e);
+  if (N(t))
+    return Promise.all(t.map((o) => p(o, e)));
+  if (!ot(t)) return t;
+  const r = Bt(t);
+  let n = r ? t[r] ?? [] : [];
+  switch (N(n) || (n = [n]), r) {
+    case "if":
+    case "?:":
+      for (let o = 0; o < n.length - 1; o += 2)
+        if (await v(await p(n[o], e)))
+          return p(n[o + 1], e);
+      return n.length % 2 === 1 ? p(n[n.length - 1], e) : null;
+    case "and": {
+      let o = null;
+      for (const c of n)
+        if (o = await p(c, e), !await v(o))
+          return o;
+      return o;
+    }
+    case "or": {
+      let o = null;
+      for (const c of n)
+        if (o = await p(c, e), await v(o)) return o;
+      return o;
+    }
+    case "map": {
+      const o = await p(n[0], e);
+      return N(o) ? await Promise.all(o.map((c) => p(n[1], c))) : [];
+    }
+    case "filter": {
+      const o = await p(n[0], e);
+      return N(o) ? (await Promise.all(
+        o.map(async (d) => {
+          const S = await v(await p(n[1], d));
+          return { item: d, shouldInclude: S };
+        })
+      )).filter(({ shouldInclude: d }) => d).map(({ item: d }) => d) : [];
+    }
+    case "reduce": {
+      const o = await p(n[0], e);
+      if (!N(o))
+        return n.length > 2 ? await p(n[2], e) : null;
+      const c = n[1];
+      let S = n.length > 2 ? await p(n[2], e) : null;
+      for (const A of o)
+        S = await p(c, { current: A, accumulator: S });
+      return S;
+    }
+    case "all": {
+      const o = await p(n[0], e);
+      if (!N(o) || o.length === 0) return !1;
+      for (const c of o)
+        if (!await v(await p(n[1], c))) return !1;
+      return !0;
+    }
+    case "some": {
+      const o = await p(n[0], e);
+      if (!N(o)) return !1;
+      for (const c of o)
+        if (await v(await p(n[1], c))) return !0;
+      return !1;
+    }
+    case "none": {
+      const o = await p(n[0], e);
+      if (!N(o)) return !0;
+      for (const c of o)
+        if (await v(await p(n[1], c))) return !1;
+      return !0;
+    }
+    case "catch":
+      try {
+        return await p(n[0], e);
+      } catch (o) {
+        return ot(o) ? await p(o, e) : n[1] ? await p(n[1], o) : o instanceof Error ? o.message : o;
+      }
+  }
+  const i = await Promise.all(n.map((o) => p(o, e))), a = r ? Ot[r] : void 0;
+  if (!a) throw new Error(`Unrecognized operation ${r}`);
+  return a.apply(e, i);
+}
+async function v(t) {
+  return pt(t) ? v(await t) : !(Array.isArray(t) && t.length === 0) && !!t;
+}
+function Bt(t) {
+  return Object.keys(t)[0];
+}
+function Ft(t) {
+  return !bt(t);
+}
+async function st(t, e, r) {
+  const n = t.getStateSnapshot(), i = t.predicates.listStore.getState().reduce((c, d) => ({
+    ...c,
+    [d.name]: (...S) => d.predicate({ ...n, args: S })
+  }), {}), a = t.features.listStore.getState().reduce((c, d) => ({
+    ...c,
+    [d.id]: async () => {
+      const { bucket: S } = await d.getBucket();
+      return S;
+    }
+  }), {}), o = {
+    ...r,
+    responses: t.responses.getAllStore.getState(),
+    location: typeof n.location == "object" ? {
+      hash: n.location.hash,
+      host: n.location.host,
+      hostname: n.location.hostname,
+      href: n.location.href,
+      origin: n.location.origin,
+      pathname: n.location.pathname,
+      port: n.location.port,
+      protocol: n.location.protocol,
+      search: n.location.search
+    } : void 0,
+    predicates: i,
+    features: a
+  };
+  return await p(e, o);
+}
+function _t(t) {
+  return !At() || !dt() ? [] : Array.from(window.document.querySelectorAll(t)).filter(
+    (e) => e instanceof HTMLElement
+  );
+}
+const $t = "open";
+function Mt(t) {
+  if (!kt())
+    throw new Error("Shadow DOM is not supported in this environment");
+  return t.attachShadow({ mode: $t });
+}
+function Yt() {
+  return new Promise((t, e) => {
+    if (!dt()) {
+      e();
+      return;
+    }
+    document.readyState !== "loading" ? t() : document.addEventListener("readystatechange", () => t(), { once: !0 });
+  });
+}
+function Tt(t, e) {
+  const r = new MutationObserver((n) => {
+    document.contains(t) || (r.disconnect(), e());
+  });
+  r.observe(document.body, { childList: !0, subtree: !0 });
+}
+const G = "picked-root", K = "picked-target", Lt = "picked-root";
+function Zt(t, e) {
+  return [
+    ...t,
+    // Target and replace picked-root web components
+    {
+      selector: `${Lt}[experience-id="${e}"]`,
+      placement: "replace"
+    }
+  ].flatMap((n) => {
+    const i = _t(n.selector).filter(
+      (a) => !Dt(a, e) && !Rt(a, e)
+    );
+    return {
+      ...n,
+      elements: i
+    };
+  });
+}
+function te(t, e) {
+  return t.flatMap((r) => r.elements.map((n) => Ct(n, r.placement, e)));
+}
+function ee(t, e) {
+  t.classList.add(K), t.classList.add(`${K}-${e}`);
+}
+function Dt(t, e) {
+  return e ? t.classList.contains(`${K}-${e}`) : t.classList.contains(`${K}`);
+}
+function Rt(t, e) {
+  return e ? t.classList.contains(`${G}-${e}`) : t.classList.contains(G);
+}
+function Pt(t) {
+  const e = document.createElement("div");
+  return e.style.display = "block", e.classList.add(G), e.classList.add(`${G}-${t}`), e;
+}
+function Ct(t, e, r) {
+  let n;
+  const i = Pt(r);
+  if (t instanceof Document)
+    n = t.body.appendChild(i);
+  else {
+    switch (e) {
+      case "replace":
+        t.replaceWith(i);
+        break;
+      case "before":
+        t.before(i);
+        break;
+      case "after":
+        t.after(i);
+        break;
+      case "prepend":
+        t.prepend(i);
+        break;
+      default:
+        t.append(i);
+        break;
+    }
+    n = i;
+  }
+  return n;
+}
+function it(t) {
+  return t.type === "conditional";
+}
+function P(t) {
+  return t.type === "step";
+}
+function at(t) {
+  return t.type === "experience";
+}
+function J(t) {
+  return t.type === "origin";
+}
+function ct(t) {
+  return t.type === "action";
+}
+const gt = (t, e, r, n, i = /* @__PURE__ */ new Set()) => i.has(r.id) ? [] : (i.add(r.id), P(r) && !n ? [r] : e.filter((o) => o.sourceNodeId === r.id).flatMap((o) => {
+  const c = t.find((d) => d.id === o.destinationNodeId);
+  return c ? gt(t, e, c, !1, i) : [];
+})), Ht = (t, e, r) => gt(t, e, r, !0, /* @__PURE__ */ new Set()), mt = (t, e, r, n, i = /* @__PURE__ */ new Set()) => {
+  if (i.has(r.id)) return [-1, -1];
+  i.add(r.id);
+  const a = e.filter((d) => d.sourceNodeId === r.id);
+  if (a.length === 0) return [0, 0];
+  let o = 1 / 0, c = -1 / 0;
+  for (const d of a) {
+    const S = t.find((T) => T.id === d.destinationNodeId);
+    if (!S) continue;
+    const [A, F] = mt(
+      t,
+      e,
+      S,
+      !1,
+      new Set(i)
+    );
+    A !== -1 && (o = Math.min(o, A + 1), c = Math.max(c, F + 1));
+  }
+  return o === 1 / 0 ? [-1, -1] : [o, c];
+}, jt = (t, e, r) => mt(t, e, r, !0, /* @__PURE__ */ new Set()), St = (t, e, r, n = /* @__PURE__ */ new Set()) => {
+  if (n.has(r.id)) return [-1, -1];
+  if (n.add(r.id), r.type === "origin") return [0, 0];
+  const i = e.filter((c) => c.destinationNodeId === r.id);
+  if (i.length === 0) return [-1, -1];
+  let a = 1 / 0, o = -1 / 0;
+  for (const c of i) {
+    const d = t.find((F) => F.id === c.sourceNodeId);
+    if (!d) continue;
+    const [S, A] = St(
+      t,
+      e,
+      d,
+      new Set(n)
+    );
+    S !== -1 && (a = Math.min(a, S + 1), o = Math.max(o, A + 1));
+  }
+  return a === 1 / 0 ? [-1, -1] : [a, o];
+}, Ut = (t, e, r) => St(t, e, r, /* @__PURE__ */ new Set()), yt = (t) => t.find((r) => r.type === "origin") || null, Q = (t, e, r) => {
+  if (!t)
+    return yt(e);
+  const n = r.find((a) => a.sourceNodeId === t.id);
+  if (!n)
+    return null;
+  const i = e.find((a) => a.id === n.destinationNodeId);
+  return i || null;
+};
+async function Wt(t, e, r, n) {
+  const i = t ? "true" : "false", a = n.find(
+    (o) => o.sourceNodeHandle === i && o.sourceNodeId === e
+  );
+  return r.find((o) => o.id === a?.destinationNodeId);
+}
+const Y = xt("experience-instance"), Gt = ft(
+  ({
+    client: t,
+    experience: e,
+    target: r
+  }) => {
+    const n = k(), i = k(), a = k(), o = k(), c = k(), d = k(), S = e.componentStore, A = Y.store("transitioning"), F = t.history.entriesStore.map((s) => s.filter((l) => l.experienceId === e.id)), T = F.map((s) => s.filter((l) => P(l.node))), x = F.map((s) => s.at(-1)?.node || null), f = D(
+      e.treeStore,
+      x,
+      ({ steps: s }, l) => s.find((u) => l && P(l) && u.id === l.stepId) || null
+    ), y = D(
+      e.treeStore,
+      T,
+      ({ steps: s }, l) => {
+        const u = l.at(-2);
+        if (!u || !P(u.node))
+          return null;
+        const h = u.node;
+        return s.find(($) => $.id === h.stepId) || null;
+      }
+    ), b = D(
+      e.treeStore,
+      x,
+      ({ nodes: s, edges: l }, u) => u ? Ht(s, l, u) : []
+    ), L = D(
+      e.treeStore,
+      x,
+      ({ nodes: s, edges: l }, u) => u ? Ut(s, l, u) : [-1, -1]
+    ), C = D(
+      e.treeStore,
+      x,
+      ({ nodes: s, edges: l }, u) => u ? jt(s, l, u) : [-1, -1]
+    ), _ = Y.store(!1), U = ut(_, {
+      open: () => !0,
+      close: () => !1,
+      toggle: (s) => !s,
+      set: (s, l) => l
+    }), ht = M(async () => {
+      t.history.back({ experienceId: e.id });
+    }), wt = B({
+      source: e.treeStore,
+      effect: async (s, l) => {
+        const u = s.nodes.find((h) => P(h) && h.stepId === l);
+        u && t.history.push({ experienceId: e.id, node: u });
+      }
+    }), Z = B({
+      source: x,
+      effect: (s) => {
+      }
+    }), V = B({
+      source: e.treeStore,
+      effect: async ({ nodes: s }) => yt(s)
+    }), q = B({
+      source: e.treeStore,
+      effect: async ({ nodes: s, edges: l }, u) => {
+        if (J(u))
+          return Q(u, s, l);
+      }
+    }), X = B({
+      source: e.treeStore,
+      effect: async ({ nodes: s, edges: l, conditionals: u }, h) => {
+        if (!it(h))
+          return;
+        const $ = u.find((O) => O.id === h.conditionalId);
+        if (!$)
+          return;
+        const E = h.id, w = await st(t, $.condition);
+        return Wt(!!w, E, s, l);
+      }
+    }), tt = B({
+      source: e.treeStore,
+      effect: async ({ nodes: s, edges: l }, u) => {
+        if (!ct(u))
+          return;
+        const h = u.action;
+        if (!h) {
+          I("warn", `Action node ${u.id} has no action name`);
+          return;
+        }
+        const $ = t.actions.getByName(h).getState();
+        if (!$) {
+          I("warn", `Action '${h}' not registered on client`);
+          const E = l.find(
+            (w) => w.sourceNodeId === u.id && w.sourceNodeHandle === "false"
+          );
+          return E ? s.find((w) => w.id === E.destinationNodeId) : null;
+        }
+        if (typeof $.action != "function") {
+          I("warn", `Action '${h}' is not a function`);
+          const E = l.find(
+            (w) => w.sourceNodeId === u.id && w.sourceNodeHandle === "false"
+          );
+          return E ? s.find((w) => w.id === E.destinationNodeId) : null;
+        }
+        try {
+          I("info", `Executing action: ${h}`), await $.action(h);
+          const E = l.find(
+            (O) => O.sourceNodeId === u.id && O.sourceNodeHandle === "true"
+          );
+          if (!E)
+            return I("warn", `No 'true' edge found for action node ${u.id}`), null;
+          const w = s.find((O) => O.id === E.destinationNodeId);
+          return I("info", `Action '${h}' succeeded, moving to node ${w?.id}`), w || null;
+        } catch (E) {
+          I("warn", `Action '${h}' failed:`, E);
+          const w = l.find(
+            (W) => W.sourceNodeId === u.id && W.sourceNodeHandle === "false"
+          );
+          if (!w)
+            return I("warn", `No 'false' edge found for action node ${u.id}`), null;
+          const O = s.find((W) => W.id === w.destinationNodeId);
+          return I("info", `Action '${h}' failed, moving to node ${O?.id}`), O || null;
+        }
+      }
+    }), Nt = M((s) => {
+      if (at(s))
+        return t.launchExperienceById(s.experienceId);
+    }), et = B({
+      source: [x, e.treeStore],
+      effect: async ([s, { nodes: l, edges: u }]) => Q(s, l, u)
+    }), H = B({
+      source: [x, e.treeStore],
+      effect: async ([s, { nodes: l, edges: u }]) => Q(s, l, u)
+    }), It = M((s) => {
+      t.history.push({ experienceId: e.id, node: s });
+    }), nt = B({
+      source: e.configStore,
+      effect: async ({ initializeOpenLogic: s }) => Ft(s) ? !!await st(t, s) : s ?? !1
+    }), z = k(), rt = k();
+    return m({
+      source: x,
+      target: z
+    }), m({
+      clock: z,
+      filter: (s) => s === null,
+      target: V
+    }), m({
+      clock: z,
+      filter: (s) => s !== null,
+      target: rt
+    }), Et({
+      source: rt,
+      match: (s) => it(s) ? "condition" : P(s) ? "step" : at(s) ? "launchExperience" : J(s) ? "origin" : ct(s) ? "action" : "other",
+      cases: {
+        origin: q,
+        condition: X,
+        step: Z,
+        launchExperience: Nt,
+        action: tt,
+        __: k()
+      }
+    }), m({
+      clock: [
+        X.doneData,
+        q.doneData,
+        V.doneData,
+        H.doneData,
+        et.doneData,
+        tt.doneData
+      ],
+      filter: Boolean,
+      target: It
+    }), m({
+      clock: i,
+      target: H
+    }), m({
+      clock: i,
+      source: f,
+      filter: Boolean,
+      target: t.eventBus.prepend((s) => ({
+        type: "step_submit",
+        step: s,
+        experience: e
+      }))
+    }), m({
+      clock: H.done,
+      source: f,
+      filter: Boolean,
+      target: t.eventBus.prepend((s) => ({
+        type: "step_submit_success",
+        step: s,
+        experience: e
+      }))
+    }), m({
+      clock: H.fail,
+      source: f,
+      filter: Boolean,
+      target: t.eventBus.prepend((s) => ({
+        type: "step_submit_error",
+        step: s,
+        experience: e
+      }))
+    }), m({
+      clock: a,
+      target: ht
+    }), m({ clock: o, target: wt }), m({
+      source: D([
+        X.pending,
+        q.pending,
+        V.pending,
+        H.pending
+      ]),
+      fn: (s) => s.some(Boolean) ? "transitioning" : "ready",
+      target: A
+    }), m({
+      clock: Z.doneData,
+      source: f,
+      filter: Boolean,
+      target: t.eventBus.prepend((s) => ({
+        type: "step_enter",
+        step: s,
+        experience: e
+      }))
+    }), m({
+      clock: d,
+      target: nt
+    }), m({
+      source: nt.doneData,
+      fn: Boolean,
+      target: _
+    }), m({
+      source: x,
+      clock: n,
+      filter: (s) => s ? J(s) : !0,
+      target: et
+    }), m({
+      source: _,
+      filter: Boolean,
+      target: n
+    }), m({
+      source: _,
+      filter: Boolean,
+      target: t.eventBus.prepend(() => ({
+        type: "experience_open",
+        experience: e
+      }))
+    }), m({
+      source: _,
+      filter: (s) => !s,
+      target: t.eventBus.prepend(() => ({
+        type: "experience_close",
+        experience: e
+      }))
+    }), m({
+      clock: c,
+      target: [d]
+    }), c(), {
+      id: Math.random().toString(36).substring(7),
+      // config
+      experienceId: e.id,
+      configStore: e.configStore,
+      target: r,
+      componentStore: S,
+      // state
+      stateStore: A,
+      // open close
+      isOpenStore: _,
+      open: U.open,
+      close: U.close,
+      toggleOpen: U.toggle,
+      setOpen: U.set,
+      // nodes
+      treeStore: e.treeStore,
+      fieldsStore: e.fieldsStore,
+      currentNodeStore: x,
+      currentStepStore: f,
+      previousStepStore: y,
+      nextReachableStepNodesStore: b,
+      stepsToOriginStore: L,
+      stepsToLeafStore: C,
+      // history
+      goToNextStep: i,
+      goToPreviousStep: a,
+      goToStepById: o,
+      stepsHistoryStore: T
+    };
+  }
+);
+function Kt(t) {
+  return lt(Gt, t);
+}
+const Vt = ft(({ client: t }) => {
+  const e = Y.store({}), r = k(), n = k(), i = k(), a = ut(e, {
+    register(f, y) {
+      const b = [
+        ...f[y.experienceId] ?? []
+      ];
+      return b.push(y), {
+        ...f,
+        [y.experienceId]: b
+      };
+    },
+    unregister(f, y) {
+      const b = y.experienceId, L = f[b]?.filter(
+        (C) => C !== y
+      );
+      return {
+        ...f,
+        [b]: L ?? []
+      };
+    }
+  }), o = M(
+    ({ experience: f, target: y }) => Kt({ client: t, experience: f, target: y })
+  ), c = M((f) => {
+    a.register(f);
+  }), d = M(
+    (f) => {
+      f.target && Tt(f.target, () => {
+        i(f);
+      });
+    }
+  ), S = M((f) => {
+    a.unregister(f);
+  }), A = M((f) => {
+    const y = f.componentStore.getState();
+    if (!y) {
+      I("warn", "No app component registered. Skipping init.");
+      return;
+    }
+    const b = y.frameworkStore.getState();
+    if (!b) {
+      I(
+        "error",
+        `No framework registered for component '${y.name}'. Skipping rendering.`
+      );
+      return;
+    }
+    const L = f.target;
+    if (!L) {
+      I(
+        "error",
+        `No target element registered for experience '${f.experienceId}'. Skipping rendering.`
+      );
+      return;
+    }
+    const C = Mt(L);
+    try {
+      b.render(C, y.component, t, f);
+    } catch (_) {
+      I("error", _);
+    }
+  });
+  m({
+    clock: r,
+    target: o
+  }), m({
+    clock: i,
+    target: S
+  }), m({
+    clock: o.doneData,
+    target: [
+      c,
+      d,
+      n
+    ]
+  }), m({
+    clock: o.doneData,
+    target: t.eventBus.prepend((f) => ({
+      type: "experience_initialize",
+      experienceInstance: f
+    }))
+  }), m({
+    clock: n,
+    target: A
+  });
+  function F(f, y) {
+    r({ experience: f, target: y });
+  }
+  const T = e.map((f) => Object.values(f).flat());
+  function x(f) {
+    return e.map((y) => y[f] || [], { skipVoid: !1 });
+  }
+  return {
+    spawn: F,
+    getByExperienceId: x,
+    listStore: T
+  };
+});
+function ne(t) {
+  return lt(Vt, t);
+}
+export {
+  P as a,
+  ne as b,
+  te as c,
+  Yt as d,
+  st as e,
+  Rt as f,
+  Zt as g,
+  Kt as h,
+  Ft as i,
+  ee as t
+};