agentworkshop 0.5.1 → 0.5.2

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

@@ -0,0 +1,47 @@
+const BACKSLASH_RE = /\\/g;
+const LT_RE = /</g;
+const DOUBLE_QUOTE_RE = /"/g;
+const TOKEN_RE = /%\w+(?:\.\w+)?/g;
+const SepSub = "%separator";
+function sub(p, token, isJson = false) {
+  let val;
+  if (token === "s" || token === "pageTitle") {
+    val = p.pageTitle;
+  } else if (token.includes(".")) {
+    const dotIndex = token.indexOf(".");
+    val = p[token.substring(0, dotIndex)]?.[token.substring(dotIndex + 1)];
+  } else {
+    val = p[token];
+  }
+  if (val !== void 0) {
+    return isJson ? (val || "").replace(BACKSLASH_RE, "\\\\").replace(LT_RE, "\\u003C").replace(DOUBLE_QUOTE_RE, '\\"') : val || "";
+  }
+  return void 0;
+}
+function processTemplateParams(s, p, sep, isJson = false) {
+  if (typeof s !== "string" || !s.includes("%"))
+    return s;
+  let decoded = s;
+  try {
+    decoded = decodeURI(s);
+  } catch {
+  }
+  const tokens = decoded.match(TOKEN_RE);
+  if (!tokens) {
+    return s;
+  }
+  const hasSepSub = s.includes(SepSub);
+  s = s.replace(TOKEN_RE, (token) => {
+    if (token === SepSub || !tokens.includes(token)) {
+      return token;
+    }
+    const re = sub(p, token.slice(1), isJson);
+    return re !== void 0 ? re : token;
+  }).trim();
+  if (hasSepSub) {
+    s = s.split(SepSub).map((part) => part.trim()).filter((part) => part !== "").join(sep ? ` ${sep} ` : " ");
+  }
+  return s;
+}
+
+export { processTemplateParams as p };

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

