@nuxtjs/sitemap 7.2.10 → 7.3.0

package/dist/runtime/server/sitemap/builder/sitemap-index.js

@@ -1,11 +1,33 @@
 import { defu } from "defu";
 import { joinURL } from "ufo";
+import { defineCachedFunction } from "nitropack/runtime";
+import { getHeader } from "h3";
 import { normaliseDate } from "../urlset/normalise.js";
-import { globalSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
-import { sortSitemapUrls } from "../urlset/sort.js";
-import { escapeValueForXml, wrapSitemapXml } from "./xml.js";
+import { globalSitemapSources, childSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
+import { sortInPlace } from "../urlset/sort.js";
+import { escapeValueForXml } from "./xml.js";
 import { resolveSitemapEntries } from "./sitemap.js";
-export async function buildSitemapIndex(resolvers, runtimeConfig, nitro) {
+const buildSitemapIndexCached = defineCachedFunction(
+  async (event, resolvers, runtimeConfig, nitro) => {
+    return buildSitemapIndexInternal(resolvers, runtimeConfig, nitro);
+  },
+  {
+    name: "sitemap:index",
+    group: "sitemap",
+    maxAge: 60 * 10,
+    // 10 minutes default
+    base: "sitemap",
+    // Use the sitemap storage
+    getKey: (event) => {
+      const host = getHeader(event, "host") || getHeader(event, "x-forwarded-host") || "";
+      const proto = getHeader(event, "x-forwarded-proto") || "https";
+      return `sitemap-index-${proto}-${host}`;
+    },
+    swr: true
+    // Enable stale-while-revalidate
+  }
+);
+async function buildSitemapIndexInternal(resolvers, runtimeConfig, nitro) {
   const {
     sitemaps,
     // enhancing
@@ -20,13 +42,32 @@ export async function buildSitemapIndex(resolvers, runtimeConfig, nitro) {
   if (!sitemaps)
     throw new Error("Attempting to build a sitemap index without required `sitemaps` configuration.");
   function maybeSort(urls) {
-    return sortEntries ? sortSitemapUrls(urls) : urls;
+    return sortEntries ? sortInPlace(urls) : urls;
   }
-  const isChunking = typeof sitemaps.chunks !== "undefined";
   const chunks = {};
-  if (isChunking) {
+  for (const sitemapName in sitemaps) {
+    if (sitemapName === "index" || sitemapName === "chunks") continue;
+    const sitemapConfig = sitemaps[sitemapName];
+    if (sitemapConfig.chunks || sitemapConfig._isChunking) {
+      sitemapConfig._isChunking = true;
+      sitemapConfig._chunkSize = typeof sitemapConfig.chunks === "number" ? sitemapConfig.chunks : sitemapConfig.chunkSize || defaultSitemapsChunkSize || 1e3;
+    } else {
+      chunks[sitemapName] = chunks[sitemapName] || { urls: [] };
+    }
+  }
+  if (typeof sitemaps.chunks !== "undefined") {
     const sitemap = sitemaps.chunks;
-    const sources = await resolveSitemapSources(await globalSitemapSources());
+    let sourcesInput = await globalSitemapSources();
+    if (nitro && resolvers.event) {
+      const ctx = {
+        event: resolvers.event,
+        sitemapName: sitemap.sitemapName,
+        sources: sourcesInput
+      };
+      await nitro.hooks.callHook("sitemap:sources", ctx);
+      sourcesInput = ctx.sources;
+    }
+    const sources = await resolveSitemapSources(sourcesInput, resolvers.event);
     const resolvedCtx = {
       urls: sources.flatMap((s) => s.urls),
       sitemapName: sitemap.sitemapName,
@@ -41,12 +82,6 @@ export async function buildSitemapIndex(resolvers, runtimeConfig, nitro) {
       chunks[chunkIndex] = chunks[chunkIndex] || { urls: [] };
       chunks[chunkIndex].urls.push(url);
     });
-  } else {
-    for (const sitemap in sitemaps) {
-      if (sitemap !== "index") {
-        chunks[sitemap] = chunks[sitemap] || { urls: [] };
-      }
-    }
   }
   const entries = [];
   for (const name in chunks) {
@@ -62,6 +97,48 @@ export async function buildSitemapIndex(resolvers, runtimeConfig, nitro) {
       entry.lastmod = normaliseDate(lastmod);
     entries.push(entry);
   }
+  for (const sitemapName in sitemaps) {
+    if (sitemapName !== "index" && sitemaps[sitemapName]._isChunking) {
+      const sitemapConfig = sitemaps[sitemapName];
+      const chunkSize = sitemapConfig._chunkSize || defaultSitemapsChunkSize || 1e3;
+      let sourcesInput = sitemapConfig.includeAppSources ? await globalSitemapSources() : [];
+      sourcesInput.push(...await childSitemapSources(sitemapConfig));
+      if (nitro && resolvers.event) {
+        const ctx = {
+          event: resolvers.event,
+          sitemapName: sitemapConfig.sitemapName,
+          sources: sourcesInput
+        };
+        await nitro.hooks.callHook("sitemap:sources", ctx);
+        sourcesInput = ctx.sources;
+      }
+      const sources = await resolveSitemapSources(sourcesInput, resolvers.event);
+      const resolvedCtx = {
+        urls: sources.flatMap((s) => s.urls),
+        sitemapName: sitemapConfig.sitemapName,
+        event: resolvers.event
+      };
+      await nitro?.hooks.callHook("sitemap:input", resolvedCtx);
+      const normalisedUrls = resolveSitemapEntries(sitemapConfig, resolvedCtx.urls, { autoI18n, isI18nMapped }, resolvers);
+      const totalUrls = normalisedUrls.length;
+      const chunkCount = Math.ceil(totalUrls / chunkSize);
+      sitemapConfig._chunkCount = chunkCount;
+      for (let i = 0; i < chunkCount; i++) {
+        const chunkName = `${sitemapName}-${i}`;
+        const entry = {
+          _sitemapName: chunkName,
+          sitemap: resolvers.canonicalUrlResolver(joinURL(sitemapsPathPrefix || "", `/${chunkName}.xml`))
+        };
+        const chunkUrls = normalisedUrls.slice(i * chunkSize, (i + 1) * chunkSize);
+        let lastmod = chunkUrls.filter((a) => !!a?.lastmod).map((a) => typeof a.lastmod === "string" ? new Date(a.lastmod) : a.lastmod).sort((a, b) => (b?.getTime() || 0) - (a?.getTime() || 0))?.[0];
+        if (!lastmod && autoLastmod)
+          lastmod = /* @__PURE__ */ new Date();
+        if (lastmod)
+          entry.lastmod = normaliseDate(lastmod);
+        entries.push(entry);
+      }
+    }
+  }
   if (sitemaps.index) {
     entries.push(...sitemaps.index.sitemaps.map((entry) => {
       return typeof entry === "string" ? { sitemap: entry } : entry;
@@ -77,9 +154,26 @@ export function urlsToIndexXml(sitemaps, resolvers, { version, xsl, credits, min
     e.lastmod ? `        <lastmod>${escapeValueForXml(e.lastmod)}</lastmod>` : false,
     "    </sitemap>"
   ].filter(Boolean).join("\n")).join("\n");
-  return wrapSitemapXml([
+  const xmlParts = [
+    '<?xml version="1.0" encoding="UTF-8"?>'
+  ];
+  if (xsl) {
+    const relativeBaseUrl = resolvers.relativeBaseUrlResolver?.(xsl) ?? xsl;
+    xmlParts.push(`<?xml-stylesheet type="text/xsl" href="${escapeValueForXml(relativeBaseUrl)}"?>`);
+  }
+  xmlParts.push(
     '<sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
     sitemapXml,
     "</sitemapindex>"
-  ], resolvers, { version, xsl, credits, minify });
+  );
+  if (credits) {
+    xmlParts.push(`<!-- XML Sitemap Index generated by @nuxtjs/sitemap v${version} at ${(/* @__PURE__ */ new Date()).toISOString()} -->`);
+  }
+  return minify ? xmlParts.join("").replace(/(?<!<[^>]*)\s(?![^<]*>)/g, "") : xmlParts.join("\n");
+}
+export async function buildSitemapIndex(resolvers, runtimeConfig, nitro) {
+  if (!import.meta.dev && !!runtimeConfig.cacheMaxAgeSeconds && runtimeConfig.cacheMaxAgeSeconds > 0 && resolvers.event) {
+    return buildSitemapIndexCached(resolvers.event, resolvers, runtimeConfig, nitro);
+  }
+  return buildSitemapIndexInternal(resolvers, runtimeConfig, nitro);
 }

package/dist/runtime/server/sitemap/builder/sitemap.d.ts

@@ -7,4 +7,4 @@ export interface NormalizedI18n extends ResolvedSitemapUrl {
 }
 export declare function resolveSitemapEntries(sitemap: SitemapDefinition, urls: SitemapUrlInput[], runtimeConfig: Pick<ModuleRuntimeConfig, 'autoI18n' | 'isI18nMapped'>, resolvers?: NitroUrlResolvers): ResolvedSitemapUrl[];
 export declare function buildSitemapUrls(sitemap: SitemapDefinition, resolvers: NitroUrlResolvers, runtimeConfig: ModuleRuntimeConfig, nitro?: NitroApp): Promise<ResolvedSitemapUrl[]>;
-export declare function urlsToXml(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>): string;
+export { urlsToXml } from './xml.js';

package/dist/runtime/server/sitemap/builder/sitemap.js

@@ -2,9 +2,9 @@ import { resolveSitePath } from "nuxt-site-config/urls";
 import { joinURL, withHttps } from "ufo";
 import { preNormalizeEntry } from "../urlset/normalise.js";
 import { childSitemapSources, globalSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
-import { sortSitemapUrls } from "../urlset/sort.js";
+import { sortInPlace } from "../urlset/sort.js";
 import { createPathFilter, logger, splitForLocales } from "../../../utils-pure.js";
-import { handleEntry, wrapSitemapXml } from "./xml.js";
+import { parseChunkInfo, sliceUrlsForChunk } from "../utils/chunk.js";
 export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
   const {
     autoI18n,
@@ -85,9 +85,23 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
           });
         } else {
           for (const l of autoI18n.locales) {
-            let loc = joinURL(`/${l.code}`, e._pathWithoutPrefix);
-            if (autoI18n.differentDomains || ["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy) && l.code === autoI18n.defaultLocale)
-              loc = e._pathWithoutPrefix;
+            let loc = e._pathWithoutPrefix;
+            if (autoI18n.pages) {
+              const pageKey = e._pathWithoutPrefix.replace(/^\//, "").replace(/\/index$/, "") || "index";
+              const pageMappings = autoI18n.pages[pageKey];
+              if (pageMappings && pageMappings[l.code] !== void 0) {
+                const customPath = pageMappings[l.code];
+                if (customPath === false)
+                  continue;
+                if (typeof customPath === "string")
+                  loc = customPath.startsWith("/") ? customPath : `/${customPath}`;
+              } else if (!autoI18n.differentDomains && !(["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy) && l.code === autoI18n.defaultLocale)) {
+                loc = joinURL(`/${l.code}`, e._pathWithoutPrefix);
+              }
+            } else {
+              if (!autoI18n.differentDomains && !(["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy) && l.code === autoI18n.defaultLocale))
+                loc = joinURL(`/${l.code}`, e._pathWithoutPrefix);
+            }
             const _sitemap = isI18nMapped ? l._sitemap : void 0;
             const newEntry = preNormalizeEntry({
               _sitemap,
@@ -99,14 +113,30 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
               alternatives: [{ code: "x-default", _hreflang: "x-default" }, ...autoI18n.locales].map((locale) => {
                 const code = locale.code === "x-default" ? autoI18n.defaultLocale : locale.code;
                 const isDefault = locale.code === "x-default" || locale.code === autoI18n.defaultLocale;
-                let href = "";
-                if (autoI18n.strategy === "prefix") {
-                  href = joinURL("/", code, e._pathWithoutPrefix);
-                } else if (["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy)) {
-                  if (isDefault) {
-                    href = e._pathWithoutPrefix;
-                  } else {
+                let href = e._pathWithoutPrefix;
+                if (autoI18n.pages) {
+                  const pageKey = e._pathWithoutPrefix.replace(/^\//, "").replace(/\/index$/, "") || "index";
+                  const pageMappings = autoI18n.pages[pageKey];
+                  if (pageMappings && pageMappings[code] !== void 0) {
+                    const customPath = pageMappings[code];
+                    if (customPath === false)
+                      return false;
+                    if (typeof customPath === "string")
+                      href = customPath.startsWith("/") ? customPath : `/${customPath}`;
+                  } else if (autoI18n.strategy === "prefix") {
                     href = joinURL("/", code, e._pathWithoutPrefix);
+                  } else if (["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy)) {
+                    if (!isDefault) {
+                      href = joinURL("/", code, e._pathWithoutPrefix);
+                    }
+                  }
+                } else {
+                  if (autoI18n.strategy === "prefix") {
+                    href = joinURL("/", code, e._pathWithoutPrefix);
+                  } else if (["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy)) {
+                    if (!isDefault) {
+                      href = joinURL("/", code, e._pathWithoutPrefix);
+                    }
                   }
                 }
                 if (!filterPath(href))
@@ -151,16 +181,12 @@ export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro)
     // chunking
     defaultSitemapsChunkSize
   } = runtimeConfig;
-  const isChunking = typeof sitemaps.chunks !== "undefined" && !Number.isNaN(Number(sitemap.sitemapName));
+  const chunkInfo = parseChunkInfo(sitemap.sitemapName, sitemaps, defaultSitemapsChunkSize);
   function maybeSort(urls) {
-    return sortEntries ? sortSitemapUrls(urls) : urls;
+    return sortEntries ? sortInPlace(urls) : urls;
   }
   function maybeSlice(urls) {
-    if (isChunking && defaultSitemapsChunkSize) {
-      const chunk = Number(sitemap.sitemapName);
-      return urls.slice(chunk * defaultSitemapsChunkSize, (chunk + 1) * defaultSitemapsChunkSize);
-    }
-    return urls;
+    return sliceUrlsForChunk(urls, sitemap.sitemapName, sitemaps, defaultSitemapsChunkSize);
   }
   if (autoI18n?.differentDomains) {
     const domain = autoI18n.locales.find((e) => [e.language, e.code].includes(sitemap.sitemapName))?.domain;
@@ -175,8 +201,22 @@ export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro)
       });
     }
   }
-  const sourcesInput = sitemap.includeAppSources ? await globalSitemapSources() : [];
-  sourcesInput.push(...await childSitemapSources(sitemap));
+  let effectiveSitemap = sitemap;
+  const baseSitemapName = chunkInfo.baseSitemapName;
+  if (chunkInfo.isChunked && baseSitemapName !== sitemap.sitemapName && sitemaps[baseSitemapName]) {
+    effectiveSitemap = sitemaps[baseSitemapName];
+  }
+  let sourcesInput = effectiveSitemap.includeAppSources ? await globalSitemapSources() : [];
+  sourcesInput.push(...await childSitemapSources(effectiveSitemap));
+  if (nitro && resolvers.event) {
+    const ctx = {
+      event: resolvers.event,
+      sitemapName: baseSitemapName,
+      sources: sourcesInput
+    };
+    await nitro.hooks.callHook("sitemap:sources", ctx);
+    sourcesInput = ctx.sources;
+  }
   const sources = await resolveSitemapSources(sourcesInput, resolvers.event);
   const resolvedCtx = {
     urls: sources.flatMap((s) => s.urls),
@@ -193,18 +233,4 @@ export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro)
   const sortedUrls = maybeSort(filteredUrls);
   return maybeSlice(sortedUrls);
 }
-export function urlsToXml(urls, resolvers, { version, xsl, credits, minify }) {
-  const urlset = urls.map((e) => {
-    const keys = Object.keys(e).filter((k) => !k.startsWith("_"));
-    return [
-      "    <url>",
-      keys.map((k) => handleEntry(k, e)).filter(Boolean).join("\n"),
-      "    </url>"
-    ].join("\n");
-  });
-  return wrapSitemapXml([
-    '<urlset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:video="http://www.google.com/schemas/sitemap-video/1.1" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1" xmlns:news="http://www.google.com/schemas/sitemap-news/0.9" xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd http://www.google.com/schemas/sitemap-image/1.1 http://www.google.com/schemas/sitemap-image/1.1/sitemap-image.xsd" xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">',
-    urlset.join("\n"),
-    "</urlset>"
-  ], resolvers, { version, xsl, credits, minify });
-}
+export { urlsToXml } from "./xml.js";

package/dist/runtime/server/sitemap/builder/xml.d.ts

@@ -1,4 +1,3 @@
-import type { ModuleRuntimeConfig, NitroUrlResolvers } from '../../../types.js';
-export declare function handleEntry(k: string, e: Record<string, any> | (string | Record<string, any>)[]): string | false;
-export declare function wrapSitemapXml(input: string[], resolvers: NitroUrlResolvers, options: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>): string;
+import type { ModuleRuntimeConfig, NitroUrlResolvers, ResolvedSitemapUrl } from '../../../types.js';
 export declare function escapeValueForXml(value: boolean | string | number): string;
+export declare function urlsToXml(urls: ResolvedSitemapUrl[], resolvers: NitroUrlResolvers, { version, xsl, credits, minify }: Pick<ModuleRuntimeConfig, 'version' | 'xsl' | 'credits' | 'minify'>): string;

package/dist/runtime/server/sitemap/builder/xml.js

@@ -1,86 +1,188 @@
-function resolveKey(k) {
-  switch (k) {
-    case "images":
-      return "image";
-    case "videos":
-      return "video";
-    // news & others?
-    case "news":
-      return "news";
-    default:
-      return k;
-  }
+export function escapeValueForXml(value) {
+  if (value === true || value === false)
+    return value ? "yes" : "no";
+  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
-function handleObject(key, obj) {
-  return [
-    `        <${key}:${key}>`,
-    ...Object.entries(obj).map(([sk, sv]) => {
-      if (key === "video" && Array.isArray(sv)) {
-        return sv.map((v) => {
-          if (typeof v === "string") {
-            return [
-              `            `,
-              `<${key}:${sk}>`,
-              escapeValueForXml(v),
-              `</${key}:${sk}>`
-            ].join("");
+const URLSET_OPENING_TAG = '<urlset xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:video="http://www.google.com/schemas/sitemap-video/1.1" xmlns:xhtml="http://www.w3.org/1999/xhtml" xmlns:image="http://www.google.com/schemas/sitemap-image/1.1" xmlns:news="http://www.google.com/schemas/sitemap-news/0.9" xsi:schemaLocation="http://www.sitemaps.org/schemas/sitemap/0.9 http://www.sitemaps.org/schemas/sitemap/0.9/sitemap.xsd http://www.google.com/schemas/sitemap-image/1.1 http://www.google.com/schemas/sitemap-image/1.1/sitemap-image.xsd" xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">';
+function buildUrlXml(url) {
+  const capacity = 50;
+  const parts = Array.from({ length: capacity });
+  let partIndex = 0;
+  parts[partIndex++] = "    <url>";
+  if (url.loc) {
+    parts[partIndex++] = `        <loc>${escapeValueForXml(url.loc)}</loc>`;
+  }
+  if (url.lastmod) {
+    parts[partIndex++] = `        <lastmod>${url.lastmod}</lastmod>`;
+  }
+  if (url.changefreq) {
+    parts[partIndex++] = `        <changefreq>${url.changefreq}</changefreq>`;
+  }
+  if (url.priority !== void 0) {
+    const priorityValue = Number.parseFloat(String(url.priority));
+    const formattedPriority = priorityValue % 1 === 0 ? String(priorityValue) : priorityValue.toFixed(1);
+    parts[partIndex++] = `        <priority>${formattedPriority}</priority>`;
+  }
+  const keys = Object.keys(url).filter((k) => !k.startsWith("_") && !["loc", "lastmod", "changefreq", "priority"].includes(k));
+  for (const key of keys) {
+    const value = url[key];
+    if (value === void 0 || value === null) continue;
+    switch (key) {
+      case "alternatives":
+        if (Array.isArray(value) && value.length > 0) {
+          for (const alt of value) {
+            const attrs = Object.entries(alt).map(([k, v]) => `${k}="${escapeValueForXml(v)}"`).join(" ");
+            parts[partIndex++] = `        <xhtml:link rel="alternate" ${attrs} />`;
           }
-          const attributes = Object.entries(v).filter(([ssk]) => ssk !== sk).map(([ssk, ssv]) => `${ssk}="${escapeValueForXml(ssv)}"`).join(" ");
-          return [
-            `            <${key}:${sk} ${attributes}>`,
-            // value is the same sk
-            v[sk],
-            `</${key}:${sk}>`
-          ].join("");
-        }).join("\n");
-      }
-      if (typeof sv === "object") {
-        if (key === "video") {
-          const attributes = Object.entries(sv).filter(([ssk]) => ssk !== sk).map(([ssk, ssv]) => `${ssk}="${escapeValueForXml(ssv)}"`).join(" ");
-          return [
-            `            <${key}:${sk} ${attributes}>`,
-            // value is the same sk
-            sv[sk],
-            `</${key}:${sk}>`
-          ].join("");
         }
-        return [
-          `            <${key}:${sk}>`,
-          ...Object.entries(sv).map(([ssk, ssv]) => `                <${key}:${ssk}>${escapeValueForXml(ssv)}</${key}:${ssk}>`),
-          `            </${key}:${sk}>`
-        ].join("\n");
-      }
-      return `            <${key}:${sk}>${escapeValueForXml(sv)}</${key}:${sk}>`;
-    }),
-    `        </${key}:${key}>`
-  ].join("\n");
-}
-function handleArray(key, arr) {
-  if (arr.length === 0)
-    return false;
-  key = resolveKey(key);
-  if (key === "alternatives") {
-    return arr.map((obj) => [
-      `        <xhtml:link rel="alternate" ${Object.entries(obj).map(([sk, sv]) => `${sk}="${escapeValueForXml(sv)}"`).join(" ")} />`
-    ].join("\n")).join("\n");
+        break;
+      case "images":
+        if (Array.isArray(value) && value.length > 0) {
+          for (const img of value) {
+            parts[partIndex++] = "        <image:image>";
+            parts[partIndex++] = `            <image:loc>${escapeValueForXml(img.loc)}</image:loc>`;
+            if (img.title) parts[partIndex++] = `            <image:title>${escapeValueForXml(img.title)}</image:title>`;
+            if (img.caption) parts[partIndex++] = `            <image:caption>${escapeValueForXml(img.caption)}</image:caption>`;
+            if (img.geo_location) parts[partIndex++] = `            <image:geo_location>${escapeValueForXml(img.geo_location)}</image:geo_location>`;
+            if (img.license) parts[partIndex++] = `            <image:license>${escapeValueForXml(img.license)}</image:license>`;
+            parts[partIndex++] = "        </image:image>";
+          }
+        }
+        break;
+      case "videos":
+        if (Array.isArray(value) && value.length > 0) {
+          for (const video of value) {
+            parts[partIndex++] = "        <video:video>";
+            parts[partIndex++] = `            <video:title>${escapeValueForXml(video.title)}</video:title>`;
+            if (video.thumbnail_loc) {
+              parts[partIndex++] = `            <video:thumbnail_loc>${escapeValueForXml(video.thumbnail_loc)}</video:thumbnail_loc>`;
+            }
+            parts[partIndex++] = `            <video:description>${escapeValueForXml(video.description)}</video:description>`;
+            if (video.content_loc) {
+              parts[partIndex++] = `            <video:content_loc>${escapeValueForXml(video.content_loc)}</video:content_loc>`;
+            }
+            if (video.player_loc) {
+              const attrs = video.player_loc.allow_embed ? ' allow_embed="yes"' : "";
+              const autoplay = video.player_loc.autoplay ? ' autoplay="yes"' : "";
+              parts[partIndex++] = `            <video:player_loc${attrs}${autoplay}>${escapeValueForXml(video.player_loc)}</video:player_loc>`;
+            }
+            if (video.duration !== void 0) {
+              parts[partIndex++] = `            <video:duration>${video.duration}</video:duration>`;
+            }
+            if (video.expiration_date) {
+              parts[partIndex++] = `            <video:expiration_date>${video.expiration_date}</video:expiration_date>`;
+            }
+            if (video.rating !== void 0) {
+              parts[partIndex++] = `            <video:rating>${video.rating}</video:rating>`;
+            }
+            if (video.view_count !== void 0) {
+              parts[partIndex++] = `            <video:view_count>${video.view_count}</video:view_count>`;
+            }
+            if (video.publication_date) {
+              parts[partIndex++] = `            <video:publication_date>${video.publication_date}</video:publication_date>`;
+            }
+            if (video.family_friendly !== void 0) {
+              parts[partIndex++] = `            <video:family_friendly>${video.family_friendly === "yes" || video.family_friendly === true ? "yes" : "no"}</video:family_friendly>`;
+            }
+            if (video.restriction) {
+              const relationship = video.restriction.relationship || "allow";
+              parts[partIndex++] = `            <video:restriction relationship="${relationship}">${escapeValueForXml(video.restriction.restriction)}</video:restriction>`;
+            }
+            if (video.platform) {
+              const relationship = video.platform.relationship || "allow";
+              parts[partIndex++] = `            <video:platform relationship="${relationship}">${escapeValueForXml(video.platform.platform)}</video:platform>`;
+            }
+            if (video.requires_subscription !== void 0) {
+              parts[partIndex++] = `            <video:requires_subscription>${video.requires_subscription === "yes" || video.requires_subscription === true ? "yes" : "no"}</video:requires_subscription>`;
+            }
+            if (video.price) {
+              const prices = Array.isArray(video.price) ? video.price : [video.price];
+              for (const price of prices) {
+                const attrs = [];
+                if (price.currency) attrs.push(`currency="${price.currency}"`);
+                if (price.type) attrs.push(`type="${price.type}"`);
+                const attrsStr = attrs.length > 0 ? " " + attrs.join(" ") : "";
+                parts[partIndex++] = `            <video:price${attrsStr}>${escapeValueForXml(price.price)}</video:price>`;
+              }
+            }
+            if (video.uploader) {
+              const info = video.uploader.info ? ` info="${escapeValueForXml(video.uploader.info)}"` : "";
+              parts[partIndex++] = `            <video:uploader${info}>${escapeValueForXml(video.uploader.uploader)}</video:uploader>`;
+            }
+            if (video.live !== void 0) {
+              parts[partIndex++] = `            <video:live>${video.live === "yes" || video.live === true ? "yes" : "no"}</video:live>`;
+            }
+            if (video.tag) {
+              const tags = Array.isArray(video.tag) ? video.tag : [video.tag];
+              for (const tag of tags) {
+                parts[partIndex++] = `            <video:tag>${escapeValueForXml(tag)}</video:tag>`;
+              }
+            }
+            if (video.category) {
+              parts[partIndex++] = `            <video:category>${escapeValueForXml(video.category)}</video:category>`;
+            }
+            if (video.gallery_loc) {
+              const title = video.gallery_loc.title ? ` title="${escapeValueForXml(video.gallery_loc.title)}"` : "";
+              parts[partIndex++] = `            <video:gallery_loc${title}>${escapeValueForXml(video.gallery_loc)}</video:gallery_loc>`;
+            }
+            parts[partIndex++] = "        </video:video>";
+          }
+        }
+        break;
+      case "news":
+        if (value) {
+          parts[partIndex++] = "        <news:news>";
+          parts[partIndex++] = "            <news:publication>";
+          parts[partIndex++] = `                <news:name>${escapeValueForXml(value.publication.name)}</news:name>`;
+          parts[partIndex++] = `                <news:language>${escapeValueForXml(value.publication.language)}</news:language>`;
+          parts[partIndex++] = "            </news:publication>";
+          if (value.title) {
+            parts[partIndex++] = `            <news:title>${escapeValueForXml(value.title)}</news:title>`;
+          }
+          if (value.publication_date) {
+            parts[partIndex++] = `            <news:publication_date>${value.publication_date}</news:publication_date>`;
+          }
+          if (value.access) {
+            parts[partIndex++] = `            <news:access>${value.access}</news:access>`;
+          }
+          if (value.genres) {
+            parts[partIndex++] = `            <news:genres>${escapeValueForXml(value.genres)}</news:genres>`;
+          }
+          if (value.keywords) {
+            parts[partIndex++] = `            <news:keywords>${escapeValueForXml(value.keywords)}</news:keywords>`;
+          }
+          if (value.stock_tickers) {
+            parts[partIndex++] = `            <news:stock_tickers>${escapeValueForXml(value.stock_tickers)}</news:stock_tickers>`;
+          }
+          parts[partIndex++] = "        </news:news>";
+        }
+        break;
+    }
   }
-  return arr.map((obj) => handleObject(key, obj)).join("\n");
-}
-export function handleEntry(k, e) {
-  return Array.isArray(e[k]) ? handleArray(k, e[k]) : typeof e[k] === "object" ? handleObject(k, e[k]) : `        <${k}>${escapeValueForXml(e[k])}</${k}>`;
+  parts[partIndex++] = "    </url>";
+  return parts.slice(0, partIndex).join("\n");
 }
-export function wrapSitemapXml(input, resolvers, options) {
-  const xsl = options.xsl ? resolvers.relativeBaseUrlResolver(options.xsl) : false;
-  const credits = options.credits;
-  input.unshift(`<?xml version="1.0" encoding="UTF-8"?>${xsl ? `<?xml-stylesheet type="text/xsl" href="${xsl}"?>` : ""}`);
-  if (credits)
-    input.push(`<!-- XML Sitemap generated by @nuxtjs/sitemap v${options.version} at ${(/* @__PURE__ */ new Date()).toISOString()} -->`);
-  if (options.minify)
-    return input.join("").replace(/(?<!<[^>]*)\s(?![^<]*>)/g, "");
-  return input.join("\n");
-}
-export function escapeValueForXml(value) {
-  if (value === true || value === false)
-    return value ? "yes" : "no";
-  return String(value).replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+export function urlsToXml(urls, resolvers, { version, xsl, credits, minify }) {
+  const estimatedSize = urls.length + 5;
+  const xmlParts = Array.from({ length: estimatedSize });
+  let partIndex = 0;
+  const xslHref = xsl ? resolvers.relativeBaseUrlResolver(xsl) : false;
+  if (xslHref) {
+    xmlParts[partIndex++] = `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${xslHref}"?>`;
+  } else {
+    xmlParts[partIndex++] = '<?xml version="1.0" encoding="UTF-8"?>';
+  }
+  xmlParts[partIndex++] = URLSET_OPENING_TAG;
+  for (const url of urls) {
+    xmlParts[partIndex++] = buildUrlXml(url);
+  }
+  xmlParts[partIndex++] = "</urlset>";
+  if (credits) {
+    xmlParts[partIndex++] = `<!-- XML Sitemap generated by @nuxtjs/sitemap v${version} at ${(/* @__PURE__ */ new Date()).toISOString()} -->`;
+  }
+  const xmlContent = xmlParts.slice(0, partIndex);
+  if (minify) {
+    return xmlContent.join("").replace(/(?<!<[^>]*)\s(?![^<]*>)/g, "");
+  }
+  return xmlContent.join("\n");
 }