@unhead/schema-org 2.0.18 → 2.1.0

package/dist/chunks/index27.mjs

@@ -0,0 +1,29 @@
+import { d as defineSchemaOrgResolver, e as resolveRelation, a8 as resolvableDateToIso } from '../shared/schema-org.Cp6bpwL2.mjs';
+import { aggregateRatingResolver } from './index2.mjs';
+import { p as personResolver } from './index3.mjs';
+import 'unhead/plugins';
+import 'unhead/utils';
+import 'ufo';
+import './index16.mjs';
+import './index28.mjs';
+import './index40.mjs';
+import './index39.mjs';
+
+const podcastSeriesResolver = defineSchemaOrgResolver({
+  defaults: {
+    "@type": "PodcastSeries"
+  },
+  resolve(node, ctx) {
+    node.author = resolveRelation(node.author, ctx, personResolver);
+    node.aggregateRating = resolveRelation(node.aggregateRating, ctx, aggregateRatingResolver);
+    if (node.datePublished)
+      node.datePublished = resolvableDateToIso(node.datePublished);
+    if (node.startDate)
+      node.startDate = resolvableDateToIso(node.startDate);
+    if (node.endDate)
+      node.endDate = resolvableDateToIso(node.endDate);
+    return node;
+  }
+});
+
+export { podcastSeriesResolver };

package/dist/chunks/index28.mjs

@@ -0,0 +1,12 @@
+import { d as defineSchemaOrgResolver } from '../shared/schema-org.Cp6bpwL2.mjs';
+import 'unhead/plugins';
+import 'unhead/utils';
+import 'ufo';
+
+const addressResolver = defineSchemaOrgResolver({
+  defaults: {
+    "@type": "PostalAddress"
+  }
+});
+
+export { addressResolver };

package/dist/chunks/index29.mjs

@@ -0,0 +1,46 @@
+import { d as defineSchemaOrgResolver, a9 as IdentityId, a6 as setIfEmpty, a7 as idReference, e as resolveRelation } from '../shared/schema-org.Cp6bpwL2.mjs';
+import { aggregateOfferResolver } from './index.mjs';
+import { aggregateRatingResolver } from './index2.mjs';
+import { offerResolver } from './index23.mjs';
+import { reviewResolver } from './index32.mjs';
+import { d as PrimaryWebPageId } from './index3.mjs';
+import 'unhead/plugins';
+import 'unhead/utils';
+import 'ufo';
+import '../shared/schema-org.Dg61qWpa.mjs';
+import '../shared/schema-org.40UJYB57.mjs';
+import './index16.mjs';
+import './index28.mjs';
+import './index40.mjs';
+import './index39.mjs';
+
+const ProductId = "#product";
+const productResolver = defineSchemaOrgResolver({
+  defaults: {
+    "@type": "Product"
+  },
+  inheritMeta: [
+    "description",
+    "image",
+    { meta: "title", key: "name" }
+  ],
+  idPrefix: ["url", ProductId],
+  resolve(node, ctx) {
+    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;
+  }
+});
+
+export { ProductId, productResolver };

package/dist/chunks/index3.mjs

