@nuxtjs/sitemap 7.4.8 → 7.4.10

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

@@ -3,8 +3,12 @@ import { joinURL, withHttps } from "ufo";
 import { preNormalizeEntry } from "../urlset/normalise.js";
 import { childSitemapSources, globalSitemapSources, resolveSitemapSources } from "../urlset/sources.js";
 import { sortInPlace } from "../urlset/sort.js";
-import { createPathFilter, logger, splitForLocales } from "../../../utils-pure.js";
+import { createPathFilter, splitForLocales } from "../../../utils-pure.js";
 import { parseChunkInfo, sliceUrlsForChunk } from "../utils/chunk.js";
+function getPageKey(pathWithoutPrefix) {
+  const stripped = pathWithoutPrefix[0] === "/" ? pathWithoutPrefix.slice(1) : pathWithoutPrefix;
+  return stripped.endsWith("/index") ? stripped.slice(0, -6) || "index" : stripped || "index";
+}
 export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
   const {
     autoI18n,
@@ -21,10 +25,16 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
     return e;
   }).filter(Boolean);
   let validI18nUrlsForTransform = [];
-  let warnIncorrectI18nTransformUsage = false;
   const withoutPrefixPaths = {};
   if (autoI18n && autoI18n.strategy !== "no_prefix") {
     const localeCodes = autoI18n.locales.map((l) => l.code);
+    const localeByCode = new Map(autoI18n.locales.map((l) => [l.code, l]));
+    const isPrefixStrategy = autoI18n.strategy === "prefix";
+    const isPrefixExceptOrAndDefault = autoI18n.strategy === "prefix_and_default" || autoI18n.strategy === "prefix_except_default";
+    const xDefaultAndLocales = [{ code: "x-default", _hreflang: "x-default" }, ...autoI18n.locales];
+    const defaultLocale = autoI18n.defaultLocale;
+    const hasPages = !!autoI18n.pages;
+    const hasDifferentDomains = !!autoI18n.differentDomains;
     validI18nUrlsForTransform = _urls.map((_e, i) => {
       if (_e._abs)
         return false;
@@ -32,15 +42,15 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
       let localeCode = split[0];
       const pathWithoutPrefix = split[1];
       if (!localeCode)
-        localeCode = autoI18n.defaultLocale;
+        localeCode = defaultLocale;
       const e = _e;
       e._pathWithoutPrefix = pathWithoutPrefix;
-      const locale = autoI18n.locales.find((l) => l.code === localeCode);
+      const locale = localeByCode.get(localeCode);
       if (!locale)
         return false;
       e._locale = locale;
       e._index = i;
-      e._key = `${e._sitemap || ""}${e._path?.pathname || "/"}${e._path.search}`;
+      e._key = `${e._sitemap || ""}${e._path?.pathname || "/"}${e._path?.search || ""}`;
       withoutPrefixPaths[pathWithoutPrefix] = withoutPrefixPaths[pathWithoutPrefix] || [];
       if (!withoutPrefixPaths[pathWithoutPrefix].some((e2) => e2._locale.code === locale.code))
         withoutPrefixPaths[pathWithoutPrefix].push(e);
@@ -48,9 +58,9 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
     }).filter(Boolean);
     for (const e of validI18nUrlsForTransform) {
       if (!e._i18nTransform && !e.alternatives?.length) {
-        const alternatives = withoutPrefixPaths[e._pathWithoutPrefix].map((u) => {
+        const alternatives = (withoutPrefixPaths[e._pathWithoutPrefix] || []).map((u) => {
           const entries = [];
-          if (u._locale.code === autoI18n.defaultLocale) {
+          if (u._locale.code === defaultLocale) {
             entries.push({
               href: u.loc,
               hreflang: "x-default"
@@ -58,7 +68,7 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
           }
           entries.push({
             href: u.loc,
-            hreflang: u._locale._hreflang || autoI18n.defaultLocale
+            hreflang: u._locale._hreflang || defaultLocale
           });
           return entries;
         }).flat().filter(Boolean);
@@ -66,14 +76,11 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
           e.alternatives = alternatives;
       } else if (e._i18nTransform) {
         delete e._i18nTransform;
-        if (autoI18n.strategy === "no_prefix") {
-          warnIncorrectI18nTransformUsage = true;
-        }
-        if (autoI18n.differentDomains) {
+        if (hasDifferentDomains) {
+          const defLocale = localeByCode.get(defaultLocale);
           e.alternatives = [
             {
-              // apply default locale domain
-              ...autoI18n.locales.find((l) => [l.code, l.language].includes(autoI18n.defaultLocale)),
+              ...defLocale,
               code: "x-default"
             },
             ...autoI18n.locales.filter((l) => !!l.domain)
@@ -84,68 +91,53 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
             };
           });
         } else {
+          const pageKey = hasPages ? getPageKey(e._pathWithoutPrefix) : "";
+          const pageMappings = hasPages ? autoI18n.pages[pageKey] : void 0;
+          const pathSearch = e._path?.search || "";
+          const pathWithoutPrefix = e._pathWithoutPrefix;
           for (const l of autoI18n.locales) {
-            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];
+            let loc = pathWithoutPrefix;
+            if (hasPages && pageMappings && pageMappings[l.code] !== void 0) {
+              const customPath = pageMappings[l.code];
+              if (customPath === false)
+                continue;
+              if (typeof customPath === "string")
+                loc = customPath[0] === "/" ? customPath : `/${customPath}`;
+            } else if (!hasDifferentDomains && !(isPrefixExceptOrAndDefault && l.code === defaultLocale)) {
+              loc = joinURL(`/${l.code}`, pathWithoutPrefix);
+            }
+            const _sitemap = isI18nMapped ? l._sitemap : void 0;
+            const alternatives = [];
+            for (const locale of xDefaultAndLocales) {
+              const code = locale.code === "x-default" ? defaultLocale : locale.code;
+              const isDefault = locale.code === "x-default" || locale.code === defaultLocale;
+              let href = pathWithoutPrefix;
+              if (hasPages && pageMappings && pageMappings[code] !== void 0) {
+                const customPath = pageMappings[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);
+                  href = customPath[0] === "/" ? customPath : `/${customPath}`;
+              } else if (isPrefixStrategy) {
+                href = joinURL("/", code, pathWithoutPrefix);
+              } else if (isPrefixExceptOrAndDefault && !isDefault) {
+                href = joinURL("/", code, pathWithoutPrefix);
               }
-            } else {
-              if (!autoI18n.differentDomains && !(["prefix_and_default", "prefix_except_default"].includes(autoI18n.strategy) && l.code === autoI18n.defaultLocale))
-                loc = joinURL(`/${l.code}`, e._pathWithoutPrefix);
+              if (!filterPath(href))
+                continue;
+              alternatives.push({
+                hreflang: locale._hreflang,
+                href
+              });
             }
-            const _sitemap = isI18nMapped ? l._sitemap : void 0;
+            const { _index: _, ...rest } = e;
             const newEntry = preNormalizeEntry({
               _sitemap,
-              ...e,
-              _index: void 0,
-              _key: `${_sitemap || ""}${loc || "/"}${e._path.search}`,
+              ...rest,
+              _key: `${_sitemap || ""}${loc || "/"}${pathSearch}`,
               _locale: l,
               loc,
-              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 = 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))
-                  return false;
-                return {
-                  hreflang: locale._hreflang,
-                  href
-                };
-              }).filter(Boolean)
+              alternatives
             }, resolvers);
             if (e._locale.code === newEntry._locale.code) {
               _urls[e._index] = newEntry;
@@ -158,15 +150,12 @@ export function resolveSitemapEntries(sitemap, urls, runtimeConfig, resolvers) {
       }
       if (isI18nMapped) {
         e._sitemap = e._sitemap || e._locale._sitemap;
-        e._key = `${e._sitemap || ""}${e.loc || "/"}${e._path.search}`;
+        e._key = `${e._sitemap || ""}${e.loc || "/"}${e._path?.search || ""}`;
       }
       if (e._index)
         _urls[e._index] = e;
     }
   }
-  if (import.meta.dev && warnIncorrectI18nTransformUsage) {
-    logger.warn("You're using _i18nTransform with the `no_prefix` strategy. This will cause issues with the sitemap. Please remove the _i18nTransform flag or change i18n strategy.");
-  }
   return _urls;
 }
 export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro) {
@@ -181,15 +170,16 @@ export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro)
     // chunking
     defaultSitemapsChunkSize
   } = runtimeConfig;
