@elgap/edukaai 0.1.0

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

@@ -0,0 +1,180 @@
+import { a as createUnhead } from './shared/unhead.D_nrZZPH.mjs';
+import { T as TagsWithInnerContent, S as SelfClosingTags } from './shared/unhead.yem5I2v_.mjs';
+import { parseHtmlForUnheadExtraction, applyHeadToHtml, parseHtmlForIndexes } from './parser.mjs';
+import 'hookable';
+import './shared/unhead.fVVqDC1O.mjs';
+import './shared/unhead.CbpEuj3y.mjs';
+
+// @__NO_SIDE_EFFECTS__
+function createHead(options = {}) {
+  const unhead = createUnhead({
+    ...options,
+    // @ts-expect-error untyped
+    document: false,
+    propResolvers: [
+      ...options.propResolvers || [],
+      (k, v) => {
+        if (k && k.startsWith("on") && typeof v === "function") {
+          return `this.dataset.${k}fired = true`;
+        }
+        return v;
+      }
+    ],
+    init: [
+      options.disableDefaults ? void 0 : {
+        htmlAttrs: {
+          lang: "en"
+        },
+        meta: [
+          {
+            charset: "utf-8"
+          },
+          {
+            name: "viewport",
+            content: "width=device-width, initial-scale=1"
+          }
+        ]
+      },
+      ...options.init || []
+    ]
+  });
+  unhead._ssrPayload = {};
+  unhead.use({
+    key: "server",
+    hooks: {
+      "tags:resolve": function(ctx) {
+        const title = ctx.tagMap.get("title");
+        const titleTemplate = ctx.tagMap.get("titleTemplate");
+        let payload = {
+          title: title?.mode === "server" ? unhead._title : void 0,
+          titleTemplate: titleTemplate?.mode === "server" ? unhead._titleTemplate : void 0
+        };
+        if (Object.keys(unhead._ssrPayload || {}).length > 0) {
+          payload = {
+            ...unhead._ssrPayload,
+            ...payload
+          };
+        }
+        if (Object.values(payload).some(Boolean)) {
+          ctx.tags.push({
+            tag: "script",
+            innerHTML: JSON.stringify(payload),
+            props: { id: "unhead:payload", type: "application/json" }
+          });
+        }
+      }
+    }
+  });
+  return unhead;
+}
+
+function extractUnheadInputFromHtml(html) {
+  return parseHtmlForUnheadExtraction(html);
+}
+
+function encodeAttribute(value) {
+  return String(value).replace(/"/g, """);
+}
+function propsToString(props) {
+  let attrs = "";
+  for (const key in props) {
+    if (!Object.hasOwn(props, key))
+      continue;
+    let value = props[key];
+    if ((key === "class" || key === "style") && typeof value !== "string") {
+      value = key === "class" ? Array.from(value).join(" ") : Array.from(value).map(([k, v]) => `${k}:${v}`).join(";");
+    }
+    if (value !== false && value !== null) {
+      attrs += value === true ? ` ${key}` : ` ${key}="${encodeAttribute(value)}"`;
+    }
+  }
+  return attrs;
+}
+
+function escapeHtml(str) {
+  return str.replace(/[&<>"'/]/g, (char) => {
+    switch (char) {
+      case "&":
+        return "&amp;";
+      case "<":
+        return "&lt;";
+      case ">":
+        return "&gt;";
+      case '"':
+        return "&quot;";
+      case "'":
+        return "&#x27;";
+      case "/":
+        return "&#x2F;";
+      default:
+        return char;
+    }
+  });
+}
+function tagToString(tag) {
+  const attrs = propsToString(tag.props);
+  const openTag = `<${tag.tag}${attrs}>`;
+  if (!TagsWithInnerContent.has(tag.tag))
+    return SelfClosingTags.has(tag.tag) ? openTag : `${openTag}</${tag.tag}>`;
+  let content = String(tag.textContent || tag.innerHTML || "");
+  content = tag.tag === "title" ? escapeHtml(content) : content.replace(new RegExp(`</${tag.tag}`, "gi"), `<\\/${tag.tag}`);
+  return SelfClosingTags.has(tag.tag) ? openTag : `${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__
+async function renderSSRHead(head, options) {
+  const beforeRenderCtx = { shouldRender: true };
+  await head.hooks.callHook("ssr:beforeRender", beforeRenderCtx);
+  if (!beforeRenderCtx.shouldRender) {
+    return {
+      headTags: "",
+      bodyTags: "",
+      bodyTagsOpen: "",
+      htmlAttrs: "",
+      bodyAttrs: ""
+    };
+  }
+  const ctx = { tags: options?.resolvedTags || await head.resolveTags() };
+  await head.hooks.callHook("ssr:render", ctx);
+  const html = ssrRenderTags(ctx.tags, options);
+  const renderCtx = { tags: ctx.tags, html };
+  await head.hooks.callHook("ssr:rendered", renderCtx);
+  return renderCtx.html;
+}
+
+// @__NO_SIDE_EFFECTS__
+async function transformHtmlTemplate(head, html, options) {
+  const template = parseHtmlForUnheadExtraction(html);
+  head.push(template.input, { _index: 0 });
+  const headHtml = await renderSSRHead(head, options);
+  return applyHeadToHtml(template, headHtml);
+}
+// @__NO_SIDE_EFFECTS__
+async function transformHtmlTemplateRaw(head, html, options) {
+  const headHtml = await renderSSRHead(head, options);
+  const template = parseHtmlForIndexes(html);
+  return applyHeadToHtml(template, headHtml);
+}
+
+export { createHead, escapeHtml, extractUnheadInputFromHtml, propsToString, renderSSRHead, ssrRenderTags, tagToString, transformHtmlTemplate, transformHtmlTemplateRaw };

package/.output/server/node_modules/unhead/dist/shared/unhead.BPM0-cfG.mjs

@@ -0,0 +1,44 @@
+import { S as SafeInputPlugin, F as FlatMetaPlugin } from './unhead.CApf5sj3.mjs';
+
+function useHead(unhead, input, options = {}) {
+  return unhead.push(input || {}, options);
+}
+function useHeadSafe(unhead, input = {}, options = {}) {
+  unhead.use(SafeInputPlugin);
+  return useHead(unhead, input, Object.assign(options, { _safe: true }));
+}
+function useSeoMeta(unhead, input = {}, options) {
+  unhead.use(FlatMetaPlugin);
+  function normalize(input2) {
+    if (input2._flatMeta) {
+      return input2;
+    }
+    const { title, titleTemplate, ...meta } = input2 || {};
+    return {
+      title,
+      titleTemplate,
+      _flatMeta: meta
+    };
+  }
+  const entry = unhead.push(normalize(input), options);
+  const corePatch = entry.patch;
+  if (!entry.__patched) {
+    entry.patch = (input2) => corePatch(normalize(input2));
+    entry.__patched = true;
+  }
+  return entry;
+}
+function useServerHead(unhead, input = {}, options = {}) {
+  options.mode = "server";
+  return unhead.push(input, options);
+}
+function useServerHeadSafe(unhead, input = {}, options = {}) {
+  options.mode = "server";
+  return useHeadSafe(unhead, input, { ...options, mode: "server" });
+}
+function useServerSeoMeta(unhead, input = {}, options) {
+  options.mode = "server";
+  return useSeoMeta(unhead, input, { ...options, mode: "server" });
+}
+
+export { useHeadSafe as a, useSeoMeta as b, useServerHead as c, useServerHeadSafe as d, useServerSeoMeta as e, useHead as u };

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

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

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

@@ -0,0 +1,269 @@
+import { b as ScriptNetworkEvents } from './unhead.yem5I2v_.mjs';
+
+function createNoopedRecordingProxy(instance = {}) {
+  const stack = [];
+  let stackIdx = -1;
+  const handler = (reuseStack = false) => ({
+    get(_, prop, receiver) {
+      if (!reuseStack) {
+        const v = Reflect.get(_, prop, receiver);
+        if (typeof v !== "undefined") {
+          return v;
+        }
+        stackIdx++;
+        stack[stackIdx] = [];
+      }
+      stack[stackIdx].push({ type: "get", key: prop });
+      return new Proxy(() => {
+      }, handler(true));
+    },
+    apply(_, __, args) {
+      stack[stackIdx].push({ type: "apply", key: "", args });
+      return void 0;
+    }
+  });
+  return {
+    proxy: new Proxy(instance || {}, handler()),
+    stack
+  };
+}
+function createForwardingProxy(target) {
+  const handler = {
+    get(_, prop, receiver) {
+      const v = Reflect.get(_, prop, receiver);
+      if (typeof v === "object") {
+        return new Proxy(v, handler);
+      }
+      return v;
+    },
+    apply(_, __, args) {
+      Reflect.apply(_, __, args);
+      return void 0;
+    }
+  };
+  return new Proxy(target, handler);
+}
+function replayProxyRecordings(target, stack) {
+  stack.forEach((recordings) => {
+    let context = target;
+    let prevContext = target;
+    recordings.forEach(({ type, key, args }) => {
+      if (type === "get") {
+        prevContext = context;
+        context = context[key];
+      } else if (type === "apply") {
+        context = context.call(prevContext, ...args);
+      }
+    });
+  });
+}
+
+function resolveScriptKey(input) {
+  return input.key || input.src || (typeof input.innerHTML === "string" ? input.innerHTML : "");
+}
+const PreconnectServerModes = ["preconnect", "dns-prefetch"];
+function useScript(head, _input, _options) {
+  const input = typeof _input === "string" ? { src: _input } : _input;
+  const options = _options || {};
+  const id = resolveScriptKey(input);
+  const prevScript = head._scripts?.[id];
+  if (prevScript) {
+    prevScript.setupTriggerHandler(options.trigger);
+    return prevScript;
+  }
+  options.beforeInit?.();
+  const syncStatus = (s) => {
+    script.status = s;
+    head.hooks.callHook(`script:updated`, hookCtx);
+  };
+  ScriptNetworkEvents.forEach((fn) => {
+    const k = fn;
+    const _fn = typeof input[k] === "function" ? input[k].bind(options.eventContext) : null;
+    input[k] = (e) => {
+      syncStatus(fn === "onload" ? "loaded" : fn === "onerror" ? "error" : "loading");
+      _fn?.(e);
+    };
+  });
+  const _cbs = { loaded: [], error: [] };
+  const _uniqueCbs = /* @__PURE__ */ new Set();
+  const _registerCb = (key, cb, options2) => {
+    if (head.ssr) {
+      return;
+    }
+    if (options2?.key) {
+      const key2 = `${options2?.key}:${options2.key}`;
+      if (_uniqueCbs.has(key2)) {
+        return;
+      }
+      _uniqueCbs.add(key2);
+    }
+    if (_cbs[key]) {
+      const i = _cbs[key].push(cb);
+      return () => _cbs[key]?.splice(i - 1, 1);
+    }
+    cb(script.instance);
+    return () => {
+    };
+  };
+  const loadPromise = new Promise((resolve) => {
+    if (head.ssr)
+      return;
+    const emit = (api) => requestAnimationFrame(() => resolve(api));
+    const _ = head.hooks.hook("script:updated", ({ script: script2 }) => {
+      const status = script2.status;
+      if (script2.id === id && (status === "loaded" || status === "error")) {
+        if (status === "loaded") {
+          if (typeof options.use === "function") {
+            const api = options.use();
+            if (api) {
+              emit(api);
+            }
+          } else {
+            emit({});
+          }
+        } else if (status === "error") {
+          resolve(false);
+        }
+        _();
+      }
+    });
+  });
+  const script = {
+    _loadPromise: loadPromise,
+    instance: !head.ssr && options?.use?.() || null,
+    proxy: null,
+    id,
+    status: "awaitingLoad",
+    remove() {
+      script._triggerAbortControllers?.forEach((ac) => ac.abort());
+      script._triggerAbortControllers?.clear();
+      script._triggerPromises = [];
+      script._warmupEl?.dispose();
+      if (script.entry) {
+        script.entry.dispose();
+        script.entry = void 0;
+        syncStatus("removed");
+        delete head._scripts?.[id];
+        return true;
+      }
+      return false;
+    },
+    warmup(rel) {
+      const { src } = input;
+      const isCrossOrigin = !src.startsWith("/") || src.startsWith("//");
+      const isPreconnect = rel && PreconnectServerModes.includes(rel);
+      let href = src;
+      if (!rel || isPreconnect && !isCrossOrigin) {
+        return;
+      }
+      if (isPreconnect) {
+        const $url = new URL(src);
+        href = `${$url.protocol}//${$url.host}`;
+      }
+      const link = {
+        href,
+        rel,
+        crossorigin: typeof input.crossorigin !== "undefined" ? input.crossorigin : isCrossOrigin ? "anonymous" : void 0,
+        referrerpolicy: typeof input.referrerpolicy !== "undefined" ? input.referrerpolicy : isCrossOrigin ? "no-referrer" : void 0,
+        fetchpriority: typeof input.fetchpriority !== "undefined" ? input.fetchpriority : "low",
+        integrity: input.integrity,
+        as: rel === "preload" ? "script" : void 0
+      };
+      script._warmupEl = head.push({ link: [link] }, { head, tagPriority: "high" });
+      return script._warmupEl;
+    },
+    load(cb) {
+      script._triggerAbortControllers?.forEach((ac) => ac.abort());
+      script._triggerAbortControllers?.clear();
+      script._triggerPromises = [];
+      if (!script.entry) {
+        syncStatus("loading");
+        const defaults = {
+          defer: true,
+          fetchpriority: "low"
+        };
+        if (input.src && (input.src.startsWith("http") || input.src.startsWith("//"))) {
+          defaults.crossorigin = "anonymous";
+          defaults.referrerpolicy = "no-referrer";
+        }
+        script.entry = head.push({
+          script: [{ ...defaults, ...input }]
+        }, options);
+      }
+      if (cb)
+        _registerCb("loaded", cb);
+      return loadPromise;
+    },
+    onLoaded(cb, options2) {
+      return _registerCb("loaded", cb, options2);
+    },
+    onError(cb, options2) {
+      return _registerCb("error", cb, options2);
+    },
+    setupTriggerHandler(trigger) {
+      if (script.status !== "awaitingLoad") {
+        return;
+      }
+      if ((typeof trigger === "undefined" || trigger === "client") && !head.ssr || trigger === "server") {
+        script.load();
+      } else if (trigger instanceof Promise) {
+        if (head.ssr) {
+          return;
+        }
+        const abortController = new AbortController();
+        script._triggerAbortControllers = script._triggerAbortControllers || /* @__PURE__ */ new Set();
+        script._triggerAbortControllers.add(abortController);
+        const abortPromise = new Promise((resolve) => {
+          abortController.signal.addEventListener("abort", () => {
+            script._triggerAbortControllers?.delete(abortController);
+            resolve();
+          });
+        });
+        script._triggerAbortController = abortController;
+        script._triggerPromises = script._triggerPromises || [];
+        const idx = script._triggerPromises.push(Promise.race([
+          trigger.then((v) => typeof v === "undefined" || v ? script.load : void 0),
+          abortPromise
+        ]).catch(() => {
+        }).then((res) => {
+          res?.();
+        }).finally(() => {
+          script._triggerPromises?.splice(idx, 1);
+        }));
+      } else if (typeof trigger === "function") {
+        trigger(script.load);
+      }
+    },
+    _cbs
+  };
+  loadPromise.then((api) => {
+    if (api !== false) {
+      script.instance = api;
+      _cbs.loaded?.forEach((cb) => cb(api));
+      _cbs.loaded = null;
+    } else {
+      _cbs.error?.forEach((cb) => cb());
+      _cbs.error = null;
+    }
+  });
+  const hookCtx = { script };
+  script.setupTriggerHandler(options.trigger);
+  if (options.use) {
+    const { proxy, stack } = createNoopedRecordingProxy(head.ssr ? {} : options.use() || {});
+    script.proxy = proxy;
+    script.onLoaded((instance) => {
+      replayProxyRecordings(instance, stack);
+      script.proxy = createForwardingProxy(instance);
+    });
+  }
+  if (!options.warmupStrategy && (typeof options.trigger === "undefined" || options.trigger === "client")) {
+    options.warmupStrategy = "preload";
+  }
+  if (options.warmupStrategy) {
+    script.warmup(options.warmupStrategy);
+  }
+  head._scripts = Object.assign(head._scripts || {}, { [id]: script });
+  return script;
+}
+
+export { resolveScriptKey as r, useScript as u };

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

