@getodk/xpath 0.2.1 → 0.3.0

package/dist/index.js

@@ -1,21 +1,21 @@
-import { c as commonjsGlobal, U as UpsertableMap, e as expressionParser, g as getAugmentedNamespace, a as getDefaultExportFromCjs } from './expressionParser-BVz9yCmv.js';
+import { c as commonjsGlobal, U as UpsertableMap, e as expressionParser, g as getAugmentedNamespace, a as getDefaultExportFromCjs } from './expressionParser-DpqfmhIO.js';
 
 function _mergeNamespaces(n, m) {
-	for (var i = 0; i < m.length; i++) {
-		const e = m[i];
-		if (typeof e !== 'string' && !Array.isArray(e)) { for (const k in e) {
-			if (k !== 'default' && !(k in n)) {
-				const d = Object.getOwnPropertyDescriptor(e, k);
-				if (d) {
-					Object.defineProperty(n, k, d.get ? d : {
-						enumerable: true,
-						get: () => e[k]
-					});
-				}
-			}
-		} }
-	}
-	return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: 'Module' }));
+    for (var i = 0; i < m.length; i++) {
+        const e = m[i];
+        if (typeof e !== 'string' && !Array.isArray(e)) { for (const k in e) {
+            if (k !== 'default' && !(k in n)) {
+                const d = Object.getOwnPropertyDescriptor(e, k);
+                if (d) {
+                    Object.defineProperty(n, k, d.get ? d : {
+                        enumerable: true,
+                        get: () => e[k]
+                    });
+                }
+            }
+        } }
+    }
+    return Object.freeze(Object.defineProperty(n, Symbol.toStringTag, { value: 'Module' }));
 }
 
 const t = {};
@@ -7952,35 +7952,6 @@ for (const e of Zt) {
   (t.configurable || t.enumerable || t.writable) && (t.configurable = !1, t.enumerable = !1, t.writable = !1, Object.defineProperty(e, "prototype", t));
 }
 
-class UnreachableError extends Error {
-  constructor(unrechable, additionalDetail) {
-    let message = `Unreachable value: ${JSON.stringify(unrechable)}`;
-    if (additionalDetail != null) {
-      message = `${message} (${additionalDetail})`;
-    }
-    super(message);
-  }
-}
-
-const identity = (value) => value;
-
-const {
-  ATTRIBUTE_NODE,
-  CDATA_SECTION_NODE,
-  COMMENT_NODE,
-  DOCUMENT_NODE,
-  DOCUMENT_FRAGMENT_NODE,
-  ELEMENT_NODE,
-  PROCESSING_INSTRUCTION_NODE,
-  TEXT_NODE
-} = Node;
-const isAttributeNode = (node) => node.nodeType === ATTRIBUTE_NODE;
-const isNamespaceAttribute = (attr) => attr.name === "xmlns" || attr.prefix === "xmlns";
-const isNamespaceNode = (node) => isAttributeNode(node) && (node.name === "xmlns" || node.prefix === "xmlns");
-const isDocumentNode = (node) => node.nodeType === DOCUMENT_NODE;
-const isElementNode = (node) => node.nodeType === ELEMENT_NODE;
-const isProcessingInstructionNode = (node) => node.nodeType === PROCESSING_INSTRUCTION_NODE;
-
 var transform = {};
 
 var exceptions = {};
@@ -21440,14 +21411,6 @@ function* toIterableIterator(iter) {
     }
   }
 }
