@manyducks.co/dolla 2.0.0-alpha.35 → 2.0.0-alpha.37

package/dist/index.js

@@ -1,262 +1,336 @@
-var Ke = Object.defineProperty;
-var _e = (i) => {
-  throw TypeError(i);
-};
-var Qe = (i, e, t) => e in i ? Ke(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
-var p = (i, e, t) => Qe(i, typeof e != "symbol" ? e + "" : e, t), pe = (i, e, t) => e.has(i) || _e("Cannot " + t);
-var a = (i, e, t) => (pe(i, e, "read from private field"), t ? t.call(i) : e.get(i)), h = (i, e, t) => e.has(i) ? _e("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(i) : e.set(i, t), d = (i, e, t, r) => (pe(i, e, "write to private field"), r ? r.call(i, t) : e.set(i, t), t), f = (i, e, t) => (pe(i, e, "access private method"), t);
-var Se = (i, e, t, r) => ({
-  set _(n) {
-    d(i, e, n, t);
-  },
-  get _() {
-    return a(i, e, r);
-  }
-});
-import { I as Je, a as Ue, b as Xe, i as Q, c as je, d as Ce, e as C, g as E, s as Me, f as Ye, h as k, j as G, P as De, k as Ze, t as xe, l as Te, m as et, p as tt, n as Ne, S as rt, o as Pe, q as Fe, r as st, u as ce, v as he, V as nt, w as at, x as it } from "./markup-BWJWLvDF.js";
-import { y as Ct, D as Dt, A as It, C as Vt, z as qt, B as Gt } from "./markup-BWJWLvDF.js";
-function Ft(i) {
-  function e() {
-    if (arguments.length === 1)
-      i = arguments[0];
-    else if (arguments.length > 1)
+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-Px0heVon.js';
+export { w as effect, B as list, y as peek, A as portal, x as set, z as strictEqual } from './markup-Px0heVon.js';
+
+function ref(value) {
+  return function() {
+    if (arguments.length === 1) {
+      value = arguments[0];
+    } else if (arguments.length > 1) {
       throw new Error(`Too many arguments. Expected 0 or 1. Got: ${arguments.length}`);
-    return i;
-  }
-  return e[Je] = !0, e;
+    }
+    return value;
+  };
 }
-function X(i) {
-  return Ue(i, "Expected `path` to be a string. Got type: %t, value: %v"), i.split("/").map((e) => e.trim()).filter((e) => e !== "");
+
+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 A(i) {
-  var t;
-  Xe(
-    (r) => Q(r == null ? void 0 : r.toString),
-    i,
+function joinPath(parts) {
+  assertArrayOf(
+    (part) => isFunction(part?.toString),
+    parts,
     "Expected `parts` to be an array of objects with a .toString() method. Got type: %t, value: %v"
-  ), i = i.filter((r) => r).flatMap(String);
-  let e = (t = i.shift()) == null ? void 0 : t.toString();
-  if (e) {
-    for (const r of i.map((n) => n.toString()))
-      r.startsWith(".") ? e = ue(e, r) : e[e.length - 1] !== "/" ? r[0] !== "/" ? e += "/" + r : e += r : r[0] === "/" ? e += r.slice(1) : e += r;
-    e && e !== "/" && e.endsWith("/") && (e = e.slice(0, e.length - 1));
-  }
-  return e ?? "";
+  );
+  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 ?? "";
 }
-function ue(i, e) {
-  if (Ue(i, "Expected `base` to be a string. Got type: %t, value: %v"), e == null && (e = i, i = ""), e.startsWith("/"))
-    return e;
-  let t = i;
-  for (; ; )
-    if (e.startsWith("..")) {
-      for (let r = t.length; r > 0; --r)
-        if (t[r] === "/" || r === 0) {
-          t = t.slice(0, r), e = e.replace(/^\.\.\/?/, "");
+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(/^\.\.\/?/, "");
           break;
         }
-    } else if (e.startsWith("."))
-      e = e.replace(/^\.\/?/, "");
-    else
+      }
+    } else if (part.startsWith(".")) {
+      part = part.replace(/^\.\/?/, "");
+    } else {
       break;
-  return A([t, e]);
+    }
+  }
+  return joinPath([resolved, part]);
 }
-function ot(i) {
-  if (!i) return {};
-  i.startsWith("?") && (i = i.slice(1));
-  const e = i.split("&").filter((t) => t.trim() !== "").map((t) => {
-    const [r, n] = t.split("=").map((s) => s.trim());
-    return n.toLowerCase() === "true" ? [r, !0] : n.toLowerCase() === "false" ? [r, !1] : isNaN(Number(n)) ? [r, n] : [r, Number(n)];
+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];
   });
-  return Object.fromEntries(e);
+  return Object.fromEntries(entries);
 }
-function Ie(i, e, t = {}) {
-  var o;
-  const [r, n] = e.split("?"), s = X(r);
-  e: for (const u of i) {
-    const { fragments: l } = u;
-    if (!(((o = l[l.length - 1]) == null ? void 0 : o.type) === 3) && l.length !== s.length || t.willMatch && !t.willMatch(u))
-      continue e;
-    const $ = [];
-    t: for (let c = 0; c < l.length; c++) {
-      const T = s[c], _ = l[c];
-      if (T == null && _.type !== 3)
-        continue e;
-      switch (_.type) {
-        case 1:
-          if (_.name.toLowerCase() === T.toLowerCase()) {
-            $.push(_);
+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);
             break;
-          } else
-            continue e;
-        case 2:
-          $.push({ ..._, value: T });
-          break;
-        case 3:
-          $.push({ ..._, value: s.slice(c).join("/") });
-          break t;
-        case 4:
-          if (isNaN(Number(T)))
-            continue e;
-          $.push({ ..._, value: Number(T) });
+          } else {
+            continue routes;
+          }
+        case 2 /* Param */:
+          matched.push({ ...frag, value: part });
           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: ${_.type}`);
+          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);
       }
     }
-    const R = {};
-    for (const c of $)
-      c.type === 2 && (R[c.name] = decodeURIComponent(c.value)), c.type === 4 && (R[c.name] = c.value), c.type === 3 && (R.wildcard = "/" + decodeURIComponent(c.value));
     return {
-      path: "/" + $.map((c) => c.value).join("/"),
-      pattern: "/" + l.map((c) => c.type === 2 ? `{${c.name}}` : c.type === 4 ? `{#${c.name}}` : c.name).join("/"),
-      params: R,
-      query: ot(n),
-      meta: u.meta
+      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
     };
   }
 }
-function lt(i) {
-  const e = [], t = [], r = [], n = [];
-  for (const o of i) {
-    const { fragments: u } = o;
-    u.some(
-      (l) => l.type === 3
-      /* Wildcard */
-    ) ? n.push(o) : u.some(
-      (l) => l.type === 4
-      /* NumericParam */
-    ) ? t.push(o) : u.some(
-      (l) => l.type === 2
-      /* Param */
-    ) ? r.push(o) : e.push(o);
-  }
-  const s = (o, u) => o.fragments.length > u.fragments.length ? -1 : 1;
-  return e.sort(s), t.sort(s), r.sort(s), n.sort(s), [...e, ...t, ...r, ...n];
+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 ct(i) {
-  const e = X(i), t = [];
-  for (let r = 0; r < e.length; r++) {
-    const n = e[r];
-    if (n === "*") {
-      if (r !== e.length - 1)
-        throw new Error(`Wildcard must be at the end of a pattern. Received: ${i}`);
-      t.push({
-        type: 3,
+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 */,
         name: "*",
         value: null
       });
-    } else n.at(0) === "{" && n.at(-1) === "}" ? t.push({
-      type: n[1] === "#" ? 4 : 2,
-      name: n[1] === "#" ? n.slice(2, -1) : n.slice(1, -1),
-      value: null
-    }) : t.push({
-      type: 1,
-      name: n,
-      value: n
-    });
+    } 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
+      });
+    }
   }
