shelfware 0.0.1 → 0.1.0

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.BQWSw36o.mjs

@@ -0,0 +1,192 @@
+import { M as MetaTagsArrayable } from './unhead.CGPOfp5O.mjs';
+
+const META_NAMESPACES = ["twitter", "fediverse"];
+const PROPERTY_NAMESPACES = ["og", "book", "article", "profile", "fb", "payment"];
+const MEDIA_KEYS = ["ogImage", "ogVideo", "ogAudio", "twitterImage"];
+const HTTP_EQUIV_KEYS = ["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 : META_NAMESPACES.includes(updated.slice(0, prefixIndex)) || PROPERTY_NAMESPACES.includes(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" || HTTP_EQUIV_KEYS.includes(key)) {
+    return "http-equiv";
+  }
+  const fixed = fixKeyCase(key);
+  const colonIndex = fixed.indexOf(":");
+  return colonIndex === -1 ? "name" : PROPERTY_NAMESPACES.includes(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 (MEDIA_KEYS.includes(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.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.Bjbp1C8D.mjs

@@ -0,0 +1,224 @@
+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.-hZVKou0.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 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 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;
+  if (!dom || head._du || activeState && activeState._d === dom && !head.dirty && !hasPendingEntries(head))
+    return false;
+  const defaultView = dom.defaultView;
+  head._du = true;
+  let didRender = false;
+  try {
+    let track = function(key, fn, fresh) {
+      renderState._s[key] = !fresh && previous[key] || fn;
+      delete previous[key];
+    }, trackEvent = function(id, k, ev, source, $el, target) {
+      const key = `${id}:event:${k}`;
+      const prev = renderState._l.get(key);
+      if (prev && prev[0] === target && prev[1] === ev && prev[2] === source) {
+        track(key, 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(key, cleanup, true);
+    }, trackCtx = function({ id, $el, tag }) {
+      renderState._e.set(id, $el);
+      if (!tag.tag.endsWith("Attrs")) {
+        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`;
+        track(elKey, previous[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}`;
+            track(key, previous[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}`;
+            track(key, previous[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));
+          track(ck, previous[ck] || (() => $el.removeAttribute(k)));
+        }
+      }
+    };
+    const beforeRenderCtx = { shouldRender: true, tags: [] };
+    callHook(head, "dom:beforeRender", beforeRenderCtx);
+    if (!beforeRenderCtx.shouldRender)
+      return false;
+    let state = activeState;
+    if (state?._d !== dom) {
+      if (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();
+      }
+      state = void 0;
+    }
+    if (!state) {
+      state = createDomState(head, dom);
+    } else {
+      state._p = state._s;
+    }
+    state._s = {};
+    const renderState = state;
+    const previous = renderState._p;
+    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);
+    }
+    if (pending.length) {
+      const tracked = new Set(renderState._e.values());
+      for (const el of [...dom.body.children, ...dom.head.children]) {
+        const elTag = el.tagName.toLowerCase();
+        if (!HasElementTags.has(elTag) || tracked.has(el))
+          continue;
+        const props = { innerHTML: el.innerHTML };
+        for (const n of el.getAttributeNames())
+          props[n] = el.getAttribute(n);
+        const next = normalizeProps({ tag: elTag, props: {} }, props);
+        next.key = el.getAttribute("data-hid") || void 0;
+        const dedupe = dedupeKey(next) || hashTag(next);
+        let k = dedupe;
+        let c = 1;
+        while (renderState._e.has(k))
+          k = `${dedupe}:${c++}`;
+        renderState._e.set(k, el);
+      }
+    }
+    for (const ctx of pending) {
+      const found = renderState._e.get(ctx.id);
+      ctx.$el = found || dom.createElement(ctx.tag.tag);
+      trackCtx(ctx);
+      if (!found)
+        (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 previous)
+      previous[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.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.C5Bksi2B.mjs

@@ -0,0 +1,49 @@
+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);
+  function notify() {
+    hooks.callHook("entries:updated", head);
+    if (!head._b)
+      head.render();
+  }
+  head.invalidate = () => {
+    for (const entry of head.entries.values())
+      delete entry._tags;
+    head.dirty = true;
+    notify();
+  };
+  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;
+    notify();
+    return {
+      _i: active._i,
+      patch(input2) {
+        active.patch(input2);
+        head.dirty = true;
+        notify();
+      },
+      dispose() {
+        unhook?.();
+        if (core.entries.has(active._i)) {
+          active.dispose();
+          head.invalidate();
+        }
+      }
+    };
+  };
+  return head;
+}
+
+export { createClientHeadAdapter as c };

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.D7HkBzZn.mjs

@@ -0,0 +1,59 @@
+function registerPlugin(head, p) {
+  if (typeof p === "function" && p.key && head.plugins.has(p.key))
+    return;
+  const plugin = typeof p === "function" ? p(head) : p;
+  const key = plugin.key || String(head.plugins.size + 1);
+  if (!head.plugins.get(key)) {
+    head.plugins.set(key, plugin);
+    for (const k in plugin.hooks || {})
+      head.hooks?.hook(k, plugin.hooks[k]);
+  }
+}
+// @__NO_SIDE_EFFECTS__
+function createUnhead(renderer, resolvedOptions = {}) {
+  const ssr = !resolvedOptions.document;
+  const entries = /* @__PURE__ */ new Map();
+  const plugins = /* @__PURE__ */ new Map();
+  const head = {
+    _entryCount: 1,
+    _h: 0,
+    plugins,
+    resolvedOptions,
+    ssr,
+    entries,
+    // adapters decorate this same object; reserve the slot to keep its shape stable
+    hooks: void 0,
+    render: () => renderer(head),
+    use: (p) => registerPlugin(head, p),
+    push(input, _options) {
+      const _i = _options?._index ?? head._entryCount++;
+      const options = _options ? { ..._options } : {};
+      delete options.head;
+      delete options.onRendered;
+      delete options._index;
+      const entry = { _i, input, options };
+      entries.set(_i, entry);
+      const active = {
+        _i,
+        dispose() {
+          entries.delete(_i);
+        },
+        patch(input2) {
+          if (ssr) {
+            entry.input = input2;
+            delete entry._tags;
+          } else {
+            entry._pending = input2;
+          }
+          if (!entries.has(_i))
+            entries.set(_i, entry);
+        }
+      };
+      return active;
+    }
+  };
+  resolvedOptions.init?.forEach((e) => e && head.push(e));
+  return head;
+}
+
+export { createUnhead as c, registerPlugin as r };