uomtiles 0.1.0

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

@@ -0,0 +1,223 @@
+import { H as HasElementTags } from './unhead.CGPOfp5O.mjs';
+import { r as resolveTags, i as isMetaArrayDupeKey, b as normalizeProps, d as dedupeKey, h as hashTag } from './unhead.DNKiVLV7.mjs';
+import { a as callHook } from './unhead.Bm4Y6XQI.mjs';
+
+const WHITESPACE_RE = /\s+/;
+// @__NO_SIDE_EFFECTS__
+function createDomRenderer(options = {}) {
+  return (head) => _renderDOMHead(head, options);
+}
+function renderDOMHead(head, options = {}) {
+  return _renderDOMHead(head, options);
+}
+function hasPendingEntries(head) {
+  for (const entry of head.entries.values()) {
+    if (entry._pending !== void 0)
+      return true;
+  }
+  return false;
+}
+function createDomState(head, dom) {
+  const state = { _d: dom, _t: dom.title, _e: /* @__PURE__ */ new Map([["htmlAttrs", dom.documentElement], ["bodyAttrs", dom.body]]), _p: {}, _s: {}, _l: /* @__PURE__ */ new Map() };
+  for (const 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;
+}
+
+export { createDomRenderer as c, renderDOMHead as r };

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

@@ -0,0 +1,32 @@
+const SelfClosingTags = /* @__PURE__ */ new Set(["meta", "link", "base"]);
+const DupeableTags = /* @__PURE__ */ new Set(["link", "style", "script", "noscript"]);
+const TagsWithInnerContent = /* @__PURE__ */ new Set(["title", "titleTemplate", "script", "style", "noscript"]);
+const HasElementTags = /* @__PURE__ */ new Set(["base", "meta", "link", "style", "script", "noscript"]);
+const ValidHeadTags = /* @__PURE__ */ new Set(["title", "base", "htmlAttrs", "bodyAttrs", "meta", "link", "style", "script", "noscript"]);
+const UniqueTags = /* @__PURE__ */ new Set(["base", "title", "titleTemplate", "bodyAttrs", "htmlAttrs", "templateParams"]);
+const TagConfigKeys = /* @__PURE__ */ new Set(["key", "tagPosition", "tagPriority", "tagDuplicateStrategy", "innerHTML", "textContent", "processTemplateParams"]);
+const ScriptNetworkEvents = /* @__PURE__ */ new Set(["onload", "onerror"]);
+const UsesMergeStrategy = /* @__PURE__ */ new Set(["templateParams", "htmlAttrs", "bodyAttrs"]);
+const MetaTagsArrayable = /* @__PURE__ */ new Set([
+  "theme-color",
+  "google-site-verification",
+  "author",
+  "og:locale:alternate",
+  "og:image",
+  "og:video",
+  "og:audio",
+  "article:author",
+  "article:tag",
+  "book:author",
+  "book:tag",
+  "twitter:image"
+]);
+const TagPriorityAliases = { critical: -8, high: -1, low: 2 };
+const hasContent = (value) => typeof value === "number" ? Number.isFinite(value) : value;
+
+// @__NO_SIDE_EFFECTS__
+function isUnsafeKey(key) {
+  return key === "__proto__" || key === "constructor" || key === "prototype";
+}
+
+export { DupeableTags as D, HasElementTags as H, MetaTagsArrayable as M, ScriptNetworkEvents as S, TagConfigKeys as T, UniqueTags as U, ValidHeadTags as V, SelfClosingTags as a, TagPriorityAliases as b, TagsWithInnerContent as c, UsesMergeStrategy as d, hasContent as h, isUnsafeKey as i };

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

@@ -0,0 +1,7 @@
+function defineHeadPlugin(plugin, key) {
+  if (key && typeof plugin === "function")
+    plugin.key = key;
+  return plugin;
+}
+
+export { defineHeadPlugin as d };

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

@@ -0,0 +1,27 @@
+function createSpyProxy(target, onApply) {
+  const stack = [];
+  let stackIdx = -1;
+  const handler = (reuseStack = false) => ({
+    get(_, prop, receiver) {
+      if (!reuseStack) {
+        stackIdx++;
+        stack[stackIdx] = [];
+      }
+      const v = Reflect.get(_, prop, receiver);
+      if (typeof v === "object" || typeof v === "function") {
+        stack[stackIdx].push({ type: "get", key: prop });
+        return new Proxy(v, handler(true));
+      }
+      stack[stackIdx].push({ type: "get", key: prop, value: v });
+      return v;
+    },
+    apply(_, __, args) {
+      stack[stackIdx].push({ type: "apply", key: "", args });
+      onApply(stack);
+      return Reflect.apply(_, __, args);
+    }
+  });
+  return new Proxy(target, handler());
+}
+
+export { createSpyProxy as c };

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

@@ -0,0 +1,196 @@
+import { c as createUnhead } 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 core = createUnhead(createServerRenderer({ tagWeight, omitLineBreaks: options.omitLineBreaks }), {
+    _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();
+  }
+  core.hooks = createHooks(options.hooks);
+  options.plugins?.forEach((p) => core.use(p));
+  return core;
+}
+
+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/shared/unhead.D7HkBzZn.mjs

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