bantou 0.1.0 → 0.2.0

package/.output/server/node_modules/unhead/dist/shared/unhead.DGl9jcjg.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.DJuZwX9c.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.DJuZwX9c.mjs

@@ -0,0 +1,400 @@
+import { U as UniqueTags, c as TagsWithInnerContent, M as MetaTagsArrayable, i as isUnsafeKey, H as HasElementTags, T as TagConfigKeys, D as DupeableTags, d as UsesMergeStrategy, V as ValidHeadTags, h as hasContent } from './unhead.CGPOfp5O.mjs';
+import { a as callHook } from './unhead.Bm4Y6XQI.mjs';
+
+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 String(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 ? /* @__PURE__ */ new Map() : /* @__PURE__ */ 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 = 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 || /* @__PURE__ */ new Map(), ...next.props[p]]) : p === "class" ? /* @__PURE__ */ 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 sanitizeTags(tags) {
+  return sanitizeTagsInPlace([...tags]);
+}
+function resolveTags(head, options) {
+  const weightFn = options?.tagWeight ?? head.resolvedOptions._tagWeight ?? DEFAULT_TAG_WEIGHT;
+  const ctx = { tagMap: /* @__PURE__ */ 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);
+}
+
+export { INVALID_ATTR_NAME_RE as I, dedupeTags as a, normalizeProps as b, resolveTitleTemplate as c, dedupeKey as d, resolveHeadInput as e, hashTag as h, isMetaArrayDupeKey as i, normalizeEntryToTags as n, resolveTags as r, sanitizeTags as s, walkResolver as w };