@@ -0,0 +1,148 @@
+import { u as unpackMeta } from './unhead.DQc16pHI.mjs';
+
+function defineHeadPlugin(plugin) {
+  return plugin;
+}
+
+const FlatMetaPlugin = /* @__PURE__ */ defineHeadPlugin({
+  key: "flatMeta",
+  hooks: {
+    "entries:normalize": (ctx) => {
+      const tagsToAdd = [];
+      ctx.tags = ctx.tags.map((t) => {
+        if (t.tag !== "_flatMeta") {
+          return t;
+        }
+        tagsToAdd.push(unpackMeta(t.props).map((p) => ({
+          ...t,
+          tag: "meta",
+          props: p
+        })));
+        return false;
+      }).filter(Boolean).concat(...tagsToAdd);
+    }
+  }
+});
+
+const WhitelistAttributes = {
+  htmlAttrs: /* @__PURE__ */ new Set(["class", "style", "lang", "dir"]),
+  bodyAttrs: /* @__PURE__ */ new Set(["class", "style"]),
+  meta: /* @__PURE__ */ new Set(["name", "property", "charset", "content", "media"]),
+  noscript: /* @__PURE__ */ new Set(["textContent"]),
+  style: /* @__PURE__ */ new Set(["media", "textContent", "nonce", "title", "blocking"]),
+  script: /* @__PURE__ */ new Set(["type", "textContent", "nonce", "blocking"]),
+  link: /* @__PURE__ */ new Set(["color", "crossorigin", "fetchpriority", "href", "hreflang", "imagesrcset", "imagesizes", "integrity", "media", "referrerpolicy", "rel", "sizes", "type"])
+};
+function acceptDataAttrs(value) {
+  return Object.fromEntries(
+    Object.entries(value || {}).filter(([key]) => key === "id" || key.startsWith("data-"))
+  );
+}
+function makeTagSafe(tag) {
+  let next = {};
+  const { tag: type, props: prev } = tag;
+  switch (type) {
+    // always safe
+    case "title":
+    case "titleTemplate":
+    case "templateParams":
+      next = prev;
+      break;
+    case "htmlAttrs":
+    case "bodyAttrs":
+      WhitelistAttributes[type].forEach((attr) => {
+        if (prev[attr]) {
+          next[attr] = prev[attr];
+        }
+      });
+      break;
+    case "style":
+      next = acceptDataAttrs(prev);
+      WhitelistAttributes.style.forEach((key) => {
+        if (prev[key]) {
+          next[key] = prev[key];
+        }
+      });
+      break;
+    // meta is safe, except for http-equiv
+    case "meta":
+      WhitelistAttributes.meta.forEach((key) => {
+        if (prev[key]) {
+          next[key] = prev[key];
+        }
+      });
+      break;
+    // link tags we don't allow stylesheets, scripts, preloading, prerendering, prefetching, etc
+    case "link":
+      WhitelistAttributes.link.forEach((key) => {
+        const val = prev[key];
+        if (!val) {
+          return;
+        }
+        if (key === "rel" && (val === "canonical" || val === "modulepreload" || val === "prerender" || val === "preload" || val === "prefetch")) {
+          return;
+        }
+        if (key === "href") {
+          if (val.includes("javascript:") || val.includes("data:")) {
+            return;
+          }
+          next[key] = val;
+        } else if (val) {
+          next[key] = val;
+        }
+      });
+      if (!next.href && !next.imagesrcset || !next.rel) {
+        return false;
+      }
+      break;
+    case "noscript":
+      WhitelistAttributes.noscript.forEach((key) => {
+        if (prev[key]) {
+          next[key] = prev[key];
+        }
+      });
+      break;
+    // we only allow JSON in scripts
+    case "script":
+      if (!tag.textContent || !prev.type?.endsWith("json")) {
+        return false;
+      }
+      WhitelistAttributes.script.forEach((s) => {
+        if (prev[s] === "textContent") {
+          try {
+            const jsonVal = typeof prev[s] === "string" ? JSON.parse(prev[s]) : prev[s];
+            next[s] = JSON.stringify(jsonVal, null, 0);
+          } catch {
+          }
+        } else if (prev[s]) {
+          next[s] = prev[s];
+        }
+      });
+      break;
+  }
+  if (!Object.keys(next).length && !tag.tag.endsWith("Attrs")) {
+    return false;
+  }
+  tag.props = { ...acceptDataAttrs(prev), ...next };
+  return tag;
+}
+const SafeInputPlugin = (
+  /* @PURE */
+  defineHeadPlugin({
+    key: "safe",
+    hooks: {
+      "entries:normalize": (ctx) => {
+        if (ctx.entry.options?._safe) {
+          ctx.tags = ctx.tags.reduce((acc, tag) => {
+            const safeTag = makeTagSafe(tag);
+            if (safeTag)
+              acc.push(safeTag);
+            return acc;
+          }, []);
+        }
+      }
+    }
+  })
+);
+
+export { FlatMetaPlugin as F, SafeInputPlugin as S, defineHeadPlugin as d };