uomtiles 0.1.0

package/.output/server/node_modules/unhead/dist/shared/unhead.DNKiVLV7.mjs

@@ -0,0 +1,400 @@
+import { U as UniqueTags, c as TagsWithInnerContent, M as MetaTagsArrayable, i as isUnsafeKey, H as HasElementTags, T as TagConfigKeys, D as DupeableTags, d as UsesMergeStrategy, V as ValidHeadTags, h as hasContent } from './unhead.CGPOfp5O.mjs';
+import { a as callHook } from './unhead.Bm4Y6XQI.mjs';
+
+const META_NOREWRITE_RE = /^(?:viewport|description|keywords|robots)$/;
+const META_KEY_ATTRS = ["name", "property", "http-equiv"];
+function isMetaArrayDupeKey(v) {
+  const i = v.indexOf(":");
+  if (i === -1)
+    return false;
+  const key = v.slice(i + 1);
+  return MetaTagsArrayable.has(key) || key.startsWith("og:image:") || key.startsWith("og:video:") || key.startsWith("og:audio:") || key.startsWith("twitter:image:");
+}
+function dedupeKey(tag) {
+  const { props, tag: t, key } = tag;
+  if (UniqueTags.has(t))
+    return t;
+  if (t === "link") {
+    if (props.rel === "canonical")
+      return "canonical";
+    if (props.rel === "alternate" && props.hreflang)
+      return `alternate:${props.hreflang}`;
+  }
+  if (props.charset)
+    return "charset";
+  if (t === "meta") {
+    for (const n of META_KEY_ATTRS) {
+      const v = props[n];
+      if (v !== void 0)
+        return `meta:${v}${(typeof v !== "string" || !v.includes(":")) && !META_NOREWRITE_RE.test(v) && key ? `:key:${key}` : ""}`;
+    }
+  }
+  if (key)
+    return `${t}:key:${key}`;
+  if (props.id)
+    return `${t}:id:${props.id}`;
+  if (t === "link" && props.rel && props.href)
+    return `link:${props.rel}:${props.href}`;
+  return TagsWithInnerContent.has(t) && (tag.textContent || tag.innerHTML) ? `${t}:content:${tag.textContent || tag.innerHTML}` : void 0;
+}
+function hashTag(tag) {
+  const identity = tag._h || tag._d || tag.textContent || tag.innerHTML;
+  if (identity)
+    return identity;
+  const keys = Object.keys(tag.props).sort();
+  let hash = `${tag.tag}:`;
+  let separator = "";
+  for (const key of keys) {
+    hash += `${separator}${key}:${String(tag.props[key])}`;
+    separator = ",";
+  }
+  return hash;
+}
+
+function walkResolver(val, resolve, key) {
+  if (key === "_resolver")
+    return val;
+  if (typeof val === "function" && (!key || key !== "titleTemplate" && !key.startsWith("on")))
+    val = val();
+  const v = resolve ? resolve(key, val) : val;
+  if (Array.isArray(v)) {
+    let out;
+    for (let i = 0; i < v.length; i++) {
+      const r = walkResolver(v[i], resolve);
+      if (out) {
+        out[i] = r;
+      } else if (r !== v[i]) {
+        out = v.slice(0, i);
+        out[i] = r;
+      }
+    }
+    return out || v;
+  }
+  if (v?.constructor === Object) {
+    let next;
+    for (const k in v) {
+      const unsafe = isUnsafeKey(k);
+      const r = unsafe ? void 0 : walkResolver(v[k], resolve, k);
+      if (!next && (unsafe || r !== v[k])) {
+        next = {};
+        for (const pk in v) {
+          if (pk === k)
+            break;
+          next[pk] = v[pk];
+        }
+      }
+      if (next && !unsafe)
+        next[k] = r;
+    }
+    return next || v;
+  }
+  return v;
+}
+
+const INVALID_ATTR_NAME_RE = /[\s"'<>/=\x00-\x1F\x7F]/;
+
+function normalizeStyleClassProps(key, value) {
+  const isStyle = key === "style";
+  const store = isStyle ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Set();
+  const add = (v) => {
+    if (!v)
+      return;
+    if (isStyle) {
+      const i = v.indexOf(":");
+      i > 0 && store.set(v.slice(0, i).trim(), v.slice(i + 1).trim());
+    } else {
+      v.split(" ").forEach((c) => c && store.add(c));
+    }
+  };
+  if (typeof value === "string") {
+    (isStyle ? value.split(";") : [value]).forEach(add);
+  } else if (Array.isArray(value)) {
+    value.forEach(add);
+  } else if (value && typeof value === "object") {
+    for (const k in value) {
+      const v = value[k];
+      v && v !== "false" && (isStyle ? store.set(k.trim(), String(v)) : add(k));
+    }
+  }
+  return store;
+}
+function normalizeProps(tag, input) {
+  tag.props = tag.props || {};
+  if (!input)
+    return tag;
+  if (tag.tag === "templateParams") {
+    tag.props = input;
+    return tag;
+  }
+  const isHtmlTag = HasElementTags.has(tag.tag) || tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs";
+  for (const prop in input) {
+    if (isUnsafeKey(prop))
+      continue;
+    const isData = prop.startsWith("data-");
+    const isHtmlAttr = isHtmlTag && !TagConfigKeys.has(prop);
+    const key = isHtmlAttr && !isData ? prop.toLowerCase() : prop;
+    if (isHtmlAttr && (!key || INVALID_ATTR_NAME_RE.test(key)))
+      continue;
+    const value = input[prop];
+    if (value === null) {
+      tag.props[key] = null;
+    } else if (prop === "class" || prop === "style") {
+      tag.props[prop] = normalizeStyleClassProps(prop, value);
+    } else if (TagConfigKeys.has(prop)) {
+      if ((prop === "textContent" || prop === "innerHTML") && typeof value === "object") {
+        const type = input.type || "application/json";
+        if (type.endsWith("json") || type === "speculationrules" || type === "importmap") {
+          tag.props.type = input.type = type;
+          tag[prop] = JSON.stringify(value);
+        }
+      } else {
+        tag[prop] = value;
+      }
+    } else if (value !== void 0) {
+      const str = String(value);
+      const isMeta = tag.tag === "meta" && key === "content";
+      tag.props[key] = str === "true" || str === "" ? isData || isMeta ? str : true : !value && isData && str === "false" ? "false" : value;
+    }
+  }
+  return tag;
+}
+function resolveHeadInput(input, propResolvers) {
+  let resolve;
+  if (propResolvers.length) {
+    resolve = (key, val) => {
+      for (let i = 0; i < propResolvers.length; i++)
+        val = propResolvers[i](key, val);
+      return val;
+    };
+    input = resolve(void 0, input);
+  }
+  return walkResolver(input, resolve);
+}
+function normalizeTag(tagName, _input) {
+  const input = typeof _input === "object" && typeof _input !== "function" ? _input : { [tagName === "script" || tagName === "noscript" || tagName === "style" ? "innerHTML" : "textContent"]: _input };
+  const tag = normalizeProps({ tag: tagName, props: {} }, input);
+  if (tag.key && DupeableTags.has(tag.tag))
+    tag.props["data-hid"] = tag._h = tag.key;
+  if (tag.tag === "script" && typeof tag.innerHTML === "object") {
+    tag.innerHTML = JSON.stringify(tag.innerHTML);
+    tag.props.type = tag.props.type || "application/json";
+  }
+  if (Array.isArray(tag.props.content)) {
+    const tags = [];
+    for (const content of tag.props.content) {
+      tags.push({ ...tag, props: { ...tag.props, content } });
+    }
+    return tags;
+  }
+  return tag;
+}
+function pushNormalizedTag(tags, tag) {
+  if (Array.isArray(tag)) {
+    for (const t of tag) tags.push(t);
+  } else {
+    tags.push(tag);
+  }
+}
+function normalizeEntryToTags(input, propResolvers) {
+  if (!input)
+    return [];
+  if (typeof input === "function")
+    input = input();
+  input = resolveHeadInput(input, propResolvers);
+  const tags = [];
+  for (const key in input) {
+    const value = input[key];
+    if (value !== void 0) {
+      if (Array.isArray(value)) {
+        for (const v of value) pushNormalizedTag(tags, normalizeTag(key, v));
+      } else {
+        pushNormalizedTag(tags, normalizeTag(key, value));
+      }
+    }
+  }
+  return tags;
+}
+
+const LT_RE = /</g;
+const SCRIPT_END_RE = /<\/script/g;
+const sortTags = (a, b) => a._w === b._w ? a._p - b._p : a._w - b._w;
+const DEFAULT_TAG_WEIGHT = () => 100;
+function isEmptyProps(props) {
+  for (const _ in props)
+    return false;
+  return true;
+}
+const TAG_MUTATING_HOOK_RE = /^tags:|:render/;
+function syncEntryHookCache(head, hooks) {
+  const count = (hooks["entries:resolve"]?.length || 0) + (hooks["entries:normalize"]?.length || 0);
+  if (head._h !== count) {
+    head._h = count;
+    for (const entry of head.entries.values())
+      delete entry._tags;
+  }
+}
+function cloneTagsInPlace(tags) {
+  for (let i = 0; i < tags.length; i++) {
+    const t = tags[i];
+    const props = { ...t.props };
+    if (props.class instanceof Set)
+      props.class = new Set(props.class);
+    if (props.style instanceof Map)
+      props.style = new Map(props.style);
+    tags[i] = { ...t, props };
+  }
+}
+function valuesToTags(ctx, sortFlatMeta) {
+  const tags = ctx.tags;
+  let w = 0;
+  for (const value of ctx.tagMap.values()) {
+    if (Array.isArray(value)) {
+      for (const tag of value) tags[w++] = tag;
+    } else {
+      tags[w++] = value;
+    }
+  }
+  tags.length = w;
+  if (sortFlatMeta)
+    tags.sort(sortTags);
+}
+function dedupeTags(ctx) {
+  let hasFlatMeta = false;
+  for (const next of ctx.tags.sort(sortTags)) {
+    const k = next._d || hashTag(next);
+    if (!k)
+      continue;
+    const prev = ctx.tagMap.get(k);
+    if (!prev) {
+      ctx.tagMap.set(k, next);
+      continue;
+    }
+    const strategy = next.tagDuplicateStrategy || (UsesMergeStrategy.has(next.tag) ? "merge" : null) || (next.key && next.key === prev.key ? "merge" : null);
+    if (strategy === "merge") {
+      const props = { ...prev.props };
+      for (const p in next.props) {
+        props[p] = p === "style" ? new Map([...prev.props.style || /* @__PURE__ */ new Map(), ...next.props[p]]) : p === "class" ? /* @__PURE__ */ new Set([...prev.props.class || [], ...next.props[p]]) : next.props[p];
+      }
+      ctx.tagMap.set(k, { ...next, props });
+    } else if (next._p >> 10 === prev._p >> 10 && next.tag === "meta" && isMetaArrayDupeKey(k)) {
+      ctx.tagMap.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) {
+      ctx.tagMap.set(k, next);
+    }
+  }
+  return hasFlatMeta;
+}
+function resolveTitleTemplate(ctx, head) {
+  const title = ctx.tagMap.get("title");
+  const tpl = ctx.tagMap.get("titleTemplate");
+  head._title = title?.textContent;
+  if (!tpl)
+    return;
+  const fn = tpl.textContent;
+  head._titleTemplate = fn;
+  if (!fn)
+    return;
+  let v = typeof fn === "function" ? fn(title?.textContent) : fn;
+  if (typeof v === "string" && !head.plugins.has("template-params"))
+    v = v.replace("%s", title?.textContent || "");
+  if (title) {
+    v === null ? ctx.tagMap.delete("title") : ctx.tagMap.set("title", { ...title, textContent: v });
+  } else {
+    ctx.tagMap.set("titleTemplate", { ...tpl, tag: "title", textContent: v });
+  }
+}
+function sanitizeTagsInPlace(tags) {
+  let w = 0;
+  for (let t of tags) {
+    const { innerHTML, tag, props } = t;
+    if (!ValidHeadTags.has(tag) || isEmptyProps(props) && !hasContent(innerHTML) && !hasContent(t.textContent))
+      continue;
+    if (tag === "meta") {
+      if (!hasContent(props.content) && !props["http-equiv"] && !props.charset)
+        continue;
+    }
+    if (tag === "script" && (innerHTML || t.textContent)) {
+      const type = String(props.type);
+      const isJsonLike = type.endsWith("json") || type === "importmap" || type === "speculationrules";
+      const escape = (content) => isJsonLike ? (typeof content === "string" ? content : JSON.stringify(content)).replace(LT_RE, "\\u003C") : typeof content === "string" ? content.replace(SCRIPT_END_RE, "<\\/script") : content;
+      t = { ...t };
+      if (innerHTML)
+        t.innerHTML = escape(innerHTML);
+      if (t.textContent)
+        t.textContent = escape(t.textContent);
+      t._d = dedupeKey(t);
+    }
+    tags[w++] = t;
+  }
+  tags.length = w;
+  return tags;
+}
+function sanitizeTags(tags) {
+  return sanitizeTagsInPlace([...tags]);
+}
+function resolveTags(head, options) {
+  const weightFn = options?.tagWeight ?? head.resolvedOptions._tagWeight ?? DEFAULT_TAG_WEIGHT;
+  const ctx = { tagMap: /* @__PURE__ */ new Map(), tags: [] };
+  const hooks = head.hooks?._hooks || {};
+  syncEntryHookCache(head, hooks);
+  for (const e of head.entries.values()) {
+    if (e._pending !== void 0) {
+      e.input = e._pending;
+      delete e._pending;
+      delete e._tags;
+      delete e._precomputedTags;
+    }
+  }
+  let entries;
+  if (hooks["entries:resolve"]?.length || hooks["entries:normalize"]?.length) {
+    entries = [...head.entries.values()];
+    if (hooks["entries:resolve"]?.length)
+      callHook(head, "entries:resolve", { entries, ...ctx });
+  }
+  syncEntryHookCache(head, hooks);
+  for (const e of entries || head.entries.values()) {
+    let tags = e._tags;
+    if (!tags) {
+      if (e._precomputedTags && weightFn === head.resolvedOptions._tagWeight && !hooks["entries:normalize"]?.length && !hooks["entries:resolve"]?.length && (!e.options || isEmptyProps(e.options))) {
+        tags = e._precomputedTags;
+      } else {
+        tags = normalizeEntryToTags(e.input, head.resolvedOptions.propResolvers || []);
+        if (e.options && !isEmptyProps(e.options)) {
+          for (const t of tags)
+            Object.assign(t, e.options);
+        }
+        if (hooks["entries:normalize"]?.length) {
+          const normalizeCtx = { tags, entry: e };
+          callHook(head, "entries:normalize", normalizeCtx);
+          tags = normalizeCtx.tags;
+        }
+        for (let i = 0; i < tags.length; i++) {
+          const t = tags[i];
+          t._w = weightFn(t);
+          t._p = (e._i << 10) + i;
+          t._d = dedupeKey(t);
+          if (!t._d)
+            t._h = hashTag(t);
+        }
+        e._tags = tags;
+      }
+    }
+    ctx.tags.push(...tags);
+  }
+  for (const name in hooks) {
+    if (hooks[name]?.length && TAG_MUTATING_HOOK_RE.test(name)) {
+      cloneTagsInPlace(ctx.tags);
+      break;
+    }
+  }
+  const hasFlatMeta = dedupeTags(ctx);
+  resolveTitleTemplate(ctx, head);
+  valuesToTags(ctx, hasFlatMeta);
+  callHook(head, "tags:beforeResolve", ctx);
+  callHook(head, "tags:resolve", ctx);
+  callHook(head, "tags:afterResolve", ctx);
+  return sanitizeTagsInPlace(ctx.tags);
+}
+
+export { INVALID_ATTR_NAME_RE as I, dedupeTags as a, normalizeProps as b, resolveTitleTemplate as c, dedupeKey as d, resolveHeadInput as e, hashTag as h, isMetaArrayDupeKey as i, normalizeEntryToTags as n, resolveTags as r, sanitizeTags as s, walkResolver as w };

package/.output/server/node_modules/unhead/dist/shared/unhead.MC5RsXLj.mjs

@@ -0,0 +1,19 @@
+import { c as createUnhead } from './unhead.D7HkBzZn.mjs';
+import { b as TagPriorityAliases } from './unhead.CGPOfp5O.mjs';
+import { c as createHooks } from './unhead.Bm4Y6XQI.mjs';
+import { c as createClientHeadAdapter } from './unhead.Bb4d5b9h.mjs';
+import { c as createDomRenderer } from './unhead.C3b2Ipoj.mjs';
+
+const tagWeight = (tag) => typeof tag.tagPriority === "number" ? tag.tagPriority : 100 + (TagPriorityAliases[tag.tagPriority] || 0);
+function createHead(options = {}) {
+  options.document = options.document || (typeof window !== "undefined" ? document : void 0);
+  const renderer = options.render || createDomRenderer({ document: options.document });
+  const core = createUnhead(renderer, { document: options.document, propResolvers: options.propResolvers, _tagWeight: tagWeight, init: [] });
+  const hooks = createHooks(options.hooks);
+  const head = createClientHeadAdapter(core, hooks, renderer);
+  options.plugins?.forEach((p) => head.use(p));
+  options.init?.forEach((e) => e && head.push(e));
+  return head;
+}
+
+export { createHead as c };

package/.output/server/node_modules/unhead/dist/shared/unhead.jEy9BmRq.mjs

@@ -0,0 +1,264 @@
+import { u as unpackMeta } from './unhead.BQWSw36o.mjs';
+import { d as defineHeadPlugin } from './unhead.CHEy9ana.mjs';
+import { h as hasContent, i as isUnsafeKey } from './unhead.CGPOfp5O.mjs';
+
+const FlatMetaPlugin = /* @__PURE__ */ defineHeadPlugin({
+  key: "flatMeta",
+  hooks: {
+    "entries:normalize": (ctx) => {
+      let hasFlatMeta = false;
+      const tags = [];
+      const tagsToAdd = [];
+      for (const t of ctx.tags) {
+        if (t.tag !== "_flatMeta") {
+          tags.push(t);
+          continue;
+        }
+        hasFlatMeta = true;
+        for (const props of unpackMeta(t.props))
+          tagsToAdd.push({ ...t, tag: "meta", props });
+      }
+      if (!hasFlatMeta)
+        return;
+      for (const tag of tagsToAdd) tags.push(tag);
+      ctx.tags = tags;
+    }
+  }
+});
+
+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 SafeDataAttrName = /^[a-z][a-z0-9-]*[a-z0-9]$/i;
+const AsciiWhitespace = /[\t\n\f\r ]+/;
+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 (isUnsafeKey(key))
+        continue;
+      clean[key] = stripProtoKeys(obj[key]);
+    }
+    return clean;
+  }
+  return obj;
+}
+function acceptDataAttrs(value, allowId = true) {
+  const next = {};
+  if (!value)
+    return next;
+  const keys = Object.keys(value);
+  for (let i = 0; i < keys.length; i++) {
+    const key = keys[i];
+    const isData = key.startsWith("data-");
+    if ((isData || allowId && key === "id") && SafeDataAttrName.test(key))
+      next[key] = value[key];
+  }
+  return next;
+}
+function hasBlockedRel(rel) {
+  const tokens = rel.split(AsciiWhitespace);
+  return !tokens.some(Boolean) || tokens.some((token) => BlockedLinkRels.has(token.toLowerCase()));
+}
+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 (hasContent(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" || hasBlockedRel(val))) {
+          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;
+        }, []);
+      }
+    },
+    "tags:afterResolve": (ctx) => {
+      ctx.tags = ctx.tags.reduce((acc, tag) => {
+        if (!tag._safe) {
+          acc.push(tag);
+          return acc;
+        }
+        if (tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs") {
+          acc.push(tag);
+          return acc;
+        }
+        const safeTag = makeTagSafe(tag);
+        if (safeTag)
+          acc.push(safeTag);
+        return acc;
+      }, []);
+    }
+  }
+});
+
+export { FlatMetaPlugin as F, SafeInputPlugin as S };