@tradik/xslt-processor 1.1.1 → 1.3.0

package/package.json

@@ -1,8 +1,11 @@
 {
   "name": "@tradik/xslt-processor",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "JavaScript implementation of XSLTProcessor for browser environments and CLI",
   "type": "module",
+  "workspaces": [
+    "packages/*"
+  ],
   "main": "dist/xslt-processor.cjs",
   "module": "dist/xslt-processor.js",
   "browser": "dist/xslt-processor.js",
@@ -38,13 +41,31 @@
   },
   "scripts": {
     "build": "node scripts/build.js",
-    "test": "node --test --experimental-test-coverage src/*.test.js src/**/*.test.js",
+    "test": "node --test --experimental-test-coverage --test-coverage-lines=100 --test-coverage-functions=100 --test-coverage-branches=96 --test-coverage-exclude=\"**/*.test.js\" --test-coverage-exclude=\"packages/**\" \"src/**/*.test.js\"",
+    "test:xslt3": "npm test --workspace @tradik/xslt3",
+    "suites:fetch": "node packages/xslt3/test-suites/fetch.mjs all",
+    "test:suites:unit": "node --test --experimental-test-coverage --test-coverage-include=\"packages/xslt3/test-suites/**\" --test-coverage-exclude=\"**/*.test.mjs\" --test-coverage-lines=96 \"packages/xslt3/test-suites/**/*.test.mjs\"",
+    "test:qt3:parse": "node packages/xslt3/test-suites/run.mjs qt3 --parse-only",
+    "test:qt3": "node packages/xslt3/test-suites/run.mjs qt3",
+    "test:xslt30": "node packages/xslt3/test-suites/run.mjs xslt30",
     "test:watch": "node --test --watch src/**/*.test.js",
-    "test:browser": "node tests/browser-test-runner.js",
-    "lint": "eslint src/",
-    "format": "prettier --write \"src/**/*.js\" \"bin/**/*.js\"",
-    "format:check": "prettier --check \"src/**/*.js\" \"bin/**/*.js\"",
-    "prepublishOnly": "npm run build && npm run test"
+    "test:conformance": "node scripts/conformance.mjs",
+    "test:dom": "node scripts/test-dom.mjs",
+    "test:conformance:unit": "node --test \"scripts/conformance/*.test.mjs\"",
+    "conformance:fetch": "node scripts/fetch-conformance.mjs",
+    "lint": "eslint src/ bin/ scripts/ tests/browser/ site/ packages/",
+    "format": "prettier --write \"src/**/*.js\" \"bin/**/*.js\" \"scripts/**/*.{js,mjs}\" \"tests/browser/**/*.mjs\" \"site/scripts/*.mjs\" \"site/templates/**/js/*.js\" \"packages/*/src/**/*.js\" \"packages/*/test-suites/**/*.mjs\"",
+    "format:check": "prettier --check \"src/**/*.js\" \"bin/**/*.js\" \"scripts/**/*.{js,mjs}\" \"tests/browser/**/*.mjs\" \"site/scripts/*.mjs\" \"site/templates/**/js/*.js\" \"packages/*/src/**/*.js\" \"packages/*/test-suites/**/*.mjs\"",
+    "prepublishOnly": "npm run build && npm run test",
+    "docs:check": "node scripts/check-links.mjs",
+    "bench": "node scripts/benchmark/run.mjs",
+    "bench:xpath": "node scripts/benchmark/run.mjs --suite xpath",
+    "bench:xslt": "node scripts/benchmark/run.mjs --suite xslt",
+    "test:bench": "node --test \"scripts/benchmark/*.test.mjs\"",
+    "test:browser": "playwright test -c tests/browser/playwright.config.mjs",
+    "test:binaries": "node --test \"scripts/binaries/*.test.mjs\" \"scripts/lib/*.test.mjs\"",
+    "test:site": "node --test --experimental-test-coverage --test-coverage-include=\"site/**\" --test-coverage-lines=96 \"site/scripts/*.test.mjs\"",
+    "site:content": "node site/scripts/build-content.mjs"
   },
   "keywords": [
     "xslt",
@@ -65,15 +86,34 @@
   "bugs": {
     "url": "https://github.com/spagu/XSLT-Processor/issues"
   },
-  "homepage": "https://github.com/spagu/XSLT-Processor#readme",
+  "homepage": "https://xslt-processor.tradik.com/",
   "engines": {
     "node": ">=20.19.0"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@playwright/test": "^1.63.0",
+    "@xmldom/xmldom": "^0.9.12",
     "esbuild": "^0.28.2",
-    "eslint": "^10.10.0",
-    "jsdom": "^29.1.1",
-    "prettier": "^3.9.6"
+    "eslint": "^10.11.0",
+    "jsdom": "^30.1.1",
+    "linkedom": "^0.18.13",
+    "prettier": "^3.9.9"
+  },
+  "peerDependencies": {
+    "@tradik/xslt3": "^1.0.0",
+    "@xmldom/xmldom": ">=0.9.0",
+    "jsdom": ">=25.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@tradik/xslt3": {
+      "optional": true
+    },
+    "@xmldom/xmldom": {
+      "optional": true
+    },
+    "jsdom": {
+      "optional": true
+    }
   }
 }

