@masters-ws/react-seo 1.2.1 → 1.4.1

package/dist/index.js

@@ -1,8 +1,13 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -15,12 +20,172 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
+// node_modules/react-fast-compare/index.js
+var require_react_fast_compare = __commonJS({
+  "node_modules/react-fast-compare/index.js"(exports2, module2) {
+    "use strict";
+    var hasElementType = typeof Element !== "undefined";
+    var hasMap = typeof Map === "function";
+    var hasSet = typeof Set === "function";
+    var hasArrayBuffer = typeof ArrayBuffer === "function" && !!ArrayBuffer.isView;
+    function equal(a, b) {
+      if (a === b) return true;
+      if (a && b && typeof a == "object" && typeof b == "object") {
+        if (a.constructor !== b.constructor) return false;
+        var length, i, keys;
+        if (Array.isArray(a)) {
+          length = a.length;
+          if (length != b.length) return false;
+          for (i = length; i-- !== 0; )
+            if (!equal(a[i], b[i])) return false;
+          return true;
+        }
+        var it;
+        if (hasMap && a instanceof Map && b instanceof Map) {
+          if (a.size !== b.size) return false;
+          it = a.entries();
+          while (!(i = it.next()).done)
+            if (!b.has(i.value[0])) return false;
+          it = a.entries();
+          while (!(i = it.next()).done)
+            if (!equal(i.value[1], b.get(i.value[0]))) return false;
+          return true;
+        }
+        if (hasSet && a instanceof Set && b instanceof Set) {
+          if (a.size !== b.size) return false;
+          it = a.entries();
+          while (!(i = it.next()).done)
+            if (!b.has(i.value[0])) return false;
+          return true;
+        }
+        if (hasArrayBuffer && ArrayBuffer.isView(a) && ArrayBuffer.isView(b)) {
+          length = a.length;
+          if (length != b.length) return false;
+          for (i = length; i-- !== 0; )
+            if (a[i] !== b[i]) return false;
+          return true;
+        }
+        if (a.constructor === RegExp) return a.source === b.source && a.flags === b.flags;
+        if (a.valueOf !== Object.prototype.valueOf && typeof a.valueOf === "function" && typeof b.valueOf === "function") return a.valueOf() === b.valueOf();
+        if (a.toString !== Object.prototype.toString && typeof a.toString === "function" && typeof b.toString === "function") return a.toString() === b.toString();
+        keys = Object.keys(a);
+        length = keys.length;
+        if (length !== Object.keys(b).length) return false;
+        for (i = length; i-- !== 0; )
+          if (!Object.prototype.hasOwnProperty.call(b, keys[i])) return false;
+        if (hasElementType && a instanceof Element) return false;
+        for (i = length; i-- !== 0; ) {
+          if ((keys[i] === "_owner" || keys[i] === "__v" || keys[i] === "__o") && a.$$typeof) {
+            continue;
+          }
+          if (!equal(a[keys[i]], b[keys[i]])) return false;
+        }
+        return true;
+      }
+      return a !== a && b !== b;
+    }
+    module2.exports = function isEqual(a, b) {
+      try {
+        return equal(a, b);
+      } catch (error) {
+        if ((error.message || "").match(/stack|recursion/i)) {
+          console.warn("react-fast-compare cannot handle circular refs");
+          return false;
+        }
+        throw error;
+      }
+    };
+  }
+});
+
+// node_modules/invariant/invariant.js
+var require_invariant = __commonJS({
+  "node_modules/invariant/invariant.js"(exports2, module2) {
+    "use strict";
+    var NODE_ENV = process.env.NODE_ENV;
+    var invariant2 = function(condition, format, a, b, c, d, e, f) {
+      if (NODE_ENV !== "production") {
+        if (format === void 0) {
+          throw new Error("invariant requires an error message argument");
+        }
+      }
+      if (!condition) {
+        var error;
+        if (format === void 0) {
+          error = new Error(
+            "Minified exception occurred; use the non-minified dev environment for the full error message and additional helpful warnings."
+          );
+        } else {
+          var args = [a, b, c, d, e, f];
+          var argIndex = 0;
+          error = new Error(
+            format.replace(/%s/g, function() {
+              return args[argIndex++];
+            })
+          );
+          error.name = "Invariant Violation";
+        }
+        error.framesToPop = 1;
+        throw error;
+      }
+    };
+    module2.exports = invariant2;
+  }
+});
+
+// node_modules/shallowequal/index.js
+var require_shallowequal = __commonJS({
+  "node_modules/shallowequal/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = function shallowEqual2(objA, objB, compare, compareContext) {
+      var ret = compare ? compare.call(compareContext, objA, objB) : void 0;
+      if (ret !== void 0) {
+        return !!ret;
+      }
+      if (objA === objB) {
+        return true;
+      }
+      if (typeof objA !== "object" || !objA || typeof objB !== "object" || !objB) {
+        return false;
+      }
+      var keysA = Object.keys(objA);
+      var keysB = Object.keys(objB);
+      if (keysA.length !== keysB.length) {
+        return false;
+      }
+      var bHasOwnProperty = Object.prototype.hasOwnProperty.bind(objB);
+      for (var idx = 0; idx < keysA.length; idx++) {
+        var key = keysA[idx];
+        if (!bHasOwnProperty(key)) {
+          return false;
+        }
+        var valueA = objA[key];
+        var valueB = objB[key];
+        ret = compare ? compare.call(compareContext, valueA, valueB, key) : void 0;
+        if (ret === false || ret === void 0 && valueA !== valueB) {
+          return false;
+        }
+      }
+      return true;
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
   Breadcrumb: () => Breadcrumb,
+  JsonLd: () => JsonLd,
   SEO: () => SEO,
   SEOProvider: () => SEOProvider,
   SeoArticle: () => SeoArticle,
@@ -37,11 +202,19 @@ __export(index_exports, {
   SeoReview: () => SeoReview,
   SeoTag: () => SeoTag,
   SeoVideo: () => SeoVideo,
+  cleanSchema: () => cleanSchema,
+  generateArticleMetadata: () => generateArticleMetadata,
   generateArticleSchema: () => generateArticleSchema,
   generateBookSchema: () => generateBookSchema,
   generateBreadcrumbSchema: () => generateBreadcrumbSchema,
+  generateCategoryMetadata: () => generateCategoryMetadata,
+  generateCollectionPageSchema: () => generateCollectionPageSchema,
   generateEventSchema: () => generateEventSchema,
   generateFAQSchema: () => generateFAQSchema,
+  generateHomepageMetadata: () => generateHomepageMetadata,
+  generateHowToSchema: () => generateHowToSchema,
+  generateItemListSchema: () => generateItemListSchema,
+  generateJobPostingSchema: () => generateJobPostingSchema,
   generateLocalBusinessSchema: () => generateLocalBusinessSchema,
   generateMovieSchema: () => generateMovieSchema,
   generateOrganizationSchema: () => generateOrganizationSchema,
@@ -49,83 +222,267 @@ __export(index_exports, {
   generatePaginationLinks: () => generatePaginationLinks,
   generatePodcastEpisodeSchema: () => generatePodcastEpisodeSchema,
   generatePodcastSchema: () => generatePodcastSchema,
+  generateProductMetadata: () => generateProductMetadata,
   generateProductSchema: () => generateProductSchema,
+  generateRecipeSchema: () => generateRecipeSchema,
   generateSoftwareSchema: () => generateSoftwareSchema,
   generateVideoSchema: () => generateVideoSchema,
+  generateWebPageSchema: () => generateWebPageSchema,
   generateWebSiteSchema: () => generateWebSiteSchema,
   toNextMetadata: () => toNextMetadata,
-  useSEOConfig: () => useSEOConfig
+  useSEOConfig: () => useSEOConfig,
+  validateSEO: () => validateSEO
 });
 module.exports = __toCommonJS(index_exports);
 
+// src/core/utils.ts
+function cleanSchema(obj) {
+  if (Array.isArray(obj)) {
+    return obj.filter((item) => item !== void 0 && item !== null).map((item) => typeof item === "object" ? cleanSchema(item) : item);
+  }
+  const cleaned = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0 || value === null) continue;
+    if (Array.isArray(value)) {
+      const cleanedArr = value.filter((item) => item !== void 0 && item !== null).map((item) => typeof item === "object" && item !== null ? cleanSchema(item) : item);
+      if (cleanedArr.length > 0) {
+        cleaned[key] = cleanedArr;
+      }
+    } else if (typeof value === "object") {
+      cleaned[key] = cleanSchema(value);
+    } else {
+      cleaned[key] = value;
+    }
+  }
+  return cleaned;
+}
+function validateSEO(schemaType, data, requiredFields) {
+  const warnings = [];
+  for (const field of requiredFields) {
+    const value = data[field];
+    if (value === void 0 || value === null || value === "") {
+      warnings.push(`[react-seo] Warning: "${field}" is missing in ${schemaType} schema. Google may not show rich results.`);
+    }
+  }
+  if (warnings.length > 0 && typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" && globalThis.process.env?.NODE_ENV !== "production") {
+    warnings.forEach((w) => console.warn(w));
+  }
+  return warnings;
+}
+
 // src/core/schemas.ts
 function generateOrganizationSchema(config) {
-  return {
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "Organization",
     "name": config.name,
     "url": config.url,
     "logo": config.logo,
+    "description": config.description,
     "sameAs": config.socialLinks || []
-  };
+  });
 }
 function generateWebSiteSchema(config) {
-  return {
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "WebSite",
     "name": config.name,
     "url": config.url,
+    "description": config.description,
+    "publisher": {
+      "@type": "Organization",
+      "name": config.name,
+      "logo": config.logo
+    },
     "potentialAction": {
       "@type": "SearchAction",
       "target": `${config.url}/search?q={search_term_string}`,
       "query-input": "required name=search_term_string"
     }
-  };
+  });
+}
+function generateWebPageSchema(data, config) {
+  return cleanSchema({
+    "@context": "https://schema.org",
+    "@type": "WebPage",
+    "name": data.name,
+    "description": data.description,
+    "url": data.url,
+    "image": data.image,
+    "datePublished": data.datePublished,
+    "dateModified": data.dateModified,
+    "isPartOf": {
+      "@type": "WebSite",
+      "name": config.name,
+      "url": config.url
+    },
+    "breadcrumb": data.breadcrumb ? generateBreadcrumbSchema(data.breadcrumb) : void 0
+  });
+}
+function generateCollectionPageSchema(data, config) {
+  return cleanSchema({
+    "@context": "https://schema.org",
+    "@type": "CollectionPage",
+    "name": data.name,
+    "description": data.description,
+    "url": data.url,
+    "image": data.image,
+    "numberOfItems": data.numberOfItems,
+    "isPartOf": {
+      "@type": "WebSite",
+      "name": config.name,
+      "url": config.url
+    }
+  });
+}
+function generateItemListSchema(data) {
+  return cleanSchema({
+    "@context": "https://schema.org",
+    "@type": "ItemList",
+    "name": data.name,
+    "url": data.url,
+    "itemListOrder": data.itemListOrder === "ascending" ? "https://schema.org/ItemListOrderAscending" : data.itemListOrder === "descending" ? "https://schema.org/ItemListOrderDescending" : "https://schema.org/ItemListUnordered",
+    "numberOfItems": data.items.length,
+    "itemListElement": data.items.map((item, index) => ({
+      "@type": "ListItem",
+      "position": item.position || index + 1,
+      "name": item.name,
+      "url": item.url,
+      "image": item.image
+    }))
+  });
 }
 function generateArticleSchema(data, config) {
+  validateSEO("NewsArticle", data, ["title", "description", "image", "publishedTime", "author"]);
   const org = generateOrganizationSchema(config);
-  return {
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "NewsArticle",
     "headline": data.title,
     "description": data.description,
-    "image": data.image || config.logo,
+    "image": data.image,
     "datePublished": data.publishedTime,
     "dateModified": data.modifiedTime || data.publishedTime,
     "mainEntityOfPage": data.url,
+    "wordCount": data.wordCount,
     "author": data.author ? {
       "@type": "Person",
       "name": data.author.name,
       "url": data.author.url
     } : org,
     "publisher": org
-  };
+  });
 }
 function generateProductSchema(data) {
-  return {
+  validateSEO("Product", data, ["name", "description", "image", "price"]);
+  let offers;
+  if (data.variants && data.variants.length > 0) {
+    const prices = data.variants.map((v) => v.price);
+    offers = {
+      "@type": "AggregateOffer",
+      "lowPrice": Math.min(...prices),
+      "highPrice": Math.max(...prices),
+      "priceCurrency": data.currency || data.variants[0]?.currency || "USD",
+      "offerCount": data.variants.length,
+      "offers": data.variants.map((v) => cleanSchema({
+        "@type": "Offer",
+        "name": v.name,
+        "sku": v.sku,
+        "price": v.price,
+        "priceCurrency": v.currency || data.currency || "USD",
+        "availability": v.availability || data.availability || "https://schema.org/InStock",
+        "url": v.url || data.url,
+        "image": v.image,
+        "itemCondition": data.condition ? `https://schema.org/${data.condition}` : void 0
+      }))
+    };
+  } else {
+    offers = cleanSchema({
+      "@type": "Offer",
+      "url": data.url,
+      "priceCurrency": data.currency || "USD",
+      "price": data.price,
+      "availability": data.availability || "https://schema.org/InStock",
+      "itemCondition": data.condition ? `https://schema.org/${data.condition}` : void 0,
+      "seller": data.seller ? {
+        "@type": "Organization",
+        "name": data.seller.name,
+        "url": data.seller.url
+      } : void 0,
+      "hasMerchantReturnPolicy": data.returnPolicy ? cleanSchema({
+        "@type": "MerchantReturnPolicy",
+        "applicableCountry": data.shipping?.shippingDestination,
+        "returnPolicyCategory": data.returnPolicy.returnPolicyCategory ? `https://schema.org/${data.returnPolicy.returnPolicyCategory}` : "https://schema.org/MerchantReturnFiniteReturnWindow",
+        "merchantReturnDays": data.returnPolicy.returnWithin,
+        "returnMethod": data.returnPolicy.returnMethod ? `https://schema.org/${data.returnPolicy.returnMethod}` : void 0,
+        "returnFees": data.returnPolicy.returnFees ? `https://schema.org/${data.returnPolicy.returnFees}` : void 0
+      }) : void 0,
+      "shippingDetails": data.shipping ? cleanSchema({
+        "@type": "OfferShippingDetails",
+        "shippingRate": data.shipping.shippingRate ? {
+          "@type": "MonetaryAmount",
+          "value": data.shipping.shippingRate.value,
+          "currency": data.shipping.shippingRate.currency
+        } : void 0,
+        "shippingDestination": data.shipping.shippingDestination ? {
+          "@type": "DefinedRegion",
+          "addressCountry": data.shipping.shippingDestination
+        } : void 0,
+        "deliveryTime": data.shipping.deliveryTime ? {
+          "@type": "ShippingDeliveryTime",
+          "handlingTime": {
+            "@type": "QuantitativeValue",
+            "minValue": 0,
+            "maxValue": 1,
+            "unitCode": "DAY"
+          },
+          "transitTime": {
+            "@type": "QuantitativeValue",
+            "minValue": data.shipping.deliveryTime.minDays,
+            "maxValue": data.shipping.deliveryTime.maxDays,
+            "unitCode": "DAY"
+          }
+        } : void 0,
+        "freeShippingThreshold": data.shipping.freeShippingThreshold ? {
+          "@type": "MonetaryAmount",
+          "value": data.shipping.freeShippingThreshold,
+          "currency": data.shipping.shippingRate?.currency || data.currency || "USD"
+        } : void 0
+      }) : void 0
+    });
+  }
+  const reviewList = data.reviews?.map((r) => cleanSchema({
+    "@type": "Review",
+    "author": { "@type": "Person", "name": r.author },
+    "datePublished": r.datePublished,
+    "reviewBody": r.reviewBody,
+    "reviewRating": {
+      "@type": "Rating",
+      "ratingValue": r.ratingValue,
+      "bestRating": r.bestRating || 5
+    }
+  }));
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "Product",
     "name": data.name,
     "description": data.description,
     "image": data.image,
     "sku": data.sku,
+    "gtin": data.gtin,
+    "mpn": data.mpn,
     "brand": data.brand ? { "@type": "Brand", "name": data.brand } : void 0,
-    "offers": {
-      "@type": "Offer",
-      "url": data.url,
-      "priceCurrency": data.currency || "USD",
-      "price": data.price,
-      "availability": data.availability || "https://schema.org/InStock"
-    },
+    "offers": offers,
     "aggregateRating": data.rating ? {
       "@type": "AggregateRating",
       "ratingValue": data.rating,
       "reviewCount": data.reviewCount || 1
-    } : void 0
-  };
+    } : void 0,
+    "review": reviewList && reviewList.length > 0 ? reviewList : void 0
+  });
 }
 function generateFAQSchema(questions) {
-  return {
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "FAQPage",
     "mainEntity": questions.map((item) => ({
@@ -136,10 +493,10 @@ function generateFAQSchema(questions) {
         "text": item.a
       }
     }))
-  };
+  });
 }
 function generateBreadcrumbSchema(items) {
-  return {
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "BreadcrumbList",
     "itemListElement": items.map((item, index) => ({
@@ -148,10 +505,11 @@ function generateBreadcrumbSchema(items) {
       "name": item.name,
       "item": item.item
     }))
-  };
+  });
 }
 function generateVideoSchema(data) {
-  return {
+  validateSEO("VideoObject", data, ["name", "description", "thumbnailUrl", "uploadDate"]);
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "VideoObject",
     "name": data.name,
@@ -161,11 +519,11 @@ function generateVideoSchema(data) {
     "duration": data.duration,
     "contentUrl": data.contentUrl,
     "embedUrl": data.embedUrl
-  };
+  });
 }
 function generateEventSchema(data) {
   const isOnline = data.location && "url" in data.location;
-  return {
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "Event",
     "name": data.name,
@@ -188,10 +546,10 @@ function generateEventSchema(data) {
       "priceCurrency": data.offers.currency,
       "url": data.offers.url
     } : void 0
-  };
+  });
 }
 function generateLocalBusinessSchema(data) {
-  return {
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "LocalBusiness",
     "name": data.name,
@@ -213,10 +571,10 @@ function generateLocalBusinessSchema(data) {
     } : void 0,
     "openingHours": data.openingHours,
     "priceRange": data.priceRange
-  };
+  });
 }
 function generateSoftwareSchema(data) {
-  return {
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "SoftwareApplication",
     "name": data.name,
@@ -235,10 +593,10 @@ function generateSoftwareSchema(data) {
     } : void 0,
     "downloadUrl": data.downloadUrl,
     "screenshot": data.screenshot
-  };
+  });
 }
 function generateBookSchema(data) {
-  return {
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "Book",
     "name": data.name,
@@ -261,10 +619,10 @@ function generateBookSchema(data) {
     "image": data.image,
     "inLanguage": data.inLanguage,
     "genre": data.genre
-  };
+  });
 }
 function generateMovieSchema(data) {
-  return {
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "Movie",
     "name": data.name,
@@ -286,10 +644,10 @@ function generateMovieSchema(data) {
       "ratingValue": data.rating,
       "reviewCount": data.reviewCount || 1
     } : void 0
-  };
+  });
 }
 function generatePodcastSchema(data) {
-  return {
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "PodcastSeries",
     "name": data.name,
@@ -302,10 +660,10 @@ function generatePodcastSchema(data) {
     "webFeed": data.webFeed,
     "url": data.url,
     "genre": data.genre
-  };
+  });
 }
 function generatePodcastEpisodeSchema(data) {
-  return {
+  return cleanSchema({
     "@context": "https://schema.org",
     "@type": "PodcastEpisode",
     "name": data.name,
@@ -322,7 +680,109 @@ function generatePodcastEpisodeSchema(data) {
       "name": data.partOfSeries.name,
       "url": data.partOfSeries.url
     } : void 0
-  };
+  });
+}
+function generateHowToSchema(data) {
+  return cleanSchema({
+    "@context": "https://schema.org",
+    "@type": "HowTo",
+    "name": data.name,
+    "description": data.description,
+    "image": data.image,
+    "totalTime": data.totalTime,
+    "estimatedCost": data.estimatedCost ? {
+      "@type": "MonetaryAmount",
+      "currency": data.estimatedCost.currency,
+      "value": data.estimatedCost.value
+    } : void 0,
+    "supply": data.supply?.map((s) => ({ "@type": "HowToSupply", "name": s })),
+    "tool": data.tool?.map((t) => ({ "@type": "HowToTool", "name": t })),
+    "step": data.steps.map((step, index) => {
+      if (typeof step === "string") {
+        return { "@type": "HowToStep", "position": index + 1, "text": step };
+      }
+      return cleanSchema({
+        "@type": "HowToStep",
+        "position": index + 1,
+        "name": step.name,
+        "text": step.text,
+        "image": step.image,
+        "url": step.url
+      });
+    })
+  });
+}
+function generateRecipeSchema(data) {
+  return cleanSchema({
+    "@context": "https://schema.org",
+    "@type": "Recipe",
+    "name": data.name,
+    "description": data.description,
+    "image": data.image,
+    "author": { "@type": "Person", "name": data.author },
+    "datePublished": data.publishedDate,
+    "prepTime": data.prepTime,
+    "cookTime": data.cookTime,
+    "totalTime": data.totalTime,
+    "recipeYield": data.recipeYield,
+    "recipeCategory": data.recipeCategory,
+    "recipeCuisine": data.recipeCuisine,
+    "recipeIngredient": data.ingredients,
+    "recipeInstructions": data.instructions.map((step) => cleanSchema({
+      "@type": "HowToStep",
+      "name": step.name,
+      "text": step.text,
+      "image": step.image
+    })),
+    "aggregateRating": data.rating ? {
+      "@type": "AggregateRating",
+      "ratingValue": data.rating,
+      "reviewCount": data.reviewCount || 1
+    } : void 0
+  });
+}
+function generateJobPostingSchema(data) {
+  return cleanSchema({
+    "@context": "https://schema.org",
+    "@type": "JobPosting",
+    "title": data.title,
+    "description": data.description,
+    "datePosted": data.datePosted,
+    "validThrough": data.validThrough,
+    "employmentType": data.employmentType,
+    "jobLocationType": data.remote ? "TELECOMMUTE" : void 0,
+    "hiringOrganization": {
+      "@type": "Organization",
+      "name": data.hiringOrganization.name,
+      "sameAs": data.hiringOrganization.sameAs,
+      "logo": data.hiringOrganization.logo
+    },
+    "jobLocation": {
+      "@type": "Place",
+      "address": {
+        "@type": "PostalAddress",
+        "streetAddress": data.jobLocation.streetAddress,
+        "addressLocality": data.jobLocation.addressLocality,
+        "addressRegion": data.jobLocation.addressRegion,
+        "postalCode": data.jobLocation.postalCode,
+        "addressCountry": data.jobLocation.addressCountry
+      }
+    },
+    "baseSalary": data.baseSalary ? {
+      "@type": "MonetaryAmount",
+      "currency": data.baseSalary.currency,
+      "value": typeof data.baseSalary.value === "number" ? {
+        "@type": "QuantitativeValue",
+        "value": data.baseSalary.value,
+        "unitText": data.baseSalary.unitText || "MONTH"
+      } : {
+        "@type": "QuantitativeValue",
+        "minValue": data.baseSalary.value.minValue,
+        "maxValue": data.baseSalary.value.maxValue,
+        "unitText": data.baseSalary.unitText || "MONTH"
+      }
+    } : void 0
+  });
 }
 
 // src/core/metadata.ts
