@unhead/schema-org 0.6.0 → 1.3.9

package/dist/shared/schema-org.96234618.cjs

@@ -0,0 +1,2025 @@
+'use strict';
+
+const ufo = require('ufo');
+const shared = require('@unhead/shared');
+
+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;
+}
+
+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],
+  resolve(node, ctx) {
+    if (node.url)
+      node.url = resolveWithBase(ctx.meta.host, node.url);
+    return node;
+  },
+  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 = Object.freeze({
+  ignoreUnknown: false,
+  respectType: false,
+  respectFunctionNames: false,
+  respectFunctionProperties: false,
+  unorderedObjects: true,
+  unorderedArrays: false,
+  unorderedSets: false,
+  excludeKeys: void 0,
+  excludeValues: void 0,
+  replacer: void 0
+});
+function objectHash(object, options) {
+  if (options) {
+    options = { ...defaults, ...options };
+  } else {
+    options = defaults;
+  }
+  const hasher = createHasher(options);
+  hasher.dispatch(object);
+  return hasher.toString();
+}
+const defaultPrototypesKeys = Object.freeze([
+  "prototype",
+  "__proto__",
+  "constructor"
+]);
+function createHasher(options) {
+  let buff = "";
+  let context = /* @__PURE__ */ new Map();
+  const write = (str) => {
+    buff += str;
+  };
+  return {
+    toString() {
+      return buff;
+    },
+    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 objString = Object.prototype.toString.call(object);
+      let objType = "";
+      const objectLength = objString.length;
+      if (objectLength < 10) {
+        objType = "unknown:[" + objString + "]";
+      } else {
+        objType = objString.slice(8, objectLength - 1);
+      }
+      objType = objType.toLowerCase();
+      let objectNumber = null;
+      if ((objectNumber = context.get(object)) === void 0) {
+        context.set(object, context.size);
+      } else {
+        return this.dispatch("[CIRCULAR:" + objectNumber + "]");
+      }
+      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();
+        }
+        let extraKeys = [];
+        if (options.respectType !== false && !isNativeFunction(object)) {
+          extraKeys = defaultPrototypesKeys;
+        }
+        if (options.excludeKeys) {
+          keys = keys.filter((key) => {
+            return !options.excludeKeys(key);
+          });
+          extraKeys = extraKeys.filter((key) => {
+            return !options.excludeKeys(key);
+          });
+        }
+        write("object:" + (keys.length + extraKeys.length) + ":");
+        const dispatchForKey = (key) => {
+          this.dispatch(key);
+          write(":");
+          if (!options.excludeValues) {
+            this.dispatch(object[key]);
+          }
+          write(",");
+        };
+        for (const key of keys) {
+          dispatchForKey(key);
+        }
+        for (const key of extraKeys) {
+          dispatchForKey(key);
+        }
+      }
+    },
+    array(arr, unordered) {
+      unordered = unordered === void 0 ? options.unorderedArrays !== false : unordered;
+      write("array:" + arr.length + ":");
+      if (!unordered || arr.length <= 1) {
+        for (const entry of arr) {
+          this.dispatch(entry);
+        }
+        return;
+      }
+      const contextAdditions = /* @__PURE__ */ new Map();
+      const entries = arr.map((entry) => {
+        const hasher = createHasher(options);
+        hasher.dispatch(entry);
+        for (const [key, value] of hasher.getContext()) {
+          contextAdditions.set(key, value);
+        }
+        return hasher.toString();
+      });
+      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);
+    },
+    string(string) {
+      write("string:" + string.length + ":");
+      write(string);
+    },
+    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);
+    },
+    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");
+    }
+  };
+}
+const nativeFunc = "[native code] }";
+const nativeFuncLength = nativeFunc.length;
+function isNativeFunction(f) {
+  if (typeof f !== "function") {
+    return false;
+  }
+  return Function.prototype.toString.call(f).slice(-nativeFuncLength) === nativeFunc;
+}
+
+class WordArray {
+  constructor(words, sigBytes) {
+    words = this.words = words || [];
+    this.sigBytes = sigBytes === void 0 ? words.length * 4 : sigBytes;
+  }
+  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._data = new WordArray();
+    this._nDataBytes = 0;
+    this._minBufferSize = 0;
+    this.blockSize = 512 / 32;
+  }
+  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(...arguments);
+    this._hash = new WordArray([...H]);
+  }
+  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}/${shared.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;
+          }
+        }
+      }
+    }
+  };
+}
+
+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.defineSchemaOrgResolver = defineSchemaOrgResolver;
+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.videoResolver = videoResolver;
+exports.virtualLocationResolver = virtualLocationResolver;
+exports.webPageResolver = webPageResolver;
+exports.webSiteResolver = webSiteResolver;