agentworkshop 0.5.1 → 0.5.3

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

@@ -0,0 +1,99 @@
+import { parseHtmlForUnheadExtraction, applyHeadToHtml, parseHtmlForIndexes } from './parser.mjs';
+export { prepareTemplate } from './parser.mjs';
+import { a as capoTagWeight } from './shared/unhead.sGLr_XKf.mjs';
+export { c as createHead, b as createServerRenderer, e as escapeHtml, p as propsToString, r as renderSSRHead, s as ssrRenderTags, t as tagToString } from './shared/unhead.sGLr_XKf.mjs';
+import { n as normalizeEntryToTags, d as dedupeKey, h as hashTag } from './shared/unhead.DNKiVLV7.mjs';
+import './shared/unhead.Bf_fPVYA.mjs';
+import './shared/unhead.D7HkBzZn.mjs';
+import './shared/unhead.Bm4Y6XQI.mjs';
+import 'hookable';
+import './shared/unhead.CGPOfp5O.mjs';
+
+let extractedTemplates;
+function cloneExtractedInput(value) {
+  if (Array.isArray(value))
+    return value.map(cloneExtractedInput);
+  if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    const clone = {};
+    for (const key of Object.keys(value))
+      clone[key] = cloneExtractedInput(value[key]);
+    return clone;
+  }
+  return value;
+}
+function freezeExtractedInput(value) {
+  if (Array.isArray(value)) {
+    for (const item of value)
+      freezeExtractedInput(item);
+  } else if (value && typeof value === "object" && Object.getPrototypeOf(value) === Object.prototype) {
+    for (const key of Object.keys(value))
+      freezeExtractedInput(value[key]);
+  }
+  return value && typeof value === "object" ? Object.freeze(value) : value;
+}
+function hasHooks(head) {
+  const hooks = head.hooks?._hooks || {};
+  for (const key in hooks) {
+    if (hooks[key]?.length)
+      return true;
+  }
+  return false;
+}
+function precomputeExtractedTags(input) {
+  const tags = normalizeEntryToTags(input, []);
+  for (let i = 0; i < tags.length; i++) {
+    const tag = tags[i];
+    tag._w = capoTagWeight(tag);
+    tag._p = i;
+    tag._d = dedupeKey(tag);
+    if (!tag._d)
+      tag._h = hashTag(tag);
+  }
+  return tags;
+}
+function extractPreparedTemplate(prepared) {
+  const cache = extractedTemplates ||= /* @__PURE__ */ new WeakMap();
+  let extracted = cache.get(prepared);
+  if (!extracted) {
+    const template = parseHtmlForUnheadExtraction(prepared.html);
+    freezeExtractedInput(template.input);
+    Object.freeze(template.indexes);
+    Object.freeze(template);
+    const tags = precomputeExtractedTags(template.input);
+    freezeExtractedInput(tags);
+    extracted = Object.freeze({
+      template,
+      tags
+    });
+    cache.set(prepared, extracted);
+  }
+  return extracted;
+}
+// @__NO_SIDE_EFFECTS__
+function transformHtmlTemplate(head, html) {
+  let cached;
+  let template;
+  if (typeof html === "string") {
+    template = parseHtmlForUnheadExtraction(html);
+  } else {
+    cached = extractPreparedTemplate(html);
+    template = cached.template;
+  }
+  const hooked = cached ? hasHooks(head) : false;
+  const hasDynamicResolver = cached ? head.resolvedOptions.propResolvers?.some((resolver) => !resolver._static) || false : false;
+  const input = cached && (hooked || hasDynamicResolver) ? cloneExtractedInput(template.input) : template.input;
+  head.push(input, { _index: 0 });
+  if (cached && !hooked && head.resolvedOptions._tagWeight === capoTagWeight && !hasDynamicResolver) {
+    const entry = head.entries.get(0);
+    if (entry)
+      entry._precomputedTags = cached.tags;
+  }
+  return applyHeadToHtml(template, head.render());
+}
+// @__NO_SIDE_EFFECTS__
+function transformHtmlTemplateRaw(head, html) {
+  const template = typeof html === "string" ? parseHtmlForIndexes(html) : html;
+  return applyHeadToHtml(template, head.render());
+}
+
+export { capoTagWeight, transformHtmlTemplate, transformHtmlTemplateRaw };

package/.output/server/node_modules/unhead/dist/shared/unhead.10KEJHqy.mjs

@@ -0,0 +1,184 @@
+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";
+}
+function walkPromises(v) {
+  if (typeof v === "function")
+    return v;
+  if (isThenable(v))
+    return Promise.resolve(v).then(walkPromises);
+  if (Array.isArray(v)) {
+    const values = v.map(walkPromises);
+    return values.some(isThenable) ? Promise.all(values) : v;
+  }
+  if (v?.constructor === Object) {
+    const keys = Object.keys(v);
+    const values = keys.map((key) => walkPromises(v[key]));
+    if (values.some(isThenable)) {
+      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"];
+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 = processTemplateParams(
+          // find templateParams
+          params.pageTitle || head._title || "",
+          params,
+          sep
+        );
+        for (const tag of tags) {
+          if (tag.processTemplateParams === false) {
+            continue;
+          }
+          const v = SupportedAttrs[tag.tag];
+          if (v && typeof tag.props[v] === "string") {
+            tag.props[v] = processTemplateParams(tag.props[v], params, sep);
+          } else if (tag.processTemplateParams || tag.tag === "titleTemplate" || tag.tag === "title") {
+            for (const p of contentAttrs) {
+              if (typeof tag[p] === "string")
+                tag[p] = processTemplateParams(tag[p], params, sep, tag.tag === "script" && 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 = processTemplateParams(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/shared/unhead.BCcw-xUY.mjs

@@ -0,0 +1,19 @@
+import { c as createUnhead } from './unhead.D7HkBzZn.mjs';
+import { b as TagPriorityAliases } from './unhead.CGPOfp5O.mjs';
+import { c as createHooks } from './unhead.Bm4Y6XQI.mjs';
+import { c as createClientHeadAdapter } from './unhead.Bb4d5b9h.mjs';
+import { c as createDomRenderer } from './unhead.BuspQZgK.mjs';
+
+const tagWeight = (tag) => typeof tag.tagPriority === "number" ? tag.tagPriority : 100 + (TagPriorityAliases[tag.tagPriority] || 0);
+function createHead(options = {}) {
+  options.document = options.document || (typeof window !== "undefined" ? document : void 0);
+  const renderer = options.render || createDomRenderer({ document: options.document });
+  const core = createUnhead(renderer, { document: options.document, propResolvers: options.propResolvers, _tagWeight: tagWeight, init: [] });
+  const hooks = createHooks(options.hooks);
+  const head = createClientHeadAdapter(core, hooks, renderer);
+  options.plugins?.forEach((p) => head.use(p));
+  options.init?.forEach((e) => e && head.push(e));
+  return head;
+}
+
+export { createHead as c };