uomtiles 0.1.3 → 0.1.6

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

@@ -1,240 +0,0 @@
-import { d as defineHeadPlugin } from './unhead.CHEy9ana.mjs';
-import { p as processTemplateParams } from './unhead.BGFxPGPQ.mjs';
-
-const sortTags = (a, b) => a._w === b._w ? a._p - b._p : a._w - b._w;
-const formatKey = (k) => !k.includes(":key") ? k.split(":").join(":key:") : k;
-const AliasSortingPlugin = /* @__PURE__ */ 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 ("body" in tag.props) {
-          if (tag.props.body) {
-            tag.tagPosition = "bodyClose";
-          }
-          delete tag.props.body;
-        }
-        if (tag.props.renderPriority != null) {
-          tag.tagPriority = tag.props.renderPriority;
-          delete tag.props.renderPriority;
-        }
-      }
-    }
-  }
-});
-
-function isThenable(v) {
-  return typeof v?.then === "function";
-}
-const maxSyncPrefix = 256;
-function walkArrayPromises(v, index) {
-  if (index === v.length)
-    return;
-  if (index === maxSyncPrefix) {
-    const values2 = new Array(v.length);
-    let hasThenable = false;
-    for (; index < v.length; index++) {
-      const value2 = walkPromises(v[index]);
-      values2[index] = value2;
-      hasThenable ||= isThenable(value2);
-    }
-    return hasThenable ? values2 : void 0;
-  }
-  const value = walkPromises(v[index]);
-  if (isThenable(value)) {
-    const values2 = new Array(v.length);
-    values2[index] = value;
-    for (let rest = index + 1; rest < v.length; rest++)
-      values2[rest] = walkPromises(v[rest]);
-    return values2;
-  }
-  const values = walkArrayPromises(v, index + 1);
-  if (values)
-    values[index] = value;
-  return values;
-}
-function walkObjectPromises(v, keys, index) {
-  if (index === keys.length)
-    return;
-  if (index === maxSyncPrefix) {
-    const values2 = new Array(keys.length);
-    let hasThenable = false;
-    for (; index < keys.length; index++) {
-      const value2 = walkPromises(v[keys[index]]);
-      values2[index] = value2;
-      hasThenable ||= isThenable(value2);
-    }
-    return hasThenable ? values2 : void 0;
-  }
-  const value = walkPromises(v[keys[index]]);
-  if (isThenable(value)) {
-    const values2 = new Array(keys.length);
-    values2[index] = value;
-    for (let rest = index + 1; rest < keys.length; rest++)
-      values2[rest] = walkPromises(v[keys[rest]]);
-    return values2;
-  }
-  const values = walkObjectPromises(v, keys, index + 1);
-  if (values)
-    values[index] = value;
-  return values;
-}
-function walkPromises(v) {
-  if (typeof v === "function")
-    return v;
-  if (isThenable(v))
-    return Promise.resolve(v).then(walkPromises);
-  if (Array.isArray(v)) {
-    const values = walkArrayPromises(v, 0);
-    return values ? Promise.all(values) : v;
-  }
-  if (v?.constructor === Object) {
-    const keys = Object.keys(v);
-    const values = walkObjectPromises(v, keys, 0);
-    if (values) {
-      return Promise.all(values).then((resolved) => Object.fromEntries(
-        keys.map((key, index) => [key, resolved[index]])
-      ));
-    }
-  }
-  return v;
-}
-const PromisesPlugin = /* @__PURE__ */ defineHeadPlugin((head) => {
-  const pending = /* @__PURE__ */ new WeakMap();
-  return {
-    key: "promises",
-    hooks: {
-      "entries:resolve": (ctx) => {
-        for (let index = ctx.entries.length - 1; index >= 0; index--) {
-          const entry = ctx.entries[index];
-          const input = entry.input;
-          if (pending.get(entry) === input) {
-            ctx.entries.splice(index, 1);
-            continue;
-          }
-          const result = walkPromises(input);
-          if (!isThenable(result)) {
-            pending.delete(entry);
-            continue;
-          }
-          pending.set(entry, input);
-          ctx.entries.splice(index, 1);
-          void Promise.resolve(result).then(
-            (resolved) => {
-              if (pending.get(entry) !== input)
-                return;
-              pending.delete(entry);
-              entry.input = resolved;
-              delete entry._tags;
-              head.invalidate?.();
-            },
-            () => {
-              if (pending.get(entry) === input)
-                pending.delete(entry);
-            }
-          );
-        }
-      }
-    }
-  };
-}, "promises");
-
-const SupportedAttrs = {
-  meta: "content",
-  link: "href",
-  htmlAttrs: "lang"
-};
-const contentAttrs = ["innerHTML", "textContent"];
-function processIfNeeded(value, params, separator, isJson = false) {
-  return typeof value === "string" && value.includes("%") ? processTemplateParams(value, params, separator, isJson) : value;
-}
-const TemplateParamsPlugin = /* @__PURE__ */ defineHeadPlugin((head) => {
-  return {
-    key: "template-params",
-    hooks: {
-      "tags:resolve": ({ tagMap, tags }) => {
-        const params = tagMap.get("templateParams")?.props || {};
-        const sep = params.separator || "|";
-        delete params.separator;
-        params.pageTitle = processIfNeeded(
-          // 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] = processIfNeeded(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] = processIfNeeded(tag[p], params, sep, tag.tag === "script" && typeof tag.props.type === "string" && 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 = processIfNeeded(title.textContent, head._templateParams, head._separator);
-        }
-      }
-    }
-  };
-}, "template-params");
-
-export { AliasSortingPlugin as A, DeprecationsPlugin as D, PromisesPlugin as P, TemplateParamsPlugin as T };

