@manyducks.co/dolla 2.0.0-alpha.39 → 2.0.0-alpha.40

package/dist/index.js

@@ -1,336 +1,261 @@
-import { a as assertArrayOf, b as assertString, i as isFunction, I as IS_ROUTER, c as atom, d as compose, g as get, s as shallowEqual, e as assertObject, f as isString, h as isObject, P as Passthrough, j as deepEqual, t as typeOf, k as cond, l as html, m as createMatcher, S as Store, n as StoreError, o as assertInstanceOf, p as createMarkup, V as View, q as groupElements, r as constructMarkup, u as noOp, v as okhash } from './markup-PXJjYgl3.js';
-export { w as effect, B as list, y as peek, A as portal, x as set, z as strictEqual } from './markup-PXJjYgl3.js';
-
-function ref(value) {
+var zt = Object.defineProperty;
+var kt = (i) => {
+  throw TypeError(i);
+};
+var Bt = (i, t, e) => t in i ? zt(i, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : i[t] = e;
+var w = (i, t, e) => Bt(i, typeof t != "symbol" ? t + "" : t, e), mt = (i, t, e) => t.has(i) || kt("Cannot " + e);
+var a = (i, t, e) => (mt(i, t, "read from private field"), e ? e.call(i) : t.get(i)), u = (i, t, e) => t.has(i) ? kt("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(i) : t.set(i, e), d = (i, t, e, s) => (mt(i, t, "write to private field"), s ? s.call(i, e) : t.set(i, e), e), f = (i, t, e) => (mt(i, t, "access private method"), e);
+var Rt = (i, t, e, s) => ({
+  set _(n) {
+    d(i, t, n, e);
+  },
+  get _() {
+    return a(i, t, s);
+  }
+});
+import { a as Kt, b as Ft, i as z, I as Ot, c as Ut, d as U, g as E, s as _t, e as Qt, f as M, h as D, P as jt, j as Jt, t as St, k as Xt, l as Mt, m as xt, S as Yt, n as Tt, o as Nt, p as Zt, V as te, q as ee, r as se, u as re, v as ne } from "./markup-DIfh0nwz.js";
+import { w as Ue, B as je, y as Ce, A as Ie, x as Ve, z as De } from "./markup-DIfh0nwz.js";
+function Ne(i) {
   return function() {
-    if (arguments.length === 1) {
-      value = arguments[0];
-    } else if (arguments.length > 1) {
+    if (arguments.length === 1)
+      i = arguments[0];
+    else if (arguments.length > 1)
       throw new Error(`Too many arguments. Expected 0 or 1. Got: ${arguments.length}`);
-    }
-    return value;
+    return i;
   };
 }
-
-function splitPath(path) {
-  assertString(path, "Expected `path` to be a string. Got type: %t, value: %v");
-  return path.split("/").map((f) => f.trim()).filter((f) => f !== "");
+function K(i) {
+  return Ft(i, "Expected `path` to be a string. Got type: %t, value: %v"), i.split("/").map((t) => t.trim()).filter((t) => t !== "");
 }
-function joinPath(parts) {
-  assertArrayOf(
-    (part) => isFunction(part?.toString),
-    parts,
+function G(i) {
+  var e;
+  Kt(
+    (s) => z(s == null ? void 0 : s.toString),
+    i,
     "Expected `parts` to be an array of objects with a .toString() method. Got type: %t, value: %v"
-  );
-  parts = parts.filter((x) => x).flatMap(String);
-  let joined = parts.shift()?.toString();
-  if (joined) {
-    for (const part of parts.map((p) => p.toString())) {
-      if (part.startsWith(".")) {
-        joined = resolvePath(joined, part);
-      } else if (joined[joined.length - 1] !== "/") {
-        if (part[0] !== "/") {
-          joined += "/" + part;
-        } else {
-          joined += part;
-        }
-      } else {
-        if (part[0] === "/") {
-          joined += part.slice(1);
-        } else {
-          joined += part;
-        }
-      }
-    }
-    if (joined && joined !== "/" && joined.endsWith("/")) {
-      joined = joined.slice(0, joined.length - 1);
-    }
-  }
-  return joined ?? "";
+  ), i = i.filter((s) => s).flatMap(String);
+  let t = (e = i.shift()) == null ? void 0 : e.toString();
+  if (t) {
+    for (const s of i.map((n) => n.toString()))
+      s.startsWith(".") ? t = ct(t, s) : t[t.length - 1] !== "/" ? s[0] !== "/" ? t += "/" + s : t += s : s[0] === "/" ? t += s.slice(1) : t += s;
+    t && t !== "/" && t.endsWith("/") && (t = t.slice(0, t.length - 1));
+  }
+  return t ?? "";
 }
-function resolvePath(base, part) {
-  assertString(base, "Expected `base` to be a string. Got type: %t, value: %v");
-  if (part == null) {
-    part = base;
-    base = "";
-  }
-  if (part.startsWith("/")) {
-    return part;
-  }
-  let resolved = base;
-  while (true) {
-    if (part.startsWith("..")) {
-      for (let i = resolved.length; i > 0; --i) {
-        if (resolved[i] === "/" || i === 0) {
-          resolved = resolved.slice(0, i);
-          part = part.replace(/^\.\.\/?/, "");
+function ct(i, t) {
+  if (Ft(i, "Expected `base` to be a string. Got type: %t, value: %v"), t == null && (t = i, i = ""), t.startsWith("/"))
+    return t;
+  let e = i;
+  for (; ; )
+    if (t.startsWith("..")) {
+      for (let s = e.length; s > 0; --s)
+        if (e[s] === "/" || s === 0) {
+          e = e.slice(0, s), t = t.replace(/^\.\.\/?/, "");
           break;
         }
-      }
-    } else if (part.startsWith(".")) {
-      part = part.replace(/^\.\/?/, "");
-    } else {
+    } else if (t.startsWith("."))
+      t = t.replace(/^\.\/?/, "");
+    else
       break;
-    }
-  }
-  return joinPath([resolved, part]);
+  return G([e, t]);
 }
-function parseQueryParams(query) {
-  if (!query) return {};
-  if (query.startsWith("?")) {
-    query = query.slice(1);
-  }
-  const entries = query.split("&").filter((x) => x.trim() !== "").map((entry) => {
-    const [key, value] = entry.split("=").map((x) => x.trim());
-    if (value.toLowerCase() === "true") {
-      return [key, true];
-    }
-    if (value.toLowerCase() === "false") {
-      return [key, false];
-    }
-    if (!isNaN(Number(value))) {
-      return [key, Number(value)];
-    }
-    return [key, value];
+function ae(i) {
+  if (!i) return {};
+  i.startsWith("?") && (i = i.slice(1));
+  const t = i.split("&").filter((e) => e.trim() !== "").map((e) => {
+    const [s, n] = e.split("=").map((r) => r.trim());
+    return n.toLowerCase() === "true" ? [s, !0] : n.toLowerCase() === "false" ? [s, !1] : isNaN(Number(n)) ? [s, n] : [s, Number(n)];
   });
-  return Object.fromEntries(entries);
+  return Object.fromEntries(t);
 }
-function matchRoutes(routes, url, options = {}) {
-  const [path, query] = url.split("?");
-  const parts = splitPath(path);
-  routes: for (const route of routes) {
-    const { fragments } = route;
-    const hasWildcard = fragments[fragments.length - 1]?.type === 3 /* Wildcard */;
-    if (!hasWildcard && fragments.length !== parts.length) {
-      continue routes;
-    }
-    if (options.willMatch && !options.willMatch(route)) {
-      continue routes;
-    }
-    const matched = [];
-    fragments: for (let i = 0; i < fragments.length; i++) {
-      const part = parts[i];
-      const frag = fragments[i];
-      if (part == null && frag.type !== 3 /* Wildcard */) {
-        continue routes;
-      }
-      switch (frag.type) {
-        case 1 /* Literal */:
-          if (frag.name.toLowerCase() === part.toLowerCase()) {
-            matched.push(frag);
+function Ct(i, t, e = {}) {
+  var o;
+  const [s, n] = t.split("?"), r = K(s);
+  t: for (const c of i) {
+    const { fragments: l } = c;
+    if (!(((o = l[l.length - 1]) == null ? void 0 : o.type) === 3) && l.length !== r.length || e.willMatch && !e.willMatch(c))
+      continue t;
+    const v = [];
+    e: for (let h = 0; h < l.length; h++) {
+      const x = r[h], k = l[h];
+      if (x == null && k.type !== 3)
+        continue t;
+      switch (k.type) {
+        case 1:
+          if (k.name.toLowerCase() === x.toLowerCase()) {
+            v.push(k);
             break;
-          } else {
-            continue routes;
-          }
-        case 2 /* Param */:
-          matched.push({ ...frag, value: part });
+          } else
+            continue t;
+        case 2:
+          v.push({ ...k, value: x });
+          break;
+        case 3:
+          v.push({ ...k, value: r.slice(h).join("/") });
+          break e;
+        case 4:
+          if (isNaN(Number(x)))
+            continue t;
+          v.push({ ...k, value: Number(x) });
           break;
-        case 3 /* Wildcard */:
-          matched.push({ ...frag, value: parts.slice(i).join("/") });
-          break fragments;
-        case 4 /* NumericParam */:
-          if (!isNaN(Number(part))) {
-            matched.push({ ...frag, value: Number(part) });
-            break;
-          } else {
-            continue routes;
-          }
         default:
-          throw new Error(`Unknown fragment type: ${frag.type}`);
-      }
-    }
-    const params = {};
-    for (const frag of matched) {
-      if (frag.type === 2 /* Param */) {
-        params[frag.name] = decodeURIComponent(frag.value);
-      }
-      if (frag.type === 4 /* NumericParam */) {
-        params[frag.name] = frag.value;
-      }
-      if (frag.type === 3 /* Wildcard */) {
-        params.wildcard = "/" + decodeURIComponent(frag.value);
+          throw new Error(`Unknown fragment type: ${k.type}`);
       }
     }
+    const $ = {};
+    for (const h of v)
+      h.type === 2 && ($[h.name] = decodeURIComponent(h.value)), h.type === 4 && ($[h.name] = h.value), h.type === 3 && ($.wildcard = "/" + decodeURIComponent(h.value));
     return {
-      path: "/" + matched.map((f) => f.value).join("/"),
-      pattern: "/" + fragments.map((f) => {
-        if (f.type === 2 /* Param */) {
-          return `{${f.name}}`;
-        }
-        if (f.type === 4 /* NumericParam */) {
-          return `{#${f.name}}`;
-        }
-        return f.name;
-      }).join("/"),
-      params,
-      query: parseQueryParams(query),
-      meta: route.meta
+      path: "/" + v.map((h) => h.value).join("/"),
+      pattern: "/" + l.map((h) => h.type === 2 ? `{${h.name}}` : h.type === 4 ? `{#${h.name}}` : h.name).join("/"),
+      params: $,
+      query: ae(n),
+      meta: c.meta
     };
   }
 }
-function sortRoutes(routes) {
-  const withoutParams = [];
-  const withNumericParams = [];
-  const withParams = [];
-  const wildcard = [];
-  for (const route of routes) {
-    const { fragments } = route;
-    if (fragments.some((f) => f.type === 3 /* Wildcard */)) {
-      wildcard.push(route);
-    } else if (fragments.some((f) => f.type === 4 /* NumericParam */)) {
-      withNumericParams.push(route);
-    } else if (fragments.some((f) => f.type === 2 /* Param */)) {
-      withParams.push(route);
-    } else {
-      withoutParams.push(route);
-    }
-  }
-  const bySizeDesc = (a, b) => {
-    if (a.fragments.length > b.fragments.length) {
-      return -1;
-    } else {
-      return 1;
-    }
-  };
-  withoutParams.sort(bySizeDesc);
-  withNumericParams.sort(bySizeDesc);
-  withParams.sort(bySizeDesc);
-  wildcard.sort(bySizeDesc);
-  return [...withoutParams, ...withNumericParams, ...withParams, ...wildcard];
+function ie(i) {
+  const t = [], e = [], s = [], n = [];
+  for (const o of i) {
+    const { fragments: c } = o;
+    c.some(
+      (l) => l.type === 3
+      /* Wildcard */
+    ) ? n.push(o) : c.some(
+      (l) => l.type === 4
+      /* NumericParam */
+    ) ? e.push(o) : c.some(
+      (l) => l.type === 2
+      /* Param */
+    ) ? s.push(o) : t.push(o);
+  }
+  const r = (o, c) => o.fragments.length > c.fragments.length ? -1 : 1;
+  return t.sort(r), e.sort(r), s.sort(r), n.sort(r), [...t, ...e, ...s, ...n];
 }
-function patternToFragments(pattern) {
-  const parts = splitPath(pattern);
-  const fragments = [];
-  for (let i = 0; i < parts.length; i++) {
-    const part = parts[i];
-    if (part === "*") {
-      if (i !== parts.length - 1) {
-        throw new Error(`Wildcard must be at the end of a pattern. Received: ${pattern}`);
-      }
-      fragments.push({
-        type: 3 /* Wildcard */,
+function oe(i) {
+  const t = K(i), e = [];
+  for (let s = 0; s < t.length; s++) {
+    const n = t[s];
+    if (n === "*") {
+      if (s !== t.length - 1)
+        throw new Error(`Wildcard must be at the end of a pattern. Received: ${i}`);
+      e.push({
+        type: 3,
         name: "*",
         value: null
       });
-    } else if (part.at(0) === "{" && part.at(-1) === "}") {
-      fragments.push({
-        type: part[1] === "#" ? 4 /* NumericParam */ : 2 /* Param */,
-        name: part[1] === "#" ? part.slice(2, -1) : part.slice(1, -1),
-        value: null
-      });
-    } else {
-      fragments.push({
-        type: 1 /* Literal */,
-        name: part,
-        value: part
-      });
-    }
+    } else n.at(0) === "{" && n.at(-1) === "}" ? e.push({
+      type: n[1] === "#" ? 4 : 2,
+      name: n[1] === "#" ? n.slice(2, -1) : n.slice(1, -1),
+      value: null
+    }) : e.push({
+      type: 1,
+      name: n,
+      value: n
+    });
   }
-  return fragments;
+  return e;
 }
-
-function createRouter(options) {
-  return new Router(options);
+function Pe(i) {
+  return new he(i);
 }
-const ROUTER_MOUNT = Symbol.for("DollaRouterMountMethod");
-const ROUTER_UNMOUNT = Symbol.for("DollaRouterUnmountMethod");
-function _isRouter(value) {
-  return value?.[IS_ROUTER] === true;
+const It = Symbol.for("DollaRouterMountMethod"), Vt = Symbol.for("DollaRouterUnmountMethod");
+function pt(i) {
+  return (i == null ? void 0 : i[Ot]) === !0;
 }
-async function _mountRouter(router, dolla) {
-  return router[ROUTER_MOUNT](dolla);
+async function le(i, t) {
+  return i[It](t);
 }
-async function _unmountRouter(router) {
-  return router[ROUTER_UNMOUNT]();
+async function ce(i) {
+  return i[Vt]();
 }
-class Router {
-  [IS_ROUTER] = true;
-  #dolla;
-  #logger;
-  #layerId = 0;
-  #activeLayers = [];
-  #routes = [];
-  #isMounted = false;
-  /**
-   * Use hash routing when true. Configured in router options.
-   */
-  #hash = false;
-  // Callbacks that need to be called on unmount.
-  #unsubscribers = [];
-  /**
-   * The current match object.
-   */
-  #match = atom();
-  /**
-   * The currently matched route pattern, if any.
-   */
-  pattern = compose(() => get(this.#match)?.pattern);
-  /**
-   * The current URL path.
-   */
-  path = compose(() => get(this.#match)?.path ?? window.location.pathname);
-  /**
-   * The current named path params.
-   */
-  params = compose(() => get(this.#match)?.params ?? {}, { equals: shallowEqual });
-  /**
-   * The current query params. Changes to this object will be reflected in the URL.
-   */
-  query = compose(() => get(this.#match)?.query ?? {}, { equals: shallowEqual });
-  constructor(options) {
-    assertObject(options, "Options must be an object. Got: %t");
-    if (options.hash) {
-      this.#hash = true;
-    }
-    this.#routes = sortRoutes(
-      options.routes.flatMap((route) => this.#prepareRoute(route)).map((route) => ({
-        pattern: route.pattern,
-        meta: route.meta,
-        fragments: patternToFragments(route.pattern)
+var Lt, Q, S, ht, T, W, J, j, C, N, m, wt, Dt, qt, B, Gt, gt, yt;
+class he {
+  constructor(t) {
+    u(this, m);
+    w(this, Lt, !0);
+    u(this, Q);
+    u(this, S);
+    u(this, ht, 0);
+    u(this, T, []);
+    u(this, W, []);
+    u(this, J, !1);
+    /**
+     * Use hash routing when true. Configured in router options.
+     */
+    u(this, j, !1);
+    // Callbacks that need to be called on unmount.
+    u(this, C, []);
+    /**
+     * The current match object.
+     */
+    u(this, N, Ut());
+    /**
+     * The currently matched route pattern, if any.
+     */
+    w(this, "pattern", U(() => {
+      var t;
+      return (t = E(a(this, N))) == null ? void 0 : t.pattern;
+    }));
+    /**
+     * The current URL path.
+     */
+    w(this, "path", U(() => {
+      var t;
+      return ((t = E(a(this, N))) == null ? void 0 : t.path) ?? window.location.pathname;
+    }));
+    /**
+     * The current named path params.
+     */
+    w(this, "params", U(() => {
+      var t;
+      return ((t = E(a(this, N))) == null ? void 0 : t.params) ?? {};
+    }, { equals: _t }));
+    /**
+     * The current query params. Changes to this object will be reflected in the URL.
+     */
+    w(this, "query", U(() => {
+      var t;
+      return ((t = E(a(this, N))) == null ? void 0 : t.query) ?? {};
+    }, { equals: _t }));
+    Qt(t, "Options must be an object. Got: %t"), t.hash && d(this, j, !0), d(this, W, ie(
+      t.routes.flatMap((e) => f(this, m, yt).call(this, e)).map((e) => ({
+        pattern: e.pattern,
+        meta: e.meta,
+        fragments: oe(e.pattern)
       }))
-    );
-    assertValidRedirects(this.#routes);
+    )), pe(a(this, W));
   }
-  async [ROUTER_MOUNT](dolla) {
-    this.#dolla = dolla;
-    this.#logger = dolla.createLogger("Dolla.router");
-    const onPopState = () => {
-      this.#updateRoute();
+  async [(Lt = Ot, It)](t) {
+    d(this, Q, t), d(this, S, t.createLogger("Dolla.router"));
+    const e = () => {
+      f(this, m, B).call(this);
     };
-    window.addEventListener("popstate", onPopState);
-    this.#unsubscribers.push(() => window.removeEventListener("popstate", onPopState));
-    const rootElement = dolla.getRootElement();
-    this.#unsubscribers.push(
-      catchLinks(rootElement, (anchor) => {
-        let href = anchor.getAttribute("href");
-        this.#logger.info("intercepted click on <a> tag", anchor);
-        if (!/^https?:\/\/|^\//.test(href)) {
-          href = joinPath([window.location.pathname, href]);
-        }
-        this.#push(href);
+    window.addEventListener("popstate", e), a(this, C).push(() => window.removeEventListener("popstate", e));
+    const s = t.getRootElement();
+    a(this, C).push(
+      de(s, (n) => {
+        let r = n.getAttribute("href");
+        a(this, S).info("intercepted click on <a> tag", n), /^https?:\/\/|^\//.test(r) || (r = G([window.location.pathname, r])), f(this, m, wt).call(this, r);
       })
-    );
-    this.#logger.info("will intercept clicks on <a> tags within root element", rootElement);
-    this.#isMounted = true;
-    await this.#updateRoute();
+    ), a(this, S).info("will intercept clicks on <a> tags within root element", s), d(this, J, !0), await f(this, m, B).call(this);
   }
-  async [ROUTER_UNMOUNT]() {
-    for (const callback of this.#unsubscribers) {
-      callback();
-    }
-    this.#unsubscribers = [];
+  async [Vt]() {
+    for (const t of a(this, C))
+      t();
+    d(this, C, []);
   }
   /**
    * Navigate backward. Pass a number of steps to hit the back button that many times.
    */
-  back(steps = 1) {
-    window.history.go(-steps);
+  back(t = 1) {
+    window.history.go(-t);
   }
   /**
    * Navigate forward. Pass a number of steps to hit the forward button that many times.
    */
-  forward(steps = 1) {
-    window.history.go(steps);
+  forward(t = 1) {
+    window.history.go(t);
   }
   /**
    * Navigates to another route.
@@ -339,741 +264,483 @@ class Router {
    * router.go("/login"); // navigate to `/login`
    * router.go["/users", 215], { replace: true }); // replace current history entry with `/users/215`
    */
-  go(path, options = {}) {
-    let joined;
-    if (Array.isArray(path)) {
-      joined = joinPath(path);
-    } else {
-      joined = path.toString();
-    }
-    joined = resolvePath(window.location.pathname, joined);
-    if (options.preserveQuery) {
-      joined += window.location.search;
-    }
-    if (options.replace) {
-      this.#replace(joined);
-    } else {
-      this.#push(joined);
-    }
-  }
-  #push(href, state) {
-    this.#logger?.info("(push)", href);
-    window.history.pushState(state, "", this.#hash ? "/#" + href : href);
-    this.#updateRoute(href);
-  }
-  #replace(href, state) {
-    this.#logger?.info("(replace)", href);
-    window.history.replaceState(state, "", this.#hash ? "/#" + href : href);
-    this.#updateRoute(href);
-  }
-  #getCurrentURL() {
-    if (this.#hash) {
-      return new URL(window.location.hash.slice(1), window.location.origin);
-    } else {
-      return new URL(window.location.pathname, window.location.origin);
-    }
-  }
-  /**
-   * Run when the location changes. Diffs and mounts new routes and updates
-   * the $path, $route, $params and $query states accordingly.
-   */
-  async #updateRoute(href) {
-    const logger = this.#logger;
-    const rootView = this.#dolla?.getRootView();
-    const url = href ? new URL(href, window.location.origin) : this.#getCurrentURL();
-    const { match, journey } = await this.#resolveRoute(url);
-    if (match) {
-      const oldPattern = this.pattern.value;
-      this.#match.value = match;
-      if (rootView && match.pattern !== oldPattern) {
-        this.#mountRoute(rootView, match);
-      }
-    } else {
-      if (this.#isMounted) {
-        logger.crash(new NoRouteError(`Failed to match route '${url.pathname}'`));
-      }
-    }
-    return { match, journey };
-  }
-  /**
-   * Takes a matched route and mounts it.
-   */
-  #mountRoute(rootView, match) {
-    const layers = match.meta.layers;
-    for (let i = 0; i < layers.length; i++) {
-      const matchedLayer = layers[i];
-      const activeLayer = this.#activeLayers[i];
-      if (activeLayer?.id !== matchedLayer.id) {
-        this.#activeLayers = this.#activeLayers.slice(0, i);
-        activeLayer?.view.unmount();
-        const parentLayer = this.#activeLayers.at(-1);
-        const parent2 = parentLayer?.view ?? rootView;
-        const view = parent2.setChildView(matchedLayer.view);
-        this.#activeLayers.push({ id: matchedLayer.id, view });
-      }
-    }
+  go(t, e = {}) {
+    let s;
+    Array.isArray(t) ? s = G(t) : s = t.toString(), s = ct(window.location.pathname, s), e.preserveQuery && (s += window.location.search), e.replace ? f(this, m, Dt).call(this, s) : f(this, m, wt).call(this, s);
   }
-  /**
-   * Takes a URL and finds a match, following redirects.
-   */
-  async #resolveRoute(url, journey = []) {
-    const match = matchRoutes(this.#routes, url.pathname);
-    if (!match) {
-      return {
-        match: null,
-        journey: [...journey, { kind: "miss", message: `no match for '${url.pathname}'` }]
+}
+Q = new WeakMap(), S = new WeakMap(), ht = new WeakMap(), T = new WeakMap(), W = new WeakMap(), J = new WeakMap(), j = new WeakMap(), C = new WeakMap(), N = new WeakMap(), m = new WeakSet(), wt = function(t, e) {
+  var s;
+  (s = a(this, S)) == null || s.info("(push)", t), window.history.pushState(e, "", a(this, j) ? "/#" + t : t), f(this, m, B).call(this, t);
+}, Dt = function(t, e) {
+  var s;
+  (s = a(this, S)) == null || s.info("(replace)", t), window.history.replaceState(e, "", a(this, j) ? "/#" + t : t), f(this, m, B).call(this, t);
+}, qt = function() {
+  return a(this, j) ? new URL(window.location.hash.slice(1), window.location.origin) : new URL(window.location.pathname, window.location.origin);
+}, B = async function(t) {
+  var c;
+  const e = a(this, S), s = (c = a(this, Q)) == null ? void 0 : c.getRootView(), n = t ? new URL(t, window.location.origin) : f(this, m, qt).call(this), { match: r, journey: o } = await f(this, m, gt).call(this, n);
+  if (r) {
+    const l = this.pattern.value;
+    a(this, N).value = r, s && r.pattern !== l && f(this, m, Gt).call(this, s, r);
+  } else
+    a(this, J) && e.crash(new we(`Failed to match route '${n.pathname}'`));
+  return { match: r, journey: o };
+}, /**
+ * Takes a matched route and mounts it.
+ */
+Gt = function(t, e) {
+  const s = e.meta.layers;
+  for (let n = 0; n < s.length; n++) {
+    const r = s[n], o = a(this, T)[n];
+    if ((o == null ? void 0 : o.id) !== r.id) {
+      d(this, T, a(this, T).slice(0, n)), o == null || o.view.unmount();
+      const c = a(this, T).at(-1), p = ((c == null ? void 0 : c.view) ?? t).setChildView(r.view);
+      a(this, T).push({ id: r.id, view: p });
+    }
+  }
+}, gt = async function(t, e = []) {
+  const s = Ct(a(this, W), t.pathname);
+  if (!s)
+    return {
+      match: null,
+      journey: [...e, { kind: "miss", message: `no match for '${t.pathname}'` }]
+    };
+  let n = s.meta.redirect;
+  if (s.meta.beforeMatch && await s.meta.beforeMatch({
+    // TODO: Allow setting context variables from here? Would apply to the context of the matched view.
+    redirect: (r) => {
+      n = r;
+    }
+  }), n != null) {
+    let r;
+    if (M(n))
+      r = me(n, s.params);
+    else if (z(n)) {
+      const o = {
+        path: s.path,
+        pattern: s.pattern,
+        params: s.params,
+        query: s.query
       };
-    }
-    let redirect = match.meta.redirect;
-    if (match.meta.beforeMatch) {
-      await match.meta.beforeMatch({
-        // TODO: Allow setting context variables from here? Would apply to the context of the matched view.
-        redirect: (path) => {
-          redirect = path;
-        }
-      });
-    }
-    if (redirect != null) {
-      let path;
-      if (isString(redirect)) {
-        path = replaceParams(redirect, match.params);
-      } else if (isFunction(redirect)) {
-        const redirectContext = {
-          path: match.path,
-          pattern: match.pattern,
-          params: match.params,
-          query: match.query
-        };
-        path = await redirect(redirectContext);
-        if (!isString(path)) {
-          throw new Error(`Redirect function must return a path to redirect to.`);
-        }
-        if (!path.startsWith("/")) {
-          path = resolvePath(match.path, path);
-        }
-      } else {
-        throw new TypeError(`Redirect must either be a path string or a function.`);
+      if (r = await n(o), !M(r))
+        throw new Error("Redirect function must return a path to redirect to.");
+      r.startsWith("/") || (r = ct(s.path, r));
+    } else
+      throw new TypeError("Redirect must either be a path string or a function.");
+    return f(this, m, gt).call(this, new URL(r, window.location.origin), [
+      ...e,
+      { kind: "redirect", message: `redirecting '${s.path}' -> '${r}'` }
+    ]);
+  } else
+    return { match: s, journey: [...e, { kind: "match", message: `matched route '${s.path}'` }] };
+}, /**
+ * Parses a route definition object into a set of matchable routes.
+ *
+ * @param route - Route config object.
+ * @param layers - Array of parent layers. Passed when this function calls itself on nested routes.
+ */
+yt = function(t, e = [], s = []) {
+  if (!D(t) || !M(t.path))
+    throw new TypeError(`Route configs must be objects with a 'path' string property. Got: ${t}`);
+  if (t.redirect && t.routes)
+    throw new Error("Route cannot have both a 'redirect' and nested 'routes'.");
+  if (t.redirect && t.view)
+    throw new Error("Route cannot have both a 'redirect' and a 'view'.");
+  if (!t.view && !t.routes && !t.redirect)
+    throw new Error("Route must have a 'view', a 'redirect', or a set of nested 'routes'.");
+  let n = [];
+  for (const l of e)
+    n.push(...K(l.path));
+  n.push(...K(t.path)), n[n.length - 1] === "*" && n.pop();
+  const r = [];
+  if (t.redirect) {
+    let l = t.redirect;
+    return M(l) && (l = ct(G(n), l), l.startsWith("/") || (l = "/" + l)), r.push({
+      pattern: "/" + G([...n, ...K(t.path)]),
+      meta: {
+        redirect: l
       }
-      return this.#resolveRoute(new URL(path, window.location.origin), [
-        ...journey,
-        { kind: "redirect", message: `redirecting '${match.path}' -> '${path}'` }
-      ]);
-    } else {
-      return { match, journey: [...journey, { kind: "match", message: `matched route '${match.path}'` }] };
-    }
-  }
-  /**
-   * Parses a route definition object into a set of matchable routes.
-   *
-   * @param route - Route config object.
-   * @param layers - Array of parent layers. Passed when this function calls itself on nested routes.
-   */
-  #prepareRoute(route, parents = [], layers = []) {
-    if (!isObject(route) || !isString(route.path)) {
-      throw new TypeError(`Route configs must be objects with a 'path' string property. Got: ${route}`);
-    }
-    if (route.redirect && route.routes) {
-      throw new Error(`Route cannot have both a 'redirect' and nested 'routes'.`);
-    } else if (route.redirect && route.view) {
-      throw new Error(`Route cannot have both a 'redirect' and a 'view'.`);
-    } else if (!route.view && !route.routes && !route.redirect) {
-      throw new Error(`Route must have a 'view', a 'redirect', or a set of nested 'routes'.`);
-    }
-    let parts = [];
-    for (const parent2 of parents) {
-      parts.push(...splitPath(parent2.path));
-    }
-    parts.push(...splitPath(route.path));
-    if (parts[parts.length - 1] === "*") {
-      parts.pop();
-    }
-    const routes = [];
-    if (route.redirect) {
-      let redirect = route.redirect;
-      if (isString(redirect)) {
-        redirect = resolvePath(joinPath(parts), redirect);
-        if (!redirect.startsWith("/")) {
-          redirect = "/" + redirect;
-        }
+    }), r;
+  }
+  let o = jt;
+  if (z(t.view))
+    o = t.view;
+  else if (t.view)
+    throw new TypeError(`Route '${t.path}' expected a view function or undefined. Got: ${t.view}`);
+  const c = { id: Rt(this, ht)._++, view: o };
+  if (t.routes)
+    for (const l of t.routes)
+      r.push(...f(this, m, yt).call(this, l, [...e, t], [...s, c]));
+  else
+    r.push({
+      pattern: parent ? G([...e.map((l) => l.path), t.path]) : t.path,
+      meta: {
+        pattern: t.path,
+        layers: [...s, c],
+        beforeMatch: t.beforeMatch
       }
-      routes.push({
-        pattern: "/" + joinPath([...parts, ...splitPath(route.path)]),
-        meta: {
-          redirect
-        }
-      });
-      return routes;
-    }
-    let view = Passthrough;
-    if (isFunction(route.view)) {
-      view = route.view;
-    } else if (route.view) {
-      throw new TypeError(`Route '${route.path}' expected a view function or undefined. Got: ${route.view}`);
-    }
-    const layer = { id: this.#layerId++, view };
-    if (route.routes) {
-      for (const subroute of route.routes) {
-        routes.push(...this.#prepareRoute(subroute, [...parents, route], [...layers, layer]));
-      }
-    } else {
-      routes.push({
-        pattern: parent ? joinPath([...parents.map((p) => p.path), route.path]) : route.path,
-        meta: {
-          pattern: route.path,
-          layers: [...layers, layer],
-          beforeMatch: route.beforeMatch
-        }
-      });
-    }
-    return routes;
-  }
-}
-const safeExternalLink = /(noopener|noreferrer) (noopener|noreferrer)/;
-const protocolLink = /^[\w-_]+:/;
-function catchLinks(root, callback, _window = window) {
-  function traverse(node) {
-    if (!node || node === root) {
-      return null;
-    }
-    if (node.localName !== "a" || node.href === void 0) {
-      return traverse(node.parentNode);
-    }
-    return node;
-  }
-  function handler(e) {
-    if (e.button && e.button !== 0 || e.ctrlKey || e.metaKey || e.altKey || e.shiftKey || e.defaultPrevented) {
-      return;
-    }
-    const anchor = traverse(e.target);
-    if (!anchor) {
-      return;
-    }
-    if (_window.location.protocol !== anchor.protocol || _window.location.hostname !== anchor.hostname || _window.location.port !== anchor.port || anchor.hasAttribute("data-router-ignore") || anchor.hasAttribute("download") || anchor.getAttribute("target") === "_blank" && safeExternalLink.test(anchor.getAttribute("rel")) || protocolLink.test(anchor.getAttribute("href"))) {
+    });
+  return r;
+};
+const ue = /(noopener|noreferrer) (noopener|noreferrer)/, fe = /^[\w-_]+:/;
+function de(i, t, e = window) {
+  function s(r) {
+    return !r || r === i ? null : r.localName !== "a" || r.href === void 0 ? s(r.parentNode) : r;
+  }
+  function n(r) {
+    if (r.button && r.button !== 0 || r.ctrlKey || r.metaKey || r.altKey || r.shiftKey || r.defaultPrevented)
       return;
-    }
-    e.preventDefault();
-    callback(anchor);
+    const o = s(r.target);
+    o && (e.location.protocol !== o.protocol || e.location.hostname !== o.hostname || e.location.port !== o.port || o.hasAttribute("data-router-ignore") || o.hasAttribute("download") || o.getAttribute("target") === "_blank" && ue.test(o.getAttribute("rel")) || fe.test(o.getAttribute("href")) || (r.preventDefault(), t(o)));
   }
-  root.addEventListener("click", handler);
-  return function cancel() {
-    root.removeEventListener("click", handler);
+  return i.addEventListener("click", n), function() {
+    i.removeEventListener("click", n);
   };
 }
-function replaceParams(path, params) {
-  for (const key in params) {
-    const value = params[key].toString();
-    path = path.replace(`{${key}}`, value).replace(`{#${key}}`, value);
+function me(i, t) {
+  for (const e in t) {
+    const s = t[e].toString();
+    i = i.replace(`{${e}}`, s).replace(`{#${e}}`, s);
   }
-  return path;
+  return i;
 }
-function assertValidRedirects(routes) {
-  for (const route of routes) {
-    if (route.meta.redirect) {
-      let redirectPath;
-      if (isFunction(route.meta.redirect)) ; else if (isString(route.meta.redirect)) {
-        redirectPath = route.meta.redirect;
-        const match = matchRoutes(routes, redirectPath, {
-          willMatch(r) {
-            return r !== route;
+function pe(i) {
+  for (const t of i)
+    if (t.meta.redirect) {
+      let e;
+      if (!z(t.meta.redirect)) if (M(t.meta.redirect)) {
+        if (e = t.meta.redirect, !Ct(i, e, {
+          willMatch(n) {
+            return n !== t;
           }
-        });
-        if (!match) {
-          throw new Error(`Found a redirect to an undefined URL. From '${route.pattern}' to '${route.meta.redirect}'`);
-        }
-      } else {
-        throw new TypeError(`Expected a string or redirect function. Got: ${route.meta.redirect}`);
-      }
+        }))
+          throw new Error(`Found a redirect to an undefined URL. From '${t.pattern}' to '${t.meta.redirect}'`);
+      } else
+        throw new TypeError(`Expected a string or redirect function. Got: ${t.meta.redirect}`);
     }
-  }
 }
-class NoRouteError extends Error {
+class we extends Error {
 }
-
-class HTTP {
-  #middleware = [];
-  #fetch = getDefaultFetch();
+var I, ut, R, _;
+class ge {
+  constructor() {
+    u(this, R);
+    u(this, I, []);
+    u(this, ut, ye());
+  }
   /**
    * Adds a new middleware that will apply to subsequent requests.
    * Returns a function to remove this middleware.
    *
    * @param middleware - A middleware function that will intercept requests.
    */
-  use(fn) {
-    this.#middleware.push(fn);
-    return () => {
-      this.#middleware.splice(this.#middleware.indexOf(fn), 1);
+  use(t) {
+    return a(this, I).push(t), () => {
+      a(this, I).splice(a(this, I).indexOf(t), 1);
     };
   }
-  async get(uri, options) {
-    return this.#request("get", uri, options);
+  async get(t, e) {
+    return f(this, R, _).call(this, "get", t, e);
   }
-  async put(uri, options) {
-    return this.#request("put", uri, options);
+  async put(t, e) {
+    return f(this, R, _).call(this, "put", t, e);
   }
-  async patch(uri, options) {
-    return this.#request("patch", uri, options);
+  async patch(t, e) {
+    return f(this, R, _).call(this, "patch", t, e);
   }
-  async post(uri, options) {
-    return this.#request("post", uri, options);
+  async post(t, e) {
+    return f(this, R, _).call(this, "post", t, e);
   }
-  async delete(uri, options) {
-    return this.#request("delete", uri, options);
+  async delete(t, e) {
+    return f(this, R, _).call(this, "delete", t, e);
   }
-  async head(uri, options) {
-    return this.#request("head", uri, options);
+  async head(t, e) {
+    return f(this, R, _).call(this, "head", t, e);
   }
-  async options(uri, options) {
-    return this.#request("options", uri, options);
+  async options(t, e) {
+    return f(this, R, _).call(this, "options", t, e);
   }
-  async trace(uri, options) {
-    return this.#request("trace", uri, options);
-  }
-  async #request(method, uri, options) {
-    const runner = new Runner({
-      ...options,
-      method,
-      uri,
-      middleware: this.#middleware,
-      fetch: this.#fetch
-    });
-    return runner.fetch();
+  async trace(t, e) {
+    return f(this, R, _).call(this, "trace", t, e);
   }
 }
-function getDefaultFetch() {
-  if (typeof window !== "undefined" && window.fetch) {
+I = new WeakMap(), ut = new WeakMap(), R = new WeakSet(), _ = async function(t, e, s) {
+  return new Ee({
+    ...s,
+    method: t,
+    uri: e,
+    middleware: a(this, I),
+    fetch: a(this, ut)
+  }).fetch();
+};
+function ye() {
+  if (typeof window < "u" && window.fetch)
     return window.fetch.bind(window);
-  }
-  if (typeof global !== "undefined" && global.fetch) {
+  if (typeof global < "u" && global.fetch)
     return global.fetch.bind(global);
-  }
   throw new Error("Running in neither browser nor node. Please run this app in one of the supported environments.");
 }
-class HTTPResponseError extends Error {
-  response;
-  constructor(response) {
-    const { status, statusText, method, url } = response;
-    const message = `${status} ${statusText}: Request failed (${method.toUpperCase()} ${url.toString()})`;
-    super(message);
-    this.response = response;
+class be extends Error {
+  constructor(e) {
+    const { status: s, statusText: n, method: r, url: o } = e, c = `${s} ${n}: Request failed (${r.toUpperCase()} ${o.toString()})`;
+    super(c);
+    w(this, "response");
+    this.response = e;
   }
 }
-class Request {
-  method;
-  url;
-  headers = new Headers();
-  body;
+class ve {
+  constructor(t) {
+    w(this, "method");
+    w(this, "url");
+    w(this, "headers", new Headers());
+    w(this, "body");
+    this.method = t.method, this.body = t.body, t.uri.startsWith("http") ? this.url = new URL(t.uri) : this.url = new URL(t.uri, window.location.origin), this._applyHeaders(t.headers), this._applyQueryParams(t.query);
+  }
   get isSameOrigin() {
     return this.url.origin === window.location.origin;
   }
-  constructor(config) {
-    this.method = config.method;
-    this.body = config.body;
-    if (config.uri.startsWith("http")) {
-      this.url = new URL(config.uri);
-    } else {
-      this.url = new URL(config.uri, window.location.origin);
-    }
-    this._applyHeaders(config.headers);
-    this._applyQueryParams(config.query);
-  }
-  _applyHeaders(headers) {
-    if (headers == null) return;
-    if (headers instanceof Map || headers instanceof Headers) {
-      headers.forEach((value, key) => {
-        this.headers.set(key, value);
-      });
-    } else if (isObject(headers)) {
-      for (const name in headers) {
-        const value = headers[name];
-        if (value instanceof Date) {
-          this.headers.set(name, value.toISOString());
-        } else if (value != null) {
-          this.headers.set(name, String(value));
+  _applyHeaders(t) {
+    if (t != null)
+      if (t instanceof Map || t instanceof Headers)
+        t.forEach((e, s) => {
+          this.headers.set(s, e);
+        });
+      else if (D(t))
+        for (const e in t) {
+          const s = t[e];
+          s instanceof Date ? this.headers.set(e, s.toISOString()) : s != null && this.headers.set(e, String(s));
         }
-      }
-    } else {
-      throw new TypeError(`Unknown headers type. Got: ${headers}`);
-    }
-  }
-  _applyQueryParams(query) {
-    if (query == null) return;
-    if (query instanceof Map || query instanceof URLSearchParams) {
-      query.forEach((value, key) => {
-        this.url.searchParams.set(key, value);
-      });
-    } else if (isObject(query)) {
-      for (const name in query) {
-        const value = query[name];
-        if (value instanceof Date) {
-          this.url.searchParams.set(name, value.toISOString());
-        } else if (value != null) {
-          this.url.searchParams.set(name, String(value));
+      else
+        throw new TypeError(`Unknown headers type. Got: ${t}`);
+  }
+  _applyQueryParams(t) {
+    if (t != null)
+      if (t instanceof Map || t instanceof URLSearchParams)
+        t.forEach((e, s) => {
+          this.url.searchParams.set(s, e);
+        });
+      else if (D(t))
+        for (const e in t) {
+          const s = t[e];
+          s instanceof Date ? this.url.searchParams.set(e, s.toISOString()) : s != null && this.url.searchParams.set(e, String(s));
         }
-      }
-    } else {
-      throw new TypeError(`Unknown query params type. Got: ${query}`);
-    }
+      else
+        throw new TypeError(`Unknown query params type. Got: ${t}`);
   }
 }
-class Runner {
-  _middleware;
-  _fetch;
-  _request;
-  _response;
-  constructor(config) {
-    this._middleware = config.middleware;
-    this._fetch = config.fetch;
-    this._request = new Request(config);
+class Ee {
+  constructor(t) {
+    w(this, "_middleware");
+    w(this, "_fetch");
+    w(this, "_request");
+    w(this, "_response");
+    this._middleware = t.middleware, this._fetch = t.fetch, this._request = new ve(t);
   }
   async fetch() {
     if (this._middleware.length > 0) {
-      const mount = (index = 0) => {
-        const current = this._middleware[index];
-        const next = this._middleware[index + 1] ? mount(index + 1) : this._handler.bind(this);
-        return async () => current(this._request, async () => {
-          await next();
-          return this._response;
-        });
+      const t = (e = 0) => {
+        const s = this._middleware[e], n = this._middleware[e + 1] ? t(e + 1) : this._handler.bind(this);
+        return async () => s(this._request, async () => (await n(), this._response));
       };
-      await mount()();
-    } else {
+      await t()();
+    } else
       await this._handler();
-    }
-    if (this._response.status < 200 || this._response.status >= 400) {
-      throw new HTTPResponseError(this._response);
-    }
+    if (this._response.status < 200 || this._response.status >= 400)
+      throw new be(this._response);
     return this._response;
   }
   // This is the function that performs the actual request after the final middleware.
   async _handler() {
-    let reqBody;
-    const req = this._request;
-    if (!req.headers.has("content-type") && isObject(req.body)) {
-      req.headers.set("content-type", "application/json");
-      reqBody = JSON.stringify(req.body);
-    } else {
-      reqBody = req.body;
-    }
-    const fetched = await this._fetch(req.url.toString(), {
-      method: req.method,
-      headers: req.headers,
-      body: reqBody
-    });
-    const contentType = fetched.headers.get("content-type");
-    let body;
-    if (contentType?.includes("application/json")) {
-      body = await fetched.json();
-    } else if (contentType?.includes("application/x-www-form-urlencoded")) {
-      body = await fetched.formData();
-    } else {
-      body = await fetched.text();
-    }
-    this._response = {
-      method: req.method,
-      url: req.url,
-      status: fetched.status,
-      statusText: fetched.statusText,
-      headers: fetched.headers,
-      body
+    let t;
+    const e = this._request;
+    !e.headers.has("content-type") && D(e.body) ? (e.headers.set("content-type", "application/json"), t = JSON.stringify(e.body)) : t = e.body;
+    const s = await this._fetch(e.url.toString(), {
+      method: e.method,
+      headers: e.headers,
+      body: t
+    }), n = s.headers.get("content-type");
+    let r;
+    n != null && n.includes("application/json") ? r = await s.json() : n != null && n.includes("application/x-www-form-urlencoded") ? r = await s.formData() : r = await s.text(), this._response = {
+      method: e.method,
+      url: e.url,
+      status: s.status,
+      statusText: s.statusText,
+      headers: s.headers,
+      body: r
     };
   }
 }
-
-class Translation {
-  dolla;
-  config;
-  #isLoaded = false;
-  #templates = /* @__PURE__ */ new Map();
-  constructor(config, dolla) {
-    this.config = config;
-    this.dolla = dolla;
+var ft, A, q, bt, Wt;
+class $e {
+  constructor(t, e) {
+    u(this, q);
+    w(this, "dolla");
+    w(this, "config");
+    u(this, ft, !1);
+    u(this, A, /* @__PURE__ */ new Map());
+    this.config = t, this.dolla = e;
   }
   async load() {
-    let strings;
-    if (!this.#isLoaded) {
-      if (isObject(this.config.strings)) {
-        strings = this.config.strings;
-      } else if (isFunction(this.config.fetch)) {
-        strings = await this.config.fetch();
-        if (!isObject(strings)) {
-          throw new Error(`Fetch function did not return an object of language strings: ${strings}`);
-        }
-      } else if (isString(this.config.path)) {
-        const res = await fetch(this.config.path);
-        if (res.ok) {
-          const body = await res.json();
-          if (isObject(body)) {
-            strings = body;
-          } else {
+    let t;
+    if (!a(this, ft)) {
+      if (D(this.config.strings))
+        t = this.config.strings;
+      else if (z(this.config.fetch)) {
+        if (t = await this.config.fetch(), !D(t))
+          throw new Error(`Fetch function did not return an object of language strings: ${t}`);
+      } else if (M(this.config.path)) {
+        const e = await fetch(this.config.path);
+        if (e.ok) {
+          const s = await e.json();
+          if (D(s))
+            t = s;
+          else
             throw new Error(
-              `Language path '${this.config.path}' did not return an object of language strings: ${body}`
+              `Language path '${this.config.path}' did not return an object of language strings: ${s}`
             );
-          }
-        } else {
-          throw new Error(`HTTP request failed.`);
-        }
-      }
-    }
-    if (strings) {
-      const entries = this.#compile(strings);
-      for (const entry of entries) {
-        this.#templates.set(entry[0], entry[1]);
+        } else
+          throw new Error("HTTP request failed.");
       }
-    } else {
-      throw new Error(`Language could not be loaded.`);
     }
+    if (t) {
+      const e = f(this, q, bt).call(this, t);
+      for (const s of e)
+        a(this, A).set(s[0], s[1]);
+    } else
+      throw new Error("Language could not be loaded.");
   }
-  getTemplate(selector) {
-    return this.#templates.get(selector) ?? {
-      segments: [{ type: 0 /* Static */, text: `[MISSING: ${selector}]` }]
+  getTemplate(t) {
+    return a(this, A).get(t) ?? {
+      segments: [{ type: 0, text: `[MISSING: ${t}]` }]
     };
   }
-  hasTemplate(selector) {
-    return this.#templates.has(selector);
+  hasTemplate(t) {
+    return a(this, A).has(t);
   }
-  #compile(strings, path = []) {
-    const entries = [];
-    for (const key in strings) {
-      switch (typeOf(strings[key])) {
-        case "string":
-          entries.push([[...path, key].join("."), this.#parseTemplate(strings[key])]);
-          break;
-        case "object":
-          entries.push(...this.#compile(strings[key], [...path, key]));
-          break;
-        default:
-          throw new Error(
-            `Expected to find a string or object at ${[...path, key].join(".")}. Got: ${typeOf(strings[key])}`
-          );
-      }
+}
+ft = new WeakMap(), A = new WeakMap(), q = new WeakSet(), bt = function(t, e = []) {
+  const s = [];
+  for (const n in t)
+    switch (St(t[n])) {
+      case "string":
+        s.push([[...e, n].join("."), f(this, q, Wt).call(this, t[n])]);
+        break;
+      case "object":
+        s.push(...f(this, q, bt).call(this, t[n], [...e, n]));
+        break;
+      default:
+        throw new Error(
+          `Expected to find a string or object at ${[...e, n].join(".")}. Got: ${St(t[n])}`
+        );
     }
-    return entries;
-  }
-  #parseTemplate(template) {
-    let Loc;
-    ((Loc2) => {
-      Loc2[Loc2["Static"] = 0] = "Static";
-      Loc2[Loc2["ValueName"] = 1] = "ValueName";
-      Loc2[Loc2["FormatName"] = 2] = "FormatName";
-      Loc2[Loc2["FormatOptionName"] = 3] = "FormatOptionName";
-      Loc2[Loc2["FormatOptionValue"] = 4] = "FormatOptionValue";
-      Loc2[Loc2["FormatOptionEnd"] = 5] = "FormatOptionEnd";
-    })(Loc || (Loc = {}));
-    const parsed = {
-      segments: []
-    };
-    let buffer = "";
-    let i = 0;
-    let loc = 0 /* Static */;
-    let segment;
-    let format;
-    let formatOptionName;
-    const startSegment = () => {
-      segment = {
-        type: 1 /* Variable */,
-        name: "",
-        formats: []
-      };
+  return s;
+}, Wt = function(t) {
+  let e;
+  ((h) => {
+    h[h.Static = 0] = "Static", h[h.ValueName = 1] = "ValueName", h[h.FormatName = 2] = "FormatName", h[h.FormatOptionName = 3] = "FormatOptionName", h[h.FormatOptionValue = 4] = "FormatOptionValue", h[h.FormatOptionEnd = 5] = "FormatOptionEnd";
+  })(e || (e = {}));
+  const s = {
+    segments: []
+  };
+  let n = "", r = 0, o = 0, c, l, p;
+  const v = () => {
+    c = {
+      type: 1,
+      name: "",
+      formats: []
     };
-    const startFormat = () => {
-      format = {
-        name: "",
-        options: {}
-      };
+  }, $ = () => {
+    l = {
+      name: "",
+      options: {}
     };
-    while (i < template.length) {
-      if (loc !== 0 /* Static */ && template[i] === " ") {
-        i++;
-        continue;
-      }
-      switch (loc) {
-        case 0 /* Static */:
-          if (template[i] === "{" && template[i + 1] === "{") {
-            loc = 1 /* ValueName */;
-            i += 2;
-            if (buffer.length > 0) {
-              parsed.segments.push({ type: 0 /* Static */, text: buffer });
-              buffer = "";
-            }
-            startSegment();
-          } else {
-            buffer += template[i];
-            i++;
-          }
-          break;
-        case 1 /* ValueName */:
-          if (template[i] === "|") {
-            loc = 2 /* FormatName */;
-            i += 1;
-            segment.name = buffer;
-            buffer = "";
-            startFormat();
-          } else if (template[i] === "}" && template[i + 1] === "}") {
-            loc = 0 /* Static */;
-            i += 2;
-            segment.name = buffer;
-            buffer = "";
-            parsed.segments.push(segment);
-          } else {
-            buffer += template[i];
-            i++;
-          }
-          break;
-        case 2 /* FormatName */:
-          if (template[i] === "(") {
-            loc = 3 /* FormatOptionName */;
-            i += 1;
-            format.name = buffer;
-            buffer = "";
-          } else if (template[i] === "}" && template[i + 1] === "}") {
-            loc = 0 /* Static */;
-            i += 2;
-            segment.formats.push(format);
-            parsed.segments.push(segment);
-          } else {
-            buffer += template[i];
-            i++;
-          }
-          break;
-        case 3 /* FormatOptionName */:
-          if (template[i] === ")") ; else if (template[i] === ":") {
-            loc = 4 /* FormatOptionValue */;
-            i += 1;
-            formatOptionName = buffer;
-            buffer = "";
-          } else if (template[i] === "}" && template[i + 1] === "}") ; else {
-            buffer += template[i];
-            i++;
-          }
-          break;
-        case 4 /* FormatOptionValue */:
-          if (template[i] === ")") {
-            loc = 5 /* FormatOptionEnd */;
-            i += 1;
-            format.options[formatOptionName] = buffer;
-            buffer = "";
-            segment.formats.push(format);
-          } else if (template[i] === ",") {
-            loc = 3 /* FormatOptionName */;
-            i += 1;
-            format.options[formatOptionName] = buffer;
-            buffer = "";
-          } else if (template[i] === "}" && template[i + 1] === "}") ; else {
-            buffer += template[i];
-            i++;
-          }
-          break;
-        case 5 /* FormatOptionEnd */:
-          if (template[i] === "|") {
-            loc = 2 /* FormatName */;
-            i += 1;
-            startFormat();
-          } else if (template[i] === "}" && template[i + 1] === "}") {
-            loc = 0 /* Static */;
-            i += 2;
-            parsed.segments.push(segment);
-          } else ;
-          break;
-      }
-    }
-    if (loc === 0 /* Static */ && buffer.length > 0) {
-      parsed.segments.push({ type: 0 /* Static */, text: buffer });
-    }
-    return parsed;
+  };
+  for (; r < t.length; ) {
+    if (o !== 0 && t[r] === " ") {
+      r++;
+      continue;
+    }
+    switch (o) {
+      case 0:
+        t[r] === "{" && t[r + 1] === "{" ? (o = 1, r += 2, n.length > 0 && (s.segments.push({ type: 0, text: n }), n = ""), v()) : (n += t[r], r++);
+        break;
+      case 1:
+        t[r] === "|" ? (o = 2, r += 1, c.name = n, n = "", $()) : t[r] === "}" && t[r + 1] === "}" ? (o = 0, r += 2, c.name = n, n = "", s.segments.push(c)) : (n += t[r], r++);
+        break;
+      case 2:
+        t[r] === "(" ? (o = 3, r += 1, l.name = n, n = "") : t[r] === "}" && t[r + 1] === "}" ? (o = 0, r += 2, c.formats.push(l), s.segments.push(c)) : (n += t[r], r++);
+        break;
+      case 3:
+        t[r] === ")" || (t[r] === ":" ? (o = 4, r += 1, p = n, n = "") : t[r] === "}" && t[r + 1] === "}" || (n += t[r], r++));
+        break;
+      case 4:
+        t[r] === ")" ? (o = 5, r += 1, l.options[p] = n, n = "", c.formats.push(l)) : t[r] === "," ? (o = 3, r += 1, l.options[p] = n, n = "") : t[r] === "}" && t[r + 1] === "}" || (n += t[r], r++);
+        break;
+      case 5:
+        t[r] === "|" ? (o = 2, r += 1, $()) : t[r] === "}" && t[r + 1] === "}" && (o = 0, r += 2, s.segments.push(c));
+        break;
+    }
+  }
+  return o === 0 && n.length > 0 && s.segments.push({ type: 0, text: n }), s;
+};
+var X, P, g, Y, Z, tt, b, y, At, vt, Et, $t, Ht;
+class ke {
+  constructor(t) {
+    u(this, y);
+    u(this, X);
+    u(this, P);
+    u(this, g, /* @__PURE__ */ new Map());
+    u(this, Y, []);
+    u(this, Z, /* @__PURE__ */ new Map());
+    u(this, tt, "auto");
+    u(this, b, Ut(""));
+    d(this, X, t), d(this, P, t.createLogger("Dolla.i18n")), this.addFormat("number", (e, s, n) => f(this, y, vt).call(this, Number(s), n)), this.addFormat("datetime", (e, s, n) => f(this, y, Et).call(this, s, n)), this.addFormat("list", (e, s, n) => f(this, y, $t).call(this, s, n)), t.beforeMount(async () => {
+      a(this, g).size > 0 && await this.setLocale(a(this, tt));
+    });
   }
-}
-class I18n {
-  #dolla;
-  #logger;
-  #translations = /* @__PURE__ */ new Map();
-  #cache = [];
-  #formats = /* @__PURE__ */ new Map();
-  #initialLocale = "auto";
-  #locale = atom("");
   get locale() {
-    return this.#locale;
-  }
-  constructor(dolla) {
-    this.#dolla = dolla;
-    this.#logger = dolla.createLogger("Dolla.i18n");
-    this.addFormat("number", (_, value, options) => {
-      return this.#formatNumber(Number(value), options);
-    });
-    this.addFormat("datetime", (_, value, options) => {
-      return this.#formatDateTime(value, options);
-    });
-    this.addFormat("list", (_, value, options) => {
-      return this.#formatList(value, options);
-    });
-    dolla.beforeMount(async () => {
-      if (this.#translations.size > 0) {
-        await this.setLocale(this.#initialLocale);
-      }
-    });
+    return a(this, b);
   }
   get locales() {
-    return [...this.#translations.keys()];
-  }
-  setup(options) {
-    options.translations.forEach((entry) => {
-      this.#translations.set(entry.locale, new Translation(entry, this.#dolla));
-    });
-    if (options.locale && options.locale !== "auto") {
-      const isRegistered = options.translations.some((entry) => entry.locale === options.locale);
-      if (!isRegistered) {
-        throw new Error(`Initial locale '${options.locale}' is not registered in the locales array.`);
-      }
-      this.#initialLocale = options.locale;
-    }
-    this.#logger.info(
-      `${this.#translations.size} language${this.#translations.size === 1 ? "" : "s"} supported: '${[...this.#translations.keys()].join("', '")}'`
+    return [...a(this, g).keys()];
+  }
+  setup(t) {
+    if (t.translations.forEach((e) => {
+      a(this, g).set(e.locale, new $e(e, a(this, X)));
+    }), t.locale && t.locale !== "auto") {
+      if (!t.translations.some((s) => s.locale === t.locale))
+        throw new Error(`Initial locale '${t.locale}' is not registered in the locales array.`);
+      d(this, tt, t.locale);
+    }
+    a(this, P).info(
+      `${a(this, g).size} language${a(this, g).size === 1 ? "" : "s"} supported: '${[...a(this, g).keys()].join("', '")}'`
     );
   }
-  async setLocale(name) {
-    let realName;
-    if (name === "auto") {
-      let names = [];
-      if (typeof navigator !== "undefined") {
-        const nav = navigator;
-        if (nav.languages?.length > 0) {
-          names.push(...nav.languages);
-        } else if (nav.language) {
-          names.push(nav.language);
-        } else if (nav.browserLanguage) {
-          names.push(nav.browserLanguage);
-        } else if (nav.userLanguage) {
-          names.push(nav.userLanguage);
-        }
-      }
-      for (const name2 of names) {
-        if (this.#translations.has(name2)) {
-          realName = name2;
-        }
-      }
-    } else {
-      if (this.#translations.has(name)) {
-        realName = name;
-      }
-    }
-    if (realName == null) {
-      const firstLanguage = this.#translations.keys().next().value;
-      if (firstLanguage) {
-        realName = firstLanguage;
+  async setLocale(t) {
+    var n;
+    let e;
+    if (t === "auto") {
+      let r = [];
+      if (typeof navigator < "u") {
+        const o = navigator;
+        ((n = o.languages) == null ? void 0 : n.length) > 0 ? r.push(...o.languages) : o.language ? r.push(o.language) : o.browserLanguage ? r.push(o.browserLanguage) : o.userLanguage && r.push(o.userLanguage);
       }
-    }
-    if (!realName || !this.#translations.has(realName)) {
-      throw new Error(`Locale '${name}' has no translation.`);
-    }
-    const translation = this.#translations.get(realName);
+      for (const o of r)
+        a(this, g).has(o) && (e = o);
+    } else
+      a(this, g).has(t) && (e = t);
+    if (e == null) {
+      const r = a(this, g).keys().next().value;
+      r && (e = r);
+    }
+    if (!e || !a(this, g).has(e))
+      throw new Error(`Locale '${t}' has no translation.`);
+    const s = a(this, g).get(e);
     try {
-      await translation.load();
-      this.#cache = [];
-      this.#locale.value = realName;
-      this.#logger.info("set language to " + realName);
-    } catch (error) {
-      if (error instanceof Error) {
-        this.#logger.crash(error);
-      }
+      await s.load(), d(this, Y, []), a(this, b).value = e, a(this, P).info("set language to " + e);
+    } catch (r) {
+      r instanceof Error && a(this, P).crash(r);
     }
   }
   /**
@@ -1085,71 +752,18 @@ class I18n {
      * @example
      * const $value = t("your.key.here", { count: 5 });
      */
-  t(selector, options) {
-    if (this === void 0) {
+  t(t, e) {
+    if (this === void 0)
       throw new Error(
         `The 't' function cannot be destructured. If you need a standalone version you can import it like so: 'import { t } from "@manyducks.co/dolla"'`
       );
-    }
-    return compose(() => {
-      const values = {};
-      for (const key in options) {
-        values[key] = get(options[key]);
-      }
-      return this.#getValue(get(this.#locale), selector, values);
+    return U(() => {
+      const s = {};
+      for (const n in e)
+        s[n] = E(e[n]);
+      return f(this, y, At).call(this, E(a(this, b)), t, s);
     });
   }
-  #getValue(locale, selector, options) {
-    const cached = this.#getCached(selector, options);
-    if (cached) return cached;
-    const translation = this.#translations.get(locale);
-    if (options.context != null) {
-      selector += "_" + options.context;
-    }
-    if (options.count != null) {
-      if (options.ordinal) {
-        const exact = `${selector}_ordinal_(=${options.count})`;
-        if (translation.hasTemplate(exact)) {
-          selector = exact;
-        } else {
-          selector += "_ordinal_" + new Intl.PluralRules(locale, { type: "ordinal" }).select(options.count);
-        }
-      } else {
-        const exact = `${selector}_(=${options.count})`;
-        if (translation.hasTemplate(exact)) {
-          selector = exact;
-        } else {
-          selector += "_" + new Intl.PluralRules(locale).select(options.count);
-        }
-      }
-    }
-    const template = translation.getTemplate(selector);
-    let output = "";
-    for (const segment of template.segments) {
-      if (segment.type === 0 /* Static */) {
-        output += segment.text;
-      } else if (segment.type === 1 /* Variable */) {
-        let value = resolve(options, segment.name);
-        const formats = options.formatOverrides?.[segment.name] ?? [...segment.formats];
-        if (segment.name === "count" && formats.length === 0) {
-          formats.push({ name: "number", options: {} });
-        }
-        for (const format of formats) {
-          const fn = this.#formats.get(format.name);
-          if (fn == null) {
-            const error = new Error(
-              `Failed to load format '${format.name}' when processing '${selector}', template: ${template}`
-            );
-            this.#logger.crash(error);
-            throw error;
-          }
-          value = fn(locale, value, format.options);
-        }
-        output += value;
-      }
-    }
-    return output;
-  }
   /**
    * Add a custom format callback.
    *
@@ -1164,8 +778,8 @@ class I18n {
    *
    * t("greeting", {name: "world"}); // State<"Hello, WORLD!">
    */
-  addFormat(name, callback) {
-    this.#formats.set(name, callback);
+  addFormat(t, e) {
+    a(this, Z).set(t, e);
   }
   /**
    * Creates an `Intl.Collator` configured for the current locale.
@@ -1173,22 +787,16 @@ class I18n {
    *
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator#options
    */
-  collator(options) {
-    return new Intl.Collator(this.#locale.value, options);
+  collator(t) {
+    return new Intl.Collator(a(this, b).value, t);
   }
   /**
    * Formats a number for the current locale. Uses `Intl.NumberFormat` under the hood.
    *
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/NumberFormat/NumberFormat#options
    */
-  number(count, options) {
-    return compose(() => {
-      get(this.#locale);
-      return this.#formatNumber(get(count), options);
-    });
-  }
-  #formatNumber(count, options) {
-    return new Intl.NumberFormat(this.#locale.value, options).format(count);
+  number(t, e) {
+    return U(() => (E(a(this, b)), f(this, y, vt).call(this, E(t), e)));
   }
   /**
    * Formats a date for the current locale. Uses `Intl.DateTimeFormat` under the hood.
@@ -1199,14 +807,8 @@ class I18n {
    * const date = new Date();
    * const $formatted = Dolla.i18n.dateTime(date, { dateFormat: "short" });
    */
-  dateTime(date, options) {
-    return compose(() => {
-      get(this.#locale);
-      return this.#formatDateTime(get(date), options);
-    });
-  }
-  #formatDateTime(date, options) {
-    return new Intl.DateTimeFormat(this.#locale.value, options).format(isString(date) ? new Date(date) : date);
+  dateTime(t, e) {
+    return U(() => (E(a(this, b)), f(this, y, Et).call(this, E(t), e)));
   }
   /**
    * Formats a list for the current locale. Uses `Intl.ListFormat` under the hood.
@@ -1217,41 +819,69 @@ class I18n {
    * const list = new Date();
    * const $formatted = Dolla.i18n.list(list, {  });
    */
-  list(list, options) {
-    return compose(() => {
-      get(this.#locale);
-      return this.#formatList(get(list), options);
-    });
-  }
-  #formatList(list, options) {
-    return new Intl.ListFormat(this.#locale.value, options).format(list);
-  }
-  // relativeTime(): State<string> {
-  // }
-  #getCached(key, values) {
-    for (const entry of this.#cache) {
-      if (entry[0] === key && deepEqual(entry[1], values)) {
-        return entry[2];
-      }
-    }
+  list(t, e) {
+    return U(() => (E(a(this, b)), f(this, y, $t).call(this, E(t), e)));
   }
 }
-function resolve(object, key) {
-  const parsed = String(key).split(/[\.\[\]]/).filter((part) => part.trim() !== "");
-  let value = object;
-  while (parsed.length > 0) {
-    const part = parsed.shift();
-    if (value != null) {
-      value = value[part];
+X = new WeakMap(), P = new WeakMap(), g = new WeakMap(), Y = new WeakMap(), Z = new WeakMap(), tt = new WeakMap(), b = new WeakMap(), y = new WeakSet(), At = function(t, e, s) {
+  var l;
+  const n = f(this, y, Ht).call(this, e, s);
+  if (n) return n;
+  const r = a(this, g).get(t);
+  if (s.context != null && (e += "_" + s.context), s.count != null)
+    if (s.ordinal) {
+      const p = `${e}_ordinal_(=${s.count})`;
+      r.hasTemplate(p) ? e = p : e += "_ordinal_" + new Intl.PluralRules(t, { type: "ordinal" }).select(s.count);
     } else {
-      value = void 0;
-    }
-  }
-  return value;
+      const p = `${e}_(=${s.count})`;
+      r.hasTemplate(p) ? e = p : e += "_" + new Intl.PluralRules(t).select(s.count);
+    }
+  const o = r.getTemplate(e);
+  let c = "";
+  for (const p of o.segments)
+    if (p.type === 0)
+      c += p.text;
+    else if (p.type === 1) {
+      let v = Re(s, p.name);
+      const $ = ((l = s.formatOverrides) == null ? void 0 : l[p.name]) ?? [...p.formats];
+      p.name === "count" && $.length === 0 && $.push({ name: "number", options: {} });
+      for (const h of $) {
+        const x = a(this, Z).get(h.name);
+        if (x == null) {
+          const k = new Error(
+            `Failed to load format '${h.name}' when processing '${e}', template: ${o}`
+          );
+          throw a(this, P).crash(k), k;
+        }
+        v = x(t, v, h.options);
+      }
+      c += v;
+    }
+  return c;
+}, vt = function(t, e) {
+  return new Intl.NumberFormat(a(this, b).value, e).format(t);
+}, Et = function(t, e) {
+  return new Intl.DateTimeFormat(a(this, b).value, e).format(M(t) ? new Date(t) : t);
+}, $t = function(t, e) {
+  return new Intl.ListFormat(a(this, b).value, e).format(t);
+}, // relativeTime(): State<string> {
+// }
+Ht = function(t, e) {
+  for (const s of a(this, Y))
+    if (s[0] === t && Jt(s[1], e))
+      return s[2];
+};
+function Re(i, t) {
+  const e = String(t).split(/[\.\[\]]/).filter((n) => n.trim() !== "");
+  let s = i;
+  for (; e.length > 0; ) {
+    const n = e.shift();
+    s != null ? s = s[n] : s = void 0;
+  }
+  return s;
 }
-
-function DefaultCrashView(props) {
-  return html`
+function _e(i) {
+  return Mt`
     <div
       style=${{
     backgroundColor: "#880000",
@@ -1264,8 +894,8 @@ function DefaultCrashView(props) {
     >
       <h1 style=${{ marginBottom: "0.5rem" }}>The app has crashed</h1>
       <p style=${{ marginBottom: "0.25rem" }}>
-        <span style=${{ fontFamily: "monospace" }}>${props.loggerName}</span>
-        ${cond(props.uid, html`<span style=${{ fontFamily: "monospace", opacity: 0.5 }}> [uid: ${props.uid}]</span>`)}
+        <span style=${{ fontFamily: "monospace" }}>${i.loggerName}</span>
+        ${Xt(i.uid, Mt`<span style=${{ fontFamily: "monospace", opacity: 0.5 }}> [uid: ${i.uid}]</span>`)}
         ${" "}says:
       </p>
       <blockquote
@@ -1288,276 +918,250 @@ function DefaultCrashView(props) {
     fontWeight: "bold"
   }}
         >
-          ${props.error.name}
+          ${i.error.name}
         </span>
-        ${props.error.message}
+        ${i.error.message}
       </blockquote>
 
       <p>Please see the browser console for details.</p>
     </div>
   `;
 }
-
-class Dolla {
-  // TODO: Take these off the global Dolla object.
-  http;
-  i18n;
-  #isMounted = false;
-  #env = "production";
-  #rootElement;
-  #rootView;
-  #crashView = DefaultCrashView;
-  #router;
-  #beforeMountCallbacks = [];
-  #onMountCallbacks = [];
-  #beforeUnmountCallbacks = [];
-  #onUnmountCallbacks = [];
-  #rootElementContext = {
-    root: this,
-    stores: /* @__PURE__ */ new Map(),
-    viewName: "Dolla"
-  };
-  #loggles = {
-    info: "development",
-    log: "development",
-    warn: "development",
-    error: true
-  };
-  #match = createMatcher("*,-Dolla.*");
-  // Registration functions for modules.
-  // All modules will be registered before mount.
-  #modules = [];
+var L, et, F, V, st, H, rt, nt, at, it, O, ot, lt, dt;
+class Se {
   constructor() {
-    this.http = new HTTP();
-    this.i18n = new I18n(this);
+    // TODO: Take these off the global Dolla object.
+    w(this, "http");
+    w(this, "i18n");
+    u(this, L, !1);
+    u(this, et, "production");
+    u(this, F);
+    u(this, V);
+    u(this, st, _e);
+    u(this, H);
+    u(this, rt, []);
+    u(this, nt, []);
+    u(this, at, []);
+    u(this, it, []);
+    u(this, O, {
+      root: this,
+      stores: /* @__PURE__ */ new Map(),
+      viewName: "Dolla"
+    });
+    u(this, ot, {
+      info: "development",
+      log: "development",
+      warn: "development",
+      error: !0
+    });
+    u(this, lt, xt("*,-Dolla.*"));
+    // Registration functions for modules.
+    // All modules will be registered before mount.
+    u(this, dt, []);
+    this.http = new ge(), this.i18n = new ke(this);
   }
   /**
    * True when the app is connected to a DOM node and displayed to the user.
    */
   get isMounted() {
-    return this.#isMounted;
+    return a(this, L);
   }
   /**
    * Get the current environment that this app is running in.
    * Environment affects which log messages will print and how much debugging info is included in the DOM.
    */
   getEnv() {
-    return this.#env;
+    return a(this, et);
   }
   /**
    * Sets the environment that this app is running in.
    * Environment affects which log messages will print and how much debugging info is included in the DOM.
    */
-  setEnv(value) {
-    this.#env = value;
+  setEnv(t) {
+    d(this, et, t);
   }
   /**
    * Sets the view that will be shown when the `crash` method is called on any logger.
    * When a crash is reported the app will be unmounted and replaced with this crash page.
    */
-  setCrashView(view) {
-    this.#crashView = view;
+  setCrashView(t) {
+    d(this, st, t);
   }
   /**
    * Returns the HTMLElement Dolla is mounted to. This will return undefined until Dolla.mount() is called.
    */
   getRootElement() {
-    return this.#rootElement;
+    return a(this, F);
   }
   /**
    * Returns the top level view Dolla is rendering inside the root element. This will return undefined until Dolla.mount() is called.
    */
   getRootView() {
-    return this.#rootView;
-  }
-  provide(store, options) {
-    const instance = new Store(store, options);
-    const attached = instance.attach(this.#rootElementContext);
-    if (!attached) {
-      let name = store.name ? `'${store.name}'` : "this store";
-      console.warn(`An instance of ${name} was already attached to this context.`);
-      return this.get(store);
-    } else {
-      return instance.value;
+    return a(this, V);
+  }
+  provide(t, e) {
+    const s = new Yt(t, e);
+    if (s.attach(a(this, O)))
+      return s.value;
+    {
+      let r = t.name ? `'${t.name}'` : "this store";
+      return console.warn(`An instance of ${r} was already attached to this context.`), this.get(t);
     }
   }
   /**
    * Gets the nearest instance of a store. Throws an error if the store isn't provided higher in the tree.
    */
-  get(store) {
-    if (isFunction(store)) {
-      const instance = this.#rootElementContext.stores.get(store);
-      if (instance == null) {
-        throw new StoreError(`Store not found on this context.`);
-      } else {
-        return instance.value;
-      }
-    } else {
-      throw new StoreError(`Invalid store.`);
-    }
-  }
-  async mount(target, root) {
-    if (this.#isMounted) {
-      throw new Error(`Dolla is already mounted.`);
-    }
-    if (isString(target)) {
-      const match = document.querySelector(target);
-      assertInstanceOf(HTMLElement, match, `Selector '${target}' did not match any element.`);
-      this.#rootElement = match;
-    } else {
-      assertInstanceOf(HTMLElement, target, "Expected an HTML element or a selector string. Got type: %t, value: %v");
-      this.#rootElement = target;
-    }
-    if (_isRouter(root)) {
-      this.#router = root;
-    }
-    const view = _isRouter(root) ? Passthrough : root;
-    const rootViewMarkup = createMarkup(view);
-    this.#rootView = this.constructView(rootViewMarkup.type, rootViewMarkup.props);
-    await Promise.all(this.#modules.map((register) => register()));
-    if (_isRouter(root)) {
-      await _mountRouter(root, this);
-    }
-    await Promise.all(this.#beforeMountCallbacks.map((callback) => callback()));
-    this.#rootView.mount(this.#rootElement);
-    this.#isMounted = true;
-    for (const store of this.#rootElementContext.stores.values()) {
-      store.handleMount();
-    }
-    for (const callback of this.#onMountCallbacks) {
-      callback();
-    }
+  get(t) {
+    if (z(t)) {
+      const e = a(this, O).stores.get(t);
+      if (e == null)
+        throw new Tt("Store not found on this context.");
+      return e.value;
+    } else
+      throw new Tt("Invalid store.");
+  }
+  async mount(t, e) {
+    if (a(this, L))
+      throw new Error("Dolla is already mounted.");
+    if (M(t)) {
+      const r = document.querySelector(t);
+      Nt(HTMLElement, r, `Selector '${t}' did not match any element.`), d(this, F, r);
+    } else
+      Nt(HTMLElement, t, "Expected an HTML element or a selector string. Got type: %t, value: %v"), d(this, F, t);
+    pt(e) && d(this, H, e);
+    const s = pt(e) ? jt : e, n = Zt(s);
+    d(this, V, this.constructView(n.type, n.props)), await Promise.all(a(this, dt).map((r) => r())), pt(e) && await le(e, this), await Promise.all(a(this, rt).map((r) => r())), a(this, V).mount(a(this, F)), d(this, L, !0);
+    for (const r of a(this, O).stores.values())
+      r.handleMount();
+    for (const r of a(this, nt))
+      r();
   }
   async unmount() {
-    if (!this.#isMounted) return;
-    await Promise.all(this.#beforeUnmountCallbacks.map((callback) => callback()));
-    this.#rootView?.unmount(false);
-    if (this.#router) {
-      await _unmountRouter(this.#router);
-    }
-    this.#isMounted = false;
-    for (const callback of this.#onUnmountCallbacks) {
-      callback();
+    var t;
+    if (a(this, L)) {
+      await Promise.all(a(this, at).map((e) => e())), (t = a(this, V)) == null || t.unmount(!1), a(this, H) && await ce(a(this, H)), d(this, L, !1);
+      for (const e of a(this, it))
+        e();
     }
   }
   /**
    * Registers a `callback` to run after `Dolla.mount` is called, before the app is mounted. If `callback` returns a Promise,
    * it will be awaited before mounting finishes. Use this to perform initial setup before the app is displayed to the user.
    */
-  beforeMount(callback) {
-    this.#beforeMountCallbacks.push(callback);
+  beforeMount(t) {
+    a(this, rt).push(t);
   }
   /**
    * Registers a `callback` to run after the app is mounted.
    */
-  onMount(callback) {
-    this.#onMountCallbacks.push(callback);
+  onMount(t) {
+    a(this, nt).push(t);
   }
   /**
    * Registers a `callback` to run after `Dolla.unmount` is called, before the app is unmounted. If `callback` returns a Promise,
    * it will be awaited before unmounting finishes. Use this to perform cleanup.
    */
-  beforeUnmount(callback) {
-    this.#beforeUnmountCallbacks.push(callback);
+  beforeUnmount(t) {
+    a(this, at).push(t);
   }
   /**
    * Registers a `callback` to run after the app is unmounted.
    */
-  onUnmount(callback) {
-    this.#onUnmountCallbacks.push(callback);
+  onUnmount(t) {
+    a(this, it).push(t);
   }
   /**
    * Update log type toggles. Values that are not passed will remain unchanged.
    */
-  setLoggles(options) {
-    for (const key in options) {
-      const value = options[key];
-      if (value) {
-        this.#loggles[key] = value;
-      }
-    }
-  }
-  setLogFilter(filter) {
-    this.#match = createMatcher(filter);
-  }
-  createLogger(name, options) {
-    const _console = options?.console ?? getDefaultConsole();
-    const self = this;
-    const loggles = this.#loggles;
-    const bind = (method) => {
-      if (loggles[method] === false || isString(loggles[method]) && loggles[method] !== self.getEnv() || !this.#match(name)) {
-        return noOp;
-      } else {
-        let label = `%c${name}`;
-        if (options?.uid) {
-          label += ` %c[uid: %c${options.uid}%c]`;
-        } else {
-          label += `%c%c%c`;
-        }
-        return _console[method].bind(
-          _console,
-          label,
-          `color:${okhash(label)};font-weight:bold`,
-          `color:#777`,
-          `color:#aaa`,
-          `color:#777`
+  setLoggles(t) {
+    for (const e in t) {
+      const s = t[e];
+      s && (a(this, ot)[e] = s);
+    }
+  }
+  setLogFilter(t) {
+    d(this, lt, xt(t));
+  }
+  createLogger(t, e) {
+    const s = (e == null ? void 0 : e.console) ?? Me(), n = this, r = a(this, ot), o = (c) => {
+      if (r[c] === !1 || M(r[c]) && r[c] !== n.getEnv() || !a(this, lt).call(this, t))
+        return re;
+      {
+        let l = `%c${t}`;
+        return e != null && e.uid ? l += ` %c[uid: %c${e.uid}%c]` : l += "%c%c%c", s[c].bind(
+          s,
+          l,
+          `color:${ne(l)};font-weight:bold`,
+          "color:#777",
+          "color:#aaa",
+          "color:#777"
         );
       }
     };
     return {
-      setName(newName) {
-        name = newName;
-        return this;
+      setName(c) {
+        return t = c, this;
       },
       get info() {
-        return bind("info");
+        return o("info");
       },
       get log() {
-        return bind("log");
+        return o("log");
       },
       get warn() {
-        return bind("warn");
+        return o("warn");
       },
       get error() {
-        return bind("error");
+        return o("error");
       },
-      crash(error) {
-        if (self.isMounted) {
-          self.unmount();
-          const crashPage = self.constructView(self.#crashView, {
-            error,
-            loggerName: name,
-            uid: options?.uid
-          });
-          crashPage.mount(self.#rootElement);
-        }
+      crash(c) {
+        n.isMounted && (n.unmount(), n.constructView(a(n, st), {
+          error: c,
+          loggerName: t,
+          uid: e == null ? void 0 : e.uid
+        }).mount(a(n, F)));
       }
     };
   }
   /**
    *
    */
-  constructView(view, props, children = []) {
-    return new View(this.#rootElementContext, view, props, children);
+  constructView(t, e, s = []) {
+    return new te(a(this, O), t, e, s);
   }
   /**
    *
    */
-  constructMarkup(markup) {
-    return groupElements(constructMarkup(this.#rootElementContext, markup));
+  constructMarkup(t) {
+    return ee(se(a(this, O), t));
   }
 }
-function getDefaultConsole() {
-  if (typeof window !== "undefined" && window.console) {
+L = new WeakMap(), et = new WeakMap(), F = new WeakMap(), V = new WeakMap(), st = new WeakMap(), H = new WeakMap(), rt = new WeakMap(), nt = new WeakMap(), at = new WeakMap(), it = new WeakMap(), O = new WeakMap(), ot = new WeakMap(), lt = new WeakMap(), dt = new WeakMap();
+function Me() {
+  if (typeof window < "u" && window.console)
     return window.console;
-  }
-  if (typeof global !== "undefined" && global.console) {
+  if (typeof global < "u" && global.console)
     return global.console;
-  }
 }
-
-const dolla = new Dolla();
-const t = dolla.i18n.t.bind(dolla.i18n);
-
-export { atom, compose, cond, createMarkup, createRouter, deepEqual, dolla as default, get, html, ref, shallowEqual, t };
+const Pt = new Se(), Le = Pt.i18n.t.bind(Pt.i18n);
+export {
+  Ut as atom,
+  U as compose,
+  Xt as cond,
+  Zt as createMarkup,
+  Pe as createRouter,
+  Jt as deepEqual,
+  Pt as default,
+  Ue as effect,
+  E as get,
+  Mt as html,
+  je as list,
+  Ce as peek,
+  Ie as portal,
+  Ne as ref,
+  Ve as set,
+  _t as shallowEqual,
+  De as strictEqual,
+  Le as t
+};
 //# sourceMappingURL=index.js.map