unhead 1.0.21 → 1.1.0

package/dist/index.cjs

@@ -2,300 +2,53 @@
 
 const hookable = require('hookable');
 const dom = require('@unhead/dom');
+const shared = require('@unhead/shared');
+const packrup = require('packrup');
 
-const ValidHeadTags = [
-  "title",
-  "titleTemplate",
-  "base",
-  "htmlAttrs",
-  "bodyAttrs",
-  "meta",
-  "link",
-  "style",
-  "script",
-  "noscript"
-];
-const TagConfigKeys = ["tagPosition", "tagPriority", "tagDuplicateStrategy"];
-
-async function normaliseTag(tagName, input) {
-  const tag = { tag: tagName, props: {} };
-  if (tagName === "title" || tagName === "titleTemplate") {
-    tag.children = 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];
-    }
-  });
-  Object.keys(tag.props).filter((k) => TagConfigKeys.includes(k)).forEach((k) => {
-    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;
-    });
-  }
-  return tag;
-}
-async function normaliseProps(props) {
-  for (const k of Object.keys(props)) {
-    if (props[k] instanceof Promise) {
-      props[k] = await props[k];
-    }
-    if (String(props[k]) === "true") {
-      props[k] = "";
-    } else if (String(props[k]) === "false") {
-      delete props[k];
-    }
+const TAG_WEIGHTS = {
+  // aliases
+  critical: 2,
+  high: 9,
+  low: 12,
+  // tags
+  base: -1,
+  title: 1,
+  meta: 10
+};
+function tagWeight(tag) {
+  if (typeof tag.tagPriority === "number")
+    return tag.tagPriority;
+  if (tag.tag === "meta") {
+    if (tag.props.charset)
+      return -2;
+    if (tag.props["http-equiv"] === "content-security-policy")
+      return 0;
   }
-  return props;
-}
-
-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());
+  const key = tag.tagPriority || tag.tag;
+  if (key in TAG_WEIGHTS) {
+    return TAG_WEIGHTS[key];
   }
-  return unpacked;
+  return 10;
 }
