@tradik/xslt-processor 1.1.1 → 1.3.0

package/src/xpath/evaluator.js

@@ -8,6 +8,118 @@
 "use strict";
 
 import { NodeType } from "./parser.js";
+import {
+  AXIS_WALKERS,
+  REVERSE_AXES,
+  ancestorAxis,
+  attributeAxis,
+  childAxis,
+  descendantAxis,
+  followingAxis,
+  followingSiblingAxis,
+  precedingAxis,
+  precedingSiblingAxis,
+  isTextNode,
+  parentOf,
+  rootNodeOf,
+} from "./axes.js";
+import {
+  NAMESPACE_NODE,
+  matchNamespaceNameTest,
+  namespaceAxis,
+} from "./namespaceNodes.js";
+import {
+  DocumentOrderIndex,
+  compareDomPositions,
+  compareNodeOrder,
+  hasNativePositionComparison,
+} from "./documentOrder.js";
+import { createNodeSetFunctions } from "./nodeSetFunctions.js";
+import {
+  codePointLength,
+  formatXPathNumber,
+  normalizeXmlSpace,
+  parseXPathNumber,
+  xpathSubstring,
+  xpathTranslate,
+} from "./strings.js";
+
+/**
+ * Namespace the `xml` prefix is bound to in every context; it cannot be
+ * undeclared or rebound (Namespaces in XML 1.0, section 3).
+ */
+export const XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
+
+/**
+ * Resolve a namespace prefix: `xml` is predeclared, every other prefix comes
+ * from the context bindings.
+ *
+ * @param {string} prefix - The prefix
+ * @param {Object<string, string>} namespaces - Bindings by prefix
+ * @returns {string|null} The namespace URI, or null when undeclared
+ */
+export function resolveNamespacePrefix(prefix, namespaces) {
+  if (prefix === "xml") return XML_NAMESPACE;
+  return Object.hasOwn(namespaces, prefix) ? namespaces[prefix] : null;
+}
+
+/**
+ * Key of a function registered by expanded name, as used by
+ * {@link XPathEvaluator#registerFunctions}: `{namespace-uri}local-name`.
+ *
+ * @param {string} namespaceUri - The function's namespace
+ * @param {string} localName - The function's local name
+ * @returns {string} The registry key
+ *
+ * @example
+ * expandedFunctionName("http://exslt.org/common", "node-set");
+ * // "{http://exslt.org/common}node-set"
+ */
+export function expandedFunctionName(namespaceUri, localName) {
+  return `{${namespaceUri}}${localName}`;
+}
+
+/**
+ * Whether an expression is a call of the core `position()` function.
+ *
+ * @param {object} expr - Expression AST node
+ * @returns {boolean} True for `position()`
+ */
+function isPositionCall(expr) {
+  return (
+    expr.type === NodeType.FUNCTION_CALL &&
+    expr.name === "position" &&
+    !expr.prefix &&
+    expr.args.length === 0
+  );
+}
+
+/**
+ * Whether a node has the principal node type of an axis, the only type a
+ * name test can match there: attributes on the attribute axis, namespace
+ * nodes on the namespace axis, elements elsewhere (XPath 1.0 section 2.3).
+ *
+ * @param {number} type - The candidate node's `nodeType`
+ * @param {string|null} axis - The axis, or null when the caller checks types
+ * @returns {boolean} True when a name test may match the node
+ */
+function isPrincipalNodeType(type, axis) {
+  if (axis === null) return true;
+  if (axis === "attribute") return type === 2;
+  if (axis === "namespace") return type === NAMESPACE_NODE;
+  return type === 1;
+}
+
+/**
+ * Whether a node belongs to an HTML document (`contentType` "text/html").
+ * Two jsdom getters, so name tests read it last.
+ *
+ * @param {Node} node - An element
+ * @returns {boolean} True for a node of an HTML document
+ */
+function isInHtmlDocument(node) {
+  return node.ownerDocument?.contentType === "text/html";
+}
 
 /**
  * XPath result types matching W3C spec
@@ -92,7 +204,18 @@ export class XPathContext {
  * XPath Evaluator
  */
 export class XPathEvaluator {
+  /**
+   * @param {object} [options] - Evaluator options
+   * @param {number} [options.maxRecursionDepth] - Deepest expression nesting
+   * @param {number} [options.maxResultSize] - Largest node-set of one step
+   * @param {number} [options.maxStringLength] - Longest string literal
+   * @param {boolean} [options.legacyNameTests] - Deprecated: let unprefixed
+   *   name tests also match nodes in a namespace, as before 1.2.0
+   */
   constructor(options = {}) {
+    this.legacyNameTests = options.legacyNameTests === true;
+    this.resetNamespaceNodes();
+    this.resetDocumentOrder();
     this.functions = Object.assign(
       Object.create(null),
       this.initCoreFunctions(),
@@ -105,6 +228,18 @@ export class XPathEvaluator {
     this.recursionDepth = 0;
   }
 
+  /**
+   * Forget the namespace nodes synthesized so far (see namespaceNodes.js),
+   * e.g. before a new transformation: the declarations of the source tree
+   * may have changed. Until then each element keeps the same namespace node
+   * objects, so they have a stable identity.
+   *
+   * @returns {void}
+   */
+  resetNamespaceNodes() {
+    this.namespaceNodes = new WeakMap();
+  }
+
   /**
    * Evaluate XPath expression against a context
    * @throws {Error} If recursion depth exceeds limit
@@ -119,6 +254,11 @@ export class XPathEvaluator {
       throw new Error("Invalid AST: missing type property");
     }
 
+    // An index created during an earlier evaluation may describe trees
+    // that have changed since; one set with resetDocumentOrder() stays
+    if (this.recursionDepth === 0 && this.ownsDocumentOrder) {
+      this.resetDocumentOrder();
+    }
     this.recursionDepth++;
     if (this.recursionDepth > this.maxRecursionDepth) {
       this.recursionDepth = 0;
@@ -144,9 +284,8 @@ export class XPathEvaluator {
       case NodeType.AND_EXPR:
         return this.evalAndExpr(ast, context);
       case NodeType.EQUALITY_EXPR:
-        return this.evalEqualityExpr(ast, context);
       case NodeType.RELATIONAL_EXPR:
-        return this.evalRelationalExpr(ast, context);
+        return this.evalComparisonExpr(ast, context);
       case NodeType.ADDITIVE_EXPR:
         return this.evalAdditiveExpr(ast, context);
       case NodeType.MULTIPLICATIVE_EXPR:
@@ -210,14 +349,15 @@ export class XPathEvaluator {
     );
   }
 
-  evalEqualityExpr(ast, context) {
-    const left = this.evaluate(ast.left, context);
-    const right = this.evaluate(ast.right, context);
-    const isEqual = this.compareValues(left, right, "=");
-    return ast.operator === "=" ? isEqual : !isEqual;
-  }
-
-  evalRelationalExpr(ast, context) {
+  /**
+   * Evaluate `=`, `!=`, `<`, `<=`, `>` or `>=`. Comparisons involving
+   * node-sets are existential, so `!=` is not `not(=)` (XPath 3.4).
+   *
+   * @param {object} ast - Equality or relational expression node
+   * @param {XPathContext} context - Evaluation context
+   * @returns {boolean} The comparison result
+   */
+  evalComparisonExpr(ast, context) {
     const left = this.evaluate(ast.left, context);
     const right = this.evaluate(ast.right, context);
     return this.compareValues(left, right, ast.operator);
@@ -298,10 +438,9 @@ export class XPathEvaluator {
     let nodes;
 
     if (ast.absolute) {
-      // Start from document root node (not document element)
-      // XPath absolute paths start from the document node
-      const doc = context.node.ownerDocument || context.node;
-      nodes = [doc];
+      // The root node of the tree containing the context node: a document,
+      // or the fragment of a result tree fragment turned into a node-set
+      nodes = [rootNodeOf(context.node)];
     } else {
       nodes = [context.node];
     }
@@ -314,192 +453,190 @@ export class XPathEvaluator {
     return nodes;
   }
 
+  /**
+   * Apply one location step to every node of a node-set.
+   *
+   * The result is in document order without duplicates. With a single context
+   * node the axis output is already duplicate free, so it only needs to be
+   * reversed for reverse axes; merging several context nodes needs a sort.
+   *
+   * @param {object} step - Step AST node
+   * @param {Node|Node[]} nodes - Context nodes
+   * @param {XPathContext} context - Evaluation context
+   * @returns {Node[]} The selected nodes in document order
+   */
   evalStepOnNodes(step, nodes, context) {
     const allNodes = Array.isArray(nodes) ? nodes : [nodes];
-    let result = [];
+    const reverse = REVERSE_AXES.has(step.axis);
 
-    for (const node of allNodes) {
-      const stepNodes = this.evalStep(step, context.clone({ node }));
-      result = result.concat(stepNodes);
+    if (allNodes.length === 1) {
+      const single = this.evalStep(step, context.clone({ node: allNodes[0] }));
+      this.validateResultSize(single);
+      return reverse ? single.reverse() : single;
+    }
 
-      // Early validation to prevent excessive memory use
-      if (result.length > this.maxResultSize * 2) {
-        this.validateResultSize(result);
+    const seen = new Set();
+    const result = [];
+    for (const node of allNodes) {
+      for (const found of this.evalStep(step, context.clone({ node }))) {
+        if (!seen.has(found)) {
+          seen.add(found);
+          result.push(found);
+        }
       }
+      this.validateResultSize(result);
     }
 
-    // Remove duplicates and sort by document order
-    const uniqueResult = [...new Set(result)];
-    this.validateResultSize(uniqueResult);
-    return this.sortByDocumentOrder(uniqueResult);
+    return this.sortByDocumentOrder(result);
   }
 
+  /**
+   * Apply one location step to a single context node.
+   *
+   * When the first predicate selects one position (`[n]` or
+   * `[position() = n]`) and the axis can be walked lazily, the walk stops at
+   * the n-th node that passes the node test instead of materializing the
+   * whole axis: `following-sibling::x[1]` in a loop is then linear.
+   *
+   * @param {object} step - Step AST node
+   * @param {XPathContext} context - Evaluation context
+   * @returns {Node[]} The selected nodes in axis order
+   */
   evalStep(step, context) {
-    // Get nodes along axis
-    let nodes = this.getAxisNodes(step.axis, context.node);
+    const { predicates } = step;
+    const position = this.positionalPredicate(step);
+    let nodes;
+    let first = 0;
 
-    // Filter by node test
-    nodes = nodes.filter((n) => this.matchNodeTest(step.nodeTest, n, context));
+    if (position !== null && Object.hasOwn(AXIS_WALKERS, step.axis)) {
+      nodes = this.nthOnAxis(step, context, position);
+      first = 1;
+    } else {
+      nodes = this.getAxisNodes(step.axis, context.node).filter((n) =>
+        this.matchNodeTest(step.nodeTest, n, context, step.axis),
+      );
+    }
 
-    // Apply predicates
-    for (const predicate of step.predicates) {
-      nodes = this.filterByPredicate(nodes, predicate, context);
+    for (let i = first; i < predicates.length; i++) {
+      nodes = this.filterByPredicate(nodes, predicates[i], context);
     }
 
     return nodes;
   }
 
+  /**
+   * The position selected by the first predicate of a step, when that
+   * predicate is a number literal `[n]` or `[position() = n]`.
+   *
+   * @param {object} step - Step AST node
+   * @returns {number|null} The position, or null for any other predicate
+   */
+  positionalPredicate(step) {
+    const expr = step.predicates[0]?.expr;
+    if (!expr) return null;
+    if (expr.type === NodeType.NUMBER) return expr.value;
+    if (expr.type !== NodeType.EQUALITY_EXPR || expr.operator !== "=") {
+      return null;
+    }
+    const { left, right } = expr;
+    if (isPositionCall(left) && right.type === NodeType.NUMBER) {
+      return right.value;
+    }
+    if (isPositionCall(right) && left.type === NodeType.NUMBER) {
+      return left.value;
+    }
+    return null;
+  }
+
+  /**
+   * The n-th node of an axis passing the node test of a step, found by
+   * walking the axis only as far as needed.
+   *
+   * @param {object} step - Step AST node
+   * @param {XPathContext} context - Evaluation context
+   * @param {number} position - The wanted proximity position
+   * @returns {Node[]} The node, or an empty node-set
+   */
+  nthOnAxis(step, context, position) {
+    // Positions are whole numbers from 1: [0], [1.5] or [NaN] select nothing
+    if (!Number.isInteger(position) || position < 1) return [];
+    let remaining = position;
+    let found = null;
+    AXIS_WALKERS[step.axis](context.node, (node) => {
+      if (!this.matchNodeTest(step.nodeTest, node, context, step.axis)) {
+        return false;
+      }
+      remaining--;
+      if (remaining > 0) return false;
+      found = node;
+      return true;
+    });
+    return found ? [found] : [];
+  }
+
+  /**
+   * Nodes on an axis (see axes.js). Reverse axes are returned nearest first,
+   * so predicates see proximity positions.
+   *
+   * @param {string} axis - Axis name
+   * @param {Node} node - Context node
+   * @returns {Node[]} The nodes on the axis
+   */
   getAxisNodes(axis, node) {
     switch (axis) {
       case "child":
-        return Array.from(node.childNodes || []);
-
-      case "parent":
-        return node.parentNode ? [node.parentNode] : [];
-
+        return childAxis(node);
+      case "parent": {
+        const parent = parentOf(node);
+        return parent ? [parent] : [];
+      }
       case "self":
         return [node];
-
       case "descendant":
-        return this.getDescendants(node, false);
-
+        return descendantAxis(node, false);
       case "descendant-or-self":
-        return this.getDescendants(node, true);
-
+        return descendantAxis(node, true);
       case "ancestor":
-        return this.getAncestors(node, false);
-
+        return ancestorAxis(node, false);
       case "ancestor-or-self":
-        return this.getAncestors(node, true);
-
+        return ancestorAxis(node, true);
       case "following-sibling":
-        return this.getFollowingSiblings(node);
-
+        return followingSiblingAxis(node);
       case "preceding-sibling":
-        return this.getPrecedingSiblings(node);
-
+        return precedingSiblingAxis(node);
       case "following":
-        return this.getFollowing(node);
-
+        return followingAxis(node);
       case "preceding":
-        return this.getPreceding(node);
-
+        return precedingAxis(node);
       case "attribute":
-        if (node.attributes) {
-          return Array.from(node.attributes);
-        }
-        return [];
-
+        return attributeAxis(node);
       case "namespace":
-        // Namespace axis - not commonly used
-        return [];
-
+        return namespaceAxis(node, this.namespaceNodes);
       default:
         throw new Error(`Unknown axis: ${axis}`);
     }
   }
 
-  getDescendants(node, includeSelf) {
-    const result = includeSelf ? [node] : [];
-    const stack = Array.from(node.childNodes || []).reverse();
-
-    while (stack.length > 0) {
-      const current = stack.pop();
-      result.push(current);
-      if (current.childNodes) {
-        for (let i = current.childNodes.length - 1; i >= 0; i--) {
-          stack.push(current.childNodes[i]);
-        }
-      }
-    }
-
-    return result;
-  }
-
-  getAncestors(node, includeSelf) {
-    const result = includeSelf ? [node] : [];
-    let current = node.parentNode;
-
-    while (current) {
-      result.push(current);
-      current = current.parentNode;
-    }
-
-    return result;
-  }
-
-  getFollowingSiblings(node) {
-    const result = [];
-    if (!node) return result;
-    let current = node.nextSibling;
-
-    while (current) {
-      result.push(current);
-      current = current.nextSibling;
-    }
-
-    return result;
-  }
-
-  getPrecedingSiblings(node) {
-    const result = [];
-    if (!node) return result;
-    let current = node.previousSibling;
-
-    while (current) {
-      result.push(current);
-      current = current.previousSibling;
-    }
-
-    return result.reverse();
-  }
-
-  getFollowing(node) {
-    const result = [];
-    let current = node;
-
-    // Go to next sibling, or ancestor's next sibling
-    while (current) {
-      if (current.nextSibling) {
-        current = current.nextSibling;
-        result.push(current);
-        // Add all descendants
-        result.push(...this.getDescendants(current, false));
-      } else {
-        current = current.parentNode;
-      }
-    }
-
-    return result;
-  }
-
-  getPreceding(node) {
-    const result = [];
-    let current = node;
-
-    while (current) {
-      if (current.previousSibling) {
-        current = current.previousSibling;
-        // Add descendants in reverse order, then the node
-        const descendants = this.getDescendants(current, false);
-        result.unshift(...descendants.reverse());
-        result.unshift(current);
-      } else {
-        current = current.parentNode;
-        if (current && current.nodeType !== 9) {
-          // Not document
-          // Don't add ancestors
-        }
-      }
-    }
-
-    return result;
-  }
-
-  matchNodeTest(nodeTest, node, context) {
+  /**
+   * Match a node test against a node.
+   *
+   * @param {object} nodeTest - Node test AST node
+   * @param {Node} node - Candidate node
+   * @param {XPathContext} context - Evaluation context (for prefixes)
+   * @param {string|null} [axis] - Axis of the step, which decides the
+   *   principal node type of name tests; null for XSLT patterns, whose
+   *   matcher checks node types itself
+   * @returns {boolean} Whether the node matches
+   */
+  matchNodeTest(nodeTest, node, context, axis = null) {
     switch (nodeTest.type) {
-      case NodeType.NAME_TEST:
-        return this.matchNameTest(nodeTest, node, context);
+      case NodeType.NAME_TEST: {
+        const type = node.nodeType;
+        return (
+          isPrincipalNodeType(type, axis) &&
+          this.matchNameTest(nodeTest, node, context, type)
+        );
+      }
 
       case NodeType.NODE_TYPE_TEST:
         return this.matchNodeTypeTest(nodeTest.nodeType, node);
@@ -512,43 +649,64 @@ export class XPathEvaluator {
     }
   }
 
-  matchNameTest(nodeTest, node, context) {
+  /**
+   * Match a name test against a node.
+   *
+   * Cheap checks run first: in jsdom every DOM getter crosses a wrapper, so
+   * `namespaceURI` and the owner document's content type are only read when
+   * the outcome depends on them.
+   *
+   * @param {object} nodeTest - Name test AST node
+   * @param {Node} node - Candidate node
+   * @param {XPathContext} context - Evaluation context (for prefixes)
+   * @param {number} [type] - The node's `nodeType`, when already read
+   * @returns {boolean} Whether the node matches
+   */
+  matchNameTest(nodeTest, node, context, type = node.nodeType) {
+    if (type === NAMESPACE_NODE) return matchNamespaceNameTest(nodeTest, node);
     // Only element and attribute nodes have names
-    if (node.nodeType !== 1 && node.nodeType !== 2) {
-      return false;
-    }
+    if (type !== 1 && type !== 2) return false;
 
-    const name = nodeTest.name;
-    const prefix = nodeTest.prefix;
+    const { name, prefix } = nodeTest;
 
-    // Wildcard
-    if (name === "*" && !prefix) {
-      return true;
-    }
-
-    // Get node's local name and namespace
-    const nodeName = node.localName || node.nodeName;
-    const nodeNs = node.namespaceURI || null;
+    if (!prefix) return this.matchUnprefixedName(name, node, type);
 
-    // Prefix:* matches all nodes in namespace
-    if (name === "*" && prefix) {
-      const ns = context.namespaces[prefix];
-      return nodeNs === ns;
+    const namespaceUri = resolveNamespacePrefix(prefix, context.namespaces);
+    if (!namespaceUri) {
+      // An undeclared prefix is an error (XPath 1.0 section 2.3), as in
+      // libxslt; it must not silently match names in no namespace
+      throw new Error(`Undefined namespace prefix: ${prefix}`);
     }
+    if ((node.namespaceURI || null) !== namespaceUri) return false;
+    return name === "*" || (node.localName || node.nodeName) === name;
+  }
 
-    // Simple name match
-    if (!prefix) {
-      // For elements, match local name (case-insensitive for HTML)
-      const doc = node.ownerDocument;
-      if (doc && doc.contentType === "text/html" && node.nodeType === 1) {
-        return nodeName.toLowerCase() === name.toLowerCase();
-      }
-      return nodeName === name;
+  /**
+   * Match a name test without prefix (`name` or `*`) against an element or
+   * attribute. The owner document's content type (two jsdom getters) is
+   * read last, only for HTML-specific outcomes.
+   *
+   * @param {string} name - The tested name, or "*"
+   * @param {Node} node - An element or attribute
+   * @param {number} type - The node's `nodeType`
+   * @returns {boolean} Whether the node matches
+   */
+  matchUnprefixedName(name, node, type) {
+    if (name === "*") return true;
+    const nodeName = node.localName || node.nodeName;
+    if (nodeName !== name) {
+      // HTML documents match element names case-insensitively
+      return (
+        type === 1 &&
+        nodeName.toLowerCase() === name.toLowerCase() &&
+        isInHtmlDocument(node)
+      );
     }
-
-    // Prefixed name match
-    const ns = context.namespaces[prefix];
-    return nodeName === name && nodeNs === ns;
+    // A QName without prefix only matches nodes in no namespace (2.3).
+    // HTML elements are in the XHTML namespace in the DOM but in none for
+    // libxslt, which receives HTML documents re-parsed from their markup.
+    if (this.legacyNameTests || node.namespaceURI === null) return true;
+    return type === 1 && isInHtmlDocument(node);
   }
 
   matchNodeTypeTest(nodeType, node) {
@@ -619,11 +777,17 @@ export class XPathEvaluator {
    * core function. Each function is called as `fn(args, context)` with the
    * evaluator as `this`.
    *
+   * Extension functions are keyed by expanded name, `{namespace-uri}local`
+   * (see {@link expandedFunctionName}), and are found through whatever prefix
+   * the expression binds to that namespace. A literal `prefix:local` key is
+   * still honoured when the prefix does not resolve to a registered function.
+   *
    * @param {Object<string, Function>} functions - Functions by name
    * @returns {XPathEvaluator} This evaluator, to allow chaining
    *
    * @example
-   * evaluator.registerFunctions({ 'my:double': (args, ctx) => 2 });
+   * evaluator.registerFunctions({ '{urn:my}double': (args, ctx) => 2 });
+   * // callable as my:double() when my is bound to urn:my
    */
   registerFunctions(functions) {
     for (const [name, fn] of Object.entries(functions)) {
@@ -632,14 +796,58 @@ export class XPathEvaluator {
     return this;
   }
 
+  /**
+   * Find the implementation of a possibly prefixed function name.
+   *
+   * @param {string} localName - The local part of the function name
+   * @param {string|null} prefix - The prefix, or null for core functions
+   * @param {Object<string, string>} namespaces - Prefix bindings
+   * @returns {Function|null} The function, or null when none is registered
+   */
+  resolveFunction(localName, prefix, namespaces) {
+    if (!prefix) return this.getFunction(localName);
+
+    const namespaceUri = resolveNamespacePrefix(prefix, namespaces);
+    const byUri =
+      namespaceUri === null
+        ? null
+        : this.getFunction(expandedFunctionName(namespaceUri, localName));
+    return byUri ?? this.getFunction(`${prefix}:${localName}`);
+  }
+
+  /**
+   * Whether a function is registered under an expanded name.
+   *
+   * @param {string} localName - The local part of the function name
+   * @param {string|null} [namespaceUri] - The namespace, null for core functions
+   * @returns {boolean} True when the function exists
+   */
+  hasFunction(localName, namespaceUri = null) {
+    const key = namespaceUri
+      ? expandedFunctionName(namespaceUri, localName)
+      : localName;
+    return this.getFunction(key) !== null;
+  }
+
+  /**
+   * Own entry of the function table, never an inherited property.
+   *
+   * @param {string} key - Registry key
+   * @returns {Function|null} The function, or null
+   */
+  getFunction(key) {
+    return Object.hasOwn(this.functions, key) ? this.functions[key] : null;
+  }
+
   evalFunctionCall(ast, context) {
-    const name = ast.prefix ? `${ast.prefix}:${ast.name}` : ast.name;
+    const fn = this.resolveFunction(ast.name, ast.prefix, context.namespaces);
 
-    if (!Object.hasOwn(this.functions, name)) {
+    if (!fn) {
+      const name = ast.prefix ? `${ast.prefix}:${ast.name}` : ast.name;
       throw new Error(`Unknown function: ${name}`);
     }
 
-    return this.functions[name].call(this, ast.args, context);
+    return fn.call(this, ast.args, context);
   }
 
   // Type conversion functions
@@ -655,12 +863,7 @@ export class XPathEvaluator {
   toNumber(value) {
     if (typeof value === "number") return value;
     if (typeof value === "boolean") return value ? 1 : 0;
-    if (typeof value === "string") {
-      const trimmed = value.trim();
-      if (trimmed === "") return NaN;
-      const num = Number(trimmed);
-      return num;
-    }
+    if (typeof value === "string") return parseXPathNumber(value);
     if (Array.isArray(value)) {
       return this.toNumber(this.toString(value));
     }
@@ -672,13 +875,7 @@ export class XPathEvaluator {
 
   toString(value) {
     if (typeof value === "string") return value;
-    if (typeof value === "number") {
-      if (isNaN(value)) return "NaN";
-      if (value === Infinity) return "Infinity";
-      if (value === -Infinity) return "-Infinity";
-      if (value === 0) return "0";
-      return String(value);
-    }
+    if (typeof value === "number") return formatXPathNumber(value);
     if (typeof value === "boolean") return value ? "true" : "false";
     if (Array.isArray(value)) {
       if (value.length === 0) return "";
@@ -712,11 +909,21 @@ export class XPathEvaluator {
         return text;
       }
 
-      case 2: // Attribute
       case 3: // Text
-      case 4: // CDATA
+      case 4: {
+        // CDATA. A run of adjacent text nodes is one XPath text node (5.7)
+        let text = node.nodeValue;
+        for (let next = node.nextSibling; isTextNode(next);) {
+          text += next.nodeValue;
+          next = next.nextSibling;
+        }
+        return text;
+      }
+
+      case 2: // Attribute
       case 7: // Processing Instruction
       case 8: // Comment
+      case NAMESPACE_NODE: // The namespace URI
         return node.nodeValue || "";
 
       default:
@@ -729,6 +936,18 @@ export class XPathEvaluator {
     const leftIsNodeSet = Array.isArray(left);
     const rightIsNodeSet = Array.isArray(right);
 
+    // A node-set compared with a boolean is converted with boolean() (3.4)
+    if (
+      (leftIsNodeSet && typeof right === "boolean") ||
+      (rightIsNodeSet && typeof left === "boolean")
+    ) {
+      return this.comparePrimitive(
+        this.toBoolean(left),
+        this.toBoolean(right),
+        operator,
+      );
+    }
+
     // Node-set comparisons
     if (leftIsNodeSet && rightIsNodeSet) {
       for (const l of left) {
@@ -804,46 +1023,46 @@ export class XPathEvaluator {
     }
   }
 
+  /**
+   * Sort nodes in document order; attributes and namespace nodes sort after
+   * their element and before its children (see documentOrder.js).
+   *
+   * With a {@link DocumentOrderIndex} (set by the XSLT engine for each
+   * transformation, or created on first use when the DOM has no
+   * `compareDocumentPosition`, as xmldom 0.8), nodes are sorted by their
+   * precomputed positions; otherwise through `compareDocumentPosition`.
+   *
+   * @param {Node[]} nodes - The nodes, sorted in place
+   * @returns {Node[]} The same array
+   */
   sortByDocumentOrder(nodes) {
     if (nodes.length <= 1) return nodes;
+    // Number the trees once per evaluation unless the DOM compares positions
+    // natively: compareDocumentPosition written in JavaScript (xmldom,
+    // jsdom) costs a tree walk per comparison
+    if (!this.documentOrder && !hasNativePositionComparison(nodes[0])) {
+      this.documentOrder = new DocumentOrderIndex();
+      this.ownsDocumentOrder = true;
+    }
+    if (this.documentOrder) return this.documentOrder.sort(nodes);
 
-    return nodes.sort((a, b) => {
-      if (a === b) return 0;
-
-      const position = a.compareDocumentPosition
-        ? a.compareDocumentPosition(b)
-        : this.compareDocumentPositionFallback(a, b);
-
-      if (position & 4) return -1; // a before b
-      if (position & 2) return 1; // a after b
-      return 0;
-    });
+    return nodes.sort((a, b) =>
+      a === b ? 0 : compareNodeOrder(a, b, compareDomPositions),
+    );
   }
 
-  compareDocumentPositionFallback(a, b) {
-    // Simple fallback for environments without compareDocumentPosition
-    const getPath = (node) => {
-      const path = [];
-      let current = node;
-      while (current) {
-        if (current.parentNode) {
-          const siblings = Array.from(current.parentNode.childNodes);
-          path.unshift(siblings.indexOf(current));
-        }
-        current = current.parentNode;
-      }
-      return path;
-    };
-
-    const pathA = getPath(a);
-    const pathB = getPath(b);
-
-    for (let i = 0; i < Math.min(pathA.length, pathB.length); i++) {
-      if (pathA[i] < pathB[i]) return 4; // a before b
-      if (pathA[i] > pathB[i]) return 2; // a after b
-    }
-
-    return pathA.length < pathB.length ? 4 : 2;
+  /**
+   * Use a new {@link DocumentOrderIndex} from now on, e.g. for a new
+   * transformation (the trees may have changed since the previous one), or
+   * none (null): `compareDocumentPosition` then orders the nodes whenever
+   * the DOM has it.
+   *
+   * @param {DocumentOrderIndex|null} [index] - The index to use
+   * @returns {void}
+   */
+  resetDocumentOrder(index = null) {
+    this.documentOrder = index;
+    this.ownsDocumentOrder = false;
   }
 
   /**
@@ -854,54 +1073,7 @@ export class XPathEvaluator {
       // Node set functions
       last: (args, ctx) => ctx.size,
       position: (args, ctx) => ctx.position,
-      count: (args, ctx) => {
-        const nodeSet = this.evaluate(args[0], ctx);
-        return Array.isArray(nodeSet) ? nodeSet.length : 1;
-      },
-      id: (args, ctx) => {
-        const value = this.toString(this.evaluate(args[0], ctx));
-        const doc = ctx.node.ownerDocument || ctx.node;
-        const ids = value.split(/\s+/).filter((id) => id);
-        const result = [];
-        for (const id of ids) {
-          const el = doc.getElementById(id);
-          if (el) result.push(el);
-        }
-        return result;
-      },
-      "local-name": (args, ctx) => {
-        let node;
-        if (args.length === 0) {
-          node = ctx.node;
-        } else {
-          const nodeSet = this.evaluate(args[0], ctx);
-          node = Array.isArray(nodeSet) ? nodeSet[0] : nodeSet;
-        }
-        if (!node) return "";
-        return node.localName || node.nodeName || "";
-      },
-      "namespace-uri": (args, ctx) => {
-        let node;
-        if (args.length === 0) {
-          node = ctx.node;
-        } else {
-          const nodeSet = this.evaluate(args[0], ctx);
-          node = Array.isArray(nodeSet) ? nodeSet[0] : nodeSet;
-        }
-        if (!node) return "";
-        return node.namespaceURI || "";
-      },
-      name: (args, ctx) => {
-        let node;
-        if (args.length === 0) {
-          node = ctx.node;
-        } else {
-          const nodeSet = this.evaluate(args[0], ctx);
-          node = Array.isArray(nodeSet) ? nodeSet[0] : nodeSet;
-        }
-        if (!node) return "";
-        return node.nodeName || "";
-      },
+      ...createNodeSetFunctions(this),
 
       // String functions
       string: (args, ctx) => {
@@ -939,61 +1111,32 @@ export class XPathEvaluator {
       },
       substring: (args, ctx) => {
         const str = this.toString(this.evaluate(args[0], ctx));
-        let start = Math.round(this.toNumber(this.evaluate(args[1], ctx)));
-        let length;
-
-        if (args.length > 2) {
-          length = Math.round(this.toNumber(this.evaluate(args[2], ctx)));
-        }
-
-        // XPath uses 1-based indexing
-        start = start - 1;
-
-        if (isNaN(start)) return "";
-        if (start < 0) {
-          if (length !== undefined) {
-            length = length + start;
-          }
-          start = 0;
-        }
-
-        if (length !== undefined) {
-          if (isNaN(length) || length <= 0) return "";
-          return str.substring(start, start + length);
-        }
-
-        return str.substring(start);
+        const start = this.toNumber(this.evaluate(args[1], ctx));
+        const length =
+          args.length > 2
+            ? this.toNumber(this.evaluate(args[2], ctx))
+            : undefined;
+        return xpathSubstring(str, start, length);
       },
       "string-length": (args, ctx) => {
         const str =
           args.length === 0
             ? this.toString([ctx.node])
             : this.toString(this.evaluate(args[0], ctx));
-        return str.length;
+        return codePointLength(str);
       },
       "normalize-space": (args, ctx) => {
         const str =
           args.length === 0
             ? this.toString([ctx.node])
             : this.toString(this.evaluate(args[0], ctx));
-        return str.trim().replace(/\s+/g, " ");
+        return normalizeXmlSpace(str);
       },
       translate: (args, ctx) => {
         const str = this.toString(this.evaluate(args[0], ctx));
         const from = this.toString(this.evaluate(args[1], ctx));
         const to = this.toString(this.evaluate(args[2], ctx));
-
-        let result = "";
-        for (const char of str) {
-          const idx = from.indexOf(char);
-          if (idx === -1) {
-            result += char;
-          } else if (idx < to.length) {
-            result += to[idx];
-          }
-          // If idx >= to.length, character is removed
-        }
-        return result;
+        return xpathTranslate(str, from, to);
       },
 
       // Boolean functions
@@ -1005,21 +1148,6 @@ export class XPathEvaluator {
       },
       true: () => true,
       false: () => false,
-      lang: (args, ctx) => {
-        const lang = this.toString(this.evaluate(args[0], ctx)).toLowerCase();
-        let node = ctx.node;
-
-        while (node && node.nodeType === 1) {
-          const xmlLang =
-            node.getAttribute("xml:lang") || node.getAttribute("lang");
-          if (xmlLang) {
-            const nodeLang = xmlLang.toLowerCase();
-            return nodeLang === lang || nodeLang.startsWith(lang + "-");
-          }
-          node = node.parentNode;
-        }
-        return false;
-      },
 
       // Number functions
       number: (args, ctx) => {
@@ -1028,14 +1156,6 @@ export class XPathEvaluator {
         }
         return this.toNumber(this.evaluate(args[0], ctx));
       },
-      sum: (args, ctx) => {
-        const nodeSet = this.evaluate(args[0], ctx);
-        if (!Array.isArray(nodeSet)) return NaN;
-        return nodeSet.reduce(
-          (sum, node) => sum + this.toNumber(this.getStringValue(node)),
-          0,
-        );
-      },
       floor: (args, ctx) => {
         return Math.floor(this.toNumber(this.evaluate(args[0], ctx)));
       },