defuss-morph 0.1.1 → 0.3.0

package/dist/all.js

@@ -16,48 +16,60 @@ var __export = (target, all) => {
 // src/index.ts
 var exports_src = {};
 __export(exports_src, {
-  updateDomWithVdom: () => updateDomWithVdom,
-  resolveGlobals: () => resolveGlobals,
-  replaceDomWithVdom: () => replaceDomWithVdom,
-  renderMarkup: () => renderMarkup,
-  removeDelegatedEventByKey: () => removeDelegatedEventByKey,
-  removeDelegatedEvent: () => removeDelegatedEvent,
-  registerDelegatedEvent: () => registerDelegatedEvent,
-  queueCallback: () => queueCallback,
-  performTransition: () => performTransition,
-  parseEventPropName: () => parseEventPropName,
-  parseDOM: () => parseDOM,
-  observeUnmount: () => observeUnmount,
-  nsMap: () => nsMap,
-  morph: () => morph2,
-  isSVG: () => isSVG,
-  isMarkup: () => isMarkup,
-  isHTML: () => isHTML,
-  htmlStringToVNodes: () => htmlStringToVNodes,
-  handleLifecycleEventsForOnMount: () => handleLifecycleEventsForOnMount,
-  getTransitionStyles: () => getTransitionStyles,
-  getRenderer: () => getRenderer,
-  getRegisteredEventTypes: () => getRegisteredEventTypes,
-  getRegisteredEventKeys: () => getRegisteredEventKeys,
-  getMimeType: () => getMimeType,
-  domNodeToVNode: () => domNodeToVNode,
-  clearDelegatedEventsDeep: () => clearDelegatedEventsDeep,
-  clearDelegatedEvents: () => clearDelegatedEvents,
-  areDomNodesEqual: () => areDomNodesEqual,
-  applyStyles: () => applyStyles,
-  XMLNS_ATTRIBUTE_NAME: () => XMLNS_ATTRIBUTE_NAME,
-  XLINK_ATTRIBUTE_NAME: () => XLINK_ATTRIBUTE_NAME,
-  REF_ATTRIBUTE_NAME: () => REF_ATTRIBUTE_NAME,
-  FROM_DOM_MARKER: () => FROM_DOM_MARKER,
-  DEFAULT_TRANSITION_CONFIG: () => DEFAULT_TRANSITION_CONFIG,
-  DANGEROUSLY_SET_INNER_HTML_ATTRIBUTE: () => DANGEROUSLY_SET_INNER_HTML_ATTRIBUTE,
+  CAPTURE_ONLY_EVENTS: () => CAPTURE_ONLY_EVENTS,
   CLASS_ATTRIBUTE_NAME: () => CLASS_ATTRIBUTE_NAME,
-  CAPTURE_ONLY_EVENTS: () => CAPTURE_ONLY_EVENTS
+  COMMENT_TYPE: () => COMMENT_TYPE,
+  DANGEROUSLY_SET_INNER_HTML_ATTRIBUTE: () => DANGEROUSLY_SET_INNER_HTML_ATTRIBUTE,
+  DEFAULT_TRANSITION_CONFIG: () => DEFAULT_TRANSITION_CONFIG,
+  FROM_DOM_MARKER: () => FROM_DOM_MARKER,
+  Fragment: () => Fragment,
+  REF_ATTRIBUTE_NAME: () => REF_ATTRIBUTE_NAME,
+  Reactive: () => Reactive,
+  XLINK_ATTRIBUTE_NAME: () => XLINK_ATTRIBUTE_NAME,
+  XMLNS_ATTRIBUTE_NAME: () => XMLNS_ATTRIBUTE_NAME,
+  applyStyles: () => applyStyles,
+  areDomNodesEqual: () => areDomNodesEqual,
+  clearDelegatedEvents: () => clearDelegatedEvents,
+  clearDelegatedEventsDeep: () => clearDelegatedEventsDeep,
+  createRef: () => createRef,
+  domNodeToVNode: () => domNodeToVNode,
+  getMimeType: () => getMimeType,
+  getRegisteredEventKeys: () => getRegisteredEventKeys,
+  getRegisteredEventTypes: () => getRegisteredEventTypes,
+  getRenderer: () => getRenderer,
+  getTransitionStyles: () => getTransitionStyles,
+  h: () => h,
+  handleLifecycleEventsForOnMount: () => handleLifecycleEventsForOnMount,
+  htmlStringToVNodes: () => htmlStringToVNodes,
+  installReactive: () => installReactive,
+  isCommentVNode: () => isCommentVNode,
+  isHTML: () => isHTML,
+  isMarkup: () => isMarkup,
+  isRef: () => isRef,
+  isSVG: () => isSVG,
+  jsx: () => jsx,
+  jsxDEV: () => jsxDEV,
+  jsxs: () => jsxs,
+  morph: () => morph,
+  nsMap: () => nsMap,
+  observeUnmount: () => observeUnmount,
+  onClearDelegatedEvents: () => onClearDelegatedEvents,
+  parseDOM: () => parseDOM,
+  parseEventPropName: () => parseEventPropName,
+  performTransition: () => performTransition,
+  queueCallback: () => queueCallback,
+  reactive: () => reactive,
+  registerDelegatedEvent: () => registerDelegatedEvent,
+  removeDelegatedEvent: () => removeDelegatedEvent,
+  removeDelegatedEventByKey: () => removeDelegatedEventByKey,
+  renderMarkup: () => renderMarkup,
+  replaceDomWithVdom: () => replaceDomWithVdom,
+  resolveGlobals: () => resolveGlobals,
+  templateContent: () => templateContent,
+  updateDomWithVdom: () => updateDomWithVdom
 });
-
 // src/queue.ts
 var queueCallback = (cb) => (...args) => queueMicrotask(() => cb(...args));
-
 // src/delegated-events.ts
 var CAPTURE_ONLY_EVENTS = new Set([
   "focus",
@@ -67,8 +79,7 @@ var CAPTURE_ONLY_EVENTS = new Set([
   "mouseleave"
 ]);
 var elementHandlerMap = new WeakMap;
-var bubbleDispatched = new WeakMap;
-var captureDispatched = new WeakMap;
+var slotListeners = new WeakMap;
 var activeDispatches = new WeakMap;
 var parseEventPropName = (propName) => {
   if (!propName.startsWith("on"))
@@ -91,146 +102,66 @@ var getOrCreateElementHandlers = (el) => {
   elementHandlerMap.set(el, created);
   return created;
 };
-var getEventPath = (event) => {
-  const composedPath = event.composedPath?.();
-  if (composedPath && composedPath.length > 0)
-    return composedPath;
-  const path = [];
-  let node = event.target;
-  while (node) {
-    path.push(node);
-    const maybeNode = node;
-    if (typeof maybeNode === "object" && maybeNode && "parentNode" in maybeNode) {
-      node = maybeNode.parentNode;
-      continue;
-    }
-    break;
-  }
-  const doc = event.target?.ownerDocument;
-  if (doc && path[path.length - 1] !== doc)
-    path.push(doc);
-  const win = doc?.defaultView;
-  if (win && path[path.length - 1] !== win)
-    path.push(win);
-  return path;
+var runSlot = (target, eventType, phase, event) => {
+  const handler = elementHandlerMap.get(target)?.get(eventType)?.[phase];
+  if (!handler)
+    return;
+  const dispatchKey = `${eventType}:${phase}`;
+  let active = activeDispatches.get(target);
+  if (active?.has(dispatchKey))
+    return;
+  if (!active) {
+    active = new Set;
+    activeDispatches.set(target, active);
+  }
+  active.add(dispatchKey);
+  try {
+    handler.call(target, event);
+  } finally {
+    active.delete(dispatchKey);
+  }
 };
-var createPhaseHandler = (eventType, phase) => {
-  const dispatched = phase === "capture" ? captureDispatched : bubbleDispatched;
-  return (event) => {
-    const path = getEventPath(event).filter((t) => typeof t === "object" && t !== null && t.nodeType === 1);
-    const ordered = phase === "capture" ? [...path].reverse() : path;
-    for (const target of ordered) {
-      const handlersByEvent = elementHandlerMap.get(target);
-      if (!handlersByEvent)
-        continue;
-      const entry = handlersByEvent.get(eventType);
-      if (!entry)
-        continue;
-      let targets = dispatched.get(event);
-      if (targets?.has(target))
-        continue;
-      if (!targets) {
-        targets = new WeakSet;
-        dispatched.set(event, targets);
-      }
-      targets.add(target);
-      const dispatchKey = `${eventType}:${phase}`;
-      let activeSet = activeDispatches.get(target);
-      if (activeSet?.has(dispatchKey))
-        continue;
-      if (!activeSet) {
-        activeSet = new Set;
-        activeDispatches.set(target, activeSet);
-      }
-      activeSet.add(dispatchKey);
-      try {
-        if (phase === "capture") {
-          if (entry.capture) {
-            entry.capture.call(target, event);
-            if (event.cancelBubble)
-              return;
-          }
-          if (entry.captureSet) {
-            for (const handler of entry.captureSet) {
-              handler.call(target, event);
-              if (event.cancelBubble)
-                return;
-            }
-          }
-        } else {
-          if (entry.bubble) {
-            entry.bubble.call(target, event);
-            if (event.cancelBubble)
-              return;
-          }
-          if (entry.bubbleSet) {
-            for (const handler of entry.bubbleSet) {
-              handler.call(target, event);
-              if (event.cancelBubble)
-                return;
-            }
-          }
-        }
-      } finally {
-        activeSet.delete(dispatchKey);
-      }
+var setSlot = (target, eventType, phase, entry, handler) => {
+  entry[phase] = handler;
+  const key = `${eventType}:${phase}`;
+  const capture = phase === "capture";
+  let byKey = slotListeners.get(target);
+  const installed = byKey?.get(key);
+  if (handler && !installed) {
+    if (!byKey) {
+      byKey = new Map;
+      slotListeners.set(target, byKey);
     }
-  };
-};
-var installedRootListeners = new WeakMap;
-var ensureRootListener = (root, eventType) => {
-  const installed = installedRootListeners.get(root) ?? new Set;
-  installedRootListeners.set(root, installed);
-  const captureKey = `${eventType}:capture`;
-  if (!installed.has(captureKey)) {
-    root.addEventListener(eventType, createPhaseHandler(eventType, "capture"), true);
-    installed.add(captureKey);
-  }
-  const bubbleKey = `${eventType}:bubble`;
-  if (!installed.has(bubbleKey)) {
-    root.addEventListener(eventType, createPhaseHandler(eventType, "bubble"), false);
-    installed.add(bubbleKey);
+    const trampoline = (event) => runSlot(target, eventType, phase, event);
+    byKey.set(key, trampoline);
+    target.addEventListener(eventType, trampoline, capture);
+  } else if (!handler && installed) {
+    byKey.delete(key);
+    target.removeEventListener(eventType, installed, capture);
   }
 };
-var getEventRoot = (element) => {
-  const root = element.getRootNode();
-  if (root && root.nodeType === 9) {
-    return root;
-  }
-  if (root && root.nodeType === 11 && "host" in root) {
-    return root;
-  }
-  return null;
+var clearPhase = (target, eventType, entry, phase) => {
+  setSlot(target, eventType, phase, entry, undefined);
+  const setKey = phase === "capture" ? "captureSet" : "bubbleSet";
+  for (const handler of entry[setKey] ?? [])
+    target.removeEventListener(eventType, handler, phase === "capture");
+  entry[setKey] = undefined;
 };
 var registerDelegatedEvent = (element, eventType, handler, options = {}) => {
-  const root = getEventRoot(element);
   const capture = options.capture || CAPTURE_ONLY_EVENTS.has(eventType);
-  if (root) {
-    ensureRootListener(root, eventType);
-  } else if (element.ownerDocument) {
-    ensureRootListener(element.ownerDocument, eventType);
-  } else {
-    element.addEventListener(eventType, handler, capture);
-  }
+  const phase = capture ? "capture" : "bubble";
   const byEvent = getOrCreateElementHandlers(element);
   const entry = byEvent.get(eventType) ?? {};
   byEvent.set(eventType, entry);
   if (options.multi) {
-    if (capture) {
-      if (!entry.captureSet)
-        entry.captureSet = new Set;
-      entry.captureSet.add(handler);
-    } else {
-      if (!entry.bubbleSet)
-        entry.bubbleSet = new Set;
-      entry.bubbleSet.add(handler);
+    const setKey = capture ? "captureSet" : "bubbleSet";
+    const set = entry[setKey] ??= new Set;
+    if (!set.has(handler)) {
+      set.add(handler);
+      element.addEventListener(eventType, handler, capture);
     }
   } else {
-    if (capture) {
-      entry.capture = handler;
-    } else {
-      entry.bubble = handler;
-    }
+    setSlot(element, eventType, phase, entry, handler);
   }
 };
 var isEntryEmpty = (entry) => !entry.capture && !entry.bubble && (!entry.captureSet || entry.captureSet.size === 0) && (!entry.bubbleSet || entry.bubbleSet.size === 0);
@@ -242,35 +173,39 @@ var removeDelegatedEvent = (target, eventType, handler, _options = {}) => {
   if (!entry)
     return;
   if (handler) {
-    if (entry.captureSet) {
-      entry.captureSet.delete(handler);
-    }
-    if (entry.bubbleSet) {
-      entry.bubbleSet.delete(handler);
-    }
-    if (entry.capture === handler) {
-      entry.capture = undefined;
+    for (const phase of ["capture", "bubble"]) {
+      const set = phase === "capture" ? entry.captureSet : entry.bubbleSet;
+      if (set?.delete(handler))
+        target.removeEventListener(eventType, handler, phase === "capture");
+      if (entry[phase] === handler)
+        setSlot(target, eventType, phase, entry, undefined);
     }
-    if (entry.bubble === handler) {
-      entry.bubble = undefined;
-    }
-    target.removeEventListener(eventType, handler, true);
-    target.removeEventListener(eventType, handler, false);
   } else {
-    entry.capture = undefined;
-    entry.bubble = undefined;
-    entry.captureSet = undefined;
-    entry.bubbleSet = undefined;
+    clearPhase(target, eventType, entry, "capture");
+    clearPhase(target, eventType, entry, "bubble");
   }
   if (isEntryEmpty(entry)) {
     byEvent.delete(eventType);
   }
 };
+var clearHooks = new Set;
+var onClearDelegatedEvents = (hook) => {
+  clearHooks.add(hook);
+  return () => {
+    clearHooks.delete(hook);
+  };
+};
 var clearDelegatedEvents = (target) => {
   const byEvent = elementHandlerMap.get(target);
-  if (!byEvent)
-    return;
-  byEvent.clear();
+  if (byEvent) {
+    for (const [eventType, entry] of byEvent) {
+      clearPhase(target, eventType, entry, "capture");
+      clearPhase(target, eventType, entry, "bubble");
+    }
+    byEvent.clear();
+  }
+  for (const hook of clearHooks)
+    hook(target);
 };
 var clearDelegatedEventsDeep = (root) => {
   clearDelegatedEvents(root);
@@ -310,16 +245,116 @@ var removeDelegatedEventByKey = (element, eventType, phase) => {
   const entry = byEvent.get(eventType);
   if (!entry)
     return;
-  if (phase === "capture") {
-    entry.capture = undefined;
-    entry.captureSet = undefined;
-  } else {
-    entry.bubble = undefined;
-    entry.bubbleSet = undefined;
-  }
+  clearPhase(element, eventType, entry, phase);
   if (isEntryEmpty(entry))
     byEvent.delete(eventType);
 };
+// src/html.ts
+var FROM_DOM_MARKER = Symbol("defuss-morph.from-dom");
+var COMMENT_TYPE = "#comment";
+var isCommentVNode = (value) => !!value && typeof value === "object" && value.type === COMMENT_TYPE;
+var HTML_BOOLEAN_ATTRIBUTES = new Set([
+  "allowfullscreen",
+  "async",
+  "autofocus",
+  "autoplay",
+  "checked",
+  "controls",
+  "default",
+  "defer",
+  "disabled",
+  "formnovalidate",
+  "hidden",
+  "inert",
+  "ismap",
+  "itemscope",
+  "loop",
+  "multiple",
+  "muted",
+  "nomodule",
+  "novalidate",
+  "open",
+  "playsinline",
+  "readonly",
+  "required",
+  "reversed",
+  "selected"
+]);
+var domAttributeToVNodeValue = (attr) => HTML_BOOLEAN_ATTRIBUTES.has(attr.name.toLowerCase()) ? true : attr.value;
+function parseDOM(input, type, Parser) {
+  return new Parser().parseFromString(input, type);
+}
+function isSVG(input, Parser) {
+  const doc = parseDOM(input, "image/svg+xml", Parser);
+  if (!doc.documentElement)
+    return false;
+  return doc.documentElement.nodeName.toLowerCase() === "svg";
+}
+function isHTML(input, Parser) {
+  const doc = parseDOM(input, "text/html", Parser);
+  return doc.documentElement.querySelectorAll("*").length > 2;
+}
+var isMarkup = (input, Parser) => input.indexOf("<") > -1 && input.indexOf(">") > -1 && (isHTML(input, Parser) || isSVG(input, Parser));
+function renderMarkup(markup, Parser, doc) {
+  const parsed = doc ? doc : parseDOM(markup, getMimeType(markup, Parser), Parser);
+  if (parsed.body)
+    return Array.from(parsed.body.childNodes);
+  return parsed.documentElement ? [parsed.documentElement] : [];
+}
+function getMimeType(input, Parser) {
+  if (isSVG(input, Parser)) {
+    return "image/svg+xml";
+  }
+  return "text/html";
+}
+var templateContent = (element) => element.localName === "template" ? element.content : undefined;
+function domNodeToVNode(node) {
+  if (node.nodeType === 3) {
+    return node.nodeValue || "";
+  }
+  if (node.nodeType === 1) {
+    const element = node;
+    const attributes = {};
+    for (let i = 0;i < element.attributes.length; i++) {
+      const attr = element.attributes[i];
+      attributes[attr.name] = domAttributeToVNodeValue(attr);
+    }
+    const children = [];
+    for (let child = (templateContent(element) ?? element).firstChild;child; child = child.nextSibling) {
+      children.push(domNodeToVNode(child));
+    }
+    attributes[FROM_DOM_MARKER] = true;
+    return { type: element.localName, attributes, children };
+  }
+  if (node.nodeType === 8) {
+    return { type: COMMENT_TYPE, value: node.nodeValue ?? "" };
+  }
+  return "";
+}
+var inertDocuments = new WeakMap;
+var DOCUMENT_START = /^\s*(?:<!--[\s\S]*?-->\s*)*<(?:!doctype|html|head|body)[\s>/]/i;
+function htmlStringToVNodes(html, Parser) {
+  if (DOCUMENT_START.test(html)) {
+    return toVNodes(new Parser().parseFromString(html, "text/html").body.childNodes);
+  }
+  let inert = inertDocuments.get(Parser);
+  if (!inert) {
+    inert = new Parser().parseFromString("", "text/html");
+    inertDocuments.set(Parser, inert);
+  }
+  const template = inert.createElement("template");
+  template.innerHTML = html;
+  return toVNodes(template.content.childNodes);
+}
+function toVNodes(nodes) {
+  const vNodes = [];
+  for (let i = 0;i < nodes.length; i++) {
+    const vnode = domNodeToVNode(nodes[i]);
+    if (vnode !== "")
+      vNodes.push(vnode);
+  }
+  return vNodes;
+}
 
 // src/renderer.ts
 var CLASS_ATTRIBUTE_NAME = "class";
@@ -369,13 +404,18 @@ var observeUnmount = (domNode, onUnmount) => {
   });
   observer.observe(parentNode, { childList: true });
 };
+var unmountObserved = new WeakSet;
 var handleLifecycleEventsForOnMount = (newEl) => {
   if (typeof newEl?.$onMount === "function") {
     newEl.$onMount(newEl);
     newEl.$onMount = null;
   }
-  if (typeof newEl?.$onUnmount === "function") {
-    observeUnmount(newEl, newEl.$onUnmount);
+  if (typeof newEl?.$onUnmount === "function" && !unmountObserved.has(newEl)) {
+    unmountObserved.add(newEl);
+    observeUnmount(newEl, () => {
+      unmountObserved.delete(newEl);
+      newEl.$onUnmount?.(newEl);
+    });
   }
 };
 var getRenderer = (document2) => {
@@ -386,6 +426,9 @@ var getRenderer = (document2) => {
       if (Array.isArray(virtualNode)) {
         return renderer.createChildElements(virtualNode, parentDomElement);
       }
+      if (typeof virtualNode === "string" || typeof virtualNode === "number") {
+        return renderer.createTextNode(String(virtualNode), parentDomElement);
+      }
       if (typeof virtualNode !== "undefined") {
         return renderer.createElement(virtualNode, parentDomElement);
       }
@@ -393,40 +436,36 @@ var getRenderer = (document2) => {
     },
     createElement: (virtualNode, parentDomElement) => {
       let newEl;
-      try {
-        if (typeof virtualNode === "function" && virtualNode.constructor.name === "AsyncFunction") {
+      if (isCommentVNode(virtualNode)) {
+        const comment = document2.createComment(virtualNode.value ?? "");
+        parentDomElement?.appendChild(comment);
+        return comment;
+      }
+      if (typeof virtualNode === "function" && virtualNode.constructor.name === "AsyncFunction") {
+        newEl = document2.createElement("div");
+      } else if (typeof virtualNode === "object" && virtualNode !== null && "type" in virtualNode) {
+        const vNode = virtualNode;
+        if (typeof vNode.type === "function") {
           newEl = document2.createElement("div");
-        } else if (typeof virtualNode === "object" && virtualNode !== null && "type" in virtualNode) {
-          const vNode = virtualNode;
-          if (typeof vNode.type === "function") {
-            newEl = document2.createElement("div");
-            newEl.innerText = `FATAL ERROR: ${vNode.type._error}`;
-          } else if (typeof vNode.type === "string" && vNode.type.toUpperCase() === "SVG" || parentDomElement && renderer.hasSvgNamespace(parentDomElement, typeof vNode.type === "string" ? vNode.type.toUpperCase() : "")) {
-            newEl = document2.createElementNS(nsMap.svg, vNode.type);
-          } else {
-            newEl = document2.createElement(vNode.type);
-          }
-          if (vNode.attributes) {
-            renderer.setAttributes(vNode, newEl);
-            if (vNode.attributes.dangerouslySetInnerHTML) {
-              newEl.innerHTML = vNode.attributes.dangerouslySetInnerHTML.__html;
-            }
-          }
-          if (vNode.children && !vNode.attributes?.dangerouslySetInnerHTML) {
-            renderer.createChildElements(vNode.children, newEl);
-          }
+          newEl.innerText = `FATAL ERROR: ${vNode.type._error}`;
+        } else if (typeof vNode.type === "string" && vNode.type.toUpperCase() === "SVG" || parentDomElement && renderer.hasSvgNamespace(parentDomElement, typeof vNode.type === "string" ? vNode.type.toUpperCase() : "")) {
+          newEl = document2.createElementNS(nsMap.svg, vNode.type);
         } else {
-          if (typeof virtualNode === "string" || typeof virtualNode === "number") {
-            newEl = document2.createElement(String(virtualNode));
+          newEl = document2.createElement(vNode.type);
+        }
+        if (vNode.attributes) {
+          renderer.setAttributes(vNode, newEl);
+          if (vNode.attributes.dangerouslySetInnerHTML) {
+            newEl.innerHTML = vNode.attributes.dangerouslySetInnerHTML.__html;
           }
         }
-        if (newEl && parentDomElement) {
-          parentDomElement.appendChild(newEl);
-          handleLifecycleEventsForOnMount(newEl);
+        if (vNode.children && !vNode.attributes?.dangerouslySetInnerHTML) {
+          renderer.createChildElements(vNode.children, templateContent(newEl) ?? newEl);
         }
-      } catch (e) {
-        console.error("Fatal error! Error happend while rendering the VDOM!", e, virtualNode);
-        throw e;
+      }
+      if (newEl && parentDomElement) {
+        parentDomElement.appendChild(newEl);
+        handleLifecycleEventsForOnMount(newEl);
       }
       return newEl;
     },
@@ -462,19 +501,8 @@ var getRenderer = (document2) => {
         return;
       }
       if (name === REF_ATTRIBUTE_NAME && typeof value !== "function") {
-        const ref = value;
-        ref.current = domElement;
+        value.current = domElement;
         domElement._defussRef = value;
-        domElement.$onUnmount = queueCallback(() => {});
-        if (domElement.parentNode) {
-          observeUnmount(domElement, domElement.$onUnmount);
-        } else {
-          queueMicrotask(() => {
-            if (domElement.parentNode) {
-              observeUnmount(domElement, domElement.$onUnmount);
-            }
-          });
-        }
         return;
       }
       const parsed = parseEventPropName(name);
@@ -485,15 +513,7 @@ var getRenderer = (document2) => {
           return;
         }
         if (eventType === "unmount") {
-          if (domElement.$onUnmount) {
-            const existingUnmount = domElement.$onUnmount;
-            domElement.$onUnmount = () => {
-              existingUnmount();
-              value();
-            };
-          } else {
-            domElement.$onUnmount = queueCallback(value);
-          }
+          domElement.$onUnmount = queueCallback(value);
           return;
         }
         registerDelegatedEvent(domElement, eventType, value, { capture });
@@ -547,99 +567,35 @@ var getRenderer = (document2) => {
   };
   return renderer;
 };
-
-// src/html.ts
-var FROM_DOM_MARKER = Symbol("defuss-morph.from-dom");
-var HTML_BOOLEAN_ATTRIBUTES = new Set([
-  "allowfullscreen",
-  "async",
-  "autofocus",
-  "autoplay",
-  "checked",
-  "controls",
-  "default",
-  "defer",
-  "disabled",
-  "formnovalidate",
-  "hidden",
-  "inert",
-  "ismap",
-  "itemscope",
-  "loop",
-  "multiple",
-  "muted",
-  "nomodule",
-  "novalidate",
-  "open",
-  "playsinline",
-  "readonly",
-  "required",
-  "reversed",
-  "selected"
-]);
-var domAttributeToVNodeValue = (attr) => HTML_BOOLEAN_ATTRIBUTES.has(attr.name.toLowerCase()) ? true : attr.value;
-function parseDOM(input, type, Parser) {
-  return new Parser().parseFromString(input, type);
-}
-function isSVG(input, Parser) {
-  const doc = parseDOM(input, "image/svg+xml", Parser);
-  if (!doc.documentElement)
-    return false;
-  return doc.documentElement.nodeName.toLowerCase() === "svg";
-}
-function isHTML(input, Parser) {
-  const doc = parseDOM(input, "text/html", Parser);
-  return doc.documentElement.querySelectorAll("*").length > 2;
-}
-var isMarkup = (input, Parser) => input.indexOf("<") > -1 && input.indexOf(">") > -1 && (isHTML(input, Parser) || isSVG(input, Parser));
-function renderMarkup(markup, Parser, doc) {
-  const parsed = doc ? doc : parseDOM(markup, getMimeType(markup, Parser), Parser);
-  if (parsed.body)
-    return Array.from(parsed.body.childNodes);
-  return parsed.documentElement ? [parsed.documentElement] : [];
-}
-function getMimeType(input, Parser) {
-  if (isSVG(input, Parser)) {
-    return "image/svg+xml";
-  }
-  return "text/html";
-}
-function domNodeToVNode(node) {
-  if (node.nodeType === 3) {
-    return node.textContent || "";
-  }
-  if (node.nodeType === 1) {
-    const element = node;
-    const attributes = {};
-    for (let i = 0;i < element.attributes.length; i++) {
-      const attr = element.attributes[i];
-      attributes[attr.name] = domAttributeToVNodeValue(attr);
-    }
-    const children = [];
-    for (let i = 0;i < element.childNodes.length; i++) {
-      const childVNode = domNodeToVNode(element.childNodes[i]);
-      children.push(childVNode);
-    }
-    return {
-      type: element.tagName.toLowerCase(),
-      attributes: { ...attributes, [FROM_DOM_MARKER]: true },
-      children
-    };
-  }
-  return "";
-}
-function htmlStringToVNodes(html, Parser) {
-  const parser = new Parser;
-  const doc = parser.parseFromString(html, "text/html");
-  const vNodes = [];
-  for (let i = 0;i < doc.body.childNodes.length; i++) {
-    const vnode = domNodeToVNode(doc.body.childNodes[i]);
-    if (vnode !== "") {
-      vNodes.push(vnode);
+// src/lis.ts
+var longestIncreasingRun = (values) => {
+  const n = values.length;
+  const marked = new Uint8Array(n);
+  const tails = new Int32Array(n);
+  const previous = new Int32Array(n);
+  let length = 0;
+  for (let i = 0;i < n; i++) {
+    const value = values[i];
+    if (value < 0)
+      continue;
+    let low = 0;
+    let high = length;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if (values[tails[mid]] < value)
+        low = mid + 1;
+      else
+        high = mid;
     }
+    previous[i] = low > 0 ? tails[low - 1] : -1;
+    tails[low] = i;
+    if (low === length)
+      length++;
   }
-  return vNodes;
-}
+  for (let i = length > 0 ? tails[length - 1] : -1;i >= 0; i = previous[i])
+    marked[i] = 1;
+  return marked;
+};
 
 // src/morph.ts
 var areDomNodesEqual = (oldNode, newNode) => {
@@ -663,8 +619,8 @@ var areDomNodesEqual = (oldNode, newNode) => {
         return false;
     }
   }
-  if (oldNode.nodeType === 3) {
-    if (oldNode.textContent !== newNode.textContent)
+  if (oldNode.nodeType === 3 || oldNode.nodeType === 8) {
+    if (oldNode.nodeValue !== newNode.nodeValue)
       return false;
   }
   return true;
@@ -761,6 +717,8 @@ function areNodeAndChildMatching(domNode, child) {
   if (typeof child === "string" || typeof child === "number" || typeof child === "boolean") {
     return domNode.nodeType === 3;
   }
+  if (isCommentVNode(child))
+    return domNode.nodeType === 8;
   if (child && typeof child === "object") {
     if (domNode.nodeType !== 1)
       return false;
@@ -854,6 +812,11 @@ function patchElementInPlace(el, vnode, globals, mergeAttributes = false) {
     return;
   morphDomDirect(el, vnode.children ?? [], globals);
 }
+function replaceNode(old, next) {
+  if (old.nodeType === 1)
+    clearDelegatedEventsDeep(old);
+  old.parentNode?.replaceChild(next, old);
+}
 function morphNode(domNode, child, globals, mergeAttributes = false) {
   if (typeof child === "string" || typeof child === "number" || typeof child === "boolean") {
     const text = String(child);
@@ -863,7 +826,18 @@ function morphNode(domNode, child, globals, mergeAttributes = false) {
       return domNode;
     }
     const next = globals.window.document.createTextNode(text);
-    domNode.parentNode?.replaceChild(next, domNode);
+    replaceNode(domNode, next);
+    return next;
+  }
+  if (isCommentVNode(child)) {
+    const data = child.value ?? "";
+    if (domNode.nodeType === 8) {
+      if (domNode.nodeValue !== data)
+        domNode.nodeValue = data;
+      return domNode;
+    }
+    const next = globals.window.document.createComment(data);
+    replaceNode(domNode, next);
     return next;
   }
   if (child && typeof child === "object") {
@@ -887,13 +861,15 @@ function morphNode(domNode, child, globals, mergeAttributes = false) {
       const first = Array.isArray(created) ? created[0] : created;
       if (!first)
         return null;
-      el.parentNode?.replaceChild(first, el);
+      replaceNode(el, first);
       handleLifecycleEventsForOnMount(first);
       return first;
     }
     patchElementInPlace(el, child, globals, mergeAttributes);
     return el;
   }
+  if (domNode.nodeType === 1)
+    clearDelegatedEventsDeep(domNode);
   domNode.parentNode?.removeChild(domNode);
   return null;
 }
@@ -954,6 +930,8 @@ function morphDiff(targetRoot, patchItems, globals) {
   for (const item of patchItems) {
     if (typeof item === "string" && item.trim() === "")
       continue;
+    if (isCommentVNode(item))
+      continue;
     const key = getVNodeMatchKey(item);
     if (!key) {
       throw new Error(`morph diff: patch items must be elements with a key or id attribute (got ${describePatchItem(item)})`);
@@ -974,71 +952,140 @@ function morphDiff(targetRoot, patchItems, globals) {
     }
   }
 }
+function moveNode(parent, node, anchor) {
+  if (typeof parent.moveBefore === "function") {
+    try {
+      parent.moveBefore(node, anchor);
+      return;
+    } catch {}
+  }
+  const doc = node.ownerDocument;
+  const active = doc?.activeElement;
+  const holdsFocus = !!active && active !== doc.body && node.contains(active);
+  let selection;
+  if (holdsFocus) {
+    try {
+      if (active.selectionStart !== null && active.selectionStart !== undefined) {
+        selection = [active.selectionStart, active.selectionEnd ?? active.selectionStart, active.selectionDirection ?? "none"];
+      }
+    } catch {
+      selection = undefined;
+    }
+  }
+  parent.insertBefore(node, anchor);
+  if (holdsFocus && active.isConnected && doc.activeElement !== active) {
+    active.focus({ preventScroll: true });
+    if (selection)
+      active.setSelectionRange(...selection);
+  }
+}
+function patchByPosition(targetRoot, nextChildren, globals) {
+  const live = targetRoot.childNodes;
+  if (live.length !== nextChildren.length)
+    return false;
+  for (let c = 0;c < nextChildren.length; c++) {
+    const node = live[c];
+    const child = nextChildren[c];
+    if (getVNodeMatchKey(child) !== null || !areNodeAndChildMatching(node, child))
+      return false;
+    if (node.nodeType === 1 && getDomMatchKeys(node).length > 0)
+      return false;
+  }
+  for (let c = 0;c < nextChildren.length; c++)
+    morphNode(live[c], nextChildren[c], globals);
+  return true;
+}
 function morphDomDirect(parentElement, newVDOM, globals, mode = "replace") {
   const el = parentElement;
   const isCustomElement = el.tagName.includes("-");
-  const targetRoot = el.shadowRoot && !isCustomElement ? el.shadowRoot : parentElement;
+  const targetRoot = templateContent(parentElement) ?? (el.shadowRoot && !isCustomElement ? el.shadowRoot : parentElement);
   const nextChildren = normalizeChildren(newVDOM, mode === "diff");
   if (mode === "diff") {
     morphDiff(targetRoot, nextChildren, globals);
     return;
   }
+  if (patchByPosition(targetRoot, nextChildren, globals))
+    return;
   const existing = Array.from(targetRoot.childNodes);
   const keyedPool = new Map;
-  const nodeKeys = new WeakMap;
+  const nodeKeys = [];
   const unkeyedPool = [];
-  for (const node of existing) {
-    const keys = getDomMatchKeys(node);
+  for (let i = 0;i < existing.length; i++) {
+    const keys = getDomMatchKeys(existing[i]);
     if (keys.length > 0) {
-      nodeKeys.set(node, keys);
+      nodeKeys[i] = keys;
       let addedToKeyedPool = false;
       for (const k of keys) {
         if (!keyedPool.has(k)) {
-          keyedPool.set(k, node);
+          keyedPool.set(k, i);
           addedToKeyedPool = true;
         }
       }
       if (!addedToKeyedPool) {
-        unkeyedPool.push(node);
+        unkeyedPool.push(i);
       }
     } else {
-      unkeyedPool.push(node);
+      unkeyedPool.push(i);
     }
   }
-  const consumeKeyedNode = (node) => {
-    const keys = nodeKeys.get(node) ?? [];
-    for (const k of keys)
-      keyedPool.delete(k);
+  const consumeKeyedNode = (i) => {
+    for (const k of nodeKeys[i] ?? []) {
+      if (keyedPool.get(k) === i)
+        keyedPool.delete(k);
+    }
   };
   const takeUnkeyedMatch = (child) => {
-    for (let i = 0;i < unkeyedPool.length; i++) {
-      const candidate = unkeyedPool[i];
-      if (areNodeAndChildMatching(candidate, child)) {
-        unkeyedPool.splice(i, 1);
-        return candidate;
+    for (let j = 0;j < unkeyedPool.length; j++) {
+      const i = unkeyedPool[j];
+      if (areNodeAndChildMatching(existing[i], child)) {
+        unkeyedPool.splice(j, 1);
+        return i;
       }
     }
-    return;
+    return -1;
   };
-  let domIndex = 0;
-  for (const child of nextChildren) {
+  const count = nextChildren.length;
+  const matched = new Int32Array(count);
+  let inOrder = true;
+  let previous = -1;
+  for (let c = 0;c < count; c++) {
+    const child = nextChildren[c];
     const key = getVNodeMatchKey(child);
-    let match;
+    let i = -1;
     if (key) {
-      match = keyedPool.get(key);
-      if (match)
-        consumeKeyedNode(match);
+      const hit = keyedPool.get(key);
+      if (hit !== undefined) {
+        i = hit;
+        consumeKeyedNode(hit);
+      }
     } else {
-      match = takeUnkeyedMatch(child);
+      i = takeUnkeyedMatch(child);
     }
-    const anchor = targetRoot.childNodes[domIndex] ?? null;
-    if (match) {
-      if (match !== anchor) {
-        targetRoot.insertBefore(match, anchor);
-      }
-      const morphed = morphNode(match, child, globals);
-      if (morphed && morphed !== match) {}
-      domIndex++;
+    matched[c] = i;
+    if (i >= 0) {
+      if (i < previous)
+        inOrder = false;
+      previous = i;
+    }
+  }
+  const stays = inOrder ? null : longestIncreasingRun(matched);
+  const staying = (c) => matched[c] >= 0 && (stays === null || stays[c] === 1);
+  let anchorAt = 0;
+  while (anchorAt < count && !staying(anchorAt))
+    anchorAt++;
+  for (let c = 0;c < count; c++) {
+    if (anchorAt <= c) {
+      anchorAt = c + 1;
+      while (anchorAt < count && !staying(anchorAt))
+        anchorAt++;
+    }
+    const anchor = anchorAt < count ? existing[matched[anchorAt]] : null;
+    const child = nextChildren[c];
+    if (matched[c] >= 0) {
+      const match = existing[matched[c]];
+      if (!staying(c))
+        moveNode(targetRoot, match, anchor);
+      morphNode(match, child, globals);
       continue;
     }
     const created = createDomFromChild(child, globals);
@@ -1048,14 +1095,13 @@ function morphDomDirect(parentElement, newVDOM, globals, mode = "replace") {
     for (const node of nodes) {
       targetRoot.insertBefore(node, anchor);
       handleLifecycleEventsForOnMount(node);
-      domIndex++;
     }
   }
   const remaining = new Set;
-  for (const node of unkeyedPool)
-    remaining.add(node);
-  for (const node of keyedPool.values())
-    remaining.add(node);
+  for (const i of unkeyedPool)
+    remaining.add(existing[i]);
+  for (const i of keyedPool.values())
+    remaining.add(existing[i]);
   for (const node of remaining) {
     if (node.parentNode === targetRoot) {
       if (node.nodeType === 1) {
@@ -1068,7 +1114,10 @@ function morphDomDirect(parentElement, newVDOM, globals, mode = "replace") {
 function replaceDomWithVdom(parentElement, newVDOM, globals) {
   const resolvedGlobals = resolveGlobals(parentElement, globals);
   while (parentElement.firstChild) {
-    parentElement.removeChild(parentElement.firstChild);
+    const child = parentElement.firstChild;
+    if (child.nodeType === 1)
+      clearDelegatedEventsDeep(child);
+    parentElement.removeChild(child);
   }
   const renderer = getRenderer(resolvedGlobals.window.document);
   const newDom = renderer.createElementOrElements(newVDOM);
@@ -1084,7 +1133,6 @@ function replaceDomWithVdom(parentElement, newVDOM, globals) {
     handleLifecycleEventsForOnMount(newDom);
   }
 }
-
 // src/transitions.ts
 var injectShakeKeyframes = (doc) => {
   if (!doc)
@@ -1168,7 +1216,9 @@ var performCrossfade = async (element, updateCallback, duration, easing) => {
   const doc = element.ownerDocument;
   try {
     const rect = element.getBoundingClientRect();
-    snapshot.style.cssText = `position:absolute;top:${rect.top}px;left:${rect.left}px;width:${rect.width}px;height:${rect.height}px;opacity:1;transition:opacity ${duration}ms ${easing};z-index:1000;`;
+    const top = rect.top + (doc.defaultView?.scrollY ?? 0);
+    const left = rect.left + (doc.defaultView?.scrollX ?? 0);
+    snapshot.style.cssText = `position:absolute;top:${top}px;left:${left}px;width:${rect.width}px;height:${rect.height}px;opacity:1;transition:opacity ${duration}ms ${easing};z-index:1000;`;
     element.style.opacity = "0";
     element.style.transition = `opacity ${duration}ms ${easing}`;
     doc.body.appendChild(snapshot);
@@ -1228,10 +1278,9 @@ var performTransition = async (element, updateCallback, config = {}) => {
     throw error;
   }
 };
-
-// src/index.ts
+// src/api.ts
 var inflightTransitions = new WeakMap;
-var morph2 = (el, newContent, options = {}) => {
+var morph = (el, newContent, options = {}) => {
   const globals = resolveGlobals(el);
   const win = globals.window;
   const mode = options.diff ? "diff" : "replace";
@@ -1242,15 +1291,15 @@ var morph2 = (el, newContent, options = {}) => {
     const transitionTarget = config.target === "self" ? el : el.parentElement;
     if (!transitionTarget) {
       apply(newContent);
-      return;
+      return Promise.resolve();
     }
-    const slot2 = { content: newContent };
-    inflightTransitions.set(el, slot2);
+    const slot = { content: newContent };
+    inflightTransitions.set(el, slot);
     return performTransition(transitionTarget, async () => {
-      if (inflightTransitions.get(el) === slot2)
-        apply(slot2.content);
+      if (inflightTransitions.get(el) === slot)
+        apply(slot.content);
     }, config).finally(() => {
-      if (inflightTransitions.get(el) === slot2)
+      if (inflightTransitions.get(el) === slot)
         inflightTransitions.delete(el);
     });
   }
@@ -1259,7 +1308,151 @@ var morph2 = (el, newContent, options = {}) => {
     slot.content = newContent;
   apply(newContent);
 };
-
+// src/jsx.ts
+var toChildren = (children) => children === undefined ? [] : Array.isArray(children) ? children.flat(Infinity) : [children];
+var isVNode2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value) && ("type" in value);
+var Fragment = (props) => toChildren(props?.children);
+function jsx(type, props, key) {
+  const { children, ...attributes } = props ?? {};
+  const resolvedKey = key ?? attributes.key;
+  if (resolvedKey !== undefined)
+    attributes.key = resolvedKey;
+  if (typeof type === "function") {
+    const result = type(children === undefined ? attributes : { ...attributes, children });
+    return resolvedKey !== undefined && isVNode2(result) && result.attributes?.key === undefined ? { ...result, attributes: { ...result.attributes, key: resolvedKey } } : result;
+  }
+  return { type, attributes, children: toChildren(children) };
+}
+var jsxs = jsx;
+var jsxDEV = (type, props, key) => jsx(type, props, key);
+function h(type, props, ...children) {
+  return jsx(type, children.length === 0 ? props : { ...props, children: children.length === 1 ? children[0] : children });
+}
+// src/ref.ts
+var createRef = (state) => ({
+  current: null,
+  state
+});
+var isRef = (value) => typeof value === "object" && value !== null && ("current" in value);
+// src/reactive.ts
+var isElement = (value) => typeof value === "object" && value !== null && value.nodeType === 1;
+var toStores = (store, caller) => {
+  const stores = Array.isArray(store) ? store : [store];
+  stores.forEach((candidate, index) => {
+    if (typeof candidate?.subscribe !== "function") {
+      throw new TypeError(`${caller}: store${Array.isArray(store) ? ` ${index}` : ""} has no subscribe() method`);
+    }
+  });
+  return stores;
+};
+var listen = (stores, update) => {
+  const unsubscribes = stores.map((store) => {
+    const result = store.subscribe(() => update());
+    if (typeof result === "function")
+      return result;
+    return () => result?.unsubscribe?.();
+  });
+  return () => {
+    for (const unsubscribe of unsubscribes)
+      unsubscribe();
+  };
+};
+var resolveTarget = (target) => {
+  if (isElement(target))
+    return () => [target];
+  if (isRef(target)) {
+    if (!isElement(target.current)) {
+      throw new TypeError("reactive: the ref has no element yet; call reactive() after the element is rendered (in onMount or later)");
+    }
+    return () => isElement(target.current) ? [target.current] : [];
+  }
+  if (target && typeof target.length === "number") {
+    const elements = Array.from(target).filter(isElement);
+    return () => elements;
+  }
+  throw new TypeError("reactive: the target must be an element, a ref or a list of elements");
+};
+function reactive(config, target) {
+  const stores = toStores(config?.store, "reactive");
+  if (typeof config.render !== "function")
+    throw new TypeError("reactive: config.render must be a function");
+  const elements = resolveTarget(target);
+  if (config.signal?.aborted || elements().length === 0)
+    return () => {};
+  const update = () => {
+    for (const el of elements())
+      morph(el, config.render());
+  };
+  update();
+  const unsubscribe = listen(stores, update);
+  let disposed = false;
+  const dispose = () => {
+    if (disposed)
+      return;
+    disposed = true;
+    unsubscribe();
+    config.signal?.removeEventListener("abort", dispose);
+    config.cleanup?.();
+  };
+  config.signal?.addEventListener("abort", dispose, { once: true });
+  return dispose;
+}
+var mounted = new WeakMap;
+var toChildren2 = (content) => {
+  if (typeof content === "string") {
+    if (!/[<&]/.test(content))
+      return content === "" ? [] : [content];
+    const Parser = globalThis.DOMParser;
+    if (!Parser) {
+      throw new TypeError("Reactive: rendering an HTML string needs a global DOMParser; return JSX/VNodes, or call reactive()");
+    }
+    return htmlStringToVNodes(content, Parser);
+  }
+  return Array.isArray(content) ? content.flat(Infinity) : [content];
+};
+function Reactive(props) {
+  const { store, render, cleanup, tag = "div", onMount, onUnmount, children: _children, ...attributes } = props;
+  const stores = toStores(store, "Reactive");
+  if (typeof render !== "function")
+    throw new TypeError("Reactive: the render prop must be a function");
+  return {
+    type: tag,
+    attributes: {
+      ...attributes,
+      onMount: (el) => {
+        mounted.get(el)?.unsubscribe();
+        mounted.set(el, { unsubscribe: listen(stores, () => morph(el, render())), cleanup });
+        morph(el, render());
+        if (typeof onMount === "function")
+          onMount(el);
+      },
+      onUnmount: (el) => {
+        const entry = mounted.get(el);
+        mounted.delete(el);
+        entry?.unsubscribe();
+        entry?.cleanup?.();
+        if (typeof onUnmount === "function")
+          onUnmount(el);
+      }
+    },
+    children: toChildren2(render())
+  };
+}
+var installReactive = (df$) => {
+  const fn = df$?.fn;
+  if (typeof fn !== "object" || fn === null) {
+    throw new TypeError("installReactive: expected defuss-query's df$ (a df$ with a df$.fn prototype)");
+  }
+  Object.defineProperty(fn, "reactive", {
+    configurable: true,
+    writable: true,
+    value: function(config) {
+      reactive(config, this);
+      return this;
+    }
+  });
+  return df$;
+};
 // src/global.ts
 if (typeof globalThis !== "undefined") {
   const g = globalThis;
@@ -1268,46 +1461,63 @@ if (typeof globalThis !== "undefined") {
     g.df$ = {};
   }
   Object.assign(g.df$, exports_src);
+  const fn = g.df$.fn;
+  if (typeof fn === "object" && fn !== null)
+    installReactive(g.df$);
 }
 export {
-  updateDomWithVdom,
-  resolveGlobals,
-  replaceDomWithVdom,
-  renderMarkup,
-  removeDelegatedEventByKey,
-  removeDelegatedEvent,
-  registerDelegatedEvent,
-  queueCallback,
-  performTransition,
-  parseEventPropName,
-  parseDOM,
-  observeUnmount,
-  nsMap,
-  morph2 as morph,
-  isSVG,
-  isMarkup,
-  isHTML,
-  htmlStringToVNodes,
-  handleLifecycleEventsForOnMount,
-  getTransitionStyles,
-  getRenderer,
-  getRegisteredEventTypes,
-  getRegisteredEventKeys,
-  getMimeType,
-  domNodeToVNode,
-  clearDelegatedEventsDeep,
-  clearDelegatedEvents,
-  areDomNodesEqual,
-  applyStyles,
-  XMLNS_ATTRIBUTE_NAME,
-  XLINK_ATTRIBUTE_NAME,
-  REF_ATTRIBUTE_NAME,
-  FROM_DOM_MARKER,
-  DEFAULT_TRANSITION_CONFIG,
-  DANGEROUSLY_SET_INNER_HTML_ATTRIBUTE,
+  CAPTURE_ONLY_EVENTS,
   CLASS_ATTRIBUTE_NAME,
-  CAPTURE_ONLY_EVENTS
+  COMMENT_TYPE,
+  DANGEROUSLY_SET_INNER_HTML_ATTRIBUTE,
+  DEFAULT_TRANSITION_CONFIG,
+  FROM_DOM_MARKER,
+  Fragment,
+  REF_ATTRIBUTE_NAME,
+  Reactive,
+  XLINK_ATTRIBUTE_NAME,
+  XMLNS_ATTRIBUTE_NAME,
+  applyStyles,
+  areDomNodesEqual,
+  clearDelegatedEvents,
+  clearDelegatedEventsDeep,
+  createRef,
+  domNodeToVNode,
+  getMimeType,
+  getRegisteredEventKeys,
+  getRegisteredEventTypes,
+  getRenderer,
+  getTransitionStyles,
+  h,
+  handleLifecycleEventsForOnMount,
+  htmlStringToVNodes,
+  installReactive,
+  isCommentVNode,
+  isHTML,
+  isMarkup,
+  isRef,
+  isSVG,
+  jsx,
+  jsxDEV,
+  jsxs,
+  morph,
+  nsMap,
+  observeUnmount,
+  onClearDelegatedEvents,
+  parseDOM,
+  parseEventPropName,
+  performTransition,
+  queueCallback,
+  reactive,
+  registerDelegatedEvent,
+  removeDelegatedEvent,
+  removeDelegatedEventByKey,
+  renderMarkup,
+  replaceDomWithVdom,
+  resolveGlobals,
+  templateContent,
+  updateDomWithVdom
 };
 
-//# debugId=BA5C1E84E9A829C164756E2164756E21
+//# debugId=18D1BB0152DB217664756E2164756E21
 //# sourceMappingURL=all.js.map