@@ -366,6 +826,9 @@ function toNextMetadata(props, config) {
     },
     other: {}
   };
+  if (config.facebookAppId) {
+    metadata.other["fb:app_id"] = config.facebookAppId;
+  }
   if (props.alternates && props.alternates.length > 0) {
     const languages = {};
     props.alternates.forEach((alt) => {
@@ -373,6 +836,12 @@ function toNextMetadata(props, config) {
     });
     metadata.alternates.languages = languages;
   }
+  if (props.prev) {
+    metadata.alternates.prev = props.prev;
+  }
+  if (props.next) {
+    metadata.alternates.next = props.next;
+  }
   metadata.appleWebApp = {
     capable: true,
     title: config.name,
@@ -380,6 +849,45 @@ function toNextMetadata(props, config) {
   };
   if (config.themeColor) metadata.themeColor = config.themeColor;
   if (config.manifest) metadata.manifest = config.manifest;
+  if (props.type === "article") {
+    if (props.publishedTime) {
+      metadata.openGraph.publishedTime = props.publishedTime;
+    }
+    if (props.modifiedTime) {
+      metadata.openGraph.modifiedTime = props.modifiedTime;
+    }
+    if (props.author) {
+      metadata.openGraph.authors = [props.author.name];
+    }
+    if (props.section) {
+      metadata.openGraph.section = props.section;
+    }
+    if (props.tags?.length) {
+      metadata.openGraph.tags = props.tags;
+    }
+  }
+  if (props.type === "product" && props.product) {
+    if (props.product.price !== void 0 && props.product.currency) {
+      metadata.other["product:price:amount"] = props.product.price.toString();
+      metadata.other["product:price:currency"] = props.product.currency;
+    }
+    if (props.product.availability) {
+      metadata.other["product:availability"] = props.product.availability;
+    }
+    if (props.product.brand) {
+      metadata.other["product:brand"] = props.product.brand;
+    }
+  }
+  if (props.readingTime) {
+    metadata.other["twitter:label1"] = "Reading time";
+    metadata.other["twitter:data1"] = `${props.readingTime} min`;
+  }
+  if (props.whatsappImage) {
+    metadata.other["og:image:secure_url"] = props.whatsappImage;
+  }
+  if (Object.keys(metadata.other).length === 0) {
+    delete metadata.other;
+  }
   return metadata;
 }
 function generatePaginationLinks(baseUrl, currentPage, totalPages) {
@@ -392,20 +900,1116 @@ function generatePaginationLinks(baseUrl, currentPage, totalPages) {
     canonical: currentPage === 1 ? cleanBase : `${cleanBase}?page=${currentPage}`
   };
 }
-function generatePaginatedTitle(title, page, suffix = "\u0635\u0641\u062D\u0629") {
+function generatePaginatedTitle(title, page, suffix = "Page") {
   return page > 1 ? `${title} - ${suffix} ${page}` : title;
 }
 
-// src/components/SEOProvider.tsx
-var import_react = require("react");
-var import_react_helmet_async = require("react-helmet-async");
+// src/core/JsonLd.tsx
 var import_jsx_runtime = require("react/jsx-runtime");
-var SEOContext = (0, import_react.createContext)(void 0);
+function JsonLd({ schema, graph = false }) {
+  const schemas = Array.isArray(schema) ? schema : [schema];
+  if (graph && schemas.length > 1) {
+    const graphData = {
+      "@context": "https://schema.org",
+      "@graph": schemas.map((s) => {
+        const { "@context": _, ...rest } = s;
+        return rest;
+      })
+    };
+    return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+      "script",
+      {
+        type: "application/ld+json",
+        dangerouslySetInnerHTML: { __html: JSON.stringify(graphData) }
+      }
+    );
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_jsx_runtime.Fragment, { children: schemas.map((s, i) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)(
+    "script",
+    {
+      type: "application/ld+json",
+      dangerouslySetInnerHTML: { __html: JSON.stringify(s) }
+    },
+    i
+  )) });
+}
+
+// src/core/product-metadata.ts
+function generateProductMetadata(product, config) {
+  const primaryImage = Array.isArray(product.image) ? product.image[0] : product.image;
+  const seoData = {
+    title: product.metaTitle || product.name,
+    description: product.metaDescription || product.description,
+    image: product.ogImage || primaryImage,
+    canonical: product.canonical || product.url,
+    type: "product",
+    noindex: product.noindex,
+    ogTitle: product.name,
+    ogDescription: product.description,
+    ogImage: product.ogImage || primaryImage,
+    ogImageWidth: product.ogImageWidth || 1200,
+    ogImageHeight: product.ogImageHeight || 630,
+    ogType: "product",
+    product: {
+      sku: product.sku,
+      brand: product.brand,
+      price: product.price,
+      currency: product.currency,
+      availability: product.availability,
+      rating: product.rating,
+      reviewCount: product.reviewCount
+    }
+  };
+  const metadata = toNextMetadata(seoData, config);
+  if (product.price !== void 0 && product.currency) {
+    metadata.other = {
+      ...metadata.other,
+      "product:price:amount": product.price.toString(),
+      "product:price:currency": product.currency
+    };
+    if (product.availability) {
+      metadata.other["product:availability"] = product.availability;
+    }
+    if (product.brand) {
+      metadata.other["product:brand"] = product.brand;
+    }
+    if (product.condition) {
+      metadata.other["product:condition"] = product.condition;
+    }
+  }
+  const productSchema = generateProductSchema({
+    name: product.name,
+    description: product.description,
+    image: product.image,
+    sku: product.sku,
+    gtin: product.gtin,
+    mpn: product.mpn,
+    brand: product.brand,
+    price: product.price,
+    currency: product.currency,
+    availability: product.availability,
+    rating: product.rating,
+    reviewCount: product.reviewCount,
+    url: product.url,
+    condition: product.condition,
+    reviews: product.reviews,
+    returnPolicy: product.returnPolicy,
+    shipping: product.shipping,
+    variants: product.variants,
+    seller: product.seller
+  });
+  const breadcrumbItems = product.breadcrumbs || [
+    { name: "Home", item: config.url },
+    { name: "Shop", item: `${config.url}/shop` },
+    ...product.category ? [{ name: product.category, item: `${config.url}/categories/${encodeURIComponent(product.category)}` }] : [],
+    { name: product.name, item: product.url }
+  ];
+  const breadcrumbSchema = generateBreadcrumbSchema(breadcrumbItems);
+  const organizationSchema = generateOrganizationSchema(config);
+  const websiteSchema = generateWebSiteSchema(config);
+  return {
+    metadata,
+    schemas: [productSchema, breadcrumbSchema, organizationSchema, websiteSchema],
+    productSchema,
+    breadcrumbSchema,
+    organizationSchema,
+    websiteSchema
+  };
+}
+
+// src/core/article-metadata.ts
+function generateArticleMetadata(article, config) {
+  const primaryImage = Array.isArray(article.image) ? article.image[0] : article.image;
+  const seoData = {
+    title: article.metaTitle || article.title,
+    description: article.metaDescription || article.description,
+    image: article.ogImage || primaryImage,
+    canonical: article.canonical || article.url,
+    type: "article",
+    noindex: article.noindex,
+    publishedTime: article.publishedTime,
+    modifiedTime: article.modifiedTime,
+    author: article.author,
+    section: article.category,
+    tags: article.tags,
+    readingTime: article.readingTime,
+    ogTitle: article.title,
+    ogDescription: article.description,
+    ogImage: article.ogImage || primaryImage,
+    ogImageWidth: article.ogImageWidth || 1200,
+    ogImageHeight: article.ogImageHeight || 630,
+    ogType: "article"
+  };
+  const metadata = toNextMetadata(seoData, config);
+  if (article.publishedTime) {
+    metadata.other = {
+      ...metadata.other,
+      "article:published_time": article.publishedTime
+    };
+  }
+  if (article.modifiedTime) {
+    metadata.other = {
+      ...metadata.other,
+      "article:modified_time": article.modifiedTime
+    };
+  }
+  if (article.category) {
+    metadata.other = {
+      ...metadata.other,
+      "article:section": article.category
+    };
+  }
+  if (article.tags?.length) {
+    metadata.other = {
+      ...metadata.other,
+      "article:tag": article.tags.join(",")
+    };
+  }
+  const articleSchema = generateArticleSchema({
+    title: article.title,
+    description: article.description,
+    image: article.image,
+    publishedTime: article.publishedTime,
+    modifiedTime: article.modifiedTime,
+    author: article.author,
+    url: article.url,
+    wordCount: article.wordCount
+  }, config);
+  const breadcrumbItems = article.breadcrumbs || [
+    { name: "Home", item: config.url },
+    ...article.category ? [{ name: article.category, item: `${config.url}/category/${encodeURIComponent(article.category)}` }] : [],
+    { name: article.title, item: article.url }
+  ];
+  const breadcrumbSchema = generateBreadcrumbSchema(breadcrumbItems);
+  const organizationSchema = generateOrganizationSchema(config);
+  const websiteSchema = generateWebSiteSchema(config);
+  return {
+    metadata,
+    schemas: [articleSchema, breadcrumbSchema, organizationSchema, websiteSchema],
+    articleSchema,
+    breadcrumbSchema,
+    organizationSchema,
+    websiteSchema
+  };
+}
+
+// src/core/category-metadata.ts
+function generateCategoryMetadata(category, config) {
+  const page = category.page || 1;
+  const totalPages = category.totalPages || 1;
+  const pageSuffix = category.pageSuffix || "Page";
+  const pagination = generatePaginationLinks(category.url, page, totalPages);
+  const title = generatePaginatedTitle(
+    category.metaTitle || category.name,
+    page,
+    pageSuffix
+  );
+  const seoData = {
+    title,
+    description: category.metaDescription || category.description,
+    image: category.image,
+    canonical: pagination.canonical,
+    type: "website",
+    noindex: category.noindex,
+    prev: pagination.prev,
+    next: pagination.next
+  };
+  const metadata = toNextMetadata(seoData, config);
+  const collectionPageSchema = generateCollectionPageSchema({
+    name: category.name,
+    description: category.description,
+    url: pagination.canonical || category.url,
+    image: category.image,
+    numberOfItems: category.items?.length
+  }, config);
+  const breadcrumbItems = category.breadcrumbs || [
+    { name: "Home", item: config.url },
+    ...category.parentCategory ? [{ name: category.parentCategory, item: `${config.url}/categories` }] : [],
+    { name: category.name, item: category.url }
+  ];
+  const breadcrumbSchema = generateBreadcrumbSchema(breadcrumbItems);
+  const organizationSchema = generateOrganizationSchema(config);
+  let itemListSchema;
+  if (category.items && category.items.length > 0) {
+    itemListSchema = generateItemListSchema({
+      name: category.name,
+      url: pagination.canonical || category.url,
+      items: category.items
+    });
+  }
+  const schemas = [collectionPageSchema, breadcrumbSchema, organizationSchema];
+  if (itemListSchema) schemas.push(itemListSchema);
+  return {
+    metadata,
+    schemas,
+    collectionPageSchema,
+    breadcrumbSchema,
+    organizationSchema,
+    itemListSchema
+  };
+}
+
+// src/core/homepage-metadata.ts
+function generateHomepageMetadata(input, config) {
+  const seoData = {
+    title: input.title || config.name,
+    description: input.description || config.description,
+    image: input.ogImage || input.image || config.logo,
+    canonical: input.canonical || config.url,
+    type: "website",
+    ogTitle: input.title || config.name,
+    ogDescription: input.description || config.description,
+    ogImage: input.ogImage || input.image || config.logo,
+    ogImageWidth: input.ogImageWidth || 1200,
+    ogImageHeight: input.ogImageHeight || 630
+  };
+  const metadata = toNextMetadata(seoData, config);
+  const webPageSchema = generateWebPageSchema({
+    name: input.title || config.name,
+    description: input.description || config.description,
+    url: config.url,
+    image: input.image || config.logo
+  }, config);
+  const organizationSchema = generateOrganizationSchema({
+    ...config,
+    socialLinks: input.socialLinks || config.socialLinks
+  });
+  const websiteSchema = generateWebSiteSchema(config);
+  const schemas = [webPageSchema, organizationSchema, websiteSchema];
+  let localBusinessSchema;
+  if (input.localBusiness) {
+    localBusinessSchema = generateLocalBusinessSchema(input.localBusiness);
+    schemas.push(localBusinessSchema);
+  }
+  return {
+    metadata,
+    schemas,
+    webPageSchema,
+    organizationSchema,
+    websiteSchema,
+    localBusinessSchema
+  };
+}
+
+// src/components/SEOProvider.tsx
+var import_react5 = require("react");
+
+// node_modules/react-helmet-async/lib/index.esm.js
+var import_react = __toESM(require("react"));
+var import_react_fast_compare = __toESM(require_react_fast_compare());
+var import_invariant = __toESM(require_invariant());
+var import_react2 = __toESM(require("react"));
+var import_react3 = __toESM(require("react"));
+var import_react4 = require("react");
+var import_shallowequal = __toESM(require_shallowequal());
+var TAG_NAMES = /* @__PURE__ */ ((TAG_NAMES2) => {
+  TAG_NAMES2["BASE"] = "base";
+  TAG_NAMES2["BODY"] = "body";
+  TAG_NAMES2["HEAD"] = "head";
+  TAG_NAMES2["HTML"] = "html";
+  TAG_NAMES2["LINK"] = "link";
+  TAG_NAMES2["META"] = "meta";
+  TAG_NAMES2["NOSCRIPT"] = "noscript";
+  TAG_NAMES2["SCRIPT"] = "script";
+  TAG_NAMES2["STYLE"] = "style";
+  TAG_NAMES2["TITLE"] = "title";
+  TAG_NAMES2["FRAGMENT"] = "Symbol(react.fragment)";
+  return TAG_NAMES2;
+})(TAG_NAMES || {});
+var SEO_PRIORITY_TAGS = {
+  link: { rel: ["amphtml", "canonical", "alternate"] },
+  script: { type: ["application/ld+json"] },
+  meta: {
+    charset: "",
+    name: ["generator", "robots", "description"],
+    property: [
+      "og:type",
+      "og:title",
+      "og:url",
+      "og:image",
+      "og:image:alt",
+      "og:description",
+      "twitter:url",
+      "twitter:title",
+      "twitter:description",
+      "twitter:image",
+      "twitter:image:alt",
+      "twitter:card",
+      "twitter:site"
+    ]
+  }
+};
+var VALID_TAG_NAMES = Object.values(TAG_NAMES);
+var REACT_TAG_MAP = {
+  accesskey: "accessKey",
+  charset: "charSet",
+  class: "className",
+  contenteditable: "contentEditable",
+  contextmenu: "contextMenu",
+  "http-equiv": "httpEquiv",
+  itemprop: "itemProp",
+  tabindex: "tabIndex"
+};
+var HTML_TAG_MAP = Object.entries(REACT_TAG_MAP).reduce(
+  (carry, [key, value]) => {
+    carry[value] = key;
+    return carry;
+  },
+  {}
+);
+var HELMET_ATTRIBUTE = "data-rh";
+var HELMET_PROPS = {
+  DEFAULT_TITLE: "defaultTitle",
+  DEFER: "defer",
+  ENCODE_SPECIAL_CHARACTERS: "encodeSpecialCharacters",
+  ON_CHANGE_CLIENT_STATE: "onChangeClientState",
+  TITLE_TEMPLATE: "titleTemplate",
+  PRIORITIZE_SEO_TAGS: "prioritizeSeoTags"
+};
+var getInnermostProperty = (propsList, property) => {
+  for (let i = propsList.length - 1; i >= 0; i -= 1) {
+    const props = propsList[i];
+    if (Object.prototype.hasOwnProperty.call(props, property)) {
+      return props[property];
+    }
+  }
+  return null;
+};
+var getTitleFromPropsList = (propsList) => {
+  let innermostTitle = getInnermostProperty(
+    propsList,
+    "title"
+    /* TITLE */
+  );
+  const innermostTemplate = getInnermostProperty(propsList, HELMET_PROPS.TITLE_TEMPLATE);
+  if (Array.isArray(innermostTitle)) {
+    innermostTitle = innermostTitle.join("");
+  }
+  if (innermostTemplate && innermostTitle) {
+    return innermostTemplate.replace(/%s/g, () => innermostTitle);
+  }
+  const innermostDefaultTitle = getInnermostProperty(propsList, HELMET_PROPS.DEFAULT_TITLE);
+  return innermostTitle || innermostDefaultTitle || void 0;
+};
+var getOnChangeClientState = (propsList) => getInnermostProperty(propsList, HELMET_PROPS.ON_CHANGE_CLIENT_STATE) || (() => {
+});
+var getAttributesFromPropsList = (tagType, propsList) => propsList.filter((props) => typeof props[tagType] !== "undefined").map((props) => props[tagType]).reduce((tagAttrs, current) => ({ ...tagAttrs, ...current }), {});
+var getBaseTagFromPropsList = (primaryAttributes, propsList) => propsList.filter((props) => typeof props[
+  "base"
+  /* BASE */
+] !== "undefined").map((props) => props[
+  "base"
+  /* BASE */
+]).reverse().reduce((innermostBaseTag, tag) => {
+  if (!innermostBaseTag.length) {
+    const keys = Object.keys(tag);
+    for (let i = 0; i < keys.length; i += 1) {
+      const attributeKey = keys[i];
+      const lowerCaseAttributeKey = attributeKey.toLowerCase();
+      if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && tag[lowerCaseAttributeKey]) {
+        return innermostBaseTag.concat(tag);
+      }
+    }
+  }
+  return innermostBaseTag;
+}, []);
+var warn = (msg) => console && typeof console.warn === "function" && console.warn(msg);
+var getTagsFromPropsList = (tagName, primaryAttributes, propsList) => {
+  const approvedSeenTags = {};
+  return propsList.filter((props) => {
+    if (Array.isArray(props[tagName])) {
+      return true;
+    }
+    if (typeof props[tagName] !== "undefined") {
+      warn(
+        `Helmet: ${tagName} should be of type "Array". Instead found type "${typeof props[tagName]}"`
+      );
+    }
+    return false;
+  }).map((props) => props[tagName]).reverse().reduce((approvedTags, instanceTags) => {
+    const instanceSeenTags = {};
+    instanceTags.filter((tag) => {
+      let primaryAttributeKey;
+      const keys2 = Object.keys(tag);
+      for (let i = 0; i < keys2.length; i += 1) {
+        const attributeKey = keys2[i];
+        const lowerCaseAttributeKey = attributeKey.toLowerCase();
+        if (primaryAttributes.indexOf(lowerCaseAttributeKey) !== -1 && !(primaryAttributeKey === "rel" && tag[primaryAttributeKey].toLowerCase() === "canonical") && !(lowerCaseAttributeKey === "rel" && tag[lowerCaseAttributeKey].toLowerCase() === "stylesheet")) {
+          primaryAttributeKey = lowerCaseAttributeKey;
+        }
+        if (primaryAttributes.indexOf(attributeKey) !== -1 && (attributeKey === "innerHTML" || attributeKey === "cssText" || attributeKey === "itemprop")) {
+          primaryAttributeKey = attributeKey;
+        }
+      }
+      if (!primaryAttributeKey || !tag[primaryAttributeKey]) {
+        return false;
+      }
+      const value = tag[primaryAttributeKey].toLowerCase();
+      if (!approvedSeenTags[primaryAttributeKey]) {
+        approvedSeenTags[primaryAttributeKey] = {};
+      }
+      if (!instanceSeenTags[primaryAttributeKey]) {
+        instanceSeenTags[primaryAttributeKey] = {};
+      }
+      if (!approvedSeenTags[primaryAttributeKey][value]) {
+        instanceSeenTags[primaryAttributeKey][value] = true;
+        return true;
+      }
+      return false;
+    }).reverse().forEach((tag) => approvedTags.push(tag));
+    const keys = Object.keys(instanceSeenTags);
+    for (let i = 0; i < keys.length; i += 1) {
+      const attributeKey = keys[i];
+      const tagUnion = {
+        ...approvedSeenTags[attributeKey],
+        ...instanceSeenTags[attributeKey]
+      };
+      approvedSeenTags[attributeKey] = tagUnion;
+    }
+    return approvedTags;
+  }, []).reverse();
+};
+var getAnyTrueFromPropsList = (propsList, checkedTag) => {
+  if (Array.isArray(propsList) && propsList.length) {
+    for (let index = 0; index < propsList.length; index += 1) {
+      const prop = propsList[index];
+      if (prop[checkedTag]) {
+        return true;
+      }
+    }
+  }
+  return false;
+};
+var reducePropsToState = (propsList) => ({
+  baseTag: getBaseTagFromPropsList([
+    "href"
+    /* HREF */
+  ], propsList),
+  bodyAttributes: getAttributesFromPropsList("bodyAttributes", propsList),
+  defer: getInnermostProperty(propsList, HELMET_PROPS.DEFER),
+  encode: getInnermostProperty(propsList, HELMET_PROPS.ENCODE_SPECIAL_CHARACTERS),
+  htmlAttributes: getAttributesFromPropsList("htmlAttributes", propsList),
+  linkTags: getTagsFromPropsList(
+    "link",
+    [
+      "rel",
+      "href"
+      /* HREF */
+    ],
+    propsList
+  ),
+  metaTags: getTagsFromPropsList(
+    "meta",
+    [
+      "name",
+      "charset",
+      "http-equiv",
+      "property",
+      "itemprop"
+      /* ITEM_PROP */
+    ],
+    propsList
+  ),
+  noscriptTags: getTagsFromPropsList("noscript", [
+    "innerHTML"
+    /* INNER_HTML */
+  ], propsList),
+  onChangeClientState: getOnChangeClientState(propsList),
+  scriptTags: getTagsFromPropsList(
+    "script",
+    [
+      "src",
+      "innerHTML"
+      /* INNER_HTML */
+    ],
+    propsList
+  ),
+  styleTags: getTagsFromPropsList("style", [
+    "cssText"
+    /* CSS_TEXT */
+  ], propsList),
+  title: getTitleFromPropsList(propsList),
+  titleAttributes: getAttributesFromPropsList("titleAttributes", propsList),
+  prioritizeSeoTags: getAnyTrueFromPropsList(propsList, HELMET_PROPS.PRIORITIZE_SEO_TAGS)
+});
+var flattenArray = (possibleArray) => Array.isArray(possibleArray) ? possibleArray.join("") : possibleArray;
+var checkIfPropsMatch = (props, toMatch) => {
+  const keys = Object.keys(props);
+  for (let i = 0; i < keys.length; i += 1) {
+    if (toMatch[keys[i]] && toMatch[keys[i]].includes(props[keys[i]])) {
+      return true;
+    }
+  }
+  return false;
+};
+var prioritizer = (elementsList, propsToMatch) => {
+  if (Array.isArray(elementsList)) {
+    return elementsList.reduce(
+      (acc, elementAttrs) => {
+        if (checkIfPropsMatch(elementAttrs, propsToMatch)) {
+          acc.priority.push(elementAttrs);
+        } else {
+          acc.default.push(elementAttrs);
+        }
+        return acc;
+      },
+      { priority: [], default: [] }
+    );
+  }
+  return { default: elementsList, priority: [] };
+};
+var without = (obj, key) => {
+  return {
+    ...obj,
+    [key]: void 0
+  };
+};
+var SELF_CLOSING_TAGS = [
+  "noscript",
+  "script",
+  "style"
+  /* STYLE */
+];
+var encodeSpecialCharacters = (str, encode = true) => {
+  if (encode === false) {
+    return String(str);
+  }
+  return String(str).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#x27;");
+};
+var generateElementAttributesAsString = (attributes) => Object.keys(attributes).reduce((str, key) => {
+  const attr = typeof attributes[key] !== "undefined" ? `${key}="${attributes[key]}"` : `${key}`;
+  return str ? `${str} ${attr}` : attr;
+}, "");
+var generateTitleAsString = (type, title, attributes, encode) => {
+  const attributeString = generateElementAttributesAsString(attributes);
+  const flattenedTitle = flattenArray(title);
+  return attributeString ? `<${type} ${HELMET_ATTRIBUTE}="true" ${attributeString}>${encodeSpecialCharacters(
+    flattenedTitle,
+    encode
+  )}</${type}>` : `<${type} ${HELMET_ATTRIBUTE}="true">${encodeSpecialCharacters(
+    flattenedTitle,
+    encode
+  )}</${type}>`;
+};
+var generateTagsAsString = (type, tags, encode = true) => tags.reduce((str, t) => {
+  const tag = t;
+  const attributeHtml = Object.keys(tag).filter(
+    (attribute) => !(attribute === "innerHTML" || attribute === "cssText")
+  ).reduce((string, attribute) => {
+    const attr = typeof tag[attribute] === "undefined" ? attribute : `${attribute}="${encodeSpecialCharacters(tag[attribute], encode)}"`;
+    return string ? `${string} ${attr}` : attr;
+  }, "");
+  const tagContent = tag.innerHTML || tag.cssText || "";
+  const isSelfClosing = SELF_CLOSING_TAGS.indexOf(type) === -1;
+  return `${str}<${type} ${HELMET_ATTRIBUTE}="true" ${attributeHtml}${isSelfClosing ? `/>` : `>${tagContent}</${type}>`}`;
+}, "");
+var convertElementAttributesToReactProps = (attributes, initProps = {}) => Object.keys(attributes).reduce((obj, key) => {
+  const mapped = REACT_TAG_MAP[key];
+  obj[mapped || key] = attributes[key];
+  return obj;
+}, initProps);
+var generateTitleAsReactComponent = (_type, title, attributes) => {
+  const initProps = {
+    key: title,
+    [HELMET_ATTRIBUTE]: true
+  };
+  const props = convertElementAttributesToReactProps(attributes, initProps);
+  return [import_react3.default.createElement("title", props, title)];
+};
+var generateTagsAsReactComponent = (type, tags) => tags.map((tag, i) => {
+  const mappedTag = {
+    key: i,
+    [HELMET_ATTRIBUTE]: true
+  };
+  Object.keys(tag).forEach((attribute) => {
+    const mapped = REACT_TAG_MAP[attribute];
+    const mappedAttribute = mapped || attribute;
+    if (mappedAttribute === "innerHTML" || mappedAttribute === "cssText") {
+      const content = tag.innerHTML || tag.cssText;
+      mappedTag.dangerouslySetInnerHTML = { __html: content };
+    } else {
+      mappedTag[mappedAttribute] = tag[attribute];
+    }
+  });
+  return import_react3.default.createElement(type, mappedTag);
+});
+var getMethodsForTag = (type, tags, encode = true) => {
+  switch (type) {
+    case "title":
+      return {
+        toComponent: () => generateTitleAsReactComponent(type, tags.title, tags.titleAttributes),
+        toString: () => generateTitleAsString(type, tags.title, tags.titleAttributes, encode)
+      };
+    case "bodyAttributes":
+    case "htmlAttributes":
+      return {
+        toComponent: () => convertElementAttributesToReactProps(tags),
+        toString: () => generateElementAttributesAsString(tags)
+      };
+    default:
+      return {
+        toComponent: () => generateTagsAsReactComponent(type, tags),
+        toString: () => generateTagsAsString(type, tags, encode)
+      };
+  }
+};
+var getPriorityMethods = ({ metaTags, linkTags, scriptTags, encode }) => {
+  const meta = prioritizer(metaTags, SEO_PRIORITY_TAGS.meta);
+  const link = prioritizer(linkTags, SEO_PRIORITY_TAGS.link);
+  const script = prioritizer(scriptTags, SEO_PRIORITY_TAGS.script);
+  const priorityMethods = {
+    toComponent: () => [
+      ...generateTagsAsReactComponent("meta", meta.priority),
+      ...generateTagsAsReactComponent("link", link.priority),
+      ...generateTagsAsReactComponent("script", script.priority)
+    ],
+    toString: () => (
+      // generate all the tags as strings and concatenate them
+      `${getMethodsForTag("meta", meta.priority, encode)} ${getMethodsForTag(
+        "link",
+        link.priority,
+        encode
+      )} ${getMethodsForTag("script", script.priority, encode)}`
+    )
+  };
+  return {
+    priorityMethods,
+    metaTags: meta.default,
+    linkTags: link.default,
+    scriptTags: script.default
+  };
+};
+var mapStateOnServer = (props) => {
+  const {
+    baseTag,
+    bodyAttributes,
+    encode = true,
+    htmlAttributes,
+    noscriptTags,
+    styleTags,
+    title = "",
+    titleAttributes,
+    prioritizeSeoTags
+  } = props;
+  let { linkTags, metaTags, scriptTags } = props;
+  let priorityMethods = {
+    toComponent: () => {
+    },
+    toString: () => ""
+  };
+  if (prioritizeSeoTags) {
+    ({ priorityMethods, linkTags, metaTags, scriptTags } = getPriorityMethods(props));
+  }
+  return {
+    priority: priorityMethods,
+    base: getMethodsForTag("base", baseTag, encode),
+    bodyAttributes: getMethodsForTag("bodyAttributes", bodyAttributes, encode),
+    htmlAttributes: getMethodsForTag("htmlAttributes", htmlAttributes, encode),
+    link: getMethodsForTag("link", linkTags, encode),
+    meta: getMethodsForTag("meta", metaTags, encode),
+    noscript: getMethodsForTag("noscript", noscriptTags, encode),
+    script: getMethodsForTag("script", scriptTags, encode),
+    style: getMethodsForTag("style", styleTags, encode),
+    title: getMethodsForTag("title", { title, titleAttributes }, encode)
+  };
+};
+var server_default = mapStateOnServer;
+var instances = [];
+var isDocument = !!(typeof window !== "undefined" && window.document && window.document.createElement);
+var HelmetData = class {
+  instances = [];
+  canUseDOM = isDocument;
+  context;
+  value = {
+    setHelmet: (serverState) => {
+      this.context.helmet = serverState;
+    },
+    helmetInstances: {
+      get: () => this.canUseDOM ? instances : this.instances,
+      add: (instance) => {
+        (this.canUseDOM ? instances : this.instances).push(instance);
+      },
+      remove: (instance) => {
+        const index = (this.canUseDOM ? instances : this.instances).indexOf(instance);
+        (this.canUseDOM ? instances : this.instances).splice(index, 1);
+      }
+    }
+  };
+  constructor(context, canUseDOM) {
+    this.context = context;
+    this.canUseDOM = canUseDOM || false;
+    if (!canUseDOM) {
+      context.helmet = server_default({
+        baseTag: [],
+        bodyAttributes: {},
+        encodeSpecialCharacters: true,
+        htmlAttributes: {},
+        linkTags: [],
+        metaTags: [],
+        noscriptTags: [],
+        scriptTags: [],
+        styleTags: [],
+        title: "",
+        titleAttributes: {}
+      });
+    }
+  }
+};
+var defaultValue = {};
+var Context = import_react2.default.createContext(defaultValue);
+var HelmetProvider = class _HelmetProvider extends import_react2.Component {
+  static canUseDOM = isDocument;
+  helmetData;
+  constructor(props) {
+    super(props);
+    this.helmetData = new HelmetData(this.props.context || {}, _HelmetProvider.canUseDOM);
+  }
+  render() {
+    return /* @__PURE__ */ import_react2.default.createElement(Context.Provider, { value: this.helmetData.value }, this.props.children);
+  }
+};
+var updateTags = (type, tags) => {
+  const headElement = document.head || document.querySelector(
+    "head"
+    /* HEAD */
+  );
+  const tagNodes = headElement.querySelectorAll(`${type}[${HELMET_ATTRIBUTE}]`);
+  const oldTags = [].slice.call(tagNodes);
+  const newTags = [];
+  let indexToDelete;
+  if (tags && tags.length) {
+    tags.forEach((tag) => {
+      const newElement = document.createElement(type);
+      for (const attribute in tag) {
+        if (Object.prototype.hasOwnProperty.call(tag, attribute)) {
+          if (attribute === "innerHTML") {
+            newElement.innerHTML = tag.innerHTML;
+          } else if (attribute === "cssText") {
+            if (newElement.styleSheet) {
+              newElement.styleSheet.cssText = tag.cssText;
+            } else {
+              newElement.appendChild(document.createTextNode(tag.cssText));
+            }
+          } else {
+            const attr = attribute;
+            const value = typeof tag[attr] === "undefined" ? "" : tag[attr];
+            newElement.setAttribute(attribute, value);
+          }
+        }
+      }
+      newElement.setAttribute(HELMET_ATTRIBUTE, "true");
+      if (oldTags.some((existingTag, index) => {
+        indexToDelete = index;
+        return newElement.isEqualNode(existingTag);
+      })) {
+        oldTags.splice(indexToDelete, 1);
+      } else {
+        newTags.push(newElement);
+      }
+    });
+  }
+  oldTags.forEach((tag) => tag.parentNode?.removeChild(tag));
+  newTags.forEach((tag) => headElement.appendChild(tag));
+  return {
+    oldTags,
+    newTags
+  };
+};
+var updateAttributes = (tagName, attributes) => {
+  const elementTag = document.getElementsByTagName(tagName)[0];
+  if (!elementTag) {
+    return;
+  }
+  const helmetAttributeString = elementTag.getAttribute(HELMET_ATTRIBUTE);
+  const helmetAttributes = helmetAttributeString ? helmetAttributeString.split(",") : [];
+  const attributesToRemove = [...helmetAttributes];
+  const attributeKeys = Object.keys(attributes);
+  for (const attribute of attributeKeys) {
+    const value = attributes[attribute] || "";
+    if (elementTag.getAttribute(attribute) !== value) {
+      elementTag.setAttribute(attribute, value);
+    }
+    if (helmetAttributes.indexOf(attribute) === -1) {
+      helmetAttributes.push(attribute);
+    }
+    const indexToSave = attributesToRemove.indexOf(attribute);
+    if (indexToSave !== -1) {
+      attributesToRemove.splice(indexToSave, 1);
+    }
+  }
+  for (let i = attributesToRemove.length - 1; i >= 0; i -= 1) {
+    elementTag.removeAttribute(attributesToRemove[i]);
+  }
+  if (helmetAttributes.length === attributesToRemove.length) {
+    elementTag.removeAttribute(HELMET_ATTRIBUTE);
+  } else if (elementTag.getAttribute(HELMET_ATTRIBUTE) !== attributeKeys.join(",")) {
+    elementTag.setAttribute(HELMET_ATTRIBUTE, attributeKeys.join(","));
+  }
+};
+var updateTitle = (title, attributes) => {
+  if (typeof title !== "undefined" && document.title !== title) {
+    document.title = flattenArray(title);
+  }
+  updateAttributes("title", attributes);
+};
+var commitTagChanges = (newState, cb) => {
+  const {
+    baseTag,
+    bodyAttributes,
+    htmlAttributes,
+    linkTags,
+    metaTags,
+    noscriptTags,
+    onChangeClientState,
+    scriptTags,
+    styleTags,
+    title,
+    titleAttributes
+  } = newState;
+  updateAttributes("body", bodyAttributes);
+  updateAttributes("html", htmlAttributes);
+  updateTitle(title, titleAttributes);
+  const tagUpdates = {
+    baseTag: updateTags("base", baseTag),
+    linkTags: updateTags("link", linkTags),
+    metaTags: updateTags("meta", metaTags),
+    noscriptTags: updateTags("noscript", noscriptTags),
+    scriptTags: updateTags("script", scriptTags),
+    styleTags: updateTags("style", styleTags)
+  };
+  const addedTags = {};
+  const removedTags = {};
+  Object.keys(tagUpdates).forEach((tagType) => {
+    const { newTags, oldTags } = tagUpdates[tagType];
+    if (newTags.length) {
+      addedTags[tagType] = newTags;
+    }
+    if (oldTags.length) {
+      removedTags[tagType] = tagUpdates[tagType].oldTags;
+    }
+  });
+  if (cb) {
+    cb();
+  }
+  onChangeClientState(newState, addedTags, removedTags);
+};
+var _helmetCallback = null;
+var handleStateChangeOnClient = (newState) => {
+  if (_helmetCallback) {
+    cancelAnimationFrame(_helmetCallback);
+  }
+  if (newState.defer) {
+    _helmetCallback = requestAnimationFrame(() => {
+      commitTagChanges(newState, () => {
+        _helmetCallback = null;
+      });
+    });
+  } else {
+    commitTagChanges(newState);
+    _helmetCallback = null;
+  }
+};
+var client_default = handleStateChangeOnClient;
+var HelmetDispatcher = class extends import_react4.Component {
+  rendered = false;
+  shouldComponentUpdate(nextProps) {
+    return !(0, import_shallowequal.default)(nextProps, this.props);
+  }
+  componentDidUpdate() {
+    this.emitChange();
+  }
+  componentWillUnmount() {
+    const { helmetInstances } = this.props.context;
+    helmetInstances.remove(this);
+    this.emitChange();
+  }
+  emitChange() {
+    const { helmetInstances, setHelmet } = this.props.context;
+    let serverState = null;
+    const state = reducePropsToState(
+      helmetInstances.get().map((instance) => {
+        const props = { ...instance.props };
+        delete props.context;
+        return props;
+      })
+    );
+    if (HelmetProvider.canUseDOM) {
+      client_default(state);
+    } else if (server_default) {
+      serverState = server_default(state);
+    }
+    setHelmet(serverState);
+  }
+  // componentWillMount will be deprecated
+  // for SSR, initialize on first render
+  // constructor is also unsafe in StrictMode
+  init() {
+    if (this.rendered) {
+      return;
+    }
+    this.rendered = true;
+    const { helmetInstances } = this.props.context;
+    helmetInstances.add(this);
+    this.emitChange();
+  }
+  render() {
+    this.init();
+    return null;
+  }
+};
+var Helmet = class extends import_react.Component {
+  static defaultProps = {
+    defer: true,
+    encodeSpecialCharacters: true,
+    prioritizeSeoTags: false
+  };
+  shouldComponentUpdate(nextProps) {
+    return !(0, import_react_fast_compare.default)(without(this.props, "helmetData"), without(nextProps, "helmetData"));
+  }
+  mapNestedChildrenToProps(child, nestedChildren) {
+    if (!nestedChildren) {
+      return null;
+    }
+    switch (child.type) {
+      case "script":
+      case "noscript":
+        return {
+          innerHTML: nestedChildren
+        };
+      case "style":
+        return {
+          cssText: nestedChildren
+        };
+      default:
+        throw new Error(
+          `<${child.type} /> elements are self-closing and can not contain children. Refer to our API for more information.`
+        );
+    }
+  }
+  flattenArrayTypeChildren(child, arrayTypeChildren, newChildProps, nestedChildren) {
+    return {
+      ...arrayTypeChildren,
+      [child.type]: [
+        ...arrayTypeChildren[child.type] || [],
+        {
+          ...newChildProps,
+          ...this.mapNestedChildrenToProps(child, nestedChildren)
+        }
+      ]
+    };
+  }
+  mapObjectTypeChildren(child, newProps, newChildProps, nestedChildren) {
+    switch (child.type) {
+      case "title":
+        return {
+          ...newProps,
+          [child.type]: nestedChildren,
+          titleAttributes: { ...newChildProps }
+        };
+      case "body":
+        return {
+          ...newProps,
+          bodyAttributes: { ...newChildProps }
+        };
+      case "html":
+        return {
+          ...newProps,
+          htmlAttributes: { ...newChildProps }
+        };
+      default:
+        return {
+          ...newProps,
+          [child.type]: { ...newChildProps }
+        };
+    }
+  }
+  mapArrayTypeChildrenToProps(arrayTypeChildren, newProps) {
+    let newFlattenedProps = { ...newProps };
+    Object.keys(arrayTypeChildren).forEach((arrayChildName) => {
+      newFlattenedProps = {
+        ...newFlattenedProps,
+        [arrayChildName]: arrayTypeChildren[arrayChildName]
+      };
+    });
+    return newFlattenedProps;
+  }
+  warnOnInvalidChildren(child, nestedChildren) {
+    (0, import_invariant.default)(
+      VALID_TAG_NAMES.some((name) => child.type === name),
+      typeof child.type === "function" ? `You may be attempting to nest <Helmet> components within each other, which is not allowed. Refer to our API for more information.` : `Only elements types ${VALID_TAG_NAMES.join(
+        ", "
+      )} are allowed. Helmet does not support rendering <${child.type}> elements. Refer to our API for more information.`
+    );
+    (0, import_invariant.default)(
+      !nestedChildren || typeof nestedChildren === "string" || Array.isArray(nestedChildren) && !nestedChildren.some((nestedChild) => typeof nestedChild !== "string"),
+      `Helmet expects a string as a child of <${child.type}>. Did you forget to wrap your children in braces? ( <${child.type}>{\`\`}</${child.type}> ) Refer to our API for more information.`
+    );
+    return true;
+  }
+  mapChildrenToProps(children, newProps) {
+    let arrayTypeChildren = {};
+    import_react.default.Children.forEach(children, (child) => {
+      if (!child || !child.props) {
+        return;
+      }
+      const { children: nestedChildren, ...childProps } = child.props;
+      const newChildProps = Object.keys(childProps).reduce((obj, key) => {
+        obj[HTML_TAG_MAP[key] || key] = childProps[key];
+        return obj;
+      }, {});
+      let { type } = child;
+      if (typeof type === "symbol") {
+        type = type.toString();
+      } else {
+        this.warnOnInvalidChildren(child, nestedChildren);
+      }
+      switch (type) {
+        case "Symbol(react.fragment)":
+          newProps = this.mapChildrenToProps(nestedChildren, newProps);
+          break;
+        case "link":
+        case "meta":
+        case "noscript":
+        case "script":
+        case "style":
+          arrayTypeChildren = this.flattenArrayTypeChildren(
+            child,
+            arrayTypeChildren,
+            newChildProps,
+            nestedChildren
+          );
+          break;
+        default:
+          newProps = this.mapObjectTypeChildren(child, newProps, newChildProps, nestedChildren);
+          break;
+      }
+    });
+    return this.mapArrayTypeChildrenToProps(arrayTypeChildren, newProps);
+  }
+  render() {
+    const { children, ...props } = this.props;
+    let newProps = { ...props };
+    let { helmetData } = props;
+    if (children) {
+      newProps = this.mapChildrenToProps(children, newProps);
+    }
+    if (helmetData && !(helmetData instanceof HelmetData)) {
+      const data = helmetData;
+      helmetData = new HelmetData(data.context, true);
+      delete newProps.helmetData;
+    }
+    return helmetData ? /* @__PURE__ */ import_react.default.createElement(HelmetDispatcher, { ...newProps, context: helmetData.value }) : /* @__PURE__ */ import_react.default.createElement(Context.Consumer, null, (context) => /* @__PURE__ */ import_react.default.createElement(HelmetDispatcher, { ...newProps, context }));
+  }
+};
+
+// src/components/SEOProvider.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+var SEOContext = (0, import_react5.createContext)(void 0);
 var SEOProvider = ({ config, children, helmetContext }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(SEOContext.Provider, { value: { config }, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)(import_react_helmet_async.HelmetProvider, { context: helmetContext, children }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(SEOContext.Provider, { value: { config }, children: /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(HelmetProvider, { context: helmetContext, children }) });
 };
 var useSEOConfig = () => {
-  const context = (0, import_react.useContext)(SEOContext);
+  const context = (0, import_react5.useContext)(SEOContext);
   if (!context) {
     throw new Error("useSEOConfig must be used within an SEOProvider");
   }
@@ -413,8 +2017,7 @@ var useSEOConfig = () => {
 };
 
 // src/components/SEO.tsx
-var import_react_helmet_async2 = require("react-helmet-async");
-var import_jsx_runtime2 = require("react/jsx-runtime");
+var import_jsx_runtime3 = require("react/jsx-runtime");
 var SEO = (props) => {
   const config = useSEOConfig();
   const title = props.title ? `${props.title} | ${config.name}` : config.name;
@@ -493,57 +2096,56 @@ var SEO = (props) => {
       schemas.push(props.schema);
     }
   }
-  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)(import_react_helmet_async2.Helmet, { children: [
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("title", { children: title }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "description", content: description }),
-    props.keywords && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "keywords", content: props.keywords.join(", ") }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "robots", content: props.noindex ? "noindex, nofollow" : props.robots || "index, follow" }),
-    !props.noindex && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("link", { rel: "canonical", href: url }),
-    props.prev && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("link", { rel: "prev", href: props.prev }),
-    props.next && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("link", { rel: "next", href: props.next }),
-    config.language && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { httpEquiv: "content-language", content: config.language }),
-    props.alternates?.map((alt, i) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("link", { rel: "alternate", hrefLang: alt.hreflang, href: alt.href }, i)),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "og:type", content: props.ogType || (props.type === "article" ? "article" : "website") }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "og:title", content: props.ogTitle || title }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "og:description", content: props.ogDescription || description }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "og:image", content: props.ogImage || image }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "og:url", content: url }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "og:site_name", content: config.name }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "og:locale", content: props.ogLocale || config.language || "en_US" }),
-    config.facebookAppId && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "fb:app_id", content: config.facebookAppId }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "twitter:card", content: props.twitterCard || "summary_large_image" }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "twitter:title", content: props.twitterTitle || title }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "twitter:description", content: props.twitterDescription || description }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "twitter:image", content: props.twitterImage || image }),
-    config.twitterHandle && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "twitter:site", content: config.twitterHandle }),
-    config.twitterHandle && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "twitter:creator", content: config.twitterHandle }),
-    props.readingTime && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "twitter:label1", content: "Reading time" }),
-    props.readingTime && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "twitter:data1", content: `${props.readingTime} min` }),
-    props.type === "article" && props.publishedTime && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "article:published_time", content: props.publishedTime }),
-    props.type === "article" && props.modifiedTime && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "article:modified_time", content: props.modifiedTime }),
-    props.type === "article" && props.section && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "article:section", content: props.section }),
-    props.type === "article" && props.tags?.map((tag) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "article:tag", content: tag }, tag)),
-    config.themeColor && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "theme-color", content: config.themeColor }),
-    config.manifest && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("link", { rel: "manifest", href: config.manifest }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "apple-mobile-web-app-capable", content: "yes" }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "apple-mobile-web-app-status-bar-style", content: "default" }),
-    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { name: "apple-mobile-web-app-title", content: config.name }),
-    props.dnsPrefetch?.map((d) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("link", { rel: "dns-prefetch", href: d }, d)),
-    props.preconnect?.map((d) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("link", { rel: "preconnect", href: d }, d)),
-    props.prefetch?.map((d) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("link", { rel: "prefetch", href: d }, d)),
-    props.preload?.map((p) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("link", { rel: "preload", href: p.href, as: p.as, type: p.type }, p.href)),
-    (props.whatsappImage || image) && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "og:image:secure_url", content: props.whatsappImage || image }),
-    props.whatsappDescription && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("meta", { property: "whatsapp:description", content: props.whatsappDescription }),
-    config.googleAnalyticsId && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("script", { async: true, src: `https://www.googletagmanager.com/gtag/js?id=${config.googleAnalyticsId}` }),
-    config.googleAnalyticsId && /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("script", { children: `window.dataLayer = window.dataLayer || []; function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', '${config.googleAnalyticsId}');` }),
-    schemas.map((schema, index) => /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }, index)),
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(Helmet, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("title", { children: title }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "description", content: description }),
+    props.keywords && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "keywords", content: props.keywords.join(", ") }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "robots", content: props.noindex ? "noindex, nofollow" : props.robots || "index, follow" }),
+    !props.noindex && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("link", { rel: "canonical", href: url }),
+    props.prev && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("link", { rel: "prev", href: props.prev }),
+    props.next && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("link", { rel: "next", href: props.next }),
+    config.language && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { httpEquiv: "content-language", content: config.language }),
+    props.alternates?.map((alt, i) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("link", { rel: "alternate", hrefLang: alt.hreflang, href: alt.href }, i)),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "og:type", content: props.ogType || (props.type === "article" ? "article" : "website") }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "og:title", content: props.ogTitle || title }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "og:description", content: props.ogDescription || description }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "og:image", content: props.ogImage || image }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "og:url", content: url }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "og:site_name", content: config.name }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "og:locale", content: props.ogLocale || config.language || "en_US" }),
+    config.facebookAppId && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "fb:app_id", content: config.facebookAppId }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "twitter:card", content: props.twitterCard || "summary_large_image" }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "twitter:title", content: props.twitterTitle || title }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "twitter:description", content: props.twitterDescription || description }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "twitter:image", content: props.twitterImage || image }),
+    config.twitterHandle && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "twitter:site", content: config.twitterHandle }),
+    config.twitterHandle && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "twitter:creator", content: config.twitterHandle }),
+    props.readingTime && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "twitter:label1", content: "Reading time" }),
+    props.readingTime && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "twitter:data1", content: `${props.readingTime} min` }),
+    props.type === "article" && props.publishedTime && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "article:published_time", content: props.publishedTime }),
+    props.type === "article" && props.modifiedTime && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "article:modified_time", content: props.modifiedTime }),
+    props.type === "article" && props.section && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "article:section", content: props.section }),
+    props.type === "article" && props.tags?.map((tag) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "article:tag", content: tag }, tag)),
+    config.themeColor && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "theme-color", content: config.themeColor }),
+    config.manifest && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("link", { rel: "manifest", href: config.manifest }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "apple-mobile-web-app-capable", content: "yes" }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "apple-mobile-web-app-status-bar-style", content: "default" }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { name: "apple-mobile-web-app-title", content: config.name }),
+    props.dnsPrefetch?.map((d) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("link", { rel: "dns-prefetch", href: d }, d)),
+    props.preconnect?.map((d) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("link", { rel: "preconnect", href: d }, d)),
+    props.prefetch?.map((d) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("link", { rel: "prefetch", href: d }, d)),
+    props.preload?.map((p) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("link", { rel: "preload", href: p.href, as: p.as, type: p.type }, p.href)),
+    (props.whatsappImage || image) && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "og:image:secure_url", content: props.whatsappImage || image }),
+    props.whatsappDescription && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("meta", { property: "whatsapp:description", content: props.whatsappDescription }),
+    config.googleAnalyticsId && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("script", { async: true, src: `https://www.googletagmanager.com/gtag/js?id=${config.googleAnalyticsId}` }),
+    config.googleAnalyticsId && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("script", { children: `window.dataLayer = window.dataLayer || []; function gtag(){dataLayer.push(arguments);} gtag('js', new Date()); gtag('config', '${config.googleAnalyticsId}');` }),
+    schemas.map((schema, index) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }, index)),
     props.children
   ] });
 };
 
 // src/components/Breadcrumb.tsx
