usage-board 3.1.0 → 3.1.1

package/dist/server/node_modules/unhead/dist/shared/unhead.D4vSFytZ.mjs

@@ -0,0 +1,236 @@
+import { u as unpackMeta } from './unhead.DQc16pHI.mjs';
+
+function defineHeadPlugin(plugin) {
+  return plugin;
+}
+
+const FlatMetaPlugin = /* @__PURE__ */ defineHeadPlugin({
+  key: "flatMeta",
+  hooks: {
+    "entries:normalize": (ctx) => {
+      const tagsToAdd = [];
+      ctx.tags = ctx.tags.map((t) => {
+        if (t.tag !== "_flatMeta") {
+          return t;
+        }
+        tagsToAdd.push(unpackMeta(t.props).map((p) => ({
+          ...t,
+          tag: "meta",
+          props: p
+        })));
+        return false;
+      }).filter(Boolean).concat(...tagsToAdd);
+    }
+  }
+});
+
+const WhitelistAttributes = {
+  htmlAttrs: /* @__PURE__ */ new Set(["class", "style", "lang", "dir"]),
+  bodyAttrs: /* @__PURE__ */ new Set(["class", "style"]),
+  meta: /* @__PURE__ */ new Set(["name", "property", "charset", "content", "media"]),
+  noscript: /* @__PURE__ */ new Set([]),
+  style: /* @__PURE__ */ new Set(["media", "nonce", "title", "blocking"]),
+  script: /* @__PURE__ */ new Set(["type", "textContent", "nonce", "blocking"]),
+  link: /* @__PURE__ */ new Set(["color", "crossorigin", "fetchpriority", "href", "hreflang", "imagesrcset", "imagesizes", "integrity", "media", "referrerpolicy", "rel", "sizes", "type"])
+};
+const BlockedLinkRels = /* @__PURE__ */ new Set(["canonical", "modulepreload", "prerender", "preload", "prefetch", "dns-prefetch", "preconnect", "manifest", "pingback"]);
+const SafeAttrName = /^[a-z][a-z0-9\-]*[a-z0-9]$/i;
+const HtmlEntityHex = /&#x([0-9a-f]+);?/gi;
+const HtmlEntityDec = /&#(\d+);?/g;
+const HtmlEntityNamed = /&(tab|newline|colon|semi|lpar|rpar|sol|bsol|comma|period|excl|num|dollar|percnt|amp|apos|ast|plus|lt|gt|equals|quest|at|lsqb|rsqb|lcub|rcub|vert|hat|grave|tilde|nbsp);?/gi;
+const ControlChars = /[\x00-\x20]+/g;
+const NamedEntityMap = {
+  tab: "	",
+  newline: "\n",
+  colon: ":",
+  semi: ";",
+  lpar: "(",
+  rpar: ")",
+  sol: "/",
+  bsol: "\\",
+  comma: ",",
+  period: ".",
+  excl: "!",
+  num: "#",
+  dollar: "$",
+  percnt: "%",
+  amp: "&",
+  apos: "'",
+  ast: "*",
+  plus: "+",
+  lt: "<",
+  gt: ">",
+  equals: "=",
+  quest: "?",
+  at: "@",
+  lsqb: "[",
+  rsqb: "]",
+  lcub: "{",
+  rcub: "}",
+  vert: "|",
+  hat: "^",
+  grave: "`",
+  tilde: "~",
+  nbsp: "\xA0"
+};
+function safeFromCodePoint(codePoint) {
+  if (codePoint > 1114111 || codePoint < 0 || Number.isNaN(codePoint))
+    return "";
+  return String.fromCodePoint(codePoint);
+}
+function decodeHtmlEntities(str) {
+  return str.replace(HtmlEntityHex, (_, hex) => safeFromCodePoint(Number.parseInt(hex, 16))).replace(HtmlEntityDec, (_, dec) => safeFromCodePoint(Number(dec))).replace(HtmlEntityNamed, (_, name) => NamedEntityMap[name.toLowerCase()] || "");
+}
+function hasDangerousProtocol(url) {
+  const entityDecoded = decodeHtmlEntities(url);
+  const cleaned = entityDecoded.replace(ControlChars, "");
+  let decoded;
+  try {
+    decoded = decodeURIComponent(cleaned);
+  } catch {
+    decoded = cleaned;
+  }
+  const sanitized = decoded.replace(ControlChars, "");
+  const lower = sanitized.toLowerCase();
+  return lower.startsWith("javascript:") || lower.startsWith("data:") || lower.startsWith("vbscript:");
+}
+function stripProtoKeys(obj) {
+  if (Array.isArray(obj))
+    return obj.map(stripProtoKeys);
+  if (obj && typeof obj === "object") {
+    const clean = {};
+    for (const key of Object.keys(obj)) {
+      if (key === "__proto__" || key === "constructor" || key === "prototype")
+        continue;
+      clean[key] = stripProtoKeys(obj[key]);
+    }
+    return clean;
+  }
+  return obj;
+}
+function acceptDataAttrs(value, allowId = true) {
+  return Object.fromEntries(
+    Object.entries(value || {}).filter(([key]) => (allowId && key === "id" || key.startsWith("data-")) && SafeAttrName.test(key))
+  );
+}
+function makeTagSafe(tag) {
+  let next = {};
+  const { tag: type, props: prev } = tag;
+  switch (type) {
+    // title: textContent is escaped in rendering (tagToString), no props needed
+    case "title":
+      break;
+    // virtual tags, not rendered to HTML — but sanitize to prevent injection if rendered
+    case "titleTemplate":
+    case "templateParams":
+      next = prev;
+      break;
+    case "htmlAttrs":
+    case "bodyAttrs":
+      WhitelistAttributes[type].forEach((attr) => {
+        if (prev[attr]) {
+          next[attr] = prev[attr];
+        }
+      });
+      delete tag.innerHTML;
+      delete tag.textContent;
+      tag.props = { ...acceptDataAttrs(prev, false), ...next };
+      return !Object.keys(tag.props).length ? false : tag;
+    case "style":
+      next = acceptDataAttrs(prev);
+      WhitelistAttributes.style.forEach((key) => {
+        if (prev[key]) {
+          next[key] = prev[key];
+        }
+      });
+      break;
+    // meta is safe, except for http-equiv
+    case "meta":
+      WhitelistAttributes.meta.forEach((key) => {
+        if (prev[key]) {
+          next[key] = prev[key];
+        }
+      });
+      break;
+    // link tags we block preloading, prerendering, prefetching, dns-prefetch, preconnect, manifest, etc
+    case "link":
+      WhitelistAttributes.link.forEach((key) => {
+        const val = prev[key];
+        if (!val) {
+          return;
+        }
+        if (key === "rel" && (typeof val !== "string" || BlockedLinkRels.has(val.toLowerCase()))) {
+          return;
+        }
+        if (key === "href" || key === "imagesrcset") {
+          if (typeof val !== "string") {
+            return;
+          }
+          const urls = key === "imagesrcset" ? val.split(",").map((s) => s.trim()) : [val];
+          if (urls.some((u) => hasDangerousProtocol(u))) {
+            return;
+          }
+          next[key] = val;
+        } else if (val) {
+          next[key] = val;
+        }
+      });
+      if (!next.href && !next.imagesrcset || !next.rel) {
+        return false;
+      }
+      break;
+    case "noscript":
+      WhitelistAttributes.noscript.forEach((key) => {
+        if (prev[key]) {
+          next[key] = prev[key];
+        }
+      });
+      break;
+    // we only allow JSON in scripts
+    case "script":
+      if (!tag.textContent || typeof prev.type !== "string" || !prev.type.endsWith("json")) {
+        return false;
+      }
+      try {
+        const jsonVal = typeof tag.textContent === "string" ? JSON.parse(tag.textContent) : tag.textContent;
+        tag.textContent = JSON.stringify(stripProtoKeys(jsonVal), null, 0);
+      } catch {
+        return false;
+      }
+      WhitelistAttributes.script.forEach((s) => {
+        if (s !== "textContent" && prev[s]) {
+          next[s] = prev[s];
+        }
+      });
+      break;
+  }
+  delete tag.innerHTML;
+  if (type !== "title" && type !== "script") {
+    delete tag.textContent;
+  }
+  tag.props = { ...acceptDataAttrs(prev), ...next };
+  if (!Object.keys(tag.props).length && !tag.tag.endsWith("Attrs") && !tag.textContent) {
+    return false;
+  }
+  return tag;
+}
+const SafeInputPlugin = (
+  /* @PURE */
+  defineHeadPlugin({
+    key: "safe",
+    hooks: {
+      "entries:normalize": (ctx) => {
+        if (ctx.entry.options?._safe) {
+          ctx.tags = ctx.tags.reduce((acc, tag) => {
+            const safeTag = makeTagSafe(tag);
+            if (safeTag)
+              acc.push(safeTag);
+            return acc;
+          }, []);
+        }
+      }
+    }
+  })
+);
+
+export { FlatMetaPlugin as F, SafeInputPlugin as S, defineHeadPlugin as d };

