unhead 1.0.21 → 1.0.22

package/dist/index.cjs

@@ -1,68 +1,313 @@
 'use strict';
 
 const hookable = require('hookable');
+const shared = require('@unhead/shared');
 const dom = require('@unhead/dom');
 
-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;
+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;
   }
-  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];
+  const key = tag.tagPriority || tag.tag;
+  if (key in TAG_WEIGHTS) {
+    return TAG_WEIGHTS[key];
+  }
+  return 10;
+}
+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));
+      }
     }
   });
-  Object.keys(tag.props).filter((k) => TagConfigKeys.includes(k)).forEach((k) => {
-    tag[k] = tag.props[k];
-    delete tag.props[k];
+}
+
+const renderTitleTemplate = (template, title) => {
+  if (template == null)
+    return title || null;
+  if (typeof template === "function")
+    return template(title);
+  return template.replace("%s", title ?? "");
+};
+const TitleTemplatePlugin = () => {
+  return shared.defineHeadPlugin({
+    hooks: {
+      "tags:resolve": (ctx) => {
+        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].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];
+        }
+        ctx.tags = tags.filter(Boolean);
+      }
+    }
   });
-  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;
+};
+
+const DeprecatedTagAttrPlugin = () => {
+  return shared.defineHeadPlugin({
+    hooks: {
+      "tag:normalise": function({ tag }) {
+        if (typeof tag.props.body !== "undefined") {
+          tag.tagPosition = "bodyClose";
+          delete tag.props.body;
+        }
+      }
+    }
+  });
+};
+
+const IsBrowser = typeof window !== "undefined";
+
+const ProvideTagHashPlugin = () => {
+  return shared.defineHeadPlugin({
+    hooks: {
+      "tag:normalise": (ctx) => {
+        const { tag, entry } = ctx;
+        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}`] = "";
+        }
+      },
+      "tags:resolve": (ctx) => {
+        ctx.tags = ctx.tags.map((t) => {
+          delete t.props._dynamic;
+          return t;
+        });
+      }
+    }
+  });
+};
+
+const ValidEventTags = ["script", "link", "bodyAttrs"];
+const EventHandlersPlugin = () => {
+  const stripEventHandlers = (mode, tag) => {
+    const props = {};
+    const eventHandlers = {};
+    Object.entries(tag.props).forEach(([key, value]) => {
+      if (key.startsWith("on") && typeof value === "function")
+        eventHandlers[key] = value;
+      else
+        props[key] = value;
     });
+    let delayedSrc;
+    if (mode === "dom" && tag.tag === "script" && typeof props.src === "string" && typeof eventHandlers.onload !== "undefined") {
+      delayedSrc = props.src;
+      delete props.src;
+    }
+    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}`;
+          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);
+            };
+          }
+        });
+        if (ctx.tag._delayedSrc) {
+          $el.setAttribute("src", ctx.tag._delayedSrc);
+        }
+      }
+    }
+  });
+};
+
+exports.activeHead = void 0;
+const setActiveHead = (head) => exports.activeHead = head;
+const getActiveHead = () => exports.activeHead;
+
+function useHead(input, options = {}) {
+  const head = getActiveHead();
+  if (head) {
+    const isBrowser = IsBrowser || head.resolvedOptions?.document;
+    if (options.mode === "server" && isBrowser || options.mode === "client" && !isBrowser)
+      return;
+    return head.push(input, options);
   }
-  return tag;
 }
-async function normaliseProps(props) {
-  for (const k of Object.keys(props)) {
-    if (props[k] instanceof Promise) {
-      props[k] = await props[k];
+const useTagTitle = (title) => useHead({ title });
+const useTagBase = (base) => useHead({ base });
+const useTagMeta = (meta) => useHead({ meta: shared.asArray(meta) });
+const useTagMetaFlat = (meta) => useTagMeta(unpackMeta(meta));
+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: shared.asArray(meta) });
+const useServerTagMetaFlat = (meta) => useServerTagMeta(unpackMeta(meta));
+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)
+  });
+};
+
+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;
     }
