unhead 1.0.22 → 1.1.0

package/dist/index.cjs

@@ -1,8 +1,9 @@
 'use strict';
 
 const hookable = require('hookable');
-const shared = require('@unhead/shared');
 const dom = require('@unhead/dom');
+const shared = require('@unhead/shared');
+const packrup = require('packrup');
 
 const TAG_WEIGHTS = {
   // aliases
@@ -66,20 +67,20 @@ const TitleTemplatePlugin = () => {
         const titleIdx = tags.findIndex((i) => i.tag === "title");
         if (titleIdx !== -1 && titleTemplateIdx !== -1) {
           const newTitle = renderTitleTemplate(
-            tags[titleTemplateIdx].children,
-            tags[titleIdx].children
+            tags[titleTemplateIdx].textContent,
+            tags[titleIdx].textContent
           );
           if (newTitle !== null) {
-            tags[titleIdx].children = newTitle || tags[titleIdx].children;
+            tags[titleIdx].textContent = newTitle || tags[titleIdx].textContent;
           } else {
             delete tags[titleIdx];
           }
         } else if (titleTemplateIdx !== -1) {
           const newTitle = renderTitleTemplate(
-            tags[titleTemplateIdx].children
+            tags[titleTemplateIdx].textContent
           );
           if (newTitle !== null) {
-            tags[titleTemplateIdx].children = newTitle;
+            tags[titleTemplateIdx].textContent = newTitle;
             tags[titleTemplateIdx].tag = "title";
             titleTemplateIdx = -1;
           }
@@ -112,15 +113,18 @@ const ProvideTagHashPlugin = () => {
   return shared.defineHeadPlugin({
     hooks: {
       "tag:normalise": (ctx) => {
-        const { tag, entry } = ctx;
+        const { tag, entry, resolvedOptions } = ctx;
+        if (resolvedOptions.experimentalHashHydration === true) {
+          tag._h = shared.hashTag(tag);
+        }
         const isDynamic = typeof tag.props._dynamic !== "undefined";
         if (!shared.HasElementTags.includes(tag.tag) || !tag.key)
           return;
-        tag._hash = shared.hashCode(JSON.stringify({ tag: tag.tag, key: tag.key }));
         if (IsBrowser || getActiveHead()?.resolvedOptions?.document)
           return;
         if (entry._m === "server" || isDynamic) {
-          tag.props[`data-h-${tag._hash}`] = "";
+          tag._h = tag._h || shared.hashTag(tag);
+          tag.props[`data-h-${tag._h}`] = "";
         }
       },
       "tags:resolve": (ctx) => {
@@ -184,7 +188,8 @@ const EventHandlersPlugin = () => {
           const sdeKey = `${ctx.tag._d || ctx.tag._p}:${k}`;
           const eventName = k.slice(2).toLowerCase();
           const eventDedupeKey = `data-h-${eventName}`;
-          delete ctx.staleSideEffects[sdeKey];
+          ctx.markSideEffect(sdeKey, () => {
+          });
           if ($el.hasAttribute(eventDedupeKey))
             return;
           const handler = value;
@@ -205,6 +210,119 @@ const EventHandlersPlugin = () => {
   });
 };
 
+const UsesMergeStrategy = ["templateParams", "htmlAttrs", "bodyAttrs"];
+const DedupesTagsPlugin = (options) => {
+  options = options || {};
+  const dedupeKeys = options.dedupeKeys || ["hid", "vmid", "key"];
+  return shared.defineHeadPlugin({
+    hooks: {
+      "tag:normalise": function({ tag }) {
+        dedupeKeys.forEach((key) => {
+          if (tag.props[key]) {
+            tag.key = tag.props[key];
+            delete tag.props[key];
+          }
+        });
+        const dedupe = tag.key ? `${tag.tag}:${tag.key}` : shared.tagDedupeKey(tag);
+        if (dedupe)
+          tag._d = dedupe;
+      },
+      "tags:resolve": function(ctx) {
+        const deduping = {};
+        ctx.tags.forEach((tag) => {
+          const dedupeKey = tag._d || tag._p;
+          const dupedTag = deduping[dedupeKey];
+          if (dupedTag) {
+            let strategy = tag?.tagDuplicateStrategy;
+            if (!strategy && UsesMergeStrategy.includes(tag.tag))
+              strategy = "merge";
+            if (strategy === "merge") {
+              const oldProps = dupedTag.props;
+              ["class", "style"].forEach((key) => {
+                if (tag.props[key] && oldProps[key]) {
+                  if (key === "style" && !oldProps[key].endsWith(";"))
+                    oldProps[key] += ";";
+                  tag.props[key] = `${oldProps[key]} ${tag.props[key]}`;
+                }
+              });
+              deduping[dedupeKey].props = {
+                ...oldProps,
+                ...tag.props
+              };
+              return;
+            } else if (tag._e === dupedTag._e) {
+              dupedTag._duped = dupedTag._duped || [];
+              tag._d = `${dupedTag._d}:${dupedTag._duped.length + 1}`;
+              dupedTag._duped.push(tag);
+              return;
+            }
+            const propCount = Object.keys(tag.props).length;
+            if ((propCount === 0 || propCount === 1 && typeof tag.props["data-h-key"] !== "undefined") && !tag.innerHTML && !tag.textContent) {
+              delete deduping[dedupeKey];
+              return;
+            }
+          }
+          deduping[dedupeKey] = tag;
+        });
+        const newTags = [];
+        Object.values(deduping).forEach((tag) => {
+          const dupes = tag._duped;
+          delete tag._duped;
+          newTags.push(tag);
+          if (dupes)
+            newTags.push(...dupes);
+        });
+        ctx.tags = newTags;
+      }
+    }
+  });
+};
+
+function processTemplateParams(s, config) {
+  const replacer = (preserveToken) => (_, token) => {
+    if (token === "pageTitle" || token === "s")
+      return "%s";
+    let val;
+    if (token.includes("."))
+      val = token.split(".").reduce((acc, key) => acc[key] || {}, config);
+    else
+      val = config[token];
+    return val || (preserveToken ? token : "");
+  };
+  let template = s.replace(/%(\w+\.?\w+)%/g, replacer()).replace(/%(\w+\.?\w+)/g, replacer(true)).trim();
+  if (config.separator) {
+    if (template.endsWith(config.separator))
+      template = template.slice(0, -config.separator.length).trim();
+    if (template.startsWith(config.separator))
+      template = template.slice(config.separator.length).trim();
+    template = template.replace(new RegExp(`\\${config.separator}\\s*\\${config.separator}`, "g"), config.separator);
+  }
+  return template;
+}
+function TemplateParamsPlugin() {
+  return shared.defineHeadPlugin({
+    hooks: {
+      "tags:resolve": (ctx) => {
+        const { tags } = ctx;
+        const templateParamsIdx = tags.findIndex((tag) => tag.tag === "templateParams");
+        if (templateParamsIdx !== -1) {
+          const templateParams = tags[templateParamsIdx].textContent;
+          delete tags[templateParamsIdx];
+          for (const tag of tags) {
+            if (tag) {
+              if (["titleTemplate", "title"].includes(tag.tag) && typeof tag.textContent === "string")
+                tag.textContent = processTemplateParams(tag.textContent, templateParams);
+              if (tag.tag === "meta" && typeof tag.props.content === "string")
+                tag.props.content = processTemplateParams(tag.props.content, templateParams);
+            }
+          }
+        }
+        ctx.tags = tags.filter(Boolean);
+      }
+    }
+  });
+}
+
 exports.activeHead = void 0;
 const setActiveHead = (head) => exports.activeHead = head;
 const getActiveHead = () => exports.activeHead;
@@ -218,6 +336,38 @@ function useHead(input, options = {}) {
     return head.push(input, options);
   }
 }
+
+function useHeadSafe(input, options = {}) {
+  return useHead(input, {
+    ...options || {},
+    transform: whitelistSafeInput
+  });
+}
+
+function useServerHead(input, options = {}) {
+  return useHead(input, { ...options, mode: "server" });
+}
+
+function useServerHeadSafe(input, options = {}) {
+  return useHeadSafe(input, { ...options, mode: "server" });
+}
+
+function useSeoMeta(input, options) {
+  const { title, titleTemplate, ...meta } = input;
+  return useHead({
+    title,
+    titleTemplate,
+    meta: unpackMeta(meta)
+  }, options);
+}
+
+function useServerSeoMeta(input, options) {
+  return useSeoMeta(input, {
+    ...options || {},
+    mode: "server"
+  });
+}
+
 const useTagTitle = (title) => useHead({ title });
 const useTagBase = (base) => useHead({ base });
 const useTagMeta = (meta) => useHead({ meta: shared.asArray(meta) });
@@ -229,10 +379,6 @@ const useTagNoscript = (noscript) => useHead({ noscript: shared.asArray(noscript
 const useHtmlAttrs = (attrs) => useHead({ htmlAttrs: attrs });
 const useBodyAttrs = (attrs) => useHead({ bodyAttrs: attrs });
 const useTitleTemplate = (titleTemplate) => useHead({ titleTemplate });
-
-function useServerHead(input, options = {}) {
-  return useHead(input, { ...options, mode: "server" });
-}
 const useServerTagTitle = (title) => useServerHead({ title });
 const useServerTagBase = (base) => useServerHead({ base });
 const useServerTagMeta = (meta) => useServerHead({ meta: shared.asArray(meta) });
@@ -245,111 +391,6 @@ const useServerHtmlAttrs = (attrs) => useServerHead({ htmlAttrs: attrs });
 const useServerBodyAttrs = (attrs) => useServerHead({ bodyAttrs: attrs });
 const useServerTitleTemplate = (titleTemplate) => useServerHead({ titleTemplate });
 
-const useSeoMeta = (input) => {
-  const { title, titleTemplate, ...meta } = input;
-  return useHead({
-    title,
-    titleTemplate,
-    meta: unpackMeta(meta)
-  });
-};
-
-function asArray(input) {
-  return Array.isArray(input) ? input : [input];
-}
-const InternalKeySymbol = "_$key";
-function packObject(input, options) {
-  const keys = Object.keys(input);
-  let [k, v] = keys;
-  options = options || {};
-  options.key = options.key || k;
-  options.value = options.value || v;
-  options.resolveKey = options.resolveKey || ((k2) => k2);
-  const resolveKey = (index) => {
-    const arr = asArray(options?.[index]);
-    return arr.find((k2) => {
-      if (typeof k2 === "string" && k2.includes(".")) {
-        return k2;
-      }
-      return k2 && keys.includes(k2);
-    });
-  };
-  const resolveValue = (k2, input2) => {
-    if (k2.includes(".")) {
-      const paths = k2.split(".");
-      let val = input2;
-      for (const path of paths)
-        val = val[path];
-      return val;
-    }
-    return input2[k2];
-  };
-  k = resolveKey("key") || k;
-  v = resolveKey("value") || v;
-  const dedupeKeyPrefix = input.key ? `${InternalKeySymbol}${input.key}-` : "";
-  let keyValue = resolveValue(k, input);
-  keyValue = options.resolveKey(keyValue);
-  return {
-    [`${dedupeKeyPrefix}${keyValue}`]: resolveValue(v, input)
-  };
-}
-
-function packArray(input, options) {
-  const packed = {};
-  for (const i of input) {
-    const packedObj = packObject(i, options);
-    const pKey = Object.keys(packedObj)[0];
-    const isDedupeKey = pKey.startsWith(InternalKeySymbol);
-    if (!isDedupeKey && packed[pKey]) {
-      packed[pKey] = Array.isArray(packed[pKey]) ? packed[pKey] : [packed[pKey]];
-      packed[pKey].push(Object.values(packedObj)[0]);
-    } else {
-      packed[isDedupeKey ? pKey.split("-").slice(1).join("-") || pKey : pKey] = packedObj[pKey];
-    }
-  }
-  return packed;
-}
-
-function unpackToArray(input, options) {
-  const unpacked = [];
-  const kFn = options.resolveKeyData || ((ctx) => ctx.key);
-  const vFn = options.resolveValueData || ((ctx) => ctx.value);
-  for (const [k, v] of Object.entries(input)) {
-    unpacked.push(...(Array.isArray(v) ? v : [v]).map((i) => {
-      const ctx = { key: k, value: i };
-      const val = vFn(ctx);
-      if (typeof val === "object")
-        return unpackToArray(val, options);
-      if (Array.isArray(val))
-        return val;
-      return {
-        [typeof options.key === "function" ? options.key(ctx) : options.key]: kFn(ctx),
-        [typeof options.value === "function" ? options.value(ctx) : options.value]: val
-      };
-    }).flat());
-  }
-  return unpacked;
-}
-
-function unpackToString(value, options) {
-  return Object.entries(value).map(([key, value2]) => {
-    if (typeof value2 === "object")
-      value2 = unpackToString(value2, options);
-    if (options.resolve) {
-      const resolved = options.resolve({ key, value: value2 });
-      if (resolved)
-        return resolved;
-    }
-    if (typeof value2 === "number")
-      value2 = value2.toString();
-    if (typeof value2 === "string" && options.wrapValue) {
-      value2 = value2.replace(new RegExp(options.wrapValue, "g"), `\\${options.wrapValue}`);
-      value2 = `${options.wrapValue}${value2}${options.wrapValue}`;
-    }
-    return `${key}${options.keyValueSeparator || ""}${value2}`;
-  }).join(options.entrySeparator || "");
-}
-
 const MetaPackingSchema = {
   robots: {
     unpack: {
@@ -405,7 +446,7 @@ function resolveMetaKeyType(key) {
 
 function packMeta(inputs) {
   const mappedPackingSchema = Object.entries(MetaPackingSchema).map(([key, value]) => [key, value.keyValue]);
-  return packArray(inputs, {
+  return packrup.packArray(inputs, {
     key: ["name", "property", "httpEquiv", "http-equiv", "charset"],
     value: ["content", "charset"],
     resolveKey(k) {
@@ -428,7 +469,7 @@ function unpackMeta(input) {
       (Array.isArray(val) ? val : [val]).forEach((entry) => {
         if (!entry)
           return;
-        const unpackedEntry = unpackToArray(entry, {
+        const unpackedEntry = packrup.unpackToArray(entry, {
           key: "property",
           value: "content",
           resolveKeyData({ key: key2 }) {
@@ -445,7 +486,7 @@ function unpackMeta(input) {
       delete input[inputKey];
     }
   });
-  const meta = unpackToArray(input, {
+  const meta = packrup.unpackToArray(input, {
     key({ key }) {
       return resolveMetaKeyType(key);
     },
@@ -458,74 +499,98 @@ function unpackMeta(input) {
     resolveValueData({ value, key }) {
       if (value === null)
         return "_null";
-      if (typeof value === "object") {
-        const definition = MetaPackingSchema[key];
-        if (key === "refresh")
-          return `${value.seconds};url=${value.url}`;
-        return unpackToString(
-          changeKeyCasingDeep(value),
-          {
-            entrySeparator: ", ",
-            keyValueSeparator: "=",
-            resolve({ value: value2, key: key2 }) {
-              if (value2 === null)
-                return "";
-              if (typeof value2 === "boolean")
-                return `${key2}`;
-            },
-            ...definition?.unpack
-          }
-        );
-      }
+      if (typeof value === "object")
+        return resolvePackedMetaObjectValue(value, key);
       return typeof value === "number" ? value.toString() : value;
     }
   });
   return [...extras, ...meta].filter((v) => typeof v.content === "undefined" || v.content !== "_null");
 }
+function resolvePackedMetaObjectValue(value, key) {
+  const definition = MetaPackingSchema[key];
+  if (key === "refresh")
+    return `${value.seconds};url=${value.url}`;
+  return packrup.unpackToString(
+    changeKeyCasingDeep(value),
+    {
+      entrySeparator: ", ",
+      keyValueSeparator: "=",
+      resolve({ value: value2, key: key2 }) {
+        if (value2 === null)
+          return "";
+        if (typeof value2 === "boolean")
+          return `${key2}`;
+      },
+      ...definition?.unpack
+    }
+  );
+}
 
 async function normaliseTag(tagName, input) {
   const tag = { tag: tagName, props: {} };
-  if (tagName === "title" || tagName === "titleTemplate") {
-    tag.children = input instanceof Promise ? await input : input;
+  if (["title", "titleTemplate", "templateParams"].includes(tagName)) {
+    tag.textContent = input instanceof Promise ? await input : input;
     return tag;
   }
-  tag.props = await normaliseProps({ ...input });
-  ["children", "innerHtml", "innerHTML"].forEach((key) => {
-    if (typeof tag.props[key] !== "undefined") {
-      tag.children = tag.props[key];
-      if (typeof tag.children === "object")
-        tag.children = JSON.stringify(tag.children);
-      delete tag.props[key];
+  if (typeof input === "string") {
+    if (!["script", "noscript", "style"].includes(tagName))
+      return false;
+    if (tagName === "script" && (/^(https?:)?\/\//.test(input) || input.startsWith("/"))) {
+      tag.props.src = input;
+    } else {
+      tag.innerHTML = input;
+      tag.key = shared.hashCode(input);
     }
-  });
+    return tag;
+  }
+  tag.props = await normaliseProps(tagName, { ...input });
+  if (tag.props.children) {
+    tag.props.innerHTML = tag.props.children;
+  }
+  delete tag.props.children;
   Object.keys(tag.props).filter((k) => shared.TagConfigKeys.includes(k)).forEach((k) => {
-    tag[k] = tag.props[k];
+    if (!["innerHTML", "textContent"].includes(k) || shared.TagsWithInnerContent.includes(tag.tag)) {
+      tag[k] = tag.props[k];
+    }
     delete tag.props[k];
   });
-  if (typeof tag.props.class === "object" && !Array.isArray(tag.props.class)) {
-    tag.props.class = Object.keys(tag.props.class).filter((k) => tag.props.class[k]);
-  }
-  if (Array.isArray(tag.props.class))
-    tag.props.class = tag.props.class.join(" ");
-  if (tag.props.content && Array.isArray(tag.props.content)) {
-    return tag.props.content.map((v, i) => {
-      const newTag = { ...tag, props: { ...tag.props } };
-      newTag.props.content = v;
-      newTag.key = `${tag.props.name || tag.props.property}:${i}`;
-      return newTag;
-    });
-  }
+  ["innerHTML", "textContent"].forEach((k) => {
+    if (tag.tag === "script" && tag[k] && ["application/ld+json", "application/json"].includes(tag.props.type)) {
+      try {
+        tag[k] = JSON.parse(tag[k]);
+      } catch (e) {
+        tag[k] = "";
+      }
+    }
+    if (typeof tag[k] === "object")
+      tag[k] = JSON.stringify(tag[k]);
+  });
+  if (tag.props.class)
+    tag.props.class = normaliseClassProp(tag.props.class);
+  if (tag.props.content && Array.isArray(tag.props.content))
+    return tag.props.content.map((v) => ({ ...tag, props: { ...tag.props, content: v } }));
   return tag;
 }
-async function normaliseProps(props) {
+function normaliseClassProp(v) {
+  if (typeof v === "object" && !Array.isArray(v)) {
+    v = Object.keys(v).filter((k) => v[k]);
+  }
+  return (Array.isArray(v) ? v.join(" ") : v).split(" ").filter((c) => c.trim()).filter(Boolean).join(" ");
+}
+async function normaliseProps(tagName, props) {
   for (const k of Object.keys(props)) {
+    const isDataKey = k.startsWith("data-");
     if (props[k] instanceof Promise) {
       props[k] = await props[k];
     }
     if (String(props[k]) === "true") {
-      props[k] = "";
+      props[k] = isDataKey ? "true" : "";
     } else if (String(props[k]) === "false") {
-      delete props[k];
+      if (isDataKey) {
+        props[k] = "false";
+      } else {
+        delete props[k];
+      }
     }
   }
   return props;
@@ -533,11 +598,11 @@ async function normaliseProps(props) {
 const TagEntityBits = 10;
 async function normaliseEntryTags(e) {
   const tagPromises = [];
-  Object.entries(e.resolvedInput || e.input).filter(([k, v]) => typeof v !== "undefined" && shared.ValidHeadTags.includes(k)).forEach(([k, value]) => {
+  Object.entries(e.resolvedInput).filter(([k, v]) => typeof v !== "undefined" && shared.ValidHeadTags.includes(k)).forEach(([k, value]) => {
     const v = shared.asArray(value);
     tagPromises.push(...v.map((props) => normaliseTag(k, props)).flat());
   });
-  return (await Promise.all(tagPromises)).flat().map((t, i) => {
+  return (await Promise.all(tagPromises)).flat().filter(Boolean).map((t, i) => {
     t._e = e._i;
     t._p = (e._i << TagEntityBits) + i;
     return t;
@@ -565,14 +630,119 @@ function changeKeyCasingDeep(input) {
   return output;
 }
 
+const WhitelistAttributes = {
+  htmlAttrs: ["id", "class", "lang", "dir"],
+  bodyAttrs: ["id", "class"],
+  meta: ["id", "name", "property", "charset", "content"],
+  noscript: ["id", "textContent"],
+  script: ["id", "type", "textContent"],
+  link: ["id", "color", "crossorigin", "fetchpriority", "href", "hreflang", "imagesrcset", "imagesizes", "integrity", "media", "referrerpolicy", "rel", "sizes", "type"]
+};
+function whitelistSafeInput(input) {
+  const filtered = {};
+  Object.keys(input).forEach((key) => {
+    const tagValue = input[key];
+    if (!tagValue)
+      return;
+    switch (key) {
+      case "title":
+      case "titleTemplate":
+      case "templateParams":
+        filtered[key] = tagValue;
+        break;
+      case "htmlAttrs":
+      case "bodyAttrs":
+        filtered[key] = {};
+        WhitelistAttributes[key].forEach((a) => {
+          if (tagValue[a])
+            filtered[key][a] = tagValue[a];
+        });
+        Object.keys(tagValue || {}).filter((a) => a.startsWith("data-")).forEach((a) => {
+          filtered[key][a] = tagValue[a];
+        });
+        break;
+      case "meta":
+        if (Array.isArray(tagValue)) {
+          filtered[key] = tagValue.map((meta) => {
+            const safeMeta = {};
+            WhitelistAttributes.meta.forEach((key2) => {
+              if (meta[key2] || key2.startsWith("data-"))
+                safeMeta[key2] = meta[key2];
+            });
+            return safeMeta;
+          }).filter((meta) => Object.keys(meta).length > 0);
+        }
+        break;
+      case "link":
+        if (Array.isArray(tagValue)) {
+          filtered[key] = tagValue.map((meta) => {
+            const link = {};
+            WhitelistAttributes.link.forEach((key2) => {
+              if (key2 === "rel" && ["stylesheet", "canonical", "modulepreload", "prerender", "preload", "prefetch"].includes(meta[key2]))
+                return;
+              if (key2 === "href") {
+                try {
+                  const url = new URL(meta[key2]);
+                  if (["javascript:", "data:"].includes(url.protocol))
+                    return;
+                  link[key2] = meta[key2];
+                } catch (e) {
+                }
+              } else if (meta[key2] || key2.startsWith("data-")) {
+                link[key2] = meta[key2];
+              }
+            });
+            return link;
+          }).filter((link) => Object.keys(link).length > 1 && !!link.rel);
+        }
+        break;
+      case "noscript":
+        if (Array.isArray(tagValue)) {
+          filtered[key] = tagValue.map((meta) => {
+            const noscript = {};
+            WhitelistAttributes.noscript.forEach((key2) => {
+              if (meta[key2] || key2.startsWith("data-"))
+                noscript[key2] = meta[key2];
+            });
+            return noscript;
+          }).filter((meta) => Object.keys(meta).length > 0);
+        }
+        break;
+      case "script":
+        if (Array.isArray(tagValue)) {
+          filtered[key] = tagValue.map((script) => {
+            const safeScript = {};
+            WhitelistAttributes.script.forEach((s) => {
+              if (script[s] || s.startsWith("data-")) {
+                if (s === "textContent") {
+                  try {
+                    const jsonVal = typeof script[s] === "string" ? JSON.parse(script[s]) : script[s];
+                    safeScript[s] = JSON.stringify(jsonVal, null, 0);
+                  } catch (e) {
+                  }
+                } else {
+                  safeScript[s] = script[s];
+                }
+              }
+            });
+            return safeScript;
+          }).filter((meta) => Object.keys(meta).length > 0);
+        }
+        break;
+    }
+  });
+  return filtered;
+}
+
 const CorePlugins = () => [
   // dedupe needs to come first
-  shared.DedupesTagsPlugin(),
+  DedupesTagsPlugin(),
   SortTagsPlugin(),
   TitleTemplatePlugin(),
   ProvideTagHashPlugin(),
   EventHandlersPlugin(),
-  DeprecatedTagAttrPlugin()
+  DeprecatedTagAttrPlugin(),
+  TemplateParamsPlugin()
 ];
 const DOMPlugins = (options = {}) => [
   dom.PatchDomOnEntryUpdatesPlugin({ document: options?.document, delayFn: options?.domDelayFn })
@@ -582,6 +752,8 @@ function createHead(options = {}) {
     ...options,
     plugins: [...DOMPlugins(options), ...options?.plugins || []]
   });
+  if (options.experimentalHashHydration && head.resolvedOptions.document)
+    head._hash = dom.maybeGetSSRHash(head.resolvedOptions.document);
   setActiveHead(head);
   return head;
 }
@@ -597,6 +769,7 @@ function createHeadCore(options = {}) {
     ...options?.plugins || []
   ];
   options.plugins.forEach((p) => p.hooks && hooks.addHooks(p.hooks));
+  options.document = options.document || (IsBrowser ? document : void 0);
   const updated = () => hooks.callHook("entries:updated", head);
   const head = {
     resolvedOptions: options,
@@ -618,6 +791,9 @@ function createHeadCore(options = {}) {
       };
       if (options2?.mode)
         activeEntry._m = options2?.mode;
+      if (options2?.transform) {
+        activeEntry._t = options2?.transform;
+      }
       entries.push(activeEntry);
       updated();
       return {
@@ -647,8 +823,10 @@ function createHeadCore(options = {}) {
       const resolveCtx = { tags: [], entries: [...entries] };
       await hooks.callHook("entries:resolve", resolveCtx);
       for (const entry of resolveCtx.entries) {
+        const transformer = entry._t || ((i) => i);
+        entry.resolvedInput = transformer(entry.resolvedInput || entry.input);
         for (const tag of await normaliseEntryTags(entry)) {
-          const tagCtx = { tag, entry };
+          const tagCtx = { tag, entry, resolvedOptions: head.resolvedOptions };
           await hooks.callHook("tag:normalise", tagCtx);
           resolveCtx.tags.push(tagCtx.tag);
         }
@@ -656,12 +834,12 @@ function createHeadCore(options = {}) {
       await hooks.callHook("tags:resolve", resolveCtx);
       return resolveCtx.tags;
     },
-    _elMap: {},
     _popSideEffectQueue() {
       const sde = { ..._sde };
       _sde = {};
       return sde;
-    }
+    },
+    _elMap: {}
   };
   head.hooks.callHook("init", head);
   return head;
@@ -672,12 +850,16 @@ const coreComposableNames = [
 ];
 const composableNames = [
   "useHead",
+  "useSeoMeta",
+  "useHeadSafe",
+  "useServerHead",
+  "useServerSeoMeta",
+  "useServerHeadSafe",
+  // deprecated
   "useTagTitle",
   "useTagBase",
   "useTagMeta",
   "useTagMetaFlat",
-  // alias
-  "useSeoMeta",
   "useTagLink",
   "useTagScript",
   "useTagStyle",
@@ -685,8 +867,6 @@ const composableNames = [
   "useHtmlAttrs",
   "useBodyAttrs",
   "useTitleTemplate",
-  // server only composables
-  "useServerHead",
   "useServerTagTitle",
   "useServerTagBase",
   "useServerTagMeta",
@@ -709,14 +889,17 @@ const unheadComposablesImports = [
 exports.ColonPrefixKeys = ColonPrefixKeys;
 exports.CorePlugins = CorePlugins;
 exports.DOMPlugins = DOMPlugins;
+exports.DedupesTagsPlugin = DedupesTagsPlugin;
 exports.DeprecatedTagAttrPlugin = DeprecatedTagAttrPlugin;
 exports.EventHandlersPlugin = EventHandlersPlugin;
+exports.MetaPackingSchema = MetaPackingSchema;
 exports.PropertyPrefixKeys = PropertyPrefixKeys;
 exports.ProvideTagHashPlugin = ProvideTagHashPlugin;
 exports.SortModifiers = SortModifiers;
 exports.SortTagsPlugin = SortTagsPlugin;
 exports.TAG_WEIGHTS = TAG_WEIGHTS;
 exports.TagEntityBits = TagEntityBits;
+exports.TemplateParamsPlugin = TemplateParamsPlugin;
 exports.TitleTemplatePlugin = TitleTemplatePlugin;
 exports.changeKeyCasingDeep = changeKeyCasingDeep;
 exports.composableNames = composableNames;
@@ -724,22 +907,28 @@ exports.createHead = createHead;
 exports.createHeadCore = createHeadCore;
 exports.fixKeyCase = fixKeyCase;
 exports.getActiveHead = getActiveHead;
+exports.normaliseClassProp = normaliseClassProp;
 exports.normaliseEntryTags = normaliseEntryTags;
 exports.normaliseProps = normaliseProps;
 exports.normaliseTag = normaliseTag;
 exports.packMeta = packMeta;
 exports.renderTitleTemplate = renderTitleTemplate;
+exports.resolveMetaKeyType = resolveMetaKeyType;
+exports.resolvePackedMetaObjectValue = resolvePackedMetaObjectValue;
 exports.setActiveHead = setActiveHead;
 exports.tagWeight = tagWeight;
 exports.unheadComposablesImports = unheadComposablesImports;
 exports.unpackMeta = unpackMeta;
 exports.useBodyAttrs = useBodyAttrs;
 exports.useHead = useHead;
+exports.useHeadSafe = useHeadSafe;
 exports.useHtmlAttrs = useHtmlAttrs;
 exports.useSeoMeta = useSeoMeta;
 exports.useServerBodyAttrs = useServerBodyAttrs;
 exports.useServerHead = useServerHead;
+exports.useServerHeadSafe = useServerHeadSafe;
 exports.useServerHtmlAttrs = useServerHtmlAttrs;
+exports.useServerSeoMeta = useServerSeoMeta;
 exports.useServerTagBase = useServerTagBase;
 exports.useServerTagLink = useServerTagLink;
 exports.useServerTagMeta = useServerTagMeta;
@@ -758,6 +947,7 @@ exports.useTagScript = useTagScript;
 exports.useTagStyle = useTagStyle;
 exports.useTagTitle = useTagTitle;
 exports.useTitleTemplate = useTitleTemplate;
+exports.whitelistSafeInput = whitelistSafeInput;
 Object.keys(shared).forEach(function (k) {
   if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = shared[k];
 });