@unhead/shared 1.2.2 → 1.3.0-beta.0

package/dist/index.cjs

@@ -1,6 +1,6 @@
 'use strict';
 
-function asArray(value) {
+function asArray$1(value) {
   return Array.isArray(value) ? value : [value];
 }
 
@@ -29,7 +29,16 @@ const ValidHeadTags = [
 ];
 const UniqueTags = ["base", "title", "titleTemplate", "bodyAttrs", "htmlAttrs", "templateParams"];
 const TagConfigKeys = ["tagPosition", "tagPriority", "tagDuplicateStrategy", "innerHTML", "textContent"];
-const EntryConfigKeys = ["tagPosition", "tagPriority"];
+const IsBrowser = typeof window !== "undefined";
+const composableNames = [
+  "getActiveHead",
+  "useHead",
+  "useSeoMeta",
+  "useHeadSafe",
+  "useServerHead",
+  "useServerSeoMeta",
+  "useServerHeadSafe"
+];
 
 function defineHeadPlugin(plugin) {
   return plugin;
@@ -42,15 +51,7 @@ function hashCode(s) {
   return ((h ^ h >>> 9) + 65536).toString(16).substring(1, 8).toLowerCase();
 }
 function hashTag(tag) {
-  return hashCode(`${tag.tag}:${tag.textContent || tag.innerHTML || ""}:${Object.entries(tag.props).map(([key, value]) => `${key}:${String(value)}`).join(",")}`);
-}
-function computeHashes(hashes) {
-  let h = 9;
-  for (const s of hashes) {
-    for (let i = 0; i < s.length; )
-      h = Math.imul(h ^ s.charCodeAt(i++), 9 ** 9);
-  }
-  return ((h ^ h >>> 9) + 65536).toString(16).substring(1, 8).toLowerCase();
+  return tag._h || hashCode(tag._d ? tag._d : `${tag.tag}:${tag.textContent || tag.innerHTML || ""}:${Object.entries(tag.props).map(([key, value]) => `${key}:${String(value)}`).join(",")}`);
 }
 
 function tagDedupeKey(tag, fn) {
@@ -83,17 +84,570 @@ function resolveTitleTemplate(template, title) {
   return template;
 }
 
-exports.EntryConfigKeys = EntryConfigKeys;
+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: {
+      keyValueSeparator: ":"
+    }
+  },
+  // Pragma directives
+  contentSecurityPolicy: {
+    unpack: {
+      keyValueSeparator: " ",
+      entrySeparator: "; "
+    },
+    metaKey: "http-equiv"
+  },
+  fbAppId: {
+    keyValue: "fb:app_id",
+    metaKey: "property"
+  },
+  ogSiteName: {
+    keyValue: "og:site_name"
+  },
+  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"
+  }
+};
+const ColonPrefixKeys = /^(og|twitter|fb)/;
+const PropertyPrefixKeys = /^(og|fb)/;
+function resolveMetaKeyType(key) {
+  return PropertyPrefixKeys.test(key) ? "property" : MetaPackingSchema[key]?.metaKey || "name";
+}
+function resolveMetaKeyValue(key) {
+  return MetaPackingSchema[key]?.keyValue || fixKeyCase(key);
+}
+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;
+}
+function resolvePackedMetaObjectValue(value, key) {
+  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 OpenGraphInputs = ["og:Image", "og:Video", "og:Audio", "twitter:Image"];
+const SimpleArrayUnpackMetas = ["themeColor"];
+function unpackMeta(input) {
+  const extras = [];
+  OpenGraphInputs.forEach((key) => {
+    const propKey = key.toLowerCase();
+    const inputKey = `${key.replace(":", "")}`;
+    const val = input[inputKey];
+    if (typeof val === "object") {
+      (Array.isArray(val) ? val : [val]).forEach((entry) => {
+        if (!entry)
+          return;
+        const unpackedEntry = unpackToArray(entry, {
+          key: key.startsWith("og") ? "property" : "name",
+          value: "content",
+          resolveKeyData({ key: key2 }) {
+            return fixKeyCase(`${propKey}${key2 !== "url" ? `:${key2}` : ""}`);
+          },
+          resolveValueData({ value }) {
+            return typeof value === "number" ? value.toString() : value;
+          }
+        });
+        extras.push(
+          ...unpackedEntry.sort((a, b) => a.property === propKey ? -1 : b.property === propKey ? 1 : 0)
+        );
+      });
+      delete input[inputKey];
+    }
+  });
+  SimpleArrayUnpackMetas.forEach((meta2) => {
+    if (input[meta2] && typeof input[meta2] !== "string") {
+      const val = Array.isArray(input[meta2]) ? input[meta2] : [input[meta2]];
+      delete input[meta2];
+      val.forEach((entry) => {
+        extras.push({
+          name: fixKeyCase(meta2),
+          ...entry
+        });
+      });
+    }
+  });
+  const meta = unpackToArray(input, {
+    key({ key }) {
+      return resolveMetaKeyType(key);
+    },
+    value({ key }) {
+      return key === "charset" ? "charset" : "content";
+    },
+    resolveKeyData({ key }) {
+      return resolveMetaKeyValue(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 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 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) => {
+              const val = meta[key2];
+              if (key2 === "rel" && ["stylesheet", "canonical", "modulepreload", "prerender", "preload", "prefetch"].includes(val))
+                return;
+              if (key2 === "href") {
+                if (val.includes("javascript:") || val.includes("data:"))
+                  return;
+                link[key2] = val;
+              } else if (val || key2.startsWith("data-")) {
+                link[key2] = val;
+              }
+            });
+            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;
+}
+
+async function normaliseTag(tagName, input, e) {
+  const tag = { tag: tagName, props: {} };
+  if (input instanceof Promise)
+    input = await input;
+  if (tagName === "templateParams") {
+    tag.props = input;
+    return tag;
+  }
+  if (["title", "titleTemplate"].includes(tagName)) {
+    if (input && typeof input === "object") {
+      tag.textContent = input.textContent;
+      if (input.tagPriority)
+        tag.tagPriority = input.tagPriority;
+    } else {
+      tag.textContent = 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;
+    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) => TagConfigKeys.includes(k)).forEach((k) => {
+    if (!["innerHTML", "textContent"].includes(k) || TagsWithInnerContent.includes(tag.tag)) {
+      tag[k] = tag.props[k];
+    }
+    delete tag.props[k];
+  });
+  TagConfigKeys.forEach((k) => {
+    if (!tag[k] && e[k]) {
+      tag[k] = e[k];
+    }
+  });
+  ["innerHTML", "textContent"].forEach((k) => {
+    if (tag.tag === "script" && typeof tag[k] === "string" && ["application/ld+json", "application/json"].includes(tag.props.type)) {
+      try {
+        tag[k] = JSON.parse(tag[k]);
+      } catch (e2) {
+        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).filter(([k, v]) => typeof v !== "undefined" && ValidHeadTags.includes(k)).forEach(([k, value]) => {
+    const v = asArray$1(value);
+    tagPromises.push(...v.map((props) => normaliseTag(k, props, e)).flat());
+  });
+  return (await Promise.all(tagPromises)).flat().filter(Boolean).map((t, i) => {
+    t._e = e._i;
+    t._p = (e._i << TagEntityBits) + i;
+    return t;
+  });
+}
+
+const TAG_WEIGHTS = {
+  // tags
+  base: -1,
+  title: 1
+};
+const TAG_ALIASES = {
+  // relative scores to their default values
+  critical: -8,
+  high: -1,
+  low: 2
+};
+function tagWeight(tag) {
+  let weight = 10;
+  const priority = tag.tagPriority;
+  if (typeof priority === "number")
+    return priority;
+  if (tag.tag === "meta") {
+    if (tag.props.charset)
+      weight = -2;
+    if (tag.props["http-equiv"] === "content-security-policy")
+      weight = 0;
+  } else if (tag.tag === "link" && tag.props.rel === "preconnect") {
+    weight = 2;
+  } else if (tag.tag in TAG_WEIGHTS) {
+    weight = TAG_WEIGHTS[tag.tag];
+  }
+  if (typeof priority === "string" && priority in TAG_ALIASES) {
+    return weight + TAG_ALIASES[priority];
+  }
+  return weight;
+}
+const SortModifiers = [{ prefix: "before:", offset: -1 }, { prefix: "after:", offset: 1 }];
+
+function processTemplateParams(s, p) {
+  if (typeof s !== "string")
+    return s;
+  function sub(token) {
+    if (["s", "pageTitle"].includes(token))
+      return p.pageTitle;
+    let val;
+    if (token.includes(".")) {
+      val = token.split(".").reduce((acc, key) => acc ? acc[key] || void 0 : void 0, p);
+    } else {
+      val = p[token];
+    }
+    return typeof val !== "undefined" ? val || "" : false;
+  }
+  let decoded = s;
+  try {
+    decoded = decodeURI(s);
+  } catch {
+  }
+  const tokens = (decoded.match(/%(\w+\.+\w+)|%(\w+)/g) || []).sort().reverse();
+  tokens.forEach((token) => {
+    const re = sub(token.slice(1));
+    if (typeof re === "string") {
+      s = s.replace(new RegExp(`\\${token}(\\W|$)`, "g"), (_, args) => `${re}${args}`).trim();
+    }
+  });
+  const sep = p.separator;
+  if (s.includes(sep)) {
+    if (s.endsWith(sep))
+      s = s.slice(0, -sep.length).trim();
+    if (s.startsWith(sep))
+      s = s.slice(sep.length).trim();
+    s = s.replace(new RegExp(`\\${sep}\\s*\\${sep}`, "g"), sep);
+  }
+  return s;
+}
+
 exports.HasElementTags = HasElementTags;
+exports.IsBrowser = IsBrowser;
 exports.SelfClosingTags = SelfClosingTags;
+exports.SortModifiers = SortModifiers;
+exports.TAG_ALIASES = TAG_ALIASES;
+exports.TAG_WEIGHTS = TAG_WEIGHTS;
 exports.TagConfigKeys = TagConfigKeys;
+exports.TagEntityBits = TagEntityBits;
 exports.TagsWithInnerContent = TagsWithInnerContent;
 exports.UniqueTags = UniqueTags;
 exports.ValidHeadTags = ValidHeadTags;
-exports.asArray = asArray;
-exports.computeHashes = computeHashes;
+exports.asArray = asArray$1;
+exports.composableNames = composableNames;
 exports.defineHeadPlugin = defineHeadPlugin;
 exports.hashCode = hashCode;
 exports.hashTag = hashTag;
+exports.normaliseClassProp = normaliseClassProp;
+exports.normaliseEntryTags = normaliseEntryTags;
+exports.normaliseProps = normaliseProps;
+exports.normaliseTag = normaliseTag;
+exports.packMeta = packMeta;
+exports.processTemplateParams = processTemplateParams;
+exports.resolveMetaKeyType = resolveMetaKeyType;
+exports.resolveMetaKeyValue = resolveMetaKeyValue;
+exports.resolvePackedMetaObjectValue = resolvePackedMetaObjectValue;
 exports.resolveTitleTemplate = resolveTitleTemplate;
 exports.tagDedupeKey = tagDedupeKey;
+exports.tagWeight = tagWeight;
+exports.unpackMeta = unpackMeta;
+exports.whitelistSafeInput = whitelistSafeInput;

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { HeadPlugin, HeadTag } from '@unhead/schema';
+import { HeadPlugin, HeadTag, MetaFlatInput, Head, MaybeArray, HeadSafe, HeadEntry, TemplateParams } from '@unhead/schema';
 
 type Arrayable<T> = T | Array<T>;
 declare function asArray<T>(value: Arrayable<T>): T[];
@@ -9,16 +9,56 @@ declare const HasElementTags: string[];
 declare const ValidHeadTags: string[];
 declare const UniqueTags: string[];
 declare const TagConfigKeys: string[];
-declare const EntryConfigKeys: string[];
+declare const IsBrowser: boolean;
+declare const composableNames: string[];
 
 declare function defineHeadPlugin(plugin: HeadPlugin): HeadPlugin;
 
 declare function hashCode(s: string): string;
 declare function hashTag(tag: HeadTag): string;
-declare function computeHashes(hashes: string[]): string;
 
 declare function tagDedupeKey<T extends HeadTag>(tag: T, fn?: (key: string) => boolean): string | false;
 
 declare function resolveTitleTemplate(template: string | ((title?: string) => string | null) | null, title?: string): string | null;
 
-export { Arrayable, EntryConfigKeys, HasElementTags, SelfClosingTags, TagConfigKeys, TagsWithInnerContent, UniqueTags, ValidHeadTags, asArray, computeHashes, defineHeadPlugin, hashCode, hashTag, resolveTitleTemplate, tagDedupeKey };
+type ValidMetaType = 'name' | 'http-equiv' | 'property' | 'charset';
+declare function resolveMetaKeyType(key: string): string;
+declare function resolveMetaKeyValue(key: string): string;
+declare function resolvePackedMetaObjectValue(value: string, key: string): string;
+/**
+ * Converts a flat meta object into an array of meta entries.
+ * @param input
+ */
+declare function unpackMeta<T extends MetaFlatInput>(input: T): Required<Head>['meta'];
+/**
+ * Convert an array of meta entries to a flat object.
+ * @param inputs
+ */
+declare function packMeta<T extends Required<Head>['meta']>(inputs: T): MetaFlatInput;
+
+declare function whitelistSafeInput(input: Record<string, MaybeArray<Record<string, string>>>): HeadSafe;
+
+declare function normaliseTag<T extends HeadTag>(tagName: T['tag'], input: HeadTag['props'] | string, e: HeadEntry<T>): Promise<T | T[] | false>;
+declare function normaliseClassProp(v: Required<Required<Head>['htmlAttrs']['class']>): string;
+declare function normaliseProps<T extends HeadTag>(tagName: T['tag'], props: T['props']): Promise<T['props']>;
+declare const TagEntityBits = 10;
+declare function normaliseEntryTags<T extends {} = Head>(e: HeadEntry<T>): Promise<HeadTag[]>;
+
+declare const TAG_WEIGHTS: {
+    readonly base: -1;
+    readonly title: 1;
+};
+declare const TAG_ALIASES: {
+    readonly critical: -8;
+    readonly high: -1;
+    readonly low: 2;
+};
+declare function tagWeight<T extends HeadTag>(tag: T): any;
+declare const SortModifiers: {
+    prefix: string;
+    offset: number;
+}[];
+
+declare function processTemplateParams(s: string, p: TemplateParams): string;
+
+export { Arrayable, HasElementTags, IsBrowser, SelfClosingTags, SortModifiers, TAG_ALIASES, TAG_WEIGHTS, TagConfigKeys, TagEntityBits, TagsWithInnerContent, UniqueTags, ValidHeadTags, ValidMetaType, asArray, composableNames, defineHeadPlugin, hashCode, hashTag, normaliseClassProp, normaliseEntryTags, normaliseProps, normaliseTag, packMeta, processTemplateParams, resolveMetaKeyType, resolveMetaKeyValue, resolvePackedMetaObjectValue, resolveTitleTemplate, tagDedupeKey, tagWeight, unpackMeta, whitelistSafeInput };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-function asArray(value) {
+function asArray$1(value) {
   return Array.isArray(value) ? value : [value];
 }
 
@@ -27,7 +27,16 @@ const ValidHeadTags = [
 ];
 const UniqueTags = ["base", "title", "titleTemplate", "bodyAttrs", "htmlAttrs", "templateParams"];
 const TagConfigKeys = ["tagPosition", "tagPriority", "tagDuplicateStrategy", "innerHTML", "textContent"];
-const EntryConfigKeys = ["tagPosition", "tagPriority"];
+const IsBrowser = typeof window !== "undefined";
+const composableNames = [
+  "getActiveHead",
+  "useHead",
+  "useSeoMeta",
+  "useHeadSafe",
+  "useServerHead",
+  "useServerSeoMeta",
+  "useServerHeadSafe"
+];
 
 function defineHeadPlugin(plugin) {
   return plugin;
@@ -40,15 +49,7 @@ function hashCode(s) {
   return ((h ^ h >>> 9) + 65536).toString(16).substring(1, 8).toLowerCase();
 }
 function hashTag(tag) {
-  return hashCode(`${tag.tag}:${tag.textContent || tag.innerHTML || ""}:${Object.entries(tag.props).map(([key, value]) => `${key}:${String(value)}`).join(",")}`);
-}
-function computeHashes(hashes) {
-  let h = 9;
-  for (const s of hashes) {
-    for (let i = 0; i < s.length; )
-      h = Math.imul(h ^ s.charCodeAt(i++), 9 ** 9);
-  }
-  return ((h ^ h >>> 9) + 65536).toString(16).substring(1, 8).toLowerCase();
+  return tag._h || hashCode(tag._d ? tag._d : `${tag.tag}:${tag.textContent || tag.innerHTML || ""}:${Object.entries(tag.props).map(([key, value]) => `${key}:${String(value)}`).join(",")}`);
 }
 
 function tagDedupeKey(tag, fn) {
@@ -81,4 +82,541 @@ function resolveTitleTemplate(template, title) {
   return template;
 }
 
-export { EntryConfigKeys, HasElementTags, SelfClosingTags, TagConfigKeys, TagsWithInnerContent, UniqueTags, ValidHeadTags, asArray, computeHashes, defineHeadPlugin, hashCode, hashTag, resolveTitleTemplate, tagDedupeKey };
+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: {
+      keyValueSeparator: ":"
+    }
+  },
+  // Pragma directives
+  contentSecurityPolicy: {
+    unpack: {
+      keyValueSeparator: " ",
+      entrySeparator: "; "
+    },
+    metaKey: "http-equiv"
+  },
+  fbAppId: {
+    keyValue: "fb:app_id",
+    metaKey: "property"
+  },
+  ogSiteName: {
+    keyValue: "og:site_name"
+  },
+  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"
+  }
+};
+const ColonPrefixKeys = /^(og|twitter|fb)/;
+const PropertyPrefixKeys = /^(og|fb)/;
+function resolveMetaKeyType(key) {
+  return PropertyPrefixKeys.test(key) ? "property" : MetaPackingSchema[key]?.metaKey || "name";
+}
+function resolveMetaKeyValue(key) {
+  return MetaPackingSchema[key]?.keyValue || fixKeyCase(key);
+}
+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;
+}
+function resolvePackedMetaObjectValue(value, key) {
+  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 OpenGraphInputs = ["og:Image", "og:Video", "og:Audio", "twitter:Image"];
+const SimpleArrayUnpackMetas = ["themeColor"];
+function unpackMeta(input) {
+  const extras = [];
+  OpenGraphInputs.forEach((key) => {
+    const propKey = key.toLowerCase();
+    const inputKey = `${key.replace(":", "")}`;
+    const val = input[inputKey];
+    if (typeof val === "object") {
+      (Array.isArray(val) ? val : [val]).forEach((entry) => {
+        if (!entry)
+          return;
+        const unpackedEntry = unpackToArray(entry, {
+          key: key.startsWith("og") ? "property" : "name",
+          value: "content",
+          resolveKeyData({ key: key2 }) {
+            return fixKeyCase(`${propKey}${key2 !== "url" ? `:${key2}` : ""}`);
+          },
+          resolveValueData({ value }) {
+            return typeof value === "number" ? value.toString() : value;
+          }
+        });
+        extras.push(
+          ...unpackedEntry.sort((a, b) => a.property === propKey ? -1 : b.property === propKey ? 1 : 0)
+        );
+      });
+      delete input[inputKey];
+    }
+  });
+  SimpleArrayUnpackMetas.forEach((meta2) => {
+    if (input[meta2] && typeof input[meta2] !== "string") {
+      const val = Array.isArray(input[meta2]) ? input[meta2] : [input[meta2]];
+      delete input[meta2];
+      val.forEach((entry) => {
+        extras.push({
+          name: fixKeyCase(meta2),
+          ...entry
+        });
+      });
+    }
+  });
+  const meta = unpackToArray(input, {
+    key({ key }) {
+      return resolveMetaKeyType(key);
+    },
+    value({ key }) {
+      return key === "charset" ? "charset" : "content";
+    },
+    resolveKeyData({ key }) {
+      return resolveMetaKeyValue(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 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 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) => {
+              const val = meta[key2];
+              if (key2 === "rel" && ["stylesheet", "canonical", "modulepreload", "prerender", "preload", "prefetch"].includes(val))
+                return;
+              if (key2 === "href") {
+                if (val.includes("javascript:") || val.includes("data:"))
+                  return;
+                link[key2] = val;
+              } else if (val || key2.startsWith("data-")) {
+                link[key2] = val;
+              }
+            });
+            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;
+}
+
+async function normaliseTag(tagName, input, e) {
+  const tag = { tag: tagName, props: {} };
+  if (input instanceof Promise)
+    input = await input;
+  if (tagName === "templateParams") {
+    tag.props = input;
+    return tag;
+  }
+  if (["title", "titleTemplate"].includes(tagName)) {
+    if (input && typeof input === "object") {
+      tag.textContent = input.textContent;
+      if (input.tagPriority)
+        tag.tagPriority = input.tagPriority;
+    } else {
+      tag.textContent = 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;
+    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) => TagConfigKeys.includes(k)).forEach((k) => {
+    if (!["innerHTML", "textContent"].includes(k) || TagsWithInnerContent.includes(tag.tag)) {
+      tag[k] = tag.props[k];
+    }
+    delete tag.props[k];
+  });
+  TagConfigKeys.forEach((k) => {
+    if (!tag[k] && e[k]) {
+      tag[k] = e[k];
+    }
+  });
+  ["innerHTML", "textContent"].forEach((k) => {
+    if (tag.tag === "script" && typeof tag[k] === "string" && ["application/ld+json", "application/json"].includes(tag.props.type)) {
+      try {
+        tag[k] = JSON.parse(tag[k]);
+      } catch (e2) {
+        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).filter(([k, v]) => typeof v !== "undefined" && ValidHeadTags.includes(k)).forEach(([k, value]) => {
+    const v = asArray$1(value);
+    tagPromises.push(...v.map((props) => normaliseTag(k, props, e)).flat());
+  });
+  return (await Promise.all(tagPromises)).flat().filter(Boolean).map((t, i) => {
+    t._e = e._i;
+    t._p = (e._i << TagEntityBits) + i;
+    return t;
+  });
+}
+
+const TAG_WEIGHTS = {
+  // tags
+  base: -1,
+  title: 1
+};
+const TAG_ALIASES = {
+  // relative scores to their default values
+  critical: -8,
+  high: -1,
+  low: 2
+};
+function tagWeight(tag) {
+  let weight = 10;
+  const priority = tag.tagPriority;
+  if (typeof priority === "number")
+    return priority;
+  if (tag.tag === "meta") {
+    if (tag.props.charset)
+      weight = -2;
+    if (tag.props["http-equiv"] === "content-security-policy")
+      weight = 0;
+  } else if (tag.tag === "link" && tag.props.rel === "preconnect") {
+    weight = 2;
+  } else if (tag.tag in TAG_WEIGHTS) {
+    weight = TAG_WEIGHTS[tag.tag];
+  }
+  if (typeof priority === "string" && priority in TAG_ALIASES) {
+    return weight + TAG_ALIASES[priority];
+  }
+  return weight;
+}
+const SortModifiers = [{ prefix: "before:", offset: -1 }, { prefix: "after:", offset: 1 }];
+
+function processTemplateParams(s, p) {
+  if (typeof s !== "string")
+    return s;
+  function sub(token) {
+    if (["s", "pageTitle"].includes(token))
+      return p.pageTitle;
+    let val;
+    if (token.includes(".")) {
+      val = token.split(".").reduce((acc, key) => acc ? acc[key] || void 0 : void 0, p);
+    } else {
+      val = p[token];
+    }
+    return typeof val !== "undefined" ? val || "" : false;
+  }
+  let decoded = s;
+  try {
+    decoded = decodeURI(s);
+  } catch {
+  }
+  const tokens = (decoded.match(/%(\w+\.+\w+)|%(\w+)/g) || []).sort().reverse();
+  tokens.forEach((token) => {
+    const re = sub(token.slice(1));
+    if (typeof re === "string") {
+      s = s.replace(new RegExp(`\\${token}(\\W|$)`, "g"), (_, args) => `${re}${args}`).trim();
+    }
+  });
+  const sep = p.separator;
+  if (s.includes(sep)) {
+    if (s.endsWith(sep))
+      s = s.slice(0, -sep.length).trim();
+    if (s.startsWith(sep))
+      s = s.slice(sep.length).trim();
+    s = s.replace(new RegExp(`\\${sep}\\s*\\${sep}`, "g"), sep);
+  }
+  return s;
+}
+
+export { HasElementTags, IsBrowser, SelfClosingTags, SortModifiers, TAG_ALIASES, TAG_WEIGHTS, TagConfigKeys, TagEntityBits, TagsWithInnerContent, UniqueTags, ValidHeadTags, asArray$1 as asArray, composableNames, defineHeadPlugin, hashCode, hashTag, normaliseClassProp, normaliseEntryTags, normaliseProps, normaliseTag, packMeta, processTemplateParams, resolveMetaKeyType, resolveMetaKeyValue, resolvePackedMetaObjectValue, resolveTitleTemplate, tagDedupeKey, tagWeight, unpackMeta, whitelistSafeInput };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@unhead/shared",
   "type": "module",
-  "version": "1.2.2",
+  "version": "1.3.0-beta.0",
   "author": "Harlan Wilton <harlan@harlanzw.com>",
   "license": "MIT",
   "funding": "https://github.com/sponsors/harlan-zw",
@@ -34,7 +34,10 @@
     "dist"
   ],
   "dependencies": {
-    "@unhead/schema": "1.2.2"
+    "@unhead/schema": "1.3.0-beta.0"
+  },
+  "devDependencies": {
+    "packrup": "^0.1.0"
   },
   "scripts": {
     "build": "unbuild .",