@unhead/schema-org 0.0.2

package/dist/index.cjs

@@ -0,0 +1,1387 @@
+'use strict';
+
+const ohash = require('ohash');
+const defu = require('defu');
+const ufo = require('ufo');
+const unhead = require('unhead');
+
+function defineSchemaOrgResolver(schema) {
+  return schema;
+}
+
+const idReference = (node) => ({
+  "@id": typeof node !== "string" ? node["@id"] : node
+});
+const 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();
+};
+const 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";
+const setIfEmpty = (node, field, value) => {
+  if (!node?.[field] && value)
+    node[field] = value;
+};
+const asArray = (input) => Array.isArray(input) ? input : [input];
+const 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);
+};
+const prefixId = (url, id) => {
+  if (ufo.hasProtocol(id))
+    return url;
+  if (!id.startsWith("#"))
+    id = `#${id}`;
+  return ufo.joinURL(url, id);
+};
+const 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;
+};
+const 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()];
+};
+const resolveWithBase = (base, urlOrPath) => {
+  if (!urlOrPath || ufo.hasProtocol(urlOrPath) || !urlOrPath.startsWith("/") && !urlOrPath.startsWith("#"))
+    return urlOrPath;
+  return ufo.withBase(urlOrPath, base);
+};
+const resolveAsGraphKey = (key) => {
+  if (!key)
+    return key;
+  return key.substring(key.lastIndexOf("#"));
+};
+const 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(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 resolveListItem = 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);
+    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, resolveListItem, {
+        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: [
+    "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) {
+    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, resolveListItem, {
+        array: true,
+        afterResolve(node2) {
+          setIfEmpty(node2, "position", index++);
+        }
+      });
+    }
+    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 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);
+    if (node.dateCreated)
+      node.dateCreated = resolvableDateToDate(node.dateCreated);
+    return node;
+  }
+});
+
+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", ohash.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;
+  }
+});
+
+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);
+    }
+  }
+});
+
+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 "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
+};
+
+const 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;
+  meta.url = ufo.joinURL(meta.host, meta.path);
+  return {
+    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
+  };
+};
+const 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 = defu.defu(node, defaults);
+  }
+  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;
+};
+const 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}/${ohash.hash(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;
+}
+
+const groupBy = (array, predicate) => array.reduce((acc, value, index, array2) => {
+  const key = predicate(value, index, array2);
+  if (!acc[key])
+    acc[key] = [];
+  acc[key].push(value);
+  return acc;
+}, {});
+const dedupeNodes = (nodes) => {
+  const sortedNodeKeys = nodes.keys();
+  const dedupedNodes = {};
+  for (const key of sortedNodeKeys) {
+    const n = nodes[key];
+    const nodeKey = resolveAsGraphKey(n["@id"] || ohash.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()
+    ];
+    const newNode = {};
+    for (const key2 of keys)
+      newNode[key2] = n[key2];
+    dedupedNodes[nodeKey] = newNode;
+  }
+  return Object.values(dedupedNodes);
+};
+
+const 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.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 dedupeNodes(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.children;
+        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.children = JSON.stringify({
+              "@context": "https://schema.org",
+              "@graph": graph.resolveGraph({ ...config, ...resolvedMeta, ...await meta() })
+            }, null, 2);
+            delete tag.props.nodes;
+          }
+        }
+      }
+    }
+  };
+}
+
+const provideResolver = (input, resolver) => {
+  if (!input)
+    input = {};
+  input._resolver = resolver;
+  return input;
+};
+const defineAddress = (input) => provideResolver(input, "address");
+const defineAggregateOffer = (input) => provideResolver(input, "aggregateOffer");
+const defineAggregateRating = (input) => provideResolver(input, "aggregateRating");
+const defineArticle = (input) => provideResolver(input, "article");
+const defineBreadcrumb = (input) => provideResolver(input, "breadcrumb");
+const defineComment = (input) => provideResolver(input, "comment");
+const defineEvent = (input) => provideResolver(input, "event");
+const defineVirtualLocation = (input) => provideResolver(input, "virtualLocation");
+const definePlace = (input) => provideResolver(input, "place");
+const defineHowTo = (input) => provideResolver(input, "howTo");
+const defineHowToStep = (input) => provideResolver(input, "howToStep");
+const defineImage = (input) => provideResolver(input, "image");
+const defineLocalBusiness = (input) => provideResolver(input, "localBusiness");
+const defineOffer = (input) => provideResolver(input, "offer");
+const defineOpeningHours = (input) => provideResolver(input, "openingHours");
+const defineOrganization = (input) => provideResolver(input, "organization");
+const definePerson = (input) => provideResolver(input, "person");
+const defineProduct = (input) => provideResolver(input, "product");
+const defineQuestion = (input) => provideResolver(input, "question");
+const defineRecipe = (input) => provideResolver(input, "recipe");
+const defineReview = (input) => provideResolver(input, "review");
+const defineVideo = (input) => provideResolver(input, "video");
+const defineWebPage = (input) => provideResolver(input, "webPage");
+const defineWebSite = (input) => provideResolver(input, "webSite");
+const defineBook = (input) => provideResolver(input, "book");
+const defineCourse = (input) => provideResolver(input, "course");
+const defineItemList = (input) => provideResolver(input, "itemList");
+const defineMovie = (input) => provideResolver(input, "movie");
+const defineSearchAction = (input) => provideResolver(input, "searchAction");
+const defineReadAction = (input) => provideResolver(input, "readAction");
+const defineSoftwareApp = (input) => provideResolver(input, "softwareApp");
+const defineBookEdition = (input) => provideResolver(input, "bookEdition");
+function useSchemaOrg(input) {
+  return unhead.useHead({
+    script: [
+      {
+        type: "application/ld+json",
+        key: "schema-org-graph",
+        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.defineAddress = defineAddress;
+exports.defineAggregateOffer = defineAggregateOffer;
+exports.defineAggregateRating = defineAggregateRating;
+exports.defineArticle = defineArticle;
+exports.defineBook = defineBook;
+exports.defineBookEdition = defineBookEdition;
+exports.defineBreadcrumb = defineBreadcrumb;
+exports.defineComment = defineComment;
+exports.defineCourse = defineCourse;
+exports.defineEvent = defineEvent;
+exports.defineHowTo = defineHowTo;
+exports.defineHowToStep = defineHowToStep;
+exports.defineImage = defineImage;
+exports.defineItemList = defineItemList;
+exports.defineLocalBusiness = defineLocalBusiness;
+exports.defineMovie = defineMovie;
+exports.defineOffer = defineOffer;
+exports.defineOpeningHours = defineOpeningHours;
+exports.defineOrganization = defineOrganization;
+exports.definePerson = definePerson;
+exports.definePlace = definePlace;
+exports.defineProduct = defineProduct;
+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.localBusinessResolver = localBusinessResolver;
+exports.movieResolver = movieResolver;
+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.resolveListItem = resolveListItem;
+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;