@@ -0,0 +1,194 @@
+import { M as MetaTagsArrayable } from './unhead.CGPOfp5O.mjs';
+
+const NAMESPACES = {
+  META: /* @__PURE__ */ new Set(["twitter", "fediverse"]),
+  OG: /* @__PURE__ */ new Set(["og", "book", "article", "profile", "fb", "payment"]),
+  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",
+  paymentExpiresAt: "payment:expires_at",
+  paymentSuccessUrl: "payment:success_url",
+  profileFirstName: "profile:first_name",
+  profileLastName: "profile:last_name",
+  profileUsername: "profile:username",
+  msapplicationConfig: "msapplication-Config",
+  msapplicationTileColor: "msapplication-TileColor",
+  msapplicationTileImage: "msapplication-TileImage"
+};
+const CAPS_RE = /([A-Z])/g;
+const OG_TWITTER_RE = /^(?:og|twitter)/;
+const MetaPackingSchema = {
+  appleItunesApp: {
+    unpack: {
+      entrySeparator: ", ",
+      resolve: ({ key, value }) => `${fixKeyCase(key)}=${value}`
+    }
+  },
+  refresh: {
+    metaKey: "http-equiv",
+    unpack: {
+      entrySeparator: ";",
+      resolve: ({ key, value }) => key === "seconds" ? `${value}` : void 0
+    }
+  },
+  robots: {
+    unpack: {
+      entrySeparator: ", ",
+      resolve: ({ key, value }) => typeof value === "boolean" ? fixKeyCase(key) : `${fixKeyCase(key)}:${value}`
+    }
+  },
+  contentSecurityPolicy: {
+    metaKey: "http-equiv",
+    unpack: {
+      entrySeparator: "; ",
+      resolve: ({ key, value }) => `${fixKeyCase(key)} ${value}`
+    }
+  },
+  charset: {}
+};
+function fixKeyCase(key) {
+  const updated = key.replace(CAPS_RE, "-$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(CAPS_RE, ":$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,
+    ...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_RE, "").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}`,
+              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.Bb4d5b9h.mjs

@@ -0,0 +1,67 @@
+import { r as registerPlugin } from './unhead.D7HkBzZn.mjs';
+
+function createClientHeadAdapter(core, hooks, render) {
+  const corePush = core.push;
+  const head = core;
+  head.ssr = false;
+  head.hooks = hooks;
+  head.dirty = !!head.dirty;
+  head.use = (p) => registerPlugin(head, p);
+  head.render = () => render(head);
+  head.invalidate = () => {
+    for (const entry of head.entries.values())
+      delete entry._tags;
+    head.dirty = true;
+    hooks.callHook("entries:updated", head);
+  };
+  head.push = (input, entryOptions) => {
+    const unhook = entryOptions?.onRendered ? hooks.hook("dom:rendered", entryOptions.onRendered) : void 0;
+    const active = corePush(input, entryOptions);
+    const entry = core.entries.get(active._i);
+    if (entry)
+      entry._o = input;
+    head.dirty = true;
+    hooks.callHook("entries:updated", head);
+    return {
+      _i: active._i,
+      patch(input2) {
+        active.patch(input2);
+        head.dirty = true;
+        hooks.callHook("entries:updated", head);
+      },
+      dispose() {
+        unhook?.();
+        if (core.entries.has(active._i)) {
+          active.dispose();
+          head.invalidate();
+        }
+      }
+    };
+  };
+  hooks.hook("entries:updated", () => {
+    head.render();
+  });
+  return head;
+}
+function createStreamClientHeadAdapter(core, hooks, render, locked) {
+  const head = createClientHeadAdapter(core, hooks, render);
+  const push = head.push;
+  head.push = (input, options) => {
+    if (locked()) {
+      return {
+        _i: -1,
+        patch: () => {
+        },
+        dispose: () => {
+        }
+      };
+    }
+    const active = push(input, options);
+    const patch = active.patch;
+    active.patch = (input2) => !locked() && patch(input2);
+    return active;
+  };
+  return head;
+}
+
+export { createStreamClientHeadAdapter as a, createClientHeadAdapter as c };

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

@@ -0,0 +1,6 @@
+const hasOwnProperty = Object.prototype.hasOwnProperty;
+function hasOwn(object, key) {
+  return hasOwnProperty.call(object, key);
+}
+
+export { hasOwn as h };

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

@@ -0,0 +1,17 @@
+import { HookableCore } from 'hookable';
+
+function createHooks(hooks) {
+  const instance = new HookableCore();
+  for (const key in hooks || {}) {
+    instance.hook(key, hooks[key]);
+  }
+  return instance;
+}
+function callHook(head, hook, ctx) {
+  const hooks = head.hooks?._hooks?.[hook];
+  if (!hooks?.length)
+    return;
+  return head.hooks?.callHook(hook, ctx);
+}
+
+export { callHook as a, createHooks as c };

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

@@ -0,0 +1,231 @@
+import { H as HasElementTags } from './unhead.CGPOfp5O.mjs';
+import { r as resolveTags, i as isMetaArrayDupeKey, b as normalizeProps, d as dedupeKey, h as hashTag } from './unhead.DNKiVLV7.mjs';
+import { a as callHook } from './unhead.Bm4Y6XQI.mjs';
+
+const WHITESPACE_RE = /\s+/;
+// @__NO_SIDE_EFFECTS__
+function createDomRenderer(options = {}) {
+  return (head) => _renderDOMHead(head, options);
+}
+function renderDOMHead(head, options = {}) {
+  return _renderDOMHead(head, options);
+}
+function hasPendingEntries(head) {
+  for (const entry of head.entries.values()) {
+    if (entry._pending !== void 0)
+      return true;
+  }
+  return false;
+}
+function cleanupDomState(state) {
+  for (const k in state._s) state._s[k]();
+  for (const k in state._p) state._p[k]();
+  state._s = {};
+  state._p = {};
+  state._e.clear();
+  state._l.clear();
+}
+function createDomState(head, dom) {
+  const state = { _d: dom, _t: dom.title, _e: /* @__PURE__ */ new Map([["htmlAttrs", dom.documentElement], ["bodyAttrs", dom.body]]), _p: {}, _s: {}, _l: /* @__PURE__ */ new Map() };
+  for (const el of [...dom.body.children, ...dom.head.children]) {
+    const tag = el.tagName.toLowerCase();
+    if (!HasElementTags.has(tag))
+      continue;
+    const props = { innerHTML: el.innerHTML };
+    for (const n of el.getAttributeNames())
+      props[n] = el.getAttribute(n);
+    const next = normalizeProps({ tag, props: {} }, props);
+    next.key = el.getAttribute("data-hid") || void 0;
+    const dedupe = dedupeKey(next) || hashTag(next);
+    let k = dedupe;
+    let c = 1;
+    while (state._e.has(k))
+      k = `${dedupe}:${c++}`;
+    state._e.set(k, el);
+  }
+  for (const entry of head.entries.values()) {
+    if (entry._o !== void 0) {
+      const orig = entry._o;
+      for (const t of ["bodyAttrs", "htmlAttrs"]) {
+        const cls = orig[t]?.class;
+        if (typeof cls === "string") {
+          const $el = state._e.get(t);
+          for (const c of cls.split(WHITESPACE_RE)) {
+            if (c)
+              state._p[`${t}:attr:class:${c}`] = () => $el.classList.remove(c);
+          }
+        }
+      }
+    }
+  }
+  return state;
+}
+function _renderDOMHead(head, options = {}) {
+  const dom = options.document || head.resolvedOptions.document;
+  const activeState = head._dom;
+  const documentChanged = !!activeState && activeState._d !== dom;
+  if (!dom || activeState && !documentChanged && !head.dirty && !hasPendingEntries(head))
+    return false;
+  if (head._du)
+    return false;
+  const defaultView = dom.defaultView;
+  head._du = true;
+  let didRender = false;
+  try {
+    let track = function(id, scope, fn, fresh) {
+      const k = `${id}:${scope}`;
+      renderState._s[k] = !fresh && renderState._p[k] || fn;
+      delete renderState._p[k];
+    }, reclaim = function(key) {
+      const prev = renderState._p[key];
+      delete renderState._p[key];
+      return prev;
+    }, trackEvent = function(id, k, ev, source, $el, target) {
+      const scope = `event:${k}`;
+      const key = `${id}:${scope}`;
+      const prev = renderState._l.get(key);
+      if (prev && prev[0] === target && prev[1] === ev && prev[2] === source) {
+        track(id, scope, prev[4]);
+        return;
+      }
+      prev?.[4]();
+      const dk = `data-${k}`;
+      const handler = ((e) => source.call($el, e));
+      const cleanup = () => {
+        target.removeEventListener(ev, handler);
+        if ($el.getAttribute(dk) === "")
+          $el.removeAttribute(dk);
+        if (renderState._l.get(key)?.[3] === handler)
+          renderState._l.delete(key);
+      };
+      target.addEventListener(ev, handler);
+      renderState._l.set(key, [target, ev, source, handler, cleanup]);
+      $el.setAttribute(dk, "");
+      track(id, scope, cleanup, true);
+    }, trackCtx = function({ id, $el, tag }) {
+      const isAttr = tag.tag.endsWith("Attrs");
+      renderState._e.set(id, $el);
+      if (!isAttr) {
+        const text = tag.textContent;
+        if (text != null && text !== "") {
+          if (text !== $el.textContent)
+            $el.textContent = text;
+          track(id, "text", () => {
+            if ($el.textContent === text)
+              $el.textContent = "";
+          }, true);
+        }
+        const html = tag.innerHTML;
+        if (html != null && html !== "") {
+          if (html !== $el.innerHTML)
+            $el.innerHTML = html;
+          track(id, "html", () => {
+            if ($el.innerHTML === html)
+              $el.innerHTML = "";
+          }, true);
+        }
+        const elKey = `${id}:el`;
+        renderState._s[elKey] = reclaim(elKey) || (() => {
+          $el?.remove();
+          renderState._e.delete(id);
+        });
+      }
+      for (const k in tag.props) {
+        const v = tag.props[k];
+        if (k[0] === "o" && k[1] === "n" && typeof v === "function") {
+          const ev = k.slice(2);
+          if ($el?.dataset?.[`${k}fired`])
+            v.call($el, new (defaultView?.Event || Event)(ev));
+          trackEvent(id, k, ev, v, $el, tag.tag === "bodyAttrs" && defaultView ? defaultView : $el);
+          continue;
+        }
+        const ck = `${id}:attr:${k}`;
+        if (k === "class" && v) {
+          for (const c of v) {
+            const key = `${ck}:${c}`;
+            renderState._s[key] = reclaim(key) || (() => $el.classList.remove(c));
+            if (!$el.classList.contains(c))
+              $el.classList.add(c);
+          }
+        } else if (k === "style" && v) {
+          for (const [sk, sv] of v) {
+            const key = `${ck}:${sk}`;
+            renderState._s[key] = reclaim(key) || (() => $el.style.removeProperty(sk));
+            $el.style.setProperty(sk, sv);
+          }
+        } else if (v !== false && v !== null) {
+          if ($el.getAttribute(k) !== v)
+            $el.setAttribute(k, v === true ? "" : String(v));
+          renderState._s[ck] = reclaim(ck) || (() => $el.removeAttribute(k));
+        }
+      }
+    };
+    const beforeRenderCtx = { shouldRender: true, tags: [] };
+    callHook(head, "dom:beforeRender", beforeRenderCtx);
+    if (!beforeRenderCtx.shouldRender)
+      return false;
+    let state = head._dom;
+    if (state?._d !== dom) {
+      if (state)
+        cleanupDomState(state);
+      state = void 0;
+    }
+    if (!state) {
+      state = createDomState(head, dom);
+    } else {
+      state._p = state._s;
+    }
+    state._s = {};
+    const renderState = state;
+    const pending = [];
+    const frag = {};
+    head.dirty = false;
+    const rawTags = resolveTags(head, options.tagWeight ? { tagWeight: options.tagWeight } : void 0);
+    const tags = [];
+    const dupeKeyCounter = {};
+    for (const tag of rawTags) {
+      const count = dupeKeyCounter[tag._d] || 0;
+      const id = (count ? `${tag._d}:${count}` : tag._d) || tag._h;
+      const ctx = { tag, id, shouldRender: true };
+      if (tag.tag === "meta" && tag._d && isMetaArrayDupeKey(tag._d))
+        dupeKeyCounter[tag._d] = count + 1;
+      tags.push(ctx);
+      if (tag.tag === "title") {
+        dom.title = tag.textContent;
+        track("title", "", () => dom.title = renderState._t);
+        continue;
+      }
+      ctx.$el = renderState._e.get(id);
+      if (ctx.$el)
+        trackCtx(ctx);
+      else if (HasElementTags.has(tag.tag))
+        pending.push(ctx);
+    }
+    for (const ctx of pending) {
+      ctx.$el = dom.createElement(ctx.tag.tag);
+      trackCtx(ctx);
+      (frag[ctx.tag.tagPosition || "head"] ??= dom.createDocumentFragment()).appendChild(ctx.$el);
+    }
+    if (frag.head)
+      dom.head.appendChild(frag.head);
+    if (frag.bodyOpen)
+      dom.body.insertBefore(frag.bodyOpen, dom.body.firstChild);
+    if (frag.bodyClose)
+      dom.body.appendChild(frag.bodyClose);
+    for (const k in renderState._p)
+      renderState._p[k]();
+    head._dom = renderState;
+    didRender = true;
+    callHook(head, "dom:rendered", { renders: tags });
+  } catch (e) {
+    head.dirty = true;
+    throw e;
+  } finally {
+    head._du = false;
+  }
+  if (didRender && (head.dirty || hasPendingEntries(head)))
+    _renderDOMHead(head, options);
+  return didRender;
+}
+
+export { createDomRenderer as c, renderDOMHead as r };

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

@@ -0,0 +1,32 @@
+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",
+  "author",
+  "og:locale:alternate",
+  "og:image",
+  "og:video",
+  "og:audio",
+  "article:author",
+  "article:tag",
+  "book:author",
+  "book:tag",
+  "twitter:image"
+]);
+const TagPriorityAliases = { critical: -8, high: -1, low: 2 };
+const hasContent = (value) => typeof value === "number" ? Number.isFinite(value) : value;
+
+// @__NO_SIDE_EFFECTS__
+function isUnsafeKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+
+export { DupeableTags as D, HasElementTags as H, MetaTagsArrayable as M, ScriptNetworkEvents as S, TagConfigKeys as T, UniqueTags as U, ValidHeadTags as V, SelfClosingTags as a, TagPriorityAliases as b, TagsWithInnerContent as c, UsesMergeStrategy as d, hasContent as h, isUnsafeKey as i };

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

@@ -0,0 +1,7 @@
+function defineHeadPlugin(plugin, key) {
+  if (key && typeof plugin === "function")
+    plugin.key = key;
+  return plugin;
+}
+
+export { defineHeadPlugin as d };

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

@@ -0,0 +1,27 @@
+function createSpyProxy(target, onApply) {
+  const stack = [];
+  let stackIdx = -1;
+  const handler = (reuseStack = false) => ({
+    get(_, prop, receiver) {
+      if (!reuseStack) {
+        stackIdx++;
+        stack[stackIdx] = [];
+      }
+      const v = Reflect.get(_, prop, receiver);
+      if (typeof v === "object" || typeof v === "function") {
+        stack[stackIdx].push({ type: "get", key: prop });
+        return new Proxy(v, handler(true));
+      }
+      stack[stackIdx].push({ type: "get", key: prop, value: v });
+      return v;
+    },
+    apply(_, __, args) {
+      stack[stackIdx].push({ type: "apply", key: "", args });
+      onApply(stack);
+      return Reflect.apply(_, __, args);
+    }
+  });
+  return new Proxy(target, handler());
+}
+
+export { createSpyProxy as c };