agentworkshop 0.5.1 → 0.5.3

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

@@ -0,0 +1,201 @@
+import { c as createUnhead, r as registerPlugin } from './unhead.D7HkBzZn.mjs';
+import { I as INVALID_ATTR_NAME_RE, r as resolveTags, n as normalizeEntryToTags, d as dedupeKey, h as hashTag } from './unhead.DNKiVLV7.mjs';
+import { a as callHook, c as createHooks } from './unhead.Bm4Y6XQI.mjs';
+import { b as TagPriorityAliases, a as SelfClosingTags, c as TagsWithInnerContent } from './unhead.CGPOfp5O.mjs';
+
+const isTruthy = (v) => v === "" || v === true;
+function capoTagWeight(tag) {
+  if (typeof tag.tagPriority === "number")
+    return tag.tagPriority;
+  let weight = 100;
+  const offset = TagPriorityAliases[tag.tagPriority] || 0;
+  if (tag.tag === "base") {
+    weight = -10;
+  } else if (tag.tag === "title") {
+    weight = 10;
+  } else if (tag.tag === "meta") {
+    weight = tag.props["http-equiv"] === "content-security-policy" ? -30 : tag.props.charset ? -20 : tag.props.name === "viewport" ? -15 : weight;
+  } else if (tag.tag === "link" && tag.props.rel) {
+    const rel = tag.props.rel;
+    weight = rel === "preconnect" ? 20 : rel === "stylesheet" ? 60 : rel === "preload" || rel === "modulepreload" ? 70 : rel === "prefetch" || rel === "dns-prefetch" || rel === "prerender" ? 90 : weight;
+  } else if (tag.tag === "script") {
+    const type = typeof tag.props.type === "string" ? tag.props.type : "";
+    const json = type.endsWith("json");
+    if (type === "importmap")
+      weight = 25;
+    else if (type === "speculationrules")
+      weight = 90;
+    else if (isTruthy(tag.props.async))
+      weight = 30;
+    else if (tag.props.src && !isTruthy(tag.props.defer) && type !== "module" && !json || (tag.innerHTML || tag.textContent) && !json)
+      weight = 50;
+    else if (isTruthy(tag.props.defer) && tag.props.src || type === "module")
+      weight = 80;
+  } else if (tag.tag === "style") {
+    weight = tag.innerHTML && /@import/.test(tag.innerHTML) ? 40 : 60;
+  }
+  return (weight || 100) + offset;
+}
+
+const DOUBLE_QUOTE_RE = /"/g;
+function encodeAttribute(value) {
+  const s = typeof value === "string" ? value : String(value);
+  return s.includes('"') ? s.replace(DOUBLE_QUOTE_RE, """) : s;
+}
+function propsToString(props) {
+  let attrs = "";
+  for (const key in props) {
+    if (!Object.hasOwn(props, key) || !key || INVALID_ATTR_NAME_RE.test(key))
+      continue;
+    let value = props[key];
+    if (typeof value !== "string") {
+      if (key === "class") {
+        let out = "";
+        for (const c of value) out += out ? ` ${c}` : c;
+        value = out;
+      } else if (key === "style") {
+        let out = "";
+        for (const [k, v] of value) out += out ? `;${k}:${v}` : `${k}:${v}`;
+        value = out;
+      }
+    }
+    if (value !== false && value !== null) {
+      attrs += value === true ? ` ${key}` : ` ${key}="${encodeAttribute(value)}"`;
+    }
+  }
+  return attrs;
+}
+
+const ESCAPE_HTML_RE = /[&<>"'/]/g;
+const CLOSE_TAG_RE = {};
+const ESCAPE_HTML_MAP = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#x27;", "/": "&#x2F;" };
+function escapeHtml(str) {
+  return str.replace(ESCAPE_HTML_RE, (c) => ESCAPE_HTML_MAP[c]);
+}
+function tagToString(tag) {
+  const attrs = propsToString(tag.props);
+  const openTag = `<${tag.tag}${attrs}>`;
+  if (SelfClosingTags.has(tag.tag))
+    return openTag;
+  if (!TagsWithInnerContent.has(tag.tag))
+    return `${openTag}</${tag.tag}>`;
+  let content = String(tag.textContent ?? tag.innerHTML ?? "");
+  content = tag.tag === "title" ? escapeHtml(content) : content.replace(CLOSE_TAG_RE[tag.tag] ||= new RegExp(`</${tag.tag}`, "gi"), `<\\/${tag.tag}`);
+  return `${openTag}${content}</${tag.tag}>`;
+}
+
+function ssrRenderTags(tags, options) {
+  const schema = { htmlAttrs: {}, bodyAttrs: {}, tags: { head: "", bodyClose: "", bodyOpen: "" } };
+  const lineBreaks = !options?.omitLineBreaks ? "\n" : "";
+  for (const tag of tags) {
+    if (tag.tag === "htmlAttrs" || tag.tag === "bodyAttrs") {
+      Object.assign(schema[tag.tag], tag.props);
+      continue;
+    }
+    const s = tagToString(tag);
+    const tagPosition = tag.tagPosition || "head";
+    schema.tags[tagPosition] += schema.tags[tagPosition] ? `${lineBreaks}${s}` : s;
+  }
+  return {
+    headTags: schema.tags.head,
+    bodyTags: schema.tags.bodyClose,
+    bodyTagsOpen: schema.tags.bodyOpen,
+    htmlAttrs: propsToString(schema.htmlAttrs),
+    bodyAttrs: propsToString(schema.bodyAttrs)
+  };
+}
+
+// @__NO_SIDE_EFFECTS__
+function createServerRenderer(options = {}) {
+  return (head) => {
+    const beforeRenderCtx = { shouldRender: true };
+    callHook(head, "ssr:beforeRender", beforeRenderCtx);
+    if (!beforeRenderCtx.shouldRender)
+      return ssrRenderTags([]);
+    const ctx = {
+      tags: options.resolvedTags || resolveTags(head, { tagWeight: options.tagWeight ?? capoTagWeight }),
+      options: { ...options }
+    };
+    callHook(head, "ssr:render", ctx);
+    const html = ssrRenderTags(ctx.tags, ctx.options);
+    const renderCtx = { tags: ctx.tags, html };
+    callHook(head, "ssr:rendered", renderCtx);
+    return renderCtx.html;
+  };
+}
+// @__NO_SIDE_EFFECTS__
+function renderSSRHead(head, options) {
+  return (/* @__PURE__ */ createServerRenderer(options))(head);
+}
+
+const DEFAULT_INIT = {
+  htmlAttrs: {
+    lang: "en"
+  },
+  meta: [
+    {
+      charset: "utf-8"
+    },
+    {
+      name: "viewport",
+      content: "width=device-width, initial-scale=1"
+    }
+  ]
+};
+const serverPropResolver = /* @__PURE__ */ Object.assign(
+  (k, v) => {
+    if (k && k.startsWith("on") && typeof v === "function") {
+      return `this.dataset.${k}fired = true`;
+    }
+    return v;
+  },
+  { _static: true }
+);
+let defaultInitTags;
+function getDefaultInitTags() {
+  if (!defaultInitTags) {
+    defaultInitTags = normalizeEntryToTags(DEFAULT_INIT, []);
+    for (let i = 0; i < defaultInitTags.length; i++) {
+      const t = defaultInitTags[i];
+      t._w = capoTagWeight(t);
+      t._p = (1 << 10) + i;
+      t._d = dedupeKey(t);
+      if (!t._d)
+        t._h = hashTag(t);
+    }
+  }
+  return defaultInitTags;
+}
+// @__NO_SIDE_EFFECTS__
+function createHead(options = {}) {
+  const tagWeight = options.tagWeight || capoTagWeight;
+  const render = createServerRenderer({ tagWeight, omitLineBreaks: options.omitLineBreaks });
+  const core = createUnhead(render, {
+    _tagWeight: tagWeight,
+    // @ts-expect-error untyped
+    document: false,
+    experimentalStreamKey: options.experimentalStreamKey,
+    propResolvers: [
+      ...options.propResolvers || [],
+      serverPropResolver
+    ],
+    init: [
+      options.disableDefaults ? void 0 : DEFAULT_INIT,
+      ...options.init || []
+    ]
+  });
+  if (!options.disableDefaults && !options.tagWeight && !options.propResolvers?.some((r) => !r._static)) {
+    const defaultEntry = core.entries.get(1);
+    if (defaultEntry)
+      defaultEntry._precomputedTags = getDefaultInitTags();
+  }
+  const hooks = createHooks(options.hooks);
+  const head = core;
+  head.hooks = hooks;
+  head.render = () => render(head);
+  head.use = (p) => registerPlugin(head, p);
+  options.plugins?.forEach((p) => head.use(p));
+  return head;
+}
+
+export { capoTagWeight as a, createServerRenderer as b, createHead as c, escapeHtml as e, propsToString as p, renderSSRHead as r, ssrRenderTags as s, tagToString as t };

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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,2 @@
+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 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: 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(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; } 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 = 21611;

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

@@ -0,0 +1,264 @@
+import { parseHtmlForIndexes, applyHeadToHtml } from '../parser.mjs';
+export { prepareTemplate } from '../parser.mjs';
+import { c as createHead } from '../shared/unhead.sGLr_XKf.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

@@ -0,0 +1,7 @@
+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.BTzUdyNs.mjs';
+export { p as processTemplateParams } from './shared/unhead.BGFxPGPQ.mjs';
+import './shared/unhead.Bm4Y6XQI.mjs';
+import 'hookable';