@magicdoor/magic-use-case-solid 0.1.0

package/dist/server.js

@@ -0,0 +1,1959 @@
+import { isServer, createComponent, useAssets, ssr, getRequestEvent } from 'solid-js/web';
+import { createSignal, onCleanup, ErrorBoundary, Show } from 'solid-js';
+import { createStore, reconcile } from 'solid-js/store';
+
+// ../core/dist/index.js
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var ConcreteEventEmitter = class {
+  constructor() {
+    __publicField(this, "events", {});
+    __publicField(this, "stateChange", "stateChange");
+    __publicField(this, "navigation", "navigation");
+    __publicField(this, "error", "error");
+    __publicField(this, "state");
+  }
+  registerForStateChange(handler) {
+    this.register(this.stateChange, handler);
+    if (this.state !== void 0) {
+      try {
+        handler(this.state);
+      } catch (error) {
+        this.unregister(this.stateChange, handler);
+        throw error;
+      }
+    }
+  }
+  unregisterFromStateChange(handler) {
+    this.unregister(this.stateChange, handler);
+  }
+  registerForNavigation(handler) {
+    this.register(this.navigation, handler);
+  }
+  unregisterFromNavigation(handler) {
+    this.unregister(this.navigation, handler);
+  }
+  registerForErrors(handler) {
+    this.register(this.error, handler);
+  }
+  unregisterFromErrors(handler) {
+    this.unregister(this.error, handler);
+  }
+  emitStateChange(data) {
+    this.state = data;
+    this.emit(this.stateChange, data);
+  }
+  /**
+   * Drops the retained state as well as notifying. Without clearing `state`,
+   * `registerForStateChange` would replay the pre-reset value to any presenter
+   * constructed afterwards.
+   */
+  resetState() {
+    this.state = void 0;
+    this.emit(this.stateChange, void 0);
+  }
+  emitError(error) {
+    if (!this.events[this.error]?.length) {
+      console.error("Unhandled use case error:", error);
+      return;
+    }
+    this.emit(this.error, error);
+  }
+  emitNavigation(url) {
+    this.emit(this.navigation, url);
+  }
+  register(event, handler) {
+    if (!this.events[event]) {
+      this.events[event] = [];
+    }
+    this.events[event].push(handler);
+  }
+  unregister(event, handler) {
+    if (!this.events[event]) return;
+    this.events[event] = this.events[event].filter((h2) => h2 !== handler);
+  }
+  emit(event, data) {
+    if (!this.events[event]) return;
+    this.events[event].forEach((handler) => {
+      try {
+        handler(data);
+      } catch (error) {
+        console.error(`Error in ${event} handler:`, error);
+      }
+    });
+  }
+};
+function createScope(initialState) {
+  const scope = {
+    state: initialState,
+    initialStatePromise: void 0,
+    runningUseCases: /* @__PURE__ */ new Map(),
+    emitter: new ConcreteEventEmitter(),
+    sources: /* @__PURE__ */ new Map(),
+    openMutationWindows: 0
+  };
+  return scope;
+}
+var browserScope = createScope();
+var resolveScope = () => browserScope;
+function currentScope() {
+  return resolveScope();
+}
+function setScopeResolver(resolver) {
+  resolveScope = resolver;
+}
+function onError(handler) {
+  const { emitter } = currentScope();
+  const wrapper = (data) => {
+    if (data instanceof Error) handler(data);
+  };
+  emitter.registerForErrors(wrapper);
+  return () => emitter.unregisterFromErrors(wrapper);
+}
+function onNavigation(handler) {
+  const { emitter } = currentScope();
+  const wrapper = (data) => {
+    if (typeof data === "string") handler(data);
+  };
+  emitter.registerForNavigation(wrapper);
+  return () => emitter.unregisterFromNavigation(wrapper);
+}
+function openMutationWindow() {
+  currentScope().openMutationWindows += 1;
+}
+function closeMutationWindow() {
+  const scope = currentScope();
+  scope.openMutationWindows = Math.max(0, scope.openMutationWindows - 1);
+}
+function isMutationWindowOpen() {
+  return currentScope().openMutationWindows > 0;
+}
+async function withMutationWindow(run) {
+  openMutationWindow();
+  try {
+    return await run();
+  } finally {
+    closeMutationWindow();
+  }
+}
+function assertMutationWindowOpen(operation) {
+  if (isMutationWindowOpen()) return;
+  throw new Error(
+    `[magic-use-case] ${operation} is only allowed inside a running use case.`
+  );
+}
+var mutatingMapMethods = /* @__PURE__ */ new Set(["set", "delete", "clear"]);
+var mutatingSetMethods = /* @__PURE__ */ new Set(["add", "delete", "clear"]);
+var mutatingArrayMethods = /* @__PURE__ */ new Set([
+  "push",
+  "pop",
+  "shift",
+  "unshift",
+  "splice",
+  "sort",
+  "reverse",
+  "fill",
+  "copyWithin"
+]);
+var iteratorKeys = /* @__PURE__ */ new Set(["values", "entries", Symbol.iterator]);
+var READONLY = {
+  marker: /* @__PURE__ */ Symbol("readonly"),
+  cache: /* @__PURE__ */ new WeakMap(),
+  label: "readonly ",
+  allows: () => false,
+  reject(action) {
+    throw new Error(`Cannot ${action} on readonly object`);
+  }
+};
+var USE_CASE = {
+  marker: /* @__PURE__ */ Symbol("useCaseWritable"),
+  cache: /* @__PURE__ */ new WeakMap(),
+  label: "",
+  allows: isMutationWindowOpen,
+  reject(action) {
+    throw new Error(
+      `[magic-use-case] Cannot ${action} outside a use case.
+
+Application state may only be mutated from within a running use case, so that every change emits a state-change event and reaches the UI. Mutating it elsewhere would leave presenters showing stale data.
+
+Move this write into a use case's runLogic().`
+    );
+  }
+};
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function mustReturnRaw(target, prop) {
+  const descriptor = Object.getOwnPropertyDescriptor(target, prop);
+  return descriptor !== void 0 && descriptor.configurable === false && descriptor.writable === false;
+}
+function wrap(value, policy) {
+  return isObject(value) ? proxyFor(value, policy) : value;
+}
+function createMapProxy(target, policy) {
+  return new Proxy(target, {
+    get(target2, prop, receiver) {
+      if (prop === policy.marker) return true;
+      if (typeof prop === "string" && mutatingMapMethods.has(prop)) {
+        if (!policy.allows()) return () => policy.reject(`call .${prop}() on ${policy.label}Map`);
+        const method = Reflect.get(target2, prop, target2);
+        return method.bind(target2);
+      }
+      if (prop === "get") {
+        return (key) => wrap(target2.get(key), policy);
+      }
+      if (prop === "forEach") {
+        return (cb) => target2.forEach((v2, k2) => cb(wrap(v2, policy), k2, receiver));
+      }
+      if (iteratorKeys.has(prop)) {
+        return function* () {
+          if (prop === "values") {
+            for (const v2 of target2.values()) yield wrap(v2, policy);
+          } else {
+            for (const [k2, v2] of target2.entries()) yield [k2, wrap(v2, policy)];
+          }
+        };
+      }
+      const value = Reflect.get(target2, prop, target2);
+      if (prop === "constructor" || typeof value !== "function") return value;
+      return value.bind(target2);
+    },
+    set(target2, prop, value) {
+      if (!policy.allows()) policy.reject(`set property '${String(prop)}'`);
+      return Reflect.set(target2, prop, value);
+    },
+    deleteProperty(target2, prop) {
+      if (!policy.allows()) policy.reject(`delete property '${String(prop)}'`);
+      return Reflect.deleteProperty(target2, prop);
+    },
+    defineProperty(target2, prop, attributes) {
+      if (!policy.allows()) policy.reject(`define property '${String(prop)}'`);
+      return Reflect.defineProperty(target2, prop, attributes);
+    }
+  });
+}
+function createSetProxy(target, policy) {
+  return new Proxy(target, {
+    get(target2, prop, receiver) {
+      if (prop === policy.marker) return true;
+      if (typeof prop === "string" && mutatingSetMethods.has(prop)) {
+        if (!policy.allows()) return () => policy.reject(`call .${prop}() on ${policy.label}Set`);
+        const method = Reflect.get(target2, prop, target2);
+        return method.bind(target2);
+      }
+      if (iteratorKeys.has(prop)) {
+        return function* () {
+          for (const v2 of target2.values()) yield wrap(v2, policy);
+        };
+      }
+      if (prop === "forEach") {
+        return (cb) => target2.forEach((v2) => cb(wrap(v2, policy), wrap(v2, policy), receiver));
+      }
+      const value = Reflect.get(target2, prop, target2);
+      if (prop === "constructor" || typeof value !== "function") return value;
+      return value.bind(target2);
+    },
+    set(target2, prop, value) {
+      if (!policy.allows()) policy.reject(`set property '${String(prop)}'`);
+      return Reflect.set(target2, prop, value);
+    },
+    deleteProperty(target2, prop) {
+      if (!policy.allows()) policy.reject(`delete property '${String(prop)}'`);
+      return Reflect.deleteProperty(target2, prop);
+    },
+    defineProperty(target2, prop, attributes) {
+      if (!policy.allows()) policy.reject(`define property '${String(prop)}'`);
+      return Reflect.defineProperty(target2, prop, attributes);
+    }
+  });
+}
+function createObjectProxy(target, policy) {
+  return new Proxy(target, {
+    get(target2, prop) {
+      if (prop === policy.marker) return true;
+      if (Array.isArray(target2) && typeof prop === "string" && mutatingArrayMethods.has(prop)) {
+        if (!policy.allows()) return () => policy.reject(`call .${prop}() on ${policy.label}Array`);
+        const method = Reflect.get(target2, prop, target2);
+        return method.bind(target2);
+      }
+      const value = Reflect.get(target2, prop, target2);
+      if (typeof value === "function") return prop === "constructor" ? value : value.bind(target2);
+      if (!isObject(value) || mustReturnRaw(target2, prop)) return value;
+      return proxyFor(value, policy);
+    },
+    set(target2, prop, value) {
+      if (!policy.allows()) policy.reject(`set property '${String(prop)}'`);
+      return Reflect.set(target2, prop, value);
+    },
+    deleteProperty(target2, prop) {
+      if (!policy.allows()) policy.reject(`delete property '${String(prop)}'`);
+      return Reflect.deleteProperty(target2, prop);
+    },
+    defineProperty(target2, prop, attributes) {
+      if (!policy.allows()) policy.reject(`define property '${String(prop)}'`);
+      return Reflect.defineProperty(target2, prop, attributes);
+    }
+  });
+}
+function proxyFor(obj, policy) {
+  if (obj === null || typeof obj !== "object") return obj;
+  if (obj[policy.marker]) return obj;
+  const cached = policy.cache.get(obj);
+  if (cached) return cached;
+  let proxy;
+  if (obj instanceof Map) {
+    proxy = createMapProxy(obj, policy);
+  } else if (obj instanceof Set) {
+    proxy = createSetProxy(obj, policy);
+  } else {
+    proxy = createObjectProxy(obj, policy);
+  }
+  policy.cache.set(obj, proxy);
+  return proxy;
+}
+function deepReadonly(obj) {
+  return proxyFor(obj, READONLY);
+}
+function useCaseWritable(obj) {
+  return proxyFor(obj, USE_CASE);
+}
+function cloneCollection(value, seen) {
+  if (value instanceof Map) {
+    const copy = /* @__PURE__ */ new Map();
+    seen.set(value, copy);
+    for (const [k2, v2] of value.entries()) {
+      copy.set(deepClone(k2, seen), deepClone(v2, seen));
+    }
+    return copy;
+  }
+  if (value instanceof Set) {
+    const copy = /* @__PURE__ */ new Set();
+    seen.set(value, copy);
+    for (const v2 of value.values()) {
+      copy.add(deepClone(v2, seen));
+    }
+    return copy;
+  }
+  if (Array.isArray(value)) {
+    const copy = [];
+    seen.set(value, copy);
+    for (const v2 of value) copy.push(deepClone(v2, seen));
+    return copy;
+  }
+  return void 0;
+}
+function deepClone(value, seen = /* @__PURE__ */ new WeakMap()) {
+  if (value === null || typeof value !== "object") return value;
+  const asObject = value;
+  const existing = seen.get(asObject);
+  if (existing !== void 0) return existing;
+  if (value instanceof Date) return new Date(value.getTime());
+  if (value instanceof RegExp) return new RegExp(value.source, value.flags);
+  const collection = cloneCollection(asObject, seen);
+  if (collection !== void 0) return collection;
+  const copy = Object.create(Object.getPrototypeOf(asObject));
+  seen.set(asObject, copy);
+  for (const key of Reflect.ownKeys(asObject)) {
+    const descriptor = Object.getOwnPropertyDescriptor(asObject, key);
+    if (!descriptor) continue;
+    if ("value" in descriptor) {
+      Object.defineProperty(copy, key, {
+        ...descriptor,
+        value: deepClone(descriptor.value, seen)
+      });
+    } else {
+      Object.defineProperty(copy, key, descriptor);
+    }
+  }
+  if (Object.isFrozen(asObject)) Object.freeze(copy);
+  else if (Object.isSealed(asObject)) Object.seal(copy);
+  return copy;
+}
+var entryPoints = /* @__PURE__ */ new WeakSet();
+function createUseCase(UseCaseClass, onProgress) {
+  const useCase = new UseCaseClass(onProgress);
+  entryPoints.add(useCase);
+  return useCase;
+}
+var UseCase = class {
+  constructor(onProgress) {
+    __publicField(this, "onProgress");
+    this.onProgress = onProgress;
+  }
+  /** Resolved per emit, so an execution always announces on the scope it is running in. */
+  get eventEmitter() {
+    return currentScope().emitter;
+  }
+  execute(params) {
+    return this.run(params, { hasCaller: !entryPoints.has(this) });
+  }
+  /**
+   * Starts a use case that this one does not wait for. It runs on its own: the
+   * caller returns and announces its own changes immediately, and the detached
+   * run announces its own when it lands. Nobody is waiting on it, so its failure
+   * is reported rather than thrown.
+   */
+  detach(UseCaseClass, params) {
+    void createUseCase(UseCaseClass).run(params, { hasCaller: false }).catch(() => void 0);
+  }
+  async run(params, run) {
+    const scope = currentScope();
+    if (scope.state === void 0) {
+      if (!scope.initialStatePromise) {
+        scope.initialStatePromise = this.initializeState().then((state) => {
+          scope.state = deepClone(state);
+        });
+      }
+      try {
+        await scope.initialStatePromise;
+      } catch (error) {
+        this.reportUnlessCallerWill(error, run);
+        throw error;
+      } finally {
+        scope.initialStatePromise = void 0;
+      }
+    }
+    const classMap = scope.runningUseCases.get(this.constructor) ?? /* @__PURE__ */ new Map();
+    scope.runningUseCases.set(this.constructor, classMap);
+    const paramsKey = JSON.stringify(params);
+    if (classMap.has(paramsKey)) {
+      await classMap.get(paramsKey);
+      this.announceUnlessCallerWill(run);
+      return;
+    }
+    const executionPromise = this.runWithUpdate(() => this.runLogic(params), run);
+    classMap.set(paramsKey, executionPromise);
+    try {
+      await executionPromise;
+    } finally {
+      classMap.delete(paramsKey);
+      if (classMap.size === 0) {
+        scope.runningUseCases.delete(this.constructor);
+      }
+    }
+  }
+  getState() {
+    return useCaseWritable(currentScope().state);
+  }
+  /**
+   * Clears application state so the next execution bootstraps it again.
+   *
+   * All four pieces of module state go together: the state itself, the
+   * emitter's retained copy, the in-flight dedup map, and any bootstrap in
+   * flight. Leaving any one behind resurrects the old state.
+   */
+  resetAppState() {
+    assertMutationWindowOpen("Resetting application state");
+    const scope = currentScope();
+    scope.state = void 0;
+    scope.runningUseCases.clear();
+    scope.initialStatePromise = void 0;
+    this.eventEmitter.resetState();
+  }
+  navigate(url) {
+    this.eventEmitter.emitNavigation(url);
+  }
+  /**
+   * Announces a failure the screen should hear about, for a use case that
+   * handles the failure rather than rethrowing it. Anything rethrown is
+   * reported on its way out and must not be reported here as well.
+   */
+  report(error) {
+    this.eventEmitter.emitError(error);
+  }
+  /**
+   * A run announces its work unless somebody is waiting on it. A nested run
+   * stays silent and its caller announces everything written beneath it, once.
+   *
+   * Whether a run has a caller is known when it starts, which is what keeps an
+   * unrelated run finishing at the same moment from being swallowed: two flows
+   * a screen started independently each reach it on their own.
+   */
+  async runWithUpdate(functionToRun, run) {
+    try {
+      await withMutationWindow(functionToRun);
+    } catch (error) {
+      this.reportUnlessCallerWill(error, run);
+      throw error;
+    } finally {
+      this.announceUnlessCallerWill(run);
+    }
+  }
+  announceUnlessCallerWill(run) {
+    if (run.hasCaller) return;
+    this.eventEmitter.emitStateChange(deepReadonly(currentScope().state));
+  }
+  /**
+   * Counting who is running cannot tell a caller from an unrelated run that
+   * happens to overlap, and guessing wrong loses the failure entirely. Whether
+   * this run has a caller is known when it starts, so that is what decides.
+   */
+  reportUnlessCallerWill(error, run) {
+    if (run.hasCaller) return;
+    this.report(error instanceof Error ? error : new Error(String(error)));
+  }
+};
+function acquireSource(scope, presentation) {
+  const existing = scope.sources.get(presentation);
+  if (existing) {
+    existing.presenters += 1;
+    return existing;
+  }
+  const source = {
+    model: void 0,
+    listeners: /* @__PURE__ */ new Set(),
+    presenters: 1,
+    handler: (state) => {
+      if (state === void 0) {
+        source.model = void 0;
+      } else {
+        try {
+          source.model = presentation(state);
+        } catch (error) {
+          console.error("[magic-use-case] A presentation threw; its model is left empty.", error);
+          source.model = void 0;
+        }
+      }
+      source.listeners.forEach((listener) => listener(source.model));
+    }
+  };
+  scope.sources.set(presentation, source);
+  scope.emitter.registerForStateChange(source.handler);
+  if (source.model === void 0 && scope.state !== void 0) {
+    source.handler(deepReadonly(scope.state));
+  }
+  return source;
+}
+function releaseSource(scope, presentation) {
+  const source = scope.sources.get(presentation);
+  if (!source) return;
+  source.presenters -= 1;
+  if (source.presenters > 0) return;
+  scope.emitter.unregisterFromStateChange(source.handler);
+  scope.sources.delete(presentation);
+}
+var Presenter = class {
+  constructor(presentation) {
+    __publicField(this, "model");
+    __publicField(this, "subscribers", /* @__PURE__ */ new Set());
+    __publicField(this, "presentation");
+    __publicField(this, "source");
+    __publicField(this, "onModel");
+    __publicField(this, "scope");
+    this.presentation = presentation;
+    this.onModel = (model) => {
+      this.model = model;
+      this.notifySubscribers();
+    };
+    this.scope = currentScope();
+    this.source = acquireSource(this.scope, presentation);
+    this.model = this.source.model;
+    this.source.listeners.add(this.onModel);
+  }
+  subscribe(listener) {
+    this.subscribers.add(listener);
+    listener(this.model);
+  }
+  unsubscribe(listener) {
+    this.subscribers.delete(listener);
+  }
+  notifySubscribers() {
+    this.subscribers.forEach((listener) => listener(this.model));
+  }
+  destroy() {
+    if (!this.source) return;
+    this.source.listeners.delete(this.onModel);
+    this.source = void 0;
+    releaseSource(this.scope, this.presentation);
+    this.subscribers.clear();
+    this.model = void 0;
+  }
+};
+var M = ((i) => (i[i.AggregateError = 1] = "AggregateError", i[i.ArrowFunction = 2] = "ArrowFunction", i[i.ErrorPrototypeStack = 4] = "ErrorPrototypeStack", i[i.ObjectAssign = 8] = "ObjectAssign", i[i.BigIntTypedArray = 16] = "BigIntTypedArray", i[i.RegExp = 32] = "RegExp", i))(M || {});
+var v = Symbol.asyncIterator;
+var dr = Symbol.hasInstance;
+var R = Symbol.isConcatSpreadable;
+var C = Symbol.iterator;
+var gr = Symbol.match;
+var yr = Symbol.matchAll;
+var Nr = Symbol.replace;
+var br = Symbol.search;
+var vr = Symbol.species;
+var Cr = Symbol.split;
+var Ar = Symbol.toPrimitive;
+var P = Symbol.toStringTag;
+var Er = Symbol.unscopables;
+var nt = { 0: "Symbol.asyncIterator", 1: "Symbol.hasInstance", 2: "Symbol.isConcatSpreadable", 3: "Symbol.iterator", 4: "Symbol.match", 5: "Symbol.matchAll", 6: "Symbol.replace", 7: "Symbol.search", 8: "Symbol.species", 9: "Symbol.split", 10: "Symbol.toPrimitive", 11: "Symbol.toStringTag", 12: "Symbol.unscopables" };
+var Ce = { [v]: 0, [dr]: 1, [R]: 2, [C]: 3, [gr]: 4, [yr]: 5, [Nr]: 6, [br]: 7, [vr]: 8, [Cr]: 9, [Ar]: 10, [P]: 11, [Er]: 12 };
+var at = { 2: "!0", 3: "!1", 1: "void 0", 0: "null", 4: "-0", 5: "1/0", 6: "-1/0", 7: "0/0" };
+var o = void 0;
+var Ae = { 0: "Error", 1: "EvalError", 2: "RangeError", 3: "ReferenceError", 4: "SyntaxError", 5: "TypeError", 6: "URIError" };
+function c(e, r, t, n, a, s, i, u, l, g, S, d) {
+  return { t: e, i: r, s: t, c: n, m: a, p: s, e: i, a: u, f: l, b: g, o: S, l: d };
+}
+function B(e) {
+  return c(2, o, e, o, o, o, o, o, o, o, o, o);
+}
+var H = B(2);
+var J = B(3);
+var Ee = B(1);
+var Ie = B(0);
+var ut = B(4);
+var lt = B(5);
+var ct = B(6);
+var ft = B(7);
+function dn(e) {
+  switch (e) {
+    case '"':
+      return '\\"';
+    case "\\":
+      return "\\\\";
+    case `
+`:
+      return "\\n";
+    case "\r":
+      return "\\r";
+    case "\b":
+      return "\\b";
+    case "	":
+      return "\\t";
+    case "\f":
+      return "\\f";
+    case "<":
+      return "\\x3C";
+    case "\u2028":
+      return "\\u2028";
+    case "\u2029":
+      return "\\u2029";
+    default:
+      return o;
+  }
+}
+function y(e) {
+  let r = "", t = 0, n;
+  for (let a = 0, s = e.length; a < s; a++) n = dn(e[a]), n && (r += e.slice(t, a) + n, t = a + 1);
+  return t === 0 ? r = e : r += e.slice(t), r;
+}
+function gn(e) {
+  switch (e) {
+    case "\\\\":
+      return "\\";
+    case '\\"':
+      return '"';
+    case "\\n":
+      return `
+`;
+    case "\\r":
+      return "\r";
+    case "\\b":
+      return "\b";
+    case "\\t":
+      return "	";
+    case "\\f":
+      return "\f";
+    case "\\x3C":
+      return "<";
+    case "\\u2028":
+      return "\u2028";
+    case "\\u2029":
+      return "\u2029";
+    default:
+      return e;
+  }
+}
+function h(e) {
+  return e.replace(/(\\\\|\\"|\\n|\\r|\\b|\\t|\\f|\\u2028|\\u2029|\\x3C)/g, gn);
+}
+var L = "__SEROVAL_REFS__";
+var le = "$R";
+var Ir = /* @__PURE__ */ new Map();
+var U = /* @__PURE__ */ new Map();
+function Rr(e) {
+  return Ir.has(e);
+}
+function St(e) {
+  if (Rr(e)) return Ir.get(e);
+  throw new Pe(e);
+}
+typeof globalThis != "undefined" ? Object.defineProperty(globalThis, L, { value: U, configurable: true, writable: false, enumerable: false }) : typeof window != "undefined" ? Object.defineProperty(window, L, { value: U, configurable: true, writable: false, enumerable: false }) : typeof self != "undefined" ? Object.defineProperty(self, L, { value: U, configurable: true, writable: false, enumerable: false }) : typeof global != "undefined" && Object.defineProperty(global, L, { value: U, configurable: true, writable: false, enumerable: false });
+function Te(e) {
+  return e instanceof EvalError ? 1 : e instanceof RangeError ? 2 : e instanceof ReferenceError ? 3 : e instanceof SyntaxError ? 4 : e instanceof TypeError ? 5 : e instanceof URIError ? 6 : 0;
+}
+function vn(e) {
+  let r = Ae[Te(e)];
+  return e.name !== r ? { name: e.name } : e.constructor.name !== r ? { name: e.constructor.name } : {};
+}
+function Z(e, r) {
+  let t = vn(e), n = Object.getOwnPropertyNames(e);
+  for (let a = 0, s = n.length, i; a < s; a++) i = n[a], i !== "name" && i !== "message" && (i === "stack" ? r & 4 && (t = t || {}, t[i] = e[i]) : (t = t || {}, t[i] = e[i]));
+  return t;
+}
+function Oe(e) {
+  return Object.isFrozen(e) ? 3 : Object.isSealed(e) ? 2 : Object.isExtensible(e) ? 0 : 1;
+}
+function we(e) {
+  switch (e) {
+    case Number.POSITIVE_INFINITY:
+      return lt;
+    case Number.NEGATIVE_INFINITY:
+      return ct;
+  }
+  return e !== e ? ft : Object.is(e, -0) ? ut : c(0, o, e, o, o, o, o, o, o, o, o, o);
+}
+function $(e) {
+  return c(1, o, y(e), o, o, o, o, o, o, o, o, o);
+}
+function he(e) {
+  return c(3, o, "" + e, o, o, o, o, o, o, o, o, o);
+}
+function dt(e) {
+  return c(4, e, o, o, o, o, o, o, o, o, o, o);
+}
+function ze(e, r) {
+  let t = r.valueOf();
+  return c(5, e, t !== t ? "" : r.toISOString(), o, o, o, o, o, o, o, o, o);
+}
+function _e(e, r) {
+  return c(6, e, o, y(r.source), r.flags, o, o, o, o, o, o, o);
+}
+function gt(e, r) {
+  return c(17, e, Ce[r], o, o, o, o, o, o, o, o, o);
+}
+function yt(e, r) {
+  return c(18, e, y(St(r)), o, o, o, o, o, o, o, o, o);
+}
+function ce(e, r, t) {
+  return c(25, e, t, y(r), o, o, o, o, o, o, o, o);
+}
+function ke(e, r, t) {
+  return c(9, e, o, o, o, o, o, t, o, o, Oe(r), o);
+}
+function De(e, r) {
+  return c(21, e, o, o, o, o, o, o, r, o, o, o);
+}
+function Fe(e, r, t) {
+  return c(15, e, o, r.constructor.name, o, o, o, o, t, r.byteOffset, o, r.length);
+}
+function Be(e, r, t) {
+  return c(16, e, o, r.constructor.name, o, o, o, o, t, r.byteOffset, o, r.length);
+}
+function Ve(e, r, t) {
+  return c(20, e, o, o, o, o, o, o, t, r.byteOffset, o, r.byteLength);
+}
+function Me(e, r, t) {
+  return c(13, e, Te(r), o, y(r.message), t, o, o, o, o, o, o);
+}
+function Le(e, r, t) {
+  return c(14, e, Te(r), o, y(r.message), t, o, o, o, o, o, o);
+}
+function Ue(e, r) {
+  return c(7, e, o, o, o, o, o, r, o, o, o, o);
+}
+function je(e, r) {
+  return c(28, o, o, o, o, o, o, [e, r], o, o, o, o);
+}
+function Ye(e, r) {
+  return c(30, o, o, o, o, o, o, [e, r], o, o, o, o);
+}
+function qe(e, r, t) {
+  return c(31, e, o, o, o, o, o, t, r, o, o, o);
+}
+function We(e, r) {
+  return c(32, e, o, o, o, o, o, o, r, o, o, o);
+}
+function Ke(e, r) {
+  return c(33, e, o, o, o, o, o, o, r, o, o, o);
+}
+function Ge(e, r) {
+  return c(34, e, o, o, o, o, o, o, r, o, o, o);
+}
+function He(e, r, t, n) {
+  return c(35, e, t, o, o, o, o, r, o, o, o, n);
+}
+var Cn = { parsing: 1, serialization: 2, deserialization: 3 };
+function An(e) {
+  return `Seroval Error (step: ${Cn[e]})`;
+}
+var En = (e, r) => An(e);
+var fe = class extends Error {
+  constructor(t, n) {
+    super(En(t, n));
+    this.cause = n;
+  }
+};
+var _ = class extends fe {
+  constructor(r) {
+    super("parsing", r);
+  }
+};
+function k(e) {
+  return `Seroval Error (specific: ${e})`;
+}
+var x = class extends Error {
+  constructor(t) {
+    super(k(1));
+    this.value = t;
+  }
+};
+var z = class extends Error {
+  constructor(r) {
+    super(k(2));
+  }
+};
+var X = class extends Error {
+  constructor(r) {
+    super(k(3));
+  }
+};
+var Pe = class extends Error {
+  constructor(t) {
+    super(k(5));
+    this.value = t;
+  }
+};
+var Q = class extends Error {
+  constructor(r) {
+    super(k(9));
+  }
+};
+var j = class {
+  constructor(r, t) {
+    this.value = r;
+    this.replacement = t;
+  }
+};
+var ee = () => {
+  let e = { p: 0, s: 0, f: 0 };
+  return e.p = new Promise((r, t) => {
+    e.s = r, e.f = t;
+  }), e;
+};
+var In = (e, r) => {
+  e.s(r), e.p.s = 1, e.p.v = r;
+};
+var Rn = (e, r) => {
+  e.f(r), e.p.s = 2, e.p.v = r;
+};
+var bt = ee.toString();
+var vt = In.toString();
+var Ct = Rn.toString();
+var xr = () => {
+  let e = [], r = [], t = true, n = false, a = 0, s = (l, g, S) => {
+    for (S = 0; S < a; S++) r[S] && r[S][g](l);
+  }, i = (l, g, S, d) => {
+    for (g = 0, S = e.length; g < S; g++) d = e[g], !t && g === S - 1 ? l[n ? "return" : "throw"](d) : l.next(d);
+  }, u = (l, g) => (t && (g = a++, r[g] = l), i(l), () => {
+    t && (r[g] = r[a], r[a--] = void 0);
+  });
+  return { __SEROVAL_STREAM__: true, on: (l) => u(l), next: (l) => {
+    t && (e.push(l), s(l, "next"));
+  }, throw: (l) => {
+    t && (e.push(l), s(l, "throw"), t = false, n = false, r.length = 0);
+  }, return: (l) => {
+    t && (e.push(l), s(l, "return"), t = false, n = true, r.length = 0);
+  } };
+};
+var At = xr.toString();
+var Tr = (e) => (r) => () => {
+  let t = 0, n = { [e]: () => n, next: () => {
+    if (t > r.d) return { done: true, value: void 0 };
+    let a = t++, s = r.v[a];
+    if (a === r.t) throw s;
+    return { done: a === r.d, value: s };
+  } };
+  return n;
+};
+var Et = Tr.toString();
+var Or = (e, r) => (t) => () => {
+  let n = 0, a = -1, s = false, i = [], u = [], l = (S = 0, d = u.length) => {
+    for (; S < d; S++) u[S].s({ done: true, value: void 0 });
+  };
+  t.on({ next: (S) => {
+    let d = u.shift();
+    d && d.s({ done: false, value: S }), i.push(S);
+  }, throw: (S) => {
+    let d = u.shift();
+    d && d.f(S), l(), a = i.length, s = true, i.push(S);
+  }, return: (S) => {
+    let d = u.shift();
+    d && d.s({ done: true, value: S }), l(), a = i.length, i.push(S);
+  } });
+  let g = { [e]: () => g, next: () => {
+    if (a === -1) {
+      let K = n++;
+      if (K >= i.length) {
+        let tt = r();
+        return u.push(tt), tt.p;
+      }
+      return { done: false, value: i[K] };
+    }
+    if (n > a) return { done: true, value: void 0 };
+    let S = n++, d = i[S];
+    if (S !== a) return { done: false, value: d };
+    if (s) throw d;
+    return { done: true, value: d };
+  } };
+  return g;
+};
+var It = Or.toString();
+var wr = (e) => {
+  let r = atob(e), t = r.length, n = new Uint8Array(t);
+  for (let a = 0; a < t; a++) n[a] = r.charCodeAt(a);
+  return n.buffer;
+};
+var Rt = wr.toString();
+function $e(e) {
+  return "__SEROVAL_SEQUENCE__" in e;
+}
+function hr(e, r, t) {
+  return { __SEROVAL_SEQUENCE__: true, v: e, t: r, d: t };
+}
+function Xe(e) {
+  let r = [], t = -1, n = -1, a = e[C]();
+  for (; ; ) try {
+    let s = a.next();
+    if (r.push(s.value), s.done) {
+      n = r.length - 1;
+      break;
+    }
+  } catch (s) {
+    t = r.length, r.push(s);
+  }
+  return hr(r, t, n);
+}
+Tr(C);
+var xt = {};
+var Tt = {};
+var Ot = { 0: {}, 1: {}, 2: {}, 3: {}, 4: {}, 5: {} };
+var wt = { 0: "[]", 1: bt, 2: vt, 3: Ct, 4: At, 5: Rt };
+function Qe(e) {
+  return "__SEROVAL_STREAM__" in e;
+}
+function re() {
+  return xr();
+}
+function er(e) {
+  let r = re(), t = e[v]();
+  async function n() {
+    try {
+      let a = await t.next();
+      a.done ? r.return(a.value) : (r.next(a.value), await n());
+    } catch (a) {
+      r.throw(a);
+    }
+  }
+  return n().catch(() => {
+  }), r;
+}
+Or(v, ee);
+function me(e, r) {
+  return { plugins: r.plugins, mode: e, marked: /* @__PURE__ */ new Set(), features: 63 ^ (r.disabledFeatures || 0), refs: r.refs || /* @__PURE__ */ new Map(), depthLimit: r.depthLimit || 1e3 };
+}
+function pe(e, r) {
+  e.marked.add(r);
+}
+function _r(e, r) {
+  let t = e.refs.size;
+  return e.refs.set(r, t), t;
+}
+function rr(e, r) {
+  let t = e.refs.get(r);
+  return t != null ? (pe(e, t), { type: 1, value: dt(t) }) : { type: 0, value: _r(e, r) };
+}
+function Y(e, r) {
+  let t = rr(e, r);
+  return t.type === 1 ? t : Rr(r) ? { type: 2, value: yt(t.value, r) } : t;
+}
+function I(e, r) {
+  let t = Y(e, r);
+  if (t.type !== 0) return t.value;
+  if (r in Ce) return gt(t.value, r);
+  throw new x(r);
+}
+function D(e, r) {
+  let t = rr(e, Ot[r]);
+  return t.type === 1 ? t.value : c(26, t.value, r, o, o, o, o, o, o, o, o, o);
+}
+function tr(e) {
+  let r = rr(e, xt);
+  return r.type === 1 ? r.value : c(27, r.value, o, o, o, o, o, o, I(e, C), o, o, o);
+}
+function nr(e) {
+  let r = rr(e, Tt);
+  return r.type === 1 ? r.value : c(29, r.value, o, o, o, o, o, [D(e, 1), I(e, v)], o, o, o, o);
+}
+function or(e, r, t, n) {
+  return c(t ? 11 : 10, e, o, o, o, n, o, o, o, o, Oe(r), o);
+}
+function ar(e, r, t, n) {
+  return c(8, r, o, o, o, o, { k: t, v: n }, o, D(e, 0), o, o, o);
+}
+function _t(e, r, t) {
+  return c(22, r, t, o, o, o, o, o, D(e, 1), o, o, o);
+}
+function sr(e, r, t) {
+  let n = new Uint8Array(t), a = "";
+  for (let s = 0, i = n.length; s < i; s++) a += String.fromCharCode(n[s]);
+  return c(19, r, y(btoa(a)), o, o, o, o, o, D(e, 5), o, o, o);
+}
+var oe = ((t) => (t[t.Vanilla = 1] = "Vanilla", t[t.Cross = 2] = "Cross", t))(oe || {});
+function Ft(e, r) {
+  for (let t = 0, n = r.length; t < n; t++) {
+    let a = r[t];
+    e.has(a) || (e.add(a), a.extends && Ft(e, a.extends));
+  }
+}
+function A(e) {
+  if (e) {
+    let r = /* @__PURE__ */ new Set();
+    return Ft(r, e), [...r];
+  }
+}
+function de(e) {
+  switch (e) {
+    case "constructor":
+    case "__proto__":
+    case "prototype":
+    case "__defineGetter__":
+    case "__defineSetter__":
+    case "__lookupGetter__":
+    case "__lookupSetter__":
+      return false;
+    default:
+      return true;
+  }
+}
+var Ro = () => T;
+var Po = Ro.toString();
+var Ht = /=>/.test(Po);
+function ur(e, r) {
+  return Ht ? (e.length === 1 ? e[0] : "(" + e.join(",") + ")") + "=>" + (r.startsWith("{") ? "(" + r + ")" : r) : "function(" + e.join(",") + "){return " + r + "}";
+}
+function Jt(e, r) {
+  return Ht ? (e.length === 1 ? e[0] : "(" + e.join(",") + ")") + "=>{" + r + "}" : "function(" + e.join(",") + "){" + r + "}";
+}
+var Xt = "hjkmoquxzABCDEFGHIJKLNPQRTUVWXYZ$_";
+var Zt = Xt.length;
+var Qt = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789$_";
+var $t = Qt.length;
+function Mr(e) {
+  let r = e % Zt, t = Xt[r];
+  for (e = (e - r) / Zt; e > 0; ) r = e % $t, t += Qt[r], e = (e - r) / $t;
+  return t;
+}
+var xo = /^[$A-Z_][0-9A-Z_$]*$/i;
+function Lr(e) {
+  let r = e[0];
+  return (r === "$" || r === "_" || r >= "A" && r <= "Z" || r >= "a" && r <= "z") && xo.test(e);
+}
+function Ne(e) {
+  switch (e.t) {
+    case 0:
+      return e.s + "=" + e.v;
+    case 2:
+      return e.s + ".set(" + e.k + "," + e.v + ")";
+    case 1:
+      return e.s + ".add(" + e.v + ")";
+    case 3:
+      return e.s + ".delete(" + e.k + ")";
+    case 4:
+      return "Object.defineProperty(" + e.s + ',"__proto__",{value:' + e.k + ",configurable:!0,enumerable:!0,writable:!0})";
+  }
+}
+function To(e) {
+  let r = [], t = e[0];
+  for (let n = 1, a = e.length, s, i = t; n < a; n++) s = e[n], s.t === 0 && s.v === i.v ? t = { t: 0, s: s.s, k: o, v: Ne(t) } : s.t === 2 && s.s === i.s ? t = { t: 2, s: Ne(t), k: s.k, v: s.v } : s.t === 1 && s.s === i.s ? t = { t: 1, s: Ne(t), k: o, v: s.v } : s.t === 3 && s.s === i.s ? t = { t: 3, s: Ne(t), k: s.k, v: o } : (r.push(t), t = s), i = s;
+  return r.push(t), r;
+}
+function sn(e) {
+  if (e.length) {
+    let r = "", t = To(e);
+    for (let n = 0, a = t.length; n < a; n++) r += Ne(t[n]) + ",";
+    return r;
+  }
+  return o;
+}
+var Oo = "Object.create(null)";
+var wo = "new Set";
+var ho = "new Map";
+var zo = "Promise.resolve";
+var _o = "Promise.reject";
+var ko = { 3: "Object.freeze", 2: "Object.seal", 1: "Object.preventExtensions", 0: o };
+function un(e, r) {
+  return { mode: e, plugins: r.plugins, features: r.features, marked: new Set(r.markedRefs), stack: [], flags: [], assignments: [] };
+}
+function Do() {
+  return { valid: /* @__PURE__ */ new Map(), vars: [] };
+}
+function lr(e) {
+  return { mode: 1, base: un(1, e), state: Do(), child: o };
+}
+var Ur = class {
+  constructor(r) {
+    this._p = r;
+  }
+  serialize(r) {
+    return f(this._p, r);
+  }
+};
+function Fo(e, r) {
+  let t = e.valid.get(r);
+  t == null && (t = e.valid.size, e.valid.set(r, t));
+  let n = e.vars[t];
+  return n == null && (n = Mr(t), e.vars[t] = n), n;
+}
+function Bo(e) {
+  return le + "[" + e + "]";
+}
+function m(e, r) {
+  return e.mode === 1 ? Fo(e.state, r) : Bo(r);
+}
+function w(e, r) {
+  e.marked.add(r);
+}
+function jr(e, r) {
+  return e.marked.has(r);
+}
+function qr(e, r, t) {
+  r !== 0 && (w(e.base, t), e.base.flags.push({ type: r, value: m(e, t) }));
+}
+function Vo(e) {
+  let r = "";
+  for (let t = 0, n = e.flags, a = n.length; t < a; t++) {
+    let s = n[t];
+    r += ko[s.type] + "(" + s.value + "),";
+  }
+  return r;
+}
+function ln(e) {
+  let r = sn(e.assignments), t = Vo(e);
+  return r ? t ? r + t : r : t;
+}
+function Wr(e, r, t) {
+  e.assignments.push({ t: 0, s: r, k: o, v: t });
+}
+function Mo(e, r, t) {
+  e.base.assignments.push({ t: 1, s: m(e, r), k: o, v: t });
+}
+function ye(e, r, t, n) {
+  e.base.assignments.push({ t: 2, s: m(e, r), k: t, v: n });
+}
+function en(e, r, t) {
+  e.base.assignments.push({ t: 3, s: m(e, r), k: t, v: o });
+}
+function be(e, r, t, n) {
+  Wr(e.base, m(e, r) + "[" + t + "]", n);
+}
+function Yr(e, r, t, n) {
+  if (!de(t)) {
+    e.base.assignments.push({ t: 4, s: m(e, r), k: n, v: o });
+    return;
+  }
+  Wr(e.base, m(e, r) + "." + t, n);
+}
+function Lo(e, r, t, n) {
+  Wr(e.base, m(e, r) + ".v[" + t + "]", n);
+}
+function F(e, r) {
+  return r.t === 4 && e.stack.includes(r.i);
+}
+function ae(e, r, t) {
+  return e.mode === 1 && !jr(e.base, r) ? t : m(e, r) + "=" + t;
+}
+function Uo(e) {
+  return L + '.get("' + e.s + '")';
+}
+function rn(e, r, t, n) {
+  return t ? F(e.base, t) ? (w(e.base, r), be(e, r, n, m(e, t.i)), "") : f(e, t) : "";
+}
+function jo(e, r) {
+  let t = r.i, n = r.a, a = n.length;
+  if (a > 0) {
+    e.base.stack.push(t);
+    let s = rn(e, t, n[0], 0), i = s === "";
+    for (let u = 1, l; u < a; u++) l = rn(e, t, n[u], u), s += "," + l, i = l === "";
+    return e.base.stack.pop(), qr(e, r.o, r.i), "[" + s + (i ? ",]" : "]");
+  }
+  return "[]";
+}
+function tn(e, r, t, n) {
+  if (typeof t == "string") {
+    let a = Number(t), s = a >= 0 && a.toString() === t || Lr(t);
+    if (F(e.base, n)) {
+      let i = m(e, n.i);
+      return w(e.base, r.i), s && a !== a ? Yr(e, r.i, t, i) : be(e, r.i, s ? t : '"' + t + '"', i), "";
+    }
+    return de(t) ? (s ? t : '"' + t + '"') + ":" + f(e, n) : '["' + t + '"]:' + f(e, n);
+  }
+  return "[" + f(e, t) + "]:" + f(e, n);
+}
+function cn(e, r, t) {
+  let n = t.k, a = n.length;
+  if (a > 0) {
+    let s = t.v;
+    e.base.stack.push(r.i);
+    let i = tn(e, r, n[0], s[0]);
+    for (let u = 1, l = i; u < a; u++) l = tn(e, r, n[u], s[u]), i += (l && i && ",") + l;
+    return e.base.stack.pop(), "{" + i + "}";
+  }
+  return "{}";
+}
+function Yo(e, r) {
+  return qr(e, r.o, r.i), cn(e, r, r.p);
+}
+function qo(e, r, t, n) {
+  let a = cn(e, r, t);
+  return a !== "{}" ? "Object.assign(" + n + "," + a + ")" : n;
+}
+function Wo(e, r, t, n, a) {
+  let s = e.base, i = f(e, a), u = Number(n), l = u >= 0 && u.toString() === n || Lr(n);
+  if (F(s, a)) l && u !== u ? Yr(e, r.i, n, i) : be(e, r.i, l ? n : '"' + n + '"', i);
+  else {
+    let g = s.assignments;
+    s.assignments = t, l && u !== u ? Yr(e, r.i, n, i) : be(e, r.i, l ? n : '"' + n + '"', i), s.assignments = g;
+  }
+}
+function Ko(e, r, t, n, a) {
+  if (typeof n == "string") Wo(e, r, t, n, a);
+  else {
+    let s = e.base, i = s.stack;
+    s.stack = [];
+    let u = f(e, a);
+    s.stack = i;
+    let l = s.assignments;
+    s.assignments = t, be(e, r.i, f(e, n), u), s.assignments = l;
+  }
+}
+function Go(e, r, t) {
+  let n = t.k, a = n.length;
+  if (a > 0) {
+    let s = [], i = t.v;
+    e.base.stack.push(r.i);
+    for (let u = 0; u < a; u++) Ko(e, r, s, n[u], i[u]);
+    return e.base.stack.pop(), sn(s);
+  }
+  return o;
+}
+function Kr(e, r, t) {
+  if (r.p) {
+    let n = e.base;
+    if (n.features & 8) t = qo(e, r, r.p, t);
+    else {
+      w(n, r.i);
+      let a = Go(e, r, r.p);
+      if (a) return "(" + ae(e, r.i, t) + "," + a + m(e, r.i) + ")";
+    }
+  }
+  return t;
+}
+function Ho(e, r) {
+  return qr(e, r.o, r.i), Kr(e, r, Oo);
+}
+function Jo(e) {
+  return 'new Date("' + e.s + '")';
+}
+function Zo(e, r) {
+  if (e.base.features & 32) return "/" + h(r.c) + "/" + r.m;
+  throw new z(r);
+}
+function nn(e, r, t) {
+  let n = e.base;
+  return F(n, t) ? (w(n, r), Mo(e, r, m(e, t.i)), "") : f(e, t);
+}
+function $o(e, r) {
+  let t = wo, n = r.a, a = n.length, s = r.i;
+  if (a > 0) {
+    e.base.stack.push(s);
+    let i = nn(e, s, n[0]);
+    for (let u = 1, l = i; u < a; u++) l = nn(e, s, n[u]), i += (l && i && ",") + l;
+    e.base.stack.pop(), i && (t += "([" + i + "])");
+  }
+  return t;
+}
+function on(e, r, t, n, a) {
+  let s = e.base;
+  if (F(s, t)) {
+    let i = m(e, t.i);
+    if (w(s, r), F(s, n)) {
+      let l = m(e, n.i);
+      return ye(e, r, i, l), "";
+    }
+    if (n.t !== 4 && n.i != null && jr(s, n.i)) {
+      let l = "(" + f(e, n) + ",[" + a + "," + a + "])";
+      return ye(e, r, i, m(e, n.i)), en(e, r, a), l;
+    }
+    let u = s.stack;
+    return s.stack = [], ye(e, r, i, f(e, n)), s.stack = u, "";
+  }
+  if (F(s, n)) {
+    let i = m(e, n.i);
+    if (w(s, r), t.t !== 4 && t.i != null && jr(s, t.i)) {
+      let l = "(" + f(e, t) + ",[" + a + "," + a + "])";
+      return ye(e, r, m(e, t.i), i), en(e, r, a), l;
+    }
+    let u = s.stack;
+    return s.stack = [], ye(e, r, f(e, t), i), s.stack = u, "";
+  }
+  return "[" + f(e, t) + "," + f(e, n) + "]";
+}
+function Xo(e, r) {
+  let t = ho, n = r.e.k, a = n.length, s = r.i, i = r.f, u = m(e, i.i), l = e.base;
+  if (a > 0) {
+    let g = r.e.v;
+    l.stack.push(s);
+    let S = on(e, s, n[0], g[0], u);
+    for (let d = 1, K = S; d < a; d++) K = on(e, s, n[d], g[d], u), S += (K && S && ",") + K;
+    l.stack.pop(), S && (t += "([" + S + "])");
+  }
+  return i.t === 26 && (w(l, i.i), t = "(" + f(e, i) + "," + t + ")"), t;
+}
+function Qo(e, r) {
+  return q(e, r.f) + '("' + r.s + '")';
+}
+function ea(e, r) {
+  return "new " + r.c + "(" + f(e, r.f) + "," + r.b + "," + r.l + ")";
+}
+function ra(e, r) {
+  return "new DataView(" + f(e, r.f) + "," + r.b + "," + r.l + ")";
+}
+function ta(e, r) {
+  let t = r.i;
+  e.base.stack.push(t);
+  let n = Kr(e, r, 'new AggregateError([],"' + r.m + '")');
+  return e.base.stack.pop(), n;
+}
+function na(e, r) {
+  return Kr(e, r, "new " + Ae[r.s] + '("' + r.m + '")');
+}
+function oa(e, r) {
+  let t, n = r.f, a = r.i, s = r.s ? zo : _o, i = e.base;
+  if (F(i, n)) {
+    let u = m(e, n.i);
+    t = s + (r.s ? "().then(" + ur([], u) + ")" : "().catch(" + Jt([], "throw " + u) + ")");
+  } else {
+    i.stack.push(a);
+    let u = f(e, n);
+    i.stack.pop(), t = s + "(" + u + ")";
+  }
+  return t;
+}
+function aa(e, r) {
+  return "Object(" + f(e, r.f) + ")";
+}
+function q(e, r) {
+  let t = f(e, r);
+  return r.t === 4 ? t : "(" + t + ")";
+}
+function sa(e, r) {
+  if (e.mode === 1) throw new z(r);
+  return "(" + ae(e, r.s, q(e, r.f) + "()") + ").p";
+}
+function ia(e, r) {
+  if (e.mode === 1) throw new z(r);
+  return q(e, r.a[0]) + "(" + m(e, r.i) + "," + f(e, r.a[1]) + ")";
+}
+function ua(e, r) {
+  if (e.mode === 1) throw new z(r);
+  return q(e, r.a[0]) + "(" + m(e, r.i) + "," + f(e, r.a[1]) + ")";
+}
+function la(e, r) {
+  let t = e.base.plugins;
+  if (t) for (let n = 0, a = t.length; n < a; n++) {
+    let s = t[n];
+    if (s.tag === r.c) return e.child == null && (e.child = new Ur(e)), s.serialize(r.s, e.child, { id: r.i });
+  }
+  throw new X(r.c);
+}
+function ca(e, r) {
+  let t = "", n = false;
+  return r.f.t !== 4 && (w(e.base, r.f.i), t = "(" + f(e, r.f) + ",", n = true), t += ae(e, r.i, "(" + Et + ")(" + m(e, r.f.i) + ")"), n && (t += ")"), t;
+}
+function fa(e, r) {
+  return q(e, r.a[0]) + "(" + f(e, r.a[1]) + ")";
+}
+function Sa(e, r) {
+  let t = r.a[0], n = r.a[1], a = e.base, s = "";
+  t.t !== 4 && (w(a, t.i), s += "(" + f(e, t)), n.t !== 4 && (w(a, n.i), s += (s ? "," : "(") + f(e, n)), s && (s += ",");
+  let i = ae(e, r.i, "(" + It + ")(" + m(e, n.i) + "," + m(e, t.i) + ")");
+  return s ? s + i + ")" : i;
+}
+function ma(e, r) {
+  return q(e, r.a[0]) + "(" + f(e, r.a[1]) + ")";
+}
+function pa(e, r) {
+  let t = ae(e, r.i, q(e, r.f) + "()"), n = r.a.length;
+  if (n) {
+    let a = f(e, r.a[0]);
+    for (let s = 1; s < n; s++) a += "," + f(e, r.a[s]);
+    return "(" + t + "," + a + "," + m(e, r.i) + ")";
+  }
+  return t;
+}
+function da(e, r) {
+  return m(e, r.i) + ".next(" + f(e, r.f) + ")";
+}
+function ga(e, r) {
+  return m(e, r.i) + ".throw(" + f(e, r.f) + ")";
+}
+function ya(e, r) {
+  return m(e, r.i) + ".return(" + f(e, r.f) + ")";
+}
+function an(e, r, t, n) {
+  let a = e.base;
+  return F(a, n) ? (w(a, r), Lo(e, r, t, m(e, n.i)), "") : f(e, n);
+}
+function Na(e, r) {
+  let t = r.a, n = t.length, a = r.i;
+  if (n > 0) {
+    e.base.stack.push(a);
+    let s = an(e, a, 0, t[0]);
+    for (let i = 1, u = s; i < n; i++) u = an(e, a, i, t[i]), s += (u && s && ",") + u;
+    if (e.base.stack.pop(), s) return "{__SEROVAL_SEQUENCE__:!0,v:[" + s + "],t:" + r.s + ",d:" + r.l + "}";
+  }
+  return "{__SEROVAL_SEQUENCE__:!0,v:[],t:-1,d:0}";
+}
+function ba(e, r) {
+  switch (r.t) {
+    case 17:
+      return nt[r.s];
+    case 18:
+      return Uo(r);
+    case 9:
+      return jo(e, r);
+    case 10:
+      return Yo(e, r);
+    case 11:
+      return Ho(e, r);
+    case 5:
+      return Jo(r);
+    case 6:
+      return Zo(e, r);
+    case 7:
+      return $o(e, r);
+    case 8:
+      return Xo(e, r);
+    case 19:
+      return Qo(e, r);
+    case 16:
+    case 15:
+      return ea(e, r);
+    case 20:
+      return ra(e, r);
+    case 14:
+      return ta(e, r);
+    case 13:
+      return na(e, r);
+    case 12:
+      return oa(e, r);
+    case 21:
+      return aa(e, r);
+    case 22:
+      return sa(e, r);
+    case 25:
+      return la(e, r);
+    case 26:
+      return wt[r.s];
+    case 35:
+      return Na(e, r);
+    default:
+      throw new z(r);
+  }
+}
+function f(e, r) {
+  switch (r.t) {
+    case 2:
+      return at[r.s];
+    case 0:
+      return "" + r.s;
+    case 1:
+      return '"' + r.s + '"';
+    case 3:
+      return r.s + "n";
+    case 4:
+      return m(e, r.i);
+    case 23:
+      return ia(e, r);
+    case 24:
+      return ua(e, r);
+    case 27:
+      return ca(e, r);
+    case 28:
+      return fa(e, r);
+    case 29:
+      return Sa(e, r);
+    case 30:
+      return ma(e, r);
+    case 31:
+      return pa(e, r);
+    case 32:
+      return da(e, r);
+    case 33:
+      return ga(e, r);
+    case 34:
+      return ya(e, r);
+    default:
+      return ae(e, r.i, ba(e, r));
+  }
+}
+function fr(e, r) {
+  let t = f(e, r);
+  if (r.i != null && e.state.vars.length) {
+    let n = ln(e.base), a = t;
+    if (n) {
+      let s = m(e, r.i);
+      a = t + "," + n + s, t.startsWith(s + "=") || (a = s + "=" + a), a = "(" + a + ")";
+    }
+    return "(" + ur(e.state.vars, a) + ")()";
+  }
+  return r.t === 10 ? "(" + t + ")" : t;
+}
+function ie(e, r) {
+  return { type: 1, base: me(e, r), child: o };
+}
+var Hr = class {
+  constructor(r, t) {
+    this._p = r;
+    this.depth = t;
+  }
+  parse(r) {
+    return E(this._p, this.depth, r);
+  }
+};
+var Jr = class {
+  constructor(r, t) {
+    this._p = r;
+    this.depth = t;
+  }
+  parse(r) {
+    return E(this._p, this.depth, r);
+  }
+  parseWithError(r) {
+    return W(this._p, this.depth, r);
+  }
+  isAlive() {
+    return this._p.state.alive;
+  }
+  pushPendingState() {
+    et(this._p);
+  }
+  popPendingState() {
+    ve(this._p);
+  }
+  onParse(r) {
+    se(this._p, r);
+  }
+  onError(r) {
+    Xr(this._p, r);
+  }
+  addCleanup(r) {
+    this._p.state.cleanups.push(r);
+  }
+};
+function Ca(e, r, t) {
+  let n = [];
+  for (let a = 0, s = t.length; a < s; a++) a in t ? n[a] = E(e, r, t[a]) : n[a] = 0;
+  return n;
+}
+function Aa(e, r, t, n) {
+  return ke(t, n, Ca(e, r, n));
+}
+function $r(e, r, t) {
+  let n = Object.entries(t), a = [], s = [];
+  for (let i = 0, u = n.length; i < u; i++) a.push(y(n[i][0])), s.push(E(e, r, n[i][1]));
+  return C in t && (a.push(I(e.base, C)), s.push(je(tr(e.base), E(e, r, Xe(t))))), v in t && (a.push(I(e.base, v)), s.push(Ye(nr(e.base), E(e, r, e.type === 1 ? re() : er(t))))), P in t && (a.push(I(e.base, P)), s.push($(t[P]))), R in t && (a.push(I(e.base, R)), s.push(t[R] ? H : J)), { k: a, v: s };
+}
+function Gr(e, r, t, n, a) {
+  return or(t, n, a, $r(e, r, n));
+}
+function Ea(e, r, t, n) {
+  return De(t, E(e, r, n.valueOf()));
+}
+function Ia(e, r, t, n) {
+  return Fe(t, n, E(e, r, n.buffer));
+}
+function Ra(e, r, t, n) {
+  return Be(t, n, E(e, r, n.buffer));
+}
+function Pa(e, r, t, n) {
+  return Ve(t, n, E(e, r, n.buffer));
+}
+function fn(e, r, t, n) {
+  let a = Z(n, e.base.features);
+  return Me(t, n, a ? $r(e, r, a) : o);
+}
+function xa(e, r, t, n) {
+  let a = Z(n, e.base.features);
+  return Le(t, n, a ? $r(e, r, a) : o);
+}
+function Ta(e, r, t, n) {
+  let a = [], s = [];
+  for (let [i, u] of n.entries()) a.push(E(e, r, i)), s.push(E(e, r, u));
+  return ar(e.base, t, a, s);
+}
+function Oa(e, r, t, n) {
+  let a = [];
+  for (let s of n.keys()) a.push(E(e, r, s));
+  return Ue(t, a);
+}
+function wa(e, r, t, n) {
+  let a = qe(t, D(e.base, 4), []);
+  return e.type === 1 || (et(e), n.on({ next: (s) => {
+    if (e.state.alive) {
+      let i = W(e, r, s);
+      i && se(e, We(t, i));
+    }
+  }, throw: (s) => {
+    if (e.state.alive) {
+      let i = W(e, r, s);
+      i && se(e, Ke(t, i));
+    }
+    ve(e);
+  }, return: (s) => {
+    if (e.state.alive) {
+      let i = W(e, r, s);
+      i && se(e, Ge(t, i));
+    }
+    ve(e);
+  } })), a;
+}
+function ha(e, r, t) {
+  if (this.state.alive) {
+    let n = W(this, r, t);
+    n && se(this, c(23, e, o, o, o, o, o, [D(this.base, 2), n], o, o, o, o)), ve(this);
+  }
+}
+function za(e, r, t) {
+  if (this.state.alive) {
+    let n = W(this, r, t);
+    n && se(this, c(24, e, o, o, o, o, o, [D(this.base, 3), n], o, o, o, o));
+  }
+  ve(this);
+}
+function _a(e, r, t, n) {
+  let a = _r(e.base, {});
+  return e.type === 2 && (et(e), n.then(ha.bind(e, a, r), za.bind(e, a, r))), _t(e.base, t, a);
+}
+function ka(e, r, t, n, a) {
+  for (let s = 0, i = a.length; s < i; s++) {
+    let u = a[s];
+    if (u.parse.sync && u.test(n)) return ce(t, u.tag, u.parse.sync(n, new Hr(e, r), { id: t }));
+  }
+  return o;
+}
+function Da(e, r, t, n, a) {
+  for (let s = 0, i = a.length; s < i; s++) {
+    let u = a[s];
+    if (u.parse.stream && u.test(n)) return ce(t, u.tag, u.parse.stream(n, new Jr(e, r), { id: t }));
+  }
+  return o;
+}
+function Sn(e, r, t, n) {
+  let a = e.base.plugins;
+  return a ? e.type === 1 ? ka(e, r, t, n, a) : Da(e, r, t, n, a) : o;
+}
+function Fa(e, r, t, n) {
+  let a = [];
+  for (let s = 0, i = n.v.length; s < i; s++) a[s] = E(e, r, n.v[s]);
+  return He(t, a, n.t, n.d);
+}
+function Ba(e, r, t, n, a) {
+  switch (a) {
+    case Object:
+      return Gr(e, r, t, n, false);
+    case o:
+      return Gr(e, r, t, n, true);
+    case Date:
+      return ze(t, n);
+    case Error:
+    case EvalError:
+    case RangeError:
+    case ReferenceError:
+    case SyntaxError:
+    case TypeError:
+    case URIError:
+      return fn(e, r, t, n);
+    case Number:
+    case Boolean:
+    case String:
+    case BigInt:
+      return Ea(e, r, t, n);
+    case ArrayBuffer:
+      return sr(e.base, t, n);
+    case Int8Array:
+    case Int16Array:
+    case Int32Array:
+    case Uint8Array:
+    case Uint16Array:
+    case Uint32Array:
+    case Uint8ClampedArray:
+    case Float32Array:
+    case Float64Array:
+      return Ia(e, r, t, n);
+    case DataView:
+      return Pa(e, r, t, n);
+    case Map:
+      return Ta(e, r, t, n);
+    case Set:
+      return Oa(e, r, t, n);
+  }
+  if (a === Promise || n instanceof Promise) return _a(e, r, t, n);
+  let s = e.base.features;
+  if (s & 32 && a === RegExp) return _e(t, n);
+  if (s & 16) switch (a) {
+    case BigInt64Array:
+    case BigUint64Array:
+      return Ra(e, r, t, n);
+  }
+  if (s & 1 && typeof AggregateError != "undefined" && (a === AggregateError || n instanceof AggregateError)) return xa(e, r, t, n);
+  if (n instanceof Error) return fn(e, r, t, n);
+  if (C in n || v in n) return Gr(e, r, t, n, !!a);
+  throw new x(n);
+}
+function Va(e, r, t, n) {
+  if (Array.isArray(n)) return Aa(e, r, t, n);
+  if (Qe(n)) return wa(e, r, t, n);
+  if ($e(n)) return Fa(e, r, t, n);
+  let a = n.constructor;
+  if (a === j) return E(e, r, n.replacement);
+  let s = Sn(e, r, t, n);
+  return s || Ba(e, r, t, n, a);
+}
+function Ma(e, r, t) {
+  let n = Y(e.base, t);
+  if (n.type !== 0) return n.value;
+  let a = Sn(e, r, n.value, t);
+  if (a) return a;
+  throw new x(t);
+}
+function E(e, r, t) {
+  if (r >= e.base.depthLimit) throw new Q(e.base.depthLimit);
+  switch (typeof t) {
+    case "boolean":
+      return t ? H : J;
+    case "undefined":
+      return Ee;
+    case "string":
+      return $(t);
+    case "number":
+      return we(t);
+    case "bigint":
+      return he(t);
+    case "object": {
+      if (t) {
+        let n = Y(e.base, t);
+        return n.type === 0 ? Va(e, r + 1, n.value, t) : n.value;
+      }
+      return Ie;
+    }
+    case "symbol":
+      return I(e.base, t);
+    case "function":
+      return Ma(e, r, t);
+    default:
+      throw new x(t);
+  }
+}
+function ue(e, r) {
+  try {
+    return E(e, 0, r);
+  } catch (t) {
+    throw t instanceof _ ? t : new _(t);
+  }
+}
+function se(e, r) {
+  e.state.initial ? e.state.buffer.push(r) : Qr(e, r, false);
+}
+function Xr(e, r) {
+  if (e.state.onError) e.state.onError(r);
+  else throw r instanceof _ ? r : new _(r);
+}
+function mn(e) {
+  e.state.onDone && e.state.onDone();
+  for (let r = 0, t = e.state.cleanups.length; r < t; r++) e.state.cleanups[r]();
+}
+function Qr(e, r, t) {
+  try {
+    e.state.onParse(r, t);
+  } catch (n) {
+    Xr(e, n);
+  }
+}
+function et(e) {
+  e.state.pending++;
+}
+function ve(e) {
+  --e.state.pending <= 0 && mn(e);
+}
+function W(e, r, t) {
+  try {
+    return E(e, r, t);
+  } catch (n) {
+    return Xr(e, n), o;
+  }
+}
+function Eu(e, r = {}) {
+  let t = A(r.plugins), n = ie(1, { plugins: t, disabledFeatures: r.disabledFeatures }), a = ue(n, e), s = lr({ plugins: t, features: n.base.features, markedRefs: n.base.marked });
+  return fr(s, a);
+}
+var STATE_GLOBAL = "__MAGIC_USE_CASE_STATE__";
+function transferredState() {
+  return globalThis[STATE_GLOBAL];
+}
+function serializedStateScript() {
+  const { state } = currentScope();
+  if (state === void 0) {
+    return "";
+  }
+  return `<script>window.${STATE_GLOBAL}=${serializedOrExplained(state)}</script>`;
+}
+function serializedOrExplained(state) {
+  try {
+    return Eu(state);
+  } catch (error) {
+    throw new Error(
+      `[magic-use-case] Application state cannot be handed to the browser.
+
+Everything in it has to be data \u2014 objects, arrays, sets, maps, dates and primitives. A class instance cannot cross, because its prototype cannot: the browser would receive the fields and none of the behavior.
+
+The serializer refused: ${String(error)}`
+    );
+  }
+}
+function adoptSerializedState() {
+  const state = transferredState();
+  if (state === void 0) {
+    return false;
+  }
+  const scope = createScope(state);
+  setScopeResolver(() => scope);
+  return true;
+}
+function createReconciledStore(initialData) {
+  const [store, setStore] = createStore(initialData);
+  const updateStore = (data) => {
+    if (typeof data === "function") {
+      const newData = data(store);
+      setStore(reconcile(newData));
+    } else {
+      setStore(reconcile(data));
+    }
+  };
+  return [store, updateStore];
+}
+
+// src/hooks/usePresenter.ts
+function usePresenter(presentation) {
+  const [model, setModel] = createReconciledStore({ value: void 0 });
+  const presenter = new Presenter(presentation);
+  const updateModel = (newModel) => {
+    setModel({ value: newModel });
+  };
+  presenter.subscribe(updateModel);
+  onCleanup(() => {
+    presenter.unsubscribe(updateModel);
+    presenter.destroy();
+  });
+  return {
+    model: () => {
+      const current = model.value;
+      return current === void 0 ? void 0 : deepReadonly(current);
+    }
+  };
+}
+var scopes = /* @__PURE__ */ new WeakMap();
+function resolveServerScope() {
+  const event = getRequestEvent();
+  if (!event) {
+    throw new Error(
+      "[magic-use-case] No request scope is available.\n\nOn a server, application state belongs to the request being served, so that concurrent requests never share it. This ran on a server but outside a request, so there is no request to resolve a scope from \u2014 and falling back to a shared one would serve a user another user's data."
+    );
+  }
+  const existing = scopes.get(event);
+  if (existing) {
+    return existing;
+  }
+  const scope = createScope();
+  scopes.set(event, scope);
+  return scope;
+}
+function useUseCase(UseCaseClass) {
+  const [isLoading, setIsLoading] = createSignal(false);
+  const [progress, setProgress] = createSignal(0);
+  const [didSucceed, setDidSucceed] = createSignal(false);
+  const useCase = createUseCase(UseCaseClass, setProgress);
+  const execute = async (params) => {
+    setIsLoading(true);
+    setDidSucceed(false);
+    try {
+      await useCase.execute(params);
+      setDidSucceed(true);
+    } catch {
+      setDidSucceed(false);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  return { execute, isLoading, didSucceed, progress };
+}
+var ErrorHandler = (props) => {
+  const [error, setError] = createSignal(void 0);
+  const reportError = (error2) => {
+    const shouldReport = props.onWillReportError(error2);
+    if (shouldReport) {
+      setError(error2);
+      props.onDidReportError?.(error2);
+    }
+  };
+  const clearError = () => {
+    setError(void 0);
+  };
+  const unsubscribe = onError(reportError);
+  onCleanup(unsubscribe);
+  return createComponent(ErrorBoundary, {
+    fallback: (error2, reset) => props.renderErrorDialog({
+      error: error2,
+      onClose: reset
+    }),
+    get children() {
+      return [props.children, createComponent(Show, {
+        get when() {
+          return error();
+        },
+        get children() {
+          return props.renderErrorDialog({
+            error: error(),
+            onClose: clearError
+          });
+        }
+      })];
+    }
+  });
+};
+var Navigator = (props) => {
+  const unsubscribe = onNavigation((url) => {
+    if (url) {
+      props.onNavigate?.(url);
+    }
+  });
+  onCleanup(unsubscribe);
+  return null;
+};
+
+// src/index.ts
+if (isServer) {
+  setScopeResolver(resolveServerScope);
+} else {
+  adoptSerializedState();
+}
+function usePresenter2(presentation) {
+  return usePresenter(presentation);
+}
+var StateTransfer = () => {
+  if (isServer) {
+    useAssets(() => ssr(serializedStateScript()));
+  }
+  return null;
+};
+
+export { ErrorHandler, Navigator, Presenter, StateTransfer, UseCase, createScope, onError, onNavigation, setScopeResolver, usePresenter2 as usePresenter, useUseCase };