Chrome stops running XSLT on November 17, 2026: fix your styled sitemap and RSS feed

curl -sL https://example.com/sitemap.xml | head -c 600 | grep -i "xml-stylesheet"

// Finds XML files that depend on browser XSLT, which Chrome stops running
// on Stable in version 158 (Nov 17, 2026).
// Usage: node check-xslt.mjs https://example.com/sitemap.xml https://example.com/feed.xml
// Local files work too: node check-xslt.mjs public/sitemap.xml

import { readFile } from "node:fs/promises";

async function load(target) {
  if (/^https?:\/\//.test(target)) {
    const res = await fetch(target, { redirect: "follow" });
    return { status: res.status, text: await res.text() };
  }
  return { status: 200, text: await readFile(target, "utf8") };
}

// Only the document prolog matters: processing instructions before the root element.
function stylesheets(xml) {
  const prolog = xml.slice(0, xml.search(/<[A-Za-z]/));
  const found = [];
  for (const [, attrs] of prolog.matchAll(/<\?xml-stylesheet\s+([^?]*)\?>/g)) {
    const type = /type\s*=\s*["']([^"']+)["']/.exec(attrs)?.[1] ?? "";
    const href = /href\s*=\s*["']([^"']+)["']/.exec(attrs)?.[1] ?? "";
    const isXslt = /xsl/i.test(type) || /\.xslt?$/i.test(href);
    found.push({ type, href, isXslt });
  }
  return found;
}

let affected = 0;
for (const target of process.argv.slice(2)) {
  try {
    const { status, text } = await load(target);
    if (status >= 400) {
      console.log(`ERROR    ${target}: HTTP ${status}`);
      continue;
    }
    const sheets = stylesheets(text);
    const xslt = sheets.filter((s) => s.isXslt);
    if (xslt.length) {
      affected++;
      console.log(`AFFECTED ${target}: uses XSLT (${xslt.map((s) => s.href).join(", ")})`);
    } else if (sheets.length) {
      console.log(`OK       ${target}: stylesheet is CSS (${sheets.map((s) => s.href).join(", ")}), not affected`);
    } else {
      console.log(`OK       ${target}: no stylesheet, shows as raw XML already`);
    }
  } catch (err) {
    console.log(`ERROR    ${target}: ${err.message}`);
  }
}
process.exitCode = affected ? 1 : 0;

node check-xslt.mjs https://example.com/sitemap.xml https://example.com/feed.xml

AFFECTED http://localhost:4321/sitemap.xml: uses XSLT (/sitemap.xsl)
AFFECTED http://localhost:4321/atom.xml: uses XSLT (/pretty-feed.xsl)
OK       http://localhost:4321/feed.xml: stylesheet is CSS (/feed.css), not affected
ERROR    http://localhost:4321/missing.xml: HTTP 404
OK       https://www.codewares.in/sitemap.xml: no stylesheet, shows as raw XML already

// Runs the XSL stylesheet your sitemap already uses, at build time in Node,
// and writes the result as a plain HTML page. Crawlers keep reading
// sitemap.xml; people get sitemap.html, which needs no browser XSLT.
// Usage: node prerender-sitemap.mjs public/sitemap.xml public/sitemap.html

import { readFile, writeFile } from "node:fs/promises";
import path from "node:path";
import { XmlParser, Xslt } from "xslt-processor";

const [input = "public/sitemap.xml", output = "public/sitemap.html"] = process.argv.slice(2);

const xml = await readFile(input, "utf8");
const href = /<\?xml-stylesheet[^?]*href\s*=\s*["']([^"']+)["']/.exec(xml)?.[1];
if (!href) throw new Error(`${input} has no xml-stylesheet to render`);

// Resolve "/sitemap.xsl" against the folder that holds the XML file.
const xslPath = path.join(path.dirname(input), href.replace(/^\//, ""));
const xsl = await readFile(xslPath, "utf8");

const parser = new XmlParser();
const html = await new Xslt().xsltProcess(parser.xmlParse(xml), parser.xmlParse(xsl));

await writeFile(output, `<!DOCTYPE html>\n${html}\n`);
console.log(`wrote ${output} (${html.length} chars) using ${xslPath}`);

npm install xslt-processor
node prerender-sitemap.mjs public/sitemap.xml public/sitemap.html

wrote public/sitemap.html (784 chars) using public\sitemap.xsl

<!DOCTYPE html>
<html>
  <head>
    <title>XML Sitemap</title>
    ...
  <body>
    <h1>XML Sitemap</h1>
    <p>3 URLs</p>
    <table>
      ...
      <tr>
        <td>
          <a href="https://example.com/pricing">https://example.com/pricing</a>
        </td>
        <td>2026-10-12</td>
      </tr>

{
  "scripts": {
    "build": "your-site-build && node prerender-sitemap.mjs dist/sitemap.xml dist/sitemap.html"
  }
}

// No stylesheet at all: read the sitemap's data and write a simple HTML page.
// Use this when your XSL file is too complex to run outside a browser.
// Usage: node sitemap-to-html.mjs public/sitemap.xml public/sitemap.html

import { readFile, writeFile } from "node:fs/promises";
import { XMLParser } from "fast-xml-parser";

const [input = "public/sitemap.xml", output = "public/sitemap.html"] = process.argv.slice(2);

const data = new XMLParser().parse(await readFile(input, "utf8"));
const urls = [data.urlset?.url ?? []].flat(); // one <url> parses as an object, not an array

const escape = (s) =>
  String(s ?? "").replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);

const rows = urls
  .map((u) => `<tr><td><a href="${escape(u.loc)}">${escape(u.loc)}</a></td><td>${escape(u.lastmod)}</td></tr>`)
  .join("\n");

await writeFile(
  output,
  `<!DOCTYPE html>
<html lang="en"><head><meta charset="utf-8"><title>Sitemap</title></head>
<body><h1>Sitemap</h1><p>${urls.length} URLs</p>
<table><tr><th>URL</th><th>Last modified</th></tr>
${rows}
</table></body></html>
`,
);
console.log(`wrote ${output} with ${urls.length} URLs`);

npm install fast-xml-parser
node sitemap-to-html.mjs public/sitemap.xml public/sitemap.html

<link rel="alternate" type="application/rss+xml"
      title="Example blog" href="https://example.com/feed.xml">