bantou 0.1.0 → 0.2.0

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

@@ -0,0 +1,49 @@
+import { r as registerPlugin } from './unhead.D7HkBzZn.mjs';
+
+function createClientHeadAdapter(core, hooks, render) {
+  const corePush = core.push;
+  const head = core;
+  head.ssr = false;
+  head.hooks = hooks;
+  head.dirty = !!head.dirty;
+  head.use = (p) => registerPlugin(head, p);
+  head.render = () => render(head);
+  function notify() {
+    hooks.callHook("entries:updated", head);
+    if (!head._b)
+      head.render();
+  }
+  head.invalidate = () => {
+    for (const entry of head.entries.values())
+      delete entry._tags;
+    head.dirty = true;
+    notify();
+  };
+  head.push = (input, entryOptions) => {
+    const unhook = entryOptions?.onRendered ? hooks.hook("dom:rendered", entryOptions.onRendered) : void 0;
+    const active = corePush(input, entryOptions);
+    const entry = core.entries.get(active._i);
+    if (entry)
+      entry._o = input;
+    head.dirty = true;
+    notify();
+    return {
+      _i: active._i,
+      patch(input2) {
+        active.patch(input2);
+        head.dirty = true;
+        notify();
+      },
+      dispose() {
+        unhook?.();
+        if (core.entries.has(active._i)) {
+          active.dispose();
+          head.invalidate();
+        }
+      }
+    };
+  };
+  return head;
+}
+
+export { createClientHeadAdapter as c };

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.C_7zwq8E.mjs

@@ -0,0 +1,11 @@
+const VALID_STREAM_KEY_RE = /^[$_a-z][$\w]*$/i;
+function parseStreamKey(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)}`
+    );
+  }
+  return streamKey;
+}
+
+export { parseStreamKey as p };

package/.output/server/node_modules/unhead/dist/shared/unhead.CaeaMM5q.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.C5Bksi2B.mjs';
+import { c as createDomRenderer } from './unhead.DD4N5B4k.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 };

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 };

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

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

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

@@ -0,0 +1,224 @@
+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.DJuZwX9c.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 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;
+  if (!dom || head._du || activeState && activeState._d === dom && !head.dirty && !hasPendingEntries(head))
+    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 }) {
+      renderState._e.set(id, $el);
+      if (!tag.tag.endsWith("Attrs")) {
+        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);
+    }
+    if (pending.length) {
+      const tracked = new Set(renderState._e.values());
+      for (const el of [...dom.body.children, ...dom.head.children]) {
+        const elTag = el.tagName.toLowerCase();
+        if (!HasElementTags.has(elTag) || tracked.has(el))
+          continue;
+        const props = { innerHTML: el.innerHTML };
+        for (const n of el.getAttributeNames())
+          props[n] = el.getAttribute(n);
+        const next = normalizeProps({ tag: elTag, props: {} }, props);
+        next.key = el.getAttribute("data-hid") || void 0;
+        const dedupe = dedupeKey(next) || hashTag(next);
+        let k = dedupe;
+        let c = 1;
+        while (renderState._e.has(k))
+          k = `${dedupe}:${c++}`;
+        renderState._e.set(k, el);
+      }
+    }
+    for (const ctx of pending) {
+      const found = renderState._e.get(ctx.id);
+      ctx.$el = found || dom.createElement(ctx.tag.tag);
+      trackCtx(ctx);
+      if (!found)
+        (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 };