package/.output/server/node_modules/unhead/dist/stream/client.mjs

@@ -1,28 +0,0 @@
-import { a as createStreamClientHeadAdapter } from '../shared/unhead.Bb4d5b9h.mjs';
-import { c as createHooks } from '../shared/unhead.Bm4Y6XQI.mjs';
-import '../shared/unhead.D7HkBzZn.mjs';
-import 'hookable';
-
-const DEFAULT_STREAM_KEY = "__unhead__";
-function createStreamableHead(options = {}) {
-  const { streamKey = DEFAULT_STREAM_KEY, ...rest } = options;
-  const win = typeof window !== "undefined" ? window : void 0;
-  const streamQueue = win?.[streamKey];
-  const core = streamQueue?._head;
-  if (!core)
-    return void 0;
-  if (core._wrapped)
-    return core;
-  const isHydrationLocked = () => streamQueue?._hydrationLocked?.() ?? false;
-  const coreRender = core.render;
-  const hooks = createHooks(rest.hooks);
-  const head = createStreamClientHeadAdapter(core, hooks, () => coreRender(), isHydrationLocked);
-  head._wrapped = true;
-  (rest.plugins || []).forEach((p) => head.use(p));
-  rest.init?.forEach((e) => e && head.push(e));
-  if (streamQueue)
-    streamQueue._head = head;
-  return head;
-}
-
-export { DEFAULT_STREAM_KEY, createStreamableHead };

package/.output/server/node_modules/unhead/dist/stream/iife.mjs

@@ -1,2 +0,0 @@
-export const streamingIifeCode = "var __unhead_iife__ = (function (exports) { 'use strict'; const DupeableTags = new Set([\"link\", \"style\", \"script\", \"noscript\"]); const TagsWithInnerContent = new Set([\"title\", \"titleTemplate\", \"script\", \"style\", \"noscript\"]); const HasElementTags = new Set([\"base\", \"meta\", \"link\", \"style\", \"script\", \"noscript\"]); const ValidHeadTags = new Set([\"title\", \"base\", \"htmlAttrs\", \"bodyAttrs\", \"meta\", \"link\", \"style\", \"script\", \"noscript\"]); const UniqueTags = new Set([\"base\", \"title\", \"titleTemplate\", \"bodyAttrs\", \"htmlAttrs\", \"templateParams\"]); const TagConfigKeys = new Set([\"key\", \"tagPosition\", \"tagPriority\", \"tagDuplicateStrategy\", \"innerHTML\", \"textContent\", \"\u0070rocessTemplateParams\"]); const UsesMergeStrategy = new Set([\"templateParams\", \"htmlAttrs\", \"bodyAttrs\"]); const MetaTagsArrayable = 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 hasContent = (value) => typeof value === \"number\" ? Number.isFinite(value) : value; function isUnsafeKey(key) { return key === \"__proto__\" || key === \"constructor\" || key === \"prototype\"; } function callHook(head, hook, ctx) { const hooks = head.hooks?._hooks?.[hook]; if (!hooks?.length) return; return head.hooks?.callHook(hook, ctx); } 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 ? new Map() : 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 || new Map(), ...next.props[p]]) : p === \"class\" ? 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 resolveTags(head, options) { const weightFn = options?.tagWeight ?? head.resolvedOptions._tagWeight ?? DEFAULT_TAG_WEIGHT; const ctx = { tagMap: 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); } const WHITESPACE_RE = /\\s+/; function createDomRenderer(options = {}) { return (head) => _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: new Map([[\"htmlAttrs\", dom.documentElement], [\"bodyAttrs\", dom.body]]), _p: {}, _s: {}, _l: 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(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 }) { 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`; 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); } 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 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; } 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]); } } function createUnhead(renderer, resolvedOptions = {}) { const ssr = !resolvedOptions.document; const entries = new Map(); const plugins = new Map(); const head = { _entryCount: 1, _h: 0, plugins, resolvedOptions, ssr, entries, 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; } const DEFAULT_STREAM_KEY = \"__unhead__\"; function init(options = {}) { const { streamKey = DEFAULT_STREAM_KEY } = options; const win = \u0074ypeof window !== \"undefined\" ? window : void 0; if (!win) return; const queue = win[streamKey]; if (queue?._head) return queue._head; const doc = typeof document !== \"undefined\" ? document : void 0; const head = createUnhead(createDomRenderer(), { document: doc }); let hydrationLocked = true; queueMicrotask(() => { hydrationLocked = false; }); function pushStreamed(entry) { const active = head.push(entry); const stored = head.entries.get(active._i); if (stored) stored._streamed = true; } if (queue?._q) { for (const entries of queue._q) { for (const entry of entries) { pushStreamed(entry); } } head.dirty = true; head.render(); } win[streamKey] = { _q: queue?._q || [], _head: head, _hydrationLocked: () => hydrationLocked, push: (entries) => { for (const entry of entries) { pushStreamed(entry); } head.dirty = true; head.render(); } }; return head; } exports.init = init; return exports; })({});__unhead_iife__.init();";
-export const streamingIifeSize = 21357;