package/dist/server/node_modules/unhead/dist/shared/unhead.DQc16pHI.mjs

@@ -0,0 +1,196 @@
+import { M as MetaTagsArrayable } from './unhead.yem5I2v_.mjs';
+
+const NAMESPACES = {
+  META: /* @__PURE__ */ new Set(["twitter"]),
+  OG: /* @__PURE__ */ new Set(["og", "book", "article", "profile", "fb"]),
+  MEDIA: /* @__PURE__ */ new Set(["ogImage", "ogVideo", "ogAudio", "twitterImage"]),
+  HTTP_EQUIV: /* @__PURE__ */ new Set(["contentType", "defaultStyle", "xUaCompatible"])
+};
+const META_ALIASES = {
+  articleExpirationTime: "article:expiration_time",
+  articleModifiedTime: "article:modified_time",
+  articlePublishedTime: "article:published_time",
+  bookReleaseDate: "book:release_date",
+  fbAppId: "fb:app_id",
+  ogAudioSecureUrl: "og:audio:secure_url",
+  ogAudioUrl: "og:audio",
+  ogImageSecureUrl: "og:image:secure_url",
+  ogImageUrl: "og:image",
+  ogSiteName: "og:site_name",
+  ogVideoSecureUrl: "og:video:secure_url",
+  ogVideoUrl: "og:video",
+  profileFirstName: "profile:first_name",
+  profileLastName: "profile:last_name",
+  profileUsername: "profile:username",
+  msapplicationConfig: "msapplication-Config",
+  msapplicationTileColor: "msapplication-TileColor",
+  msapplicationTileImage: "msapplication-TileImage"
+};
+const MetaPackingSchema = {
+  appleItunesApp: {
+    unpack: {
+      entrySeparator: ", ",
+      // @ts-expect-error untyped
+      resolve: ({ key, value }) => `${fixKeyCase(key)}=${value}`
+    }
+  },
+  refresh: {
+    metaKey: "http-equiv",
+    unpack: {
+      entrySeparator: ";",
+      // @ts-expect-error untyped
+      resolve: ({ key, value }) => key === "seconds" ? `${value}` : void 0
+    }
+  },
+  robots: {
+    unpack: {
+      entrySeparator: ", ",
+      // @ts-expect-error untyped
+      resolve: ({ key, value }) => typeof value === "boolean" ? fixKeyCase(key) : `${fixKeyCase(key)}:${value}`
+    }
+  },
+  contentSecurityPolicy: {
+    metaKey: "http-equiv",
+    unpack: {
+      entrySeparator: "; ",
+      // @ts-expect-error untyped
+      resolve: ({ key, value }) => `${fixKeyCase(key)} ${value}`
+    }
+  },
+  charset: {}
+};
+function fixKeyCase(key) {
+  const updated = key.replace(/([A-Z])/g, "-$1").toLowerCase();
+  const prefixIndex = updated.indexOf("-");
+  return prefixIndex === -1 ? updated : NAMESPACES.META.has(updated.slice(0, prefixIndex)) || NAMESPACES.OG.has(updated.slice(0, prefixIndex)) ? key.replace(/([A-Z])/g, ":$1").toLowerCase() : updated;
+}
+function sanitizeObject(input) {
+  return Object.fromEntries(Object.entries(input).filter(([k, v]) => String(v) !== "false" && k));
+}
+function transformObject(obj) {
+  return Array.isArray(obj) ? obj.map(transformObject) : !obj || typeof obj !== "object" ? obj : Object.fromEntries(Object.entries(obj).map(([k, v]) => [fixKeyCase(k), transformObject(v)]));
+}
+function unpackToString(value, options = {}) {
+  const { entrySeparator = "", keyValueSeparator = "", wrapValue, resolve } = options;
+  return Object.entries(value).map(([key, val]) => {
+    if (resolve) {
+      const resolved = resolve({ key, value: val });
+      if (resolved !== void 0)
+        return resolved;
+    }
+    const processedVal = typeof val === "object" ? unpackToString(val, options) : typeof val === "number" ? val.toString() : typeof val === "string" && wrapValue ? `${wrapValue}${val.replace(new RegExp(wrapValue, "g"), `\\${wrapValue}`)}${wrapValue}` : val;
+    return `${key}${keyValueSeparator}${processedVal}`;
+  }).join(entrySeparator);
+}
+function handleObjectEntry(key, value) {
+  const sanitizedValue = sanitizeObject(value);
+  const fixedKey = fixKeyCase(key);
+  const attr = resolveMetaKeyType(fixedKey);
+  if (!MetaTagsArrayable.has(fixedKey)) {
+    return [{ [attr]: fixedKey, ...sanitizedValue }];
+  }
+  const input = Object.fromEntries(
+    Object.entries(sanitizedValue).map(([k, v]) => [`${key}${k === "url" ? "" : `${k[0].toUpperCase()}${k.slice(1)}`}`, v])
+  );
+  return unpackMeta(input || {}).sort((a, b) => (a[attr]?.length || 0) - (b[attr]?.length || 0));
+}
+function resolveMetaKeyType(key) {
+  if (MetaPackingSchema[key]?.metaKey === "http-equiv" || NAMESPACES.HTTP_EQUIV.has(key)) {
+    return "http-equiv";
+  }
+  const fixed = fixKeyCase(key);
+  const colonIndex = fixed.indexOf(":");
+  return colonIndex === -1 ? "name" : NAMESPACES.OG.has(fixed.slice(0, colonIndex)) ? "property" : "name";
+}
+function resolveMetaKeyValue(key) {
+  return META_ALIASES[key] || fixKeyCase(key);
+}
+function resolvePackedMetaObjectValue(value, key) {
+  if (key === "refresh")
+    return `${value.seconds};url=${value.url}`;
+  return unpackToString(transformObject(value), {
+    keyValueSeparator: "=",
+    entrySeparator: ", ",
+    resolve: ({ value: value2, key: key2 }) => value2 === null ? "" : typeof value2 === "boolean" ? key2 : void 0,
+    // @ts-expect-error untyped
+    ...MetaPackingSchema[key]?.unpack
+  });
+}
+function unpackMeta(input) {
+  const extras = [];
+  const primitives = {};
+  for (const [key, value] of Object.entries(input)) {
+    if (Array.isArray(value)) {
+      if (key === "themeColor") {
+        value.forEach((v) => {
+          if (typeof v === "object" && v !== null) {
+            extras.push({ name: "theme-color", ...v });
+          }
+        });
+        continue;
+      }
+      for (const v of value) {
+        if (typeof v === "object" && v !== null) {
+          const urlProps = [];
+          const otherProps = [];
+          for (const [propKey, propValue] of Object.entries(v)) {
+            const metaKey = `${key}${propKey === "url" ? "" : `:${propKey}`}`;
+            const meta2 = unpackMeta({ [metaKey]: propValue });
+            (propKey === "url" ? urlProps : otherProps).push(...meta2);
+          }
+          extras.push(...urlProps, ...otherProps);
+        } else {
+          extras.push(...typeof v === "string" ? unpackMeta({ [key]: v }) : handleObjectEntry(key, v));
+        }
+      }
+      continue;
+    }
+    if (typeof value === "object" && value) {
+      if (NAMESPACES.MEDIA.has(key)) {
+        const prefix = key.startsWith("twitter") ? "twitter" : "og";
+        const type = key.replace(/^(og|twitter)/, "").toLowerCase();
+        const metaKey = prefix === "twitter" ? "name" : "property";
+        if (value.url) {
+          extras.push({
+            [metaKey]: `${prefix}:${type}`,
+            content: value.url
+          });
+        }
+        if (value.secureUrl) {
+          extras.push({
+            [metaKey]: `${prefix}:${type}:secure_url`,
+            content: value.secureUrl
+          });
+        }
+        for (const [propKey, propValue] of Object.entries(value)) {
+          if (propKey !== "url" && propKey !== "secureUrl") {
+            extras.push({
+              [metaKey]: `${prefix}:${type}:${propKey}`,
+              // @ts-expect-error untyped
+              content: propValue
+            });
+          }
+        }
+      } else if (MetaTagsArrayable.has(fixKeyCase(key))) {
+        extras.push(...handleObjectEntry(key, value));
+      } else {
+        primitives[key] = sanitizeObject(value);
+      }
+    } else {
+      primitives[key] = value;
+    }
+  }
+  const meta = Object.entries(primitives).map(([key, value]) => {
+    if (key === "charset")
+      return { charset: value === null ? "_null" : value };
+    const metaKey = resolveMetaKeyType(key);
+    const keyValue = resolveMetaKeyValue(key);
+    const processedValue = value === null ? "_null" : typeof value === "object" ? resolvePackedMetaObjectValue(value, key) : typeof value === "number" ? value.toString() : value;
+    return metaKey === "http-equiv" ? { "http-equiv": keyValue, "content": processedValue } : { [metaKey]: keyValue, content: processedValue };
+  });
+  return [...extras, ...meta].map(
+    (m) => !("content" in m) ? m : m.content === "_null" ? { ...m, content: null } : m
+  );
+}
+
+export { resolveMetaKeyValue as a, resolvePackedMetaObjectValue as b, resolveMetaKeyType as r, unpackMeta as u };