-
-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: {
-      keyValueSeparator: ":"
-    }
-  },
-  // Pragma directives
-  contentSecurityPolicy: {
-    unpack: {
-      keyValueSeparator: " ",
-      entrySeparator: "; "
-    },
-    metaKey: "http-equiv"
-  },
-  fbAppId: {
-    keyValue: "fb:app_id",
-    metaKey: "property"
-  },
-  msapplicationTileImage: {
-    keyValue: "msapplication-TileImage"
-  },
-  /**
-   * Tile colour for windows
-   */
-  msapplicationTileColor: {
-    keyValue: "msapplication-TileColor"
-  },
-  /**
-   * URL of a config for windows tile.
-   */
-  msapplicationConfig: {
-    keyValue: "msapplication-Config"
-  },
-  charset: {
-    metaKey: "charset"
-  },
-  contentType: {
-    metaKey: "http-equiv"
-  },
-  defaultStyle: {
-    metaKey: "http-equiv"
-  },
-  xUaCompatible: {
-    metaKey: "http-equiv"
-  },
-  refresh: {
-    metaKey: "http-equiv"
-  }
-};
-function resolveMetaKeyType(key) {
-  return PropertyPrefixKeys.test(key) ? "property" : MetaPackingSchema[key]?.metaKey || "name";
-}
-
-const ArrayableInputs = ["Image", "Video", "Audio"];
-function unpackMeta(input) {
-  const extras = [];
-  ArrayableInputs.forEach((key) => {
-    const ogKey = `og:${key.toLowerCase()}`;
-    const inputKey = `og${key}`;
-    const val = input[inputKey];
-    if (typeof val === "object") {
-      (Array.isArray(val) ? val : [val]).forEach((entry) => {
-        if (!entry)
-          return;
-        const unpackedEntry = unpackToArray(entry, {
-          key: "property",
-          value: "content",
-          resolveKeyData({ key: key2 }) {
-            return fixKeyCase(`${ogKey}${key2 !== "url" ? `:${key2}` : ""}`);
-          },
-          resolveValueData({ value }) {
-            return typeof value === "number" ? value.toString() : value;
-          }
-        });
-        extras.push(
-          ...unpackedEntry.sort((a, b) => a.property === ogKey ? -1 : b.property === ogKey ? 1 : 0)
-        );
-      });
-      delete input[inputKey];
-    }
-  });
-  const meta = unpackToArray(input, {
-    key({ key }) {
-      return resolveMetaKeyType(key);
-    },
-    value({ key }) {
-      return key === "charset" ? "charset" : "content";
-    },
-    resolveKeyData({ key }) {
-      return MetaPackingSchema[key]?.keyValue || fixKeyCase(key);
-    },
-    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
+const SortModifiers = [{ prefix: "before:", offset: -1 }, { prefix: "after:", offset: 1 }];
+function SortTagsPlugin() {
+  return shared.defineHeadPlugin({
+    hooks: {
+      "tags:resolve": (ctx) => {
+        const tagPositionForKey = (key) => ctx.tags.find((tag) => tag._d === key)?._p;
+        for (const { prefix, offset } of SortModifiers) {
+          for (const tag of ctx.tags.filter((tag2) => typeof tag2.tagPriority === "string" && tag2.tagPriority.startsWith(prefix))) {
+            const position = tagPositionForKey(
+              tag.tagPriority.replace(prefix, "")
+            );
+            if (typeof position !== "undefined")
+              tag._p = position + offset;
           }
-        );
+        }
+        ctx.tags.sort((a, b) => a._p - b._p).sort((a, b) => tagWeight(a) - tagWeight(b));
       }
-      return typeof value === "number" ? value.toString() : value;
     }
   });
-  return [...extras, ...meta].filter((v) => typeof v.content === "undefined" || v.content !== "_null");
-}
-
-const PropertyPrefixKeys = /^(og|fb)/;
-const ColonPrefixKeys = /^(og|twitter|fb)/;
-function fixKeyCase(key) {
-  key = key.replace(/([A-Z])/g, "-$1").toLowerCase();
-  if (ColonPrefixKeys.test(key)) {
-    key = key.replace("secure-url", "secure_url").replace(/-/g, ":");
-  }
-  return key;
-}
-function changeKeyCasingDeep(input) {
-  if (Array.isArray(input)) {
-    return input.map((entry) => changeKeyCasingDeep(entry));
-  }
-  if (typeof input !== "object" || Array.isArray(input))
-    return input;
-  const output = {};
-  for (const [key, value] of Object.entries(input))
-    output[fixKeyCase(key)] = changeKeyCasingDeep(value);
-  return output;
-}
-
-const tagWeight = (tag) => {
-  if (typeof tag.tagPriority === "number")
-    return tag.tagPriority;
-  switch (tag.tagPriority) {
-    case "critical":
-      return 2;
-    case "high":
-      return 9;
-    case "low":
-      return 12;
-  }
-  switch (tag.tag) {
-    case "base":
-      return -1;
-    case "title":
-      return 1;
-    case "meta":
-      if (tag.props.charset)
-        return -2;
-      if (tag.props["http-equiv"] === "content-security-policy")
-        return 0;
-      return 10;
-    default:
-      return 10;
-  }
-};
-const sortTags = (aTag, bTag) => {
-  return tagWeight(aTag) - tagWeight(bTag);
-};
-
-const UniqueTags = ["base", "title", "titleTemplate", "bodyAttrs", "htmlAttrs"];
-function tagDedupeKey(tag, fn) {
-  const { props, tag: tagName } = tag;
-  if (UniqueTags.includes(tagName))
-    return tagName;
-  if (tagName === "link" && props.rel === "canonical")
-    return "canonical";
-  if (props.charset)
-    return "charset";
-  const name = ["id"];
-  if (tagName === "meta")
-    name.push(...["name", "property", "http-equiv"]);
-  for (const n of name) {
-    if (typeof props[n] !== "undefined") {
-      const val = String(props[n]);
-      if (fn && !fn(val))
-        return false;
-      return `${tagName}:${n}:${val}`;
-    }
-  }
-  return false;
 }
 
 const renderTitleTemplate = (template, title) => {
@@ -305,127 +58,44 @@ const renderTitleTemplate = (template, title) => {
     return template(title);
   return template.replace("%s", title ?? "");
 };
-function resolveTitleTemplateFromTags(tags) {
-  let titleTemplateIdx = tags.findIndex((i) => i.tag === "titleTemplate");
-  const titleIdx = tags.findIndex((i) => i.tag === "title");
-  if (titleIdx !== -1 && titleTemplateIdx !== -1) {
-    const newTitle = renderTitleTemplate(
-      tags[titleTemplateIdx].children,
-      tags[titleIdx].children
-    );
-    if (newTitle !== null) {
-      tags[titleIdx].children = newTitle || tags[titleIdx].children;
-    } else {
-      delete tags[titleIdx];
-    }
-  } else if (titleTemplateIdx !== -1) {
-    const newTitle = renderTitleTemplate(
-      tags[titleTemplateIdx].children
-    );
-    if (newTitle !== null) {
-      tags[titleTemplateIdx].children = newTitle;
-      tags[titleTemplateIdx].tag = "title";
-      titleTemplateIdx = -1;
-    }
-  }
-  if (titleTemplateIdx !== -1) {
-    delete tags[titleTemplateIdx];
-  }
-  return tags.filter(Boolean);
-}
-
-const DedupesTagsPlugin = (options) => {
-  options = options || {};
-  const dedupeKeys = options.dedupeKeys || ["hid", "vmid", "key"];
-  return 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}` : tagDedupeKey(tag);
-        if (dedupe)
-          tag._d = dedupe;
-      },
-      "tags:resolve": function(ctx) {
-        const deduping = {};
-        ctx.tags.forEach((tag) => {
-          let dedupeKey = tag._d || tag._p;
-          const dupedTag = deduping[dedupeKey];
-          if (dupedTag) {
-            let strategy = tag?.tagDuplicateStrategy;
-            if (!strategy && (tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs"))
-              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) {
-              dedupeKey = tag._d = `${dedupeKey}:${tag._p}`;
-            }
-            const propCount = Object.keys(tag.props).length;
-            if ((propCount === 0 || propCount === 1 && typeof tag.props["data-h-key"] !== "undefined") && !tag.children) {
-              delete deduping[dedupeKey];
-              return;
-            }
-          }
-          deduping[dedupeKey] = tag;
-        });
-        ctx.tags = Object.values(deduping);
-      }
-    }
-  });
-};
-
-const SortTagsPlugin = () => {
-  return defineHeadPlugin({
+const TitleTemplatePlugin = () => {
+  return shared.defineHeadPlugin({
     hooks: {
       "tags:resolve": (ctx) => {
-        const tagIndexForKey = (key) => ctx.tags.find((tag) => tag._d === key)?._p;
-        for (const tag of ctx.tags) {
-          if (!tag.tagPriority || typeof tag.tagPriority === "number")
-            continue;
-          const modifiers = [{ prefix: "before:", offset: -1 }, { prefix: "after:", offset: 1 }];
-          for (const { prefix, offset } of modifiers) {
-            if (tag.tagPriority.startsWith(prefix)) {
-              const key = tag.tagPriority.replace(prefix, "");
-              const index = tagIndexForKey(key);
-              if (typeof index !== "undefined")
-                tag._p = index + offset;
-            }
+        const { tags } = ctx;
+        let titleTemplateIdx = tags.findIndex((i) => i.tag === "titleTemplate");
+        const titleIdx = tags.findIndex((i) => i.tag === "title");
+        if (titleIdx !== -1 && titleTemplateIdx !== -1) {
+          const newTitle = renderTitleTemplate(
+            tags[titleTemplateIdx].textContent,
+            tags[titleIdx].textContent
+          );
+          if (newTitle !== null) {
+            tags[titleIdx].textContent = newTitle || tags[titleIdx].textContent;
+          } else {
+            delete tags[titleIdx];
+          }
+        } else if (titleTemplateIdx !== -1) {
+          const newTitle = renderTitleTemplate(
+            tags[titleTemplateIdx].textContent
+          );
+          if (newTitle !== null) {
+            tags[titleTemplateIdx].textContent = newTitle;
+            tags[titleTemplateIdx].tag = "title";
+            titleTemplateIdx = -1;
           }
         }
-        ctx.tags.sort((a, b) => a._p - b._p).sort(sortTags);
-      }
-    }
-  });
-};
-
-const TitleTemplatePlugin = () => {
-  return defineHeadPlugin({
-    hooks: {
-      "tags:resolve": (ctx) => {
-        ctx.tags = resolveTitleTemplateFromTags(ctx.tags);
+        if (titleTemplateIdx !== -1) {
+          delete tags[titleTemplateIdx];
+        }
+        ctx.tags = tags.filter(Boolean);
       }
     }
   });
 };
 
 const DeprecatedTagAttrPlugin = () => {
-  return defineHeadPlugin({
+  return shared.defineHeadPlugin({
     hooks: {
       "tag:normalise": function({ tag }) {
         if (typeof tag.props.body !== "undefined") {
@@ -440,18 +110,21 @@ const DeprecatedTagAttrPlugin = () => {
 const IsBrowser = typeof window !== "undefined";
 
 const ProvideTagHashPlugin = () => {
-  return defineHeadPlugin({
+  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 (!HasElementTags.includes(tag.tag) || !tag.key)
+        if (!shared.HasElementTags.includes(tag.tag) || !tag.key)
           return;
-        tag._hash = dom.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) => {
@@ -464,23 +137,7 @@ const ProvideTagHashPlugin = () => {
   });
 };
 
-const PatchDomOnEntryUpdatesPlugin = (options) => {
-  return defineHeadPlugin({
-    hooks: {
-      "entries:updated": function(head) {
-        if (typeof options?.document === "undefined" && typeof window === "undefined")
-          return;
-        let delayFn = options?.delayFn;
-        if (!delayFn && typeof requestAnimationFrame !== "undefined")
-          delayFn = requestAnimationFrame;
-        import('@unhead/dom').then(({ debouncedRenderDOMHead }) => {
-          debouncedRenderDOMHead(head, { document: options?.document || window.document, delayFn });
-        });
-      }
-    }
-  });
-};
-
+const ValidEventTags = ["script", "link", "bodyAttrs"];
 const EventHandlersPlugin = () => {
   const stripEventHandlers = (mode, tag) => {
     const props = {};
@@ -496,65 +153,175 @@ const EventHandlersPlugin = () => {
       delayedSrc = props.src;
       delete props.src;
     }
-    return { props, eventHandlers, delayedSrc };
+    return { props, eventHandlers, delayedSrc };
+  };
+  return shared.defineHeadPlugin({
+    hooks: {
+      "ssr:render": function(ctx) {
+        ctx.tags = ctx.tags.map((tag) => {
+          if (!ValidEventTags.includes(tag.tag))
+            return tag;
+          if (!Object.entries(tag.props).find(([key, value]) => key.startsWith("on") && typeof value === "function"))
+            return tag;
+          tag.props = stripEventHandlers("ssr", tag).props;
+          return tag;
+        });
+      },
+      "dom:beforeRenderTag": function(ctx) {
+        if (!ValidEventTags.includes(ctx.tag.tag))
+          return;
+        if (!Object.entries(ctx.tag.props).find(([key, value]) => key.startsWith("on") && typeof value === "function"))
+          return;
+        const { props, eventHandlers, delayedSrc } = stripEventHandlers("dom", ctx.tag);
+        if (!Object.keys(eventHandlers).length)
+          return;
+        ctx.tag.props = props;
+        ctx.tag._eventHandlers = eventHandlers;
+        ctx.tag._delayedSrc = delayedSrc;
+      },
+      "dom:renderTag": function(ctx) {
+        const $el = ctx.$el;
+        if (!ctx.tag._eventHandlers || !$el)
+          return;
+        const $eventListenerTarget = ctx.tag.tag === "bodyAttrs" && typeof window !== "undefined" ? window : $el;
+        Object.entries(ctx.tag._eventHandlers).forEach(([k, value]) => {
+          const sdeKey = `${ctx.tag._d || ctx.tag._p}:${k}`;
+          const eventName = k.slice(2).toLowerCase();
+          const eventDedupeKey = `data-h-${eventName}`;
+          ctx.markSideEffect(sdeKey, () => {
+          });
+          if ($el.hasAttribute(eventDedupeKey))
+            return;
+          const handler = value;
+          $el.setAttribute(eventDedupeKey, "");
+          $eventListenerTarget.addEventListener(eventName, handler);
+          if (ctx.entry) {
+            ctx.entry._sde[sdeKey] = () => {
+              $eventListenerTarget.removeEventListener(eventName, handler);
+              $el.removeAttribute(eventDedupeKey);
+            };
+          }
+        });
+        if (ctx.tag._delayedSrc) {
+          $el.setAttribute("src", ctx.tag._delayedSrc);
+        }
+      }
+    }
+  });
+};
+
+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 : "");
   };
-  return defineHeadPlugin({
+  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: {
-      "ssr:render": function(ctx) {
-        ctx.tags = ctx.tags.map((tag) => {
-          tag.props = stripEventHandlers("ssr", tag).props;
-          return tag;
-        });
-      },
-      "dom:beforeRenderTag": function(ctx) {
-        const { props, eventHandlers, delayedSrc } = stripEventHandlers("dom", ctx.tag);
-        if (!Object.keys(eventHandlers).length)
-          return;
-        ctx.tag.props = props;
-        ctx.tag._eventHandlers = eventHandlers;
-        ctx.tag._delayedSrc = delayedSrc;
-      },
-      "dom:renderTag": function(ctx) {
-        const $el = ctx.$el;
-        if (!ctx.tag._eventHandlers || !$el)
-          return;
-        const $eventListenerTarget = ctx.tag.tag === "bodyAttrs" && typeof window !== "undefined" ? window : $el;
-        Object.entries(ctx.tag._eventHandlers).forEach(([k, value]) => {
-          const sdeKey = `${ctx.tag._d || ctx.tag._p}:${k}`;
-          const eventName = k.slice(2).toLowerCase();
-          const eventDedupeKey = `data-h-${eventName}`;
-          delete ctx.staleSideEffects[sdeKey];
-          if ($el.hasAttribute(eventDedupeKey))
-            return;
-          const handler = value;
-          $el.setAttribute(eventDedupeKey, "");
-          $eventListenerTarget.addEventListener(eventName, handler);
-          if (ctx.entry) {
-            ctx.entry._sde[sdeKey] = () => {
-              $eventListenerTarget.removeEventListener(eventName, handler);
-              $el.removeAttribute(eventDedupeKey);
-            };
+      "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);
+            }
           }
-        });
-        if (ctx.tag._delayedSrc) {
-          $el.setAttribute("src", ctx.tag._delayedSrc);
         }
+        ctx.tags = tags.filter(Boolean);
       }
     }
   });
-};
-
-function asArray(value) {
-  return Array.isArray(value) ? value : [value];
 }
-const HasElementTags = [
-  "base",
-  "meta",
-  "link",
-  "style",
-  "script",
-  "noscript"
-];
 
 exports.activeHead = void 0;
 const setActiveHead = (head) => exports.activeHead = head;
@@ -569,57 +336,404 @@ 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: asArray(meta) });
+const useTagMeta = (meta) => useHead({ meta: shared.asArray(meta) });
 const useTagMetaFlat = (meta) => useTagMeta(unpackMeta(meta));
-const useTagLink = (link) => useHead({ link: asArray(link) });
-const useTagScript = (script) => useHead({ script: asArray(script) });
-const useTagStyle = (style) => useHead({ style: asArray(style) });
-const useTagNoscript = (noscript) => useHead({ noscript: asArray(noscript) });
+const useTagLink = (link) => useHead({ link: shared.asArray(link) });
+const useTagScript = (script) => useHead({ script: shared.asArray(script) });
+const useTagStyle = (style) => useHead({ style: shared.asArray(style) });
+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: asArray(meta) });
+const useServerTagMeta = (meta) => useServerHead({ meta: shared.asArray(meta) });
 const useServerTagMetaFlat = (meta) => useServerTagMeta(unpackMeta(meta));
-const useServerTagLink = (link) => useServerHead({ link: asArray(link) });
-const useServerTagScript = (script) => useServerHead({ script: asArray(script) });
-const useServerTagStyle = (style) => useServerHead({ style: asArray(style) });
-const useServerTagNoscript = (noscript) => useServerHead({ noscript: asArray(noscript) });
+const useServerTagLink = (link) => useServerHead({ link: shared.asArray(link) });
+const useServerTagScript = (script) => useServerHead({ script: shared.asArray(script) });
+const useServerTagStyle = (style) => useServerHead({ style: shared.asArray(style) });
+const useServerTagNoscript = (noscript) => useServerHead({ noscript: shared.asArray(noscript) });
 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)
-  });
+const MetaPackingSchema = {
+  robots: {
+    unpack: {
+      keyValueSeparator: ":"
+    }
+  },
+  // Pragma directives
+  contentSecurityPolicy: {
+    unpack: {
+      keyValueSeparator: " ",
+      entrySeparator: "; "
+    },
+    metaKey: "http-equiv"
+  },
+  fbAppId: {
+    keyValue: "fb:app_id",
+    metaKey: "property"
+  },
+  msapplicationTileImage: {
+    keyValue: "msapplication-TileImage"
+  },
+  /**
+   * Tile colour for windows
+   */
+  msapplicationTileColor: {
+    keyValue: "msapplication-TileColor"
+  },
+  /**
+   * URL of a config for windows tile.
+   */
+  msapplicationConfig: {
+    keyValue: "msapplication-Config"
+  },
+  charset: {
+    metaKey: "charset"
+  },
+  contentType: {
+    metaKey: "http-equiv"
+  },
+  defaultStyle: {
+    metaKey: "http-equiv"
+  },
+  xUaCompatible: {
+    metaKey: "http-equiv"
+  },
+  refresh: {
+    metaKey: "http-equiv"
+  }
 };
+function resolveMetaKeyType(key) {
+  return PropertyPrefixKeys.test(key) ? "property" : MetaPackingSchema[key]?.metaKey || "name";
+}
 
-const TagEntityBits = 10;
+function packMeta(inputs) {
+  const mappedPackingSchema = Object.entries(MetaPackingSchema).map(([key, value]) => [key, value.keyValue]);
+  return packrup.packArray(inputs, {
+    key: ["name", "property", "httpEquiv", "http-equiv", "charset"],
+    value: ["content", "charset"],
+    resolveKey(k) {
+      let key = mappedPackingSchema.filter((sk) => sk[1] === k)?.[0]?.[0] || k;
+      const replacer = (_, letter) => letter?.toUpperCase();
+      key = key.replace(/:([a-z])/g, replacer).replace(/-([a-z])/g, replacer);
+      return key;
+    }
+  });
+}
+
+const ArrayableInputs = ["Image", "Video", "Audio"];
+function unpackMeta(input) {
+  const extras = [];
+  ArrayableInputs.forEach((key) => {
+    const ogKey = `og:${key.toLowerCase()}`;
+    const inputKey = `og${key}`;
+    const val = input[inputKey];
+    if (typeof val === "object") {
+      (Array.isArray(val) ? val : [val]).forEach((entry) => {
+        if (!entry)
+          return;
+        const unpackedEntry = packrup.unpackToArray(entry, {
+          key: "property",
+          value: "content",
+          resolveKeyData({ key: key2 }) {
+            return fixKeyCase(`${ogKey}${key2 !== "url" ? `:${key2}` : ""}`);
+          },
+          resolveValueData({ value }) {
+            return typeof value === "number" ? value.toString() : value;
+          }
+        });
+        extras.push(
+          ...unpackedEntry.sort((a, b) => a.property === ogKey ? -1 : b.property === ogKey ? 1 : 0)
+        );
+      });
+      delete input[inputKey];
+    }
+  });
+  const meta = packrup.unpackToArray(input, {
+    key({ key }) {
+      return resolveMetaKeyType(key);
+    },
+    value({ key }) {
+      return key === "charset" ? "charset" : "content";
+    },
+    resolveKeyData({ key }) {
+      return MetaPackingSchema[key]?.keyValue || fixKeyCase(key);
+    },
+    resolveValueData({ value, key }) {
+      if (value === null)
+        return "_null";
+      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 (["title", "titleTemplate", "templateParams"].includes(tagName)) {
+    tag.textContent = input instanceof Promise ? await input : input;
+    return tag;
+  }
+  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) => {
+    if (!["innerHTML", "textContent"].includes(k) || shared.TagsWithInnerContent.includes(tag.tag)) {
+      tag[k] = tag.props[k];
+    }
+    delete tag.props[k];
+  });
+  ["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;
+}
+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] = isDataKey ? "true" : "";
+    } else if (String(props[k]) === "false") {
+      if (isDataKey) {
+        props[k] = "false";
+      } else {
+        delete props[k];
+      }
+    }
+  }
+  return props;
+}
+const TagEntityBits = 10;
 async function normaliseEntryTags(e) {
   const tagPromises = [];
-  Object.entries(e.resolvedInput || e.input).filter(([k, v]) => typeof v !== "undefined" && ValidHeadTags.includes(k)).forEach(([k, value]) => {
-    const v = asArray(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;
   });
 }
 
+const PropertyPrefixKeys = /^(og|fb)/;
+const ColonPrefixKeys = /^(og|twitter|fb)/;
+function fixKeyCase(key) {
+  key = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+  if (ColonPrefixKeys.test(key)) {
+    key = key.replace("secure-url", "secure_url").replace(/-/g, ":");
+  }
+  return key;
+}
+function changeKeyCasingDeep(input) {
+  if (Array.isArray(input)) {
+    return input.map((entry) => changeKeyCasingDeep(entry));
+  }
+  if (typeof input !== "object" || Array.isArray(input))
+    return input;
+  const output = {};
+  for (const [key, value] of Object.entries(input))
+    output[fixKeyCase(key)] = changeKeyCasingDeep(value);
+  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
   DedupesTagsPlugin(),
@@ -627,16 +741,19 @@ const CorePlugins = () => [
   TitleTemplatePlugin(),
   ProvideTagHashPlugin(),
   EventHandlersPlugin(),
-  DeprecatedTagAttrPlugin()
+  DeprecatedTagAttrPlugin(),
+  TemplateParamsPlugin()
 ];
 const DOMPlugins = (options = {}) => [
-  PatchDomOnEntryUpdatesPlugin({ document: options?.document, delayFn: options?.domDelayFn })
+  dom.PatchDomOnEntryUpdatesPlugin({ document: options?.document, delayFn: options?.domDelayFn })
 ];
 function createHead(options = {}) {
   const head = createHeadCore({
     ...options,
     plugins: [...DOMPlugins(options), ...options?.plugins || []]
   });
+  if (options.experimentalHashHydration && head.resolvedOptions.document)
+    head._hash = dom.maybeGetSSRHash(head.resolvedOptions.document);
   setActiveHead(head);
   return head;
 }
@@ -652,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,
@@ -673,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 {
@@ -702,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);
         }
@@ -711,32 +834,32 @@ 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;
 }
 
-function defineHeadPlugin(plugin) {
-  return plugin;
-}
-
 const coreComposableNames = [
   "getActiveHead"
 ];
 const composableNames = [
   "useHead",
+  "useSeoMeta",
+  "useHeadSafe",
+  "useServerHead",
+  "useServerSeoMeta",
+  "useServerHeadSafe",
+  // deprecated
   "useTagTitle",
   "useTagBase",
   "useTagMeta",
   "useTagMetaFlat",
-  // alias
-  "useSeoMeta",
   "useTagLink",
   "useTagScript",
   "useTagStyle",
@@ -744,8 +867,6 @@ const composableNames = [
   "useHtmlAttrs",
   "useBodyAttrs",
   "useTitleTemplate",
-  // server only composables
-  "useServerHead",
   "useServerTagTitle",
   "useServerTagBase",
   "useServerTagMeta",
@@ -765,32 +886,49 @@ const unheadComposablesImports = [
   }
 ];
 
+exports.ColonPrefixKeys = ColonPrefixKeys;
 exports.CorePlugins = CorePlugins;
 exports.DOMPlugins = DOMPlugins;
 exports.DedupesTagsPlugin = DedupesTagsPlugin;
 exports.DeprecatedTagAttrPlugin = DeprecatedTagAttrPlugin;
 exports.EventHandlersPlugin = EventHandlersPlugin;
-exports.HasElementTags = HasElementTags;
-exports.PatchDomOnEntryUpdatesPlugin = PatchDomOnEntryUpdatesPlugin;
+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.asArray = asArray;
+exports.changeKeyCasingDeep = changeKeyCasingDeep;
 exports.composableNames = composableNames;
 exports.createHead = createHead;
 exports.createHeadCore = createHeadCore;
-exports.defineHeadPlugin = defineHeadPlugin;
+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;
@@ -809,3 +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];
+});