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

package/dist/markup-PXJjYgl3.js

@@ -1,1506 +0,0 @@
-import htm from 'htm/mini';
-import { SubscriberFlags, createReactiveSystem } from 'alien-signals';
-
-function typeOf(value) {
-  const type = typeof value;
-  switch (type) {
-    case "undefined":
-      return type;
-    case "number":
-      if (isNaN(value)) return "NaN";
-      return type;
-    case "function":
-      if (/^\s*class\s+/.test(value.toString())) return "class";
-      return type;
-    case "object":
-      if (value === null) return "null";
-      if (value instanceof Promise) return "promise";
-      if (value instanceof Map) return "map";
-      if (value instanceof Set) return "set";
-      if (Array.isArray(value)) return "array";
-      return type;
-    default:
-      return type;
-  }
-}
-function isArray(value) {
-  return Array.isArray(value);
-}
-function isArrayOf(check, value) {
-  return isArray(value) && value.every((item) => check(item));
-}
-function assertArrayOf(check, value, errorMessage) {
-  if (isArrayOf(check, value)) {
-    return true;
-  }
-  throw new TypeError(formatError(value, errorMessage));
-}
-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";
-}
-function isNumber(value) {
-  return typeof value === "number" && !isNaN(value);
-}
-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));
-}
-function formatError(value, message) {
-  const typeName = typeOf(value);
-  const valueString = value?.toString?.() || String(value);
-  return message.replaceAll("%t", typeName).replaceAll("%v", valueString);
-}
-
-const DEPENDENCY = Symbol("dependency");
-const {
-  link,
-  propagate,
-  updateDirtyFlag,
-  startTracking,
-  endTracking,
-  processEffectNotifications,
-  processComputedUpdate,
-  processPendingInnerEffects
-} = createReactiveSystem({
-  updateComputed(computed) {
-    const prevSub = activeSub;
-    activeSub = computed;
-    startTracking(computed);
-    try {
-      const oldValue = computed.currentValue;
-      const newValue = computed.getter(oldValue);
-      if (!computed.equals(oldValue, newValue)) {
-        computed.currentValue = newValue;
-        return true;
-      }
-      return false;
-    } finally {
-      activeSub = prevSub;
-      endTracking(computed);
-    }
-  },
-  notifyEffect(e) {
-    const flags = e.flags;
-    if (flags & SubscriberFlags.Dirty || flags & SubscriberFlags.PendingComputed && updateDirtyFlag(e, flags)) {
-      queueEffect(e);
-    } else {
-      processPendingInnerEffects(e, e.flags);
-    }
-    return true;
-  }
-});
-let activeSub;
-const PENDING_EFFECTS = [];
-let flushPending = false;
-function flushEffects() {
-  if (!flushPending) {
-    flushPending = true;
-    queueMicrotask(() => {
-      flushPending = false;
-      for (let i = 0; i < PENDING_EFFECTS.length; i++) {
-        const e = PENDING_EFFECTS[i];
-        const prevSub = activeSub;
-        activeSub = e;
-        startTracking(e);
-        try {
-          e.fn();
-        } finally {
-          activeSub = prevSub;
-          endTracking(e);
-        }
-      }
-      PENDING_EFFECTS.length = 0;
-    });
-  }
-}
-function queueEffect(e) {
-  PENDING_EFFECTS.push(e);
-  flushEffects();
-}
-function stopEffect() {
-  startTracking(this);
-  endTracking(this);
-  queueMicrotask(() => {
-    PENDING_EFFECTS.splice(PENDING_EFFECTS.indexOf(this), 1);
-  });
-}
-class Atom {
-  #signal;
-  #equals;
-  name;
-  constructor(signal, options) {
-    this.#signal = signal;
-    this.#equals = options?.equals ?? Object.is;
-    if (options?.name) {
-      this.name = options.name;
-    }
-    Object.defineProperty(this, DEPENDENCY, {
-      value: signal,
-      configurable: false,
-      enumerable: false,
-      writable: false
-    });
-  }
-  get value() {
-    return this.#signal.currentValue;
-  }
-  set value(next) {
-    if (!this.#equals(this.#signal.currentValue, next)) {
-      this.#signal.currentValue = next;
-      const subs = this.#signal.subs;
-      if (subs !== void 0) {
-        propagate(subs);
-        processEffectNotifications();
-      }
-    }
-  }
-}
-class Composed {
-  computed;
-  constructor(computed) {
-    this.computed = computed;
-    Object.defineProperty(this, DEPENDENCY, {
-      value: computed,
-      configurable: false,
-      enumerable: false,
-      writable: false
-    });
-  }
-  get value() {
-    const computed = this.computed;
-    const flags = computed.flags;
-    if (flags & (SubscriberFlags.Dirty | SubscriberFlags.PendingComputed)) {
-      processComputedUpdate(computed, flags);
-    }
-    return computed.currentValue;
-  }
-}
-function isReactive(value) {
-  return value != null && value[DEPENDENCY] != null;
-}
-function atom(value, options) {
-  return new Atom({ currentValue: value, subs: void 0, subsTail: void 0 }, options);
-}
-function compose(fn, options) {
-  return new Composed({
-    currentValue: void 0,
-    equals: options?.equals ?? Object.is,
-    subs: void 0,
-    subsTail: void 0,
-    deps: void 0,
-    depsTail: void 0,
-    flags: SubscriberFlags.Computed | SubscriberFlags.Dirty,
-    getter: (cachedValue) => {
-      let returned = fn(cachedValue);
-      returned = get(returned);
-      return returned;
-    }
-  });
-}
-function set(atom2, next) {
-  if (isFunction(next)) {
-    atom2.value = next(atom2.value);
-  } else if (arguments.length > 1) {
-    atom2.value = next;
-  } else {
-    return (next2) => set(atom2, next2);
-  }
-}
-function get(value) {
-  if (isReactive(value)) {
-    if (activeSub !== void 0) {
-      const dep = value[DEPENDENCY];
-      link(dep, activeSub);
-    }
-    return value.value;
-  } else {
-    return value;
-  }
-}
-function peek(value) {
-  if (isReactive(value)) {
-    return value.value;
-  } else {
-    return value;
-  }
-}
-function effect(fn) {
-  const e = {
-    fn,
-    subs: void 0,
-    subsTail: void 0,
-    deps: void 0,
-    depsTail: void 0,
-    flags: SubscriberFlags.Effect
-  };
-  if (activeSub !== void 0) {
-    link(e, activeSub);
-  }
-  queueEffect(e);
-  return stopEffect.bind(e);
-}
-
-const noOp = () => {
-};
-let idCounter = 1;
-function getUniqueId() {
-  idCounter = idCounter % Number.MAX_SAFE_INTEGER + 1;
-  return idCounter.toString(36) + Date.now().toString(36);
-}
-function strictEqual(a, b) {
-  return Object.is(a, b);
-}
-function shallowEqual(a, b) {
-  if (Object.is(a, b)) return true;
-  const t = typeOf(a);
-  if (t !== typeOf(b)) {
-    return false;
-  }
-  switch (t) {
-    case "object":
-      let size = 0;
-      for (const key in a) {
-        if (a[key] !== b[key]) return false;
-        size++;
-      }
-      return Object.keys(b).length === size;
-    case "array":
-      if (a.length !== b.length) return false;
-      for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i]) return false;
-      }
-      return true;
-    case "map":
-      if (a.size !== b.size) return false;
-      for (const key of a.keys()) {
-        if (a[key] !== b[key]) return false;
-      }
-      return true;
-    case "set":
-      if (isFunction(a.symmetricDifference)) {
-        return a.symmetricDifference(b).size === 0;
-      } else {
-        for (const key of a.keys()) {
-          if (a[key] !== b.get(key)) return false;
-        }
-        return true;
-      }
-  }
-  return false;
-}
-function deepEqual(a, b) {
-  if (a === b) return true;
-  if (a && b && typeof a == "object" && typeof b == "object") {
-    if (a.constructor !== b.constructor) return false;
-    var length, i, keys;
-    if (Array.isArray(a)) {
-      length = a.length;
-      if (length != b.length) return false;
-      for (i = length; i-- !== 0; ) if (!deepEqual(a[i], b[i])) return false;
-      return true;
-    }
-    if (a instanceof Map && b instanceof Map) {
-      if (a.size !== b.size) return false;
-      for (i of a.entries()) if (!b.has(i[0])) return false;
-      for (i of a.entries()) if (!deepEqual(i[1], b.get(i[0]))) return false;
-      return true;
-    }
-    if (a instanceof Set && b instanceof Set) {
-      if (a.size !== b.size) return false;
-      for (i of a.entries()) if (!b.has(i[0])) return false;
-      return true;
-    }
-    if (ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
-      length = a.length;
-      if (length != b.length) return false;
-      for (i = length; i-- !== 0; ) if (a[i] !== b[i]) return false;
-      return true;
-    }
-    if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
-    if (a.valueOf !== Object.prototype.valueOf) return a.valueOf() === b.valueOf();
-    if (a.toString !== Object.prototype.toString) return a.toString() === b.toString();
-    keys = Object.keys(a);
-    length = keys.length;
-    if (length !== Object.keys(b).length) return false;
-    for (i = length; i-- !== 0; ) if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
-    for (i = length; i-- !== 0; ) {
-      var key = keys[i];
-      if (!deepEqual(a[key], b[key])) return false;
-    }
-    return true;
-  }
-  return a !== a && b !== b;
-}
-function omit(keys, object) {
-  const process = (object2) => {
-    const newObject = {};
-    for (const key in object2) {
-      if (!keys.includes(key)) {
-        newObject[key] = object2[key];
-      }
-    }
-    return newObject;
-  };
-  if (object == null) {
-    return process;
-  }
-  return process(object);
-}
-function okhash(value) {
-  let hue = 0;
-  for (let i = 0; i < value.length; i++) {
-    hue = (hue + value.charCodeAt(i) * 10) % 360;
-  }
-  return `oklch(0.68 0.15 ${hue}deg)`;
-}
-function createMatcher(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;
-  };
-}
-
-const IS_MARKUP_ELEMENT = Symbol.for("DollaMarkupElement");
-const IS_ROUTER = Symbol.for("DollaRouter");
-
-function Passthrough(_, ctx) {
-  return ctx.outlet();
-}
-
-class DOMNode {
-  [IS_MARKUP_ELEMENT] = true;
-  node;
-  get isMounted() {
-    return this.node.parentNode != null;
-  }
-  constructor(node) {
-    this.node = node;
-  }
-  mount(parent, after) {
-    parent.insertBefore(this.node, after?.nextSibling ?? null);
-  }
-  unmount(parentIsUnmounting = false) {
-    if (this.node.parentNode && !parentIsUnmounting) {
-      this.node.parentNode.removeChild(this.node);
-    }
-  }
-}
-
-class Dynamic {
-  [IS_MARKUP_ELEMENT] = true;
-  node = document.createTextNode("");
-  children = [];
-  elementContext;
-  source;
-  unsubscribe;
-  get isMounted() {
-    return this.node.parentNode != null;
-  }
-  constructor(options) {
-    this.source = options.source;
-    this.elementContext = options.elementContext;
-  }
-  mount(parent, after) {
-    if (!this.isMounted) {
-      parent.insertBefore(this.node, after?.nextSibling ?? null);
-      this.unsubscribe = effect(() => {
-        const content = get(this.source);
-        if (!isRenderable(content)) {
-          console.error(content);
-          throw new TypeError(
-            `Dynamic received invalid value to render. Got type: ${typeOf(content)}, value: ${content}`
-          );
-        }
-        this.update(isArray(content) ? content : [content]);
-      });
-    }
-  }
-  unmount(parentIsUnmounting = false) {
-    this.unsubscribe?.();
-    if (this.isMounted) {
-      this.cleanup(parentIsUnmounting);
-      this.node.parentNode?.removeChild(this.node);
-    }
-  }
-  cleanup(parentIsUnmounting) {
-    for (const element of this.children) {
-      element.unmount(parentIsUnmounting);
-    }
-    this.children = [];
-  }
-  update(children) {
-    this.cleanup(false);
-    if (children == null || children.length === 0 || !this.isMounted) {
-      return;
-    }
-    const newElements = children.flatMap((c) => {
-      if (isMarkupElement(c)) {
-        return c;
-      } else {
-        return constructMarkup(this.elementContext, toMarkup(c));
-      }
-    });
-    for (const element of newElements) {
-      const previous = this.children.at(-1)?.node || this.node;
-      element.mount(this.node.parentNode, previous);
-      this.children.push(element);
-    }
-    const parent = this.node.parentNode;
-    const lastChildNextSibling = this.children.at(-1)?.node?.nextSibling ?? null;
-    parent.insertBefore(this.node, lastChildNextSibling);
-  }
-}
-
-const isCamelCaseEventName = (key) => /^on[A-Z]/.test(key);
-class HTML {
-  [IS_MARKUP_ELEMENT] = true;
-  node;
-  props;
-  childMarkup = [];
-  children = [];
-  unsubscribers = [];
-  elementContext;
-  // Track the ref so we can nullify it on unmount.
-  ref;
-  // Prevents 'onClickOutside' handlers from firing in the same cycle in which the element is connected.
-  canClickAway = false;
-  get isMounted() {
-    return this.node.parentNode != null;
-  }
-  constructor({ tag, props, children, elementContext }) {
-    if (tag.toLowerCase() === "svg") {
-      elementContext = {
-        ...elementContext,
-        isSVG: true
-      };
-    }
-    if (elementContext.isSVG) {
-      this.node = document.createElementNS("http://www.w3.org/2000/svg", tag);
-    } else {
-      this.node = document.createElement(tag);
-    }
-    if (elementContext.root.getEnv() === "development" && elementContext.viewName) {
-      this.node.dataset.view = elementContext.viewName;
-    }
-    if (props.ref) {
-      if (isFunction(props.ref)) {
-        this.ref = props.ref;
-        this.ref(this.node);
-      } else {
-        throw new Error("Expected ref to be a function. Got: " + props.ref);
-      }
-    }
-    this.props = {
-      ...omit(["ref", "class", "className"], props),
-      class: props.className ?? props.class
-    };
-    if (children) {
-      this.childMarkup = children;
-    }
-    this.elementContext = elementContext;
-  }
-  mount(parent, after) {
-    if (parent == null) {
-      throw new Error(`HTML element requires a parent element as the first argument to connect. Got: ${parent}`);
-    }
-    if (!this.isMounted) {
-      if (this.childMarkup.length > 0) {
-        this.children = constructMarkup(this.elementContext, this.childMarkup);
-      }
-      for (let i = 0; i < this.children.length; i++) {
-        const child = this.children[i];
-        const previous = i > 0 ? this.children[i - 1].node : void 0;
-        child.mount(this.node, previous);
-      }
-      this.applyProps(this.node, this.props);
-      if (this.props.style) this.applyStyles(this.node, this.props.style, this.unsubscribers);
-      if (this.props.class) this.applyClasses(this.node, this.props.class, this.unsubscribers);
-    }
-    parent.insertBefore(this.node, after?.nextSibling ?? null);
-    setTimeout(() => {
-      this.canClickAway = true;
-    }, 0);
-  }
-  unmount(parentIsUnmounting = false) {
-    if (this.isMounted) {
-      if (!parentIsUnmounting) {
-        this.node.parentNode?.removeChild(this.node);
-      }
-      for (const child of this.children) {
-        child.unmount(true);
-      }
-      if (this.ref) {
-        this.ref(void 0);
-      }
-      this.canClickAway = false;
-      for (const unsubscribe of this.unsubscribers) {
-        unsubscribe();
-      }
-      this.unsubscribers.length = 0;
-    }
-  }
-  attachProp(value, callback) {
-    if (isReactive(value)) {
-      this.unsubscribers.push(effect(() => callback(get(value))));
-    } else {
-      callback(value);
-    }
-  }
-  applyProps(element, props) {
-    for (const key in props) {
-      const value = props[key];
-      if (key === "attributes") {
-        const values = value;
-        for (const name in values) {
-          this.attachProp(values[name], (current) => {
-            if (current == null) {
-              element.removeAttribute(name);
-            } else {
-              element.setAttribute(name, String(current));
-            }
-          });
-        }
-      } else if (key === "onClickOutside" || key === "onclickoutside") {
-        const listener = (e) => {
-          if (this.canClickAway && !element.contains(e.target)) {
-            if (isReactive(value)) {
-              value.value(e);
-            } else {
-              value(e);
-            }
-          }
-        };
-        const options = { capture: true };
-        window.addEventListener("click", listener, options);
-        this.unsubscribers.push(() => {
-          window.removeEventListener("click", listener, options);
-        });
-      } else if (isCamelCaseEventName(key)) {
-        const eventName = key.slice(2).toLowerCase();
-        const listener = isReactive(value) ? (e) => value.value(e) : value;
-        element.addEventListener(eventName, listener);
-        this.unsubscribers.push(() => {
-          element.removeEventListener(eventName, listener);
-        });
-      } else if (key.includes("-")) {
-        this.attachProp(value, (current) => {
-          if (current == null) {
-            element.removeAttribute(key);
-          } else {
-            element.setAttribute(key, String(current));
-          }
-        });
-      } else if (!privateProps.includes(key)) {
-        if (this.elementContext.isSVG) {
-          this.attachProp(value, (current) => {
-            if (current != null) {
-              element.setAttribute(key, String(props[key]));
-            } else {
-              element.removeAttribute(key);
-            }
-          });
-        } else {
-          switch (key) {
-            case "contentEditable":
-            case "value":
-              this.attachProp(value, (current) => {
-                element[key] = String(current);
-              });
-              break;
-            case "for":
-              this.attachProp(value, (current) => {
-                element.htmlFor = current;
-              });
-              break;
-            case "checked":
-              this.attachProp(value, (current) => {
-                element.checked = current;
-                if (current) {
-                  element.setAttribute("checked", "");
-                } else {
-                  element.removeAttribute("checked");
-                }
-              });
-              break;
-            // Attribute-aliased props
-            case "exportParts":
-            case "part":
-            case "translate":
-            case "type":
-            case "title": {
-              const _key = key.toLowerCase();
-              this.attachProp(value, (current) => {
-                if (current == void 0) {
-                  element.removeAttribute(_key);
-                } else {
-                  element.setAttribute(_key, String(current));
-                }
-              });
-              break;
-            }
-            case "autocomplete":
-            case "autocapitalize":
-              this.attachProp(value, (current) => {
-                if (typeof current === "string") {
-                  element.autocomplete = current;
-                } else if (current) {
-                  element.autocomplete = "on";
-                } else {
-                  element.autocomplete = "off";
-                }
-              });
-              break;
-            default: {
-              this.attachProp(value, (current) => {
-                element[key] = current;
-              });
-              break;
-            }
-          }
-        }
-      }
-    }
-  }
-  applyStyles(element, styles, unsubscribers) {
-    const propUnsubscribers = [];
-    if (isReactive(styles)) {
-      let unapply;
-      const unsubscribe = effect(() => {
-        if (isFunction(unapply)) {
-          unapply();
-        }
-        element.style.cssText = "";
-        unapply = this.applyStyles(element, get(styles), unsubscribers);
-      });
-      unsubscribers.push(unsubscribe);
-      propUnsubscribers.push(unsubscribe);
-    } else {
-      const mapped = getStyleMap(styles);
-      for (const name in mapped) {
-        const { value, priority } = mapped[name];
-        if (isReactive(value)) {
-          const unsubscribe = effect(() => {
-            if (get(value)) {
-              element.style.setProperty(name, String(value.value), priority);
-            } else {
-              element.style.removeProperty(name);
-            }
-          });
-          unsubscribers.push(unsubscribe);
-          propUnsubscribers.push(unsubscribe);
-        } else if (value != void 0) {
-          element.style.setProperty(name, String(value));
-        }
-      }
-    }
-    return function unapply() {
-      for (const unsubscribe of propUnsubscribers) {
-        unsubscribe();
-        unsubscribers.splice(unsubscribers.indexOf(unsubscribe), 1);
-      }
-    };
-  }
-  applyClasses(element, classes, unsubscribers) {
-    const classUnsubscribers = [];
-    if (isReactive(classes)) {
-      let unapply;
-      const unsubscribe = effect(() => {
-        if (isFunction(unapply)) {
-          unapply();
-        }
-        element.removeAttribute("class");
-        unapply = this.applyClasses(element, get(classes), unsubscribers);
-      });
-      unsubscribers.push(unsubscribe);
-      classUnsubscribers.push(unsubscribe);
-    } else {
-      const mapped = getClassMap(classes);
-      for (const name in mapped) {
-        const value = mapped[name];
-        if (isReactive(value)) {
-          const unsubscribe = effect(() => {
-            if (get(value)) {
-              element.classList.add(name);
-            } else {
-              element.classList.remove(name);
-            }
-          });
-          unsubscribers.push(unsubscribe);
-          classUnsubscribers.push(unsubscribe);
-        } else if (value) {
-          element.classList.add(name);
-        }
-      }
-    }
-    return function unapply() {
-      for (const unsubscribe of classUnsubscribers) {
-        unsubscribe();
-        unsubscribers.splice(unsubscribers.indexOf(unsubscribe), 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(Boolean).forEach((item) => {
-      Object.assign(mapped, getClassMap(item));
-    });
-  }
-  delete mapped["undefined"];
-  return mapped;
-}
-function getStyleMap(styles) {
-  let mapped = {};
-  if (isString(styles)) {
-    const lines = styles.split(";").filter((line) => line.trim() !== "");
-    for (const line of lines) {
-      const [key, _value] = line.split(":");
-      const entry = {
-        value: _value
-      };
-      if (_value.includes("!important")) {
-        entry.priority = "important";
-        entry.value = _value.replace("!important", "").trim();
-      } else {
-        entry.value = _value.trim();
-      }
-      mapped[camelToKebab(key.trim())] = entry;
-    }
-  }
-  if (isObject(styles)) {
-    for (const key in styles) {
-      if (key.startsWith("--")) {
-        mapped[key] = { value: styles[key] };
-      } else {
-        mapped[camelToKebab(key)] = { value: styles[key] };
-      }
-    }
-  } else if (Array.isArray(styles)) {
-    Array.from(styles).filter((item) => item != null).forEach((item) => {
-      Object.assign(mapped, getStyleMap(item));
-    });
-  }
-  return mapped;
-}
-function camelToKebab(value) {
-  return value.replace(/[A-Z]+(?![a-z])|[A-Z]/g, ($, ofs) => (ofs ? "-" : "") + $.toLowerCase());
-}
-const privateProps = ["ref", "children", "class", "style", "data"];
-
-let Context$1 = class Context {
-  store;
-  constructor(store) {
-    this.store = store;
-    const descriptors = Object.getOwnPropertyDescriptors(this.store.logger);
-    for (const key in descriptors) {
-      if (key !== "setName") {
-        Object.defineProperty(this, key, descriptors[key]);
-      }
-    }
-  }
-  get isMounted() {
-    return this.store.isMounted;
-  }
-  get name() {
-    return this.store.name || this.store.id;
-  }
-  set name(value) {
-    this.store.name = value;
-    this.store.logger.setName(value);
-  }
-  get(store) {
-    if (isFunction(store)) {
-      let context = this.store.elementContext;
-      let instance;
-      while (true) {
-        instance = context.stores.get(store);
-        if (instance == null && context.parent != null) {
-          context = context.parent;
-        } else {
-          break;
-        }
-      }
-      if (instance == null) {
-        throw new StoreError(`Store '${store.name}' is not provided on this context.`);
-      } else {
-        return instance.value;
-      }
-    } else {
-      throw new StoreError(`Invalid store.`);
-    }
-  }
-  onMount(callback) {
-    this.store.lifecycleListeners.mount.push(callback);
-  }
-  onUnmount(callback) {
-    this.store.lifecycleListeners.unmount.push(callback);
-  }
-  effect(callback) {
-    const store = this.store;
-    if (store.isMounted) {
-      const unsubscribe = effect(callback);
-      store.lifecycleListeners.unmount.push(unsubscribe);
-      return unsubscribe;
-    } else {
-      let unsubscribe;
-      let disposed = false;
-      store.lifecycleListeners.mount.push(() => {
-        if (!disposed) {
-          unsubscribe = effect(callback);
-          store.lifecycleListeners.unmount.push(unsubscribe);
-        }
-      });
-      return () => {
-        if (unsubscribe != null) {
-          disposed = true;
-          unsubscribe();
-        }
-      };
-    }
-  }
-};
-class Store {
-  fn;
-  _options;
-  /**
-   * Value is guaranteed to be set after `attach` is called.
-   */
-  value;
-  isMounted = false;
-  elementContext;
-  lifecycleListeners = { mount: [], unmount: [] };
-  logger;
-  id = getUniqueId();
-  name;
-  constructor(fn, options) {
-    this.fn = fn;
-    this.name = fn.name;
-    this._options = options;
-  }
-  /**
-   * Attaches this Store to the elementContext.
-   * Returns false if there was already an instance attached, and true otherwise.
-   */
-  attach(elementContext) {
-    if (elementContext.stores.has(this.fn)) {
-      return false;
-    }
-    this.elementContext = elementContext;
-    this.logger = elementContext.root.createLogger(this.name);
-    const context = new Context$1(this);
-    try {
-      this.value = this.fn.call(context, this._options, context);
-    } catch (error) {
-      this.logger.crash(error);
-      throw error;
-    }
-    elementContext.stores.set(this.fn, this);
-    return true;
-  }
-  handleMount() {
-    this.isMounted = true;
-    for (const listener of this.lifecycleListeners.mount) {
-      listener();
-    }
-    this.lifecycleListeners.mount.length = 0;
-  }
-  handleUnmount() {
-    this.isMounted = false;
-    for (const listener of this.lifecycleListeners.unmount) {
-      listener();
-    }
-    this.lifecycleListeners.unmount.length = 0;
-  }
-}
-class StoreError extends Error {
-}
-
-class Context {
-  view;
-  constructor(view) {
-    this.view = view;
-    const descriptors = Object.getOwnPropertyDescriptors(this.view.logger);
-    for (const key in descriptors) {
-      if (key !== "setName") {
-        Object.defineProperty(this, key, descriptors[key]);
-      }
-    }
-  }
-  get uid() {
-    return this.view.uniqueId;
-  }
-  get isMounted() {
-    return this.view.isMounted;
-  }
-  get name() {
-    return this.view.elementContext.viewName || this.uid;
-  }
-  set name(value) {
-    this.view.elementContext.viewName = value;
-    this.view.logger.setName(value);
-  }
-  provide(store, options) {
-    const instance = new Store(store, options);
-    const attached = instance.attach(this.view.elementContext);
-    if (attached) {
-      this.view.lifecycleListeners.mount.push(() => {
-        instance.handleMount();
-      });
-      this.view.lifecycleListeners.unmount.push(() => {
-        instance.handleUnmount();
-      });
-      return instance.value;
-    } else {
-      let name = store.name ? `'${store.name}'` : "this store";
-      this.view.logger.warn(`An instance of ${name} was already attached to this context.`);
-      return this.get(store);
-    }
-  }
-  get(store) {
-    if (isFunction(store)) {
-      let context = this.view.elementContext;
-      let instance;
-      while (true) {
-        instance = context.stores.get(store);
-        if (instance == null && context.parent != null) {
-          context = context.parent;
-        } else {
-          break;
-        }
-      }
-      if (instance == null) {
-        throw new StoreError(`Store '${store.name}' is not provided on this context.`);
-      } else {
-        return instance.value;
-      }
-    } else {
-      throw new StoreError(`Invalid store.`);
-    }
-  }
-  beforeMount(callback) {
-    this.view.lifecycleListeners.beforeMount.push(callback);
-  }
-  onMount(callback) {
-    this.view.lifecycleListeners.mount.push(callback);
-  }
-  beforeUnmount(callback) {
-    this.view.lifecycleListeners.beforeUnmount.push(callback);
-  }
-  onUnmount(callback) {
-    this.view.lifecycleListeners.unmount.push(callback);
-  }
-  effect(callback) {
-    if (this.view.isMounted) {
-      const unsubscribe = effect(callback);
-      this.view.lifecycleListeners.unmount.push(unsubscribe);
-      return unsubscribe;
-    } else {
-      let unsubscribe;
-      let disposed = false;
-      this.view.lifecycleListeners.mount.push(() => {
-        if (!disposed) {
-          unsubscribe = effect(callback);
-          this.view.lifecycleListeners.unmount.push(unsubscribe);
-        }
-      });
-      return () => {
-        if (unsubscribe != null) {
-          disposed = true;
-          unsubscribe();
-        }
-      };
-    }
-  }
-  outlet() {
-    return createMarkup("$outlet", { children: this.view.children });
-  }
-}
-class View {
-  [IS_MARKUP_ELEMENT] = true;
-  uniqueId = getUniqueId();
-  elementContext;
-  logger;
-  props;
-  fn;
-  element;
-  childMarkup;
-  children = atom([]);
-  lifecycleListeners = { beforeMount: [], mount: [], beforeUnmount: [], unmount: [] };
-  constructor(elementContext, fn, props, children = []) {
-    this.elementContext = {
-      ...elementContext,
-      parent: elementContext,
-      viewName: fn.name,
-      stores: /* @__PURE__ */ new Map()
-    };
-    this.logger = elementContext.root.createLogger(fn.name || "🌇 anonymous view", { uid: this.uniqueId });
-    this.props = props;
-    this.fn = fn;
-    this.childMarkup = children;
-  }
-  /*===============================*\
-  ||         "Public" API          ||
-  \*===============================*/
-  get node() {
-    return this.element?.node;
-  }
-  isMounted = false;
-  mount(parent, after) {
-    const wasConnected = this.isMounted;
-    if (!wasConnected) {
-      this._initialize();
-      for (const listener of this.lifecycleListeners.beforeMount) {
-        listener();
-      }
-    }
-    if (this.element) {
-      this.element.mount(parent, after);
-    }
-    if (!wasConnected) {
-      this.isMounted = true;
-      requestAnimationFrame(() => {
-        for (const listener of this.lifecycleListeners.mount) {
-          listener();
-        }
-      });
-    }
-  }
-  unmount(parentIsUnmounting = false) {
-    for (const listener of this.lifecycleListeners.beforeUnmount) {
-      listener();
-    }
-    if (this.element) {
-      this.element.unmount(parentIsUnmounting);
-    }
-    this.isMounted = false;
-    for (const listener of this.lifecycleListeners.unmount) {
-      listener();
-    }
-    this.lifecycleListeners.beforeMount.length = 0;
-    this.lifecycleListeners.mount.length = 0;
-    this.lifecycleListeners.beforeUnmount.length = 0;
-    this.lifecycleListeners.unmount.length = 0;
-  }
-  setChildView(fn) {
-    this.childMarkup = [];
-    const node = new View(this.elementContext, fn, {});
-    this.children.value = [node];
-    return node;
-  }
-  /*===============================*\
-  ||           Internal            ||
-  \*===============================*/
-  _initialize() {
-    const context = new Context(this);
-    let result;
-    try {
-      result = this.fn.call(context, this.props, context);
-      if (this.childMarkup.length) {
-        this.children.value = constructMarkup(this.elementContext, this.childMarkup);
-      }
-    } catch (error) {
-      if (error instanceof Error) {
-        this.logger.crash(error);
-      }
-      throw error;
-    }
-    if (result === null) ; else if (result instanceof Node) {
-      this.element = groupElements(constructMarkup(this.elementContext, createMarkup("$node", { value: result })));
-    } else if (isReactive(result)) {
-      this.element = groupElements(
-        constructMarkup(this.elementContext, createMarkup("$dynamic", { source: result }))
-      );
-    } else if (isMarkup(result) || isArrayOf(isMarkup, result)) {
-      this.element = groupElements(constructMarkup(this.elementContext, result));
-    } else {
-      const error = new TypeError(
-        `Expected '${this.fn.name}' function to return a DOM node, Markup element, Readable or null. Got: ${typeOf(result)}`
-      );
-      this.logger.crash(error);
-    }
-  }
-}
-
-class List {
-  [IS_MARKUP_ELEMENT] = true;
-  node = document.createTextNode("");
-  items;
-  unsubscribe = null;
-  connectedItems = [];
-  elementContext;
-  renderFn;
-  keyFn;
-  get isMounted() {
-    return this.node.parentNode != null;
-  }
-  constructor({ elementContext, items, renderFn, keyFn }) {
-    this.elementContext = elementContext;
-    this.items = items;
-    this.renderFn = renderFn;
-    this.keyFn = keyFn;
-  }
-  mount(parent, after) {
-    if (!this.isMounted) {
-      parent.insertBefore(this.node, after?.nextSibling ?? null);
-      this.unsubscribe = effect(() => {
-        let value = get(this.items);
-        if (value == null) {
-          value = [];
-          console.log("list received empty value", value, this);
-        }
-        this._update(Array.from(value));
-      });
-    }
-  }
-  unmount(parentIsUnmounting = false) {
-    if (this.unsubscribe) {
-      this.unsubscribe();
-      this.unsubscribe = null;
-    }
-    if (!parentIsUnmounting && this.isMounted) {
-      this.node.parentNode?.removeChild(this.node);
-    }
-    this._cleanup(parentIsUnmounting);
-  }
-  _cleanup(parentIsUnmounting) {
-    for (const item of this.connectedItems) {
-      item.element.unmount(parentIsUnmounting);
-    }
-    this.connectedItems = [];
-  }
-  _update(value) {
-    if (value.length === 0 || !this.isMounted) {
-      return this._cleanup(false);
-    }
-    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.element.unmount(false);
-      }
-    }
-    for (const potential of potentialItems) {
-      const connected = this.connectedItems.find((item) => item.key === potential.key);
-      if (connected) {
-        connected.item.value = potential.value;
-        connected.index.value = potential.index;
-        newItems[potential.index] = connected;
-      } else {
-        const item = atom(potential.value);
-        const index2 = atom(potential.index);
-        newItems[potential.index] = {
-          key: potential.key,
-          item,
-          index: index2,
-          element: new View(this.elementContext, ListItemView, {
-            item: compose(() => item.value),
-            index: index2,
-            renderFn: this.renderFn
-          })
-        };
-      }
-    }
-    for (let i = 0; i < newItems.length; i++) {
-      const item = newItems[i];
-      const previous = newItems[i - 1]?.element.node ?? this.node;
-      item.element.mount(this.node.parentNode, previous);
-    }
-    this.connectedItems = newItems;
-    const lastItem = newItems.at(-1)?.element.node ?? this.node;
-    this.node.parentNode?.insertBefore(this.node, lastItem.nextSibling);
-  }
-}
-function ListItemView(props, context) {
-  context.name = "@ListItem";
-  return props.renderFn.call(context, props.item, props.index, context);
-}
-
-class Outlet {
-  [IS_MARKUP_ELEMENT] = true;
-  node = document.createTextNode("");
-  isMounted = false;
-  source;
-  elements = [];
-  unsubscribe;
-  constructor(source) {
-    this.source = source;
-  }
-  mount(parent, after) {
-    if (!this.isMounted) {
-      this.isMounted = true;
-      parent.insertBefore(this.node, after?.nextSibling ?? null);
-      if (isReactive(this.source)) {
-        this.unsubscribe = effect(() => {
-          this.update(get(this.source));
-        });
-      } else {
-        this.update(this.elements);
-      }
-    }
-  }
-  unmount(parentIsUnmounting = false) {
-    if (this.unsubscribe) {
-      this.unsubscribe();
-      this.unsubscribe = void 0;
-    }
-    if (this.isMounted) {
-      this.cleanup(parentIsUnmounting);
-      this.isMounted = false;
-    }
-  }
-  cleanup(parentIsUnmounting) {
-    for (const element of this.elements) {
-      element.unmount(parentIsUnmounting);
-    }
-    this.elements = [];
-  }
-  update(newElements) {
-    this.cleanup(false);
-    if (newElements.length > 0) {
-      for (let i = 0; i < newElements.length; i++) {
-        const element = newElements[i];
-        const previous = i > 0 ? this.elements[i - 1] : void 0;
-        element.mount(this.node.parentElement, previous?.node);
-        this.elements.push(element);
-      }
-      this.node.parentNode?.insertBefore(this.node, this.elements.at(-1)?.node ?? null);
-    }
-  }
-}
-
-class Portal {
-  [IS_MARKUP_ELEMENT] = true;
-  config;
-  element;
-  get isMounted() {
-    if (!this.element) {
-      return false;
-    }
-    return this.element.isMounted;
-  }
-  constructor(config) {
-    this.config = config;
-  }
-  mount(_parent, _after) {
-    const { content, parent } = this.config;
-    if (isMarkupElement(content)) {
-      this.element = content;
-    } else {
-      this.element = groupElements(constructMarkup(this.config.elementContext, toMarkup(content)));
-    }
-    this.element.mount(parent);
-  }
-  unmount(parentIsUnmounting = false) {
-    if (this.element?.isMounted) {
-      this.element.unmount(parentIsUnmounting);
-    }
-  }
-}
-
-function isMarkup(value) {
-  return value instanceof VNode;
-}
-function isMarkupElement(value) {
-  return value?.[IS_MARKUP_ELEMENT] === true;
-}
-function toMarkup(renderables) {
-  if (!isArray(renderables)) {
-    renderables = [renderables];
-  }
-  return renderables.flat(Infinity).filter((x) => x !== null && x !== void 0 && x !== false).map((x) => {
-    if (isMarkup(x)) {
-      return x;
-    }
-    if (x instanceof Node) {
-      return createMarkup("$node", { value: x });
-    }
-    if (isReactive(x)) {
-      return createMarkup("$dynamic", { source: x });
-    }
-    return createMarkup("$text", { value: x });
-  });
-}
-function createMarkup(type, props, ...children) {
-  return new VNode(type, props, ...children);
-}
-class VNode {
-  type;
-  props;
-  children;
-  constructor(type, props, ...children) {
-    this.type = type;
-    this.props = props;
-    this.children = toMarkup(children);
-  }
-}
-const html = htm.bind(createMarkup);
-function cond(condition, thenContent, elseContent) {
-  return createMarkup("$dynamic", {
-    source: compose(() => {
-      const value = get(condition);
-      if (value && thenContent) {
-        return thenContent;
-      } else if (!value && elseContent) {
-        return elseContent;
-      }
-      return null;
-    })
-  });
-}
-function list(items, keyFn, renderFn) {
-  return createMarkup("$list", { items: compose(() => items), keyFn, renderFn });
-}
-function portal(parent, content) {
-  return createMarkup("$portal", { parent, content });
-}
-function constructMarkup(elementContext, markup) {
-  const items = isArray(markup) ? markup : [markup];
-  return items.map((item) => {
-    if (isFunction(item.type)) {
-      return new View(elementContext, item.type, item.props, item.children);
-    } else if (isString(item.type)) {
-      switch (item.type) {
-        case "$node": {
-          const attrs = item.props;
-          return new DOMNode(attrs.value);
-        }
-        case "$text": {
-          const attrs = item.props;
-          return new DOMNode(document.createTextNode(String(attrs.value)));
-        }
-        case "$list": {
-          const attrs = item.props;
-          return new List({
-            items: attrs.items,
-            keyFn: attrs.keyFn,
-            renderFn: attrs.renderFn,
-            elementContext
-          });
-        }
-        case "$dynamic": {
-          const attrs = item.props;
-          return new Dynamic({
-            source: attrs.source,
-            elementContext
-          });
-        }
-        case "$outlet": {
-          const attrs = item.props;
-          return new Outlet(attrs.children);
-        }
-        case "$portal": {
-          const attrs = item.props;
-          return new Portal({
-            content: attrs.content,
-            parent: attrs.parent,
-            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,
-            elementContext
-          });
-      }
-    } else {
-      throw new TypeError(`Expected a string or view function. Got: ${item.type}`);
-    }
-  });
-}
-function groupElements(elements) {
-  if (elements.length === 1) {
-    return elements[0];
-  }
-  return new Outlet(elements);
-}
-function isRenderable(value) {
-  return value == null || value === false || isString(value) || isNumber(value) || isMarkup(value) || isReactive(value) || isArrayOf(isRenderable, value);
-}
-
-export { portal as A, list as B, IS_ROUTER as I, Passthrough as P, Store as S, View as V, assertArrayOf as a, assertString as b, atom as c, compose as d, assertObject as e, isString as f, get as g, isObject as h, isFunction as i, deepEqual as j, cond as k, html as l, createMatcher as m, StoreError as n, assertInstanceOf as o, createMarkup as p, groupElements as q, constructMarkup as r, shallowEqual as s, typeOf as t, noOp as u, okhash as v, effect as w, set as x, peek as y, strictEqual as z };
-//# sourceMappingURL=markup-PXJjYgl3.js.map