@modular-react/journeys 0.1.0

package/dist/runtime-DyU_PmaC.js

@@ -0,0 +1,599 @@
+//#region src/validation.ts
+var e = class extends Error {
+	issues;
+	constructor(e) {
+		super(`[@modular-react/journeys] Invalid journey registration:\n  - ${e.join("\n  - ")}`), this.name = "JourneyValidationError", this.issues = e;
+	}
+}, t = class extends Error {
+	constructor(e, t) {
+		super(`[@modular-react/journeys] ${e}`, t), this.name = "JourneyHydrationError";
+	}
+}, n = class extends Error {
+	journeyId;
+	constructor(e, t) {
+		super(`[@modular-react/journeys] Unknown journey id "${e}". Registered: ${t.join(", ") || "(none)"}`), this.name = "UnknownJourneyError", this.journeyId = e;
+	}
+};
+function r(t, n) {
+	let r = [], i = /* @__PURE__ */ new Map();
+	for (let e of n) i.set(e.id, e);
+	for (let e of n) e.exitPoints && Object.prototype.hasOwnProperty.call(e.exitPoints, "allowBack") && r.push(`module "${e.id}" declares an exit named "allowBack", which collides with the reserved per-entry transition control key. Rename the exit (e.g. "allowBackExit").`);
+	let a = /* @__PURE__ */ new Set();
+	for (let e of t) {
+		let t = e.definition;
+		a.has(t.id) && r.push(`journey "${t.id}" is registered more than once`), a.add(t.id);
+		let n = t.transitions ?? {};
+		for (let [e, a] of Object.entries(n)) {
+			let n = i.get(e);
+			if (!n) {
+				r.push(`journey "${t.id}" references unknown module id "${e}" in transitions`);
+				continue;
+			}
+			if (!a || typeof a != "object") {
+				r.push(`journey "${t.id}" has malformed transitions for module "${e}" (expected an object)`);
+				continue;
+			}
+			for (let [i, o] of Object.entries(a)) {
+				let a = n.entryPoints?.[i];
+				if (!a) {
+					r.push(`journey "${t.id}" references unknown entry "${e}.${i}"`);
+					continue;
+				}
+				if (!o || typeof o != "object") {
+					r.push(`journey "${t.id}" has malformed transitions for entry "${e}.${i}" (expected an object)`);
+					continue;
+				}
+				let s = o;
+				for (let a of Object.keys(s)) a !== "allowBack" && (!n.exitPoints || !(a in n.exitPoints)) && r.push(`journey "${t.id}" references unknown exit "${e}.${i}.${a}"`);
+				if (s.allowBack === !0) {
+					let n = a.allowBack;
+					n !== "preserve-state" && n !== "rollback" && r.push(`journey "${t.id}" sets allowBack on "${e}.${i}" but the module entry does not declare allowBack`);
+				}
+			}
+		}
+	}
+	if (r.length > 0) throw new e(r);
+}
+function i(e) {
+	let t = [];
+	return (!e.id || typeof e.id != "string") && t.push("journey is missing a string id"), (!e.version || typeof e.version != "string") && t.push(`journey "${e.id ?? "(unknown)"}" is missing a string version`), typeof e.initialState != "function" && t.push(`journey "${e.id}" must declare initialState as a function`), typeof e.start != "function" && t.push(`journey "${e.id}" must declare start as a function`), (!e.transitions || typeof e.transitions != "object") && t.push(`journey "${e.id}" must declare transitions`), t;
+}
+//#endregion
+//#region src/runtime.ts
+var a = /* @__PURE__ */ new WeakMap();
+function o(e, r = {}) {
+	let i = r.debug ?? s(), o = r.modules ?? {}, c = /* @__PURE__ */ new Map();
+	for (let t of e) c.set(t.definition.id, t);
+	let l = /* @__PURE__ */ new Map(), u = /* @__PURE__ */ new Map();
+	function d(e, t) {
+		return `${e}::${t}`;
+	}
+	function f(e) {
+		e.revision += 1, e.cachedSnapshot = null;
+		for (let t of e.listeners) try {
+			t();
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] listener threw", e);
+		}
+	}
+	function p() {
+		return (/* @__PURE__ */ new Date()).toISOString();
+	}
+	function m() {
+		try {
+			let e = globalThis.crypto;
+			if (e?.randomUUID) return `ji_${e.randomUUID()}`;
+		} catch {}
+		let e = Math.random().toString(36).slice(2, 10);
+		return `ji_${Date.now().toString(36)}_${e}`;
+	}
+	function h(e) {
+		return {
+			id: e.definition.id,
+			version: e.definition.version,
+			meta: e.definition.meta
+		};
+	}
+	function g(e) {
+		let t = c.get(e);
+		if (!t) throw new n(e, [...c.keys()]);
+		return t;
+	}
+	function _(e) {
+		return {
+			moduleId: e.module,
+			entry: e.entry,
+			input: e.input
+		};
+	}
+	function v(e) {
+		if (!e) return !1;
+		let t = o[e.moduleId]?.entryPoints?.[e.entry]?.allowBack;
+		return t === "rollback" || t === "preserve-state" ? t : !1;
+	}
+	function y(e, t) {
+		return t ? e.transitions?.[t.moduleId]?.[t.entry]?.allowBack === !0 : !1;
+	}
+	function b(e) {
+		if (typeof e != "object" || !e) return e;
+		let t = Array.isArray(e) ? [...e] : { ...e };
+		if (i) try {
+			Object.freeze(t);
+		} catch {}
+		return t;
+	}
+	function x(e, t) {
+		let n = t.options?.maxHistory;
+		if (!(n === void 0 || n <= 0)) {
+			for (; e.history.length > n;) e.history.shift(), e.rollbackSnapshots.shift();
+			e.hasRollbackSnapshot = e.rollbackSnapshots.some((e) => e !== void 0);
+		}
+	}
+	function S(e, t) {
+		let n = D(e);
+		if (e.saveInFlight) {
+			e.pendingSave = n;
+			return;
+		}
+		C(e, t, n);
+	}
+	async function C(e, t, n) {
+		e.saveInFlight = !0;
+		try {
+			if (!e.persistenceKey) return;
+			await t.save(e.persistenceKey, n);
+		} catch (t) {
+			i && console.error(`[@modular-react/journeys] Failed to persist "${e.journeyId}" instance ${e.id}`, t);
+		} finally {
+			if (e.saveInFlight = !1, e.pendingRemove) e.pendingRemove = !1, e.pendingSave = null, e.persistenceKey && E(t, e.persistenceKey);
+			else if (e.pendingSave) {
+				let n = e.pendingSave;
+				e.pendingSave = null, C(e, t, n);
+			}
+		}
+	}
+	function w(e, t) {
+		if (!e.persistenceKey) return;
+		e.pendingSave = null;
+		let n = e.persistenceKey;
+		if (u.delete(d(e.journeyId, n)), e.saveInFlight) {
+			e.pendingRemove = !0;
+			return;
+		}
+		E(t, n);
+	}
+	function T(e, t) {
+		E(e, t);
+	}
+	function E(e, t) {
+		try {
+			let n = e.remove(t);
+			n && typeof n.catch == "function" && n.catch((e) => {
+				i && console.error("[@modular-react/journeys] persistence.remove rejected", e);
+			});
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] persistence.remove threw", e);
+		}
+	}
+	function D(e) {
+		return {
+			definitionId: e.journeyId,
+			version: c.get(e.journeyId).definition.version,
+			instanceId: e.id,
+			status: e.status === "loading" ? "active" : e.status,
+			step: e.step,
+			history: [...e.history],
+			rollbackSnapshots: e.hasRollbackSnapshot ? e.rollbackSnapshots.map((e) => e === void 0 ? null : e) : void 0,
+			terminalPayload: e.status === "completed" || e.status === "aborted" ? e.terminalPayload : void 0,
+			state: e.state,
+			startedAt: e.startedAt,
+			updatedAt: e.updatedAt
+		};
+	}
+	function O(e, t, n, r, a) {
+		let o = {
+			journeyId: t.journeyId,
+			instanceId: t.id,
+			from: n,
+			to: r,
+			exit: a,
+			state: t.state,
+			history: [...t.history]
+		};
+		try {
+			e.definition.onTransition?.(o);
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onTransition (definition) threw", e);
+		}
+		try {
+			e.options?.onTransition?.(o);
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onTransition (registration) threw", e);
+		}
+	}
+	function k(e, t, n) {
+		if (t.terminalFired) return;
+		t.terminalFired = !0;
+		let r = {
+			journeyId: t.journeyId,
+			instanceId: t.id,
+			state: t.state,
+			history: t.history
+		};
+		try {
+			e.definition.onComplete?.(r, n);
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onComplete (definition) threw", e);
+		}
+		try {
+			e.options?.onComplete?.(r, n);
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onComplete (registration) threw", e);
+		}
+	}
+	function A(e, t, n) {
+		if (t.terminalFired) return;
+		t.terminalFired = !0;
+		let r = {
+			journeyId: t.journeyId,
+			instanceId: t.id,
+			state: t.state,
+			history: t.history
+		};
+		try {
+			e.definition.onAbort?.(r, n);
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onAbort (definition) threw", e);
+		}
+		try {
+			e.options?.onAbort?.(r, n);
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onAbort (registration) threw", e);
+		}
+	}
+	function j(e, t, n, r) {
+		try {
+			e.options?.onError?.(n, { step: r });
+		} catch (e) {
+			i && console.error("[@modular-react/journeys] onError (registration) threw", e);
+		}
+	}
+	function M(e, t, n, r) {
+		let a = e.step, s = e.state;
+		if ("state" in n && (e.state = n.state), "next" in n) {
+			let c = _(n.next);
+			if (i && Object.keys(o).length > 0) {
+				let e = o[c.moduleId];
+				e ? e.entryPoints?.[c.entry] || console.warn(`[@modular-react/journeys] Transition on "${a?.moduleId}.${a?.entry}" returned next.entry="${c.moduleId}.${c.entry}" which is not a declared entry on that module.`) : console.warn(`[@modular-react/journeys] Transition on "${a?.moduleId}.${a?.entry}" returned next.module="${c.moduleId}" which is not in the runtime's module map — the outlet will render a "no entry" error.`);
+			}
+			a && (e.history.push(a), N(c) === "rollback" ? (e.rollbackSnapshots.push(b(s)), e.hasRollbackSnapshot = !0) : e.rollbackSnapshots.push(void 0)), e.step = c, e.status = "active", e.stepToken += 1, e.updatedAt = p(), e.cachedCallbacks = null, x(e, t), O(t, e, a, c, r);
+		} else "complete" in n ? (a && (e.history.push(a), e.rollbackSnapshots.push(void 0)), e.step = null, e.status = "completed", e.terminalPayload = n.complete, e.stepToken += 1, e.updatedAt = p(), e.cachedCallbacks = null, x(e, t), O(t, e, a, null, r), k(t, e, n.complete)) : "abort" in n && (a && (e.history.push(a), e.rollbackSnapshots.push(void 0)), e.step = null, e.status = "aborted", e.terminalPayload = n.abort, e.stepToken += 1, e.updatedAt = p(), e.cachedCallbacks = null, x(e, t), O(t, e, a, null, r), A(t, e, n.abort));
+		let c = t.options?.persistence;
+		c && (e.status === "active" ? S(e, c) : w(e, c)), f(e);
+	}
+	function N(e) {
+		return v(e);
+	}
+	function P(e, t, n, r, a) {
+		if (e.status !== "active") {
+			i && console.warn(`[@modular-react/journeys] Exit("${r}") dropped on instance ${e.id} — status=${e.status}. (This is the expected no-op when an exit fires before the initial async load settles; await the load or subscribe for status changes before dispatching.)`);
+			return;
+		}
+		if (e.stepToken !== n) {
+			i && console.warn(`[@modular-react/journeys] Stale exit("${r}") dropped on instance ${e.id}`);
+			return;
+		}
+		let o = e.step;
+		if (!o) return;
+		let s = t.definition.transitions?.[o.moduleId]?.[o.entry]?.[r];
+		if (typeof s != "function") {
+			i && console.warn(`[@modular-react/journeys] No transition for exit("${r}") on ${o.moduleId}.${o.entry} — ignoring.`);
+			return;
+		}
+		let c;
+		try {
+			c = s({
+				state: e.state,
+				input: o.input,
+				output: a
+			});
+		} catch (n) {
+			i && console.error("[@modular-react/journeys] transition handler threw", n), j(t, e, n, o), M(e, t, { abort: {
+				reason: "transition-error",
+				exit: r,
+				error: n
+			} }, r);
+			return;
+		}
+		if (c && typeof c.then == "function") {
+			i && console.error(`[@modular-react/journeys] Transition handler for ${o.moduleId}.${o.entry}."${r}" returned a Promise. Transitions must be synchronous and pure — put async work inside a loading entry point on a module.`), M(e, t, { abort: {
+				reason: "transition-returned-promise",
+				exit: r
+			} }, r);
+			return;
+		}
+		M(e, t, c, r);
+	}
+	function F(e, t, n) {
+		if (e.status !== "active" || e.stepToken !== n || e.history.length === 0) return;
+		let r = e.step;
+		if (!r || !y(t.definition, r)) return;
+		let i = e.history.pop(), a = e.rollbackSnapshots.pop();
+		v(r) === "rollback" && a !== void 0 && (e.state = a), e.hasRollbackSnapshot = e.rollbackSnapshots.some((e) => e !== void 0), e.step = i, e.stepToken += 1, e.updatedAt = p(), e.cachedCallbacks = null, O(t, e, r, i, null);
+		let o = t.options?.persistence;
+		o && S(e, o), f(e);
+	}
+	function I(e, t) {
+		if (e.cachedCallbacks && e.cachedCallbacks.stepToken === e.stepToken) return e.cachedCallbacks;
+		let n = e.stepToken, r = (r, i) => {
+			P(e, t, n, r, i);
+		}, i = v(e.step);
+		return i === !1 && e.step && y(t.definition, e.step) && !o[e.step.moduleId] && (i = "preserve-state"), e.cachedCallbacks = {
+			stepToken: n,
+			exit: r,
+			goBack: i !== !1 && y(t.definition, e.step) && e.history.length > 0 ? () => {
+				F(e, t, n);
+			} : void 0
+		}, e.cachedCallbacks;
+	}
+	function L(e) {
+		if (e.cachedSnapshot && e.cachedSnapshot.revision === e.revision) return e.cachedSnapshot.instance;
+		let t = [...e.history], n = {
+			id: e.id,
+			journeyId: e.journeyId,
+			status: e.status,
+			step: e.step,
+			history: t,
+			state: e.state,
+			terminalPayload: e.status === "completed" || e.status === "aborted" ? e.terminalPayload : void 0,
+			startedAt: e.startedAt,
+			updatedAt: e.updatedAt,
+			serialize: () => D(e)
+		};
+		return e.cachedSnapshot = {
+			revision: e.revision,
+			instance: n
+		}, n;
+	}
+	function R(e, t, n, r) {
+		let i = p();
+		return {
+			id: t,
+			journeyId: e.definition.id,
+			status: "loading",
+			step: null,
+			history: [],
+			rollbackSnapshots: [],
+			hasRollbackSnapshot: !1,
+			state: r,
+			terminalPayload: void 0,
+			startedAt: i,
+			updatedAt: i,
+			stepToken: 0,
+			persistenceKey: n,
+			terminalFired: !1,
+			retryCount: 0,
+			listeners: /* @__PURE__ */ new Set(),
+			pendingSave: null,
+			saveInFlight: !1,
+			pendingRemove: !1,
+			revision: 0,
+			cachedSnapshot: null,
+			cachedCallbacks: null
+		};
+	}
+	function z(e, t, n) {
+		let r = e.definition, i = n ?? R(e, m(), null, r.initialState(t));
+		n ? (i.state = r.initialState(t), i.history = [], i.rollbackSnapshots = [], i.hasRollbackSnapshot = !1) : l.set(i.id, i);
+		let a = _(r.start(i.state, t));
+		i.step = a, i.status = "active", i.stepToken += 1, i.terminalFired = !1, i.terminalPayload = void 0, i.retryCount = 0, i.updatedAt = p(), i.cachedCallbacks = null, O(e, i, null, a, null);
+		let o = e.options?.persistence;
+		return o && S(i, o), f(i), i.id;
+	}
+	function B(e, n) {
+		let r = n.history.length;
+		if (n.rollbackSnapshots && n.rollbackSnapshots.length !== r) throw new t(`Blob for journey "${e.journeyId}" has rollbackSnapshots.length=${n.rollbackSnapshots.length} but history.length=${r}. Fix the persisted blob (pad rollbackSnapshots with null for non-rollback entries) or provide onHydrate to migrate.`);
+		e.state = n.state, e.step = n.step, e.history = [...n.history], n.rollbackSnapshots ? (e.rollbackSnapshots = n.rollbackSnapshots.map((e) => e === null ? void 0 : e), e.hasRollbackSnapshot = e.rollbackSnapshots.some((e) => e !== void 0)) : (e.rollbackSnapshots = Array.from({ length: r }, () => void 0), e.hasRollbackSnapshot = !1), e.status = n.status, e.terminalPayload = n.terminalPayload, e.startedAt = n.startedAt, e.updatedAt = n.updatedAt, e.stepToken += 1, e.terminalFired = n.status !== "active", e.cachedCallbacks = null;
+	}
+	function V(e, t, n) {
+		let r;
+		try {
+			r = t.load(n);
+		} catch (e) {
+			return i && console.error("[@modular-react/journeys] persistence.load threw", e), null;
+		}
+		return r && r.then, r;
+	}
+	function H(e, t) {
+		let n = t, r = !1;
+		if (e.definition.onHydrate) {
+			r = !0;
+			try {
+				n = e.definition.onHydrate(n);
+			} catch (e) {
+				return i && console.error("[@modular-react/journeys] onHydrate (definition) threw", e), {
+					ok: !1,
+					reason: "on-hydrate-threw",
+					cause: e
+				};
+			}
+		}
+		let a = e.options?.onHydrate;
+		if (a) {
+			r = !0;
+			try {
+				n = a(n);
+			} catch (e) {
+				return i && console.error("[@modular-react/journeys] onHydrate (registration) threw", e), {
+					ok: !1,
+					reason: "on-hydrate-threw",
+					cause: e
+				};
+			}
+		}
+		return r ? {
+			ok: !0,
+			blob: n
+		} : t.version === e.definition.version ? {
+			ok: !0,
+			blob: t
+		} : {
+			ok: !1,
+			reason: "version-mismatch"
+		};
+	}
+	let U = {
+		start(e, ...t) {
+			let n = t.length > 0 ? t[0] : void 0, r = g(typeof e == "string" ? e : e.id), a = r.options?.persistence;
+			if (a) {
+				let e = a.keyFor({
+					journeyId: r.definition.id,
+					input: n
+				}), t = d(r.definition.id, e), o = u.get(t), s = o ? l.get(o) : null;
+				if (s && (s.status === "active" || s.status === "loading")) return s.id;
+				let c = r.definition, p = V(r, a, e);
+				if (p && typeof p.then == "function") {
+					let o = m(), s = R(r, o, e, c.initialState(n));
+					return l.set(o, s), u.set(t, o), f(s), p.then((t) => {
+						if (s.status !== "loading") return;
+						if (!t || t.status !== "active") {
+							t && T(a, e), z(r, n, s);
+							return;
+						}
+						let o = H(r, t);
+						if (!o.ok) {
+							T(a, e), z(r, n, s);
+							return;
+						}
+						try {
+							B(s, o.blob);
+						} catch (t) {
+							i && console.error("[@modular-react/journeys] hydrate after async load failed", t), T(a, e), z(r, n, s);
+							return;
+						}
+						f(s);
+					}, (e) => {
+						i && console.error("[@modular-react/journeys] persistence.load rejected", e), s.status === "loading" && z(r, n, s);
+					}), o;
+				}
+				let h = p;
+				if (h && h.status === "active") {
+					let o = H(r, h);
+					if (o.ok) {
+						let s = o.blob.instanceId && !l.has(o.blob.instanceId) ? o.blob.instanceId : m(), d = R(r, s, e, c.initialState(n));
+						l.set(s, d), u.set(t, s);
+						try {
+							B(d, o.blob);
+						} catch (o) {
+							i && console.error("[@modular-react/journeys] hydrate during start failed", o), l.delete(s), u.delete(t), T(a, e);
+							let d = m(), f = R(r, d, e, c.initialState(n));
+							return l.set(d, f), u.set(t, d), z(r, n, f);
+						}
+						return f(d), s;
+					}
+					T(a, e);
+				} else h && T(a, e);
+				let g = m(), _ = R(r, g, e, c.initialState(n));
+				return l.set(g, _), u.set(t, g), z(r, n, _);
+			}
+			return z(r, n);
+		},
+		hydrate(e, n) {
+			let r = g(e), i = H(r, n);
+			if (!i.ok) throw i.reason === "on-hydrate-threw" ? new t(`onHydrate threw while migrating blob for "${e}" (blob=${n.version} def=${r.definition.version}).`, { cause: i.cause }) : new t(`Hydrate version mismatch for "${e}": blob=${n.version} def=${r.definition.version}. Provide onHydrate to migrate.`);
+			let a = i.blob.instanceId || m();
+			if (l.has(a)) throw new t(`Cannot hydrate journey "${e}" with instance id "${a}" — an instance with the same id is already in memory. Call forget(id) first if you intend to replace it.`);
+			let o = R(r, a, null, i.blob.state);
+			l.set(a, o);
+			try {
+				B(o, i.blob);
+			} catch (e) {
+				throw l.delete(a), e;
+			}
+			return f(o), a;
+		},
+		getInstance(e) {
+			let t = l.get(e);
+			return t ? L(t) : null;
+		},
+		listInstances() {
+			return [...l.keys()];
+		},
+		listDefinitions() {
+			return [...c.values()].map(h);
+		},
+		isRegistered(e) {
+			return c.has(e);
+		},
+		subscribe(e, t) {
+			let n = l.get(e);
+			return n ? (n.listeners.add(t), () => {
+				n.listeners.delete(t);
+			}) : () => {};
+		},
+		end(e, t) {
+			let n = l.get(e);
+			if (!n || n.status === "completed" || n.status === "aborted") return;
+			let r = c.get(n.journeyId);
+			if (!r) return;
+			if (n.status === "loading") {
+				M(n, r, { abort: { reason: t ?? "abandoned" } }, null);
+				return;
+			}
+			let a = { abort: { reason: t ?? "abandoned" } }, o = r.options?.onAbandon ?? r.definition.onAbandon;
+			if (o) try {
+				a = o({
+					journeyId: n.journeyId,
+					instanceId: n.id,
+					step: n.step,
+					state: n.state,
+					reason: t ?? "abandoned"
+				});
+			} catch (e) {
+				i && console.error("[@modular-react/journeys] onAbandon threw", e), j(r, n, e, n.step), a = { abort: {
+					reason: t ?? "abandoned",
+					cause: "onAbandon-threw",
+					error: e
+				} };
+			}
+			M(n, r, a, null);
+		},
+		forget(e) {
+			let t = l.get(e);
+			t && (t.status !== "completed" && t.status !== "aborted" || (t.persistenceKey && u.delete(d(t.journeyId, t.persistenceKey)), t.listeners.clear(), l.delete(e)));
+		},
+		forgetTerminal() {
+			let e = 0;
+			for (let [t, n] of l) (n.status === "completed" || n.status === "aborted") && (n.persistenceKey && u.delete(d(n.journeyId, n.persistenceKey)), n.listeners.clear(), l.delete(t), e += 1);
+			return e;
+		}
+	};
+	function W(e, t, n) {
+		let r = l.get(e);
+		if (!r) return;
+		let i = c.get(r.journeyId);
+		i && j(i, r, t, n);
+	}
+	let G = {
+		__bindStepCallbacks: I,
+		__getRecord: (e) => l.get(e),
+		__getRegistered: (e) => c.get(e),
+		__moduleMap: o,
+		__debug: i,
+		__fireComponentError: W
+	};
+	return a.set(U, G), U;
+}
+function s() {
+	let e = globalThis;
+	return !!e.process && e.process.env?.NODE_ENV !== "production";
+}
+function c(e) {
+	let t = a.get(e);
+	if (!t) throw Error("[@modular-react/journeys] getInternals() called on a runtime that was not produced by createJourneyRuntime().");
+	return t;
+}
+//#endregion
+export { n as a, e as i, c as n, r as o, t as r, i as s, o as t };
+
+//# sourceMappingURL=runtime-DyU_PmaC.js.map