package/.output/server/node_modules/unhead/dist/stream/server.mjs

@@ -1,264 +0,0 @@
-import { parseHtmlForIndexes, applyHeadToHtml } from '../parser.mjs';
-export { prepareTemplate } from '../parser.mjs';
-import { c as createHead } from '../shared/unhead.CfKy3Kuq.mjs';
-import { e as resolveHeadInput } from '../shared/unhead.DNKiVLV7.mjs';
-import { DEFAULT_STREAM_KEY } from './client.mjs';
-import '../shared/unhead.Bf_fPVYA.mjs';
-import '../shared/unhead.D7HkBzZn.mjs';
-import '../shared/unhead.Bm4Y6XQI.mjs';
-import 'hookable';
-import '../shared/unhead.CGPOfp5O.mjs';
-import '../shared/unhead.Bb4d5b9h.mjs';
-
-const LT_RE = /</g;
-const GT_RE = />/g;
-const AMP_RE = /&/g;
-const SSR_OUTLET_RE = /<!--\s*(?:app-html|ssr-outlet)\s*-->/;
-let encoder;
-let preparedStreamingLayouts;
-const VALID_STREAM_KEY_RE = /^[$_a-z][$\w]*$/i;
-function assertValidStreamKey(streamKey) {
-  if (typeof streamKey !== "string" || !VALID_STREAM_KEY_RE.test(streamKey)) {
-    throw new Error(
-      `[unhead] Invalid streamKey: must be a valid JavaScript identifier matching ${VALID_STREAM_KEY_RE}. Received: ${JSON.stringify(streamKey)}`
-    );
-  }
-}
-// @__NO_SIDE_EFFECTS__
-function createStreamableHead(options = {}) {
-  const { streamKey, ...rest } = options;
-  if (streamKey !== void 0)
-    assertValidStreamKey(streamKey);
-  const head = createHead({
-    ...rest,
-    experimentalStreamKey: streamKey
-  });
-  let resolveShellReady;
-  const shellReady = new Promise((resolve) => {
-    resolveShellReady = resolve;
-  });
-  return {
-    head,
-    onShellReady: () => resolveShellReady(),
-    shellReady
-  };
-}
-function getStreamKey(head) {
-  const key = head.resolvedOptions.experimentalStreamKey || DEFAULT_STREAM_KEY;
-  assertValidStreamKey(key);
-  return key;
-}
-function createBootstrapScript(streamKey = DEFAULT_STREAM_KEY, nonce) {
-  assertValidStreamKey(streamKey);
-  const nonceAttr = nonce ? ` nonce="${nonce.replace(/"/g, "&quot;")}"` : "";
-  return `<script${nonceAttr}>window.${streamKey}={_q:[],push(e){this._q.push(e)}}<\/script>`;
-}
-function renderShell(head) {
-  const result = head.render();
-  head.entries.clear();
-  return result;
-}
-function renderSSRHeadShell(head, template) {
-  const parsed = typeof template === "string" ? parseHtmlForIndexes(template) : template;
-  const result = applyShellToTemplate(head, head.render(), parsed);
-  head.entries.clear();
-  return result;
-}
-function applyShellToTemplate(head, ssr, parsed) {
-  return applyHeadToHtml(parsed, {
-    htmlAttrs: ssr.htmlAttrs,
-    headTags: createBootstrapScript(getStreamKey(head)) + ssr.headTags,
-    bodyAttrs: ssr.bodyAttrs,
-    bodyTags: ssr.bodyTags
-  });
-}
-function renderSSRHeadSuspenseChunk(head) {
-  if (!head.entries.size)
-    return "";
-  const streamKey = getStreamKey(head);
-  const propResolvers = head.resolvedOptions.propResolvers || [];
-  let serialized;
-  try {
-    const inputs = Array.from(head.entries.values(), (e) => resolveHeadInput(e.input, propResolvers));
-    serialized = safeJsonStringify(inputs);
-  } catch (error) {
-    for (const [key, entry] of head.entries) {
-      try {
-        safeJsonStringify(resolveHeadInput(entry.input, propResolvers));
-      } catch {
-        head.entries.delete(key);
-      }
-    }
-    throw error;
-  }
-  head.entries.clear();
-  return `window.${streamKey}.push(${serialized})`;
-}
-function safeJsonStringify(obj) {
-  return JSON.stringify(obj).replace(LT_RE, "\\u003c").replace(GT_RE, "\\u003e").replace(AMP_RE, "\\u0026");
-}
-function wrapStream(head, stream, template, preRenderedState, options) {
-  const flushChunk = options?.flushChunk;
-  const enc = encoder ??= new TextEncoder();
-  let reader;
-  let end = "";
-  return new ReadableStream({
-    // Async so a failure here rejects into an errored stream instead of
-    // throwing synchronously out of the constructor. The reader is acquired
-    // before rendering (and released if rendering fails) so a failure at
-    // either step leaves `head.entries` intact and the upstream unlocked
-    // for retry.
-    async start(controller) {
-      const activeReader = stream.getReader();
-      let parts;
-      try {
-        parts = prepareStreamingTemplate(head, template, preRenderedState);
-      } catch (error) {
-        activeReader.releaseLock();
-        throw error;
-      }
-      reader = activeReader;
-      end = parts.end;
-      controller.enqueue(enc.encode(parts.shell));
-    },
-    // Read at most one upstream chunk per downstream request so backpressure
-    // propagates instead of eagerly draining the app stream.
-    async pull(controller) {
-      const activeReader = reader;
-      if (!activeReader)
-        return;
-      const result = await activeReader.read().then(
-        (value) => ({ ok: true, value }),
-        (error) => ({ ok: false, error })
-      );
-      if (activeReader !== reader)
-        return;
-      if (!result.ok) {
-        reader = void 0;
-        activeReader.releaseLock();
-        controller.error(result.error);
-        return;
-      }
-      if (result.value.done) {
-        reader = void 0;
-        activeReader.releaseLock();
-        const extra2 = flushChunk?.();
-        if (extra2)
-          controller.enqueue(enc.encode(extra2));
-        if (end)
-          controller.enqueue(enc.encode(end));
-        controller.close();
-        return;
-      }
-      controller.enqueue(result.value.value);
-      const extra = flushChunk?.();
-      if (extra)
-        controller.enqueue(enc.encode(extra));
-    },
-    async cancel(reason) {
-      const activeReader = reader;
-      reader = void 0;
-      if (activeReader) {
-        try {
-          await activeReader.cancel(reason);
-        } catch {
-        }
-        activeReader.releaseLock();
-      }
-    }
-  });
-}
-function createStreamingTemplateLayout(parsed) {
-  const html = parsed.html;
-  const bodyEnd = parsed.indexes.bodyTagEnd;
-  const bodyCloseStart = parsed.indexes.bodyCloseTagStart;
-  if (bodyEnd < 0 || bodyCloseStart < 0)
-    return;
-  const bodyInterior = html.substring(bodyEnd, bodyCloseStart);
-  const markerMatch = bodyInterior.match(SSR_OUTLET_RE);
-  let beforeStream;
-  let afterStream;
-  if (markerMatch) {
-    beforeStream = bodyInterior.substring(0, markerMatch.index);
-    afterStream = bodyInterior.substring(markerMatch.index + markerMatch[0].length);
-  } else {
-    beforeStream = "";
-    afterStream = bodyInterior;
-  }
-  const shellPart = html.substring(0, bodyEnd) + beforeStream;
-  const endPart = html.substring(bodyCloseStart);
-  let shellTemplate;
-  if (bodyCloseStart >= bodyEnd) {
-    const shellLen = shellPart.length;
-    const { htmlTagStart, headTagEnd, bodyTagStart } = parsed.indexes;
-    const shellHtmlTagStart = htmlTagStart >= 0 && htmlTagStart + 5 <= shellLen ? htmlTagStart : -1;
-    let shellHtmlTagEnd = -1;
-    if (shellHtmlTagStart >= 0) {
-      const gt = shellPart.indexOf(">", shellHtmlTagStart);
-      shellHtmlTagEnd = gt >= 0 ? gt + 1 : shellLen + 7;
-    }
-    shellTemplate = {
-      html: `${shellPart}</body></html>`,
-      input: parsed.input,
-      indexes: {
-        htmlTagStart: shellHtmlTagStart,
-        htmlTagEnd: shellHtmlTagEnd,
-        headTagEnd: headTagEnd >= 0 && headTagEnd + 7 <= shellLen ? headTagEnd : -1,
-        // <body> is always fully inside the prefix in this branch.
-        bodyTagStart,
-        bodyTagEnd: bodyEnd,
-        bodyCloseTagStart: bodyCloseStart + 7 <= shellLen ? bodyCloseStart : shellLen
-      }
-    };
-  } else {
-    shellTemplate = parseHtmlForIndexes(`${shellPart}</body></html>`);
-  }
-  return {
-    shellTemplate,
-    endBeforeBodyTags: afterStream,
-    endAfterBodyTags: endPart
-  };
-}
-function getPreparedStreamingLayout(template) {
-  const cache = preparedStreamingLayouts ||= /* @__PURE__ */ new WeakMap();
-  let layout = cache.get(template);
-  if (layout === void 0) {
-    layout = createStreamingTemplateLayout(template) || null;
-    if (layout) {
-      Object.freeze(layout.shellTemplate.indexes);
-      Object.freeze(layout.shellTemplate);
-      Object.freeze(layout);
-    }
-    cache.set(template, layout);
-  }
-  return layout || void 0;
-}
-function prepareStreamingTemplate(head, template, preRenderedState) {
-  const ssr = preRenderedState ?? head.render();
-  const parsed = typeof template === "string" ? parseHtmlForIndexes(template) : template;
-  const layout = typeof template === "string" ? createStreamingTemplateLayout(parsed) : getPreparedStreamingLayout(template);
-  let parts;
-  if (layout) {
-    const shell = applyHeadToHtml(layout.shellTemplate, {
-      htmlAttrs: ssr.htmlAttrs,
-      headTags: createBootstrapScript(getStreamKey(head)) + ssr.headTags,
-      bodyAttrs: ssr.bodyAttrs,
-      bodyTags: ""
-    }).replace("</body></html>", "");
-    parts = {
-      shell,
-      end: layout.endBeforeBodyTags + ssr.bodyTags + layout.endAfterBodyTags
-    };
-  } else {
-    parts = {
-      shell: applyShellToTemplate(head, ssr, parsed),
-      end: ""
-    };
-  }
-  if (!preRenderedState) {
-    head.entries.clear();
-  }
-  return parts;
-}
-
-export { createBootstrapScript, createStreamableHead, prepareStreamingTemplate, renderSSRHeadShell, renderSSRHeadSuspenseChunk, renderShell, wrapStream };

package/.output/server/node_modules/unhead/dist/utils.mjs

@@ -1,7 +0,0 @@
-export { D as DupeableTags, H as HasElementTags, M as MetaTagsArrayable, S as ScriptNetworkEvents, a as SelfClosingTags, T as TagConfigKeys, b as TagPriorityAliases, c as TagsWithInnerContent, U as UniqueTags, d as UsesMergeStrategy, V as ValidHeadTags } from './shared/unhead.CGPOfp5O.mjs';
-export { d as dedupeKey, a as dedupeTags, h as hashTag, i as isMetaArrayDupeKey, n as normalizeEntryToTags, b as normalizeProps, r as resolveTags, c as resolveTitleTemplate, s as sanitizeTags, w as walkResolver } from './shared/unhead.DNKiVLV7.mjs';
-export { h as hasOwn } from './shared/unhead.Bf_fPVYA.mjs';
-export { r as resolveMetaKeyType, a as resolveMetaKeyValue, b as resolvePackedMetaObjectValue, u as unpackMeta } from './shared/unhead.BQWSw36o.mjs';
-export { p as processTemplateParams } from './shared/unhead.BGFxPGPQ.mjs';
-import './shared/unhead.Bm4Y6XQI.mjs';
-import 'hookable';