renovate-log-parser 0.1.1 → 0.2.0

package/web/.output/server/node_modules/unhead/dist/shared/unhead.CaI5ZD4O.mjs

@@ -1,182 +0,0 @@
-import { createHooks } from 'hookable';
-import { n as normalizeEntryToTags, d as dedupeKey, h as hashTag, i as isMetaArrayDupeKey } from './unhead.B3VbJo7Y.mjs';
-import { t as tagWeight, s as sortTags } from './unhead.CbpEuj3y.mjs';
-import { c as UsesMergeStrategy, V as ValidHeadTags } from './unhead.yem5I2v_.mjs';
-
-function registerPlugin(head, p) {
-  const plugin = typeof p === "function" ? p(head) : p;
-  const key = plugin.key || String(head.plugins.size + 1);
-  const exists = head.plugins.get(key);
-  if (!exists) {
-    head.plugins.set(key, plugin);
-    head.hooks.addHooks(plugin.hooks || {});
-  }
-}
-// @__NO_SIDE_EFFECTS__
-function createHeadCore(resolvedOptions = {}) {
-  return /* @__PURE__ */ createUnhead(resolvedOptions);
-}
-// @__NO_SIDE_EFFECTS__
-function createUnhead(resolvedOptions = {}) {
-  const hooks = createHooks();
-  hooks.addHooks(resolvedOptions.hooks || {});
-  const ssr = !resolvedOptions.document;
-  const entries = /* @__PURE__ */ new Map();
-  const plugins = /* @__PURE__ */ new Map();
-  const normalizeQueue = /* @__PURE__ */ new Set();
-  const head = {
-    _entryCount: 1,
-    // 0 is reserved for internal use
-    plugins,
-    dirty: false,
-    resolvedOptions,
-    hooks,
-    ssr,
-    entries,
-    headEntries() {
-      return [...entries.values()];
-    },
-    use: (p) => registerPlugin(head, p),
-    push(input, _options) {
-      const options = { ..._options || {} };
-      delete options.head;
-      const _i = options._index ?? head._entryCount++;
-      const inst = { _i, input, options };
-      const _ = {
-        _poll(rm = false) {
-          head.dirty = true;
-          !rm && normalizeQueue.add(_i);
-          hooks.callHook("entries:updated", head);
-        },
-        dispose() {
-          if (entries.delete(_i)) {
-            head.invalidate();
-          }
-        },
-        // a patch is the same as creating a new entry, just a nice DX
-        patch(input2) {
-          if (!options.mode || options.mode === "server" && ssr || options.mode === "client" && !ssr) {
-            inst.input = input2;
-            entries.set(_i, inst);
-            _._poll();
-          }
-        }
-      };
-      _.patch(input);
-      return _;
-    },
-    async resolveTags() {
-      const ctx = {
-        tagMap: /* @__PURE__ */ new Map(),
-        tags: [],
-        entries: [...head.entries.values()]
-      };
-      await hooks.callHook("entries:resolve", ctx);
-      while (normalizeQueue.size) {
-        const i = normalizeQueue.values().next().value;
-        normalizeQueue.delete(i);
-        const e = entries.get(i);
-        if (e) {
-          const normalizeCtx = {
-            tags: normalizeEntryToTags(e.input, resolvedOptions.propResolvers || []).map((t) => Object.assign(t, e.options)),
-            entry: e
-          };
-          await hooks.callHook("entries:normalize", normalizeCtx);
-          e._tags = normalizeCtx.tags.map((t, i2) => {
-            t._w = tagWeight(head, t);
-            t._p = (e._i << 10) + i2;
-            t._d = dedupeKey(t);
-            if (!t._d)
-              t._h = hashTag(t);
-            return t;
-          });
-        }
-      }
-      let hasFlatMeta = false;
-      ctx.entries.flatMap((e) => (e._tags || []).map((t) => ({ ...t, props: { ...t.props } }))).sort(sortTags).reduce((acc, next) => {
-        const k = next._d || next._h;
-        if (!acc.has(k))
-          return acc.set(k, next);
-        const prev = acc.get(k);
-        const strategy = next?.tagDuplicateStrategy || (UsesMergeStrategy.has(next.tag) ? "merge" : null) || (next.key && next.key === prev.key ? "merge" : null);
-        if (strategy === "merge") {
-          const newProps = { ...prev.props };
-          Object.entries(next.props).forEach(([p, v]) => (
-            // @ts-expect-error untyped
-            newProps[p] = p === "style" ? new Map([...prev.props.style || /* @__PURE__ */ new Map(), ...v]) : p === "class" ? /* @__PURE__ */ new Set([...prev.props.class || /* @__PURE__ */ new Set(), ...v]) : v
-          ));
-          acc.set(k, { ...next, props: newProps });
-        } else if (next._p >> 10 === prev._p >> 10 && next.tag === "meta" && isMetaArrayDupeKey(k)) {
-          acc.set(k, Object.assign([...Array.isArray(prev) ? prev : [prev], next], next));
-          hasFlatMeta = true;
-        } else if (next._w === prev._w ? next._p > prev._p : next?._w < prev?._w) {
-          acc.set(k, next);
-        }
-        return acc;
-      }, ctx.tagMap);
-      const title = ctx.tagMap.get("title");
-      const titleTemplate = ctx.tagMap.get("titleTemplate");
-      head._title = title?.textContent;
-      if (titleTemplate) {
-        const titleTemplateFn = titleTemplate?.textContent;
-        head._titleTemplate = titleTemplateFn;
-        if (titleTemplateFn) {
-          let newTitle = typeof titleTemplateFn === "function" ? titleTemplateFn(title?.textContent) : titleTemplateFn;
-          if (typeof newTitle === "string" && !head.plugins.has("template-params")) {
-            newTitle = newTitle.replace("%s", title?.textContent || "");
-          }
-          if (title) {
-            newTitle === null ? ctx.tagMap.delete("title") : ctx.tagMap.set("title", { ...title, textContent: newTitle });
-          } else {
-            titleTemplate.tag = "title";
-            titleTemplate.textContent = newTitle;
-          }
-        }
-      }
-      ctx.tags = Array.from(ctx.tagMap.values());
-      if (hasFlatMeta) {
-        ctx.tags = ctx.tags.flat().sort(sortTags);
-      }
-      await hooks.callHook("tags:beforeResolve", ctx);
-      await hooks.callHook("tags:resolve", ctx);
-      await hooks.callHook("tags:afterResolve", ctx);
-      const finalTags = [];
-      for (const t of ctx.tags) {
-        const { innerHTML, tag, props } = t;
-        if (!ValidHeadTags.has(tag)) {
-          continue;
-        }
-        if (Object.keys(props).length === 0 && !t.innerHTML && !t.textContent) {
-          continue;
-        }
-        if (tag === "meta" && !props.content && !props["http-equiv"] && !props.charset) {
-          continue;
-        }
-        if (tag === "script" && innerHTML) {
-          if (String(props.type).endsWith("json")) {
-            const v = typeof innerHTML === "string" ? innerHTML : JSON.stringify(innerHTML);
-            t.innerHTML = v.replace(/</g, "\\u003C");
-          } else if (typeof innerHTML === "string") {
-            t.innerHTML = innerHTML.replace(new RegExp(`</${tag}`, "g"), `<\\/${tag}`);
-          }
-          t._d = dedupeKey(t);
-        }
-        finalTags.push(t);
-      }
-      return finalTags;
-    },
-    invalidate() {
-      for (const entry of entries.values()) {
-        normalizeQueue.add(entry._i);
-      }
-      head.dirty = true;
-      hooks.callHook("entries:updated", head);
-    }
-  };
-  (resolvedOptions?.plugins || []).forEach((p) => registerPlugin(head, p));
-  head.hooks.callHook("init", head);
-  resolvedOptions.init?.forEach((e) => e && head.push(e));
-  return head;
-}
-
-export { createUnhead as a, createHeadCore as c };

