@manyducks.co/dolla 1.0.1 → 2.0.0-alpha.0

package/dist/index.js

@@ -0,0 +1,1308 @@
+var yt = Object.defineProperty;
+var et = (r) => {
+  throw TypeError(r);
+};
+var wt = (r, e, t) => e in r ? yt(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var k = (r, e, t) => wt(r, typeof e != "symbol" ? e + "" : e, t), Ie = (r, e, t) => e.has(r) || et("Cannot " + t);
+var s = (r, e, t) => (Ie(r, e, "read from private field"), t ? t.call(r) : e.get(r)), f = (r, e, t) => e.has(r) ? et("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(r) : e.set(r, t), w = (r, e, t, n) => (Ie(r, e, "write to private field"), n ? n.call(r, t) : e.set(r, t), t), P = (r, e, t) => (Ie(r, e, "access private method"), t);
+var tt = (r, e, t, n) => ({
+  set _(i) {
+    w(r, e, i, t);
+  },
+  get _() {
+    return s(r, e, n);
+  }
+});
+import { i as ze, s as Ge, a as bt, d as Be, b as vt, c as Ze, e as H, f as Q, g as ct, h as $t, w as lt, j as Qe, r as Et, k as Lt, l as nt, m as kt, t as St, n as Pt, o as Rt, p as xt, q as rt, u as at, v as Mt, x as Ne, y as Te } from "./fragment-s33qZBzz.js";
+import { F as dn, A as gn, z as pn, C as mn, B as yn } from "./fragment-s33qZBzz.js";
+function ht(r, e) {
+  return e.outlet();
+}
+var K, Ve, T, q;
+class Ot {
+  constructor() {
+    f(this, T);
+    f(this, K, []);
+    f(this, Ve, Nt());
+  }
+  /**
+   * 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 s(this, K).push(e), () => {
+      s(this, K).splice(s(this, K).indexOf(e), 1);
+    };
+  }
+  async get(e, t) {
+    return P(this, T, q).call(this, "get", e, t);
+  }
+  async put(e, t) {
+    return P(this, T, q).call(this, "put", e, t);
+  }
+  async patch(e, t) {
+    return P(this, T, q).call(this, "patch", e, t);
+  }
+  async post(e, t) {
+    return P(this, T, q).call(this, "post", e, t);
+  }
+  async delete(e, t) {
+    return P(this, T, q).call(this, "delete", e, t);
+  }
+  async head(e, t) {
+    return P(this, T, q).call(this, "head", e, t);
+  }
+  async options(e, t) {
+    return P(this, T, q).call(this, "options", e, t);
+  }
+  async trace(e, t) {
+    return P(this, T, q).call(this, "trace", e, t);
+  }
+}
+K = new WeakMap(), Ve = new WeakMap(), T = new WeakSet(), q = async function(e, t, n) {
+  return At({
+    ...n,
+    method: e,
+    uri: t,
+    middleware: s(this, K),
+    fetch: s(this, Ve)
+  });
+};
+function Nt() {
+  if (typeof window < "u" && window.fetch)
+    return window.fetch.bind(window);
+  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 Tt extends Error {
+  constructor(t) {
+    const { status: n, statusText: i, method: a, uri: o } = t, d = `${n} ${i}: Request failed (${a.toUpperCase()} ${o})`;
+    super(d);
+    k(this, "response");
+    this.response = t;
+  }
+}
+async function At(r) {
+  const { headers: e, query: t, fetch: n, middleware: i } = r, a = {
+    method: r.method,
+    uri: r.uri,
+    get sameOrigin() {
+      return !a.uri.startsWith("http");
+    },
+    query: new URLSearchParams(),
+    headers: new Headers(),
+    body: r.body
+  };
+  if (e)
+    if (e instanceof Map || e instanceof Headers)
+      e.forEach((c, h) => {
+        a.headers.set(h, c);
+      });
+    else if (e != null && typeof e == "object" && !Array.isArray(e))
+      for (const c in e) {
+        const h = e[c];
+        h instanceof Date ? a.headers.set(c, h.toISOString()) : h != null && a.headers.set(c, String(h));
+      }
+    else
+      throw new TypeError(`Unknown headers type. Got: ${e}`);
+  if (t)
+    if (t instanceof Map || t instanceof URLSearchParams)
+      t.forEach((c, h) => {
+        a.query.set(h, c);
+      });
+    else if (t != null && typeof t == "object" && !Array.isArray(t))
+      for (const c in t) {
+        const h = t[c];
+        h instanceof Date ? a.query.set(c, h.toISOString()) : h != null && a.query.set(c, String(h));
+      }
+    else
+      throw new TypeError(`Unknown query params type. Got: ${t}`);
+  let o;
+  const d = async () => {
+    const c = a.query.toString(), h = c.length > 0 ? a.uri + "?" + c : a.uri;
+    let y;
+    !a.headers.has("content-type") && ze(a.body) ? (a.headers.set("content-type", "application/json"), y = JSON.stringify(a.body)) : y = a.body;
+    const b = await n(h, {
+      method: a.method,
+      headers: a.headers,
+      body: y
+    }), g = Object.fromEntries(b.headers.entries()), p = g["content-type"];
+    let $;
+    p != null && p.includes("application/json") ? $ = await b.json() : p != null && p.includes("application/x-www-form-urlencoded") ? $ = await b.formData() : $ = await b.text(), o = {
+      method: a.method,
+      uri: a.uri,
+      status: b.status,
+      statusText: b.statusText,
+      headers: g,
+      body: $
+    };
+  };
+  if (i.length > 0) {
+    const c = (h = 0) => {
+      const y = i[h], b = i[h + 1] ? c(h + 1) : d;
+      return async () => y(a, async () => (await b(), o));
+    };
+    await c()();
+  } else
+    await d();
+  if (o.status < 200 || o.status >= 400)
+    throw new Tt(o);
+  return o;
+}
+class jt {
+  constructor(e, t) {
+    k(this, "dolla");
+    k(this, "config");
+    k(this, "strings");
+    this.config = e, this.dolla = t;
+  }
+  async load() {
+    if (this.strings == null) {
+      if (Ze(this.config.fetch)) {
+        const e = await this.config.fetch();
+        if (ze(e))
+          this.strings = e;
+        else
+          throw new Error(`Fetch function did not return an object of language strings: ${e}`);
+      } else if (H(this.config.path)) {
+        const e = await this.dolla.http.get(this.config.path);
+        if (e.status >= 200 && e.status < 300)
+          if (ze(e.body))
+            this.strings = e.body;
+          else
+            throw new Error(
+              `Language path '${this.config.path}' did not return an object of language strings: ${e.body}`
+            );
+        else
+          throw new Error("HTTP request failed.");
+      }
+    }
+    if (this.strings == null)
+      throw new Error("Language could not be loaded.");
+    return this.strings;
+  }
+}
+var we, J, M, ie, be, ve, oe, $e, Fe, ut;
+class Ct {
+  constructor(e) {
+    f(this, Fe);
+    f(this, we);
+    f(this, J);
+    f(this, M, /* @__PURE__ */ new Map());
+    f(this, ie, []);
+    f(this, be, "auto");
+    k(this, "$current");
+    f(this, ve);
+    f(this, oe);
+    f(this, $e);
+    w(this, we, e), w(this, J, e.createLogger("dolla/language"));
+    const [t, n] = Q(), [i, a] = Q();
+    this.$current = t, w(this, ve, n), w(this, oe, i), w(this, $e, a), e.beforeMount(async () => {
+      s(this, M).size > 0 && await this.setLanguage(s(this, be));
+    });
+  }
+  get supportedLanguages() {
+    return [...s(this, M).keys()];
+  }
+  setup(e) {
+    if (e.languages.forEach((t) => {
+      s(this, M).set(t.name, new jt(t, s(this, we)));
+    }), e.initialLanguage && e.initialLanguage !== "auto") {
+      if (!e.languages.some((n) => n.name === e.initialLanguage))
+        throw new Error(`Initial language '${e.initialLanguage}' has no registered translation.`);
+      w(this, be, e.initialLanguage);
+    }
+    s(this, J).info(
+      `${s(this, M).size} language${s(this, M).size === 1 ? "" : "s"} supported: '${[...s(this, M).keys()].join("', '")}'`
+    );
+  }
+  async setLanguage(e) {
+    var i;
+    let t;
+    if (e === "auto") {
+      let a = [];
+      if (typeof navigator == "object") {
+        const o = navigator;
+        ((i = o.languages) == null ? void 0 : i.length) > 0 ? a.push(...o.languages) : o.language ? a.push(o.language) : o.browserLanguage ? a.push(o.browserLanguage) : o.userLanguage && a.push(o.userLanguage);
+      }
+      for (const o of a)
+        s(this, M).has(o) && (t = o);
+    } else
+      s(this, M).has(e) && (t = e);
+    if (t == null) {
+      const a = s(this, M).keys().next().value;
+      a && (t = a);
+    }
+    if (!t || !s(this, M).has(t))
+      throw new Error(`Language '${e}' is not configured for this app.`);
+    const n = s(this, M).get(t);
+    try {
+      const a = await n.load();
+      s(this, $e).call(this, a), s(this, ve).call(this, t), s(this, J).info("set language to " + t);
+    } catch (a) {
+      a instanceof Error && s(this, J).crash(a);
+    }
+  }
+  /**
+   * Returns a Signal containing the value at `key`.
+  
+   * @param key - Key to the translated value.
+   * @param values - A map of {{placeholder}} names and the values to replace them with.
+   */
+  t(e, t) {
+    if (this === void 0)
+      throw new Error(
+        `The 't' function cannot be destructured. If you need a standalone version you can import it from the package like so: 'import { t } from "@manyducks.co/dolla"'`
+      );
+    if (!this.$current.get())
+      return Ut;
+    const n = P(this, Fe, ut).call(this, e, t);
+    if (n)
+      return n;
+    if (t) {
+      const a = {};
+      for (const [d, c] of Object.entries(t))
+        bt(c) && (a[d] = c);
+      const o = Object.entries(a);
+      if (o.length > 0) {
+        const d = o.map((h) => h[1]), c = Be([s(this, oe), ...d], (h, ...y) => {
+          const b = y.map(($, N) => o[N]), g = {
+            ...t
+          };
+          for (let $ = 0; $ < b.length; $++) {
+            const N = b[$][0];
+            g[N] = y[$];
+          }
+          const p = it(h, e) || `[NO TRANSLATION: ${e}]`;
+          return st(p, g);
+        });
+        return s(this, ie).push([e, t, c]), c;
+      }
+    }
+    const i = Be([s(this, oe)], (a) => {
+      let o = it(a, e) || `[NO TRANSLATION: ${e}]`;
+      return t && (o = st(o, t)), o;
+    });
+    return s(this, ie).push([e, t, i]), i;
+  }
+}
+we = new WeakMap(), J = new WeakMap(), M = new WeakMap(), ie = new WeakMap(), be = new WeakMap(), ve = new WeakMap(), oe = new WeakMap(), $e = new WeakMap(), Fe = new WeakSet(), ut = function(e, t) {
+  for (const n of s(this, ie))
+    if (n[0] === e && vt(n[1], t))
+      return n[2];
+};
+const Ut = Ge("[NO LANGUAGE SET]");
+function st(r, e) {
+  for (const t in e)
+    r = r.replace(`{{${t}}}`, String(e[t]));
+  return r;
+}
+function it(r, e) {
+  const t = String(e).split(/[\.\[\]]/).filter((i) => i.trim() !== "");
+  let n = r;
+  for (; t.length > 0; ) {
+    const i = t.shift();
+    n != null ? n = n[i] : n = void 0;
+  }
+  return n;
+}
+var Y, Ee, V, F, ce, _, le, Ae;
+class qt {
+  constructor(e) {
+    f(this, le);
+    f(this, Y);
+    f(this, Ee);
+    // Keyed updates ensure only the most recent callback queued with a certain key
+    // will be called, keeping DOM operations to a minimum.
+    f(this, V, /* @__PURE__ */ new Map());
+    // All unkeyed updates are run on every batch.
+    f(this, F, []);
+    f(this, ce, []);
+    f(this, _, !1);
+    w(this, Y, e), w(this, Ee, e.createLogger("dolla/render"));
+  }
+  /**
+   * Queues a callback to run in the next render batch.
+   * Running your DOM mutations in update callbacks reduces layout thrashing.
+   * Returns a Promise that resolves once the callback has run.
+   */
+  update(e, t) {
+    return new Promise((n) => {
+      t ? s(this, V).set(t, () => {
+        e(), n();
+      }) : s(this, F).push(() => {
+        e(), n();
+      }), !s(this, _) && s(this, Y).isMounted && (w(this, _, !0), P(this, le, Ae).call(this));
+    });
+  }
+  /**
+   * Queues a callback that reads DOM information to run after the next render batch,
+   * ensuring all writes have been performed before reading.
+   * Returns a Promise that resolves once the callback has run.
+   */
+  async read(e) {
+    return new Promise((t) => {
+      s(this, ce).push(() => {
+        e(), t();
+      }), !s(this, _) && s(this, Y).isMounted && (w(this, _, !0), P(this, le, Ae).call(this));
+    });
+  }
+}
+Y = new WeakMap(), Ee = new WeakMap(), V = new WeakMap(), F = new WeakMap(), ce = new WeakMap(), _ = new WeakMap(), le = new WeakSet(), Ae = function() {
+  const e = s(this, V).size + s(this, F).length;
+  if ((!s(this, Y).isMounted || e === 0) && w(this, _, !1), !s(this, _)) {
+    for (const t of s(this, ce))
+      t();
+    w(this, ce, []);
+    return;
+  }
+  requestAnimationFrame(() => {
+    s(this, Ee).info(`Batching ${s(this, V).size + s(this, F).length} queued DOM update(s).`);
+    for (const t of s(this, V).values())
+      t();
+    s(this, V).clear();
+    for (const t of s(this, F))
+      t();
+    w(this, F, []), P(this, le, Ae).call(this);
+  });
+};
+function de() {
+  return de = Object.assign || function(r) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var n in t)
+        Object.prototype.hasOwnProperty.call(t, n) && (r[n] = t[n]);
+    }
+    return r;
+  }, de.apply(this, arguments);
+}
+var C;
+(function(r) {
+  r.Pop = "POP", r.Push = "PUSH", r.Replace = "REPLACE";
+})(C || (C = {}));
+var qe = process.env.NODE_ENV !== "production" ? function(r) {
+  return Object.freeze(r);
+} : function(r) {
+  return r;
+};
+function je(r, e) {
+  if (!r) {
+    typeof console < "u" && console.warn(e);
+    try {
+      throw new Error(e);
+    } catch {
+    }
+  }
+}
+var _e = "beforeunload", _t = "hashchange", ft = "popstate";
+function Dt(r) {
+  r === void 0 && (r = {});
+  var e = r, t = e.window, n = t === void 0 ? document.defaultView : t, i = n.history;
+  function a() {
+    var m = n.location, l = m.pathname, u = m.search, v = m.hash, E = i.state || {};
+    return [E.idx, qe({
+      pathname: l,
+      search: u,
+      hash: v,
+      state: E.usr || null,
+      key: E.key || "default"
+    })];
+  }
+  var o = null;
+  function d() {
+    if (o)
+      p.call(o), o = null;
+    else {
+      var m = C.Pop, l = a(), u = l[0], v = l[1];
+      if (p.length)
+        if (u != null) {
+          var E = y - u;
+          E && (o = {
+            action: m,
+            location: v,
+            retry: function() {
+              D(E * -1);
+            }
+          }, D(E));
+        } else
+          process.env.NODE_ENV !== "production" && je(
+            !1,
+            // TODO: Write up a doc that explains our blocking strategy in
+            // detail and link to it here so people can understand better what
+            // is going on and how to avoid it.
+            "You are trying to block a POP navigation to a location that was not created by the history library. The block will fail silently in production, but in general you should do all navigation with the history library (instead of using window.history.pushState directly) to avoid this situation."
+          );
+      else
+        re(m);
+    }
+  }
+  n.addEventListener(ft, d);
+  var c = C.Pop, h = a(), y = h[0], b = h[1], g = He(), p = He();
+  y == null && (y = 0, i.replaceState(de({}, i.state, {
+    idx: y
+  }), ""));
+  function $(m) {
+    return typeof m == "string" ? m : Ce(m);
+  }
+  function N(m, l) {
+    return l === void 0 && (l = null), qe(de({
+      pathname: b.pathname,
+      hash: "",
+      search: ""
+    }, typeof m == "string" ? Ke(m) : m, {
+      state: l,
+      key: dt()
+    }));
+  }
+  function ge(m, l) {
+    return [{
+      usr: m.state,
+      key: m.key,
+      idx: l
+    }, $(m)];
+  }
+  function pe(m, l, u) {
+    return !p.length || (p.call({
+      action: m,
+      location: l,
+      retry: u
+    }), !1);
+  }
+  function re(m) {
+    c = m;
+    var l = a();
+    y = l[0], b = l[1], g.call({
+      action: c,
+      location: b
+    });
+  }
+  function ae(m, l) {
+    var u = C.Push, v = N(m, l);
+    function E() {
+      ae(m, l);
+    }
+    if (pe(u, v, E)) {
+      var R = ge(v, y + 1), O = R[0], A = R[1];
+      try {
+        i.pushState(O, "", A);
+      } catch {
+        n.location.assign(A);
+      }
+      re(u);
+    }
+  }
+  function me(m, l) {
+    var u = C.Replace, v = N(m, l);
+    function E() {
+      me(m, l);
+    }
+    if (pe(u, v, E)) {
+      var R = ge(v, y), O = R[0], A = R[1];
+      i.replaceState(O, "", A), re(u);
+    }
+  }
+  function D(m) {
+    i.go(m);
+  }
+  var B = {
+    get action() {
+      return c;
+    },
+    get location() {
+      return b;
+    },
+    createHref: $,
+    push: ae,
+    replace: me,
+    go: D,
+    back: function() {
+      D(-1);
+    },
+    forward: function() {
+      D(1);
+    },
+    listen: function(l) {
+      return g.push(l);
+    },
+    block: function(l) {
+      var u = p.push(l);
+      return p.length === 1 && n.addEventListener(_e, De), function() {
+        u(), p.length || n.removeEventListener(_e, De);
+      };
+    }
+  };
+  return B;
+}
+function Ht(r) {
+  r === void 0 && (r = {});
+  var e = r, t = e.window, n = t === void 0 ? document.defaultView : t, i = n.history;
+  function a() {
+    var l = Ke(n.location.hash.substr(1)), u = l.pathname, v = u === void 0 ? "/" : u, E = l.search, R = E === void 0 ? "" : E, O = l.hash, A = O === void 0 ? "" : O, U = i.state || {};
+    return [U.idx, qe({
+      pathname: v,
+      search: R,
+      hash: A,
+      state: U.usr || null,
+      key: U.key || "default"
+    })];
+  }
+  var o = null;
+  function d() {
+    if (o)
+      p.call(o), o = null;
+    else {
+      var l = C.Pop, u = a(), v = u[0], E = u[1];
+      if (p.length)
+        if (v != null) {
+          var R = y - v;
+          R && (o = {
+            action: l,
+            location: E,
+            retry: function() {
+              B(R * -1);
+            }
+          }, B(R));
+        } else
+          process.env.NODE_ENV !== "production" && je(
+            !1,
+            // TODO: Write up a doc that explains our blocking strategy in
+            // detail and link to it here so people can understand better
+            // what is going on and how to avoid it.
+            "You are trying to block a POP navigation to a location that was not created by the history library. The block will fail silently in production, but in general you should do all navigation with the history library (instead of using window.history.pushState directly) to avoid this situation."
+          );
+      else
+        ae(l);
+    }
+  }
+  n.addEventListener(ft, d), n.addEventListener(_t, function() {
+    var l = a(), u = l[1];
+    Ce(u) !== Ce(b) && d();
+  });
+  var c = C.Pop, h = a(), y = h[0], b = h[1], g = He(), p = He();
+  y == null && (y = 0, i.replaceState(de({}, i.state, {
+    idx: y
+  }), ""));
+  function $() {
+    var l = document.querySelector("base"), u = "";
+    if (l && l.getAttribute("href")) {
+      var v = n.location.href, E = v.indexOf("#");
+      u = E === -1 ? v : v.slice(0, E);
+    }
+    return u;
+  }
+  function N(l) {
+    return $() + "#" + (typeof l == "string" ? l : Ce(l));
+  }
+  function ge(l, u) {
+    return u === void 0 && (u = null), qe(de({
+      pathname: b.pathname,
+      hash: "",
+      search: ""
+    }, typeof l == "string" ? Ke(l) : l, {
+      state: u,
+      key: dt()
+    }));
+  }
+  function pe(l, u) {
+    return [{
+      usr: l.state,
+      key: l.key,
+      idx: u
+    }, N(l)];
+  }
+  function re(l, u, v) {
+    return !p.length || (p.call({
+      action: l,
+      location: u,
+      retry: v
+    }), !1);
+  }
+  function ae(l) {
+    c = l;
+    var u = a();
+    y = u[0], b = u[1], g.call({
+      action: c,
+      location: b
+    });
+  }
+  function me(l, u) {
+    var v = C.Push, E = ge(l, u);
+    function R() {
+      me(l, u);
+    }
+    if (process.env.NODE_ENV !== "production" && je(E.pathname.charAt(0) === "/", "Relative pathnames are not supported in hash history.push(" + JSON.stringify(l) + ")"), re(v, E, R)) {
+      var O = pe(E, y + 1), A = O[0], U = O[1];
+      try {
+        i.pushState(A, "", U);
+      } catch {
+        n.location.assign(U);
+      }
+      ae(v);
+    }
+  }
+  function D(l, u) {
+    var v = C.Replace, E = ge(l, u);
+    function R() {
+      D(l, u);
+    }
+    if (process.env.NODE_ENV !== "production" && je(E.pathname.charAt(0) === "/", "Relative pathnames are not supported in hash history.replace(" + JSON.stringify(l) + ")"), re(v, E, R)) {
+      var O = pe(E, y), A = O[0], U = O[1];
+      i.replaceState(A, "", U), ae(v);
+    }
+  }
+  function B(l) {
+    i.go(l);
+  }
+  var m = {
+    get action() {
+      return c;
+    },
+    get location() {
+      return b;
+    },
+    createHref: N,
+    push: me,
+    replace: D,
+    go: B,
+    back: function() {
+      B(-1);
+    },
+    forward: function() {
+      B(1);
+    },
+    listen: function(u) {
+      return g.push(u);
+    },
+    block: function(u) {
+      var v = p.push(u);
+      return p.length === 1 && n.addEventListener(_e, De), function() {
+        v(), p.length || n.removeEventListener(_e, De);
+      };
+    }
+  };
+  return m;
+}
+function De(r) {
+  r.preventDefault(), r.returnValue = "";
+}
+function He() {
+  var r = [];
+  return {
+    get length() {
+      return r.length;
+    },
+    push: function(t) {
+      return r.push(t), function() {
+        r = r.filter(function(n) {
+          return n !== t;
+        });
+      };
+    },
+    call: function(t) {
+      r.forEach(function(n) {
+        return n && n(t);
+      });
+    }
+  };
+}
+function dt() {
+  return Math.random().toString(36).substr(2, 8);
+}
+function Ce(r) {
+  var e = r.pathname, t = e === void 0 ? "/" : e, n = r.search, i = n === void 0 ? "" : n, a = r.hash, o = a === void 0 ? "" : a;
+  return i && i !== "?" && (t += i.charAt(0) === "?" ? i : "?" + i), o && o !== "#" && (t += o.charAt(0) === "#" ? o : "#" + o), t;
+}
+function Ke(r) {
+  var e = {};
+  if (r) {
+    var t = r.indexOf("#");
+    t >= 0 && (e.hash = r.substr(t), r = r.substr(0, t));
+    var n = r.indexOf("?");
+    n >= 0 && (e.search = r.substr(n), r = r.substr(0, n)), r && (e.pathname = r);
+  }
+  return e;
+}
+function ye(r) {
+  return ct(r, "Expected `path` to be a string. Got type: %t, value: %v"), r.split("/").map((e) => e.trim()).filter((e) => e !== "");
+}
+function se(r) {
+  var t;
+  $t(
+    (n) => Ze(n == null ? void 0 : n.toString),
+    r,
+    "Expected `parts` to be an array of objects with a .toString() method. Got type: %t, value: %v"
+  ), r = r.filter((n) => n).flatMap(String);
+  let e = (t = r.shift()) == null ? void 0 : t.toString();
+  if (e) {
+    for (const n of r.map((i) => i.toString()))
+      n.startsWith(".") ? e = Ue(e, n) : e[e.length - 1] !== "/" ? n[0] !== "/" ? e += "/" + n : e += n : n[0] === "/" ? e += n.slice(1) : e += n;
+    e && e !== "/" && e.endsWith("/") && (e = e.slice(0, e.length - 1));
+  }
+  return e ?? "";
+}
+function Ue(r, e) {
+  if (ct(r, "Expected `base` to be a string. Got type: %t, value: %v"), e == null && (e = r, r = ""), e.startsWith("/"))
+    return e;
+  let t = r;
+  for (; ; )
+    if (e.startsWith("..")) {
+      for (let n = t.length; n > 0; --n)
+        if (t[n] === "/" || n === 0) {
+          t = t.slice(0, n), e = e.replace(/^\.\.\/?/, "");
+          break;
+        }
+    } else if (e.startsWith("."))
+      e = e.replace(/^\.\/?/, "");
+    else
+      break;
+  return se([t, e]);
+}
+function Je(r) {
+  if (!r) return {};
+  r.startsWith("?") && (r = r.slice(1));
+  const e = r.split("&").filter((t) => t.trim() !== "").map((t) => {
+    const [n, i] = t.split("=").map((a) => a.trim());
+    return i.toLowerCase() === "true" ? [n, !0] : i.toLowerCase() === "false" ? [n, !1] : isNaN(Number(i)) ? [n, i] : [n, Number(i)];
+  });
+  return Object.fromEntries(e);
+}
+function ot(r, e, t = {}) {
+  var o;
+  const [n, i] = e.split("?"), a = ye(n);
+  e: for (const d of r) {
+    const { fragments: c } = d;
+    if (!(((o = c[c.length - 1]) == null ? void 0 : o.type) === 3) && c.length !== a.length || t.willMatch && !t.willMatch(d))
+      continue e;
+    const y = [];
+    t: for (let g = 0; g < c.length; g++) {
+      const p = a[g], $ = c[g];
+      if (p == null && $.type !== 3)
+        continue e;
+      switch ($.type) {
+        case 1:
+          if ($.name.toLowerCase() === p.toLowerCase()) {
+            y.push($);
+            break;
+          } else
+            continue e;
+        case 2:
+          y.push({ ...$, value: p });
+          break;
+        case 3:
+          y.push({ ...$, value: a.slice(g).join("/") });
+          break t;
+        case 4:
+          if (isNaN(Number(p)))
+            continue e;
+          y.push({ ...$, value: Number(p) });
+          break;
+        default:
+          throw new Error(`Unknown fragment type: ${$.type}`);
+      }
+    }
+    const b = /* @__PURE__ */ Object.create(null);
+    for (const g of y)
+      g.type === 2 && (b[g.name] = decodeURIComponent(g.value)), g.type === 4 && (b[g.name] = g.value), g.type === 3 && (b.wildcard = "/" + decodeURIComponent(g.value));
+    return {
+      path: "/" + y.map((g) => g.value).join("/"),
+      pattern: "/" + c.map((g) => g.type === 2 ? `{${g.name}}` : g.type === 4 ? `{#${g.name}}` : g.name).join("/"),
+      params: b,
+      query: Je(i),
+      meta: d.meta
+    };
+  }
+}
+function Vt(r) {
+  const e = [], t = [], n = [], i = [];
+  for (const o of r) {
+    const { fragments: d } = o;
+    d.some(
+      (c) => c.type === 3
+      /* Wildcard */
+    ) ? i.push(o) : d.some(
+      (c) => c.type === 4
+      /* NumericParam */
+    ) ? t.push(o) : d.some(
+      (c) => c.type === 2
+      /* Param */
+    ) ? n.push(o) : e.push(o);
+  }
+  const a = (o, d) => o.fragments.length > d.fragments.length ? -1 : 1;
+  return e.sort(a), t.sort(a), n.sort(a), i.sort(a), [...e, ...t, ...n, ...i];
+}
+function Ft(r) {
+  const e = ye(r), t = [];
+  for (let n = 0; n < e.length; n++) {
+    const i = e[n];
+    if (i === "*") {
+      if (n !== e.length - 1)
+        throw new Error(`Wildcard must be at the end of a pattern. Received: ${r}`);
+      t.push({
+        type: 3,
+        name: "*",
+        value: null
+      });
+    } else i.at(0) === "{" && i.at(-1) === "}" ? t.push({
+      type: i[1] === "#" ? 4 : 2,
+      name: i[1] === "#" ? i.slice(2, -1) : i.slice(1, -1),
+      value: null
+    }) : t.push({
+      type: 1,
+      name: i,
+      value: i
+    });
+  }
+  return t;
+}
+var gt = /* @__PURE__ */ ((r) => (r.hash = "hash", r.path = "path", r))(gt || {}), Le, j, X, S, We, W, ke, Z, ee, he, ue, fe, Se, G, Ye, Xe;
+class pt {
+  constructor(e, t) {
+    f(this, G);
+    f(this, Le);
+    f(this, j);
+    f(this, X);
+    f(this, S, Dt());
+    f(this, We, 0);
+    f(this, W, []);
+    f(this, ke);
+    f(this, Z, []);
+    f(this, ee);
+    /**
+     * The currently matched route pattern, if any.
+     */
+    k(this, "$pattern");
+    f(this, he);
+    /**
+     * The current URL path.
+     */
+    k(this, "$path");
+    f(this, ue);
+    /**
+     * The current named path params.
+     */
+    k(this, "$params");
+    f(this, fe);
+    /**
+     * The current query params. Changes to this object will be reflected in the URL.
+     */
+    k(this, "$query");
+    f(this, Se);
+    w(this, Le, e), w(this, j, e.createLogger("dolla/router")), w(this, X, t);
+    const [n, i] = Q(null), [a, o] = Q(""), [d, c] = Q({}), [h, y] = Q(Je(window.location.search));
+    this.$pattern = n, w(this, he, i), this.$path = a, w(this, ue, o), this.$params = d, w(this, fe, c), this.$query = h, w(this, Se, y), e.beforeMount(() => {
+      w(this, ee, lt([h], (g) => {
+        const p = new URLSearchParams();
+        for (const N in g)
+          p.set(N, String(g[N]));
+        const $ = "?" + p.toString();
+        $ != s(this, S).location.search && s(this, S).replace({
+          pathname: s(this, S).location.pathname,
+          search: $
+        });
+      }));
+      const b = (g) => {
+        P(this, G, Xe).call(this, g);
+      };
+      s(this, S).listen(b), P(this, G, Xe).call(this, s(this, S)), s(this, j).info("Intercepting <a> clicks within root element:", s(this, X).rootElement), mt(s(this, X).rootElement, (g) => {
+        let p = g.getAttribute("href");
+        s(this, j).info("Intercepted link click", g, p), /^https?:\/\/|^\//.test(p) || (p = se([s(this, S).location.pathname, p])), s(this, S).push(p);
+      });
+    }), e.onUnmount(() => {
+      s(this, ee) && (s(this, ee).call(this), w(this, ee, void 0));
+    });
+  }
+  setup(e) {
+    e.style === "hash" && w(this, S, Ht()), w(this, Z, Vt(
+      e.routes.flatMap((t) => P(this, G, Ye).call(this, t)).map((t) => ({
+        pattern: t.pattern,
+        meta: t.meta,
+        fragments: Ft(t.pattern)
+      }))
+    ));
+    for (const t of s(this, Z))
+      if (t.meta.redirect) {
+        let n;
+        if (!Ze(t.meta.redirect)) if (H(t.meta.redirect)) {
+          if (n = t.meta.redirect, !ot(s(this, Z), n, {
+            willMatch(a) {
+              return a !== t;
+            }
+          }))
+            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}`);
+      }
+  }
+  /**
+   * Navigates to another route.
+   *
+   * @example
+   * navigate("/login"); // navigate to `/login`
+   * navigate(["/users", 215], { replace: true }); // replace current history entry with `/users/215`
+   */
+  go(e, t = {}) {
+    let n;
+    Array.isArray(e) ? n = se(e) : n = e.toString(), n = Ue(s(this, S).location.pathname, n), t.preserveQuery && (n += s(this, S).location.search), t.replace ? s(this, S).replace(n) : s(this, S).push(n);
+  }
+  /**
+   * Navigate backward. Pass a number of steps to hit the back button that many times.
+   */
+  back(e = 1) {
+    s(this, S).go(-e);
+  }
+  /**
+   * Navigate forward. Pass a number of steps to hit the forward button that many times.
+   */
+  forward(e = 1) {
+    s(this, S).go(e);
+  }
+}
+Le = new WeakMap(), j = new WeakMap(), X = new WeakMap(), S = new WeakMap(), We = new WeakMap(), W = new WeakMap(), ke = new WeakMap(), Z = new WeakMap(), ee = new WeakMap(), he = new WeakMap(), ue = new WeakMap(), fe = new WeakMap(), Se = new WeakMap(), G = new WeakSet(), /**
+ * 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.
+ */
+Ye = function(e, t = [], n = []) {
+  if (!(typeof e == "object" && !Array.isArray(e)) || typeof e.path != "string")
+    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 i = [];
+  for (const h of t)
+    i.push(...ye(h.path));
+  i.push(...ye(e.path)), i[i.length - 1] === "*" && i.pop();
+  const a = [];
+  if (e.redirect) {
+    let h = e.redirect;
+    return H(h) && (h = Ue(se(i), h), h.startsWith("/") || (h = "/" + h)), a.push({
+      pattern: "/" + se([...i, ...ye(e.path)]),
+      meta: {
+        redirect: h
+      }
+    }), a;
+  }
+  let o = ht;
+  if (typeof e.view == "function")
+    o = e.view;
+  else if (e.view)
+    throw new TypeError(`Route '${e.path}' expected a view function or undefined. Got: ${e.view}`);
+  const d = Qe(o), c = { id: tt(this, We)._++, markup: d };
+  if (e.routes)
+    for (const h of e.routes)
+      a.push(...P(this, G, Ye).call(this, h, [...t, e], [...n, c]));
+  else
+    a.push({
+      pattern: parent ? se([...t.map((h) => h.path), e.path]) : e.path,
+      meta: {
+        pattern: e.path,
+        layers: [...n, c],
+        beforeMatch: e.beforeMatch
+      }
+    });
+  return a;
+}, Xe = async function({ location: e }) {
+  e.search !== s(this, ke) && (w(this, ke, e.search), s(this, Se).call(this, Je(e.search)));
+  const t = ot(s(this, Z), e.pathname);
+  if (!t) {
+    s(this, he).call(this, null), s(this, ue).call(this, e.pathname), s(this, fe).call(this, {
+      wildcard: e.pathname
+    });
+    return;
+  }
+  if (t.meta.beforeMatch && await t.meta.beforeMatch({
+    redirect: (n) => {
+      throw new Error("Redirect not yet implemented.");
+    }
+  }), s(this, j).info(`Matched route: '${t.pattern}' ('${t.path}')`), t.meta.redirect != null)
+    if (typeof t.meta.redirect == "string") {
+      const n = zt(t.meta.redirect, t.params);
+      s(this, j).info(`Redirecting to: '${n}'`), s(this, S).replace(n);
+    } else if (typeof t.meta.redirect == "function") {
+      const n = {
+        path: t.path,
+        pattern: t.pattern,
+        params: t.params,
+        query: t.query
+      };
+      let i = await t.meta.redirect(n);
+      if (typeof i != "string")
+        throw new Error("Redirect function must return a path to redirect to.");
+      i.startsWith("/") || (i = Ue(t.path, i)), s(this, j).info(`Redirecting to: '${i}'`), s(this, S).replace(i);
+    } else
+      throw new TypeError("Redirect must either be a path string or a function.");
+  else if (s(this, ue).call(this, t.path), s(this, fe).call(this, t.params), t.pattern !== this.$pattern.get()) {
+    s(this, he).call(this, t.pattern);
+    const n = t.meta.layers;
+    for (let i = 0; i < n.length; i++) {
+      const a = n[i], o = s(this, W)[i];
+      if ((o == null ? void 0 : o.id) !== a.id) {
+        s(this, j).info(`Replacing layer @${i} (active ID: ${o == null ? void 0 : o.id}, matched ID: ${a.id})`), w(this, W, s(this, W).slice(0, i));
+        const d = s(this, W).at(-1), c = {
+          dolla: s(this, Le)
+        }, h = Et(a.markup, c), y = Lt(h);
+        o && o.handle.connected && o.handle.disconnect(), d ? d.handle.setChildren(h) : s(this, X).rootView.setChildren(h), s(this, W).push({ id: a.id, handle: y });
+      }
+    }
+  }
+};
+const Wt = /(noopener|noreferrer) (noopener|noreferrer)/, It = /^[\w-_]+:/;
+function mt(r, e, t = window) {
+  function n(a) {
+    return !a || a === r ? null : a.localName !== "a" || a.href === void 0 ? n(a.parentNode) : a;
+  }
+  function i(a) {
+    if (a.button && a.button !== 0 || a.ctrlKey || a.metaKey || a.altKey || a.shiftKey || a.defaultPrevented)
+      return;
+    const o = n(a.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" && Wt.test(o.getAttribute("rel")) || It.test(o.getAttribute("href")) || (a.preventDefault(), e(o)));
+  }
+  return r.addEventListener("click", i), function() {
+    r.removeEventListener("click", i);
+  };
+}
+function zt(r, e) {
+  for (const t in e) {
+    const n = e[t].toString();
+    r = r.replace(`{${t}}`, n).replace(`{#${t}}`, n);
+  }
+  return r;
+}
+const Jt = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  Router: pt,
+  RoutingStyle: gt,
+  catchLinks: mt
+}, Symbol.toStringTag, { value: "Module" }));
+var I, Pe, te, ne, Re, xe, Me, Oe, x, z;
+class Gt {
+  constructor() {
+    f(this, I, !1);
+    f(this, Pe, "production");
+    f(this, te);
+    f(this, ne);
+    k(this, "http");
+    k(this, "language");
+    k(this, "render");
+    k(this, "router");
+    f(this, Re, []);
+    f(this, xe, []);
+    f(this, Me, []);
+    f(this, Oe, []);
+    f(this, x, {
+      info: "development",
+      log: "development",
+      warn: "development",
+      error: !0
+    });
+    f(this, z, nt("*,-dolla/*"));
+    k(this, "createSignal", Q);
+    k(this, "createSettableSignal", kt);
+    k(this, "toSettableSignal", St);
+    k(this, "signalify", Ge);
+    k(this, "designalify", Pt);
+    k(this, "derive", Be);
+    k(this, "watch", lt);
+    k(this, "createRef", Rt);
+    k(this, "isRef", xt);
+    const e = this;
+    this.http = new Ot(), this.language = new Ct(this), this.render = new qt(this), this.router = new pt(this, {
+      get rootElement() {
+        return s(e, te);
+      },
+      get rootView() {
+        return s(e, ne);
+      }
+    });
+  }
+  get isMounted() {
+    return s(this, I);
+  }
+  get env() {
+    return s(this, Pe);
+  }
+  set env(e) {
+    w(this, Pe, e);
+  }
+  async mount(e, t) {
+    if (s(this, I))
+      throw new Error("Dolla is already mounted.");
+    if (H(e)) {
+      const a = document.querySelector(e);
+      rt(HTMLElement, a, `Selector '${e}' did not match any element.`), w(this, te, a);
+    } else
+      rt(HTMLElement, e, "Expected an HTML element or a selector string. Got type: %t, value: %v"), w(this, te, e);
+    let n;
+    t ? n = Qe(t) : n = Qe(ht), w(this, ne, at({ dolla: this }, n.type, n.props)), await Promise.all(s(this, Re).map((a) => a())), s(this, ne).connect(s(this, te)), w(this, I, !0);
+    for (const a of s(this, xe))
+      a();
+  }
+  async unmount() {
+    var e;
+    if (s(this, I)) {
+      await Promise.all(s(this, Me).map((t) => t())), (e = s(this, ne)) == null || e.disconnect(), w(this, I, !1);
+      for (const t of s(this, Oe))
+        t();
+    }
+  }
+  /**
+   * 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) {
+    s(this, Re).push(e);
+  }
+  /**
+   * Registers a `callback` to run after the app is mounted.
+   */
+  onMount(e) {
+    s(this, xe).push(e);
+  }
+  /**
+   * 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) {
+    s(this, Me).push(e);
+  }
+  /**
+   * Registers a `callback` to run after the app is unmounted.
+   */
+  onUnmount(e) {
+    s(this, Oe).push(e);
+  }
+  /**
+   * Update log level settings. Values that are not passed will remain unchanged.
+   */
+  setLoggles(e) {
+    for (const t in e) {
+      const n = e[t];
+      n && (s(this, x)[t] = n);
+    }
+  }
+  setLogFilter(e) {
+    w(this, z, nt(e));
+  }
+  createLogger(e, t) {
+    const n = Ge(e), i = (t == null ? void 0 : t.console) ?? Mt(), a = this;
+    return {
+      get info() {
+        var d;
+        const o = n.get();
+        if (s(a, x).info === !1 || H(s(a, x).info) && s(a, x).info !== a.env || !s(d = a, z).call(d, o))
+          return Ne;
+        {
+          let c = `%c${o}`;
+          return t != null && t.uid ? c += ` %c[uid: %c${t.uid}%c]` : c += "%c%c%c", i.info.bind(
+            i,
+            c,
+            `color:${Te(c)};font-weight:bold`,
+            "color:#777",
+            "color:#aaa",
+            "color:#777"
+          );
+        }
+      },
+      get log() {
+        var d;
+        const o = n.get();
+        if (s(a, x).log === !1 || H(s(a, x).log) && s(a, x).log !== a.env || !s(d = a, z).call(d, o))
+          return Ne;
+        {
+          let c = `%c${o}`;
+          return t != null && t.uid ? c += ` %c[uid: %c${t.uid}%c]` : c += "%c%c%c", i.log.bind(
+            i,
+            c,
+            `color:${Te(c)};font-weight:bold`,
+            "color:#777",
+            "color:#aaa",
+            "color:#777"
+          );
+        }
+      },
+      get warn() {
+        var d;
+        const o = n.get();
+        if (s(a, x).warn === !1 || H(s(a, x).warn) && s(a, x).warn !== a.env || !s(d = a, z).call(d, o))
+          return Ne;
+        {
+          let c = `%c${o}`;
+          return t != null && t.uid ? c += ` %c[uid: %c${t.uid}%c]` : c += "%c%c%c", i.warn.bind(
+            i,
+            c,
+            `color:${Te(c)};font-weight:bold`,
+            "color:#777",
+            "color:#aaa",
+            "color:#777"
+          );
+        }
+      },
+      get error() {
+        var d;
+        const o = n.get();
+        if (s(a, x).error === !1 || H(s(a, x).error) && s(a, x).error !== a.env || !s(d = a, z).call(d, o))
+          return Ne;
+        {
+          let c = `%c${o}`;
+          return t != null && t.uid ? c += ` %c[uid: %c${t.uid}%c]` : c += "%c%c%c", i.error.bind(
+            i,
+            c,
+            `color:${Te(c)};font-weight:bold`,
+            "color:#777",
+            "color:#aaa",
+            "color:#777"
+          );
+        }
+      },
+      crash(o) {
+      }
+    };
+  }
+  constructView(e, t, n = []) {
+    return at({ dolla: this }, e, t, n);
+  }
+}
+I = new WeakMap(), Pe = new WeakMap(), te = new WeakMap(), ne = new WeakMap(), Re = new WeakMap(), xe = new WeakMap(), Me = new WeakMap(), Oe = new WeakMap(), x = new WeakMap(), z = new WeakMap();
+const L = new Gt(), Yt = L.beforeMount.bind(L), Xt = L.onMount.bind(L), Zt = L.beforeUnmount.bind(L), en = L.onUnmount.bind(L), tn = L.mount.bind(L), nn = L.unmount.bind(L), rn = L.http, an = L.render, sn = L.createLogger.bind(L), on = L.setLogFilter.bind(L), cn = L.setLoggles.bind(L), ln = L.language.t.bind(L.language), hn = L.constructView.bind(L);
+export {
+  dn as Fragment,
+  Yt as beforeMount,
+  Zt as beforeUnmount,
+  gn as cond,
+  hn as constructView,
+  sn as createLogger,
+  Rt as createRef,
+  kt as createSettableSignal,
+  Q as createSignal,
+  pn as createSignalSetter,
+  L as default,
+  Be as derive,
+  Pt as designalify,
+  rn as http,
+  xt as isRef,
+  Qe as m,
+  tn as mount,
+  Xt as onMount,
+  en as onUnmount,
+  mn as portal,
+  an as render,
+  yn as repeat,
+  Jt as router,
+  on as setLogFilter,
+  cn as setLogges,
+  Ge as signalify,
+  ln as t,
+  St as toSettableSignal,
+  nn as unmount,
+  lt as watch
+};
+//# sourceMappingURL=index.js.map