@manyducks.co/dolla 0.67.0

package/lib/index.js

@@ -0,0 +1,4062 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/simple-color-hash/lib/index.js
+var require_lib = __commonJS({
+  "node_modules/simple-color-hash/lib/index.js"(exports, module) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    var _slicedToArray = function() {
+      function a(a2, b) {
+        var c = [], d = true, e = false, f = void 0;
+        try {
+          for (var g, h = a2[Symbol.iterator](); !(d = (g = h.next()).done) && (c.push(g.value), !(b && c.length === b)); d = true)
+            ;
+        } catch (a3) {
+          e = true, f = a3;
+        } finally {
+          try {
+            !d && h["return"] && h["return"]();
+          } finally {
+            if (e)
+              throw f;
+          }
+        }
+        return c;
+      }
+      return function(b, c) {
+        if (Array.isArray(b))
+          return b;
+        if (Symbol.iterator in Object(b))
+          return a(b, c);
+        throw new TypeError("Invalid attempt to destructure non-iterable instance");
+      };
+    }();
+    var rgbToHex = function(a) {
+      return a.reduce(function(a2, b) {
+        return 16 > b ? a2 + "0" + b.toString(16) : a2 + b.toString(16);
+      }, "#");
+    };
+    var hslToRgb = function(a, b, c) {
+      var d = 0.5 > c ? c * (1 + b) : c + b - c * b, e = 2 * c - d, f = function(a2, b2, c2) {
+        var d2 = Math.round, e2 = 0 > c2 ? c2 + 1 : 1 < c2 ? c2 - 1 : c2;
+        return e2 = e2 < 1 / 6 ? a2 + 6 * (b2 - a2) * e2 : e2 < 1 / 2 ? b2 : e2 < 2 / 3 ? a2 + 6 * (b2 - a2) * (2 / 3 - e2) : a2, d2(255 * e2);
+      }, g = f(e, d, a + 1 / 3), h = f(e, d, a), i = f(e, d, a - 1 / 3);
+      return [g, h, i];
+    };
+    var hslGeneration = function(a, b, c, d) {
+      var e = a % 1007 / 1007, f = function(a2, b2, c2) {
+        return a2 * (c2 - b2) + b2;
+      }, g = f(e, b.min, b.max), h = f(e, c.min, c.max), i = f(e, d.max, d.min);
+      return [g, h, i];
+    };
+    var standardHashFunction = function(a) {
+      return a.split("").reduce(function(a2, b, c) {
+        return a2 * b.charCodeAt(0) * c + 1;
+      }, 1);
+    };
+    var generateColorHash = function(a) {
+      var b = a.str, c = a.hue, d = c === void 0 ? { min: 0, max: 360 } : c, e = a.sat, f = e === void 0 ? { min: 0.35, max: 0.65 } : e, g = a.light, h = g === void 0 ? { min: 0.3, max: 0.7 } : g, i = a.hashFunction, j = i === void 0 ? standardHashFunction : i, k = a.scheme, l = k === void 0 ? "hex" : k, m2 = hslGeneration(j(b), d, f, h), n = _slicedToArray(m2, 3), o = n[0], p = n[1], q = n[2], r = hslToRgb(o / 360, p, q), s = rgbToHex(r);
+      if ("hsl" === l)
+        return [o, p, q];
+      return "rgb" === l ? r : s;
+    };
+    exports.default = generateColorHash, module.exports = exports.default;
+  }
+});
+
+// node_modules/@borf/bedrock/lib/typeChecking.js
+function typeOf(value) {
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (value === null) {
+    return "null";
+  }
+  const type = typeof value;
+  switch (type) {
+    case "number":
+      if (isNaN(value)) {
+        return "NaN";
+      }
+      return "number";
+    case "function":
+      if (isClass(value)) {
+        return "class";
+      }
+      return type;
+    case "object":
+      if (isArray(value)) {
+        return "array";
+      }
+      if (isPromise(value)) {
+        return "promise";
+      }
+      return type;
+    default:
+      return type;
+  }
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isArrayOf(...args) {
+  const check = args[0];
+  const test = (value) => {
+    return isArray(value) && value.every((item) => check(item));
+  };
+  if (args.length < 2) {
+    return test;
+  } else {
+    return test(args[1]);
+  }
+}
+function assertArrayOf(...args) {
+  const check = args[0];
+  const message = isString(args[2]) ? args[2] : "Expected an array of valid items. Got type: %t, value: %v";
+  const test = (value) => {
+    if (isArray(value) && value.every((item) => check(item))) {
+      return true;
+    }
+    throw new TypeError(formatError(value, message));
+  };
+  if (args.length < 2) {
+    return test;
+  } else {
+    return test(args[1]);
+  }
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function assertString(value, errorMessage) {
+  if (isString(value)) {
+    return true;
+  }
+  throw new TypeError(formatError(value, errorMessage ?? "Expected a string. Got type: %t, value: %v"));
+}
+function isFunction(value) {
+  return typeof value === "function" && !isClass(value);
+}
+function assertFunction(value, errorMessage) {
+  if (isFunction(value)) {
+    return true;
+  }
+  throw new TypeError(formatError(value, errorMessage ?? "Expected a function. Got type: %t, value: %v"));
+}
+function isNumber(value) {
+  return typeof value === "number" && !isNaN(value);
+}
+function isPromise(value) {
+  if (value == null)
+    return false;
+  const obj = value;
+  return obj instanceof Promise || isFunction(obj.then) && isFunction(obj.catch) && isFunction(obj.finally);
+}
+function isClass(value) {
+  return typeof value === "function" && /^\s*class\s+/.test(value.toString());
+}
+function assertInstanceOf(...args) {
+  const constructor = args[0];
+  const errorMessage = isString(args[2]) ? args[2] : `Expected instance of ${constructor.name}. Got type: %t, value: %v`;
+  const test = (value) => {
+    if (value instanceof constructor) {
+      return true;
+    }
+    throw new TypeError(formatError(value, errorMessage));
+  };
+  if (args.length < 2) {
+    return test;
+  } else {
+    return test(args[1]);
+  }
+}
+function isObject(value) {
+  return value != null && typeof value === "object" && !isArray(value);
+}
+function assertObject(value, errorMessage) {
+  if (isObject(value)) {
+    return true;
+  }
+  throw new TypeError(formatError(value, errorMessage ?? "Expected an object. Got type: %t, value: %v"));
+}
+function formatError(value, message) {
+  const typeName = typeOf(value);
+  const valueString = value?.toString?.() || String(value);
+  return message.replaceAll("%t", typeName).replaceAll("%v", valueString);
+}
+
+// node_modules/@borf/bedrock/lib/routing.js
+var FragTypes;
+(function(FragTypes2) {
+  FragTypes2[FragTypes2["Literal"] = 1] = "Literal";
+  FragTypes2[FragTypes2["Param"] = 2] = "Param";
+  FragTypes2[FragTypes2["Wildcard"] = 3] = "Wildcard";
+  FragTypes2[FragTypes2["NumericParam"] = 4] = "NumericParam";
+})(FragTypes || (FragTypes = {}));
+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 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");
+  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 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 (part.startsWith(".")) {
+      part = part.replace(/^\.\/?/, "");
+    } else {
+      break;
+    }
+  }
+  return joinPath([resolved, part]);
+}
+function parseQueryParams(query) {
+  if (!query)
+    return {};
+  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(entries);
+}
+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 === FragTypes.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 !== FragTypes.Wildcard) {
+            continue routes;
+          }
+          switch (frag.type) {
+            case FragTypes.Literal:
+              if (frag.name.toLowerCase() === part.toLowerCase()) {
+                matched.push(frag);
+                break;
+              } else {
+                continue routes;
+              }
+            case FragTypes.Param:
+              matched.push({ ...frag, value: part });
+              break;
+            case FragTypes.Wildcard:
+              matched.push({ ...frag, value: parts.slice(i).join("/") });
+              break fragments;
+            case FragTypes.NumericParam:
+              if (!isNaN(Number(part))) {
+                matched.push({ ...frag, value: Number(part) });
+                break;
+              } else {
+                continue routes;
+              }
+            default:
+              throw new Error(`Unknown fragment type: ${frag.type}`);
+          }
+        }
+      const params = /* @__PURE__ */ Object.create(null);
+      for (const frag of matched) {
+        if (frag.type === FragTypes.Param) {
+          params[frag.name] = decodeURIComponent(frag.value);
+        }
+        if (frag.type === FragTypes.NumericParam) {
+          params[frag.name] = frag.value;
+        }
+        if (frag.type === FragTypes.Wildcard) {
+          params.wildcard = "/" + decodeURIComponent(frag.value);
+        }
+      }
+      return {
+        path: "/" + matched.map((f) => f.value).join("/"),
+        pattern: "/" + fragments.map((f) => {
+          if (f.type === FragTypes.Param) {
+            return `{${f.name}}`;
+          }
+          if (f.type === FragTypes.NumericParam) {
+            return `{#${f.name}}`;
+          }
+          return f.name;
+        }).join("/"),
+        params,
+        query: parseQueryParams(query),
+        meta: route.meta
+      };
+    }
+}
+function sortRoutes(routes) {
+  const withoutParams = [];
+  const withNumericParams = [];
+  const withParams = [];
+  const wildcard = [];
+  for (const route of routes) {
+    const { fragments } = route;
+    if (fragments.some((f) => f.type === FragTypes.Wildcard)) {
+      wildcard.push(route);
+    } else if (fragments.some((f) => f.type === FragTypes.NumericParam)) {
+      withNumericParams.push(route);
+    } else if (fragments.some((f) => f.type === FragTypes.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 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: FragTypes.Wildcard,
+        name: "*",
+        value: null
+      });
+    } else if (part.at(0) === "{" && part.at(-1) === "}") {
+      fragments.push({
+        type: part[1] === "#" ? FragTypes.NumericParam : FragTypes.Param,
+        name: part[1] === "#" ? part.slice(2, -1) : part.slice(1, -1),
+        value: null
+      });
+    } else {
+      fragments.push({
+        type: FragTypes.Literal,
+        name: part,
+        value: part
+      });
+    }
+  }
+  return fragments;
+}
+
+// src/classes/CrashCollector.ts
+var CrashCollector = class {
+  #errors = [];
+  #errorCallbacks = [];
+  /**
+   * Registers a callback to receive all errors that pass through the CrashCollector.
+   * Returns a function that cancels this listener when called.
+   */
+  onError(callback) {
+    this.#errorCallbacks.push(callback);
+    return () => {
+      this.#errorCallbacks.splice(this.#errorCallbacks.indexOf(callback), 1);
+    };
+  }
+  /**
+   * Reports an unrecoverable error that requires crashing the whole app.
+   */
+  crash({ error, componentName }) {
+    const ctx = {
+      error,
+      severity: "crash",
+      componentName: componentName ?? "anonymous component"
+    };
+    this.#errors.push(ctx);
+    for (const callback of this.#errorCallbacks) {
+      callback(ctx);
+    }
+    throw error;
+  }
+  /**
+   * Reports a recoverable error.
+   */
+  error({ error, componentName }) {
+    const ctx = {
+      error,
+      severity: "error",
+      componentName: componentName ?? "anonymous component"
+    };
+    this.#errors.push(ctx);
+    for (const callback of this.#errorCallbacks) {
+      callback(ctx);
+    }
+  }
+};
+
+// src/classes/DebugHub.ts
+var import_simple_color_hash = __toESM(require_lib(), 1);
+var DebugHub = class {
+  #filter = "*,-dolla/*";
+  #matcher;
+  #console;
+  #options;
+  constructor(options, _console = getDefaultConsole()) {
+    if (options.filter) {
+      this.#filter = options.filter;
+    }
+    this.#matcher = makeMatcher(this.#filter);
+    this.#console = _console;
+    this.#options = options;
+  }
+  /**
+   * Returns a debug channel labelled by `name`. Used for logging from components.
+   */
+  channel(options) {
+    const _console = this.#console;
+    const hubOptions = this.#options;
+    const match = (value) => {
+      return this.#matcher(value);
+    };
+    return {
+      get info() {
+        const name = options.name;
+        if (hubOptions.info === false || isString(hubOptions.info) && hubOptions.info !== hubOptions.mode || !match(name)) {
+          return noOp;
+        } else {
+          const label = `%c${name}`;
+          return _console.info.bind(_console, label, `color:${hash(label)};font-weight:bold`);
+        }
+      },
+      get log() {
+        const name = options.name;
+        if (hubOptions.log === false || isString(hubOptions.log) && hubOptions.log !== hubOptions.mode || !match(name)) {
+          return noOp;
+        } else {
+          const label = `%c${name}`;
+          return _console.log.bind(_console, label, `color:${hash(label)};font-weight:bold`);
+        }
+      },
+      get warn() {
+        const name = options.name;
+        if (hubOptions.warn === false || isString(hubOptions.warn) && hubOptions.warn !== hubOptions.mode || !match(name)) {
+          return noOp;
+        } else {
+          const label = `%c${name}`;
+          return _console.warn.bind(_console, label, `color:${hash(label)};font-weight:bold`);
+        }
+      },
+      get error() {
+        const name = options.name;
+        if (hubOptions.error === false || isString(hubOptions.error) && hubOptions.error !== hubOptions.mode || !match(name)) {
+          return noOp;
+        } else {
+          const label = `%c${name}`;
+          return _console.error.bind(_console, label, `color:${hash(label)};font-weight:bold`);
+        }
+      }
+    };
+  }
+  get filter() {
+    return this.#filter;
+  }
+  set filter(pattern) {
+    this.#filter = pattern;
+    this.#matcher = makeMatcher(pattern);
+  }
+};
+function getDefaultConsole() {
+  if (typeof window !== "undefined" && window.console) {
+    return window.console;
+  }
+  if (typeof global !== "undefined" && global.console) {
+    return global.console;
+  }
+}
+var noOp = () => {
+};
+function hash(value) {
+  return (0, import_simple_color_hash.default)({
+    str: value,
+    sat: { min: 0.35, max: 0.55 },
+    light: { min: 0.6, max: 0.6 }
+  });
+}
+function makeMatcher(pattern) {
+  if (pattern instanceof RegExp) {
+    return (value) => pattern.test(value);
+  }
+  const matchers = {
+    positive: [],
+    negative: []
+  };
+  const parts = pattern.split(",").map((p) => p.trim()).filter((p) => p !== "");
+  for (let part of parts) {
+    let section = "positive";
+    if (part.startsWith("-")) {
+      section = "negative";
+      part = part.slice(1);
+    }
+    if (part === "*") {
+      matchers[section].push(function() {
+        return true;
+      });
+    } else if (part.endsWith("*")) {
+      matchers[section].push(function(value) {
+        return value.startsWith(part.slice(0, part.length - 1));
+      });
+    } else {
+      matchers[section].push(function(value) {
+        return value === part;
+      });
+    }
+  }
+  return function(name) {
+    const { positive, negative } = matchers;
+    if (negative.some((fn) => fn(name))) {
+      return false;
+    }
+    if (positive.length > 0 && !positive.some((fn) => fn(name))) {
+      return false;
+    }
+    return true;
+  };
+}
+
+// src/utils.ts
+function isPlainObject(value) {
+  return value != null && typeof value === "object" && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.getPrototypeOf({});
+}
+function deepEqual(one, two) {
+  if (one === two) {
+    return true;
+  }
+  if (isPlainObject(one) && isPlainObject(two)) {
+    const keysOne = Object.keys(one);
+    const keysTwo = Object.keys(two);
+    if (keysOne.length !== keysTwo.length) {
+      return false;
+    }
+    for (const key in one) {
+      if (!deepEqual(one[key], two[key])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  if (Array.isArray(one) && Array.isArray(two)) {
+    if (one.length !== two.length) {
+      return false;
+    }
+    for (const index in one) {
+      if (!deepEqual(one[index], two[index])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  return one === two;
+}
+function merge(one, two) {
+  if (isObject(one)) {
+    if (!isObject(two)) {
+      return two;
+    }
+    const merged = Object.assign({}, one);
+    for (const key in two) {
+      merged[key] = merge(merged[key], two[key]);
+    }
+    return merged;
+  } else {
+    return two;
+  }
+}
+function omit(keys, object) {
+  const process2 = (object2) => {
+    const newObject = {};
+    for (const key in object2) {
+      if (!keys.includes(key)) {
+        newObject[key] = object2[key];
+      }
+    }
+    return newObject;
+  };
+  if (object == null) {
+    return process2;
+  }
+  return process2(object);
+}
+
+// src/state.ts
+var UNOBSERVED = Symbol("Unobserved");
+var OBSERVE = Symbol("Observe");
+function isReadable(value) {
+  return value != null && typeof value === "object" && typeof value[OBSERVE] === "function" && typeof value.get === "function";
+}
+function isWritable(value) {
+  return isReadable(value) && typeof value.set === "function" && typeof value.update === "function";
+}
+function readable(value) {
+  if (isWritable(value)) {
+    return {
+      get: value.get,
+      [OBSERVE]: value[OBSERVE]
+    };
+  }
+  if (isReadable(value)) {
+    return value;
+  }
+  return {
+    get: () => value,
+    [OBSERVE]: (callback) => {
+      callback(value, void 0);
+      return function stop() {
+      };
+    }
+  };
+}
+function writable(value) {
+  if (isWritable(value)) {
+    return value;
+  }
+  if (isReadable(value)) {
+    throw new TypeError(`Failed to convert Readable into a Writable; can't add write access to a read-only value.`);
+  }
+  const observers = [];
+  let currentValue = value;
+  return {
+    // ----- Readable ----- //
+    get: () => currentValue,
+    [OBSERVE]: (callback) => {
+      observers.push(callback);
+      function stop() {
+        observers.splice(observers.indexOf(callback), 1);
+      }
+      callback(currentValue, void 0);
+      return stop;
+    },
+    // ----- Writable ----- //
+    set: (newValue) => {
+      if (!deepEqual(currentValue, newValue)) {
+        const previousValue = currentValue;
+        currentValue = newValue;
+        for (const callback of observers) {
+          callback(currentValue, previousValue);
+        }
+      }
+    },
+    update: (callback) => {
+      const newValue = callback(currentValue);
+      if (!deepEqual(currentValue, newValue)) {
+        const previousValue = currentValue;
+        currentValue = newValue;
+        for (const callback2 of observers) {
+          callback2(currentValue, previousValue);
+        }
+      }
+    }
+  };
+}
+function observe(readable2, callback) {
+  const readables = [];
+  if (Array.isArray(readable2) && readable2.every(isReadable)) {
+    readables.push(...readable2);
+  } else if (isReadable(readable2)) {
+    readables.push(readable2);
+  } else {
+    console.warn(readable2);
+    throw new TypeError(
+      `Expected one Readable or an array of Readables as the first argument. Got value: ${readable2}, type: ${typeOf(
+        readable2
+      )}`
+    );
+  }
+  if (readables.length === 0) {
+    throw new TypeError(`Expected at least one readable.`);
+  }
+  if (readables.length > 1) {
+    return computed(readables, callback)[OBSERVE](() => {
+    });
+  } else {
+    return readables[0][OBSERVE](callback);
+  }
+}
+function computed(...args) {
+  if (isReadable(args[0])) {
+    if (typeof args[1] !== "function") {
+      throw new TypeError(
+        `When first argument is a Readable the second argument must be a callback function. Got type: ${typeOf(
+          args[1]
+        )}, value: ${args[1]}`
+      );
+    }
+    const readable2 = args[0];
+    const compute = args[1];
+    return {
+      get: () => compute(readable2.get()),
+      [OBSERVE]: (callback) => {
+        let lastComputedValue = UNOBSERVED;
+        let lastObservedValue;
+        return readable2[OBSERVE]((currentValue) => {
+          const computedValue = compute(currentValue, lastObservedValue);
+          if (!deepEqual(computedValue, lastComputedValue)) {
+            const previousValue = lastComputedValue === UNOBSERVED ? void 0 : lastComputedValue;
+            callback(computedValue, previousValue);
+            lastComputedValue = computedValue;
+            lastObservedValue = currentValue;
+          }
+        });
+      }
+    };
+  } else if (Array.isArray(args[0])) {
+    let updateValue2 = function() {
+      const computedValue = compute(observedValues, previousObservedValues);
+      if (!deepEqual(computedValue, latestComputedValue)) {
+        const previousValue = latestComputedValue === UNOBSERVED ? void 0 : latestComputedValue;
+        latestComputedValue = computedValue;
+        previousObservedValues = observedValues;
+        for (const callback of observers) {
+          callback(computedValue, previousValue);
+        }
+      }
+    }, startObserving2 = function() {
+      if (isObserving)
+        return;
+      for (let i = 0; i < readables.length; i++) {
+        const readable2 = readables[i];
+        stopCallbacks.push(
+          observe(readable2, (value) => {
+            observedValues[i] = value;
+            if (isObserving) {
+              updateValue2();
+            }
+          })
+        );
+      }
+      previousObservedValues = new Array().fill(void 0, 0, readables.length);
+      observedValues = readables.map((x) => x.get());
+      isObserving = true;
+      updateValue2();
+    }, stopObserving2 = function() {
+      isObserving = false;
+      for (const callback of stopCallbacks) {
+        callback();
+      }
+      stopCallbacks = [];
+    };
+    var updateValue = updateValue2, startObserving = startObserving2, stopObserving = stopObserving2;
+    if (typeof args[1] !== "function") {
+      throw new TypeError(
+        `When first argument is an array of Readables the second argument must be a callback function. Got type: ${typeOf(
+          args[1]
+        )}, value: ${args[1]}`
+      );
+    }
+    if (!args[0].every(isReadable)) {
+      throw new TypeError(
+        `Computed expected an array of Readables. Got: [${args[0].map((x) => isReadable(x) ? `Readable<${typeOf(x.get())}>` : typeof x).join(", ")}]`
+      );
+    }
+    const readables = args[0];
+    const compute = args[1];
+    const observers = [];
+    let stopCallbacks = [];
+    let isObserving = false;
+    let previousObservedValues = [];
+    let observedValues = [];
+    let latestComputedValue = UNOBSERVED;
+    return {
+      get: () => {
+        if (isObserving) {
+          return latestComputedValue;
+        } else {
+          return compute(
+            readables.map((x) => x.get()),
+            new Array().fill(void 0, 0, readables.length)
+          );
+        }
+      },
+      [OBSERVE]: (callback) => {
+        if (!isObserving) {
+          startObserving2();
+        }
+        callback(latestComputedValue, void 0);
+        observers.push(callback);
+        return function stop() {
+          observers.splice(observers.indexOf(callback), 1);
+          if (observers.length === 0) {
+            stopObserving2();
+          }
+        };
+      }
+    };
+  } else {
+    throw new TypeError(
+      `Expected a Readable or array of Readables as a first argument. Got: ${typeOf(args[0])}, value: ${args[0]}`
+    );
+  }
+}
+function proxy(source, config) {
+  if (!isReadable(source)) {
+    throw new TypeError(`Proxy source must be a Readable.`);
+  }
+  const observers = [];
+  const currentValue = () => config.get(source);
+  return {
+    // ----- Readable ----- //
+    get: () => config.get(source),
+    [OBSERVE]: (callback) => {
+      let lastComputedValue = UNOBSERVED;
+      return source[OBSERVE]((_) => {
+        const computedValue = config.get(source);
+        if (!deepEqual(computedValue, lastComputedValue)) {
+          const previousValue = lastComputedValue === UNOBSERVED ? void 0 : lastComputedValue;
+          callback(computedValue, previousValue);
+          lastComputedValue = computedValue;
+        }
+      });
+    },
+    // ----- Writable ----- //
+    set: (newValue) => {
+      config.set(source, newValue);
+    },
+    update: (callback) => {
+      const newValue = callback(config.get(source));
+      config.set(source, newValue);
+    }
+  };
+}
+function unwrap(value) {
+  if (isReadable(value)) {
+    return value.get();
+  }
+  return value;
+}
+
+// src/nodes/cond.ts
+var Conditional = class {
+  node;
+  endNode;
+  $predicate;
+  stopCallback;
+  thenContent;
+  elseContent;
+  connectedContent = [];
+  appContext;
+  elementContext;
+  constructor(config) {
+    this.$predicate = config.$predicate;
+    this.thenContent = config.thenContent ? toMarkup(config.thenContent) : void 0;
+    this.elseContent = config.elseContent ? toMarkup(config.elseContent) : void 0;
+    this.appContext = config.appContext;
+    this.elementContext = config.elementContext;
+    if (this.appContext.mode === "development") {
+      this.node = document.createComment("Conditional");
+      this.endNode = document.createComment("/Conditional");
+    } else {
+      this.node = document.createTextNode("");
+      this.endNode = document.createTextNode("");
+    }
+  }
+  get connected() {
+    return this.node.parentNode != null;
+  }
+  connect(parent, after) {
+    if (!this.connected) {
+      parent.insertBefore(this.node, after?.nextSibling ?? null);
+      if (this.appContext.mode === "development") {
+        parent.insertBefore(this.endNode, this.node.nextSibling);
+      }
+      this.stopCallback = observe(this.$predicate, (value) => {
+        this.update(value);
+      });
+    }
+  }
+  disconnect() {
+    if (this.stopCallback) {
+      this.stopCallback();
+      this.stopCallback = void 0;
+    }
+    for (const handle of this.connectedContent) {
+      handle.disconnect();
+    }
+    this.connectedContent = [];
+    if (this.connected) {
+      this.node.parentNode?.removeChild(this.node);
+      this.endNode.parentNode?.removeChild(this.endNode);
+    }
+  }
+  update(value) {
+    for (const handle of this.connectedContent) {
+      handle.disconnect();
+    }
+    this.connectedContent = [];
+    if (value && this.thenContent) {
+      this.connectedContent = renderMarkupToDOM(this.thenContent, this);
+    } else if (!value && this.elseContent) {
+      this.connectedContent = renderMarkupToDOM(this.elseContent, this);
+    }
+    for (let i = 0; i < this.connectedContent.length; i++) {
+      const handle = this.connectedContent[i];
+      const previous = this.connectedContent[i - 1]?.node ?? this.node;
+      handle.connect(this.node.parentNode, previous);
+    }
+    if (this.appContext.mode === "development") {
+      this.node.textContent = `Conditional (${value ? "truthy" : "falsy"})`;
+    }
+  }
+  async setChildren(children) {
+  }
+};
+
+// node_modules/nanoid/index.browser.js
+var nanoid = (size = 21) => crypto.getRandomValues(new Uint8Array(size)).reduce((id, byte) => {
+  byte &= 63;
+  if (byte < 36) {
+    id += byte.toString(36);
+  } else if (byte < 62) {
+    id += (byte - 26).toString(36).toUpperCase();
+  } else if (byte > 62) {
+    id += "-";
+  } else {
+    id += "_";
+  }
+  return id;
+}, "");
+
+// src/nodes/html.ts
+var isCamelCaseEventName = (key) => /^on[A-Z]/.test(key);
+var HTML = class {
+  node;
+  props;
+  children;
+  stopCallbacks = [];
+  appContext;
+  elementContext;
+  uniqueId = nanoid();
+  // Prevents 'onClickOutside' handlers from firing in the same cycle in which the element is connected.
+  canClickAway = false;
+  get connected() {
+    return this.node.parentNode != null;
+  }
+  constructor({ tag, props, children, appContext, elementContext }) {
+    elementContext = { ...elementContext };
+    if (tag.toLowerCase() === "svg") {
+      elementContext.isSVG = true;
+    }
+    if (elementContext.isSVG) {
+      this.node = document.createElementNS("http://www.w3.org/2000/svg", tag);
+    } else {
+      this.node = document.createElement(tag);
+    }
+    if (appContext.mode === "development") {
+      this.node.dataset.uniqueId = this.uniqueId;
+    }
+    if (props.ref) {
+      if (isWritable(props.ref)) {
+        props.ref.set(this.node);
+      } else if (isFunction(props.ref)) {
+        props.ref(this.node);
+      } else {
+        throw new Error("Expected an instance of Ref. Got: " + props.ref);
+      }
+    }
+    this.props = {
+      ...omit(["ref", "class", "className"], props),
+      class: props.className ?? props.class
+    };
+    this.children = children ? renderMarkupToDOM(children, { appContext, elementContext }) : [];
+    this.appContext = appContext;
+    this.elementContext = elementContext;
+  }
+  connect(parent, after) {
+    if (parent == null) {
+      throw new Error(`HTML element requires a parent element as the first argument to connect. Got: ${parent}`);
+    }
+    if (!this.connected) {
+      for (const child of this.children) {
+        child.connect(this.node);
+      }
+      this.applyProps(this.node, this.props);
+      if (this.props.style)
+        this.applyStyles(this.node, this.props.style, this.stopCallbacks);
+      if (this.props.class)
+        this.applyClasses(this.node, this.props.class, this.stopCallbacks);
+    }
+    parent.insertBefore(this.node, after?.nextSibling ?? null);
+    setTimeout(() => {
+      this.canClickAway = true;
+    }, 0);
+  }
+  disconnect() {
+    if (this.connected) {
+      for (const child of this.children) {
+        child.disconnect();
+      }
+      this.node.parentNode?.removeChild(this.node);
+      this.canClickAway = false;
+      for (const stop of this.stopCallbacks) {
+        stop();
+      }
+      this.stopCallbacks = [];
+    }
+  }
+  setChildren(next) {
+    const current = this.children;
+    const patched = [];
+    const length = Math.max(current.length, next.length);
+    for (let i = 0; i < length; i++) {
+      if (!current[i] && next[i]) {
+        patched[i] = next[i];
+        patched[i].connect(this.node, patched[i - 1]?.node);
+      } else if (current[i] && !next[i]) {
+        current[i].disconnect();
+      } else if (current[i] != next[i]) {
+        patched[i] = next[i];
+        current[i].disconnect();
+        patched[i].connect(this.node, patched[i - 1]?.node);
+      }
+    }
+    this.children = patched;
+  }
+  getUpdateKey(type, value) {
+    return `${this.uniqueId}:${type}:${value}`;
+  }
+  applyProps(element, props) {
+    const render = this.appContext.stores.get("render").instance?.exports;
+    const attachProp = (value, callback, updateKey) => {
+      if (isReadable(value)) {
+        this.stopCallbacks.push(
+          observe(value, (value2) => {
+            render.update(() => {
+              callback(value2);
+            }, updateKey);
+          })
+        );
+      } else {
+        render.update(() => {
+          callback(value);
+        }, updateKey);
+      }
+    };
+    for (const key in props) {
+      const value = props[key];
+      if (key === "attributes") {
+        const values = value;
+        for (const name in values) {
+          attachProp(
+            values[name],
+            (current) => {
+              if (current == null) {
+                element.removeAttribute(name);
+              } else {
+                element.setAttribute(name, String(current));
+              }
+            },
+            this.getUpdateKey("attr", name)
+          );
+        }
+      } else if (key === "eventListeners") {
+        const values = value;
+        for (const name in values) {
+          const listener = isReadable(value) ? (e) => value.get()(e) : value;
+          element.addEventListener(name, listener);
+          this.stopCallbacks.push(() => {
+            element.removeEventListener(name, listener);
+          });
+        }
+      } else if (key === "$$value") {
+        if (!isWritable(value)) {
+          throw new TypeError(`$$value property must be a Writable. Got: ${value} (${typeof value})`);
+        }
+        attachProp(
+          value,
+          (current) => {
+            element.value = String(current);
+          },
+          this.getUpdateKey("prop", "value")
+        );
+        const listener = (e) => {
+          const updated = toTypeOf(value.get(), e.currentTarget.value);
+          value.set(updated);
+        };
+        element.addEventListener("input", listener);
+        this.stopCallbacks.push(() => {
+          element.removeEventListener("input", listener);
+        });
+      } else if (key === "onClickOutside" || key === "onclickoutside") {
+        const listener = (e) => {
+          if (this.canClickAway && !element.contains(e.target)) {
+            if (isReadable(value)) {
+              value.get()(e);
+            } else {
+              value(e);
+            }
+          }
+        };
+        const options = { capture: true };
+        window.addEventListener("click", listener, options);
+        this.stopCallbacks.push(() => {
+          window.removeEventListener("click", listener, options);
+        });
+      } else if (isCamelCaseEventName(key)) {
+        const eventName = key.slice(2).toLowerCase();
+        const listener = isReadable(value) ? (e) => value.get()(e) : value;
+        element.addEventListener(eventName, listener);
+        this.stopCallbacks.push(() => {
+          element.removeEventListener(eventName, listener);
+        });
+      } else if (key.includes("-")) {
+        attachProp(
+          value,
+          (current) => {
+            if (current == null) {
+              element.removeAttribute(key);
+            } else {
+              element.setAttribute(key, String(current));
+            }
+          },
+          this.getUpdateKey("attr", key)
+        );
+      } else if (!privateProps.includes(key)) {
+        if (this.elementContext.isSVG) {
+          attachProp(
+            value,
+            (current) => {
+              if (current != null) {
+                element.setAttribute(key, String(props[key]));
+              } else {
+                element.removeAttribute(key);
+              }
+            },
+            this.getUpdateKey("attr", key)
+          );
+        } else {
+          switch (key) {
+            case "contentEditable":
+            case "value":
+              attachProp(
+                value,
+                (current) => {
+                  element[key] = String(current);
+                },
+                this.getUpdateKey("prop", key)
+              );
+              break;
+            case "for":
+              attachProp(
+                value,
+                (current) => {
+                  element.htmlFor = current;
+                },
+                this.getUpdateKey("prop", "htmlFor")
+              );
+              break;
+            case "checked":
+              attachProp(
+                value,
+                (current) => {
+                  element.checked = current;
+                  if (current) {
+                    element.setAttribute("checked", "");
+                  } else {
+                    element.removeAttribute("checked");
+                  }
+                },
+                this.getUpdateKey("prop", "checked")
+              );
+              break;
+            case "exportParts":
+            case "part":
+            case "translate":
+            case "title": {
+              const _key = key.toLowerCase();
+              attachProp(
+                value,
+                (current) => {
+                  if (current == void 0) {
+                    element.removeAttribute(_key);
+                  } else {
+                    element.setAttribute(_key, String(current));
+                  }
+                },
+                this.getUpdateKey("attr", _key)
+              );
+              break;
+            }
+            case "autocomplete":
+            case "autocapitalize":
+              attachProp(
+                value,
+                (current) => {
+                  if (typeof current === "string") {
+                    element.autocomplete = current;
+                  } else if (current) {
+                    element.autocomplete = "on";
+                  } else {
+                    element.autocomplete = "off";
+                  }
+                },
+                this.getUpdateKey("prop", key)
+              );
+              break;
+            default: {
+              attachProp(
+                value,
+                (current) => {
+                  element[key] = current;
+                },
+                this.getUpdateKey("prop", key)
+              );
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+  applyStyles(element, styles, stopCallbacks) {
+    const render = this.appContext.stores.get("render").instance?.exports;
+    const propStopCallbacks = [];
+    if (styles == void 0) {
+      element.style.cssText = "";
+    } else if (isReadable(styles)) {
+      let unapply;
+      const stop = observe(styles, (current) => {
+        render.update(() => {
+          if (isFunction(unapply)) {
+            unapply();
+          }
+          element.style.cssText = "";
+          unapply = this.applyStyles(element, current, stopCallbacks);
+        }, this.getUpdateKey("styles", "*"));
+      });
+      stopCallbacks.push(stop);
+      propStopCallbacks.push(stop);
+    } else if (isObject(styles)) {
+      styles = styles;
+      for (const key in styles) {
+        const value = styles[key];
+        const setProperty = key.startsWith("--") ? (key2, value2) => value2 == null ? element.style.removeProperty(key2) : element.style.setProperty(key2, value2) : (key2, value2) => element.style[key2] = value2 ?? "";
+        if (isReadable(value)) {
+          const stop = observe(value, (current) => {
+            render.update(() => {
+              if (current != null) {
+                setProperty(key, current);
+              } else {
+                element.style.removeProperty(key);
+              }
+            }, this.getUpdateKey("style", key));
+          });
+          stopCallbacks.push(stop);
+          propStopCallbacks.push(stop);
+        } else if (isString(value)) {
+          setProperty(key, value);
+        } else if (isNumber(value)) {
+          setProperty(key, value + "px");
+        } else {
+          throw new TypeError(`Style properties should be strings, $states or numbers. Got (${key}: ${value})`);
+        }
+      }
+    } else {
+      throw new TypeError(`Expected style property to be a string, $state, or object. Got: ${styles}`);
+    }
+    return function unapply() {
+      for (const stop of propStopCallbacks) {
+        stop();
+        stopCallbacks.splice(stopCallbacks.indexOf(stop), 1);
+      }
+    };
+  }
+  applyClasses(element, classes, stopCallbacks) {
+    const render = this.appContext.stores.get("render").instance?.exports;
+    const classStopCallbacks = [];
+    if (isReadable(classes)) {
+      let unapply;
+      const stop = observe(classes, (current) => {
+        render.update(() => {
+          if (isFunction(unapply)) {
+            unapply();
+          }
+          element.removeAttribute("class");
+          unapply = this.applyClasses(element, current, stopCallbacks);
+        }, this.getUpdateKey("attr", "class"));
+      });
+      stopCallbacks.push(stop);
+      classStopCallbacks.push(stop);
+    } else {
+      const mapped = getClassMap(classes);
+      for (const name in mapped) {
+        const value = mapped[name];
+        if (isReadable(value)) {
+          const stop = observe(value, (current) => {
+            render.update(() => {
+              if (current) {
+                element.classList.add(name);
+              } else {
+                element.classList.remove(name);
+              }
+            });
+          });
+          stopCallbacks.push(stop);
+          classStopCallbacks.push(stop);
+        } else if (value) {
+          element.classList.add(name);
+        }
+      }
+    }
+    return function unapply() {
+      for (const stop of classStopCallbacks) {
+        stop();
+        stopCallbacks.splice(stopCallbacks.indexOf(stop), 1);
+      }
+    };
+  }
+};
+function getClassMap(classes) {
+  let mapped = {};
+  if (isString(classes)) {
+    const names = classes.split(" ");
+    for (const name of names) {
+      mapped[name] = true;
+    }
+  } else if (isObject(classes)) {
+    Object.assign(mapped, classes);
+  } else if (Array.isArray(classes)) {
+    Array.from(classes).filter((item) => item != null).forEach((item) => {
+      Object.assign(mapped, getClassMap(item));
+    });
+  }
+  return mapped;
+}
+function toTypeOf(target, source) {
+  const type = typeof target;
+  if (type === "string") {
+    return String(source);
+  }
+  if (type === "number") {
+    return Number(source);
+  }
+  if (type === "boolean") {
+    return Boolean(source);
+  }
+  return source;
+}
+var privateProps = ["ref", "children", "class", "style", "data"];
+
+// src/nodes/observer.ts
+var Observer = class {
+  node;
+  endNode;
+  connectedViews = [];
+  renderFn;
+  appContext;
+  elementContext;
+  observerControls;
+  get connected() {
+    return this.node.parentNode != null;
+  }
+  constructor({ readables, renderFn, appContext, elementContext }) {
+    this.appContext = appContext;
+    this.elementContext = elementContext;
+    this.renderFn = renderFn;
+    this.node = document.createComment("Observer");
+    this.endNode = document.createComment("/Observer");
+    let _stop;
+    this.observerControls = {
+      start: () => {
+        if (_stop != null)
+          return;
+        _stop = observe(readables, (...values) => {
+          const rendered = this.renderFn(...values);
+          if (!isRenderable(rendered)) {
+            console.error(rendered);
+            throw new TypeError(
+              `Observer received invalid value to render. Got type: ${typeOf(rendered)}, value: ${rendered}`
+            );
+          }
+          if (Array.isArray(rendered)) {
+            this.update(...rendered);
+          } else {
+            this.update(rendered);
+          }
+        });
+      },
+      stop: () => {
+        if (_stop == null)
+          return;
+        _stop();
+        _stop = void 0;
+      }
+    };
+  }
+  connect(parent, after) {
+    if (!this.connected) {
+      parent.insertBefore(this.node, after?.nextSibling ?? null);
+      this.observerControls.start();
+    }
+  }
+  disconnect() {
+    this.observerControls.stop();
+    if (this.connected) {
+      this.cleanup();
+      this.node.parentNode?.removeChild(this.node);
+    }
+  }
+  async setChildren() {
+    console.warn("setChildren is not implemented for Dynamic");
+  }
+  cleanup() {
+    while (this.connectedViews.length > 0) {
+      this.connectedViews.pop()?.disconnect();
+    }
+  }
+  update(...children) {
+    this.cleanup();
+    if (children == null || !this.connected) {
+      return;
+    }
+    const handles = children.map((c) => {
+      if (isDOMHandle(c)) {
+        return c;
+      } else if (isMarkup(c)) {
+        return getRenderHandle(renderMarkupToDOM(c, this));
+      } else {
+        return getRenderHandle(renderMarkupToDOM(toMarkup(c), this));
+      }
+    });
+    for (const handle of handles) {
+      const previous = this.connectedViews.at(-1)?.node || this.node;
+      handle.connect(this.node.parentNode, previous);
+      this.connectedViews.push(handle);
+    }
+    if (this.appContext.mode === "development") {
+      const lastNode = this.connectedViews.at(-1)?.node;
+      if (this.endNode.previousSibling !== lastNode) {
+        this.node.parentNode.insertBefore(this.endNode, lastNode?.nextSibling ?? null);
+      }
+    }
+  }
+};
+
+// src/nodes/outlet.ts
+var Outlet = class {
+  node;
+  endNode;
+  $children;
+  stopCallback;
+  connectedChildren = [];
+  appContext;
+  elementContext;
+  constructor(config) {
+    this.$children = config.$children;
+    this.appContext = config.appContext;
+    this.elementContext = config.elementContext;
+    if (this.appContext.mode === "development") {
+      this.node = document.createComment("Outlet");
+      this.endNode = document.createComment("/Outlet");
+    } else {
+      this.node = document.createTextNode("");
+      this.endNode = document.createTextNode("");
+    }
+  }
+  get connected() {
+    return this.node?.parentNode != null;
+  }
+  connect(parent, after) {
+    if (!this.connected) {
+      parent.insertBefore(this.node, after?.nextSibling ?? null);
+      this.stopCallback = observe(this.$children, (children) => {
+        this.update(children);
+      });
+    }
+  }
+  disconnect() {
+    if (this.stopCallback) {
+      this.stopCallback();
+      this.stopCallback = void 0;
+    }
+    if (this.connected) {
+      for (const child of this.connectedChildren) {
+        child.disconnect();
+      }
+      this.connectedChildren = [];
+      this.endNode.parentNode?.removeChild(this.endNode);
+    }
+  }
+  update(newChildren) {
+    for (const child of this.connectedChildren) {
+      child.disconnect();
+    }
+    this.connectedChildren = newChildren;
+    for (let i = 0; i < this.connectedChildren.length; i++) {
+      const child = this.connectedChildren[i];
+      const previous = i > 0 ? this.connectedChildren[i] : void 0;
+      child.connect(this.node.parentElement, previous?.node);
+    }
+    if (this.appContext.mode === "development") {
+      this.node.textContent = `Outlet (${newChildren.length} ${newChildren.length === 1 ? "child" : "children"})`;
+      this.node.parentElement?.insertBefore(
+        this.endNode,
+        this.connectedChildren[this.connectedChildren.length - 1]?.node?.nextSibling ?? null
+      );
+    }
+  }
+  setChildren(children) {
+  }
+};
+
+// src/nodes/portal.ts
+var Portal = class {
+  config;
+  handle;
+  get connected() {
+    if (!this.handle) {
+      return false;
+    }
+    return this.handle.connected;
+  }
+  constructor(config) {
+    this.config = config;
+  }
+  connect(_parent, _after) {
+    const { content, parent } = this.config;
+    if (isDOMHandle(content)) {
+      this.handle = content;
+    } else if (isMarkup(content)) {
+      this.handle = getRenderHandle(renderMarkupToDOM(content, this.config));
+    } else {
+      this.handle = getRenderHandle(renderMarkupToDOM(toMarkup(content), this.config));
+    }
+    this.handle.connect(parent);
+  }
+  disconnect() {
+    if (this.handle?.connected) {
+      this.handle.disconnect();
+    }
+  }
+  setChildren(children) {
+    this.handle?.setChildren(children);
+  }
+};
+
+// src/view.ts
+var SECRETS = Symbol("VIEW_SECRETS");
+function getViewSecrets(ctx) {
+  return ctx[SECRETS];
+}
+function initView(config) {
+  const appContext = config.appContext;
+  const elementContext = {
+    ...config.elementContext,
+    stores: /* @__PURE__ */ new Map(),
+    parent: config.elementContext
+  };
+  const $$children = writable(renderMarkupToDOM(config.children ?? [], { appContext, elementContext }));
+  let isConnected = false;
+  const stopObserverCallbacks = [];
+  const connectedCallbacks = [];
+  const disconnectedCallbacks = [];
+  const beforeConnectCallbacks = [];
+  const beforeDisconnectCallbacks = [];
+  const uniqueId = nanoid();
+  const ctx = {
+    get uniqueId() {
+      return uniqueId;
+    },
+    name: config.view.name ?? "anonymous",
+    getStore(store) {
+      let name;
+      if (typeof store === "string") {
+        name = store;
+      } else {
+        name = store.name;
+      }
+      if (typeof store !== "string") {
+        let ec = elementContext;
+        while (ec) {
+          if (ec.stores.has(store)) {
+            return ec.stores.get(store)?.instance.exports;
+          }
+          ec = ec.parent;
+        }
+      }
+      if (appContext.stores.has(store)) {
+        const _store = appContext.stores.get(store);
+        if (!_store.instance) {
+          appContext.crashCollector.crash({
+            componentName: ctx.name,
+            error: new Error(`Store '${name}' is not registered on this app.`)
+          });
+        }
+        return _store.instance.exports;
+      }
+      appContext.crashCollector.crash({
+        componentName: ctx.name,
+        error: new Error(`Store '${name}' is not registered on this app.`)
+      });
+    },
+    onConnected(callback) {
+      connectedCallbacks.push(callback);
+    },
+    onDisconnected(callback) {
+      disconnectedCallbacks.push(callback);
+    },
+    beforeConnect(callback) {
+      beforeConnectCallbacks.push(callback);
+    },
+    beforeDisconnect(callback) {
+      beforeDisconnectCallbacks.push(callback);
+    },
+    crash(error) {
+      config.appContext.crashCollector.crash({ error, componentName: ctx.name });
+    },
+    observe(readables, callback) {
+      if (isConnected) {
+        const stop = observe(readables, callback);
+        stopObserverCallbacks.push(stop);
+      } else {
+        connectedCallbacks.push(() => {
+          const stop = observe(readables, callback);
+          stopObserverCallbacks.push(stop);
+        });
+      }
+    },
+    outlet() {
+      return m("$outlet", { $children: readable($$children) });
+    }
+  };
+  const debugChannel = appContext.debugHub.channel({
+    get name() {
+      return ctx.name;
+    }
+  });
+  Object.defineProperties(ctx, Object.getOwnPropertyDescriptors(debugChannel));
+  Object.defineProperty(ctx, SECRETS, {
+    enumerable: false,
+    configurable: false,
+    value: {
+      appContext,
+      elementContext
+    }
+  });
+  let rendered;
+  function initialize() {
+    let result;
+    try {
+      result = config.view(config.props, ctx);
+    } catch (error) {
+      if (error instanceof Error) {
+        appContext.crashCollector.crash({ error, componentName: ctx.name });
+      }
+      throw error;
+    }
+    if (result instanceof Promise) {
+      appContext.crashCollector.crash({
+        error: new TypeError(`View function cannot return a Promise.`),
+        componentName: ctx.name
+      });
+    }
+    if (result === null) {
+    } else if (result instanceof Node) {
+      rendered = getRenderHandle(renderMarkupToDOM(m("$node", { value: result }), { appContext, elementContext }));
+    } else if (isMarkup(result) || isArrayOf(isMarkup, result)) {
+      rendered = getRenderHandle(renderMarkupToDOM(result, { appContext, elementContext }));
+    } else if (isReadable(result)) {
+      rendered = getRenderHandle(
+        renderMarkupToDOM(m("$observer", { readables: [result], renderFn: (x) => x }), { appContext, elementContext })
+      );
+    } else {
+      console.warn(result, config);
+      appContext.crashCollector.crash({
+        error: new TypeError(
+          `Expected '${config.view.name}' function to return a DOM node, Markup element, Readable or null. Got: ${typeOf(result)}`
+        ),
+        componentName: ctx.name
+      });
+    }
+  }
+  const handle = {
+    get node() {
+      return rendered?.node;
+    },
+    get connected() {
+      return isConnected;
+    },
+    connect(parent, after) {
+      const wasConnected = isConnected;
+      if (!wasConnected) {
+        initialize();
+        while (beforeConnectCallbacks.length > 0) {
+          const callback = beforeConnectCallbacks.shift();
+          callback();
+        }
+      }
+      if (rendered) {
+        rendered.connect(parent, after);
+      }
+      if (!wasConnected) {
+        isConnected = true;
+        requestAnimationFrame(() => {
+          while (connectedCallbacks.length > 0) {
+            const callback = connectedCallbacks.shift();
+            callback();
+          }
+        });
+      }
+    },
+    disconnect() {
+      while (beforeDisconnectCallbacks.length > 0) {
+        const callback = beforeDisconnectCallbacks.shift();
+        callback();
+      }
+      if (rendered) {
+        rendered.disconnect();
+      }
+      isConnected = false;
+      while (disconnectedCallbacks.length > 0) {
+        const callback = disconnectedCallbacks.shift();
+        callback();
+      }
+      while (stopObserverCallbacks.length > 0) {
+        const callback = stopObserverCallbacks.shift();
+        callback();
+      }
+    },
+    async setChildren(children) {
+      $$children.set(children);
+    }
+  };
+  return handle;
+}
+
+// src/nodes/repeat.ts
+var Repeat = class {
+  node;
+  endNode;
+  $items;
+  stopCallback;
+  connectedItems = [];
+  appContext;
+  elementContext;
+  renderFn;
+  keyFn;
+  get connected() {
+    return this.node.parentNode != null;
+  }
+  constructor({ appContext, elementContext, $items, renderFn, keyFn }) {
+    this.appContext = appContext;
+    this.elementContext = elementContext;
+    this.$items = $items;
+    this.renderFn = renderFn;
+    this.keyFn = keyFn;
+    if (appContext.mode === "development") {
+      this.node = document.createComment("Repeat");
+      this.endNode = document.createComment("/Repeat");
+    } else {
+      this.node = document.createTextNode("");
+      this.endNode = document.createTextNode("");
+    }
+  }
+  connect(parent, after) {
+    if (!this.connected) {
+      parent.insertBefore(this.node, after?.nextSibling ?? null);
+      this.stopCallback = observe(this.$items, (value) => {
+        this._update(Array.from(value));
+      });
+    }
+  }
+  disconnect() {
+    if (this.stopCallback) {
+      this.stopCallback();
+      this.stopCallback = void 0;
+    }
+    if (this.connected) {
+      this.node.parentNode?.removeChild(this.node);
+      this.endNode.parentNode?.removeChild(this.endNode);
+    }
+    this._cleanup();
+  }
+  setChildren() {
+    console.warn("setChildren is not implemented for repeat()");
+  }
+  _cleanup() {
+    for (const item of this.connectedItems) {
+      item.handle.disconnect();
+    }
+    this.connectedItems = [];
+  }
+  _update(value) {
+    if (value.length === 0 || !this.connected) {
+      return this._cleanup();
+    }
+    const potentialItems = [];
+    let index = 0;
+    for (const item of value) {
+      potentialItems.push({
+        key: this.keyFn(item, index),
+        value: item,
+        index: index++
+      });
+    }
+    const newItems = [];
+    for (const connected of this.connectedItems) {
+      const potentialItem = potentialItems.find((p) => p.key === connected.key);
+      if (!potentialItem) {
+        connected.handle.disconnect();
+      }
+    }
+    for (const potential of potentialItems) {
+      const connected = this.connectedItems.find((item) => item.key === potential.key);
+      if (connected) {
+        connected.$$value.set(potential.value);
+        connected.$$index.set(potential.index);
+        newItems[potential.index] = connected;
+      } else {
+        const $$value = writable(potential.value);
+        const $$index = writable(potential.index);
+        newItems[potential.index] = {
+          key: potential.key,
+          $$value,
+          $$index,
+          handle: initView({
+            view: RepeatItemView,
+            appContext: this.appContext,
+            elementContext: this.elementContext,
+            props: { $value: readable($$value), $index: readable($$index), renderFn: this.renderFn }
+          })
+        };
+      }
+    }
+    for (let i = 0; i < newItems.length; i++) {
+      const item = newItems[i];
+      const previous = newItems[i - 1]?.handle.node ?? this.node;
+      item.handle.connect(this.node.parentNode, previous);
+    }
+    this.connectedItems = newItems;
+    if (this.appContext.mode === "development") {
+      this.node.textContent = `Repeat (${newItems.length} item${newItems.length === 1 ? "" : "s"})`;
+      const lastItem = newItems.at(-1)?.handle.node ?? this.node;
+      this.node.parentNode?.insertBefore(this.endNode, lastItem.nextSibling);
+    }
+  }
+};
+function RepeatItemView({ $value, $index, renderFn }, ctx) {
+  return renderFn($value, $index, ctx);
+}
+
+// src/nodes/text.ts
+var Text = class {
+  node = document.createTextNode("");
+  value = "";
+  stopCallback;
+  get connected() {
+    return this.node.parentNode != null;
+  }
+  constructor({ value }) {
+    this.value = value;
+  }
+  async connect(parent, after = null) {
+    if (!this.connected) {
+      if (isReadable(this.value)) {
+        this.stopCallback = observe(this.value, (value) => {
+          this.update(value);
+        });
+      } else {
+        this.update(this.value);
+      }
+    }
+    parent.insertBefore(this.node, after?.nextSibling ?? null);
+  }
+  async disconnect() {
+    if (this.connected) {
+      if (this.stopCallback) {
+        this.stopCallback();
+        this.stopCallback = void 0;
+      }
+      this.node.parentNode.removeChild(this.node);
+    }
+  }
+  update(value) {
+    if (value != null) {
+      this.node.textContent = value.toString();
+    } else {
+      this.node.textContent = "";
+    }
+  }
+  async setChildren() {
+  }
+};
+
+// src/markup.ts
+var MARKUP = Symbol("Markup");
+function isMarkup(value) {
+  return isObject(value) && value[MARKUP] === true;
+}
+function isDOMHandle(value) {
+  return isObject(value) && isFunction(value.connect) && isFunction(value.disconnect);
+}
+function toMarkup(renderables) {
+  if (!isArray(renderables)) {
+    renderables = [renderables];
+  }
+  return renderables.flat(Infinity).filter((x) => x !== null && x !== void 0 && x !== false).map((x) => {
+    if (x instanceof Node) {
+      return m("$node", { value: x });
+    }
+    if (isMarkup(x)) {
+      return x;
+    }
+    if (isString(x) || isNumber(x)) {
+      return m("$text", { value: x });
+    }
+    if (isReadable(x)) {
+      return m("$observer", {
+        readables: [x],
+        renderFn: (x2) => x2
+      });
+    }
+    console.error(x);
+    throw new TypeError(`Unexpected child type. Got: ${x}`);
+  });
+}
+function m(type, props, ...children) {
+  return {
+    [MARKUP]: true,
+    type,
+    props,
+    children: toMarkup(children)
+  };
+}
+function cond(predicate, thenContent, elseContent) {
+  const $predicate = readable(predicate);
+  return m("$cond", {
+    $predicate,
+    thenContent,
+    elseContent
+  });
+}
+function repeat(items, keyFn, renderFn) {
+  const $items = readable(items);
+  return m("$repeat", { $items, keyFn, renderFn });
+}
+function portal(content, parent) {
+  return m("$portal", { content, parent });
+}
+var NodeHandle = class {
+  node;
+  get connected() {
+    return this.node.parentNode != null;
+  }
+  constructor(node) {
+    this.node = node;
+  }
+  async connect(parent, after) {
+    parent.insertBefore(this.node, after?.nextSibling ?? null);
+  }
+  async disconnect() {
+    if (this.node.parentNode) {
+      this.node.parentNode.removeChild(this.node);
+    }
+  }
+  async setChildren(children) {
+  }
+};
+function renderMarkupToDOM(markup, ctx) {
+  const items = isArray(markup) ? markup : [markup];
+  return items.map((item) => {
+    if (isFunction(item.type)) {
+      return initView({
+        view: item.type,
+        props: item.props,
+        children: item.children,
+        appContext: ctx.appContext,
+        elementContext: ctx.elementContext
+      });
+    } else if (isString(item.type)) {
+      switch (item.type) {
+        case "$node": {
+          const attrs = item.props;
+          return new NodeHandle(attrs.value);
+        }
+        case "$text": {
+          const attrs = item.props;
+          return new Text({
+            value: attrs.value
+          });
+        }
+        case "$cond": {
+          const attrs = item.props;
+          return new Conditional({
+            $predicate: attrs.$predicate,
+            thenContent: attrs.thenContent,
+            elseContent: attrs.elseContent,
+            appContext: ctx.appContext,
+            elementContext: ctx.elementContext
+          });
+        }
+        case "$repeat": {
+          const attrs = item.props;
+          return new Repeat({
+            $items: attrs.$items,
+            keyFn: attrs.keyFn,
+            renderFn: attrs.renderFn,
+            appContext: ctx.appContext,
+            elementContext: ctx.elementContext
+          });
+        }
+        case "$observer": {
+          const attrs = item.props;
+          return new Observer({
+            readables: attrs.readables,
+            renderFn: attrs.renderFn,
+            appContext: ctx.appContext,
+            elementContext: ctx.elementContext
+          });
+        }
+        case "$outlet": {
+          const attrs = item.props;
+          return new Outlet({
+            $children: attrs.$children,
+            appContext: ctx.appContext,
+            elementContext: ctx.elementContext
+          });
+        }
+        case "$portal": {
+          const attrs = item.props;
+          return new Portal({
+            content: attrs.content,
+            parent: attrs.parent,
+            appContext: ctx.appContext,
+            elementContext: ctx.elementContext
+          });
+        }
+        default:
+          if (item.type.startsWith("$")) {
+            throw new Error(`Unknown markup type: ${item.type}`);
+          }
+          return new HTML({
+            tag: item.type,
+            props: item.props,
+            children: item.children,
+            appContext: ctx.appContext,
+            elementContext: ctx.elementContext
+          });
+      }
+    } else {
+      throw new TypeError(`Expected a string or view function. Got: ${item.type}`);
+    }
+  });
+}
+function getRenderHandle(handles) {
+  if (handles.length === 1) {
+    return handles[0];
+  }
+  const node = document.createComment("renderHandle");
+  let isConnected = false;
+  return {
+    get node() {
+      return node;
+    },
+    get connected() {
+      return isConnected;
+    },
+    async connect(parent, after) {
+      parent.insertBefore(node, after ? after : null);
+      for (const handle of handles) {
+        const previous = handles[handles.length - 1]?.node ?? node;
+        await handle.connect(parent, previous);
+      }
+      isConnected = true;
+    },
+    async disconnect() {
+      if (isConnected) {
+        for (const handle of handles) {
+          handle.disconnect();
+        }
+        node.remove();
+      }
+      isConnected = false;
+    },
+    async setChildren() {
+    }
+  };
+}
+function isRenderable(value) {
+  return value == null || value === false || typeof value === "string" || typeof value === "number" || isMarkup(value) || isReadable(value) || isArrayOf(isRenderable, value);
+}
+
+// src/store.ts
+var SECRETS2 = Symbol("STORE_SECRETS");
+function getStoreSecrets(c) {
+  return c[SECRETS2];
+}
+function initStore(config) {
+  const appContext = config.appContext;
+  const elementContext = config.elementContext;
+  let isConnected = false;
+  const stopObserverCallbacks = [];
+  const connectedCallbacks = [];
+  const disconnectedCallbacks = [];
+  const ctx = {
+    name: config.store.name ?? "anonymous",
+    options: config.options,
+    getStore(store) {
+      let name;
+      if (typeof store === "string") {
+        name = store;
+      } else {
+        name = store.name;
+      }
+      if (typeof store !== "string") {
+        let ec = elementContext;
+        while (ec) {
+          if (ec.stores.has(store)) {
+            return ec.stores.get(store)?.instance.exports;
+          }
+          ec = ec.parent;
+        }
+      }
+      if (appContext.stores.has(store)) {
+        const _store = appContext.stores.get(store);
+        if (!_store.instance) {
+          appContext.crashCollector.crash({
+            componentName: ctx.name,
+            error: new Error(
+              `Store '${name}' was accessed before it was set up. Make sure '${name}' is registered before components that access it.`
+            )
+          });
+        }
+        return _store.instance.exports;
+      }
+      appContext.crashCollector.crash({
+        componentName: ctx.name,
+        error: new Error(`Store '${name}' is not registered on this app.`)
+      });
+    },
+    onConnected(callback) {
+      connectedCallbacks.push(callback);
+    },
+    onDisconnected(callback) {
+      disconnectedCallbacks.push(callback);
+    },
+    crash(error) {
+      config.appContext.crashCollector.crash({ error, componentName: ctx.name });
+    },
+    observe(readables, callback) {
+      if (isConnected) {
+        const stop = observe(readables, callback);
+        stopObserverCallbacks.push(stop);
+      } else {
+        connectedCallbacks.push(() => {
+          const stop = observe(readables, callback);
+          stopObserverCallbacks.push(stop);
+        });
+      }
+    }
+  };
+  const debugChannel = appContext.debugHub.channel({
+    get name() {
+      return ctx.name;
+    }
+  });
+  Object.defineProperties(ctx, Object.getOwnPropertyDescriptors(debugChannel));
+  Object.defineProperty(ctx, SECRETS2, {
+    enumerable: false,
+    configurable: false,
+    value: {
+      appContext,
+      elementContext
+    }
+  });
+  let exports;
+  return {
+    get name() {
+      return ctx.name;
+    },
+    get exports() {
+      return exports;
+    },
+    setup() {
+      let result;
+      try {
+        result = config.store(ctx);
+      } catch (error) {
+        if (error instanceof Error) {
+          appContext.crashCollector.crash({ error, componentName: ctx.name });
+        } else {
+          throw error;
+        }
+      }
+      if (result instanceof Promise) {
+        appContext.crashCollector.crash({
+          error: new TypeError(`Store function cannot return a Promise`),
+          componentName: ctx.name
+        });
+      }
+      if (!isObject(result)) {
+        const error = new TypeError(`Expected ${ctx.name} function to return an object. Got: ${typeOf(result)}`);
+        appContext.crashCollector.crash({ error, componentName: ctx.name });
+      }
+      exports = result;
+    },
+    connect() {
+      while (connectedCallbacks.length > 0) {
+        const callback = connectedCallbacks.shift();
+        callback();
+      }
+    },
+    disconnect() {
+      while (disconnectedCallbacks.length > 0) {
+        const callback = disconnectedCallbacks.shift();
+        callback();
+      }
+    }
+  };
+}
+
+// src/stores/dialog.ts
+function DialogStore(ctx) {
+  ctx.name = "dolla/dialog";
+  const { appContext, elementContext } = getStoreSecrets(ctx);
+  const container = document.createElement("div");
+  container.style.position = "fixed";
+  container.style.top = "0";
+  container.style.right = "0";
+  container.style.bottom = "0";
+  container.style.left = "0";
+  container.style.zIndex = "99999";
+  const $$dialogs = writable([]);
+  let activeDialogs = [];
+  function dialogChangedCallback() {
+    if (activeDialogs.length > 0) {
+      if (!container.parentNode) {
+        document.body.appendChild(container);
+      }
+    } else {
+      if (container.parentNode) {
+        document.body.removeChild(container);
+      }
+    }
+  }
+  ctx.observe($$dialogs, (dialogs) => {
+    requestAnimationFrame(() => {
+      let removed = [];
+      let added = [];
+      for (const dialog of activeDialogs) {
+        if (!dialogs.includes(dialog)) {
+          removed.push(dialog);
+        }
+      }
+      for (const dialog of dialogs) {
+        if (!activeDialogs.includes(dialog)) {
+          added.push(dialog);
+        }
+      }
+      for (const dialog of removed) {
+        if (dialog.transitionOutCallback) {
+          dialog.transitionOutCallback().then(() => {
+            dialog.instance.disconnect();
+            activeDialogs.splice(activeDialogs.indexOf(dialog), 1);
+            dialogChangedCallback();
+          });
+        } else {
+          dialog.instance.disconnect();
+          activeDialogs.splice(activeDialogs.indexOf(dialog), 1);
+        }
+      }
+      for (const dialog of added) {
+        dialog.instance.connect(container);
+        if (dialog.transitionInCallback) {
+          dialog.transitionInCallback();
+        }
+        activeDialogs.push(dialog);
+      }
+      dialogChangedCallback();
+    });
+  });
+  ctx.onDisconnected(() => {
+    if (container.parentNode) {
+      document.body.removeChild(container);
+    }
+  });
+  function open(view, props) {
+    const $$open = writable(true);
+    let dialog;
+    let transitionInCallback;
+    let transitionOutCallback;
+    let instance = initView({
+      view,
+      appContext,
+      elementContext,
+      props: {
+        ...props,
+        $$open,
+        transitionIn: (callback) => {
+          transitionInCallback = callback;
+        },
+        transitionOut: (callback) => {
+          transitionOutCallback = callback;
+        }
+      }
+    });
+    dialog = {
+      instance,
+      // These must be getters because the fns passed to props aren't called until before connect.
+      get transitionInCallback() {
+        return transitionInCallback;
+      },
+      get transitionOutCallback() {
+        return transitionOutCallback;
+      }
+    };
+    $$dialogs.update((current) => {
+      return [...current, dialog];
+    });
+    const stopObserver = observe($$open, (value) => {
+      if (!value) {
+        closeDialog();
+      }
+    });
+    function closeDialog() {
+      $$dialogs.update((current) => {
+        return current.filter((x) => x !== dialog);
+      });
+      dialog = void 0;
+      stopObserver();
+    }
+    return closeDialog;
+  }
+  return {
+    open
+  };
+}
+
+// src/stores/document.ts
+function DocumentStore(ctx) {
+  ctx.name = "dolla/document";
+  const $$title = writable(document.title);
+  const $$visibility = writable(document.visibilityState);
+  const $$orientation = writable("landscape");
+  const $$colorScheme = writable("light");
+  ctx.observe($$title, (current) => {
+    document.title = current;
+  });
+  const onVisibilityChange = () => {
+    $$visibility.set(document.visibilityState);
+  };
+  const onFocus = () => {
+    $$visibility.set("visible");
+  };
+  const landscapeQuery = window.matchMedia("(orientation: landscape)");
+  function onOrientationChange(e) {
+    $$orientation.set(e.matches ? "landscape" : "portrait");
+  }
+  onOrientationChange(landscapeQuery);
+  const colorSchemeQuery = window.matchMedia("(prefers-color-scheme: dark)");
+  function onColorChange(e) {
+    $$colorScheme.set(e.matches ? "dark" : "light");
+  }
+  onColorChange(colorSchemeQuery);
+  ctx.onConnected(function() {
+    landscapeQuery.addEventListener("change", onOrientationChange);
+    colorSchemeQuery.addEventListener("change", onColorChange);
+    document.addEventListener("visibilitychange", onVisibilityChange);
+    window.addEventListener("focus", onFocus);
+  });
+  ctx.onDisconnected(function() {
+    landscapeQuery.removeEventListener("change", onOrientationChange);
+    colorSchemeQuery.removeEventListener("change", onColorChange);
+    document.removeEventListener("visibilitychange", onVisibilityChange);
+    window.removeEventListener("focus", onFocus);
+  });
+  return {
+    $$title,
+    $visibility: readable($$visibility),
+    $orientation: readable($$orientation),
+    $colorScheme: readable($$colorScheme)
+  };
+}
+
+// src/stores/http.ts
+function HTTPStore(ctx) {
+  ctx.name = "dolla/http";
+  const fetch = ctx.options.fetch ?? getDefaultFetch();
+  const middleware = [];
+  async function request(method, uri, options) {
+    return makeRequest({ ...options, method, uri, middleware, fetch });
+  }
+  return {
+    /**
+     * 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.
+     */
+    middleware(fn) {
+      middleware.push(fn);
+      return function remove() {
+        middleware.splice(middleware.indexOf(fn), 1);
+      };
+    },
+    async get(uri, options) {
+      return request("get", uri, options);
+    },
+    async put(uri, options) {
+      return request("put", uri, options);
+    },
+    async patch(uri, options) {
+      return request("patch", uri, options);
+    },
+    async post(uri, options) {
+      return request("post", uri, options);
+    },
+    async delete(uri, options) {
+      return request("delete", uri, options);
+    },
+    async head(uri, options) {
+      return request("head", uri, options);
+    },
+    async options(uri, options) {
+      return request("options", uri, options);
+    },
+    async trace(uri, options) {
+      return request("trace", uri, options);
+    }
+  };
+}
+function getDefaultFetch() {
+  if (typeof window !== "undefined" && window.fetch) {
+    return window.fetch.bind(window);
+  }
+  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.");
+}
+var HTTPResponseError = class extends Error {
+  response;
+  constructor(response) {
+    const { status, statusText, method, uri } = response;
+    const message = `${status} ${statusText}: Request failed (${method.toUpperCase()} ${uri})`;
+    super(message);
+    this.response = response;
+  }
+};
+async function makeRequest(config) {
+  const { headers, query, fetch, middleware } = config;
+  const request = {
+    method: config.method,
+    uri: config.uri,
+    get sameOrigin() {
+      return !request.uri.startsWith("http");
+    },
+    query: new URLSearchParams(),
+    headers: new Headers(),
+    body: config.body
+  };
+  if (headers) {
+    if (headers instanceof Map || headers instanceof Headers) {
+      headers.forEach((value, key) => {
+        request.headers.set(key, value);
+      });
+    } else if (headers != null && typeof headers === "object" && !Array.isArray(headers)) {
+      for (const name in headers) {
+        request.headers.set(name, String(headers[name]));
+      }
+    } else {
+      throw new TypeError(`Unknown headers type. Got: ${headers}`);
+    }
+  }
+  if (query) {
+    if (query instanceof Map || query instanceof URLSearchParams) {
+      query.forEach((value, key) => {
+        request.query.set(key, value);
+      });
+    } else if (query != null && typeof query === "object" && !Array.isArray(query)) {
+      for (const name in query) {
+        request.query.set(name, String(query[name]));
+      }
+    } else {
+      throw new TypeError(`Unknown query params type. Got: ${query}`);
+    }
+  }
+  let response;
+  const handler = async () => {
+    const query2 = request.query.toString();
+    const fullURL = request.query.keys.length > 0 ? request.uri + "?" + query2 : request.uri;
+    let reqBody;
+    if (!request.headers.has("content-type") && isObject(request.body)) {
+      request.headers.set("content-type", "application/json");
+      reqBody = JSON.stringify(request.body);
+    } else {
+      reqBody = request.body;
+    }
+    const fetched = await fetch(fullURL, {
+      method: request.method,
+      headers: request.headers,
+      body: reqBody
+    });
+    const headers2 = Object.fromEntries(fetched.headers.entries());
+    const contentType = headers2["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();
+    }
+    response = {
+      method: request.method,
+      uri: request.uri,
+      status: fetched.status,
+      statusText: fetched.statusText,
+      headers: headers2,
+      body
+    };
+  };
+  if (middleware.length > 0) {
+    const mount = (index = 0) => {
+      const current = middleware[index];
+      const next = middleware[index + 1] ? mount(index + 1) : handler;
+      return async () => current(request, async () => {
+        await next();
+        return response;
+      });
+    };
+    await mount()();
+  } else {
+    await handler();
+  }
+  if (response.status < 200 || response.status >= 400) {
+    throw new HTTPResponseError(response);
+  }
+  return response;
+}
+
+// src/stores/language.ts
+function LanguageStore(ctx) {
+  ctx.name = "dolla/language";
+  const languages = /* @__PURE__ */ new Map();
+  Object.entries(ctx.options.languages).forEach(([tag, config]) => {
+    languages.set(tag, new Language(tag, config));
+  });
+  ctx.info(
+    `App supports ${languages.size} language${languages.size === 1 ? "" : "s"}: '${[...languages.keys()].join("', '")}'`
+  );
+  const $$isLoaded = writable(false);
+  const $$language = writable(void 0);
+  const $$translation = writable(void 0);
+  const $noLanguageValue = readable("[NO LANGUAGE SET]");
+  const translationCache = [];
+  function getCached(key, values) {
+    for (const entry of translationCache) {
+      if (entry[0] === key && deepEqual(entry[1], values)) {
+        return entry[2];
+      }
+    }
+  }
+  function replaceMustaches(template, values) {
+    for (const name in values) {
+      template = template.replace(`{{${name}}}`, String(values[name]));
+    }
+    return template;
+  }
+  const currentLanguage = ctx.options.currentLanguage ? languages.get(ctx.options.currentLanguage) : languages.get([...languages.keys()][0]);
+  if (currentLanguage == null) {
+    $$isLoaded.set(true);
+  } else {
+    ctx.info(`Current language is '${currentLanguage.tag}'.`);
+    currentLanguage.getTranslation().then((translation) => {
+      $$language.set(currentLanguage.tag);
+      $$translation.set(translation);
+      $$isLoaded.set(true);
+    });
+  }
+  return {
+    $isLoaded: readable($$isLoaded),
+    $currentLanguage: readable($$language),
+    supportedLanguages: [...languages.keys()],
+    async setLanguage(tag) {
+      if (!languages.has(tag)) {
+        throw new Error(`Language '${tag}' is not supported.`);
+      }
+      const lang = languages.get(tag);
+      try {
+        const translation = await lang.getTranslation();
+        $$translation.set(translation);
+        $$language.set(tag);
+        ctx.info("set language to " + tag);
+      } catch (error) {
+        if (error instanceof Error) {
+          ctx.crash(error);
+        }
+      }
+    },
+    /**
+         * Returns a Readable of the translated value.
+    
+         * @param key - Key to the translated value.
+         * @param values - A map of {{placeholder}} names and the values to replace them with.
+         */
+    translate(key, values) {
+      if (!$$language.get()) {
+        return $noLanguageValue;
+      }
+      const cached = getCached(key, values);
+      if (cached) {
+        return cached;
+      }
+      if (values) {
+        const readableValues = {};
+        for (const [key2, value] of Object.entries(values)) {
+          if (typeof value?.observe === "function") {
+            readableValues[key2] = value;
+          }
+        }
+        const readableEntries = Object.entries(readableValues);
+        if (readableEntries.length > 0) {
+          const $merged = computed([$$translation, ...readableEntries.map((x) => x[1])], ([t, ...entryValues]) => {
+            const entries = entryValues.map((_, i) => readableEntries[i]);
+            const mergedValues = {
+              ...values
+            };
+            for (let i = 0; i < entries.length; i++) {
+              const key2 = entries[i][0];
+              mergedValues[key2] = entryValues[i];
+            }
+            const result = resolve(t, key) || `[NO TRANSLATION: ${key}]`;
+            return replaceMustaches(result, mergedValues);
+          });
+          translationCache.push([key, values, $merged]);
+          return $merged;
+        }
+      }
+      const $replaced = computed($$translation, (t) => {
+        let result = resolve(t, key) || `[NO TRANSLATION: ${key}]`;
+        if (values) {
+          result = replaceMustaches(result, values);
+        }
+        return result;
+      });
+      translationCache.push([key, values, $replaced]);
+      return $replaced;
+    }
+  };
+}
+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 {
+      value = void 0;
+    }
+  }
+  return value;
+}
+var Language = class {
+  #tag;
+  #config;
+  #translation;
+  get tag() {
+    return this.#tag;
+  }
+  constructor(tag, config) {
+    this.#tag = tag;
+    this.#config = config;
+  }
+  async getTranslation() {
+    if (!this.#translation) {
+      if (isFunction(this.#config.translation)) {
+        const result = this.#config.translation();
+        if (isPromise(result)) {
+          const resolved = await result;
+          assertObject(
+            resolved,
+            `Translation promise of language '${this.#tag}' must resolve to an object of translated strings. Got type: %t, value: %v`
+          );
+          this.#translation = resolved;
+        } else if (isObject(result)) {
+          this.#translation = result;
+        } else {
+          throw new TypeError(
+            `Translation function of '${this.#tag}' must return an object or promise. Got type: ${typeOf(
+              result
+            )}, value: ${result}`
+          );
+        }
+      } else if (isObject(this.#config.translation)) {
+        this.#translation = this.#config.translation;
+      } else {
+        throw new TypeError(
+          `Translation of '${this.#tag}' must be an object of translated strings, a function that returns one, or an async function that resolves to one. Got type: ${typeOf(
+            this.#config.translation
+          )}, value: ${this.#config.translation}`
+        );
+      }
+    }
+    return this.#translation;
+  }
+};
+
+// src/stores/render.ts
+function RenderStore(ctx) {
+  ctx.name = "dolla/render";
+  const keyedUpdates = /* @__PURE__ */ new Map();
+  let unkeyedUpdates = [];
+  let reads = [];
+  let isUpdating = false;
+  let isConnected = false;
+  ctx.onConnected(() => {
+    isConnected = true;
+  });
+  ctx.onDisconnected(() => {
+    isConnected = false;
+  });
+  function runUpdates() {
+    const totalQueued = keyedUpdates.size + unkeyedUpdates.length;
+    if (!isConnected || totalQueued === 0) {
+      isUpdating = false;
+    }
+    if (!isUpdating) {
+      for (const callback of reads) {
+        callback();
+      }
+      reads = [];
+      return;
+    }
+    requestAnimationFrame(() => {
+      ctx.info(`Batching ${keyedUpdates.size + unkeyedUpdates.length} queued DOM update(s).`);
+      for (const callback of keyedUpdates.values()) {
+        callback();
+      }
+      keyedUpdates.clear();
+      for (const callback of unkeyedUpdates) {
+        callback();
+      }
+      unkeyedUpdates = [];
+      runUpdates();
+    });
+  }
+  return {
+    /**
+     * 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(callback, key) {
+      return new Promise((resolve2) => {
+        if (key) {
+          keyedUpdates.set(key, () => {
+            callback();
+            resolve2();
+          });
+        } else {
+          unkeyedUpdates.push(() => {
+            callback();
+            resolve2();
+          });
+        }
+        if (!isUpdating && isConnected) {
+          isUpdating = true;
+          runUpdates();
+        }
+      });
+    },
+    /**
+     * 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.
+     */
+    read(callback) {
+      return new Promise((resolve2) => {
+        reads.push(() => {
+          callback();
+          resolve2();
+        });
+        if (!isUpdating && isConnected) {
+          isUpdating = true;
+          runUpdates();
+        }
+      });
+    }
+  };
+}
+
+// node_modules/@babel/runtime/helpers/esm/extends.js
+function _extends() {
+  _extends = Object.assign || function(target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+
+// node_modules/history/index.js
+var Action;
+(function(Action2) {
+  Action2["Pop"] = "POP";
+  Action2["Push"] = "PUSH";
+  Action2["Replace"] = "REPLACE";
+})(Action || (Action = {}));
+var readOnly = true ? function(obj) {
+  return Object.freeze(obj);
+} : function(obj) {
+  return obj;
+};
+function warning(cond2, message) {
+  if (!cond2) {
+    if (typeof console !== "undefined")
+      console.warn(message);
+    try {
+      throw new Error(message);
+    } catch (e) {
+    }
+  }
+}
+var BeforeUnloadEventType = "beforeunload";
+var HashChangeEventType = "hashchange";
+var PopStateEventType = "popstate";
+function createBrowserHistory(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _options = options, _options$window = _options.window, window2 = _options$window === void 0 ? document.defaultView : _options$window;
+  var globalHistory = window2.history;
+  function getIndexAndLocation() {
+    var _window$location = window2.location, pathname = _window$location.pathname, search = _window$location.search, hash2 = _window$location.hash;
+    var state = globalHistory.state || {};
+    return [state.idx, readOnly({
+      pathname,
+      search,
+      hash: hash2,
+      state: state.usr || null,
+      key: state.key || "default"
+    })];
+  }
+  var blockedPopTx = null;
+  function handlePop() {
+    if (blockedPopTx) {
+      blockers.call(blockedPopTx);
+      blockedPopTx = null;
+    } else {
+      var nextAction = Action.Pop;
+      var _getIndexAndLocation = getIndexAndLocation(), nextIndex = _getIndexAndLocation[0], nextLocation = _getIndexAndLocation[1];
+      if (blockers.length) {
+        if (nextIndex != null) {
+          var delta = index - nextIndex;
+          if (delta) {
+            blockedPopTx = {
+              action: nextAction,
+              location: nextLocation,
+              retry: function retry() {
+                go(delta * -1);
+              }
+            };
+            go(delta);
+          }
+        } else {
+          true ? warning(
+            false,
+            // 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."
+          ) : void 0;
+        }
+      } else {
+        applyTx(nextAction);
+      }
+    }
+  }
+  window2.addEventListener(PopStateEventType, handlePop);
+  var action = Action.Pop;
+  var _getIndexAndLocation2 = getIndexAndLocation(), index = _getIndexAndLocation2[0], location = _getIndexAndLocation2[1];
+  var listeners = createEvents();
+  var blockers = createEvents();
+  if (index == null) {
+    index = 0;
+    globalHistory.replaceState(_extends({}, globalHistory.state, {
+      idx: index
+    }), "");
+  }
+  function createHref(to) {
+    return typeof to === "string" ? to : createPath(to);
+  }
+  function getNextLocation(to, state) {
+    if (state === void 0) {
+      state = null;
+    }
+    return readOnly(_extends({
+      pathname: location.pathname,
+      hash: "",
+      search: ""
+    }, typeof to === "string" ? parsePath(to) : to, {
+      state,
+      key: createKey()
+    }));
+  }
+  function getHistoryStateAndUrl(nextLocation, index2) {
+    return [{
+      usr: nextLocation.state,
+      key: nextLocation.key,
+      idx: index2
+    }, createHref(nextLocation)];
+  }
+  function allowTx(action2, location2, retry) {
+    return !blockers.length || (blockers.call({
+      action: action2,
+      location: location2,
+      retry
+    }), false);
+  }
+  function applyTx(nextAction) {
+    action = nextAction;
+    var _getIndexAndLocation3 = getIndexAndLocation();
+    index = _getIndexAndLocation3[0];
+    location = _getIndexAndLocation3[1];
+    listeners.call({
+      action,
+      location
+    });
+  }
+  function push(to, state) {
+    var nextAction = Action.Push;
+    var nextLocation = getNextLocation(to, state);
+    function retry() {
+      push(to, state);
+    }
+    if (allowTx(nextAction, nextLocation, retry)) {
+      var _getHistoryStateAndUr = getHistoryStateAndUrl(nextLocation, index + 1), historyState = _getHistoryStateAndUr[0], url = _getHistoryStateAndUr[1];
+      try {
+        globalHistory.pushState(historyState, "", url);
+      } catch (error) {
+        window2.location.assign(url);
+      }
+      applyTx(nextAction);
+    }
+  }
+  function replace(to, state) {
+    var nextAction = Action.Replace;
+    var nextLocation = getNextLocation(to, state);
+    function retry() {
+      replace(to, state);
+    }
+    if (allowTx(nextAction, nextLocation, retry)) {
+      var _getHistoryStateAndUr2 = getHistoryStateAndUrl(nextLocation, index), historyState = _getHistoryStateAndUr2[0], url = _getHistoryStateAndUr2[1];
+      globalHistory.replaceState(historyState, "", url);
+      applyTx(nextAction);
+    }
+  }
+  function go(delta) {
+    globalHistory.go(delta);
+  }
+  var history = {
+    get action() {
+      return action;
+    },
+    get location() {
+      return location;
+    },
+    createHref,
+    push,
+    replace,
+    go,
+    back: function back() {
+      go(-1);
+    },
+    forward: function forward() {
+      go(1);
+    },
+    listen: function listen(listener) {
+      return listeners.push(listener);
+    },
+    block: function block(blocker) {
+      var unblock = blockers.push(blocker);
+      if (blockers.length === 1) {
+        window2.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
+      }
+      return function() {
+        unblock();
+        if (!blockers.length) {
+          window2.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
+        }
+      };
+    }
+  };
+  return history;
+}
+function createHashHistory(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  var _options2 = options, _options2$window = _options2.window, window2 = _options2$window === void 0 ? document.defaultView : _options2$window;
+  var globalHistory = window2.history;
+  function getIndexAndLocation() {
+    var _parsePath = parsePath(window2.location.hash.substr(1)), _parsePath$pathname = _parsePath.pathname, pathname = _parsePath$pathname === void 0 ? "/" : _parsePath$pathname, _parsePath$search = _parsePath.search, search = _parsePath$search === void 0 ? "" : _parsePath$search, _parsePath$hash = _parsePath.hash, hash2 = _parsePath$hash === void 0 ? "" : _parsePath$hash;
+    var state = globalHistory.state || {};
+    return [state.idx, readOnly({
+      pathname,
+      search,
+      hash: hash2,
+      state: state.usr || null,
+      key: state.key || "default"
+    })];
+  }
+  var blockedPopTx = null;
+  function handlePop() {
+    if (blockedPopTx) {
+      blockers.call(blockedPopTx);
+      blockedPopTx = null;
+    } else {
+      var nextAction = Action.Pop;
+      var _getIndexAndLocation4 = getIndexAndLocation(), nextIndex = _getIndexAndLocation4[0], nextLocation = _getIndexAndLocation4[1];
+      if (blockers.length) {
+        if (nextIndex != null) {
+          var delta = index - nextIndex;
+          if (delta) {
+            blockedPopTx = {
+              action: nextAction,
+              location: nextLocation,
+              retry: function retry() {
+                go(delta * -1);
+              }
+            };
+            go(delta);
+          }
+        } else {
+          true ? warning(
+            false,
+            // 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."
+          ) : void 0;
+        }
+      } else {
+        applyTx(nextAction);
+      }
+    }
+  }
+  window2.addEventListener(PopStateEventType, handlePop);
+  window2.addEventListener(HashChangeEventType, function() {
+    var _getIndexAndLocation5 = getIndexAndLocation(), nextLocation = _getIndexAndLocation5[1];
+    if (createPath(nextLocation) !== createPath(location)) {
+      handlePop();
+    }
+  });
+  var action = Action.Pop;
+  var _getIndexAndLocation6 = getIndexAndLocation(), index = _getIndexAndLocation6[0], location = _getIndexAndLocation6[1];
+  var listeners = createEvents();
+  var blockers = createEvents();
+  if (index == null) {
+    index = 0;
+    globalHistory.replaceState(_extends({}, globalHistory.state, {
+      idx: index
+    }), "");
+  }
+  function getBaseHref() {
+    var base = document.querySelector("base");
+    var href = "";
+    if (base && base.getAttribute("href")) {
+      var url = window2.location.href;
+      var hashIndex = url.indexOf("#");
+      href = hashIndex === -1 ? url : url.slice(0, hashIndex);
+    }
+    return href;
+  }
+  function createHref(to) {
+    return getBaseHref() + "#" + (typeof to === "string" ? to : createPath(to));
+  }
+  function getNextLocation(to, state) {
+    if (state === void 0) {
+      state = null;
+    }
+    return readOnly(_extends({
+      pathname: location.pathname,
+      hash: "",
+      search: ""
+    }, typeof to === "string" ? parsePath(to) : to, {
+      state,
+      key: createKey()
+    }));
+  }
+  function getHistoryStateAndUrl(nextLocation, index2) {
+    return [{
+      usr: nextLocation.state,
+      key: nextLocation.key,
+      idx: index2
+    }, createHref(nextLocation)];
+  }
+  function allowTx(action2, location2, retry) {
+    return !blockers.length || (blockers.call({
+      action: action2,
+      location: location2,
+      retry
+    }), false);
+  }
+  function applyTx(nextAction) {
+    action = nextAction;
+    var _getIndexAndLocation7 = getIndexAndLocation();
+    index = _getIndexAndLocation7[0];
+    location = _getIndexAndLocation7[1];
+    listeners.call({
+      action,
+      location
+    });
+  }
+  function push(to, state) {
+    var nextAction = Action.Push;
+    var nextLocation = getNextLocation(to, state);
+    function retry() {
+      push(to, state);
+    }
+    true ? warning(nextLocation.pathname.charAt(0) === "/", "Relative pathnames are not supported in hash history.push(" + JSON.stringify(to) + ")") : void 0;
+    if (allowTx(nextAction, nextLocation, retry)) {
+      var _getHistoryStateAndUr3 = getHistoryStateAndUrl(nextLocation, index + 1), historyState = _getHistoryStateAndUr3[0], url = _getHistoryStateAndUr3[1];
+      try {
+        globalHistory.pushState(historyState, "", url);
+      } catch (error) {
+        window2.location.assign(url);
+      }
+      applyTx(nextAction);
+    }
+  }
+  function replace(to, state) {
+    var nextAction = Action.Replace;
+    var nextLocation = getNextLocation(to, state);
+    function retry() {
+      replace(to, state);
+    }
+    true ? warning(nextLocation.pathname.charAt(0) === "/", "Relative pathnames are not supported in hash history.replace(" + JSON.stringify(to) + ")") : void 0;
+    if (allowTx(nextAction, nextLocation, retry)) {
+      var _getHistoryStateAndUr4 = getHistoryStateAndUrl(nextLocation, index), historyState = _getHistoryStateAndUr4[0], url = _getHistoryStateAndUr4[1];
+      globalHistory.replaceState(historyState, "", url);
+      applyTx(nextAction);
+    }
+  }
+  function go(delta) {
+    globalHistory.go(delta);
+  }
+  var history = {
+    get action() {
+      return action;
+    },
+    get location() {
+      return location;
+    },
+    createHref,
+    push,
+    replace,
+    go,
+    back: function back() {
+      go(-1);
+    },
+    forward: function forward() {
+      go(1);
+    },
+    listen: function listen(listener) {
+      return listeners.push(listener);
+    },
+    block: function block(blocker) {
+      var unblock = blockers.push(blocker);
+      if (blockers.length === 1) {
+        window2.addEventListener(BeforeUnloadEventType, promptBeforeUnload);
+      }
+      return function() {
+        unblock();
+        if (!blockers.length) {
+          window2.removeEventListener(BeforeUnloadEventType, promptBeforeUnload);
+        }
+      };
+    }
+  };
+  return history;
+}
+function promptBeforeUnload(event) {
+  event.preventDefault();
+  event.returnValue = "";
+}
+function createEvents() {
+  var handlers = [];
+  return {
+    get length() {
+      return handlers.length;
+    },
+    push: function push(fn) {
+      handlers.push(fn);
+      return function() {
+        handlers = handlers.filter(function(handler) {
+          return handler !== fn;
+        });
+      };
+    },
+    call: function call(arg) {
+      handlers.forEach(function(fn) {
+        return fn && fn(arg);
+      });
+    }
+  };
+}
+function createKey() {
+  return Math.random().toString(36).substr(2, 8);
+}
+function createPath(_ref) {
+  var _ref$pathname = _ref.pathname, pathname = _ref$pathname === void 0 ? "/" : _ref$pathname, _ref$search = _ref.search, search = _ref$search === void 0 ? "" : _ref$search, _ref$hash = _ref.hash, hash2 = _ref$hash === void 0 ? "" : _ref$hash;
+  if (search && search !== "?")
+    pathname += search.charAt(0) === "?" ? search : "?" + search;
+  if (hash2 && hash2 !== "#")
+    pathname += hash2.charAt(0) === "#" ? hash2 : "#" + hash2;
+  return pathname;
+}
+function parsePath(path) {
+  var parsedPath = {};
+  if (path) {
+    var hashIndex = path.indexOf("#");
+    if (hashIndex >= 0) {
+      parsedPath.hash = path.substr(hashIndex);
+      path = path.substr(0, hashIndex);
+    }
+    var searchIndex = path.indexOf("?");
+    if (searchIndex >= 0) {
+      parsedPath.search = path.substr(searchIndex);
+      path = path.substr(0, searchIndex);
+    }
+    if (path) {
+      parsedPath.pathname = path;
+    }
+  }
+  return parsedPath;
+}
+
+// src/stores/router.ts
+function RouterStore(ctx) {
+  ctx.name = "dolla/router";
+  const { appContext, elementContext } = getStoreSecrets(ctx);
+  let history;
+  if (ctx.options.history) {
+    history = ctx.options.history;
+  } else if (ctx.options.hash) {
+    history = createHashHistory();
+  } else {
+    history = createBrowserHistory();
+  }
+  for (const route of ctx.options.routes) {
+    if (route.meta.redirect) {
+      let redirectPath;
+      if (isFunction(route.meta.redirect)) {
+        throw new Error(`Redirect functions are not yet supported.`);
+      } else if (isString(route.meta.redirect)) {
+        redirectPath = route.meta.redirect;
+      } else {
+        throw new TypeError(`Expected a string or redirect function. Got: ${route.meta.redirect}`);
+      }
+      const match = matchRoutes(ctx.options.routes, redirectPath, {
+        willMatch(r) {
+          return r !== route;
+        }
+      });
+      if (!match) {
+        throw new Error(`Found a redirect to an undefined URL. From '${route.pattern}' to '${route.meta.redirect}'`);
+      }
+    }
+  }
+  const $$pattern = writable(null);
+  const $$path = writable("");
+  const $$params = writable({});
+  const $$query = writable({});
+  let isRouteChange = false;
+  ctx.observe($$query, (current) => {
+    if (isRouteChange) {
+      isRouteChange = false;
+      return;
+    }
+    const params = new URLSearchParams();
+    for (const key in current) {
+      params.set(key, String(current[key]));
+    }
+    history.replace({
+      pathname: history.location.pathname,
+      search: "?" + params.toString()
+    });
+  });
+  ctx.onConnected(() => {
+    history.listen(onRouteChange);
+    onRouteChange(history);
+    catchLinks(appContext.rootElement, (anchor) => {
+      let href = anchor.getAttribute("href");
+      if (!/^https?:\/\/|^\//.test(href)) {
+        href = joinPath([history.location.pathname, href]);
+      }
+      history.push(href);
+    });
+  });
+  let activeLayers = [];
+  let lastQuery;
+  const onRouteChange = async ({ location }) => {
+    if (location.search !== lastQuery) {
+      lastQuery = location.search;
+      isRouteChange = true;
+      $$query.set(parseQueryParams(location.search));
+    }
+    const matched = matchRoutes(ctx.options.routes, location.pathname);
+    if (!matched) {
+      $$pattern.set(null);
+      $$path.set(location.pathname);
+      $$params.set({
+        wildcard: location.pathname
+      });
+      return;
+    }
+    ctx.info(`Matched route: '${matched.pattern}'`);
+    if (matched.meta.redirect != null) {
+      if (typeof matched.meta.redirect === "string") {
+        let path = matched.meta.redirect;
+        for (const key in matched.params) {
+          path = path.replace(":" + key, matched.params[key].toString());
+        }
+        ctx.info(`Redirecting to: '${path}'`);
+        history.replace(path);
+      } else if (typeof matched.meta.redirect === "function") {
+        throw new Error(`Redirect functions aren't implemented yet.`);
+      } else {
+        throw new TypeError(`Redirect must either be a path string or a function.`);
+      }
+    } else {
+      $$path.set(matched.path);
+      $$params.set(matched.params);
+      if (matched.pattern !== $$pattern.get()) {
+        $$pattern.set(matched.pattern);
+        const layers = matched.meta.layers;
+        for (let i = 0; i < layers.length; i++) {
+          const matchedLayer = layers[i];
+          const activeLayer = activeLayers[i];
+          if (activeLayer?.id !== matchedLayer.id) {
+            ctx.info(`Replacing layer ${i} (active ID: ${activeLayer?.id}, matched ID: ${matchedLayer.id})`);
+            activeLayers = activeLayers.slice(0, i);
+            const parentLayer = activeLayers[activeLayers.length - 1];
+            const renderContext = { appContext, elementContext };
+            const rendered = renderMarkupToDOM(matchedLayer.markup, renderContext);
+            const handle = getRenderHandle(rendered);
+            requestAnimationFrame(() => {
+              if (activeLayer && activeLayer.handle.connected) {
+                activeLayer.handle.disconnect();
+              }
+              if (parentLayer) {
+                parentLayer.handle.setChildren(rendered);
+              } else {
+                appContext.rootView.setChildren(rendered);
+              }
+            });
+            activeLayers.push({ id: matchedLayer.id, handle });
+          }
+        }
+      }
+    }
+  };
+  function navigate(path, options = {}) {
+    let joined;
+    if (Array.isArray(path)) {
+      joined = joinPath(path);
+    } else {
+      joined = path.toString();
+    }
+    joined = resolvePath(history.location.pathname, joined);
+    if (options.replace) {
+      history.replace(joined);
+    } else {
+      history.push(joined);
+    }
+  }
+  return {
+    /**
+     * The currently matched route pattern, if any.
+     */
+    $pattern: readable($$pattern),
+    /**
+     * The current URL path.
+     */
+    $path: readable($$path),
+    /**
+     * The current named path params.
+     */
+    $params: readable($$params),
+    /**
+     * The current query params. Changes to this object will be reflected in the URL.
+     */
+    $$query,
+    /**
+     * Navigate backward. Pass a number of steps to hit the back button that many times.
+     */
+    back(steps = 1) {
+      history.go(-steps);
+    },
+    /**
+     * Navigate forward. Pass a number of steps to hit the forward button that many times.
+     */
+    forward(steps = 1) {
+      history.go(steps);
+    },
+    /**
+     * Navigates to another route.
+     *
+     * @example
+     * navigate("/login"); // navigate to `/login`
+     * navigate(["/users", 215], { replace: true }); // replace current history entry with `/users/215`
+     *
+     * @param args - One or more path segments optionally followed by an options object.
+     */
+    navigate
+  };
+}
+var safeExternalLink = /(noopener|noreferrer) (noopener|noreferrer)/;
+var protocolLink = /^[\w-_]+:/;
+function catchLinks(root, callback, _window = window) {
+  function traverse(node) {
+    if (!node || node === root) {
+      return null;
+    }
+    if (node.localName !== "a" || node.href === void 0) {
+      return traverse(node.parentNode);
+    }
+    return node;
+  }
+  function handler(e) {
+    if (e.button && e.button !== 0 || e.ctrlKey || e.metaKey || e.altKey || e.shiftKey || e.defaultPrevented) {
+      return;
+    }
+    const anchor = traverse(e.target);
+    if (!anchor) {
+      return;
+    }
+    if (_window.location.protocol !== anchor.protocol || _window.location.hostname !== anchor.hostname || _window.location.port !== anchor.port || anchor.hasAttribute("data-router-ignore") || anchor.hasAttribute("download") || anchor.getAttribute("target") === "_blank" && safeExternalLink.test(anchor.getAttribute("rel")) || protocolLink.test(anchor.getAttribute("href"))) {
+      return;
+    }
+    e.preventDefault();
+    callback(anchor);
+  }
+  root.addEventListener("click", handler);
+  return function cancel() {
+    root.removeEventListener("click", handler);
+  };
+}
+
+// src/app.ts
+function DefaultRootView(_, ctx) {
+  return ctx.outlet();
+}
+function makeApp(options) {
+  if (options && !isObject(options)) {
+    throw new TypeError(`App options must be an object. Got: ${options}`);
+  }
+  let isConnected = false;
+  let mainView = m(DefaultRootView);
+  let configureCallback;
+  const settings = merge(
+    {
+      debug: {
+        filter: "*,-dolla/*",
+        log: "development",
+        // Only print logs in development.
+        warn: "development",
+        // Only print warnings in development.
+        error: true
+        // Always print errors.
+      },
+      router: {
+        hash: false
+      },
+      mode: "production"
+    },
+    options ?? {}
+  );
+  const stores = /* @__PURE__ */ new Map([
+    ["dialog", { store: DialogStore }],
+    ["router", { store: RouterStore }],
+    ["document", { store: DocumentStore }],
+    ["http", { store: HTTPStore }],
+    ["language", { store: LanguageStore }],
+    ["render", { store: RenderStore }]
+  ]);
+  const languages = /* @__PURE__ */ new Map();
+  let currentLanguage;
+  let layerId = 0;
+  let routes = [];
+  function prepareRoute(route, layers = []) {
+    if (!isObject(route) || !isString(route.pattern)) {
+      throw new TypeError(`Route configs must be objects with a 'pattern' string property. Got: ${route}`);
+    }
+    const parts = splitPath(route.pattern);
+    if (parts[parts.length - 1] === "*") {
+      parts.pop();
+    }
+    const routes2 = [];
+    if (route.redirect) {
+      let redirect = route.redirect;
+      if (isString(redirect)) {
+        redirect = resolvePath(joinPath(parts), redirect);
+        if (!redirect.startsWith("/")) {
+          redirect = "/" + redirect;
+        }
+      }
+      routes2.push({
+        pattern: route.pattern,
+        meta: {
+          redirect
+        }
+      });
+      return routes2;
+    }
+    let view;
+    if (!route.view) {
+      view = DefaultRootView;
+    } else if (typeof route.view === "function") {
+      view = route.view;
+    } else {
+      throw new TypeError(`Route '${route.pattern}' expected a view function. Got: ${route.view}`);
+    }
+    const markup = m(view);
+    const layer = { id: layerId++, markup };
+    if (route.subroutes) {
+      const router = {
+        route: (pattern, view2, subroutes) => {
+          pattern = joinPath([...parts, pattern]);
+          routes2.push(...prepareRoute({ pattern, view: view2, subroutes }));
+          return router;
+        },
+        redirect: (pattern, redirect) => {
+          pattern = joinPath([...parts, pattern]);
+          routes2.push(...prepareRoute({ pattern, redirect }));
+          return router;
+        }
+      };
+      route.subroutes(router);
+    } else {
+      routes2.push({
+        pattern: route.pattern,
+        meta: {
+          pattern: route.pattern,
+          layers: [...layers, layer]
+        }
+      });
+    }
+    return routes2;
+  }
+  const crashCollector = new CrashCollector();
+  const debugHub = new DebugHub({ ...settings.debug, crashCollector, mode: settings.mode });
+  const debugChannel = debugHub.channel({ name: "dolla/App" });
+  crashCollector.onError(async ({ error, severity, componentName }) => {
+    if (severity === "crash") {
+      await disconnect();
+      const instance = initView({
+        view: DefaultCrashPage,
+        appContext,
+        elementContext,
+        props: {
+          message: error.message,
+          error,
+          componentName
+        }
+      });
+      instance.connect(appContext.rootElement);
+    }
+  });
+  async function connect(selector) {
+    return new Promise(async (resolve2) => {
+      let element = null;
+      if (isString(selector)) {
+        element = document.querySelector(selector);
+        assertInstanceOf(HTMLElement, element, `Selector string '${selector}' did not match any element.`);
+      }
+      assertInstanceOf(HTMLElement, element, "Expected a DOM node or a selector string. Got type: %t, value: %v");
+      appContext.rootElement = element;
+      routes = sortRoutes(routes);
+      const language = stores.get("language");
+      stores.set("language", {
+        ...language,
+        options: {
+          languages: Object.fromEntries(languages.entries()),
+          currentLanguage
+        }
+      });
+      const router = stores.get("router");
+      stores.set("router", {
+        ...router,
+        options: {
+          options: settings.router,
+          routes
+        }
+      });
+      debugChannel.info(`Total routes: ${routes.length}`);
+      appContext.rootView = initView({
+        view: mainView.type,
+        props: mainView.props,
+        appContext,
+        elementContext
+      });
+      for (let [key, item] of stores.entries()) {
+        const { store, options: options2 } = item;
+        const channelPrefix = isString(key) ? "dolla/store" : "store";
+        const label = isString(key) ? key : store.name ?? "(anonymous)";
+        const config = {
+          store,
+          appContext,
+          elementContext,
+          channelPrefix,
+          label,
+          options: options2 ?? {}
+        };
+        const instance = initStore(config);
+        instance.setup();
+        stores.set(key, { ...item, instance });
+      }
+      for (const { instance } of stores.values()) {
+        instance.connect();
+      }
+      if (configureCallback) {
+        await configureCallback({
+          // TODO: Add context methods
+        });
+      }
+      const { $isLoaded } = stores.get("language").instance.exports;
+      const done = () => {
+        appContext.rootView.connect(appContext.rootElement);
+        isConnected = true;
+        resolve2();
+      };
+      if ($isLoaded.get()) {
+        return done();
+      }
+      const stop = observe($isLoaded, (isLoaded) => {
+        if (isLoaded) {
+          stop();
+          done();
+        }
+      });
+    });
+  }
+  async function disconnect() {
+    if (isConnected) {
+      appContext.rootView.disconnect();
+      isConnected = false;
+      for (const { instance } of stores.values()) {
+        instance.disconnect();
+      }
+    }
+  }
+  const appContext = {
+    crashCollector,
+    debugHub,
+    stores,
+    mode: settings.mode ?? "production"
+    // $dialogs - added by dialog store
+  };
+  const elementContext = {
+    stores: /* @__PURE__ */ new Map()
+  };
+  const app = {
+    connect,
+    disconnect,
+    get isConnected() {
+      return isConnected;
+    },
+    main(view, attributes) {
+      if (mainView.type !== DefaultRootView) {
+        debugChannel.warn(`Root view is already defined. Only the final main call will take effect.`);
+      }
+      if (typeof view === "function") {
+        mainView = m(view, attributes);
+      } else {
+        throw new TypeError(`Expected a view function. Got type: ${typeOf(view)}, value: ${view}`);
+      }
+      return app;
+    },
+    store(store, options2) {
+      let config;
+      if (isFunction(store)) {
+        config = { store, options: options2 };
+      } else {
+        throw new TypeError(`Expected a store function. Got type: ${typeOf(store)}, value: ${store}`);
+      }
+      assertFunction(store, "Expected a store function or a store config object. Got type: %t, value: %v");
+      stores.set(store, config);
+      return app;
+    },
+    getStore(store) {
+      const match = stores.get(store);
+      const name = isString(store) ? store : store.name;
+      if (!match) {
+        throw new Error(`Store '${name}' is not registered on this app.`);
+      }
+      if (!match.instance) {
+        throw new Error(`Store '${name}' is not yet initialized. App must be connected first.`);
+      }
+      return match.instance.exports;
+    },
+    language(tag, config) {
+      languages.set(tag, config);
+      return app;
+    },
+    setLanguage(tag, fallback) {
+      if (tag === "auto") {
+        let tags = [];
+        if (typeof navigator === "object") {
+          const nav = navigator;
+          if (nav.languages?.length > 0) {
+            tags.push(...nav.languages);
+          } else if (nav.language) {
+            tags.push(nav.language);
+          } else if (nav.browserLanguage) {
+            tags.push(nav.browserLanguage);
+          } else if (nav.userLanguage) {
+            tags.push(nav.userLanguage);
+          }
+        }
+        for (const tag2 of tags) {
+          if (languages.has(tag2)) {
+            currentLanguage = tag2;
+            return this;
+          }
+        }
+        if (!currentLanguage && fallback) {
+          if (languages.has(fallback)) {
+            currentLanguage = fallback;
+          }
+        }
+      } else {
+        if (languages.has(tag)) {
+          currentLanguage = tag;
+        } else {
+          throw new Error(`Language '${tag}' has not been added to this app yet.`);
+        }
+      }
+      return app;
+    },
+    route(pattern, view, subroutes) {
+      assertString(pattern, "Pattern must be a string. Got type: %t, value: %v");
+      if (view == null) {
+        assertFunction(subroutes, "Sub routes must be defined when `view` is null.");
+      }
+      prepareRoute({ pattern, view, subroutes }).forEach((route) => {
+        routes.push({
+          pattern: route.pattern,
+          meta: route.meta,
+          fragments: patternToFragments(route.pattern)
+        });
+      });
+      return app;
+    },
+    redirect(pattern, redirect) {
+      if (!isFunction(redirect) && !isString(redirect)) {
+        throw new TypeError(`Expected a redirect path or function. Got type: ${typeOf(redirect)}, value: ${redirect}`);
+      }
+      prepareRoute({ pattern, redirect }).forEach((route) => {
+        routes.push({
+          pattern: route.pattern,
+          meta: route.meta,
+          fragments: patternToFragments(route.pattern)
+        });
+      });
+      return app;
+    },
+    configure(callback) {
+      if (configureCallback !== void 0) {
+        debugChannel.warn(`Configure callback is already defined. Only the final configure call will take effect.`);
+      }
+      configureCallback = callback;
+      return app;
+    }
+  };
+  return app;
+}
+function DefaultCrashPage({ message, error, componentName }) {
+  return m(
+    "div",
+    {
+      style: {
+        backgroundColor: "#880000",
+        color: "#fff",
+        padding: "2rem",
+        position: "fixed",
+        inset: 0,
+        fontSize: "20px"
+      }
+    },
+    m("h1", { style: { marginBottom: "0.5rem" } }, "The app has crashed"),
+    m(
+      "p",
+      { style: { marginBottom: "0.25rem" } },
+      m("span", { style: { fontFamily: "monospace" } }, componentName),
+      " says:"
+    ),
+    m(
+      "blockquote",
+      {
+        style: {
+          backgroundColor: "#991111",
+          padding: "0.25em",
+          borderRadius: "6px",
+          fontFamily: "monospace",
+          marginBottom: "1rem"
+        }
+      },
+      m(
+        "span",
+        {
+          style: {
+            display: "inline-block",
+            backgroundColor: "red",
+            padding: "0.1em 0.4em",
+            marginRight: "0.5em",
+            borderRadius: "4px",
+            fontSize: "0.9em",
+            fontWeight: "bold"
+          }
+        },
+        error.name
+      ),
+      message
+    ),
+    m("p", {}, "Please see the browser console for details.")
+  );
+}
+
+// src/spring.ts
+function spring(initialValue, options) {
+  const mass = options?.mass ?? 2;
+  const stiffness = options?.stiffness ?? 1200;
+  const damping = options?.damping ?? 160;
+  const velocity = options?.velocity ?? 5;
+  const endAmplitude = options?.endAmplitude ?? 1e-3;
+  const endWindow = options?.endWindow ?? 20;
+  const $$currentValue = writable(initialValue);
+  let nextId = 0;
+  let currentAnimationId;
+  const snapTo = (newValue) => {
+    currentAnimationId = void 0;
+    $$currentValue.set(newValue);
+  };
+  const animateTo = async (endValue, options2) => {
+    const mediaQuery = window.matchMedia("(prefers-reduced-motion: reduce)");
+    if (mediaQuery.matches) {
+      return snapTo(endValue);
+    }
+    const _endAmplitude = readable(options2?.endAmplitude ?? endAmplitude).get();
+    const _endWindow = readable(options2?.endWindow ?? endWindow).get();
+    return new Promise((resolve2) => {
+      const id = nextId++;
+      const amplitude = makeAmplitudeMeasurer(_endWindow);
+      const springParams = {
+        mass: options2?.mass ?? mass,
+        stiffness: options2?.stiffness ?? stiffness,
+        damping: options2?.damping ?? damping,
+        velocity: options2?.velocity ?? velocity
+      };
+      const startTime = Date.now();
+      const startValue = $$currentValue.get();
+      const step = () => {
+        if (currentAnimationId !== id) {
+          resolve2();
+          return;
+        }
+        const elapsedTime = Date.now() - startTime;
+        const proportion = solve(springParams, elapsedTime / 1e3);
+        $$currentValue.set(startValue + (endValue - startValue) * proportion);
+        amplitude.sample(proportion);
+        if (amplitude.value && amplitude.value < _endAmplitude) {
+          currentAnimationId = void 0;
+          $$currentValue.set(endValue);
+        }
+        window.requestAnimationFrame(step);
+      };
+      currentAnimationId = id;
+      window.requestAnimationFrame(step);
+    });
+  };
+  return {
+    get: $$currentValue.get,
+    set: snapTo,
+    update: (callback) => {
+      const newValue = callback($$currentValue.get());
+      snapTo(newValue);
+    },
+    [OBSERVE]: $$currentValue[OBSERVE],
+    animateTo
+  };
+}
+function solve(parameters, elapsedSeconds) {
+  const mass = unwrap(parameters.mass);
+  const stiffness = unwrap(parameters.stiffness);
+  const damping = unwrap(parameters.damping);
+  const initialVelocity = unwrap(parameters.velocity);
+  const dampingRatio = damping / (2 * Math.sqrt(stiffness * mass));
+  const speed = Math.sqrt(stiffness / mass);
+  let B;
+  let position;
+  if (dampingRatio < 1) {
+    const dampedSpeed = speed * Math.sqrt(1 - dampingRatio * dampingRatio);
+    B = (dampingRatio * speed + -initialVelocity) / dampedSpeed;
+    position = (Math.cos(dampedSpeed * elapsedSeconds) + B * Math.sin(dampedSpeed * elapsedSeconds)) * Math.exp(-elapsedSeconds * speed * dampingRatio);
+  } else {
+    B = speed + -initialVelocity;
+    position = (1 + B * elapsedSeconds) * Math.exp(-elapsedSeconds * speed);
+  }
+  return 1 - position;
+}
+function makeAmplitudeMeasurer(resolution) {
+  const samples = [];
+  return {
+    sample(value) {
+      samples.push(value);
+      while (samples.length > resolution) {
+        samples.shift();
+      }
+    },
+    get value() {
+      if (samples.length < resolution) {
+        return null;
+      }
+      return Math.max(...samples) - Math.min(...samples);
+    }
+  };
+}
+
+// src/views/fragment.ts
+function Fragment(_, ctx) {
+  return ctx.outlet();
+}
+
+// src/views/store-scope.ts
+function StoreScope(props, ctx) {
+  const { appContext, elementContext } = getViewSecrets(ctx);
+  const instance = initStore({
+    store: props.store,
+    options: props.options,
+    appContext,
+    elementContext
+  });
+  instance.setup();
+  elementContext.stores.set(props.store, {
+    store: props.store,
+    options: props.options,
+    instance
+  });
+  ctx.beforeConnect(() => {
+    return instance.connect();
+  });
+  ctx.onDisconnected(() => {
+    instance.disconnect();
+  });
+  return ctx.outlet();
+}
+export {
+  Fragment,
+  StoreScope,
+  computed,
+  cond,
+  isReadable,
+  isWritable,
+  m,
+  makeApp,
+  observe,
+  portal,
+  proxy,
+  readable,
+  repeat,
+  spring,
+  unwrap,
+  writable
+};
+//# sourceMappingURL=index.js.map