@unhead/schema-org 2.0.0-alpha.2 → 2.0.0-alpha.21

package/dist/shared/schema-org.D-L8HzUn.cjs

@@ -1,1611 +0,0 @@
-'use strict';
-
-const shared = require('@unhead/shared');
-const defu = require('defu');
-const ufo = require('ufo');
-const ohash = require('ohash');
-
-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 {
-  }
-  return typeof val === "string" ? val : val.toString();
-}
-const IS_VALID_W3C_DATE = [
-  /(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d\.\d+([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))|(\d{4}-[01]\d-[0-3]\dT[0-2]\d:[0-5]\d([+-][0-2]\d:[0-5]\d|Z))/,
-  /^\d{4}-[01]\d-[0-3]\d$/,
-  /^\d{4}-[01]\d$/,
-  /^\d{4}$/
-];
-function isValidW3CDate(d) {
-  return IS_VALID_W3C_DATE.some((r) => r.test(d));
-}
-function resolvableDateToIso(val) {
-  if (!val)
-    return val;
-  try {
-    if (val instanceof Date)
-      return val.toISOString();
-    else if (isValidW3CDate(val))
-      return val;
-    else
-      return new Date(Date.parse(val)).toISOString();
-  } catch {
-  }
-  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 data = new Set(asArray(node[field]));
-  data.add(value);
-  node[field] = [...data].filter(Boolean);
-}
-function prefixId(url, id) {
-  if (ufo.hasProtocol(id))
-    return id;
-  if (!id.includes("#"))
-    id = `#${id}`;
-  return ufo.withBase(id, url);
-}
-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[0] !== "/" && urlOrPath[0] !== "#")
-    return urlOrPath;
-  return ufo.withBase(urlOrPath, base);
-}
-function resolveAsGraphKey(key) {
-  if (!key)
-    return key;
-  return key.substring(key.lastIndexOf("#"));
-}
-function stripEmptyProperties(obj) {
-  for (const k in obj) {
-    if (!Object.prototype.hasOwnProperty.call(obj, k)) {
-      continue;
-    }
-    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 || obj[k] === undefined)
-      delete obj[k];
-  }
-  return obj;
-}
-
-const quantitativeValueResolver = defineSchemaOrgResolver({
-  cast(node) {
-    if (typeof node === "number") {
-      return {
-        value: node
-      };
-    }
-    return node;
-  },
-  defaults: {
-    "@type": "QuantitativeValue"
-  }
-});
-const monetaryAmountResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "MonetaryAmount"
-  },
-  resolve(node, ctx) {
-    if (typeof node.value !== "number")
-      node.value = resolveRelation(node.value, ctx, quantitativeValueResolver);
-    return node;
-  }
-});
-
-const merchantReturnPolicyResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "MerchantReturnPolicy"
-  },
-  resolve(node, ctx) {
-    if (node.returnPolicyCategory)
-      node.returnPolicyCategory = ufo.withBase(node.returnPolicyCategory, "https://schema.org/");
-    if (node.returnFees)
-      node.returnFees = ufo.withBase(node.returnFees, "https://schema.org/");
-    if (node.returnMethod)
-      node.returnMethod = ufo.withBase(node.returnMethod, "https://schema.org/");
-    node.returnShippingFeesAmount = resolveRelation(node.returnShippingFeesAmount, ctx, monetaryAmountResolver);
-    return node;
-  }
-});
-
-const definedRegionResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "DefinedRegion"
-  }
-});
-
-const shippingDeliveryTimeResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "ShippingDeliveryTime"
-  },
-  resolve(node, ctx) {
-    node.handlingTime = resolveRelation(node.handlingTime, ctx, quantitativeValueResolver);
-    node.transitTime = resolveRelation(node.transitTime, ctx, quantitativeValueResolver);
-    return node;
-  }
-});
-
-const offerShippingDetailsResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "OfferShippingDetails"
-  },
-  resolve(node, ctx) {
-    node.deliveryTime = resolveRelation(node.deliveryTime, ctx, shippingDeliveryTimeResolver);
-    node.shippingDestination = resolveRelation(node.shippingDestination, ctx, definedRegionResolver);
-    node.shippingRate = resolveRelation(node.shippingRate, ctx, monetaryAmountResolver);
-    return node;
-  }
-});
-
-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.itemCondition)
-      node.itemCondition = ufo.withBase(node.itemCondition, "https://schema.org/");
-    if (node.priceValidUntil)
-      node.priceValidUntil = resolvableDateToIso(node.priceValidUntil);
-    node.hasMerchantReturnPolicy = resolveRelation(node.hasMerchantReturnPolicy, ctx, merchantReturnPolicyResolver);
-    node.shippingDetails = resolveRelation(node.shippingDetails, ctx, offerShippingDetailsResolver);
-    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 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 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 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 && isIdentity) {
-      if (!ctx.find("#organization")) {
-        const logoNode = resolveRelation(node.logo, ctx, imageResolver, {
-          root: true,
-          afterResolve(logo) {
-            logo["@id"] = prefixId(ctx.meta.host, "#logo");
-            setIfEmpty(logo, "caption", node.name);
-          }
-        });
-        if (webPage && logoNode)
-          setIfEmpty(webPage, "primaryImageOfPage", idReference(logoNode));
-        ctx.nodes.push({
-          // we want to make a simple node that has the essentials, this will allow parent nodes to inject
-          // as well without inserting invalid data (i.e LocalBusiness operatingHours)
-          "@type": "Organization",
-          "name": node.name,
-          "url": node.url,
-          "sameAs": node.sameAs,
-          // 'image': idReference(logoNode),
-          "address": node.address,
-          // needs to be a URL
-          "logo": resolveRelation(node.logo, ctx, imageResolver, { root: false }).url,
-          "_priority": -1,
-          "@id": prefixId(ctx.meta.host, "#organization")
-          // avoid the id so nothing can link to it
-        });
-      }
-      delete node.logo;
-    }
-    if (isIdentity && webPage)
-      setIfEmpty(webPage, "about", idReference(node));
-    const webSite = ctx.find(PrimaryWebSiteId);
-    if (webSite)
-      setIfEmpty(webSite, "publisher", 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" && ctx.meta.url) {
-      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 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 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 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 = resolveNode({ ...node }, ctx, organizationResolver);
-    return node;
-  },
-  resolveRootNode(node, ctx) {
-    organizationResolver.resolveRootNode(node, ctx);
-    return node;
-  }
-});
-
-const ratingResolver = defineSchemaOrgResolver({
-  cast(node) {
-    if (node === "number") {
-      return {
-        ratingValue: node
-      };
-    }
-    return node;
-  },
-  defaults: {
-    "@type": "Rating",
-    "bestRating": 5,
-    "worstRating": 1
-  }
-});
-
-const foodEstablishmentResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": ["Organization", "LocalBusiness", "FoodEstablishment"]
-  },
-  inheritMeta: [
-    { key: "url", meta: "host" },
-    { key: "currenciesAccepted", meta: "currency" }
-  ],
-  idPrefix: ["host", IdentityId],
-  resolve(node, ctx) {
-    resolveDefaultType(node, ["Organization", "LocalBusiness", "FoodEstablishment"]);
-    node.starRating = resolveRelation(node.starRating, ctx, ratingResolver);
-    node = resolveNode(node, ctx, localBusinessResolver);
-    return node;
-  },
-  resolveRootNode(node, ctx) {
-    localBusinessResolver.resolveRootNode(node, ctx);
-    return node;
-  }
-});
-
-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 jobPostingResolver = defineSchemaOrgResolver({
-  defaults: {
-    "@type": "JobPosting"
-  },
-  idPrefix: ["url", "#job-posting"],
-  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;
-  },
-  resolveRootNode(jobPosting, { find }) {
-    const webPage = find(PrimaryWebPageId);
-    const identity = find(IdentityId);
-    if (identity)
-      setIfEmpty(jobPosting, "hiringOrganization", idReference(identity));
-    if (webPage)
-      setIfEmpty(jobPosting, "mainEntityOfPage", idReference(webPage));
-    return jobPosting;
-  }
-});
-
-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 && (typeof video.thumbnailUrl === "string" || Array.isArray(video.thumbnailUrl))) {
-      const images = asArray(video.thumbnailUrl).map((image) => resolveWithBase(ctx.meta.host, image));
-      video.thumbnailUrl = images.length > 1 ? images : images[0];
-    }
-    if (video.thumbnail)
-      video.thumbnail = resolveRelation(video.thumbnailUrl, ctx, imageResolver);
-    return video;
-  },
-  resolveRootNode(video, { find }) {
-    if (video.image && !video.thumbnail) {
-      const firstImage = asArray(video.image)[0];
-      setIfEmpty(video, "thumbnail", 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 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;
-      delete question.question;
-    }
-    if (question.answer) {
-      question.acceptedAnswer = question.answer;
-      delete 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 "foodEstablishment":
-      return foodEstablishmentResolver;
-    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 (Array.isArray(v)) {
-      v.forEach((v2, k2) => {
-        if (typeof v2 === "object" && v2?._resolver) {
-          node[k][k2] = resolveRelation(v2, ctx, v2._resolver);
-        }
-      });
-    }
-    if (typeof v === "object" && v?._resolver)
-      node[k] = resolveRelation(v, ctx, v._resolver);
-  }
-  stripEmptyProperties(node);
-  return node;
-}
-function resolveNodeId(node, ctx, resolver, resolveAsRoot = false) {
-  if (node["@id"] && node["@id"].startsWith("http"))
-    return node;
-  const prefix = resolver ? (Array.isArray(resolver.idPrefix) ? resolver.idPrefix[0] : resolver.idPrefix) || "url" : "url";
-  const rootId = node["@id"] || (resolver ? Array.isArray(resolver.idPrefix) ? resolver.idPrefix?.[1] : undefined : "");
-  if (!node["@id"] && resolveAsRoot && rootId) {
-    node["@id"] = prefixId(ctx.meta[prefix], rootId);
-    return node;
-  }
-  if (node["@id"]?.startsWith("#/schema/") || node["@id"]?.startsWith("/")) {
-    node["@id"] = prefixId(ctx.meta[prefix], node["@id"]);
-    return node;
-  }
-  let alias = resolver?.alias;
-  if (!alias) {
-    const type = asArray(node["@type"])?.[0] || "";
-    alias = type.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
-  }
-  const hashNodeData = {};
-  for (const key in node) {
-    if (key[0] === "_") {
-      continue;
-    }
-    if (!Object.prototype.hasOwnProperty.call(node, key)) {
-      continue;
-    }
-    hashNodeData[key] = node[key];
-  }
-  node["@id"] = prefixId(ctx.meta[prefix], `#/schema/${alias}/${node["@id"] || shared.hashCode(JSON.stringify(hashNodeData))}`);
-  return node;
-}
-function resolveRelation(input, ctx, fallbackResolver, options = {}) {
-  if (!input)
-    return input;
-  const ids = asArray(input).map((a) => {
-    const keys = Object.keys(a).length;
-    if (keys === 1 && a["@id"] || keys === 2 && a["@id"] && a["@type"]) {
-      return resolveNodeId({
-        // we drop @type
-        "@id": ctx.find(a["@id"])?.["@id"] || a["@id"]
-      }, ctx);
-    }
-    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 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 uniqueBy(array, predicate) {
-  return Object.values(groupBy(array, predicate)).map((a) => a[a.length - 1]);
-}
-const merge = defu.createDefu((object, key, value) => {
-  if (Array.isArray(object[key])) {
-    if (Array.isArray(value)) {
-      const map = {};
-      for (const item of [...object[key], ...value])
-        map[ohash.hash(item)] = item;
-      object[key] = Object.values(map);
-      if (key === "itemListElement") {
-        object[key] = [...uniqueBy(object[key], (item) => item.position)];
-      }
-      return true;
-    }
-    object[key] = merge(object[key], Array.isArray(value) ? value : [value]);
-    return true;
-  }
-});
-function dedupeNodes(nodes) {
-  const dedupedNodes = {};
-  for (const key of nodes.keys()) {
-    const n = nodes[key];
-    const nodeKey = resolveAsGraphKey(n["@id"] || ohash.hash(n));
-    if (dedupedNodes[nodeKey] && n._dedupeStrategy !== "replace")
-      dedupedNodes[nodeKey] = merge(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"] || ohash.hash(n));
-    const groupedKeys = groupBy(Object.keys(n), (key2) => {
-      const val = n[key2];
-      if (key2[0] === "_")
-        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 = merge(newNode, dedupedNodes[nodeKey]);
-    dedupedNodes[nodeKey] = newNode;
-  }
-  return Object.values(dedupedNodes);
-}
-
-const baseRelationNodes = [
-  "translationOfWork",
-  "workTranslation"
-];
-function createSchemaOrgGraph() {
-  const ctx = {
-    find(id) {
-      let resolver = (s) => s;
-      if (id[0] === "#") {
-        resolver = resolveAsGraphKey;
-      } else if (id[0] === "/") {
-        resolver = (s) => s.replace(/(https?:)?\/\//, "").split("/")[0];
-      }
-      const key = resolver(id);
-      return ctx.nodes.filter((n) => !!n["@id"]).find((n) => resolver(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;
-        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
-          });
-        }
-        baseRelationNodes.forEach((k) => {
-          node[k] = resolveRelation(node[k], ctx);
-        });
-        if (node._resolver?.resolveRootNode)
-          node._resolver.resolveRootNode(node, ctx);
-        delete node._resolver;
-      });
-      return normaliseNodes(ctx.nodes);
-    },
-    nodes: [],
-    meta: {}
-  };
-  return ctx;
-}
-
-function UnheadSchemaOrg(options) {
-  return SchemaOrgUnheadPlugin({}, () => ({}), options);
-}
-function PluginSchemaOrg(options) {
-  const fallback = () => ({});
-  return SchemaOrgUnheadPlugin({}, options?.resolveMeta || fallback, options);
-}
-function SchemaOrgUnheadPlugin(config, meta, options) {
-  config = resolveMeta({ ...config });
-  let graph;
-  let resolvedMeta = {};
-  return shared.defineHeadPlugin((head) => ({
-    key: "schema-org",
-    hooks: {
-      "entries:resolve": () => {
-        graph = createSchemaOrgGraph();
-      },
-      "tag:normalise": async ({ tag }) => {
-        if (tag.tag === "script" && tag.props.type === "application/ld+json" && tag.props.nodes) {
-          const { loadResolver } = await Promise.resolve().then(function () { return resolver; });
-          const nodes = await tag.props.nodes;
-          for (const node of Array.isArray(nodes) ? nodes : [nodes]) {
-            if (typeof node !== "object" || Object.keys(node).length === 0) {
-              continue;
-            }
-            const newNode = {
-              ...node,
-              _dedupeStrategy: tag.tagDuplicateStrategy,
-              _resolver: loadResolver(await node._resolver)
-            };
-            graph.push(newNode);
-          }
-          tag.tagPosition = tag.tagPosition || config.tagPosition === "head" ? "head" : "bodyClose";
-        }
-        if (tag.tag === "htmlAttrs" && tag.props.lang) {
-          resolvedMeta.inLanguage = tag.props.lang;
-        } else 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;
-          if (resolvedMeta.url && !resolvedMeta.host) {
-            try {
-              resolvedMeta.host = new URL(resolvedMeta.url).origin;
-            } catch {
-            }
-          }
-        } else if (tag.tag === "meta" && tag.props.property === "og:image") {
-          resolvedMeta.image = tag.props.content;
-        } else if (tag.tag === "templateParams" && tag.props.schemaOrg) {
-          resolvedMeta = {
-            ...resolvedMeta,
-            // @ts-expect-error untyped
-            ...tag.props.schemaOrg
-          };
-          delete tag.props.schemaOrg;
-        }
-      },
-      "tags:resolve": async (ctx) => {
-        for (const k in ctx.tags) {
-          const tag = ctx.tags[k];
-          if (tag.tag === "script" && tag.props.type === "application/ld+json" && tag.props.nodes) {
-            delete tag.props.nodes;
-            const resolvedGraph = graph.resolveGraph({ ...await meta?.() || {}, ...config, ...resolvedMeta });
-            if (!resolvedGraph.length) {
-              tag.props = {};
-              return;
-            }
-            const minify = options?.minify || process.env.NODE_ENV === "production";
-            tag.innerHTML = JSON.stringify({
-              "@context": "https://schema.org",
-              "@graph": resolvedGraph
-            }, (_, value) => {
-              if (typeof value !== "object")
-                return shared.processTemplateParams(value, head._templateParams, head._separator);
-              return value;
-            }, minify ? 0 : 2);
-            return;
-          }
-        }
-      },
-      "tags:afterResolve": (ctx) => {
-        let firstNodeKey;
-        for (const k in ctx.tags) {
-          const tag = ctx.tags[k];
-          if (tag.props.type === "application/ld+json" && tag.props.nodes || tag.key === "schema-org-graph") {
-            delete tag.props.nodes;
-            if (typeof firstNodeKey === "undefined") {
-              firstNodeKey = k;
-              continue;
-            }
-            ctx.tags[firstNodeKey].props = defu.defu(ctx.tags[firstNodeKey].props, tag.props);
-            delete ctx.tags[firstNodeKey].props.nodes;
-            ctx.tags[k] = false;
-          }
-        }
-        ctx.tags = ctx.tags.filter(Boolean);
-      }
-    }
-  }));
-}
-
-exports.HowToId = HowToId;
-exports.PluginSchemaOrg = PluginSchemaOrg;
-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.UnheadSchemaOrg = UnheadSchemaOrg;
-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.foodEstablishmentResolver = foodEstablishmentResolver;
-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;