@@ -0,0 +1,317 @@
+import { d as defineSchemaOrgResolver, a6 as setIfEmpty, a7 as idReference, e as resolveRelation, af as resolveAsGraphKey, a9 as IdentityId, a8 as resolvableDateToIso, ag as prefixId, a5 as imageResolver, aa as resolveDefaultType, ad as resolveWithBase, ac as asArray, ah as trimLength } from '../shared/schema-org.Cp6bpwL2.mjs';
+import { withoutTrailingSlash } from 'ufo';
+import { listItemResolver } from './index16.mjs';
+import { addressResolver } from './index28.mjs';
+import { searchActionResolver } from './index40.mjs';
+import { readActionResolver } from './index39.mjs';
+
+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 index$5 = {
+  __proto__: null,
+  PrimaryBreadcrumbId: PrimaryBreadcrumbId,
+  breadcrumbResolver: breadcrumbResolver
+};
+
+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);
+    node.dateModified = resolvableDateToIso(node.dateModified);
+    node.datePublished = resolvableDateToIso(node.datePublished);
+    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 index$4 = {
+  __proto__: null,
+  PrimaryWebSiteId: PrimaryWebSiteId,
+  searchActionResolver: searchActionResolver,
+  webSiteResolver: webSiteResolver
+};
+
+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 index$3 = {
+  __proto__: null,
+  organizationResolver: organizationResolver
+};
+
+const PrimaryWebPageId = "#webpage";
+const webPageResolver = defineSchemaOrgResolver({
+  defaults({ meta }) {
+    const endPath = 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 index$2 = {
+  __proto__: null,
+  PrimaryWebPageId: PrimaryWebPageId,
+  readActionResolver: readActionResolver,
+  webPageResolver: webPageResolver
+};
+
+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 index$1 = {
+  __proto__: null,
+  personResolver: personResolver
+};
+
+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 index = {
+  __proto__: null,
+  PrimaryArticleId: PrimaryArticleId,
+  articleResolver: articleResolver
+};
+
+export { PrimaryArticleId as P, articleResolver as a, PrimaryBreadcrumbId as b, breadcrumbResolver as c, PrimaryWebPageId as d, PrimaryWebSiteId as e, webSiteResolver as f, index$4 as g, index$3 as h, index$5 as i, index$2 as j, index$1 as k, index as l, organizationResolver as o, personResolver as p, webPageResolver as w };

package/dist/chunks/index30.mjs

@@ -0,0 +1,53 @@
+import { d as defineSchemaOrgResolver, ac as asArray, ae as dedupeMerge, a7 as idReference, e as resolveRelation, a8 as resolvableDateToIso } from '../shared/schema-org.Cp6bpwL2.mjs';
+import { d as PrimaryWebPageId } from './index3.mjs';
+import 'unhead/plugins';
+import 'unhead/utils';
+import 'ufo';
+import './index16.mjs';
+import './index28.mjs';
+import './index40.mjs';
+import './index39.mjs';
+
+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);
+    question.dateCreated = resolvableDateToIso(question.dateCreated);
+    return question;
+  },
+  resolveRootNode(question, { find }) {
+    const webPage = find(PrimaryWebPageId);
+    if (webPage && asArray(webPage["@type"]).includes("FAQPage"))
+      dedupeMerge(webPage, "mainEntity", idReference(question));
+  }
+});
+
+export { questionResolver };

package/dist/chunks/index31.mjs

@@ -0,0 +1,41 @@
+import { d as defineSchemaOrgResolver, a6 as setIfEmpty, a7 as idReference, e as resolveRelation } from '../shared/schema-org.Cp6bpwL2.mjs';
+import { P as PrimaryArticleId, d as PrimaryWebPageId } from './index3.mjs';
+import { h as howToStepResolver } from './index12.mjs';
+import 'unhead/plugins';
+import 'unhead/utils';
+import 'ufo';
+import './index16.mjs';
+import './index28.mjs';
+import './index40.mjs';
+import './index39.mjs';
+
+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;
+  }
+});
+
+export { RecipeId, recipeResolver };

package/dist/chunks/index32.mjs

@@ -0,0 +1,26 @@
+import { p as personResolver } from './index3.mjs';
+import { r as ratingResolver } from '../shared/schema-org.40UJYB57.mjs';
+import { d as defineSchemaOrgResolver, e as resolveRelation } from '../shared/schema-org.Cp6bpwL2.mjs';
+import 'ufo';
+import './index16.mjs';
+import 'unhead/plugins';
+import 'unhead/utils';
+import './index28.mjs';
+import './index40.mjs';
+import './index39.mjs';
+
+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;
+  }
+});
+
+export { reviewResolver };

package/dist/chunks/index33.mjs

@@ -0,0 +1,47 @@
+import { d as defineSchemaOrgResolver, a9 as IdentityId, a6 as setIfEmpty, a7 as idReference, aa as resolveDefaultType, e as resolveRelation } from '../shared/schema-org.Cp6bpwL2.mjs';
+import { aggregateRatingResolver } from './index2.mjs';
+import { offerResolver } from './index23.mjs';
+import { reviewResolver } from './index32.mjs';
+import { d as PrimaryWebPageId } from './index3.mjs';
+import 'unhead/plugins';
+import 'unhead/utils';
+import 'ufo';
+import '../shared/schema-org.Dg61qWpa.mjs';
+import '../shared/schema-org.40UJYB57.mjs';
+import './index16.mjs';
+import './index28.mjs';
+import './index40.mjs';
+import './index39.mjs';
+
+const ServiceId = "#service";
+const serviceResolver = defineSchemaOrgResolver({
+  defaults: {
+    "@type": "Service"
+  },
+  inheritMeta: [
+    "description",
+    "image",
+    { meta: "title", key: "name" }
+  ],
+  idPrefix: ["url", ServiceId],
+  resolve(node, ctx) {
+    resolveDefaultType(node, "Service");
+    node.offers = resolveRelation(node.offers, ctx, offerResolver);
+    node.aggregateRating = resolveRelation(node.aggregateRating, ctx, aggregateRatingResolver);
+    node.review = resolveRelation(node.review, ctx, reviewResolver);
+    return node;
+  },
+  resolveRootNode(service, { find }) {
+    const webPage = find(PrimaryWebPageId);
+    const identity = find(IdentityId);
+    if (identity)
+      setIfEmpty(service, "provider", idReference(identity));
+    if (identity)
+      setIfEmpty(service, "brand", idReference(identity));
+    if (webPage)
+      setIfEmpty(service, "mainEntityOfPage", idReference(webPage));
+    return service;
+  }
+});
+
+export { ServiceId, serviceResolver };