package/src/XSLTProcessor.js

@@ -4,6 +4,9 @@
  * Native-compatible XSLTProcessor implementation for browser environments.
  * Based on W3C DOM Level 3 XSL Transformations and XSLT 1.0 Specification.
  *
+ * With the `xsltVersion: "auto"` option, XSLT 2.0/3.0 stylesheets are run by
+ * the optional peer dependency @tradik/xslt3 (see bridge/).
+ *
  * Reference: https://developer.mozilla.org/en-US/docs/Web/API/XSLTProcessor
  * XSLT 1.0: http://www.w3.org/TR/1999/REC-xslt-19991116
  * XPath 1.0: http://www.w3.org/TR/1999/REC-xpath-19991116
@@ -14,6 +17,23 @@
  */
 
 import { XsltEngine } from "./xslt/engine.js";
+import { findParseError } from "./xslt/domParsing.js";
+import { preloadedDocumentLoader } from "./async/preload.js";
+import {
+  importStylesheetAsync,
+  transformAsync,
+  transformToStream,
+} from "./async/processor.js";
+import { createXslt3Engine } from "./bridge/engine.js";
+import { loadXslt3 } from "./bridge/loader.js";
+import { usesXslt3, xsltVersionMode } from "./bridge/version.js";
+
+/**
+ * The native XSLTProcessor constructor that installGlobal() replaced, kept so
+ * that isNativeXSLTSupported() keeps probing the browser's implementation
+ * rather than this one.
+ */
+let nativeProcessor = null;
 
 /**
  * XSLTProcessor
@@ -26,12 +46,79 @@ import { XsltEngine } from "./xslt/engine.js";
  * const fragment = processor.transformToFragment(xmlDoc, document);
  */
 export class XSLTProcessor {
-  constructor() {
+  /**
+   * @param {object} [options] - Non-standard options (the native constructor
+   *   takes none)
+   * @param {boolean} [options.legacyNameTests] - Deprecated: let unprefixed
+   *   name tests (`item`, `@a`) also match nodes in a namespace, as before
+   *   1.2.0. XPath 1.0 and Chrome only match nodes in no namespace.
+   * @param {boolean} [options.enableDynamicEvaluate] - Allow EXSLT
+   *   `dyn:evaluate()`, which evaluates XPath built from strings; enable it
+   *   only for trusted input.
+   * @param {() => Date} [options.clock] - Clock for EXSLT current-time
+   *   functions (reproducible output).
+   * @param {number} [options.maxTemplateDepth] - Deepest nesting of template
+   *   instantiations; deeper recursion throws "Template recursion too deep"
+   *   (default 3000, libxslt's limit).
+   * @param {"1.0"|"auto"} [options.xsltVersion] - "1.0" (default): every
+   *   stylesheet runs with the XSLT 1.0 engine, a `version="2.0"` one in
+   *   forwards-compatible mode, as in Chrome. "auto": a stylesheet whose
+   *   version is 2.0 or more runs with @tradik/xslt3 (an optional peer
+   *   dependency, loaded on demand; see {@link XSLTProcessor.preload}).
+   * @throws {RangeError} For an invalid `xsltVersion`
+   *
+   * @example
+   * // Temporary migration aid for stylesheets written against 1.1.x
+   * const processor = new XSLTProcessor({ legacyNameTests: true });
+   *
+   * @example
+   * // XSLT 2.0/3.0 stylesheets through the same API
+   * const processor = new XSLTProcessor({ xsltVersion: "auto" });
+   * await processor.importStylesheetAsync(xsl20Doc);
+   */
+  constructor(options = {}) {
+    this._options = {
+      legacyNameTests: options?.legacyNameTests === true,
+      enableDynamicEvaluate: options?.enableDynamicEvaluate === true,
+      clock: options?.clock ?? null,
+      maxTemplateDepth: options?.maxTemplateDepth,
+      xsltVersion: xsltVersionMode(options?.xsltVersion),
+    };
     this._engine = null;
     this._stylesheet = null;
     this._parameters = new Map();
     this._stylesheetLoader = null;
     this._documentLoader = null;
+    // Set by importStylesheet/importStylesheetAsync: the URI and modules of
+    // the stylesheet, and the document() documents preloaded asynchronously
+    this._stylesheetUri = undefined;
+    this._modules = [];
+    this._preloadedDocuments = null;
+  }
+
+  /**
+   * Load @tradik/xslt3, so that the synchronous API of processors created
+   * with `xsltVersion: "auto"` can run XSLT 2.0/3.0 stylesheets (the
+   * asynchronous API loads it by itself). Non-W3C.
+   *
+   * @param {"2.0"|"3.0"} [version] - The XSLT version to prepare for
+   * @returns {Promise<void>} Resolves once the engine is loaded
+   * @throws {RangeError} For another version (synchronously)
+   * @throws {Error} Rejects with "Cannot load @tradik/xslt3: install
+   *   @tradik/xslt3 to run XSLT 2.0/3.0 stylesheets" when it is missing
+   *
+   * @example
+   * await XSLTProcessor.preload("3.0");
+   * const processor = new XSLTProcessor({ xsltVersion: "auto" });
+   * processor.importStylesheet(xsl30Doc);
+   */
+  static preload(version = "3.0") {
+    if (version !== "2.0" && version !== "3.0") {
+      throw new RangeError(
+        `Invalid XSLT version "${version}": expected "2.0" or "3.0"`,
+      );
+    }
+    return loadXslt3().then(() => undefined);
   }
 
   /**
@@ -40,9 +127,11 @@ export class XSLTProcessor {
    * The engine is created lazily by {@link XSLTProcessor#importStylesheet},
    * so this getter returns `null` until a stylesheet has been imported.
    * Prefer the public {@link XSLTProcessor#setStylesheetLoader} over reaching
-   * into the engine directly.
+   * into the engine directly. A stylesheet run by @tradik/xslt3
+   * (`xsltVersion: "auto"`) has an `Xslt3Engine` (bridge/engine.js).
    *
-   * @returns {import('./xslt/engine.js').XsltEngine|null} The engine, or null before import
+   * @returns {import('./xslt/engine.js').XsltEngine|import('./bridge/engine.js').Xslt3Engine|null}
+   *   The engine, or null before import
    *
    * @example
    * processor.importStylesheet(xslDoc, '/styles/main.xsl');
@@ -133,7 +222,7 @@ export class XSLTProcessor {
 
     // Keep an already created engine in sync
     if (this._engine) {
-      this._engine.setDocumentLoader(this._documentLoader);
+      this._engine.setDocumentLoader(this._engineDocumentLoader());
     }
 
     return this;
@@ -151,6 +240,10 @@ export class XSLTProcessor {
    *   base URI when resolving relative `xsl:import`/`xsl:include` hrefs. When
    *   omitted, hrefs are passed to the loader unresolved.
    * @returns {void}
+   * @throws {Error} When the stylesheet is malformed or invalid, e.g. has an
+   *   invalid pattern (XSLT 1.0 section 5.2), or, with `xsltVersion: "auto"`,
+   *   is an XSLT 2.0/3.0 stylesheet and @tradik/xslt3 has not been loaded
+   *   ({@link XSLTProcessor.preload})
    *
    * @example
    * const parser = new DOMParser();
@@ -172,31 +265,193 @@ export class XSLTProcessor {
     }
 
     // Check for parser errors
-    const errorNode = style.querySelector
-      ? style.querySelector("parsererror")
-      : null;
-    if (errorNode) {
+    if (findParseError(style)) {
       throw new Error("XSLT stylesheet contains parse errors");
     }
 
-    this._stylesheet = style;
-    this._engine = new XsltEngine({
-      stylesheetLoader: this._stylesheetLoader,
-      documentLoader: this._documentLoader,
-    });
+    this._compile(style, stylesheetUri);
+  }
+
+  /**
+   * Imports a stylesheet whose `xsl:import`/`xsl:include` modules and
+   * literal `document('...')` documents are loaded asynchronously first
+   * (non-W3C). The modules are loaded in parallel, each URI once; a cycle
+   * rejects with "Circular stylesheet reference detected". A document that
+   * fails to load is reported only if the transformation evaluates that
+   * `document()` call. Computed `document()` URIs still go through the
+   * synchronous {@link XSLTProcessor#setDocumentLoader} loader, and modules
+   * that were not preloaded through {@link XSLTProcessor#setStylesheetLoader}.
+   *
+   * @param {Node|string|Uint8Array|ArrayBuffer|ReadableStream|AsyncIterable} style -
+   *   The stylesheet: a node, or markup / a stream of markup to parse
+   * @param {string} [stylesheetUri] - Base URI of relative hrefs and
+   *   `document()` URIs
+   * @param {object} [options] - Loading options
+   * @param {Function} [options.loader] - `(uri, baseUri, { signal }) =>
+   *   Promise<Document|string|Uint8Array|ArrayBuffer|Response|null>`; the
+   *   global `fetch` by default
+   * @param {Function} [options.documentLoader] - Loader of `document()`
+   *   documents, `options.loader` by default
+   * @param {AbortSignal} [options.signal] - Cancels loading
+   * @returns {Promise<void>} Resolves once the stylesheet is imported; on
+   *   failure the processor keeps its previous stylesheet
+   *
+   * @example
+   * await processor.importStylesheetAsync(xslDoc, "https://example.com/xsl/main.xsl");
+   */
+  importStylesheetAsync(style, stylesheetUri, options = {}) {
+    return importStylesheetAsync(this, style, stylesheetUri, options);
+  }
+
+  /**
+   * Compile a stylesheet into a new engine; the processor is only updated
+   * when compiling succeeds.
+   *
+   * @param {Node} style - The stylesheet
+   * @param {string} [stylesheetUri] - Its URI
+   * @param {object} [preloaded] - What importStylesheetAsync loaded
+   * @param {Function|null} [preloaded.stylesheetLoader] - Module loader
+   * @param {Node[]} [preloaded.modules] - Every stylesheet module
+   * @param {Map<string, object>|null} [preloaded.documents] - document() documents
+   * @returns {void}
+   * @private
+   */
+  _compile(style, stylesheetUri, preloaded = {}) {
+    const {
+      stylesheetLoader = this._stylesheetLoader,
+      modules = [style],
+      documents = null,
+    } = preloaded;
+    const engineOptions = {
+      legacyNameTests: this._options.legacyNameTests,
+      enableDynamicEvaluate: this._options.enableDynamicEvaluate,
+      clock: this._options.clock,
+      maxTemplateDepth: this._options.maxTemplateDepth,
+      stylesheetLoader,
+      documentLoader: this._engineDocumentLoader(documents),
+    };
+    const engine = this._usesXslt3(style)
+      ? createXslt3Engine(style, engineOptions)
+      : new XsltEngine(engineOptions);
 
     // Apply any previously set parameters
     for (const [key, value] of this._parameters) {
-      this._engine.setParameterValue(key, value);
+      engine.setParameterValue(key, value);
     }
 
-    this._engine.importStylesheet(style, stylesheetUri);
+    // An invalid stylesheet (e.g. an invalid pattern) throws here and leaves
+    // the processor as it was
+    engine.importStylesheet(style, stylesheetUri);
+    // Modules not preloaded keep going through the configured loader
+    engine.setStylesheetLoader(this._stylesheetLoader);
+    this._engine = engine;
+    this._stylesheet = style;
+    this._stylesheetUri = stylesheetUri;
+    this._modules = modules;
+    this._preloadedDocuments = documents;
+  }
+
+  /**
+   * Whether a stylesheet is run by @tradik/xslt3 (`xsltVersion: "auto"` and
+   * version 2.0 or more).
+   *
+   * @param {Node} style - The stylesheet
+   * @returns {boolean} True for @tradik/xslt3
+   * @private
+   */
+  _usesXslt3(style) {
+    return usesXslt3(style, this._options.xsltVersion);
+  }
+
+  /**
+   * Load the engine a stylesheet needs before compiling it (async API).
+   *
+   * @param {Node} style - The stylesheet
+   * @returns {Promise<void>} Resolves once the engine is available
+   * @private
+   */
+  async _prepareEngine(style) {
+    if (this._usesXslt3(style)) await loadXslt3();
+  }
+
+  /**
+   * The document() loader given to the engine: preloaded documents first,
+   * then the configured synchronous loader.
+   *
+   * @param {Map<string, object>|null} [documents] - Preloaded documents
+   * @returns {Function|null} The loader
+   * @private
+   */
+  _engineDocumentLoader(documents = this._preloadedDocuments) {
+    return documents
+      ? preloadedDocumentLoader(documents, this._documentLoader)
+      : this._documentLoader;
+  }
+
+  /**
+   * Add asynchronously preloaded document() documents.
+   *
+   * @param {Map<string, object>} documents - Preloaded outcomes by URI
+   * @returns {void}
+   * @private
+   */
+  _usePreloadedDocuments(documents) {
+    this._preloadedDocuments = new Map([
+      ...(this._preloadedDocuments ?? []),
+      ...documents,
+    ]);
+    this._engine.setDocumentLoader(this._engineDocumentLoader());
+  }
+
+  /**
+   * Throw the native error of a transformation without stylesheet.
+   *
+   * @param {string} method - The method called
+   * @returns {void}
+   * @throws {Error} When no stylesheet has been imported
+   * @private
+   */
+  _requireStylesheet(method) {
+    if (!this._engine || !this._stylesheet) {
+      throw new Error(
+        `Failed to execute '${method}' on 'XSLTProcessor': No stylesheet has been imported.`,
+      );
+    }
+  }
+
+  /**
+   * Throw the native error of a source that is not a document, element or
+   * fragment.
+   *
+   * @param {string} method - The method called
+   * @param {Node} source - The source node
+   * @returns {void}
+   * @throws {TypeError} For other node types
+   * @private
+   */
+  _checkSource(method, source) {
+    if (
+      source.nodeType !== 1 &&
+      source.nodeType !== 9 &&
+      source.nodeType !== 11
+    ) {
+      throw new TypeError(
+        `Failed to execute '${method}' on 'XSLTProcessor': The source is not a valid node type.`,
+      );
+    }
   }
 
   /**
    * Transforms the node source by applying the XSLT stylesheet.
    * Returns a document fragment.
    *
+   * As in Chrome, when `output` is an HTML document and the output method is
+   * `html` (declared, or detected from an `<html>` result root), the result
+   * is serialized and parsed by the HTML parser of `output`, so it holds
+   * real `HTMLElement`s (`<a>` is an `HTMLAnchorElement`, `<script>` runs
+   * when inserted). Other results keep the element names and namespaces of
+   * the result tree.
+   *
    * @param {Node} source - The XML document to transform
    * @param {Document} output - The document that will own the generated fragment
    * @returns {DocumentFragment} The transformed result as a DocumentFragment
@@ -218,22 +473,9 @@ export class XSLTProcessor {
       );
     }
 
-    if (!this._engine || !this._stylesheet) {
-      throw new Error(
-        "Failed to execute 'transformToFragment' on 'XSLTProcessor': No stylesheet has been imported.",
-      );
-    }
+    this._requireStylesheet("transformToFragment");
 
-    // Validate source node
-    if (
-      source.nodeType !== 1 &&
-      source.nodeType !== 9 &&
-      source.nodeType !== 11
-    ) {
-      throw new TypeError(
-        "Failed to execute 'transformToFragment' on 'XSLTProcessor': The source is not a valid node type.",
-      );
-    }
+    this._checkSource("transformToFragment", source);
 
     // Validate output document
     if (output.nodeType !== 9) {
@@ -243,7 +485,7 @@ export class XSLTProcessor {
     }
 
     try {
-      return this._engine.transform(source, output);
+      return this._engine.transformToFragment(source, output);
     } catch (error) {
       // Match native behavior - return null on error
       console.error("XSLT transformation error:", error);
@@ -269,22 +511,9 @@ export class XSLTProcessor {
       );
     }
 
-    if (!this._engine || !this._stylesheet) {
-      throw new Error(
-        "Failed to execute 'transformToDocument' on 'XSLTProcessor': No stylesheet has been imported.",
-      );
-    }
+    this._requireStylesheet("transformToDocument");
 
-    // Validate source node
-    if (
-      source.nodeType !== 1 &&
-      source.nodeType !== 9 &&
-      source.nodeType !== 11
-    ) {
-      throw new TypeError(
-        "Failed to execute 'transformToDocument' on 'XSLTProcessor': The source is not a valid node type.",
-      );
-    }
+    this._checkSource("transformToDocument", source);
 
     try {
       return this._engine.transformToDocument(source);
@@ -318,22 +547,9 @@ export class XSLTProcessor {
       );
     }
 
-    if (!this._engine || !this._stylesheet) {
-      throw new Error(
-        "Failed to execute 'transformToString' on 'XSLTProcessor': No stylesheet has been imported.",
-      );
-    }
+    this._requireStylesheet("transformToString");
 
-    // Validate source node
-    if (
-      source.nodeType !== 1 &&
-      source.nodeType !== 9 &&
-      source.nodeType !== 11
-    ) {
-      throw new TypeError(
-        "Failed to execute 'transformToString' on 'XSLTProcessor': The source is not a valid node type.",
-      );
-    }
+    this._checkSource("transformToString", source);
 
     try {
       return this._engine.transformToString(source);
@@ -344,6 +560,57 @@ export class XSLTProcessor {
     }
   }
 
+  /**
+   * Transforms asynchronously and resolves with the serialized result
+   * (non-W3C). The source may be a node, markup, bytes, a `ReadableStream`
+   * or an async iterable of strings or bytes; streams are read to their end
+   * before parsing, because XSLT 1.0 needs the whole source tree. Unlike
+   * {@link XSLTProcessor#transformToString}, failures reject the promise.
+   *
+   * @param {Node|string|Uint8Array|ArrayBuffer|ReadableStream|AsyncIterable} source - Input
+   * @param {object} [options] - Options
+   * @param {AbortSignal} [options.signal] - Cancels loading and reading
+   * @param {Node|string|ReadableStream|AsyncIterable} [options.stylesheet] -
+   *   A stylesheet to import first with importStylesheetAsync
+   * @param {string} [options.stylesheetUri] - The URI of that stylesheet
+   * @param {Function} [options.fetchStylesheet] - Asynchronous loader of its
+   *   xsl:import/xsl:include modules (`fetch` by default)
+   * @param {Function} [options.fetchDocument] - Asynchronous loader of the
+   *   literal document() documents (`fetchStylesheet` by default when a
+   *   stylesheet is given)
+   * @returns {Promise<string>} The serialized result
+   *
+   * @example
+   * const html = await processor.transformAsync((await fetch("data.xml")).body);
+   */
+  transformAsync(source, options = {}) {
+    return transformAsync(this, source, options);
+  }
+
+  /**
+   * Transforms and returns the serialized result as a `ReadableStream` of
+   * strings (non-W3C). The result tree is built in memory on the first read;
+   * serialization then produces chunks of about `chunkSize` code units on
+   * demand, so the output is never one string and the first bytes are
+   * available before serialization ends. Failures error the stream.
+   *
+   * @param {Node|string|Uint8Array|ArrayBuffer|ReadableStream|AsyncIterable} source - Input
+   * @param {{signal?: AbortSignal, chunkSize?: number}} [options] - `signal`
+   *   cancels (errors the stream with its reason); `chunkSize` defaults to
+   *   16384
+   * @returns {ReadableStream<string>} The serialized result
+   * @throws {Error} When no stylesheet has been imported
+   * @throws {TypeError} For a source node of the wrong type
+   * @throws {RangeError} For an invalid chunk size
+   *
+   * @example
+   * // Node.js
+   * Readable.fromWeb(processor.transformToStream(xmlDoc)).pipe(process.stdout);
+   */
+  transformToStream(source, options = {}) {
+    return transformToStream(this, source, options);
+  }
+
   /**
    * Sets a parameter in the XSLT stylesheet.
    *
@@ -482,22 +749,28 @@ export class XSLTProcessor {
   reset() {
     this._engine = null;
     this._stylesheet = null;
+    this._stylesheetUri = undefined;
+    this._modules = [];
+    this._preloadedDocuments = null;
     this._parameters.clear();
   }
 }
 
 /**
- * Check if native XSLTProcessor is available and functional
+ * Check if native XSLTProcessor is available and functional.
+ *
+ * After installGlobal() replaced the global, the original native constructor
+ * is probed; this implementation never counts as native.
  *
  * @returns {boolean} True if native XSLTProcessor works correctly
  */
 export function isNativeXSLTSupported() {
-  if (typeof globalThis.XSLTProcessor === "undefined") {
-    return false;
-  }
+  const current = globalThis.XSLTProcessor;
+  const Native = current === XSLTProcessor ? nativeProcessor : current;
+  if (typeof Native !== "function") return false;
 
   try {
-    const processor = new globalThis.XSLTProcessor();
+    const processor = new Native();
     const parser = new DOMParser();
 
     const xslt = parser.parseFromString(
@@ -530,6 +803,10 @@ export function installGlobal(force = false) {
     return false;
   }
 
+  const current = globalThis.XSLTProcessor;
+  if (typeof current === "function" && current !== XSLTProcessor) {
+    nativeProcessor = current;
+  }
   globalThis.XSLTProcessor = XSLTProcessor;
   return true;
 }

package/src/async/abort.js

@@ -0,0 +1,63 @@
+/**
+ * AbortSignal Helpers
+ *
+ * Every asynchronous entry point takes an optional `signal`. It is checked
+ * between steps (and between output chunks), passed to loaders, and raced
+ * against loader promises so that a loader ignoring the signal cannot keep an
+ * aborted call pending. The synchronous parts (compiling the stylesheet,
+ * building the result tree) cannot be interrupted once started.
+ *
+ * @module async/abort
+ */
+
+/**
+ * The reason of an aborted signal, with a DOMException fallback for
+ * implementations without `reason`.
+ *
+ * @param {AbortSignal} signal - An aborted signal
+ * @returns {*} The abort reason
+ */
+function abortReason(signal) {
+  return (
+    signal.reason ??
+    new globalThis.DOMException("This operation was aborted", "AbortError")
+  );
+}
+
+/**
+ * Throw the abort reason when a signal is aborted.
+ *
+ * @param {AbortSignal} [signal] - Optional signal
+ * @returns {void}
+ * @throws {*} The abort reason
+ *
+ * @example
+ * throwIfAborted(options.signal);
+ */
+export function throwIfAborted(signal) {
+  if (signal?.aborted) throw abortReason(signal);
+}
+
+/**
+ * Settle with a promise, or reject with the abort reason as soon as the
+ * signal aborts, whichever comes first.
+ *
+ * @template T
+ * @param {Promise<T>|T} work - The pending work
+ * @param {AbortSignal} [signal] - Optional signal
+ * @returns {Promise<T>} The work's outcome, or the abort rejection
+ *
+ * @example
+ * const text = await abortable(loader(uri), signal);
+ */
+export function abortable(work, signal) {
+  if (!signal) return Promise.resolve(work);
+  if (signal.aborted) return Promise.reject(abortReason(signal));
+  return new Promise((resolve, reject) => {
+    const onAbort = () => reject(abortReason(signal));
+    signal.addEventListener("abort", onAbort, { once: true });
+    Promise.resolve(work)
+      .then(resolve, reject)
+      .finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}