unhead 3.1.6 → 3.1.7

package/dist/shared/{unhead.H5gLMTHA.mjs → unhead.CR32jx68.mjs}

@@ -1,10 +1,14 @@
-import { U as UniqueTags, c as TagsWithInnerContent, M as MetaTagsArrayable, H as HasElementTags, T as TagConfigKeys, D as DupeableTags, d as UsesMergeStrategy, V as ValidHeadTags } from './unhead.fg-0ge_u.mjs';
-import { a as callHook } from './unhead.DvIxXxuO.mjs';
+import { U as UniqueTags, c as TagsWithInnerContent, M as MetaTagsArrayable, i as isUnsafeKey, H as HasElementTags, T as TagConfigKeys, D as DupeableTags, d as UsesMergeStrategy, V as ValidHeadTags } from './unhead.1eoQpFT1.mjs';
+import { a as callHook } from './unhead.Bm4Y6XQI.mjs';
 
 const META_NOREWRITE_RE = /^(?:viewport|description|keywords|robots)$/;
 const META_KEY_ATTRS = ["name", "property", "http-equiv"];
 function isMetaArrayDupeKey(v) {
-  return MetaTagsArrayable.has(v.split(":")[1]);
+  const i = v.indexOf(":");
+  if (i === -1)
+    return false;
+  const j = v.indexOf(":", i + 1);
+  return MetaTagsArrayable.has(v.slice(i + 1, j === -1 ? v.length : j));
 }
 function dedupeKey(tag) {
   const { props, tag: t, key } = tag;
@@ -36,7 +40,18 @@ function dedupeKey(tag) {
   return TagsWithInnerContent.has(t) && (tag.textContent || tag.innerHTML) ? `${t}:content:${tag.textContent || tag.innerHTML}` : void 0;
 }
 function hashTag(tag) {
-  return tag._h || tag._d || tag.textContent || tag.innerHTML || `${tag.tag}:${Object.entries(tag.props).map(([k, v]) => `${k}:${String(v)}`).join()}`;
+  const identity = tag._h || tag._d || tag.textContent || tag.innerHTML;
+  if (identity)
+    return identity;
+  let hash = `${tag.tag}:`;
+  let separator = "";
+  for (const key in tag.props) {
+    if (Object.hasOwn(tag.props, key)) {
+      hash += `${separator}${key}:${String(tag.props[key])}`;
+      separator = ",";
+    }
+  }
+  return hash;
 }
 
 function walkResolver(val, resolve, key) {
@@ -45,20 +60,42 @@ function walkResolver(val, resolve, key) {
   if (typeof val === "function" && (!key || key !== "titleTemplate" && !key.startsWith("on")))
     val = val();
   const v = resolve ? resolve(key, val) : val;
-  if (Array.isArray(v))
-    return v.map((r) => walkResolver(r, resolve));
+  if (Array.isArray(v)) {
+    let out;
+    for (let i = 0; i < v.length; i++) {
+      const r = walkResolver(v[i], resolve);
+      if (out) {
+        out[i] = r;
+      } else if (r !== v[i]) {
+        out = v.slice(0, i);
+        out[i] = r;
+      }
+    }
+    return out || v;
+  }
   if (v?.constructor === Object) {
-    const next = {};
+    let next;
     for (const k in v) {
-      if (k === "__proto__" || k === "constructor" || k === "prototype")
-        continue;
-      next[k] = walkResolver(v[k], resolve, k);
+      const unsafe = isUnsafeKey(k);
+      const r = unsafe ? void 0 : walkResolver(v[k], resolve, k);
+      if (!next && (unsafe || r !== v[k])) {
+        next = {};
+        for (const pk in v) {
+          if (pk === k)
+            break;
+          next[pk] = v[pk];
+        }
+      }
+      if (next && !unsafe)
+        next[k] = r;
     }
-    return next;
+    return next || v;
   }
   return v;
 }
 
+const INVALID_ATTR_NAME_RE = /[\s"'<>/=\x00-\x1F\x7F]/;
+
 function normalizeStyleClassProps(key, value) {
   const isStyle = key === "style";
   const store = isStyle ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Set();
@@ -94,11 +131,16 @@ function normalizeProps(tag, input) {
   }
   const isHtmlTag = HasElementTags.has(tag.tag) || tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs";
   for (const prop in input) {
-    if (prop === "__proto__" || prop === "constructor" || prop === "prototype")
+    if (isUnsafeKey(prop))
+      continue;
+    const isData = prop.startsWith("data-");
+    const isHtmlAttr = isHtmlTag && !TagConfigKeys.has(prop);
+    const key = isHtmlAttr && !isData ? prop.toLowerCase() : prop;
+    if (isHtmlAttr && (!key || INVALID_ATTR_NAME_RE.test(key)))
       continue;
     const value = input[prop];
     if (value === null) {
-      tag.props[prop] = null;
+      tag.props[key] = null;
     } else if (prop === "class" || prop === "style") {
       tag.props[prop] = normalizeStyleClassProps(prop, value);
     } else if (TagConfigKeys.has(prop)) {
@@ -112,8 +154,6 @@ function normalizeProps(tag, input) {
         tag[prop] = value;
       }
     } else if (value !== void 0) {
-      const isData = prop.startsWith("data-");
-      const key = isHtmlTag && !isData ? prop.toLowerCase() : prop;
       const str = String(value);
       const isMeta = tag.tag === "meta" && key === "content";
       tag.props[key] = str === "true" || str === "" ? isData || isMeta ? str : true : !value && isData && str === "false" ? "false" : value;
@@ -130,7 +170,21 @@ function normalizeTag(tagName, _input) {
     tag.innerHTML = JSON.stringify(tag.innerHTML);
     tag.props.type = tag.props.type || "application/json";
   }
-  return Array.isArray(tag.props.content) ? tag.props.content.map((v) => ({ ...tag, props: { ...tag.props, content: v } })) : tag;
+  if (Array.isArray(tag.props.content)) {
+    const tags = [];
+    for (const content of tag.props.content) {
+      tags.push({ ...tag, props: { ...tag.props, content } });
+    }
+    return tags;
+  }
+  return tag;
+}
+function pushNormalizedTag(tags, tag) {
+  if (Array.isArray(tag)) {
+    for (const t of tag) tags.push(t);
+  } else {
+    tags.push(tag);
+  }
 }
 function normalizeEntryToTags(input, propResolvers) {
   if (!input)
@@ -151,21 +205,60 @@ function normalizeEntryToTags(input, propResolvers) {
   for (const key in input) {
     const value = input[key];
     if (value !== void 0) {
-      for (const v of Array.isArray(value) ? value : [value]) tags.push(normalizeTag(key, v));
+      if (Array.isArray(value)) {
+        for (const v of value) pushNormalizedTag(tags, normalizeTag(key, v));
+      } else {
+        pushNormalizedTag(tags, normalizeTag(key, value));
+      }
     }
   }
-  return tags.flat();
+  return tags;
 }
 
 const LT_RE = /</g;
 const SCRIPT_END_RE = /<\/script/g;
 const sortTags = (a, b) => a._w === b._w ? a._p - b._p : a._w - b._w;
 const DEFAULT_TAG_WEIGHT = () => 100;
+function isEmptyProps(props) {
+  for (const _ in props)
+    return false;
+  return true;
+}
 const TAG_MUTATING_HOOK_RE = /^tags:|:render/;
+function pushEntryTags(ctx, entries, needsClone) {
+  for (const tags of entries) {
+    for (const t of tags) {
+      if (needsClone) {
+        const props = { ...t.props };
+        if (props.class instanceof Set)
+          props.class = new Set(props.class);
+        if (props.style instanceof Map)
+          props.style = new Map(props.style);
+        ctx.tags.push({ ...t, props });
+      } else {
+        ctx.tags.push(t);
+      }
+    }
+  }
+}
+function valuesToTags(ctx, sortFlatMeta) {
+  ctx.tags = [];
+  for (const value of ctx.tagMap.values()) {
+    if (Array.isArray(value)) {
+      for (const tag of value) ctx.tags.push(tag);
+    } else {
+      ctx.tags.push(value);
+    }
+  }
+  if (sortFlatMeta)
+    ctx.tags.sort(sortTags);
+}
 function dedupeTags(ctx) {
   let hasFlatMeta = false;
   for (const next of ctx.tags.sort(sortTags)) {
     const k = next._d || hashTag(next);
+    if (!k)
+      continue;
     const prev = ctx.tagMap.get(k);
     if (!prev) {
       ctx.tagMap.set(k, next);
@@ -210,7 +303,7 @@ function sanitizeTags(tags) {
   const out = [];
   for (let t of tags) {
     const { innerHTML, tag, props } = t;
-    if (!ValidHeadTags.has(tag) || !Object.keys(props).length && !innerHTML && !t.textContent)
+    if (!ValidHeadTags.has(tag) || isEmptyProps(props) && !innerHTML && !t.textContent)
       continue;
     if (tag === "meta" && !props.content && !props["http-equiv"] && !props.charset)
       continue;
@@ -242,22 +335,28 @@ function resolveTags(head, options) {
     }
   }
   callHook(head, "entries:resolve", { entries, ...ctx });
+  const entryTags = [];
   for (const e of entries) {
     if (!e._tags) {
+      const tags = normalizeEntryToTags(e.input, head.resolvedOptions.propResolvers || []);
+      for (const t of tags)
+        Object.assign(t, e.options);
       const normalizeCtx = {
-        tags: normalizeEntryToTags(e.input, head.resolvedOptions.propResolvers || []).map((t) => Object.assign(t, e.options)),
+        tags,
         entry: e
       };
       callHook(head, "entries:normalize", normalizeCtx);
-      e._tags = normalizeCtx.tags.map((t, i) => {
+      for (let i = 0; i < normalizeCtx.tags.length; i++) {
+        const t = normalizeCtx.tags[i];
         t._w = weightFn(t);
         t._p = (e._i << 10) + i;
         t._d = dedupeKey(t);
         if (!t._d)
           t._h = hashTag(t);
-        return t;
-      });
+      }
+      e._tags = normalizeCtx.tags;
     }
+    entryTags.push(e._tags);
   }
   let needsClone = false;
   for (const k in hooks) {
@@ -266,23 +365,14 @@ function resolveTags(head, options) {
       break;
     }
   }
-  ctx.tags = needsClone ? entries.flatMap((e) => (e._tags || []).map((t) => {
-    const props = { ...t.props };
-    if (props.class instanceof Set)
-      props.class = new Set(props.class);
-    if (props.style instanceof Map)
-      props.style = new Map(props.style);
-    return { ...t, props };
-  })) : entries.flatMap((e) => e._tags || []);
+  pushEntryTags(ctx, entryTags, needsClone);
   const hasFlatMeta = dedupeTags(ctx);
   resolveTitleTemplate(ctx, head);
-  ctx.tags = [...ctx.tagMap.values()];
-  if (hasFlatMeta)
-    ctx.tags = ctx.tags.flat().sort(sortTags);
+  valuesToTags(ctx, hasFlatMeta);
   callHook(head, "tags:beforeResolve", ctx);
   callHook(head, "tags:resolve", ctx);
   callHook(head, "tags:afterResolve", ctx);
   return sanitizeTags(ctx.tags);
 }
 
-export { dedupeTags as a, normalizeProps as b, resolveTitleTemplate as c, dedupeKey as d, hashTag as h, isMetaArrayDupeKey as i, normalizeEntryToTags as n, resolveTags as r, sanitizeTags as s, walkResolver as w };
+export { INVALID_ATTR_NAME_RE as I, dedupeTags as a, normalizeProps as b, resolveTitleTemplate as c, dedupeKey as d, hashTag as h, isMetaArrayDupeKey as i, normalizeEntryToTags as n, resolveTags as r, sanitizeTags as s, walkResolver as w };

package/dist/shared/{unhead.CBkhoTGw.mjs → unhead.CT1xoGPh.mjs}

@@ -1,4 +1,4 @@
-import { M as MetaTagsArrayable } from './unhead.fg-0ge_u.mjs';
+import { M as MetaTagsArrayable } from './unhead.1eoQpFT1.mjs';
 
 const NAMESPACES = {
   META: /* @__PURE__ */ new Set(["twitter", "fediverse"]),

package/dist/shared/unhead.CaGVnLUe.mjs

@@ -0,0 +1,231 @@
+import { H as HasElementTags } from './unhead.1eoQpFT1.mjs';
+import { r as resolveTags, i as isMetaArrayDupeKey, b as normalizeProps, d as dedupeKey, h as hashTag } from './unhead.CR32jx68.mjs';
+import { a as callHook } from './unhead.Bm4Y6XQI.mjs';
+
+const WHITESPACE_RE = /\s+/;
+// @__NO_SIDE_EFFECTS__
+function createDomRenderer(options = {}) {
+  return (head) => _renderDOMHead(head, options);
+}
+function renderDOMHead(head, options = {}) {
+  return _renderDOMHead(head, options);
+}
+function hasPendingEntries(head) {
+  for (const entry of head.entries.values()) {
+    if (entry._pending !== void 0)
+      return true;
+  }
+  return false;
+}
+function cleanupDomState(state) {
+  for (const k in state._s) state._s[k]();
+  for (const k in state._p) state._p[k]();
+  state._s = {};
+  state._p = {};
+  state._e.clear();
+  state._l.clear();
+}
+function createDomState(head, dom) {
+  const state = { _d: dom, _t: dom.title, _e: /* @__PURE__ */ new Map([["htmlAttrs", dom.documentElement], ["bodyAttrs", dom.body]]), _p: {}, _s: {}, _l: /* @__PURE__ */ new Map() };
+  for (const el of [...dom.body.children, ...dom.head.children]) {
+    const tag = el.tagName.toLowerCase();
+    if (!HasElementTags.has(tag))
+      continue;
+    const props = { innerHTML: el.innerHTML };
+    for (const n of el.getAttributeNames())
+      props[n] = el.getAttribute(n);
+    const next = normalizeProps({ tag, props: {} }, props);
+    next.key = el.getAttribute("data-hid") || void 0;
+    const dedupe = dedupeKey(next) || hashTag(next);
+    let k = dedupe;
+    let c = 1;
+    while (state._e.has(k))
+      k = `${dedupe}:${c++}`;
+    state._e.set(k, el);
+  }
+  for (const entry of head.entries.values()) {
+    if (entry._o !== void 0) {
+      const orig = entry._o;
+      for (const t of ["bodyAttrs", "htmlAttrs"]) {
+        const cls = orig[t]?.class;
+        if (typeof cls === "string") {
+          const $el = state._e.get(t);
+          for (const c of cls.split(WHITESPACE_RE)) {
+            if (c)
+              state._p[`${t}:attr:class:${c}`] = () => $el.classList.remove(c);
+          }
+        }
+      }
+    }
+  }
+  return state;
+}
+function _renderDOMHead(head, options = {}) {
+  const dom = options.document || head.resolvedOptions.document;
+  const activeState = head._dom;
+  const documentChanged = !!activeState && activeState._d !== dom;
+  if (!dom || !documentChanged && !head.dirty && !hasPendingEntries(head))
+    return false;
+  if (head._du)
+    return false;
+  const defaultView = dom.defaultView;
+  head._du = true;
+  let didRender = false;
+  try {
+    let track = function(id, scope, fn, fresh) {
+      const k = `${id}:${scope}`;
+      renderState._s[k] = !fresh && renderState._p[k] || fn;
+      delete renderState._p[k];
+    }, reclaim = function(key) {
+      const prev = renderState._p[key];
+      delete renderState._p[key];
+      return prev;
+    }, trackEvent = function(id, k, ev, source, $el, target) {
+      const scope = `event:${k}`;
+      const key = `${id}:${scope}`;
+      const prev = renderState._l.get(key);
+      if (prev && prev[0] === target && prev[1] === ev && prev[2] === source) {
+        track(id, scope, prev[4]);
+        return;
+      }
+      prev?.[4]();
+      const dk = `data-${k}`;
+      const handler = ((e) => source.call($el, e));
+      const cleanup = () => {
+        target.removeEventListener(ev, handler);
+        if ($el.getAttribute(dk) === "")
+          $el.removeAttribute(dk);
+        if (renderState._l.get(key)?.[3] === handler)
+          renderState._l.delete(key);
+      };
+      target.addEventListener(ev, handler);
+      renderState._l.set(key, [target, ev, source, handler, cleanup]);
+      $el.setAttribute(dk, "");
+      track(id, scope, cleanup, true);
+    }, trackCtx = function({ id, $el, tag }) {
+      const isAttr = tag.tag.endsWith("Attrs");
+      renderState._e.set(id, $el);
+      if (!isAttr) {
+        const text = tag.textContent;
+        if (text != null && text !== "") {
+          if (text !== $el.textContent)
+            $el.textContent = text;
+          track(id, "text", () => {
+            if ($el.textContent === text)
+              $el.textContent = "";
+          }, true);
+        }
+        const html = tag.innerHTML;
+        if (html != null && html !== "") {
+          if (html !== $el.innerHTML)
+            $el.innerHTML = html;
+          track(id, "html", () => {
+            if ($el.innerHTML === html)
+              $el.innerHTML = "";
+          }, true);
+        }
+        const elKey = `${id}:el`;
+        renderState._s[elKey] = reclaim(elKey) || (() => {
+          $el?.remove();
+          renderState._e.delete(id);
+        });
+      }
+      for (const k in tag.props) {
+        const v = tag.props[k];
+        if (k[0] === "o" && k[1] === "n" && typeof v === "function") {
+          const ev = k.slice(2);
+          if ($el?.dataset?.[`${k}fired`])
+            v.call($el, new (defaultView?.Event || Event)(ev));
+          trackEvent(id, k, ev, v, $el, tag.tag === "bodyAttrs" && defaultView ? defaultView : $el);
+          continue;
+        }
+        const ck = `${id}:attr:${k}`;
+        if (k === "class" && v) {
+          for (const c of v) {
+            const key = `${ck}:${c}`;
+            renderState._s[key] = reclaim(key) || (() => $el.classList.remove(c));
+            if (!$el.classList.contains(c))
+              $el.classList.add(c);
+          }
+        } else if (k === "style" && v) {
+          for (const [sk, sv] of v) {
+            const key = `${ck}:${sk}`;
+            renderState._s[key] = reclaim(key) || (() => $el.style.removeProperty(sk));
+            $el.style.setProperty(sk, sv);
+          }
+        } else if (v !== false && v !== null) {
+          if ($el.getAttribute(k) !== v)
+            $el.setAttribute(k, v === true ? "" : String(v));
+          renderState._s[ck] = reclaim(ck) || (() => $el.removeAttribute(k));
+        }
+      }
+    };
+    const beforeRenderCtx = { shouldRender: true, tags: [] };
+    callHook(head, "dom:beforeRender", beforeRenderCtx);
+    if (!beforeRenderCtx.shouldRender)
+      return false;
+    let state = head._dom;
+    if (state?._d !== dom) {
+      if (state)
+        cleanupDomState(state);
+      state = void 0;
+    }
+    if (!state) {
+      state = createDomState(head, dom);
+    } else {
+      state._p = state._s;
+    }
+    state._s = {};
+    const renderState = state;
+    const pending = [];
+    const frag = {};
+    head.dirty = false;
+    const rawTags = resolveTags(head, options.tagWeight ? { tagWeight: options.tagWeight } : void 0);
+    const tags = [];
+    const dupeKeyCounter = {};
+    for (const tag of rawTags) {
+      const count = dupeKeyCounter[tag._d] || 0;
+      const id = (count ? `${tag._d}:${count}` : tag._d) || tag._h;
+      const ctx = { tag, id, shouldRender: true };
+      if (tag._d && isMetaArrayDupeKey(tag._d))
+        dupeKeyCounter[tag._d] = count + 1;
+      tags.push(ctx);
+      if (tag.tag === "title") {
+        dom.title = tag.textContent;
+        track("title", "", () => dom.title = renderState._t);
+        continue;
+      }
+      ctx.$el = renderState._e.get(id);
+      if (ctx.$el)
+        trackCtx(ctx);
+      else if (HasElementTags.has(tag.tag))
+        pending.push(ctx);
+    }
+    for (const ctx of pending) {
+      ctx.$el = dom.createElement(ctx.tag.tag);
+      trackCtx(ctx);
+      (frag[ctx.tag.tagPosition || "head"] ??= dom.createDocumentFragment()).appendChild(ctx.$el);
+    }
+    if (frag.head)
+      dom.head.appendChild(frag.head);
+    if (frag.bodyOpen)
+      dom.body.insertBefore(frag.bodyOpen, dom.body.firstChild);
+    if (frag.bodyClose)
+      dom.body.appendChild(frag.bodyClose);
+    for (const k in renderState._p)
+      renderState._p[k]();
+    head._dom = renderState;
+    didRender = true;
+    callHook(head, "dom:rendered", { renders: tags });
+  } catch (e) {
+    head.dirty = true;
+    throw e;
+  } finally {
+    head._du = false;
+  }
+  if (didRender && (head.dirty || hasPendingEntries(head)))
+    _renderDOMHead(head, options);
+  return didRender;
+}
+
+export { createDomRenderer as c, renderDOMHead as r };

package/dist/shared/{unhead.YBmQyFpm.d.ts → unhead.Cnhe7n9-.d.ts}

@@ -1,4 +1,4 @@
-import { U as Unhead, F as UseScriptInput, G as UseScriptOptions, J as UseScriptReturn } from './unhead.CBj56GgY.js';
+import { U as Unhead, F as UseScriptInput, G as UseScriptOptions, J as UseScriptReturn } from './unhead.Dv-MkoX9.js';
 
 /**
  * Load third-party scripts with SSR support and a proxied API.

package/dist/shared/{unhead.Blkhu0Cr.d.ts → unhead.DQadHCLi.d.ts}

@@ -1,5 +1,5 @@
 import { HookableCore } from 'hookable';
-import { U as Unhead, S as SSRHeadPayload, f as ServerHeadHooks, a as CreateServerHeadOptions } from './unhead.CBj56GgY.js';
+import { U as Unhead, S as SSRHeadPayload, f as ServerHeadHooks, a as CreateServerHeadOptions } from './unhead.Dv-MkoX9.js';
 import { R as ResolvableHead } from './unhead.Dl7UHSN0.js';
 
 interface ServerUnhead<T = ResolvableHead> extends Unhead<T, SSRHeadPayload> {

package/dist/shared/{unhead.CBj56GgY.d.ts → unhead.Dv-MkoX9.d.ts}

@@ -263,8 +263,10 @@ interface HeadPluginOptions extends CreateHeadOptions {
 }
 type HeadPluginInput = (HeadPluginOptions & {
     key: string;
-}) | ((head: Unhead) => HeadPluginOptions & {
+}) | (((head: Unhead) => HeadPluginOptions & {
     key: string;
+}) & {
+    key?: string;
 });
 type HeadPlugin = HeadPluginOptions & {
     key: string;
@@ -484,10 +486,6 @@ interface Unhead<Input = ResolvableHead, RenderResult = unknown> {
      * @internal
      */
     _titleTemplate?: string;
-    /**
-     * @internal
-     */
-    _ssrPayload?: ResolvableHead;
     /**
      * @internal
      */

package/dist/shared/{unhead.CfgPMHXt.mjs → unhead.WK9wg_ep.mjs}

@@ -1,4 +1,6 @@
 function registerPlugin(head, p) {
+  if (typeof p === "function" && p.key && head.plugins.has(p.key))
+    return;
   const plugin = typeof p === "function" ? p(head) : p;
   const key = plugin.key || String(head.plugins.size + 1);
   if (!head.plugins.get(key)) {