-    if (String(props[k]) === "true") {
-      props[k] = "";
-    } else if (String(props[k]) === "false") {
-      delete props[k];
+    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 props;
+  return packed;
 }
 
 function unpackToArray(input, options) {
@@ -158,6 +403,20 @@ function resolveMetaKeyType(key) {
   return PropertyPrefixKeys.test(key) ? "property" : MetaPackingSchema[key]?.metaKey || "name";
 }
 
+function packMeta(inputs) {
+  const mappedPackingSchema = Object.entries(MetaPackingSchema).map(([key, value]) => [key, value.keyValue]);
+  return 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 = [];
@@ -224,393 +483,58 @@ function unpackMeta(input) {
   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) => {
-  if (template == null)
-    return title || null;
-  if (typeof template === "function")
-    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];
+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;
   }
-  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({
-    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;
-            }
-          }
-        }
-        ctx.tags.sort((a, b) => a._p - b._p).sort(sortTags);
-      }
-    }
-  });
-};
-
-const TitleTemplatePlugin = () => {
-  return defineHeadPlugin({
-    hooks: {
-      "tags:resolve": (ctx) => {
-        ctx.tags = resolveTitleTemplateFromTags(ctx.tags);
-      }
-    }
-  });
-};
-
-const DeprecatedTagAttrPlugin = () => {
-  return defineHeadPlugin({
-    hooks: {
-      "tag:normalise": function({ tag }) {
-        if (typeof tag.props.body !== "undefined") {
-          tag.tagPosition = "bodyClose";
-          delete tag.props.body;
-        }
-      }
-    }
-  });
-};
-
-const IsBrowser = typeof window !== "undefined";
-
-const ProvideTagHashPlugin = () => {
-  return defineHeadPlugin({
-    hooks: {
-      "tag:normalise": (ctx) => {
-        const { tag, entry } = ctx;
-        const isDynamic = typeof tag.props._dynamic !== "undefined";
-        if (!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}`] = "";
-        }
-      },
-      "tags:resolve": (ctx) => {
-        ctx.tags = ctx.tags.map((t) => {
-          delete t.props._dynamic;
-          return t;
-        });
-      }
+  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];
     }
   });
-};
-
-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 });
-        });
-      }
-    }
+  Object.keys(tag.props).filter((k) => shared.TagConfigKeys.includes(k)).forEach((k) => {
+    tag[k] = tag.props[k];
+    delete tag.props[k];
   });
-};
-
-const EventHandlersPlugin = () => {
-  const stripEventHandlers = (mode, tag) => {
-    const props = {};
-    const eventHandlers = {};
-    Object.entries(tag.props).forEach(([key, value]) => {
-      if (key.startsWith("on") && typeof value === "function")
-        eventHandlers[key] = value;
-      else
-        props[key] = value;
+  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;
     });
-    let delayedSrc;
-    if (mode === "dom" && tag.tag === "script" && typeof props.src === "string" && typeof eventHandlers.onload !== "undefined") {
-      delayedSrc = props.src;
-      delete props.src;
+  }
+  return tag;
+}
+async function normaliseProps(props) {
+  for (const k of Object.keys(props)) {
+    if (props[k] instanceof Promise) {
+      props[k] = await props[k];
     }
-    return { props, eventHandlers, delayedSrc };
-  };
-  return 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);
-            };
-          }
-        });
-        if (ctx.tag._delayedSrc) {
-          $el.setAttribute("src", ctx.tag._delayedSrc);
-        }
-      }
+    if (String(props[k]) === "true") {
+      props[k] = "";
+    } else if (String(props[k]) === "false") {
+      delete props[k];
     }
-  });
-};
-
-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;
-const getActiveHead = () => exports.activeHead;
-
-function useHead(input, options = {}) {
-  const head = getActiveHead();
-  if (head) {
-    const isBrowser = IsBrowser || head.resolvedOptions?.document;
-    if (options.mode === "server" && isBrowser || options.mode === "client" && !isBrowser)
-      return;
-    return head.push(input, options);
   }
+  return props;
 }
-const useTagTitle = (title) => useHead({ title });
-const useTagBase = (base) => useHead({ base });
-const useTagMeta = (meta) => useHead({ meta: 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 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 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 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 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 || e.input).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) => {
@@ -620,9 +544,30 @@ async function normaliseEntryTags(e) {
   });
 }
 
+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 CorePlugins = () => [
   // dedupe needs to come first
-  DedupesTagsPlugin(),
+  shared.DedupesTagsPlugin(),
   SortTagsPlugin(),
   TitleTemplatePlugin(),
   ProvideTagHashPlugin(),
@@ -630,7 +575,7 @@ const CorePlugins = () => [
   DeprecatedTagAttrPlugin()
 ];
 const DOMPlugins = (options = {}) => [
-  PatchDomOnEntryUpdatesPlugin({ document: options?.document, delayFn: options?.domDelayFn })
+  dom.PatchDomOnEntryUpdatesPlugin({ document: options?.document, delayFn: options?.domDelayFn })
 ];
 function createHead(options = {}) {
   const head = createHeadCore({
@@ -722,10 +667,6 @@ function createHeadCore(options = {}) {
   return head;
 }
 
-function defineHeadPlugin(plugin) {
-  return plugin;
-}
-
 const coreComposableNames = [
   "getActiveHead"
 ];
@@ -765,25 +706,33 @@ 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.PropertyPrefixKeys = PropertyPrefixKeys;
 exports.ProvideTagHashPlugin = ProvideTagHashPlugin;
+exports.SortModifiers = SortModifiers;
 exports.SortTagsPlugin = SortTagsPlugin;
+exports.TAG_WEIGHTS = TAG_WEIGHTS;
+exports.TagEntityBits = TagEntityBits;
 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.normaliseEntryTags = normaliseEntryTags;
+exports.normaliseProps = normaliseProps;
+exports.normaliseTag = normaliseTag;
+exports.packMeta = packMeta;
+exports.renderTitleTemplate = renderTitleTemplate;
 exports.setActiveHead = setActiveHead;
+exports.tagWeight = tagWeight;
 exports.unheadComposablesImports = unheadComposablesImports;
+exports.unpackMeta = unpackMeta;
 exports.useBodyAttrs = useBodyAttrs;
 exports.useHead = useHead;
 exports.useHtmlAttrs = useHtmlAttrs;
@@ -809,3 +758,6 @@ exports.useTagScript = useTagScript;
 exports.useTagStyle = useTagStyle;
 exports.useTagTitle = useTagTitle;
 exports.useTitleTemplate = useTitleTemplate;
+Object.keys(shared).forEach(function (k) {
+  if (k !== 'default' && !exports.hasOwnProperty(k)) exports[k] = shared[k];
+});