@unhead/schema-org 0.6.0 → 1.3.9

package/dist/index.cjs

@@ -1,1943 +1,9 @@
 'use strict';
 
-const ufo = require('ufo');
+const SchemaOrgUnheadPlugin = require('./shared/schema-org.96234618.cjs');
 const unhead = require('unhead');
-
-function defineSchemaOrgResolver(schema) {
-  return schema;
-}
-
-function idReference(node) {
-  return {
-    "@id": typeof node !== "string" ? node["@id"] : node
-  };
-}
-function resolvableDateToDate(val) {
-  try {
-    const date = val instanceof Date ? val : new Date(Date.parse(val));
-    return `${date.getFullYear()}-${date.getMonth()}-${date.getDate()}`;
-  } catch (e) {
-  }
-  return typeof val === "string" ? val : val.toString();
-}
-function resolvableDateToIso(val) {
-  if (!val)
-    return val;
-  try {
-    if (val instanceof Date)
-      return val.toISOString();
-    else
-      return new Date(Date.parse(val)).toISOString();
-  } catch (e) {
-  }
-  return typeof val === "string" ? val : val.toString();
-}
-const IdentityId = "#identity";
-function setIfEmpty(node, field, value) {
-  if (!node?.[field] && value)
-    node[field] = value;
-}
-function asArray(input) {
-  return Array.isArray(input) ? input : [input];
-}
-function dedupeMerge(node, field, value) {
-  const dedupeMerge2 = [];
-  const input = asArray(node[field]);
-  dedupeMerge2.push(...input);
-  const data = new Set(dedupeMerge2);
-  data.add(value);
-  node[field] = [...data.values()].filter(Boolean);
-}
-function prefixId(url, id) {
-  if (ufo.hasProtocol(id))
-    return url;
-  if (!id.startsWith("#"))
-    id = `#${id}`;
-  return ufo.joinURL(url, id);
-}
-function trimLength(val, length) {
-  if (!val)
-    return val;
-  if (val.length > length) {
-    const trimmedString = val.substring(0, length);
-    return trimmedString.substring(0, Math.min(trimmedString.length, trimmedString.lastIndexOf(" ")));
-  }
-  return val;
-}
-function resolveDefaultType(node, defaultType) {
-  const val = node["@type"];
-  if (val === defaultType)
-    return;
-  const types = /* @__PURE__ */ new Set([
-    ...asArray(defaultType),
-    ...asArray(val)
-  ]);
-  node["@type"] = types.size === 1 ? val : [...types.values()];
-}
-function resolveWithBase(base, urlOrPath) {
-  if (!urlOrPath || ufo.hasProtocol(urlOrPath) || !urlOrPath.startsWith("/") && !urlOrPath.startsWith("#"))
-    return urlOrPath;
-  return ufo.withBase(urlOrPath, base);
-}
-function resolveAsGraphKey(key) {
-  if (!key)
-    return key;
-  return key.substring(key.lastIndexOf("#"));
-}
-function stripEmptyProperties(obj) {
-  Object.keys(obj).forEach((k) => {
-    if (obj[k] && typeof obj[k] === "object") {
-      if (obj[k].__v_isReadonly || obj[k].__v_isRef)
-        return;
-      stripEmptyProperties(obj[k]);
-      return;
-    }
-    if (obj[k] === "" || obj[k] === null || typeof obj[k] === "undefined")
-      delete obj[k];
-  });
-  return obj;
-}
-function hashCode(s) {
-  let h = 9;
-  for (let i = 0; i < s.length; )
-    h = Math.imul(h ^ s.charCodeAt(i++), 9 ** 9);
-  return ((h ^ h >>> 9) + 65536).toString(16).substring(1, 8).toLowerCase();
-}
-
-const offerResolver = defineSchemaOrgResolver({
-  cast(node) {
-    if (typeof node === "number" || typeof node === "string") {
-      return {
-        price: node
-      };
-    }
-    return node;
-  },
-  defaults: {
-    "@type": "Offer",
-    "availability": "InStock"
-  },
-  resolve(node, ctx) {
-    setIfEmpty(node, "priceCurrency", ctx.meta.currency);
-    setIfEmpty(node, "priceValidUntil", new Date(Date.UTC((/* @__PURE__ */ new Date()).getFullYear() + 1, 12, -1, 0, 0, 0)));
-    if (node.url)
-      resolveWithBase(ctx.meta.host, node.url);
-    if (node.availability)
-      node.availability = ufo.withBase(node.availability, "https://schema.org/");
-    if (node.priceValidUntil)
-      node.priceValidUntil = resolvableDateToIso(node.priceValidUntil);
-    return node;
-  }
-});
-
-const aggregateOfferResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "AggregateOffer"
-  },
-  inheritMeta: [
-    { meta: "currency", key: "priceCurrency" }
-  ],
-  resolve(node, ctx) {
-    node.offers = resolveRelation(node.offers, ctx, offerResolver);
-    if (node.offers)
-      setIfEmpty(node, "offerCount", asArray(node.offers).length);
-    return node;
-  }
-});
-
-const aggregateRatingResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "AggregateRating"
-  }
-});
-
-const searchActionResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "SearchAction",
-    "target": {
-      "@type": "EntryPoint"
-    },
-    "query-input": {
-      "@type": "PropertyValueSpecification",
-      "valueRequired": true,
-      "valueName": "search_term_string"
-    }
-  },
-  resolve(node, ctx) {
-    if (typeof node.target === "string") {
-      node.target = {
-        "@type": "EntryPoint",
-        "urlTemplate": resolveWithBase(ctx.meta.host, node.target)
-      };
-    }
-    return node;
-  }
-});
-
-const PrimaryWebSiteId = "#website";
-const webSiteResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "WebSite"
-  },
-  inheritMeta: [
-    "inLanguage",
-    { meta: "host", key: "url" }
-  ],
-  idPrefix: ["host", PrimaryWebSiteId],
-  resolve(node, ctx) {
-    node.potentialAction = resolveRelation(node.potentialAction, ctx, searchActionResolver, {
-      array: true
-    });
-    node.publisher = resolveRelation(node.publisher, ctx);
-    return node;
-  },
-  resolveRootNode(node, { find }) {
-    if (resolveAsGraphKey(node["@id"]) === PrimaryWebSiteId) {
-      const identity = find(IdentityId);
-      if (identity)
-        setIfEmpty(node, "publisher", idReference(identity));
-      const webPage = find(PrimaryWebPageId);
-      if (webPage)
-        setIfEmpty(webPage, "isPartOf", idReference(node));
-    }
-    return node;
-  }
-});
-
-const listItemResolver = defineSchemaOrgResolver({
-  cast(node) {
-    if (typeof node === "string") {
-      node = {
-        name: node
-      };
-    }
-    return node;
-  },
-  defaults: {
-    "@type": "ListItem"
-  },
-  resolve(node, ctx) {
-    if (typeof node.item === "string")
-      node.item = resolveWithBase(ctx.meta.host, node.item);
-    else if (typeof node.item === "object")
-      node.item = resolveRelation(node.item, ctx);
-    return node;
-  }
-});
-
-const PrimaryBreadcrumbId = "#breadcrumb";
-const breadcrumbResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "BreadcrumbList"
-  },
-  idPrefix: ["url", PrimaryBreadcrumbId],
-  resolve(breadcrumb, ctx) {
-    if (breadcrumb.itemListElement) {
-      let index = 1;
-      breadcrumb.itemListElement = resolveRelation(breadcrumb.itemListElement, ctx, listItemResolver, {
-        array: true,
-        afterResolve(node) {
-          setIfEmpty(node, "position", index++);
-        }
-      });
-    }
-    return breadcrumb;
-  },
-  resolveRootNode(node, { find }) {
-    const webPage = find(PrimaryWebPageId);
-    if (webPage)
-      setIfEmpty(webPage, "breadcrumb", idReference(node));
-  }
-});
-
-const imageResolver = defineSchemaOrgResolver({
-  alias: "image",
-  cast(input) {
-    if (typeof input === "string") {
-      input = {
-        url: input
-      };
-    }
-    return input;
-  },
-  defaults: {
-    "@type": "ImageObject"
-  },
-  inheritMeta: [
-    // @todo possibly only do if there's a caption
-    "inLanguage"
-  ],
-  idPrefix: "host",
-  resolve(image, { meta }) {
-    image.url = resolveWithBase(meta.host, image.url);
-    setIfEmpty(image, "contentUrl", image.url);
-    if (image.height && !image.width)
-      delete image.height;
-    if (image.width && !image.height)
-      delete image.width;
-    return image;
-  }
-});
-
-const addressResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "PostalAddress"
-  }
-});
-
-const organizationResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "Organization"
-  },
-  idPrefix: ["host", IdentityId],
-  inheritMeta: [
-    { meta: "host", key: "url" }
-  ],
-  resolve(node, ctx) {
-    resolveDefaultType(node, "Organization");
-    node.address = resolveRelation(node.address, ctx, addressResolver);
-    return node;
-  },
-  resolveRootNode(node, ctx) {
-    const isIdentity = resolveAsGraphKey(node["@id"]) === IdentityId;
-    const webPage = ctx.find(PrimaryWebPageId);
-    if (node.logo) {
-      node.logo = resolveRelation(node.logo, ctx, imageResolver, {
-        root: true,
-        afterResolve(logo) {
-          if (isIdentity)
-            logo["@id"] = prefixId(ctx.meta.host, "#logo");
-          setIfEmpty(logo, "caption", node.name);
-        }
-      });
-      if (webPage)
-        setIfEmpty(webPage, "primaryImageOfPage", idReference(node.logo));
-    }
-    if (isIdentity && webPage)
-      setIfEmpty(webPage, "about", idReference(node));
-    const webSite = ctx.find(PrimaryWebSiteId);
-    if (webSite)
-      setIfEmpty(webSite, "publisher", idReference(node));
-  }
-});
-
-const personResolver = defineSchemaOrgResolver({
-  cast(node) {
-    if (typeof node === "string") {
-      return {
-        name: node
-      };
-    }
-    return node;
-  },
-  defaults: {
-    "@type": "Person"
-  },
-  idPrefix: ["host", IdentityId],
-  resolveRootNode(node, { find, meta }) {
-    if (resolveAsGraphKey(node["@id"]) === IdentityId) {
-      setIfEmpty(node, "url", meta.host);
-      const webPage = find(PrimaryWebPageId);
-      if (webPage)
-        setIfEmpty(webPage, "about", idReference(node));
-      const webSite = find(PrimaryWebSiteId);
-      if (webSite)
-        setIfEmpty(webSite, "publisher", idReference(node));
-    }
-    const article = find(PrimaryArticleId);
-    if (article)
-      setIfEmpty(article, "author", idReference(node));
-  }
-});
-
-const readActionResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "ReadAction"
-  },
-  resolve(node, ctx) {
-    if (!node.target.includes(ctx.meta.url))
-      node.target.unshift(ctx.meta.url);
-    return node;
-  }
-});
-
-const PrimaryWebPageId = "#webpage";
-const webPageResolver = defineSchemaOrgResolver({
-  defaults({ meta }) {
-    const endPath = ufo.withoutTrailingSlash(meta.url.substring(meta.url.lastIndexOf("/") + 1));
-    let type = "WebPage";
-    switch (endPath) {
-      case "about":
-      case "about-us":
-        type = "AboutPage";
-        break;
-      case "search":
-        type = "SearchResultsPage";
-        break;
-      case "checkout":
-        type = "CheckoutPage";
-        break;
-      case "contact":
-      case "get-in-touch":
-      case "contact-us":
-        type = "ContactPage";
-        break;
-      case "faq":
-        type = "FAQPage";
-        break;
-    }
-    const defaults = {
-      "@type": type
-    };
-    return defaults;
-  },
-  idPrefix: ["url", PrimaryWebPageId],
-  inheritMeta: [
-    { meta: "title", key: "name" },
-    "description",
-    "datePublished",
-    "dateModified",
-    "url"
-  ],
-  resolve(node, ctx) {
-    node.dateModified = resolvableDateToIso(node.dateModified);
-    node.datePublished = resolvableDateToIso(node.datePublished);
-    resolveDefaultType(node, "WebPage");
-    node.about = resolveRelation(node.about, ctx, organizationResolver);
-    node.breadcrumb = resolveRelation(node.breadcrumb, ctx, breadcrumbResolver);
-    node.author = resolveRelation(node.author, ctx, personResolver);
-    node.primaryImageOfPage = resolveRelation(node.primaryImageOfPage, ctx, imageResolver);
-    node.potentialAction = resolveRelation(node.potentialAction, ctx, readActionResolver);
-    if (node["@type"] === "WebPage") {
-      setIfEmpty(node, "potentialAction", [
-        {
-          "@type": "ReadAction",
-          "target": [ctx.meta.url]
-        }
-      ]);
-    }
-    return node;
-  },
-  resolveRootNode(webPage, { find, meta }) {
-    const identity = find(IdentityId);
-    const webSite = find(PrimaryWebSiteId);
-    const logo = find("#logo");
-    if (identity && meta.url === meta.host)
-      setIfEmpty(webPage, "about", idReference(identity));
-    if (logo)
-      setIfEmpty(webPage, "primaryImageOfPage", idReference(logo));
-    if (webSite)
-      setIfEmpty(webPage, "isPartOf", idReference(webSite));
-    const breadcrumb = find(PrimaryBreadcrumbId);
-    if (breadcrumb)
-      setIfEmpty(webPage, "breadcrumb", idReference(breadcrumb));
-    return webPage;
-  }
-});
-
-const PrimaryArticleId = "#article";
-const articleResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "Article"
-  },
-  inheritMeta: [
-    "inLanguage",
-    "description",
-    "image",
-    "dateModified",
-    "datePublished",
-    { meta: "title", key: "headline" }
-  ],
-  idPrefix: ["url", PrimaryArticleId],
-  resolve(node, ctx) {
-    node.author = resolveRelation(node.author, ctx, personResolver, {
-      root: true
-    });
-    node.publisher = resolveRelation(node.publisher, ctx);
-    node.dateModified = resolvableDateToIso(node.dateModified);
-    node.datePublished = resolvableDateToIso(node.datePublished);
-    resolveDefaultType(node, "Article");
-    node.headline = trimLength(node.headline, 110);
-    return node;
-  },
-  resolveRootNode(node, { find, meta }) {
-    const webPage = find(PrimaryWebPageId);
-    const identity = find(IdentityId);
-    if (node.image && !node.thumbnailUrl) {
-      const firstImage = asArray(node.image)[0];
-      if (typeof firstImage === "string")
-        setIfEmpty(node, "thumbnailUrl", resolveWithBase(meta.host, firstImage));
-      else if (firstImage?.["@id"])
-        setIfEmpty(node, "thumbnailUrl", find(firstImage["@id"])?.url);
-    }
-    if (identity) {
-      setIfEmpty(node, "publisher", idReference(identity));
-      setIfEmpty(node, "author", idReference(identity));
-    }
-    if (webPage) {
-      setIfEmpty(node, "isPartOf", idReference(webPage));
-      setIfEmpty(node, "mainEntityOfPage", idReference(webPage));
-      setIfEmpty(webPage, "potentialAction", [
-        {
-          "@type": "ReadAction",
-          "target": [meta.url]
-        }
-      ]);
-      setIfEmpty(webPage, "dateModified", node.dateModified);
-      setIfEmpty(webPage, "datePublished", node.datePublished);
-    }
-    return node;
-  }
-});
-
-const bookEditionResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "Book"
-  },
-  inheritMeta: [
-    "inLanguage"
-  ],
-  resolve(node, ctx) {
-    if (node.bookFormat)
-      node.bookFormat = ufo.withBase(node.bookFormat, "https://schema.org/");
-    if (node.datePublished)
-      node.datePublished = resolvableDateToDate(node.datePublished);
-    node.author = resolveRelation(node.author, ctx);
-    return node;
-  },
-  resolveRootNode(node, { find }) {
-    const identity = find(IdentityId);
-    if (identity)
-      setIfEmpty(node, "provider", idReference(identity));
-    return node;
-  }
-});
-const PrimaryBookId = "#book";
-const bookResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "Book"
-  },
-  inheritMeta: [
-    "description",
-    "url",
-    { meta: "title", key: "name" }
-  ],
-  idPrefix: ["url", PrimaryBookId],
-  resolve(node, ctx) {
-    node.workExample = resolveRelation(node.workExample, ctx, bookEditionResolver);
-    node.author = resolveRelation(node.author, ctx);
-    if (node.url)
-      ufo.withBase(node.url, ctx.meta.host);
-    return node;
-  },
-  resolveRootNode(node, { find }) {
-    const identity = find(IdentityId);
-    if (identity)
-      setIfEmpty(node, "author", idReference(identity));
-    return node;
-  }
-});
-
-const commentResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "Comment"
-  },
-  idPrefix: "url",
-  resolve(node, ctx) {
-    node.author = resolveRelation(node.author, ctx, personResolver, {
-      root: true
-    });
-    return node;
-  },
-  resolveRootNode(node, { find }) {
-    const article = find(PrimaryArticleId);
-    if (article)
-      setIfEmpty(node, "about", idReference(article));
-  }
-});
-
-const courseResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "Course"
-  },
-  resolve(node, ctx) {
-    node.provider = resolveRelation(node.provider, ctx, organizationResolver, {
-      root: true
-    });
-    return node;
-  },
-  resolveRootNode(node, { find }) {
-    const identity = find(IdentityId);
-    if (identity)
-      setIfEmpty(node, "provider", idReference(identity));
-    return node;
-  }
-});
-
-const placeResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "Place"
-  },
-  resolve(node, ctx) {
-    if (typeof node.address !== "string")
-      node.address = resolveRelation(node.address, ctx, addressResolver);
-    return node;
-  }
-});
-
-const virtualLocationResolver = defineSchemaOrgResolver({
-  cast(node) {
-    if (typeof node === "string") {
-      return {
-        url: node
-      };
-    }
-    return node;
-  },
-  defaults: {
-    "@type": "VirtualLocation"
-  }
-});
-
-const PrimaryEventId = "#event";
-const eventResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "Event"
-  },
-  inheritMeta: [
-    "inLanguage",
-    "description",
-    "image",
-    { meta: "title", key: "name" }
-  ],
-  idPrefix: ["url", PrimaryEventId],
-  resolve(node, ctx) {
-    if (node.location) {
-      const isVirtual = node.location === "string" || node.location?.url !== "undefined";
-      node.location = resolveRelation(node.location, ctx, isVirtual ? virtualLocationResolver : placeResolver);
-    }
-    node.performer = resolveRelation(node.performer, ctx, personResolver, {
-      root: true
-    });
-    node.organizer = resolveRelation(node.organizer, ctx, organizationResolver, {
-      root: true
-    });
-    node.offers = resolveRelation(node.offers, ctx, offerResolver);
-    if (node.eventAttendanceMode)
-      node.eventAttendanceMode = ufo.withBase(node.eventAttendanceMode, "https://schema.org/");
-    if (node.eventStatus)
-      node.eventStatus = ufo.withBase(node.eventStatus, "https://schema.org/");
-    const isOnline = node.eventStatus === "https://schema.org/EventMovedOnline";
-    const dates = ["startDate", "previousStartDate", "endDate"];
-    dates.forEach((date) => {
-      if (!isOnline) {
-        if (node[date] instanceof Date && node[date].getHours() === 0 && node[date].getMinutes() === 0)
-          node[date] = resolvableDateToDate(node[date]);
-      } else {
-        node[date] = resolvableDateToIso(node[date]);
-      }
-    });
-    setIfEmpty(node, "endDate", node.startDate);
-    return node;
-  },
-  resolveRootNode(node, { find }) {
-    const identity = find(IdentityId);
-    if (identity)
-      setIfEmpty(node, "organizer", idReference(identity));
-  }
-});
-
-const howToStepDirectionResolver = defineSchemaOrgResolver({
-  cast(node) {
-    if (typeof node === "string") {
-      return {
-        text: node
-      };
-    }
-    return node;
-  },
-  defaults: {
-    "@type": "HowToDirection"
-  }
-});
-
-const howToStepResolver = defineSchemaOrgResolver({
-  cast(node) {
-    if (typeof node === "string") {
-      return {
-        text: node
-      };
-    }
-    return node;
-  },
-  defaults: {
-    "@type": "HowToStep"
-  },
-  resolve(step, ctx) {
-    if (step.url)
-      step.url = resolveWithBase(ctx.meta.url, step.url);
-    if (step.image) {
-      step.image = resolveRelation(step.image, ctx, imageResolver, {
-        root: true
-      });
-    }
-    if (step.itemListElement)
-      step.itemListElement = resolveRelation(step.itemListElement, ctx, howToStepDirectionResolver);
-    return step;
-  }
-});
-
-const HowToId = "#howto";
-const howToResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "HowTo"
-  },
-  inheritMeta: [
-    "description",
-    "image",
-    "inLanguage",
-    { meta: "title", key: "name" }
-  ],
-  idPrefix: ["url", HowToId],
-  resolve(node, ctx) {
-    node.step = resolveRelation(node.step, ctx, howToStepResolver);
-    return node;
-  },
-  resolveRootNode(node, { find }) {
-    const webPage = find(PrimaryWebPageId);
-    if (webPage)
-      setIfEmpty(node, "mainEntityOfPage", idReference(webPage));
-  }
-});
-
-const itemListResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "ItemList"
-  },
-  resolve(node, ctx) {
-    if (node.itemListElement) {
-      let index = 1;
-      node.itemListElement = resolveRelation(node.itemListElement, ctx, listItemResolver, {
-        array: true,
-        afterResolve(node2) {
-          setIfEmpty(node2, "position", index++);
-        }
-      });
-    }
-    return node;
-  }
-});
-
-const quantitativeValueResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "QuantitativeValue"
-  }
-});
-const monetaryAmountResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "MonetaryAmount"
-  },
-  resolve(node, ctx) {
-    node.value = resolveRelation(node.value, ctx, quantitativeValueResolver);
-    return node;
-  }
-});
-
-const jobPostingResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "JobPosting"
-  },
-  resolve(node, ctx) {
-    node.datePosted = resolvableDateToIso(node.datePosted);
-    node.hiringOrganization = resolveRelation(node.hiringOrganization, ctx, organizationResolver);
-    node.jobLocation = resolveRelation(node.jobLocation, ctx, placeResolver);
-    node.baseSalary = resolveRelation(node.baseSalary, ctx, monetaryAmountResolver);
-    node.validThrough = resolvableDateToIso(node.validThrough);
-    return node;
-  }
-});
-
-const openingHoursResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "OpeningHoursSpecification",
-    "opens": "00:00",
-    "closes": "23:59"
-  }
-});
-
-const localBusinessResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": ["Organization", "LocalBusiness"]
-  },
-  inheritMeta: [
-    { key: "url", meta: "host" },
-    { key: "currenciesAccepted", meta: "currency" }
-  ],
-  idPrefix: ["host", IdentityId],
-  resolve(node, ctx) {
-    resolveDefaultType(node, ["Organization", "LocalBusiness"]);
-    node.address = resolveRelation(node.address, ctx, addressResolver);
-    node.openingHoursSpecification = resolveRelation(node.openingHoursSpecification, ctx, openingHoursResolver);
-    node.logo = resolveRelation(node.logo, ctx, imageResolver, {
-      afterResolve(logo) {
-        const hasLogo = !!ctx.find("#logo");
-        if (!hasLogo)
-          logo["@id"] = prefixId(ctx.meta.host, "#logo");
-        setIfEmpty(logo, "caption", node.name);
-      }
-    });
-    return node;
-  }
-});
-
-const ratingResolver = defineSchemaOrgResolver({
-  cast(node) {
-    if (node === "number") {
-      return {
-        ratingValue: node
-      };
-    }
-    return node;
-  },
-  defaults: {
-    "@type": "Rating",
-    "bestRating": 5,
-    "worstRating": 1
-  }
-});
-
-const reviewResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "Review"
-  },
-  inheritMeta: [
-    "inLanguage"
-  ],
-  resolve(review, ctx) {
-    review.reviewRating = resolveRelation(review.reviewRating, ctx, ratingResolver);
-    review.author = resolveRelation(review.author, ctx, personResolver);
-    return review;
-  }
-});
-
-const videoResolver = defineSchemaOrgResolver({
-  cast(input) {
-    if (typeof input === "string") {
-      input = {
-        url: input
-      };
-    }
-    return input;
-  },
-  alias: "video",
-  defaults: {
-    "@type": "VideoObject"
-  },
-  inheritMeta: [
-    { meta: "title", key: "name" },
-    "description",
-    "image",
-    "inLanguage",
-    { meta: "datePublished", key: "uploadDate" }
-  ],
-  idPrefix: "host",
-  resolve(video, ctx) {
-    if (video.uploadDate)
-      video.uploadDate = resolvableDateToIso(video.uploadDate);
-    video.url = resolveWithBase(ctx.meta.host, video.url);
-    if (video.caption && !video.description)
-      video.description = video.caption;
-    if (!video.description)
-      video.description = "No description";
-    if (video.thumbnailUrl)
-      video.thumbnailUrl = resolveRelation(video.thumbnailUrl, ctx, imageResolver);
-    return video;
-  },
-  resolveRootNode(video, { find }) {
-    if (video.image && !video.thumbnailUrl) {
-      const firstImage = asArray(video.image)[0];
-      setIfEmpty(video, "thumbnailUrl", find(firstImage["@id"])?.url);
-    }
-  }
-});
-
-const movieResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "Movie"
-  },
-  resolve(node, ctx) {
-    node.aggregateRating = resolveRelation(node.aggregateRating, ctx, aggregateRatingResolver);
-    node.review = resolveRelation(node.review, ctx, reviewResolver);
-    node.director = resolveRelation(node.director, ctx, personResolver);
-    node.actor = resolveRelation(node.actor, ctx, personResolver);
-    node.trailer = resolveRelation(node.trailer, ctx, videoResolver);
-    if (node.dateCreated)
-      node.dateCreated = resolvableDateToDate(node.dateCreated);
-    return node;
-  }
-});
-
-const defaults = {
-  ignoreUnknown: false,
-  respectType: false,
-  respectFunctionNames: false,
-  respectFunctionProperties: false,
-  unorderedObjects: true,
-  unorderedArrays: false,
-  unorderedSets: false
-};
-function objectHash(object, options = {}) {
-  options = { ...defaults, ...options };
-  const hasher = createHasher(options);
-  hasher.dispatch(object);
-  return hasher.toString();
-}
-function createHasher(options) {
-  const buff = [];
-  let context = [];
-  const write = (str) => {
-    buff.push(str);
-  };
-  return {
-    toString() {
-      return buff.join("");
-    },
-    getContext() {
-      return context;
-    },
-    dispatch(value) {
-      if (options.replacer) {
-        value = options.replacer(value);
-      }
-      const type = value === null ? "null" : typeof value;
-      return this["_" + type](value);
-    },
-    _object(object) {
-      if (object && typeof object.toJSON === "function") {
-        return this._object(object.toJSON());
-      }
-      const pattern = /\[object (.*)]/i;
-      const objString = Object.prototype.toString.call(object);
-      const _objType = pattern.exec(objString);
-      const objType = _objType ? _objType[1].toLowerCase() : "unknown:[" + objString.toLowerCase() + "]";
-      let objectNumber = null;
-      if ((objectNumber = context.indexOf(object)) >= 0) {
-        return this.dispatch("[CIRCULAR:" + objectNumber + "]");
-      } else {
-        context.push(object);
-      }
-      if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
-        write("buffer:");
-        return write(object.toString("utf8"));
-      }
-      if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
-        if (this["_" + objType]) {
-          this["_" + objType](object);
-        } else if (!options.ignoreUnknown) {
-          this._unkown(object, objType);
-        }
-      } else {
-        let keys = Object.keys(object);
-        if (options.unorderedObjects) {
-          keys = keys.sort();
-        }
-        if (options.respectType !== false && !isNativeFunction(object)) {
-          keys.splice(0, 0, "prototype", "__proto__", "letructor");
-        }
-        if (options.excludeKeys) {
-          keys = keys.filter(function(key) {
-            return !options.excludeKeys(key);
-          });
-        }
-        write("object:" + keys.length + ":");
-        for (const key of keys) {
-          this.dispatch(key);
-          write(":");
-          if (!options.excludeValues) {
-            this.dispatch(object[key]);
-          }
-          write(",");
-        }
-      }
-    },
-    _array(arr, unordered) {
-      unordered = typeof unordered !== "undefined" ? unordered : options.unorderedArrays !== false;
-      write("array:" + arr.length + ":");
-      if (!unordered || arr.length <= 1) {
-        for (const entry of arr) {
-          this.dispatch(entry);
-        }
-        return;
-      }
-      const contextAdditions = [];
-      const entries = arr.map((entry) => {
-        const hasher = createHasher(options);
-        hasher.dispatch(entry);
-        contextAdditions.push(hasher.getContext());
-        return hasher.toString();
-      });
-      context = [...context, ...contextAdditions];
-      entries.sort();
-      return this._array(entries, false);
-    },
-    _date(date) {
-      return write("date:" + date.toJSON());
-    },
-    _symbol(sym) {
-      return write("symbol:" + sym.toString());
-    },
-    _unkown(value, type) {
-      write(type);
-      if (!value) {
-        return;
-      }
-      write(":");
-      if (value && typeof value.entries === "function") {
-        return this._array(
-          Array.from(value.entries()),
-          true
-          /* ordered */
-        );
-      }
-    },
-    _error(err) {
-      return write("error:" + err.toString());
-    },
-    _boolean(bool) {
-      return write("bool:" + bool.toString());
-    },
-    _string(string) {
-      write("string:" + string.length + ":");
-      write(string.toString());
-    },
-    _function(fn) {
-      write("fn:");
-      if (isNativeFunction(fn)) {
-        this.dispatch("[native]");
-      } else {
-        this.dispatch(fn.toString());
-      }
-      if (options.respectFunctionNames !== false) {
-        this.dispatch("function-name:" + String(fn.name));
-      }
-      if (options.respectFunctionProperties) {
-        this._object(fn);
-      }
-    },
-    _number(number) {
-      return write("number:" + number.toString());
-    },
-    _xml(xml) {
-      return write("xml:" + xml.toString());
-    },
-    _null() {
-      return write("Null");
-    },
-    _undefined() {
-      return write("Undefined");
-    },
-    _regexp(regex) {
-      return write("regex:" + regex.toString());
-    },
-    _uint8array(arr) {
-      write("uint8array:");
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _uint8clampedarray(arr) {
-      write("uint8clampedarray:");
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _int8array(arr) {
-      write("int8array:");
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _uint16array(arr) {
-      write("uint16array:");
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _int16array(arr) {
-      write("int16array:");
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _uint32array(arr) {
-      write("uint32array:");
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _int32array(arr) {
-      write("int32array:");
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _float32array(arr) {
-      write("float32array:");
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _float64array(arr) {
-      write("float64array:");
-      return this.dispatch(Array.prototype.slice.call(arr));
-    },
-    _arraybuffer(arr) {
-      write("arraybuffer:");
-      return this.dispatch(new Uint8Array(arr));
-    },
-    _url(url) {
-      return write("url:" + url.toString());
-    },
-    _map(map) {
-      write("map:");
-      const arr = [...map];
-      return this._array(arr, options.unorderedSets !== false);
-    },
-    _set(set) {
-      write("set:");
-      const arr = [...set];
-      return this._array(arr, options.unorderedSets !== false);
-    },
-    _file(file) {
-      write("file:");
-      return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
-    },
-    _blob() {
-      if (options.ignoreUnknown) {
-        return write("[blob]");
-      }
-      throw new Error(
-        'Hashing Blob objects is currently not supported\nUse "options.replacer" or "options.ignoreUnknown"\n'
-      );
-    },
-    _domwindow() {
-      return write("domwindow");
-    },
-    _bigint(number) {
-      return write("bigint:" + number.toString());
-    },
-    /* Node.js standard native objects */
-    _process() {
-      return write("process");
-    },
-    _timer() {
-      return write("timer");
-    },
-    _pipe() {
-      return write("pipe");
-    },
-    _tcp() {
-      return write("tcp");
-    },
-    _udp() {
-      return write("udp");
-    },
-    _tty() {
-      return write("tty");
-    },
-    _statwatcher() {
-      return write("statwatcher");
-    },
-    _securecontext() {
-      return write("securecontext");
-    },
-    _connection() {
-      return write("connection");
-    },
-    _zlib() {
-      return write("zlib");
-    },
-    _context() {
-      return write("context");
-    },
-    _nodescript() {
-      return write("nodescript");
-    },
-    _httpparser() {
-      return write("httpparser");
-    },
-    _dataview() {
-      return write("dataview");
-    },
-    _signal() {
-      return write("signal");
-    },
-    _fsevent() {
-      return write("fsevent");
-    },
-    _tlswrap() {
-      return write("tlswrap");
-    }
-  };
-}
-function isNativeFunction(f) {
-  if (typeof f !== "function") {
-    return false;
-  }
-  const exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code]\s+}$/i;
-  return exp.exec(Function.prototype.toString.call(f)) != null;
-}
-
-class WordArray {
-  constructor(words, sigBytes) {
-    words = this.words = words || [];
-    this.sigBytes = sigBytes !== void 0 ? sigBytes : words.length * 4;
-  }
-  toString(encoder) {
-    return (encoder || Hex).stringify(this);
-  }
-  concat(wordArray) {
-    this.clamp();
-    if (this.sigBytes % 4) {
-      for (let i = 0; i < wordArray.sigBytes; i++) {
-        const thatByte = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
-        this.words[this.sigBytes + i >>> 2] |= thatByte << 24 - (this.sigBytes + i) % 4 * 8;
-      }
-    } else {
-      for (let j = 0; j < wordArray.sigBytes; j += 4) {
-        this.words[this.sigBytes + j >>> 2] = wordArray.words[j >>> 2];
-      }
-    }
-    this.sigBytes += wordArray.sigBytes;
-    return this;
-  }
-  clamp() {
-    this.words[this.sigBytes >>> 2] &= 4294967295 << 32 - this.sigBytes % 4 * 8;
-    this.words.length = Math.ceil(this.sigBytes / 4);
-  }
-  clone() {
-    return new WordArray([...this.words]);
-  }
-}
-const Hex = {
-  stringify(wordArray) {
-    const hexChars = [];
-    for (let i = 0; i < wordArray.sigBytes; i++) {
-      const bite = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
-      hexChars.push((bite >>> 4).toString(16), (bite & 15).toString(16));
-    }
-    return hexChars.join("");
-  }
-};
-const Base64 = {
-  stringify(wordArray) {
-    const keyStr = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-    const base64Chars = [];
-    for (let i = 0; i < wordArray.sigBytes; i += 3) {
-      const byte1 = wordArray.words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
-      const byte2 = wordArray.words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;
-      const byte3 = wordArray.words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;
-      const triplet = byte1 << 16 | byte2 << 8 | byte3;
-      for (let j = 0; j < 4 && i * 8 + j * 6 < wordArray.sigBytes * 8; j++) {
-        base64Chars.push(keyStr.charAt(triplet >>> 6 * (3 - j) & 63));
-      }
-    }
-    return base64Chars.join("");
-  }
-};
-const Latin1 = {
-  parse(latin1Str) {
-    const latin1StrLength = latin1Str.length;
-    const words = [];
-    for (let i = 0; i < latin1StrLength; i++) {
-      words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;
-    }
-    return new WordArray(words, latin1StrLength);
-  }
-};
-const Utf8 = {
-  parse(utf8Str) {
-    return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
-  }
-};
-class BufferedBlockAlgorithm {
-  constructor() {
-    this._minBufferSize = 0;
-    this.blockSize = 512 / 32;
-    this.reset();
-  }
-  reset() {
-    this._data = new WordArray();
-    this._nDataBytes = 0;
-  }
-  _append(data) {
-    if (typeof data === "string") {
-      data = Utf8.parse(data);
-    }
-    this._data.concat(data);
-    this._nDataBytes += data.sigBytes;
-  }
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
-  _doProcessBlock(_dataWords, _offset) {
-  }
-  _process(doFlush) {
-    let processedWords;
-    let nBlocksReady = this._data.sigBytes / (this.blockSize * 4);
-    if (doFlush) {
-      nBlocksReady = Math.ceil(nBlocksReady);
-    } else {
-      nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
-    }
-    const nWordsReady = nBlocksReady * this.blockSize;
-    const nBytesReady = Math.min(nWordsReady * 4, this._data.sigBytes);
-    if (nWordsReady) {
-      for (let offset = 0; offset < nWordsReady; offset += this.blockSize) {
-        this._doProcessBlock(this._data.words, offset);
-      }
-      processedWords = this._data.words.splice(0, nWordsReady);
-      this._data.sigBytes -= nBytesReady;
-    }
-    return new WordArray(processedWords, nBytesReady);
-  }
-}
-class Hasher extends BufferedBlockAlgorithm {
-  update(messageUpdate) {
-    this._append(messageUpdate);
-    this._process();
-    return this;
-  }
-  finalize(messageUpdate) {
-    if (messageUpdate) {
-      this._append(messageUpdate);
-    }
-  }
-}
-
-const H = [
-  1779033703,
-  -1150833019,
-  1013904242,
-  -1521486534,
-  1359893119,
-  -1694144372,
-  528734635,
-  1541459225
-];
-const K = [
-  1116352408,
-  1899447441,
-  -1245643825,
-  -373957723,
-  961987163,
-  1508970993,
-  -1841331548,
-  -1424204075,
-  -670586216,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  -2132889090,
-  -1680079193,
-  -1046744716,
-  -459576895,
-  -272742522,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  -1740746414,
-  -1473132947,
-  -1341970488,
-  -1084653625,
-  -958395405,
-  -710438585,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  -2117940946,
-  -1838011259,
-  -1564481375,
-  -1474664885,
-  -1035236496,
-  -949202525,
-  -778901479,
-  -694614492,
-  -200395387,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  -2067236844,
-  -1933114872,
-  -1866530822,
-  -1538233109,
-  -1090935817,
-  -965641998
-];
-const W = [];
-class SHA256 extends Hasher {
-  constructor() {
-    super();
-    this.reset();
-  }
-  reset() {
-    super.reset();
-    this._hash = new WordArray([...H]);
-  }
-  _doProcessBlock(M, offset) {
-    const H2 = this._hash.words;
-    let a = H2[0];
-    let b = H2[1];
-    let c = H2[2];
-    let d = H2[3];
-    let e = H2[4];
-    let f = H2[5];
-    let g = H2[6];
-    let h = H2[7];
-    for (let i = 0; i < 64; i++) {
-      if (i < 16) {
-        W[i] = M[offset + i] | 0;
-      } else {
-        const gamma0x = W[i - 15];
-        const gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;
-        const gamma1x = W[i - 2];
-        const gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;
-        W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
-      }
-      const ch = e & f ^ ~e & g;
-      const maj = a & b ^ a & c ^ b & c;
-      const sigma0 = (a << 30 | a >>> 2) ^ (a << 19 | a >>> 13) ^ (a << 10 | a >>> 22);
-      const sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);
-      const t1 = h + sigma1 + ch + K[i] + W[i];
-      const t2 = sigma0 + maj;
-      h = g;
-      g = f;
-      f = e;
-      e = d + t1 | 0;
-      d = c;
-      c = b;
-      b = a;
-      a = t1 + t2 | 0;
-    }
-    H2[0] = H2[0] + a | 0;
-    H2[1] = H2[1] + b | 0;
-    H2[2] = H2[2] + c | 0;
-    H2[3] = H2[3] + d | 0;
-    H2[4] = H2[4] + e | 0;
-    H2[5] = H2[5] + f | 0;
-    H2[6] = H2[6] + g | 0;
-    H2[7] = H2[7] + h | 0;
-  }
-  finalize(messageUpdate) {
-    super.finalize(messageUpdate);
-    const nBitsTotal = this._nDataBytes * 8;
-    const nBitsLeft = this._data.sigBytes * 8;
-    this._data.words[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
-    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(
-      nBitsTotal / 4294967296
-    );
-    this._data.words[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
-    this._data.sigBytes = this._data.words.length * 4;
-    this._process();
-    return this._hash;
-  }
-}
-function sha256base64(message) {
-  return new SHA256().finalize(message).toString(Base64);
-}
-
-function hash(object, options = {}) {
-  const hashed = typeof object === "string" ? object : objectHash(object, options);
-  return sha256base64(hashed).slice(0, 10);
-}
-
-const ProductId = "#product";
-const productResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "Product"
-  },
-  inheritMeta: [
-    "description",
-    "image",
-    { meta: "title", key: "name" }
-  ],
-  idPrefix: ["url", ProductId],
-  resolve(node, ctx) {
-    setIfEmpty(node, "sku", hash(node.name));
-    node.aggregateOffer = resolveRelation(node.aggregateOffer, ctx, aggregateOfferResolver);
-    node.aggregateRating = resolveRelation(node.aggregateRating, ctx, aggregateRatingResolver);
-    node.offers = resolveRelation(node.offers, ctx, offerResolver);
-    node.review = resolveRelation(node.review, ctx, reviewResolver);
-    return node;
-  },
-  resolveRootNode(product, { find }) {
-    const webPage = find(PrimaryWebPageId);
-    const identity = find(IdentityId);
-    if (identity)
-      setIfEmpty(product, "brand", idReference(identity));
-    if (webPage)
-      setIfEmpty(product, "mainEntityOfPage", idReference(webPage));
-    return product;
-  }
-});
-
-const answerResolver = defineSchemaOrgResolver({
-  cast(node) {
-    if (typeof node === "string") {
-      return {
-        text: node
-      };
-    }
-    return node;
-  },
-  defaults: {
-    "@type": "Answer"
-  }
-});
-
-const questionResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "Question"
-  },
-  inheritMeta: [
-    "inLanguage"
-  ],
-  idPrefix: "url",
-  resolve(question, ctx) {
-    if (question.question)
-      question.name = question.question;
-    if (question.answer)
-      question.acceptedAnswer = question.answer;
-    question.acceptedAnswer = resolveRelation(question.acceptedAnswer, ctx, answerResolver);
-    return question;
-  },
-  resolveRootNode(question, { find }) {
-    const webPage = find(PrimaryWebPageId);
-    if (webPage && asArray(webPage["@type"]).includes("FAQPage"))
-      dedupeMerge(webPage, "mainEntity", idReference(question));
-  }
-});
-
-const RecipeId = "#recipe";
-const recipeResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "Recipe"
-  },
-  inheritMeta: [
-    { meta: "title", key: "name" },
-    "description",
-    "image",
-    "datePublished"
-  ],
-  idPrefix: ["url", RecipeId],
-  resolve(node, ctx) {
-    node.recipeInstructions = resolveRelation(node.recipeInstructions, ctx, howToStepResolver);
-    return node;
-  },
-  resolveRootNode(node, { find }) {
-    const article = find(PrimaryArticleId);
-    const webPage = find(PrimaryWebPageId);
-    if (article)
-      setIfEmpty(node, "mainEntityOfPage", idReference(article));
-    else if (webPage)
-      setIfEmpty(node, "mainEntityOfPage", idReference(webPage));
-    if (article?.author)
-      setIfEmpty(node, "author", article.author);
-    return node;
-  }
-});
-
-const softwareAppResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "SoftwareApplication"
-  },
-  resolve(node, ctx) {
-    resolveDefaultType(node, "SoftwareApplication");
-    node.offers = resolveRelation(node.offers, ctx, offerResolver);
-    node.aggregateRating = resolveRelation(node.aggregateRating, ctx, aggregateRatingResolver);
-    node.review = resolveRelation(node.review, ctx, reviewResolver);
-    return node;
-  }
-});
-
-function loadResolver(resolver) {
-  switch (resolver) {
-    case "address":
-      return addressResolver;
-    case "aggregateOffer":
-      return aggregateOfferResolver;
-    case "aggregateRating":
-      return aggregateRatingResolver;
-    case "article":
-      return articleResolver;
-    case "breadcrumb":
-      return breadcrumbResolver;
-    case "comment":
-      return commentResolver;
-    case "event":
-      return eventResolver;
-    case "virtualLocation":
-      return virtualLocationResolver;
-    case "place":
-      return placeResolver;
-    case "howTo":
-      return howToResolver;
-    case "howToStep":
-      return howToStepResolver;
-    case "image":
-      return imageResolver;
-    case "localBusiness":
-      return localBusinessResolver;
-    case "offer":
-      return offerResolver;
-    case "openingHours":
-      return openingHoursResolver;
-    case "organization":
-      return organizationResolver;
-    case "person":
-      return personResolver;
-    case "product":
-      return productResolver;
-    case "question":
-      return questionResolver;
-    case "recipe":
-      return recipeResolver;
-    case "review":
-      return reviewResolver;
-    case "video":
-      return videoResolver;
-    case "webPage":
-      return webPageResolver;
-    case "webSite":
-      return webSiteResolver;
-    case "book":
-      return bookResolver;
-    case "course":
-      return courseResolver;
-    case "itemList":
-      return itemListResolver;
-    case "jobPosting":
-      return jobPostingResolver;
-    case "listItem":
-      return listItemResolver;
-    case "movie":
-      return movieResolver;
-    case "searchAction":
-      return searchActionResolver;
-    case "readAction":
-      return readActionResolver;
-    case "softwareApp":
-      return softwareAppResolver;
-    case "bookEdition":
-      return bookEditionResolver;
-  }
-  return null;
-}
-
-const resolver = {
-  __proto__: null,
-  loadResolver: loadResolver
-};
-
-function resolveMeta(meta) {
-  if (!meta.host && meta.canonicalHost)
-    meta.host = meta.canonicalHost;
-  if (!meta.tagPosition && meta.position)
-    meta.tagPosition = meta.position;
-  if (!meta.currency && meta.defaultCurrency)
-    meta.currency = meta.defaultCurrency;
-  if (!meta.inLanguage && meta.defaultLanguage)
-    meta.inLanguage = meta.defaultLanguage;
-  if (!meta.path)
-    meta.path = "/";
-  if (!meta.host && typeof document !== "undefined")
-    meta.host = document.location.host;
-  if (!meta.url && meta.canonicalUrl)
-    meta.url = meta.canonicalUrl;
-  if (meta.path !== "/") {
-    if (meta.trailingSlash && !ufo.hasTrailingSlash(meta.path))
-      meta.path = ufo.withTrailingSlash(meta.path);
-    else if (!meta.trailingSlash && ufo.hasTrailingSlash(meta.path))
-      meta.path = ufo.withoutTrailingSlash(meta.path);
-  }
-  meta.url = ufo.joinURL(meta.host, meta.path);
-  return {
-    ...meta,
-    host: meta.host,
-    url: meta.url,
-    currency: meta.currency,
-    image: meta.image,
-    inLanguage: meta.inLanguage,
-    title: meta.title,
-    description: meta.description,
-    datePublished: meta.datePublished,
-    dateModified: meta.dateModified
-  };
-}
-function resolveNode(node, ctx, resolver) {
-  if (resolver?.cast)
-    node = resolver.cast(node, ctx);
-  if (resolver?.defaults) {
-    let defaults = resolver.defaults || {};
-    if (typeof defaults === "function")
-      defaults = defaults(ctx);
-    node = {
-      ...defaults,
-      ...node
-    };
-  }
-  resolver.inheritMeta?.forEach((entry) => {
-    if (typeof entry === "string")
-      setIfEmpty(node, entry, ctx.meta[entry]);
-    else
-      setIfEmpty(node, entry.key, ctx.meta[entry.meta]);
-  });
-  if (resolver?.resolve)
-    node = resolver.resolve(node, ctx);
-  for (const k in node) {
-    const v = node[k];
-    if (typeof v === "object" && v?._resolver)
-      node[k] = resolveRelation(v, ctx, v._resolver);
-  }
-  stripEmptyProperties(node);
-  return node;
-}
-function resolveNodeId(node, ctx, resolver, resolveAsRoot = false) {
-  const prefix = Array.isArray(resolver.idPrefix) ? resolver.idPrefix[0] : resolver.idPrefix;
-  if (!prefix)
-    return node;
-  if (node["@id"] && !node["@id"].startsWith(ctx.meta.host)) {
-    node["@id"] = prefixId(ctx.meta[prefix], node["@id"]);
-    return node;
-  }
-  const rootId = Array.isArray(resolver.idPrefix) ? resolver.idPrefix?.[1] : void 0;
-  if (resolveAsRoot && rootId) {
-    node["@id"] = prefixId(ctx.meta[prefix], rootId);
-  }
-  if (!node["@id"]) {
-    let alias = resolver?.alias;
-    if (!alias) {
-      const type = asArray(node["@type"])?.[0] || "";
-      alias = type.toLowerCase();
-    }
-    const hashNodeData = {};
-    Object.entries(node).forEach(([key, val]) => {
-      if (!key.startsWith("_"))
-        hashNodeData[key] = val;
-    });
-    node["@id"] = prefixId(ctx.meta[prefix], `#/schema/${alias}/${hashCode(JSON.stringify(hashNodeData))}`);
-  }
-  return node;
-}
-function resolveRelation(input, ctx, fallbackResolver, options = {}) {
-  if (!input)
-    return input;
-  const ids = asArray(input).map((a) => {
-    if (Object.keys(a).length === 1 && a["@id"])
-      return a;
-    let resolver = fallbackResolver;
-    if (a._resolver) {
-      resolver = a._resolver;
-      if (typeof resolver === "string")
-        resolver = loadResolver(resolver);
-      delete a._resolver;
-    }
-    if (!resolver)
-      return a;
-    let node = resolveNode(a, ctx, resolver);
-    if (options.afterResolve)
-      options.afterResolve(node);
-    if (options.generateId || options.root)
-      node = resolveNodeId(node, ctx, resolver, false);
-    if (options.root) {
-      if (resolver.resolveRootNode)
-        resolver.resolveRootNode(node, ctx);
-      ctx.push(node);
-      return idReference(node["@id"]);
-    }
-    return node;
-  });
-  if (!options.array && ids.length === 1)
-    return ids[0];
-  return ids;
-}
-
-function isObject(value) {
-  return value !== null && typeof value === "object";
-}
-function _defu(baseObject, defaults, namespace = ".", merger) {
-  if (!isObject(defaults)) {
-    return _defu(baseObject, {}, namespace, merger);
-  }
-  const object = Object.assign({}, defaults);
-  for (const key in baseObject) {
-    if (key === "__proto__" || key === "constructor") {
-      continue;
-    }
-    const value = baseObject[key];
-    if (value === null || value === void 0) {
-      continue;
-    }
-    if (merger && merger(object, key, value, namespace)) {
-      continue;
-    }
-    if (Array.isArray(value) && Array.isArray(object[key])) {
-      object[key] = [...value, ...object[key]];
-    } else if (isObject(value) && isObject(object[key])) {
-      object[key] = _defu(
-        value,
-        object[key],
-        (namespace ? `${namespace}.` : "") + key.toString(),
-        merger
-      );
-    } else {
-      object[key] = value;
-    }
-  }
-  return object;
-}
-function createDefu(merger) {
-  return (...arguments_) => (
-    // eslint-disable-next-line unicorn/no-array-reduce
-    arguments_.reduce((p, c) => _defu(p, c, "", merger), {})
-  );
-}
-const defu = createDefu();
-
-function groupBy(array, predicate) {
-  return array.reduce((acc, value, index, array2) => {
-    const key = predicate(value, index, array2);
-    if (!acc[key])
-      acc[key] = [];
-    acc[key].push(value);
-    return acc;
-  }, {});
-}
-function dedupeNodes(nodes) {
-  const dedupedNodes = {};
-  for (const key of nodes.keys()) {
-    const n = nodes[key];
-    const nodeKey = resolveAsGraphKey(n["@id"] || hash(n));
-    if (dedupedNodes[nodeKey])
-      dedupedNodes[nodeKey] = defu(nodes[key], dedupedNodes[nodeKey]);
-    else
-      dedupedNodes[nodeKey] = nodes[key];
-  }
-  return Object.values(dedupedNodes);
-}
-function normaliseNodes(nodes) {
-  const sortedNodeKeys = nodes.keys();
-  const dedupedNodes = {};
-  for (const key of sortedNodeKeys) {
-    const n = nodes[key];
-    const nodeKey = resolveAsGraphKey(n["@id"] || hash(n));
-    const groupedKeys = groupBy(Object.keys(n), (key2) => {
-      const val = n[key2];
-      if (key2.startsWith("_"))
-        return "ignored";
-      if (Array.isArray(val) || typeof val === "object")
-        return "relations";
-      return "primitives";
-    });
-    const keys = [
-      ...(groupedKeys.primitives || []).sort(),
-      ...(groupedKeys.relations || []).sort()
-    ];
-    let newNode = {};
-    for (const key2 of keys)
-      newNode[key2] = n[key2];
-    if (dedupedNodes[nodeKey])
-      newNode = defu(newNode, dedupedNodes[nodeKey]);
-    dedupedNodes[nodeKey] = newNode;
-  }
-  return Object.values(dedupedNodes);
-}
-
-function createSchemaOrgGraph() {
-  const ctx = {
-    find(id) {
-      const key = resolveAsGraphKey(id);
-      return ctx.nodes.filter((n) => !!n["@id"]).find((n) => resolveAsGraphKey(n["@id"]) === key);
-    },
-    push(input) {
-      asArray(input).forEach((node) => {
-        const registeredNode = node;
-        ctx.nodes.push(registeredNode);
-      });
-    },
-    resolveGraph(meta) {
-      ctx.meta = resolveMeta({ ...meta });
-      ctx.nodes.forEach((node, key) => {
-        const resolver = node._resolver;
-        if (resolver) {
-          node = resolveNode(node, ctx, resolver);
-          node = resolveNodeId(node, ctx, resolver, true);
-        }
-        ctx.nodes[key] = node;
-      });
-      ctx.nodes = dedupeNodes(ctx.nodes);
-      ctx.nodes.forEach((node) => {
-        if (node.image && typeof node.image === "string") {
-          node.image = resolveRelation(node.image, ctx, imageResolver, {
-            root: true
-          });
-        }
-        if (node._resolver?.resolveRootNode)
-          node._resolver.resolveRootNode(node, ctx);
-        delete node._resolver;
-      });
-      return normaliseNodes(ctx.nodes);
-    },
-    nodes: [],
-    meta: {}
-  };
-  return ctx;
-}
-
-function SchemaOrgUnheadPlugin(config, meta) {
-  config = resolveMeta({ ...config });
-  let graph;
-  const resolvedMeta = {};
-  return {
-    hooks: {
-      "entries:resolve": function() {
-        graph = createSchemaOrgGraph();
-      },
-      "tag:normalise": async function({ tag }) {
-        if (tag.key === "schema-org-graph") {
-          const { loadResolver } = await Promise.resolve().then(function () { return resolver; });
-          const nodes = await tag.props.nodes;
-          for (const node of Array.isArray(nodes) ? nodes : [nodes]) {
-            const newNode = {
-              ...node,
-              _resolver: loadResolver(await node._resolver)
-            };
-            graph.push(newNode);
-          }
-          tag.tagPosition = config.tagPosition === "head" ? "head" : "bodyClose";
-        }
-        if (tag.tag === "title")
-          resolvedMeta.title = tag.textContent;
-        else if (tag.tag === "meta" && tag.props.name === "description")
-          resolvedMeta.description = tag.props.content;
-        else if (tag.tag === "link" && tag.props.rel === "canonical")
-          resolvedMeta.url = tag.props.href;
-        else if (tag.tag === "meta" && tag.props.property === "og:image")
-          resolvedMeta.image = tag.props.content;
-      },
-      "tags:resolve": async function(ctx) {
-        for (const tag of ctx.tags) {
-          if (tag.tag === "script" && tag.key === "schema-org-graph") {
-            tag.innerHTML = JSON.stringify({
-              "@context": "https://schema.org",
-              "@graph": graph.resolveGraph({ ...config, ...resolvedMeta, ...await meta() })
-            }, null, 2);
-            delete tag.props.nodes;
-          }
-        }
-      }
-    }
-  };
-}
+require('ufo');
+require('@unhead/shared');
 
 function provideResolver(input, resolver) {
   if (!input)
@@ -2056,30 +122,63 @@ function useSchemaOrg(input) {
         nodes: input
       }
     ]