-const map$1 = (fn) => (
-  // eslint-disable-next-line @typescript-eslint/no-shadow -- naming the function is helpful in stack traces/debugging
-  function* map2(iterable) {
-    for (const item of toIterableIterator(iterable)) {
-      yield fn(item);
-    }
-  }
-);
 const filter = (guard) => (
   // eslint-disable-next-line @typescript-eslint/no-shadow -- naming the function is helpful in stack traces/debugging
   function* filter2(iterable) {
@@ -21472,6 +21435,228 @@ const tee = (input) => {
   return transformExports.tee(input, 2);
 };
 
+const extendNodeKindGuards = (base) => {
+  const assertXPathNode = (value, message = "Invalid context node") => {
+    if (!base.isXPathNode(value)) {
+      throw new Error(message);
+    }
+  };
+  const isParentNode = (value) => {
+    const kind = base.getNodeKind(value);
+    return kind === "document" || kind === "element";
+  };
+  const extensions = {
+    assertXPathNode,
+    assertParentNode: (value, message = "Invalid parent node") => {
+      assertXPathNode(value);
+      if (!isParentNode(value)) {
+        throw new Error(message);
+      }
+    },
+    isDocument: (node) => {
+      return base.getNodeKind(node) === "document";
+    },
+    isElement: (node) => {
+      return base.getNodeKind(node) === "element";
+    },
+    isNamespaceDeclaration: (node) => {
+      return base.getNodeKind(node) === "namespace_declaration";
+    },
+    isAttribute: (node) => {
+      return base.getNodeKind(node) === "attribute";
+    },
+    isText: (node) => {
+      return base.getNodeKind(node) === "text";
+    },
+    isComment: (node) => {
+      return base.getNodeKind(node) === "comment";
+    },
+    isProcessingInstruction: (node) => {
+      return base.getNodeKind(node) === "processing_instruction";
+    },
+    isParentNode,
+    isQualifiedNamedNode: (node) => {
+      const kind = base.getNodeKind(node);
+      return kind === "element" || kind === "attribute";
+    }
+  };
+  return Object.assign(base, extensions);
+};
+const extendIterableOperations = (base) => {
+  const extensions = {
+    filterAttributes: filter(base.isAttribute),
+    filterQualifiedNamedNodes: filter(base.isQualifiedNamedNode),
+    filterComments: filter(base.isComment),
+    filterNamespaceDeclarations: filter(base.isNamespaceDeclaration),
+    filterProcessingInstructions: filter(base.isProcessingInstruction),
+    filterTextNodes: filter(base.isText),
+    sortInDocumentOrder: (nodes) => {
+      return Array.from(nodes).sort((a, b) => base.compareDocumentOrder(a, b));
+    }
+  };
+  return Object.assign(base, extensions);
+};
+const getElementByUniqueIdFactory = (adapter, getNamedAttributeValue) => {
+  const adapterImplementation = adapter.getElementByUniqueId?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  function* getElementDescendants(node) {
+    if (adapter.isElement(node)) {
+      yield node;
+    }
+    for (const element of adapter.getChildElements(node)) {
+      yield element;
+      yield* getElementDescendants(element);
+    }
+  }
+  return (node, id) => {
+    const containingDocument = adapter.getContainingDocument(node);
+    for (const element of getElementDescendants(containingDocument)) {
+      if (getNamedAttributeValue(element, "id") === id) {
+        return element;
+      }
+    }
+    return null;
+  };
+};
+const getQualifiedNamedAttributeValueFactory = (adapter) => {
+  const adapterImplementation = adapter.getQualifiedNamedAttributeValue?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node, namespaceURI, localName) => {
+    const attributes = adapter.getAttributes(node);
+    for (const attribute of attributes) {
+      if (adapter.getNamespaceURI(attribute) === namespaceURI && adapter.getLocalName(attribute) === localName) {
+        return adapter.getNodeValue(attribute);
+      }
+    }
+    return null;
+  };
+};
+const getLocalNamedAttributeValueFactory = (adapter) => {
+  const adapterImplementation = adapter.getLocalNamedAttributeValue?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node, localName) => {
+    const attributes = adapter.getAttributes(node);
+    for (const attribute of attributes) {
+      if (adapter.getLocalName(attribute) === localName) {
+        return adapter.getNodeValue(attribute);
+      }
+    }
+    return null;
+  };
+};
+const hasLocalNamedAttributeFactory = (adapter, lookup) => {
+  const adapterImplementation = adapter.hasLocalNamedAttribute?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node, localName) => {
+    return lookup(node, localName) != null;
+  };
+};
+const getChildrenByLocalNameFactory = (adapter) => {
+  const adapterImplementation = adapter.getChildrenByLocalName?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node, localName) => {
+    return Array.from(adapter.getChildElements(node)).filter((element) => {
+      return adapter.getLocalName(element) === localName;
+    });
+  };
+};
+const getFirstChildNodeFactory = (adapter) => {
+  const adapterImplementation = adapter.getFirstChildNode?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node) => {
+    const [childNode] = adapter.getChildNodes(node);
+    return childNode ?? null;
+  };
+};
+const getLastChildNodeFactory = (adapter) => {
+  const adapterImplementation = adapter.getLastChildNode?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node) => {
+    return Array.from(adapter.getChildNodes(node)).at(-1) ?? null;
+  };
+};
+const getFirstChildElementFactory = (adapter) => {
+  const adapterImplementation = adapter.getFirstChildElement?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node) => {
+    const [childElement] = adapter.getChildElements(node);
+    return childElement ?? null;
+  };
+};
+const getLastChildElementFactory = (adapter) => {
+  const adapterImplementation = adapter.getLastChildElement?.bind(adapter);
+  if (adapterImplementation != null) {
+    return adapterImplementation;
+  }
+  return (node) => {
+    return Array.from(adapter.getChildElements(node)).at(-1) ?? null;
+  };
+};
+const extendOptimizableOperations = (base) => {
+  const getLocalNamedAttributeValue = getLocalNamedAttributeValueFactory(base);
+  const extensions = {
+    getElementByUniqueId: getElementByUniqueIdFactory(base, getLocalNamedAttributeValue),
+    getQualifiedNamedAttributeValue: getQualifiedNamedAttributeValueFactory(base),
+    getLocalNamedAttributeValue,
+    hasLocalNamedAttribute: hasLocalNamedAttributeFactory(base, getLocalNamedAttributeValue),
+    getChildrenByLocalName: getChildrenByLocalNameFactory(base),
+    getFirstChildNode: getFirstChildNodeFactory(base),
+    getFirstChildElement: getFirstChildElementFactory(base),
+    getLastChildNode: getLastChildNodeFactory(base),
+    getLastChildElement: getLastChildElementFactory(base)
+  };
+  return Object.assign(base, extensions);
+};
+const DERIVED_DOM_PROVIDER = Symbol("DERIVED_DOM_PROVIDER");
+const derivedDOMProvider = (base) => {
+  return Object.assign({}, base, {
+    [DERIVED_DOM_PROVIDER]: true
+  });
+};
+const isXPathDOMProvider = (adapter) => {
+  return DERIVED_DOM_PROVIDER in adapter && adapter[DERIVED_DOM_PROVIDER] === true;
+};
+const xpathDOMProvider = (adapter) => {
+  if (isXPathDOMProvider(adapter)) {
+    console.warn(
+      "Repeat call to xpathDOMProvider: provider has already been derived from provided adapter"
+    );
+    return adapter;
+  }
+  const extendedGuards = extendNodeKindGuards(adapter);
+  const extendedIterableOperations = extendIterableOperations(extendedGuards);
+  const exended = extendOptimizableOperations(extendedIterableOperations);
+  return derivedDOMProvider(exended);
+};
+
+class UnreachableError extends Error {
+  constructor(unrechable, additionalDetail) {
+    let message = `Unreachable value: ${JSON.stringify(unrechable)}`;
+    if (additionalDetail != null) {
+      message = `${message} (${additionalDetail})`;
+    }
+    super(message);
+  }
+}
+
+const identity = (value) => value;
+
 class Reiterable {
   constructor(source) {
     this.source = source;
@@ -21691,7 +21876,7 @@ class NodeEvaluation extends ValueEvaluation {
     let { computedValues } = this;
     if (computedValues == null) {
       const { context, value: node } = this;
-      const stringValue = node.textContent ?? "";
+      const stringValue = context.domProvider.getNodeValue(node);
       const isEmpty = trimXMLXPathWhitespace(stringValue) === "";
       const booleanValue = !isEmpty;
       const numberFunction = context.functions.getDefaultImplementation("number");
@@ -21720,32 +21905,244 @@ class NodeEvaluation extends ValueEvaluation {
   }
 }
 
+function* concat$2(...iterables) {
+  for (const iterable of iterables) {
+    yield* iterable;
+  }
+}
+function* flatMapNodeSets(contextNodes, fn) {
+  for (const contextNode of contextNodes) {
+    yield* fn(contextNode);
+  }
+}
 function* toNodeEvaluations(context, nodes) {
   for (const node of nodes) {
     yield new NodeEvaluation(context, node);
   }
 }
-const filterNamespace = filter(isNamespaceAttribute);
-const filterNonNamespace = filter((attr) => !isNamespaceAttribute(attr));
-const filterNonAttribute = filter((node) => !isAttributeNode(node));
-const axisNameToMethod = {
-  ["ancestor" /* ANCESTOR */]: "ancestor",
-  ["ancestor-or-self" /* ANCESTOR_OR_SELF */]: "ancestorOrSelf",
-  ["attribute" /* ATTRIBUTE */]: "attribute",
-  ["child" /* CHILD */]: "child",
-  ["descendant" /* DESCENDANT */]: "descendant",
-  ["descendant-or-self" /* DESCENDANT_OR_SELF */]: "descendantOrSelf",
-  ["following" /* FOLLOWING */]: "following",
-  ["following-sibling" /* FOLLOWING_SIBLING */]: "followingSibling",
-  ["namespace" /* NAMESPACE */]: "namespace",
-  ["parent" /* PARENT */]: "parent",
-  ["preceding" /* PRECEDING */]: "preceding",
-  ["preceding-sibling" /* PRECEDING_SIBLING */]: "precedingSibling",
-  ["self" /* SELF */]: "self"
+const getNodeTypeFilter = (domProvider, step) => {
+  switch (step.axisType) {
+    case "attribute":
+      return domProvider.filterAttributes;
+    case "namespace":
+      return domProvider.filterNamespaceDeclarations;
+  }
+  switch (step.nodeType) {
+    case "__NAMED__":
+      return domProvider.filterQualifiedNamedNodes;
+    case "processing-instruction":
+      return domProvider.filterProcessingInstructions;
+    case "comment":
+      return domProvider.filterComments;
+    case "node":
+      return identity;
+    case "text":
+      return domProvider.filterTextNodes;
+    default:
+      throw new UnreachableError(step);
+  }
+};
+const axisEvaluationContext = (currentContext, contextNode) => {
+  const { domProvider, contextDocument, rootNode, visited } = currentContext;
+  return {
+    domProvider,
+    contextDocument,
+    rootNode,
+    contextNode,
+    visited
+  };
+};
+function* siblings(context, methodName) {
+  const method = context.domProvider[methodName];
+  let currentNode = context.contextNode;
+  while (currentNode != null) {
+    currentNode = method(currentNode);
+    if (currentNode != null) {
+      yield currentNode;
+    }
+  }
+}
+const getDocumentOrderTraversalContextNode = (domProvider, contextNode) => {
+  if (domProvider.isAttribute(contextNode) || domProvider.isNamespaceDeclaration(contextNode)) {
+    const parentElement = domProvider.getParentNode(contextNode);
+    domProvider.assertParentNode(parentElement);
+    return parentElement;
+  }
+  return contextNode;
+};
+function* filterValues(iter) {
+  for (const item of iter) {
+    if (item != null) {
+      yield item;
+    }
+  }
+}
+function* documentRootPrecedingSiblings(domAdapter, precedingContext, documentRoot, step) {
+  const documentRootContext = axisEvaluationContext(precedingContext, documentRoot);
+  const precedingSiblings = axisEvaluators["preceding-sibling"](documentRootContext, step);
+  for (const node of precedingSiblings) {
+    try {
+      if (domAdapter.getNodeKind(node) != null) {
+        yield node;
+      }
+    } catch {
+    }
+  }
+}
+const axisEvaluators = {
+  ancestor: function* ancestor(context, step) {
+    const { rootNode } = context;
+    const parentNodes = axisEvaluators.parent(context, step);
+    for (const parentNode of parentNodes) {
+      if (parentNode !== rootNode) {
+        const parentContext = axisEvaluationContext(context, parentNode);
+        yield* axisEvaluators.ancestor(parentContext, step);
+      }
+      yield parentNode;
+    }
+  },
+  "ancestor-or-self": function* ancestorOrSelf(context, step) {
+    const { contextNode } = context;
+    const isNamedStep = step.stepType !== "NodeTypeTest";
+    const currentContext = axisEvaluationContext(context, contextNode);
+    yield* axisEvaluators.ancestor(currentContext, step);
+    if (!isNamedStep || context.domProvider.isElement(contextNode)) {
+      yield contextNode;
+    }
+  },
+  attribute: (context) => {
+    return context.domProvider.getAttributes(context.contextNode);
+  },
+  child: (context, step) => {
+    const { contextNode, domProvider } = context;
+    if (step.nodeType === "__NAMED__") {
+      return domProvider.getChildElements(contextNode);
+    }
+    return domProvider.getChildNodes(contextNode);
+  },
+  descendant: function* descendant(context, step) {
+    for (const childNode of axisEvaluators.child(context, step)) {
+      yield childNode;
+      const childContext = axisEvaluationContext(context, childNode);
+      yield* axisEvaluators.descendant(childContext, step);
+    }
+  },
+  "descendant-or-self": function* descendantOrSelf(context, step) {
+    const { contextNode } = context;
+    yield contextNode;
+    const selfContext = axisEvaluationContext(context, contextNode);
+    yield* axisEvaluators.descendant(selfContext, step);
+  },
+  following: function* following(context, step) {
+    const { domProvider, contextDocument, rootNode } = context;
+    const contextNode = getDocumentOrderTraversalContextNode(domProvider, context.contextNode);
+    if (context.visited.has(contextNode)) {
+      return;
+    }
+    context.visited.add(contextNode);
+    const parentNode = domProvider.getParentNode(contextNode);
+    if (contextNode === rootNode || parentNode === contextDocument) {
+      return;
+    }
+    let firstChild;
+    let nextSibling = null;
+    if (step.nodeType === "__NAMED__") {
+      firstChild = domProvider.getFirstChildElement(contextNode);
+      nextSibling = domProvider.getNextSiblingElement(contextNode);
+    } else {
+      firstChild = domProvider.getFirstChildNode(contextNode);
+      nextSibling = domProvider.getNextSiblingNode(contextNode);
+    }
+    let currentNodes = filterValues([firstChild, nextSibling]);
+    if (parentNode != null && parentNode !== rootNode) {
+      const followingParentSiblingsContext = axisEvaluationContext(context, parentNode);
+      const followingParentSiblings = axisEvaluators["following-sibling"](
+        followingParentSiblingsContext,
+        step
+      );
+      currentNodes = concat$2(currentNodes, followingParentSiblings);
+    }
+    for (const currentNode of currentNodes) {
+      yield currentNode;
+      const currentContext = axisEvaluationContext(context, currentNode);
+      yield* axisEvaluators.following(currentContext, step);
+    }
+  },
+  "following-sibling": (context, step) => {
+    if (step.nodeType === "__NAMED__") {
+      return siblings(context, "getNextSiblingElement");
+    }
+    return siblings(context, "getNextSiblingNode");
+  },
+  namespace: (context) => {
+    return context.domProvider.getNamespaceDeclarations(context.contextNode);
+  },
+  parent: function* parent(context) {
+    const { rootNode, contextNode } = context;
+    if (contextNode === rootNode) {
+      return;
+    }
+    const parentNode = context.domProvider.getParentNode(contextNode);
+    if (parentNode != null) {
+      yield parentNode;
+    }
+  },
+  preceding: function* preceding(context, step) {
+    const { domProvider, rootNode, contextDocument, visited } = context;
+    const contextNode = getDocumentOrderTraversalContextNode(domProvider, context.contextNode);
+    if (visited.has(contextNode)) {
+      return;
+    }
+    visited.add(contextNode);
+    if (contextNode === rootNode) {
+      return;
+    }
+    const parentNode = domProvider.getParentNode(contextNode);
+    if (parentNode === contextDocument) {
+      yield* documentRootPrecedingSiblings(domProvider, context, contextNode, step);
+      return;
+    }
+    let lastChild;
+    let previousSibling;
+    if (step.nodeType === "__NAMED__") {
+      previousSibling = domProvider.getPreviousSiblingElement(contextNode);
+      lastChild = domProvider.getLastChildElement(contextNode);
+    } else {
+      previousSibling = domProvider.getPreviousSiblingNode(contextNode);
+      lastChild = domProvider.getLastChildNode(contextNode);
+    }
+    if (lastChild === contextNode) {
+      lastChild = null;
+    }
+    let currentNodes = filterValues([lastChild, previousSibling]);
+    if (contextNode !== rootNode && parentNode != null && parentNode !== rootNode) {
+      const precedingParentSiblingsContext = axisEvaluationContext(context, parentNode);
+      const precedingParentSiblings = axisEvaluators["preceding-sibling"](
+        precedingParentSiblingsContext,
+        step
+      );
+      currentNodes = concat$2(currentNodes, precedingParentSiblings);
+    }
+    for (const currentNode of currentNodes) {
+      yield currentNode;
+      const currentContext = axisEvaluationContext(context, currentNode);
+      yield* preceding(currentContext, step);
+    }
+  },
+  "preceding-sibling": (context, step) => {
+    if (step.nodeType === "__NAMED__") {
+      return siblings(context, "getPreviousSiblingElement");
+    }
+    return siblings(context, "getPreviousSiblingNode");
+  },
+  self: function* self(context) {
+    yield context.contextNode;
+  }
 };
 class LocationPathEvaluation {
   constructor(parentContext, contextNodes, options = {}) {
     this.parentContext = parentContext;
+    this.domProvider = parentContext.domProvider;
     const {
       evaluator,
       contextDocument,
@@ -21753,8 +22150,7 @@ class LocationPathEvaluation {
       functions,
       namespaceResolver,
       rootNode,
-      timeZone,
-      treeWalkers
+      timeZone
     } = parentContext;
     this.evaluator = evaluator;
     this.contextDocument = contextDocument;
@@ -21763,9 +22159,8 @@ class LocationPathEvaluation {
     this.namespaceResolver = namespaceResolver;
     this.rootNode = rootNode;
     this.timeZone = timeZone;
-    this.treeWalkers = treeWalkers;
-    const [nodes] = tee(distinct(contextNodes));
-    this.nodes = nodes;
+    const nodes = distinct(contextNodes);
+    this._nodes = nodes;
     this.nodeEvaluations = Reiterable.from(toNodeEvaluations(this, contextNodes));
     if (options.contextSize != null) {
       this.optionsContextSize = options.contextSize;
@@ -21774,6 +22169,16 @@ class LocationPathEvaluation {
     }
     this.initializedContextPosition = options.contextPosition ?? 1;
   }
+  static isInstance(context, value) {
+    return value instanceof LocationPathEvaluation && value.domProvider === context.domProvider;
+  }
+  static assertInstance = (context, value, message) => {
+    if (!this.isInstance(context, value)) {
+      throw new Error(message ?? "Expected a node-set result");
+    }
+  };
+  // --- DOM adapter/provider ---
+  domProvider;
   // --- Evaluation ---
   type = "NODE";
   nodeEvaluations;
@@ -21786,10 +22191,13 @@ class LocationPathEvaluation {
   evaluationContextNode;
   contextDocument;
   rootNode;
-  nodes;
+  _nodes;
+  get nodes() {
+    return this._nodes;
+  }
   get contextNodes() {
-    const [nodes, contextNodes] = tee(this.nodes);
-    this.nodes = nodes;
+    const [nodes, contextNodes] = tee(this._nodes);
+    this._nodes = nodes;
     return contextNodes;
   }
   computedContextSize = null;
@@ -21797,7 +22205,6 @@ class LocationPathEvaluation {
   initializedContextPosition;
   functions;
   namespaceResolver;
-  treeWalkers;
   timeZone;
   /**
    * TODO: this is a temporary accommodation for these cases which are presently
@@ -21939,257 +22346,68 @@ class LocationPathEvaluation {
   gte(operand) {
     return this.compare((lhs, rhs) => lhs.gte(rhs), operand);
   }
-  getTreeWalker(step) {
-    const { treeWalkers } = this;
-    switch (step.nodeType) {
-      case "__NAMED__":
-        return treeWalkers.ELEMENT;
-      case "comment":
-        return treeWalkers.COMMENT;
-      case "node":
-        return treeWalkers.ANY;
-      case "processing-instruction":
-        return treeWalkers.PROCESSING_INSTRUCTION;
-      case "text":
-        return treeWalkers.TEXT;
-      default:
-        throw new UnreachableError(step);
-    }
-  }
-  *ancestor(step) {
-    const { rootNode } = this;
-    const parents = this.parent(step);
-    for (const parent of parents) {
-      if (parent !== rootNode) {
-        const parentContext = new LocationPathEvaluation(this, [parent]);
-        yield* parentContext.ancestor(step);
-      }
-      yield parent;
-    }
-  }
-  *ancestorOrSelf(step) {
-    const isNamedStep = step.stepType !== "NodeTypeTest";
-    for (const self of this) {
-      yield* self.ancestor(step);
-      for (const node of self.contextNodes) {
-        if (!isNamedStep || isElementNode(node)) {
-          yield node;
-        }
-      }
-    }
-  }
-  *attribute() {
-    for (const node of this.contextNodes) {
-      yield* filterNonNamespace(node.attributes ?? []);
-    }
-  }
-  *child(step) {
-    const treeWalker = this.getTreeWalker(step);
-    for (const node of this.contextNodes) {
-      let currentNode = node;
-      treeWalker.currentNode = currentNode;
-      treeWalker.firstChild();
-      do {
-        currentNode = treeWalker.currentNode;
-        if (currentNode.parentNode === node) {
-          yield currentNode;
-          treeWalker.currentNode = currentNode;
-        }
-      } while (treeWalker.nextSibling() != null);
-    }
-  }
-  *descendant(step) {
-    const treeWalker = this.getTreeWalker(step);
-    for (const node of this.contextNodes) {
-      treeWalker.currentNode = node;
-      if (treeWalker.firstChild() == null) {
-        continue;
-      }
-      do {
-        const { currentNode } = treeWalker;
-        if (!node.contains(currentNode)) {
-          break;
-        }
-        yield currentNode;
-        treeWalker.currentNode = currentNode;
-      } while (treeWalker.nextNode() != null);
-    }
-  }
-  *descendantOrSelf(step) {
-    for (const self of this) {
-      yield* self.contextNodes;
-      yield* self.descendant(step);
-    }
-  }
-  *following(step) {
-    const contextNodes = map$1((node) => node.ownerElement ?? node)(
-      this.contextNodes
-    );
-    const treeWalker = this.getTreeWalker(step);
-    const visited = /* @__PURE__ */ new WeakSet();
-    for (const node of contextNodes) {
-      const { nextSibling } = node;
-      if (nextSibling == null) {
-        continue;
-      }
-      treeWalker.currentNode = nextSibling;
-      do {
-        const { currentNode } = treeWalker;
-        if (visited.has(currentNode)) {
-          continue;
-        }
-        visited.add(currentNode);
-        yield currentNode;
-        treeWalker.currentNode = currentNode;
-      } while (treeWalker.nextNode() != null);
-    }
-  }
-  *followingSibling(step) {
-    const visited = /* @__PURE__ */ new WeakSet();
-    const treeWalker = this.getTreeWalker(step);
-    for (const node of this.contextNodes) {
-      const { nextSibling } = node;
-      if (nextSibling == null) {
-        continue;
-      }
-      const { parentNode } = node;
-      treeWalker.currentNode = nextSibling;
-      do {
-        const { currentNode } = treeWalker;
-        if (visited.has(currentNode) || currentNode.parentNode !== parentNode) {
-          continue;
-        }
-        visited.add(currentNode);
-        yield currentNode;
-        treeWalker.currentNode = currentNode;
-      } while (treeWalker.nextSibling() != null);
-    }
-  }
-  *namespace() {
-    for (const node of this.contextNodes) {
-      yield* filterNamespace(node.attributes ?? []);
-    }
-  }
-  *parent(step) {
-    const { contextNodes, rootNode } = this;
-    const treeWalker = this.getTreeWalker(step);
-    for (const node of contextNodes) {
-      const contextNode = node.ownerElement ?? node;
-      if (contextNode === rootNode) {
-        continue;
-      }
-      if (contextNode !== node) {
-        yield contextNode;
-        continue;
-      }
-      treeWalker.currentNode = contextNode;
-      const parentNode = treeWalker.parentNode();
-      if (parentNode != null) {
-        yield parentNode;
-        treeWalker.currentNode = parentNode;
-      }
-    }
-  }
-  *preceding(step) {
-    const { rootNode } = this;
-    const { nodeType = null } = step;
-    const treeWalker = this.getTreeWalker(step);
-    treeWalker.currentNode = rootNode;
-    if (nodeType != null && nodeType !== "node") {
-      treeWalker.nextNode();
-      treeWalker.previousNode();
-    }
-    for (const node of this.contextNodes) {
-      const contextNode = node.ownerElement ?? node;
-      do {
-        const { currentNode } = treeWalker;
-        if (currentNode.contains(contextNode)) {
-          continue;
-        }
-        if (currentNode === contextNode || (contextNode.compareDocumentPosition(currentNode) & Node.DOCUMENT_POSITION_PRECEDING) === 0) {
-          break;
-        }
-        yield currentNode;
-        treeWalker.currentNode = currentNode;
-      } while (treeWalker.nextNode() != null);
-    }
-  }
-  *precedingSibling(step) {
-    const { nodeType = null } = step;
-    const treeWalker = this.getTreeWalker(step);
-    let parentNode = null;
-    for (const node of filterNonAttribute(this.contextNodes)) {
-      const currentParentNode = node.parentNode;
-      if (currentParentNode == null) {
-        continue;
-      }
-      if (currentParentNode !== parentNode) {
-        parentNode = currentParentNode;
-        treeWalker.currentNode = parentNode.firstChild;
-        if (nodeType != null && nodeType !== "node") {
-          treeWalker.nextSibling();
-          treeWalker.previousSibling();
-        }
-      }
-      do {
-        const { currentNode } = treeWalker;
-        if (currentNode === node) {
-          break;
-        }
-        yield currentNode;
-        treeWalker.currentNode = currentNode;
-      } while (treeWalker.nextSibling() != null);
-    }
-  }
-  *self() {
-    yield* this.contextNodes;
-  }
   step(step) {
-    let nodesFilter = identity;
-    const { namespaceResolver } = this;
+    const { domProvider, namespaceResolver } = this;
+    let nodesFilter;
     switch (step.stepType) {
       case "NodeTypeTest":
+      case "UnqualifiedWildcardTest":
+        nodesFilter = getNodeTypeFilter(domProvider, step);
         break;
       case "NodeNameTest": {
         const { nodeName } = step;
         const nullNamespaceURI = namespaceResolver.lookupNamespaceURI(null);
         nodesFilter = filter((node) => {
-          const { namespaceURI } = node;
-          return node.localName === nodeName && (namespaceURI == null || namespaceURI === nullNamespaceURI);
+          if (!domProvider.isQualifiedNamedNode(node)) {
+            return false;
+          }
+          const namespaceURI = domProvider.getNamespaceURI(node);
+          return domProvider.getLocalName(node) === nodeName && (namespaceURI == null || namespaceURI === nullNamespaceURI);
         });
         break;
       }
       case "ProcessingInstructionNameTest": {
         const { processingInstructionName } = step;
         nodesFilter = filter((node) => {
-          return node.nodeName === processingInstructionName;
+          return domProvider.isProcessingInstruction(node) && domProvider.getProcessingInstructionName(node) === processingInstructionName;
         });
         break;
       }
       case "QualifiedNameTest": {
         const { prefix, localName } = step;
         const namespaceURI = namespaceResolver.lookupNamespaceURI(prefix);
-        nodesFilter = filter(
-          (node) => node.localName === localName && node.namespaceURI === namespaceURI
-        );
+        nodesFilter = filter((node) => {
+          return domProvider.isQualifiedNamedNode(node) && domProvider.getLocalName(node) === localName && domProvider.getNamespaceURI(node) === namespaceURI;
+        });
         break;
       }
       case "QualifiedWildcardTest": {
         const { prefix } = step;
         const namespaceURI = namespaceResolver.lookupNamespaceURI(prefix);
-        nodesFilter = filter(
-          (node) => node.namespaceURI === namespaceURI
-        );
+        nodesFilter = filter((node) => {
+          return domProvider.isQualifiedNamedNode(node) && domProvider.getNamespaceURI(node) === namespaceURI;
+        });
         break;
       }
-      case "UnqualifiedWildcardTest":
-        break;
       default:
         throw new UnreachableError(step);
     }
     const { axisType } = step;
-    const axisMethod = axisNameToMethod[axisType];
-    const nodes = nodesFilter(this[axisMethod](step));
+    const axisEvaluator = axisEvaluators[axisType];
+    const context = {
+      domProvider: this.domProvider,
+      rootNode: this.rootNode,
+      contextDocument: this.contextDocument,
+      visited: /* @__PURE__ */ new WeakSet()
+    };
+    let nodes = flatMapNodeSets(this.contextNodes, function* (contextNode) {
+      const currentContext = axisEvaluationContext(context, contextNode);
+      const axisNodes = axisEvaluator(currentContext, step);
+      yield* nodesFilter(axisNodes);
+    });
+    if (axisType === "preceding" || axisType === "preceding-sibling") {
+      nodes = this.domProvider.sortInDocumentOrder(nodes);
+    }
     return new LocationPathEvaluation(this, nodes);
   }
   evaluateLocationPathExpression(expression) {
@@ -22241,18 +22459,36 @@ const staticNamespaces = new StaticNamespaces("xf", XFORMS_NAMESPACE_URI, {
 });
 const namespaceURIs = new UpsertableMap();
 class NamespaceResolver {
-  constructor(rootNode, referenceNode) {
+  constructor(domProvider, rootNode, referenceNode, contextResolver) {
+    this.domProvider = domProvider;
     this.rootNode = rootNode;
     this.referenceNode = referenceNode;
-    this.contextResolver = referenceNode ?? rootNode;
+    const contextResolverNode = referenceNode ?? rootNode;
+    if (contextResolver == null) {
+      this.contextResolver = (prefix) => {
+        return domProvider.resolveNamespaceURI(contextResolverNode, prefix);
+      };
+    } else if (typeof contextResolver === "function") {
+      this.contextResolver = contextResolver;
+    } else {
+      this.contextResolver = (prefix) => contextResolver.lookupNamespaceURI(prefix);
+    }
+  }
+  static isInstance(rootNode, value) {
+    return value instanceof NamespaceResolver && value.rootNode === rootNode;
+  }
+  static from(domProvider, rootNode, referenceNode, contextResolver) {
+    if (this.isInstance(rootNode, contextResolver)) {
+      return contextResolver;
+    }
+    return new this(
+      domProvider,
+      rootNode,
+      referenceNode ?? null,
+      contextResolver
+    );
   }
   contextResolver;
-  lookupNodeNamespaceURI = (node, prefix) => {
-    return node.lookupNamespaceURI(prefix);
-  };
-  lookupStaticNamespaceURI = (prefix) => {
-    return staticNamespaces.get(prefix) ?? null;
-  };
   /**
    * Note: while it is likely consistent with the **spec** to resolve a `null`
    * prefix, it's not typical in a browser environment for the resolver to be
@@ -22263,102 +22499,33 @@ class NamespaceResolver {
    */
   lookupNamespaceURI(prefix) {
     return namespaceURIs.upsert(this.contextResolver, () => new UpsertableMap()).upsert(prefix, () => {
-      return this.contextResolver.lookupNamespaceURI(prefix) ?? staticNamespaces.get(prefix) ?? null;
+      return this.contextResolver(prefix) ?? staticNamespaces.get(prefix) ?? null;
     });
   }
 }
 
-const assertParentNode = (node) => {
-  if (node.children == null) {
-    throw "todo assertParentNode";
-  }
-};
-
-const getDocument = (node) => node.nodeType === Node.DOCUMENT_NODE ? node : node.ownerDocument;
-const getRootNode = (node) => {
-  if (isDocumentNode(node)) {
-    return node;
-  }
-  if (isElementNode(node)) {
-    const rootNode = node.getRootNode();
-    assertParentNode(rootNode);
-    return rootNode;
-  }
-  if (isAttributeNode(node)) {
-    const { ownerElement } = node;
-    if (ownerElement == null) {
-      throw "todo";
-    }
-    return getRootNode(ownerElement);
-  }
-  const { parentElement } = node;
-  if (parentElement == null) {
-    throw "todo getRootNode COMMENT | PROCESSING_INSTRUCTION | TEXT";
-  }
-  return getRootNode(parentElement);
-};
-const {
-  SHOW_ELEMENT,
-  SHOW_ATTRIBUTE,
-  SHOW_TEXT,
-  SHOW_CDATA_SECTION,
-  SHOW_PROCESSING_INSTRUCTION,
-  SHOW_COMMENT,
-  SHOW_DOCUMENT,
-  SHOW_DOCUMENT_TYPE
-} = NodeFilter;
-const SHOW_ANY = 0 | SHOW_ELEMENT | SHOW_ATTRIBUTE | SHOW_TEXT | SHOW_CDATA_SECTION | SHOW_PROCESSING_INSTRUCTION | SHOW_COMMENT | SHOW_DOCUMENT | SHOW_DOCUMENT_TYPE;
-const SHOW_ANY_TEXT = 0 | SHOW_TEXT | SHOW_CDATA_SECTION;
-const TreeWalkerFilter = {
-  ANY: SHOW_ANY,
-  ELEMENT: SHOW_ELEMENT,
-  TEXT: SHOW_ANY_TEXT,
-  COMMENT: SHOW_COMMENT,
-  PROCESSING_INSTRUCTION: SHOW_PROCESSING_INSTRUCTION
-};
-const getTreeWalker = (contextDocument, contextNode = contextDocument, filter = "ANY") => {
-  const flag = TreeWalkerFilter[filter];
-  return contextDocument.createTreeWalker(contextNode, flag);
-};
-
-class EvaluationContextTreeWalkers {
-  ANY;
-  COMMENT;
-  ELEMENT;
-  PROCESSING_INSTRUCTION;
-  TEXT;
-  constructor(contextDocument, rootNode) {
-    this.ANY = getTreeWalker(contextDocument, rootNode, "ANY");
-    this.COMMENT = getTreeWalker(contextDocument, rootNode, "COMMENT");
-    this.ELEMENT = getTreeWalker(contextDocument, rootNode, "ELEMENT");
-    this.PROCESSING_INSTRUCTION = getTreeWalker(
-      contextDocument,
-      rootNode,
-      "PROCESSING_INSTRUCTION"
-    );
-    this.TEXT = getTreeWalker(contextDocument, rootNode, "TEXT");
-  }
-}
 class EvaluationContext {
   constructor(evaluator, contextNode, options = {}) {
     this.evaluator = evaluator;
-    const {
-      rootNode = getRootNode(contextNode),
-      document = getDocument(rootNode),
-      functions = evaluator.functions,
-      namespaceResolver = new NamespaceResolver(document, contextNode),
-      treeWalkers = new EvaluationContextTreeWalkers(document, rootNode),
-      timeZone = evaluator.timeZone
-    } = options;
-    this.contextDocument = document;
+    const { domProvider } = evaluator;
+    this.domProvider = domProvider;
+    const { namespaceResolver } = options;
+    const rootNode = options.rootNode ?? domProvider.getContainingDocument(contextNode);
+    const contextDocument = domProvider.getContainingDocument(rootNode);
+    this.contextDocument = contextDocument;
     this.evaluationContextNode = contextNode;
     this.contextNodes = [contextNode];
     this.rootNode = rootNode;
-    this.functions = functions;
-    this.namespaceResolver = namespaceResolver;
-    this.treeWalkers = treeWalkers;
-    this.timeZone = timeZone;
+    this.functions = options.functions ?? evaluator.functions;
+    this.namespaceResolver = NamespaceResolver.from(
+      domProvider,
+      contextDocument,
+      contextDocument,
+      namespaceResolver
+    );
+    this.timeZone = options.timeZone ?? evaluator.timeZone;
   }
+  domProvider;
   /**
    * @see {@link Context.evaluationContextNode}
    */
@@ -22369,7 +22536,6 @@ class EvaluationContext {
   functions;
   namespaceResolver;
   timeZone;
-  treeWalkers;
   contextPosition() {
     return 1;
   }
@@ -22517,21 +22683,19 @@ class BooleanEvaluation extends ValueEvaluation {
 }
 
 class TypedFunctionImplementation extends FunctionImplementation {
-  constructor(localName, TypedResult, signature, call) {
-    super(
-      localName,
-      signature,
-      (context, args) => {
-        const runtimeResult = call(context, args);
-        return new TypedResult(context, runtimeResult);
-      }
-    );
+  constructor(localName, signature, call, resultFactory) {
+    super(localName, signature, (context, args) => {
+      const result = call(context, args);
+      return resultFactory(context, result);
+    });
   }
 }
 
 class BooleanFunction extends TypedFunctionImplementation {
   constructor(localName, signature, call) {
-    super(localName, BooleanEvaluation, signature, call);
+    super(localName, signature, call, (context, value) => {
+      return new BooleanEvaluation(context, value);
+    });
   }
 }
 
@@ -22556,15 +22720,19 @@ const lang = new BooleanFunction(
     if (contextNode == null) {
       return false;
     }
-    let contextElement = isElementNode(contextNode) ? contextNode : contextNode.parentElement;
-    if (contextElement == null) {
+    const { domProvider } = context;
+    let currentContextNode = domProvider.isElement(contextNode) ? contextNode : domProvider.getParentNode(contextNode);
+    if (currentContextNode == null) {
       return false;
     }
-    let langValue = contextElement.getAttributeNS(XML_NAMESPACE_URI, "lang");
+    let langValue = null;
     do {
-      langValue = contextElement?.getAttributeNS(XML_NAMESPACE_URI, "lang")?.toLowerCase() ?? null;
-      contextElement = contextElement.parentElement;
-    } while (langValue == null && contextElement != null);
+      if (currentContextNode == null || !domProvider.isElement(currentContextNode)) {
+        break;
+      }
+      langValue = domProvider.getQualifiedNamedAttributeValue(currentContextNode, XML_NAMESPACE_URI, "lang")?.toLowerCase() ?? null;
+      currentContextNode = domProvider.getParentNode(currentContextNode);
+    } while (langValue == null && currentContextNode != null);
     return langValue != null && (langValue === language || langValue.startsWith(`${language}-`));
   }
 );
@@ -22577,12 +22745,12 @@ const not = new BooleanFunction(
 );
 
 const boolean$2 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	boolean: boolean$1,
-	false: falseFn,
-	lang,
-	not,
-	true: trueFn
+    __proto__: null,
+    boolean: boolean$1,
+    false: falseFn,
+    lang,
+    not,
+    true: trueFn
 }, Symbol.toStringTag, { value: 'Module' }));
 
 class InvalidArgumentError extends Error {}
@@ -23591,11 +23759,7 @@ class NodeSetFunction extends FunctionImplementation {
   constructor(localName, signature, call) {
     super(localName, signature, (context, args) => {
       const nodes = call(context, args);
-      return LocationPathEvaluation.fromArbitraryNodes(
-        context,
-        nodes,
-        this
-      );
+      return LocationPathEvaluation.fromArbitraryNodes(context, nodes, this);
     });
   }
 }
@@ -23618,42 +23782,20 @@ class NumberEvaluation extends ValueEvaluation {
 
 class NumberFunction extends TypedFunctionImplementation {
   constructor(localName, signature, call) {
-    super(localName, NumberEvaluation, signature, call);
+    super(localName, signature, call, (context, value) => {
+      return new NumberEvaluation(context, value);
+    });
   }
 }
 
 class StringFunction extends TypedFunctionImplementation {
   constructor(localName, signature, call) {
-    super(localName, StringEvaluation, signature, call);
+    super(localName, signature, call, (context, value) => {
+      return new StringEvaluation(context, value);
+    });
   }
 }
 
-const { DOCUMENT_POSITION_FOLLOWING, DOCUMENT_POSITION_PRECEDING } = Node;
-const sortDocumentOrder = (nodes) => {
-  const array = Array.from(nodes);
-  if (array.length < 2) {
-    return array;
-  }
-  return array.sort((a, b) => {
-    const compared = b.compareDocumentPosition(a);
-    if (compared === 0 && a !== b) {
-      if (a.ownerElement === b) {
-        return 1;
-      }
-      if (a === b.ownerElement) {
-        return -1;
-      }
-    }
-    if (compared & DOCUMENT_POSITION_FOLLOWING) {
-      return 1;
-    }
-    if (compared & DOCUMENT_POSITION_PRECEDING) {
-      return -1;
-    }
-    return 0;
-  });
-};
-
 const { toCount } = reduce;
 const count = new NumberFunction(
   "count",
@@ -23685,15 +23827,15 @@ const id = new NodeSetFunction(
     if (elementIds.length === 0) {
       return [];
     }
-    const { contextDocument } = context;
+    const { contextDocument, domProvider } = context;
     const elements = elementIds.flatMap((elementId) => {
-      const element = contextDocument.getElementById(elementId);
+      const element = domProvider.getElementByUniqueId(contextDocument, elementId);
       if (element == null) {
         return [];
       }
       return element;
     });
-    return sortDocumentOrder(elements);
+    return context.domProvider.sortInDocumentOrder(elements);
   }
 );
 const last = new NumberFunction("last", [], (context) => context.contextSize());
@@ -23709,11 +23851,14 @@ const localName = new StringFunction(
     if (node == null) {
       return "";
     }
-    if (node.nodeType !== Node.ELEMENT_NODE && node.nodeType !== Node.ATTRIBUTE_NODE && node.nodeType !== Node.PROCESSING_INSTRUCTION_NODE) {
-      return "";
+    const { domProvider } = context;
+    if (domProvider.isQualifiedNamedNode(node)) {
+      return domProvider.getLocalName(node);
+    }
+    if (domProvider.isProcessingInstruction(node)) {
+      return domProvider.getProcessingInstructionName(node);
     }
-    const name2 = isNamespaceNode(node) ? "" : isProcessingInstructionNode(node) ? node.nodeName : node.localName ?? "";
-    return name2;
+    return "";
   }
 );
 const name = new StringFunction(
@@ -23728,13 +23873,14 @@ const name = new StringFunction(
     if (node == null) {
       return "";
     }
-    if (node.nodeType !== Node.ELEMENT_NODE && node.nodeType !== Node.ATTRIBUTE_NODE && node.nodeType !== Node.PROCESSING_INSTRUCTION_NODE) {
-      return "";
+    const { domProvider } = context;
+    if (domProvider.isQualifiedNamedNode(node)) {
+      return domProvider.getQualifiedName(node);
     }
-    if (isNamespaceNode(node)) {
-      return "";
+    if (domProvider.isProcessingInstruction(node)) {
+      return domProvider.getProcessingInstructionName(node);
     }
-    return node.nodeName ?? "";
+    return "";
   }
 );
 const namespaceURI = new StringFunction(
@@ -23749,10 +23895,11 @@ const namespaceURI = new StringFunction(
     if (node == null) {
       return "";
     }
-    if (isNamespaceNode(node)) {
-      return "";
+    const { domProvider } = context;
+    if (domProvider.isQualifiedNamedNode(node)) {
+      return domProvider.getNamespaceURI(node) ?? "";
     }
-    return node.namespaceURI ?? "";
+    return "";
   }
 );
 const position$1 = new NumberFunction(
@@ -23762,15 +23909,15 @@ const position$1 = new NumberFunction(
 );
 
 const nodeset$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	count,
-	current,
-	id,
-	last,
-	localName,
-	name,
-	namespaceURI,
-	position: position$1
+    __proto__: null,
+    count,
+    current,
+    id,
+    last,
+    localName,
+    name,
+    namespaceURI,
+    position: position$1
 }, Symbol.toStringTag, { value: 'Module' }));
 
 class FunctionAlias extends FunctionImplementation {
@@ -23869,12 +24016,12 @@ const sum$1 = new NumberFunction(
 );
 
 const number$3 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	ceiling,
-	floor,
-	number: number$2,
-	round: round$1,
-	sum: sum$1
+    __proto__: null,
+    ceiling,
+    floor,
+    number: number$2,
+    round: round$1,
+    sum: sum$1
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const escapeRegExp = (value) => value.replace(/[\\^$*+?.()|[\]{}]/g, "\\$&");
@@ -24020,17 +24167,17 @@ const translate = new StringFunction(
 );
 
 const string$3 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	concat: concat$1,
-	contains,
-	normalizeSpace,
-	startsWith,
-	string: string$2,
-	stringLength,
-	substring,
-	substringAfter,
-	substringBefore,
-	translate
+    __proto__: null,
+    concat: concat$1,
+    contains,
+    normalizeSpace,
+    startsWith,
+    string: string$2,
+    stringLength,
+    substring,
+    substringAfter,
+    substringBefore,
+    translate
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const fn = new FunctionLibrary(FN_NAMESPACE_URI, [
@@ -24452,9 +24599,7 @@ class FilterPathExpressionEvaluator extends LocationPathEvaluator {
   evaluateNodes(context) {
     if (this.hasSteps) {
       const filterContextResults = this.filterExpression.evaluate(context);
-      if (!(filterContextResults instanceof LocationPathEvaluation)) {
-        throw "todo not a node-set context";
-      }
+      LocationPathEvaluation.assertInstance(context, filterContextResults);
       return super.evaluateNodes(filterContextResults);
     }
     return this.filterExpression.evaluateNodes(context);
@@ -24625,7 +24770,7 @@ class UnionExpressionEvaluator extends LocationPathExpressionEvaluator {
     if (!(rhs instanceof LocationPathEvaluation)) {
       throw "todo rhs not node-set result";
     }
-    return sortDocumentOrder(distinct(multiExports.chain(lhs.nodes, rhs.nodes)));
+    return context.domProvider.sortInDocumentOrder(distinct(multiExports.chain(lhs.nodes, rhs.nodes)));
   }
 }
 
@@ -24748,19 +24893,29 @@ class FunctionLibraryCollection {
   }
 }
 
-const ResultTypes = {
-  BOOLEAN_TYPE: XPathResult.BOOLEAN_TYPE,
-  NUMBER_TYPE: XPathResult.NUMBER_TYPE,
-  STRING_TYPE: XPathResult.STRING_TYPE,
-  UNORDERED_NODE_ITERATOR_TYPE: XPathResult.UNORDERED_NODE_ITERATOR_TYPE,
-  ORDERED_NODE_ITERATOR_TYPE: XPathResult.ORDERED_NODE_ITERATOR_TYPE,
-  UNORDERED_NODE_SNAPSHOT_TYPE: XPathResult.UNORDERED_NODE_SNAPSHOT_TYPE,
-  ORDERED_NODE_SNAPSHOT_TYPE: XPathResult.ORDERED_NODE_SNAPSHOT_TYPE,
-  ANY_UNORDERED_NODE_TYPE: XPathResult.ANY_UNORDERED_NODE_TYPE,
-  FIRST_ORDERED_NODE_TYPE: XPathResult.FIRST_ORDERED_NODE_TYPE
+const ANY_TYPE$2 = 0;
+const NUMBER_TYPE$2 = 1;
+const STRING_TYPE$2 = 2;
+const BOOLEAN_TYPE$2 = 3;
+const UNORDERED_NODE_ITERATOR_TYPE$2 = 4;
+const ORDERED_NODE_ITERATOR_TYPE$2 = 5;
+const UNORDERED_NODE_SNAPSHOT_TYPE$2 = 6;
+const ORDERED_NODE_SNAPSHOT_TYPE$2 = 7;
+const ANY_UNORDERED_NODE_TYPE$2 = 8;
+const FIRST_ORDERED_NODE_TYPE$2 = 9;
+const XPATH_EVALUATION_RESULT = {
+  ANY_TYPE: ANY_TYPE$2,
+  ANY_UNORDERED_NODE_TYPE: ANY_UNORDERED_NODE_TYPE$2,
+  BOOLEAN_TYPE: BOOLEAN_TYPE$2,
+  FIRST_ORDERED_NODE_TYPE: FIRST_ORDERED_NODE_TYPE$2,
+  NUMBER_TYPE: NUMBER_TYPE$2,
+  ORDERED_NODE_ITERATOR_TYPE: ORDERED_NODE_ITERATOR_TYPE$2,
+  ORDERED_NODE_SNAPSHOT_TYPE: ORDERED_NODE_SNAPSHOT_TYPE$2,
+  STRING_TYPE: STRING_TYPE$2,
+  UNORDERED_NODE_ITERATOR_TYPE: UNORDERED_NODE_ITERATOR_TYPE$2,
+  UNORDERED_NODE_SNAPSHOT_TYPE: UNORDERED_NODE_SNAPSHOT_TYPE$2
 };
 
-const NODE_SET_RESULT_TYPE = -1;
 const {
   ANY_TYPE: ANY_TYPE$1,
   NUMBER_TYPE: NUMBER_TYPE$1,
@@ -24772,7 +24927,7 @@ const {
   ORDERED_NODE_SNAPSHOT_TYPE: ORDERED_NODE_SNAPSHOT_TYPE$1,
   ANY_UNORDERED_NODE_TYPE: ANY_UNORDERED_NODE_TYPE$1,
   FIRST_ORDERED_NODE_TYPE: FIRST_ORDERED_NODE_TYPE$1
-} = XPathResult;
+} = XPATH_EVALUATION_RESULT;
 class BaseResult {
   static ANY_TYPE = ANY_TYPE$1;
   static NUMBER_TYPE = NUMBER_TYPE$1;
@@ -24794,7 +24949,6 @@ class BaseResult {
   ORDERED_NODE_SNAPSHOT_TYPE = ORDERED_NODE_SNAPSHOT_TYPE$1;
   ANY_UNORDERED_NODE_TYPE = ANY_UNORDERED_NODE_TYPE$1;
   FIRST_ORDERED_NODE_TYPE = FIRST_ORDERED_NODE_TYPE$1;
-  static NODE_SET_RESULT_TYPE = NODE_SET_RESULT_TYPE;
 }
 
 class InvalidNodeSetResultError extends Error {
@@ -24803,9 +24957,6 @@ class InvalidNodeSetResultError extends Error {
   }
 }
 class PrimitiveResult extends BaseResult {
-  get resultType() {
-    return this.type;
-  }
   get singleNodeValue() {
     throw new InvalidNodeSetResultError();
   }
@@ -24822,9 +24973,8 @@ class PrimitiveResult extends BaseResult {
 }
 
 class BooleanResult extends PrimitiveResult {
-  isIntermediateResult = false;
-  type = PrimitiveResult.BOOLEAN_TYPE;
   nodes = null;
+  resultType = PrimitiveResult.BOOLEAN_TYPE;
   booleanValue;
   numberValue;
   stringValue;
@@ -24837,13 +24987,12 @@ class BooleanResult extends PrimitiveResult {
 }
 
 class NodeSetResult extends BaseResult {
-  constructor(value) {
+  constructor(domProvider, value) {
     super();
+    this.domProvider = domProvider;
     this.value = value;
     this.nodes = value;
   }
-  isIntermediateResult = false;
-  type = BaseResult.NODE_SET_RESULT_TYPE;
   nodes;
   computedBooleanValue = null;
   computedNumberValue = null;
@@ -24864,7 +25013,12 @@ class NodeSetResult extends BaseResult {
   compute() {
     let { computedBooleanValue, computedNumberValue, computedStringValue } = this;
     if (computedBooleanValue == null || computedNumberValue == null || computedStringValue == null) {
-      computedStringValue = this.singleNodeValue?.textContent ?? "";
+      const { singleNodeValue } = this;
+      if (singleNodeValue == null) {
+        computedStringValue = "";
+      } else {
+        computedStringValue = this.domProvider.getNodeValue(singleNodeValue);
+      }
       const isBlank = computedStringValue === "";
       computedBooleanValue = !isBlank;
       computedNumberValue = isBlank ? NaN : Number(computedStringValue);
@@ -24877,9 +25031,9 @@ class NodeSetResult extends BaseResult {
   }
 }
 class NodeSetSnapshotResult extends NodeSetResult {
-  constructor(resultType, nodes) {
+  constructor(domProvider, resultType, nodes) {
     const snapshot = [...Reiterable.from(nodes)];
-    super(snapshot);
+    super(domProvider, snapshot);
     this.resultType = resultType;
     const snapshotIterator = snapshot.values();
     this.snapshot = snapshot;
@@ -24912,8 +25066,8 @@ class InvalidSnapshotError extends Error {
   }
 }
 class NodeSetIteratorResult extends NodeSetResult {
-  constructor(resultType, nodes) {
-    super(nodes);
+  constructor(domProvider, resultType, nodes) {
+    super(domProvider, nodes);
     this.resultType = resultType;
     this.nodes = Reiterable.from(nodes);
   }
@@ -24959,9 +25113,8 @@ class NodeSetIteratorResult extends NodeSetResult {
 }
 
 class NumberResult extends PrimitiveResult {
-  isIntermediateResult = false;
-  type = PrimitiveResult.NUMBER_TYPE;
   nodes = null;
+  resultType = PrimitiveResult.NUMBER_TYPE;
   booleanValue;
   numberValue;
   stringValue;
@@ -24974,9 +25127,8 @@ class NumberResult extends PrimitiveResult {
 }
 
 class StringResult extends PrimitiveResult {
-  isIntermediateResult = false;
-  type = PrimitiveResult.STRING_TYPE;
   nodes = null;
+  resultType = PrimitiveResult.STRING_TYPE;
   booleanValue;
   numberValue;
   stringValue;
@@ -24999,8 +25151,8 @@ const {
   ORDERED_NODE_SNAPSHOT_TYPE,
   ANY_UNORDERED_NODE_TYPE,
   FIRST_ORDERED_NODE_TYPE
-} = globalThis.XPathResult;
-const toXPathResult = (resultType, evaluation) => {
+} = XPATH_EVALUATION_RESULT;
+const toXPathEvaluationResult = (domProvider, resultType, evaluation) => {
   const { nodes } = evaluation;
   switch (resultType) {
     case ANY_TYPE:
@@ -25011,8 +25163,13 @@ const toXPathResult = (resultType, evaluation) => {
           return new NumberResult(evaluation);
         case "STRING":
           return new StringResult(evaluation);
-        case "NODE":
-          return new NodeSetIteratorResult(UNORDERED_NODE_ITERATOR_TYPE, evaluation.nodes);
+        case "NODE": {
+          return new NodeSetIteratorResult(
+            domProvider,
+            UNORDERED_NODE_ITERATOR_TYPE,
+            evaluation.nodes ?? []
+          );
+        }
         default:
           throw new UnreachableError(evaluation.type);
       }
@@ -25029,59 +25186,63 @@ const toXPathResult = (resultType, evaluation) => {
       if (nodes == null) {
         throw "todo not a node-set";
       }
-      return new NodeSetIteratorResult(resultType, nodes);
+      return new NodeSetIteratorResult(domProvider, resultType, nodes);
     case UNORDERED_NODE_SNAPSHOT_TYPE:
     case ORDERED_NODE_SNAPSHOT_TYPE:
       if (nodes == null) {
         throw "todo not a node-set";
       }
-      return new NodeSetSnapshotResult(resultType, nodes);
+      return new NodeSetSnapshotResult(domProvider, resultType, nodes);
     default:
       throw new UnreachableError(resultType);
   }
 };
 
 const functions$1 = new FunctionLibraryCollection([fn]);
-const isNonNullEntry = (entry) => entry[1] != null;
-const partialOmitNullish = (object) => Object.fromEntries(Object.entries(object).filter(isNonNullEntry));
 class Evaluator {
+  domProvider;
   // TODO: see notes on cache in `ExpressionParser.ts`, update or remove those
   // if this usage changes in a way that addresses concerns expressed there.
   parser;
   functions;
   parseOptions;
-  resultTypes = ResultTypes;
-  rootNodeDocument = null;
   rootNode;
-  sharedContextOptions;
   timeZone;
-  constructor(options = {}) {
-    const { parseOptions = {}, rootNode, timeZoneId } = options;
+  constructor(options) {
+    const rootNode = options.rootNode ?? null;
+    const { domAdapter, parseOptions = {}, timeZoneId } = options;
+    const domProvider = xpathDOMProvider(domAdapter);
+    if (rootNode != null) {
+      domProvider.assertParentNode(rootNode, "Invalid root node");
+    }
+    this.domProvider = domProvider;
+    this.rootNode = rootNode;
     this.functions = options.functions ?? functions$1;
     this.parseOptions = parseOptions;
     this.parser = expressionParser;
-    this.rootNode = rootNode ?? null;
-    if (rootNode != null) {
-      this.rootNodeDocument = rootNode.ownerDocument ?? rootNode;
-    }
-    this.sharedContextOptions = partialOmitNullish({
-      rootNode
-    });
     this.timeZone = new Pt.TimeZone(timeZoneId ?? Pt.Now.timeZoneId());
   }
+  /**
+   * @package - exposed for testing
+   */
+  getEvaluationContext(contextNode, namespaceResolver) {
+    const contextOptions = {
+      rootNode: this.rootNode,
+      namespaceResolver
+    };
+    this.domProvider.assertXPathNode(contextNode);
+    return new EvaluationContext(this, contextNode, contextOptions);
+  }
   evaluate(expression, contextNode, namespaceResolver, resultType) {
     const tree = this.parser.parse(expression, this.parseOptions);
-    const evaluationContextNamespaceResolver = typeof namespaceResolver === "function" ? {
-      lookupNamespaceURI: namespaceResolver
-    } : namespaceResolver;
-    const contextOptions = partialOmitNullish({
-      ...this.sharedContextOptions,
-      namespaceResolver: evaluationContextNamespaceResolver
-    });
     const expr = createExpression(tree.rootNode);
-    const context = new EvaluationContext(this, contextNode, contextOptions);
-    const results = expr.evaluate(context);
-    return toXPathResult(resultType ?? XPathResult.ANY_TYPE, results);
+    const evaluationContext = this.getEvaluationContext(contextNode, namespaceResolver);
+    const results = expr.evaluate(evaluationContext);
+    return toXPathEvaluationResult(
+      this.domProvider,
+      resultType ?? XPATH_EVALUATION_RESULT.ANY_TYPE,
+      results
+    );
   }
   getContextNode(options) {
     const contextNode = options.contextNode ?? this.rootNode;
@@ -25094,19 +25255,24 @@ class Evaluator {
   }
   evaluateBoolean(expression, options = {}) {
     const contextNode = this.getContextNode(options);
-    return this.evaluate(expression, contextNode, null, XPathResult.BOOLEAN_TYPE).booleanValue;
+    return this.evaluate(expression, contextNode, null, XPATH_EVALUATION_RESULT.BOOLEAN_TYPE).booleanValue;
   }
   evaluateNumber(expression, options = {}) {
     const contextNode = this.getContextNode(options);
-    return this.evaluate(expression, contextNode, null, XPathResult.NUMBER_TYPE).numberValue;
+    return this.evaluate(expression, contextNode, null, XPATH_EVALUATION_RESULT.NUMBER_TYPE).numberValue;
   }
   evaluateString(expression, options = {}) {
     const contextNode = this.getContextNode(options);
-    return this.evaluate(expression, contextNode, null, XPathResult.STRING_TYPE).stringValue;
+    return this.evaluate(expression, contextNode, null, XPATH_EVALUATION_RESULT.STRING_TYPE).stringValue;
   }
   evaluateNode(expression, options = {}) {
     const contextNode = this.getContextNode(options);
-    const node = this.evaluate(expression, contextNode, null, XPathResult.FIRST_ORDERED_NODE_TYPE).singleNodeValue;
+    const node = this.evaluate(
+      expression,
+      contextNode,
+      null,
+      XPATH_EVALUATION_RESULT.FIRST_ORDERED_NODE_TYPE
+    ).singleNodeValue;
     if (!options.assertExists) {
       return node;
     }
@@ -25130,7 +25296,7 @@ class Evaluator {
       expression,
       contextNode,
       null,
-      XPathResult.ORDERED_NODE_SNAPSHOT_TYPE
+      XPATH_EVALUATION_RESULT.ORDERED_NODE_SNAPSHOT_TYPE
     );
     const { snapshotLength } = snapshotResult;
     const nodes = [];
@@ -25144,6 +25310,287 @@ class Evaluator {
   }
 }
 
+class IncompatibleRuntimeEnvironmentError extends Error {
+}
+
+let didAssertNodeConstructor = false;
+const assertNodeConstructor = (NodeConstructor) => {
+  if (didAssertNodeConstructor) {
+    return;
+  }
+  const isExpectedFunctionSignature = typeof NodeConstructor === "function" && NodeConstructor.name === "Node" && NodeConstructor.length === 0;
+  if (!isExpectedFunctionSignature || !(globalThis.document instanceof NodeConstructor)) {
+    throw new IncompatibleRuntimeEnvironmentError();
+  }
+  didAssertNodeConstructor = true;
+};
+const getNodeConstructor = () => {
+  const { Node } = globalThis;
+  assertNodeConstructor(Node);
+  return Node;
+};
+
+const DOCUMENT_NODE = 9;
+const ELEMENT_NODE = 1;
+const ATTRIBUTE_NODE = 2;
+const TEXT_NODE = 3;
+const CDATA_SECTION_NODE = 4;
+const COMMENT_NODE = 8;
+const PROCESSING_INSTRUCTION_NODE = 7;
+const DOCUMENT_TYPE_NODE = 10;
+const isUnknownWHATNode = (value) => {
+  return value instanceof getNodeConstructor();
+};
+const getOptionalNodeKind = (value) => {
+  if (!isUnknownWHATNode(value)) {
+    return null;
+  }
+  const node = value;
+  switch (node.nodeType) {
+    case DOCUMENT_NODE:
+      return "document";
+    case DOCUMENT_TYPE_NODE:
+      return "UNSPECIFIED_NON_XPATH_NODE";
+    case ELEMENT_NODE:
+      return "element";
+    case ATTRIBUTE_NODE:
+      if (node.namespaceURI === XMLNS_NAMESPACE_URI) {
+        return "namespace_declaration";
+      }
+      return "attribute";
+    case TEXT_NODE:
+    case CDATA_SECTION_NODE:
+      return "text";
+    case COMMENT_NODE:
+      return "comment";
+    case PROCESSING_INSTRUCTION_NODE:
+      return "processing_instruction";
+    default:
+      return null;
+  }
+};
+const getWHATNodeKind = (node) => {
+  const nodeKind = getOptionalNodeKind(node);
+  if (nodeKind == null) {
+    throw new Error(`Unsupported WHAT node type: ${node.nodeType}`);
+  }
+  return nodeKind;
+};
+const isWHATNode = (value) => {
+  const nodeKind = getOptionalNodeKind(value);
+  return nodeKind != null && nodeKind !== "UNSPECIFIED_NON_XPATH_NODE";
+};
+const isWHATDocument = (node) => {
+  return node.nodeType === DOCUMENT_NODE;
+};
+const isWHATElement = (node) => {
+  return node.nodeType === ELEMENT_NODE;
+};
+const isWHATNamespaceDeclaration = (node) => {
+  return node.nodeType === ATTRIBUTE_NODE && node.namespaceURI === XMLNS_NAMESPACE_URI;
+};
+const isWHATAttribute = (node) => {
+  return node.nodeType === ATTRIBUTE_NODE && node.namespaceURI !== XMLNS_NAMESPACE_URI;
+};
+const isWHATParentNode = (node) => {
+  return isWHATDocument(node) || isWHATElement(node);
+};
+
+const getWHATNamespaceURI = (node) => {
+  return node.namespaceURI;
+};
+const getWHATQualifiedName = (node) => {
+  return node.nodeName;
+};
+const getWHATLocalName = (node) => {
+  return node.localName;
+};
+const getWHATProcessingInstructionName = (node) => {
+  return node.nodeName;
+};
+const resolveWHATNamespaceURI = (node, prefix) => {
+  return node.lookupNamespaceURI(prefix);
+};
+
+const getContainingWHATDocument = (node) => {
+  if (isWHATDocument(node)) {
+    return node;
+  }
+  return node.ownerDocument;
+};
+const getOwnerWHATElement = (node) => {
+  const ownerElement = node.ownerElement ?? null;
+  return ownerElement;
+};
+const getAttrs = (node) => {
+  if (isWHATElement(node)) {
+    return Array.from(node.attributes);
+  }
+  return [];
+};
+const getWHATNamespaceDeclarations = (node) => {
+  return getAttrs(node).filter(isWHATNamespaceDeclaration);
+};
+const getWHATAttributes = (node) => {
+  return getAttrs(node).filter(isWHATAttribute);
+};
+const getWHATParentNode = (node) => {
+  let parentNode = getOwnerWHATElement(node);
+  if (parentNode == null) {
+    parentNode = node.parentNode;
+  }
+  return parentNode;
+};
+const getWHATChildNodes = (node) => {
+  if (!isWHATParentNode(node)) {
+    return [];
+  }
+  return Array.from(node.childNodes);
+};
+const getChildWHATElements = (node) => {
+  if (!isWHATParentNode(node)) {
+    return [];
+  }
+  return Array.from(node.children);
+};
+const getPreviousSiblingWHATNode = (node) => {
+  const previousSibling = node.previousSibling;
+  return previousSibling;
+};
+const getPreviousSiblingWHATElement = (node) => {
+  const previousElementSibling = node.previousElementSibling ?? null;
+  return previousElementSibling;
+};
+const getNextSiblingWHATNode = (node) => {
+  return node.nextSibling;
+};
+const getNextSiblingWHATElement = (node) => {
+  const nextElementSibling = node.nextElementSibling ?? null;
+  return nextElementSibling;
+};
+const isDescendantWHATNode = (ancestor, other) => {
+  return ancestor.contains(other);
+};
+const getWHATDocumentPositionComparableNode = (node) => {
+  return getOwnerWHATElement(node) ?? node;
+};
+const DOCUMENT_POSITION_PRECEDING = 2;
+const DOCUMENT_POSITION_FOLLOWING = 4;
+const compareWHATDocumentOrder = (a, b) => {
+  if (a === b) {
+    return 0;
+  }
+  const compared = b.compareDocumentPosition(a);
+  if (compared === 0) {
+    if (getWHATDocumentPositionComparableNode(a) === b) {
+      return 1;
+    }
+    if (a === getWHATDocumentPositionComparableNode(b)) {
+      return -1;
+    }
+  }
+  if (compared & DOCUMENT_POSITION_FOLLOWING) {
+    return 1;
+  }
+  if (compared & DOCUMENT_POSITION_PRECEDING) {
+    return -1;
+  }
+  throw new Error("Failed to compare document position");
+};
+
+const getQualifiedNamedWHATAttributeValue = (node, namespaceURI, localName) => {
+  return node.getAttributeNS(namespaceURI, localName);
+};
+const getLocalNamedWHATAttributeValue = (node, localName) => {
+  return node.getAttribute(localName);
+};
+const hasLocalNamedWHATAttribute = (node, localName) => {
+  return node.hasAttribute(localName);
+};
+const getWHATElementByUniqueId = (node, id) => {
+  const element = getContainingWHATDocument(node).getElementById(id);
+  return element;
+};
+const getWHATChildrenByLocalName = (node, localName) => {
+  return getChildWHATElements(node).filter((element) => {
+    return element.localName === localName;
+  });
+};
+const getFirstWHATChildNode = (node) => {
+  const firstChild = node.firstChild;
+  return firstChild;
+};
+const getLastWHATChildNode = (node) => {
+  const lastChild = node.lastChild;
+  return lastChild;
+};
+const getFirstChildWHATElement = (node) => {
+  const firstElementChild = node.firstElementChild ?? null;
+  return firstElementChild;
+};
+const getLastChildWHATElement = (node) => {
+  const lastElementChild = node.lastElementChild ?? null;
+  return lastElementChild;
+};
+
+const getWHATNodeValue = (node) => {
+  return node.textContent ?? "";
+};
+
+const whatDOMAdapter = {
+  // XPathNodeKindAdapter
+  getNodeKind: getWHATNodeKind,
+  isXPathNode: isWHATNode,
+  // XPathNameAdapter
+  getLocalName: getWHATLocalName,
+  getNamespaceURI: getWHATNamespaceURI,
+  getQualifiedName: getWHATQualifiedName,
+  getProcessingInstructionName: getWHATProcessingInstructionName,
+  resolveNamespaceURI: resolveWHATNamespaceURI,
+  // XPathValueAdapter
+  getNodeValue: getWHATNodeValue,
+  // XPathTraversalAdapter
+  compareDocumentOrder: compareWHATDocumentOrder,
+  getAttributes: getWHATAttributes,
+  getChildElements: getChildWHATElements,
+  getChildNodes: getWHATChildNodes,
+  getContainingDocument: getContainingWHATDocument,
+  getNamespaceDeclarations: getWHATNamespaceDeclarations,
+  getNextSiblingElement: getNextSiblingWHATElement,
+  getNextSiblingNode: getNextSiblingWHATNode,
+  getParentNode: getWHATParentNode,
+  getPreviousSiblingElement: getPreviousSiblingWHATElement,
+  getPreviousSiblingNode: getPreviousSiblingWHATNode,
+  isDescendantNode: isDescendantWHATNode,
+  // XPathDOMOptimizableOperations
+  getElementByUniqueId: getWHATElementByUniqueId,
+  getChildrenByLocalName: getWHATChildrenByLocalName,
+  getQualifiedNamedAttributeValue: getQualifiedNamedWHATAttributeValue,
+  getLocalNamedAttributeValue: getLocalNamedWHATAttributeValue,
+  hasLocalNamedAttribute: hasLocalNamedWHATAttribute,
+  getFirstChildElement: getFirstChildWHATElement,
+  getFirstChildNode: getFirstWHATChildNode,
+  getLastChildElement: getLastChildWHATElement,
+  getLastChildNode: getLastWHATChildNode
+};
+
+const DEFAULT_DOM_ADAPTER = whatDOMAdapter;
+const DEFAULT_DOM_PROVIDER = xpathDOMProvider(DEFAULT_DOM_ADAPTER);
+
+const XPathNodeKindKey = Symbol("XPathNodeKindKey");
+
+class DefaultEvaluator extends Evaluator {
+  constructor(options) {
+    super({
+      ...options,
+      domAdapter: DEFAULT_DOM_ADAPTER
+    });
+  }
+}
+
+const XFORMS_LOCAL_NAME = Symbol("XFORMS_LOCAL_NAME");
+const XFORMS_KNOWN_ATTRIBUTE = Symbol("XFORMS_KNOWN_ATTRIBUTE");
+
 const DAY_MILLISECONDS = 1e3 * 60 * 60 * 24;
 const MILLISECOND_NANOSECONDS = BigInt(1e6);
 const ISO_DATE_LIKE_SUBPATTERN = "\\d{4}-\\d{2}-\\d{2}";
@@ -25510,14 +25957,14 @@ const decimalTime = new NumberFunction(
 );
 
 const datetime = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	date,
-	decimalDateTime,
-	decimalTime,
-	formatDate,
-	formatDateTime,
-	today,
-	xfNow
+    __proto__: null,
+    date,
+    decimalDateTime,
+    decimalTime,
+    formatDate,
+    formatDateTime,
+    today,
+    xfNow
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const enk = new FunctionLibrary(ENKETO_NAMESPACE_URI, [
@@ -25525,209 +25972,18 @@ const enk = new FunctionLibrary(ENKETO_NAMESPACE_URI, [
   new FunctionAlias("format-date", formatDateTime)
 ]);
 
-class UpsertableWeakMap extends WeakMap {
-  upsert(key, produce) {
-    if (this.has(key)) {
-      return this.get(key);
-    }
-    const value = produce(key);
-    this.set(key, value);
-    return value;
-  }
-}
-
-const SUPPORTS_SCOPE_CHILD_SELECTOR = (() => {
-  const parent = document.createElement("parent");
-  const child1 = document.createElement("child1");
-  const child2 = document.createElement("child2");
-  child2.append(child1);
-  parent.append(child2);
-  return parent.querySelector(":scope > child1") === child1 && parent.querySelector(":scope > child2") !== child2;
-})();
-const getScopedElement = (() => {
-  if (SUPPORTS_SCOPE_CHILD_SELECTOR) {
-    return (lookup, contextNode) => {
-      return contextNode.querySelector(lookup.scopedSelector);
-    };
-  }
-  return (lookup, contextNode) => {
-    const { unscopedSelector } = lookup;
-    for (const child of contextNode.children) {
-      if (child.matches(unscopedSelector)) {
-        return child;
-      }
-    }
-    return null;
-  };
-})();
-const getScopedElements = (() => {
-  if (SUPPORTS_SCOPE_CHILD_SELECTOR) {
-    return (lookup, contextNode) => {
-      return contextNode.querySelectorAll(lookup.scopedSelector);
-    };
-  }
-  return (lookup, contextNode) => {
-    const { unscopedSelector } = lookup;
-    return Array.from(contextNode.children).filter((child) => {
-      return child.matches(unscopedSelector);
-    });
-  };
-})();
-class ScopedElementLookup {
-  constructor(scopedSelector, unscopedSelector) {
-    this.scopedSelector = scopedSelector;
-    this.unscopedSelector = unscopedSelector;
-  }
-  /**
-   * WARNING: `T` is unchecked at runtime, use with caution!
-   */
-  getElement(contextNode) {
-    return getScopedElement(this, contextNode);
-  }
-  /**
-   * WARNING: `T` is unchecked at runtime, use with caution!
-   */
-  getElements(contextNode) {
-    return getScopedElements(this, contextNode);
-  }
-}
-
-const itextRootLookup = new ScopedElementLookup(":scope > itext", "itext");
-const getItextRoot = (modelElement) => {
-  return itextRootLookup.getElement(modelElement);
-};
-const translationLookup = new ScopedElementLookup(
-  ":scope > translation[lang]",
-  "translation[lang]"
-);
-const translationElementsCache = new UpsertableWeakMap();
-const getTranslationElementMap = (modelElement) => {
-  return translationElementsCache.upsert(modelElement, () => {
-    const itextRoot = getItextRoot(modelElement);
-    if (itextRoot == null) {
-      return /* @__PURE__ */ new Map();
-    }
-    const translationElements = Array.from(
-      translationLookup.getElements(itextRoot)
-    );
-    return new Map(
-      translationElements.map((element) => {
-        return [element.getAttribute("lang"), element];
-      })
-    );
-  });
-};
-const getTranslationElement = (modelElement, translationLanguage) => {
-  const translationElementMap = getTranslationElementMap(modelElement);
-  return translationElementMap.get(translationLanguage) ?? null;
-};
-const translationTextLookup = new ScopedElementLookup(":scope > text[id]", "text[id]");
-const translationsCache = new UpsertableWeakMap();
-const getTranslationTextByLanguage = (modelElement, language, itextID) => {
-  const translationElement = getTranslationElement(modelElement, language);
-  if (translationElement == null) {
-    return null;
-  }
-  const textMaps = translationsCache.upsert(modelElement, () => {
-    return new UpsertableWeakMap();
-  });
-  const textMap = textMaps.upsert(translationElement, () => {
-    const textElements = Array.from(
-      translationTextLookup.getElements(translationElement)
-    );
-    return new Map(
-      textElements.map((element) => {
-        return [element.getAttribute("id"), element];
-      })
-    );
-  });
-  return textMap.get(itextID) ?? null;
-};
-const defaultTextValueLookup = new ScopedElementLookup(
-  ":scope > value:not([form])",
-  "value:not([form])"
-);
-const getDefaultTextValueElement = (textElement) => {
-  return defaultTextValueLookup.getElement(textElement);
-};
-const getTranslationMetadata = (modelElement) => {
-  const languages = [];
-  let defaultLanguage = null;
-  if (modelElement == null) {
-    return {
-      defaultLanguage,
-      languages
-    };
-  }
-  const translationElementMap = getTranslationElementMap(modelElement);
-  for (const [language, element] of translationElementMap) {
-    if (defaultLanguage == null && element.hasAttribute("default")) {
-      defaultLanguage = language;
-      languages.unshift(language);
-    } else {
-      languages.push(language);
-    }
-  }
-  if (defaultLanguage == null) {
-    defaultLanguage = languages[0] ?? null;
-  }
-  return {
-    defaultLanguage,
-    languages
-  };
-};
-class XFormsItextTranslations {
-  constructor(evaluator) {
-    this.evaluator = evaluator;
-    const { defaultLanguage, languages } = getTranslationMetadata(evaluator.modelElement);
-    this.defaultLanguage = defaultLanguage;
-    this.activeLanguage = defaultLanguage;
-    this.languages = languages;
-  }
-  defaultLanguage;
-  languages;
-  activeLanguage;
-  getLanguages() {
-    return this.languages;
-  }
-  getActiveLanguage() {
-    return this.activeLanguage;
-  }
-  setActiveLanguage(language) {
-    this.activeLanguage = language ?? this.defaultLanguage;
-    return this.activeLanguage;
-  }
-}
-
 const itext = new StringFunction(
   "itext",
   [{ arityType: "required", typeHint: "string" }],
   (context, [itextIDExpression]) => {
-    const { evaluator } = context;
-    if (!(evaluator instanceof XFormsXPathEvaluator)) {
-      throw new Error("itext not available");
-    }
-    const { modelElement } = evaluator;
-    if (modelElement == null) {
-      return "";
-    }
-    const activeLanguage = evaluator.translations.getActiveLanguage();
-    if (activeLanguage == null) {
-      return "";
-    }
     const itextID = itextIDExpression.evaluate(context).toString();
-    const textElement = getTranslationTextByLanguage(modelElement, activeLanguage, itextID);
-    if (textElement == null) {
-      return "";
-    }
-    const defaultTextValue = getDefaultTextValueElement(textElement);
-    return defaultTextValue?.textContent ?? "";
+    return XFormsXPathEvaluator.getDefaultTranslationText(context, itextID);
   }
 );
 
 const string$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	itext
+    __proto__: null,
+    itext
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const jr = new FunctionLibrary(JAVAROSA_NAMESPACE_URI, [...Object.values(string$1)]);
@@ -25823,11 +26079,11 @@ const xfIf = new FunctionImplementation(
 );
 
 const boolean = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	booleanFromString,
-	checklist,
-	weightedChecklist,
-	xfIf
+    __proto__: null,
+    booleanFromString,
+    checklist,
+    weightedChecklist,
+    xfIf
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const DEGREES_MAX = {
@@ -25977,9 +26233,9 @@ const distance = new NumberFunction(
 );
 
 const geo = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	area,
-	distance
+    __proto__: null,
+    area,
+    distance
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const MAX_INT_32 = 2147483647;
@@ -26051,23 +26307,18 @@ const assertArgument = (index, arg) => {
     throw new Error(`Argument ${index + 1} expected`);
   }
 };
-const assertIsLocationPathEvaluation = (evaluation) => {
-  if (!(evaluation instanceof LocationPathEvaluation)) {
-    throw new Error("Expected a node-set result");
-  }
-};
 const evaluateArgumentToFilterableNodes = (context, arg) => {
   const evaluation = arg.evaluate(context);
-  assertIsLocationPathEvaluation(evaluation);
+  LocationPathEvaluation.assertInstance(context, evaluation);
   return Array.from(evaluation.contextNodes);
 };
-const compareContainmentDepth = ({ repeats: a }, { repeats: b }) => {
+const compareContainmentDepth = (domProvider, { repeats: a }, { repeats: b }) => {
   for (const repeatA of a) {
     for (const repeatB of b) {
-      if (repeatA.contains(repeatB)) {
+      if (domProvider.isDescendantNode(repeatA, repeatB)) {
         return -1;
       }
-      if (repeatB.contains(repeatA)) {
+      if (domProvider.isDescendantNode(repeatB, repeatA)) {
         return 1;
       }
     }
@@ -26118,14 +26369,15 @@ const indexedRepeat = new NodeSetFunction(
         position: position2
       });
     }
-    pairs = pairs.sort(compareContainmentDepth);
+    const { domProvider } = context;
+    pairs = pairs.sort((pairA, pairB) => compareContainmentDepth(domProvider, pairA, pairB));
     let repeatContextNode;
     for (const [index, pair] of pairs.entries()) {
       const { position: position2 } = pair;
       let { repeats } = pair;
       if (index > 0) {
         repeats = pair.repeats.filter((repeat) => {
-          return repeatContextNode.contains(repeat);
+          return domProvider.isDescendantNode(repeatContextNode, repeat);
         });
       }
       const positionedRepeat = repeats[position2 - 1];
@@ -26136,40 +26388,20 @@ const indexedRepeat = new NodeSetFunction(
     }
     const targetNodes = evaluateArgumentToFilterableNodes(context, target);
     return targetNodes.filter((targetNode) => {
-      return repeatContextNode.contains(targetNode);
+      return domProvider.isDescendantNode(repeatContextNode, targetNode);
     });
   }
 );
-const identifiedInstanceLookup = new ScopedElementLookup(":scope > instance[id]", "instance[id]");
-const instancesCache = new UpsertableWeakMap();
-const getInstanceElementByID = (modelElement, id) => {
-  const instances = instancesCache.upsert(modelElement, () => {
-    const instanceElements = Array.from(
-      identifiedInstanceLookup.getElements(modelElement)
-    );
-    return new Map(
-      instanceElements.map((element) => {
-        return [element.getAttribute("id"), element];
-      })
-    );
-  });
-  return instances.get(id) ?? null;
-};
 const instance = new NodeSetFunction(
   "instance",
   [{ arityType: "required" }],
   (context, [idExpression]) => {
     const id = idExpression.evaluate(context).toString();
-    const { evaluator } = context;
-    if (!(evaluator instanceof XFormsXPathEvaluator)) {
-      throw new Error("itext not available");
-    }
-    const { modelElement } = evaluator;
-    if (modelElement == null) {
+    const instanceElement = XFormsXPathEvaluator.getSecondaryInstance(context, id);
+    if (instanceElement == null) {
       return [];
     }
-    const instanceElement = getInstanceElementByID(modelElement, id);
-    return instanceElement == null ? [] : [instanceElement];
+    return [instanceElement];
   }
 );
 const once = new StringFunction(
@@ -26180,13 +26412,17 @@ const once = new StringFunction(
     if (contextNode == null) {
       throw "todo once no context";
     }
-    const string = contextNode.textContent ?? "";
+    const string = context.domProvider.getNodeValue(contextNode);
     if (string === "") {
       return expression.evaluate(context).toString();
     }
     return string;
   }
 );
+const isLikelyRepeatRangeEvaluationContextCommentMarkerNode = (context, node) => {
+  const { evaluationContextNode } = context;
+  return context.domProvider.isComment(node) && node === evaluationContextNode;
+};
 const position = new NumberFunction(
   "position",
   [{ arityType: "optional" }],
@@ -26195,9 +26431,7 @@ const position = new NumberFunction(
       return context.contextPosition();
     }
     const results = expression.evaluate(context);
-    if (!(results instanceof LocationPathEvaluation)) {
-      throw "todo not a node-set";
-    }
+    LocationPathEvaluation.assertInstance(context, results);
     const [first, next] = results.values();
     if (first == null) {
       return NaN;
@@ -26205,15 +26439,27 @@ const position = new NumberFunction(
     if (next != null) {
       throw "todo enforce single node(?)";
     }
+    const { domProvider } = context;
     const { value } = first;
-    const { nodeName } = value;
-    let currentNode = value;
-    let result = 1;
-    while ((currentNode = currentNode.previousSibling) != null) {
-      if (currentNode.nodeName === nodeName) {
-        result += 1;
+    if (!domProvider.isQualifiedNamedNode(value)) {
+      if (isLikelyRepeatRangeEvaluationContextCommentMarkerNode(context, value)) {
+        return context.contextPosition();
       }
+      throw new Error(
+        "Cannot get position among contiguous nodes with same name: not a named node."
+      );
     }
+    const nodeName = domProvider.getQualifiedName(value);
+    let currentNode = value;
+    let result = 0;
+    do {
+      result += 1;
+      const previousNode = domProvider.getPreviousSiblingElement(currentNode);
+      if (previousNode == null) {
+        break;
+      }
+      currentNode = previousNode;
+    } while (domProvider.getQualifiedName(currentNode) === nodeName);
     return result;
   }
 );
@@ -26225,9 +26471,7 @@ const randomize = new NodeSetFunction(
   ],
   (context, [expression, seedExpression]) => {
     const results = expression.evaluate(context);
-    if (!(results instanceof LocationPathEvaluation)) {
-      throw "todo (not a node-set)";
-    }
+    LocationPathEvaluation.assertInstance(context, results);
     const nodeResults = Array.from(results.values());
     const nodes = nodeResults.map(({ value }) => value);
     const seed = seedExpression?.evaluate(context).toNumber();
@@ -26236,13 +26480,13 @@ const randomize = new NodeSetFunction(
 );
 
 const nodeset = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	countNonEmpty,
-	indexedRepeat,
-	instance,
-	once,
-	position,
-	randomize
+    __proto__: null,
+    countNonEmpty,
+    indexedRepeat,
+    instance,
+    once,
+    position,
+    randomize
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const abs = mathAlias("abs");
@@ -26327,28 +26571,28 @@ const sqrt = mathAlias("sqrt");
 const tan = mathAlias("tan");
 
 const number$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	abs,
-	acos,
-	asin,
-	atan,
-	atan2,
-	cos,
-	exp,
-	exp10,
-	int,
-	log,
-	log10,
-	max,
-	min,
-	number,
-	pi,
-	pow,
-	random,
-	round,
-	sin,
-	sqrt,
-	tan
+    __proto__: null,
+    abs,
+    acos,
+    asin,
+    atan,
+    atan2,
+    cos,
+    exp,
+    exp10,
+    int,
+    log,
+    log10,
+    max,
+    min,
+    number,
+    pi,
+    pow,
+    random,
+    round,
+    sin,
+    sqrt,
+    tan
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const countSelected = new NumberFunction(
@@ -26385,10 +26629,10 @@ const selectedAt = new StringFunction(
 );
 
 const select = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	countSelected,
-	selected,
-	selectedAt
+    __proto__: null,
+    countSelected,
+    selected,
+    selectedAt
 }, Symbol.toStringTag, { value: 'Module' }));
 
 var cryptoJs = {exports: {}};
@@ -26402,8 +26646,8 @@ var core = {exports: {}};
 const __viteBrowserExternal = {};
 
 const __viteBrowserExternal$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	default: __viteBrowserExternal
+    __proto__: null,
+    default: __viteBrowserExternal
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const require$$0 = /*@__PURE__*/getAugmentedNamespace(__viteBrowserExternal$1);
@@ -27798,8 +28042,8 @@ var encBase64Exports = encBase64$1.exports;
 const encBase64 = /*@__PURE__*/getDefaultExportFromCjs(encBase64Exports);
 
 const base64 = /*#__PURE__*/_mergeNamespaces({
-	__proto__: null,
-	default: encBase64
+    __proto__: null,
+    default: encBase64
 }, [encBase64Exports]);
 
 var encBase64url = {exports: {}};
@@ -32947,8 +33191,8 @@ var encHexExports = encHex$1.exports;
 const encHex = /*@__PURE__*/getDefaultExportFromCjs(encHexExports);
 
 const hex = /*#__PURE__*/_mergeNamespaces({
-	__proto__: null,
-	default: encHex
+    __proto__: null,
+    default: encHex
 }, [encHexExports]);
 
 const toStrings = (context, expressions) => {
@@ -32979,11 +33223,11 @@ const coalesce = new StringFunction(
 const concat = new StringFunction(
   "concat",
   [{ arityType: "variadic", typeHint: "string" }],
-  (context, expressions) => {
-    if (expressions.length === 0) {
+  (context, args) => {
+    if (args.length === 0) {
       return "";
     }
-    return expressions.flatMap((expression) => {
+    return args.flatMap((expression) => {
       const results = expression.evaluate(context);
       return Array.from(results).map((result) => result.toString());
     }).join("");
@@ -33089,10 +33333,29 @@ const substr = new StringFunction(
     return start <= end ? string.substring(start, end) : "";
   }
 );
+let didAssertCrypto = false;
+const assertCrypto = (crypto) => {
+  if (didAssertCrypto) {
+    return;
+  }
+  if (typeof crypto !== "object" || crypto == null) {
+    throw new IncompatibleRuntimeEnvironmentError();
+  }
+  if (typeof crypto.randomUUID !== "function" || crypto.randomUUID.length !== 0) {
+    throw new IncompatibleRuntimeEnvironmentError();
+  }
+  didAssertCrypto = true;
+};
+const getGlobalCrypto = () => {
+  const { crypto } = globalThis;
+  assertCrypto(crypto);
+  return crypto;
+};
 const uuid = new StringFunction(
   "uuid",
   [{ arityType: "optional", typeHint: "number" }],
   (context, [lengthExpression]) => {
+    const crypto = getGlobalCrypto();
     let result = crypto.randomUUID();
     if (lengthExpression == null) {
       return result;
@@ -33109,15 +33372,15 @@ const uuid = new StringFunction(
 );
 
 const string = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	coalesce,
-	concat,
-	digest,
-	endsWith,
-	join,
-	regex,
-	substr,
-	uuid
+    __proto__: null,
+    coalesce,
+    concat,
+    digest,
+    endsWith,
+    join,
+    regex,
+    substr,
+    uuid
 }, Symbol.toStringTag, { value: 'Module' }));
 
 const xf = new FunctionLibrary(XFORMS_NAMESPACE_URI, [
@@ -33130,29 +33393,197 @@ const xf = new FunctionLibrary(XFORMS_NAMESPACE_URI, [
   ...Object.values(string)
 ]);
 
+class UpsertableWeakMap extends WeakMap {
+  upsert(key, produce) {
+    if (this.has(key)) {
+      return this.get(key);
+    }
+    const value = produce(key);
+    this.set(key, value);
+    return value;
+  }
+}
+
+class XFormsItextTranslations {
+  constructor(domProvider, translationElementMap) {
+    this.domProvider = domProvider;
+    this.translationElementMap = translationElementMap;
+    this.domProvider = domProvider;
+    this.translationElementMap = translationElementMap;
+    const { defaultLanguage, languages } = this.getTranslationMetadata(
+      domProvider,
+      translationElementMap
+    );
+    this.defaultLanguage = defaultLanguage;
+    this.activeLanguage = defaultLanguage;
+    this.languages = languages;
+  }
+  defaultLanguage = null;
+  languages = [];
+  activeLanguage = null;
+  translationsCache = new UpsertableWeakMap();
+  getTranslationMetadata(domProvider, translationElementMap) {
+    const languages = [];
+    let defaultLanguage = null;
+    for (const [language, element] of translationElementMap) {
+      if (defaultLanguage == null && domProvider.hasLocalNamedAttribute(element, "default")) {
+        defaultLanguage = language;
+        languages.unshift(language);
+      } else {
+        languages.push(language);
+      }
+    }
+    if (defaultLanguage == null) {
+      defaultLanguage = languages[0] ?? null;
+    }
+    return {
+      defaultLanguage,
+      languages
+    };
+  }
+  getTranslationTextElement(itextID) {
+    const activeLanguage = this.getActiveLanguage();
+    if (activeLanguage == null) {
+      return null;
+    }
+    const { domProvider, translationElementMap, translationsCache } = this;
+    const translationElement = translationElementMap.get(activeLanguage);
+    if (translationElement == null) {
+      return null;
+    }
+    const textMap = translationsCache.upsert(translationElement, () => {
+      const textElements = Array.from(
+        domProvider.getChildrenByLocalName(translationElement, "text")
+      );
+      return new Map(
+        textElements.flatMap((element) => {
+          const id = domProvider.getLocalNamedAttributeValue(element, "id");
+          if (id == null) {
+            return [];
+          }
+          return [[id, element]];
+        })
+      );
+    });
+    return textMap.get(itextID) ?? null;
+  }
+  /**
+   * @package
+   *
+   * Here, "default" is meant as more precise language than "regular" as
+   * {@link https://getodk.github.io/xforms-spec/#languages | specified by ODK XForms}. In other words, this is equivalent to the following hypothetical XPath pseudo-code (whitespace added to improve structural clarity):
+   *
+   * ```xpath
+   * string(
+   *   imaginary:itext-translation(
+   *     xpath3-fn:environment-variable('activeLanguage')
+   *   )
+   *     /text[@id = $itextID]
+   *       /value[not(@form)]
+   * )
+   * ```
+   *
+   * Or alternately:
+   *
+   * ```xpath
+   * string(
+   *   imaginary:itext-root()
+   *     /translation[@lang = xpath3-fn:environment-variable('activeLanguage')]
+   *       /text[@id = $itextID]
+   *         /value[not(@form)]
+   * )
+   * ```
+   *
+   * @todo The above really feels like it adds some helpful clarity to how `jr:itext()` is designed to work, and the kinds of structures, state and input involved. Since there's already some discomfort around that API as specified, it's worth considering
+   */
+  getDefaultTranslationText(itextID) {
+    const textElement = this.getTranslationTextElement(itextID);
+    if (textElement == null) {
+      return "";
+    }
+    const { domProvider } = this;
+    for (const valueElement of domProvider.getChildrenByLocalName(textElement, "value")) {
+      if (!domProvider.hasLocalNamedAttribute(valueElement, "form")) {
+        return domProvider.getNodeValue(valueElement);
+      }
+    }
+    return "";
+  }
+  getLanguages() {
+    return this.languages;
+  }
+  getActiveLanguage() {
+    return this.activeLanguage;
+  }
+  setActiveLanguage(language) {
+    this.activeLanguage = language ?? this.defaultLanguage;
+    return this.activeLanguage;
+  }
+}
+
 const functions = new FunctionLibraryCollection([enk, xf, fn, jr], {
   defaultNamespaceURIs: [enk.namespaceURI, xf.namespaceURI, fn.namespaceURI]
 });
+const assertInternalXFormsXPathEvaluatorContext = (context) => {
+  const { evaluator } = context;
+  if (evaluator instanceof XFormsXPathEvaluator && /**
+   * This check ensures that we apply consistent DOM adapter access where an
+   * (ODK XForms) XPath expression crosses tree boundaries (e.g. any two of
+   * primary instance, secondary instance, itext translations).
+   *
+   * It's not totally clear whether this check is strictly necessary! Even if
+   * not, it should be cheap enough not to bother finding out.
+   */
+  evaluator.domProvider === context.domProvider) {
+    return;
+  }
+  throw new Error("Expected evaluation context initiated by XFormsXPathEvaluator");
+};
 class XFormsXPathEvaluator extends Evaluator {
+  static getSecondaryInstance(context, id) {
+    assertInternalXFormsXPathEvaluatorContext(context);
+    return context.evaluator.secondaryInstancesById.get(id) ?? null;
+  }
+  static getDefaultTranslationText(context, itextID) {
+    assertInternalXFormsXPathEvaluatorContext(context);
+    return context.evaluator.itextTranslations.getDefaultTranslationText(itextID);
+  }
   rootNode;
-  rootNodeDocument;
-  modelElement;
-  translations;
+  /**
+   * @package
+   * @see {@link InternalXFormsXPathEvaluator}
+   */
+  itextTranslations;
+  /**
+   * @package
+   * @see {@link InternalXFormsXPathEvaluator}
+   */
+  secondaryInstancesById;
   constructor(options) {
     super({
       functions,
       ...options
     });
-    const { rootNode } = options;
-    const rootNodeDocument = rootNode.ownerDocument ?? rootNode;
-    this.modelElement = this.evaluateNode("./h:html/h:head/xf:model", {
-      contextNode: rootNodeDocument
-    });
+    this.secondaryInstancesById = options.secondaryInstancesById;
     this.rootNode = options.rootNode;
-    this.rootNodeDocument = rootNodeDocument;
-    this.translations = new XFormsItextTranslations(this);
+    this.itextTranslations = new XFormsItextTranslations(
+      this.domProvider,
+      options.itextTranslationsByLanguage
+    );
+  }
+  getLanguages() {
+    return this.itextTranslations.getLanguages();
+  }
+  getActiveLanguage() {
+    return this.itextTranslations.getActiveLanguage();
+  }
+  setActiveLanguage(language) {
+    return this.itextTranslations.setActiveLanguage(language);
+  }
+  getSecondaryInstance(id) {
+    return this.secondaryInstancesById.get(id);
   }
 }
 
-export { Evaluator, XFormsXPathEvaluator };
+export { DEFAULT_DOM_ADAPTER, DEFAULT_DOM_PROVIDER, DefaultEvaluator, Evaluator, XFORMS_KNOWN_ATTRIBUTE, XFORMS_LOCAL_NAME, XFormsXPathEvaluator, XPathNodeKindKey };
 //# sourceMappingURL=index.js.map