solid-js 1.9.3 → 2.0.0-experimental.0

package/web/dist/web.js

@@ -1,1220 +0,0 @@
-import {
-  createRoot,
-  createRenderEffect,
-  untrack,
-  sharedConfig,
-  enableHydration,
-  getOwner,
-  createEffect,
-  runWithOwner,
-  createMemo,
-  createSignal,
-  onCleanup,
-  splitProps
-} from "solid-js";
-export {
-  ErrorBoundary,
-  For,
-  Index,
-  Match,
-  Show,
-  Suspense,
-  SuspenseList,
-  Switch,
-  createComponent,
-  createRenderEffect as effect,
-  getOwner,
-  createMemo as memo,
-  mergeProps,
-  untrack
-} from "solid-js";
-
-const booleans = [
-  "allowfullscreen",
-  "async",
-  "autofocus",
-  "autoplay",
-  "checked",
-  "controls",
-  "default",
-  "disabled",
-  "formnovalidate",
-  "hidden",
-  "indeterminate",
-  "inert",
-  "ismap",
-  "loop",
-  "multiple",
-  "muted",
-  "nomodule",
-  "novalidate",
-  "open",
-  "playsinline",
-  "readonly",
-  "required",
-  "reversed",
-  "seamless",
-  "selected"
-];
-const Properties = /*#__PURE__*/ new Set([
-  "className",
-  "value",
-  "readOnly",
-  "formNoValidate",
-  "isMap",
-  "noModule",
-  "playsInline",
-  ...booleans
-]);
-const ChildProperties = /*#__PURE__*/ new Set([
-  "innerHTML",
-  "textContent",
-  "innerText",
-  "children"
-]);
-const Aliases = /*#__PURE__*/ Object.assign(Object.create(null), {
-  className: "class",
-  htmlFor: "for"
-});
-const PropAliases = /*#__PURE__*/ Object.assign(Object.create(null), {
-  class: "className",
-  formnovalidate: {
-    $: "formNoValidate",
-    BUTTON: 1,
-    INPUT: 1
-  },
-  ismap: {
-    $: "isMap",
-    IMG: 1
-  },
-  nomodule: {
-    $: "noModule",
-    SCRIPT: 1
-  },
-  playsinline: {
-    $: "playsInline",
-    VIDEO: 1
-  },
-  readonly: {
-    $: "readOnly",
-    INPUT: 1,
-    TEXTAREA: 1
-  }
-});
-function getPropAlias(prop, tagName) {
-  const a = PropAliases[prop];
-  return typeof a === "object" ? (a[tagName] ? a["$"] : undefined) : a;
-}
-const DelegatedEvents = /*#__PURE__*/ new Set([
-  "beforeinput",
-  "click",
-  "dblclick",
-  "contextmenu",
-  "focusin",
-  "focusout",
-  "input",
-  "keydown",
-  "keyup",
-  "mousedown",
-  "mousemove",
-  "mouseout",
-  "mouseover",
-  "mouseup",
-  "pointerdown",
-  "pointermove",
-  "pointerout",
-  "pointerover",
-  "pointerup",
-  "touchend",
-  "touchmove",
-  "touchstart"
-]);
-const SVGElements = /*#__PURE__*/ new Set([
-  "altGlyph",
-  "altGlyphDef",
-  "altGlyphItem",
-  "animate",
-  "animateColor",
-  "animateMotion",
-  "animateTransform",
-  "circle",
-  "clipPath",
-  "color-profile",
-  "cursor",
-  "defs",
-  "desc",
-  "ellipse",
-  "feBlend",
-  "feColorMatrix",
-  "feComponentTransfer",
-  "feComposite",
-  "feConvolveMatrix",
-  "feDiffuseLighting",
-  "feDisplacementMap",
-  "feDistantLight",
-  "feDropShadow",
-  "feFlood",
-  "feFuncA",
-  "feFuncB",
-  "feFuncG",
-  "feFuncR",
-  "feGaussianBlur",
-  "feImage",
-  "feMerge",
-  "feMergeNode",
-  "feMorphology",
-  "feOffset",
-  "fePointLight",
-  "feSpecularLighting",
-  "feSpotLight",
-  "feTile",
-  "feTurbulence",
-  "filter",
-  "font",
-  "font-face",
-  "font-face-format",
-  "font-face-name",
-  "font-face-src",
-  "font-face-uri",
-  "foreignObject",
-  "g",
-  "glyph",
-  "glyphRef",
-  "hkern",
-  "image",
-  "line",
-  "linearGradient",
-  "marker",
-  "mask",
-  "metadata",
-  "missing-glyph",
-  "mpath",
-  "path",
-  "pattern",
-  "polygon",
-  "polyline",
-  "radialGradient",
-  "rect",
-  "set",
-  "stop",
-  "svg",
-  "switch",
-  "symbol",
-  "text",
-  "textPath",
-  "tref",
-  "tspan",
-  "use",
-  "view",
-  "vkern"
-]);
-const SVGNamespace = {
-  xlink: "http://www.w3.org/1999/xlink",
-  xml: "http://www.w3.org/XML/1998/namespace"
-};
-const DOMElements = /*#__PURE__*/ new Set([
-  "html",
-  "base",
-  "head",
-  "link",
-  "meta",
-  "style",
-  "title",
-  "body",
-  "address",
-  "article",
-  "aside",
-  "footer",
-  "header",
-  "main",
-  "nav",
-  "section",
-  "body",
-  "blockquote",
-  "dd",
-  "div",
-  "dl",
-  "dt",
-  "figcaption",
-  "figure",
-  "hr",
-  "li",
-  "ol",
-  "p",
-  "pre",
-  "ul",
-  "a",
-  "abbr",
-  "b",
-  "bdi",
-  "bdo",
-  "br",
-  "cite",
-  "code",
-  "data",
-  "dfn",
-  "em",
-  "i",
-  "kbd",
-  "mark",
-  "q",
-  "rp",
-  "rt",
-  "ruby",
-  "s",
-  "samp",
-  "small",
-  "span",
-  "strong",
-  "sub",
-  "sup",
-  "time",
-  "u",
-  "var",
-  "wbr",
-  "area",
-  "audio",
-  "img",
-  "map",
-  "track",
-  "video",
-  "embed",
-  "iframe",
-  "object",
-  "param",
-  "picture",
-  "portal",
-  "source",
-  "svg",
-  "math",
-  "canvas",
-  "noscript",
-  "script",
-  "del",
-  "ins",
-  "caption",
-  "col",
-  "colgroup",
-  "table",
-  "tbody",
-  "td",
-  "tfoot",
-  "th",
-  "thead",
-  "tr",
-  "button",
-  "datalist",
-  "fieldset",
-  "form",
-  "input",
-  "label",
-  "legend",
-  "meter",
-  "optgroup",
-  "option",
-  "output",
-  "progress",
-  "select",
-  "textarea",
-  "details",
-  "dialog",
-  "menu",
-  "summary",
-  "details",
-  "slot",
-  "template",
-  "acronym",
-  "applet",
-  "basefont",
-  "bgsound",
-  "big",
-  "blink",
-  "center",
-  "content",
-  "dir",
-  "font",
-  "frame",
-  "frameset",
-  "hgroup",
-  "image",
-  "keygen",
-  "marquee",
-  "menuitem",
-  "nobr",
-  "noembed",
-  "noframes",
-  "plaintext",
-  "rb",
-  "rtc",
-  "shadow",
-  "spacer",
-  "strike",
-  "tt",
-  "xmp",
-  "a",
-  "abbr",
-  "acronym",
-  "address",
-  "applet",
-  "area",
-  "article",
-  "aside",
-  "audio",
-  "b",
-  "base",
-  "basefont",
-  "bdi",
-  "bdo",
-  "bgsound",
-  "big",
-  "blink",
-  "blockquote",
-  "body",
-  "br",
-  "button",
-  "canvas",
-  "caption",
-  "center",
-  "cite",
-  "code",
-  "col",
-  "colgroup",
-  "content",
-  "data",
-  "datalist",
-  "dd",
-  "del",
-  "details",
-  "dfn",
-  "dialog",
-  "dir",
-  "div",
-  "dl",
-  "dt",
-  "em",
-  "embed",
-  "fieldset",
-  "figcaption",
-  "figure",
-  "font",
-  "footer",
-  "form",
-  "frame",
-  "frameset",
-  "head",
-  "header",
-  "hgroup",
-  "hr",
-  "html",
-  "i",
-  "iframe",
-  "image",
-  "img",
-  "input",
-  "ins",
-  "kbd",
-  "keygen",
-  "label",
-  "legend",
-  "li",
-  "link",
-  "main",
-  "map",
-  "mark",
-  "marquee",
-  "menu",
-  "menuitem",
-  "meta",
-  "meter",
-  "nav",
-  "nobr",
-  "noembed",
-  "noframes",
-  "noscript",
-  "object",
-  "ol",
-  "optgroup",
-  "option",
-  "output",
-  "p",
-  "param",
-  "picture",
-  "plaintext",
-  "portal",
-  "pre",
-  "progress",
-  "q",
-  "rb",
-  "rp",
-  "rt",
-  "rtc",
-  "ruby",
-  "s",
-  "samp",
-  "script",
-  "section",
-  "select",
-  "shadow",
-  "slot",
-  "small",
-  "source",
-  "spacer",
-  "span",
-  "strike",
-  "strong",
-  "style",
-  "sub",
-  "summary",
-  "sup",
-  "table",
-  "tbody",
-  "td",
-  "template",
-  "textarea",
-  "tfoot",
-  "th",
-  "thead",
-  "time",
-  "title",
-  "tr",
-  "track",
-  "tt",
-  "u",
-  "ul",
-  "var",
-  "video",
-  "wbr",
-  "xmp",
-  "input",
-  "h1",
-  "h2",
-  "h3",
-  "h4",
-  "h5",
-  "h6"
-]);
-
-function reconcileArrays(parentNode, a, b) {
-  let bLength = b.length,
-    aEnd = a.length,
-    bEnd = bLength,
-    aStart = 0,
-    bStart = 0,
-    after = a[aEnd - 1].nextSibling,
-    map = null;
-  while (aStart < aEnd || bStart < bEnd) {
-    if (a[aStart] === b[bStart]) {
-      aStart++;
-      bStart++;
-      continue;
-    }
-    while (a[aEnd - 1] === b[bEnd - 1]) {
-      aEnd--;
-      bEnd--;
-    }
-    if (aEnd === aStart) {
-      const node = bEnd < bLength ? (bStart ? b[bStart - 1].nextSibling : b[bEnd - bStart]) : after;
-      while (bStart < bEnd) parentNode.insertBefore(b[bStart++], node);
-    } else if (bEnd === bStart) {
-      while (aStart < aEnd) {
-        if (!map || !map.has(a[aStart])) a[aStart].remove();
-        aStart++;
-      }
-    } else if (a[aStart] === b[bEnd - 1] && b[bStart] === a[aEnd - 1]) {
-      const node = a[--aEnd].nextSibling;
-      parentNode.insertBefore(b[bStart++], a[aStart++].nextSibling);
-      parentNode.insertBefore(b[--bEnd], node);
-      a[aEnd] = b[bEnd];
-    } else {
-      if (!map) {
-        map = new Map();
-        let i = bStart;
-        while (i < bEnd) map.set(b[i], i++);
-      }
-      const index = map.get(a[aStart]);
-      if (index != null) {
-        if (bStart < index && index < bEnd) {
-          let i = aStart,
-            sequence = 1,
-            t;
-          while (++i < aEnd && i < bEnd) {
-            if ((t = map.get(a[i])) == null || t !== index + sequence) break;
-            sequence++;
-          }
-          if (sequence > index - bStart) {
-            const node = a[aStart];
-            while (bStart < index) parentNode.insertBefore(b[bStart++], node);
-          } else parentNode.replaceChild(b[bStart++], a[aStart++]);
-        } else aStart++;
-      } else a[aStart++].remove();
-    }
-  }
-}
-
-const $$EVENTS = "_$DX_DELEGATE";
-function render(code, element, init, options = {}) {
-  let disposer;
-  createRoot(dispose => {
-    disposer = dispose;
-    element === document
-      ? code()
-      : insert(element, code(), element.firstChild ? null : undefined, init);
-  }, options.owner);
-  return () => {
-    disposer();
-    element.textContent = "";
-  };
-}
-function template(html, isImportNode, isSVG) {
-  let node;
-  const create = () => {
-    const t = document.createElement("template");
-    t.innerHTML = html;
-    return isSVG ? t.content.firstChild.firstChild : t.content.firstChild;
-  };
-  const fn = isImportNode
-    ? () => untrack(() => document.importNode(node || (node = create()), true))
-    : () => (node || (node = create())).cloneNode(true);
-  fn.cloneNode = fn;
-  return fn;
-}
-function delegateEvents(eventNames, document = window.document) {
-  const e = document[$$EVENTS] || (document[$$EVENTS] = new Set());
-  for (let i = 0, l = eventNames.length; i < l; i++) {
-    const name = eventNames[i];
-    if (!e.has(name)) {
-      e.add(name);
-      document.addEventListener(name, eventHandler);
-    }
-  }
-}
-function clearDelegatedEvents(document = window.document) {
-  if (document[$$EVENTS]) {
-    for (let name of document[$$EVENTS].keys()) document.removeEventListener(name, eventHandler);
-    delete document[$$EVENTS];
-  }
-}
-function setProperty(node, name, value) {
-  if (isHydrating(node)) return;
-  node[name] = value;
-}
-function setAttribute(node, name, value) {
-  if (isHydrating(node)) return;
-  if (value == null) node.removeAttribute(name);
-  else node.setAttribute(name, value);
-}
-function setAttributeNS(node, namespace, name, value) {
-  if (isHydrating(node)) return;
-  if (value == null) node.removeAttributeNS(namespace, name);
-  else node.setAttributeNS(namespace, name, value);
-}
-function setBoolAttribute(node, name, value) {
-  if (isHydrating(node)) return;
-  value ? node.setAttribute(name, "") : node.removeAttribute(name);
-}
-function className(node, value) {
-  if (isHydrating(node)) return;
-  if (value == null) node.removeAttribute("class");
-  else node.className = value;
-}
-function addEventListener(node, name, handler, delegate) {
-  if (delegate) {
-    if (Array.isArray(handler)) {
-      node[`$$${name}`] = handler[0];
-      node[`$$${name}Data`] = handler[1];
-    } else node[`$$${name}`] = handler;
-  } else if (Array.isArray(handler)) {
-    const handlerFn = handler[0];
-    node.addEventListener(name, (handler[0] = e => handlerFn.call(node, handler[1], e)));
-  } else node.addEventListener(name, handler, typeof handler !== "function" && handler);
-}
-function classList(node, value, prev = {}) {
-  const classKeys = Object.keys(value || {}),
-    prevKeys = Object.keys(prev);
-  let i, len;
-  for (i = 0, len = prevKeys.length; i < len; i++) {
-    const key = prevKeys[i];
-    if (!key || key === "undefined" || value[key]) continue;
-    toggleClassKey(node, key, false);
-    delete prev[key];
-  }
-  for (i = 0, len = classKeys.length; i < len; i++) {
-    const key = classKeys[i],
-      classValue = !!value[key];
-    if (!key || key === "undefined" || prev[key] === classValue || !classValue) continue;
-    toggleClassKey(node, key, true);
-    prev[key] = classValue;
-  }
-  return prev;
-}
-function style(node, value, prev) {
-  if (!value) return prev ? setAttribute(node, "style") : value;
-  const nodeStyle = node.style;
-  if (typeof value === "string") return (nodeStyle.cssText = value);
-  typeof prev === "string" && (nodeStyle.cssText = prev = undefined);
-  prev || (prev = {});
-  value || (value = {});
-  let v, s;
-  for (s in prev) {
-    value[s] == null && nodeStyle.removeProperty(s);
-    delete prev[s];
-  }
-  for (s in value) {
-    v = value[s];
-    if (v !== prev[s]) {
-      nodeStyle.setProperty(s, v);
-      prev[s] = v;
-    }
-  }
-  return prev;
-}
-function spread(node, props = {}, isSVG, skipChildren) {
-  const prevProps = {};
-  if (!skipChildren) {
-    createRenderEffect(
-      () => (prevProps.children = insertExpression(node, props.children, prevProps.children))
-    );
-  }
-  createRenderEffect(() => typeof props.ref === "function" && use(props.ref, node));
-  createRenderEffect(() => assign(node, props, isSVG, true, prevProps, true));
-  return prevProps;
-}
-function dynamicProperty(props, key) {
-  const src = props[key];
-  Object.defineProperty(props, key, {
-    get() {
-      return src();
-    },
-    enumerable: true
-  });
-  return props;
-}
-function use(fn, element, arg) {
-  return untrack(() => fn(element, arg));
-}
-function insert(parent, accessor, marker, initial) {
-  if (marker !== undefined && !initial) initial = [];
-  if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
-  createRenderEffect(current => insertExpression(parent, accessor(), current, marker), initial);
-}
-function assign(node, props, isSVG, skipChildren, prevProps = {}, skipRef = false) {
-  props || (props = {});
-  for (const prop in prevProps) {
-    if (!(prop in props)) {
-      if (prop === "children") continue;
-      prevProps[prop] = assignProp(node, prop, null, prevProps[prop], isSVG, skipRef, props);
-    }
-  }
-  for (const prop in props) {
-    if (prop === "children") {
-      if (!skipChildren) insertExpression(node, props.children);
-      continue;
-    }
-    const value = props[prop];
-    prevProps[prop] = assignProp(node, prop, value, prevProps[prop], isSVG, skipRef, props);
-  }
-}
-function hydrate$1(code, element, options = {}) {
-  if (globalThis._$HY.done) return render(code, element, [...element.childNodes], options);
-  sharedConfig.completed = globalThis._$HY.completed;
-  sharedConfig.events = globalThis._$HY.events;
-  sharedConfig.load = id => globalThis._$HY.r[id];
-  sharedConfig.has = id => id in globalThis._$HY.r;
-  sharedConfig.gather = root => gatherHydratable(element, root);
-  sharedConfig.registry = new Map();
-  sharedConfig.context = {
-    id: options.renderId || "",
-    count: 0
-  };
-  try {
-    gatherHydratable(element, options.renderId);
-    return render(code, element, [...element.childNodes], options);
-  } finally {
-    sharedConfig.context = null;
-  }
-}
-function getNextElement(template) {
-  let node,
-    key,
-    hydrating = isHydrating();
-  if (!hydrating || !(node = sharedConfig.registry.get((key = getHydrationKey())))) {
-    return template();
-  }
-  if (sharedConfig.completed) sharedConfig.completed.add(node);
-  sharedConfig.registry.delete(key);
-  return node;
-}
-function getNextMatch(el, nodeName) {
-  while (el && el.localName !== nodeName) el = el.nextSibling;
-  return el;
-}
-function getNextMarker(start) {
-  let end = start,
-    count = 0,
-    current = [];
-  if (isHydrating(start)) {
-    while (end) {
-      if (end.nodeType === 8) {
-        const v = end.nodeValue;
-        if (v === "$") count++;
-        else if (v === "/") {
-          if (count === 0) return [end, current];
-          count--;
-        }
-      }
-      current.push(end);
-      end = end.nextSibling;
-    }
-  }
-  return [end, current];
-}
-function runHydrationEvents() {
-  if (sharedConfig.events && !sharedConfig.events.queued) {
-    queueMicrotask(() => {
-      const { completed, events } = sharedConfig;
-      if (!events) return;
-      events.queued = false;
-      while (events.length) {
-        const [el, e] = events[0];
-        if (!completed.has(el)) return;
-        events.shift();
-        eventHandler(e);
-      }
-      if (sharedConfig.done) {
-        sharedConfig.events = _$HY.events = null;
-        sharedConfig.completed = _$HY.completed = null;
-      }
-    });
-    sharedConfig.events.queued = true;
-  }
-}
-function isHydrating(node) {
-  return !!sharedConfig.context && !sharedConfig.done && (!node || node.isConnected);
-}
-function toPropertyName(name) {
-  return name.toLowerCase().replace(/-([a-z])/g, (_, w) => w.toUpperCase());
-}
-function toggleClassKey(node, key, value) {
-  const classNames = key.trim().split(/\s+/);
-  for (let i = 0, nameLen = classNames.length; i < nameLen; i++)
-    node.classList.toggle(classNames[i], value);
-}
-function assignProp(node, prop, value, prev, isSVG, skipRef, props) {
-  let isCE, isProp, isChildProp, propAlias, forceProp;
-  if (prop === "style") return style(node, value, prev);
-  if (prop === "classList") return classList(node, value, prev);
-  if (value === prev) return prev;
-  if (prop === "ref") {
-    if (!skipRef) value(node);
-  } else if (prop.slice(0, 3) === "on:") {
-    const e = prop.slice(3);
-    prev && node.removeEventListener(e, prev, typeof prev !== "function" && prev);
-    value && node.addEventListener(e, value, typeof value !== "function" && value);
-  } else if (prop.slice(0, 10) === "oncapture:") {
-    const e = prop.slice(10);
-    prev && node.removeEventListener(e, prev, true);
-    value && node.addEventListener(e, value, true);
-  } else if (prop.slice(0, 2) === "on") {
-    const name = prop.slice(2).toLowerCase();
-    const delegate = DelegatedEvents.has(name);
-    if (!delegate && prev) {
-      const h = Array.isArray(prev) ? prev[0] : prev;
-      node.removeEventListener(name, h);
-    }
-    if (delegate || value) {
-      addEventListener(node, name, value, delegate);
-      delegate && delegateEvents([name]);
-    }
-  } else if (prop.slice(0, 5) === "attr:") {
-    setAttribute(node, prop.slice(5), value);
-  } else if (prop.slice(0, 5) === "bool:") {
-    setBoolAttribute(node, prop.slice(5), value);
-  } else if (
-    (forceProp = prop.slice(0, 5) === "prop:") ||
-    (isChildProp = ChildProperties.has(prop)) ||
-    (!isSVG &&
-      ((propAlias = getPropAlias(prop, node.tagName)) || (isProp = Properties.has(prop)))) ||
-    (isCE = node.nodeName.includes("-") || "is" in props)
-  ) {
-    if (forceProp) {
-      prop = prop.slice(5);
-      isProp = true;
-    } else if (isHydrating(node)) return value;
-    if (prop === "class" || prop === "className") className(node, value);
-    else if (isCE && !isProp && !isChildProp) node[toPropertyName(prop)] = value;
-    else node[propAlias || prop] = value;
-  } else {
-    const ns = isSVG && prop.indexOf(":") > -1 && SVGNamespace[prop.split(":")[0]];
-    if (ns) setAttributeNS(node, ns, prop, value);
-    else setAttribute(node, Aliases[prop] || prop, value);
-  }
-  return value;
-}
-function eventHandler(e) {
-  if (sharedConfig.registry && sharedConfig.events) {
-    if (sharedConfig.events.find(([el, ev]) => ev === e)) return;
-  }
-  let node = e.target;
-  const key = `$$${e.type}`;
-  const oriTarget = e.target;
-  const oriCurrentTarget = e.currentTarget;
-  const retarget = value =>
-    Object.defineProperty(e, "target", {
-      configurable: true,
-      value
-    });
-  const handleNode = () => {
-    const handler = node[key];
-    if (handler && !node.disabled) {
-      const data = node[`${key}Data`];
-      data !== undefined ? handler.call(node, data, e) : handler.call(node, e);
-      if (e.cancelBubble) return;
-    }
-    node.host &&
-      typeof node.host !== "string" &&
-      !node.host._$host &&
-      node.contains(e.target) &&
-      retarget(node.host);
-    return true;
-  };
-  const walkUpTree = () => {
-    while (handleNode() && (node = node._$host || node.parentNode || node.host));
-  };
-  Object.defineProperty(e, "currentTarget", {
-    configurable: true,
-    get() {
-      return node || document;
-    }
-  });
-  if (sharedConfig.registry && !sharedConfig.done) sharedConfig.done = _$HY.done = true;
-  if (e.composedPath) {
-    const path = e.composedPath();
-    retarget(path[0]);
-    for (let i = 0; i < path.length - 2; i++) {
-      node = path[i];
-      if (!handleNode()) break;
-      if (node._$host) {
-        node = node._$host;
-        walkUpTree();
-        break;
-      }
-      if (node.parentNode === oriCurrentTarget) {
-        break;
-      }
-    }
-  } else walkUpTree();
-  retarget(oriTarget);
-}
-function insertExpression(parent, value, current, marker, unwrapArray) {
-  const hydrating = isHydrating(parent);
-  if (hydrating) {
-    !current && (current = [...parent.childNodes]);
-    let cleaned = [];
-    for (let i = 0; i < current.length; i++) {
-      const node = current[i];
-      if (node.nodeType === 8 && node.data.slice(0, 2) === "!$") node.remove();
-      else cleaned.push(node);
-    }
-    current = cleaned;
-  }
-  while (typeof current === "function") current = current();
-  if (value === current) return current;
-  const t = typeof value,
-    multi = marker !== undefined;
-  parent = (multi && current[0] && current[0].parentNode) || parent;
-  if (t === "string" || t === "number") {
-    if (hydrating) return current;
-    if (t === "number") {
-      value = value.toString();
-      if (value === current) return current;
-    }
-    if (multi) {
-      let node = current[0];
-      if (node && node.nodeType === 3) {
-        node.data !== value && (node.data = value);
-      } else node = document.createTextNode(value);
-      current = cleanChildren(parent, current, marker, node);
-    } else {
-      if (current !== "" && typeof current === "string") {
-        current = parent.firstChild.data = value;
-      } else current = parent.textContent = value;
-    }
-  } else if (value == null || t === "boolean") {
-    if (hydrating) return current;
-    current = cleanChildren(parent, current, marker);
-  } else if (t === "function") {
-    createRenderEffect(() => {
-      let v = value();
-      while (typeof v === "function") v = v();
-      current = insertExpression(parent, v, current, marker);
-    });
-    return () => current;
-  } else if (Array.isArray(value)) {
-    const array = [];
-    const currentArray = current && Array.isArray(current);
-    if (normalizeIncomingArray(array, value, current, unwrapArray)) {
-      createRenderEffect(() => (current = insertExpression(parent, array, current, marker, true)));
-      return () => current;
-    }
-    if (hydrating) {
-      if (!array.length) return current;
-      if (marker === undefined) return (current = [...parent.childNodes]);
-      let node = array[0];
-      if (node.parentNode !== parent) return current;
-      const nodes = [node];
-      while ((node = node.nextSibling) !== marker) nodes.push(node);
-      return (current = nodes);
-    }
-    if (array.length === 0) {
-      current = cleanChildren(parent, current, marker);
-      if (multi) return current;
-    } else if (currentArray) {
-      if (current.length === 0) {
-        appendNodes(parent, array, marker);
-      } else reconcileArrays(parent, current, array);
-    } else {
-      current && cleanChildren(parent);
-      appendNodes(parent, array);
-    }
-    current = array;
-  } else if (value.nodeType) {
-    if (hydrating && value.parentNode) return (current = multi ? [value] : value);
-    if (Array.isArray(current)) {
-      if (multi) return (current = cleanChildren(parent, current, marker, value));
-      cleanChildren(parent, current, null, value);
-    } else if (current == null || current === "" || !parent.firstChild) {
-      parent.appendChild(value);
-    } else parent.replaceChild(value, parent.firstChild);
-    current = value;
-  } else;
-  return current;
-}
-function normalizeIncomingArray(normalized, array, current, unwrap) {
-  let dynamic = false;
-  for (let i = 0, len = array.length; i < len; i++) {
-    let item = array[i],
-      prev = current && current[normalized.length],
-      t;
-    if (item == null || item === true || item === false);
-    else if ((t = typeof item) === "object" && item.nodeType) {
-      normalized.push(item);
-    } else if (Array.isArray(item)) {
-      dynamic = normalizeIncomingArray(normalized, item, prev) || dynamic;
-    } else if (t === "function") {
-      if (unwrap) {
-        while (typeof item === "function") item = item();
-        dynamic =
-          normalizeIncomingArray(
-            normalized,
-            Array.isArray(item) ? item : [item],
-            Array.isArray(prev) ? prev : [prev]
-          ) || dynamic;
-      } else {
-        normalized.push(item);
-        dynamic = true;
-      }
-    } else {
-      const value = String(item);
-      if (prev && prev.nodeType === 3 && prev.data === value) normalized.push(prev);
-      else normalized.push(document.createTextNode(value));
-    }
-  }
-  return dynamic;
-}
-function appendNodes(parent, array, marker = null) {
-  for (let i = 0, len = array.length; i < len; i++) parent.insertBefore(array[i], marker);
-}
-function cleanChildren(parent, current, marker, replacement) {
-  if (marker === undefined) return (parent.textContent = "");
-  const node = replacement || document.createTextNode("");
-  if (current.length) {
-    let inserted = false;
-    for (let i = current.length - 1; i >= 0; i--) {
-      const el = current[i];
-      if (node !== el) {
-        const isParent = el.parentNode === parent;
-        if (!inserted && !i)
-          isParent ? parent.replaceChild(node, el) : parent.insertBefore(node, marker);
-        else isParent && el.remove();
-      } else inserted = true;
-    }
-  } else parent.insertBefore(node, marker);
-  return [node];
-}
-function gatherHydratable(element, root) {
-  const templates = element.querySelectorAll(`*[data-hk]`);
-  for (let i = 0; i < templates.length; i++) {
-    const node = templates[i];
-    const key = node.getAttribute("data-hk");
-    if ((!root || key.startsWith(root)) && !sharedConfig.registry.has(key))
-      sharedConfig.registry.set(key, node);
-  }
-}
-function getHydrationKey() {
-  return sharedConfig.getNextContextId();
-}
-function NoHydration(props) {
-  return sharedConfig.context ? undefined : props.children;
-}
-function Hydration(props) {
-  return props.children;
-}
-const voidFn = () => undefined;
-const RequestContext = Symbol();
-function innerHTML(parent, content) {
-  !sharedConfig.context && (parent.innerHTML = content);
-}
-
-function throwInBrowser(func) {
-  const err = new Error(`${func.name} is not supported in the browser, returning undefined`);
-  console.error(err);
-}
-function renderToString(fn, options) {
-  throwInBrowser(renderToString);
-}
-function renderToStringAsync(fn, options) {
-  throwInBrowser(renderToStringAsync);
-}
-function renderToStream(fn, options) {
-  throwInBrowser(renderToStream);
-}
-function ssr(template, ...nodes) {}
-function ssrElement(name, props, children, needsId) {}
-function ssrClassList(value) {}
-function ssrStyle(value) {}
-function ssrAttribute(key, value) {}
-function ssrHydrationKey() {}
-function resolveSSRNode(node) {}
-function escape(html) {}
-function ssrSpread(props, isSVG, skipChildren) {}
-
-const isServer = false;
-const isDev = false;
-const SVG_NAMESPACE = "http://www.w3.org/2000/svg";
-function createElement(tagName, isSVG = false) {
-  return isSVG ? document.createElementNS(SVG_NAMESPACE, tagName) : document.createElement(tagName);
-}
-const hydrate = (...args) => {
-  enableHydration();
-  return hydrate$1(...args);
-};
-function Portal(props) {
-  const { useShadow } = props,
-    marker = document.createTextNode(""),
-    mount = () => props.mount || document.body,
-    owner = getOwner();
-  let content;
-  let hydrating = !!sharedConfig.context;
-  createEffect(
-    () => {
-      if (hydrating) getOwner().user = hydrating = false;
-      content || (content = runWithOwner(owner, () => createMemo(() => props.children)));
-      const el = mount();
-      if (el instanceof HTMLHeadElement) {
-        const [clean, setClean] = createSignal(false);
-        const cleanup = () => setClean(true);
-        createRoot(dispose => insert(el, () => (!clean() ? content() : dispose()), null));
-        onCleanup(cleanup);
-      } else {
-        const container = createElement(props.isSVG ? "g" : "div", props.isSVG),
-          renderRoot =
-            useShadow && container.attachShadow
-              ? container.attachShadow({
-                  mode: "open"
-                })
-              : container;
-        Object.defineProperty(container, "_$host", {
-          get() {
-            return marker.parentNode;
-          },
-          configurable: true
-        });
-        insert(renderRoot, content);
-        el.appendChild(container);
-        props.ref && props.ref(container);
-        onCleanup(() => el.removeChild(container));
-      }
-    },
-    undefined,
-    {
-      render: !hydrating
-    }
-  );
-  return marker;
-}
-function Dynamic(props) {
-  const [p, others] = splitProps(props, ["component"]);
-  const cached = createMemo(() => p.component);
-  return createMemo(() => {
-    const component = cached();
-    switch (typeof component) {
-      case "function":
-        return untrack(() => component(others));
-      case "string":
-        const isSvg = SVGElements.has(component);
-        const el = sharedConfig.context ? getNextElement() : createElement(component, isSvg);
-        spread(el, others, isSvg);
-        return el;
-    }
-  });
-}
-
-export {
-  Aliases,
-  voidFn as Assets,
-  ChildProperties,
-  DOMElements,
-  DelegatedEvents,
-  Dynamic,
-  Hydration,
-  voidFn as HydrationScript,
-  NoHydration,
-  Portal,
-  Properties,
-  RequestContext,
-  SVGElements,
-  SVGNamespace,
-  addEventListener,
-  assign,
-  classList,
-  className,
-  clearDelegatedEvents,
-  delegateEvents,
-  dynamicProperty,
-  escape,
-  voidFn as generateHydrationScript,
-  voidFn as getAssets,
-  getHydrationKey,
-  getNextElement,
-  getNextMarker,
-  getNextMatch,
-  getPropAlias,
-  voidFn as getRequestEvent,
-  hydrate,
-  innerHTML,
-  insert,
-  isDev,
-  isServer,
-  render,
-  renderToStream,
-  renderToString,
-  renderToStringAsync,
-  resolveSSRNode,
-  runHydrationEvents,
-  setAttribute,
-  setAttributeNS,
-  setBoolAttribute,
-  setProperty,
-  spread,
-  ssr,
-  ssrAttribute,
-  ssrClassList,
-  ssrElement,
-  ssrHydrationKey,
-  ssrSpread,
-  ssrStyle,
-  style,
-  template,
-  use,
-  voidFn as useAssets
-};