-  return t;
+  return fragments;
 }
-function Lt(i) {
-  return new ft(i);
+
+function createRouter(options) {
+  return new Router(options);
 }
-const Ve = Symbol.for("DollaRouterMountMethod"), qe = Symbol.for("DollaRouterUnmountMethod");
-function ge(i) {
-  return (i == null ? void 0 : i[je]) === !0;
+const ROUTER_MOUNT = Symbol.for("DollaRouterMountMethod");
+const ROUTER_UNMOUNT = Symbol.for("DollaRouterUnmountMethod");
+function _isRouter(value) {
+  return value?.[IS_ROUTER] === true;
 }
-async function ht(i, e) {
-  return i[Ve](e);
+async function _mountRouter(router, dolla) {
+  return router[ROUTER_MOUNT](dolla);
 }
-async function ut(i) {
-  return i[qe]();
+async function _unmountRouter(router) {
+  return router[ROUTER_UNMOUNT]();
 }
-var Oe, H, x, fe, N, z, Y, D, I, P, m, ye, Ge, We, J, Ae, be, ve;
-class ft {
-  constructor(e) {
-    h(this, m);
-    p(this, Oe, !0);
-    h(this, H);
-    h(this, x);
-    h(this, fe, 0);
-    h(this, N, []);
-    h(this, z, []);
-    h(this, Y, !1);
-    /**
-     * Use hash routing when true. Configured in router options.
-     */
-    h(this, D, !1);
-    // Callbacks that need to be called on unmount.
-    h(this, I, []);
-    /**
-     * The current match object.
-     */
-    h(this, P, Ce());
-    /**
-     * The currently matched route pattern, if any.
-     */
-    p(this, "pattern", C(() => {
-      var e;
-      return (e = E(a(this, P))) == null ? void 0 : e.pattern;
-    }));
-    /**
-     * The current URL path.
-     */
-    p(this, "path", C(() => {
-      var e;
-      return ((e = E(a(this, P))) == null ? void 0 : e.path) ?? window.location.pathname;
-    }));
-    /**
-     * The current named path params.
-     */
-    p(this, "params", C(() => {
-      var e;
-      return ((e = E(a(this, P))) == null ? void 0 : e.params) ?? {};
-    }, { equals: Me }));
-    /**
-     * The current query params. Changes to this object will be reflected in the URL.
-     */
-    p(this, "query", C(() => {
-      var e;
-      return ((e = E(a(this, P))) == null ? void 0 : e.query) ?? {};
-    }, { equals: Me }));
-    Ye(e, "Options must be an object. Got: %t"), e.hash && d(this, D, !0), d(this, z, lt(
-      e.routes.flatMap((t) => f(this, m, ve).call(this, t)).map((t) => ({
-        pattern: t.pattern,
-        meta: t.meta,
-        fragments: ct(t.pattern)
+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)
       }))
-    )), gt(a(this, z));
+    );
+    assertValidRedirects(this.#routes);
   }
-  async [(Oe = je, Ve)](e) {
-    d(this, H, e), d(this, x, e.createLogger("Dolla.router"));
-    const t = () => {
-      f(this, m, J).call(this);
+  async [ROUTER_MOUNT](dolla) {
+    this.#dolla = dolla;
+    this.#logger = dolla.createLogger("Dolla.router");
+    const onPopState = () => {
+      this.#updateRoute();
     };
-    window.addEventListener("popstate", t), a(this, I).push(() => window.removeEventListener("popstate", t));
-    const r = e.getRootElement();
-    a(this, I).push(
-      wt(r, (n) => {
-        let s = n.getAttribute("href");
-        a(this, x).info("intercepted click on <a> tag", n), /^https?:\/\/|^\//.test(s) || (s = A([window.location.pathname, s])), f(this, m, ye).call(this, s);
+    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);
       })
-    ), a(this, x).info("will intercept clicks on <a> tags within root element", r), d(this, Y, !0), await f(this, m, J).call(this);
+    );
+    this.#logger.info("will intercept clicks on <a> tags within root element", rootElement);
+    this.#isMounted = true;
+    await this.#updateRoute();
   }
-  async [qe]() {
-    for (const e of a(this, I))
-      e();
-    d(this, I, []);
+  async [ROUTER_UNMOUNT]() {
+    for (const callback of this.#unsubscribers) {
+      callback();
+    }
+    this.#unsubscribers = [];
   }
   /**
    * Navigate backward. Pass a number of steps to hit the back button that many times.
    */
-  back(e = 1) {
-    window.history.go(-e);
+  back(steps = 1) {
+    window.history.go(-steps);
   }
   /**
    * Navigate forward. Pass a number of steps to hit the forward button that many times.
    */
-  forward(e = 1) {
-    window.history.go(e);
+  forward(steps = 1) {
+    window.history.go(steps);
   }
   /**
    * Navigates to another route.
@@ -265,499 +339,741 @@ class ft {
    * router.go("/login"); // navigate to `/login`
    * router.go["/users", 215], { replace: true }); // replace current history entry with `/users/215`
    */
-  go(e, t = {}) {
-    if (a(this, H) == null)
-      throw new Error("Routa methods won't work until you register it: Dolla.use(Routa, { /* ...options */ })");
-    let r;
-    Array.isArray(e) ? r = A(e) : r = e.toString(), r = ue(window.location.pathname, r), t.preserveQuery && (r += window.location.search), t.replace ? f(this, m, Ge).call(this, r) : f(this, m, ye).call(this, r);
+  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);
+    }
   }
-}
-H = new WeakMap(), x = new WeakMap(), fe = new WeakMap(), N = new WeakMap(), z = new WeakMap(), Y = new WeakMap(), D = new WeakMap(), I = new WeakMap(), P = new WeakMap(), m = new WeakSet(), ye = function(e, t) {
-  var r;
-  (r = a(this, x)) == null || r.info("(push)", e), window.history.pushState(t, "", a(this, D) ? "/#" + e : e), f(this, m, J).call(this, e);
-}, Ge = function(e, t) {
-  var r;
-  (r = a(this, x)) == null || r.info("(replace)", e), window.history.replaceState(t, "", a(this, D) ? "/#" + e : e), f(this, m, J).call(this, e);
-}, We = function() {
-  return a(this, D) ? new URL(window.location.hash.slice(1), window.location.origin) : new URL(window.location.pathname, window.location.origin);
-}, J = async function(e) {
-  var u;
-  const t = a(this, x), r = (u = a(this, H)) == null ? void 0 : u.getRootView(), n = e ? new URL(e, window.location.origin) : f(this, m, We).call(this), { match: s, journey: o } = await f(this, m, be).call(this, n);
-  for (const l of o)
-    switch (l.kind) {
-      case "match":
-        t == null || t.info(`📍 ${l.message}`);
-        break;
-      case "redirect":
-        t == null || t.info(`↩️ ${l.message}`);
-        break;
-      case "miss":
-        t == null || t.info(`💀 ${l.message}`);
-        break;
-    }
-  if (s) {
-    const l = this.pattern.value;
-    a(this, P).value = s, r && s.pattern !== l && f(this, m, Ae).call(this, r, s);
-  } else
-    a(this, Y) && t.crash(new yt(`Failed to match route '${n.pathname}'`));
-  return { match: s, journey: o };
-}, /**
- * Takes a matched route and mounts it.
- */
-Ae = function(e, t) {
-  const r = t.meta.layers;
-  for (let n = 0; n < r.length; n++) {
-    const s = r[n], o = a(this, N)[n];
-    if ((o == null ? void 0 : o.id) !== s.id) {
-      d(this, N, a(this, N).slice(0, n)), o == null || o.view.unmount();
-      const u = a(this, N).at(-1), w = ((u == null ? void 0 : u.view) ?? e).setChildView(s.view);
-      a(this, N).push({ id: s.id, view: w });
-    }
-  }
-}, be = async function(e, t = []) {
-  const r = Ie(a(this, z), e.pathname);
-  if (!r)
-    return {
-      match: null,
-      journey: [...t, { kind: "miss", message: `no match for '${e.pathname}'` }]
-    };
-  let n = r.meta.redirect;
-  if (r.meta.beforeMatch && await r.meta.beforeMatch({
-    // TODO: Allow setting context variables from here? Would apply to the context of the matched view.
-    redirect: (s) => {
-      n = s;
-    }
-  }), n != null) {
-    let s;
-    if (k(n))
-      s = pt(n, r.params);
-    else if (Q(n)) {
-      const o = {
-        path: r.path,
-        pattern: r.pattern,
-        params: r.params,
-        query: r.query
+  #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 });
+      }
+    }
+  }
+  /**
+   * 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}'` }]
       };
-      if (s = await n(o), !k(s))
-        throw new Error("Redirect function must return a path to redirect to.");
-      s.startsWith("/") || (s = ue(r.path, s));
-    } else
-      throw new TypeError("Redirect must either be a path string or a function.");
-    return f(this, m, be).call(this, new URL(s, window.location.origin), [
-      ...t,
-      { kind: "redirect", message: `redirecting '${r.path}' -> '${s}'` }
-    ]);
-  } else
-    return { match: r, journey: [...t, { kind: "match", message: `matched route '${r.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.
- */
-ve = function(e, t = [], r = []) {
-  if (!G(e) || !k(e.path))
-    throw new TypeError(`Route configs must be objects with a 'path' string property. Got: ${e}`);
-  if (e.redirect && e.routes)
-    throw new Error("Route cannot have both a 'redirect' and nested 'routes'.");
-  if (e.redirect && e.view)
-    throw new Error("Route cannot have both a 'redirect' and a 'view'.");
-  if (!e.view && !e.routes && !e.redirect)
-    throw new Error("Route must have a 'view', a 'redirect', or a set of nested 'routes'.");
-  let n = [];
-  for (const l of t)
-    n.push(...X(l.path));
-  n.push(...X(e.path)), n[n.length - 1] === "*" && n.pop();
-  const s = [];
-  if (e.redirect) {
-    let l = e.redirect;
-    return k(l) && (l = ue(A(n), l), l.startsWith("/") || (l = "/" + l)), s.push({
-      pattern: "/" + A([...n, ...X(e.path)]),
-      meta: {
-        redirect: l
+    }
+    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.`);
+      }
+      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;
+        }
       }
-    }), s;
-  }
-  let o = De;
-  if (Q(e.view))
-    o = e.view;
-  else if (e.view)
-    throw new TypeError(`Route '${e.path}' expected a view function or undefined. Got: ${e.view}`);
-  const u = { id: Se(this, fe)._++, view: o };
-  if (e.routes)
-    for (const l of e.routes)
-      s.push(...f(this, m, ve).call(this, l, [...t, e], [...r, u]));
-  else
-    s.push({
-      pattern: parent ? A([...t.map((l) => l.path), e.path]) : e.path,
-      meta: {
-        pattern: e.path,
-        layers: [...r, u],
-        beforeMatch: e.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]));
       }
-    });
-  return s;
-};
-const dt = /(noopener|noreferrer) (noopener|noreferrer)/, mt = /^[\w-_]+:/;
-function wt(i, e, t = window) {
-  function r(s) {
-    return !s || s === i ? null : s.localName !== "a" || s.href === void 0 ? r(s.parentNode) : s;
-  }
-  function n(s) {
-    if (s.button && s.button !== 0 || s.ctrlKey || s.metaKey || s.altKey || s.shiftKey || s.defaultPrevented)
+    } 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 o = r(s.target);
-    o && (t.location.protocol !== o.protocol || t.location.hostname !== o.hostname || t.location.port !== o.port || o.hasAttribute("data-router-ignore") || o.hasAttribute("download") || o.getAttribute("target") === "_blank" && dt.test(o.getAttribute("rel")) || mt.test(o.getAttribute("href")) || (s.preventDefault(), e(o)));
+    }
+    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;
+    }
+    e.preventDefault();
+    callback(anchor);
   }
-  return i.addEventListener("click", n), function() {
-    i.removeEventListener("click", n);
+  root.addEventListener("click", handler);
+  return function cancel() {
+    root.removeEventListener("click", handler);
   };
 }
-function pt(i, e) {
-  for (const t in e) {
-    const r = e[t].toString();
-    i = i.replace(`{${t}}`, r).replace(`{#${t}}`, r);
+function replaceParams(path, params) {
+  for (const key in params) {
+    const value = params[key].toString();
+    path = path.replace(`{${key}}`, value).replace(`{#${key}}`, value);
   }
-  return i;
+  return path;
 }
-function gt(i) {
-  for (const e of i)
-    if (e.meta.redirect) {
-      let t;
-      if (!Q(e.meta.redirect)) if (k(e.meta.redirect)) {
-        if (t = e.meta.redirect, !Ie(i, t, {
-          willMatch(n) {
-            return n !== e;
+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;
           }
-        }))
-          throw new Error(`Found a redirect to an undefined URL. From '${e.pattern}' to '${e.meta.redirect}'`);
-      } else
-        throw new TypeError(`Expected a string or redirect function. Got: ${e.meta.redirect}`);
+        });
+        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}`);
+      }
     }
+  }
 }
-class yt extends Error {
+class NoRouteError extends Error {
 }
-var V, de, S, M;
-class bt {
-  // #dolla: Dolla;
-  // #logger: Logger;
-  constructor() {
-    h(this, S);
-    h(this, V, []);
-    h(this, de, vt());
-  }
+
+class HTTP {
+  #middleware = [];
+  #fetch = getDefaultFetch();
   /**
    * 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(e) {
-    return a(this, V).push(e), () => {
-      a(this, V).splice(a(this, V).indexOf(e), 1);
+  use(fn) {
+    this.#middleware.push(fn);
+    return () => {
+      this.#middleware.splice(this.#middleware.indexOf(fn), 1);
     };
   }
-  async get(e, t) {
-    return f(this, S, M).call(this, "get", e, t);
+  async get(uri, options) {
+    return this.#request("get", uri, options);
   }
-  async put(e, t) {
-    return f(this, S, M).call(this, "put", e, t);
+  async put(uri, options) {
+    return this.#request("put", uri, options);
   }
-  async patch(e, t) {
-    return f(this, S, M).call(this, "patch", e, t);
+  async patch(uri, options) {
+    return this.#request("patch", uri, options);
   }
-  async post(e, t) {
-    return f(this, S, M).call(this, "post", e, t);
+  async post(uri, options) {
+    return this.#request("post", uri, options);
   }
-  async delete(e, t) {
-    return f(this, S, M).call(this, "delete", e, t);
+  async delete(uri, options) {
+    return this.#request("delete", uri, options);
   }
-  async head(e, t) {
-    return f(this, S, M).call(this, "head", e, t);
+  async head(uri, options) {
+    return this.#request("head", uri, options);
   }
-  async options(e, t) {
-    return f(this, S, M).call(this, "options", e, t);
+  async options(uri, options) {
+    return this.#request("options", uri, options);
   }
-  async trace(e, t) {
-    return f(this, S, M).call(this, "trace", e, t);
+  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();
   }
 }
-V = new WeakMap(), de = new WeakMap(), S = new WeakSet(), M = async function(e, t, r) {
-  return new kt({
-    ...r,
-    method: e,
-    uri: t,
-    middleware: a(this, V),
-    fetch: a(this, de)
-  }).fetch();
-};
-function vt() {
-  if (typeof window < "u" && window.fetch)
+function getDefaultFetch() {
+  if (typeof window !== "undefined" && window.fetch) {
     return window.fetch.bind(window);
-  if (typeof global < "u" && global.fetch)
+  }
+  if (typeof global !== "undefined" && 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 $t extends Error {
-  constructor(t) {
-    const { status: r, statusText: n, method: s, url: o } = t, u = `${r} ${n}: Request failed (${s.toUpperCase()} ${o.toString()})`;
-    super(u);
-    p(this, "response");
-    this.response = t;
+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 Et {
-  constructor(e) {
-    p(this, "method");
-    p(this, "url");
-    p(this, "headers", new Headers());
-    p(this, "body");
-    this.method = e.method, this.body = e.body, e.uri.startsWith("http") ? this.url = new URL(e.uri) : this.url = new URL(e.uri, window.location.origin), this._applyHeaders(e.headers), this._applyQueryParams(e.query);
-  }
+class Request {
+  method;
+  url;
+  headers = new Headers();
+  body;
   get isSameOrigin() {
     return this.url.origin === window.location.origin;
   }
-  _applyHeaders(e) {
-    if (e != null)
-      if (e instanceof Map || e instanceof Headers)
-        e.forEach((t, r) => {
-          this.headers.set(r, t);
-        });
-      else if (G(e))
-        for (const t in e) {
-          const r = e[t];
-          r instanceof Date ? this.headers.set(t, r.toISOString()) : r != null && this.headers.set(t, String(r));
+  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));
         }
-      else
-        throw new TypeError(`Unknown headers type. Got: ${e}`);
-  }
-  _applyQueryParams(e) {
-    if (e != null)
-      if (e instanceof Map || e instanceof URLSearchParams)
-        e.forEach((t, r) => {
-          this.url.searchParams.set(r, t);
-        });
-      else if (G(e))
-        for (const t in e) {
-          const r = e[t];
-          r instanceof Date ? this.url.searchParams.set(t, r.toISOString()) : r != null && this.url.searchParams.set(t, String(r));
+      }
+    } 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 query params type. Got: ${e}`);
+      }
+    } else {
+      throw new TypeError(`Unknown query params type. Got: ${query}`);
+    }
   }
 }
-class kt {
-  constructor(e) {
-    p(this, "_middleware");
-    p(this, "_fetch");
-    p(this, "_request");
-    p(this, "_response");
-    this._middleware = e.middleware, this._fetch = e.fetch, this._request = new Et(e);
+class Runner {
+  _middleware;
+  _fetch;
+  _request;
+  _response;
+  constructor(config) {
+    this._middleware = config.middleware;
+    this._fetch = config.fetch;
+    this._request = new Request(config);
   }
   async fetch() {
     if (this._middleware.length > 0) {
-      const e = (t = 0) => {
-        const r = this._middleware[t], n = this._middleware[t + 1] ? e(t + 1) : this._handler.bind(this);
-        return async () => r(this._request, async () => (await n(), this._response));
+      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;
+        });
       };
-      await e()();
-    } else
+      await mount()();
+    } else {
       await this._handler();
-    if (this._response.status < 200 || this._response.status >= 400)
-      throw new $t(this._response);
+    }
+    if (this._response.status < 200 || this._response.status >= 400) {
+      throw new HTTPResponseError(this._response);
+    }
     return this._response;
   }
   // This is the function that performs the actual request after the final middleware.
   async _handler() {
-    let e;
-    const t = this._request;
-    !t.headers.has("content-type") && G(t.body) ? (t.headers.set("content-type", "application/json"), e = JSON.stringify(t.body)) : e = t.body;
-    const r = await this._fetch(t.url.toString(), {
-      method: t.method,
-      headers: t.headers,
-      body: e
-    }), n = r.headers.get("content-type");
-    let s;
-    n != null && n.includes("application/json") ? s = await r.json() : n != null && n.includes("application/x-www-form-urlencoded") ? s = await r.formData() : s = await r.text(), this._response = {
-      method: t.method,
-      url: t.url,
-      status: r.status,
-      statusText: r.statusText,
-      headers: r.headers,
-      body: s
+    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
     };
   }
 }
-var me, B, W, $e, He;
-class Rt {
-  constructor(e, t) {
-    h(this, W);
-    p(this, "dolla");
-    p(this, "config");
-    h(this, me, !1);
-    h(this, B, /* @__PURE__ */ new Map());
-    this.config = e, this.dolla = t;
+
+class Translation {
+  dolla;
+  config;
+  #isLoaded = false;
+  #templates = /* @__PURE__ */ new Map();
+  constructor(config, dolla) {
+    this.config = config;
+    this.dolla = dolla;
   }
   async load() {
-    let e;
-    if (!a(this, me)) {
-      if (G(this.config.strings))
-        e = this.config.strings;
-      else if (Q(this.config.fetch)) {
-        if (e = await this.config.fetch(), !G(e))
-          throw new Error(`Fetch function did not return an object of language strings: ${e}`);
-      } else if (k(this.config.path)) {
-        const t = await fetch(this.config.path);
-        if (t.ok) {
-          const r = await t.json();
-          if (G(r))
-            e = r;
-          else
+    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 {
             throw new Error(
-              `Language path '${this.config.path}' did not return an object of language strings: ${r}`
+              `Language path '${this.config.path}' did not return an object of language strings: ${body}`
             );
-        } else
-          throw new Error("HTTP request failed.");
+          }
+        } 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(`Language could not be loaded.`);
     }
-    if (e) {
-      const t = f(this, W, $e).call(this, e);
-      for (const r of t)
-        a(this, B).set(r[0], r[1]);
-    } else
-      throw new Error("Language could not be loaded.");
   }
-  getTemplate(e) {
-    return a(this, B).get(e) ?? {
-      segments: [{ type: 0, text: `[MISSING: ${e}]` }]
+  getTemplate(selector) {
+    return this.#templates.get(selector) ?? {
+      segments: [{ type: 0 /* Static */, text: `[MISSING: ${selector}]` }]
     };
   }
-  hasTemplate(e) {
-    return a(this, B).has(e);
+  hasTemplate(selector) {
+    return this.#templates.has(selector);
   }
-}
-me = new WeakMap(), B = new WeakMap(), W = new WeakSet(), $e = function(e, t = []) {
-  const r = [];
-  for (const n in e)
-    switch (xe(e[n])) {
-      case "string":
-        r.push([[...t, n].join("."), f(this, W, He).call(this, e[n])]);
-        break;
-      case "object":
-        r.push(...f(this, W, $e).call(this, e[n], [...t, n]));
-        break;
-      default:
-        throw new Error(
-          `Expected to find a string or object at ${[...t, n].join(".")}. Got: ${xe(e[n])}`
-        );
+  #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])}`
+          );
+      }
     }
-  return r;
-}, He = function(e) {
-  let t;
-  ((c) => {
-    c[c.Static = 0] = "Static", c[c.ValueName = 1] = "ValueName", c[c.FormatName = 2] = "FormatName", c[c.FormatOptionName = 3] = "FormatOptionName", c[c.FormatOptionValue = 4] = "FormatOptionValue", c[c.FormatOptionEnd = 5] = "FormatOptionEnd";
-  })(t || (t = {}));
-  const r = {
-    segments: []
-  };
-  let n = "", s = 0, o = 0, u, l, w;
-  const $ = () => {
-    u = {
-      type: 1,
-      name: "",
-      formats: []
+    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: []
     };
-  }, R = () => {
-    l = {
-      name: "",
-      options: {}
+    let buffer = "";
+    let i = 0;
+    let loc = 0 /* Static */;
+    let segment;
+    let format;
+    let formatOptionName;
+    const startSegment = () => {
+      segment = {
+        type: 1 /* Variable */,
+        name: "",
+        formats: []
+      };
     };
-  };
-  for (; s < e.length; ) {
-    if (o !== 0 && e[s] === " ") {
-      s++;
-      continue;
-    }
-    switch (o) {
-      case 0:
-        e[s] === "{" && e[s + 1] === "{" ? (o = 1, s += 2, n.length > 0 && (r.segments.push({ type: 0, text: n }), n = ""), $()) : (n += e[s], s++);
-        break;
-      case 1:
-        e[s] === "|" ? (o = 2, s += 1, u.name = n, n = "", R()) : e[s] === "}" && e[s + 1] === "}" ? (o = 0, s += 2, u.name = n, n = "", r.segments.push(u)) : (n += e[s], s++);
-        break;
-      case 2:
-        e[s] === "(" ? (o = 3, s += 1, l.name = n, n = "") : e[s] === "}" && e[s + 1] === "}" ? (o = 0, s += 2, u.formats.push(l), r.segments.push(u)) : (n += e[s], s++);
-        break;
-      case 3:
-        e[s] === ")" || (e[s] === ":" ? (o = 4, s += 1, w = n, n = "") : e[s] === "}" && e[s + 1] === "}" || (n += e[s], s++));
-        break;
-      case 4:
-        e[s] === ")" ? (o = 5, s += 1, l.options[w] = n, n = "", u.formats.push(l)) : e[s] === "," ? (o = 3, s += 1, l.options[w] = n, n = "") : e[s] === "}" && e[s + 1] === "}" || (n += e[s], s++);
-        break;
-      case 5:
-        e[s] === "|" ? (o = 2, s += 1, R()) : e[s] === "}" && e[s + 1] === "}" && (o = 0, s += 2, r.segments.push(u));
-        break;
-    }
-  }
-  return o === 0 && n.length > 0 && r.segments.push({ type: 0, text: n }), r;
-};
-var Z, F, y, ee, te, re, v, b, ze, Ee, ke, Re, Be;
-class _t {
-  constructor(e) {
-    h(this, b);
-    h(this, Z);
-    h(this, F);
-    h(this, y, /* @__PURE__ */ new Map());
-    h(this, ee, []);
-    h(this, te, /* @__PURE__ */ new Map());
-    h(this, re, "auto");
-    h(this, v, Ce(""));
-    d(this, Z, e), d(this, F, e.createLogger("Dolla.i18n")), this.addFormat("number", (t, r, n) => f(this, b, Ee).call(this, Number(r), n)), this.addFormat("datetime", (t, r, n) => f(this, b, ke).call(this, r, n)), this.addFormat("list", (t, r, n) => f(this, b, Re).call(this, r, n)), e.beforeMount(async () => {
-      a(this, y).size > 0 && await this.setLocale(a(this, re));
-    });
+    const startFormat = () => {
+      format = {
+        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;
   }
+}
+class I18n {
+  #dolla;
+  #logger;
+  #translations = /* @__PURE__ */ new Map();
+  #cache = [];
+  #formats = /* @__PURE__ */ new Map();
+  #initialLocale = "auto";
+  #locale = atom("");
   get locale() {
-    return a(this, v);
+    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);
+      }
+    });
   }
   get locales() {
-    return [...a(this, y).keys()];
-  }
-  setup(e) {
-    if (e.translations.forEach((t) => {
-      a(this, y).set(t.locale, new Rt(t, a(this, Z)));
-    }), e.locale && e.locale !== "auto") {
-      if (!e.translations.some((r) => r.locale === e.locale))
-        throw new Error(`Initial locale '${e.locale}' is not registered in the locales array.`);
-      d(this, re, e.locale);
-    }
-    a(this, F).info(
-      `${a(this, y).size} language${a(this, y).size === 1 ? "" : "s"} supported: '${[...a(this, y).keys()].join("', '")}'`
+    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("', '")}'`
     );
   }
-  async setLocale(e) {
-    var n;
-    let t;
-    if (e === "auto") {
-      let s = [];
-      if (typeof navigator < "u") {
-        const o = navigator;
-        ((n = o.languages) == null ? void 0 : n.length) > 0 ? s.push(...o.languages) : o.language ? s.push(o.language) : o.browserLanguage ? s.push(o.browserLanguage) : o.userLanguage && s.push(o.userLanguage);
+  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;
       }
-      for (const o of s)
-        a(this, y).has(o) && (t = o);
-    } else
-      a(this, y).has(e) && (t = e);
-    if (t == null) {
-      const s = a(this, y).keys().next().value;
-      s && (t = s);
-    }
-    if (!t || !a(this, y).has(t))
-      throw new Error(`Locale '${e}' has no translation.`);
-    const r = a(this, y).get(t);
+    }
+    if (realName == null) {
+      const firstLanguage = this.#translations.keys().next().value;
+      if (firstLanguage) {
+        realName = firstLanguage;
+      }
+    }
+    if (!realName || !this.#translations.has(realName)) {
+      throw new Error(`Locale '${name}' has no translation.`);
+    }
+    const translation = this.#translations.get(realName);
     try {
-      await r.load(), d(this, ee, []), a(this, v).value = t, a(this, F).info("set language to " + t);
-    } catch (s) {
-      s instanceof Error && a(this, F).crash(s);
+      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);
+      }
     }
   }
   /**
@@ -769,18 +1085,71 @@ class _t {
      * @example
      * const $value = t("your.key.here", { count: 5 });
      */
-  t(e, t) {
-    if (this === void 0)
+  t(selector, options) {
+    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 C(() => {
-      const r = {};
-      for (const n in t)
-        r[n] = E(t[n]);
-      return f(this, b, ze).call(this, E(a(this, v)), e, r);
+    }
+    return compose(() => {
+      const values = {};
+      for (const key in options) {
+        values[key] = get(options[key]);
+      }
+      return this.#getValue(get(this.#locale), selector, values);
     });
   }
+  #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.
    *
@@ -795,8 +1164,8 @@ class _t {
    *
    * t("greeting", {name: "world"}); // State<"Hello, WORLD!">
    */
-  addFormat(e, t) {
-    a(this, te).set(e, t);
+  addFormat(name, callback) {
+    this.#formats.set(name, callback);
   }
   /**
    * Creates an `Intl.Collator` configured for the current locale.
@@ -804,16 +1173,22 @@ class _t {
    *
    * @see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/Collator/Collator#options
    */
-  collator(e) {
-    return new Intl.Collator(a(this, v).value, e);
+  collator(options) {
+    return new Intl.Collator(this.#locale.value, options);
   }
   /**
    * 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(e, t) {
-    return C(() => (E(a(this, v)), f(this, b, Ee).call(this, E(e), t)));
+  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);
   }
   /**
    * Formats a date for the current locale. Uses `Intl.DateTimeFormat` under the hood.
@@ -824,8 +1199,14 @@ class _t {
    * const date = new Date();
    * const $formatted = Dolla.i18n.dateTime(date, { dateFormat: "short" });
    */
-  dateTime(e, t) {
-    return C(() => (E(a(this, v)), f(this, b, ke).call(this, E(e), t)));
+  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);
   }
   /**
    * Formats a list for the current locale. Uses `Intl.ListFormat` under the hood.
@@ -836,69 +1217,41 @@ class _t {
    * const list = new Date();
    * const $formatted = Dolla.i18n.list(list, {  });
    */
-  list(e, t) {
-    return C(() => (E(a(this, v)), f(this, b, Re).call(this, E(e), t)));
+  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];
+      }
+    }
   }
 }
-Z = new WeakMap(), F = new WeakMap(), y = new WeakMap(), ee = new WeakMap(), te = new WeakMap(), re = new WeakMap(), v = new WeakMap(), b = new WeakSet(), ze = function(e, t, r) {
-  var l;
-  const n = f(this, b, Be).call(this, t, r);
-  if (n) return n;
-  const s = a(this, y).get(e);
-  if (r.context != null && (t += "_" + r.context), r.count != null)
-    if (r.ordinal) {
-      const w = `${t}_ordinal_(=${r.count})`;
-      s.hasTemplate(w) ? t = w : t += "_ordinal_" + new Intl.PluralRules(e, { type: "ordinal" }).select(r.count);
+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];
     } else {
-      const w = `${t}_(=${r.count})`;
-      s.hasTemplate(w) ? t = w : t += "_" + new Intl.PluralRules(e).select(r.count);
-    }
-  const o = s.getTemplate(t);
-  let u = "";
-  for (const w of o.segments)
-    if (w.type === 0)
-      u += w.text;
-    else if (w.type === 1) {
-      let $ = St(r, w.name);
-      const R = ((l = r.formatOverrides) == null ? void 0 : l[w.name]) ?? [...w.formats];
-      w.name === "count" && R.length === 0 && R.push({ name: "number", options: {} });
-      for (const c of R) {
-        const T = a(this, te).get(c.name);
-        if (T == null) {
-          const _ = new Error(
-            `Failed to load format '${c.name}' when processing '${t}', template: ${o}`
-          );
-          throw a(this, F).crash(_), _;
-        }
-        $ = T(e, $, c.options);
-      }
-      u += $;
-    }
-  return u;
-}, Ee = function(e, t) {
-  return new Intl.NumberFormat(a(this, v).value, t).format(e);
-}, ke = function(e, t) {
-  return new Intl.DateTimeFormat(a(this, v).value, t).format(k(e) ? new Date(e) : e);
-}, Re = function(e, t) {
-  return new Intl.ListFormat(a(this, v).value, t).format(e);
-}, // relativeTime(): State<string> {
-// }
-Be = function(e, t) {
-  for (const r of a(this, ee))
-    if (r[0] === e && Ze(r[1], t))
-      return r[2];
-};
-function St(i, e) {
-  const t = String(e).split(/[\.\[\]]/).filter((n) => n.trim() !== "");
-  let r = i;
-  for (; t.length > 0; ) {
-    const n = t.shift();
-    r != null ? r = r[n] : r = void 0;
-  }
-  return r;
+      value = void 0;
+    }
+  }
+  return value;
 }
