@tradik/xslt-processor 1.0.0

package/dist/xslt-processor.browser.js

@@ -0,0 +1,3302 @@
+var XsltProcessorLib = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+  // src/index.js
+  var index_exports = {};
+  __export(index_exports, {
+    VERSION: () => VERSION,
+    XPathContext: () => XPathContext,
+    XPathEvaluator: () => XPathEvaluator,
+    XPathResultType: () => XPathResultType,
+    XSLTProcessor: () => XSLTProcessor,
+    XsltContext: () => XsltContext,
+    XsltEngine: () => XsltEngine,
+    default: () => XSLTProcessor_default,
+    evaluateXPath: () => evaluate,
+    installGlobal: () => installGlobal,
+    isBrowser: () => isBrowser,
+    isNativeXSLTSupported: () => isNativeXSLTSupported,
+    isNode: () => isNode,
+    parseXPath: () => parse,
+    selectFirstXPath: () => selectFirst,
+    selectXPath: () => select
+  });
+
+  // src/xpath/tokenizer.js
+  var TokenType = {
+    // Literals
+    NUMBER: "NUMBER",
+    LITERAL: "LITERAL",
+    // Operators
+    SLASH: "SLASH",
+    DOUBLE_SLASH: "DOUBLE_SLASH",
+    PIPE: "PIPE",
+    PLUS: "PLUS",
+    MINUS: "MINUS",
+    STAR: "STAR",
+    DIV: "DIV",
+    MOD: "MOD",
+    EQUALS: "EQUALS",
+    NOT_EQUALS: "NOT_EQUALS",
+    LT: "LT",
+    LTE: "LTE",
+    GT: "GT",
+    GTE: "GTE",
+    AND: "AND",
+    OR: "OR",
+    // Brackets
+    LPAREN: "LPAREN",
+    RPAREN: "RPAREN",
+    LBRACKET: "LBRACKET",
+    RBRACKET: "RBRACKET",
+    // Axes
+    AXIS: "AXIS",
+    AT: "AT",
+    DOT: "DOT",
+    DOUBLE_DOT: "DOUBLE_DOT",
+    DOUBLE_COLON: "DOUBLE_COLON",
+    // Names
+    NAME: "NAME",
+    NCNAME: "NCNAME",
+    PREFIX: "PREFIX",
+    FUNCTION: "FUNCTION",
+    NODE_TYPE: "NODE_TYPE",
+    // Other
+    COMMA: "COMMA",
+    DOLLAR: "DOLLAR",
+    COLON: "COLON",
+    EOF: "EOF"
+  };
+  var AXIS_NAMES = /* @__PURE__ */ new Set([
+    "ancestor",
+    "ancestor-or-self",
+    "attribute",
+    "child",
+    "descendant",
+    "descendant-or-self",
+    "following",
+    "following-sibling",
+    "namespace",
+    "parent",
+    "preceding",
+    "preceding-sibling",
+    "self"
+  ]);
+  var NODE_TYPES = /* @__PURE__ */ new Set([
+    "comment",
+    "text",
+    "processing-instruction",
+    "node"
+  ]);
+  var OPERATORS = /* @__PURE__ */ new Set(["and", "or", "mod", "div"]);
+  var Token = class {
+    constructor(type, value, position) {
+      this.type = type;
+      this.value = value;
+      this.position = position;
+    }
+    toString() {
+      return `Token(${this.type}, ${JSON.stringify(this.value)}, pos=${this.position})`;
+    }
+  };
+  var OPERATOR_CONTEXT_BLOCKERS = /* @__PURE__ */ new Set([
+    TokenType.AT,
+    TokenType.DOUBLE_COLON,
+    TokenType.LPAREN,
+    TokenType.LBRACKET,
+    TokenType.COMMA,
+    // Operators - after an operator, next name token should be a name, not an operator
+    TokenType.SLASH,
+    TokenType.DOUBLE_SLASH,
+    TokenType.PIPE,
+    TokenType.PLUS,
+    TokenType.MINUS,
+    TokenType.STAR,
+    TokenType.DIV,
+    TokenType.MOD,
+    TokenType.EQUALS,
+    TokenType.NOT_EQUALS,
+    TokenType.LT,
+    TokenType.LTE,
+    TokenType.GT,
+    TokenType.GTE,
+    TokenType.AND,
+    TokenType.OR
+  ]);
+  var XPathTokenizer = class {
+    constructor(expression) {
+      this.expression = expression;
+      this.position = 0;
+      this.tokens = [];
+    }
+    /**
+     * Get the last token that was added (if any)
+     */
+    getLastToken() {
+      return this.tokens.length > 0 ? this.tokens[this.tokens.length - 1] : null;
+    }
+    /**
+     * Check if the current context allows operator names (div, mod, and, or)
+     * Per XPath 1.0 spec disambiguation rules.
+     */
+    isOperatorContext() {
+      const lastToken = this.getLastToken();
+      if (!lastToken) return false;
+      if (OPERATOR_CONTEXT_BLOCKERS.has(lastToken.type)) return false;
+      return true;
+    }
+    tokenize() {
+      this.tokens = [];
+      this.position = 0;
+      while (this.position < this.expression.length) {
+        this.skipWhitespace();
+        if (this.position >= this.expression.length) break;
+        const token = this.nextToken();
+        if (token) {
+          this.tokens.push(token);
+        }
+      }
+      this.tokens.push(new Token(TokenType.EOF, null, this.position));
+      return this.tokens;
+    }
+    skipWhitespace() {
+      while (this.position < this.expression.length && /\s/.test(this.expression[this.position])) {
+        this.position++;
+      }
+    }
+    peek(offset = 0) {
+      return this.expression[this.position + offset];
+    }
+    consume() {
+      return this.expression[this.position++];
+    }
+    nextToken() {
+      const startPos = this.position;
+      const char = this.peek();
+      if (char === '"' || char === "'") {
+        return this.readStringLiteral();
+      }
+      if (/[0-9]/.test(char) || char === "." && /[0-9]/.test(this.peek(1))) {
+        return this.readNumber();
+      }
+      if (char === "/" && this.peek(1) === "/") {
+        this.position += 2;
+        return new Token(TokenType.DOUBLE_SLASH, "//", startPos);
+      }
+      if (char === "." && this.peek(1) === ".") {
+        this.position += 2;
+        return new Token(TokenType.DOUBLE_DOT, "..", startPos);
+      }
+      if (char === ":" && this.peek(1) === ":") {
+        this.position += 2;
+        return new Token(TokenType.DOUBLE_COLON, "::", startPos);
+      }
+      if (char === "!" && this.peek(1) === "=") {
+        this.position += 2;
+        return new Token(TokenType.NOT_EQUALS, "!=", startPos);
+      }
+      if (char === "<" && this.peek(1) === "=") {
+        this.position += 2;
+        return new Token(TokenType.LTE, "<=", startPos);
+      }
+      if (char === ">" && this.peek(1) === "=") {
+        this.position += 2;
+        return new Token(TokenType.GTE, ">=", startPos);
+      }
+      const singleCharTokens = {
+        "/": TokenType.SLASH,
+        "|": TokenType.PIPE,
+        "+": TokenType.PLUS,
+        "-": TokenType.MINUS,
+        "*": TokenType.STAR,
+        "=": TokenType.EQUALS,
+        "<": TokenType.LT,
+        ">": TokenType.GT,
+        "(": TokenType.LPAREN,
+        ")": TokenType.RPAREN,
+        "[": TokenType.LBRACKET,
+        "]": TokenType.RBRACKET,
+        "@": TokenType.AT,
+        ".": TokenType.DOT,
+        ",": TokenType.COMMA,
+        $: TokenType.DOLLAR,
+        ":": TokenType.COLON
+      };
+      if (singleCharTokens[char]) {
+        this.position++;
+        return new Token(singleCharTokens[char], char, startPos);
+      }
+      if (this.isNameStartChar(char)) {
+        return this.readName();
+      }
+      throw new Error(
+        `Unexpected character '${char}' at position ${this.position} in expression: ${this.expression}`
+      );
+    }
+    readStringLiteral() {
+      const startPos = this.position;
+      const quote = this.consume();
+      let value = "";
+      while (this.position < this.expression.length && this.peek() !== quote) {
+        value += this.consume();
+      }
+      if (this.position >= this.expression.length) {
+        throw new Error(`Unterminated string literal at position ${startPos}`);
+      }
+      this.consume();
+      return new Token(TokenType.LITERAL, value, startPos);
+    }
+    readNumber() {
+      const startPos = this.position;
+      let value = "";
+      while (this.position < this.expression.length && /[0-9]/.test(this.peek())) {
+        value += this.consume();
+      }
+      if (this.peek() === "." && /[0-9]/.test(this.peek(1))) {
+        value += this.consume();
+        while (this.position < this.expression.length && /[0-9]/.test(this.peek())) {
+          value += this.consume();
+        }
+      }
+      return new Token(TokenType.NUMBER, parseFloat(value), startPos);
+    }
+    readName() {
+      const startPos = this.position;
+      let value = "";
+      while (this.position < this.expression.length && this.isNameChar(this.peek())) {
+        value += this.consume();
+      }
+      this.skipWhitespace();
+      if (AXIS_NAMES.has(value) && this.peek() === ":" && this.peek(1) === ":") {
+        return new Token(TokenType.AXIS, value, startPos);
+      }
+      const savedPos = this.position;
+      this.skipWhitespace();
+      if (this.peek() === "(") {
+        if (NODE_TYPES.has(value)) {
+          return new Token(TokenType.NODE_TYPE, value, startPos);
+        }
+        return new Token(TokenType.FUNCTION, value, startPos);
+      }
+      this.position = savedPos;
+      if (OPERATORS.has(value) && this.isOperatorContext()) {
+        const opTokens = {
+          and: TokenType.AND,
+          or: TokenType.OR,
+          mod: TokenType.MOD,
+          div: TokenType.DIV
+        };
+        return new Token(opTokens[value], value, startPos);
+      }
+      return new Token(TokenType.NAME, value, startPos);
+    }
+    isNameStartChar(char) {
+      if (!char) return false;
+      const code = char.charCodeAt(0);
+      return char === "_" || code >= 65 && code <= 90 || // A-Z
+      code >= 97 && code <= 122 || // a-z
+      code >= 192;
+    }
+    isNameChar(char) {
+      if (!char) return false;
+      const code = char.charCodeAt(0);
+      return this.isNameStartChar(char) || char === "-" || char === "." || code >= 48 && code <= 57;
+    }
+  };
+  function tokenize(expression) {
+    const tokenizer = new XPathTokenizer(expression);
+    return tokenizer.tokenize();
+  }
+
+  // src/xpath/parser.js
+  var NodeType = {
+    // Expression types
+    OR_EXPR: "OrExpr",
+    AND_EXPR: "AndExpr",
+    EQUALITY_EXPR: "EqualityExpr",
+    RELATIONAL_EXPR: "RelationalExpr",
+    ADDITIVE_EXPR: "AdditiveExpr",
+    MULTIPLICATIVE_EXPR: "MultiplicativeExpr",
+    UNARY_EXPR: "UnaryExpr",
+    UNION_EXPR: "UnionExpr",
+    // Path expressions
+    PATH_EXPR: "PathExpr",
+    LOCATION_PATH: "LocationPath",
+    STEP: "Step",
+    PREDICATE: "Predicate",
+    // Primaries
+    VARIABLE_REF: "VariableRef",
+    LITERAL: "Literal",
+    NUMBER: "Number",
+    FUNCTION_CALL: "FunctionCall",
+    // Node tests
+    NAME_TEST: "NameTest",
+    NODE_TYPE_TEST: "NodeTypeTest",
+    PI_TEST: "ProcessingInstructionTest"
+  };
+  var ASTNode = class {
+    constructor(type, props = {}) {
+      this.type = type;
+      Object.assign(this, props);
+    }
+  };
+  var XPathParser = class {
+    constructor(tokens) {
+      this.tokens = tokens;
+      this.position = 0;
+    }
+    parse() {
+      const expr = this.parseExpr();
+      if (!this.isAtEnd()) {
+        throw new Error(
+          `Unexpected token ${this.peek().type} at position ${this.peek().position}`
+        );
+      }
+      return expr;
+    }
+    // Expr ::= OrExpr
+    parseExpr() {
+      return this.parseOrExpr();
+    }
+    // OrExpr ::= AndExpr | OrExpr 'or' AndExpr
+    parseOrExpr() {
+      let left = this.parseAndExpr();
+      while (this.match(TokenType.OR)) {
+        const right = this.parseAndExpr();
+        left = new ASTNode(NodeType.OR_EXPR, { left, right });
+      }
+      return left;
+    }
+    // AndExpr ::= EqualityExpr | AndExpr 'and' EqualityExpr
+    parseAndExpr() {
+      let left = this.parseEqualityExpr();
+      while (this.match(TokenType.AND)) {
+        const right = this.parseEqualityExpr();
+        left = new ASTNode(NodeType.AND_EXPR, { left, right });
+      }
+      return left;
+    }
+    // EqualityExpr ::= RelationalExpr | EqualityExpr '=' RelationalExpr | EqualityExpr '!=' RelationalExpr
+    parseEqualityExpr() {
+      let left = this.parseRelationalExpr();
+      while (true) {
+        if (this.match(TokenType.EQUALS)) {
+          const right = this.parseRelationalExpr();
+          left = new ASTNode(NodeType.EQUALITY_EXPR, {
+            operator: "=",
+            left,
+            right
+          });
+        } else if (this.match(TokenType.NOT_EQUALS)) {
+          const right = this.parseRelationalExpr();
+          left = new ASTNode(NodeType.EQUALITY_EXPR, {
+            operator: "!=",
+            left,
+            right
+          });
+        } else {
+          break;
+        }
+      }
+      return left;
+    }
+    // RelationalExpr ::= AdditiveExpr | RelationalExpr '<' AdditiveExpr | ...
+    parseRelationalExpr() {
+      let left = this.parseAdditiveExpr();
+      while (true) {
+        if (this.match(TokenType.LT)) {
+          const right = this.parseAdditiveExpr();
+          left = new ASTNode(NodeType.RELATIONAL_EXPR, {
+            operator: "<",
+            left,
+            right
+          });
+        } else if (this.match(TokenType.LTE)) {
+          const right = this.parseAdditiveExpr();
+          left = new ASTNode(NodeType.RELATIONAL_EXPR, {
+            operator: "<=",
+            left,
+            right
+          });
+        } else if (this.match(TokenType.GT)) {
+          const right = this.parseAdditiveExpr();
+          left = new ASTNode(NodeType.RELATIONAL_EXPR, {
+            operator: ">",
+            left,
+            right
+          });
+        } else if (this.match(TokenType.GTE)) {
+          const right = this.parseAdditiveExpr();
+          left = new ASTNode(NodeType.RELATIONAL_EXPR, {
+            operator: ">=",
+            left,
+            right
+          });
+        } else {
+          break;
+        }
+      }
+      return left;
+    }
+    // AdditiveExpr ::= MultiplicativeExpr | AdditiveExpr '+' MultiplicativeExpr | AdditiveExpr '-' MultiplicativeExpr
+    parseAdditiveExpr() {
+      let left = this.parseMultiplicativeExpr();
+      while (true) {
+        if (this.match(TokenType.PLUS)) {
+          const right = this.parseMultiplicativeExpr();
+          left = new ASTNode(NodeType.ADDITIVE_EXPR, {
+            operator: "+",
+            left,
+            right
+          });
+        } else if (this.match(TokenType.MINUS)) {
+          const right = this.parseMultiplicativeExpr();
+          left = new ASTNode(NodeType.ADDITIVE_EXPR, {
+            operator: "-",
+            left,
+            right
+          });
+        } else {
+          break;
+        }
+      }
+      return left;
+    }
+    // MultiplicativeExpr ::= UnaryExpr | MultiplicativeExpr '*' UnaryExpr | ...
+    parseMultiplicativeExpr() {
+      let left = this.parseUnaryExpr();
+      while (true) {
+        if (this.match(TokenType.STAR)) {
+          const right = this.parseUnaryExpr();
+          left = new ASTNode(NodeType.MULTIPLICATIVE_EXPR, {
+            operator: "*",
+            left,
+            right
+          });
+        } else if (this.match(TokenType.DIV)) {
+          const right = this.parseUnaryExpr();
+          left = new ASTNode(NodeType.MULTIPLICATIVE_EXPR, {
+            operator: "div",
+            left,
+            right
+          });
+        } else if (this.match(TokenType.MOD)) {
+          const right = this.parseUnaryExpr();
+          left = new ASTNode(NodeType.MULTIPLICATIVE_EXPR, {
+            operator: "mod",
+            left,
+            right
+          });
+        } else {
+          break;
+        }
+      }
+      return left;
+    }
+    // UnaryExpr ::= UnionExpr | '-' UnaryExpr
+    parseUnaryExpr() {
+      if (this.match(TokenType.MINUS)) {
+        const operand = this.parseUnaryExpr();
+        return new ASTNode(NodeType.UNARY_EXPR, { operator: "-", operand });
+      }
+      return this.parseUnionExpr();
+    }
+    // UnionExpr ::= PathExpr | UnionExpr '|' PathExpr
+    parseUnionExpr() {
+      let left = this.parsePathExpr();
+      while (this.match(TokenType.PIPE)) {
+        const right = this.parsePathExpr();
+        left = new ASTNode(NodeType.UNION_EXPR, { left, right });
+      }
+      return left;
+    }
+    // PathExpr ::= LocationPath | FilterExpr | FilterExpr '/' RelativeLocationPath | FilterExpr '//' RelativeLocationPath
+    parsePathExpr() {
+      if (this.check(TokenType.SLASH) || this.check(TokenType.DOUBLE_SLASH)) {
+        return this.parseLocationPath();
+      }
+      if (this.isStepStart()) {
+        return this.parseLocationPath();
+      }
+      const filter = this.parseFilterExpr();
+      if (this.check(TokenType.SLASH) || this.check(TokenType.DOUBLE_SLASH)) {
+        const steps = [];
+        while (this.check(TokenType.SLASH) || this.check(TokenType.DOUBLE_SLASH)) {
+          const isDescendant = this.match(TokenType.DOUBLE_SLASH);
+          if (!isDescendant) this.advance();
+          if (isDescendant) {
+            steps.push(
+              new ASTNode(NodeType.STEP, {
+                axis: "descendant-or-self",
+                nodeTest: new ASTNode(NodeType.NODE_TYPE_TEST, {
+                  nodeType: "node"
+                }),
+                predicates: []
+              })
+            );
+          }
+          steps.push(this.parseStep());
+        }
+        return new ASTNode(NodeType.PATH_EXPR, { filter, steps });
+      }
+      return filter;
+    }
+    // LocationPath ::= RelativeLocationPath | AbsoluteLocationPath
+    parseLocationPath() {
+      let absolute = false;
+      const steps = [];
+      if (this.match(TokenType.DOUBLE_SLASH)) {
+        absolute = true;
+        steps.push(
+          new ASTNode(NodeType.STEP, {
+            axis: "descendant-or-self",
+            nodeTest: new ASTNode(NodeType.NODE_TYPE_TEST, { nodeType: "node" }),
+            predicates: []
+          })
+        );
+        if (!this.isAtEnd() && !this.check(TokenType.EOF)) {
+          steps.push(this.parseStep());
+        }
+      } else if (this.match(TokenType.SLASH)) {
+        absolute = true;
+        if (this.isStepStart()) {
+          steps.push(this.parseStep());
+        }
+      } else {
+        steps.push(this.parseStep());
+      }
+      while (this.check(TokenType.SLASH) || this.check(TokenType.DOUBLE_SLASH)) {
+        const isDescendant = this.match(TokenType.DOUBLE_SLASH);
+        if (!isDescendant) this.advance();
+        if (isDescendant) {
+          steps.push(
+            new ASTNode(NodeType.STEP, {
+              axis: "descendant-or-self",
+              nodeTest: new ASTNode(NodeType.NODE_TYPE_TEST, {
+                nodeType: "node"
+              }),
+              predicates: []
+            })
+          );
+        }
+        steps.push(this.parseStep());
+      }
+      return new ASTNode(NodeType.LOCATION_PATH, { absolute, steps });
+    }
+    // Step ::= AxisSpecifier NodeTest Predicate* | AbbreviatedStep
+    parseStep() {
+      if (this.match(TokenType.DOT)) {
+        return new ASTNode(NodeType.STEP, {
+          axis: "self",
+          nodeTest: new ASTNode(NodeType.NODE_TYPE_TEST, { nodeType: "node" }),
+          predicates: []
+        });
+      }
+      if (this.match(TokenType.DOUBLE_DOT)) {
+        return new ASTNode(NodeType.STEP, {
+          axis: "parent",
+          nodeTest: new ASTNode(NodeType.NODE_TYPE_TEST, { nodeType: "node" }),
+          predicates: []
+        });
+      }
+      let axis = "child";
+      if (this.match(TokenType.AT)) {
+        axis = "attribute";
+      } else if (this.check(TokenType.AXIS)) {
+        axis = this.advance().value;
+        this.expect(TokenType.DOUBLE_COLON);
+      }
+      const nodeTest = this.parseNodeTest();
+      const predicates = [];
+      while (this.check(TokenType.LBRACKET)) {
+        predicates.push(this.parsePredicate());
+      }
+      return new ASTNode(NodeType.STEP, { axis, nodeTest, predicates });
+    }
+    // NodeTest ::= NameTest | NodeType '(' ')' | 'processing-instruction' '(' Literal ')'
+    parseNodeTest() {
+      if (this.check(TokenType.NODE_TYPE)) {
+        const nodeType = this.advance().value;
+        this.expect(TokenType.LPAREN);
+        if (nodeType === "processing-instruction" && this.check(TokenType.LITERAL)) {
+          const name = this.advance().value;
+          this.expect(TokenType.RPAREN);
+          return new ASTNode(NodeType.PI_TEST, { name });
+        }
+        this.expect(TokenType.RPAREN);
+        return new ASTNode(NodeType.NODE_TYPE_TEST, { nodeType });
+      }
+      return this.parseNameTest();
+    }
+    // NameTest ::= '*' | NCName ':' '*' | QName
+    parseNameTest() {
+      if (this.match(TokenType.STAR)) {
+        return new ASTNode(NodeType.NAME_TEST, { name: "*", prefix: null });
+      }
+      if (!this.check(TokenType.NAME)) {
+        throw new Error(`Expected name at position ${this.peek().position}`);
+      }
+      const name = this.advance().value;
+      if (this.match(TokenType.COLON)) {
+        if (this.match(TokenType.STAR)) {
+          return new ASTNode(NodeType.NAME_TEST, { name: "*", prefix: name });
+        }
+        if (this.check(TokenType.NAME)) {
+          const localName = this.advance().value;
+          return new ASTNode(NodeType.NAME_TEST, {
+            name: localName,
+            prefix: name
+          });
+        }
+        throw new Error(
+          `Expected name or * after : at position ${this.peek().position}`
+        );
+      }
+      return new ASTNode(NodeType.NAME_TEST, { name, prefix: null });
+    }
+    // Predicate ::= '[' Expr ']'
+    parsePredicate() {
+      this.expect(TokenType.LBRACKET);
+      const expr = this.parseExpr();
+      this.expect(TokenType.RBRACKET);
+      return new ASTNode(NodeType.PREDICATE, { expr });
+    }
+    // FilterExpr ::= PrimaryExpr | FilterExpr Predicate
+    parseFilterExpr() {
+      let primary = this.parsePrimaryExpr();
+      while (this.check(TokenType.LBRACKET)) {
+        const predicate = this.parsePredicate();
+        primary = new ASTNode(NodeType.PATH_EXPR, {
+          filter: primary,
+          predicates: [predicate]
+        });
+      }
+      return primary;
+    }
+    // PrimaryExpr ::= VariableReference | '(' Expr ')' | Literal | Number | FunctionCall
+    parsePrimaryExpr() {
+      if (this.match(TokenType.DOLLAR)) {
+        if (!this.check(TokenType.NAME)) {
+          throw new Error(
+            `Expected variable name at position ${this.peek().position}`
+          );
+        }
+        const name = this.advance().value;
+        let prefix = null;
+        if (this.match(TokenType.COLON)) {
+          prefix = name;
+          if (!this.check(TokenType.NAME)) {
+            throw new Error(
+              `Expected local name at position ${this.peek().position}`
+            );
+          }
+          const localName = this.advance().value;
+          return new ASTNode(NodeType.VARIABLE_REF, { name: localName, prefix });
+        }
+        return new ASTNode(NodeType.VARIABLE_REF, { name, prefix });
+      }
+      if (this.match(TokenType.LPAREN)) {
+        const expr = this.parseExpr();
+        this.expect(TokenType.RPAREN);
+        return expr;
+      }
+      if (this.check(TokenType.LITERAL)) {
+        return new ASTNode(NodeType.LITERAL, { value: this.advance().value });
+      }
+      if (this.check(TokenType.NUMBER)) {
+        return new ASTNode(NodeType.NUMBER, { value: this.advance().value });
+      }
+      if (this.check(TokenType.FUNCTION)) {
+        return this.parseFunctionCall();
+      }
+      throw new Error(
+        `Unexpected token ${this.peek().type} at position ${this.peek().position}`
+      );
+    }
+    // FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument )* )? ')'
+    // Note: Prefixed function calls (prefix:fn()) are not supported because
+    // the tokenizer identifies functions by NAME followed by '(' - prefixed
+    // names like 'fn:name()' are tokenized as NAME:NAME() which is parsed
+    // as a location path, not a function call.
+    parseFunctionCall() {
+      const name = this.advance().value;
+      return this.parseFunctionCallArgs(name, null);
+    }
+    parseFunctionCallArgs(name, prefix) {
+      this.expect(TokenType.LPAREN);
+      const args = [];
+      if (!this.check(TokenType.RPAREN)) {
+        args.push(this.parseExpr());
+        while (this.match(TokenType.COMMA)) {
+          args.push(this.parseExpr());
+        }
+      }
+      this.expect(TokenType.RPAREN);
+      return new ASTNode(NodeType.FUNCTION_CALL, { name, prefix, args });
+    }
+    // Helper methods
+    isStepStart() {
+      const type = this.peek().type;
+      return type === TokenType.NAME || type === TokenType.STAR || type === TokenType.AT || type === TokenType.DOT || type === TokenType.DOUBLE_DOT || type === TokenType.AXIS || type === TokenType.NODE_TYPE;
+    }
+    peek() {
+      return this.tokens[this.position];
+    }
+    advance() {
+      if (!this.isAtEnd()) {
+        return this.tokens[this.position++];
+      }
+      return this.tokens[this.position];
+    }
+    check(type) {
+      if (this.isAtEnd()) return false;
+      return this.peek().type === type;
+    }
+    match(type) {
+      if (this.check(type)) {
+        this.advance();
+        return true;
+      }
+      return false;
+    }
+    expect(type) {
+      if (!this.check(type)) {
+        throw new Error(
+          `Expected ${type} but got ${this.peek().type} at position ${this.peek().position}`
+        );
+      }
+      return this.advance();
+    }
+    isAtEnd() {
+      return this.peek().type === TokenType.EOF;
+    }
+  };
+  function parse(expression) {
+    const tokens = tokenize(expression);
+    const parser = new XPathParser(tokens);
+    return parser.parse();
+  }
+
+  // src/xpath/evaluator.js
+  var XPathResultType = {
+    ANY_TYPE: 0,
+    NUMBER_TYPE: 1,
+    STRING_TYPE: 2,
+    BOOLEAN_TYPE: 3,
+    UNORDERED_NODE_ITERATOR_TYPE: 4,
+    ORDERED_NODE_ITERATOR_TYPE: 5,
+    UNORDERED_NODE_SNAPSHOT_TYPE: 6,
+    ORDERED_NODE_SNAPSHOT_TYPE: 7,
+    ANY_UNORDERED_NODE_TYPE: 8,
+    FIRST_ORDERED_NODE_TYPE: 9
+  };
+  var XPathLimits = {
+    MAX_RECURSION_DEPTH: 100,
+    MAX_RESULT_SIZE: 1e4,
+    MAX_STRING_LENGTH: 1e6
+  };
+  var FORBIDDEN_VARIABLE_NAMES = Object.freeze([
+    "__proto__",
+    "constructor",
+    "prototype",
+    "__defineGetter__",
+    "__defineSetter__",
+    "__lookupGetter__",
+    "__lookupSetter__"
+  ]);
+  var XPathContext = class _XPathContext {
+    constructor(node, position = 1, size = 1, variables = {}, namespaces = {}) {
+      this.node = node;
+      this.position = position;
+      this.size = size;
+      this.variables = variables;
+      this.namespaces = namespaces;
+    }
+    clone(overrides = {}) {
+      return new _XPathContext(
+        overrides.node ?? this.node,
+        overrides.position ?? this.position,
+        overrides.size ?? this.size,
+        overrides.variables ?? this.variables,
+        overrides.namespaces ?? this.namespaces
+      );
+    }
+  };
+  var XPathEvaluator = class {
+    constructor(options = {}) {
+      this.functions = this.initCoreFunctions();
+      this.maxRecursionDepth = options.maxRecursionDepth ?? XPathLimits.MAX_RECURSION_DEPTH;
+      this.maxResultSize = options.maxResultSize ?? XPathLimits.MAX_RESULT_SIZE;
+      this.maxStringLength = options.maxStringLength ?? XPathLimits.MAX_STRING_LENGTH;
+      this.recursionDepth = 0;
+    }
+    /**
+     * Evaluate XPath expression against a context
+     * @throws {Error} If recursion depth exceeds limit
+     * @throws {Error} If AST is invalid
+     */
+    evaluate(ast, context) {
+      if (!ast || typeof ast !== "object") {
+        throw new Error("Invalid AST: expected object");
+      }
+      if (!ast.type) {
+        throw new Error("Invalid AST: missing type property");
+      }
+      this.recursionDepth++;
+      if (this.recursionDepth > this.maxRecursionDepth) {
+        this.recursionDepth = 0;
+        throw new Error(
+          `Maximum recursion depth exceeded (${this.maxRecursionDepth})`
+        );
+      }
+      try {
+        return this.evaluateInternal(ast, context);
+      } finally {
+        this.recursionDepth--;
+      }
+    }
+    /**
+     * Internal evaluation (after validation)
+     */
+    evaluateInternal(ast, context) {
+      switch (ast.type) {
+        case NodeType.OR_EXPR:
+          return this.evalOrExpr(ast, context);
+        case NodeType.AND_EXPR:
+          return this.evalAndExpr(ast, context);
+        case NodeType.EQUALITY_EXPR:
+          return this.evalEqualityExpr(ast, context);
+        case NodeType.RELATIONAL_EXPR:
+          return this.evalRelationalExpr(ast, context);
+        case NodeType.ADDITIVE_EXPR:
+          return this.evalAdditiveExpr(ast, context);
+        case NodeType.MULTIPLICATIVE_EXPR:
+          return this.evalMultiplicativeExpr(ast, context);
+        case NodeType.UNARY_EXPR:
+          return this.evalUnaryExpr(ast, context);
+        case NodeType.UNION_EXPR:
+          return this.evalUnionExpr(ast, context);
+        case NodeType.PATH_EXPR:
+          return this.evalPathExpr(ast, context);
+        case NodeType.LOCATION_PATH:
+          return this.evalLocationPath(ast, context);
+        case NodeType.VARIABLE_REF:
+          return this.evalVariableRef(ast, context);
+        case NodeType.LITERAL:
+          return this.validateString(ast.value);
+        case NodeType.NUMBER:
+          return ast.value;
+        case NodeType.FUNCTION_CALL:
+          return this.evalFunctionCall(ast, context);
+        default:
+          throw new Error(`Unknown AST node type: ${String(ast.type)}`);
+      }
+    }
+    /**
+     * Validate and limit string length
+     */
+    validateString(str) {
+      if (typeof str === "string" && str.length > this.maxStringLength) {
+        throw new Error(
+          `String exceeds maximum length (${this.maxStringLength})`
+        );
+      }
+      return str;
+    }
+    /**
+     * Validate result size
+     */
+    validateResultSize(nodes) {
+      if (Array.isArray(nodes) && nodes.length > this.maxResultSize) {
+        throw new Error(
+          `Result set exceeds maximum size (${this.maxResultSize})`
+        );
+      }
+      return nodes;
+    }
+    evalOrExpr(ast, context) {
+      return this.toBoolean(this.evaluate(ast.left, context)) || this.toBoolean(this.evaluate(ast.right, context));
+    }
+    evalAndExpr(ast, context) {
+      return this.toBoolean(this.evaluate(ast.left, context)) && this.toBoolean(this.evaluate(ast.right, context));
+    }
+    evalEqualityExpr(ast, context) {
+      const left = this.evaluate(ast.left, context);
+      const right = this.evaluate(ast.right, context);
+      const isEqual = this.compareValues(left, right, "=");
+      return ast.operator === "=" ? isEqual : !isEqual;
+    }
+    evalRelationalExpr(ast, context) {
+      const left = this.evaluate(ast.left, context);
+      const right = this.evaluate(ast.right, context);
+      return this.compareValues(left, right, ast.operator);
+    }
+    evalAdditiveExpr(ast, context) {
+      const left = this.toNumber(this.evaluate(ast.left, context));
+      const right = this.toNumber(this.evaluate(ast.right, context));
+      return ast.operator === "+" ? left + right : left - right;
+    }
+    evalMultiplicativeExpr(ast, context) {
+      const left = this.toNumber(this.evaluate(ast.left, context));
+      const right = this.toNumber(this.evaluate(ast.right, context));
+      switch (ast.operator) {
+        case "*":
+          return left * right;
+        case "div":
+          return left / right;
+        case "mod":
+          return left % right;
+        default:
+          throw new Error(`Unknown multiplicative operator: ${ast.operator}`);
+      }
+    }
+    evalUnaryExpr(ast, context) {
+      const value = this.toNumber(this.evaluate(ast.operand, context));
+      return -value;
+    }
+    evalUnionExpr(ast, context) {
+      const left = this.evaluate(ast.left, context);
+      const right = this.evaluate(ast.right, context);
+      const leftNodes = Array.isArray(left) ? left : [left];
+      const rightNodes = Array.isArray(right) ? right : [right];
+      const seen = /* @__PURE__ */ new Set();
+      const result = [];
+      for (const node of [...leftNodes, ...rightNodes]) {
+        if (!seen.has(node)) {
+          seen.add(node);
+          result.push(node);
+        }
+      }
+      this.validateResultSize(result);
+      return this.sortByDocumentOrder(result);
+    }
+    evalPathExpr(ast, context) {
+      if (ast.filter) {
+        let result = this.evaluate(ast.filter, context);
+        if (ast.predicates) {
+          for (const pred of ast.predicates) {
+            result = this.filterByPredicate(result, pred, context);
+          }
+        }
+        if (ast.steps) {
+          for (const step of ast.steps) {
+            result = this.evalStepOnNodes(step, result, context);
+          }
+        }
+        return result;
+      }
+      return [];
+    }
+    evalLocationPath(ast, context) {
+      let nodes;
+      if (ast.absolute) {
+        const doc = context.node.ownerDocument || context.node;
+        nodes = [doc];
+      } else {
+        nodes = [context.node];
+      }
+      for (const step of ast.steps) {
+        nodes = this.evalStepOnNodes(step, nodes, context);
+        this.validateResultSize(nodes);
+      }
+      return nodes;
+    }
+    evalStepOnNodes(step, nodes, context) {
+      const allNodes = Array.isArray(nodes) ? nodes : [nodes];
+      let result = [];
+      for (const node of allNodes) {
+        const stepNodes = this.evalStep(step, context.clone({ node }));
+        result = result.concat(stepNodes);
+        if (result.length > this.maxResultSize * 2) {
+          this.validateResultSize(result);
+        }
+      }
+      const uniqueResult = [...new Set(result)];
+      this.validateResultSize(uniqueResult);
+      return this.sortByDocumentOrder(uniqueResult);
+    }
+    evalStep(step, context) {
+      let nodes = this.getAxisNodes(step.axis, context.node);
+      nodes = nodes.filter((n) => this.matchNodeTest(step.nodeTest, n, context));
+      for (const predicate of step.predicates) {
+        nodes = this.filterByPredicate(nodes, predicate, context);
+      }
+      return nodes;
+    }
+    getAxisNodes(axis, node) {
+      switch (axis) {
+        case "child":
+          return Array.from(node.childNodes || []);
+        case "parent":
+          return node.parentNode ? [node.parentNode] : [];
+        case "self":
+          return [node];
+        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 "attribute":
+          if (node.attributes) {
+            return Array.from(node.attributes);
+          }
+          return [];
+        case "namespace":
+          return [];
+        default:
+          throw new Error(`Unknown axis: ${axis}`);
+      }
+    }
+    getDescendants(node, includeSelf) {
+      const result = includeSelf ? [node] : [];
+      const stack = Array.from(node.childNodes || []).reverse();
+      while (stack.length > 0) {
+        const current = stack.pop();
+        result.push(current);
+        if (current.childNodes) {
+          for (let i = current.childNodes.length - 1; i >= 0; i--) {
+            stack.push(current.childNodes[i]);
+          }
+        }
+      }
+      return result;
+    }
+    getAncestors(node, includeSelf) {
+      const result = includeSelf ? [node] : [];
+      let current = node.parentNode;
+      while (current) {
+        result.push(current);
+        current = current.parentNode;
+      }
+      return result;
+    }
+    getFollowingSiblings(node) {
+      const result = [];
+      if (!node) return result;
+      let current = node.nextSibling;
+      while (current) {
+        result.push(current);
+        current = current.nextSibling;
+      }
+      return result;
+    }
+    getPrecedingSiblings(node) {
+      const result = [];
+      if (!node) return result;
+      let current = node.previousSibling;
+      while (current) {
+        result.push(current);
+        current = current.previousSibling;
+      }
+      return result.reverse();
+    }
+    getFollowing(node) {
+      const result = [];
+      let current = node;
+      while (current) {
+        if (current.nextSibling) {
+          current = current.nextSibling;
+          result.push(current);
+          result.push(...this.getDescendants(current, false));
+        } else {
+          current = current.parentNode;
+        }
+      }
+      return result;
+    }
+    getPreceding(node) {
+      const result = [];
+      let current = node;
+      while (current) {
+        if (current.previousSibling) {
+          current = current.previousSibling;
+          const descendants = this.getDescendants(current, false);
+          result.unshift(...descendants.reverse());
+          result.unshift(current);
+        } else {
+          current = current.parentNode;
+          if (current && current.nodeType !== 9) {
+          }
+        }
+      }
+      return result;
+    }
+    matchNodeTest(nodeTest, node, context) {
+      switch (nodeTest.type) {
+        case NodeType.NAME_TEST:
+          return this.matchNameTest(nodeTest, node, context);
+        case NodeType.NODE_TYPE_TEST:
+          return this.matchNodeTypeTest(nodeTest.nodeType, node);
+        case NodeType.PI_TEST:
+          return node.nodeType === 7 && node.nodeName === nodeTest.name;
+        default:
+          return false;
+      }
+    }
+    matchNameTest(nodeTest, node, context) {
+      if (node.nodeType !== 1 && node.nodeType !== 2) {
+        return false;
+      }
+      const name = nodeTest.name;
+      const prefix = nodeTest.prefix;
+      if (name === "*" && !prefix) {
+        return true;
+      }
+      const nodeName = node.localName || node.nodeName;
+      const nodeNs = node.namespaceURI || null;
+      if (name === "*" && prefix) {
+        const ns2 = context.namespaces[prefix];
+        return nodeNs === ns2;
+      }
+      if (!prefix) {
+        const doc = node.ownerDocument;
+        if (doc && doc.contentType === "text/html" && node.nodeType === 1) {
+          return nodeName.toLowerCase() === name.toLowerCase();
+        }
+        return nodeName === name;
+      }
+      const ns = context.namespaces[prefix];
+      return nodeName === name && nodeNs === ns;
+    }
+    matchNodeTypeTest(nodeType, node) {
+      switch (nodeType) {
+        case "node":
+          return true;
+        case "text":
+          return node.nodeType === 3;
+        case "comment":
+          return node.nodeType === 8;
+        case "processing-instruction":
+          return node.nodeType === 7;
+        default:
+          return false;
+      }
+    }
+    filterByPredicate(nodes, predicate, context) {
+      const result = [];
+      const nodeArray = Array.isArray(nodes) ? nodes : [nodes];
+      const size = nodeArray.length;
+      for (let i = 0; i < nodeArray.length; i++) {
+        const node = nodeArray[i];
+        const predicateContext = context.clone({
+          node,
+          position: i + 1,
+          size
+        });
+        const value = this.evaluate(predicate.expr, predicateContext);
+        if (typeof value === "number") {
+          if (value === i + 1) {
+            result.push(node);
+          }
+        } else if (this.toBoolean(value)) {
+          result.push(node);
+        }
+      }
+      return result;
+    }
+    evalVariableRef(ast, context) {
+      const name = ast.prefix ? `${ast.prefix}:${ast.name}` : ast.name;
+      if (FORBIDDEN_VARIABLE_NAMES.includes(name) || FORBIDDEN_VARIABLE_NAMES.includes(ast.name)) {
+        throw new Error(`Forbidden variable name: $${name}`);
+      }
+      if (!Object.prototype.hasOwnProperty.call(context.variables, name)) {
+        throw new Error(`Undefined variable: $${name}`);
+      }
+      return context.variables[name];
+    }
+    evalFunctionCall(ast, context) {
+      const name = ast.prefix ? `${ast.prefix}:${ast.name}` : ast.name;
+      const fn = this.functions[name];
+      if (!fn) {
+        throw new Error(`Unknown function: ${name}`);
+      }
+      return fn.call(this, ast.args, context);
+    }
+    // Type conversion functions
+    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;
+      if (value && value.nodeType) return true;
+      return Boolean(value);
+    }
+    toNumber(value) {
+      if (typeof value === "number") return value;
+      if (typeof value === "boolean") return value ? 1 : 0;
+      if (typeof value === "string") {
+        const trimmed = value.trim();
+        if (trimmed === "") return NaN;
+        const num = Number(trimmed);
+        return num;
+      }
+      if (Array.isArray(value)) {
+        return this.toNumber(this.toString(value));
+      }
+      if (value && value.nodeType) {
+        return this.toNumber(this.getStringValue(value));
+      }
+      return NaN;
+    }
+    toString(value) {
+      if (typeof value === "string") return value;
+      if (typeof value === "number") {
+        if (isNaN(value)) return "NaN";
+        if (value === Infinity) return "Infinity";
+        if (value === -Infinity) return "-Infinity";
+        if (value === 0) return "0";
+        return String(value);
+      }
+      if (typeof value === "boolean") return value ? "true" : "false";
+      if (Array.isArray(value)) {
+        if (value.length === 0) return "";
+        return this.getStringValue(value[0]);
+      }
+      if (value && value.nodeType) {
+        return this.getStringValue(value);
+      }
+      return String(value);
+    }
+    getStringValue(node) {
+      if (!node) return "";
+      switch (node.nodeType) {
+        case 1:
+        // Element
+        case 9:
+        // Document
+        case 11: {
+          let text = "";
+          const walker = (n) => {
+            if (n.nodeType === 3) {
+              text += n.nodeValue || "";
+            } else if (n.childNodes) {
+              for (const child of n.childNodes) {
+                walker(child);
+              }
+            }
+          };
+          walker(node);
+          return text;
+        }
+        case 2:
+        // Attribute
+        case 3:
+        // Text
+        case 4:
+        // CDATA
+        case 7:
+        // Processing Instruction
+        case 8:
+          return node.nodeValue || "";
+        default:
+          return "";
+      }
+    }
+    // Comparison helper
+    compareValues(left, right, operator) {
+      const leftIsNodeSet = Array.isArray(left);
+      const rightIsNodeSet = Array.isArray(right);
+      if (leftIsNodeSet && rightIsNodeSet) {
+        for (const l of left) {
+          for (const r of right) {
+            if (this.comparePrimitive(
+              this.getStringValue(l),
+              this.getStringValue(r),
+              operator
+            )) {
+              return true;
+            }
+          }
+        }
+        return false;
+      }
+      if (leftIsNodeSet) {
+        for (const l of left) {
+          if (this.comparePrimitive(this.getStringValue(l), right, operator)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      if (rightIsNodeSet) {
+        for (const r of right) {
+          if (this.comparePrimitive(left, this.getStringValue(r), operator)) {
+            return true;
+          }
+        }
+        return false;
+      }
+      return this.comparePrimitive(left, right, operator);
+    }
+    comparePrimitive(left, right, operator) {
+      if (operator === "=" || operator === "!=") {
+        if (typeof left === "boolean" || typeof right === "boolean") {
+          const result2 = this.toBoolean(left) === this.toBoolean(right);
+          return operator === "=" ? result2 : !result2;
+        }
+        if (typeof left === "number" || typeof right === "number") {
+          const result2 = this.toNumber(left) === this.toNumber(right);
+          return operator === "=" ? result2 : !result2;
+        }
+        const result = this.toString(left) === this.toString(right);
+        return operator === "=" ? result : !result;
+      }
+      const leftNum = this.toNumber(left);
+      const rightNum = this.toNumber(right);
+      switch (operator) {
+        case "<":
+          return leftNum < rightNum;
+        case "<=":
+          return leftNum <= rightNum;
+        case ">":
+          return leftNum > rightNum;
+        case ">=":
+          return leftNum >= rightNum;
+        default:
+          throw new Error(`Unknown comparison operator: ${operator}`);
+      }
+    }
+    sortByDocumentOrder(nodes) {
+      if (nodes.length <= 1) return nodes;
+      return nodes.sort((a, b) => {
+        if (a === b) return 0;
+        const position = a.compareDocumentPosition ? a.compareDocumentPosition(b) : this.compareDocumentPositionFallback(a, b);
+        if (position & 4) return -1;
+        if (position & 2) return 1;
+        return 0;
+      });
+    }
+    compareDocumentPositionFallback(a, b) {
+      const getPath = (node) => {
+        const path = [];
+        let current = node;
+        while (current) {
+          if (current.parentNode) {
+            const siblings = Array.from(current.parentNode.childNodes);
+            path.unshift(siblings.indexOf(current));
+          }
+          current = current.parentNode;
+        }
+        return path;
+      };
+      const pathA = getPath(a);
+      const pathB = getPath(b);
+      for (let i = 0; i < Math.min(pathA.length, pathB.length); i++) {
+        if (pathA[i] < pathB[i]) return 4;
+        if (pathA[i] > pathB[i]) return 2;
+      }
+      return pathA.length < pathB.length ? 4 : 2;
+    }
+    /**
+     * Initialize XPath 1.0 core functions
+     */
+    initCoreFunctions() {
+      return {
+        // Node set functions
+        last: (args, ctx) => ctx.size,
+        position: (args, ctx) => ctx.position,
+        count: (args, ctx) => {
+          const nodeSet = this.evaluate(args[0], ctx);
+          return Array.isArray(nodeSet) ? nodeSet.length : 1;
+        },
+        id: (args, ctx) => {
+          const value = this.toString(this.evaluate(args[0], ctx));
+          const doc = ctx.node.ownerDocument || ctx.node;
+          const ids = value.split(/\s+/).filter((id) => id);
+          const result = [];
+          for (const id of ids) {
+            const el = doc.getElementById(id);
+            if (el) result.push(el);
+          }
+          return result;
+        },
+        "local-name": (args, ctx) => {
+          let node;
+          if (args.length === 0) {
+            node = ctx.node;
+          } else {
+            const nodeSet = this.evaluate(args[0], ctx);
+            node = Array.isArray(nodeSet) ? nodeSet[0] : nodeSet;
+          }
+          if (!node) return "";
+          return node.localName || node.nodeName || "";
+        },
+        "namespace-uri": (args, ctx) => {
+          let node;
+          if (args.length === 0) {
+            node = ctx.node;
+          } else {
+            const nodeSet = this.evaluate(args[0], ctx);
+            node = Array.isArray(nodeSet) ? nodeSet[0] : nodeSet;
+          }
+          if (!node) return "";
+          return node.namespaceURI || "";
+        },
+        name: (args, ctx) => {
+          let node;
+          if (args.length === 0) {
+            node = ctx.node;
+          } else {
+            const nodeSet = this.evaluate(args[0], ctx);
+            node = Array.isArray(nodeSet) ? nodeSet[0] : nodeSet;
+          }
+          if (!node) return "";
+          return node.nodeName || "";
+        },
+        // String functions
+        string: (args, ctx) => {
+          if (args.length === 0) {
+            return this.toString([ctx.node]);
+          }
+          return this.toString(this.evaluate(args[0], ctx));
+        },
+        concat: (args, ctx) => {
+          return args.map((arg) => this.toString(this.evaluate(arg, ctx))).join("");
+        },
+        "starts-with": (args, ctx) => {
+          const str = this.toString(this.evaluate(args[0], ctx));
+          const prefix = this.toString(this.evaluate(args[1], ctx));
+          return str.startsWith(prefix);
+        },
+        contains: (args, ctx) => {
+          const str = this.toString(this.evaluate(args[0], ctx));
+          const substr = this.toString(this.evaluate(args[1], ctx));
+          return str.includes(substr);
+        },
+        "substring-before": (args, ctx) => {
+          const str = this.toString(this.evaluate(args[0], ctx));
+          const substr = this.toString(this.evaluate(args[1], ctx));
+          const idx = str.indexOf(substr);
+          return idx === -1 ? "" : str.substring(0, idx);
+        },
+        "substring-after": (args, ctx) => {
+          const str = this.toString(this.evaluate(args[0], ctx));
+          const substr = this.toString(this.evaluate(args[1], ctx));
+          const idx = str.indexOf(substr);
+          return idx === -1 ? "" : str.substring(idx + substr.length);
+        },
+        substring: (args, ctx) => {
+          const str = this.toString(this.evaluate(args[0], ctx));
+          let start = Math.round(this.toNumber(this.evaluate(args[1], ctx)));
+          let length;
+          if (args.length > 2) {
+            length = Math.round(this.toNumber(this.evaluate(args[2], ctx)));
+          }
+          start = start - 1;
+          if (isNaN(start)) return "";
+          if (start < 0) {
+            if (length !== void 0) {
+              length = length + start;
+            }
+            start = 0;
+          }
+          if (length !== void 0) {
+            if (isNaN(length) || length <= 0) return "";
+            return str.substring(start, start + length);
+          }
+          return str.substring(start);
+        },
+        "string-length": (args, ctx) => {
+          const str = args.length === 0 ? this.toString([ctx.node]) : this.toString(this.evaluate(args[0], ctx));
+          return str.length;
+        },
+        "normalize-space": (args, ctx) => {
+          const str = args.length === 0 ? this.toString([ctx.node]) : this.toString(this.evaluate(args[0], ctx));
+          return str.trim().replace(/\s+/g, " ");
+        },
+        translate: (args, ctx) => {
+          const str = this.toString(this.evaluate(args[0], ctx));
+          const from = this.toString(this.evaluate(args[1], ctx));
+          const to = this.toString(this.evaluate(args[2], ctx));
+          let result = "";
+          for (const char of str) {
+            const idx = from.indexOf(char);
+            if (idx === -1) {
+              result += char;
+            } else if (idx < to.length) {
+              result += to[idx];
+            }
+          }
+          return result;
+        },
+        // Boolean functions
+        boolean: (args, ctx) => {
+          return this.toBoolean(this.evaluate(args[0], ctx));
+        },
+        not: (args, ctx) => {
+          return !this.toBoolean(this.evaluate(args[0], ctx));
+        },
+        true: () => true,
+        false: () => false,
+        lang: (args, ctx) => {
+          const lang = this.toString(this.evaluate(args[0], ctx)).toLowerCase();
+          let node = ctx.node;
+          while (node && node.nodeType === 1) {
+            const xmlLang = node.getAttribute("xml:lang") || node.getAttribute("lang");
+            if (xmlLang) {
+              const nodeLang = xmlLang.toLowerCase();
+              return nodeLang === lang || nodeLang.startsWith(lang + "-");
+            }
+            node = node.parentNode;
+          }
+          return false;
+        },
+        // Number functions
+        number: (args, ctx) => {
+          if (args.length === 0) {
+            return this.toNumber([ctx.node]);
+          }
+          return this.toNumber(this.evaluate(args[0], ctx));
+        },
+        sum: (args, ctx) => {
+          const nodeSet = this.evaluate(args[0], ctx);
+          if (!Array.isArray(nodeSet)) return NaN;
+          return nodeSet.reduce(
+            (sum, node) => sum + this.toNumber(this.getStringValue(node)),
+            0
+          );
+        },
+        floor: (args, ctx) => {
+          return Math.floor(this.toNumber(this.evaluate(args[0], ctx)));
+        },
+        ceiling: (args, ctx) => {
+          return Math.ceil(this.toNumber(this.evaluate(args[0], ctx)));
+        },
+        round: (args, ctx) => {
+          const num = this.toNumber(this.evaluate(args[0], ctx));
+          if (isNaN(num)) return NaN;
+          if (num === -0.5) return -0;
+          return Math.round(num);
+        }
+      };
+    }
+  };
+
+  // src/xslt/engine.js
+  var XSLT_NS = "http://www.w3.org/1999/XSL/Transform";
+  var XsltContext = class _XsltContext {
+    constructor(options = {}) {
+      this.currentNode = options.currentNode;
+      this.currentNodeList = options.currentNodeList || [];
+      this.position = options.position || 1;
+      this.variables = { ...options.variables };
+      this.parameters = { ...options.parameters };
+      this.outputDocument = options.outputDocument;
+      this.stylesheet = options.stylesheet;
+      this.namespaces = { ...options.namespaces };
+      this.templates = options.templates || [];
+      this.keys = options.keys || {};
+      this.decimalFormats = options.decimalFormats || {};
+      this.outputMethod = options.outputMethod || "xml";
+      this.xpathEvaluator = options.xpathEvaluator || new XPathEvaluator();
+    }
+    clone(overrides = {}) {
+      return new _XsltContext({
+        currentNode: overrides.currentNode ?? this.currentNode,
+        currentNodeList: overrides.currentNodeList ?? this.currentNodeList,
+        position: overrides.position ?? this.position,
+        variables: overrides.variables ? { ...this.variables, ...overrides.variables } : { ...this.variables },
+        parameters: overrides.parameters ? { ...this.parameters, ...overrides.parameters } : { ...this.parameters },
+        outputDocument: this.outputDocument,
+        stylesheet: this.stylesheet,
+        namespaces: overrides.namespaces ? { ...this.namespaces, ...overrides.namespaces } : { ...this.namespaces },
+        templates: this.templates,
+        keys: this.keys,
+        decimalFormats: this.decimalFormats,
+        outputMethod: this.outputMethod,
+        xpathEvaluator: this.xpathEvaluator
+      });
+    }
+    getVariable(name) {
+      if (name in this.variables) {
+        return this.variables[name];
+      }
+      if (name in this.parameters) {
+        return this.parameters[name];
+      }
+      throw new Error(`Undefined variable: $${name}`);
+    }
+    setVariable(name, value) {
+      this.variables[name] = value;
+    }
+  };
+  var XsltEngine = class {
+    constructor(options = {}) {
+      this.xpathEvaluator = new XPathEvaluator();
+      this.templates = [];
+      this.keys = {};
+      this.globalVariables = {};
+      this.globalParameters = {};
+      this.outputSettings = {
+        method: "xml",
+        encoding: "UTF-8",
+        indent: "no",
+        omitXmlDeclaration: "no",
+        doctypePublic: null,
+        doctypeSystem: null,
+        mediaType: null,
+        cdataSectionElements: []
+      };
+      this.namespaces = {};
+      this.decimalFormats = {};
+      this.stylesheetDoc = null;
+      this.attributeSets = {};
+      this.namespaceAliases = {};
+      this.stripSpace = [];
+      this.preserveSpace = [];
+      this.stylesheetLoader = options.stylesheetLoader || null;
+      this.currentImportPrecedence = 0;
+      this.processedStylesheets = /* @__PURE__ */ new Set();
+      this.baseUri = options.baseUri || "";
+    }
+    /**
+     * Set the stylesheet loader function for xsl:import and xsl:include
+     * @param {Function} loader - Function(href, baseUri) => Document or string (XML)
+     */
+    setStylesheetLoader(loader) {
+      this.stylesheetLoader = loader;
+    }
+    /**
+     * Resolve a relative URI against a base URI
+     */
+    resolveUri(href, baseUri) {
+      if (!baseUri || href.startsWith("http://") || href.startsWith("https://") || href.startsWith("/")) {
+        return href;
+      }
+      const lastSlash = baseUri.lastIndexOf("/");
+      const baseDir = lastSlash >= 0 ? baseUri.substring(0, lastSlash + 1) : "";
+      return baseDir + href;
+    }
+    /**
+     * Load an external stylesheet document
+     */
+    loadStylesheet(href, baseUri) {
+      if (!this.stylesheetLoader) {
+        throw new Error(
+          `Cannot load stylesheet "${href}": no stylesheetLoader configured. Use engine.setStylesheetLoader(fn) to provide a loader function.`
+        );
+      }
+      const resolvedUri = this.resolveUri(href, baseUri);
+      const result = this.stylesheetLoader(resolvedUri, baseUri);
+      return { document: result, uri: resolvedUri };
+    }
+    /**
+     * Parse XML string to document (helper for stylesheet loading)
+     */
+    parseXmlString(xmlString) {
+      if (typeof DOMParser !== "undefined") {
+        const parser = new DOMParser();
+        const doc = parser.parseFromString(xmlString, "application/xml");
+        const parseError = doc.querySelector("parsererror");
+        if (parseError) {
+          throw new Error(`XML parse error: ${parseError.textContent}`);
+        }
+        return doc;
+      }
+      throw new Error("XML parsing not available in this environment");
+    }
+    /**
+     * Import and compile an XSLT stylesheet
+     * @param {Document|Element} stylesheetNode - The stylesheet document or root element
+     * @param {string} [stylesheetUri] - Optional URI of the stylesheet for resolving imports
+     */
+    importStylesheet(stylesheetNode, stylesheetUri) {
+      const isMainStylesheet = this.stylesheetDoc === null;
+      if (isMainStylesheet) {
+        this.stylesheetDoc = stylesheetNode.ownerDocument || stylesheetNode;
+        if (stylesheetUri) {
+          this.baseUri = stylesheetUri;
+          this.processedStylesheets.add(stylesheetUri);
+        }
+      }
+      const root = stylesheetNode.documentElement || stylesheetNode;
+      if (!this.isXsltElement(root, "stylesheet") && !this.isXsltElement(root, "transform")) {
+        if (root.getAttribute && root.getAttribute("xsl:version")) {
+          this.processLiteralResultStylesheet(root);
+          return;
+        }
+        throw new Error(
+          "Invalid XSLT stylesheet: root element must be xsl:stylesheet or xsl:transform"
+        );
+      }
+      this.collectNamespaces(root);
+      const imports = [];
+      const otherElements = [];
+      for (const child of root.childNodes) {
+        if (child.nodeType !== 1) continue;
+        if (this.isXsltElement(child, "import")) {
+          imports.push(child);
+        } else {
+          otherElements.push(child);
+        }
+      }
+      for (const importNode of imports) {
+        this.processImport(importNode, stylesheetUri || this.baseUri);
+      }
+      for (const child of otherElements) {
+        if (this.isXsltElement(child, "template")) {
+          this.registerTemplate(child);
+        } else if (this.isXsltElement(child, "output")) {
+          this.processOutput(child);
+        } else if (this.isXsltElement(child, "variable")) {
+          this.processGlobalVariable(child);
+        } else if (this.isXsltElement(child, "param")) {
+          this.processGlobalParam(child);
+        } else if (this.isXsltElement(child, "key")) {
+          this.processKey(child);
+        } else if (this.isXsltElement(child, "decimal-format")) {
+          this.processDecimalFormat(child);
+        } else if (this.isXsltElement(child, "namespace-alias")) {
+          this.processNamespaceAlias(child);
+        } else if (this.isXsltElement(child, "attribute-set")) {
+          this.processAttributeSet(child);
+        } else if (this.isXsltElement(child, "strip-space")) {
+          this.processStripSpace(child);
+        } else if (this.isXsltElement(child, "preserve-space")) {
+          this.processPreserveSpace(child);
+        } else if (this.isXsltElement(child, "include")) {
+          this.processInclude(child, stylesheetUri || this.baseUri);
+        }
+      }
+      if (isMainStylesheet) {
+        this.currentImportPrecedence++;
+      }
+    }
+    /**
+     * Process xsl:include element
+     * Includes are merged at the same import precedence level
+     */
+    processInclude(node, baseUri) {
+      const href = node.getAttribute("href");
+      if (!href) {
+        throw new Error("xsl:include requires an href attribute");
+      }
+      const resolvedUri = this.resolveUri(href, baseUri);
+      if (this.processedStylesheets.has(resolvedUri)) {
+        throw new Error(`Circular stylesheet reference detected: ${resolvedUri}`);
+      }
+      this.processedStylesheets.add(resolvedUri);
+      try {
+        const { document: stylesheetDoc } = this.loadStylesheet(href, baseUri);
+        let doc = stylesheetDoc;
+        if (typeof stylesheetDoc === "string") {
+          doc = this.parseXmlString(stylesheetDoc);
+        }
+        const savedPrecedence = this.currentImportPrecedence;
+        this.processIncludedStylesheet(doc, resolvedUri);
+        this.currentImportPrecedence = savedPrecedence;
+      } catch (error) {
+        throw new Error(
+          `Failed to include stylesheet "${href}": ${error.message}`
+        );
+      }
+    }
+    /**
+     * Process xsl:import element
+     * Imports have lower precedence than the importing stylesheet
+     */
+    processImport(node, baseUri) {
+      const href = node.getAttribute("href");
+      if (!href) {
+        throw new Error("xsl:import requires an href attribute");
+      }
+      const resolvedUri = this.resolveUri(href, baseUri);
+      if (this.processedStylesheets.has(resolvedUri)) {
+        throw new Error(`Circular stylesheet reference detected: ${resolvedUri}`);
+      }
+      this.processedStylesheets.add(resolvedUri);
+      try {
+        const { document: stylesheetDoc } = this.loadStylesheet(href, baseUri);
+        let doc = stylesheetDoc;
+        if (typeof stylesheetDoc === "string") {
+          doc = this.parseXmlString(stylesheetDoc);
+        }
+        this.processIncludedStylesheet(doc, resolvedUri);
+        this.currentImportPrecedence++;
+      } catch (error) {
+        throw new Error(
+          `Failed to import stylesheet "${href}": ${error.message}`
+        );
+      }
+    }
+    /**
+     * Process an included/imported stylesheet document
+     */
+    processIncludedStylesheet(stylesheetDoc, stylesheetUri) {
+      const root = stylesheetDoc.documentElement || stylesheetDoc;
+      if (!this.isXsltElement(root, "stylesheet") && !this.isXsltElement(root, "transform")) {
+        throw new Error(
+          "Included/imported document is not a valid XSLT stylesheet"
+        );
+      }
+      this.collectNamespaces(root);
+      const imports = [];
+      const otherElements = [];
+      for (const child of root.childNodes) {
+        if (child.nodeType !== 1) continue;
+        if (this.isXsltElement(child, "import")) {
+          imports.push(child);
+        } else {
+          otherElements.push(child);
+        }
+      }
+      for (const importNode of imports) {
+        this.processImport(importNode, stylesheetUri);
+      }
+      for (const child of otherElements) {
+        if (this.isXsltElement(child, "template")) {
+          this.registerTemplate(child);
+        } else if (this.isXsltElement(child, "output")) {
+          this.processOutput(child);
+        } else if (this.isXsltElement(child, "variable")) {
+          this.processGlobalVariable(child);
+        } else if (this.isXsltElement(child, "param")) {
+          this.processGlobalParam(child);
+        } else if (this.isXsltElement(child, "key")) {
+          this.processKey(child);
+        } else if (this.isXsltElement(child, "decimal-format")) {
+          this.processDecimalFormat(child);
+        } else if (this.isXsltElement(child, "namespace-alias")) {
+          this.processNamespaceAlias(child);
+        } else if (this.isXsltElement(child, "attribute-set")) {
+          this.processAttributeSet(child);
+        } else if (this.isXsltElement(child, "strip-space")) {
+          this.processStripSpace(child);
+        } else if (this.isXsltElement(child, "preserve-space")) {
+          this.processPreserveSpace(child);
+        } else if (this.isXsltElement(child, "include")) {
+          this.processInclude(child, stylesheetUri);
+        }
+      }
+    }
+    processLiteralResultStylesheet(root) {
+      this.templates.push({
+        match: "/",
+        name: null,
+        mode: null,
+        priority: 0.5,
+        node: root
+      });
+    }
+    collectNamespaces(node) {
+      if (!node.attributes) return;
+      for (const attr of node.attributes) {
+        if (attr.name.startsWith("xmlns:")) {
+          const prefix = attr.name.substring(6);
+          if (attr.value !== XSLT_NS) {
+            this.namespaces[prefix] = attr.value;
+          }
+        } else if (attr.name === "xmlns" && attr.value !== XSLT_NS) {
+          this.namespaces[""] = attr.value;
+        }
+      }
+    }
+    registerTemplate(node) {
+      const match = node.getAttribute("match");
+      const name = node.getAttribute("name");
+      const mode = node.getAttribute("mode") || null;
+      const priorityAttr = node.getAttribute("priority");
+      const priority = priorityAttr ? parseFloat(priorityAttr) : this.calculatePriority(match);
+      this.templates.push({
+        match,
+        name,
+        mode,
+        priority,
+        importPrecedence: this.currentImportPrecedence,
+        node
+      });
+    }
+    calculatePriority(matchPattern) {
+      if (!matchPattern) return 0.5;
+      if (matchPattern === "*" || matchPattern === "node()" || matchPattern === "text()" || matchPattern === "comment()" || matchPattern === "processing-instruction()") {
+        return -0.5;
+      }
+      if (matchPattern.includes(":*")) {
+        return -0.25;
+      }
+      if (/^[a-zA-Z_][\w.-]*$/.test(matchPattern)) {
+        return 0;
+      }
+      return 0.5;
+    }
+    processOutput(node) {
+      const method = node.getAttribute("method");
+      if (method) this.outputSettings.method = method;
+      const encoding = node.getAttribute("encoding");
+      if (encoding) this.outputSettings.encoding = encoding;
+      const indent = node.getAttribute("indent");
+      if (indent) this.outputSettings.indent = indent;
+      const omit = node.getAttribute("omit-xml-declaration");
+      if (omit) this.outputSettings.omitXmlDeclaration = omit;
+      const doctypePublic = node.getAttribute("doctype-public");
+      if (doctypePublic) this.outputSettings.doctypePublic = doctypePublic;
+      const doctypeSystem = node.getAttribute("doctype-system");
+      if (doctypeSystem) this.outputSettings.doctypeSystem = doctypeSystem;
+      const mediaType = node.getAttribute("media-type");
+      if (mediaType) this.outputSettings.mediaType = mediaType;
+      const cdataElements = node.getAttribute("cdata-section-elements");
+      if (cdataElements) {
+        this.outputSettings.cdataSectionElements = cdataElements.split(/\s+/).filter(Boolean);
+      }
+    }
+    processGlobalVariable(node) {
+      const name = node.getAttribute("name");
+      const select2 = node.getAttribute("select");
+      this.globalVariables[name] = { node, select: select2 };
+    }
+    processGlobalParam(node) {
+      const name = node.getAttribute("name");
+      const select2 = node.getAttribute("select");
+      this.globalParameters[name] = { node, select: select2 };
+    }
+    processKey(node) {
+      const name = node.getAttribute("name");
+      const match = node.getAttribute("match");
+      const use = node.getAttribute("use");
+      this.keys[name] = { match, use };
+    }
+    processDecimalFormat(node) {
+      const name = node.getAttribute("name") || "";
+      this.decimalFormats[name] = {
+        decimalSeparator: node.getAttribute("decimal-separator") || ".",
+        groupingSeparator: node.getAttribute("grouping-separator") || ",",
+        percent: node.getAttribute("percent") || "%",
+        perMille: node.getAttribute("per-mille") || "\u2030",
+        zeroDigit: node.getAttribute("zero-digit") || "0",
+        digit: node.getAttribute("digit") || "#",
+        patternSeparator: node.getAttribute("pattern-separator") || ";",
+        infinity: node.getAttribute("infinity") || "Infinity",
+        nan: node.getAttribute("NaN") || "NaN",
+        minusSign: node.getAttribute("minus-sign") || "-"
+      };
+    }
+    processNamespaceAlias(node) {
+      const stylesheet = node.getAttribute("stylesheet-prefix");
+      const result = node.getAttribute("result-prefix");
+      this.namespaceAliases[stylesheet] = result;
+    }
+    processAttributeSet(node) {
+      const name = node.getAttribute("name");
+      const useAttributeSets = node.getAttribute("use-attribute-sets");
+      this.attributeSets[name] = {
+        node,
+        useAttributeSets: useAttributeSets ? useAttributeSets.split(/\s+/).filter(Boolean) : []
+      };
+    }
+    processStripSpace(node) {
+      const elements = node.getAttribute("elements");
+      if (elements) {
+        this.stripSpace.push(...elements.split(/\s+/).filter(Boolean));
+      }
+    }
+    processPreserveSpace(node) {
+      const elements = node.getAttribute("elements");
+      if (elements) {
+        this.preserveSpace.push(...elements.split(/\s+/).filter(Boolean));
+      }
+    }
+    /**
+     * Transform a source document
+     */
+    transform(sourceNode, ownerDocument) {
+      const doc = ownerDocument || (typeof document !== "undefined" ? document : null);
+      if (!doc) {
+        throw new Error("No output document available");
+      }
+      const context = new XsltContext({
+        currentNode: sourceNode.documentElement || sourceNode,
+        currentNodeList: [sourceNode.documentElement || sourceNode],
+        position: 1,
+        outputDocument: doc,
+        stylesheet: this.stylesheetDoc,
+        namespaces: { ...this.namespaces },
+        templates: this.templates,
+        keys: this.keys,
+        decimalFormats: this.decimalFormats,
+        outputMethod: this.outputSettings.method,
+        xpathEvaluator: this.xpathEvaluator
+      });
+      for (const [name, def] of Object.entries(this.globalParameters)) {
+        if (!(name in context.parameters)) {
+          context.parameters[name] = this.evaluateVariable(def, context);
+        }
+      }
+      for (const [name, def] of Object.entries(this.globalVariables)) {
+        context.variables[name] = this.evaluateVariable(def, context);
+      }
+      const fragment = doc.createDocumentFragment();
+      this.applyTemplates(
+        [sourceNode.documentElement || sourceNode],
+        null,
+        context,
+        fragment
+      );
+      return fragment;
+    }
+    /**
+     * Transform to a complete document
+     */
+    transformToDocument(sourceNode) {
+      const doc = this.createDocument();
+      const fragment = this.transform(sourceNode, doc);
+      while (fragment.firstChild) {
+        doc.appendChild(fragment.firstChild);
+      }
+      return doc;
+    }
+    createDocument() {
+      if (typeof document !== "undefined") {
+        return document.implementation.createDocument(null, null, null);
+      }
+      throw new Error("Document creation not available in this environment");
+    }
+    evaluateVariable(def, context) {
+      if (def.select) {
+        return this.evaluateXPath(def.select, context);
+      }
+      const fragment = context.outputDocument.createDocumentFragment();
+      this.processChildren(def.node, context, fragment);
+      return fragment;
+    }
+    /**
+     * Apply templates to a node list
+     */
+    applyTemplates(nodes, mode, context, output) {
+      const nodeList = Array.isArray(nodes) ? nodes : [nodes];
+      for (let i = 0; i < nodeList.length; i++) {
+        const node = nodeList[i];
+        const template = this.findMatchingTemplate(node, mode, context);
+        if (template) {
+          const newContext = context.clone({
+            currentNode: node,
+            currentNodeList: nodeList,
+            position: i + 1
+          });
+          this.processTemplate(template.node, newContext, output);
+        } else {
+          this.applyBuiltinTemplate(node, mode, context, output);
+        }
+      }
+    }
+    /**
+     * Find the best matching template for a node
+     */
+    findMatchingTemplate(node, mode, context) {
+      let bestMatch = null;
+      let bestPriority = -Infinity;
+      let bestImportPrecedence = -Infinity;
+      for (const template of this.templates) {
+        if (template.mode !== mode) continue;
+        if (!template.match) continue;
+        if (this.matchesPattern(node, template.match, context)) {
+          const priority = template.priority;
+          const importPrecedence = template.importPrecedence || 0;
+          if (importPrecedence > bestImportPrecedence || importPrecedence === bestImportPrecedence && priority > bestPriority) {
+            bestMatch = template;
+            bestPriority = priority;
+            bestImportPrecedence = importPrecedence;
+          }
+        }
+      }
+      return bestMatch;
+    }
+    /**
+     * Check if a node matches an XSLT pattern
+     */
+    matchesPattern(node, pattern, context) {
+      const patterns = this.splitUnionPattern(pattern);
+      for (const p of patterns) {
+        if (this.matchesSinglePattern(node, p.trim(), context)) {
+          return true;
+        }
+      }
+      return false;
+    }
+    splitUnionPattern(pattern) {
+      const parts = [];
+      let current = "";
+      let depth = 0;
+      let inString = false;
+      let stringChar = "";
+      for (let i = 0; i < pattern.length; i++) {
+        const char = pattern[i];
+        if (inString) {
+          current += char;
+          if (char === stringChar) {
+            inString = false;
+          }
+        } else if (char === '"' || char === "'") {
+          inString = true;
+          stringChar = char;
+          current += char;
+        } else if (char === "[") {
+          depth++;
+          current += char;
+        } else if (char === "]") {
+          depth--;
+          current += char;
+        } else if (char === "|" && depth === 0) {
+          parts.push(current);
+          current = "";
+        } else {
+          current += char;
+        }
+      }
+      if (current) {
+        parts.push(current);
+      }
+      return parts;
+    }
+    matchesSinglePattern(node, pattern, context) {
+      var _a;
+      try {
+        if (pattern === "/") {
+          return node.nodeType === 9 || node === ((_a = node.ownerDocument) == null ? void 0 : _a.documentElement);
+        }
+        const ast = parse(pattern);
+        if (pattern.startsWith("/")) {
+          const doc = node.ownerDocument || node;
+          const xpathContext2 = new XPathContext(
+            doc,
+            1,
+            1,
+            { ...context.variables, ...context.parameters },
+            context.namespaces
+          );
+          const result2 = this.xpathEvaluator.evaluate(ast, xpathContext2);
+          const nodes2 = Array.isArray(result2) ? result2 : [result2];
+          return nodes2.includes(node);
+        }
+        if (node.parentNode) {
+          const xpathContext2 = new XPathContext(
+            node.parentNode,
+            1,
+            1,
+            { ...context.variables, ...context.parameters },
+            context.namespaces
+          );
+          const result2 = this.xpathEvaluator.evaluate(ast, xpathContext2);
+          const nodes2 = Array.isArray(result2) ? result2 : [result2];
+          return nodes2.includes(node);
+        }
+        const xpathContext = new XPathContext(
+          node,
+          1,
+          1,
+          { ...context.variables, ...context.parameters },
+          context.namespaces
+        );
+        const result = this.xpathEvaluator.evaluate(ast, xpathContext);
+        const nodes = Array.isArray(result) ? result : [result];
+        return nodes.includes(node);
+      } catch {
+        return false;
+      }
+    }
+    /**
+     * Apply built-in template rules
+     */
+    applyBuiltinTemplate(node, mode, context, output) {
+      switch (node.nodeType) {
+        case 1:
+        // Element
+        case 9:
+        // Document
+        case 11:
+          this.applyTemplates(Array.from(node.childNodes), mode, context, output);
+          break;
+        case 3:
+        // Text
+        case 4: {
+          const text = context.outputDocument.createTextNode(
+            node.nodeValue || ""
+          );
+          output.appendChild(text);
+          break;
+        }
+        case 2: {
+          const attrText = context.outputDocument.createTextNode(
+            node.nodeValue || ""
+          );
+          output.appendChild(attrText);
+          break;
+        }
+      }
+    }
+    /**
+     * Process template content
+     */
+    processTemplate(templateNode, context, output) {
+      const localContext = context.clone();
+      for (const child of templateNode.childNodes) {
+        if (child.nodeType === 1 && this.isXsltElement(child, "param")) {
+          const name = child.getAttribute("name");
+          if (!(name in localContext.parameters)) {
+            localContext.parameters[name] = this.evaluateVariable(
+              { node: child, select: child.getAttribute("select") },
+              localContext
+            );
+          }
+        }
+      }
+      this.processChildren(templateNode, localContext, output);
+    }
+    /**
+     * Process child nodes of an XSLT element
+     */
+    processChildren(node, context, output) {
+      for (const child of node.childNodes) {
+        this.processNode(child, context, output);
+      }
+    }
+    /**
+     * Process a single node in the stylesheet
+     */
+    processNode(node, context, output) {
+      switch (node.nodeType) {
+        case 1:
+          this.processElement(node, context, output);
+          break;
+        case 3:
+        // Text
+        case 4: {
+          const text = node.nodeValue;
+          if (text && (text.trim() || this.shouldPreserveSpace(node))) {
+            const textNode = context.outputDocument.createTextNode(text);
+            output.appendChild(textNode);
+          }
+          break;
+        }
+      }
+    }
+    shouldPreserveSpace(node) {
+      let current = node.parentNode;
+      while (current && current.nodeType === 1) {
+        const space = current.getAttribute("xml:space");
+        if (space === "preserve") return true;
+        if (space === "default") return false;
+        current = current.parentNode;
+      }
+      return false;
+    }
+    /**
+     * Process an element in the stylesheet
+     */
+    processElement(node, context, output) {
+      if (this.isXsltNamespace(node)) {
+        this.processXsltElement(node, context, output);
+      } else {
+        this.processLiteralResultElement(node, context, output);
+      }
+    }
+    /**
+     * Process an XSLT instruction element
+     */
+    processXsltElement(node, context, output) {
+      const localName = node.localName || node.nodeName.replace(/^xsl:/, "");
+      switch (localName) {
+        case "apply-templates":
+          this.xslApplyTemplates(node, context, output);
+          break;
+        case "call-template":
+          this.xslCallTemplate(node, context, output);
+          break;
+        case "value-of":
+          this.xslValueOf(node, context, output);
+          break;
+        case "text":
+          this.xslText(node, context, output);
+          break;
+        case "element":
+          this.xslElement(node, context, output);
+          break;
+        case "attribute":
+          this.xslAttribute(node, context, output);
+          break;
+        case "if":
+          this.xslIf(node, context, output);
+          break;
+        case "choose":
+          this.xslChoose(node, context, output);
+          break;
+        case "for-each":
+          this.xslForEach(node, context, output);
+          break;
+        case "copy":
+          this.xslCopy(node, context, output);
+          break;
+        case "copy-of":
+          this.xslCopyOf(node, context, output);
+          break;
+        case "variable":
+          this.xslVariable(node, context, output);
+          break;
+        case "param":
+          break;
+        case "comment":
+          this.xslComment(node, context, output);
+          break;
+        case "processing-instruction":
+          this.xslProcessingInstruction(node, context, output);
+          break;
+        case "number":
+          this.xslNumber(node, context, output);
+          break;
+        case "sort":
+          break;
+        case "with-param":
+          break;
+        case "message":
+          this.xslMessage(node, context, output);
+          break;
+        case "fallback":
+          break;
+        default:
+          console.warn(`Unknown XSLT element: ${localName}`);
+      }
+    }
+    /**
+     * Process a literal result element (non-XSLT)
+     */
+    processLiteralResultElement(node, context, output) {
+      let outputElement;
+      const namespaceURI = node.namespaceURI;
+      const nodeName = node.nodeName;
+      let resolvedNS = namespaceURI;
+      if (namespaceURI) {
+        for (const [from, to] of Object.entries(this.namespaceAliases)) {
+          if (this.namespaces[from] === namespaceURI) {
+            resolvedNS = this.namespaces[to] || to;
+            break;
+          }
+        }
+      }
+      if (resolvedNS && context.outputDocument.createElementNS) {
+        outputElement = context.outputDocument.createElementNS(
+          resolvedNS,
+          nodeName
+        );
+      } else {
+        outputElement = context.outputDocument.createElement(nodeName);
+      }
+      if (node.attributes) {
+        for (const attr of node.attributes) {
+          if (attr.namespaceURI === XSLT_NS) continue;
+          if (attr.name.startsWith("xmlns")) continue;
+          const value = this.processAttributeValueTemplate(attr.value, context);
+          outputElement.setAttribute(attr.name, value);
+        }
+      }
+      this.processChildren(node, context, outputElement);
+      output.appendChild(outputElement);
+    }
+    /**
+     * Process attribute value templates (expressions in curly braces)
+     */
+    processAttributeValueTemplate(value, context) {
+      if (!value.includes("{")) return value;
+      let result = "";
+      let i = 0;
+      while (i < value.length) {
+        if (value[i] === "{") {
+          if (value[i + 1] === "{") {
+            result += "{";
+            i += 2;
+          } else {
+            let depth = 1;
+            let j = i + 1;
+            while (j < value.length && depth > 0) {
+              if (value[j] === "{") depth++;
+              else if (value[j] === "}") depth--;
+              j++;
+            }
+            const expr = value.substring(i + 1, j - 1);
+            const evalResult = this.evaluateXPath(expr, context);
+            result += this.xpathEvaluator.toString(evalResult);
+            i = j;
+          }
+        } else if (value[i] === "}") {
+          if (value[i + 1] === "}") {
+            result += "}";
+            i += 2;
+          } else {
+            throw new Error("Unmatched } in attribute value template");
+          }
+        } else {
+          result += value[i];
+          i++;
+        }
+      }
+      return result;
+    }
+    // XSLT Instructions
+    xslApplyTemplates(node, context, output) {
+      const select2 = node.getAttribute("select") || "node()";
+      const mode = node.getAttribute("mode") || null;
+      let nodes = this.evaluateXPath(select2, context);
+      if (!Array.isArray(nodes)) {
+        nodes = nodes ? [nodes] : [];
+      }
+      const sortSpecs = [];
+      for (const child of node.childNodes) {
+        if (child.nodeType === 1 && this.isXsltElement(child, "sort")) {
+          sortSpecs.push({
+            select: child.getAttribute("select") || ".",
+            order: child.getAttribute("order") || "ascending",
+            dataType: child.getAttribute("data-type") || "text",
+            caseOrder: child.getAttribute("case-order") || "upper-first",
+            lang: child.getAttribute("lang")
+          });
+        }
+      }
+      if (sortSpecs.length > 0) {
+        nodes = this.sortNodes(nodes, sortSpecs, context);
+      }
+      const params = {};
+      for (const child of node.childNodes) {
+        if (child.nodeType === 1 && this.isXsltElement(child, "with-param")) {
+          const name = child.getAttribute("name");
+          const selectAttr = child.getAttribute("select");
+          if (selectAttr) {
+            params[name] = this.evaluateXPath(selectAttr, context);
+          } else {
+            const fragment = context.outputDocument.createDocumentFragment();
+            this.processChildren(child, context, fragment);
+            params[name] = fragment;
+          }
+        }
+      }
+      const newContext = context.clone({
+        parameters: { ...context.parameters, ...params }
+      });
+      this.applyTemplates(nodes, mode, newContext, output);
+    }
+    xslCallTemplate(node, context, output) {
+      const name = node.getAttribute("name");
+      const template = this.templates.find((t) => t.name === name);
+      if (!template) {
+        throw new Error(`Template not found: ${name}`);
+      }
+      const params = {};
+      for (const child of node.childNodes) {
+        if (child.nodeType === 1 && this.isXsltElement(child, "with-param")) {
+          const paramName = child.getAttribute("name");
+          const selectAttr = child.getAttribute("select");
+          if (selectAttr) {
+            params[paramName] = this.evaluateXPath(selectAttr, context);
+          } else {
+            const fragment = context.outputDocument.createDocumentFragment();
+            this.processChildren(child, context, fragment);
+            params[paramName] = fragment;
+          }
+        }
+      }
+      const newContext = context.clone({
+        parameters: { ...context.parameters, ...params }
+      });
+      this.processTemplate(template.node, newContext, output);
+    }
+    xslValueOf(node, context, output) {
+      const select2 = node.getAttribute("select");
+      const disableOutputEscaping = node.getAttribute("disable-output-escaping") === "yes";
+      const result = this.evaluateXPath(select2, context);
+      const text = this.xpathEvaluator.toString(result);
+      if (text) {
+        const textNode = context.outputDocument.createTextNode(text);
+        if (disableOutputEscaping) {
+          textNode._disableOutputEscaping = true;
+        }
+        output.appendChild(textNode);
+      }
+    }
+    xslText(node, context, output) {
+      const disableOutputEscaping = node.getAttribute("disable-output-escaping") === "yes";
+      let text = "";
+      for (const child of node.childNodes) {
+        if (child.nodeType === 3 || child.nodeType === 4) {
+          text += child.nodeValue || "";
+        }
+      }
+      if (text) {
+        const textNode = context.outputDocument.createTextNode(text);
+        if (disableOutputEscaping) {
+          textNode._disableOutputEscaping = true;
+        }
+        output.appendChild(textNode);
+      }
+    }
+    xslElement(node, context, output) {
+      const name = this.processAttributeValueTemplate(
+        node.getAttribute("name"),
+        context
+      );
+      const namespace = node.getAttribute("namespace");
+      const useAttributeSets = node.getAttribute("use-attribute-sets");
+      let element;
+      if (namespace) {
+        const ns = this.processAttributeValueTemplate(namespace, context);
+        element = context.outputDocument.createElementNS(ns, name);
+      } else {
+        element = context.outputDocument.createElement(name);
+      }
+      if (useAttributeSets) {
+        this.applyAttributeSets(useAttributeSets, context, element);
+      }
+      this.processChildren(node, context, element);
+      output.appendChild(element);
+    }
+    xslAttribute(node, context, output) {
+      const name = this.processAttributeValueTemplate(
+        node.getAttribute("name"),
+        context
+      );
+      const namespace = node.getAttribute("namespace");
+      const fragment = context.outputDocument.createDocumentFragment();
+      this.processChildren(node, context, fragment);
+      let value = "";
+      const getText = (n) => {
+        if (n.nodeType === 3 || n.nodeType === 4) {
+          value += n.nodeValue || "";
+        } else if (n.childNodes) {
+          for (const child of n.childNodes) {
+            getText(child);
+          }
+        }
+      };
+      getText(fragment);
+      if (output.nodeType === 1) {
+        if (namespace) {
+          const ns = this.processAttributeValueTemplate(namespace, context);
+          output.setAttributeNS(ns, name, value);
+        } else {
+          output.setAttribute(name, value);
+        }
+      }
+    }
+    xslIf(node, context, output) {
+      const test = node.getAttribute("test");
+      const result = this.evaluateXPath(test, context);
+      if (this.xpathEvaluator.toBoolean(result)) {
+        this.processChildren(node, context, output);
+      }
+    }
+    xslChoose(node, context, output) {
+      for (const child of node.childNodes) {
+        if (child.nodeType !== 1) continue;
+        if (this.isXsltElement(child, "when")) {
+          const test = child.getAttribute("test");
+          const result = this.evaluateXPath(test, context);
+          if (this.xpathEvaluator.toBoolean(result)) {
+            this.processChildren(child, context, output);
+            return;
+          }
+        } else if (this.isXsltElement(child, "otherwise")) {
+          this.processChildren(child, context, output);
+          return;
+        }
+      }
+    }
+    xslForEach(node, context, output) {
+      const select2 = node.getAttribute("select");
+      let nodes = this.evaluateXPath(select2, context);
+      if (!Array.isArray(nodes)) {
+        nodes = nodes ? [nodes] : [];
+      }
+      const sortSpecs = [];
+      for (const child of node.childNodes) {
+        if (child.nodeType === 1 && this.isXsltElement(child, "sort")) {
+          sortSpecs.push({
+            select: child.getAttribute("select") || ".",
+            order: child.getAttribute("order") || "ascending",
+            dataType: child.getAttribute("data-type") || "text",
+            caseOrder: child.getAttribute("case-order") || "upper-first",
+            lang: child.getAttribute("lang")
+          });
+        }
+      }
+      if (sortSpecs.length > 0) {
+        nodes = this.sortNodes(nodes, sortSpecs, context);
+      }
+      for (let i = 0; i < nodes.length; i++) {
+        const newContext = context.clone({
+          currentNode: nodes[i],
+          currentNodeList: nodes,
+          position: i + 1
+        });
+        this.processChildren(node, newContext, output);
+      }
+    }
+    xslCopy(node, context, output) {
+      const currentNode = context.currentNode;
+      const useAttributeSets = node.getAttribute("use-attribute-sets");
+      switch (currentNode.nodeType) {
+        case 1: {
+          let copy;
+          if (currentNode.namespaceURI) {
+            copy = context.outputDocument.createElementNS(
+              currentNode.namespaceURI,
+              currentNode.nodeName
+            );
+          } else {
+            copy = context.outputDocument.createElement(currentNode.nodeName);
+          }
+          if (useAttributeSets) {
+            this.applyAttributeSets(useAttributeSets, context, copy);
+          }
+          this.processChildren(node, context, copy);
+          output.appendChild(copy);
+          break;
+        }
+        case 2:
+          if (output.nodeType === 1) {
+            output.setAttribute(currentNode.name, currentNode.value);
+          }
+          break;
+        case 3:
+        // Text
+        case 4: {
+          const textCopy = context.outputDocument.createTextNode(
+            currentNode.nodeValue || ""
+          );
+          output.appendChild(textCopy);
+          break;
+        }
+        case 7: {
+          const piCopy = context.outputDocument.createProcessingInstruction(
+            currentNode.target,
+            currentNode.data
+          );
+          output.appendChild(piCopy);
+          break;
+        }
+        case 8: {
+          const commentCopy = context.outputDocument.createComment(
+            currentNode.nodeValue || ""
+          );
+          output.appendChild(commentCopy);
+          break;
+        }
+        case 9:
+        // Document
+        case 11:
+          this.processChildren(node, context, output);
+          break;
+      }
+    }
+    xslCopyOf(node, context, output) {
+      const select2 = node.getAttribute("select");
+      const result = this.evaluateXPath(select2, context);
+      this.copyToOutput(result, context, output);
+    }
+    copyToOutput(value, context, output) {
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          this.copyToOutput(item, context, output);
+        }
+        return;
+      }
+      if (value && value.nodeType) {
+        const clone = this.deepCloneNode(value, context.outputDocument);
+        output.appendChild(clone);
+      } else if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        const text = context.outputDocument.createTextNode(String(value));
+        output.appendChild(text);
+      }
+    }
+    deepCloneNode(node, targetDoc) {
+      switch (node.nodeType) {
+        case 1: {
+          let clone;
+          if (node.namespaceURI && targetDoc.createElementNS) {
+            clone = targetDoc.createElementNS(node.namespaceURI, node.nodeName);
+          } else {
+            clone = targetDoc.createElement(node.nodeName);
+          }
+          if (node.attributes) {
+            for (const attr of node.attributes) {
+              clone.setAttribute(attr.name, attr.value);
+            }
+          }
+          for (const child of node.childNodes) {
+            clone.appendChild(this.deepCloneNode(child, targetDoc));
+          }
+          return clone;
+        }
+        case 3:
+        // Text
+        case 4:
+          return targetDoc.createTextNode(node.nodeValue || "");
+        case 7:
+          return targetDoc.createProcessingInstruction(node.target, node.data);
+        case 8:
+          return targetDoc.createComment(node.nodeValue || "");
+        case 11: {
+          const frag = targetDoc.createDocumentFragment();
+          for (const child of node.childNodes) {
+            frag.appendChild(this.deepCloneNode(child, targetDoc));
+          }
+          return frag;
+        }
+        default:
+          return targetDoc.createTextNode("");
+      }
+    }
+    xslVariable(node, context, _output) {
+      const name = node.getAttribute("name");
+      const select2 = node.getAttribute("select");
+      let value;
+      if (select2) {
+        value = this.evaluateXPath(select2, context);
+      } else {
+        const fragment = context.outputDocument.createDocumentFragment();
+        this.processChildren(node, context, fragment);
+        value = fragment;
+      }
+      context.setVariable(name, value);
+    }
+    xslComment(node, context, output) {
+      const fragment = context.outputDocument.createDocumentFragment();
+      this.processChildren(node, context, fragment);
+      let text = "";
+      const getText = (n) => {
+        if (n.nodeType === 3 || n.nodeType === 4) {
+          text += n.nodeValue || "";
+        } else if (n.childNodes) {
+          for (const child of n.childNodes) {
+            getText(child);
+          }
+        }
+      };
+      getText(fragment);
+      const comment = context.outputDocument.createComment(text);
+      output.appendChild(comment);
+    }
+    xslProcessingInstruction(node, context, output) {
+      const name = this.processAttributeValueTemplate(
+        node.getAttribute("name"),
+        context
+      );
+      const fragment = context.outputDocument.createDocumentFragment();
+      this.processChildren(node, context, fragment);
+      let data = "";
+      const getText = (n) => {
+        if (n.nodeType === 3 || n.nodeType === 4) {
+          data += n.nodeValue || "";
+        } else if (n.childNodes) {
+          for (const child of n.childNodes) {
+            getText(child);
+          }
+        }
+      };
+      getText(fragment);
+      const pi = context.outputDocument.createProcessingInstruction(name, data);
+      output.appendChild(pi);
+    }
+    xslNumber(node, context, output) {
+      const value = node.getAttribute("value");
+      const format = node.getAttribute("format") || "1";
+      const level = node.getAttribute("level") || "single";
+      let number;
+      if (value) {
+        number = Math.round(
+          this.xpathEvaluator.toNumber(this.evaluateXPath(value, context))
+        );
+      } else {
+        number = this.countNumber(context.currentNode, level, node, context);
+      }
+      const formatted = this.formatNumber(number, format);
+      const text = context.outputDocument.createTextNode(formatted);
+      output.appendChild(text);
+    }
+    countNumber(node, level, spec, context) {
+      const count = spec.getAttribute("count");
+      const _from = spec.getAttribute("from");
+      if (level === "single") {
+        let n = 1;
+        let sibling = node.previousSibling;
+        while (sibling) {
+          if (sibling.nodeType === 1) {
+            if (!count || this.matchesPattern(sibling, count, context)) {
+              n++;
+            }
+          }
+          sibling = sibling.previousSibling;
+        }
+        return n;
+      }
+      return 1;
+    }
+    formatNumber(number, format) {
+      if (/^[0-9]+$/.test(format)) {
+        return String(number).padStart(format.length, "0");
+      }
+      if (format === "a") {
+        return String.fromCharCode(96 + (number - 1) % 26 + 1);
+      }
+      if (format === "A") {
+        return String.fromCharCode(64 + (number - 1) % 26 + 1);
+      }
+      if (format === "i") {
+        return this.toRoman(number).toLowerCase();
+      }
+      if (format === "I") {
+        return this.toRoman(number);
+      }
+      return String(number);
+    }
+    toRoman(num) {
+      const romanNumerals = [
+        ["M", 1e3],
+        ["CM", 900],
+        ["D", 500],
+        ["CD", 400],
+        ["C", 100],
+        ["XC", 90],
+        ["L", 50],
+        ["XL", 40],
+        ["X", 10],
+        ["IX", 9],
+        ["V", 5],
+        ["IV", 4],
+        ["I", 1]
+      ];
+      let result = "";
+      for (const [numeral, value] of romanNumerals) {
+        while (num >= value) {
+          result += numeral;
+          num -= value;
+        }
+      }
+      return result;
+    }
+    xslMessage(node, context, _output) {
+      const terminate = node.getAttribute("terminate") === "yes";
+      const fragment = context.outputDocument.createDocumentFragment();
+      this.processChildren(node, context, fragment);
+      let text = "";
+      const getText = (n) => {
+        if (n.nodeType === 3 || n.nodeType === 4) {
+          text += n.nodeValue || "";
+        } else if (n.childNodes) {
+          for (const child of n.childNodes) {
+            getText(child);
+          }
+        }
+      };
+      getText(fragment);
+      console.log("XSLT Message:", text);
+      if (terminate) {
+        throw new Error(`XSLT terminated: ${text}`);
+      }
+    }
+    applyAttributeSets(names, context, element) {
+      const setNames = names.split(/\s+/).filter(Boolean);
+      for (const name of setNames) {
+        const attrSet = this.attributeSets[name];
+        if (attrSet) {
+          if (attrSet.useAttributeSets.length > 0) {
+            this.applyAttributeSets(
+              attrSet.useAttributeSets.join(" "),
+              context,
+              element
+            );
+          }
+          for (const child of attrSet.node.childNodes) {
+            if (child.nodeType === 1 && this.isXsltElement(child, "attribute")) {
+              this.xslAttribute(child, context, element);
+            }
+          }
+        }
+      }
+    }
+    sortNodes(nodes, sortSpecs, context) {
+      return [...nodes].sort((a, b) => {
+        for (const spec of sortSpecs) {
+          const contextA = context.clone({ currentNode: a });
+          const contextB = context.clone({ currentNode: b });
+          let valueA = this.evaluateXPath(spec.select, contextA);
+          let valueB = this.evaluateXPath(spec.select, contextB);
+          valueA = this.xpathEvaluator.toString(valueA) || "";
+          valueB = this.xpathEvaluator.toString(valueB) || "";
+          if (spec.dataType === "number") {
+            valueA = parseFloat(valueA) || 0;
+            valueB = parseFloat(valueB) || 0;
+          } else {
+            if (spec.caseOrder === "lower-first") {
+              valueA = valueA.toLowerCase();
+              valueB = valueB.toLowerCase();
+            } else {
+              valueA = valueA.toUpperCase();
+              valueB = valueB.toUpperCase();
+            }
+          }
+          let cmp;
+          if (typeof valueA === "number") {
+            cmp = valueA - valueB;
+          } else {
+            cmp = valueA.localeCompare(valueB, spec.lang || void 0);
+          }
+          if (spec.order === "descending") {
+            cmp = -cmp;
+          }
+          if (cmp !== 0) return cmp;
+        }
+        return 0;
+      });
+    }
+    evaluateXPath(expr, context) {
+      const ast = parse(expr);
+      const xpathContext = new XPathContext(
+        context.currentNode,
+        context.position,
+        context.currentNodeList.length,
+        { ...context.variables, ...context.parameters },
+        context.namespaces
+      );
+      return this.xpathEvaluator.evaluate(ast, xpathContext);
+    }
+    isXsltNamespace(node) {
+      return node.namespaceURI === XSLT_NS || node.nodeName && node.nodeName.startsWith("xsl:");
+    }
+    isXsltElement(node, localName) {
+      if (node.nodeType !== 1) return false;
+      const nodeName = node.localName || node.nodeName;
+      return node.namespaceURI === XSLT_NS && nodeName === localName || node.nodeName === `xsl:${localName}`;
+    }
+  };
+
+  // src/XSLTProcessor.js
+  var XSLTProcessor = class {
+    constructor() {
+      this._engine = null;
+      this._stylesheet = null;
+      this._parameters = /* @__PURE__ */ new Map();
+    }
+    /**
+     * Imports the XSLT stylesheet.
+     *
+     * If the given node is a document node, you can pass in a full XSL Transform
+     * or a literal result element transform; otherwise, it must be an
+     * <xsl:stylesheet> or <xsl:transform> element.
+     *
+     * @param {Node} style - The XSLT stylesheet to import (Document or Element)
+     * @returns {void}
+     *
+     * @example
+     * const parser = new DOMParser();
+     * const xslDoc = parser.parseFromString(xslText, 'application/xml');
+     * processor.importStylesheet(xslDoc);
+     */
+    importStylesheet(style) {
+      if (!style) {
+        throw new TypeError(
+          "Failed to execute 'importStylesheet' on 'XSLTProcessor': 1 argument required, but only 0 present."
+        );
+      }
+      if (style.nodeType !== 1 && style.nodeType !== 9) {
+        throw new TypeError(
+          "Failed to execute 'importStylesheet' on 'XSLTProcessor': The node provided is not a Document or Element."
+        );
+      }
+      const errorNode = style.querySelector ? style.querySelector("parsererror") : null;
+      if (errorNode) {
+        throw new Error("XSLT stylesheet contains parse errors");
+      }
+      this._stylesheet = style;
+      this._engine = new XsltEngine();
+      for (const [key, value] of this._parameters) {
+        this._engine.globalParameters[key] = { value };
+      }
+      this._engine.importStylesheet(style);
+    }
+    /**
+     * Transforms the node source by applying the XSLT stylesheet.
+     * Returns a document fragment.
+     *
+     * @param {Node} source - The XML document to transform
+     * @param {Document} output - The document that will own the generated fragment
+     * @returns {DocumentFragment} The transformed result as a DocumentFragment
+     *
+     * @example
+     * const fragment = processor.transformToFragment(xmlDoc, document);
+     * document.getElementById('output').appendChild(fragment);
+     */
+    transformToFragment(source, output) {
+      if (!source) {
+        throw new TypeError(
+          "Failed to execute 'transformToFragment' on 'XSLTProcessor': 2 arguments required, but only 0 present."
+        );
+      }
+      if (!output) {
+        throw new TypeError(
+          "Failed to execute 'transformToFragment' on 'XSLTProcessor': 2 arguments required, but only 1 present."
+        );
+      }
+      if (!this._engine || !this._stylesheet) {
+        throw new Error(
+          "Failed to execute 'transformToFragment' on 'XSLTProcessor': No stylesheet has been imported."
+        );
+      }
+      if (source.nodeType !== 1 && source.nodeType !== 9 && source.nodeType !== 11) {
+        throw new TypeError(
+          "Failed to execute 'transformToFragment' on 'XSLTProcessor': The source is not a valid node type."
+        );
+      }
+      if (output.nodeType !== 9) {
+        throw new TypeError(
+          "Failed to execute 'transformToFragment' on 'XSLTProcessor': The output is not a Document."
+        );
+      }
+      try {
+        return this._engine.transform(source, output);
+      } catch (error) {
+        console.error("XSLT transformation error:", error);
+        return null;
+      }
+    }
+    /**
+     * Transforms the node source by applying the XSLT stylesheet.
+     * Returns a full XML document.
+     *
+     * @param {Node} source - The XML document to transform
+     * @returns {XMLDocument} The transformed result as an XMLDocument
+     *
+     * @example
+     * const resultDoc = processor.transformToDocument(xmlDoc);
+     * const serialized = new XMLSerializer().serializeToString(resultDoc);
+     */
+    transformToDocument(source) {
+      if (!source) {
+        throw new TypeError(
+          "Failed to execute 'transformToDocument' on 'XSLTProcessor': 1 argument required, but only 0 present."
+        );
+      }
+      if (!this._engine || !this._stylesheet) {
+        throw new Error(
+          "Failed to execute 'transformToDocument' on 'XSLTProcessor': No stylesheet has been imported."
+        );
+      }
+      if (source.nodeType !== 1 && source.nodeType !== 9 && source.nodeType !== 11) {
+        throw new TypeError(
+          "Failed to execute 'transformToDocument' on 'XSLTProcessor': The source is not a valid node type."
+        );
+      }
+      try {
+        return this._engine.transformToDocument(source);
+      } catch (error) {
+        console.error("XSLT transformation error:", error);
+        return null;
+      }
+    }
+    /**
+     * Sets a parameter in the XSLT stylesheet.
+     *
+     * @param {string|null} namespaceURI - The namespace URI of the XSLT parameter (use null for no namespace)
+     * @param {string} localName - The local name of the parameter
+     * @param {*} value - The value to set (string, number, boolean, or node-set)
+     * @returns {void}
+     *
+     * @example
+     * processor.setParameter(null, 'sortOrder', 'ascending');
+     * processor.setParameter('http://example.com/ns', 'limit', 10);
+     */
+    setParameter(namespaceURI, localName, value) {
+      if (arguments.length < 3) {
+        throw new TypeError(
+          `Failed to execute 'setParameter' on 'XSLTProcessor': 3 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      if (typeof localName !== "string" || localName === "") {
+        throw new TypeError(
+          "Failed to execute 'setParameter' on 'XSLTProcessor': The localName argument must be a non-empty string."
+        );
+      }
+      const key = namespaceURI ? `{${namespaceURI}}${localName}` : localName;
+      this._parameters.set(key, value);
+      if (this._engine) {
+        this._engine.globalParameters[key] = { value };
+      }
+    }
+    /**
+     * Gets the value of a parameter from the XSLT stylesheet.
+     *
+     * @param {string|null} namespaceURI - The namespace URI of the parameter
+     * @param {string} localName - The local name of the parameter
+     * @returns {*} The parameter value, or empty string if not set
+     *
+     * @example
+     * const sortOrder = processor.getParameter(null, 'sortOrder');
+     */
+    getParameter(namespaceURI, localName) {
+      if (arguments.length < 2) {
+        throw new TypeError(
+          `Failed to execute 'getParameter' on 'XSLTProcessor': 2 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      if (typeof localName !== "string") {
+        throw new TypeError(
+          "Failed to execute 'getParameter' on 'XSLTProcessor': The localName argument must be a string."
+        );
+      }
+      const key = namespaceURI ? `{${namespaceURI}}${localName}` : localName;
+      if (this._parameters.has(key)) {
+        return this._parameters.get(key);
+      }
+      return "";
+    }
+    /**
+     * Removes a parameter from the XSLT processor.
+     *
+     * The XSLTProcessor will use the default value for the parameter
+     * as specified in the XSLT stylesheet.
+     *
+     * @param {string|null} namespaceURI - The namespace URI of the parameter
+     * @param {string} localName - The local name of the parameter
+     * @returns {void}
+     *
+     * @example
+     * processor.removeParameter(null, 'sortOrder');
+     */
+    removeParameter(namespaceURI, localName) {
+      if (arguments.length < 2) {
+        throw new TypeError(
+          `Failed to execute 'removeParameter' on 'XSLTProcessor': 2 arguments required, but only ${arguments.length} present.`
+        );
+      }
+      if (typeof localName !== "string") {
+        throw new TypeError(
+          "Failed to execute 'removeParameter' on 'XSLTProcessor': The localName argument must be a string."
+        );
+      }
+      const key = namespaceURI ? `{${namespaceURI}}${localName}` : localName;
+      this._parameters.delete(key);
+      if (this._engine) {
+        delete this._engine.globalParameters[key];
+      }
+    }
+    /**
+     * Removes all set parameters from the XSLTProcessor.
+     *
+     * The processor will use default values specified in the XSLT stylesheet.
+     *
+     * @returns {void}
+     *
+     * @example
+     * processor.clearParameters();
+     */
+    clearParameters() {
+      this._parameters.clear();
+      if (this._engine) {
+        this._engine.globalParameters = {};
+      }
+    }
+    /**
+     * Removes all parameters and stylesheets from the XSLTProcessor.
+     *
+     * @returns {void}
+     *
+     * @example
+     * processor.reset();
+     * // Now need to call importStylesheet() again before transforming
+     */
+    reset() {
+      this._engine = null;
+      this._stylesheet = null;
+      this._parameters.clear();
+    }
+  };
+  function isNativeXSLTSupported() {
+    if (typeof globalThis.XSLTProcessor === "undefined") {
+      return false;
+    }
+    try {
+      const processor = new globalThis.XSLTProcessor();
+      const parser = new DOMParser();
+      const xslt = parser.parseFromString(
+        `<?xml version="1.0"?>
+      <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+        <xsl:template match="/"><test/></xsl:template>
+      </xsl:stylesheet>`,
+        "application/xml"
+      );
+      processor.importStylesheet(xslt);
+      const xml = parser.parseFromString("<root/>", "application/xml");
+      const result = processor.transformToFragment(xml, document);
+      return result !== null && result.childNodes.length > 0;
+    } catch {
+      return false;
+    }
+  }
+  function installGlobal(force = false) {
+    if (!force && isNativeXSLTSupported()) {
+      return false;
+    }
+    globalThis.XSLTProcessor = XSLTProcessor;
+    return true;
+  }
+  var XSLTProcessor_default = XSLTProcessor;
+
+  // src/xpath/index.js
+  function evaluate(expression, contextNode, options = {}) {
+    const ast = parse(expression);
+    const evaluator = new XPathEvaluator();
+    const context = new XPathContext(
+      contextNode,
+      1,
+      1,
+      options.variables || {},
+      options.namespaces || {}
+    );
+    return evaluator.evaluate(ast, context);
+  }
+  function select(expression, contextNode, options = {}) {
+    const result = evaluate(expression, contextNode, options);
+    if (Array.isArray(result)) return result;
+    if (result && result.nodeType) return [result];
+    return [];
+  }
+  function selectFirst(expression, contextNode, options = {}) {
+    const nodes = select(expression, contextNode, options);
+    return nodes.length > 0 ? nodes[0] : null;
+  }
+
+  // src/index.js
+  var VERSION = "1.0.0";
+  var isBrowser = typeof window !== "undefined" && typeof document !== "undefined";
+  var isNode = typeof process !== "undefined" && process.versions != null && process.versions.node != null;
+  return __toCommonJS(index_exports);
+})();
+
+// Auto-install as global XSLTProcessor replacement if native is not functional
+if (typeof window !== 'undefined') {
+  XsltProcessorLib.installGlobal();
+}
+
+//# sourceMappingURL=xslt-processor.browser.js.map