@tradik/xslt-processor 1.0.3 → 1.1.1

package/dist/xslt-processor.js

@@ -781,12 +781,22 @@ var FORBIDDEN_VARIABLE_NAMES = Object.freeze([
   "__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(
@@ -794,13 +804,17 @@ var XPathContext = class _XPathContext {
       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;
@@ -1150,7 +1164,7 @@ var XPathEvaluator = class {
       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":
@@ -1191,13 +1205,31 @@ var XPathEvaluator = class {
     }
     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) {
@@ -1254,7 +1286,7 @@ var XPathEvaluator = class {
       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) {
@@ -1559,8 +1591,1486 @@ var XPathEvaluator = class {
   }
 };
 
+// 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;
@@ -1576,6 +3086,8 @@ var XsltContext = class _XsltContext {
     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({
@@ -1591,7 +3103,9 @@ var XsltContext = class _XsltContext {
       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) {
@@ -1616,7 +3130,9 @@ var XsltEngine = class {
     this.globalParameters = {};
     this.outputSettings = {
       method: "xml",
+      version: "1.0",
       encoding: "UTF-8",
+      standalone: null,
       indent: "no",
       omitXmlDeclaration: "no",
       doctypePublic: null,
@@ -1628,13 +3144,105 @@ var XsltEngine = class {
     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
@@ -1645,14 +3253,13 @@ var XsltEngine = class {
   }
   /**
    * 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
@@ -1774,7 +3381,8 @@ var XsltEngine = class {
       this.currentImportPrecedence = savedPrecedence;
     } catch (error) {
       throw new Error(
-        `Failed to include stylesheet "${href}": ${error.message}`
+        `Failed to include stylesheet "${href}": ${error.message}`,
+        { cause: error }
       );
     }
   }
@@ -1802,7 +3410,8 @@ var XsltEngine = class {
       this.currentImportPrecedence++;
     } catch (error) {
       throw new Error(
-        `Failed to import stylesheet "${href}": ${error.message}`
+        `Failed to import stylesheet "${href}": ${error.message}`,
+        { cause: error }
       );
     }
   }
@@ -1878,39 +3487,50 @@ var XsltEngine = class {
       }
     }
   }
+  /**
+   * 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");
@@ -1931,16 +3551,80 @@ var XsltEngine = class {
     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") || "";
@@ -1958,9 +3642,7 @@ var XsltEngine = class {
     };
   }
   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");
@@ -1990,11 +3672,13 @@ var XsltEngine = class {
     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,
@@ -2003,6 +3687,7 @@ var XsltEngine = class {
       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);
@@ -2011,28 +3696,91 @@ var XsltEngine = class {
     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);
     }
@@ -2052,7 +3800,9 @@ var XsltEngine = class {
         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 {
@@ -2063,13 +3813,14 @@ var XsltEngine = class {
   /**
    * 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;
@@ -2142,19 +3893,22 @@ var XsltEngine = class {
           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];
@@ -2165,7 +3919,8 @@ var XsltEngine = class {
         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];
@@ -2279,6 +4034,9 @@ var XsltEngine = class {
       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;
@@ -2338,34 +4096,47 @@ var XsltEngine = class {
   }
   /**
    * 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);
@@ -2452,6 +4223,38 @@ var XsltEngine = class {
     });
     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);
@@ -2776,79 +4579,47 @@ var XsltEngine = class {
   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";
@@ -2932,7 +4703,8 @@ var XsltEngine = class {
       context.position,
       context.currentNodeList.length,
       { ...context.variables, ...context.parameters },
-      context.namespaces
+      context.namespaces,
+      context
     );
     return this.xpathEvaluator.evaluate(ast, xpathContext);
   }
@@ -2952,6 +4724,94 @@ var XSLTProcessor = class {
     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.
@@ -2961,14 +4821,17 @@ var XSLTProcessor = class {
    * <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."
@@ -2984,11 +4847,14 @@ var XSLTProcessor = class {
       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.
@@ -3069,6 +4935,45 @@ var XSLTProcessor = class {
       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.
    *
@@ -3095,7 +5000,7 @@ var XSLTProcessor = class {
     const key = namespaceURI ? `{${namespaceURI}}${localName}` : localName;
     this._parameters.set(key, value);
     if (this._engine) {
-      this._engine.globalParameters[key] = { value };
+      this._engine.setParameterValue(key, value);
     }
   }
   /**
@@ -3152,7 +5057,7 @@ var XSLTProcessor = class {
     const key = namespaceURI ? `{${namespaceURI}}${localName}` : localName;
     this._parameters.delete(key);
     if (this._engine) {
-      delete this._engine.globalParameters[key];
+      this._engine.clearParameterValue(key);
     }
   }
   /**
@@ -3168,12 +5073,19 @@ var XSLTProcessor = class {
   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
@@ -3242,9 +5154,9 @@ function selectFirst(expression, contextNode, options = {}) {
 }
 
 // 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;
 export {
   VERSION,
   XPathContext,
@@ -3259,8 +5171,12 @@ export {
   isBrowser,
   isNativeXSLTSupported,
   isNode,
+  isRawText,
+  markRawText,
   parse as parseXPath,
+  resolveOutputSettings,
   selectFirst as selectFirstXPath,
-  select as selectXPath
+  select as selectXPath,
+  serializeResult
 };
 //# sourceMappingURL=xslt-processor.js.map