-var import_react_helmet_async3 = require("react-helmet-async");
-var import_jsx_runtime3 = require("react/jsx-runtime");
+var import_jsx_runtime4 = require("react/jsx-runtime");
 var Breadcrumb = ({
   items,
   className = "breadcrumb",
@@ -560,22 +2162,22 @@ var Breadcrumb = ({
       "item": item.item
     }))
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
-    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_react_helmet_async3.Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) }),
-    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("nav", { className, "aria-label": "Breadcrumb", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("ol", { style: { display: "flex", listStyle: "none", padding: 0 }, children: items.map((item, index) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(import_jsx_runtime4.Fragment, { children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) }),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("nav", { className, "aria-label": "Breadcrumb", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("ol", { style: { display: "flex", listStyle: "none", padding: 0 }, children: items.map((item, index) => {
       const isLast = index === items.length - 1;
-      return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("li", { style: { display: "flex", alignItems: "center" }, children: [
-        renderLink ? renderLink(item, isLast) : isLast ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { "aria-current": "page", children: item.name }) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("a", { href: item.item, children: item.name }),
-        !isLast && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { style: { margin: "0 8px" }, children: separator })
+      return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("li", { style: { display: "flex", alignItems: "center" }, children: [
+        renderLink ? renderLink(item, isLast) : isLast ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { "aria-current": "page", children: item.name }) : /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("a", { href: item.item, children: item.name }),
+        !isLast && /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("span", { style: { margin: "0 8px" }, children: separator })
       ] }, index);
     }) }) })
   ] });
 };
 
 // src/components/SeoArticle.tsx
