@nuxtjs/sitemap 8.2.3 → 8.3.1

package/dist/runtime/types.d.ts

@@ -148,11 +148,22 @@ export interface ModuleOptions extends SitemapDefinition {
      */
     experimentalWarmUp?: boolean;
     /**
-     * Send the Sitemap as a compressed stream supporting gzip, brolti, etc.
+     * Compress sitemap responses with gzip or deflate when supported by the client.
      *
-     * @experimental Will be enabled by default in v5 (if stable)
+     * @experimental This option may change in a future release.
      */
     experimentalCompression?: boolean;
+    /**
+     * Serialize dynamic sitemap responses as a pull-driven stream instead of building
+     * the complete XML string in memory first. Prerendered sitemaps remain buffered.
+     *
+     * Accessing `ctx.sitemap` in the `sitemap:output` hook buffers that response for
+     * backwards compatibility.
+     *
+     * @default false
+     * @experimental This option may change in a future release.
+     */
+    experimentalStreaming?: boolean;
     /**
      * When enabled, sitemap generation only runs during prerendering.
      * The sitemap building code is tree-shaken from the runtime bundle.
@@ -227,7 +238,7 @@ export interface AutoI18nConfig {
     strategy: 'prefix' | 'prefix_except_default' | 'prefix_and_default' | 'no_prefix';
     pages?: Record<string, Record<string, string | false>>;
 }
-export interface ModuleRuntimeConfig extends Pick<ModuleOptions, 'sitemapsPathPrefix' | 'cacheMaxAgeSeconds' | 'sitemapName' | 'excludeAppSources' | 'sortEntries' | 'defaultSitemapsChunkSize' | 'xslColumns' | 'xslTips' | 'debug' | 'discoverImages' | 'discoverVideos' | 'autoLastmod' | 'xsl' | 'credits' | 'minify'> {
+export interface ModuleRuntimeConfig extends Pick<ModuleOptions, 'sitemapsPathPrefix' | 'cacheMaxAgeSeconds' | 'sitemapName' | 'excludeAppSources' | 'sortEntries' | 'defaultSitemapsChunkSize' | 'xslColumns' | 'xslTips' | 'debug' | 'discoverImages' | 'discoverVideos' | 'autoLastmod' | 'xsl' | 'credits' | 'minify' | 'experimentalStreaming'> {
     version: string;
     isNuxtContentDocumentDriven: boolean;
     sitemaps: {

package/dist/runtime/utils-pure.d.ts

@@ -1,8 +1,9 @@
 import type { FilterInput } from './types.js';
 export { createFilter, type CreateFilterOptions } from 'nuxtseo-shared/utils';
 export declare const logger: import("consola").ConsolaInstance;
-export declare function mergeOnKey<T, K extends keyof T>(arr: T[], key: K): T[];
-export declare function splitForLocales(path: string, locales: string[]): [string | null, string];
+export declare function xmlEscape(value: string | number | boolean | Date): string;
+export declare function mergeOnKey<T, K extends keyof T>(arr: T[], key: K, onMerge?: (key: T[K]) => void): T[];
+export declare function splitForLocales(path: string, locales: readonly string[] | Set<string>): [string | null, string];
 /**
  * Resolve which locale a multi-sitemap name belongs to.
  *
@@ -20,10 +21,10 @@ export declare function normalizeRuntimeFilters(input?: FilterInput[]): (RegExp
 export declare function createPathFilter(options?: {
     include?: (FilterInput | string | RegExp)[];
     exclude?: (FilterInput | string | RegExp)[];
-}, baseURL?: string): (loc: string) => boolean;
+}, baseURL?: string): (loc: string, pathname?: string) => boolean;
 export interface PageMatch {
     mappings: Record<string, string | false>;
     paramSegments: string[];
 }
-export declare function findPageMapping(pathWithoutPrefix: string, pages: Record<string, Record<string, string | false>>): PageMatch | null;
+export declare function findPageMapping(pathWithoutPrefix: string, pages: Record<string, Record<string, string | false>>, sortedKeys?: string[]): PageMatch | null;
 export declare function applyDynamicParams(customPath: string, paramSegments: string[]): string;

package/dist/runtime/utils-pure.js

@@ -1,39 +1,54 @@
-import { createConsola } from "consola";
 import { createDefu } from "defu";
-import { createFilter } from "nuxtseo-shared/utils";
-import { parseURL, withLeadingSlash, withoutBase } from "ufo";
+import { createFilter, createModuleLogger } from "nuxtseo-shared/utils";
+import { parseURL, withoutBase } from "ufo";
 export { createFilter } from "nuxtseo-shared/utils";
-export const logger = createConsola({
-  defaults: {
-    tag: "@nuxt/sitemap"
-  }
-});
+export const logger = createModuleLogger("@nuxt/sitemap");
+const XML_ENTITIES = {
+  "&": "&",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&apos;"
+};
+const XML_SPECIAL_CHARS_RE = /[&<>"']/g;
+const HAS_XML_SPECIAL_CHARS_RE = /[&<>"']/;
+export function xmlEscape(value) {
+  const input = String(value);
+  return HAS_XML_SPECIAL_CHARS_RE.test(input) ? input.replace(XML_SPECIAL_CHARS_RE, (char) => XML_ENTITIES[char]) : input;
+}
 const merger = createDefu((obj, key, value) => {
   if (Array.isArray(obj[key]) && Array.isArray(value))
     obj[key] = Array.from(/* @__PURE__ */ new Set([...obj[key], ...value]));
   return obj[key];
 });