-  }, { mode: process.env.NODE_ENV === "development" ? "all" : "server" });
+  });
 }
 
-exports.HowToId = HowToId;
-exports.PrimaryArticleId = PrimaryArticleId;
-exports.PrimaryBookId = PrimaryBookId;
-exports.PrimaryBreadcrumbId = PrimaryBreadcrumbId;
-exports.PrimaryEventId = PrimaryEventId;
-exports.PrimaryWebPageId = PrimaryWebPageId;
-exports.PrimaryWebSiteId = PrimaryWebSiteId;
-exports.ProductId = ProductId;
-exports.RecipeId = RecipeId;
-exports.SchemaOrgUnheadPlugin = SchemaOrgUnheadPlugin;
-exports.addressResolver = addressResolver;
-exports.aggregateOfferResolver = aggregateOfferResolver;
-exports.aggregateRatingResolver = aggregateRatingResolver;
-exports.articleResolver = articleResolver;
-exports.bookEditionResolver = bookEditionResolver;
-exports.bookResolver = bookResolver;
-exports.breadcrumbResolver = breadcrumbResolver;
-exports.commentResolver = commentResolver;
-exports.courseResolver = courseResolver;
-exports.createSchemaOrgGraph = createSchemaOrgGraph;
-exports.dedupeNodes = dedupeNodes;
+exports.HowToId = SchemaOrgUnheadPlugin.HowToId;
+exports.PrimaryArticleId = SchemaOrgUnheadPlugin.PrimaryArticleId;
+exports.PrimaryBookId = SchemaOrgUnheadPlugin.PrimaryBookId;
+exports.PrimaryBreadcrumbId = SchemaOrgUnheadPlugin.PrimaryBreadcrumbId;
+exports.PrimaryEventId = SchemaOrgUnheadPlugin.PrimaryEventId;
+exports.PrimaryWebPageId = SchemaOrgUnheadPlugin.PrimaryWebPageId;
+exports.PrimaryWebSiteId = SchemaOrgUnheadPlugin.PrimaryWebSiteId;
+exports.ProductId = SchemaOrgUnheadPlugin.ProductId;
+exports.RecipeId = SchemaOrgUnheadPlugin.RecipeId;
+exports.SchemaOrgUnheadPlugin = SchemaOrgUnheadPlugin.SchemaOrgUnheadPlugin;
+exports.addressResolver = SchemaOrgUnheadPlugin.addressResolver;
+exports.aggregateOfferResolver = SchemaOrgUnheadPlugin.aggregateOfferResolver;
+exports.aggregateRatingResolver = SchemaOrgUnheadPlugin.aggregateRatingResolver;
+exports.articleResolver = SchemaOrgUnheadPlugin.articleResolver;
+exports.bookEditionResolver = SchemaOrgUnheadPlugin.bookEditionResolver;
+exports.bookResolver = SchemaOrgUnheadPlugin.bookResolver;
+exports.breadcrumbResolver = SchemaOrgUnheadPlugin.breadcrumbResolver;
+exports.commentResolver = SchemaOrgUnheadPlugin.commentResolver;
+exports.courseResolver = SchemaOrgUnheadPlugin.courseResolver;
+exports.createSchemaOrgGraph = SchemaOrgUnheadPlugin.createSchemaOrgGraph;
+exports.dedupeNodes = SchemaOrgUnheadPlugin.dedupeNodes;
+exports.defineSchemaOrgResolver = SchemaOrgUnheadPlugin.defineSchemaOrgResolver;
+exports.eventResolver = SchemaOrgUnheadPlugin.eventResolver;
+exports.howToResolver = SchemaOrgUnheadPlugin.howToResolver;
+exports.howToStepDirectionResolver = SchemaOrgUnheadPlugin.howToStepDirectionResolver;
+exports.howToStepResolver = SchemaOrgUnheadPlugin.howToStepResolver;
+exports.imageResolver = SchemaOrgUnheadPlugin.imageResolver;
+exports.itemListResolver = SchemaOrgUnheadPlugin.itemListResolver;
+exports.jobPostingResolver = SchemaOrgUnheadPlugin.jobPostingResolver;
+exports.listItemResolver = SchemaOrgUnheadPlugin.listItemResolver;
+exports.localBusinessResolver = SchemaOrgUnheadPlugin.localBusinessResolver;
+exports.movieResolver = SchemaOrgUnheadPlugin.movieResolver;
+exports.normaliseNodes = SchemaOrgUnheadPlugin.normaliseNodes;
+exports.offerResolver = SchemaOrgUnheadPlugin.offerResolver;
+exports.openingHoursResolver = SchemaOrgUnheadPlugin.openingHoursResolver;
+exports.organizationResolver = SchemaOrgUnheadPlugin.organizationResolver;
+exports.personResolver = SchemaOrgUnheadPlugin.personResolver;
+exports.placeResolver = SchemaOrgUnheadPlugin.placeResolver;
+exports.productResolver = SchemaOrgUnheadPlugin.productResolver;
+exports.questionResolver = SchemaOrgUnheadPlugin.questionResolver;
+exports.ratingResolver = SchemaOrgUnheadPlugin.ratingResolver;
+exports.readActionResolver = SchemaOrgUnheadPlugin.readActionResolver;
+exports.recipeResolver = SchemaOrgUnheadPlugin.recipeResolver;
+exports.resolveMeta = SchemaOrgUnheadPlugin.resolveMeta;
+exports.resolveNode = SchemaOrgUnheadPlugin.resolveNode;
+exports.resolveNodeId = SchemaOrgUnheadPlugin.resolveNodeId;
+exports.resolveRelation = SchemaOrgUnheadPlugin.resolveRelation;
+exports.reviewResolver = SchemaOrgUnheadPlugin.reviewResolver;
+exports.searchActionResolver = SchemaOrgUnheadPlugin.searchActionResolver;
+exports.softwareAppResolver = SchemaOrgUnheadPlugin.softwareAppResolver;
+exports.videoResolver = SchemaOrgUnheadPlugin.videoResolver;
+exports.virtualLocationResolver = SchemaOrgUnheadPlugin.virtualLocationResolver;
+exports.webPageResolver = SchemaOrgUnheadPlugin.webPageResolver;
+exports.webSiteResolver = SchemaOrgUnheadPlugin.webSiteResolver;
 exports.defineAddress = defineAddress;
 exports.defineAggregateOffer = defineAggregateOffer;
 exports.defineAggregateRating = defineAggregateRating;
