woby/dist/create_element.ssr-B59OYen7.js

A high-performance framework with fine-grained observable/signal-based reactivity for building rich applications.

import { a as wrapElement } from "./wrap_clone_element-CPcdGL7P.js";
import { n as isObject, i as isFunction, k as isString, o as isSVGElement, p as isNode, q as isVoidChild, u as untrack, v as setProps } from "./setters-Ddu0s6oK.js";
const emptyTags = [
  "area",
  "base",
  "br",
  "col",
  "command",
  "embed",
  "hr",
  "img",
  "input",
  "keygen",
  "link",
  "meta",
  "param",
  "source",
  "track",
  "wbr"
];
let esc = (str) => String(str).replace(/[&<>"']/g, (s) => `&${map[s]};`);
let map = { "&": "amp", "<": "lt", ">": "gt", '"': "quot", "'": "apos" };
let setInnerHTMLAttr = "dangerouslySetInnerHTML";
let DOMAttributeNames = {
  className: "class",
  htmlFor: "for"
};
let sanitized = {};
function h(name, attrs) {
  let stack = [], s = "";
  attrs = attrs || {};
  for (let i = arguments.length; i-- > 2; ) {
    stack.push(arguments[i]);
  }
  if (typeof name === "function") {
    attrs.children = stack.reverse();
    return name(attrs);
  }
  if (name) {
    s += "<" + name;
    if (attrs) for (let i in attrs) {
      if (attrs[i] !== false && attrs[i] != null && i !== setInnerHTMLAttr) {
        s += ` ${DOMAttributeNames[i] ? DOMAttributeNames[i] : esc(i)}="${esc(attrs[i])}"`;
      }
    }
    s += ">";
  }
  if (emptyTags.indexOf(name) === -1) {
    if (attrs[setInnerHTMLAttr]) {
      s += attrs[setInnerHTMLAttr].__html;
    } else while (stack.length) {
      let child = stack.pop();
      if (child) {
        if (child.pop) {
          for (let i = child.length; i--; ) stack.push(child[i]);
        } else {
          s += sanitized[child] === true ? child : esc(child);
        }
      }
    }
    s += name ? `</${name}>` : "";
  }
  sanitized[s] = true;
  return s;
}
const createHTMLNode = h;
const createSVGNode = h;
const createElement = (component, _props, ..._children) => {
  const children = _children.length > 1 ? _children : _children.length > 0 ? _children[0] : void 0;
  const hasChildren = !isVoidChild(children);
  if (hasChildren && isObject(_props) && "children" in _props) {
    throw new Error('Providing "children" both as a prop and as rest arguments is forbidden');
  }
  if (isFunction(component)) {
    const props = hasChildren ? { ..._props, children } : _props;
    return wrapElement(() => {
      return untrack(() => component.call(component, props));
    });
  } else if (isString(component)) {
    const isSVG = isSVGElement(component);
    const createNode = isSVG ? createSVGNode : createHTMLNode;
    const stack = new Error();
    return wrapElement(() => {
      const p = { children: null };
      untrack(() => {
        if (_props) {
          setProps(p, _props, stack);
        }
        if (hasChildren) {
          setProps(p, children2, stack);
        }
      });
      const { children: children2, ...pp } = p;
      return createNode(component, pp, ...[children2].flat(Infinity));
    });
  } else if (isNode(component)) {
    return wrapElement(() => component);
  } else {
    throw new Error("Invalid component");
  }
};
export {
  createElement as c
};
//# sourceMappingURL=create_element.ssr-B59OYen7.js.map