@tradik/xslt-processor 1.0.3 → 1.1.1

package/dist/xslt-processor.browser.js

@@ -33,9 +33,13 @@ var XsltProcessorLib = (() => {
     isBrowser: () => isBrowser,
     isNativeXSLTSupported: () => isNativeXSLTSupported,
     isNode: () => isNode,
+    isRawText: () => isRawText,
+    markRawText: () => markRawText,
     parseXPath: () => parse,
+    resolveOutputSettings: () => resolveOutputSettings,
     selectFirstXPath: () => selectFirst,
-    selectXPath: () => select
+    selectXPath: () => select,
+    serializeResult: () => serializeResult
   });
 
   // src/xpath/tokenizer.js
@@ -821,12 +825,22 @@ var XsltProcessorLib = (() => {
     "__lookupSetter__"
   ]);
   var XPathContext = class _XPathContext {
-    constructor(node, position = 1, size = 1, variables = {}, namespaces = {}) {
+    /**
+     * @param {Node} node - The context node
+     * @param {number} [position] - The context position (1-based)
+     * @param {number} [size] - The context size
+     * @param {Object} [variables] - Variable bindings by name
+     * @param {Object} [namespaces] - Namespace bindings by prefix
+     * @param {*} [hostContext] - Opaque context of the host language (XSLT),
+     *   carried through unchanged so host defined functions can reach it
+     */
+    constructor(node, position = 1, size = 1, variables = {}, namespaces = {}, hostContext = null) {
       this.node = node;
       this.position = position;
       this.size = size;
       this.variables = variables;
       this.namespaces = namespaces;
+      this.hostContext = hostContext;
     }
     clone(overrides = {}) {
       return new _XPathContext(
@@ -834,13 +848,17 @@ var XsltProcessorLib = (() => {
         overrides.position ?? this.position,
         overrides.size ?? this.size,
         overrides.variables ?? this.variables,
-        overrides.namespaces ?? this.namespaces
+        overrides.namespaces ?? this.namespaces,
+        overrides.hostContext ?? this.hostContext
       );
     }
   };
   var XPathEvaluator = class {
     constructor(options = {}) {
-      this.functions = this.initCoreFunctions();
+      this.functions = Object.assign(
+        /* @__PURE__ */ Object.create(null),
+        this.initCoreFunctions()
+      );
       this.maxRecursionDepth = options.maxRecursionDepth ?? XPathLimits.MAX_RECURSION_DEPTH;
       this.maxResultSize = options.maxResultSize ?? XPathLimits.MAX_RESULT_SIZE;
       this.maxStringLength = options.maxStringLength ?? XPathLimits.MAX_STRING_LENGTH;
@@ -1190,7 +1208,7 @@ var XsltProcessorLib = (() => {
         case "node":
           return true;
         case "text":
-          return node.nodeType === 3;
+          return node.nodeType === 3 || node.nodeType === 4;
         case "comment":
           return node.nodeType === 8;
         case "processing-instruction":
@@ -1231,13 +1249,31 @@ var XsltProcessorLib = (() => {
       }
       return context.variables[name];
     }
+    /**
+     * Register additional functions, for example the XSLT function library.
+     *
+     * Existing names are overwritten, so a host language can also specialise a
+     * core function. Each function is called as `fn(args, context)` with the
+     * evaluator as `this`.
+     *
+     * @param {Object<string, Function>} functions - Functions by name
+     * @returns {XPathEvaluator} This evaluator, to allow chaining
+     *
+     * @example
+     * evaluator.registerFunctions({ 'my:double': (args, ctx) => 2 });
+     */
+    registerFunctions(functions) {
+      for (const [name, fn] of Object.entries(functions)) {
+        this.functions[name] = fn;
+      }
+      return this;
+    }
     evalFunctionCall(ast, context) {
       const name = ast.prefix ? `${ast.prefix}:${ast.name}` : ast.name;
-      const fn = this.functions[name];
-      if (!fn) {
+      if (!Object.hasOwn(this.functions, name)) {
         throw new Error(`Unknown function: ${name}`);
       }
-      return fn.call(this, ast.args, context);
+      return this.functions[name].call(this, ast.args, context);
     }
     // Type conversion functions
     toBoolean(value) {
@@ -1294,7 +1330,7 @@ var XsltProcessorLib = (() => {
         case 11: {
           let text = "";
           const walker = (n) => {
-            if (n.nodeType === 3) {
+            if (n.nodeType === 3 || n.nodeType === 4) {
               text += n.nodeValue || "";
             } else if (n.childNodes) {
               for (const child of n.childNodes) {
@@ -1599,8 +1635,1486 @@ var XsltProcessorLib = (() => {
     }
   };
 
+  // src/xslt/elements.js
+  var XSLT_NAMESPACE = "http://www.w3.org/1999/XSL/Transform";
+  var XSLT_ELEMENTS = Object.freeze([
+    "apply-imports",
+    "apply-templates",
+    "attribute",
+    "call-template",
+    "choose",
+    "comment",
+    "copy",
+    "copy-of",
+    "element",
+    "fallback",
+    "for-each",
+    "if",
+    "message",
+    "number",
+    "otherwise",
+    "param",
+    "processing-instruction",
+    "sort",
+    "text",
+    "value-of",
+    "variable",
+    "when",
+    "with-param"
+  ]);
+  var ELEMENT_SET = new Set(XSLT_ELEMENTS);
+  function isXsltElementAvailable(localName) {
+    return ELEMENT_SET.has(localName);
+  }
+
+  // src/xslt/formatNumber.js
+  var DEFAULT_DECIMAL_FORMAT = Object.freeze({
+    decimalSeparator: ".",
+    groupingSeparator: ",",
+    percent: "%",
+    perMille: "\u2030",
+    zeroDigit: "0",
+    digit: "#",
+    patternSeparator: ";",
+    infinity: "Infinity",
+    nan: "NaN",
+    minusSign: "-"
+  });
+  function splitSubPatterns(pattern, format) {
+    const index = pattern.indexOf(format.patternSeparator);
+    if (index === -1) return { positive: pattern, negative: null };
+    return {
+      positive: pattern.substring(0, index),
+      negative: pattern.substring(index + format.patternSeparator.length)
+    };
+  }
+  function parseSubPattern(subPattern, format) {
+    const special = /* @__PURE__ */ new Set([
+      format.digit,
+      format.zeroDigit,
+      format.groupingSeparator,
+      format.decimalSeparator
+    ]);
+    let start = 0;
+    while (start < subPattern.length && !special.has(subPattern[start])) start++;
+    let end = start;
+    while (end < subPattern.length && special.has(subPattern[end])) end++;
+    const prefix = subPattern.substring(0, start);
+    const numeric = subPattern.substring(start, end);
+    const suffix = subPattern.substring(end);
+    const decimalIndex = numeric.indexOf(format.decimalSeparator);
+    const integerPart = decimalIndex === -1 ? numeric : numeric.substring(0, decimalIndex);
+    const fractionPart = decimalIndex === -1 ? "" : numeric.substring(decimalIndex + 1);
+    const groupingIndex = integerPart.lastIndexOf(format.groupingSeparator);
+    const affixes = prefix + suffix;
+    let multiplier = 1;
+    if (affixes.includes(format.percent)) multiplier = 100;
+    else if (affixes.includes(format.perMille)) multiplier = 1e3;
+    return {
+      prefix,
+      suffix,
+      multiplier,
+      minInteger: countOccurrences(integerPart, format.zeroDigit),
+      minFraction: countOccurrences(fractionPart, format.zeroDigit),
+      maxFraction: Math.min(fractionPart.length, 100),
+      groupingSize: groupingIndex === -1 ? 0 : integerPart.length - groupingIndex - 1
+    };
+  }
+  function countOccurrences(text, char) {
+    let total = 0;
+    for (const current of text) {
+      if (current === char) total++;
+    }
+    return total;
+  }
+  function applyGrouping(digits, size, separator) {
+    if (size <= 0 || digits.length <= size) return digits;
+    let result = "";
+    for (let i = 0; i < digits.length; i++) {
+      const fromEnd = digits.length - i;
+      if (i > 0 && fromEnd % size === 0) result += separator;
+      result += digits[i];
+    }
+    return result;
+  }
+  function translateDigits(text, zeroDigit) {
+    const offset = zeroDigit.codePointAt(0) - 48;
+    if (offset === 0) return text;
+    return text.replaceAll(
+      /\d/g,
+      (digit) => String.fromCodePoint(digit.codePointAt(0) + offset)
+    );
+  }
+  function formatMagnitude(magnitude, spec, format) {
+    const fixed = magnitude.toFixed(spec.maxFraction);
+    const [rawInteger, rawFraction = ""] = fixed.split(".");
+    let fraction = rawFraction;
+    while (fraction.length > spec.minFraction && fraction.endsWith("0")) {
+      fraction = fraction.slice(0, -1);
+    }
+    let integer = rawInteger.padStart(spec.minInteger, "0");
+    if (spec.minInteger === 0 && integer === "0" && fraction.length > 0) {
+      integer = "";
+    }
+    integer = applyGrouping(integer, spec.groupingSize, format.groupingSeparator);
+    const body = fraction.length > 0 ? integer + format.decimalSeparator + fraction : integer;
+    return translateDigits(body, format.zeroDigit);
+  }
+  function formatNumber(value, pattern, decimalFormat = DEFAULT_DECIMAL_FORMAT) {
+    const format = { ...DEFAULT_DECIMAL_FORMAT, ...decimalFormat };
+    if (typeof value !== "number" || Number.isNaN(value)) return format.nan;
+    const subPatterns = splitSubPatterns(pattern, format);
+    const positive = parseSubPattern(subPatterns.positive, format);
+    const isNegative = value < 0;
+    let spec = positive;
+    let prefix = positive.prefix;
+    let suffix = positive.suffix;
+    if (isNegative) {
+      if (subPatterns.negative !== null) {
+        spec = parseSubPattern(subPatterns.negative, format);
+        prefix = spec.prefix;
+        suffix = spec.suffix;
+      } else {
+        prefix = format.minusSign + positive.prefix;
+      }
+    }
+    const magnitude = Math.abs(value) * spec.multiplier;
+    const body = Number.isFinite(magnitude) ? formatMagnitude(magnitude, spec, format) : format.infinity;
+    return prefix + body + suffix;
+  }
+
+  // src/xslt/functions.js
+  var VENDOR = "@tradik/xslt-processor";
+  var VENDOR_URL = "https://github.com/spagu/XSLT-Processor";
+  var SYSTEM_PROPERTIES = Object.freeze({
+    "xsl:version": "1",
+    "xsl:vendor": VENDOR,
+    "xsl:vendor-url": VENDOR_URL
+  });
+  function ownerDocumentOf(node) {
+    return node.ownerDocument || node;
+  }
+  function toStringList(evaluator, stringify, value) {
+    if (Array.isArray(value)) {
+      return value.map((node) => evaluator.getStringValue(node));
+    }
+    return [stringify(value)];
+  }
+  function splitQName(qname) {
+    const colon = qname.indexOf(":");
+    if (colon === -1) return { prefix: null, localName: qname };
+    return {
+      prefix: qname.substring(0, colon),
+      localName: qname.substring(colon + 1)
+    };
+  }
+  function createXsltFunctions(engine) {
+    const evaluator = engine.xpathEvaluator;
+    const stringify = evaluator.toString.bind(evaluator);
+    const evaluate2 = (arg, ctx) => evaluator.evaluate(arg, ctx);
+    const asString = (arg, ctx) => stringify(evaluate2(arg, ctx));
+    return {
+      /**
+       * `document(object, base?)` - load external XML documents.
+       *
+       * An empty URI denotes the stylesheet itself. Without a document loader, or
+       * when the loader returns null, the result is an empty node-set. The
+       * optional second argument is read as a base URI string.
+       */
+      document: (args, ctx) => {
+        const baseUri = args.length > 1 ? asString(args[1], ctx) : engine.baseUri;
+        const uris = toStringList(evaluator, stringify, evaluate2(args[0], ctx));
+        const result = [];
+        for (const uri of uris) {
+          const doc = engine.loadDocument(uri, baseUri || engine.baseUri);
+          if (doc && !result.includes(doc)) result.push(doc);
+        }
+        return result;
+      },
+      /** `key(name, value)` - look up nodes through an `xsl:key` index. */
+      key: (args, ctx) => {
+        const name = asString(args[0], ctx);
+        const values = toStringList(evaluator, stringify, evaluate2(args[1], ctx));
+        return engine.keyRegistry.lookup(name, values, ownerDocumentOf(ctx.node));
+      },
+      /** `format-number(number, pattern, decimalFormat?)`. */
+      "format-number": (args, ctx) => {
+        const value = evaluator.toNumber(evaluate2(args[0], ctx));
+        const pattern = asString(args[1], ctx);
+        const formatName = args.length > 2 ? asString(args[2], ctx) : "";
+        const format = engine.decimalFormats[formatName] || DEFAULT_DECIMAL_FORMAT;
+        return formatNumber(value, pattern, format);
+      },
+      /** `current()` - the XSLT current node, not the XPath context node. */
+      current: (args, ctx) => {
+        const currentNode = ctx.hostContext?.currentNode;
+        return currentNode ? [currentNode] : [ctx.node];
+      },
+      /** `generate-id(node-set?)` - a stable id for the life of the transform. */
+      "generate-id": (args, ctx) => {
+        let node = ctx.node;
+        if (args.length > 0) {
+          const nodeSet = evaluate2(args[0], ctx);
+          node = Array.isArray(nodeSet) ? nodeSet[0] : nodeSet;
+        }
+        return node ? engine.generateId(node) : "";
+      },
+      /** `system-property(name)` - XSLT version and vendor information. */
+      "system-property": (args, ctx) => {
+        const name = asString(args[0], ctx);
+        return Object.hasOwn(SYSTEM_PROPERTIES, name) ? SYSTEM_PROPERTIES[name] : "";
+      },
+      /** `function-available(name)` - reflects the evaluator function table. */
+      "function-available": (args, ctx) => {
+        const name = asString(args[0], ctx);
+        return Object.hasOwn(evaluator.functions, name);
+      },
+      /** `element-available(name)` - reflects the XSLT elements the engine runs. */
+      "element-available": (args, ctx) => {
+        const { prefix, localName } = splitQName(asString(args[0], ctx));
+        if (!prefix) return false;
+        const namespaceUri = ctx.namespaces[prefix] ?? (prefix === "xsl" ? XSLT_NAMESPACE : null);
+        return namespaceUri === XSLT_NAMESPACE && isXsltElementAvailable(localName);
+      },
+      /**
+       * `unparsed-entity-uri(name)` - always empty.
+       *
+       * Unparsed entity declarations are not exposed by the DOM, so this
+       * processor cannot resolve them; returning the empty string keeps
+       * stylesheets that call the function working.
+       */
+      "unparsed-entity-uri": () => ""
+    };
+  }
+
+  // src/xslt/keys.js
+  var KeyIndexRegistry = class {
+    /**
+     * @param {Object} options - Registry configuration
+     * @param {Object<string, {match: string, use: string}>} options.keys - Declared keys by name
+     * @param {(node: Node, pattern: string) => boolean} options.matchesPattern - XSLT pattern matcher
+     * @param {(node: Node, expression: string) => string[]} options.evaluateUse - `use` evaluator returning key values
+     */
+    constructor({ keys, matchesPattern, evaluateUse }) {
+      this.keys = keys;
+      this.matchesPattern = matchesPattern;
+      this.evaluateUse = evaluateUse;
+      this.cache = /* @__PURE__ */ new WeakMap();
+    }
+    /**
+     * Drop every cached index, for example after the key declarations changed.
+     *
+     * @returns {void}
+     *
+     * @example
+     * registry.clear();
+     */
+    clear() {
+      this.cache = /* @__PURE__ */ new WeakMap();
+    }
+    /**
+     * Look up the nodes indexed under one or more key values.
+     *
+     * @param {string} name - The key name
+     * @param {string|string[]} values - One key value, or several to union
+     * @param {Document} doc - The document to search
+     * @returns {Node[]} Matching nodes in document order, without duplicates
+     * @throws {Error} When the key name was never declared
+     *
+     * @example
+     * registry.lookup('byId', 'a1', xmlDoc);
+     */
+    lookup(name, values, doc) {
+      if (!Object.hasOwn(this.keys, name)) {
+        throw new Error(`Undefined key: ${name}`);
+      }
+      const index = this.getIndex(name, doc);
+      const wanted = Array.isArray(values) ? values : [values];
+      const result = [];
+      for (const value of wanted) {
+        for (const node of index.get(value) || []) {
+          if (!result.includes(node)) result.push(node);
+        }
+      }
+      return result;
+    }
+    /**
+     * Get (building if needed) the index of one key for one document.
+     *
+     * @param {string} name - The key name
+     * @param {Document} doc - The document being indexed
+     * @returns {Map<string, Node[]>} Key value to nodes
+     */
+    getIndex(name, doc) {
+      let byName = this.cache.get(doc);
+      if (!byName) {
+        byName = /* @__PURE__ */ new Map();
+        this.cache.set(doc, byName);
+      }
+      let index = byName.get(name);
+      if (!index) {
+        index = this.buildIndex(name, doc);
+        byName.set(name, index);
+      }
+      return index;
+    }
+    /**
+     * Build the index of one key for one document.
+     *
+     * @param {string} name - The key name
+     * @param {Document} doc - The document being indexed
+     * @returns {Map<string, Node[]>} Key value to nodes
+     */
+    buildIndex(name, doc) {
+      const { match, use } = this.keys[name];
+      const index = /* @__PURE__ */ new Map();
+      for (const node of documentOrderNodes(doc)) {
+        if (!this.matchesPattern(node, match)) continue;
+        for (const value of this.evaluateUse(node, use)) {
+          const bucket = index.get(value);
+          if (bucket) bucket.push(node);
+          else index.set(value, [node]);
+        }
+      }
+      return index;
+    }
+  };
+  function* documentOrderNodes(root) {
+    const stack = [root];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      yield current;
+      if (current.nodeType === 1 && current.attributes) {
+        for (const attribute of current.attributes) yield attribute;
+      }
+      const children = current.childNodes;
+      if (children) {
+        for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
+      }
+    }
+  }
+
+  // src/xslt/number.js
+  var COUNTABLE_NODE_TYPES = /* @__PURE__ */ new Set([1, 3, 4, 7, 8]);
+  function matchesDefaultCount(candidate, node) {
+    if (candidate.nodeType !== node.nodeType) return false;
+    if (candidate.nodeType === 1) return candidate.nodeName === node.nodeName;
+    return true;
+  }
+  function createCountPredicate(node, count, matcher) {
+    if (count) return (candidate) => matcher(candidate, count);
+    return (candidate) => matchesDefaultCount(candidate, node);
+  }
+  function createFromPredicate(from, matcher) {
+    if (!from) return () => false;
+    return (candidate) => matcher(candidate, from);
+  }
+  function siblingPosition(node, isCounted) {
+    let position = 1;
+    let sibling = node.previousSibling;
+    while (sibling) {
+      if (COUNTABLE_NODE_TYPES.has(sibling.nodeType) && isCounted(sibling)) {
+        position++;
+      }
+      sibling = sibling.previousSibling;
+    }
+    return position;
+  }
+  function nodesUpToTarget(target) {
+    const root = target.ownerDocument || target;
+    const result = [];
+    const stack = [root];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      result.push(current);
+      if (current === target) break;
+      const children = current.childNodes;
+      if (children) {
+        for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
+      }
+    }
+    return result;
+  }
+  function countSingle(node, isCounted, isFrom) {
+    let current = node;
+    while (current && current.nodeType !== 9) {
+      if (isFrom(current)) return [];
+      if (isCounted(current)) return [siblingPosition(current, isCounted)];
+      current = current.parentNode;
+    }
+    return [];
+  }
+  function countMultiple(node, isCounted, isFrom) {
+    const numbers = [];
+    let current = node;
+    while (current && current.nodeType !== 9) {
+      if (isFrom(current)) break;
+      if (isCounted(current)) {
+        numbers.unshift(siblingPosition(current, isCounted));
+      }
+      current = current.parentNode;
+    }
+    return numbers;
+  }
+  function countAny(node, isCounted, isFrom) {
+    let total = 0;
+    for (const candidate of nodesUpToTarget(node)) {
+      if (!COUNTABLE_NODE_TYPES.has(candidate.nodeType)) continue;
+      if (isFrom(candidate)) {
+        total = 0;
+        continue;
+      }
+      if (isCounted(candidate)) total++;
+    }
+    return total > 0 ? [total] : [];
+  }
+  function countXsltNumber(node, options, matcher) {
+    const { level = "single", count = null, from = null } = options;
+    const isCounted = createCountPredicate(node, count, matcher);
+    const isFrom = createFromPredicate(from, matcher);
+    if (level === "any") return countAny(node, isCounted, isFrom);
+    if (level === "multiple") return countMultiple(node, isCounted, isFrom);
+    return countSingle(node, isCounted, isFrom);
+  }
+
+  // src/xslt/numberFormat.js
+  function toAlphabetic(value, upperCase) {
+    let remaining = value;
+    let result = "";
+    while (remaining > 0) {
+      const index = (remaining - 1) % 26;
+      result = String.fromCodePoint((upperCase ? 65 : 97) + index) + result;
+      remaining = Math.floor((remaining - 1) / 26);
+    }
+    return result;
+  }
+  var ROMAN_NUMERALS = Object.freeze([
+    ["M", 1e3],
+    ["CM", 900],
+    ["D", 500],
+    ["CD", 400],
+    ["C", 100],
+    ["XC", 90],
+    ["L", 50],
+    ["XL", 40],
+    ["X", 10],
+    ["IX", 9],
+    ["V", 5],
+    ["IV", 4],
+    ["I", 1]
+  ]);
+  function toRoman(value) {
+    let remaining = value;
+    let result = "";
+    for (const [numeral, amount] of ROMAN_NUMERALS) {
+      while (remaining >= amount) {
+        result += numeral;
+        remaining -= amount;
+      }
+    }
+    return result;
+  }
+  function formatToken(value, token) {
+    if (/^\d+$/.test(token)) {
+      return String(value).padStart(token.length, "0");
+    }
+    if (value <= 0) return String(value);
+    switch (token) {
+      case "a":
+        return toAlphabetic(value, false);
+      case "A":
+        return toAlphabetic(value, true);
+      case "i":
+        return toRoman(value).toLowerCase();
+      case "I":
+        return toRoman(value);
+      default:
+        return String(value);
+    }
+  }
+  function parseFormat(format) {
+    const parts = format.match(/[a-zA-Z0-9]+|[^a-zA-Z0-9]+/g) || [];
+    const isToken = (part) => /^[a-zA-Z0-9]+$/.test(part);
+    const tokens = [];
+    const separators = [];
+    let prefix = "";
+    let suffix = "";
+    for (const part of parts) {
+      if (isToken(part)) tokens.push(part);
+      else if (tokens.length === 0) prefix = part;
+      else separators.push(part);
+    }
+    if (parts.length > 0 && tokens.length > 0 && !isToken(parts.at(-1))) {
+      suffix = separators.pop();
+    }
+    if (tokens.length === 0) tokens.push("1");
+    return { prefix, suffix, tokens, separators };
+  }
+  function formatXsltNumber(numbers, format = "1") {
+    if (numbers.length === 0) return "";
+    const { prefix, suffix, tokens, separators } = parseFormat(format);
+    let result = prefix;
+    numbers.forEach((value, index) => {
+      if (index > 0) {
+        const separator = separators[index - 1] ?? separators.at(-1) ?? ".";
+        result += separator;
+      }
+      result += formatToken(value, tokens[index] ?? tokens.at(-1));
+    });
+    return result + suffix;
+  }
+
+  // src/xslt/uri.js
+  var ABSOLUTE_URI_PATTERN = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+  function resolveUri(href, baseUri) {
+    if (!href) return href;
+    if (!baseUri || isAbsoluteUri(href) || href.startsWith("/")) {
+      return href;
+    }
+    const lastSlash = baseUri.lastIndexOf("/");
+    const baseDir = lastSlash >= 0 ? baseUri.substring(0, lastSlash + 1) : "";
+    return baseDir + href;
+  }
+  function isAbsoluteUri(uri) {
+    return ABSOLUTE_URI_PATTERN.test(uri);
+  }
+  function stripFragment(uri) {
+    if (typeof uri !== "string") return "";
+    const hash = uri.indexOf("#");
+    return hash === -1 ? uri : uri.substring(0, hash);
+  }
+
+  // src/xslt/whitespace.js
+  var DOCUMENT_TYPE_NODE = 10;
+  function nameTestPriority(nameTest) {
+    if (nameTest === "*") return -0.5;
+    if (nameTest.endsWith(":*")) return -0.25;
+    return 0;
+  }
+  function matchesNameTest(element, nameTest) {
+    if (nameTest === "*") return true;
+    if (nameTest.endsWith(":*")) {
+      const prefix = nameTest.slice(0, -2);
+      return element.nodeName.startsWith(`${prefix}:`);
+    }
+    return element.nodeName === nameTest || element.localName === nameTest;
+  }
+  var WhitespaceFilter = class {
+    /**
+     * @param {string[]} [stripSpace] - Name tests from `xsl:strip-space`
+     * @param {string[]} [preserveSpace] - Name tests from `xsl:preserve-space`
+     */
+    constructor(stripSpace = [], preserveSpace = []) {
+      this.stripSpace = stripSpace;
+      this.preserveSpace = preserveSpace;
+    }
+    /**
+     * Whether the filter can remove anything at all.
+     *
+     * @returns {boolean} True when at least one `xsl:strip-space` was declared
+     *
+     * @example
+     * new WhitespaceFilter(['*']).isActive(); // true
+     */
+    isActive() {
+      return this.stripSpace.length > 0;
+    }
+    /**
+     * Whether whitespace-only children of an element are stripped.
+     *
+     * The most specific name test wins; `xsl:preserve-space` wins ties.
+     *
+     * @param {Element} element - The parent element
+     * @returns {boolean} True when whitespace-only text children are removed
+     *
+     * @example
+     * new WhitespaceFilter(['*'], ['pre']).isStripped(preElement); // false
+     */
+    isStripped(element) {
+      let stripPriority = -Infinity;
+      let preservePriority = -Infinity;
+      for (const nameTest of this.stripSpace) {
+        if (matchesNameTest(element, nameTest)) {
+          stripPriority = Math.max(stripPriority, nameTestPriority(nameTest));
+        }
+      }
+      for (const nameTest of this.preserveSpace) {
+        if (matchesNameTest(element, nameTest)) {
+          preservePriority = Math.max(
+            preservePriority,
+            nameTestPriority(nameTest)
+          );
+        }
+      }
+      return stripPriority > -Infinity && stripPriority > preservePriority;
+    }
+  };
+  function hasXmlSpacePreserve(node) {
+    let current = node;
+    while (current?.nodeType === 1) {
+      const value = current.getAttribute("xml:space");
+      if (value === "preserve") return true;
+      if (value === "default") return false;
+      current = current.parentNode;
+    }
+    return false;
+  }
+  function pruneWhitespace(root, filter) {
+    const doomed = [];
+    const stack = [root];
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if ((current.nodeType === 3 || current.nodeType === 4) && current.nodeValue !== null && current.nodeValue.trim() === "" && current.parentNode?.nodeType === 1 && filter.isStripped(current.parentNode) && !hasXmlSpacePreserve(current.parentNode)) {
+        doomed.push(current);
+      }
+      const children = current.childNodes;
+      if (children) {
+        for (let i = children.length - 1; i >= 0; i--) stack.push(children[i]);
+      }
+    }
+    for (const node of doomed) node.remove();
+  }
+  function stripWhitespaceNodes(sourceNode, filter, targetDoc) {
+    let root;
+    if (sourceNode.nodeType === 9) {
+      root = targetDoc;
+      for (const child of Array.from(sourceNode.childNodes)) {
+        if (child.nodeType === DOCUMENT_TYPE_NODE) continue;
+        targetDoc.appendChild(targetDoc.importNode(child, true));
+      }
+    } else {
+      root = targetDoc.importNode(sourceNode, true);
+      targetDoc.appendChild(root);
+    }
+    pruneWhitespace(root, filter);
+    return root;
+  }
+
+  // src/xslt/literalResult.js
+  function lookupNamespaceUri(node, prefix) {
+    if (typeof node.lookupNamespaceURI === "function") {
+      const found = node.lookupNamespaceURI(prefix);
+      if (found) return found;
+    }
+    const attributeName = prefix ? `xmlns:${prefix}` : "xmlns";
+    let current = node;
+    while (current?.nodeType === 1) {
+      const value = current.getAttribute(attributeName);
+      if (value) return value;
+      current = current.parentNode;
+    }
+    return null;
+  }
+  var NamespaceAliasMap = class {
+    constructor() {
+      this.byUri = /* @__PURE__ */ new Map();
+    }
+    /**
+     * Record one `xsl:namespace-alias` declaration.
+     *
+     * @param {Element} node - The `xsl:namespace-alias` element
+     * @returns {void}
+     *
+     * @example
+     * aliases.add(namespaceAliasElement);
+     */
+    add(node) {
+      const stylesheetPrefix = node.getAttribute("stylesheet-prefix");
+      const resultPrefix = node.getAttribute("result-prefix");
+      if (!stylesheetPrefix || !resultPrefix) return;
+      const fromUri = lookupNamespaceUri(
+        node,
+        stylesheetPrefix === "#default" ? null : stylesheetPrefix
+      );
+      if (!fromUri) return;
+      const isDefaultResult = resultPrefix === "#default";
+      const toUri = lookupNamespaceUri(
+        node,
+        isDefaultResult ? null : resultPrefix
+      );
+      this.byUri.set(fromUri, {
+        uri: toUri,
+        prefix: isDefaultResult ? null : resultPrefix
+      });
+    }
+    /**
+     * Whether any alias was declared.
+     *
+     * @returns {boolean} True when at least one alias is known
+     *
+     * @example
+     * aliases.isEmpty();
+     */
+    isEmpty() {
+      return this.byUri.size === 0;
+    }
+    /**
+     * Apply aliasing to a literal result name.
+     *
+     * @param {string|null} namespaceUri - The namespace of the stylesheet node
+     * @param {string} localName - The local name of the stylesheet node
+     * @returns {{namespaceUri: (string|null), qname: string}|null} The aliased name, or null when no alias applies
+     *
+     * @example
+     * aliases.resolve('http://www.w3.org/1999/XSL/TransformAlias', 'stylesheet');
+     * // { namespaceUri: 'http://www.w3.org/1999/XSL/Transform', qname: 'xsl:stylesheet' }
+     */
+    resolve(namespaceUri, localName) {
+      const alias = namespaceUri ? this.byUri.get(namespaceUri) : void 0;
+      if (!alias) return null;
+      return {
+        namespaceUri: alias.uri,
+        qname: alias.prefix ? `${alias.prefix}:${localName}` : localName
+      };
+    }
+  };
+  function shouldCopyAttribute(attribute, xsltNamespace) {
+    if (attribute.namespaceURI === xsltNamespace) return false;
+    if (attribute.name === "xmlns" || attribute.name.startsWith("xmlns:")) {
+      return false;
+    }
+    return !attribute.name.startsWith("xsl:");
+  }
+  function getXsltAttribute(node, localName, xsltNamespace) {
+    if (!node.attributes) return null;
+    for (const attribute of node.attributes) {
+      const matchesNamespace = attribute.namespaceURI === xsltNamespace && (attribute.localName || attribute.name) === localName;
+      if (matchesNamespace || attribute.name === `xsl:${localName}`) {
+        return attribute.value;
+      }
+    }
+    return null;
+  }
+
+  // src/xslt/resultTree.js
+  function createResultDocument(ownerDocument) {
+    return ownerDocument.implementation.createDocument(null, null, null);
+  }
+  function importResultNode(node, targetDoc) {
+    const copy = targetDoc.importNode(node, false);
+    if (node._disableOutputEscaping) {
+      copy._disableOutputEscaping = true;
+    }
+    if (node.childNodes) {
+      for (const child of node.childNodes) {
+        copy.appendChild(importResultNode(child, targetDoc));
+      }
+    }
+    return copy;
+  }
+  function importResultFragment(fragment, targetDoc) {
+    if (fragment.ownerDocument === targetDoc) return fragment;
+    const imported = targetDoc.createDocumentFragment();
+    for (const child of fragment.childNodes) {
+      imported.appendChild(importResultNode(child, targetDoc));
+    }
+    return imported;
+  }
+
+  // src/xslt/templatePriority.js
+  var NAME = String.raw`[A-Za-z_][\w.-]*`;
+  var QNAME = `(?:${NAME}:)?${NAME}`;
+  var QNAME_PATTERN = new RegExp(`^(?:child::|attribute::|@)?${QNAME}$`);
+  var PREFIX_WILDCARD_PATTERN = new RegExp(
+    String.raw`^(?:child::|attribute::|@)?${NAME}:\*$`
+  );
+  var NODE_TEST_PATTERN = /^(?:child::|attribute::|@)?(?:\*|node\(\)|text\(\)|comment\(\)|processing-instruction\(\))$/;
+  var PI_LITERAL_PATTERN = /^(?:child::)?processing-instruction\(\s*(?:"[^"]*"|'[^']*')\s*\)$/;
+  function calculatePriority(pattern) {
+    if (!pattern) return 0.5;
+    if (NODE_TEST_PATTERN.test(pattern)) return -0.5;
+    if (PREFIX_WILDCARD_PATTERN.test(pattern)) return -0.25;
+    if (QNAME_PATTERN.test(pattern) || PI_LITERAL_PATTERN.test(pattern)) return 0;
+    return 0.5;
+  }
+
+  // src/xslt/serializer/constants.js
+  var NODE_TYPE = {
+    ELEMENT: 1,
+    TEXT: 3,
+    CDATA_SECTION: 4,
+    PROCESSING_INSTRUCTION: 7,
+    COMMENT: 8,
+    DOCUMENT: 9,
+    DOCUMENT_FRAGMENT: 11
+  };
+  var XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
+  var XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+  var TEXT_MODE = {
+    ESCAPE: "escape",
+    CDATA: "cdata",
+    RAW: "raw"
+  };
+  var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+    "area",
+    "base",
+    "br",
+    "col",
+    "embed",
+    "hr",
+    "img",
+    "input",
+    "link",
+    "meta",
+    "param",
+    "source",
+    "track",
+    "wbr"
+  ]);
+  var RAW_TEXT_ELEMENTS = /* @__PURE__ */ new Set(["script", "style"]);
+  var PRESERVE_SPACE_ELEMENTS = /* @__PURE__ */ new Set([
+    "pre",
+    "script",
+    "style",
+    "textarea"
+  ]);
+  var INDENT_UNIT = "  ";
+
+  // src/xslt/serializer/settings.js
+  function isYes(value) {
+    return value === true || String(value).toLowerCase() === "yes";
+  }
+  function toNameSet(value) {
+    if (Array.isArray(value)) {
+      return new Set(value);
+    }
+    if (typeof value === "string") {
+      return new Set(value.split(/\s+/).filter(Boolean));
+    }
+    return /* @__PURE__ */ new Set();
+  }
+  function findRootElement(node) {
+    if (!node) {
+      return null;
+    }
+    if (node.nodeType === NODE_TYPE.ELEMENT) {
+      return node;
+    }
+    for (const child of node.childNodes || []) {
+      if (child.nodeType === NODE_TYPE.ELEMENT) {
+        return child;
+      }
+    }
+    return null;
+  }
+  function detectOutputMethod(node) {
+    const root = findRootElement(node);
+    const isHtmlRoot = root && !root.namespaceURI && root.localName.toLowerCase() === "html";
+    return isHtmlRoot ? "html" : "xml";
+  }
+  function resolveOutputSettings(outputSettings, node) {
+    const raw = outputSettings || {};
+    const declared = typeof raw.method === "string" ? raw.method.trim() : "";
+    const method = declared && declared !== "auto" ? declared.toLowerCase() : detectOutputMethod(node);
+    return {
+      method,
+      version: raw.version || "1.0",
+      encoding: raw.encoding || "UTF-8",
+      standalone: raw.standalone || null,
+      indent: isYes(raw.indent),
+      omitXmlDeclaration: isYes(raw.omitXmlDeclaration),
+      doctypePublic: raw.doctypePublic || null,
+      doctypeSystem: raw.doctypeSystem || null,
+      mediaType: raw.mediaType || null,
+      cdataSectionElements: toNameSet(raw.cdataSectionElements)
+    };
+  }
+
+  // src/xslt/serializer/escape.js
+  var XML_TEXT_ESCAPES = { "&": "&amp;", "<": "&lt;" };
+  var HTML_TEXT_ESCAPES = { "&": "&amp;", "<": "&lt;", ">": "&gt;" };
+  var XML_ATTRIBUTE_ESCAPES = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "	": "&#9;",
+    "\n": "&#10;",
+    "\r": "&#13;"
+  };
+  var HTML_ATTRIBUTE_ESCAPES = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;"
+  };
+  function escapeWith(value, pattern, escapes) {
+    return String(value).replaceAll(pattern, (character) => escapes[character]);
+  }
+  function escapeXmlText(value) {
+    return escapeWith(value, /[&<]/g, XML_TEXT_ESCAPES).replaceAll(
+      "]]>",
+      "]]&gt;"
+    );
+  }
+  function escapeXmlAttribute(value) {
+    return escapeWith(value, /[&<>"\t\n\r]/g, XML_ATTRIBUTE_ESCAPES);
+  }
+  function escapeHtmlText(value) {
+    return escapeWith(value, /[&<>]/g, HTML_TEXT_ESCAPES);
+  }
+  function escapeHtmlAttribute(value) {
+    return escapeWith(value, /[&<>"]/g, HTML_ATTRIBUTE_ESCAPES);
+  }
+  function wrapCdata(value) {
+    return `<![CDATA[${String(value).replaceAll("]]>", "]]]]><![CDATA[>")}]]>`;
+  }
+
+  // src/xslt/serializer/namespaces.js
+  function createNamespaceScope() {
+    return /* @__PURE__ */ new Map([
+      ["", ""],
+      ["xml", XML_NAMESPACE]
+    ]);
+  }
+  function collectNamespaceDeclarations(element, scope) {
+    const declarations = [];
+    let next = scope;
+    const declare = (prefix, uri) => {
+      if (next.get(prefix) === uri) {
+        return;
+      }
+      if (next === scope) {
+        next = new Map(scope);
+      }
+      next.set(prefix, uri);
+      declarations.push({ prefix, uri });
+    };
+    declare(element.prefix || "", element.namespaceURI || "");
+    const attributes = Array.from(element.attributes || []);
+    for (const attribute of attributes) {
+      if (attribute.namespaceURI !== XMLNS_NAMESPACE && attribute.prefix) {
+        declare(attribute.prefix, attribute.namespaceURI || "");
+      }
+    }
+    for (const attribute of attributes) {
+      if (attribute.namespaceURI === XMLNS_NAMESPACE) {
+        declare(attribute.prefix ? attribute.localName : "", attribute.value);
+      }
+    }
+    return { declarations, scope: next };
+  }
+
+  // src/xslt/serializer/indent.js
+  function isWhitespaceOnlyText(node) {
+    return !/\S/.test(node.nodeValue || "");
+  }
+  function getIndentableChildren(element) {
+    const indentable = [];
+    for (const child of element.childNodes) {
+      if (child.nodeType === NODE_TYPE.TEXT) {
+        if (isWhitespaceOnlyText(child)) {
+          continue;
+        }
+        return null;
+      }
+      if (child.nodeType !== NODE_TYPE.ELEMENT && child.nodeType !== NODE_TYPE.COMMENT && child.nodeType !== NODE_TYPE.PROCESSING_INSTRUCTION) {
+        return null;
+      }
+      indentable.push(child);
+    }
+    return indentable.length > 0 ? indentable : null;
+  }
+
+  // src/xslt/serializer/rawText.js
+  var rawTextNodes = /* @__PURE__ */ new WeakSet();
+  function markRawText(node) {
+    if (node) {
+      rawTextNodes.add(node);
+    }
+    return node;
+  }
+  function isRawText(node) {
+    if (!node) {
+      return false;
+    }
+    return rawTextNodes.has(node) || node._disableOutputEscaping === true;
+  }
+
+  // src/xslt/serializer/baseWriter.js
+  var BaseWriter = class {
+    /**
+     * @param {object} settings - Normalized output settings
+     * @param {{xhtml?: boolean}} [options] - Dialect options
+     */
+    constructor(settings, options = {}) {
+      this.settings = settings;
+      this.xhtml = options.xhtml === true;
+      this.parts = [];
+    }
+    /**
+     * Serialize a result tree node.
+     *
+     * @param {Node} node - Document, fragment or element to serialize
+     * @returns {string} Serialized output
+     */
+    serialize(node) {
+      this.parts = [];
+      this.writeProlog(node);
+      this.writeNode(node, createNamespaceScope(), 0, TEXT_MODE.ESCAPE);
+      return this.parts.join("");
+    }
+    /**
+     * Write the XML declaration and the document type declaration.
+     *
+     * @param {Node} node - Result tree root
+     * @returns {void}
+     */
+    writeProlog(node) {
+      if (this.emitsXmlDeclaration) {
+        const { version, encoding, standalone } = this.settings;
+        const standalonePart = standalone ? ` standalone="${standalone}"` : "";
+        this.parts.push(
+          `<?xml version="${version}" encoding="${encoding}"${standalonePart}?>
+`
+        );
+      }
+      const doctype = this.doctypeMarkup(findRootElement(node));
+      if (doctype) {
+        this.parts.push(`${doctype}
+`);
+      }
+    }
+    /**
+     * Write any result tree node.
+     *
+     * @param {Node} node - Node to write
+     * @param {Map<string, string>} scope - Namespace scope in effect
+     * @param {number} depth - Current indentation depth
+     * @param {string} textMode - {@link TEXT_MODE} for character data children
+     * @returns {void}
+     */
+    writeNode(node, scope, depth, textMode) {
+      switch (node.nodeType) {
+        case NODE_TYPE.ELEMENT:
+          this.writeElement(node, scope, depth);
+          break;
+        case NODE_TYPE.TEXT:
+        case NODE_TYPE.CDATA_SECTION:
+          this.writeText(node, textMode);
+          break;
+        case NODE_TYPE.COMMENT:
+          this.parts.push(`<!--${node.nodeValue}-->`);
+          break;
+        case NODE_TYPE.PROCESSING_INSTRUCTION:
+          this.writeProcessingInstruction(node);
+          break;
+        case NODE_TYPE.DOCUMENT:
+        case NODE_TYPE.DOCUMENT_FRAGMENT:
+          this.writeChildNodes(node, scope, depth, textMode);
+          break;
+        default:
+          break;
+      }
+    }
+    /**
+     * Write every child of a node without adding whitespace.
+     *
+     * @param {Node} node - Parent node
+     * @param {Map<string, string>} scope - Namespace scope in effect
+     * @param {number} depth - Current indentation depth
+     * @param {string} textMode - {@link TEXT_MODE} for character data children
+     * @returns {void}
+     */
+    writeChildNodes(node, scope, depth, textMode) {
+      for (const child of node.childNodes) {
+        this.writeNode(child, scope, depth, textMode);
+      }
+    }
+    /**
+     * Write an element with its namespaces, attributes and children.
+     *
+     * @param {Element} element - Element to write
+     * @param {Map<string, string>} scope - Namespace scope inherited from the parent
+     * @param {number} depth - Current indentation depth
+     * @returns {void}
+     */
+    writeElement(element, scope, depth) {
+      const namespaces = this.emitsNamespaces ? collectNamespaceDeclarations(element, scope) : { declarations: [], scope };
+      const name = element.nodeName;
+      this.parts.push(
+        `<${name}${this.namespaceMarkup(namespaces.declarations)}` + this.attributesMarkup(element)
+      );
+      if (!element.firstChild) {
+        this.parts.push(this.emptyElementMarkup(element, name));
+        return;
+      }
+      this.parts.push(">");
+      this.writeElementChildren(element, namespaces.scope, depth);
+      this.parts.push(`</${name}>`);
+    }
+    /**
+     * Write the children of an element, indenting element-only content.
+     *
+     * @param {Element} element - Parent element
+     * @param {Map<string, string>} scope - Namespace scope in effect
+     * @param {number} depth - Depth of the parent element
+     * @returns {void}
+     */
+    writeElementChildren(element, scope, depth) {
+      const textMode = this.childTextMode(element);
+      const indentable = this.indentableChildren(element, textMode);
+      if (!indentable) {
+        this.writeChildNodes(element, scope, depth, textMode);
+        return;
+      }
+      const childIndent = `
+${INDENT_UNIT.repeat(depth + 1)}`;
+      for (const child of indentable) {
+        this.parts.push(childIndent);
+        this.writeNode(child, scope, depth + 1, textMode);
+      }
+      this.parts.push(`
+${INDENT_UNIT.repeat(depth)}`);
+    }
+    /**
+     * Determine the children to indent inside an element.
+     *
+     * @param {Element} element - Parent element
+     * @param {string} textMode - {@link TEXT_MODE} for character data children
+     * @returns {Node[]|null} Children to indent, or null when indenting is off
+     */
+    indentableChildren(element, textMode) {
+      if (!this.settings.indent || textMode !== TEXT_MODE.ESCAPE) {
+        return null;
+      }
+      if (!this.allowsIndentInside(element)) {
+        return null;
+      }
+      return getIndentableChildren(element);
+    }
+    /**
+     * Build the namespace declaration markup of an element.
+     *
+     * @param {Array<{prefix: string, uri: string}>} declarations - Declarations
+     * @returns {string} Attribute markup, starting with a space when non-empty
+     */
+    namespaceMarkup(declarations) {
+      return declarations.map(({ prefix, uri }) => {
+        const name = prefix ? `xmlns:${prefix}` : "xmlns";
+        return ` ${name}="${this.escapeAttribute(uri)}"`;
+      }).join("");
+    }
+    /**
+     * Build the attribute markup of an element, skipping namespace declarations.
+     *
+     * @param {Element} element - Element being written
+     * @returns {string} Attribute markup, starting with a space when non-empty
+     */
+    attributesMarkup(element) {
+      let markup = "";
+      for (const attribute of Array.from(element.attributes || [])) {
+        if (attribute.namespaceURI !== XMLNS_NAMESPACE) {
+          markup += this.attributeMarkup(attribute);
+        }
+      }
+      return markup;
+    }
+    /**
+     * Build the markup of a single attribute.
+     *
+     * @param {Attr} attribute - Attribute to write
+     * @returns {string} Attribute markup, starting with a space
+     */
+    attributeMarkup(attribute) {
+      return ` ${attribute.name}="${this.escapeAttribute(attribute.value)}"`;
+    }
+    /**
+     * Write a character data node.
+     *
+     * Nodes produced with `disable-output-escaping="yes"` are written verbatim.
+     *
+     * @param {Node} node - Text or CDATA section node
+     * @param {string} textMode - {@link TEXT_MODE} requested by the parent
+     * @returns {void}
+     */
+    writeText(node, textMode) {
+      const value = node.nodeValue || "";
+      if (isRawText(node)) {
+        this.parts.push(value);
+        return;
+      }
+      const mode = this.resolveTextMode(node, textMode);
+      if (mode === TEXT_MODE.CDATA) {
+        this.parts.push(wrapCdata(value));
+      } else if (mode === TEXT_MODE.RAW) {
+        this.parts.push(value);
+      } else {
+        this.parts.push(this.escapeText(value));
+      }
+    }
+    /**
+     * Resolve the effective text mode of a character data node.
+     *
+     * @param {Node} node - Text or CDATA section node
+     * @param {string} textMode - {@link TEXT_MODE} requested by the parent
+     * @returns {string} A {@link TEXT_MODE} value
+     */
+    resolveTextMode(node, textMode) {
+      if (textMode !== TEXT_MODE.ESCAPE) {
+        return textMode;
+      }
+      return node.nodeType === NODE_TYPE.CDATA_SECTION ? this.cdataNodeMode : TEXT_MODE.ESCAPE;
+    }
+    /**
+     * Write a processing instruction node.
+     *
+     * @param {ProcessingInstruction} node - Node to write
+     * @returns {void}
+     */
+    writeProcessingInstruction(node) {
+      const data = node.nodeValue || "";
+      const separator = data ? " " : "";
+      this.parts.push(`<?${node.target}${separator}${data}${this.piTerminator}`);
+    }
+  };
+
+  // src/xslt/serializer/xmlSerializer.js
+  var XmlWriter = class extends BaseWriter {
+    /**
+     * Whether an XML declaration has to be written.
+     * @returns {boolean} True when the declaration is not omitted
+     */
+    get emitsXmlDeclaration() {
+      return !this.settings.omitXmlDeclaration;
+    }
+    /**
+     * Whether namespace declarations have to be written.
+     * @returns {boolean} Always true for XML output
+     */
+    get emitsNamespaces() {
+      return true;
+    }
+    /**
+     * Terminator of a processing instruction.
+     * @returns {string} The XML processing instruction terminator
+     */
+    get piTerminator() {
+      return "?>";
+    }
+    /**
+     * How a source CDATA section node has to be written.
+     * @returns {string} A {@link TEXT_MODE} value
+     */
+    get cdataNodeMode() {
+      return TEXT_MODE.CDATA;
+    }
+    /**
+     * Build the document type declaration for the xml output method.
+     *
+     * @param {Element|null} rootElement - Result document element
+     * @returns {string} Doctype markup, or an empty string when not applicable
+     */
+    doctypeMarkup(rootElement) {
+      const { doctypePublic, doctypeSystem } = this.settings;
+      if (!rootElement || !doctypeSystem) {
+        return "";
+      }
+      const name = rootElement.nodeName;
+      return doctypePublic ? `<!DOCTYPE ${name} PUBLIC "${doctypePublic}" "${doctypeSystem}">` : `<!DOCTYPE ${name} SYSTEM "${doctypeSystem}">`;
+    }
+    /**
+     * Determine how the character data children of an element are written.
+     *
+     * @param {Element} element - Parent element
+     * @returns {string} A {@link TEXT_MODE} value
+     */
+    childTextMode(element) {
+      const names = this.settings.cdataSectionElements;
+      return names.has(element.nodeName) || names.has(element.localName) ? TEXT_MODE.CDATA : TEXT_MODE.ESCAPE;
+    }
+    /**
+     * Whether the content of an element may be re-indented.
+     *
+     * @param {Element} _element - Element being inspected
+     * @returns {boolean} Always true for XML output
+     */
+    allowsIndentInside(_element) {
+      return true;
+    }
+    /**
+     * Build the markup closing an element that has no children.
+     *
+     * @param {Element} element - Empty element
+     * @param {string} _name - Element name as written
+     * @returns {string} Markup terminating the start tag
+     */
+    emptyElementMarkup(element, _name) {
+      return this.xhtml && this.isVoidElement(element) ? " />" : "/>";
+    }
+    /**
+     * Test whether an element is an HTML void element.
+     *
+     * @param {Element} element - Element to test
+     * @returns {boolean} True for void elements such as `br`
+     */
+    isVoidElement(element) {
+      return VOID_ELEMENTS.has(String(element.localName).toLowerCase());
+    }
+    /**
+     * Escape character data.
+     *
+     * @param {string} value - Text content
+     * @returns {string} Escaped text
+     */
+    escapeText(value) {
+      return escapeXmlText(value);
+    }
+    /**
+     * Escape an attribute value.
+     *
+     * @param {string} value - Attribute value
+     * @returns {string} Escaped value
+     */
+    escapeAttribute(value) {
+      return escapeXmlAttribute(value);
+    }
+  };
+
+  // src/xslt/serializer/htmlSerializer.js
+  var HtmlWriter = class extends XmlWriter {
+    /**
+     * The html output method never writes an XML declaration.
+     * @returns {boolean} Always false
+     */
+    get emitsXmlDeclaration() {
+      return false;
+    }
+    /**
+     * The html output method never writes namespace declarations.
+     * @returns {boolean} Always false
+     */
+    get emitsNamespaces() {
+      return false;
+    }
+    /**
+     * HTML processing instructions are terminated by `>` alone.
+     * @returns {string} The HTML processing instruction terminator
+     */
+    get piTerminator() {
+      return ">";
+    }
+    /**
+     * HTML has no CDATA sections, so such nodes are escaped as text.
+     * @returns {string} A {@link TEXT_MODE} value
+     */
+    get cdataNodeMode() {
+      return TEXT_MODE.ESCAPE;
+    }
+    /**
+     * Build the document type declaration for the html output method.
+     *
+     * @param {Element|null} rootElement - Result document element
+     * @returns {string} Doctype markup, or an empty string when not applicable
+     */
+    doctypeMarkup(rootElement) {
+      const { doctypePublic, doctypeSystem } = this.settings;
+      if (!doctypePublic && !doctypeSystem) {
+        return "";
+      }
+      const name = rootElement ? rootElement.nodeName : "html";
+      if (doctypePublic && doctypeSystem) {
+        return `<!DOCTYPE ${name} PUBLIC "${doctypePublic}" "${doctypeSystem}">`;
+      }
+      if (doctypePublic) {
+        return `<!DOCTYPE ${name} PUBLIC "${doctypePublic}">`;
+      }
+      return `<!DOCTYPE ${name} SYSTEM "${doctypeSystem}">`;
+    }
+    /**
+     * Script and style content is written verbatim.
+     *
+     * @param {Element} element - Parent element
+     * @returns {string} A {@link TEXT_MODE} value
+     */
+    childTextMode(element) {
+      return RAW_TEXT_ELEMENTS.has(String(element.localName).toLowerCase()) ? TEXT_MODE.RAW : TEXT_MODE.ESCAPE;
+    }
+    /**
+     * Content of `pre`, `script`, `style` and `textarea` is never re-indented.
+     *
+     * @param {Element} element - Element being inspected
+     * @returns {boolean} True when the content may be indented
+     */
+    allowsIndentInside(element) {
+      return !PRESERVE_SPACE_ELEMENTS.has(
+        String(element.localName).toLowerCase()
+      );
+    }
+    /**
+     * Void elements have no end tag; every other element gets one.
+     *
+     * @param {Element} element - Empty element
+     * @param {string} name - Element name as written
+     * @returns {string} Markup terminating the start tag
+     */
+    emptyElementMarkup(element, name) {
+      return this.isVoidElement(element) ? ">" : `></${name}>`;
+    }
+    /**
+     * Boolean attributes are minimized to their name alone.
+     *
+     * @param {Attr} attribute - Attribute to write
+     * @returns {string} Attribute markup, starting with a space
+     */
+    attributeMarkup(attribute) {
+      const { name, value } = attribute;
+      if (String(value).toLowerCase() === name.toLowerCase()) {
+        return ` ${name}`;
+      }
+      return ` ${name}="${this.escapeAttribute(value)}"`;
+    }
+    /**
+     * Escape character data for HTML.
+     *
+     * @param {string} value - Text content
+     * @returns {string} Escaped text
+     */
+    escapeText(value) {
+      return escapeHtmlText(value);
+    }
+    /**
+     * Escape an attribute value for HTML.
+     *
+     * @param {string} value - Attribute value
+     * @returns {string} Escaped value
+     */
+    escapeAttribute(value) {
+      return escapeHtmlAttribute(value);
+    }
+  };
+
+  // src/xslt/serializer/textSerializer.js
+  function serializeText(node) {
+    if (node.nodeType === NODE_TYPE.TEXT || node.nodeType === NODE_TYPE.CDATA_SECTION) {
+      return node.nodeValue || "";
+    }
+    let text = "";
+    for (const child of node.childNodes || []) {
+      text += serializeText(child);
+    }
+    return text;
+  }
+
+  // src/xslt/serializer.js
+  function serializeResult(node, outputSettings = {}) {
+    if (!node) {
+      return "";
+    }
+    const settings = resolveOutputSettings(outputSettings, node);
+    if (settings.method === "text") {
+      return serializeText(node);
+    }
+    if (settings.method === "html") {
+      return new HtmlWriter(settings).serialize(node);
+    }
+    return new XmlWriter(settings, {
+      xhtml: settings.method === "xhtml"
+    }).serialize(node);
+  }
+
   // src/xslt/engine.js
-  var XSLT_NS = "http://www.w3.org/1999/XSL/Transform";
+  var XSLT_NS = XSLT_NAMESPACE;
   var XsltContext = class _XsltContext {
     constructor(options = {}) {
       this.currentNode = options.currentNode;
@@ -1616,6 +3130,8 @@ var XsltProcessorLib = (() => {
       this.decimalFormats = options.decimalFormats || {};
       this.outputMethod = options.outputMethod || "xml";
       this.xpathEvaluator = options.xpathEvaluator || new XPathEvaluator();
+      this.currentTemplate = options.currentTemplate || null;
+      this.currentMode = options.currentMode ?? null;
     }
     clone(overrides = {}) {
       return new _XsltContext({
@@ -1631,7 +3147,9 @@ var XsltProcessorLib = (() => {
         keys: this.keys,
         decimalFormats: this.decimalFormats,
         outputMethod: this.outputMethod,
-        xpathEvaluator: this.xpathEvaluator
+        xpathEvaluator: this.xpathEvaluator,
+        currentTemplate: overrides.currentTemplate ?? this.currentTemplate,
+        currentMode: overrides.currentMode ?? this.currentMode
       });
     }
     getVariable(name) {
@@ -1656,7 +3174,9 @@ var XsltProcessorLib = (() => {
       this.globalParameters = {};
       this.outputSettings = {
         method: "xml",
+        version: "1.0",
         encoding: "UTF-8",
+        standalone: null,
         indent: "no",
         omitXmlDeclaration: "no",
         doctypePublic: null,
@@ -1668,13 +3188,105 @@ var XsltProcessorLib = (() => {
       this.decimalFormats = {};
       this.stylesheetDoc = null;
       this.attributeSets = {};
-      this.namespaceAliases = {};
+      this.namespaceAliases = new NamespaceAliasMap();
       this.stripSpace = [];
       this.preserveSpace = [];
       this.stylesheetLoader = options.stylesheetLoader || null;
       this.currentImportPrecedence = 0;
       this.processedStylesheets = /* @__PURE__ */ new Set();
       this.baseUri = options.baseUri || "";
+      this.documentLoader = options.documentLoader || null;
+      this.loadedDocuments = /* @__PURE__ */ new Map();
+      this.generatedIds = /* @__PURE__ */ new WeakMap();
+      this.generatedIdCount = 0;
+      this.rootContext = null;
+      this.keyRegistry = new KeyIndexRegistry({
+        keys: this.keys,
+        matchesPattern: (node, pattern) => this.matchesPattern(node, pattern, this.rootContext),
+        evaluateUse: (node, expression) => this.evaluateKeyValues(node, expression)
+      });
+      this.xpathEvaluator.registerFunctions(createXsltFunctions(this));
+    }
+    /**
+     * Set the loader used by the XSLT `document()` function.
+     *
+     * The loader is synchronous and must return a `Document`, an XML string or
+     * null. Returning null (or configuring no loader at all) makes `document()`
+     * evaluate to an empty node-set instead of failing the transformation.
+     *
+     * @param {((uri: string, baseUri?: string) => (Document|string|null))|null} loader - The loader, or null to remove it
+     * @returns {XsltEngine} This engine, to allow chaining
+     *
+     * @example
+     * engine.setDocumentLoader((uri) => readFileSync(uri, 'utf8'));
+     */
+    setDocumentLoader(loader) {
+      this.documentLoader = loader ?? null;
+      this.loadedDocuments.clear();
+      return this;
+    }
+    /**
+     * Load an external document for the `document()` function.
+     *
+     * Results are cached per resolved URI for the life of the engine, so the same
+     * URI always yields the identical node-set.
+     *
+     * @param {string} uri - The requested URI, fragment identifiers are ignored
+     * @param {string} [baseUri] - Base URI used to resolve relative references
+     * @returns {Document|null} The loaded document, or null when unavailable
+     *
+     * @example
+     * engine.loadDocument('data.xml', '/styles/main.xsl');
+     */
+    loadDocument(uri, baseUri) {
+      const target = stripFragment(uri);
+      if (target === "") return this.stylesheetDoc;
+      if (!this.documentLoader) return null;
+      const resolved = resolveUri(target, baseUri);
+      if (this.loadedDocuments.has(resolved)) {
+        return this.loadedDocuments.get(resolved);
+      }
+      const loaded = this.documentLoader(resolved, baseUri);
+      const doc = typeof loaded === "string" ? this.parseXmlString(loaded) : loaded || null;
+      this.loadedDocuments.set(resolved, doc);
+      return doc;
+    }
+    /**
+     * Return the stable identifier of a node for `generate-id()`.
+     *
+     * @param {Node} node - The node to identify
+     * @returns {string} An identifier starting with a letter
+     *
+     * @example
+     * engine.generateId(element); // 'N1'
+     */
+    generateId(node) {
+      let id = this.generatedIds.get(node);
+      if (!id) {
+        this.generatedIdCount++;
+        id = `N${this.generatedIdCount}`;
+        this.generatedIds.set(node, id);
+      }
+      return id;
+    }
+    /**
+     * Evaluate the `use` expression of an `xsl:key` for one node.
+     *
+     * @param {Node} node - The node being indexed
+     * @param {string} expression - The `use` expression
+     * @returns {string[]} The key values contributed by the node
+     */
+    evaluateKeyValues(node, expression) {
+      const context = this.rootContext.clone({
+        currentNode: node,
+        currentNodeList: [node],
+        position: 1
+      });
+      const value = this.evaluateXPath(expression, context);
+      if (Array.isArray(value)) {
+        return value.map((item) => this.xpathEvaluator.getStringValue(item));
+      }
+      return [this.xpathEvaluator.toString(value)];
     }
     /**
      * Set the stylesheet loader function for xsl:import and xsl:include
@@ -1685,14 +3297,13 @@ var XsltProcessorLib = (() => {
     }
     /**
      * Resolve a relative URI against a base URI
+     *
+     * @param {string} href - The URI to resolve
+     * @param {string} [baseUri] - The base URI
+     * @returns {string} The resolved URI
      */
     resolveUri(href, baseUri) {
-      if (!baseUri || href.startsWith("http://") || href.startsWith("https://") || href.startsWith("/")) {
-        return href;
-      }
-      const lastSlash = baseUri.lastIndexOf("/");
-      const baseDir = lastSlash >= 0 ? baseUri.substring(0, lastSlash + 1) : "";
-      return baseDir + href;
+      return resolveUri(href, baseUri);
     }
     /**
      * Load an external stylesheet document
@@ -1814,7 +3425,8 @@ var XsltProcessorLib = (() => {
         this.currentImportPrecedence = savedPrecedence;
       } catch (error) {
         throw new Error(
-          `Failed to include stylesheet "${href}": ${error.message}`
+          `Failed to include stylesheet "${href}": ${error.message}`,
+          { cause: error }
         );
       }
     }
@@ -1842,7 +3454,8 @@ var XsltProcessorLib = (() => {
         this.currentImportPrecedence++;
       } catch (error) {
         throw new Error(
-          `Failed to import stylesheet "${href}": ${error.message}`
+          `Failed to import stylesheet "${href}": ${error.message}`,
+          { cause: error }
         );
       }
     }
@@ -1918,39 +3531,50 @@ var XsltProcessorLib = (() => {
         }
       }
     }
+    /**
+     * Register a template rule.
+     *
+     * A union match pattern is equivalent to a set of template rules, one per
+     * alternative (XSLT 1.0 section 5.5), so each alternative is registered
+     * separately with its own default priority.
+     *
+     * @param {Element} node - The xsl:template element
+     */
     registerTemplate(node) {
       const match = node.getAttribute("match");
       const name = node.getAttribute("name");
       const mode = node.getAttribute("mode") || null;
       const priorityAttr = node.getAttribute("priority");
-      const priority = priorityAttr ? parseFloat(priorityAttr) : this.calculatePriority(match);
-      this.templates.push({
-        match,
-        name,
-        mode,
-        priority,
-        importPrecedence: this.currentImportPrecedence,
-        node
-      });
+      const alternatives = match ? this.splitUnionPattern(match).map((p) => p.trim()) : [null];
+      for (const alternative of alternatives) {
+        this.templates.push({
+          match: alternative,
+          name,
+          mode,
+          priority: priorityAttr ? parseFloat(priorityAttr) : this.calculatePriority(alternative),
+          importPrecedence: this.currentImportPrecedence,
+          node
+        });
+      }
     }
+    /**
+     * Default priority of a single match pattern (see templatePriority.js).
+     *
+     * @param {string|null} matchPattern - The match pattern
+     * @returns {number} The default priority
+     */
     calculatePriority(matchPattern) {
-      if (!matchPattern) return 0.5;
-      if (matchPattern === "*" || matchPattern === "node()" || matchPattern === "text()" || matchPattern === "comment()" || matchPattern === "processing-instruction()") {
-        return -0.5;
-      }
-      if (matchPattern.includes(":*")) {
-        return -0.25;
-      }
-      if (/^[a-zA-Z_][\w.-]*$/.test(matchPattern)) {
-        return 0;
-      }
-      return 0.5;
+      return calculatePriority(matchPattern ? matchPattern.trim() : matchPattern);
     }
     processOutput(node) {
       const method = node.getAttribute("method");
       if (method) this.outputSettings.method = method;
+      const version = node.getAttribute("version");
+      if (version) this.outputSettings.version = version;
       const encoding = node.getAttribute("encoding");
       if (encoding) this.outputSettings.encoding = encoding;
+      const standalone = node.getAttribute("standalone");
+      if (standalone) this.outputSettings.standalone = standalone;
       const indent = node.getAttribute("indent");
       if (indent) this.outputSettings.indent = indent;
       const omit = node.getAttribute("omit-xml-declaration");
@@ -1971,16 +3595,80 @@ var XsltProcessorLib = (() => {
       const select2 = node.getAttribute("select");
       this.globalVariables[name] = { node, select: select2 };
     }
+    /**
+     * Register an `xsl:param` top level declaration.
+     *
+     * A value supplied from outside (through `setParameter`) has precedence over
+     * the declared default, so it survives compilation of the stylesheet.
+     *
+     * @param {Element} node - The `xsl:param` element
+     * @returns {void}
+     */
     processGlobalParam(node) {
       const name = node.getAttribute("name");
       const select2 = node.getAttribute("select");
-      this.globalParameters[name] = { node, select: select2 };
+      const existing = this.globalParameters[name];
+      const definition = { node, select: select2 };
+      if (existing && "value" in existing) {
+        definition.value = existing.value;
+      }
+      this.globalParameters[name] = definition;
+    }
+    /**
+     * Supply the value of a global parameter from outside the stylesheet.
+     *
+     * The value is merged into the `xsl:param` declaration when there is one, so
+     * removing the value later restores the declared default.
+     *
+     * @param {string} name - The parameter name, `{uri}local` when namespaced
+     * @param {*} value - The value to use
+     * @returns {void}
+     *
+     * @example
+     * engine.setParameterValue('sortOrder', 'ascending');
+     */
+    setParameterValue(name, value) {
+      const definition = this.globalParameters[name];
+      if (definition) definition.value = value;
+      else this.globalParameters[name] = { value };
+    }
+    /**
+     * Remove an externally supplied parameter value.
+     *
+     * The `xsl:param` declaration of the stylesheet is kept, so the parameter
+     * falls back to its declared default instead of becoming undefined.
+     *
+     * @param {string} name - The parameter name, `{uri}local` when namespaced
+     * @returns {void}
+     *
+     * @example
+     * engine.clearParameterValue('sortOrder');
+     */
+    clearParameterValue(name) {
+      const definition = this.globalParameters[name];
+      if (!definition) return;
+      if (definition.node) delete definition.value;
+      else delete this.globalParameters[name];
+    }
+    /**
+     * Remove every externally supplied parameter value.
+     *
+     * @returns {void}
+     *
+     * @example
+     * engine.clearParameterValues();
+     */
+    clearParameterValues() {
+      for (const name of Object.keys(this.globalParameters)) {
+        this.clearParameterValue(name);
+      }
     }
     processKey(node) {
       const name = node.getAttribute("name");
       const match = node.getAttribute("match");
       const use = node.getAttribute("use");
       this.keys[name] = { match, use };
+      this.keyRegistry.clear();
     }
     processDecimalFormat(node) {
       const name = node.getAttribute("name") || "";
@@ -1998,9 +3686,7 @@ var XsltProcessorLib = (() => {
       };
     }
     processNamespaceAlias(node) {
-      const stylesheet = node.getAttribute("stylesheet-prefix");
-      const result = node.getAttribute("result-prefix");
-      this.namespaceAliases[stylesheet] = result;
+      this.namespaceAliases.add(node);
     }
     processAttributeSet(node) {
       const name = node.getAttribute("name");
@@ -2030,11 +3716,13 @@ var XsltProcessorLib = (() => {
       if (!doc) {
         throw new Error("No output document available");
       }
+      const resultDocument = createResultDocument(doc);
+      const source = this.prepareSource(sourceNode, doc);
       const context = new XsltContext({
-        currentNode: sourceNode,
-        currentNodeList: [sourceNode],
+        currentNode: source,
+        currentNodeList: [source],
         position: 1,
-        outputDocument: doc,
+        outputDocument: resultDocument,
         stylesheet: this.stylesheetDoc,
         namespaces: { ...this.namespaces },
         templates: this.templates,
@@ -2043,6 +3731,7 @@ var XsltProcessorLib = (() => {
         outputMethod: this.outputSettings.method,
         xpathEvaluator: this.xpathEvaluator
       });
+      this.rootContext = context;
       for (const [name, def] of Object.entries(this.globalParameters)) {
         if (!(name in context.parameters)) {
           context.parameters[name] = this.evaluateVariable(def, context);
@@ -2051,28 +3740,91 @@ var XsltProcessorLib = (() => {
       for (const [name, def] of Object.entries(this.globalVariables)) {
         context.variables[name] = this.evaluateVariable(def, context);
       }
-      const fragment = doc.createDocumentFragment();
-      this.applyTemplates([sourceNode], null, context, fragment);
-      return fragment;
+      const fragment = resultDocument.createDocumentFragment();
+      this.applyTemplates([source], null, context, fragment);
+      return importResultFragment(fragment, doc);
+    }
+    /**
+     * Apply `xsl:strip-space` to the source tree.
+     *
+     * Stripping produces a copy so the caller's document is never modified; when
+     * no `xsl:strip-space` is declared the original node is used unchanged.
+     *
+     * @param {Node} sourceNode - The source document or element
+     * @param {Document} ownerDocument - Document providing the DOM implementation
+     * @returns {Node} The source to transform
+     */
+    prepareSource(sourceNode, ownerDocument) {
+      const filter = new WhitespaceFilter(this.stripSpace, this.preserveSpace);
+      if (!filter.isActive()) return sourceNode;
+      return stripWhitespaceNodes(
+        sourceNode,
+        filter,
+        createResultDocument(ownerDocument)
+      );
     }
     /**
      * Transform to a complete document
      */
     transformToDocument(sourceNode) {
-      const doc = this.createDocument();
+      const doc = this.createDocument(sourceNode);
       const fragment = this.transform(sourceNode, doc);
       while (fragment.firstChild) {
         doc.appendChild(fragment.firstChild);
       }
       return doc;
     }
-    createDocument() {
+    /**
+     * Transform a source document and serialize the result to a string.
+     *
+     * Non-W3C convenience method: the result tree is serialized honoring the
+     * `xsl:output` settings of the stylesheet (XSLT 1.0 section 16).
+     *
+     * @param {Node} sourceNode - Source document or element to transform
+     * @returns {string} The serialized transformation result
+     */
+    transformToString(sourceNode) {
+      const fragment = this.transform(
+        sourceNode,
+        this.createDocument(sourceNode)
+      );
+      return serializeResult(fragment, this.outputSettings);
+    }
+    /**
+     * Create an empty XML document to hold a transformation result.
+     *
+     * Uses the global `document` when running in a browser and otherwise falls
+     * back to the DOM implementation owning `referenceNode` (e.g. a jsdom or
+     * xmldom document in Node.js).
+     *
+     * @param {Node} [referenceNode] - Any node whose DOM implementation can be reused
+     * @returns {Document} A new empty document
+     * @throws {Error} When no DOM implementation is available
+     */
+    createDocument(referenceNode) {
       if (typeof document !== "undefined") {
         return document.implementation.createDocument(null, null, null);
       }
+      const ownerDocument = referenceNode && (referenceNode.nodeType === 9 ? referenceNode : referenceNode.ownerDocument);
+      if (ownerDocument?.implementation) {
+        return ownerDocument.implementation.createDocument(null, null, null);
+      }
       throw new Error("Document creation not available in this environment");
     }
+    /**
+     * Compute the value of a variable or parameter definition.
+     *
+     * A value supplied from outside (`setParameter`) wins over the `select`
+     * expression and over the instantiated content of the declaration.
+     *
+     * @param {{value?: *, select?: string, node?: Element}} def - The definition
+     * @param {XsltContext} context - The context used for evaluation
+     * @returns {*} The variable value
+     */
     evaluateVariable(def, context) {
+      if ("value" in def) {
+        return def.value;
+      }
       if (def.select) {
         return this.evaluateXPath(def.select, context);
       }
@@ -2092,7 +3844,9 @@ var XsltProcessorLib = (() => {
           const newContext = context.clone({
             currentNode: node,
             currentNodeList: nodeList,
-            position: i + 1
+            position: i + 1,
+            currentTemplate: template,
+            currentMode: mode
           });
           this.processTemplate(template.node, newContext, output);
         } else {
@@ -2103,13 +3857,14 @@ var XsltProcessorLib = (() => {
     /**
      * Find the best matching template for a node
      */
-    findMatchingTemplate(node, mode, context) {
+    findMatchingTemplate(node, mode, context, maxImportPrecedence = Infinity) {
       let bestMatch = null;
       let bestPriority = -Infinity;
       let bestImportPrecedence = -Infinity;
       for (const template of this.templates) {
         if (template.mode !== mode) continue;
         if (!template.match) continue;
+        if ((template.importPrecedence || 0) >= maxImportPrecedence) continue;
         if (this.matchesPattern(node, template.match, context)) {
           const priority = template.priority;
           const importPrecedence = template.importPrecedence || 0;
@@ -2170,10 +3925,9 @@ var XsltProcessorLib = (() => {
       return parts;
     }
     matchesSinglePattern(node, pattern, context) {
-      var _a;
       try {
         if (pattern === "/") {
-          return node.nodeType === 9 || node === ((_a = node.ownerDocument) == null ? void 0 : _a.documentElement);
+          return node.nodeType === 9 || node === node.ownerDocument?.documentElement;
         }
         const ast = parse(pattern);
         if (pattern.startsWith("/")) {
@@ -2183,19 +3937,22 @@ var XsltProcessorLib = (() => {
             1,
             1,
             { ...context.variables, ...context.parameters },
-            context.namespaces
+            context.namespaces,
+            context
           );
           const result2 = this.xpathEvaluator.evaluate(ast, xpathContext2);
           const nodes2 = Array.isArray(result2) ? result2 : [result2];
           return nodes2.includes(node);
         }
-        if (node.parentNode) {
+        const parent = node.nodeType === 2 ? node.ownerElement : node.parentNode;
+        if (parent) {
           const xpathContext2 = new XPathContext(
-            node.parentNode,
+            parent,
             1,
             1,
             { ...context.variables, ...context.parameters },
-            context.namespaces
+            context.namespaces,
+            context
           );
           const result2 = this.xpathEvaluator.evaluate(ast, xpathContext2);
           const nodes2 = Array.isArray(result2) ? result2 : [result2];
@@ -2206,7 +3963,8 @@ var XsltProcessorLib = (() => {
           1,
           1,
           { ...context.variables, ...context.parameters },
-          context.namespaces
+          context.namespaces,
+          context
         );
         const result = this.xpathEvaluator.evaluate(ast, xpathContext);
         const nodes = Array.isArray(result) ? result : [result];
@@ -2320,6 +4078,9 @@ var XsltProcessorLib = (() => {
         case "apply-templates":
           this.xslApplyTemplates(node, context, output);
           break;
+        case "apply-imports":
+          this.xslApplyImports(node, context, output);
+          break;
         case "call-template":
           this.xslCallTemplate(node, context, output);
           break;
@@ -2379,34 +4140,47 @@ var XsltProcessorLib = (() => {
     }
     /**
      * Process a literal result element (non-XSLT)
+     *
+     * Applies `xsl:namespace-alias` to the element and its attributes, honours
+     * `xsl:use-attribute-sets` and keeps XSLT-only attributes and namespace
+     * declarations out of the result tree.
+     *
+     * @param {Element} node - The literal result element in the stylesheet
+     * @param {XsltContext} context - The current XSLT context
+     * @param {Node} output - The result tree node receiving the element
+     * @returns {void}
      */
     processLiteralResultElement(node, context, output) {
-      let outputElement;
-      const namespaceURI = node.namespaceURI;
-      const nodeName = node.nodeName;
-      let resolvedNS = namespaceURI;
-      if (namespaceURI) {
-        for (const [from, to] of Object.entries(this.namespaceAliases)) {
-          if (this.namespaces[from] === namespaceURI) {
-            resolvedNS = this.namespaces[to] || to;
-            break;
-          }
-        }
-      }
-      if (resolvedNS && context.outputDocument.createElementNS) {
-        outputElement = context.outputDocument.createElementNS(
-          resolvedNS,
-          nodeName
-        );
-      } else {
-        outputElement = context.outputDocument.createElement(nodeName);
+      const localName = node.localName || node.nodeName;
+      const alias = this.namespaceAliases.resolve(node.namespaceURI, localName);
+      const namespaceUri = alias ? alias.namespaceUri : node.namespaceURI;
+      const qname = alias ? alias.qname : node.nodeName;
+      const outputElement = namespaceUri && context.outputDocument.createElementNS ? context.outputDocument.createElementNS(namespaceUri, qname) : context.outputDocument.createElement(qname);
+      const useAttributeSets = getXsltAttribute(
+        node,
+        "use-attribute-sets",
+        XSLT_NS
+      );
+      if (useAttributeSets) {
+        this.applyAttributeSets(useAttributeSets, context, outputElement);
       }
       if (node.attributes) {
         for (const attr of node.attributes) {
-          if (attr.namespaceURI === XSLT_NS) continue;
-          if (attr.name.startsWith("xmlns")) continue;
+          if (!shouldCopyAttribute(attr, XSLT_NS)) continue;
           const value = this.processAttributeValueTemplate(attr.value, context);
-          outputElement.setAttribute(attr.name, value);
+          const attrAlias = this.namespaceAliases.resolve(
+            attr.namespaceURI,
+            attr.localName || attr.name
+          );
+          if (attrAlias) {
+            outputElement.setAttributeNS(
+              attrAlias.namespaceUri,
+              attrAlias.qname,
+              value
+            );
+          } else {
+            outputElement.setAttribute(attr.name, value);
+          }
         }
       }
       this.processChildren(node, context, outputElement);
@@ -2493,6 +4267,38 @@ var XsltProcessorLib = (() => {
       });
       this.applyTemplates(nodes, mode, newContext, output);
     }
+    /**
+     * Instantiate `xsl:apply-imports`.
+     *
+     * Only templates with a lower import precedence than the template being
+     * instantiated are considered; when none matches, the built-in template rules
+     * apply, exactly as for `xsl:apply-templates`.
+     *
+     * @param {Element} node - The `xsl:apply-imports` element
+     * @param {XsltContext} context - The current XSLT context
+     * @param {Node} output - The result tree node receiving the output
+     * @returns {void}
+     */
+    xslApplyImports(node, context, output) {
+      const currentNode = context.currentNode;
+      const mode = context.currentMode ?? null;
+      const precedence = context.currentTemplate ? context.currentTemplate.importPrecedence || 0 : 0;
+      const template = this.findMatchingTemplate(
+        currentNode,
+        mode,
+        context,
+        precedence
+      );
+      if (!template) {
+        this.applyBuiltinTemplate(currentNode, mode, context, output);
+        return;
+      }
+      this.processTemplate(
+        template.node,
+        context.clone({ currentTemplate: template }),
+        output
+      );
+    }
     xslCallTemplate(node, context, output) {
       const name = node.getAttribute("name");
       const template = this.templates.find((t) => t.name === name);
@@ -2817,79 +4623,47 @@ var XsltProcessorLib = (() => {
     xslNumber(node, context, output) {
       const value = node.getAttribute("value");
       const format = node.getAttribute("format") || "1";
-      const level = node.getAttribute("level") || "single";
-      let number;
+      let numbers;
       if (value) {
-        number = Math.round(
-          this.xpathEvaluator.toNumber(this.evaluateXPath(value, context))
-        );
+        numbers = [
+          Math.round(
+            this.xpathEvaluator.toNumber(this.evaluateXPath(value, context))
+          )
+        ];
       } else {
-        number = this.countNumber(context.currentNode, level, node, context);
+        numbers = countXsltNumber(
+          context.currentNode,
+          {
+            level: node.getAttribute("level") || "single",
+            count: node.getAttribute("count"),
+            from: node.getAttribute("from")
+          },
+          (candidate, pattern) => this.matchesPattern(candidate, pattern, context)
+        );
       }
-      const formatted = this.formatNumber(number, format);
-      const text = context.outputDocument.createTextNode(formatted);
+      const text = context.outputDocument.createTextNode(
+        formatXsltNumber(numbers, format)
+      );
       output.appendChild(text);
     }
-    countNumber(node, level, spec, context) {
-      const count = spec.getAttribute("count");
-      const _from = spec.getAttribute("from");
-      if (level === "single") {
-        let n = 1;
-        let sibling = node.previousSibling;
-        while (sibling) {
-          if (sibling.nodeType === 1) {
-            if (!count || this.matchesPattern(sibling, count, context)) {
-              n++;
-            }
-          }
-          sibling = sibling.previousSibling;
-        }
-        return n;
-      }
-      return 1;
-    }
+    /**
+     * Format a single number with an `xsl:number` format token.
+     *
+     * @param {number} number - The number to format
+     * @param {string} format - The format token, e.g. `1`, `01`, `a`, `I`
+     * @returns {string} The formatted number
+     */
     formatNumber(number, format) {
-      if (/^[0-9]+$/.test(format)) {
-        return String(number).padStart(format.length, "0");
-      }
-      if (format === "a") {
-        return String.fromCharCode(96 + (number - 1) % 26 + 1);
-      }
-      if (format === "A") {
-        return String.fromCharCode(64 + (number - 1) % 26 + 1);
-      }
-      if (format === "i") {
-        return this.toRoman(number).toLowerCase();
-      }
-      if (format === "I") {
-        return this.toRoman(number);
-      }
-      return String(number);
+      return formatXsltNumber([number], format);
     }
+    /**
+     * Convert a number to an upper case Roman numeral.
+     *
+     * @param {number} num - The number to convert
+     * @returns {string} The Roman numeral
+     */
     toRoman(num) {
-      const romanNumerals = [
-        ["M", 1e3],
-        ["CM", 900],
-        ["D", 500],
-        ["CD", 400],
-        ["C", 100],
-        ["XC", 90],
-        ["L", 50],
-        ["XL", 40],
-        ["X", 10],
-        ["IX", 9],
-        ["V", 5],
-        ["IV", 4],
-        ["I", 1]
-      ];
-      let result = "";
-      for (const [numeral, value] of romanNumerals) {
-        while (num >= value) {
-          result += numeral;
-          num -= value;
-        }
-      }
-      return result;
+      return toRoman(num);
     }
     xslMessage(node, context, _output) {
       const terminate = node.getAttribute("terminate") === "yes";
@@ -2973,7 +4747,8 @@ var XsltProcessorLib = (() => {
         context.position,
         context.currentNodeList.length,
         { ...context.variables, ...context.parameters },
-        context.namespaces
+        context.namespaces,
+        context
       );
       return this.xpathEvaluator.evaluate(ast, xpathContext);
     }
@@ -2993,6 +4768,94 @@ var XsltProcessorLib = (() => {
       this._engine = null;
       this._stylesheet = null;
       this._parameters = /* @__PURE__ */ new Map();
+      this._stylesheetLoader = null;
+      this._documentLoader = null;
+    }
+    /**
+     * The underlying XSLT engine (advanced usage).
+     *
+     * 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.
+     *
+     * @returns {import('./xslt/engine.js').XsltEngine|null} The engine, or null before import
+     *
+     * @example
+     * processor.importStylesheet(xslDoc, '/styles/main.xsl');
+     * console.log(processor.engine.outputSettings.method);
+     */
+    get engine() {
+      return this._engine;
+    }
+    /**
+     * Sets the loader used to resolve `xsl:import` and `xsl:include` references.
+     *
+     * The loader is synchronous: it MUST return the external stylesheet as a
+     * `Document` or as an XML string (which is parsed automatically). Promises
+     * are not awaited by the engine, so pre-load remote stylesheets before
+     * calling `importStylesheet`.
+     *
+     * The loader may be set before or after `importStylesheet`. When set before,
+     * it is passed to the engine on creation, which is required for the loader to
+     * be used while the stylesheet is being compiled. When set after, the live
+     * engine is updated as well.
+     *
+     * @param {((href: string, baseUri?: string) => (Document|string))|null} loader
+     *   The loader function, or null to remove a previously configured loader
+     * @returns {XSLTProcessor} This processor, to allow chaining
+     * @throws {TypeError} If the loader is neither a function nor null
+     *
+     * @example
+     * processor.setStylesheetLoader((href) => readFileSync(href, 'utf8'));
+     * processor.importStylesheet(mainStylesheet, '/styles/main.xsl');
+     */
+    setStylesheetLoader(loader) {
+      if (loader !== null && loader !== void 0 && typeof loader !== "function") {
+        throw new TypeError(
+          "Failed to execute 'setStylesheetLoader' on 'XSLTProcessor': The loader argument must be a function or null."
+        );
+      }
+      this._stylesheetLoader = loader ?? null;
+      if (this._engine) {
+        this._engine.setStylesheetLoader(this._stylesheetLoader);
+      }
+      return this;
+    }
+    /**
+     * Sets the loader used to resolve the XSLT `document()` function.
+     *
+     * The loader is synchronous: it MUST return the referenced document as a
+     * `Document`, as an XML string (which is parsed automatically) or as `null`
+     * when the document cannot be provided. Returning `null`, like configuring no
+     * loader at all, makes `document()` evaluate to an empty node-set rather than
+     * failing the transformation.
+     *
+     * The loader may be set before or after `importStylesheet`; a live engine is
+     * kept in sync.
+     *
+     * @param {((uri: string, baseUri?: string) => (Document|string|null))|null} loader
+     *   The loader function, or null to remove a previously configured loader
+     * @returns {XSLTProcessor} This processor, to allow chaining
+     * @throws {TypeError} If the loader is neither a function nor null
+     *
+     * @example
+     * // Node.js: resolve document() against the file system
+     * import { readFileSync } from 'node:fs';
+     * processor.setDocumentLoader((uri) => readFileSync(uri, 'utf8'));
+     * processor.importStylesheet(xslDoc, '/styles/main.xsl');
+     */
+    setDocumentLoader(loader) {
+      if (loader !== null && loader !== void 0 && typeof loader !== "function") {
+        throw new TypeError(
+          "Failed to execute 'setDocumentLoader' on 'XSLTProcessor': The loader argument must be a function or null."
+        );
+      }
+      this._documentLoader = loader ?? null;
+      if (this._engine) {
+        this._engine.setDocumentLoader(this._documentLoader);
+      }
+      return this;
     }
     /**
      * Imports the XSLT stylesheet.
@@ -3002,14 +4865,17 @@ var XsltProcessorLib = (() => {
      * <xsl:stylesheet> or <xsl:transform> element.
      *
      * @param {Node} style - The XSLT stylesheet to import (Document or Element)
+     * @param {string} [stylesheetUri] - Optional URI of the stylesheet, used as the
+     *   base URI when resolving relative `xsl:import`/`xsl:include` hrefs. When
+     *   omitted, hrefs are passed to the loader unresolved.
      * @returns {void}
      *
      * @example
      * const parser = new DOMParser();
      * const xslDoc = parser.parseFromString(xslText, 'application/xml');
-     * processor.importStylesheet(xslDoc);
+     * processor.importStylesheet(xslDoc, '/styles/main.xsl');
      */
-    importStylesheet(style) {
+    importStylesheet(style, stylesheetUri) {
       if (!style) {
         throw new TypeError(
           "Failed to execute 'importStylesheet' on 'XSLTProcessor': 1 argument required, but only 0 present."
@@ -3025,11 +4891,14 @@ var XsltProcessorLib = (() => {
         throw new Error("XSLT stylesheet contains parse errors");
       }
       this._stylesheet = style;
-      this._engine = new XsltEngine();
+      this._engine = new XsltEngine({
+        stylesheetLoader: this._stylesheetLoader,
+        documentLoader: this._documentLoader
+      });
       for (const [key, value] of this._parameters) {
-        this._engine.globalParameters[key] = { value };
+        this._engine.setParameterValue(key, value);
       }
-      this._engine.importStylesheet(style);
+      this._engine.importStylesheet(style, stylesheetUri);
     }
     /**
      * Transforms the node source by applying the XSLT stylesheet.
@@ -3110,6 +4979,45 @@ var XsltProcessorLib = (() => {
         return null;
       }
     }
+    /**
+     * Transforms the node source by applying the XSLT stylesheet and serializes
+     * the result to a string honoring the stylesheet `xsl:output` settings.
+     *
+     * Non-W3C convenience method: the native XSLTProcessor has no equivalent.
+     * Output method, indentation, XML declaration, document type declaration,
+     * CDATA sections and `disable-output-escaping` are all honored
+     * (XSLT 1.0 section 16).
+     *
+     * @param {Node} source - The XML document to transform
+     * @returns {string|null} The serialized result, or null on a transformation error
+     *
+     * @example
+     * const xml = processor.transformToString(xmlDoc);
+     * // '<?xml version="1.0" encoding="UTF-8"?>\n<BAR>\n  <QUX/>\n</BAR>'
+     */
+    transformToString(source) {
+      if (!source) {
+        throw new TypeError(
+          "Failed to execute 'transformToString' on 'XSLTProcessor': 1 argument required, but only 0 present."
+        );
+      }
+      if (!this._engine || !this._stylesheet) {
+        throw new Error(
+          "Failed to execute 'transformToString' on 'XSLTProcessor': No stylesheet has been imported."
+        );
+      }
+      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."
+        );
+      }
+      try {
+        return this._engine.transformToString(source);
+      } catch (error) {
+        console.error("XSLT transformation error:", error);
+        return null;
+      }
+    }
     /**
      * Sets a parameter in the XSLT stylesheet.
      *
@@ -3136,7 +5044,7 @@ var XsltProcessorLib = (() => {
       const key = namespaceURI ? `{${namespaceURI}}${localName}` : localName;
       this._parameters.set(key, value);
       if (this._engine) {
-        this._engine.globalParameters[key] = { value };
+        this._engine.setParameterValue(key, value);
       }
     }
     /**
@@ -3193,7 +5101,7 @@ var XsltProcessorLib = (() => {
       const key = namespaceURI ? `{${namespaceURI}}${localName}` : localName;
       this._parameters.delete(key);
       if (this._engine) {
-        delete this._engine.globalParameters[key];
+        this._engine.clearParameterValue(key);
       }
     }
     /**
@@ -3209,12 +5117,19 @@ var XsltProcessorLib = (() => {
     clearParameters() {
       this._parameters.clear();
       if (this._engine) {
-        this._engine.globalParameters = {};
+        this._engine.clearParameterValues();
       }
     }
     /**
      * Removes all parameters and stylesheets from the XSLTProcessor.
      *
+     * Per the W3C `XSLTProcessor` semantics, `reset()` clears stylesheet state and
+     * parameters only. The stylesheet and document loaders are processor
+     * configuration rather than stylesheet state, so they are deliberately
+     * preserved and stay effective for the next `importStylesheet()` call. Pass
+     * `null` to {@link XSLTProcessor#setStylesheetLoader} or
+     * {@link XSLTProcessor#setDocumentLoader} to remove them explicitly.
+     *
      * @returns {void}
      *
      * @example
@@ -3283,9 +5198,9 @@ var XsltProcessorLib = (() => {
   }
 
   // src/index.js
-  var VERSION = "1.0.0";
+  var VERSION = "1.1.1";
   var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
-  var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+  var isNode = typeof process !== "undefined" && process.versions?.node != null;
   return __toCommonJS(index_exports);
 })();