@highstate/designer 0.9.4 → 0.9.5

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

@@ -1,94 +0,0 @@
-export { A as AliasSortingPlugin, D as DeprecationsPlugin, P as PromisesPlugin, T as TemplateParamsPlugin } from './shared/unhead.DeCxexjU.mjs';
-import { d as defineHeadPlugin } from './shared/unhead.CApf5sj3.mjs';
-export { F as FlatMetaPlugin, S as SafeInputPlugin } from './shared/unhead.CApf5sj3.mjs';
-import './shared/unhead.DZbvapt-.mjs';
-import './shared/unhead.C13swrCa.mjs';
-import './shared/unhead.DQc16pHI.mjs';
-import './shared/unhead.yem5I2v_.mjs';
-
-function CanonicalPlugin(options) {
-  return (head) => {
-    function resolvePath(path) {
-      if (options?.customResolver) {
-        return options.customResolver(path);
-      }
-      let host = options.canonicalHost || (!head.ssr ? window.location.origin : "");
-      if (!host.startsWith("http") && !host.startsWith("//")) {
-        host = `https://${host}`;
-      }
-      host = new URL(host).origin;
-      if (path.startsWith("http") || path.startsWith("//"))
-        return path;
-      try {
-        return new URL(path, host).toString();
-      } catch {
-        return path;
-      }
-    }
-    return {
-      key: "canonical",
-      hooks: {
-        "tags:resolve": (ctx) => {
-          for (const tag of ctx.tags) {
-            if (tag.tag === "meta") {
-              if (tag.props.property?.startsWith("og:image") || tag.props.name?.startsWith("twitter:image")) {
-                tag.props.content = resolvePath(tag.props.content);
-              } else if (tag.props?.property === "og:url") {
-                tag.props.content = resolvePath(tag.props.content);
-              }
-            } else if (tag.tag === "link" && tag.props.rel === "canonical") {
-              tag.props.href = resolvePath(tag.props.href);
-            }
-          }
-        }
-      }
-    };
-  };
-}
-
-function InferSeoMetaPlugin(options = {}) {
-  return defineHeadPlugin((head) => {
-    head.push({
-      meta: [
-        {
-          name: "twitter:card",
-          content: options.twitterCard || "summary_large_image",
-          tagPriority: "low"
-        },
-        {
-          "property": "og:title",
-          "tagPriority": "low",
-          "data-infer": ""
-        },
-        {
-          "property": "og:description",
-          "tagPriority": "low",
-          "data-infer": ""
-        }
-      ]
-    });
-    return {
-      key: "infer-seo-meta",
-      hooks: {
-        "tags:beforeResolve": ({ tagMap }) => {
-          let title = head._title || "";
-          const titleTemplate = head._titleTemplate;
-          const ogTitle = tagMap.get("meta:og:title");
-          if (typeof ogTitle?.props["data-infer"] !== "undefined") {
-            if (titleTemplate) {
-              title = typeof titleTemplate === "function" ? titleTemplate(title) : titleTemplate.replace("%s", title);
-            }
-            ogTitle.props.content = options.ogTitle ? options.ogTitle(title) : title || "";
-          }
-          const description = tagMap.get("meta:description")?.props?.content;
-          const ogDescription = tagMap.get("meta:og:description");
-          if (typeof ogDescription?.props["data-infer"] !== "undefined") {
-            ogDescription.props.content = options.ogDescription ? options.ogDescription(description) : description || "";
-          }
-        }
-      }
-    };
-  });
-}
-
-export { CanonicalPlugin, InferSeoMetaPlugin, defineHeadPlugin };

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