package/dist/chunks/index34.mjs

@@ -0,0 +1,29 @@
+import { d as defineSchemaOrgResolver, aa as resolveDefaultType, e as resolveRelation } from '../shared/schema-org.Cp6bpwL2.mjs';
+import { aggregateRatingResolver } from './index2.mjs';
+import { offerResolver } from './index23.mjs';
+import { reviewResolver } from './index32.mjs';
+import 'unhead/plugins';
+import 'unhead/utils';
+import 'ufo';
+import '../shared/schema-org.Dg61qWpa.mjs';
+import './index3.mjs';
+import './index16.mjs';
+import './index28.mjs';
+import './index40.mjs';
+import './index39.mjs';
+import '../shared/schema-org.40UJYB57.mjs';
+
+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;
+  }
+});
+
+export { softwareAppResolver };

package/dist/chunks/index35.mjs

@@ -0,0 +1,34 @@
+import { d as defineSchemaOrgResolver, e as resolveRelation, a8 as resolvableDateToIso } from '../shared/schema-org.Cp6bpwL2.mjs';
+import { aggregateRatingResolver } from './index2.mjs';
+import { p as personResolver } from './index3.mjs';
+import { reviewResolver } from './index32.mjs';
+import { videoResolver } from './index38.mjs';
+import 'unhead/plugins';
+import 'unhead/utils';
+import 'ufo';
+import './index16.mjs';
+import './index28.mjs';
+import './index40.mjs';
+import './index39.mjs';
+import '../shared/schema-org.40UJYB57.mjs';
+
+const tvEpisodeResolver = defineSchemaOrgResolver({
+  defaults: {
+    "@type": "TVEpisode"
+  },
+  resolve(node, ctx) {
+    node.actor = resolveRelation(node.actor, ctx, personResolver);
+    node.director = resolveRelation(node.director, ctx, personResolver);
+    node.musicBy = resolveRelation(node.musicBy, ctx, personResolver);
+    node.video = resolveRelation(node.video, ctx, videoResolver);
+    node.aggregateRating = resolveRelation(node.aggregateRating, ctx, aggregateRatingResolver);
+    node.review = resolveRelation(node.review, ctx, reviewResolver);
+    if (node.datePublished)
+      node.datePublished = resolvableDateToIso(node.datePublished);
+    if (node.uploadDate)
+      node.uploadDate = resolvableDateToIso(node.uploadDate);
+    return node;
+  }
+});
+
+export { tvEpisodeResolver };

package/dist/chunks/index36.mjs

@@ -0,0 +1,33 @@
+import { d as defineSchemaOrgResolver, e as resolveRelation, a8 as resolvableDateToIso } from '../shared/schema-org.Cp6bpwL2.mjs';
+import { aggregateRatingResolver } from './index2.mjs';
+import { p as personResolver, o as organizationResolver } from './index3.mjs';
+import { videoResolver } from './index38.mjs';
+import 'unhead/plugins';
+import 'unhead/utils';
+import 'ufo';
+import './index16.mjs';
+import './index28.mjs';
+import './index40.mjs';
+import './index39.mjs';
+
+const tvSeasonResolver = defineSchemaOrgResolver({
+  defaults: {
+    "@type": "TVSeason"
+  },
+  resolve(node, ctx) {
+    node.actor = resolveRelation(node.actor, ctx, personResolver);
+    node.director = resolveRelation(node.director, ctx, personResolver);
+    node.productionCompany = resolveRelation(node.productionCompany, ctx, organizationResolver);
+    node.aggregateRating = resolveRelation(node.aggregateRating, ctx, aggregateRatingResolver);
+    node.trailer = resolveRelation(node.trailer, ctx, videoResolver);
+    if (node.datePublished)
+      node.datePublished = resolvableDateToIso(node.datePublished);
+    if (node.startDate)
+      node.startDate = resolvableDateToIso(node.startDate);
+    if (node.endDate)
+      node.endDate = resolvableDateToIso(node.endDate);
+    return node;
+  }
+});
+
+export { tvSeasonResolver };