package/dist/server/node_modules/unhead/dist/shared/unhead.TxTMM7cM.mjs

@@ -0,0 +1,166 @@
+import { d as defineHeadPlugin } from './unhead.D4vSFytZ.mjs';
+import { s as sortTags } from './unhead.CbpEuj3y.mjs';
+import { p as processTemplateParams } from './unhead.BYvz9V1x.mjs';
+
+const formatKey = (k) => !k.includes(":key") ? k.split(":").join(":key:") : k;
+const AliasSortingPlugin = defineHeadPlugin({
+  key: "aliasSorting",
+  hooks: {
+    "tags:resolve": (ctx) => {
+      let m = false;
+      for (const t of ctx.tags) {
+        const p = t.tagPriority;
+        if (!p)
+          continue;
+        const s = String(p);
+        if (s.startsWith("before:")) {
+          const k = formatKey(s.slice(7));
+          const l = ctx.tagMap.get(k);
+          if (l) {
+            if (typeof l.tagPriority === "number")
+              t.tagPriority = l.tagPriority;
+            t._p = l._p - 1;
+            m = true;
+          }
+        } else if (s.startsWith("after:")) {
+          const k = formatKey(s.slice(6));
+          const l = ctx.tagMap.get(k);
+          if (l) {
+            if (typeof l.tagPriority === "number")
+              t.tagPriority = l.tagPriority;
+            t._p = l._p + 1;
+            m = true;
+          }
+        }
+      }
+      if (m)
+        ctx.tags = ctx.tags.sort(sortTags);
+    }
+  }
+});
+
+const DeprecationsPlugin = /* @__PURE__ */ defineHeadPlugin({
+  key: "deprecations",
+  hooks: {
+    "entries:normalize": ({ tags }) => {
+      for (const tag of tags) {
+        if (tag.props.children) {
+          tag.innerHTML = tag.props.children;
+          delete tag.props.children;
+        }
+        if (tag.props.hid) {
+          tag.key = tag.props.hid;
+          delete tag.props.hid;
+        }
+        if (tag.props.vmid) {
+          tag.key = tag.props.vmid;
+          delete tag.props.vmid;
+        }
+        if (tag.props.body) {
+          tag.tagPosition = "bodyClose";
+          delete tag.props.body;
+        }
+      }
+    }
+  }
+});
+
+async function walkPromises(v) {
+  const type = typeof v;
+  if (type === "function") {
+    return v;
+  }
+  if (v instanceof Promise) {
+    return await v;
+  }
+  if (Array.isArray(v)) {
+    return await Promise.all(v.map((r) => walkPromises(r)));
+  }
+  if (v?.constructor === Object) {
+    const next = {};
+    for (const key of Object.keys(v)) {
+      next[key] = await walkPromises(v[key]);
+    }
+    return next;
+  }
+  return v;
+}
+const PromisesPlugin = /* @__PURE__ */ defineHeadPlugin({
+  key: "promises",
+  hooks: {
+    "entries:resolve": async (ctx) => {
+      const promises = [];
+      for (const k in ctx.entries) {
+        if (!ctx.entries[k]._promisesProcessed) {
+          promises.push(
+            walkPromises(ctx.entries[k].input).then((val) => {
+              ctx.entries[k].input = val;
+              ctx.entries[k]._promisesProcessed = true;
+            })
+          );
+        }
+      }
+      await Promise.all(promises);
+    }
+  }
+});
+
+const SupportedAttrs = {
+  meta: "content",
+  link: "href",
+  htmlAttrs: "lang"
+};
+const contentAttrs = ["innerHTML", "textContent"];
+const TemplateParamsPlugin = /* @__PURE__ */ defineHeadPlugin((head) => {
+  return {
+    key: "template-params",
+    hooks: {
+      "entries:normalize": (ctx) => {
+        const params = ctx.tags.filter((t) => t.tag === "templateParams" && t.mode === "server")?.[0]?.props || {};
+        if (Object.keys(params).length) {
+          head._ssrPayload = {
+            templateParams: {
+              ...head._ssrPayload?.templateParams || {},
+              ...params
+            }
+          };
+        }
+      },
+      "tags:resolve": ({ tagMap, tags }) => {
+        const params = tagMap.get("templateParams")?.props || {};
+        const sep = params.separator || "|";
+        delete params.separator;
+        params.pageTitle = processTemplateParams(
+          // find templateParams
+          params.pageTitle || head._title || "",
+          params,
+          sep
+        );
+        for (const tag of tags) {
+          if (tag.processTemplateParams === false) {
+            continue;
+          }
+          const v = SupportedAttrs[tag.tag];
+          if (v && typeof tag.props[v] === "string") {
+            tag.props[v] = processTemplateParams(tag.props[v], params, sep);
+          } else if (tag.processTemplateParams || tag.tag === "titleTemplate" || tag.tag === "title") {
+            for (const p of contentAttrs) {
+              if (typeof tag[p] === "string")
+                tag[p] = processTemplateParams(tag[p], params, sep, tag.tag === "script" && tag.props.type.endsWith("json"));
+            }
+          }
+        }
+        head._templateParams = params;
+        head._separator = sep;
+      },
+      "tags:afterResolve": ({ tagMap }) => {
+        const title = tagMap.get("title");
+        if (title?.textContent && title.processTemplateParams !== false) {
+          title.textContent = processTemplateParams(title.textContent, head._templateParams, head._separator);
+        }
+      }
+    }
+  };
+});
+
+export { AliasSortingPlugin as A, DeprecationsPlugin as D, PromisesPlugin as P, TemplateParamsPlugin as T };