@@ -1,220 +0,0 @@
-import { a as createUnhead } from './shared/unhead.Txd0XTIP.mjs';
-import { T as TagsWithInnerContent, S as SelfClosingTags$1 } from './shared/unhead.yem5I2v_.mjs';
-import 'hookable';
-import './shared/unhead.Cp0iF6eN.mjs';
-import './shared/unhead.DZbvapt-.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;
-}
-
-const Attrs = /(\w+)(?:=["']([^"']*)["'])?/g;
-const HtmlTag = /<html[^>]*>/;
-const BodyTag = /<body[^>]*>/;
-const HeadContent = /<head[^>]*>(.*?)<\/head>/s;
-const SelfClosingTags = /<(meta|link|base)[^>]*>/g;
-const ClosingTags = /<(title|script|style)[^>]*>[\s\S]*?<\/\1>/g;
-const NewLines = /(\n\s*)+/g;
-function extractAttributes(tag) {
-  const inner = tag.match(/<([^>]*)>/)?.[1].split(" ").slice(1).join(" ");
-  if (!inner)
-    return {};
-  const attrs = inner.match(Attrs);
-  return attrs?.reduce((acc, attr) => {
-    const sep = attr.indexOf("=");
-    const key = sep > 0 ? attr.slice(0, sep) : attr;
-    const val = sep > 0 ? attr.slice(sep + 1).slice(1, -1) : true;
-    return { ...acc, [key]: val };
-  }, {}) || {};
-}
-function extractUnheadInputFromHtml(html) {
-  const input = {};
-  input.htmlAttrs = extractAttributes(html.match(HtmlTag)?.[0] || "");
-  html = html.replace(HtmlTag, "<html>");
-  input.bodyAttrs = extractAttributes(html.match(BodyTag)?.[0] || "");
-  html = html.replace(BodyTag, "<body>");
-  const innerHead = html.match(HeadContent)?.[1] || "";
-  innerHead.match(SelfClosingTags)?.forEach((s) => {
-    html = html.replace(s, "");
-    const tag = s.split(" ")[0].slice(1);
-    input[tag] = input[tag] || [];
-    input[tag].push(extractAttributes(s));
-  });
-  innerHead.match(ClosingTags)?.map((tag) => tag.trim()).filter(Boolean).forEach((tag) => {
-    html = html.replace(tag, "");
-    const type = tag.match(/<([a-z-]+)/)?.[1];
-    const res = extractAttributes(tag);
-    const innerContent = tag.match(/>([\s\S]*)</)?.[1];
-    if (innerContent) {
-      res[type !== "script" ? "textContent" : "innerHTML"] = innerContent;
-    }
-    if (type === "title") {
-      input.title = res;
-    } else {
-      input[type] = input[type] || [];
-      input[type].push(res);
-    }
-  });
-  html = html.replace(NewLines, "\n");
-  return { html, input };
-}
-
-function encodeAttribute(value) {
-  return String(value).replace(/"/g, "&quot;");
-}
-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$1.has(tag.tag) ? openTag : `${openTag}</${tag.tag}>`;
-  let content = String(tag.innerHTML || "");
-  if (tag.textContent)
-    content = escapeHtml(String(tag.textContent));
-  return SelfClosingTags$1.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)
-  };
-}
-
-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;
-}
-
-async function transformHtmlTemplate(head, html, options) {
-  const { html: parsedHtml, input } = extractUnheadInputFromHtml(html);
-  head.push(input, { _index: 0 });
-  const headHtml = await renderSSRHead(head, options);
-  return parsedHtml.replace("<html>", `<html${headHtml.htmlAttrs}>`).replace("<body>", `<body>${headHtml.bodyTagsOpen ? `
-${headHtml.bodyTagsOpen}` : ``}`).replace("<body>", `<body${headHtml.bodyAttrs}>`).replace("</head>", `${headHtml.headTags}</head>`).replace("</body>", `${headHtml.bodyTags}</body>`);
-}
-
-export { createHead, escapeHtml, extractUnheadInputFromHtml, propsToString, renderSSRHead, ssrRenderTags, tagToString, transformHtmlTemplate };

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

@@ -1,48 +0,0 @@
-const SepSub = "%separator";
-const SepSubRE = new RegExp(`${SepSub}(?:\\s*${SepSub})*`, "g");
-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) {
-    if (s.endsWith(SepSub))
-      s = s.slice(0, -SepSub.length);
-    if (s.startsWith(SepSub))
-      s = s.slice(SepSub.length);
-    s = s.replace(SepSubRE, sep || "").trim();
-  }
-  return s;
-}
-
-export { processTemplateParams as p };

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

@@ -1,148 +0,0 @@
-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 };

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

