@tradik/xslt-processor 1.0.0

package/dist/xslt-processor.js

@@ -0,0 +1,3271 @@
+// 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) {
+    try {
+      if (pattern === "/") {
+        return node.nodeType === 9 || node === node.ownerDocument?.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;
+export {
+  VERSION,
+  XPathContext,
+  XPathEvaluator,
+  XPathResultType,
+  XSLTProcessor,
+  XsltContext,
+  XsltEngine,
+  XSLTProcessor_default as default,
+  evaluate as evaluateXPath,
+  installGlobal,
+  isBrowser,
+  isNativeXSLTSupported,
+  isNode,
+  parse as parseXPath,
+  selectFirst as selectFirstXPath,
+  select as selectXPath
+};
+//# sourceMappingURL=xslt-processor.js.map