-  const chunkInfo = parseChunkInfo(sitemap.sitemapName, sitemaps, defaultSitemapsChunkSize);
+  const chunkSize = defaultSitemapsChunkSize || void 0;
+  const chunkInfo = parseChunkInfo(sitemap.sitemapName, sitemaps, chunkSize);
   function maybeSort(urls2) {
     return sortEntries ? sortInPlace(urls2) : urls2;
   }
   function maybeSlice(urls2) {
-    return sliceUrlsForChunk(urls2, sitemap.sitemapName, sitemaps, defaultSitemapsChunkSize);
+    return sliceUrlsForChunk(urls2, sitemap.sitemapName, sitemaps, chunkSize);
   }
   if (autoI18n?.differentDomains) {
-    const domain = autoI18n.locales.find((e) => [e.language, e.code].includes(sitemap.sitemapName))?.domain;
+    const domain = autoI18n.locales.find((e) => e.language === sitemap.sitemapName || e.code === sitemap.sitemapName)?.domain;
     if (domain) {
       const _tester = resolvers.canonicalUrlResolver;
       resolvers.canonicalUrlResolver = (path) => resolveSitePath(path, {
@@ -232,8 +222,11 @@ export async function buildSitemapUrls(sitemap, resolvers, runtimeConfig, nitro)
   const filteredUrls = enhancedUrls.filter((e) => {
     if (e._sitemap === false)
       return false;
-    if (isMultiSitemap && e._sitemap && sitemap.sitemapName)
+    if (isMultiSitemap && e._sitemap && sitemap.sitemapName) {
+      if (sitemap._isChunking)
+        return sitemap.sitemapName.startsWith(e._sitemap + "-");
       return e._sitemap === sitemap.sitemapName;
+    }
     return true;
   });
   const sortedUrls = maybeSort(filteredUrls);

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

@@ -5,193 +5,105 @@ export function escapeValueForXml(value) {
     return value ? "yes" : "no";
   return xmlEscape(String(value));
 }
+const yesNo = (v) => v === "yes" || v === true ? "yes" : "no";
 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>`;
+function buildUrlXml(url, NL, I1, I2, I3, I4) {
+  let xml = `${I1}<url>${NL}`;
+  if (url.loc) xml += `${I2}<loc>${xmlEscape(url.loc)}</loc>${NL}`;
+  if (url.lastmod) xml += `${I2}<lastmod>${url.lastmod}</lastmod>${NL}`;
+  if (url.changefreq) xml += `${I2}<changefreq>${url.changefreq}</changefreq>${NL}`;
+  if (url.priority !== void 0) {
+    const p = typeof url.priority === "number" ? url.priority : Number.parseFloat(url.priority);
+    xml += `${I2}<priority>${p % 1 === 0 ? p : p.toFixed(1)}</priority>${NL}`;
   }
-  if (url.changefreq) {
-    parts[partIndex++] = `        <changefreq>${url.changefreq}</changefreq>`;
+  if (url.alternatives) {
+    for (const alt of url.alternatives) {
+      let attrs = "";
+      for (const [k, v] of Object.entries(alt)) attrs += ` ${k}="${xmlEscape(String(v))}"`;
+      xml += `${I2}<xhtml:link rel="alternate"${attrs} />${NL}`;
+    }
   }
-  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>`;
+  if (url.images) {
+    for (const img of url.images) {
+      xml += `${I2}<image:image>${NL}${I3}<image:loc>${xmlEscape(img.loc)}</image:loc>${NL}`;
+      if (img.title) xml += `${I3}<image:title>${xmlEscape(img.title)}</image:title>${NL}`;
+      if (img.caption) xml += `${I3}<image:caption>${xmlEscape(img.caption)}</image:caption>${NL}`;
+      if (img.geo_location) xml += `${I3}<image:geo_location>${xmlEscape(img.geo_location)}</image:geo_location>${NL}`;
+      if (img.license) xml += `${I3}<image:license>${xmlEscape(img.license)}</image:license>${NL}`;
+      xml += `${I2}</image:image>${NL}`;
+    }
   }
-  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} />`;
-          }
-        }
-        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>";
-          }
+  if (url.videos) {
+    for (const video of url.videos) {
+      xml += `${I2}<video:video>${NL}${I3}<video:title>${xmlEscape(video.title)}</video:title>${NL}`;
+      if (video.thumbnail_loc) xml += `${I3}<video:thumbnail_loc>${xmlEscape(video.thumbnail_loc)}</video:thumbnail_loc>${NL}`;
+      xml += `${I3}<video:description>${xmlEscape(video.description)}</video:description>${NL}`;
+      if (video.content_loc) xml += `${I3}<video:content_loc>${xmlEscape(video.content_loc)}</video:content_loc>${NL}`;
+      if (video.player_loc) xml += `${I3}<video:player_loc>${xmlEscape(video.player_loc)}</video:player_loc>${NL}`;
+      if (video.duration !== void 0) xml += `${I3}<video:duration>${video.duration}</video:duration>${NL}`;
+      if (video.expiration_date) xml += `${I3}<video:expiration_date>${video.expiration_date}</video:expiration_date>${NL}`;
+      if (video.rating !== void 0) xml += `${I3}<video:rating>${video.rating}</video:rating>${NL}`;
+      if (video.view_count !== void 0) xml += `${I3}<video:view_count>${video.view_count}</video:view_count>${NL}`;
+      if (video.publication_date) xml += `${I3}<video:publication_date>${video.publication_date}</video:publication_date>${NL}`;
+      if (video.family_friendly !== void 0) xml += `${I3}<video:family_friendly>${yesNo(video.family_friendly)}</video:family_friendly>${NL}`;
+      if (video.restriction) xml += `${I3}<video:restriction relationship="${video.restriction.relationship || "allow"}">${xmlEscape(video.restriction.restriction)}</video:restriction>${NL}`;
+      if (video.platform) xml += `${I3}<video:platform relationship="${video.platform.relationship || "allow"}">${xmlEscape(video.platform.platform)}</video:platform>${NL}`;
+      if (video.requires_subscription !== void 0) xml += `${I3}<video:requires_subscription>${yesNo(video.requires_subscription)}</video:requires_subscription>${NL}`;
+      if (video.price) {
+        for (const price of video.price) {
+          const c = price.currency ? ` currency="${price.currency}"` : "";
+          const t = price.type ? ` type="${price.type}"` : "";
+          xml += `${I3}<video:price${c}${t}>${xmlEscape(String(price.price ?? ""))}</video:price>${NL}`;
         }
-        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;
+      }
+      if (video.uploader) {
+        const info = video.uploader.info ? ` info="${xmlEscape(video.uploader.info)}"` : "";
+        xml += `${I3}<video:uploader${info}>${xmlEscape(video.uploader.uploader)}</video:uploader>${NL}`;
+      }
+      if (video.live !== void 0) xml += `${I3}<video:live>${yesNo(video.live)}</video:live>${NL}`;
+      if (video.tag) {
+        const tags = Array.isArray(video.tag) ? video.tag : [video.tag];
+        for (const t of tags) xml += `${I3}<video:tag>${xmlEscape(t)}</video:tag>${NL}`;
+      }
+      if (video.category) xml += `${I3}<video:category>${xmlEscape(video.category)}</video:category>${NL}`;
+      if (video.gallery_loc) xml += `${I3}<video:gallery_loc>${xmlEscape(video.gallery_loc)}</video:gallery_loc>${NL}`;
+      xml += `${I2}</video:video>${NL}`;
     }
   }
-  parts[partIndex++] = "    </url>";
-  return parts.slice(0, partIndex).join("\n");
+  if (url.news) {
+    xml += `${I2}<news:news>${NL}${I3}<news:publication>${NL}`;
+    xml += `${I4}<news:name>${xmlEscape(url.news.publication.name)}</news:name>${NL}`;
+    xml += `${I4}<news:language>${xmlEscape(url.news.publication.language)}</news:language>${NL}`;
+    xml += `${I3}</news:publication>${NL}`;
+    if (url.news.title) xml += `${I3}<news:title>${xmlEscape(url.news.title)}</news:title>${NL}`;
+    if (url.news.publication_date) xml += `${I3}<news:publication_date>${url.news.publication_date}</news:publication_date>${NL}`;
+    xml += `${I2}</news:news>${NL}`;
+  }
+  xml += `${I1}</url>`;
+  return xml;
 }
 export function urlsToXml(urls, resolvers, { version, xsl, credits, minify }, errorInfo) {
-  const estimatedSize = urls.length + 5;
-  const xmlParts = Array.from({ length: estimatedSize });
-  let partIndex = 0;
   let xslHref = xsl ? resolvers.relativeBaseUrlResolver(xsl) : false;
-  if (xslHref && errorInfo && errorInfo.messages.length > 0) {
+  if (xslHref && errorInfo?.messages.length) {
     xslHref = withQuery(xslHref, {
       errors: "true",
       error_messages: errorInfo.messages,
       error_urls: errorInfo.urls
     });
   }
-  if (xslHref) {
-    xmlParts[partIndex++] = `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${escapeValueForXml(xslHref)}"?>`;
-  } else {
-    xmlParts[partIndex++] = '<?xml version="1.0" encoding="UTF-8"?>';
-  }
-  xmlParts[partIndex++] = URLSET_OPENING_TAG;
+  const NL = minify ? "" : "\n";
+  const I1 = minify ? "" : "    ";
+  const I2 = minify ? "" : "        ";
+  const I3 = minify ? "" : "            ";
+  const I4 = minify ? "" : "                ";
+  let xml = xslHref ? `<?xml version="1.0" encoding="UTF-8"?><?xml-stylesheet type="text/xsl" href="${escapeValueForXml(xslHref)}"?>${NL}` : `<?xml version="1.0" encoding="UTF-8"?>${NL}`;
+  xml += URLSET_OPENING_TAG + NL;
   for (const url of urls) {
-    xmlParts[partIndex++] = buildUrlXml(url);
+    xml += buildUrlXml(url, NL, I1, I2, I3, I4) + NL;
   }
-  xmlParts[partIndex++] = "</urlset>";
+  xml += "</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, "");
+    xml += `${NL}<!-- XML Sitemap generated by @nuxtjs/sitemap v${version} at ${(/* @__PURE__ */ new Date()).toISOString()} -->`;
   }
-  return xmlContent.join("\n");
+  return xml;
 }

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