package/dist/server/node_modules/unhead/dist/shared/unhead.yem5I2v_.mjs

@@ -0,0 +1,38 @@
+const SelfClosingTags = /* @__PURE__ */ new Set(["meta", "link", "base"]);
+const DupeableTags = /* @__PURE__ */ new Set(["link", "style", "script", "noscript"]);
+const TagsWithInnerContent = /* @__PURE__ */ new Set(["title", "titleTemplate", "script", "style", "noscript"]);
+const HasElementTags = /* @__PURE__ */ new Set([
+  "base",
+  "meta",
+  "link",
+  "style",
+  "script",
+  "noscript"
+]);
+const ValidHeadTags = /* @__PURE__ */ new Set([
+  "title",
+  "base",
+  "htmlAttrs",
+  "bodyAttrs",
+  "meta",
+  "link",
+  "style",
+  "script",
+  "noscript"
+]);
+const UniqueTags = /* @__PURE__ */ new Set(["base", "title", "titleTemplate", "bodyAttrs", "htmlAttrs", "templateParams"]);
+const TagConfigKeys = /* @__PURE__ */ new Set(["key", "tagPosition", "tagPriority", "tagDuplicateStrategy", "innerHTML", "textContent", "processTemplateParams"]);
+const ScriptNetworkEvents = /* @__PURE__ */ new Set(["onload", "onerror"]);
+const UsesMergeStrategy = /* @__PURE__ */ new Set(["templateParams", "htmlAttrs", "bodyAttrs"]);
+const MetaTagsArrayable = /* @__PURE__ */ new Set([
+  "theme-color",
+  "google-site-verification",
+  "og",
+  "article",
+  "book",
+  "profile",
+  "twitter",
+  "author"
+]);
+
+export { DupeableTags as D, HasElementTags as H, MetaTagsArrayable as M, SelfClosingTags as S, TagsWithInnerContent as T, UniqueTags as U, ValidHeadTags as V, TagConfigKeys as a, ScriptNetworkEvents as b, UsesMergeStrategy as c };

package/dist/server/node_modules/unhead/dist/utils.mjs

@@ -0,0 +1,5 @@
+export { D as DupeableTags, H as HasElementTags, M as MetaTagsArrayable, b as ScriptNetworkEvents, S as SelfClosingTags, a as TagConfigKeys, T as TagsWithInnerContent, U as UniqueTags, c as UsesMergeStrategy, V as ValidHeadTags } from './shared/unhead.yem5I2v_.mjs';
+export { d as dedupeKey, h as hashTag, i as isMetaArrayDupeKey, n as normalizeEntryToTags, a as normalizeProps, w as walkResolver } from './shared/unhead.B5FWS6X0.mjs';
+export { r as resolveMetaKeyType, a as resolveMetaKeyValue, b as resolvePackedMetaObjectValue, u as unpackMeta } from './shared/unhead.DQc16pHI.mjs';
+export { s as sortTags, t as tagWeight } from './shared/unhead.CbpEuj3y.mjs';
+export { p as processTemplateParams } from './shared/unhead.BYvz9V1x.mjs';