package/web/.output/server/node_modules/unhead/dist/shared/unhead.CbpEuj3y.mjs

@@ -1,71 +0,0 @@
-const sortTags = (a, b) => a._w === b._w ? a._p - b._p : a._w - b._w;
-const TAG_WEIGHTS = {
-  base: -10,
-  title: 10
-};
-const TAG_ALIASES = {
-  critical: -8,
-  high: -1,
-  low: 2
-};
-const WEIGHT_MAP = {
-  meta: {
-    "content-security-policy": -30,
-    "charset": -20,
-    "viewport": -15
-  },
-  link: {
-    "preconnect": 20,
-    "stylesheet": 60,
-    "preload": 70,
-    "modulepreload": 70,
-    "prefetch": 90,
-    "dns-prefetch": 90,
-    "prerender": 90
-  },
-  script: {
-    async: 30,
-    defer: 80,
-    sync: 50
-  },
-  style: {
-    imported: 40,
-    sync: 60
-  }
-};
-const ImportStyleRe = /@import/;
-const isTruthy = (val) => val === "" || val === true;
-function tagWeight(head, tag) {
-  if (typeof tag.tagPriority === "number")
-    return tag.tagPriority;
-  let weight = 100;
-  const offset = TAG_ALIASES[tag.tagPriority] || 0;
-  const weightMap = head.resolvedOptions.disableCapoSorting ? {
-    link: {},
-    script: {},
-    style: {}
-  } : WEIGHT_MAP;
-  if (tag.tag in TAG_WEIGHTS) {
-    weight = TAG_WEIGHTS[tag.tag];
-  } else if (tag.tag === "meta") {
-    const metaType = tag.props["http-equiv"] === "content-security-policy" ? "content-security-policy" : tag.props.charset ? "charset" : tag.props.name === "viewport" ? "viewport" : null;
-    if (metaType)
-      weight = WEIGHT_MAP.meta[metaType];
-  } else if (tag.tag === "link" && tag.props.rel) {
-    weight = weightMap.link[tag.props.rel];
-  } else if (tag.tag === "script") {
-    const type = String(tag.props.type);
-    if (isTruthy(tag.props.async)) {
-      weight = weightMap.script.async;
-    } else if (tag.props.src && !isTruthy(tag.props.defer) && !isTruthy(tag.props.async) && type !== "module" && !type.endsWith("json") || tag.innerHTML && !type.endsWith("json")) {
-      weight = weightMap.script.sync;
-    } else if (isTruthy(tag.props.defer) && tag.props.src && !isTruthy(tag.props.async) || type === "module") {
-      weight = weightMap.script.defer;
-    }
-  } else if (tag.tag === "style") {
-    weight = tag.innerHTML && ImportStyleRe.test(tag.innerHTML) ? weightMap.style.imported : weightMap.style.sync;
-  }
-  return (weight || 100) + offset;
-}
-
-export { sortTags as s, tagWeight as t };

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

@@ -1,236 +0,0 @@
-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/web/.output/server/node_modules/unhead/dist/shared/unhead.DQc16pHI.mjs

@@ -1,196 +0,0 @@
-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 };