@@ -1,177 +0,0 @@
-import { U as UniqueTags, T as TagsWithInnerContent, M as MetaTagsArrayable, a as TagConfigKeys, D as DupeableTags } from './unhead.yem5I2v_.mjs';
-
-const allowedMetaProperties = ["name", "property", "http-equiv"];
-function isMetaArrayDupeKey(v) {
-  const k = v.split(":")[1];
-  return MetaTagsArrayable.has(k);
-}
-function dedupeKey(tag) {
-  const { props, tag: name } = tag;
-  if (UniqueTags.has(name))
-    return name;
-  if (name === "link" && props.rel === "canonical")
-    return "canonical";
-  if (props.charset)
-    return "charset";
-  if (tag.tag === "meta") {
-    for (const n of allowedMetaProperties) {
-      if (props[n] !== void 0) {
-        return `${name}:${props[n]}`;
-      }
-    }
-  }
-  if (tag.key) {
-    return `${name}:key:${tag.key}`;
-  }
-  if (props.id) {
-    return `${name}:id:${props.id}`;
-  }
-  if (TagsWithInnerContent.has(name)) {
-    const v = tag.textContent || tag.innerHTML;
-    if (v) {
-      return `${name}:content:${v}`;
-    }
-  }
-}
-function hashTag(tag) {
-  const dedupe = tag._h || tag._d;
-  if (dedupe)
-    return dedupe;
-  const inner = tag.textContent || tag.innerHTML;
-  if (inner)
-    return inner;
-  return `${tag.tag}:${Object.entries(tag.props).map(([k, v]) => `${k}:${String(v)}`).join(",")}`;
-}
-
-function walkResolver(val, resolve, key) {
-  const type = typeof val;
-  if (type === "function") {
-    if (!key || key !== "titleTemplate" && !(key[0] === "o" && key[1] === "n")) {
-      val = val();
-    }
-  }
-  let v;
-  if (resolve) {
-    v = resolve(key, val);
-  }
-  if (Array.isArray(v)) {
-    return v.map((r) => walkResolver(r, resolve));
-  }
-  if (v?.constructor === Object) {
-    const next = {};
-    for (const key2 of Object.keys(v)) {
-      next[key2] = walkResolver(v[key2], resolve, key2);
-    }
-    return next;
-  }
-  return v;
-}
-
-function normalizeStyleClassProps(key, value) {
-  const store = key === "style" ? /* @__PURE__ */ new Map() : /* @__PURE__ */ new Set();
-  function processValue(rawValue) {
-    const value2 = rawValue.trim();
-    if (!value2)
-      return;
-    if (key === "style") {
-      const [k, ...v] = value2.split(":").map((s) => s.trim());
-      if (k && v.length)
-        store.set(k, v.join(":"));
-    } else {
-      value2.split(" ").filter(Boolean).forEach((c) => store.add(c));
-    }
-  }
-  if (typeof value === "string") {
-    key === "style" ? value.split(";").forEach(processValue) : processValue(value);
-  } else if (Array.isArray(value)) {
-    value.forEach((item) => processValue(item));
-  } else if (value && typeof value === "object") {
-    Object.entries(value).forEach(([k, v]) => {
-      if (v && v !== "false") {
-        key === "style" ? store.set(k.trim(), v) : processValue(k);
-      }
-    });
-  }
-  return store;
-}
-function normalizeProps(tag, input) {
-  tag.props = tag.props || {};
-  if (!input) {
-    return tag;
-  }
-  Object.entries(input).forEach(([key, value]) => {
-    if (value === null) {
-      tag.props[key] = null;
-      return;
-    }
-    if (key === "class" || key === "style") {
-      tag.props[key] = normalizeStyleClassProps(key, value);
-      return;
-    }
-    if (TagConfigKeys.has(key)) {
-      if (["textContent", "innerHTML"].includes(key) && typeof value === "object") {
-        let type = input.type;
-        if (!input.type) {
-          type = "application/json";
-        }
-        if (!type?.endsWith("json") && type !== "speculationrules") {
-          return;
-        }
-        input.type = type;
-        tag.props.type = type;
-        tag[key] = JSON.stringify(value);
-      } else {
-        tag[key] = value;
-      }
-      return;
-    }
-    const strValue = String(value);
-    const isDataKey = key.startsWith("data-");
-    if (strValue === "true" || strValue === "") {
-      tag.props[key] = isDataKey ? strValue : true;
-    } else if (!value && isDataKey && strValue === "false") {
-      tag.props[key] = "false";
-    } else if (value !== void 0) {
-      tag.props[key] = value;
-    }
-  });
-  return tag;
-}
-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";
-  }
-  return Array.isArray(tag.props.content) ? tag.props.content.map((v) => ({ ...tag, props: { ...tag.props, content: v } })) : tag;
-}
-function normalizeEntryToTags(input, propResolvers) {
-  if (!input) {
-    return [];
-  }
-  if (typeof input === "function") {
-    input = input();
-  }
-  const resolvers = (key, val) => {
-    for (let i = 0; i < propResolvers.length; i++) {
-      val = propResolvers[i](key, val);
-    }
-    return val;
-  };
-  input = resolvers(void 0, input);
-  const tags = [];
-  input = walkResolver(input, resolvers);
-  Object.entries(input || {}).forEach(([key, value]) => {
-    if (value === void 0)
-      return;
-    for (const v of Array.isArray(value) ? value : [value])
-      tags.push(normalizeTag(key, v));
-  });
-  return tags.flat();
-}
-
-export { normalizeProps as a, dedupeKey as d, hashTag as h, isMetaArrayDupeKey as i, normalizeEntryToTags as n, walkResolver as w };