-var import_jsx_runtime4 = require("react/jsx-runtime");
+var import_jsx_runtime5 = require("react/jsx-runtime");
 var SeoArticle = ({ article, ...rest }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
     SEO,
     {
       type: "article",
@@ -593,9 +2195,9 @@ var SeoArticle = ({ article, ...rest }) => {
 };
 
 // src/components/SeoProduct.tsx
-var import_jsx_runtime5 = require("react/jsx-runtime");
+var import_jsx_runtime6 = require("react/jsx-runtime");
 var SeoProduct = ({ item, ...rest }) => {
-  return /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(
     SEO,
     {
       type: "product",
@@ -617,8 +2219,7 @@ var SeoProduct = ({ item, ...rest }) => {
 };
 
 // src/components/SeoFAQ.tsx
-var import_react_helmet_async4 = require("react-helmet-async");
-var import_jsx_runtime6 = require("react/jsx-runtime");
+var import_jsx_runtime7 = require("react/jsx-runtime");
 var SeoFAQ = ({ items }) => {
   const schema = {
     "@context": "https://schema.org",
@@ -632,12 +2233,11 @@ var SeoFAQ = ({ items }) => {
       }
     }))
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime6.jsx)(import_react_helmet_async4.Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime6.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
 };
 
 // src/components/SeoVideo.tsx
-var import_react_helmet_async5 = require("react-helmet-async");
-var import_jsx_runtime7 = require("react/jsx-runtime");
+var import_jsx_runtime8 = require("react/jsx-runtime");
 var SeoVideo = ({ video }) => {
   const schema = {
     "@context": "https://schema.org",
@@ -655,12 +2255,11 @@ var SeoVideo = ({ video }) => {
       "userInteractionCount": video.interactionStatistic.viewCount
     } : void 0
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime7.jsx)(import_react_helmet_async5.Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime7.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
 };
 
 // src/components/SeoEvent.tsx
-var import_react_helmet_async6 = require("react-helmet-async");
-var import_jsx_runtime8 = require("react/jsx-runtime");
+var import_jsx_runtime9 = require("react/jsx-runtime");
 var SeoEvent = ({ event }) => {
   const schema = {
     "@context": "https://schema.org",
@@ -696,12 +2295,11 @@ var SeoEvent = ({ event }) => {
       "url": event.organizer.url
     } : void 0
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime8.jsx)(import_react_helmet_async6.Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime8.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
 };
 
 // src/components/SeoLocalBusiness.tsx
-var import_react_helmet_async7 = require("react-helmet-async");
-var import_jsx_runtime9 = require("react/jsx-runtime");
+var import_jsx_runtime10 = require("react/jsx-runtime");
 var SeoLocalBusiness = ({ business }) => {
   const schema = {
     "@context": "https://schema.org",
@@ -728,23 +2326,29 @@ var SeoLocalBusiness = ({ business }) => {
     } : void 0,
     "openingHours": business.openingHours
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime9.jsx)(import_react_helmet_async7.Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime9.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime10.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
 };
 
 // src/components/SeoCategory.tsx
-var import_jsx_runtime10 = require("react/jsx-runtime");
-var SeoCategory = ({ category, page = 1, totalPage = 1, ...rest }) => {
+var import_jsx_runtime11 = require("react/jsx-runtime");
+var SeoCategory = ({
+  category,
+  page = 1,
+  totalPage = 1,
+  pageSuffix = "Page",
+  ...rest
+}) => {
   const hasNext = page < totalPage;
   const hasPrev = page > 1;
   const baseUrl = category.url.split("?")[0];
   const nextUrl = hasNext ? `${baseUrl}?page=${page + 1}` : void 0;
   const prevUrl = hasPrev ? page === 2 ? baseUrl : `${baseUrl}?page=${page - 1}` : void 0;
   const canonical = page === 1 ? baseUrl : `${baseUrl}?page=${page}`;
-  return /* @__PURE__ */ (0, import_jsx_runtime10.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
     SEO,
     {
       type: "website",
-      title: `${category.name}${page > 1 ? ` - \u0635\u0641\u062D\u0629 ${page}` : ""}`,
+      title: `${category.name}${page > 1 ? ` - ${pageSuffix} ${page}` : ""}`,
       description: category.description,
       image: category.image,
       canonical,
@@ -763,20 +2367,29 @@ var SeoCategory = ({ category, page = 1, totalPage = 1, ...rest }) => {
 };
 
 // src/components/SeoTag.tsx
-var import_jsx_runtime11 = require("react/jsx-runtime");
-var SeoTag = ({ tag, page = 1, totalPage = 1, ...rest }) => {
+var import_jsx_runtime12 = require("react/jsx-runtime");
+var SeoTag = ({
+  tag,
+  page = 1,
+  totalPage = 1,
+  titlePrefix = "Tag",
+  pageSuffix = "Page",
+  defaultDescription,
+  ...rest
+}) => {
   const hasNext = page < totalPage;
   const hasPrev = page > 1;
   const baseUrl = tag.url.split("?")[0];
   const nextUrl = hasNext ? `${baseUrl}?page=${page + 1}` : void 0;
   const prevUrl = hasPrev ? page === 2 ? baseUrl : `${baseUrl}?page=${page - 1}` : void 0;
   const canonical = page === 1 ? baseUrl : `${baseUrl}?page=${page}`;
-  return /* @__PURE__ */ (0, import_jsx_runtime11.jsx)(
+  const desc = tag.description || (defaultDescription ? defaultDescription.replace("{name}", tag.name) : `All posts tagged with ${tag.name}`);
+  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
     SEO,
     {
       type: "website",
-      title: `\u062A\u0627\u063A: ${tag.name}${page > 1 ? ` - \u0635\u0641\u062D\u0629 ${page}` : ""}`,
-      description: tag.description || `\u0643\u0644 \u0627\u0644\u0645\u0642\u0627\u0644\u0627\u062A \u0627\u0644\u0645\u062A\u0639\u0644\u0642\u0629 \u0628\u0640 ${tag.name}`,
+      title: `${titlePrefix}: ${tag.name}${page > 1 ? ` - ${pageSuffix} ${page}` : ""}`,
+      description: desc,
       canonical,
       next: nextUrl,
       prev: prevUrl,
@@ -786,19 +2399,25 @@ var SeoTag = ({ tag, page = 1, totalPage = 1, ...rest }) => {
 };
 
 // src/components/SeoAuthor.tsx
-var import_jsx_runtime12 = require("react/jsx-runtime");
-var SeoAuthor = ({ author, page = 1, totalPage = 1, ...rest }) => {
+var import_jsx_runtime13 = require("react/jsx-runtime");
+var SeoAuthor = ({
+  author,
+  page = 1,
+  totalPage = 1,
+  pageSuffix = "Page",
+  ...rest
+}) => {
   const hasNext = page < totalPage;
   const hasPrev = page > 1;
   const baseUrl = author.url.split("?")[0];
   const nextUrl = hasNext ? `${baseUrl}?page=${page + 1}` : void 0;
   const prevUrl = hasPrev ? page === 2 ? baseUrl : `${baseUrl}?page=${page - 1}` : void 0;
   const canonical = page === 1 ? baseUrl : `${baseUrl}?page=${page}`;
-  return /* @__PURE__ */ (0, import_jsx_runtime12.jsx)(
+  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(
     SEO,
     {
       type: "profile",
-      title: `${author.name}${page > 1 ? ` - \u0635\u0641\u062D\u0629 ${page}` : ""}`,
+      title: `${author.name}${page > 1 ? ` - ${pageSuffix} ${page}` : ""}`,
       description: author.description,
       image: author.image,
       canonical,
@@ -819,8 +2438,7 @@ var SeoAuthor = ({ author, page = 1, totalPage = 1, ...rest }) => {
 };
 
 // src/components/SeoHowTo.tsx
-var import_react_helmet_async8 = require("react-helmet-async");
-var import_jsx_runtime13 = require("react/jsx-runtime");
+var import_jsx_runtime14 = require("react/jsx-runtime");
 var SeoHowTo = ({ name, description, image, steps }) => {
   const schema = {
     "@context": "https://schema.org",
@@ -846,12 +2464,11 @@ var SeoHowTo = ({ name, description, image, steps }) => {
       };
     })
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime13.jsx)(import_react_helmet_async8.Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime13.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
 };
 
 // src/components/SeoReview.tsx
-var import_react_helmet_async9 = require("react-helmet-async");
-var import_jsx_runtime14 = require("react/jsx-runtime");
+var import_jsx_runtime15 = require("react/jsx-runtime");
 var SeoReview = ({ itemReviewed, review }) => {
   const schema = {
     "@context": "https://schema.org",
@@ -874,12 +2491,11 @@ var SeoReview = ({ itemReviewed, review }) => {
       "worstRating": review.worstRating || 1
     }
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime14.jsx)(import_react_helmet_async9.Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime14.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
 };
 
 // src/components/SeoCourse.tsx
-var import_react_helmet_async10 = require("react-helmet-async");
-var import_jsx_runtime15 = require("react/jsx-runtime");
+var import_jsx_runtime16 = require("react/jsx-runtime");
 var SeoCourse = ({ course }) => {
   const schema = {
     "@context": "https://schema.org",
@@ -893,12 +2509,11 @@ var SeoCourse = ({ course }) => {
     },
     "image": course.image
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime15.jsx)(import_react_helmet_async10.Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime15.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
 };
 
 // src/components/SeoRecipe.tsx
-var import_react_helmet_async11 = require("react-helmet-async");
-var import_jsx_runtime16 = require("react/jsx-runtime");
+var import_jsx_runtime17 = require("react/jsx-runtime");
 var SeoRecipe = ({ recipe }) => {
   const schema = {
     "@context": "https://schema.org",
@@ -925,12 +2540,11 @@ var SeoRecipe = ({ recipe }) => {
       "image": step.image
     }))
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime16.jsx)(import_react_helmet_async11.Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime16.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
 };
 
 // src/components/SeoJobPosting.tsx
-var import_react_helmet_async12 = require("react-helmet-async");
-var import_jsx_runtime17 = require("react/jsx-runtime");
+var import_jsx_runtime18 = require("react/jsx-runtime");
 var SeoJobPosting = ({ job }) => {
   const schema = {
     "@context": "https://schema.org",
@@ -972,11 +2586,12 @@ var SeoJobPosting = ({ job }) => {
       }
     } : void 0
   };
-  return /* @__PURE__ */ (0, import_jsx_runtime17.jsx)(import_react_helmet_async12.Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime17.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
+  return /* @__PURE__ */ (0, import_jsx_runtime18.jsx)(Helmet, { children: /* @__PURE__ */ (0, import_jsx_runtime18.jsx)("script", { type: "application/ld+json", children: JSON.stringify(schema) }) });
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Breadcrumb,
+  JsonLd,
   SEO,
   SEOProvider,
   SeoArticle,
@@ -993,11 +2608,19 @@ var SeoJobPosting = ({ job }) => {
   SeoReview,
   SeoTag,
   SeoVideo,
+  cleanSchema,
+  generateArticleMetadata,
   generateArticleSchema,
   generateBookSchema,
   generateBreadcrumbSchema,
+  generateCategoryMetadata,
+  generateCollectionPageSchema,
   generateEventSchema,
   generateFAQSchema,
+  generateHomepageMetadata,
+  generateHowToSchema,
+  generateItemListSchema,
+  generateJobPostingSchema,
   generateLocalBusinessSchema,
   generateMovieSchema,
   generateOrganizationSchema,
@@ -1005,10 +2628,14 @@ var SeoJobPosting = ({ job }) => {
   generatePaginationLinks,
   generatePodcastEpisodeSchema,
   generatePodcastSchema,
+  generateProductMetadata,
   generateProductSchema,
+  generateRecipeSchema,
   generateSoftwareSchema,
   generateVideoSchema,
+  generateWebPageSchema,
   generateWebSiteSchema,
   toNextMetadata,
-  useSEOConfig
+  useSEOConfig,
+  validateSEO
 });