@highstate/designer 0.7.2 → 0.7.3

package/.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 };

package/.output/server/node_modules/unhead/dist/shared/unhead.DZbvapt-.mjs

@@ -1,70 +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") {
-    if (isTruthy(tag.props.async)) {
-      weight = weightMap.script.async;
-    } else if (tag.props.src && !isTruthy(tag.props.defer) && !isTruthy(tag.props.async) && tag.props.type !== "module" && !tag.props.type?.endsWith("json")) {
-      weight = weightMap.script.sync;
-    } else if (isTruthy(tag.props.defer) && tag.props.src && !isTruthy(tag.props.async)) {
-      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/.output/server/node_modules/unhead/dist/shared/unhead.DeCxexjU.mjs

@@ -1,166 +0,0 @@
-import { d as defineHeadPlugin } from './unhead.CApf5sj3.mjs';
-import { s as sortTags } from './unhead.DZbvapt-.mjs';
-import { p as processTemplateParams } from './unhead.C13swrCa.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/.output/server/node_modules/unhead/dist/shared/unhead.Txd0XTIP.mjs

@@ -1,172 +0,0 @@
-import { createHooks } from 'hookable';
-import { n as normalizeEntryToTags, d as dedupeKey, i as isMetaArrayDupeKey } from './unhead.Cp0iF6eN.mjs';
-import { t as tagWeight, s as sortTags } from './unhead.DZbvapt-.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 = [];
-  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.push(_i);
-          hooks.callHook("entries:updated", head);
-        },
-        dispose() {
-          if (entries.delete(_i)) {
-            _._poll(true);
-          }
-        },
-        // 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.length) {
-        const i = normalizeQueue.shift();
-        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);
-            return t;
-          });
-        }
-      }
-      let hasFlatMeta = false;
-      ctx.entries.flatMap((e) => (e._tags || []).map((t) => ({ ...t, props: { ...t.props } }))).sort(sortTags).reduce((acc, next) => {
-        const k = String(next._d || next._p);
-        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 && isMetaArrayDupeKey(next._d)) {
-          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 = typeof titleTemplateFn === "string" ? titleTemplateFn : void 0;
-        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 (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;
-    }
-  };
-  (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/.output/server/node_modules/unhead/dist/shared/unhead.yem5I2v_.mjs

@@ -1,38 +0,0 @@
-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/.output/server/node_modules/unhead/dist/utils.mjs

@@ -1,5 +0,0 @@
-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.Cp0iF6eN.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.DZbvapt-.mjs';
-export { p as processTemplateParams } from './shared/unhead.C13swrCa.mjs';