xslt-processor 3.4.0 → 4.0.0

package/index.js

@@ -1,13 +1,4468 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExprContext = exports.xmlEscapeText = exports.XmlParser = exports.Xslt = exports.XPath = void 0;
-var xpath_1 = require("./xpath");
-Object.defineProperty(exports, "XPath", { enumerable: true, get: function () { return xpath_1.XPath; } });
-var xslt_1 = require("./xslt");
-Object.defineProperty(exports, "Xslt", { enumerable: true, get: function () { return xslt_1.Xslt; } });
-var dom_1 = require("./dom");
-Object.defineProperty(exports, "XmlParser", { enumerable: true, get: function () { return dom_1.XmlParser; } });
-Object.defineProperty(exports, "xmlEscapeText", { enumerable: true, get: function () { return dom_1.xmlEscapeText; } });
-var xpath_2 = require("./xpath");
-Object.defineProperty(exports, "ExprContext", { enumerable: true, get: function () { return xpath_2.ExprContext; } });
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ExprContext: () => ExprContext,
+  XPath: () => XPath,
+  XmlParser: () => XmlParser,
+  Xslt: () => Xslt,
+  xmlEscapeText: () => xmlEscapeText
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/xpath/lib/src/lexer/token.ts
+var XPathToken = class {
+  constructor(type, lexeme) {
+    this.type = type;
+    this.lexeme = lexeme;
+  }
+};
+
+// src/xpath/lib/src/lexer/lexer.ts
+var RESERVED_WORDS = {
+  // Location axes (XPath 1.0 complete list)
+  "ancestor": { type: "LOCATION", value: "ancestor" },
+  "ancestor-or-self": { type: "LOCATION", value: "ancestor-or-self" },
+  "attribute": { type: "LOCATION", value: "attribute" },
+  "child": { type: "LOCATION", value: "child" },
+  "descendant": { type: "LOCATION", value: "descendant" },
+  "descendant-or-self": { type: "LOCATION", value: "descendant-or-self" },
+  "following": { type: "LOCATION", value: "following" },
+  "following-sibling": { type: "LOCATION", value: "following-sibling" },
+  "namespace": { type: "LOCATION", value: "namespace" },
+  "parent": { type: "LOCATION", value: "parent" },
+  "preceding": { type: "LOCATION", value: "preceding" },
+  "preceding-sibling": { type: "LOCATION", value: "preceding-sibling" },
+  "self": { type: "LOCATION", value: "self" },
+  // Node type tests
+  "node": { type: "NODE_TYPE", value: "node" },
+  "text": { type: "NODE_TYPE", value: "text" },
+  "comment": { type: "NODE_TYPE", value: "comment" },
+  "processing-instruction": { type: "NODE_TYPE", value: "processing-instruction" },
+  // Operators
+  "and": { type: "OPERATOR", value: "and" },
+  "or": { type: "OPERATOR", value: "or" },
+  "div": { type: "OPERATOR", value: "div" },
+  "mod": { type: "OPERATOR", value: "mod" },
+  // Node set functions
+  "last": { type: "FUNCTION", value: "last" },
+  "position": { type: "FUNCTION", value: "position" },
+  "count": { type: "FUNCTION", value: "count" },
+  "id": { type: "FUNCTION", value: "id" },
+  "local-name": { type: "FUNCTION", value: "local-name" },
+  "namespace-uri": { type: "FUNCTION", value: "namespace-uri" },
+  "name": { type: "FUNCTION", value: "name" },
+  // String functions
+  "string": { type: "FUNCTION", value: "string" },
+  "concat": { type: "FUNCTION", value: "concat" },
+  "starts-with": { type: "FUNCTION", value: "starts-with" },
+  "contains": { type: "FUNCTION", value: "contains" },
+  "substring-before": { type: "FUNCTION", value: "substring-before" },
+  "substring-after": { type: "FUNCTION", value: "substring-after" },
+  "substring": { type: "FUNCTION", value: "substring" },
+  "string-length": { type: "FUNCTION", value: "string-length" },
+  "normalize-space": { type: "FUNCTION", value: "normalize-space" },
+  "translate": { type: "FUNCTION", value: "translate" },
+  // Boolean functions
+  "boolean": { type: "FUNCTION", value: "boolean" },
+  "not": { type: "FUNCTION", value: "not" },
+  "true": { type: "FUNCTION", value: "true" },
+  "false": { type: "FUNCTION", value: "false" },
+  "lang": { type: "FUNCTION", value: "lang" },
+  // Number functions
+  "number": { type: "FUNCTION", value: "number" },
+  "sum": { type: "FUNCTION", value: "sum" },
+  "floor": { type: "FUNCTION", value: "floor" },
+  "ceiling": { type: "FUNCTION", value: "ceiling" },
+  "round": { type: "FUNCTION", value: "round" },
+  // XSLT-specific functions (commonly used)
+  "document": { type: "FUNCTION", value: "document" },
+  "key": { type: "FUNCTION", value: "key" },
+  "format-number": { type: "FUNCTION", value: "format-number" },
+  "current": { type: "FUNCTION", value: "current" },
+  "unparsed-entity-uri": { type: "FUNCTION", value: "unparsed-entity-uri" },
+  "generate-id": { type: "FUNCTION", value: "generate-id" },
+  "system-property": { type: "FUNCTION", value: "system-property" },
+  "element-available": { type: "FUNCTION", value: "element-available" },
+  "function-available": { type: "FUNCTION", value: "function-available" }
+};
+var XPathLexer = class {
+  /**
+   * Check if character is a valid start of an identifier.
+   * Supports Unicode letters according to XML NCName specification.
+   */
+  isAlpha(char) {
+    return /^[a-zA-Z_\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]$/.test(char);
+  }
+  /**
+   * Check if character is valid in an identifier (after the first character).
+   * Supports Unicode letters and digits according to XML NCName specification.
+   * Note: Hyphen is handled separately in parseIdentifier for reserved words.
+   */
+  isAlphaNumeric(char) {
+    return /^[a-zA-Z0-9_\u00B7\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0300-\u036F\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u203F-\u2040\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]$/.test(char);
+  }
+  isNumber(char) {
+    return /^[0-9]$/.test(char);
+  }
+  isWhitespace(char) {
+    return /^[\s\t\n\r]$/.test(char);
+  }
+  peek() {
+    return this.expression[this.current];
+  }
+  peekNext() {
+    return this.expression[this.current + 1];
+  }
+  next() {
+    return this.expression[this.current++];
+  }
+  match(expected) {
+    if (this.current >= this.expression.length) return false;
+    if (this.expression[this.current] !== expected) return false;
+    this.current++;
+    return true;
+  }
+  parseIdentifier(firstCharacter) {
+    let characters = firstCharacter;
+    while (this.current < this.expression.length) {
+      const char = this.expression[this.current];
+      if (this.isAlphaNumeric(char)) {
+        characters += this.next();
+      } else if (char === "-") {
+        const nextChar = this.expression[this.current + 1];
+        if (nextChar && this.isAlphaNumeric(nextChar)) {
+          this.current++;
+          characters += "-";
+          while (this.current < this.expression.length && this.isAlphaNumeric(this.expression[this.current])) {
+            characters += this.next();
+          }
+        } else {
+          break;
+        }
+      } else {
+        break;
+      }
+    }
+    const likelyReservedWord = RESERVED_WORDS[characters.toLowerCase()];
+    if (likelyReservedWord) {
+      return new XPathToken(likelyReservedWord.type, characters);
+    }
+    if (characters.length > 0) {
+      return new XPathToken("IDENTIFIER", characters);
+    }
+    throw new Error(`Invalid identifier: ${characters}`);
+  }
+  parseString(quoteChar) {
+    let value = "";
+    while (this.current < this.expression.length && this.expression[this.current] !== quoteChar) {
+      value += this.next();
+    }
+    if (this.current >= this.expression.length) {
+      throw new Error(`Unterminated string literal`);
+    }
+    this.next();
+    return new XPathToken("STRING", value);
+  }
+  parseNumber(firstCharacter) {
+    let characters = firstCharacter;
+    while (this.current < this.expression.length && this.isNumber(this.expression[this.current]) && this.expression[this.current] !== ".") {
+      characters += this.next();
+    }
+    if (this.current < this.expression.length && this.expression[this.current] === ".") {
+      characters += this.next();
+      while (this.current < this.expression.length && this.isNumber(this.expression[this.current])) {
+        characters += this.next();
+      }
+    }
+    if (characters.length > 0) {
+      return new XPathToken("NUMBER", characters);
+    }
+    throw new Error(`Invalid number: ${characters}`);
+  }
+  scanToken() {
+    const char = this.next();
+    if (this.isWhitespace(char)) {
+      return null;
+    }
+    switch (char) {
+      case "@":
+        return new XPathToken("AT", char);
+      case "$":
+        return new XPathToken("DOLLAR", char);
+      case "|":
+        return new XPathToken("PIPE", char);
+      case "{":
+        return new XPathToken("OPEN_CURLY_BRACKET", char);
+      case "}":
+        return new XPathToken("CLOSE_CURLY_BRACKET", char);
+      case "[":
+        return new XPathToken("OPEN_SQUARE_BRACKET", char);
+      case "]":
+        return new XPathToken("CLOSE_SQUARE_BRACKET", char);
+      case "(":
+        return new XPathToken("OPEN_PAREN", char);
+      case ")":
+        return new XPathToken("CLOSE_PAREN", char);
+      case "+":
+        return new XPathToken("PLUS", char);
+      case "-":
+        return new XPathToken("MINUS", char);
+      case "*":
+        return new XPathToken("ASTERISK", char);
+      case ",":
+        return new XPathToken("COMMA", char);
+      // Tokens that may be single or double character
+      case ".":
+        if (this.match(".")) {
+          return new XPathToken("DOT_DOT", "..");
+        }
+        if (this.peek() && this.isNumber(this.peek())) {
+          return this.parseNumber(char);
+        }
+        return new XPathToken("DOT", char);
+      case "/":
+        if (this.match("/")) {
+          return new XPathToken("DOUBLE_SLASH", "//");
+        }
+        return new XPathToken("SLASH", char);
+      case ":":
+        if (this.match(":")) {
+          return new XPathToken("COLON_COLON", "::");
+        }
+        return new XPathToken("COLON", char);
+      case "=":
+        return new XPathToken("EQUALS", char);
+      case "!":
+        if (this.match("=")) {
+          return new XPathToken("NOT_EQUALS", "!=");
+        }
+        throw new Error(`Unexpected character: ${char}`);
+      case "<":
+        if (this.match("=")) {
+          return new XPathToken("LESS_THAN_OR_EQUAL", "<=");
+        }
+        return new XPathToken("LESS_THAN", char);
+      case ">":
+        if (this.match("=")) {
+          return new XPathToken("GREATER_THAN_OR_EQUAL", ">=");
+        }
+        return new XPathToken("GREATER_THAN", char);
+      // String literals
+      case "'":
+        return this.parseString("'");
+      case '"':
+        return this.parseString('"');
+      default:
+        if (this.isNumber(char)) {
+          return this.parseNumber(char);
+        }
+        if (this.isAlpha(char)) {
+          return this.parseIdentifier(char);
+        }
+        throw new Error(`Unexpected character: ${char}`);
+    }
+  }
+  scan(expression) {
+    this.expression = expression;
+    this.tokens = [];
+    this.current = 0;
+    while (this.current < this.expression.length) {
+      const token = this.scanToken();
+      if (token !== null) {
+        this.tokens.push(token);
+      }
+    }
+    return this.tokens;
+  }
+};
+
+// src/xpath/lib/src/expressions/expression.ts
+var XPathExpression = class {
+};
+
+// src/xpath/lib/src/expressions/literal-expression.ts
+var XPathStringLiteral = class extends XPathExpression {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  evaluate(_context) {
+    return this.value;
+  }
+};
+var XPathNumberLiteral = class extends XPathExpression {
+  constructor(value) {
+    super();
+    this.value = value;
+  }
+  evaluate(_context) {
+    return this.value;
+  }
+};
+
+// src/xpath/lib/src/expressions/variable-reference-expression.ts
+var XPathVariableReference = class extends XPathExpression {
+  constructor(name) {
+    super();
+    this.name = name;
+  }
+  evaluate(context) {
+    if (!context.variables) {
+      throw new Error(`Variable $${this.name} is not defined`);
+    }
+    if (!(this.name in context.variables)) {
+      throw new Error(`Variable $${this.name} is not defined`);
+    }
+    return context.variables[this.name];
+  }
+};
+
+// src/xpath/lib/src/expressions/unary-expression.ts
+var XPathUnaryExpression = class extends XPathExpression {
+  constructor(operator, operand) {
+    super();
+    this.operator = operator;
+    this.operand = operand;
+  }
+  evaluate(context) {
+    const value = this.operand.evaluate(context);
+    switch (this.operator) {
+      case "-":
+        return -Number(value);
+      default:
+        throw new Error(`Unknown unary operator: ${this.operator}`);
+    }
+  }
+};
+
+// src/xpath/lib/src/expressions/binary-expression.ts
+var XPathBinaryExpression = class extends XPathExpression {
+  constructor(left, right, operator) {
+    super();
+    this.left = left;
+    this.right = right;
+    this.operator = operator;
+  }
+  evaluate(context) {
+    const leftValue = this.left.evaluate(context);
+    const rightValue = this.right.evaluate(context);
+    return this.compare(leftValue, rightValue, this.operator);
+  }
+  /**
+   * XPath comparison rules:
+   * - If both are node-sets: compare each node in left with each node in right
+   * - If one is node-set and other is string: convert node-set to strings and compare
+   * - If one is node-set and other is number: convert node-set to numbers and compare
+   * - If one is node-set and other is boolean: convert node-set to boolean and compare
+   * - Otherwise, convert both to numbers for numeric comparison, or strings for equality
+   */
+  compare(left, right, operator) {
+    const leftIsNodeSet = Array.isArray(left);
+    const rightIsNodeSet = Array.isArray(right);
+    if (leftIsNodeSet && rightIsNodeSet) {
+      return this.compareNodeSets(left, right, operator);
+    }
+    if (leftIsNodeSet) {
+      return this.compareNodeSetToValue(left, right, operator);
+    }
+    if (rightIsNodeSet) {
+      return this.compareValueToNodeSet(left, right, operator);
+    }
+    return this.comparePrimitives(left, right, operator);
+  }
+  compareNodeSets(left, right, operator) {
+    for (const leftNode of left) {
+      const leftStr = this.getStringValue(leftNode);
+      for (const rightNode of right) {
+        const rightStr = this.getStringValue(rightNode);
+        if (this.comparePrimitives(leftStr, rightStr, operator)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+  compareNodeSetToValue(nodeSet, value, operator) {
+    for (const node of nodeSet) {
+      const nodeValue = typeof value === "number" ? Number(this.getStringValue(node)) : this.getStringValue(node);
+      if (this.comparePrimitives(nodeValue, value, operator)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  compareValueToNodeSet(value, nodeSet, operator) {
+    for (const node of nodeSet) {
+      const nodeValue = typeof value === "number" ? Number(this.getStringValue(node)) : this.getStringValue(node);
+      if (this.comparePrimitives(value, nodeValue, operator)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  comparePrimitives(left, right, operator) {
+    switch (operator) {
+      case "=":
+        return left == right;
+      // Use loose equality for type coercion
+      case "!=":
+        return left != right;
+      case "<":
+        return Number(left) < Number(right);
+      case ">":
+        return Number(left) > Number(right);
+      case "<=":
+        return Number(left) <= Number(right);
+      case ">=":
+        return Number(left) >= Number(right);
+      default:
+        throw new Error(`Unknown operator: ${operator}`);
+    }
+  }
+  getStringValue(node) {
+    if (!node) return "";
+    if (node.nodeType === 3 || node.nodeType === 2) {
+      return node.nodeValue || node.textContent || "";
+    }
+    if (node.textContent !== void 0) {
+      return node.textContent;
+    }
+    if (node.childNodes) {
+      let text = "";
+      for (const child of Array.from(node.childNodes)) {
+        if (child.nodeType === 3) {
+          text += child.nodeValue || "";
+        } else if (child.nodeType === 1) {
+          text += this.getStringValue(child);
+        }
+      }
+      return text;
+    }
+    return String(node);
+  }
+};
+
+// src/xpath/lib/src/expressions/arithmetic-expression.ts
+var XPathArithmeticExpression = class extends XPathExpression {
+  constructor(left, right, operator) {
+    super();
+    this.left = left;
+    this.right = right;
+    this.operator = operator;
+  }
+  evaluate(context) {
+    const leftValue = Number(this.left.evaluate(context));
+    const rightValue = Number(this.right.evaluate(context));
+    switch (this.operator) {
+      case "+":
+        return leftValue + rightValue;
+      case "-":
+        return leftValue - rightValue;
+      case "*":
+        return leftValue * rightValue;
+      case "div":
+        return leftValue / rightValue;
+      case "mod":
+        return leftValue % rightValue;
+      default:
+        throw new Error(`Unknown arithmetic operator: ${this.operator}`);
+    }
+  }
+};
+
+// src/xpath/lib/src/expressions/logical-expression.ts
+var XPathLogicalExpression = class extends XPathExpression {
+  constructor(left, right, operator) {
+    super();
+    this.left = left;
+    this.right = right;
+    this.operator = operator;
+  }
+  toBoolean(value) {
+    if (typeof value === "boolean") {
+      return value;
+    }
+    if (typeof value === "number") {
+      return value !== 0 && !isNaN(value);
+    }
+    if (typeof value === "string") {
+      return value.length > 0;
+    }
+    if (Array.isArray(value)) {
+      return value.length > 0;
+    }
+    return !!value;
+  }
+  evaluate(context) {
+    const leftValue = this.toBoolean(this.left.evaluate(context));
+    if (this.operator === "and") {
+      if (!leftValue) return false;
+      return this.toBoolean(this.right.evaluate(context));
+    }
+    if (this.operator === "or") {
+      if (leftValue) return true;
+      return this.toBoolean(this.right.evaluate(context));
+    }
+    throw new Error(`Unknown logical operator: ${this.operator}`);
+  }
+};
+
+// src/xpath/lib/src/expressions/step-expression.ts
+var XPathStep = class extends XPathExpression {
+  constructor(axis, nodeTest, predicates = []) {
+    super();
+    this.axis = axis;
+    this.nodeTest = nodeTest;
+    this.predicates = predicates;
+  }
+  evaluate(context) {
+    const node = context == null ? void 0 : context.node;
+    if (!node) return [];
+    let candidates = this.getNodesByAxis(node, context);
+    candidates = candidates.filter((n) => this.matchesNodeTest(n, context));
+    candidates = this.applyPredicates(candidates, context);
+    return candidates;
+  }
+  getNodesByAxis(node, context) {
+    switch (this.axis) {
+      case "child":
+        return this.getChildNodes(node);
+      case "parent":
+        return node.parentNode ? [node.parentNode] : [];
+      case "self":
+        return [node];
+      case "attribute":
+        if (node.attributes) {
+          return Array.from(node.attributes);
+        }
+        return Array.from(node.childNodes || []).filter((n) => n.nodeType === 2);
+      case "descendant":
+        return this.getDescendants(node, false);
+      case "descendant-or-self":
+        return this.getDescendants(node, true);
+      case "ancestor":
+        return this.getAncestors(node, false);
+      case "ancestor-or-self":
+        return this.getAncestors(node, true);
+      case "following-sibling":
+        return this.getFollowingSiblings(node);
+      case "preceding-sibling":
+        return this.getPrecedingSiblings(node);
+      case "following":
+        return this.getFollowing(node);
+      case "preceding":
+        return this.getPreceding(node);
+      case "namespace":
+        return [];
+      case "self-and-siblings":
+        if (context == null ? void 0 : context.nodeList) {
+          return context.nodeList.filter((n) => n.nodeType !== 2);
+        }
+        return [node];
+      default:
+        return [];
+    }
+  }
+  /**
+   * Get child nodes excluding attribute nodes.
+   * XNode stores attributes in childNodes, but XPath child axis doesn't include them.
+   */
+  getChildNodes(node) {
+    const children = Array.from(node.childNodes || []);
+    return children.filter((n) => n.nodeType !== 2);
+  }
+  getDescendants(node, includeSelf) {
+    const result = [];
+    if (includeSelf) result.push(node);
+    const walk = (n) => {
+      for (const child of this.getChildNodes(n)) {
+        result.push(child);
+        walk(child);
+      }
+    };
+    walk(node);
+    return result;
+  }
+  getAncestors(node, includeSelf) {
+    const result = [];
+    if (includeSelf) result.push(node);
+    let current = node.parentNode;
+    while (current) {
+      result.push(current);
+      current = current.parentNode;
+    }
+    return result;
+  }
+  getFollowingSiblings(node) {
+    const result = [];
+    let sibling = node.nextSibling;
+    while (sibling) {
+      result.push(sibling);
+      sibling = sibling.nextSibling;
+    }
+    return result;
+  }
+  getPrecedingSiblings(node) {
+    const result = [];
+    let sibling = node.previousSibling;
+    while (sibling) {
+      result.unshift(sibling);
+      sibling = sibling.previousSibling;
+    }
+    return result;
+  }
+  getFollowing(node) {
+    const result = [];
+    let sibling = node.nextSibling;
+    while (sibling) {
+      result.push(sibling);
+      result.push(...this.getDescendants(sibling, false));
+      sibling = sibling.nextSibling;
+    }
+    let ancestor = node.parentNode;
+    while (ancestor) {
+      sibling = ancestor.nextSibling;
+      while (sibling) {
+        result.push(sibling);
+        result.push(...this.getDescendants(sibling, false));
+        sibling = sibling.nextSibling;
+      }
+      ancestor = ancestor.parentNode;
+    }
+    return result;
+  }
+  getPreceding(node) {
+    const result = [];
+    let sibling = node.previousSibling;
+    while (sibling) {
+      result.unshift(sibling);
+      const descendants = this.getDescendants(sibling, false);
+      result.unshift(...descendants);
+      sibling = sibling.previousSibling;
+    }
+    let ancestor = node.parentNode;
+    while (ancestor) {
+      sibling = ancestor.previousSibling;
+      while (sibling) {
+        result.unshift(sibling);
+        const descendants = this.getDescendants(sibling, false);
+        result.unshift(...descendants);
+        sibling = sibling.previousSibling;
+      }
+      ancestor = ancestor.parentNode;
+    }
+    return result;
+  }
+  matchesNodeTest(node, context) {
+    var _a, _b;
+    const nodeType = node.nodeType;
+    switch (this.nodeTest.type) {
+      case "wildcard":
+        if (this.nodeTest.name && this.nodeTest.name.endsWith(":*")) {
+          const prefix = this.nodeTest.name.slice(0, -2);
+          const nsUri = (_a = context == null ? void 0 : context.namespaces) == null ? void 0 : _a[prefix];
+          if (!nsUri) return false;
+          const nodeNsUri = node.namespaceURI || node.namespaceUri || "";
+          return (nodeType === 1 || nodeType === 2) && nodeNsUri === nsUri;
+        }
+        return nodeType === 1 || nodeType === 2;
+      case "name":
+        if (nodeType !== 1 && nodeType !== 2) return false;
+        const testName = this.nodeTest.name;
+        const colonIndex = testName.indexOf(":");
+        if (colonIndex > 0) {
+          const prefix = testName.substring(0, colonIndex);
+          const localName = testName.substring(colonIndex + 1);
+          const nsUri = (_b = context == null ? void 0 : context.namespaces) == null ? void 0 : _b[prefix];
+          if (!nsUri) {
+            return false;
+          }
+          const nodeLocalName = node.localName || node.nodeName;
+          const nodeNsUri = node.namespaceURI || node.namespaceUri || "";
+          return nodeLocalName === localName && nodeNsUri === nsUri;
+        }
+        const nodeName = node.localName || node.nodeName;
+        return nodeName === testName;
+      case "node-type":
+        switch (this.nodeTest.nodeType) {
+          case "node":
+            return true;
+          // matches any node
+          case "text":
+            return nodeType === 3;
+          // text node
+          case "comment":
+            return nodeType === 8;
+          // comment node
+          case "processing-instruction":
+            return nodeType === 7;
+          // processing instruction
+          default:
+            return false;
+        }
+      case "processing-instruction":
+        if (nodeType !== 7) return false;
+        if (this.nodeTest.name) {
+          return node.target === this.nodeTest.name;
+        }
+        return true;
+      default:
+        return false;
+    }
+  }
+  applyPredicates(nodes, context) {
+    let result = nodes;
+    for (const predicate of this.predicates) {
+      const filtered = [];
+      const size = result.length;
+      for (let i = 0; i < result.length; i++) {
+        const predicateContext = __spreadProps(__spreadValues({}, context), {
+          node: result[i],
+          position: i + 1,
+          size
+        });
+        const predicateResult = predicate.evaluate(predicateContext);
+        if (typeof predicateResult === "number") {
+          if (predicateResult === i + 1) {
+            filtered.push(result[i]);
+          }
+        } else if (this.toBoolean(predicateResult)) {
+          filtered.push(result[i]);
+        }
+      }
+      result = filtered;
+    }
+    return result;
+  }
+  toBoolean(value) {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "number") return value !== 0 && !isNaN(value);
+    if (typeof value === "string") return value.length > 0;
+    if (Array.isArray(value)) return value.length > 0;
+    return !!value;
+  }
+};
+
+// src/xpath/lib/src/expressions/predicate-expression.ts
+var XPathPredicate = class extends XPathExpression {
+  constructor(expression) {
+    super();
+    this.expression = expression;
+  }
+  evaluate(context) {
+    return this.expression.evaluate(context);
+  }
+  test(context) {
+    const result = this.evaluate(context);
+    if (typeof result === "number") {
+      return result === (context == null ? void 0 : context.position);
+    }
+    return this.toBoolean(result);
+  }
+  toBoolean(value) {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "number") return value !== 0 && !isNaN(value);
+    if (typeof value === "string") return value.length > 0;
+    if (Array.isArray(value)) return value.length > 0;
+    return !!value;
+  }
+};
+
+// src/xpath/lib/src/expressions/location-path-expression.ts
+var XPathLocationPath = class extends XPathExpression {
+  constructor(steps, absolute = false) {
+    super();
+    this.steps = steps;
+    this.absolute = absolute;
+  }
+  evaluate(context) {
+    let nodes;
+    if (this.absolute) {
+      const root = this.getDocumentRoot(context == null ? void 0 : context.node);
+      nodes = root ? [root] : [];
+    } else {
+      nodes = (context == null ? void 0 : context.node) ? [context.node] : [];
+    }
+    for (const step of this.steps) {
+      const nextNodes = [];
+      for (const node of nodes) {
+        const stepContext = __spreadProps(__spreadValues({}, context), { node });
+        const result = step.evaluate(stepContext);
+        nextNodes.push(...result);
+      }
+      nodes = this.uniqueNodes(nextNodes);
+    }
+    return nodes;
+  }
+  getDocumentRoot(node) {
+    if (!node) return null;
+    let root = node;
+    while (root.parentNode) {
+      root = root.parentNode;
+    }
+    return root;
+  }
+  uniqueNodes(nodes) {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const node of nodes) {
+      if (!seen.has(node)) {
+        seen.add(node);
+        result.push(node);
+      }
+    }
+    return result;
+  }
+};
+
+// src/xpath/lib/src/expressions/filter-expression.ts
+var XPathFilterExpression = class extends XPathExpression {
+  constructor(expression, predicate) {
+    super();
+    this.expression = expression;
+    this.predicate = predicate;
+  }
+  evaluate(context) {
+    return [];
+  }
+};
+
+// src/xpath/lib/src/expressions/union-expression.ts
+var XPathUnionExpression = class extends XPathExpression {
+  constructor(left, right) {
+    super();
+    this.left = left;
+    this.right = right;
+  }
+  evaluate(context) {
+    const leftResult = this.left.evaluate(context);
+    const rightResult = this.right.evaluate(context);
+    const leftNodes = Array.isArray(leftResult) ? leftResult : [];
+    const rightNodes = Array.isArray(rightResult) ? rightResult : [];
+    return this.unionNodes(leftNodes, rightNodes);
+  }
+  unionNodes(left, right) {
+    const seen = /* @__PURE__ */ new Set();
+    const result = [];
+    for (const node of left) {
+      if (!seen.has(node)) {
+        seen.add(node);
+        result.push(node);
+      }
+    }
+    for (const node of right) {
+      if (!seen.has(node)) {
+        seen.add(node);
+        result.push(node);
+      }
+    }
+    return this.sortByDocumentOrder(result);
+  }
+  sortByDocumentOrder(nodes) {
+    return nodes.sort((a, b) => {
+      if (a === b) return 0;
+      if (typeof a.compareDocumentPosition === "function") {
+        const position = a.compareDocumentPosition(b);
+        if (position & 4) return -1;
+        if (position & 2) return 1;
+      }
+      return 0;
+    });
+  }
+};
+
+// src/xpath/lib/src/expressions/function-call-expression.ts
+var XPathFunctionCall = class extends XPathExpression {
+  constructor(name, args) {
+    super();
+    this.name = name;
+    this.args = args;
+  }
+  evaluate(context) {
+    var _a, _b;
+    const evaluatedArgs = this.args.map((arg) => arg.evaluate(context));
+    switch (this.name) {
+      // Node set functions
+      case "last":
+        return (_a = context.size) != null ? _a : 0;
+      case "position":
+        return (_b = context.position) != null ? _b : 0;
+      case "count":
+        return Array.isArray(evaluatedArgs[0]) ? evaluatedArgs[0].length : 0;
+      case "local-name":
+        return this.localName(evaluatedArgs, context);
+      case "namespace-uri":
+        return this.namespaceUri(evaluatedArgs, context);
+      case "name":
+        return this.nodeName(evaluatedArgs, context);
+      // String functions
+      case "string":
+        return this.stringValue(evaluatedArgs, context);
+      case "concat":
+        return evaluatedArgs.map(String).join("");
+      case "starts-with":
+        return String(evaluatedArgs[0]).startsWith(String(evaluatedArgs[1]));
+      case "contains":
+        return String(evaluatedArgs[0]).includes(String(evaluatedArgs[1]));
+      case "substring-before":
+        return this.substringBefore(evaluatedArgs);
+      case "substring-after":
+        return this.substringAfter(evaluatedArgs);
+      case "substring":
+        return this.substring(evaluatedArgs);
+      case "string-length":
+        return this.stringLength(evaluatedArgs, context);
+      case "normalize-space":
+        return this.normalizeSpace(evaluatedArgs, context);
+      case "translate":
+        return this.translate(evaluatedArgs);
+      // Boolean functions
+      case "boolean":
+        return this.toBoolean(evaluatedArgs[0]);
+      case "not":
+        return !this.toBoolean(evaluatedArgs[0]);
+      case "true":
+        return true;
+      case "false":
+        return false;
+      case "lang":
+        return this.lang(evaluatedArgs, context);
+      // Number functions
+      case "number":
+        return this.toNumber(evaluatedArgs, context);
+      case "sum":
+        return this.sum(evaluatedArgs);
+      case "floor":
+        return Math.floor(Number(evaluatedArgs[0]));
+      case "ceiling":
+        return Math.ceil(Number(evaluatedArgs[0]));
+      case "round":
+        return Math.round(Number(evaluatedArgs[0]));
+      default:
+        if (context.functions && typeof context.functions[this.name] === "function") {
+          return context.functions[this.name](...evaluatedArgs);
+        }
+        throw new Error(`Unknown function: ${this.name}`);
+    }
+  }
+  toBoolean(value) {
+    if (typeof value === "boolean") return value;
+    if (typeof value === "number") return value !== 0 && !isNaN(value);
+    if (typeof value === "string") return value.length > 0;
+    if (Array.isArray(value)) return value.length > 0;
+    return !!value;
+  }
+  toNumber(args, context) {
+    if (args.length === 0) {
+      return Number(this.stringValue([], context));
+    }
+    return Number(args[0]);
+  }
+  stringValue(args, context) {
+    var _a, _b, _c, _d;
+    if (args.length === 0) {
+      return (_b = (_a = context.node) == null ? void 0 : _a.textContent) != null ? _b : "";
+    }
+    const value = args[0];
+    if (Array.isArray(value) && value.length > 0) {
+      return (_d = (_c = value[0]) == null ? void 0 : _c.textContent) != null ? _d : String(value[0]);
+    }
+    return String(value);
+  }
+  stringLength(args, context) {
+    if (args.length === 0) {
+      return this.stringValue([], context).length;
+    }
+    return String(args[0]).length;
+  }
+  normalizeSpace(args, context) {
+    const str = args.length === 0 ? this.stringValue([], context) : String(args[0]);
+    return str.trim().replace(/\s+/g, " ");
+  }
+  substringBefore(args) {
+    const str = String(args[0]);
+    const search = String(args[1]);
+    const index = str.indexOf(search);
+    return index === -1 ? "" : str.substring(0, index);
+  }
+  substringAfter(args) {
+    const str = String(args[0]);
+    const search = String(args[1]);
+    const index = str.indexOf(search);
+    return index === -1 ? "" : str.substring(index + search.length);
+  }
+  substring(args) {
+    const str = String(args[0]);
+    const start = Math.round(Number(args[1])) - 1;
+    if (args.length === 2) {
+      return str.substring(Math.max(0, start));
+    }
+    const length = Math.round(Number(args[2]));
+    const adjustedStart = Math.max(0, start);
+    const adjustedLength = Math.min(length - (adjustedStart - start), str.length - adjustedStart);
+    return str.substring(adjustedStart, adjustedStart + adjustedLength);
+  }
+  translate(args) {
+    const str = String(args[0]);
+    const from = String(args[1]);
+    const to = String(args[2]);
+    let result = "";
+    for (const char of str) {
+      const index = from.indexOf(char);
+      if (index === -1) {
+        result += char;
+      } else if (index < to.length) {
+        result += to[index];
+      }
+    }
+    return result;
+  }
+  localName(args, context) {
+    var _a;
+    const node = this.getNodeArg(args, context);
+    return (_a = node == null ? void 0 : node.localName) != null ? _a : "";
+  }
+  namespaceUri(args, context) {
+    var _a;
+    const node = this.getNodeArg(args, context);
+    return (_a = node == null ? void 0 : node.namespaceURI) != null ? _a : "";
+  }
+  nodeName(args, context) {
+    var _a;
+    const node = this.getNodeArg(args, context);
+    return (_a = node == null ? void 0 : node.nodeName) != null ? _a : "";
+  }
+  getNodeArg(args, context) {
+    if (args.length > 0 && Array.isArray(args[0]) && args[0].length > 0) {
+      return args[0][0];
+    }
+    return context.node;
+  }
+  sum(args) {
+    const nodeSet = args[0];
+    if (!Array.isArray(nodeSet)) return 0;
+    return nodeSet.reduce((acc, node) => {
+      var _a;
+      const value = Number((_a = node == null ? void 0 : node.textContent) != null ? _a : node);
+      return acc + (isNaN(value) ? 0 : value);
+    }, 0);
+  }
+  lang(args, context) {
+    var _a, _b;
+    const targetLang = String(args[0]).toLowerCase();
+    let node = context.node;
+    while (node) {
+      const lang = ((_a = node.getAttribute) == null ? void 0 : _a.call(node, "xml:lang")) || ((_b = node.getAttribute) == null ? void 0 : _b.call(node, "lang"));
+      if (lang) {
+        const nodeLang = lang.toLowerCase();
+        return nodeLang === targetLang || nodeLang.startsWith(targetLang + "-");
+      }
+      node = node.parentNode;
+    }
+    return false;
+  }
+};
+
+// src/xpath/lib/src/parser.ts
+var XPathParser = class {
+  constructor() {
+    this.tokens = [];
+    this.current = 0;
+  }
+  parse(tokens) {
+    this.tokens = tokens;
+    this.current = 0;
+    if (tokens.length === 0) {
+      throw new Error("Empty expression");
+    }
+    const expr = this.parseExpr();
+    if (!this.isAtEnd()) {
+      throw new Error(`Unexpected token: ${this.peek().lexeme}`);
+    }
+    return expr;
+  }
+  // ==================== Token Management ====================
+  peek() {
+    return this.tokens[this.current];
+  }
+  peekNext() {
+    return this.tokens[this.current + 1];
+  }
+  previous() {
+    return this.tokens[this.current - 1];
+  }
+  isAtEnd() {
+    return this.current >= this.tokens.length;
+  }
+  advance() {
+    if (!this.isAtEnd()) this.current++;
+    return this.previous();
+  }
+  check(type) {
+    if (this.isAtEnd()) return false;
+    return this.peek().type === type;
+  }
+  checkLexeme(lexeme) {
+    if (this.isAtEnd()) return false;
+    return this.peek().lexeme === lexeme;
+  }
+  match(...types) {
+    for (const type of types) {
+      if (this.check(type)) {
+        this.advance();
+        return true;
+      }
+    }
+    return false;
+  }
+  consume(type, message) {
+    var _a, _b;
+    if (this.check(type)) return this.advance();
+    throw new Error(`${message}. Got: ${(_b = (_a = this.peek()) == null ? void 0 : _a.lexeme) != null ? _b : "EOF"}`);
+  }
+  // ==================== Expression Parsing ====================
+  parseExpr() {
+    return this.parseOrExpr();
+  }
+  parseOrExpr() {
+    let left = this.parseAndExpr();
+    while (this.check("OPERATOR") && this.peek().lexeme === "or") {
+      this.advance();
+      const right = this.parseAndExpr();
+      left = new XPathLogicalExpression(left, right, "or");
+    }
+    return left;
+  }
+  parseAndExpr() {
+    let left = this.parseEqualityExpr();
+    while (this.check("OPERATOR") && this.peek().lexeme === "and") {
+      this.advance();
+      const right = this.parseEqualityExpr();
+      left = new XPathLogicalExpression(left, right, "and");
+    }
+    return left;
+  }
+  parseEqualityExpr() {
+    let left = this.parseRelationalExpr();
+    while (this.match("EQUALS", "NOT_EQUALS")) {
+      const operator = this.previous().lexeme;
+      const right = this.parseRelationalExpr();
+      left = new XPathBinaryExpression(left, right, operator);
+    }
+    return left;
+  }
+  parseRelationalExpr() {
+    let left = this.parseAdditiveExpr();
+    while (this.match("LESS_THAN", "GREATER_THAN", "LESS_THAN_OR_EQUAL", "GREATER_THAN_OR_EQUAL")) {
+      const operator = this.previous().lexeme;
+      const right = this.parseAdditiveExpr();
+      left = new XPathBinaryExpression(left, right, operator);
+    }
+    return left;
+  }
+  parseAdditiveExpr() {
+    let left = this.parseMultiplicativeExpr();
+    while (this.match("PLUS", "MINUS")) {
+      const operator = this.previous().lexeme;
+      const right = this.parseMultiplicativeExpr();
+      left = new XPathArithmeticExpression(left, right, operator);
+    }
+    return left;
+  }
+  parseMultiplicativeExpr() {
+    let left = this.parseUnaryExpr();
+    while (true) {
+      if (this.match("ASTERISK")) {
+        const right = this.parseUnaryExpr();
+        left = new XPathArithmeticExpression(left, right, "*");
+      } else if (this.check("OPERATOR") && (this.peek().lexeme === "div" || this.peek().lexeme === "mod")) {
+        const operator = this.advance().lexeme;
+        const right = this.parseUnaryExpr();
+        left = new XPathArithmeticExpression(left, right, operator);
+      } else {
+        break;
+      }
+    }
+    return left;
+  }
+  parseUnaryExpr() {
+    if (this.match("MINUS")) {
+      const operand = this.parseUnaryExpr();
+      return new XPathUnaryExpression("-", operand);
+    }
+    return this.parseUnionExpr();
+  }
+  parseUnionExpr() {
+    let left = this.parsePathExpr();
+    while (this.match("PIPE")) {
+      const right = this.parsePathExpr();
+      left = new XPathUnionExpression(left, right);
+    }
+    return left;
+  }
+  // ==================== Path Expression Parsing ====================
+  parsePathExpr() {
+    if (this.check("SLASH") || this.check("DOUBLE_SLASH")) {
+      return this.parseLocationPath();
+    }
+    if (this.isStepStart()) {
+      return this.parseLocationPath();
+    }
+    const filterExpr = this.parseFilterExpr();
+    if (this.match("SLASH", "DOUBLE_SLASH")) {
+      const isDescendant = this.previous().type === "DOUBLE_SLASH";
+      const steps = this.parseRelativeLocationPath();
+      if (isDescendant) {
+        steps.unshift(new XPathStep("descendant-or-self", { type: "node-type", nodeType: "node" }));
+      }
+      return new XPathFilterExpression(filterExpr, new XPathLocationPath(steps, false));
+    }
+    return filterExpr;
+  }
+  isStepStart() {
+    if (this.isAtEnd()) return false;
+    const token = this.peek();
+    if (token.type === "DOT" || token.type === "DOT_DOT") return true;
+    if (token.type === "AT") return true;
+    if (token.type === "LOCATION") return true;
+    if (token.type === "NODE_TYPE") return true;
+    if (token.type === "ASTERISK") return true;
+    if (token.type === "IDENTIFIER" || token.type === "OPERATOR" || token.type === "FUNCTION") {
+      const next = this.peekNext();
+      return !next || next.type !== "OPEN_PAREN";
+    }
+    return false;
+  }
+  parseLocationPath() {
+    let absolute = false;
+    const steps = [];
+    if (this.match("SLASH")) {
+      absolute = true;
+      if (!this.isAtEnd() && this.isStepStart()) {
+        steps.push(...this.parseRelativeLocationPath());
+      }
+    } else if (this.match("DOUBLE_SLASH")) {
+      absolute = true;
+      steps.push(new XPathStep("descendant-or-self", { type: "node-type", nodeType: "node" }));
+      steps.push(...this.parseRelativeLocationPath());
+    } else {
+      steps.push(...this.parseRelativeLocationPath());
+    }
+    return new XPathLocationPath(steps, absolute);
+  }
+  parseRelativeLocationPath() {
+    const steps = [];
+    steps.push(this.parseStep());
+    while (this.match("SLASH", "DOUBLE_SLASH")) {
+      const isDescendant = this.previous().type === "DOUBLE_SLASH";
+      if (isDescendant) {
+        steps.push(new XPathStep("descendant-or-self", { type: "node-type", nodeType: "node" }));
+      }
+      steps.push(this.parseStep());
+    }
+    return steps;
+  }
+  parseStep() {
+    if (this.match("DOT")) {
+      return new XPathStep("self", { type: "node-type", nodeType: "node" });
+    }
+    if (this.match("DOT_DOT")) {
+      return new XPathStep("parent", { type: "node-type", nodeType: "node" });
+    }
+    let axis = "child";
+    if (this.match("AT")) {
+      axis = "attribute";
+    } else if (this.check("LOCATION")) {
+      const next = this.peekNext();
+      if (next && next.type === "COLON_COLON") {
+        axis = this.advance().lexeme;
+        this.advance();
+      }
+    }
+    const nodeTest = this.parseNodeTest();
+    const predicates = this.parsePredicates();
+    return new XPathStep(axis, nodeTest, predicates);
+  }
+  parseNodeTest() {
+    var _a, _b;
+    if (this.match("ASTERISK")) {
+      return { type: "wildcard" };
+    }
+    if (this.check("NODE_TYPE")) {
+      const next = this.peekNext();
+      if (next && next.type === "OPEN_PAREN") {
+        const nodeType = this.advance().lexeme;
+        this.advance();
+        if (nodeType === "processing-instruction" && this.check("STRING")) {
+          const name = this.advance().lexeme;
+          this.consume("CLOSE_PAREN", "Expected ')' after processing-instruction name");
+          return { type: "processing-instruction", name };
+        }
+        this.consume("CLOSE_PAREN", "Expected ')' after node type");
+        return { type: "node-type", nodeType };
+      }
+    }
+    if (this.check("IDENTIFIER") || this.check("LOCATION") || this.check("FUNCTION") || this.check("NODE_TYPE") || this.check("OPERATOR")) {
+      const name = this.advance().lexeme;
+      if (this.match("COLON")) {
+        if (this.match("ASTERISK")) {
+          return { type: "wildcard", name: `${name}:*` };
+        }
+        if (this.check("IDENTIFIER") || this.check("LOCATION") || this.check("FUNCTION") || this.check("NODE_TYPE") || this.check("OPERATOR")) {
+          const localName = this.advance().lexeme;
+          return { type: "name", name: `${name}:${localName}` };
+        }
+        throw new Error("Expected local name after namespace prefix");
+      }
+      return { type: "name", name };
+    }
+    throw new Error(`Expected node test, got: ${(_b = (_a = this.peek()) == null ? void 0 : _a.lexeme) != null ? _b : "EOF"}`);
+  }
+  parsePredicates() {
+    const predicates = [];
+    while (this.match("OPEN_SQUARE_BRACKET")) {
+      const expr = this.parseExpr();
+      this.consume("CLOSE_SQUARE_BRACKET", "Expected ']' after predicate");
+      predicates.push(new XPathPredicate(expr));
+    }
+    return predicates;
+  }
+  // ==================== Filter Expression Parsing ====================
+  parseFilterExpr() {
+    let expr = this.parsePrimaryExpr();
+    while (this.check("OPEN_SQUARE_BRACKET")) {
+      const predicates = this.parsePredicates();
+      for (const predicate of predicates) {
+        expr = new XPathFilterExpression(expr, predicate);
+      }
+    }
+    return expr;
+  }
+  parsePrimaryExpr() {
+    var _a, _b;
+    if (this.match("DOLLAR")) {
+      const name = this.consume("IDENTIFIER", "Expected variable name after $").lexeme;
+      return new XPathVariableReference(name);
+    }
+    if (this.match("OPEN_PAREN")) {
+      const expr = this.parseExpr();
+      this.consume("CLOSE_PAREN", "Expected ')' after expression");
+      return expr;
+    }
+    if (this.check("STRING")) {
+      const value = this.advance().lexeme;
+      return new XPathStringLiteral(value);
+    }
+    if (this.check("NUMBER")) {
+      const value = parseFloat(this.advance().lexeme);
+      return new XPathNumberLiteral(value);
+    }
+    if (this.check("FUNCTION") || this.check("IDENTIFIER")) {
+      const next = this.peekNext();
+      if (next && next.type === "OPEN_PAREN") {
+        return this.parseFunctionCall();
+      }
+    }
+    throw new Error(`Unexpected token in primary expression: ${(_b = (_a = this.peek()) == null ? void 0 : _a.lexeme) != null ? _b : "EOF"}`);
+  }
+  parseFunctionCall() {
+    const name = this.advance().lexeme;
+    this.consume("OPEN_PAREN", "Expected '(' after function name");
+    const args = [];
+    if (!this.check("CLOSE_PAREN")) {
+      do {
+        args.push(this.parseExpr());
+      } while (this.match("COMMA"));
+    }
+    this.consume("CLOSE_PAREN", "Expected ')' after function arguments");
+    return new XPathFunctionCall(name, args);
+  }
+};
+
+// src/xpath/lib/src/context.ts
+function createContext(node, options) {
+  return __spreadValues({
+    node,
+    position: 1,
+    size: 1
+  }, options);
+}
+
+// src/xpath/values/string-value.ts
+var StringValue = class {
+  constructor(value) {
+    this.value = value;
+    this.type = "string";
+  }
+  stringValue() {
+    return String(this.value);
+  }
+  booleanValue() {
+    return this.value.length > 0;
+  }
+  numberValue() {
+    return this.value - 0;
+  }
+  nodeSetValue() {
+    throw this;
+  }
+};
+
+// src/xpath/values/number-value.ts
+var NumberValue = class {
+  constructor(value) {
+    this.value = value;
+    this.type = "number";
+  }
+  stringValue() {
+    return `${this.value}`;
+  }
+  booleanValue() {
+    return !!this.value;
+  }
+  numberValue() {
+    return this.value - 0;
+  }
+  nodeSetValue() {
+    throw this;
+  }
+};
+
+// src/xpath/values/boolean-value.ts
+var BooleanValue = class {
+  constructor(value) {
+    this.value = value;
+    this.type = "boolean";
+  }
+  stringValue() {
+    return `${this.value}`;
+  }
+  booleanValue() {
+    return this.value;
+  }
+  numberValue() {
+    return this.value ? 1 : 0;
+  }
+  nodeSetValue() {
+    throw this;
+  }
+};
+
+// src/dom/functions.ts
+function domGetAttributeValue(node, name) {
+  return node.getAttributeValue(name);
+}
+function domSetAttribute(node, name, value) {
+  return node.setAttribute(name, value);
+}
+function domAppendChild(node, child) {
+  return node.appendChild(child);
+}
+function domCreateTextNode(node, text) {
+  return node.createTextNode(text);
+}
+function domCreateElement(doc, name) {
+  return doc.createElement(name);
+}
+function domCreateCDATASection(doc, data) {
+  return doc.createCDATASection(data);
+}
+function domCreateComment(doc, text) {
+  return doc.createComment(text);
+}
+function domCreateDocumentFragment(doc) {
+  return doc.createDocumentFragment();
+}
+function domCreateDTDSection(doc, data) {
+  return doc.createDTDSection(data);
+}
+
+// src/constants.ts
+var DOM_ELEMENT_NODE = 1;
+var DOM_ATTRIBUTE_NODE = 2;
+var DOM_TEXT_NODE = 3;
+var DOM_CDATA_SECTION_NODE = 4;
+var DOM_PROCESSING_INSTRUCTION_NODE = 7;
+var DOM_COMMENT_NODE = 8;
+var DOM_DOCUMENT_NODE = 9;
+var DOM_DOCUMENT_TYPE_NODE = 10;
+var DOM_DOCUMENT_FRAGMENT_NODE = 11;
+
+// src/dom/xnode.ts
+var _XNode = class _XNode {
+  constructor(type, name, opt_value, opt_owner, opt_namespace) {
+    this.id = Math.random() * (Number.MAX_SAFE_INTEGER - 1) + 1;
+    this.childNodes = [];
+    this.visited = false;
+    this.escape = true;
+    this.siblingPosition = -1;
+    this.init(type, name, opt_value, opt_owner, opt_namespace);
+  }
+  /**
+   * Node initialization. Called by the constructor and `recycle` method.
+   * @param type The node type.
+   * @param name The node name.
+   * @param value The node value.
+   * @param owner The node owner.
+   * @param namespaceUri The node namespace.
+   */
+  init(type, name, value, owner, namespaceUri) {
+    this.nodeType = type - 0;
+    this.nodeName = `${name}`;
+    this.nodeValue = `${value}`;
+    this.ownerDocument = owner;
+    this.namespaceUri = namespaceUri || null;
+    [this.prefix, this.localName] = this.qualifiedNameToParts(`${name}`);
+    this.firstChild = null;
+    this.lastChild = null;
+    this.nextSibling = null;
+    this.previousSibling = null;
+    this.parentNode = null;
+  }
+  qualifiedNameToParts(name) {
+    if (name.includes(":")) {
+      return name.split(":");
+    }
+    return [null, name];
+  }
+  // Traverses the element nodes in the DOM section underneath the given
+  // node and invokes the given callbacks as methods on every element
+  // node encountered. Function opt_pre is invoked before a node's
+  // children are traversed; opt_post is invoked after they are
+  // traversed. Traversal will not be continued if a callback function
+  // returns boolean false. NOTE(mesch): copied from
+  // <//google3/maps/webmaps/javascript/dom.js>.
+  domTraverseElements(node, opt_pre, opt_post) {
+    let ret;
+    if (opt_pre) {
+      ret = opt_pre.call(null, node);
+      if (typeof ret == "boolean" && !ret) {
+        return false;
+      }
+    }
+    for (let c = node.firstChild; c; c = c.nextSibling) {
+      if (c.nodeType == DOM_ELEMENT_NODE) {
+        ret = this.domTraverseElements.call(this, c, opt_pre, opt_post);
+        if (typeof ret == "boolean" && !ret) {
+          return false;
+        }
+      }
+    }
+    if (opt_post) {
+      ret = opt_post.call(null, node);
+      if (typeof ret == "boolean" && !ret) {
+        return false;
+      }
+    }
+  }
+  // TODO: Do we still need this?
+  static recycle(node) {
+    if (!node) {
+      return;
+    }
+    if (node.constructor.name === "XDocument") {
+      this.recycle(node.documentElement);
+      return;
+    }
+    if (node.constructor != this) {
+      return;
+    }
+    this._unusedXNodes.push(node);
+    for (let c = 0; c < node.childNodes.length; ++c) {
+      this.recycle(node.childNodes[c]);
+    }
+    node.childNodes.length = 0;
+    node.init.call(0, "", "", null);
+  }
+  static create(type, name, value, owner, namespace) {
+    if (this._unusedXNodes.length > 0) {
+      const node = this._unusedXNodes.pop();
+      node.init(type, name, value, owner, namespace);
+      return node;
+    }
+    return new _XNode(type, name, value, owner, namespace);
+  }
+  static clone(node, newOwner) {
+    const newNode = new _XNode(node.nodeType, node.nodeName, node.nodeValue, newOwner, node.namespaceUri);
+    newNode.id = node.id;
+    for (let child of node.childNodes) {
+      newNode.appendChild(_XNode.clone(child, newNode));
+    }
+    return newNode;
+  }
+  appendChild(node) {
+    if (this.childNodes.length === 0) {
+      this.firstChild = node;
+    }
+    node.previousSibling = this.lastChild;
+    node.nextSibling = null;
+    if (this.lastChild) {
+      this.lastChild.nextSibling = node;
+    }
+    node.parentNode = this;
+    this.lastChild = node;
+    this.childNodes.push(node);
+  }
+  replaceChild(newNode, oldNode) {
+    if (oldNode == newNode) {
+      return;
+    }
+    for (let i = 0; i < this.childNodes.length; ++i) {
+      if (this.childNodes[i] == oldNode) {
+        this.childNodes[i] = newNode;
+        let p = oldNode.parentNode;
+        oldNode.parentNode = null;
+        newNode.parentNode = p;
+        p = oldNode.previousSibling;
+        oldNode.previousSibling = null;
+        newNode.previousSibling = p;
+        if (newNode.previousSibling) {
+          newNode.previousSibling.nextSibling = newNode;
+        }
+        p = oldNode.nextSibling;
+        oldNode.nextSibling = null;
+        newNode.nextSibling = p;
+        if (newNode.nextSibling) {
+          newNode.nextSibling.previousSibling = newNode;
+        }
+        if (this.firstChild == oldNode) {
+          this.firstChild = newNode;
+        }
+        if (this.lastChild == oldNode) {
+          this.lastChild = newNode;
+        }
+        break;
+      }
+    }
+  }
+  insertBefore(newNode, oldNode) {
+    if (oldNode == newNode) {
+      return;
+    }
+    if (oldNode.parentNode != this) {
+      return;
+    }
+    if (newNode.parentNode) {
+      newNode.parentNode.removeChild(newNode);
+    }
+    const newChildren = [];
+    for (const c of this.childNodes) {
+      if (c == oldNode) {
+        newChildren.push(newNode);
+        newNode.parentNode = this;
+        newNode.previousSibling = oldNode.previousSibling;
+        oldNode.previousSibling = newNode;
+        if (newNode.previousSibling) {
+          newNode.previousSibling.nextSibling = newNode;
+        }
+        newNode.nextSibling = oldNode;
+        if (this.firstChild == oldNode) {
+          this.firstChild = newNode;
+        }
+      }
+      newChildren.push(c);
+    }
+    this.childNodes = newChildren;
+  }
+  removeChild(node) {
+    const newChildren = [];
+    for (const c of this.childNodes) {
+      if (c != node) {
+        newChildren.push(c);
+      } else {
+        if (c.previousSibling) {
+          c.previousSibling.nextSibling = c.nextSibling;
+        }
+        if (c.nextSibling) {
+          c.nextSibling.previousSibling = c.previousSibling;
+        }
+        if (this.firstChild == c) {
+          this.firstChild = c.nextSibling;
+        }
+        if (this.lastChild == c) {
+          this.lastChild = c.previousSibling;
+        }
+      }
+    }
+    this.childNodes = newChildren;
+  }
+  hasAttributes() {
+    const attributes = this.childNodes.filter((n) => n.nodeType === DOM_ATTRIBUTE_NODE);
+    return attributes.length > 0;
+  }
+  setAttribute(name, value) {
+    const attributes = this.childNodes.filter((n) => n.nodeType === DOM_ATTRIBUTE_NODE);
+    for (let i = 0; i < attributes.length; ++i) {
+      if (attributes[i].nodeName == name) {
+        attributes[i].nodeValue = `${value}`;
+        return;
+      }
+    }
+    const newAttribute = _XNode.create(DOM_ATTRIBUTE_NODE, name, value, this);
+    newAttribute.parentNode = this;
+    this.appendChild(newAttribute);
+  }
+  setAttributeNS(namespace, name, value) {
+    const attributes = this.childNodes.filter((n) => n.nodeType === DOM_ATTRIBUTE_NODE);
+    for (let i = 0; i < attributes.length; ++i) {
+      const attribute = attributes[i];
+      if (attribute.namespaceUri == namespace && attribute.localName == this.qualifiedNameToParts(`${name}`)[1]) {
+        attribute.nodeValue = `${value}`;
+        attribute.nodeName = `${name}`;
+        attribute.prefix = this.qualifiedNameToParts(`${name}`)[0];
+        return;
+      }
+    }
+    const newAttribute = _XNode.create(DOM_ATTRIBUTE_NODE, name, value, this, namespace);
+    newAttribute.parentNode = this;
+    this.appendChild(newAttribute);
+  }
+  getAttributeValue(name) {
+    const attributes = this.childNodes.filter((n) => n.nodeType === DOM_ATTRIBUTE_NODE);
+    for (let i = 0; i < attributes.length; ++i) {
+      if (attributes[i].nodeName === name) {
+        return attributes[i].nodeValue;
+      }
+    }
+    return null;
+  }
+  getAttributeNS(namespace, localName) {
+    const attributes = this.childNodes.filter((n) => n.nodeType === DOM_ATTRIBUTE_NODE);
+    for (let i = 0; i < attributes.length; ++i) {
+      const attribute = attributes[i];
+      if (attribute.namespaceUri === namespace && attribute.localName === localName) {
+        return attribute.nodeValue;
+      }
+    }
+    return null;
+  }
+  hasAttribute(name) {
+    const attributes = this.childNodes.filter((n) => n.nodeType === DOM_ATTRIBUTE_NODE);
+    for (let i = 0; i < attributes.length; ++i) {
+      if (attributes[i].nodeName === name) {
+        return true;
+      }
+    }
+    return false;
+  }
+  hasAttributeNS(namespace, localName) {
+    const attributes = this.childNodes.filter((n) => n.nodeType === DOM_ATTRIBUTE_NODE);
+    for (let i = 0; i < attributes.length; ++i) {
+      const attribute = attributes[i];
+      if (attribute.namespaceUri === namespace && attribute.localName === localName) {
+        return true;
+      }
+    }
+    return false;
+  }
+  removeAttribute(name) {
+    const newChildNodes = [];
+    for (let i = 0; i < this.childNodes.length; ++i) {
+      const childNode = this.childNodes[i];
+      if (childNode.nodeType !== DOM_ATTRIBUTE_NODE) {
+        newChildNodes.push(childNode);
+        continue;
+      }
+      if (childNode.nodeName !== name) {
+        newChildNodes.push(childNode);
+      }
+    }
+    this.childNodes = newChildNodes;
+  }
+  removeAttributeNS(namespace, localName) {
+    const newChildNodes = [];
+    for (let i = 0; i < this.childNodes.length; ++i) {
+      const childNode = this.childNodes[i];
+      if (childNode.nodeType !== DOM_ATTRIBUTE_NODE) {
+        newChildNodes.push(childNode);
+        continue;
+      }
+      if (childNode.localName !== localName || childNode.namespaceUri !== namespace) {
+        newChildNodes.push(childNode);
+      }
+    }
+    this.childNodes = newChildNodes;
+  }
+  getElementsByTagName(name) {
+    const ret = [];
+    const self = this;
+    if ("*" == name) {
+      this.domTraverseElements(
+        this,
+        (node) => {
+          if (self == node) return;
+          ret.push(node);
+        },
+        null
+      );
+    } else {
+      this.domTraverseElements(
+        this,
+        (node) => {
+          if (self == node) return;
+          if (node.nodeName == name) {
+            ret.push(node);
+          }
+        },
+        null
+      );
+    }
+    return ret;
+  }
+  getElementsByTagNameNS(namespace, localName) {
+    const ret = [];
+    const self = this;
+    if ("*" == namespace && "*" == localName) {
+      this.domTraverseElements(
+        this,
+        (node) => {
+          if (self == node) return;
+          ret.push(node);
+        },
+        null
+      );
+    } else if ("*" == namespace) {
+      this.domTraverseElements(
+        this,
+        (node) => {
+          if (self == node) return;
+          if (node.localName == localName) ret.push(node);
+        },
+        null
+      );
+    } else if ("*" == localName) {
+      this.domTraverseElements(
+        this,
+        (node) => {
+          if (self == node) return;
+          if (node.namespaceUri == namespace) ret.push(node);
+        },
+        null
+      );
+    } else {
+      this.domTraverseElements(
+        this,
+        (node) => {
+          if (self == node) return;
+          if (node.localName == localName && node.namespaceUri == namespace) {
+            ret.push(node);
+          }
+        },
+        null
+      );
+    }
+    return ret;
+  }
+  getElementById(id) {
+    let ret = null;
+    this.domTraverseElements(
+      this,
+      (node) => {
+        if (node.getAttributeValue("id") == id) {
+          ret = node;
+          return false;
+        }
+      },
+      null
+    );
+    return ret;
+  }
+  getAncestorByLocalName(localName) {
+    if (this.parentNode === null || this.parentNode === void 0) {
+      return void 0;
+    }
+    if (this.parentNode.localName === localName) {
+      return this.parentNode;
+    }
+    return this.parentNode.getAncestorByLocalName(localName);
+  }
+  getAncestorById(id) {
+    if (this.parentNode === null || this.parentNode === void 0) {
+      return void 0;
+    }
+    if (this.parentNode.id === id) {
+      return this.parentNode;
+    }
+    return this.parentNode.getAncestorById(id);
+  }
+  toString() {
+    return `${this.nodeType}, ${this.nodeName}, ${this.nodeValue}`;
+  }
+};
+_XNode._unusedXNodes = [];
+var XNode = _XNode;
+
+// src/dom/xdocument.ts
+var XDocument = class extends XNode {
+  constructor() {
+    super(DOM_DOCUMENT_NODE, "#document", null, null);
+    this.documentElement = null;
+  }
+  // TODO: Do we still need this?
+  /* clear() {
+      XNode.recycle(this.documentElement);
+      this.documentElement = null;
+  } */
+  appendChild(node) {
+    super.appendChild(node);
+    this.documentElement = this.childNodes[0];
+  }
+  createElement(name) {
+    return XNode.create(DOM_ELEMENT_NODE, name, null, this);
+  }
+  createElementNS(namespace, name) {
+    return XNode.create(DOM_ELEMENT_NODE, name, null, this, namespace);
+  }
+  createDocumentFragment() {
+    return XNode.create(DOM_DOCUMENT_FRAGMENT_NODE, "#document-fragment", null, this);
+  }
+  createTextNode(value) {
+    return XNode.create(DOM_TEXT_NODE, "#text", value, this);
+  }
+  createAttribute(name) {
+    return XNode.create(DOM_ATTRIBUTE_NODE, name, null, this);
+  }
+  createAttributeNS(namespace, name) {
+    return XNode.create(DOM_ATTRIBUTE_NODE, name, null, this, namespace);
+  }
+  createComment(data) {
+    return XNode.create(DOM_COMMENT_NODE, "#comment", data, this);
+  }
+  createCDATASection(data) {
+    return XNode.create(DOM_CDATA_SECTION_NODE, "#cdata-section", data, this);
+  }
+  createDTDSection(data) {
+    return XNode.create(DOM_DOCUMENT_TYPE_NODE, "#dtd-section", data, this);
+  }
+};
+
+// src/dom/xml-functions.ts
+var import_he = __toESM(require("he"));
+function xmlValue(node, disallowBrowserSpecificOptimization = false) {
+  if (!node) {
+    return "";
+  }
+  let ret = "";
+  switch (node.nodeType) {
+    case DOM_DOCUMENT_TYPE_NODE:
+      return `<!DOCTYPE ${node.nodeValue}>`;
+    case DOM_TEXT_NODE:
+    case DOM_CDATA_SECTION_NODE:
+    case DOM_ATTRIBUTE_NODE:
+      return node.nodeValue;
+    case DOM_ELEMENT_NODE:
+    case DOM_DOCUMENT_NODE:
+    case DOM_DOCUMENT_FRAGMENT_NODE:
+      if (!disallowBrowserSpecificOptimization) {
+        const browserNode = node;
+        const innerText = browserNode.innerText;
+        if (innerText !== void 0) {
+          return innerText;
+        }
+        const textContent = browserNode.textContent;
+        if (textContent !== void 0) {
+          return textContent;
+        }
+      }
+      const textNodes = node.childNodes.filter((n) => n.nodeType !== DOM_ATTRIBUTE_NODE);
+      for (let i = 0; i < textNodes.length; ++i) {
+        ret += xmlValue(textNodes[i]);
+      }
+      return ret;
+  }
+}
+function xmlValueLegacyBehavior(node, disallowBrowserSpecificOptimization = false) {
+  if (!node) {
+    return "";
+  }
+  let returnedXmlString = "";
+  switch (node.nodeType) {
+    case DOM_ATTRIBUTE_NODE:
+    case DOM_TEXT_NODE:
+      returnedXmlString += node.nodeValue;
+      break;
+    case DOM_CDATA_SECTION_NODE:
+      returnedXmlString += node.nodeValue;
+      break;
+    case DOM_DOCUMENT_NODE:
+    case DOM_DOCUMENT_FRAGMENT_NODE:
+    case DOM_ELEMENT_NODE:
+      if (!disallowBrowserSpecificOptimization) {
+        const browserNode = node;
+        const innerText = browserNode.innerText;
+        if (innerText !== void 0) {
+          return innerText;
+        }
+        const textContent = browserNode.textContent;
+        if (textContent !== void 0) {
+          return textContent;
+        }
+      }
+      const len = node.childNodes.length;
+      for (let i = 0; i < len; ++i) {
+        returnedXmlString += xmlValue(node.childNodes[i]);
+      }
+      break;
+  }
+  return returnedXmlString;
+}
+function xmlTransformedText(node, options = {
+  cData: true,
+  escape: true,
+  selfClosingTags: true,
+  outputMethod: "xml"
+}) {
+  const buffer = [];
+  xmlTransformedTextRecursive(node, buffer, options);
+  return buffer.join("");
+}
+function xmlTransformedTextRecursive(node, buffer, options) {
+  if (node.visited) return;
+  const nodeType = node.nodeType;
+  const nodeValue = node.nodeValue;
+  if (nodeType === DOM_TEXT_NODE) {
+    if (node.nodeValue && node.nodeValue.trim() !== "") {
+      const finalText = node.escape && options.escape ? xmlEscapeText(node.nodeValue) : xmlUnescapeText(node.nodeValue);
+      buffer.push(finalText);
+    }
+  } else if (nodeType === DOM_CDATA_SECTION_NODE) {
+    if (options.cData) {
+      buffer.push(xmlEscapeText(nodeValue));
+    } else {
+      buffer.push(`<![CDATA[${nodeValue}]]>`);
+    }
+  } else if (nodeType == DOM_COMMENT_NODE) {
+    buffer.push(`<!-- ${nodeValue} -->`);
+  } else if (nodeType == DOM_ELEMENT_NODE) {
+    if (node.nodeName !== null && node.nodeName !== void 0) {
+      xmlElementLogicTrivial(node, buffer, options);
+    } else {
+      xmlElementLogicMuted(node, buffer, options);
+    }
+  } else if (nodeType === DOM_DOCUMENT_NODE || nodeType === DOM_DOCUMENT_FRAGMENT_NODE) {
+    let childNodes = node.firstChild ? [] : node.childNodes;
+    if (node.firstChild) {
+      let child = node.firstChild;
+      while (child) {
+        childNodes.push(child);
+        child = child.nextSibling;
+      }
+    }
+    childNodes.sort((a, b) => a.siblingPosition - b.siblingPosition);
+    for (let i = 0; i < childNodes.length; ++i) {
+      xmlTransformedTextRecursive(childNodes[i], buffer, options);
+    }
+  }
+  node.visited = true;
+}
+function xmlElementLogicTrivial(node, buffer, options) {
+  buffer.push(`<${xmlFullNodeName(node)}`);
+  let attributes = [];
+  if (node.firstChild) {
+    let child = node.firstChild;
+    while (child) {
+      if (child.nodeType === DOM_ATTRIBUTE_NODE) {
+        attributes.push(child);
+      }
+      child = child.nextSibling;
+    }
+  }
+  if (attributes.length === 0) {
+    attributes = node.childNodes.filter((n) => n.nodeType === DOM_ATTRIBUTE_NODE);
+  }
+  for (let i = 0; i < attributes.length; ++i) {
+    const attribute = attributes[i];
+    if (!attribute) {
+      continue;
+    }
+    if (attribute.nodeName && attribute.nodeValue) {
+      buffer.push(` ${xmlFullNodeName(attribute)}="${xmlEscapeAttr(attribute.nodeValue)}"`);
+    }
+  }
+  let childNodes = [];
+  if (node.firstChild) {
+    let child = node.firstChild;
+    while (child) {
+      if (child.nodeType !== DOM_ATTRIBUTE_NODE) {
+        childNodes.push(child);
+      }
+      child = child.nextSibling;
+    }
+  }
+  if (childNodes.length === 0) {
+    childNodes = node.childNodes.filter((n) => n.nodeType !== DOM_ATTRIBUTE_NODE);
+  }
+  childNodes = childNodes.sort((a, b) => a.siblingPosition - b.siblingPosition);
+  if (childNodes.length === 0) {
+    if (options.outputMethod === "html" && ["hr", "link", "meta"].includes(node.nodeName)) {
+      buffer.push(">");
+    } else if (options.selfClosingTags) {
+      buffer.push("/>");
+    } else {
+      buffer.push(`></${xmlFullNodeName(node)}>`);
+    }
+  } else {
+    buffer.push(">");
+    for (let i = 0; i < childNodes.length; ++i) {
+      xmlTransformedTextRecursive(childNodes[i], buffer, options);
+    }
+    buffer.push(`</${xmlFullNodeName(node)}>`);
+  }
+}
+function xmlElementLogicMuted(node, buffer, options) {
+  let childNodes = [];
+  if (node.firstChild) {
+    let child = node.firstChild;
+    while (child) {
+      childNodes.push(child);
+      child = child.nextSibling;
+    }
+  } else {
+    childNodes = node.childNodes;
+  }
+  childNodes = childNodes.sort((a, b) => a.siblingPosition - b.siblingPosition);
+  for (let i = 0; i < childNodes.length; ++i) {
+    xmlTransformedTextRecursive(childNodes[i], buffer, options);
+  }
+}
+function xmlFullNodeName(node) {
+  const nodeName = node.nodeName;
+  if (node.prefix && nodeName.indexOf(`${node.prefix}:`) != 0) {
+    return `${node.prefix}:${nodeName}`;
+  }
+  return nodeName;
+}
+function xmlUnescapeText(text) {
+  return `${text}`.replace(/&lt;/g, "<").replace(/&gt;/g, ">");
+}
+function xmlEscapeText(s) {
+  return `${s}`.replace(/&/g, "&amp;").replace(/&amp;amp;/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function xmlEscapeAttr(s) {
+  return xmlEscapeText(s).replace(/"/g, "&quot;");
+}
+function xmlGetAttribute(node, name) {
+  const value = domGetAttributeValue(node, name);
+  if (value) {
+    return import_he.default.decode(value);
+  }
+  return value;
+}
+
+// src/dom/xml-parser.ts
+var import_he2 = __toESM(require("he"));
+
+// src/dom/xmltoken.ts
+var XML_S = "[ 	\r\n]+";
+var XML_EQ = `(${XML_S})?=(${XML_S})?`;
+var XML_CHAR_REF = "&#[0-9]+;|&#x[0-9a-fA-F]+;";
+var XML10_VERSION_INFO = `${XML_S}version${XML_EQ}("1\\.0"|'1\\.0')`;
+var XML10_BASE_CHAR = "A-Za-z\xC0-\xD6\xD8-\xF6\xF8-\xFF\u0100-\u0131\u0134-\u013E\u0141-\u0148\u014A-\u017E\u0180-\u01C3\u01CD-\u01F0\u01F4-\u01F5\u01FA-\u0217\u0250-\u02A8\u02BB-\u02C1\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03CE\u03D0-\u03D6\u03DA\u03DC\u03DE\u03E0\u03E2-\u03F3\u0401-\u040C\u040E-\u044F\u0451-\u045C\u045E-\u0481\u0490-\u04C4\u04C7-\u04C8\u04CB-\u04CC\u04D0-\u04EB\u04EE-\u04F5\u04F8-\u04F9\u0531-\u0556\u0559\u0561-\u0586\u05D0-\u05EA\u05F0-\u05F2\u0621-\u063A\u0641-\u064A\u0671-\u06B7\u06BA-\u06BE\u06C0-\u06CE\u06D0-\u06D3\u06D5\u06E5-\u06E6\u0905-\u0939\u093D\u0958-\u0961\u0985-\u098C\u098F-\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09DC-\u09DD\u09DF-\u09E1\u09F0-\u09F1\u0A05-\u0A0A\u0A0F-\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32-\u0A33\u0A35-\u0A36\u0A38-\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8B\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2-\u0AB3\u0AB5-\u0AB9\u0ABD\u0AE0\u0B05-\u0B0C\u0B0F-\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32-\u0B33\u0B36-\u0B39\u0B3D\u0B5C-\u0B5D\u0B5F-\u0B61\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99-\u0B9A\u0B9C\u0B9E-\u0B9F\u0BA3-\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB5\u0BB7-\u0BB9\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C33\u0C35-\u0C39\u0C60-\u0C61\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CDE\u0CE0-\u0CE1\u0D05-\u0D0C\u0D0E-\u0D10\u0D12-\u0D28\u0D2A-\u0D39\u0D60-\u0D61\u0E01-\u0E2E\u0E30\u0E32-\u0E33\u0E40-\u0E45\u0E81-\u0E82\u0E84\u0E87-\u0E88\u0E8A\u0E8D\u0E94-\u0E97\u0E99-\u0E9F\u0EA1-\u0EA3\u0EA5\u0EA7\u0EAA-\u0EAB\u0EAD-\u0EAE\u0EB0\u0EB2-\u0EB3\u0EBD\u0EC0-\u0EC4\u0F40-\u0F47\u0F49-\u0F69\u10A0-\u10C5\u10D0-\u10F6\u1100\u1102-\u1103\u1105-\u1107\u1109\u110B-\u110C\u110E-\u1112\u113C\u113E\u1140\u114C\u114E\u1150\u1154-\u1155\u1159\u115F-\u1161\u1163\u1165\u1167\u1169\u116D-\u116E\u1172-\u1173\u1175\u119E\u11A8\u11AB\u11AE-\u11AF\u11B7-\u11B8\u11BA\u11BC-\u11C2\u11EB\u11F0\u11F9\u1E00-\u1E9B\u1EA0-\u1EF9\u1F00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2126\u212A-\u212B\u212E\u2180-\u2182\u3041-\u3094\u30A1-\u30FA\u3105-\u312C\uAC00-\uD7A3";
+var XML10_IDEOGRAPHIC = "\u4E00-\u9FA5\u3007\u3021-\u3029";
+var XML10_COMBINING_CHAR = "\u0300-\u0345\u0360-\u0361\u0483-\u0486\u0591-\u05A1\u05A3-\u05B9\u05BB-\u05BD\u05BF\u05C1-\u05C2\u05C4\u064B-\u0652\u0670\u06D6-\u06DC\u06DD-\u06DF\u06E0-\u06E4\u06E7-\u06E8\u06EA-\u06ED\u0901-\u0903\u093C\u093E-\u094C\u094D\u0951-\u0954\u0962-\u0963\u0981-\u0983\u09BC\u09BE\u09BF\u09C0-\u09C4\u09C7-\u09C8\u09CB-\u09CD\u09D7\u09E2-\u09E3\u0A02\u0A3C\u0A3E\u0A3F\u0A40-\u0A42\u0A47-\u0A48\u0A4B-\u0A4D\u0A70-\u0A71\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0B01-\u0B03\u0B3C\u0B3E-\u0B43\u0B47-\u0B48\u0B4B-\u0B4D\u0B56-\u0B57\u0B82-\u0B83\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C01-\u0C03\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55-\u0C56\u0C82-\u0C83\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5-\u0CD6\u0D02-\u0D03\u0D3E-\u0D43\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EB9\u0EBB-\u0EBC\u0EC8-\u0ECD\u0F18-\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86-\u0F8B\u0F90-\u0F95\u0F97\u0F99-\u0FAD\u0FB1-\u0FB7\u0FB9\u20D0-\u20DC\u20E1\u302A-\u302F\u3099\u309A";
+var XML10_DIGIT = "0-9\u0660-\u0669\u06F0-\u06F9\u0966-\u096F\u09E6-\u09EF\u0A66-\u0A6F\u0AE6-\u0AEF\u0B66-\u0B6F\u0BE7-\u0BEF\u0C66-\u0C6F\u0CE6-\u0CEF\u0D66-\u0D6F\u0E50-\u0E59\u0ED0-\u0ED9\u0F20-\u0F29";
+var XML10_EXTENDER = "\xB7\u02D0\u02D1\u0387\u0640\u0E46\u0EC6\u3005\u3031-\u3035\u309D-\u309E\u30FC-\u30FE";
+var XML10_LETTER = XML10_BASE_CHAR + XML10_IDEOGRAPHIC;
+var XML10_NAME_CHAR = `${XML10_LETTER + XML10_DIGIT}\\._:${XML10_COMBINING_CHAR}${XML10_EXTENDER}-`;
+var XML10_NAME = `[${XML10_LETTER}_:][${XML10_NAME_CHAR}]*`;
+var XML10_ENTITY_REF = `&${XML10_NAME};`;
+var XML10_REFERENCE = `${XML10_ENTITY_REF}|${XML_CHAR_REF}`;
+var XML10_ATT_VALUE = `"(([^<&"]|${XML10_REFERENCE})*)"|'(([^<&']|${XML10_REFERENCE})*)'`;
+var XML10_ATTRIBUTE = `(${XML10_NAME})${XML_EQ}(${XML10_ATT_VALUE})`;
+var XML11_VERSION_INFO = `${XML_S}version${XML_EQ}("1\\.1"|'1\\.1')`;
+var XML11_NAME_START_CHAR = ":A-Z_a-z\xC0-\xD6\xD8-\xF6\xF8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD";
+var XML11_NAME_CHAR = XML11_NAME_START_CHAR + "\\.0-9\xB7\u0300-\u036F\u203F-\u2040-";
+var XML11_NAME = `[${XML11_NAME_START_CHAR}][${XML11_NAME_CHAR}]*`;
+var XML11_ENTITY_REF = `&${XML11_NAME};`;
+var XML11_REFERENCE = `${XML11_ENTITY_REF}|${XML_CHAR_REF}`;
+var XML11_ATT_VALUE = `"(([^<&"]|${XML11_REFERENCE})*)"|'(([^<&']|${XML11_REFERENCE})*)'`;
+var XML11_ATTRIBUTE = `(${XML11_NAME})${XML_EQ}(${XML11_ATT_VALUE})`;
+var XML_NC_NAME_CHAR = `${XML10_LETTER + XML10_DIGIT}\\._${XML10_COMBINING_CHAR}${XML10_EXTENDER}-`;
+var XML_NC_NAME = `[${XML10_LETTER}_][${XML_NC_NAME_CHAR}]*`;
+
+// src/dom/xml-parser.ts
+var XmlParser = class {
+  constructor() {
+    this.regexEmpty = /\/$/;
+    this.XML10_TAGNAME_REGEXP = new RegExp(`^(${XML10_NAME})`);
+    this.XML10_ATTRIBUTE_REGEXP = new RegExp(XML10_ATTRIBUTE, "g");
+    this.XML11_TAGNAME_REGEXP = new RegExp(`^(${XML11_NAME})`);
+    this.XML11_ATTRIBUTE_REGEXP = new RegExp(XML11_ATTRIBUTE, "g");
+    this.lenientHtmlTags = ["hr", "link", "meta"];
+  }
+  /**
+   * The entry point for this parser.
+   * It verifies whether the document seems to be HTML.
+   * HTML is a special case if XML and it should be parsed differently.
+   * @param xmlOrHtml The XML or HTML content to be parsed.
+   * @returns A DOM document.
+   */
+  xmlParse(xmlOrHtml) {
+    if (xmlOrHtml.toUpperCase().startsWith("<!DOCTYPE HTML")) {
+      return this.htmlParse(xmlOrHtml);
+    }
+    return this.xmlStrictParse(xmlOrHtml);
+  }
+  /**
+   * Given an XNode, returns an object mapping prefixes to their corresponding namespaces in its scope.
+   * Default namespace is treated as if its prefix were the empty string.
+   * @param node The Node.
+   * @returns An object with prefixes and namespace URLs.
+   */
+  namespaceMapAt(node) {
+    const map = {
+      // reserved namespaces: https://www.w3.org/TR/REC-xml-names/#xmlReserved
+      xmlns: "http://www.w3.org/2000/xmlns/",
+      xml: "http://www.w3.org/XML/1998/namespace"
+    };
+    let n = node;
+    while (n !== null) {
+      for (let i = 0; i < n.childNodes.length; i++) {
+        const childNode = n.childNodes[i];
+        if (childNode.nodeType !== DOM_ATTRIBUTE_NODE) {
+          continue;
+        }
+        if (childNode.nodeName.startsWith("xmlns:")) {
+          const prefix = childNode.nodeName.split(":")[1];
+          if (!(prefix in map)) map[prefix] = childNode.nodeValue;
+        } else if (childNode.nodeName == "xmlns") {
+          if (!("" in map)) map[""] = childNode.nodeValue || null;
+        }
+      }
+      n = n.parentNode;
+    }
+    return map;
+  }
+  /**
+   * HTML needs to be parsed differently because it's a special case of XML.
+   * Sources:
+   *
+   * - https://blog.teamtreehouse.com/to-close-or-not-to-close-tags-in-html5
+   * @param htmlText The HTML text
+   * @returns A DOM document.
+   */
+  htmlParse(htmlText) {
+    const xmlDocument = new XDocument();
+    const root = xmlDocument;
+    const stack = [];
+    let parent = root;
+    stack.push(parent);
+    let tag = false, quotes = false, doublequotes = false, start = 0;
+    for (let i = 0; i < htmlText.length; ++i) {
+      let char = htmlText.charAt(i);
+      if (tag) {
+        if (!doublequotes && char === "'") {
+          quotes = !quotes;
+        } else if (!quotes && char === '"') {
+          doublequotes = !doublequotes;
+        } else if (!quotes && !doublequotes && char === ">") {
+          let text = htmlText.slice(start, i);
+          if (text.charAt(0) === "/") {
+            stack.pop();
+            parent = stack[stack.length - 1];
+          } else if (text.charAt(0) === "!") {
+          } else {
+            const empty = text.match(this.regexEmpty);
+            const tagName = this.XML10_TAGNAME_REGEXP.exec(text)[1];
+            let node = domCreateElement(xmlDocument, tagName);
+            let attribute;
+            while (attribute = this.XML10_ATTRIBUTE_REGEXP.exec(text)) {
+              const val = import_he2.default.decode(attribute[5] || attribute[7] || "");
+              domSetAttribute(node, attribute[1], val);
+            }
+            node.siblingPosition = parent.childNodes.length;
+            domAppendChild(parent, node);
+            if (!empty && !this.lenientHtmlTags.includes(tagName)) {
+              parent = node;
+              stack.push(node);
+            }
+          }
+          start = i + 1;
+          tag = false;
+          quotes = false;
+          doublequotes = false;
+        }
+      } else {
+        if (char === "<") {
+          let text = htmlText.slice(start, i);
+          if (text && parent !== root) {
+            domAppendChild(parent, domCreateTextNode(xmlDocument, text));
+          }
+          if (htmlText.slice(i + 1, i + 4) === "!--") {
+            let endTagIndex = htmlText.slice(i + 4).indexOf("-->");
+            if (endTagIndex) {
+              let node = domCreateComment(xmlDocument, htmlText.slice(i + 4, i + endTagIndex + 4));
+              domAppendChild(parent, node);
+              i += endTagIndex + 6;
+            }
+          } else if (htmlText.slice(i + 1, i + 9) === "!DOCTYPE") {
+            let endTagIndex = htmlText.slice(i + 9).indexOf(">");
+            if (endTagIndex) {
+              const dtdValue = htmlText.slice(i + 9, i + endTagIndex + 9).trimStart();
+              const node = domCreateDTDSection(xmlDocument, dtdValue);
+              domAppendChild(parent, node);
+              i += endTagIndex + dtdValue.length + 5;
+            }
+          } else {
+            tag = true;
+          }
+          start = i + 1;
+        }
+      }
+    }
+    return xmlDocument;
+  }
+  /**
+   * Parses the given XML string with our custom, JavaScript XML parser.
+   * @param xml The XML String.
+   * @returns A XDocument.
+   * @author Steffen Meschkat <mesch@google.com>
+   */
+  xmlStrictParse(xml) {
+    let regexTagname;
+    let regexAttribute;
+    if (xml.match(/^<\?xml/)) {
+      if (xml.search(new RegExp(XML10_VERSION_INFO)) === 5) {
+        regexTagname = this.XML10_TAGNAME_REGEXP;
+        regexAttribute = this.XML10_ATTRIBUTE_REGEXP;
+      } else if (xml.search(new RegExp(XML11_VERSION_INFO)) === 5) {
+        regexTagname = this.XML11_TAGNAME_REGEXP;
+        regexAttribute = this.XML11_ATTRIBUTE_REGEXP;
+      } else {
+        throw new Error("XML VersionInfo has an unknown version number.");
+      }
+    } else {
+      regexTagname = this.XML10_TAGNAME_REGEXP;
+      regexAttribute = this.XML10_ATTRIBUTE_REGEXP;
+    }
+    const xmlDocument = new XDocument();
+    const root = xmlDocument;
+    const stack = [];
+    let parent = root;
+    stack.push(parent);
+    let tag = false, quotes = false, doublequotes = false, start = 0;
+    for (let i = 0; i < xml.length; ++i) {
+      let char = xml.charAt(i);
+      if (tag && !doublequotes && char === "'") {
+        quotes = !quotes;
+      } else if (tag && !quotes && char === '"') {
+        doublequotes = !doublequotes;
+      } else if (tag && char === ">" && !quotes && !doublequotes) {
+        let text = xml.slice(start, i);
+        if (text.charAt(0) === "/") {
+          stack.pop();
+          parent = stack[stack.length - 1];
+        } else if (text.charAt(0) === "?") {
+        } else if (text.charAt(0) === "!") {
+        } else {
+          const empty = text.match(this.regexEmpty);
+          const tagname = regexTagname.exec(text)[1];
+          let node = domCreateElement(xmlDocument, tagname);
+          let attribute;
+          while (attribute = regexAttribute.exec(text)) {
+            const val = import_he2.default.decode(attribute[5] || attribute[7] || "");
+            domSetAttribute(node, attribute[1], val);
+          }
+          node.siblingPosition = parent.childNodes.length;
+          domAppendChild(parent, node);
+          if (!empty) {
+            parent = node;
+            stack.push(node);
+          }
+          const namespaceMap = this.namespaceMapAt(node);
+          if (node.prefix !== null) {
+            if (node.prefix in namespaceMap) node.namespaceUri = namespaceMap[node.prefix];
+          } else {
+            if ("" in namespaceMap) node.namespaceUri = namespaceMap[""];
+          }
+          for (let i2 = 0; i2 < node.childNodes.length; ++i2) {
+            const childNode = node.childNodes[i2];
+            if (childNode.nodeType !== DOM_ATTRIBUTE_NODE) {
+              continue;
+            }
+            if (childNode.prefix !== null && childNode.prefix in namespaceMap) {
+              childNode.namespaceUri = namespaceMap[childNode.prefix];
+            }
+          }
+        }
+        start = i + 1;
+        tag = false;
+        quotes = false;
+        doublequotes = false;
+      } else if (!tag && char === "<") {
+        let text = xml.slice(start, i);
+        if (text && parent !== root) {
+          domAppendChild(parent, domCreateTextNode(xmlDocument, text));
+        }
+        if (xml.slice(i + 1, i + 4) === "!--") {
+          let endTagIndex = xml.slice(i + 4).indexOf("-->");
+          if (endTagIndex) {
+            let node = domCreateComment(xmlDocument, xml.slice(i + 4, i + endTagIndex + 4));
+            domAppendChild(parent, node);
+            i += endTagIndex + 6;
+          }
+        } else if (xml.slice(i + 1, i + 9) === "![CDATA[") {
+          let endTagIndex = xml.slice(i + 9).indexOf("]]>");
+          if (endTagIndex) {
+            let node = domCreateCDATASection(xmlDocument, xml.slice(i + 9, i + endTagIndex + 9));
+            domAppendChild(parent, node);
+            i += endTagIndex + 11;
+          }
+        } else if (xml.slice(i + 1, i + 9) === "!DOCTYPE") {
+          let endTagIndex = xml.slice(i + 9).indexOf(">");
+          if (endTagIndex) {
+            const dtdValue = xml.slice(i + 9, i + endTagIndex + 9).trimStart();
+            const node = domCreateDTDSection(xmlDocument, dtdValue);
+            domAppendChild(parent, node);
+            i += endTagIndex + dtdValue.length + 5;
+          }
+        } else {
+          tag = true;
+        }
+        start = i + 1;
+      }
+    }
+    return root;
+  }
+};
+
+// src/xpath/values/node-set-value.ts
+var NodeSetValue = class {
+  constructor(value) {
+    this.value = value;
+    this.type = "node-set";
+  }
+  stringValue() {
+    if (this.value.length === 0) {
+      return "";
+    }
+    return xmlValue(this.value[0]);
+  }
+  booleanValue() {
+    return this.value.length > 0;
+  }
+  numberValue() {
+    return parseInt(this.stringValue()) - 0;
+  }
+  nodeSetValue() {
+    return this.value;
+  }
+};
+
+// src/xpath/xpath.ts
+var Expression = class {
+  constructor(xpathExpression, nodeConverter) {
+    this.xpathExpression = xpathExpression;
+    this.nodeConverter = nodeConverter;
+    if (xpathExpression instanceof XPathLocationPath) {
+      this.absolute = xpathExpression.absolute;
+      this.steps = xpathExpression.steps.map((step, index) => ({
+        axis: step.axis,
+        nodeTest: step.nodeTest,
+        predicates: step.predicates,
+        // Add methods needed by old code
+        hasPositionalPredicate: false,
+        // TODO: implement proper detection
+        predicate: step.predicates || [],
+        evaluate: (ctx) => {
+          const xpathCtx = this.nodeConverter.exprContextToXPathContext(ctx);
+          const result = step.evaluate(xpathCtx);
+          return this.nodeConverter.wrapResult(result, ctx);
+        }
+      }));
+    }
+  }
+  /**
+   * Evaluate the expression in the given context.
+   */
+  evaluate(context) {
+    const xpathContext = this.nodeConverter.exprContextToXPathContext(context);
+    const result = this.xpathExpression.evaluate(xpathContext);
+    return this.nodeConverter.wrapResult(result, context);
+  }
+};
+var LocationExpr = class extends Expression {
+  constructor(xpathExpression, nodeConverter) {
+    super(xpathExpression, nodeConverter);
+    this.absolute = xpathExpression.absolute;
+    this.steps = xpathExpression.steps.map((step) => ({
+      axis: step.axis,
+      nodeTest: step.nodeTest,
+      predicates: step.predicates || [],
+      predicate: step.predicates || [],
+      hasPositionalPredicate: this.hasPositionalPredicate(step.predicates || [])
+    }));
+  }
+  hasPositionalPredicate(predicates) {
+    return false;
+  }
+  appendStep(step) {
+    this.steps.push(step);
+  }
+  prependStep(step) {
+    this.steps.unshift(step);
+  }
+};
+var UnionExpr = class extends Expression {
+  constructor(xpathExpression, nodeConverter, expr1, expr2) {
+    super(xpathExpression, nodeConverter);
+    this.expr1 = expr1;
+    this.expr2 = expr2;
+  }
+};
+var NodeConverter = class {
+  /**
+   * Convert ExprContext to XPathContext for the new XPath implementation.
+   * XNodes are used directly since they implement enough of the XPathNode interface.
+   */
+  exprContextToXPathContext(exprContext) {
+    const currentNode = exprContext.nodeList[exprContext.position];
+    const xpathNode = this.adaptXNode(currentNode);
+    const nodeList = exprContext.nodeList.map((node) => this.adaptXNode(node));
+    return createContext(xpathNode, {
+      position: exprContext.position + 1,
+      // XPath is 1-based
+      size: exprContext.nodeList.length,
+      nodeList,
+      variables: this.convertVariables(exprContext),
+      functions: this.createCustomFunctions(exprContext),
+      namespaces: exprContext.knownNamespaces
+    });
+  }
+  /**
+   * Adapt XNode to be compatible with XPathNode interface.
+   * We add missing properties but keep the original XNode reference.
+   */
+  adaptXNode(node) {
+    if (!node) return null;
+    const adapted = node;
+    if (!("namespaceURI" in adapted)) {
+      Object.defineProperty(adapted, "namespaceURI", {
+        get() {
+          return this.namespaceUri;
+        },
+        enumerable: true,
+        configurable: true
+      });
+    }
+    if (!("textContent" in adapted)) {
+      Object.defineProperty(adapted, "textContent", {
+        get() {
+          return this._getTextContent();
+        },
+        enumerable: true,
+        configurable: true
+      });
+    }
+    if (!("_getTextContent" in adapted)) {
+      adapted._getTextContent = function() {
+        if (this.nodeType === 3 || this.nodeType === 2) {
+          return this.nodeValue || "";
+        }
+        if (!this.childNodes) return "";
+        let text = "";
+        for (const child of this.childNodes) {
+          if (child.nodeType === 3) {
+            text += child.nodeValue || "";
+          } else if (child.nodeType === 1) {
+            text += this._getTextContent.call(child);
+          }
+        }
+        return text;
+      };
+    }
+    if (!("attributes" in adapted)) {
+      Object.defineProperty(adapted, "attributes", {
+        get() {
+          return this.childNodes ? this.childNodes.filter((n) => n.nodeType === 2) : [];
+        },
+        enumerable: true,
+        configurable: true
+      });
+    }
+    if (!("getAttribute" in adapted)) {
+      adapted.getAttribute = function(name) {
+        return this.getAttributeValue ? this.getAttributeValue(name) : null;
+      };
+    }
+    return adapted;
+  }
+  /**
+   * Convert XPathNode result back to XNode.
+   * Since we're now using XNodes directly, this is mostly a type cast.
+   */
+  xPathNodeToXNode(xpathNode) {
+    if (!xpathNode) return null;
+    return xpathNode;
+  }
+  /**
+   * Get text content from an XNode.
+   */
+  getTextContent(node) {
+    if (node.nodeType === 3 || node.nodeType === 2) {
+      return node.nodeValue || "";
+    }
+    if (!node.childNodes) return "";
+    let text = "";
+    for (const child of node.childNodes) {
+      if (child.nodeType === 3) {
+        text += child.nodeValue || "";
+      } else if (child.nodeType === 1) {
+        text += this.getTextContent(child);
+      }
+    }
+    return text;
+  }
+  /**
+   * Convert variables from ExprContext format to XPathContext format.
+   */
+  convertVariables(exprContext) {
+    const variables = {};
+    for (const [name, value] of Object.entries(exprContext.variables || {})) {
+      if (value && typeof value === "object" && "stringValue" in value) {
+        const nodeValue = value;
+        if (nodeValue.type === "node-set") {
+          variables[name] = value.nodeSetValue().map((n) => this.adaptXNode(n));
+        } else if (nodeValue.type === "string") {
+          variables[name] = value.stringValue();
+        } else if (nodeValue.type === "number") {
+          variables[name] = value.numberValue();
+        } else if (nodeValue.type === "boolean") {
+          variables[name] = value.booleanValue();
+        } else {
+          variables[name] = value.stringValue();
+        }
+      } else {
+        variables[name] = value;
+      }
+    }
+    return variables;
+  }
+  /**
+   * Create custom functions for XPath context (like key(), document(), etc.).
+   */
+  createCustomFunctions(exprContext) {
+    const functions = {};
+    functions["key"] = (keyName, keyValue) => {
+      var _a;
+      const keyDef = (_a = exprContext.keys) == null ? void 0 : _a[keyName];
+      if (keyDef && keyDef[keyValue]) {
+        const nodeSetValue = keyDef[keyValue];
+        return nodeSetValue.nodeSetValue().map((n) => this.adaptXNode(n));
+      }
+      return [];
+    };
+    functions["current"] = () => {
+      const currentNode = exprContext.nodeList[exprContext.position];
+      return [this.adaptXNode(currentNode)];
+    };
+    functions["format-number"] = (number, format, decimalFormatName) => {
+      const settings = exprContext.decimalFormatSettings;
+      return number.toLocaleString();
+    };
+    functions["xml-to-json"] = (nodes) => {
+      if (exprContext.xsltVersion === "1.0") {
+        throw new Error('xml-to-json() is not supported in XSLT 1.0. Use version="3.0" in your stylesheet.');
+      }
+      const node = Array.isArray(nodes) ? nodes[0] : nodes;
+      if (!node) {
+        return '""';
+      }
+      return this.xmlToJson(node);
+    };
+    return functions;
+  }
+  /**
+   * Convert an XML node to a JSON string representation.
+   * This is a simplified implementation of XSLT 3.0's xml-to-json().
+   */
+  xmlToJson(node) {
+    if (!node) {
+      return '""';
+    }
+    if (node.nodeType === 3) {
+      const text = node.nodeValue || "";
+      return JSON.stringify(text);
+    }
+    if (node.nodeType === 1) {
+      const textContent = this.getTextContent(node);
+      return JSON.stringify(textContent);
+    }
+    if (node.nodeType === 2) {
+      return JSON.stringify(node.nodeValue || "");
+    }
+    return '""';
+  }
+  /**
+   * Wrap XPath result in appropriate NodeValue type.
+   */
+  wrapResult(result, exprContext) {
+    if (Array.isArray(result)) {
+      const xnodes = result.map((node) => this.xPathNodeToXNode(node)).filter((n) => n !== null);
+      return new NodeSetValue(xnodes);
+    }
+    if (typeof result === "string") {
+      return new StringValue(result);
+    }
+    if (typeof result === "number") {
+      return new NumberValue(result);
+    }
+    if (typeof result === "boolean") {
+      return new BooleanValue(result);
+    }
+    return new NodeSetValue([]);
+  }
+  /**
+   * Clear any internal state if needed.
+   */
+  clearCache() {
+  }
+};
+var XPath = class {
+  constructor() {
+    this.parseCache = /* @__PURE__ */ new Map();
+    this.lexer = new XPathLexer();
+    this.parser = new XPathParser();
+    this.nodeConverter = new NodeConverter();
+  }
+  /**
+   * Parse an XPath expression and return an Expression object.
+   * @param expression The XPath expression string.
+   * @param axis Optional axis override for relative paths.
+   */
+  xPathParse(expression, axis) {
+    const cacheKey = `${expression}:${axis || ""}`;
+    if (this.parseCache.has(cacheKey)) {
+      return this.parseCache.get(cacheKey);
+    }
+    const tokens = this.lexer.scan(expression);
+    const xpathExpr = this.parser.parse(tokens);
+    const wrappedExpr = this.wrapExpression(xpathExpr, axis);
+    this.parseCache.set(cacheKey, wrappedExpr);
+    return wrappedExpr;
+  }
+  /**
+   * Parse and evaluate an XPath expression.
+   * @param select The XPath expression string.
+   * @param context The expression context.
+   */
+  xPathEval(select, context) {
+    const expression = this.xPathParse(select);
+    return expression.evaluate(context);
+  }
+  /**
+   * Sort nodes in context according to sort specifications.
+   * @param context The expression context with nodes to sort.
+   * @param sort Array of sort specifications.
+   */
+  xPathSort(context, sort) {
+    if (sort.length === 0) {
+      return;
+    }
+    const sortList = [];
+    for (let i = 0; i < context.contextSize(); ++i) {
+      const node = context.nodeList[i];
+      const sortItem = {
+        node,
+        key: []
+      };
+      const clonedContext = context.clone([node], 0);
+      for (const s of sort) {
+        const value = s.expr.evaluate(clonedContext);
+        let evalue;
+        if (s.type === "text") {
+          evalue = value.stringValue();
+        } else if (s.type === "number") {
+          evalue = value.numberValue();
+        }
+        sortItem.key.push({
+          value: evalue,
+          order: s.order
+        });
+      }
+      sortItem.key.push({
+        value: i,
+        order: "ascending"
+      });
+      sortList.push(sortItem);
+    }
+    sortList.sort(this.xPathSortByKey);
+    const nodes = [];
+    for (let i = 0; i < sortList.length; ++i) {
+      const node = sortList[i].node;
+      node.siblingPosition = i;
+      nodes.push(node);
+    }
+    context.nodeList = nodes;
+    context.setNode(0);
+  }
+  /**
+   * Comparison function for sorting.
+   */
+  xPathSortByKey(v1, v2) {
+    for (let i = 0; i < v1.key.length; ++i) {
+      const o = v1.key[i].order === "descending" ? -1 : 1;
+      if (v1.key[i].value > v2.key[i].value) {
+        return 1 * o;
+      }
+      if (v1.key[i].value < v2.key[i].value) {
+        return -1 * o;
+      }
+    }
+    return 0;
+  }
+  /**
+   * Wrap a new XPath expression in the backward-compatible Expression class.
+   */
+  wrapExpression(xpathExpr, axis) {
+    if (xpathExpr instanceof XPathLocationPath) {
+      if (axis && xpathExpr.steps.length > 0 && !xpathExpr.absolute) {
+        xpathExpr.steps[0].axis = axis;
+      }
+      return new LocationExpr(xpathExpr, this.nodeConverter);
+    }
+    if (xpathExpr instanceof XPathUnionExpression) {
+      const expr1 = this.wrapExpression(xpathExpr.left, axis);
+      const expr2 = this.wrapExpression(xpathExpr.right, axis);
+      return new UnionExpr(xpathExpr, this.nodeConverter, expr1, expr2);
+    }
+    return new Expression(xpathExpr, this.nodeConverter);
+  }
+  /**
+   * Clear parse cache (useful for testing or memory management).
+   */
+  clearCache() {
+    this.parseCache.clear();
+    this.nodeConverter.clearCache();
+  }
+};
+
+// src/xpath/tokens.ts
+var TOK_NUMBER = {
+  label: "[number]",
+  prec: 35,
+  re: new RegExp("^\\d+(\\.\\d*)?"),
+  key: void 0
+};
+
+// src/xpath/expr-context.ts
+var ExprContext = class _ExprContext {
+  /**
+   * Constructor -- gets the node, its position, the node set it
+   * belongs to, and a parent context as arguments. The parent context
+   * is used to implement scoping rules for variables: if a variable
+   * is not found in the current context, it is looked for in the
+   * parent context, recursively. Except for node, all arguments have
+   * default values: default position is 0, default node set is the
+   * set that contains only the node, and the default parent is null.
+   *
+   * Notice that position starts at 0 at the outside interface;
+   * inside XPath expressions this shows up as position()=1.
+   * @param nodeList TODO
+   * @param opt_position TODO
+   * @param opt_parent TODO
+   * @param opt_caseInsensitive TODO
+   * @param opt_ignoreAttributesWithoutValue TODO
+   * @param opt_returnOnFirstMatch TODO
+   * @param opt_ignoreNonElementNodesForNTA TODO
+   */
+  constructor(nodeList, xsltVersion = "1.0", opt_position, opt_decimalFormatSettings, opt_variables, opt_knownNamespaces, opt_parent, opt_caseInsensitive, opt_ignoreAttributesWithoutValue, opt_returnOnFirstMatch, opt_ignoreNonElementNodesForNTA) {
+    this.nodeList = nodeList;
+    this.xsltVersion = xsltVersion;
+    this.position = opt_position || 0;
+    this.variables = opt_variables || {};
+    this.keys = (opt_parent == null ? void 0 : opt_parent.keys) || {};
+    this.knownNamespaces = opt_knownNamespaces || {};
+    this.parent = opt_parent || null;
+    this.caseInsensitive = opt_caseInsensitive || false;
+    this.ignoreAttributesWithoutValue = opt_ignoreAttributesWithoutValue || false;
+    this.returnOnFirstMatch = opt_returnOnFirstMatch || false;
+    this.ignoreNonElementNodesForNTA = opt_ignoreNonElementNodesForNTA || false;
+    this.inApplyTemplates = false;
+    this.baseTemplateMatched = false;
+    this.decimalFormatSettings = opt_decimalFormatSettings || {
+      decimalSeparator: ".",
+      groupingSeparator: ",",
+      infinity: "Infinity",
+      minusSign: "-",
+      naN: "NaN",
+      percent: "%",
+      perMille: "\u2030",
+      zeroDigit: "0",
+      digit: "#",
+      patternSeparator: ";"
+    };
+    if (opt_parent) {
+      this.root = opt_parent.root;
+    } else if (this.nodeList[this.position].nodeType == DOM_DOCUMENT_NODE) {
+      this.root = this.nodeList[this.position];
+    } else {
+      this.root = this.nodeList[this.position].ownerDocument;
+    }
+  }
+  /**
+   * clone() -- creates a new context with the current context as
+   * parent. If passed as argument to clone(), the new context has a
+   * different node, position, or node set. What is not passed is
+   * inherited from the cloned context.
+   * @param opt_nodeList TODO
+   * @param opt_position TODO
+   * @returns TODO
+   */
+  clone(opt_nodeList, opt_position) {
+    return new _ExprContext(
+      opt_nodeList || this.nodeList,
+      this.xsltVersion,
+      typeof opt_position !== "undefined" ? opt_position : this.position,
+      this.decimalFormatSettings,
+      this.variables,
+      this.knownNamespaces,
+      this,
+      this.caseInsensitive,
+      this.ignoreAttributesWithoutValue,
+      this.returnOnFirstMatch,
+      this.ignoreNonElementNodesForNTA
+    );
+  }
+  setVariable(name, value) {
+    if (value instanceof StringValue || value instanceof BooleanValue || value instanceof NumberValue || value instanceof NodeSetValue) {
+      this.variables[name] = value;
+      return;
+    }
+    if ("true" === value) {
+      this.variables[name] = new BooleanValue(true);
+    } else if ("false" === value) {
+      this.variables[name] = new BooleanValue(false);
+    } else if (TOK_NUMBER.re.test(String(value))) {
+      this.variables[name] = new NumberValue(value);
+    } else {
+      this.variables[name] = new StringValue(value);
+    }
+  }
+  getVariable(name) {
+    if (typeof this.variables[name] != "undefined") {
+      return this.variables[name];
+    }
+    if (this.parent) {
+      return this.parent.getVariable(name);
+    }
+    return null;
+  }
+  setNode(position) {
+    this.position = position;
+  }
+  contextSize() {
+    return this.nodeList.length;
+  }
+  isCaseInsensitive() {
+    return this.caseInsensitive;
+  }
+  setCaseInsensitive(caseInsensitive) {
+    return this.caseInsensitive = caseInsensitive;
+  }
+  isIgnoreAttributesWithoutValue() {
+    return this.ignoreAttributesWithoutValue;
+  }
+  setIgnoreAttributesWithoutValue(ignore) {
+    return this.ignoreAttributesWithoutValue = ignore;
+  }
+  isReturnOnFirstMatch() {
+    return this.returnOnFirstMatch;
+  }
+  setReturnOnFirstMatch(returnOnFirstMatch) {
+    return this.returnOnFirstMatch = returnOnFirstMatch;
+  }
+  isIgnoreNonElementNodesForNTA() {
+    return this.ignoreNonElementNodesForNTA;
+  }
+  setIgnoreNonElementNodesForNTA(ignoreNonElementNodesForNTA) {
+    return this.ignoreNonElementNodesForNTA = ignoreNonElementNodesForNTA;
+  }
+};
+
+// src/xpath/match-resolver.ts
+var MatchResolver = class {
+  /**
+   * Entry point for expression matching.
+   * @param expression The expression to be resolved.
+   * @param context The Expression Context.
+   * @returns An array of nodes.
+   */
+  expressionMatch(expression, context) {
+    if (expression instanceof LocationExpr) {
+      return this.locationExpressionMatch(expression, context);
+    }
+    if (expression instanceof UnionExpr) {
+      return this.unionExpressionMatch(expression, context);
+    }
+    try {
+      const result = expression.evaluate(context);
+      return result.nodeSetValue();
+    } catch (e) {
+      return [];
+    }
+  }
+  /**
+   * Resolves a LocationExpr.
+   * @param expression The Location Expression.
+   * @param context The Expression Context.
+   * @returns Either the results of a relative resolution, or the results of an
+   *          absolute resolution.
+   */
+  locationExpressionMatch(expression, context) {
+    if (!expression.steps || expression.steps.length <= 0) {
+      if (expression.absolute) {
+        const contextNode = context.nodeList[context.position];
+        if (contextNode.nodeName === "#document") {
+          return [contextNode];
+        }
+        return [];
+      }
+      return [context.nodeList[context.position]];
+    }
+    if (expression.absolute) {
+      const firstStep = expression.steps[0];
+      if (firstStep.axis === "self") {
+        return this.absoluteXsltMatchByDocumentNode(expression, context);
+      }
+      return this.absoluteXsltMatch(expression, context);
+    }
+    return this.relativeXsltMatch(expression, context);
+  }
+  /**
+   * Resolves a UnionExpr.
+   * @param expression The Union Expression.
+   * @param context The Expression Context.
+   * @returns The concatenated result of evaluating both sides of the expression.
+   */
+  unionExpressionMatch(expression, context) {
+    const expr1Nodes = this.expressionMatch(expression.expr1, context);
+    return expr1Nodes.concat(this.expressionMatch(expression.expr2, context));
+  }
+  /**
+   * Finds all the nodes through absolute XPath search, starting on
+   * the #document parent node.
+   * @param expression The Expression.
+   * @param context The Expression Context.
+   * @returns The list of found nodes.
+   */
+  absoluteXsltMatchByDocumentNode(expression, context) {
+    const clonedContext = context.clone([context.root], 0);
+    const matchedNodes = expression.evaluate(clonedContext).nodeSetValue();
+    const finalList = [];
+    for (const element of matchedNodes) {
+      if (element.id === context.nodeList[context.position].id) {
+        finalList.push(element);
+      }
+    }
+    return finalList;
+  }
+  /**
+   * Finds all the nodes through absolute XPath search, starting with the
+   * first child of the #document node.
+   * @param expression The Expression.
+   * @param context The Expression Context.
+   * @returns The list of found nodes.
+   */
+  absoluteXsltMatch(expression, context) {
+    var _a;
+    const firstChildOfRoot = context.root.childNodes.find((c) => c.nodeName !== "#dtd-section");
+    if (!firstChildOfRoot) return [];
+    const clonedContext = context.clone([firstChildOfRoot], 0);
+    const matchedNodes = expression.evaluate(clonedContext).nodeSetValue();
+    const finalList = [];
+    let nodeList;
+    if (context.nodeList.length === 1 && context.nodeList[0].nodeName === "#document") {
+      nodeList = [context.nodeList[0].childNodes.find((c) => c.nodeName !== "#dtd-section")];
+    } else {
+      nodeList = context.nodeList;
+    }
+    for (const element of matchedNodes) {
+      if (element.id === ((_a = nodeList[context.position]) == null ? void 0 : _a.id)) {
+        finalList.push(element);
+      }
+    }
+    return finalList;
+  }
+  /**
+   * Tries to find relative nodes from the actual context position.
+   * If found nodes are already in the context, or if they are children of
+   * nodes in the context, they are returned.
+   * @param expression The expression used.
+   * @param context The Expression Context.
+   * @returns The list of found nodes.
+   */
+  relativeXsltMatch(expression, context) {
+    const clonedContext = context.clone();
+    const nodes = expression.evaluate(clonedContext).nodeSetValue();
+    if (nodes.length === 1 && nodes[0].nodeName === "#document") {
+      return [nodes[0].childNodes[0]];
+    }
+    return nodes;
+  }
+};
+
+// src/xpath/node-tests/node-test-any.ts
+var NodeTestAny = class {
+  constructor() {
+    this.value = new BooleanValue(true);
+  }
+  evaluate() {
+    return this.value;
+  }
+};
+
+// src/xpath/node-tests/node-test-comment.ts
+var NodeTestComment = class {
+  evaluate(ctx) {
+    return new BooleanValue(ctx.nodeList[ctx.position].nodeType == DOM_COMMENT_NODE);
+  }
+};
+
+// src/xpath/node-tests/node-test-element-or-attribute.ts
+var NodeTestElementOrAttribute = class {
+  evaluate(context) {
+    const node = context.nodeList[context.position];
+    return new BooleanValue(node.nodeType == DOM_ELEMENT_NODE || node.nodeType == DOM_ATTRIBUTE_NODE);
+  }
+};
+
+// src/xpath/node-tests/node-test-name.ts
+var NodeTestName = class {
+  constructor(name) {
+    this.name = name;
+    if (name.indexOf(":") > 0) {
+      const nameAndNamespacePrefix = name.split(":");
+      this.namespacePrefix = nameAndNamespacePrefix[0];
+      this.name = nameAndNamespacePrefix[1];
+    }
+    this.re = new RegExp(`^${name}$`, "i");
+  }
+  evaluate(context) {
+    const node = context.nodeList[context.position];
+    if (this.namespacePrefix !== void 0) {
+      const namespaceValue = context.knownNamespaces[this.namespacePrefix];
+      if (namespaceValue !== node.namespaceUri) {
+        return new BooleanValue(false);
+      }
+      if (context.caseInsensitive) {
+        if (node.localName.length !== this.name.length) return new BooleanValue(false);
+        return new BooleanValue(this.re.test(node.localName));
+      }
+      return new BooleanValue(node.localName === this.name);
+    }
+    if (context.caseInsensitive) {
+      if (node.nodeName.length !== this.name.length) return new BooleanValue(false);
+      return new BooleanValue(this.re.test(node.nodeName));
+    }
+    return new BooleanValue(node.nodeName === this.name);
+  }
+};
+
+// src/xpath/node-tests/node-test-nc.ts
+var NodeTestNC = class {
+  constructor(nsprefix) {
+    this.regex = new RegExp(`^${nsprefix}:`);
+    this.nsprefix = nsprefix;
+  }
+  evaluate(ctx) {
+    const n = ctx.nodeList[ctx.position];
+    return new BooleanValue(n.nodeName.match(this.regex));
+  }
+};
+
+// src/xpath/node-tests/node-test-pi.ts
+var NodeTestPI = class {
+  constructor(target) {
+    this.target = target;
+  }
+  evaluate(context) {
+    const node = context.nodeList[context.position];
+    return new BooleanValue(
+      node.nodeType == DOM_PROCESSING_INSTRUCTION_NODE && (!this.target || node.nodeName == this.target)
+    );
+  }
+};
+
+// src/xpath/node-tests/node-test-text.ts
+var NodeTestText = class {
+  evaluate(ctx) {
+    return new BooleanValue(ctx.nodeList[ctx.position].nodeType == DOM_TEXT_NODE);
+  }
+};
+
+// src/xslt/functions.ts
+function calculateStepPriority(step) {
+  const nodeTest = step.nodeTest;
+  const hasPredicates = step.predicate && step.predicate.length > 0 || step.predicates && step.predicates.length > 0;
+  if (hasPredicates) {
+    return 0.5;
+  }
+  if (nodeTest && typeof nodeTest === "object" && "type" in nodeTest) {
+    switch (nodeTest.type) {
+      case "wildcard":
+        if (nodeTest.name && nodeTest.name.endsWith(":*")) {
+          return -0.25;
+        }
+        return -0.5;
+      case "node-type":
+        if (nodeTest.nodeType === "processing-instruction" && nodeTest.name) {
+          return 0;
+        }
+        return -0.5;
+      case "processing-instruction":
+        return nodeTest.name ? 0 : -0.5;
+      case "name":
+        return 0;
+      default:
+        return 0;
+    }
+  }
+  if (nodeTest instanceof NodeTestAny) {
+    return -0.5;
+  }
+  if (nodeTest instanceof NodeTestElementOrAttribute) {
+    return -0.5;
+  }
+  if (nodeTest instanceof NodeTestText) {
+    return -0.5;
+  }
+  if (nodeTest instanceof NodeTestComment) {
+    return -0.5;
+  }
+  if (nodeTest instanceof NodeTestPI) {
+    return nodeTest.target ? 0 : -0.5;
+  }
+  if (nodeTest instanceof NodeTestNC) {
+    return -0.25;
+  }
+  if (nodeTest instanceof NodeTestName) {
+    return 0;
+  }
+  return 0;
+}
+function calculateLocationPathPriority(expr) {
+  if (!expr.steps || expr.steps.length === 0) {
+    if (expr.absolute) {
+      return -0.5;
+    }
+    return 0;
+  }
+  if (expr.steps.length > 1) {
+    return 0.5;
+  }
+  return calculateStepPriority(expr.steps[0]);
+}
+function calculateUnionExprPriority(expr, xPath) {
+  const priority1 = calculateDefaultPriorityFromExpression(expr.expr1, xPath);
+  const priority2 = calculateDefaultPriorityFromExpression(expr.expr2, xPath);
+  return Math.min(priority1, priority2);
+}
+function calculateDefaultPriorityFromExpression(expr, xPath) {
+  if (expr instanceof LocationExpr) {
+    return calculateLocationPathPriority(expr);
+  }
+  if (expr instanceof UnionExpr) {
+    return calculateUnionExprPriority(expr, xPath);
+  }
+  return 0.5;
+}
+function calculateDefaultPriority(pattern, xPath) {
+  try {
+    const expr = xPath.xPathParse(pattern, "self-and-siblings");
+    return calculateDefaultPriorityFromExpression(expr, xPath);
+  } catch (e) {
+    console.warn(`Failed to parse pattern "${pattern}" for priority calculation:`, e);
+    return 0;
+  }
+}
+function matchesMode(template, mode) {
+  const templateMode = template.getAttributeValue("mode");
+  if (!mode) {
+    return !templateMode || templateMode === "#default";
+  }
+  if (mode === "#all") {
+    return true;
+  }
+  if (templateMode === "#all") {
+    return true;
+  }
+  return templateMode === mode;
+}
+function isTemplate(node) {
+  if (node.nodeType !== DOM_ELEMENT_NODE) {
+    return false;
+  }
+  if (node.namespaceUri === "http://www.w3.org/1999/XSL/Transform") {
+    return node.localName === "template";
+  }
+  return node.prefix === "xsl" && node.localName === "template";
+}
+function collectAndExpandTemplates(stylesheetElement, mode, xPath) {
+  const templates = [];
+  let docOrder = 0;
+  for (const child of stylesheetElement.childNodes) {
+    if (!isTemplate(child)) {
+      continue;
+    }
+    if (!matchesMode(child, mode)) {
+      continue;
+    }
+    const match = child.getAttributeValue("match");
+    if (!match) {
+      continue;
+    }
+    const priorityAttr = child.getAttributeValue("priority");
+    const explicitPriority = priorityAttr ? parseFloat(priorityAttr) : null;
+    const defaultPriority = calculateDefaultPriority(match, xPath);
+    const effectivePriority = explicitPriority !== null && !isNaN(explicitPriority) ? explicitPriority : defaultPriority;
+    templates.push({
+      template: child,
+      explicitPriority: explicitPriority !== null && !isNaN(explicitPriority) ? explicitPriority : null,
+      defaultPriority,
+      effectivePriority,
+      importPrecedence: 0,
+      // TODO: Set properly when xsl:import is fully implemented
+      documentOrder: docOrder++,
+      matchPattern: match
+    });
+  }
+  return templates;
+}
+function splitUnionPattern(pattern) {
+  const alternatives = [];
+  let current = "";
+  let depth = 0;
+  let inSingleQuote = false;
+  let inDoubleQuote = false;
+  for (let i = 0; i < pattern.length; i++) {
+    const char = pattern[i];
+    if (char === "'" && !inDoubleQuote) {
+      inSingleQuote = !inSingleQuote;
+      current += char;
+    } else if (char === '"' && !inSingleQuote) {
+      inDoubleQuote = !inDoubleQuote;
+      current += char;
+    } else if (!inSingleQuote && !inDoubleQuote) {
+      if (char === "[" || char === "(") {
+        depth++;
+        current += char;
+      } else if (char === "]" || char === ")") {
+        depth--;
+        current += char;
+      } else if (char === "|" && depth === 0) {
+        alternatives.push(current.trim());
+        current = "";
+      } else {
+        current += char;
+      }
+    } else {
+      current += char;
+    }
+  }
+  if (current.trim()) {
+    alternatives.push(current.trim());
+  }
+  return alternatives;
+}
+function nodeMatchesSinglePattern(node, pattern, context, matchResolver, xPath) {
+  if (pattern === "/") {
+    return node.nodeName === "#document";
+  }
+  if (pattern.startsWith("@")) {
+    if (node.nodeType !== 2) {
+      return false;
+    }
+    const attrPattern = pattern.substring(1);
+    if (attrPattern === "*") {
+      return true;
+    }
+    const attrName = node.localName || node.nodeName;
+    const patternLocalName = attrPattern.includes(":") ? attrPattern.substring(attrPattern.indexOf(":") + 1) : attrPattern;
+    return attrName === patternLocalName || node.nodeName === attrPattern;
+  }
+  const nodeContext = context.clone([node], 0);
+  try {
+    const expr = xPath.xPathParse(pattern, "self-and-siblings");
+    const nodes = matchResolver.expressionMatch(expr, nodeContext);
+    if (nodes.some((n) => n.id === node.id)) {
+      return true;
+    }
+  } catch (e) {
+  }
+  if (pattern === "*" && node.nodeType === DOM_ELEMENT_NODE) {
+    return true;
+  }
+  if (pattern.includes("[") || pattern.includes("/")) {
+    try {
+      const rootContext = context.clone([context.root], 0);
+      const descendantPattern = pattern.startsWith("/") ? pattern : "//" + pattern;
+      const expr = xPath.xPathParse(descendantPattern);
+      const nodes = matchResolver.expressionMatch(expr, rootContext);
+      if (nodes.some((n) => n.id === node.id)) {
+        return true;
+      }
+    } catch (e) {
+    }
+  }
+  return false;
+}
+function nodeMatchesPattern(node, pattern, context, matchResolver, xPath) {
+  const alternatives = splitUnionPattern(pattern);
+  for (const alt of alternatives) {
+    if (nodeMatchesSinglePattern(node, alt, context, matchResolver, xPath)) {
+      return true;
+    }
+  }
+  return false;
+}
+function selectBestTemplate(templates, context, matchResolver, xPath) {
+  const matching = [];
+  const currentNode = context.nodeList[context.position];
+  for (const t of templates) {
+    try {
+      if (nodeMatchesPattern(currentNode, t.matchPattern, context, matchResolver, xPath)) {
+        matching.push(t);
+      }
+    } catch (e) {
+      console.warn(`Failed to match pattern "${t.matchPattern}":`, e);
+    }
+  }
+  if (matching.length === 0) {
+    return {
+      selectedTemplate: null,
+      hasConflict: false,
+      conflictingTemplates: []
+    };
+  }
+  matching.sort((a, b) => {
+    if (a.importPrecedence !== b.importPrecedence) {
+      return b.importPrecedence - a.importPrecedence;
+    }
+    if (a.effectivePriority !== b.effectivePriority) {
+      return b.effectivePriority - a.effectivePriority;
+    }
+    return b.documentOrder - a.documentOrder;
+  });
+  const winner = matching[0];
+  const conflicts = matching.filter(
+    (t) => t.importPrecedence === winner.importPrecedence && t.effectivePriority === winner.effectivePriority
+  );
+  return {
+    selectedTemplate: winner.template,
+    hasConflict: conflicts.length > 1,
+    conflictingTemplates: conflicts.length > 1 ? conflicts : []
+  };
+}
+function emitConflictWarning(result, node) {
+  if (!result.hasConflict || result.conflictingTemplates.length < 2) {
+    return;
+  }
+  const patterns = result.conflictingTemplates.map((t) => `"${t.matchPattern}" (priority: ${t.effectivePriority})`).join(", ");
+  console.warn(
+    `XSLT Warning: Ambiguous template match for node <${node.nodeName}>. Multiple templates match with equal priority: ${patterns}. Using the last one in document order.`
+  );
+}
+
+// src/xslt/xslt.ts
+var Xslt = class {
+  constructor(options = {
+    cData: true,
+    escape: true,
+    selfClosingTags: true,
+    parameters: []
+  }) {
+    this.xPath = new XPath();
+    this.xmlParser = new XmlParser();
+    this.matchResolver = new MatchResolver();
+    this.options = {
+      cData: options.cData === true,
+      escape: options.escape === true,
+      selfClosingTags: options.selfClosingTags === true,
+      parameters: options.parameters || []
+    };
+    this.outputMethod = "xml";
+    this.outputOmitXmlDeclaration = "no";
+    this.decimalFormatSettings = {
+      decimalSeparator: ".",
+      groupingSeparator: ",",
+      infinity: "Infinity",
+      minusSign: "-",
+      naN: "NaN",
+      percent: "%",
+      perMille: "\u2030",
+      zeroDigit: "0",
+      digit: "#",
+      patternSeparator: ";"
+    };
+    this.firstTemplateRan = false;
+  }
+  /**
+   * The exported entry point of the XSL-T processor.
+   * @param xmlDoc The input document root, as DOM node.
+   * @param stylesheet The stylesheet document root, as DOM node.
+   * @returns the processed document, as XML text in a string.
+   */
+  xsltProcess(xmlDoc, stylesheet) {
+    return __async(this, null, function* () {
+      const outputDocument = new XDocument();
+      this.outputDocument = outputDocument;
+      const expressionContext = new ExprContext([xmlDoc]);
+      if (this.options.parameters.length > 0) {
+        for (const parameter of this.options.parameters) {
+          expressionContext.setVariable(parameter.name, new StringValue(parameter.value));
+        }
+      }
+      yield this.xsltProcessContext(expressionContext, stylesheet, this.outputDocument);
+      const transformedOutputXml = xmlTransformedText(outputDocument, {
+        cData: this.options.cData,
+        escape: this.options.escape,
+        selfClosingTags: this.options.selfClosingTags,
+        outputMethod: this.outputMethod
+      });
+      return transformedOutputXml;
+    });
+  }
+  /**
+   * The main entry point of the XSL-T processor, as explained on the top of the file.
+   * @param context The input document root, as XPath `ExprContext`.
+   * @param template The stylesheet document root, as DOM node.
+   * @param output If set, the output where the transformation should occur.
+   */
+  xsltProcessContext(context, template, output) {
+    return __async(this, null, function* () {
+      if (!this.isXsltElement(template)) {
+        yield this.xsltPassThrough(context, template, output);
+      } else {
+        let node, select, value, nodes;
+        switch (template.localName) {
+          case "apply-imports":
+            throw new Error(`not implemented: ${template.localName}`);
+          case "apply-templates":
+            yield this.xsltApplyTemplates(context, template, output);
+            break;
+          case "attribute":
+            yield this.xsltAttribute(context, template, output);
+            break;
+          case "attribute-set":
+            throw new Error(`not implemented: ${template.localName}`);
+          case "call-template":
+            yield this.xsltCallTemplate(context, template, output);
+            break;
+          case "choose":
+            yield this.xsltChoose(context, template, output);
+            break;
+          case "comment":
+            yield this.xsltComment(context, template, output);
+            break;
+          case "copy":
+            node = this.xsltCopy(output || this.outputDocument, context.nodeList[context.position]);
+            if (node) {
+              yield this.xsltChildNodes(context, template, node);
+            }
+            break;
+          case "copy-of":
+            select = xmlGetAttribute(template, "select");
+            value = this.xPath.xPathEval(select, context);
+            const destinationNode = output || this.outputDocument;
+            if (value.type === "node-set") {
+              nodes = value.nodeSetValue();
+              for (let i = 0; i < nodes.length; ++i) {
+                this.xsltCopyOf(destinationNode, nodes[i]);
+              }
+            } else {
+              let node2 = domCreateTextNode(this.outputDocument, value.stringValue());
+              node2.siblingPosition = destinationNode.childNodes.length;
+              domAppendChild(destinationNode, node2);
+            }
+            break;
+          case "decimal-format":
+            this.xsltDecimalFormat(context, template);
+            break;
+          case "element":
+            yield this.xsltElement(context, template, output);
+            break;
+          case "fallback":
+            throw new Error(`not implemented: ${template.localName}`);
+          case "for-each":
+            yield this.xsltForEach(context, template, output);
+            break;
+          case "if":
+            yield this.xsltIf(context, template, output);
+            break;
+          case "import":
+            yield this.xsltImport(context, template, output);
+            break;
+          case "include":
+            yield this.xsltInclude(context, template, output);
+            break;
+          case "key":
+            this.xsltKey(context, template);
+            break;
+          case "message":
+            throw new Error(`not implemented: ${template.localName}`);
+          case "namespace-alias":
+            throw new Error(`not implemented: ${template.localName}`);
+          case "number":
+            throw new Error(`not implemented: ${template.localName}`);
+          case "otherwise":
+            throw new Error(`xsl:otherwise can't be used outside of xsl:choose.`);
+          case "output":
+            this.outputMethod = xmlGetAttribute(template, "method");
+            this.outputOmitXmlDeclaration = xmlGetAttribute(template, "omit-xml-declaration");
+            break;
+          case "param":
+            yield this.xsltVariable(context, template, false);
+            break;
+          case "preserve-space":
+            throw new Error(`not implemented: ${template.localName}`);
+          case "processing-instruction":
+            throw new Error(`not implemented: ${template.localName}`);
+          case "sort":
+            this.xsltSort(context, template);
+            break;
+          case "strip-space":
+            throw new Error(`not implemented: ${template.localName}`);
+          case "stylesheet":
+          case "transform":
+            yield this.xsltTransformOrStylesheet(context, template, output);
+            break;
+          case "template":
+            yield this.xsltTemplate(context, template, output);
+            break;
+          case "text":
+            this.xsltText(context, template, output);
+            break;
+          case "value-of":
+            this.xsltValueOf(context, template, output);
+            break;
+          case "variable":
+            yield this.xsltVariable(context, template, true);
+            break;
+          case "when":
+            throw new Error(`xsl:when can't be used outside of xsl:choose.`);
+          case "with-param":
+            throw new Error(`error if here: ${template.localName}`);
+          default:
+            throw new Error(`error if here: ${template.localName}`);
+        }
+      }
+    });
+  }
+  /**
+   * Implements `xsl:apply-templates`.
+   * @param context The Expression Context.
+   * @param template The template.
+   * @param output The output. Only used if there's no corresponding output node already defined.
+   * @protected
+   */
+  xsltApplyTemplates(context, template, output) {
+    return __async(this, null, function* () {
+      const select = xmlGetAttribute(template, "select");
+      let nodes = [];
+      if (select) {
+        nodes = this.xPath.xPathEval(select, context).nodeSetValue();
+      } else {
+        nodes = context.nodeList[context.position].childNodes;
+      }
+      const mode = xmlGetAttribute(template, "mode");
+      const top = template.ownerDocument.documentElement;
+      const expandedTemplates = collectAndExpandTemplates(top, mode, this.xPath);
+      const modifiedContext = context.clone(nodes);
+      for (let j = 0; j < modifiedContext.contextSize(); ++j) {
+        const currentNode = modifiedContext.nodeList[j];
+        if (currentNode.nodeType === DOM_TEXT_NODE) {
+          const textNodeContext = context.clone(
+            [currentNode],
+            0
+          );
+          this.commonLogicTextNode(textNodeContext, currentNode, output);
+        } else {
+          const clonedContext = modifiedContext.clone(
+            [currentNode],
+            0
+          );
+          clonedContext.inApplyTemplates = true;
+          const selection = selectBestTemplate(
+            expandedTemplates,
+            clonedContext,
+            this.matchResolver,
+            this.xPath
+          );
+          if (selection.hasConflict) {
+            emitConflictWarning(selection, currentNode);
+          }
+          if (selection.selectedTemplate) {
+            yield this.xsltChildNodes(clonedContext, selection.selectedTemplate, output);
+          }
+        }
+      }
+    });
+  }
+  /**
+   * Implements `xsl:attribute`.
+   * @param context The Expression Context.
+   * @param template The template.
+   * @param output The output. Only used if there's no corresponding output node already defined.
+   * @protected
+   */
+  xsltAttribute(context, template, output) {
+    return __async(this, null, function* () {
+      const nameExpr = xmlGetAttribute(template, "name");
+      const name = this.xsltAttributeValue(nameExpr, context);
+      const documentFragment = domCreateDocumentFragment(this.outputDocument);
+      yield this.xsltChildNodes(context, template, documentFragment);
+      const value = xmlValueLegacyBehavior(documentFragment);
+      if (output) {
+        domSetAttribute(output, name, value);
+      }
+    });
+  }
+  /**
+   * Implements `xsl:call-template`.
+   * @param context The Expression Context.
+   * @param template The template.
+   * @param output The output, used when a fragment is passed by a previous step.
+   */
+  xsltCallTemplate(context, template, output) {
+    return __async(this, null, function* () {
+      const name = xmlGetAttribute(template, "name");
+      const top = template.ownerDocument.documentElement;
+      const paramContext = context.clone();
+      yield this.xsltWithParam(paramContext, template);
+      for (let i = 0; i < top.childNodes.length; ++i) {
+        let childNode = top.childNodes[i];
+        if (childNode.nodeType === DOM_ELEMENT_NODE && this.isXsltElement(childNode, "template") && domGetAttributeValue(childNode, "name") === name) {
+          yield this.xsltChildNodes(paramContext, childNode, output);
+          break;
+        }
+      }
+    });
+  }
+  /**
+   * Implements `xsl:choose`, its child nodes `xsl:when`, and
+   * `xsl:otherwise`.
+   * @param context The Expression Context.
+   * @param template The template.
+   * @param output The output. Only used if there's no corresponding output node already defined.
+   */
+  xsltChoose(context, template, output) {
+    return __async(this, null, function* () {
+      for (const childNode of template.childNodes) {
+        if (childNode.nodeType !== DOM_ELEMENT_NODE) {
+          continue;
+        }
+        if (this.isXsltElement(childNode, "when")) {
+          const test = xmlGetAttribute(childNode, "test");
+          if (this.xPath.xPathEval(test, context).booleanValue()) {
+            yield this.xsltChildNodes(context, childNode, output);
+            break;
+          }
+        } else if (this.isXsltElement(childNode, "otherwise")) {
+          yield this.xsltChildNodes(context, childNode, output);
+          break;
+        }
+      }
+    });
+  }
+  /**
+   * Implements `xsl:copy` for all node types.
+   * @param {XNode} destination the node being copied to, part of output document.
+   * @param {XNode} source the node being copied, part in input document.
+   * @returns {XNode|null} If an element node was created, the element node. Otherwise, null.
+   */
+  xsltCopy(destination, source) {
+    if (source.nodeType == DOM_ELEMENT_NODE) {
+      let node = domCreateElement(this.outputDocument, source.nodeName);
+      if (source.namespaceUri !== null && source.namespaceUri !== void 0) {
+        domSetAttribute(node, "xmlns", source.namespaceUri);
+      }
+      node.siblingPosition = destination.childNodes.length;
+      domAppendChild(destination, node);
+      return node;
+    }
+    if (source.nodeType == DOM_TEXT_NODE) {
+      let node = domCreateTextNode(this.outputDocument, source.nodeValue);
+      node.siblingPosition = destination.childNodes.length;
+      domAppendChild(destination, node);
+    } else if (source.nodeType == DOM_CDATA_SECTION_NODE) {
+      let node = domCreateCDATASection(this.outputDocument, source.nodeValue);
+      node.siblingPosition = destination.childNodes.length;
+      domAppendChild(destination, node);
+    } else if (source.nodeType == DOM_COMMENT_NODE) {
+      let node = domCreateComment(this.outputDocument, source.nodeValue);
+      node.siblingPosition = destination.childNodes.length;
+      domAppendChild(destination, node);
+    } else if (source.nodeType == DOM_ATTRIBUTE_NODE) {
+      domSetAttribute(destination, source.nodeName, source.nodeValue);
+    }
+    return null;
+  }
+  /**
+   * Implements `xsl:comment`. 
+   * @param context The Expression Context.
+   * @param template The template.
+   * @param output The output. Only used if there's no corresponding output node already defined. 
+   */
+  xsltComment(context, template, output) {
+    return __async(this, null, function* () {
+      const node = domCreateDocumentFragment(this.outputDocument);
+      yield this.xsltChildNodes(context, template, node);
+      const commentData = xmlValue(node);
+      const commentNode = domCreateComment(this.outputDocument, commentData);
+      const resolvedOutput = output || this.outputDocument;
+      resolvedOutput.appendChild(commentNode);
+    });
+  }
+  /**
+   * Implements `xsl:copy-of` for node-set values of the select
+   * expression. Recurses down the source node tree, which is part of
+   * the input document.
+   * @param {XNode} destination the node being copied to, part of output document.
+   * @param {XNode} source the node being copied, part in input document.
+   */
+  xsltCopyOf(destination, source) {
+    if (source.nodeType == DOM_DOCUMENT_FRAGMENT_NODE || source.nodeType == DOM_DOCUMENT_NODE) {
+      for (let i = 0; i < source.childNodes.length; ++i) {
+        this.xsltCopyOf(destination, source.childNodes[i]);
+      }
+    } else {
+      const node = this.xsltCopy(destination, source);
+      if (node) {
+        for (let i = 0; i < source.childNodes.length; ++i) {
+          this.xsltCopyOf(node, source.childNodes[i]);
+        }
+      }
+    }
+  }
+  /**
+   * Implements `xsl:decimal-format`, registering the settings in this instance
+   * and the current context. 
+   * @param context The Expression Context.
+   * @param template The template.
+   */
+  xsltDecimalFormat(context, template) {
+    const name = xmlGetAttribute(template, "name");
+    const decimalSeparator = xmlGetAttribute(template, "decimal-separator");
+    const groupingSeparator = xmlGetAttribute(template, "grouping-separator");
+    const infinity = xmlGetAttribute(template, "infinity");
+    const minusSign = xmlGetAttribute(template, "minus-sign");
+    const naN = xmlGetAttribute(template, "NaN");
+    const percent = xmlGetAttribute(template, "percent");
+    const perMille = xmlGetAttribute(template, "per-mille");
+    const zeroDigit = xmlGetAttribute(template, "zero-digit");
+    const digit = xmlGetAttribute(template, "digit");
+    const patternSeparator = xmlGetAttribute(template, "pattern-separator");
+    this.decimalFormatSettings = {
+      name: name || this.decimalFormatSettings.name,
+      decimalSeparator: decimalSeparator || this.decimalFormatSettings.decimalSeparator,
+      groupingSeparator: groupingSeparator || this.decimalFormatSettings.groupingSeparator,
+      infinity: infinity || this.decimalFormatSettings.infinity,
+      minusSign: minusSign || this.decimalFormatSettings.minusSign,
+      naN: naN || this.decimalFormatSettings.naN,
+      percent: percent || this.decimalFormatSettings.percent,
+      perMille: perMille || this.decimalFormatSettings.perMille,
+      zeroDigit: zeroDigit || this.decimalFormatSettings.zeroDigit,
+      digit: digit || this.decimalFormatSettings.digit,
+      patternSeparator: patternSeparator || this.decimalFormatSettings.patternSeparator
+    };
+    context.decimalFormatSettings = this.decimalFormatSettings;
+  }
+  /**
+   * Implements `xsl:element`.
+   * @param context The Expression Context.
+   * @param template The template.
+   */
+  xsltElement(context, template, output) {
+    return __async(this, null, function* () {
+      const nameExpr = xmlGetAttribute(template, "name");
+      const name = this.xsltAttributeValue(nameExpr, context);
+      const node = domCreateElement(this.outputDocument, name);
+      domAppendChild(output || this.outputDocument, node);
+      const clonedContext = context.clone(void 0, 0);
+      yield this.xsltChildNodes(clonedContext, template, node);
+    });
+  }
+  /**
+   * Implements `xsl:for-each`.
+   * @param context The Expression Context.
+   * @param template The template.
+   * @param output The output.
+   */
+  xsltForEach(context, template, output) {
+    return __async(this, null, function* () {
+      const select = xmlGetAttribute(template, "select");
+      const nodes = this.xPath.xPathEval(select, context).nodeSetValue();
+      if (nodes.length === 0) {
+        return;
+      }
+      const sortContext = context.clone(nodes);
+      this.xsltSort(sortContext, template);
+      const nodesWithParent = sortContext.nodeList.filter((n) => n.parentNode !== null && n.parentNode !== void 0);
+      if (nodesWithParent.length <= 0) {
+        throw new Error("Nodes with no parents defined.");
+      }
+      for (let i = 0; i < sortContext.contextSize(); ++i) {
+        yield this.xsltChildNodes(sortContext.clone(sortContext.nodeList, i), template, output);
+      }
+    });
+  }
+  /**
+   * Implements `xsl:if`.
+   * @param context The Expression Context.
+   * @param template The template.
+   * @param output The output.
+   */
+  xsltIf(context, template, output) {
+    return __async(this, null, function* () {
+      const test = xmlGetAttribute(template, "test");
+      if (this.xPath.xPathEval(test, context).booleanValue()) {
+        yield this.xsltChildNodes(context, template, output);
+      }
+    });
+  }
+  /**
+   * Common implementation for `<xsl:import>` and `<xsl:include>`.
+   * @param context The Expression Context.
+   * @param template The template.
+   * @param output The output.
+   * @param isImport Whether this is an import (true) or include (false).
+   */
+  xsltImportOrInclude(context, template, output, isImport) {
+    return __async(this, null, function* () {
+      const elementName = isImport ? "xsl:import" : "xsl:include";
+      const [major, minor] = process.versions.node.split(".").map(Number);
+      if (major <= 17 && minor < 5) {
+        throw new Error(`Your Node.js version does not support \`<${elementName}>\`. If possible, please update your Node.js version to at least version 17.5.0.`);
+      }
+      if (!global.globalThis.fetch) {
+        global.globalThis.fetch = fetch;
+        global.globalThis.Headers = Headers;
+        global.globalThis.Request = Request;
+        global.globalThis.Response = Response;
+      }
+      const hrefAttributeFind = template.childNodes.filter((n) => n.nodeName === "href");
+      if (hrefAttributeFind.length <= 0) {
+        throw new Error(`<${elementName}> with no href attribute defined.`);
+      }
+      const hrefAttribute = hrefAttributeFind[0];
+      const fetchTest = yield global.globalThis.fetch(hrefAttribute.nodeValue);
+      const fetchResponse = yield fetchTest.text();
+      const includedXslt = this.xmlParser.xmlParse(fetchResponse);
+      yield this.xsltChildNodes(context, includedXslt.childNodes[0], output);
+    });
+  }
+  /**
+   * Implements `<xsl:import>`. For now the code is nearly identical to `<xsl:include>`, but there's
+   * no precedence evaluation implemented yet.
+   * @param context The Expression Context.
+   * @param template The template.
+   * @param output The output.
+   */
+  xsltImport(context, template, output) {
+    return __async(this, null, function* () {
+      yield this.xsltImportOrInclude(context, template, output, true);
+    });
+  }
+  /**
+   * Implements `xsl:include`.
+   * @param context The Expression Context.
+   * @param template The template.
+   * @param output The output.
+   */
+  xsltInclude(context, template, output) {
+    return __async(this, null, function* () {
+      yield this.xsltImportOrInclude(context, template, output, false);
+    });
+  }
+  /**
+   * Implements `xsl:key`.
+   * @param context The Expression Context.
+   * @param template The template.
+   */
+  xsltKey(context, template) {
+    const name = xmlGetAttribute(template, "name");
+    const match = xmlGetAttribute(template, "match");
+    const use = xmlGetAttribute(template, "use");
+    if (!name || !match || !use) {
+      let errorMessage = "<xsl:key> missing required parameters: ";
+      if (!name) {
+        errorMessage += "name, ";
+      }
+      if (!match) {
+        errorMessage += "match, ";
+      }
+      if (!use) {
+        errorMessage += "use, ";
+      }
+      errorMessage = errorMessage.slice(0, -2);
+      throw new Error(errorMessage);
+    }
+    let keyContext;
+    if (context.nodeList[context.position].nodeName === "#document") {
+      keyContext = context.clone(context.nodeList[context.position].childNodes);
+    } else {
+      keyContext = context;
+    }
+    const nodes = this.xsltMatch(match, keyContext);
+    if (!(name in context.keys)) {
+      context.keys[name] = {};
+    }
+    for (const node of nodes) {
+      const nodeContext = context.clone([node]);
+      const attribute = this.xPath.xPathEval(use, nodeContext);
+      const attributeValue = attribute.stringValue();
+      context.keys[name][attributeValue] = new NodeSetValue([node]);
+    }
+  }
+  /**
+   * Orders the current node list in the input context according to the
+   * sort order specified by xsl:sort child nodes of the current
+   * template node. This happens before the operation specified by the
+   * current template node is executed.
+   * @param context The expression context.
+   * @param template The template node.
+   * @todo case-order is not implemented.
+   */
+  xsltSort(context, template) {
+    const sort = [];
+    for (const childNode of template.childNodes) {
+      if (childNode.nodeType == DOM_ELEMENT_NODE && this.isXsltElement(childNode, "sort")) {
+        const select = xmlGetAttribute(childNode, "select");
+        const expression = this.xPath.xPathParse(select);
+        const type = xmlGetAttribute(childNode, "data-type") || "text";
+        const order = xmlGetAttribute(childNode, "order") || "ascending";
+        sort.push({
+          expr: expression,
+          type,
+          order
+        });
+      }
+    }
+    this.xPath.xPathSort(context, sort);
+  }
+  /**
+   * Implements `xsl:template`.
+   * @param context The Expression Context.
+   * @param template The `<xsl:template>` node.
+   * @param output The output. In general, a fragment that will be used by 
+   *               the caller.
+   */
+  xsltTemplate(context, template, output) {
+    return __async(this, null, function* () {
+      if (!context.inApplyTemplates && context.baseTemplateMatched) {
+        return;
+      }
+      const match = xmlGetAttribute(template, "match");
+      if (!match) return;
+      const nodes = this.xsltMatch(match, context, "self-and-siblings");
+      if (nodes.length > 0) {
+        this.firstTemplateRan = true;
+        if (!context.inApplyTemplates) {
+          context.baseTemplateMatched = true;
+        }
+        const templateContext = context.clone(nodes, 0);
+        yield this.xsltChildNodes(templateContext, template, output);
+      }
+    });
+  }
+  xsltText(context, template, output) {
+    const text = xmlValue(template);
+    const node = domCreateTextNode(this.outputDocument, text);
+    const disableOutputEscaping = template.childNodes.filter(
+      (a) => a.nodeType === DOM_ATTRIBUTE_NODE && a.nodeName === "disable-output-escaping"
+    );
+    if (disableOutputEscaping.length > 0 && disableOutputEscaping[0].nodeValue === "yes") {
+      node.escape = false;
+    }
+    const destinationTextNode = output || this.outputDocument;
+    destinationTextNode.appendChild(node);
+  }
+  /**
+   * Implements `<xsl:stylesheet>` and `<xsl:transform>`, and its corresponding
+   * validations.
+   * @param context The Expression Context.
+   * @param template The `<xsl:stylesheet>` or `<xsl:transform>` node.
+   * @param output The output. In general, a fragment that will be used by
+   *               the caller.
+   */
+  xsltTransformOrStylesheet(context, template, output) {
+    return __async(this, null, function* () {
+      for (let stylesheetAttribute of template.childNodes.filter((n) => n.nodeType === DOM_ATTRIBUTE_NODE)) {
+        switch (stylesheetAttribute.nodeName) {
+          case "version":
+            this.version = stylesheetAttribute.nodeValue;
+            if (!["1.0", "2.0", "3.0"].includes(this.version)) {
+              throw new Error(
+                `XSLT version not defined or invalid. Actual resolved version: ${this.version || "(none)"}.`
+              );
+            }
+            context.xsltVersion = this.version;
+            break;
+          default:
+            if (stylesheetAttribute.prefix === "xmlns") {
+              context.knownNamespaces[stylesheetAttribute.localName] = stylesheetAttribute.nodeValue;
+            }
+            break;
+        }
+      }
+      let importsDone = false;
+      for (const child of template.childNodes) {
+        if (child.nodeType === DOM_ELEMENT_NODE) {
+          if (this.isXsltElement(child, "import")) {
+            if (importsDone) {
+              throw new Error("<xsl:import> should be the first child node of <xsl:stylesheet> or <xsl:transform>.");
+            }
+          } else {
+            importsDone = true;
+          }
+        }
+      }
+      const nonTemplates = [];
+      const templates = [];
+      for (const child of template.childNodes) {
+        if (child.nodeType === DOM_ELEMENT_NODE && this.isXsltElement(child, "template")) {
+          templates.push(child);
+        } else {
+          nonTemplates.push(child);
+        }
+      }
+      const contextClone = context.clone();
+      for (const child of nonTemplates) {
+        yield this.xsltProcessContext(contextClone, child, output);
+      }
+      if (templates.length > 0) {
+        const expandedTemplates = collectAndExpandTemplates(template, null, this.xPath);
+        const matchCandidates = [];
+        for (const t of expandedTemplates) {
+          try {
+            const matchedNodes = this.xsltMatch(t.matchPattern, contextClone);
+            if (matchedNodes.length > 0) {
+              matchCandidates.push({ priority: t, matchedNodes });
+            }
+          } catch (e) {
+            console.warn(`Failed to match pattern "${t.matchPattern}":`, e);
+          }
+        }
+        if (matchCandidates.length > 0) {
+          matchCandidates.sort((a, b) => {
+            if (a.priority.importPrecedence !== b.priority.importPrecedence) {
+              return b.priority.importPrecedence - a.priority.importPrecedence;
+            }
+            if (a.priority.effectivePriority !== b.priority.effectivePriority) {
+              return b.priority.effectivePriority - a.priority.effectivePriority;
+            }
+            return b.priority.documentOrder - a.priority.documentOrder;
+          });
+          const winner = matchCandidates[0];
+          const conflicts = matchCandidates.filter(
+            (t) => t.priority.importPrecedence === winner.priority.importPrecedence && t.priority.effectivePriority === winner.priority.effectivePriority
+          );
+          if (conflicts.length > 1) {
+            const patterns = conflicts.map((t) => `"${t.priority.matchPattern}" (priority: ${t.priority.effectivePriority})`).join(", ");
+            console.warn(
+              `XSLT Warning: Ambiguous template match. Multiple templates match with equal priority: ${patterns}. Using the last one in document order.`
+            );
+          }
+          this.firstTemplateRan = true;
+          contextClone.baseTemplateMatched = true;
+          const templateContext = contextClone.clone(winner.matchedNodes, 0);
+          yield this.xsltChildNodes(templateContext, winner.priority.template, output);
+        }
+      }
+    });
+  }
+  xsltValueOf(context, template, output) {
+    const select = xmlGetAttribute(template, "select");
+    const attribute = this.xPath.xPathEval(select, context);
+    const value = attribute.stringValue();
+    const node = domCreateTextNode(this.outputDocument, value);
+    const targetOutput = output || this.outputDocument;
+    node.siblingPosition = targetOutput.childNodes.length;
+    targetOutput.appendChild(node);
+  }
+  /**
+   * Evaluates a variable or parameter and set it in the current input
+   * context. Implements `xsl:variable`, `xsl:param`, and `xsl:with-param`.
+   *
+   * @param context The expression context.
+   * @param template The template node.
+   * @param override flag that defines if the value computed here
+   * overrides the one already in the input context if that is the
+   * case. I.e. decides if this is a default value or a local
+   * value. `xsl:variable` and `xsl:with-param` override; `xsl:param` doesn't.
+   */
+  xsltVariable(context, template, override) {
+    return __async(this, null, function* () {
+      const name = xmlGetAttribute(template, "name");
+      const select = xmlGetAttribute(template, "select");
+      let value;
+      const nonAttributeChildren = template.childNodes.filter((n) => n.nodeType !== DOM_ATTRIBUTE_NODE);
+      if (nonAttributeChildren.length > 0) {
+        const fragment = domCreateDocumentFragment(template.ownerDocument);
+        yield this.xsltChildNodes(context, template, fragment);
+        value = new NodeSetValue([fragment]);
+      } else if (select) {
+        value = this.xPath.xPathEval(select, context);
+      } else {
+        let parameterValue = "";
+        const filteredParameter = this.options.parameters.filter((p) => p.name === name);
+        if (filteredParameter.length > 0) {
+          parameterValue = filteredParameter[0].value;
+        }
+        value = new StringValue(parameterValue);
+      }
+      if (override || !context.getVariable(name)) {
+        context.setVariable(name, value);
+      }
+    });
+  }
+  /**
+   * Traverses the template node tree. Calls the main processing
+   * function with the current input context for every child node of the
+   * current template node.
+   * @param context Normally the Expression Context.
+   * @param template The XSL-T definition.
+   * @param output If set, the output where the transformation should occur.
+   */
+  xsltChildNodes(context, template, output) {
+    return __async(this, null, function* () {
+      const contextClone = context.clone();
+      for (let i = 0; i < template.childNodes.length; ++i) {
+        yield this.xsltProcessContext(contextClone, template.childNodes[i], output);
+      }
+    });
+  }
+  /**
+   * This logic is used in two different places:
+   * - `xsltPassThrough`, if the template asks this library to write a text node;
+   * - `xsltProcessContext`, `apply-templates` operation, when the current node is text.
+   * 
+   * Text nodes always require a parent, and they never have children.
+   * @param context The Expression Context.
+   * @param template The template, that contains the node value to be written.
+   * @param output The output.
+   */
+  commonLogicTextNode(context, template, output) {
+    if (output) {
+      let node = domCreateTextNode(this.outputDocument, template.nodeValue);
+      node.siblingPosition = output.childNodes.length;
+      domAppendChild(output, node);
+    }
+  }
+  /**
+   * Passes template text to the output. The current template node does
+   * not specify an XSL-T operation and therefore is appended to the
+   * output with all its attributes. Then continues traversing the
+   * template node tree.
+   * @param context The Expression Context.
+   * @param template The XSLT stylesheet or transformation.
+   * @param output The output.
+   */
+  xsltPassThrough(context, template, output) {
+    return __async(this, null, function* () {
+      switch (template.nodeType) {
+        case DOM_TEXT_NODE:
+          if (this.xsltPassText(template)) {
+            this.commonLogicTextNode(context, template, output);
+          }
+          break;
+        case DOM_ELEMENT_NODE:
+          let node;
+          let elementContext = context;
+          node = context.nodeList[context.position];
+          let newNode;
+          newNode = domCreateElement(this.outputDocument, template.nodeName);
+          newNode.siblingPosition = node.siblingPosition;
+          domAppendChild(output || this.outputDocument, newNode);
+          yield this.xsltChildNodes(elementContext, template, newNode);
+          const templateAttributes = template.childNodes.filter((a) => (a == null ? void 0 : a.nodeType) === DOM_ATTRIBUTE_NODE);
+          for (const attribute of templateAttributes) {
+            const name = attribute.nodeName;
+            const value = this.xsltAttributeValue(attribute.nodeValue, elementContext);
+            domSetAttribute(newNode, name, value);
+          }
+          break;
+        default:
+          yield this.xsltChildNodes(context, template, output);
+      }
+    });
+  }
+  /**
+   * Determines if a text node in the XSLT template document is to be
+   * stripped according to XSLT whitespace stripping rules.
+   * @see [XSLT], section 3.4.
+   * @param template The XSLT template.
+   * @returns TODO
+   * @todo Whitespace stripping on the input document is
+   * currently not implemented.
+   */
+  xsltPassText(template) {
+    if (!template.nodeValue.match(/^\s*$/)) {
+      return true;
+    }
+    let element = template.parentNode;
+    if (this.isXsltElement(element, "text")) {
+      return true;
+    }
+    while (element && element.nodeType == DOM_ELEMENT_NODE) {
+      const xmlspace = domGetAttributeValue(element, "xml:space");
+      if (xmlspace) {
+        if (xmlspace == "default") {
+          return false;
+        }
+        if (xmlspace == "preserve") {
+          return true;
+        }
+      }
+      element = element.parentNode;
+    }
+    return false;
+  }
+  findAttributeInContext(attributeName, context) {
+    return context.nodeList[context.position].childNodes.find(
+      (a) => a.nodeType === DOM_ATTRIBUTE_NODE && a.nodeName === attributeName
+    );
+  }
+  /**
+   * Evaluates an XSL-T attribute value template. Attribute value
+   * templates are attributes on XSL-T elements that contain XPath
+   * expressions in braces {}. The XSL-T expressions are evaluated in
+   * the current input context.
+   * @param value TODO
+   * @param context TODO
+   * @returns TODO
+   */
+  xsltAttributeValue(value, context) {
+    const parts = value.split("{");
+    if (parts.length === 1) {
+      return value;
+    }
+    let ret = "";
+    for (let i = 0; i < parts.length; ++i) {
+      const rp = parts[i].split("}");
+      if (rp.length != 2) {
+        ret += parts[i];
+        continue;
+      }
+      const val = this.xPath.xPathEval(rp[0], context).stringValue();
+      ret += val + rp[1];
+    }
+    return ret;
+  }
+  /**
+   * Evaluates an XPath expression in the current input context as a
+   * match.
+   * @see [XSLT] section 5.2, paragraph 1
+   * @param match TODO
+   * @param context The Expression Context.
+   * @param axis The XPath axis. Used when the match does not start with the parent.
+   * @returns {XNode[]} A list of the found nodes.
+   */
+  xsltMatch(match, context, axis) {
+    const expression = this.xPath.xPathParse(match, axis);
+    return this.matchResolver.expressionMatch(expression, context);
+  }
+  /**
+   * Sets parameters defined by xsl:with-param child nodes of the
+   * current template node, in the current input context. This happens
+   * before the operation specified by the current template node is
+   * executed.
+   * @param context The Expression Context.
+   * @param template The template node.
+   */
+  xsltWithParam(context, template) {
+    return __async(this, null, function* () {
+      for (const childNode of template.childNodes) {
+        if (childNode.nodeType === DOM_ELEMENT_NODE && this.isXsltElement(childNode, "with-param")) {
+          yield this.xsltVariable(context, childNode, true);
+        }
+      }
+    });
+  }
+  /**
+   * Test if the given element is an XSLT element, optionally the one with the given name.
+   * @param {XNode} element The element.
+   * @param {string} opt_wantedName The name for comparison.
+   * @returns True, if element is an XSL node. False otherwise.
+   */
+  isXsltElement(element, opt_wantedName) {
+    if (opt_wantedName && element.localName != opt_wantedName) return false;
+    if (element.namespaceUri) return element.namespaceUri === "http://www.w3.org/1999/XSL/Transform";
+    return element.prefix === "xsl";
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ExprContext,
+  XPath,
+  XmlParser,
+  Xslt,
+  xmlEscapeText
+});
 //# sourceMappingURL=index.js.map