@warlock.js/sitemap 5.15.0 → 5.16.0

package/esm/types.d.mts

@@ -2,32 +2,63 @@
 /** The `<changefreq>` values the sitemap protocol defines. */
 type ChangeFreq = "always" | "hourly" | "daily" | "weekly" | "monthly" | "yearly" | "never";
 /**
- * One `<url>` block. `path` is app-relative (`/posts/hello-world`) — this
- * package joins it against the configured origin; see `url.ts`.
+ * One language version of a page, serialised as
+ * `<xhtml:link rel="alternate" hreflang="…" href="…"/>`.
+ *
+ * `hreflang` is not interpreted: `en`, `en-GB` and `x-default` are all just
+ * values. This package understands the PROTOCOL concept of an alternate; it
+ * does not understand anybody's locale system, and it never derives a
+ * locale-prefixed path for you.
+ */
+type SitemapAlternate = {
+  readonly hreflang: string; /** A path resolved against `baseUrl`, or an absolute URL used as given. */
+  readonly path: string;
+};
+/**
+ * One `<url>` block. Only `path` is required; `name` and `route` are carried
+ * for the diagnostics in `routes()` and `duplicates()` and never serialised.
  */
 type SitemapEntry = {
-  path: string;
-  lastmod?: string;
-  changefreq?: ChangeFreq;
-  priority?: number;
+  /** The CONCRETE path: `/posts/123`. A pattern is not a URL. */readonly path: string; /** Optional label for the route this came from: `post-details`. */
+  readonly name?: string; /** Optional pattern this came from: `/posts/:id`. */
+  readonly route?: string;
+  readonly lastmod?: string | Date;
+  readonly changefreq?: ChangeFreq;
+  readonly priority?: number; /** Language versions of THIS page, conventionally including itself. */
+  readonly alternates?: readonly SitemapAlternate[];
 };
 /**
- * A page's `sitemap` export, when it is a function: produces the entries a
- * dynamic route stands for. Runs server-side, at sitemap-build time — not
- * per-request.
+ * An entry after normalisation: the path carries its leading slash, the
+ * builder's defaults have been folded in, and `lastmod` is always the
+ * serialised string — a `Date` is resolved once, at `add()`, so `toXML()`
+ * stays pure and repeatable.
  */