@@ -35,7 +35,7 @@ async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
       nitro._sitemapWarned = true;
       logger.error("Sitemap Site URL missing!");
       logger.info("To fix this please add `{ site: { url: 'site.com' } }` to your Nuxt config or a `NUXT_PUBLIC_SITE_URL=site.com` to your .env. Learn more at https://nuxtseo.com/site-config/getting-started/how-it-works");
-      throw new createError({
+      throw createError({
         statusMessage: "You must provide a site URL to prerender a sitemap.",
         statusCode: 500
       });
@@ -78,8 +78,9 @@ async function buildSitemapXml(event, definition, resolvers, runtimeConfig) {
     resolvedCtx.urls = resolvedCtx.urls.map((e) => preNormalizeEntry(e, resolvers));
   }
   const maybeSort = (urls2) => runtimeConfig.sortEntries ? sortInPlace(urls2) : urls2;
-  const normalizedPreDedupe = resolvedCtx.urls.map((e) => normaliseEntry(e, definition.defaults, resolvers));
-  const urls = maybeSort(mergeOnKey(normalizedPreDedupe, "_key").map((e) => normaliseEntry(e, definition.defaults, resolvers)));
+  const defaults = definition.defaults || {};
+  const normalizedPreDedupe = resolvedCtx.urls.map((e) => normaliseEntry(e, defaults, resolvers));
+  const urls = maybeSort(mergeOnKey(normalizedPreDedupe, "_key").map((e) => normaliseEntry(e, defaults, resolvers)));
   if (definition._isChunking && definition.sitemapName.includes("-")) {
     const parts = definition.sitemapName.split("-");
     const lastPart = parts.pop();