@solidjs/web 2.0.0-experimental.0

package/dist/web.cjs

@@ -0,0 +1,721 @@
+'use strict';
+
+var solidJs = require('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(["value", "readOnly", "formNoValidate", "isMap", "noModule", "playsInline", ...booleans]);
+const ChildProperties = /*#__PURE__*/new Set(["innerHTML", "textContent", "innerText", "children"]);
+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;
+  solidJs.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, isMathML) {
+  let node;
+  const create = () => {
+    const t = isMathML ? document.createElementNS("http://www.w3.org/1998/Math/MathML", "template") : document.createElement("template");
+    t.innerHTML = html;
+    return isSVG ? t.content.firstChild.firstChild : isMathML ? t.firstChild : t.content.firstChild;
+  };
+  return isImportNode ? () => solidJs.untrack(() => document.importNode(node || (node = create()), true)) : () => (node || (node = create())).cloneNode(true);
+}
+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) {
+  node[name] = value;
+}
+function setAttribute(node, name, value) {
+  if (value == null) node.removeAttribute(name);else node.setAttribute(name, value);
+}
+function setAttributeNS(node, namespace, name, value) {
+  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, isSVG, prev) {
+  if (value == null) {
+    prev && node.removeAttribute("class");
+    return;
+  }
+  if (typeof value === "string") {
+    value !== prev && (isSVG ? node.setAttribute("class", value) : node.className = value);
+    return;
+  }
+  if (typeof prev === "string") {
+    prev = {};
+    node.removeAttribute("class");
+  } else prev = classListToObject(prev || {});
+  value = classListToObject(value);
+  const classKeys = Object.keys(value || {});
+  const 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);
+  }
+  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);
+  }
+}
+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 style(node, value, prev) {
+  if (!value) {
+    prev ? setAttribute(node, "style") : value;
+    return;
+  }
+  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 value) {
+    v = value[s];
+    if (v !== prev[s]) nodeStyle.setProperty(s, v);
+    delete prev[s];
+  }
+  for (s in prev) value[s] == null && nodeStyle.removeProperty(s);
+}
+function spread(node, props = {}, isSVG, skipChildren) {
+  const prevProps = {};
+  if (!skipChildren) {
+    solidJs.createRenderEffect(() => normalize(props.children, prevProps.children), value => {
+      insertExpression(node, value, prevProps.children);
+      prevProps.children = value;
+    });
+  }
+  solidJs.createRenderEffect(() => typeof props.ref === "function" && use(props.ref, node), () => {});
+  solidJs.createRenderEffect(() => {
+    const newProps = {};
+    for (const prop in props) {
+      if (prop === "children" || prop === "ref") continue;
+      newProps[prop] = props[prop];
+    }
+    return newProps;
+  }, props => 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) {
+  solidJs.untrack(() => fn(element, arg));
+}
+function insert(parent, accessor, marker, initial) {
+  const multi = marker !== undefined;
+  if (multi && !initial) initial = [];
+  if (typeof accessor !== "function") {
+    accessor = normalize(accessor, initial, multi, true);
+    if (typeof accessor !== "function") return insertExpression(parent, accessor, initial, marker);
+  }
+  solidJs.createRenderEffect(prev => normalize(accessor, prev, multi), (value, current) => insertExpression(parent, value, 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);
+    }
+  }
+  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);
+  }
+}
+function hydrate$1(code, element, options = {}) {
+  if (globalThis._$HY.done) return render(code, element, [...element.childNodes], options);
+  solidJs.sharedConfig.completed = globalThis._$HY.completed;
+  solidJs.sharedConfig.events = globalThis._$HY.events;
+  solidJs.sharedConfig.load = id => globalThis._$HY.r[id];
+  solidJs.sharedConfig.has = id => id in globalThis._$HY.r;
+  solidJs.sharedConfig.gather = root => gatherHydratable(element, root);
+  solidJs.sharedConfig.registry = new Map();
+  solidJs.sharedConfig.context = {
+    id: options.renderId || "",
+    count: 0
+  };
+  try {
+    gatherHydratable(element, options.renderId);
+    return render(code, element, [...element.childNodes], options);
+  } finally {
+    solidJs.sharedConfig.context = null;
+  }
+}
+function getNextElement(template) {
+  let node,
+    key,
+    hydrating = isHydrating();
+  if (!hydrating || !(node = solidJs.sharedConfig.registry.get(key = getHydrationKey()))) {
+    return template();
+  }
+  if (solidJs.sharedConfig.completed) solidJs.sharedConfig.completed.add(node);
+  solidJs.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 (solidJs.sharedConfig.events && !solidJs.sharedConfig.events.queued) {
+    queueMicrotask(() => {
+      const {
+        completed,
+        events
+      } = solidJs.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 (solidJs.sharedConfig.done) {
+        solidJs.sharedConfig.events = _$HY.events = null;
+        solidJs.sharedConfig.completed = _$HY.completed = null;
+      }
+    });
+    solidJs.sharedConfig.events.queued = true;
+  }
+}
+function isHydrating(node) {
+  return !!solidJs.sharedConfig.context && !solidJs.sharedConfig.done && (!node || node.isConnected);
+}
+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 classListToObject(classList) {
+  if (Array.isArray(classList)) {
+    const result = {};
+    for (let i = 0, len = classList.length; i < len; i++) {
+      const key = classList[i];
+      if (typeof key === "object" && key != null) Object.assign(result, key);else if (key || key === 0) result[key] = true;
+    }
+    return result;
+  }
+  return classList;
+}
+function assignProp(node, prop, value, prev, isSVG, skipRef) {
+  let propAlias, forceProp;
+  if (prop === "style") return style(node, value, prev), value;
+  if (prop === "class") return className(node, value, isSVG, prev), value;
+  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, 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:") || ChildProperties.has(prop) || !isSVG && (propAlias = getPropAlias(prop, node.tagName)) || Properties.has(prop)) {
+    if (forceProp) prop = prop.slice(5);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, prop, value);
+  }
+  return value;
+}
+function eventHandler(e) {
+  if (solidJs.sharedConfig.registry && solidJs.sharedConfig.events) {
+    if (solidJs.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 (solidJs.sharedConfig.registry && !solidJs.sharedConfig.done) solidJs.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) {
+  if (value === current) return;
+  const t = typeof value,
+    multi = marker !== undefined;
+  if (t === "string" || t === "number") {
+    const tc = typeof current;
+    if (tc === "string" || tc === "number") {
+      parent.firstChild.data = value;
+    } else parent.textContent = value;
+  } else if (value === undefined) {
+    cleanChildren(parent, current, marker);
+  } else if (value.nodeType) {
+    if (Array.isArray(current)) {
+      cleanChildren(parent, current, multi ? marker : null, value);
+    } else if (current === undefined || !parent.firstChild) {
+      parent.appendChild(value);
+    } else parent.replaceChild(value, parent.firstChild);
+  } else if (Array.isArray(value)) {
+    const currentArray = current && Array.isArray(current);
+    if (value.length === 0) {
+      cleanChildren(parent, current, marker);
+    } else if (currentArray) {
+      if (current.length === 0) {
+        appendNodes(parent, value, marker);
+      } else reconcileArrays(parent, current, value);
+    } else {
+      current && cleanChildren(parent);
+      appendNodes(parent, value);
+    }
+  } else ;
+}
+function normalize(value, current, multi, doNotUnwrap) {
+  value = solidJs.flatten(value, {
+    skipNonRendered: true,
+    doNotUnwrap
+  });
+  if (doNotUnwrap && typeof value === "function") return value;
+  if (multi && value != null && !Array.isArray(value)) value = [value];
+  if (Array.isArray(value)) {
+    for (let i = 0, len = value.length; i < len; i++) {
+      const item = value[i],
+        prev = current && current[i],
+        t = typeof item;
+      if (t === "string" || t === "number") value[i] = prev && prev.nodeType === 3 && prev.data === item ? prev : document.createTextNode(item);
+    }
+  }
+  return value;
+}
+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 = "";
+  if (current.length) {
+    let inserted = false;
+    for (let i = current.length - 1; i >= 0; i--) {
+      const el = current[i];
+      if (replacement !== el) {
+        const isParent = el.parentNode === parent;
+        if (replacement && !inserted && !i) isParent ? parent.replaceChild(replacement, el) : parent.insertBefore(replacement, marker);else isParent && el.remove();
+      } else inserted = true;
+    }
+  } else if (replacement) parent.insertBefore(replacement, marker);
+}
+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)) && !solidJs.sharedConfig.registry.has(key)) solidJs.sharedConfig.registry.set(key, node);
+  }
+}
+function getHydrationKey() {
+  return solidJs.sharedConfig.getNextContextId();
+}
+function NoHydration(props) {
+  return solidJs.sharedConfig.context ? undefined : props.children;
+}
+function Hydration(props) {
+  return props.children;
+}
+const voidFn = () => undefined;
+const RequestContext = Symbol();
+
+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) {}
+
+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) => {
+  solidJs.enableHydration();
+  return hydrate$1(...args);
+};
+function Portal(props) {
+  const treeMarker = document.createTextNode(""),
+    startMarker = document.createTextNode(""),
+    endMarker = document.createTextNode(""),
+    mount = () => createElementProxy(props.mount || document.body, treeMarker);
+  let content = solidJs.createMemo(() => [startMarker, props.children]);
+  solidJs.createRenderEffect(() => [mount(), content()], ([m, c]) => {
+    m.appendChild(endMarker);
+    insert(m, c, endMarker);
+    return () => {
+      let c = startMarker;
+      while (c && c !== endMarker) {
+        const n = c.nextSibling;
+        m.removeChild(c);
+        c = n;
+      }
+    };
+  });
+  return treeMarker;
+}
+function createElementProxy(el, marker) {
+  return new Proxy(el, {
+    get(target, prop) {
+      if (prop === "appendChild" || prop === "insertBefore") {
+        return (...args) => {
+          Object.defineProperty(args[0], "_$host", {
+            get: () => marker.parentNode,
+            configurable: true
+          });
+          target[prop](...args);
+        };
+      }
+      const value = Reflect.get(target, prop);
+      return typeof value === "function" ? value.bind(target) : value;
+    }
+  });
+}
+function Dynamic(props) {
+  const others = solidJs.omit(props, "component");
+  const cached = solidJs.createMemo(() => props.component);
+  return solidJs.createMemo(() => {
+    const component = cached();
+    switch (typeof component) {
+      case "function":
+        return solidJs.untrack(() => component(others));
+      case "string":
+        const isSvg = SVGElements.has(component);
+        const el = solidJs.sharedConfig.context ? getNextElement() : createElement(component, isSvg);
+        spread(el, others, isSvg);
+        return el;
+    }
+  });
+}
+
+Object.defineProperty(exports, "ErrorBoundary", {
+  enumerable: true,
+  get: function () { return solidJs.ErrorBoundary; }
+});
+Object.defineProperty(exports, "For", {
+  enumerable: true,
+  get: function () { return solidJs.For; }
+});
+Object.defineProperty(exports, "Match", {
+  enumerable: true,
+  get: function () { return solidJs.Match; }
+});
+Object.defineProperty(exports, "Show", {
+  enumerable: true,
+  get: function () { return solidJs.Show; }
+});
+Object.defineProperty(exports, "Suspense", {
+  enumerable: true,
+  get: function () { return solidJs.Suspense; }
+});
+Object.defineProperty(exports, "Switch", {
+  enumerable: true,
+  get: function () { return solidJs.Switch; }
+});
+Object.defineProperty(exports, "createComponent", {
+  enumerable: true,
+  get: function () { return solidJs.createComponent; }
+});
+Object.defineProperty(exports, "effect", {
+  enumerable: true,
+  get: function () { return solidJs.createRenderEffect; }
+});
+Object.defineProperty(exports, "getOwner", {
+  enumerable: true,
+  get: function () { return solidJs.getOwner; }
+});
+Object.defineProperty(exports, "memo", {
+  enumerable: true,
+  get: function () { return solidJs.createMemo; }
+});
+Object.defineProperty(exports, "mergeProps", {
+  enumerable: true,
+  get: function () { return solidJs.merge; }
+});
+Object.defineProperty(exports, "untrack", {
+  enumerable: true,
+  get: function () { return solidJs.untrack; }
+});
+exports.Assets = voidFn;
+exports.ChildProperties = ChildProperties;
+exports.DOMElements = DOMElements;
+exports.DelegatedEvents = DelegatedEvents;
+exports.Dynamic = Dynamic;
+exports.Hydration = Hydration;
+exports.HydrationScript = voidFn;
+exports.NoHydration = NoHydration;
+exports.Portal = Portal;
+exports.Properties = Properties;
+exports.RequestContext = RequestContext;
+exports.SVGElements = SVGElements;
+exports.SVGNamespace = SVGNamespace;
+exports.addEventListener = addEventListener;
+exports.assign = assign;
+exports.className = className;
+exports.clearDelegatedEvents = clearDelegatedEvents;
+exports.delegateEvents = delegateEvents;
+exports.dynamicProperty = dynamicProperty;
+exports.escape = escape;
+exports.generateHydrationScript = voidFn;
+exports.getAssets = voidFn;
+exports.getHydrationKey = getHydrationKey;
+exports.getNextElement = getNextElement;
+exports.getNextMarker = getNextMarker;
+exports.getNextMatch = getNextMatch;
+exports.getPropAlias = getPropAlias;
+exports.getRequestEvent = voidFn;
+exports.hydrate = hydrate;
+exports.insert = insert;
+exports.isDev = isDev;
+exports.isServer = isServer;
+exports.render = render;
+exports.renderToStream = renderToStream;
+exports.renderToString = renderToString;
+exports.renderToStringAsync = renderToStringAsync;
+exports.resolveSSRNode = resolveSSRNode;
+exports.runHydrationEvents = runHydrationEvents;
+exports.setAttribute = setAttribute;
+exports.setAttributeNS = setAttributeNS;
+exports.setBoolAttribute = setBoolAttribute;
+exports.setProperty = setProperty;
+exports.spread = spread;
+exports.ssr = ssr;
+exports.ssrAttribute = ssrAttribute;
+exports.ssrClassList = ssrClassList;
+exports.ssrElement = ssrElement;
+exports.ssrHydrationKey = ssrHydrationKey;
+exports.ssrStyle = ssrStyle;
+exports.style = style;
+exports.template = template;
+exports.use = use;
+exports.useAssets = voidFn;