@blinkk/root 3.1.4 → 3.1.5

package/dist/chunk-AJR6VAT7.js

@@ -0,0 +1,694 @@
+import {
+  Fragment
+} from "./chunk-3Z5TNZEP.js";
+
+// src/jsx/jsx-render.ts
+import { options as preactOptions } from "preact";
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "area",
+  "base",
+  "br",
+  "col",
+  "embed",
+  "hr",
+  "img",
+  "input",
+  "link",
+  "meta",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var RAW_CONTENT_ELEMENTS = /* @__PURE__ */ new Set(["pre", "textarea", "script", "style"]);
+var DEFAULT_BLOCK_ELEMENTS = /* @__PURE__ */ new Set([
+  "address",
+  "article",
+  "aside",
+  "base",
+  "blockquote",
+  "body",
+  "dd",
+  "details",
+  "dialog",
+  "div",
+  "dl",
+  "dt",
+  "fieldset",
+  "figcaption",
+  "figure",
+  "footer",
+  "form",
+  "h1",
+  "h2",
+  "h3",
+  "h4",
+  "h5",
+  "h6",
+  "head",
+  "header",
+  "hgroup",
+  "hr",
+  "html",
+  "li",
+  "link",
+  "main",
+  "meta",
+  "nav",
+  "noscript",
+  "ol",
+  "optgroup",
+  "option",
+  "p",
+  "pre",
+  "script",
+  "search",
+  "section",
+  "select",
+  "style",
+  "summary",
+  "table",
+  "tbody",
+  "td",
+  "tfoot",
+  "th",
+  "thead",
+  "title",
+  "tr",
+  "ul"
+]);
+var ALWAYS_BLOCK_ELEMENTS = /* @__PURE__ */ new Set([
+  "base",
+  "link",
+  "meta",
+  "script",
+  "style",
+  "title"
+]);
+var TAG_FLAG_VOID = 1;
+var TAG_FLAG_ALWAYS_BLOCK = 2;
+var TAG_FLAG_RAW = 4;
+var TAG_FLAG_BLOCK = 8;
+var TAG_STATIC_FLAGS = /* @__PURE__ */ new Map();
+for (const t of VOID_ELEMENTS) {
+  TAG_STATIC_FLAGS.set(t, (TAG_STATIC_FLAGS.get(t) || 0) | TAG_FLAG_VOID);
+}
+for (const t of ALWAYS_BLOCK_ELEMENTS) {
+  TAG_STATIC_FLAGS.set(
+    t,
+    (TAG_STATIC_FLAGS.get(t) || 0) | TAG_FLAG_ALWAYS_BLOCK
+  );
+}
+for (const t of RAW_CONTENT_ELEMENTS) {
+  TAG_STATIC_FLAGS.set(t, (TAG_STATIC_FLAGS.get(t) || 0) | TAG_FLAG_RAW);
+}
+for (const t of DEFAULT_BLOCK_ELEMENTS) {
+  TAG_STATIC_FLAGS.set(t, (TAG_STATIC_FLAGS.get(t) || 0) | TAG_FLAG_BLOCK);
+}
+var BOOLEAN_ATTRS = /* @__PURE__ */ new Set([
+  "allowfullscreen",
+  "async",
+  "autofocus",
+  "autoplay",
+  "capture",
+  "checked",
+  "controls",
+  "default",
+  "defer",
+  "disabled",
+  "disableremoteplayback",
+  "download",
+  "draggable",
+  "formnovalidate",
+  "hidden",
+  "inert",
+  "ismap",
+  "itemscope",
+  "loop",
+  "multiple",
+  "muted",
+  "nomodule",
+  "novalidate",
+  "open",
+  "playsinline",
+  "popover",
+  "readonly",
+  "required",
+  "reversed",
+  "selected"
+]);
+var PROP_TO_ATTR = Object.assign(
+  /* @__PURE__ */ Object.create(null),
+  {
+    acceptCharset: "accept-charset",
+    autoCapitalize: "autocapitalize",
+    autoComplete: "autocomplete",
+    autoFocus: "autofocus",
+    autoPlay: "autoplay",
+    charSet: "charset",
+    className: "class",
+    colSpan: "colspan",
+    contentEditable: "contenteditable",
+    crossOrigin: "crossorigin",
+    dateTime: "datetime",
+    disableRemotePlayback: "disableremoteplayback",
+    encType: "enctype",
+    formAction: "formaction",
+    formEncType: "formenctype",
+    formMethod: "formmethod",
+    formNoValidate: "formnovalidate",
+    formTarget: "formtarget",
+    frameBorder: "frameborder",
+    hrefLang: "hreflang",
+    htmlFor: "for",
+    httpEquiv: "http-equiv",
+    inputMode: "inputmode",
+    itemProp: "itemprop",
+    itemRef: "itemref",
+    itemScope: "itemscope",
+    itemType: "itemtype",
+    maxLength: "maxlength",
+    mediaGroup: "mediagroup",
+    minLength: "minlength",
+    noModule: "nomodule",
+    noValidate: "novalidate",
+    playsInline: "playsinline",
+    readOnly: "readonly",
+    referrerPolicy: "referrerpolicy",
+    rowSpan: "rowspan",
+    spellCheck: "spellcheck",
+    srcDoc: "srcdoc",
+    srcLang: "srclang",
+    srcSet: "srcset",
+    tabIndex: "tabindex",
+    useMap: "usemap",
+    // SVG presentation attributes (camelCase -> kebab-case).
+    clipPath: "clip-path",
+    clipRule: "clip-rule",
+    colorInterpolation: "color-interpolation",
+    colorInterpolationFilters: "color-interpolation-filters",
+    dominantBaseline: "dominant-baseline",
+    fillOpacity: "fill-opacity",
+    fillRule: "fill-rule",
+    floodColor: "flood-color",
+    floodOpacity: "flood-opacity",
+    imageRendering: "image-rendering",
+    letterSpacing: "letter-spacing",
+    lightingColor: "lighting-color",
+    markerEnd: "marker-end",
+    markerMid: "marker-mid",
+    markerStart: "marker-start",
+    paintOrder: "paint-order",
+    pointerEvents: "pointer-events",
+    shapeRendering: "shape-rendering",
+    stopColor: "stop-color",
+    stopOpacity: "stop-opacity",
+    strokeDasharray: "stroke-dasharray",
+    strokeDashoffset: "stroke-dashoffset",
+    strokeLinecap: "stroke-linecap",
+    strokeLinejoin: "stroke-linejoin",
+    strokeMiterlimit: "stroke-miterlimit",
+    strokeOpacity: "stroke-opacity",
+    strokeWidth: "stroke-width",
+    textAnchor: "text-anchor",
+    textDecoration: "text-decoration",
+    textRendering: "text-rendering",
+    transformOrigin: "transform-origin",
+    vectorEffect: "vector-effect",
+    wordSpacing: "word-spacing",
+    writingMode: "writing-mode"
+  }
+);
+var AMP = "&";
+var LT = "<";
+var GT = ">";
+var QUOT = """;
+var HTML_ESCAPE_RE = /[&<>]/;
+var ATTR_ESCAPE_RE = /[&<>"]/;
+var EMPTY_GLOBAL_CTX = {};
+function isDef(value) {
+  return value !== null && value !== void 0;
+}
+function escapeHtml(str) {
+  if (!HTML_ESCAPE_RE.test(str)) return str;
+  let result = "";
+  let last = 0;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    let escaped;
+    if (ch === 38) escaped = AMP;
+    else if (ch === 60) escaped = LT;
+    else if (ch === 62) escaped = GT;
+    if (escaped) {
+      result += str.slice(last, i) + escaped;
+      last = i + 1;
+    }
+  }
+  return result + str.slice(last);
+}
+function escapeAttr(str) {
+  if (!ATTR_ESCAPE_RE.test(str)) return str;
+  let result = "";
+  let last = 0;
+  for (let i = 0; i < str.length; i++) {
+    const ch = str.charCodeAt(i);
+    let escaped;
+    if (ch === 38) escaped = AMP;
+    else if (ch === 34) escaped = QUOT;
+    else if (ch === 60) escaped = LT;
+    else if (ch === 62) escaped = GT;
+    if (escaped) {
+      result += str.slice(last, i) + escaped;
+      last = i + 1;
+    }
+  }
+  return result + str.slice(last);
+}
+var STYLE_KEY_CACHE = /* @__PURE__ */ new Map();
+var UPPERCASE_RE = /[A-Z]/g;
+function toKebabCase(key) {
+  let cached = STYLE_KEY_CACHE.get(key);
+  if (cached === void 0) {
+    cached = key.replace(UPPERCASE_RE, (m) => "-" + m.toLowerCase());
+    STYLE_KEY_CACHE.set(key, cached);
+  }
+  return cached;
+}
+function styleToString(style) {
+  let result = "";
+  let first = true;
+  for (const key in style) {
+    const value = style[key];
+    if (!isDef(value) || value === "") continue;
+    if (first) {
+      first = false;
+    } else {
+      result += ";";
+    }
+    result += `${toKebabCase(key)}:${value}`;
+  }
+  return result;
+}
+function renderJsxToString(vnode, options) {
+  const mode = options?.mode ?? "pretty";
+  const isPretty = mode === "pretty";
+  let customBlockSet;
+  if (isPretty && options?.blockElements && options.blockElements.length > 0) {
+    customBlockSet = /* @__PURE__ */ new Set();
+    for (const el of options.blockElements) {
+      if (!DEFAULT_BLOCK_ELEMENTS.has(el)) {
+        customBlockSet.add(el);
+      }
+    }
+    if (customBlockSet.size === 0) {
+      customBlockSet = void 0;
+    }
+  }
+  let contextStacks;
+  let ctxVersion = 0;
+  let cachedGlobalCtx = EMPTY_GLOBAL_CTX;
+  let cachedGlobalCtxVersion = 0;
+  let nlFlag = false;
+  function pushCtx(contextId, value) {
+    if (!contextStacks) {
+      contextStacks = /* @__PURE__ */ new Map();
+    }
+    let stack = contextStacks.get(contextId);
+    if (!stack) {
+      stack = [];
+      contextStacks.set(contextId, stack);
+    }
+    stack.push(value);
+    ctxVersion++;
+  }
+  function popCtx(contextId) {
+    const stack = contextStacks?.get(contextId);
+    if (stack) {
+      stack.pop();
+      if (stack.length === 0) {
+        contextStacks?.delete(contextId);
+      }
+    }
+    ctxVersion++;
+  }
+  function buildGlobalContext() {
+    if (ctxVersion === cachedGlobalCtxVersion) return cachedGlobalCtx;
+    if (!contextStacks || contextStacks.size === 0) {
+      cachedGlobalCtx = EMPTY_GLOBAL_CTX;
+      cachedGlobalCtxVersion = ctxVersion;
+      return cachedGlobalCtx;
+    }
+    const globalCtx = {};
+    for (const [contextId, stack] of contextStacks) {
+      if (stack.length > 0) {
+        globalCtx[contextId] = {
+          props: { value: stack[stack.length - 1] },
+          sub: noop
+        };
+      }
+    }
+    cachedGlobalCtx = globalCtx;
+    cachedGlobalCtxVersion = ctxVersion;
+    return globalCtx;
+  }
+  function render(node, inline) {
+    const t = typeof node;
+    if (t === "string") {
+      nlFlag = node.indexOf("\n") >= 0;
+      return escapeHtml(node);
+    }
+    if (t === "object") {
+      if (node === null) {
+        nlFlag = false;
+        return "";
+      }
+      if (Array.isArray(node)) {
+        let out = "";
+        let anyNewline = false;
+        for (let i = 0; i < node.length; i++) {
+          const child = node[i];
+          if (typeof child === "string") {
+            out += escapeHtml(child);
+            anyNewline = anyNewline || child.indexOf("\n") >= 0;
+          } else {
+            out += render(child, inline);
+            anyNewline = anyNewline || nlFlag;
+          }
+        }
+        nlFlag = anyNewline;
+        return out;
+      }
+      if (!("type" in node)) {
+        nlFlag = false;
+        return "";
+      }
+      const type = node.type;
+      if (typeof type === "string") {
+        return renderElement(type, node.props, inline);
+      }
+      if (type === Fragment) {
+        return renderChildren(node.props ? node.props.children : void 0);
+      }
+      if (typeof type === "function") {
+        return renderComponent(node);
+      }
+      return "";
+    }
+    if (t === "number" || t === "bigint") {
+      nlFlag = false;
+      return String(node);
+    }
+    nlFlag = false;
+    return "";
+  }
+  function renderComponent(vnode2) {
+    const { type, props } = vnode2;
+    const fn = type;
+    const fnAny = fn;
+    if (fnAny._isProvider && fnAny._context) {
+      const ctx = fnAny._context;
+      ctx._stack.push(props.value);
+      const result = activeChildren(props.children);
+      ctx._stack.pop();
+      return result;
+    }
+    let contextId;
+    if (typeof fnAny.__c === "string" && fnAny.__c.startsWith("__cC")) {
+      contextId = fnAny.__c;
+    } else if (fnAny.__ && typeof fnAny.__ === "object" && fnAny.__.__c) {
+      contextId = fnAny.__.__c;
+    }
+    if (contextId) {
+      pushCtx(contextId, props.value);
+      const result = activeChildren(props.children);
+      popCtx(contextId);
+      return result;
+    }
+    if (fn.contextType) {
+      const ctx = fn.contextType;
+      const ctxId = ctx.__c;
+      const stack = contextStacks?.get(ctxId);
+      const value = stack && stack.length > 0 ? stack[stack.length - 1] : ctx.__;
+      if (typeof props.children === "function") {
+        return activeRender(props.children(value));
+      }
+      return activeChildren(props.children);
+    }
+    const component = {
+      props,
+      context: buildGlobalContext(),
+      state: {},
+      __v: vnode2,
+      // _vnode
+      __d: false,
+      // _dirty
+      __h: [],
+      // _renderCallbacks
+      __s: {},
+      // _nextState
+      __H: null
+      // _hooks (initialised by hooks addon)
+    };
+    vnode2.__c = component;
+    preactOptions.__b?.(vnode2);
+    preactOptions.__r?.(vnode2);
+    try {
+      if (fn.prototype && fn.prototype.render) {
+        const instance = new fn(props, component.context);
+        instance.__n = component.__n;
+        instance.__H = component.__H;
+        vnode2.__c = instance;
+        preactOptions.__r?.(vnode2);
+        return activeRender(instance.render(instance.props, instance.state));
+      }
+      const rendered = fn(props, component.context);
+      return activeRender(rendered);
+    } finally {
+      preactOptions.diffed?.(vnode2);
+    }
+  }
+  function renderElement(tag, props, inline) {
+    const flags = TAG_STATIC_FLAGS.get(tag) || 0;
+    const isBlock = (flags & TAG_FLAG_ALWAYS_BLOCK) !== 0 || !inline && ((flags & TAG_FLAG_BLOCK) !== 0 || customBlockSet !== void 0 && customBlockSet.has(tag));
+    const attrs = renderAttrs(tag, props);
+    const openTag = "<" + tag + attrs + ">";
+    if ((flags & TAG_FLAG_VOID) !== 0) {
+      if (isBlock) {
+        nlFlag = true;
+        return openTag + "\n";
+      }
+      nlFlag = false;
+      return openTag;
+    }
+    let inner = "";
+    let innerHasNewline = false;
+    if (props) {
+      const dsih = props.dangerouslySetInnerHTML;
+      if (dsih && dsih.__html != null) {
+        inner = dsih.__html;
+        innerHasNewline = inner.includes("\n");
+      } else if (props.children != null) {
+        const children = props.children;
+        if (typeof children === "string") {
+          inner = escapeHtml(children);
+          innerHasNewline = children.indexOf("\n") >= 0;
+        } else {
+          inner = renderChildren(children);
+          innerHasNewline = nlFlag;
+        }
+      } else if (tag === "textarea") {
+        const textVal = props.value ?? props.defaultValue;
+        if (textVal != null) {
+          inner = escapeHtml(String(textVal));
+          innerHasNewline = inner.includes("\n");
+        }
+      }
+    }
+    if (isBlock) {
+      nlFlag = true;
+      const hasBlockChildren = (flags & TAG_FLAG_RAW) === 0 && innerHasNewline;
+      if (hasBlockChildren) {
+        return openTag + "\n" + inner + "</" + tag + ">\n";
+      }
+      return openTag + inner + "</" + tag + ">\n";
+    }
+    nlFlag = innerHasNewline;
+    return openTag + inner + "</" + tag + ">";
+  }
+  function renderAttrs(tag, props) {
+    if (!props) return "";
+    const isTextarea = tag === "textarea";
+    let result = "";
+    for (const key in props) {
+      const value = props[key];
+      if (value == null) continue;
+      if (key === "children" || key === "dangerouslySetInnerHTML" || key === "key" || key === "ref" || key === "__self" || key === "__source") {
+        continue;
+      }
+      if (isTextarea && (key === "value" || key === "defaultValue")) {
+        continue;
+      }
+      const attrName = PROP_TO_ATTR[key] || key;
+      const valueType = typeof value;
+      if (valueType === "string") {
+        result += " " + attrName + '="' + escapeAttr(value) + '"';
+      } else if (valueType === "number") {
+        result += " " + attrName + '="' + value + '"';
+      } else if (value === true) {
+        result += BOOLEAN_ATTRS.has(attrName) ? " " + attrName : " " + attrName + '="true"';
+      } else if (value === false) {
+        if (!BOOLEAN_ATTRS.has(attrName)) {
+          result += " " + attrName + '="false"';
+        }
+      } else if (valueType === "function") {
+        continue;
+      } else if (key === "style" && valueType === "object") {
+        const styleStr = styleToString(value);
+        if (styleStr) {
+          result += " " + attrName + '="' + escapeAttr(styleStr) + '"';
+        }
+      } else {
+        result += " " + attrName + '="' + escapeAttr(String(value)) + '"';
+      }
+    }
+    return result;
+  }
+  function hasMixedContent(children) {
+    let hasText = false;
+    let hasElement = false;
+    for (let i = 0; i < children.length; i++) {
+      const child = children[i];
+      const t = typeof child;
+      if (t === "string" || t === "number" || t === "bigint") {
+        hasText = true;
+      } else if (t === "object" && child !== null && "type" in child) {
+        hasElement = true;
+      }
+      if (hasText && hasElement) return true;
+    }
+    return false;
+  }
+  function renderChildren(children) {
+    if (children == null) {
+      nlFlag = false;
+      return "";
+    }
+    if (Array.isArray(children)) {
+      const inline = hasMixedContent(children);
+      let out = "";
+      let anyNewline = false;
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        if (typeof child === "string") {
+          out += escapeHtml(child);
+          anyNewline = anyNewline || child.indexOf("\n") >= 0;
+        } else {
+          out += render(child, inline);
+          anyNewline = anyNewline || nlFlag;
+        }
+      }
+      nlFlag = anyNewline;
+      return out;
+    }
+    return render(children);
+  }
+  function mRender(node) {
+    const t = typeof node;
+    if (t === "string") {
+      return escapeHtml(node);
+    }
+    if (t === "object") {
+      if (node === null) {
+        return "";
+      }
+      if (Array.isArray(node)) {
+        let out = "";
+        for (let i = 0; i < node.length; i++) {
+          const child = node[i];
+          out += typeof child === "string" ? escapeHtml(child) : mRender(child);
+        }
+        return out;
+      }
+      if (!("type" in node)) {
+        return "";
+      }
+      const type = node.type;
+      if (typeof type === "string") {
+        return mElement(type, node.props);
+      }
+      if (type === Fragment) {
+        return mChildren(node.props ? node.props.children : void 0);
+      }
+      if (typeof type === "function") {
+        return renderComponent(node);
+      }
+      return "";
+    }
+    if (t === "number" || t === "bigint") {
+      return String(node);
+    }
+    return "";
+  }
+  function mElement(tag, props) {
+    const attrs = renderAttrs(tag, props);
+    if (VOID_ELEMENTS.has(tag)) {
+      return "<" + tag + attrs + ">";
+    }
+    let inner = "";
+    if (props) {
+      const dsih = props.dangerouslySetInnerHTML;
+      if (dsih && dsih.__html != null) {
+        inner = dsih.__html;
+      } else {
+        const children = props.children;
+        if (children != null) {
+          inner = typeof children === "string" ? escapeHtml(children) : mChildren(children);
+        } else if (tag === "textarea") {
+          const textVal = props.value ?? props.defaultValue;
+          if (textVal != null) {
+            inner = escapeHtml(String(textVal));
+          }
+        }
+      }
+    }
+    return "<" + tag + attrs + ">" + inner + "</" + tag + ">";
+  }
+  function mChildren(children) {
+    if (children == null) {
+      return "";
+    }
+    if (Array.isArray(children)) {
+      let out = "";
+      for (let i = 0; i < children.length; i++) {
+        const child = children[i];
+        const t2 = typeof child;
+        if (t2 === "string") {
+          out += escapeHtml(child);
+        } else if (t2 === "object" && child !== null && typeof child.type === "string") {
+          out += mElement(child.type, child.props);
+        } else {
+          out += mRender(child);
+        }
+      }
+      return out;
+    }
+    const t = typeof children;
+    if (t === "string") {
+      return escapeHtml(children);
+    }
+    if (t === "object" && children !== null && typeof children.type === "string") {
+      return mElement(children.type, children.props);
+    }
+    return mRender(children);
+  }
+  const activeRender = isPretty ? render : mRender;
+  const activeChildren = isPretty ? renderChildren : mChildren;
+  return activeRender(vnode);
+}
+function noop() {
+}
+
+export {
+  renderJsxToString
+};
+//# sourceMappingURL=chunk-AJR6VAT7.js.map