@@ -2108,43 +207,10 @@ exports.defineQuestion = defineQuestion;
 exports.defineReadAction = defineReadAction;
 exports.defineRecipe = defineRecipe;
 exports.defineReview = defineReview;
-exports.defineSchemaOrgResolver = defineSchemaOrgResolver;
 exports.defineSearchAction = defineSearchAction;
 exports.defineSoftwareApp = defineSoftwareApp;
 exports.defineVideo = defineVideo;
 exports.defineVirtualLocation = defineVirtualLocation;
 exports.defineWebPage = defineWebPage;
 exports.defineWebSite = defineWebSite;
-exports.eventResolver = eventResolver;
-exports.howToResolver = howToResolver;
-exports.howToStepDirectionResolver = howToStepDirectionResolver;
-exports.howToStepResolver = howToStepResolver;
-exports.imageResolver = imageResolver;
-exports.itemListResolver = itemListResolver;
-exports.jobPostingResolver = jobPostingResolver;
-exports.listItemResolver = listItemResolver;
-exports.localBusinessResolver = localBusinessResolver;
-exports.movieResolver = movieResolver;
-exports.normaliseNodes = normaliseNodes;
-exports.offerResolver = offerResolver;
-exports.openingHoursResolver = openingHoursResolver;
-exports.organizationResolver = organizationResolver;
-exports.personResolver = personResolver;
-exports.placeResolver = placeResolver;
-exports.productResolver = productResolver;
-exports.questionResolver = questionResolver;
-exports.ratingResolver = ratingResolver;
-exports.readActionResolver = readActionResolver;
-exports.recipeResolver = recipeResolver;
-exports.resolveMeta = resolveMeta;
-exports.resolveNode = resolveNode;
-exports.resolveNodeId = resolveNodeId;
-exports.resolveRelation = resolveRelation;
-exports.reviewResolver = reviewResolver;
-exports.searchActionResolver = searchActionResolver;
-exports.softwareAppResolver = softwareAppResolver;
 exports.useSchemaOrg = useSchemaOrg;
-exports.videoResolver = videoResolver;
-exports.virtualLocationResolver = virtualLocationResolver;
-exports.webPageResolver = webPageResolver;
-exports.webSiteResolver = webSiteResolver;