-type SitemapEntries = () => SitemapEntry[] | Promise<SitemapEntry[]>;
-/** Fallback `changefreq`/`priority` applied to any entry that omits them. */
-type SitemapDefaults = {
-  changefreq?: ChangeFreq;
-  priority?: number;
+type ResolvedSitemapEntry = Omit<SitemapEntry, "lastmod"> & {
+  readonly lastmod?: string;
 };
-/** `src/config/sitemap.ts` — written by `warlock add sitemap`. */
-type SitemapConfig = {
-  enabled: boolean;
-  path: string;
-  defaults?: SitemapDefaults;
+type SitemapOptions = {
+  /** Absolute origin: `https://example.com` or `https://example.com/base`. */readonly baseUrl: string; /** Applied to every entry that does not set its own. */
+  readonly changefreq?: ChangeFreq;
+  readonly priority?: number;
+  readonly lastmod?: string | Date;
+};
+/**
+ * How many URLs a route contributed. A `count: 0` row is the interesting one:
+ * the route was declared and produced nothing, so a whole section is missing.
+ */
+type RouteSummary = {
+  readonly route: string;
+  readonly count: number;
+};
+/**
+ * A path that was added more than once. The later add wins silently, so this
+ * is the only way a caller can see it happened.
+ */
+type DuplicateReport = {
+  readonly path: string; /** Always >= 2. */
+  readonly count: number; /** The `route` of each add, in order, so colliding sources are nameable. */
+  readonly routes: readonly (string | undefined)[];
 };
 //#endregion
-export { ChangeFreq, SitemapConfig, SitemapDefaults, SitemapEntries, SitemapEntry };
+export { ChangeFreq, DuplicateReport, ResolvedSitemapEntry, RouteSummary, SitemapAlternate, SitemapEntry, SitemapOptions };
 //# sourceMappingURL=types.d.mts.map

package/esm/url.d.mts

@@ -5,25 +5,6 @@
  * already carries one.
  */
 declare function joinOrigin(origin: string, routePath: string): string;
-/**
- * Raised when the sitemap is enabled but no public origin is configured.
- * Refuses to boot rather than falling back to a request-derived origin: a
- * sitemap served with the wrong host is worse than one that refuses to
- * start, because nothing downstream ever tells you it was wrong.
- */
-declare class MissingPublicUrlError extends Error {
-  constructor();
-}
-type ResolveOriginOptions = {
-  /** `app.publicUrl` from the app's config, when set. */publicUrl?: string; /** Defaults to `process.env`; overridable for tests. */
-  env?: Record<string, string | undefined>;
-};
-/**
- * The origin the sitemap is served from: `app.publicUrl` first, then the
- * `PUBLIC_APP_URL` env fallback. Throws {@link MissingPublicUrlError} when
- * neither is set — this is the boot-time check, called once, not per-request.
- */
-declare function resolveOrigin(options?: ResolveOriginOptions): string;
 //#endregion
-export { MissingPublicUrlError, ResolveOriginOptions, joinOrigin, resolveOrigin };
+export { joinOrigin };
 //# sourceMappingURL=url.d.mts.map

package/esm/url.mjs

@@ -1,3 +1,5 @@
+import { InvalidBaseUrlError } from "./errors.mjs";
+
 //#region ../sitemap/src/url.ts
 /**
 * Joins a configured origin and an app-relative route path into one absolute
@@ -8,28 +10,33 @@ function joinOrigin(origin, routePath) {
 	return `${origin.endsWith("/") ? origin.slice(0, -1) : origin}${routePath.startsWith("/") ? routePath : `/${routePath}`}`;
 }
 /**
-* Raised when the sitemap is enabled but no public origin is configured.
-* Refuses to boot rather than falling back to a request-derived origin: a
-* sitemap served with the wrong host is worse than one that refuses to
-* start, because nothing downstream ever tells you it was wrong.
+* Validates a `baseUrl` and returns it without its trailing slash.
+*
+* `new URL()` accepts `mailto:` and `file:` happily, so the protocol is
+* checked explicitly — a sitemap `<loc>` that is not http(s) is not a document
+* any crawler will fetch.
 */
-var MissingPublicUrlError = class extends Error {
-	constructor() {
-		super("Sitemap is enabled but no public origin is configured. Set `app.publicUrl` in warlock.config.ts, or the PUBLIC_APP_URL environment variable.");
-		this.name = "MissingPublicUrlError";
+function normalizeBaseUrl(value) {
+	if (typeof value !== "string" || value.trim() === "") throw new InvalidBaseUrlError(value, "expected a non-empty string");
+	let parsed;
+	try {
+		parsed = new URL(value);
+	} catch {
+		throw new InvalidBaseUrlError(value, "not an absolute URL");
 	}
-};
-/**
-* The origin the sitemap is served from: `app.publicUrl` first, then the
-* `PUBLIC_APP_URL` env fallback. Throws {@link MissingPublicUrlError} when
-* neither is set — this is the boot-time check, called once, not per-request.
-*/
-function resolveOrigin(options = {}) {
-	const origin = options.publicUrl ?? options.env?.PUBLIC_APP_URL;
-	if (!origin) throw new MissingPublicUrlError();
-	return origin;
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") throw new InvalidBaseUrlError(value, `unsupported protocol "${parsed.protocol}"`);
+	const href = parsed.href;
+	return href.endsWith("/") ? href.slice(0, -1) : href;
+}
+/** True for a value already usable as a `<loc>` without joining an origin. */
+function isAbsoluteUrl(value) {
+	return /^https?:\/\//i.test(value);
+}
+/** Resolves an entry or alternate path against the base URL, unless it is already absolute. */
+function resolveAgainstBase(baseUrl, path) {
+	return isAbsoluteUrl(path) ? path : joinOrigin(baseUrl, path);
 }
 
 //#endregion
-export { MissingPublicUrlError, joinOrigin, resolveOrigin };
+export { joinOrigin, normalizeBaseUrl, resolveAgainstBase };
 //# sourceMappingURL=url.mjs.map

package/esm/url.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"url.mjs","names":[],"sources":["../../../../../../sitemap/src/url.ts"],"sourcesContent":["/**\n * Joins a configured origin and an app-relative route path into one absolute\n * URL, with exactly one slash at the seam regardless of whether either side\n * already carries one.\n */\nexport function joinOrigin(origin: string, routePath: string): string {\n  const trimmedOrigin = origin.endsWith(\"/\") ? origin.slice(0, -1) : origin;\n  const normalizedPath = routePath.startsWith(\"/\") ? routePath : `/${routePath}`;\n\n  return `${trimmedOrigin}${normalizedPath}`;\n}\n\n/**\n * Raised when the sitemap is enabled but no public origin is configured.\n * Refuses to boot rather than falling back to a request-derived origin: a\n * sitemap served with the wrong host is worse than one that refuses to\n * start, because nothing downstream ever tells you it was wrong.\n */\nexport class MissingPublicUrlError extends Error {\n  public constructor() {\n    super(\n      \"Sitemap is enabled but no public origin is configured. Set `app.publicUrl` \" +\n        \"in warlock.config.ts, or the PUBLIC_APP_URL environment variable.\",\n    );\n    this.name = \"MissingPublicUrlError\";\n  }\n}\n\nexport type ResolveOriginOptions = {\n  /** `app.publicUrl` from the app's config, when set. */\n  publicUrl?: string;\n  /** Defaults to `process.env`; overridable for tests. */\n  env?: Record<string, string | undefined>;\n};\n\n/**\n * The origin the sitemap is served from: `app.publicUrl` first, then the\n * `PUBLIC_APP_URL` env fallback. Throws {@link MissingPublicUrlError} when\n * neither is set — this is the boot-time check, called once, not per-request.\n */\nexport function resolveOrigin(options: ResolveOriginOptions = {}): string {\n  const origin = options.publicUrl ?? options.env?.PUBLIC_APP_URL;\n\n  if (!origin) throw new MissingPublicUrlError();\n\n  return origin;\n}\n"],"mappings":";;;;;;AAKA,SAAgB,WAAW,QAAgB,WAA2B;CAIpE,OAAO,GAHe,OAAO,SAAS,GAAG,IAAI,OAAO,MAAM,GAAG,EAAE,IAAI,SAC5C,UAAU,WAAW,GAAG,IAAI,YAAY,IAAI;AAGrE;;;;;;;AAQA,IAAa,wBAAb,cAA2C,MAAM;CAC/C,AAAO,cAAc;EACnB,MACE,8IAEF;EACA,KAAK,OAAO;CACd;AACF;;;;;;AAcA,SAAgB,cAAc,UAAgC,CAAC,GAAW;CACxE,MAAM,SAAS,QAAQ,aAAa,QAAQ,KAAK;CAEjD,IAAI,CAAC,QAAQ,MAAM,IAAI,sBAAsB;CAE7C,OAAO;AACT"}
+{"version":3,"file":"url.mjs","names":[],"sources":["../../../../../../sitemap/src/url.ts"],"sourcesContent":["import { InvalidBaseUrlError } from \"./errors\";\n\n/**\n * Joins a configured origin and an app-relative route path into one absolute\n * URL, with exactly one slash at the seam regardless of whether either side\n * already carries one.\n */\nexport function joinOrigin(origin: string, routePath: string): string {\n  const trimmedOrigin = origin.endsWith(\"/\") ? origin.slice(0, -1) : origin;\n  const normalizedPath = routePath.startsWith(\"/\") ? routePath : `/${routePath}`;\n\n  return `${trimmedOrigin}${normalizedPath}`;\n}\n\n/**\n * Validates a `baseUrl` and returns it without its trailing slash.\n *\n * `new URL()` accepts `mailto:` and `file:` happily, so the protocol is\n * checked explicitly — a sitemap `<loc>` that is not http(s) is not a document\n * any crawler will fetch.\n */\nexport function normalizeBaseUrl(value: string): string {\n  if (typeof value !== \"string\" || value.trim() === \"\") {\n    throw new InvalidBaseUrlError(value, \"expected a non-empty string\");\n  }\n\n  let parsed: URL;\n\n  try {\n    parsed = new URL(value);\n  } catch {\n    throw new InvalidBaseUrlError(value, \"not an absolute URL\");\n  }\n\n  if (parsed.protocol !== \"http:\" && parsed.protocol !== \"https:\") {\n    throw new InvalidBaseUrlError(value, `unsupported protocol \"${parsed.protocol}\"`);\n  }\n\n  const href = parsed.href;\n\n  return href.endsWith(\"/\") ? href.slice(0, -1) : href;\n}\n\n/** True for a value already usable as a `<loc>` without joining an origin. */\nexport function isAbsoluteUrl(value: string): boolean {\n  return /^https?:\\/\\//i.test(value);\n}\n\n/** Resolves an entry or alternate path against the base URL, unless it is already absolute. */\nexport function resolveAgainstBase(baseUrl: string, path: string): string {\n  return isAbsoluteUrl(path) ? path : joinOrigin(baseUrl, path);\n}\n"],"mappings":";;;;;;;;AAOA,SAAgB,WAAW,QAAgB,WAA2B;CAIpE,OAAO,GAHe,OAAO,SAAS,GAAG,IAAI,OAAO,MAAM,GAAG,EAAE,IAAI,SAC5C,UAAU,WAAW,GAAG,IAAI,YAAY,IAAI;AAGrE;;;;;;;;AASA,SAAgB,iBAAiB,OAAuB;CACtD,IAAI,OAAO,UAAU,YAAY,MAAM,KAAK,MAAM,IAChD,MAAM,IAAI,oBAAoB,OAAO,6BAA6B;CAGpE,IAAI;CAEJ,IAAI;EACF,SAAS,IAAI,IAAI,KAAK;CACxB,QAAQ;EACN,MAAM,IAAI,oBAAoB,OAAO,qBAAqB;CAC5D;CAEA,IAAI,OAAO,aAAa,WAAW,OAAO,aAAa,UACrD,MAAM,IAAI,oBAAoB,OAAO,yBAAyB,OAAO,SAAS,EAAE;CAGlF,MAAM,OAAO,OAAO;CAEpB,OAAO,KAAK,SAAS,GAAG,IAAI,KAAK,MAAM,GAAG,EAAE,IAAI;AAClD;;AAGA,SAAgB,cAAc,OAAwB;CACpD,OAAO,gBAAgB,KAAK,KAAK;AACnC;;AAGA,SAAgB,mBAAmB,SAAiB,MAAsB;CACxE,OAAO,cAAc,IAAI,IAAI,OAAO,WAAW,SAAS,IAAI;AAC9D"}

package/esm/xml.d.mts

@@ -1,14 +1,25 @@
-import { SitemapEntry } from "./types.mjs";
+import { ResolvedSitemapEntry } from "./types.mjs";
 
 //#region ../sitemap/src/xml.d.ts
 /** Escapes the five XML-significant characters. A URL's query string routinely contains `&`. */
 declare function escapeXml(value: string): string;
+/**
+ * Renders one `<url>` block. Exported so the streaming writer can measure the
+ * exact bytes it is about to append before deciding whether the byte ceiling
+ * forces a new shard — a separate approximation could disagree with what is
+ * actually written.
+ */
+declare function renderUrlBlock(entry: ResolvedSitemapEntry, baseUrl: string): string;
 /**
  * Serialises entries into a `urlset` sitemap document — the sitemaps.org
  * namespace, `<url>` per entry, element order `loc` / `lastmod` / `changefreq`
- * / `priority` (schema order; a validator that checks order rejects any other).
+ * / `priority` (schema order; a validator that checks order rejects any other),
+ * then any `xhtml:link` alternates.
+ *
+ * The xhtml namespace is declared only when some entry actually carries an
+ * alternate — an unused namespace on every single-language sitemap is noise.
  */
-declare function buildSitemapXml(entries: readonly SitemapEntry[], origin: string): string;
+declare function buildSitemapXml(entries: readonly ResolvedSitemapEntry[], baseUrl: string): string;
 //#endregion
-export { buildSitemapXml, escapeXml };
+export { buildSitemapXml, escapeXml, renderUrlBlock };
 //# sourceMappingURL=xml.d.mts.map

package/esm/xml.mjs

@@ -1,4 +1,4 @@
-import { joinOrigin } from "./url.mjs";
+import { resolveAgainstBase } from "./url.mjs";
 
 //#region ../sitemap/src/xml.ts
 const XML_ESCAPES = {
@@ -12,24 +12,46 @@ const XML_ESCAPES = {
 function escapeXml(value) {
 	return value.replace(/[&<>"']/g, (char) => XML_ESCAPES[char] ?? char);
 }
-function entryXml(entry, origin) {
-	const lines = [`  <url>`, `    <loc>${escapeXml(joinOrigin(origin, entry.path))}</loc>`];
+const XHTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
+/**
+* The `xmlns:xhtml` attribute exactly as it appears on `<urlset>`, including
+* its leading space. Exported so the shard writer can charge its byte length
+* against the ceiling without duplicating the string it measures.
+*/
+const XHTML_NAMESPACE_ATTR = ` xmlns:xhtml="${XHTML_NAMESPACE}"`;
+/**
+* Renders one `<url>` block. Exported so the streaming writer can measure the
+* exact bytes it is about to append before deciding whether the byte ceiling
+* forces a new shard — a separate approximation could disagree with what is
+* actually written.
+*/
+function renderUrlBlock(entry, baseUrl) {
+	const lines = [`  <url>`, `    <loc>${escapeXml(resolveAgainstBase(baseUrl, entry.path))}</loc>`];
 	if (entry.lastmod !== void 0) lines.push(`    <lastmod>${escapeXml(entry.lastmod)}</lastmod>`);
 	if (entry.changefreq !== void 0) lines.push(`    <changefreq>${entry.changefreq}</changefreq>`);
 	if (entry.priority !== void 0) lines.push(`    <priority>${entry.priority}</priority>`);
+	for (const alternate of entry.alternates ?? []) {
+		const href = escapeXml(resolveAgainstBase(baseUrl, alternate.path));
+		lines.push(`    <xhtml:link rel="alternate" hreflang="${escapeXml(alternate.hreflang)}" href="${href}"/>`);
+	}
 	lines.push(`  </url>`);
 	return lines.join("\n");
 }
 /**
 * Serialises entries into a `urlset` sitemap document — the sitemaps.org
 * namespace, `<url>` per entry, element order `loc` / `lastmod` / `changefreq`
-* / `priority` (schema order; a validator that checks order rejects any other).
+* / `priority` (schema order; a validator that checks order rejects any other),
+* then any `xhtml:link` alternates.
+*
+* The xhtml namespace is declared only when some entry actually carries an
+* alternate — an unused namespace on every single-language sitemap is noise.
 */
-function buildSitemapXml(entries, origin) {
-	const body = entries.map((entry) => entryXml(entry, origin)).join("\n");
-	return "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\n" + (body.length > 0 ? `${body}\n` : "") + `</urlset>\n`;
+function buildSitemapXml(entries, baseUrl) {
+	const namespaces = entries.some((entry) => (entry.alternates?.length ?? 0) > 0) ? XHTML_NAMESPACE_ATTR : "";
+	const body = entries.map((entry) => renderUrlBlock(entry, baseUrl)).join("\n");
+	return `<?xml version="1.0" encoding="UTF-8"?>\n<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9"${namespaces}>\n` + (body.length > 0 ? `${body}\n` : "") + `</urlset>\n`;
 }
 
 //#endregion
-export { buildSitemapXml, escapeXml };
+export { XHTML_NAMESPACE_ATTR, buildSitemapXml, escapeXml, renderUrlBlock };
 //# sourceMappingURL=xml.mjs.map

package/esm/xml.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"xml.mjs","names":[],"sources":["../../../../../../sitemap/src/xml.ts"],"sourcesContent":["import type { SitemapEntry } from \"./types\";\nimport { joinOrigin } from \"./url\";\n\nconst XML_ESCAPES: Record<string, string> = {\n  \"&\": \"&amp;\",\n  \"<\": \"&lt;\",\n  \">\": \"&gt;\",\n  '\"': \"&quot;\",\n  \"'\": \"&apos;\",\n};\n\n/** Escapes the five XML-significant characters. A URL's query string routinely contains `&`. */\nexport function escapeXml(value: string): string {\n  // The character class and the table are written together, so the lookup can\n  // only miss if one is edited without the other; falling back to the original\n  // character keeps that editing mistake from silently emitting `undefined`\n  // into a URL.\n  return value.replace(/[&<>\"']/g, (char) => XML_ESCAPES[char] ?? char);\n}\n\nfunction entryXml(entry: SitemapEntry, origin: string): string {\n  const lines = [`  <url>`, `    <loc>${escapeXml(joinOrigin(origin, entry.path))}</loc>`];\n\n  if (entry.lastmod !== undefined) {\n    lines.push(`    <lastmod>${escapeXml(entry.lastmod)}</lastmod>`);\n  }\n\n  if (entry.changefreq !== undefined) {\n    lines.push(`    <changefreq>${entry.changefreq}</changefreq>`);\n  }\n\n  if (entry.priority !== undefined) {\n    lines.push(`    <priority>${entry.priority}</priority>`);\n  }\n\n  lines.push(`  </url>`);\n\n  return lines.join(\"\\n\");\n}\n\n/**\n * Serialises entries into a `urlset` sitemap document — the sitemaps.org\n * namespace, `<url>` per entry, element order `loc` / `lastmod` / `changefreq`\n * / `priority` (schema order; a validator that checks order rejects any other).\n */\nexport function buildSitemapXml(entries: readonly SitemapEntry[], origin: string): string {\n  const body = entries.map((entry) => entryXml(entry, origin)).join(\"\\n\");\n\n  return (\n    `<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n` +\n    `<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\">\\n` +\n    (body.length > 0 ? `${body}\\n` : \"\") +\n    `</urlset>\\n`\n  );\n}\n"],"mappings":";;;AAGA,MAAM,cAAsC;CAC1C,KAAK;CACL,KAAK;CACL,KAAK;CACL,MAAK;CACL,KAAK;AACP;;AAGA,SAAgB,UAAU,OAAuB;CAK/C,OAAO,MAAM,QAAQ,aAAa,SAAS,YAAY,SAAS,IAAI;AACtE;AAEA,SAAS,SAAS,OAAqB,QAAwB;CAC7D,MAAM,QAAQ,CAAC,WAAW,YAAY,UAAU,WAAW,QAAQ,MAAM,IAAI,CAAC,EAAE,OAAO;CAEvF,IAAI,MAAM,YAAY,QACpB,MAAM,KAAK,gBAAgB,UAAU,MAAM,OAAO,EAAE,WAAW;CAGjE,IAAI,MAAM,eAAe,QACvB,MAAM,KAAK,mBAAmB,MAAM,WAAW,cAAc;CAG/D,IAAI,MAAM,aAAa,QACrB,MAAM,KAAK,iBAAiB,MAAM,SAAS,YAAY;CAGzD,MAAM,KAAK,UAAU;CAErB,OAAO,MAAM,KAAK,IAAI;AACxB;;;;;;AAOA,SAAgB,gBAAgB,SAAkC,QAAwB;CACxF,MAAM,OAAO,QAAQ,KAAK,UAAU,SAAS,OAAO,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI;CAEtE,OACE,kHAEC,KAAK,SAAS,IAAI,GAAG,KAAK,MAAM,MACjC;AAEJ"}
+{"version":3,"file":"xml.mjs","names":[],"sources":["../../../../../../sitemap/src/xml.ts"],"sourcesContent":["import type { ResolvedSitemapEntry } from \"./types\";\nimport { resolveAgainstBase } from \"./url\";\n\nconst XML_ESCAPES: Record<string, string> = {\n  \"&\": \"&amp;\",\n  \"<\": \"&lt;\",\n  \">\": \"&gt;\",\n  '\"': \"&quot;\",\n  \"'\": \"&apos;\",\n};\n\n/** Escapes the five XML-significant characters. A URL's query string routinely contains `&`. */\nexport function escapeXml(value: string): string {\n  // The character class and the table are written together, so the lookup can\n  // only miss if one is edited without the other; falling back to the original\n  // character keeps that editing mistake from silently emitting `undefined`\n  // into a URL.\n  return value.replace(/[&<>\"']/g, (char) => XML_ESCAPES[char] ?? char);\n}\n\nconst XHTML_NAMESPACE = \"http://www.w3.org/1999/xhtml\";\n\n/**\n * The `xmlns:xhtml` attribute exactly as it appears on `<urlset>`, including\n * its leading space. Exported so the shard writer can charge its byte length\n * against the ceiling without duplicating the string it measures.\n */\nexport const XHTML_NAMESPACE_ATTR = ` xmlns:xhtml=\"${XHTML_NAMESPACE}\"`;\n\n/**\n * Renders one `<url>` block. Exported so the streaming writer can measure the\n * exact bytes it is about to append before deciding whether the byte ceiling\n * forces a new shard — a separate approximation could disagree with what is\n * actually written.\n */\nexport function renderUrlBlock(entry: ResolvedSitemapEntry, baseUrl: string): string {\n  const lines = [`  <url>`, `    <loc>${escapeXml(resolveAgainstBase(baseUrl, entry.path))}</loc>`];\n\n  if (entry.lastmod !== undefined) {\n    lines.push(`    <lastmod>${escapeXml(entry.lastmod)}</lastmod>`);\n  }\n\n  if (entry.changefreq !== undefined) {\n    lines.push(`    <changefreq>${entry.changefreq}</changefreq>`);\n  }\n\n  if (entry.priority !== undefined) {\n    lines.push(`    <priority>${entry.priority}</priority>`);\n  }\n\n  for (const alternate of entry.alternates ?? []) {\n    const href = escapeXml(resolveAgainstBase(baseUrl, alternate.path));\n\n    lines.push(\n      `    <xhtml:link rel=\"alternate\" hreflang=\"${escapeXml(alternate.hreflang)}\" href=\"${href}\"/>`,\n    );\n  }\n\n  lines.push(`  </url>`);\n\n  return lines.join(\"\\n\");\n}\n\n/**\n * Serialises entries into a `urlset` sitemap document — the sitemaps.org\n * namespace, `<url>` per entry, element order `loc` / `lastmod` / `changefreq`\n * / `priority` (schema order; a validator that checks order rejects any other),\n * then any `xhtml:link` alternates.\n *\n * The xhtml namespace is declared only when some entry actually carries an\n * alternate — an unused namespace on every single-language sitemap is noise.\n */\nexport function buildSitemapXml(entries: readonly ResolvedSitemapEntry[], baseUrl: string): string {\n  const hasAlternates = entries.some((entry) => (entry.alternates?.length ?? 0) > 0);\n  const namespaces = hasAlternates ? XHTML_NAMESPACE_ATTR : \"\";\n  const body = entries.map((entry) => renderUrlBlock(entry, baseUrl)).join(\"\\n\");\n\n  return (\n    `<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n` +\n    `<urlset xmlns=\"http://www.sitemaps.org/schemas/sitemap/0.9\"${namespaces}>\\n` +\n    (body.length > 0 ? `${body}\\n` : \"\") +\n    `</urlset>\\n`\n  );\n}\n"],"mappings":";;;AAGA,MAAM,cAAsC;CAC1C,KAAK;CACL,KAAK;CACL,KAAK;CACL,MAAK;CACL,KAAK;AACP;;AAGA,SAAgB,UAAU,OAAuB;CAK/C,OAAO,MAAM,QAAQ,aAAa,SAAS,YAAY,SAAS,IAAI;AACtE;AAEA,MAAM,kBAAkB;;;;;;AAOxB,MAAa,uBAAuB,iBAAiB,gBAAgB;;;;;;;AAQrE,SAAgB,eAAe,OAA6B,SAAyB;CACnF,MAAM,QAAQ,CAAC,WAAW,YAAY,UAAU,mBAAmB,SAAS,MAAM,IAAI,CAAC,EAAE,OAAO;CAEhG,IAAI,MAAM,YAAY,QACpB,MAAM,KAAK,gBAAgB,UAAU,MAAM,OAAO,EAAE,WAAW;CAGjE,IAAI,MAAM,eAAe,QACvB,MAAM,KAAK,mBAAmB,MAAM,WAAW,cAAc;CAG/D,IAAI,MAAM,aAAa,QACrB,MAAM,KAAK,iBAAiB,MAAM,SAAS,YAAY;CAGzD,KAAK,MAAM,aAAa,MAAM,cAAc,CAAC,GAAG;EAC9C,MAAM,OAAO,UAAU,mBAAmB,SAAS,UAAU,IAAI,CAAC;EAElE,MAAM,KACJ,6CAA6C,UAAU,UAAU,QAAQ,EAAE,UAAU,KAAK,IAC5F;CACF;CAEA,MAAM,KAAK,UAAU;CAErB,OAAO,MAAM,KAAK,IAAI;AACxB;;;;;;;;;;AAWA,SAAgB,gBAAgB,SAA0C,SAAyB;CAEjG,MAAM,aADgB,QAAQ,MAAM,WAAW,MAAM,YAAY,UAAU,KAAK,CACjD,IAAI,uBAAuB;CAC1D,MAAM,OAAO,QAAQ,KAAK,UAAU,eAAe,OAAO,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI;CAE7E,OACE,sGAC8D,WAAW,QACxE,KAAK,SAAS,IAAI,GAAG,KAAK,MAAM,MACjC;AAEJ"}