-function Mt(i) {
-  return Te`
+
+function DefaultCrashView(props) {
+  return html`
     <div
       style=${{
     backgroundColor: "#880000",
@@ -911,8 +1264,8 @@ function Mt(i) {
     >
       <h1 style=${{ marginBottom: "0.5rem" }}>The app has crashed</h1>
       <p style=${{ marginBottom: "0.25rem" }}>
-        <span style=${{ fontFamily: "monospace" }}>${i.loggerName}</span>
-        ${et(i.uid, Te`<span style=${{ fontFamily: "monospace", opacity: 0.5 }}> [uid: ${i.uid}]</span>`)}
+        <span style=${{ fontFamily: "monospace" }}>${props.loggerName}</span>
+        ${cond(props.uid, html`<span style=${{ fontFamily: "monospace", opacity: 0.5 }}> [uid: ${props.uid}]</span>`)}
         ${" "}says:
       </p>
       <blockquote
@@ -935,290 +1288,276 @@ function Mt(i) {
     fontWeight: "bold"
   }}
         >
-          ${i.error.name}
+          ${props.error.name}
         </span>
-        ${i.error.message}
+        ${props.error.message}
       </blockquote>
 
       <p>Please see the browser console for details.</p>
     </div>
   `;
 }
-var L, se, O, q, ne, K, ae, ie, oe, le, U, g, j, we;
-class xt {
+
+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 = [];
   constructor() {
-    // TODO: Take these off the global Dolla object.
-    p(this, "http");
-    p(this, "i18n");
-    h(this, L, !1);
-    h(this, se, "production");
-    h(this, O);
-    h(this, q);
-    h(this, ne, Mt);
-    h(this, K);
-    h(this, ae, []);
-    h(this, ie, []);
-    h(this, oe, []);
-    h(this, le, []);
-    h(this, U, {
-      root: this,
-      data: {},
-      emitter: new tt(),
-      stores: /* @__PURE__ */ new Map(),
-      viewName: "Dolla"
-    });
-    h(this, g, {
-      info: "development",
-      log: "development",
-      warn: "development",
-      error: !0
-    });
-    h(this, j, Ne("*,-Dolla.*"));
-    // Registration functions for modules.
-    // All modules will be registered before mount.
-    h(this, we, []);
-    this.http = new bt(), this.i18n = new _t(this);
+    this.http = new HTTP();
+    this.i18n = new I18n(this);
   }
   /**
    * True when the app is connected to a DOM node and displayed to the user.
    */
   get isMounted() {
-    return a(this, L);
+    return this.#isMounted;
   }
   /**
    * 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 a(this, se);
+    return this.#env;
   }
   /**
    * 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(e) {
-    d(this, se, e);
+  setEnv(value) {
+    this.#env = value;
   }
   /**
    * 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(e) {
-    d(this, ne, e);
+  setCrashView(view) {
+    this.#crashView = view;
   }
   /**
    * Returns the HTMLElement Dolla is mounted to. This will return undefined until Dolla.mount() is called.
    */
   getRootElement() {
-    return a(this, O);
+    return this.#rootElement;
   }
   /**
    * Returns the top level view Dolla is rendering inside the root element. This will return undefined until Dolla.mount() is called.
    */
   getRootView() {
-    return a(this, q);
-  }
-  provide(e, t) {
-    const r = new rt(e, t);
-    if (r.attach(a(this, U)))
-      return r.value;
-    {
-      let s = e.name ? `'${e.name}'` : "this store";
-      return console.warn(`An instance of ${s} was already attached to this context.`), this.get(e);
+    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;
     }
   }
   /**
    * Gets the nearest instance of a store. Throws an error if the store isn't provided higher in the tree.
    */
-  get(e) {
-    if (Q(e)) {
-      const t = a(this, U).stores.get(e);
-      if (t == null)
-        throw new Pe("Store not found on this context.");
-      return t.value;
-    } else
-      throw new Pe("Invalid store.");
-  }
-  async mount(e, t) {
-    if (a(this, L))
-      throw new Error("Dolla is already mounted.");
-    if (k(e)) {
-      const s = document.querySelector(e);
-      Fe(HTMLElement, s, `Selector '${e}' did not match any element.`), d(this, O, s);
-    } else
-      Fe(HTMLElement, e, "Expected an HTML element or a selector string. Got type: %t, value: %v"), d(this, O, e);
-    ge(t) && d(this, K, t);
-    const r = ge(t) ? De : t, n = st(r);
-    d(this, q, this.constructView(n.type, n.props)), await Promise.all(a(this, we).map((s) => s())), ge(t) && await ht(t, this), await Promise.all(a(this, ae).map((s) => s())), a(this, q).mount(a(this, O)), d(this, L, !0);
-    for (const s of a(this, U).stores.values())
-      s.handleMount();
-    for (const s of a(this, ie))
-      s();
+  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();
+    }
   }
   async unmount() {
-    var e;
-    if (a(this, L)) {
-      await Promise.all(a(this, oe).map((t) => t())), (e = a(this, q)) == null || e.unmount(!1), a(this, K) && await ut(a(this, K)), d(this, L, !1);
-      for (const t of a(this, le))
-        t();
+    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();
     }
   }
   /**
    * 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(e) {
-    a(this, ae).push(e);
+  beforeMount(callback) {
+    this.#beforeMountCallbacks.push(callback);
   }
   /**
    * Registers a `callback` to run after the app is mounted.
    */
-  onMount(e) {
-    a(this, ie).push(e);
+  onMount(callback) {
+    this.#onMountCallbacks.push(callback);
   }
   /**
    * 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(e) {
-    a(this, oe).push(e);
+  beforeUnmount(callback) {
+    this.#beforeUnmountCallbacks.push(callback);
   }
   /**
    * Registers a `callback` to run after the app is unmounted.
    */
-  onUnmount(e) {
-    a(this, le).push(e);
+  onUnmount(callback) {
+    this.#onUnmountCallbacks.push(callback);
   }
   /**
    * Update log type toggles. Values that are not passed will remain unchanged.
    */
-  setLoggles(e) {
-    for (const t in e) {
-      const r = e[t];
-      r && (a(this, g)[t] = r);
+  setLoggles(options) {
+    for (const key in options) {
+      const value = options[key];
+      if (value) {
+        this.#loggles[key] = value;
+      }
     }
   }
-  setLogFilter(e) {
-    d(this, j, Ne(e));
-  }
-  createLogger(e, t) {
-    const r = (t == null ? void 0 : t.console) ?? Tt(), n = this;
+  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`
+        );
+      }
+    };
     return {
-      setName(s) {
-        return e = s, this;
+      setName(newName) {
+        name = newName;
+        return this;
       },
       get info() {
-        var s;
-        if (a(n, g).info === !1 || k(a(n, g).info) && a(n, g).info !== n.getEnv() || !a(s = n, j).call(s, e))
-          return ce;
-        {
-          let o = `%c${e}`;
-          return t != null && t.uid ? o += ` %c[uid: %c${t.uid}%c]` : o += "%c%c%c", r.info.bind(
-            r,
-            o,
-            `color:${he(o)};font-weight:bold`,
-            "color:#777",
-            "color:#aaa",
-            "color:#777"
-          );
-        }
+        return bind("info");
       },
       get log() {
-        var s;
-        if (a(n, g).log === !1 || k(a(n, g).log) && a(n, g).log !== n.getEnv() || !a(s = n, j).call(s, e))
-          return ce;
-        {
-          let o = `%c${e}`;
-          return t != null && t.uid ? o += ` %c[uid: %c${t.uid}%c]` : o += "%c%c%c", r.log.bind(
-            r,
-            o,
-            `color:${he(o)};font-weight:bold`,
-            "color:#777",
-            "color:#aaa",
-            "color:#777"
-          );
-        }
+        return bind("log");
       },
       get warn() {
-        var s;
-        if (a(n, g).warn === !1 || k(a(n, g).warn) && a(n, g).warn !== n.getEnv() || !a(s = n, j).call(s, e))
-          return ce;
-        {
-          let o = `%c${e}`;
-          return t != null && t.uid ? o += ` %c[uid: %c${t.uid}%c]` : o += "%c%c%c", r.warn.bind(
-            r,
-            o,
-            `color:${he(o)};font-weight:bold`,
-            "color:#777",
-            "color:#aaa",
-            "color:#777"
-          );
-        }
+        return bind("warn");
       },
       get error() {
-        var s;
-        if (a(n, g).error === !1 || k(a(n, g).error) && a(n, g).error !== n.getEnv() || !a(s = n, j).call(s, e))
-          return ce;
-        {
-          let o = `%c${e}`;
-          return t != null && t.uid ? o += ` %c[uid: %c${t.uid}%c]` : o += "%c%c%c", r.error.bind(
-            r,
-            o,
-            `color:${he(o)};font-weight:bold`,
-            "color:#777",
-            "color:#aaa",
-            "color:#777"
-          );
-        }
+        return bind("error");
       },
-      crash(s) {
-        n.isMounted && (n.unmount(), n.constructView(a(n, ne), {
-          error: s,
-          loggerName: e,
-          uid: t == null ? void 0 : t.uid
-        }).mount(a(n, O)));
+      crash(error) {
+        if (self.isMounted) {
+          self.unmount();
+          const crashPage = self.constructView(self.#crashView, {
+            error,
+            loggerName: name,
+            uid: options?.uid
+          });
+          crashPage.mount(self.#rootElement);
+        }
       }
     };
   }
   /**
    *
    */
-  constructView(e, t, r = []) {
-    return new nt(a(this, U), e, t, r);
+  constructView(view, props, children = []) {
+    return new View(this.#rootElementContext, view, props, children);
   }
   /**
    *
    */
-  constructMarkup(e) {
-    return at(it(a(this, U), e));
+  constructMarkup(markup) {
+    return groupElements(constructMarkup(this.#rootElementContext, markup));
   }
 }
-L = new WeakMap(), se = new WeakMap(), O = new WeakMap(), q = new WeakMap(), ne = new WeakMap(), K = new WeakMap(), ae = new WeakMap(), ie = new WeakMap(), oe = new WeakMap(), le = new WeakMap(), U = new WeakMap(), g = new WeakMap(), j = new WeakMap(), we = new WeakMap();
-function Tt() {
-  if (typeof window < "u" && window.console)
+function getDefaultConsole() {
+  if (typeof window !== "undefined" && window.console) {
     return window.console;
-  if (typeof global < "u" && global.console)
+  }
+  if (typeof global !== "undefined" && global.console) {
     return global.console;
+  }
 }
-const Le = new xt(), Ot = Le.i18n.t.bind(Le.i18n);
-export {
-  Ce as atom,
-  C as compose,
-  et as cond,
-  st as createMarkup,
-  Lt as createRouter,
-  Ze as deepEqual,
-  Le as default,
-  Ct as effect,
-  E as get,
-  Te as html,
-  Dt as list,
-  It as peek,
-  Vt as portal,
-  Ft as ref,
-  qt as set,
-  Me as shallowEqual,
-  Gt as strictEqual,
-  Ot as t
-};
+
+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 };
 //# sourceMappingURL=index.js.map