-export function mergeOnKey(arr, key) {
+export function mergeOnKey(arr, key, onMerge) {
+  if (arr.length < 2)
+    return arr;
   const seen = /* @__PURE__ */ new Map();
   let resultLength = 0;
-  const result = Array.from({ length: arr.length });
   for (const item of arr) {
     const k = item[key];
     if (seen.has(k)) {
       const existingIndex = seen.get(k);
-      result[existingIndex] = merger(item, result[existingIndex]);
+      onMerge?.(item[key]);
+      arr[existingIndex] = merger(item, arr[existingIndex]);
     } else {
       seen.set(k, resultLength);
-      result[resultLength++] = item;
+      arr[resultLength++] = item;
     }
   }
-  result.length = resultLength;
-  return result;
+  arr.length = resultLength;
+  return arr;
 }
 export function splitForLocales(path, locales) {
-  const prefix = withLeadingSlash(path).split("/")[1];
-  if (prefix && locales.includes(prefix))
-    return [prefix, path.replace(`/${prefix}`, "")];
+  const start = path.charCodeAt(0) === 47 ? 1 : 0;
+  const end = path.indexOf("/", start);
+  const prefix = path.slice(start, end === -1 ? path.length : end);
+  const hasLocale = locales instanceof Set ? locales.has(prefix) : locales.includes(prefix);
+  if (prefix && hasLocale) {
+    const prefixEnd = start + prefix.length;
+    return [prefix, start === 1 ? path.slice(prefixEnd) : path];
+  }
   return [null, path];
 }
 export function resolveI18nSitemapLocaleKey(sitemapName, localeSitemapKeys) {
@@ -63,25 +78,27 @@ export function createPathFilter(options = {}, baseURL) {
     exclude: normalizeRuntimeFilters(options.exclude)
   });
   const hasBase = baseURL && baseURL !== "/";
-  return (loc) => {
-    let path = loc;
-    try {
-      path = parseURL(loc).pathname;
-    } catch {
-      return false;
+  return (loc, pathname) => {
+    let path = pathname;
+    if (typeof path !== "string") {
+      try {
+        path = parseURL(loc).pathname;
+      } catch {
+        return false;
+      }
     }
     if (hasBase)
       path = withoutBase(path, baseURL);
     return urlFilter(path);
   };
 }
-export function findPageMapping(pathWithoutPrefix, pages) {
+export function findPageMapping(pathWithoutPrefix, pages, sortedKeys) {
   const stripped = pathWithoutPrefix[0] === "/" ? pathWithoutPrefix.slice(1) : pathWithoutPrefix;
   const pageKey = stripped.endsWith("/index") ? stripped.slice(0, -6) || "index" : stripped || "index";
   if (pages[pageKey])
     return { mappings: pages[pageKey], paramSegments: [] };
-  const sortedKeys = Object.keys(pages).sort((a, b) => b.length - a.length);
-  for (const key of sortedKeys) {
+  const keys = sortedKeys || Object.keys(pages).sort((a, b) => b.length - a.length);
+  for (const key of keys) {
     if (pageKey.startsWith(`${key}/`)) {
       const paramPath = pageKey.slice(key.length + 1);
       return { mappings: pages[key], paramSegments: paramPath.split("/") };

package/dist/utils.d.mts

@@ -1,5 +1,8 @@
-import { SitemapUrl, SitemapUrlInput } from '../dist/runtime/types.js';
+import { SitemapUrl } from '../dist/runtime/types.js';
 export * from '../dist/runtime/types.js';
+export { SitemapDocumentLoadResult, SitemapDocumentLoader, SitemapLoadFailureCode, SitemapLoadRequest, SitemapLoadSource, SitemapReadOptions, SitemapReadResult, SitemapReader, SitemapReaderOptions, SitemapTargetAuthorization, SitemapTargetAuthorizer, SitemapWalkDocument, SitemapWalkDocumentVisitor, SitemapWalkFailure, SitemapWalkNonRetainedResult, SitemapWalkOptions, SitemapWalkPartialReason, SitemapWalkResult, SitemapWalkRetainedResult, createSitemapReader } from 'sitemapd';
+export { FetchDocumentLoaderOptions, SitemapFetch, createFetchDocumentLoader } from 'sitemapd/fetch';
+export { CollectSitemapResult, ParseSitemapOptions, SitemapCompleteness, SitemapDocument, SitemapDocumentKind, SitemapExtensions, SitemapFormat, SitemapInput, SitemapIssue, SitemapIssueCode, SitemapParseEvent, SitemapReference, SitemapUrlRecord, collectSitemap, parseSitemap } from 'sitemapd/parse';
 
 declare function parseHtmlExtractSitemapMeta(html: string, options?: {
     images?: boolean;
@@ -9,31 +12,4 @@ declare function parseHtmlExtractSitemapMeta(html: string, options?: {
     resolveUrl?: (s: string) => string;
 }): Partial<SitemapUrl> | null;
 
-interface SitemapWarning {
-    type: 'validation';
-    message: string;
-    context?: {
-        url?: string;
-        field?: string;
-        value?: unknown;
-    };
-}
-interface SitemapParseResult {
-    urls: SitemapUrlInput[];
-    warnings: SitemapWarning[];
-}
-declare function parseSitemapXml(xml: string): Promise<SitemapParseResult>;
-
-interface SitemapIndexEntry {
-    loc: string;
-    lastmod?: string;
-}
-interface SitemapIndexParseResult {
-    entries: SitemapIndexEntry[];
-    warnings: SitemapWarning[];
-}
-declare function parseSitemapIndex(xml: string): Promise<SitemapIndexParseResult>;
-declare function isSitemapIndex(xml: string): boolean;
-
-export { isSitemapIndex, parseHtmlExtractSitemapMeta, parseSitemapIndex, parseSitemapXml };
-export type { SitemapIndexEntry, SitemapIndexParseResult, SitemapParseResult, SitemapWarning };
+export { parseHtmlExtractSitemapMeta };

package/dist/utils.d.ts

@@ -1,5 +1,8 @@
-import { SitemapUrl, SitemapUrlInput } from '../dist/runtime/types.js';
+import { SitemapUrl } from '../dist/runtime/types.js';
 export * from '../dist/runtime/types.js';
+export { SitemapDocumentLoadResult, SitemapDocumentLoader, SitemapLoadFailureCode, SitemapLoadRequest, SitemapLoadSource, SitemapReadOptions, SitemapReadResult, SitemapReader, SitemapReaderOptions, SitemapTargetAuthorization, SitemapTargetAuthorizer, SitemapWalkDocument, SitemapWalkDocumentVisitor, SitemapWalkFailure, SitemapWalkNonRetainedResult, SitemapWalkOptions, SitemapWalkPartialReason, SitemapWalkResult, SitemapWalkRetainedResult, createSitemapReader } from 'sitemapd';
+export { FetchDocumentLoaderOptions, SitemapFetch, createFetchDocumentLoader } from 'sitemapd/fetch';
+export { CollectSitemapResult, ParseSitemapOptions, SitemapCompleteness, SitemapDocument, SitemapDocumentKind, SitemapExtensions, SitemapFormat, SitemapInput, SitemapIssue, SitemapIssueCode, SitemapParseEvent, SitemapReference, SitemapUrlRecord, collectSitemap, parseSitemap } from 'sitemapd/parse';
 
 declare function parseHtmlExtractSitemapMeta(html: string, options?: {
     images?: boolean;
@@ -9,31 +12,4 @@ declare function parseHtmlExtractSitemapMeta(html: string, options?: {
     resolveUrl?: (s: string) => string;
 }): Partial<SitemapUrl> | null;
 
-interface SitemapWarning {
-    type: 'validation';
-    message: string;
-    context?: {
-        url?: string;
-        field?: string;
-        value?: unknown;
-    };
-}
-interface SitemapParseResult {
-    urls: SitemapUrlInput[];
-    warnings: SitemapWarning[];
-}
-declare function parseSitemapXml(xml: string): Promise<SitemapParseResult>;
-
-interface SitemapIndexEntry {
-    loc: string;
-    lastmod?: string;
-}
-interface SitemapIndexParseResult {
-    entries: SitemapIndexEntry[];
-    warnings: SitemapWarning[];
-}
-declare function parseSitemapIndex(xml: string): Promise<SitemapIndexParseResult>;
-declare function isSitemapIndex(xml: string): boolean;
-
-export { isSitemapIndex, parseHtmlExtractSitemapMeta, parseSitemapIndex, parseSitemapXml };
-export type { SitemapIndexEntry, SitemapIndexParseResult, SitemapParseResult, SitemapWarning };
+export { parseHtmlExtractSitemapMeta };

package/dist/utils.mjs

@@ -1,421 +1,6 @@
 export { p as parseHtmlExtractSitemapMeta } from './shared/sitemap.BoMnWHOt.mjs';
+export { createSitemapReader } from 'sitemapd';
+export { createFetchDocumentLoader } from 'sitemapd/fetch';
+export { collectSitemap, parseSitemap } from 'sitemapd/parse';
 import 'ufo';
 import 'ultrahtml';
-
-function isValidUrl(value) {
-  return URL.canParse(value);
-}
-async function parseSitemapIndex(xml) {
-  if (!xml)
-    throw new Error("Empty XML input provided");
-  const { XMLParser } = await import('fast-xml-parser');
-  const parser = new XMLParser({
-    isArray: (tagName) => tagName === "sitemap",
-    removeNSPrefix: true,
-    trimValues: true
-  });
-  const parsed = parser.parse(xml);
-  if (parsed?.sitemapindex === void 0)
-    throw new Error("XML does not contain a valid sitemapindex element");
-  if (!parsed.sitemapindex || !parsed.sitemapindex.sitemap)
-    return { entries: [], warnings: [] };
-  const sitemaps = Array.isArray(parsed.sitemapindex.sitemap) ? parsed.sitemapindex.sitemap : [parsed.sitemapindex.sitemap];
-  const warnings = [];
-  const entries = [];
-  for (const s of sitemaps) {
-    if (typeof s.loc !== "string" || !s.loc.trim().length) {
-      warnings.push({
-        type: "validation",
-        message: "Sitemap entry missing required loc element"
-      });
-      continue;
-    }
-    const loc = s.loc.trim();
-    if (!isValidUrl(loc)) {
-      warnings.push({
-        type: "validation",
-        message: "Sitemap entry has invalid URL",
-        context: { url: loc }
-      });
-      continue;
-    }
-    entries.push({
-      loc,
-      ...s.lastmod && { lastmod: s.lastmod.trim() }
-    });
-  }
-  return { entries, warnings };
-}
-function isSitemapIndex(xml) {
-  return xml.includes("<sitemapindex") || xml.includes("sitemapindex>");
-}
-
-function isValidString(value) {
-  return typeof value === "string" && value.trim().length > 0;
-}
-function parseNumber(value) {
-  if (typeof value === "number")
-    return value;
-  if (typeof value === "string" && value.trim()) {
-    const num = Number.parseFloat(value.trim());
-    return Number.isNaN(num) ? void 0 : num;
-  }
-  return void 0;
-}
-function parseInteger(value) {
-  if (typeof value === "number")
-    return Math.floor(value);
-  if (typeof value === "string" && value.trim()) {
-    const num = Number.parseInt(value.trim(), 10);
-    return Number.isNaN(num) ? void 0 : num;
-  }
-  return void 0;
-}
-function extractUrlFromParsedElement(urlElement, warnings) {
-  if (!isValidString(urlElement.loc)) {
-    warnings.push({
-      type: "validation",
-      message: "URL entry missing required loc element",
-      context: { url: String(urlElement.loc || "undefined") }
-    });
-    return null;
-  }
-  const urlObj = { loc: urlElement.loc };
-  if (isValidString(urlElement.lastmod)) {
-    urlObj.lastmod = urlElement.lastmod;
-  }
-  if (isValidString(urlElement.changefreq)) {
-    const validFreqs = ["always", "hourly", "daily", "weekly", "monthly", "yearly", "never"];
-    if (validFreqs.includes(urlElement.changefreq)) {
-      urlObj.changefreq = urlElement.changefreq;
-    } else {
-      warnings.push({
-        type: "validation",
-        message: "Invalid changefreq value",
-        context: { url: urlElement.loc, field: "changefreq", value: urlElement.changefreq }
-      });
-    }
-  }
-  const priority = parseNumber(urlElement.priority);
-  if (priority !== void 0 && !Number.isNaN(priority)) {
-    if (priority < 0 || priority > 1) {
-      warnings.push({
-        type: "validation",
-        message: "Priority value should be between 0.0 and 1.0, clamping to valid range",
-        context: { url: urlElement.loc, field: "priority", value: priority }
-      });
-    }
-    urlObj.priority = Math.max(0, Math.min(1, priority));
-  } else if (urlElement.priority !== void 0) {
-    warnings.push({
-      type: "validation",
-      message: "Invalid priority value",
-      context: { url: urlElement.loc, field: "priority", value: urlElement.priority }
-    });
-  }
-  if (urlElement.image) {
-    const images = Array.isArray(urlElement.image) ? urlElement.image : [urlElement.image];
-    const validImages = images.map((img) => {
-      if (isValidString(img.loc)) {
-        return { loc: img.loc };
-      } else {
-        warnings.push({
-          type: "validation",
-          message: "Image missing required loc element",
-          context: { url: urlElement.loc, field: "image.loc" }
-        });
-        return null;
-      }
-    }).filter((img) => img !== null);
-    if (validImages.length > 0) {
-      urlObj.images = validImages;
-    }
-  }
-  if (urlElement.video) {
-    const videos = Array.isArray(urlElement.video) ? urlElement.video : [urlElement.video];
-    const validVideos = videos.map((video) => {
-      const missingFields = [];
-      if (!isValidString(video.title))
-        missingFields.push("title");
-      if (!isValidString(video.thumbnail_loc))
-        missingFields.push("thumbnail_loc");
-      if (!isValidString(video.description))
-        missingFields.push("description");
-      if (!isValidString(video.content_loc))
-        missingFields.push("content_loc");
-      if (missingFields.length > 0) {
-        warnings.push({
-          type: "validation",
-          message: `Video missing required fields: ${missingFields.join(", ")}`,
-          context: { url: urlElement.loc, field: "video" }
-        });
-        return null;
-      }
-      const videoObj = {
-        title: video.title,
-        thumbnail_loc: video.thumbnail_loc,
-        description: video.description,
-        content_loc: video.content_loc
-      };
-      if (isValidString(video.player_loc)) {
-        videoObj.player_loc = video.player_loc;
-      }
-      const duration = parseInteger(video.duration);
-      if (duration !== void 0) {
-        videoObj.duration = duration;
-      } else if (video.duration !== void 0) {
-        warnings.push({
-          type: "validation",
-          message: "Invalid video duration value",
-          context: { url: urlElement.loc, field: "video.duration", value: video.duration }
-        });
-      }
-      if (isValidString(video.expiration_date)) {
-        videoObj.expiration_date = video.expiration_date;
-      }
-      const rating = parseNumber(video.rating);
-      if (rating !== void 0) {
-        if (rating < 0 || rating > 5) {
-          warnings.push({
-            type: "validation",
-            message: "Video rating should be between 0.0 and 5.0",
-            context: { url: urlElement.loc, field: "video.rating", value: rating }
-          });
-        }
-        videoObj.rating = rating;
-      } else if (video.rating !== void 0) {
-        warnings.push({
-          type: "validation",
-          message: "Invalid video rating value",
-          context: { url: urlElement.loc, field: "video.rating", value: video.rating }
-        });
-      }
-      const viewCount = parseInteger(video.view_count);
-      if (viewCount !== void 0) {
-        videoObj.view_count = viewCount;
-      } else if (video.view_count !== void 0) {
-        warnings.push({
-          type: "validation",
-          message: "Invalid video view_count value",
-          context: { url: urlElement.loc, field: "video.view_count", value: video.view_count }
-        });
-      }
-      if (isValidString(video.publication_date)) {
-        videoObj.publication_date = video.publication_date;
-      }
-      if (isValidString(video.family_friendly)) {
-        const validValues = ["yes", "no"];
-        if (validValues.includes(video.family_friendly)) {
-          videoObj.family_friendly = video.family_friendly;
-        } else {
-          warnings.push({
-            type: "validation",
-            message: 'Invalid video family_friendly value, should be "yes" or "no"',
-            context: { url: urlElement.loc, field: "video.family_friendly", value: video.family_friendly }
-          });
-        }
-      }
-      if (isValidString(video.requires_subscription)) {
-        const validValues = ["yes", "no"];
-        if (validValues.includes(video.requires_subscription)) {
-          videoObj.requires_subscription = video.requires_subscription;
-        } else {
-          warnings.push({
-            type: "validation",
-            message: 'Invalid video requires_subscription value, should be "yes" or "no"',
-            context: { url: urlElement.loc, field: "video.requires_subscription", value: video.requires_subscription }
-          });
-        }
-      }
-      if (isValidString(video.live)) {
-        const validValues = ["yes", "no"];
-        if (validValues.includes(video.live)) {
-          videoObj.live = video.live;
-        } else {
-          warnings.push({
-            type: "validation",
-            message: 'Invalid video live value, should be "yes" or "no"',
-            context: { url: urlElement.loc, field: "video.live", value: video.live }
-          });
-        }
-      }
-      if (video.restriction && typeof video.restriction === "object") {
-        const restriction = video.restriction;
-        if (isValidString(restriction.relationship) && isValidString(restriction["#text"])) {
-          const validRelationships = ["allow", "deny"];
-          if (validRelationships.includes(restriction.relationship)) {
-            videoObj.restriction = {
-              relationship: restriction.relationship,
-              restriction: restriction["#text"]
-            };
-          } else {
-            warnings.push({
-              type: "validation",
-              message: 'Invalid video restriction relationship, should be "allow" or "deny"',
-              context: { url: urlElement.loc, field: "video.restriction.relationship", value: restriction.relationship }
-            });
-          }
-        }
-      }
-      if (video.platform && typeof video.platform === "object") {
-        const platform = video.platform;
-        if (isValidString(platform.relationship) && isValidString(platform["#text"])) {
-          const validRelationships = ["allow", "deny"];
-          if (validRelationships.includes(platform.relationship)) {
-            videoObj.platform = {
-              relationship: platform.relationship,
-              platform: platform["#text"]
-            };
-          } else {
-            warnings.push({
-              type: "validation",
-              message: 'Invalid video platform relationship, should be "allow" or "deny"',
-              context: { url: urlElement.loc, field: "video.platform.relationship", value: platform.relationship }
-            });
-          }
-        }
-      }
-      if (video.price) {
-        const prices = Array.isArray(video.price) ? video.price : [video.price];
-        const validPrices = prices.map((price) => {
-          const priceValue = price["#text"];
-          if (priceValue == null || typeof priceValue !== "string" && typeof priceValue !== "number") {
-            warnings.push({
-              type: "validation",
-              message: "Video price missing value",
-              context: { url: urlElement.loc, field: "video.price" }
-            });
-            return null;
-          }
-          const validTypes = ["rent", "purchase", "package", "subscription"];
-          if (price.type && !validTypes.includes(price.type)) {
-            warnings.push({
-              type: "validation",
-              message: `Invalid video price type "${price.type}", should be one of: ${validTypes.join(", ")}`,
-              context: { url: urlElement.loc, field: "video.price.type", value: price.type }
-            });
-          }
-          return {
-            price: String(priceValue),
-            currency: price.currency,
-            type: price.type
-          };
-        }).filter((p) => p !== null);
-        if (validPrices.length > 0) {
-          videoObj.price = validPrices;
-        }
-      }
-      if (video.uploader && typeof video.uploader === "object") {
-        const uploader = video.uploader;
-        if (isValidString(uploader.info) && isValidString(uploader["#text"])) {
-          videoObj.uploader = {
-            uploader: uploader["#text"],
-            info: uploader.info
-          };
-        } else {
-          warnings.push({
-            type: "validation",
-            message: "Video uploader missing required info or name",
-            context: { url: urlElement.loc, field: "video.uploader" }
-          });
-        }
-      }
-      if (video.tag) {
-        const tags = Array.isArray(video.tag) ? video.tag : [video.tag];
-        const validTags = tags.filter(isValidString);
-        if (validTags.length > 0) {
-          videoObj.tag = validTags;
-        }
-      }
-      return videoObj;
-    }).filter((video) => video !== null);
-    if (validVideos.length > 0) {
-      urlObj.videos = validVideos;
-    }
-  }
-  if (urlElement.link) {
-    const links = Array.isArray(urlElement.link) ? urlElement.link : [urlElement.link];
-    const alternatives = links.map((link) => {
-      if (link.rel === "alternate" && isValidString(link.hreflang) && isValidString(link.href)) {
-        return {
-          hreflang: link.hreflang,
-          href: link.href
-        };
-      } else {
-        warnings.push({
-          type: "validation",
-          message: 'Alternative link missing required rel="alternate", hreflang, or href',
-          context: { url: urlElement.loc, field: "link" }
-        });
-        return null;
-      }
-    }).filter((alt) => alt !== null);
-    if (alternatives.length > 0) {
-      urlObj.alternatives = alternatives;
-    }
-  }
-  if (urlElement.news && typeof urlElement.news === "object") {
-    const news = urlElement.news;
-    if (isValidString(news.title) && isValidString(news.publication_date) && news.publication && isValidString(news.publication.name) && isValidString(news.publication.language)) {
-      urlObj.news = {
-        title: news.title,
-        publication_date: news.publication_date,
-        publication: {
-          name: news.publication.name,
-          language: news.publication.language
-        }
-      };
-    } else {
-      warnings.push({
-        type: "validation",
-        message: "News entry missing required fields (title, publication_date, publication.name, publication.language)",
-        context: { url: urlElement.loc, field: "news" }
-      });
-    }
-  }
-  return Object.fromEntries(
-    Object.entries(urlObj).filter(
-      ([_, value]) => value != null && (!Array.isArray(value) || value.length > 0)
-    )
-  );
-}
-async function parseSitemapXml(xml) {
-  const warnings = [];
-  if (!xml) {
-    throw new Error("Empty XML input provided");
-  }
-  const { XMLParser } = await import('fast-xml-parser');
-  const parser = new XMLParser({
-    isArray: (tagName) => ["url", "image", "video", "link", "tag", "price"].includes(tagName),
-    removeNSPrefix: true,
-    parseAttributeValue: false,
-    ignoreAttributes: false,
-    attributeNamePrefix: "",
-    trimValues: true
-  });
-  try {
-    const parsed = parser.parse(xml);
-    if (!parsed?.urlset) {
-      throw new Error("XML does not contain a valid urlset element");
-    }
-    if (!parsed.urlset.url) {
-      throw new Error("Sitemap contains no URL entries");
-    }
-    const urls = Array.isArray(parsed.urlset.url) ? parsed.urlset.url : [parsed.urlset.url];
-    const validUrls = urls.map((url) => extractUrlFromParsedElement(url, warnings)).filter((url) => url !== null);
-    if (validUrls.length === 0 && urls.length > 0) {
-      warnings.push({
-        type: "validation",
-        message: "No valid URLs found in sitemap after validation"
-      });
-    }
-    return { urls: validUrls, warnings };
-  } catch (error) {
-    if (error instanceof Error && (error.message === "Empty XML input provided" || error.message === "XML does not contain a valid urlset element" || error.message === "Sitemap contains no URL entries")) {
-      throw error;
-    }
-    throw new Error(`Failed to parse XML: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}
-
-export { isSitemapIndex, parseSitemapIndex, parseSitemapXml };