xslt-processor 1.0.0 → 1.1.0

package/{src/xpath → xpath}/xpath.js

@@ -37,19 +37,19 @@
 // Original author: Steffen Meschkat <mesch@google.com>
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.XPath = void 0;
-const util_1 = require("../dom/util");
-const expressions_1 = require("./expressions");
-const node_test_any_1 = require("./node-test-any");
-const node_test_comment_1 = require("./node-test-comment");
-const node_test_element_or_attribute_1 = require("./node-test-element-or-attribute");
-const node_test_name_1 = require("./node-test-name");
-const node_test_nc_1 = require("./node-test-nc");
-const node_test_pi_1 = require("./node-test-pi");
-const node_test_text_1 = require("./node-test-text");
-const tokens_1 = require("./tokens");
-const xpath_grammar_rules_1 = require("./xpath-grammar-rules");
-class XPath {
-    constructor() {
+var util_1 = require("../dom/util");
+var expressions_1 = require("./expressions");
+var node_test_any_1 = require("./node-test-any");
+var node_test_comment_1 = require("./node-test-comment");
+var node_test_element_or_attribute_1 = require("./node-test-element-or-attribute");
+var node_test_name_1 = require("./node-test-name");
+var node_test_nc_1 = require("./node-test-nc");
+var node_test_pi_1 = require("./node-test-pi");
+var node_test_text_1 = require("./node-test-text");
+var tokens_1 = require("./tokens");
+var xpath_grammar_rules_1 = require("./xpath-grammar-rules");
+var XPath = /** @class */ (function () {
+    function XPath() {
         // The productions of the grammar. Columns of the table:
         //
         // - target nonterminal,
@@ -146,67 +146,67 @@ class XPath {
     // tree, an expression object with an evaluate() method that evaluates the
     // expression in an actual context. These factory functions are used
     // in the specification of the grammar rules, below.
-    makeTokenExpr(m) {
+    XPath.prototype.makeTokenExpr = function (m) {
         return new expressions_1.TokenExpr(m);
-    }
-    passExpr(e) {
+    };
+    XPath.prototype.passExpr = function (e) {
         return e;
-    }
-    makeLocationExpr1(slash, rel) {
+    };
+    XPath.prototype.makeLocationExpr1 = function (slash, rel) {
         rel.absolute = true;
         return rel;
-    }
-    makeLocationExpr2(dslash, rel) {
+    };
+    XPath.prototype.makeLocationExpr2 = function (dslash, rel) {
         rel.absolute = true;
         rel.prependStep(this.makeAbbrevStep(dslash.value));
         return rel;
-    }
-    makeLocationExpr3() {
-        const ret = new expressions_1.LocationExpr(this);
+    };
+    XPath.prototype.makeLocationExpr3 = function () {
+        var ret = new expressions_1.LocationExpr(this);
         ret.appendStep(this.makeAbbrevStep('.'));
         ret.absolute = true;
         return ret;
-    }
-    makeLocationExpr4(dslash) {
-        const ret = new expressions_1.LocationExpr(this);
+    };
+    XPath.prototype.makeLocationExpr4 = function (dslash) {
+        var ret = new expressions_1.LocationExpr(this);
         ret.absolute = true;
         ret.appendStep(this.makeAbbrevStep(dslash.value));
         return ret;
-    }
-    makeLocationExpr5(step) {
-        const ret = new expressions_1.LocationExpr(this);
+    };
+    XPath.prototype.makeLocationExpr5 = function (step) {
+        var ret = new expressions_1.LocationExpr(this);
         ret.appendStep(step);
         return ret;
-    }
-    makeLocationExpr6(rel, slash, step) {
+    };
+    XPath.prototype.makeLocationExpr6 = function (rel, slash, step) {
         rel.appendStep(step);
         return rel;
-    }
-    makeLocationExpr7(rel, dslash, step) {
+    };
+    XPath.prototype.makeLocationExpr7 = function (rel, dslash, step) {
         rel.appendStep(this.makeAbbrevStep(dslash.value));
         rel.appendStep(step);
         return rel;
-    }
-    makeStepExpr1(dot) {
+    };
+    XPath.prototype.makeStepExpr1 = function (dot) {
         return this.makeAbbrevStep(dot.value);
-    }
-    makeStepExpr2(ddot) {
+    };
+    XPath.prototype.makeStepExpr2 = function (ddot) {
         return this.makeAbbrevStep(ddot.value);
-    }
-    makeStepExpr3(axisname, axis, nodetest) {
+    };
+    XPath.prototype.makeStepExpr3 = function (axisname, axis, nodetest) {
         return new expressions_1.StepExpr(axisname.value, nodetest, this);
-    }
-    makeStepExpr4(at, nodetest) {
+    };
+    XPath.prototype.makeStepExpr4 = function (at, nodetest) {
         return new expressions_1.StepExpr('attribute', nodetest, this);
-    }
-    makeStepExpr5(nodetest) {
+    };
+    XPath.prototype.makeStepExpr5 = function (nodetest) {
         return new expressions_1.StepExpr('child', nodetest, this);
-    }
-    makeStepExpr6(step, predicate) {
+    };
+    XPath.prototype.makeStepExpr6 = function (step, predicate) {
         step.appendPredicate(predicate);
         return step;
-    }
-    makeAbbrevStep(abbrev) {
+    };
+    XPath.prototype.makeAbbrevStep = function (abbrev) {
         switch (abbrev) {
             case '//':
                 return new expressions_1.StepExpr('descendant-or-self', new node_test_any_1.NodeTestAny(), this);
@@ -215,18 +215,18 @@ class XPath {
             case '..':
                 return new expressions_1.StepExpr('parent', new node_test_any_1.NodeTestAny(), this);
         }
-    }
-    makeNodeTestExpr1() {
+    };
+    XPath.prototype.makeNodeTestExpr1 = function () {
         return new node_test_element_or_attribute_1.NodeTestElementOrAttribute();
-    }
-    makeNodeTestExpr2(ncname) {
+    };
+    XPath.prototype.makeNodeTestExpr2 = function (ncname) {
         return new node_test_nc_1.NodeTestNC(ncname.value);
-    }
-    makeNodeTestExpr3(qname) {
+    };
+    XPath.prototype.makeNodeTestExpr3 = function (qname) {
         return new node_test_name_1.NodeTestName(qname.value);
-    }
-    makeNodeTestExpr4(typeo) {
-        const type = typeo.value.replace(/\s*\($/, '');
+    };
+    XPath.prototype.makeNodeTestExpr4 = function (typeo) {
+        var type = typeo.value.replace(/\s*\($/, '');
         switch (type) {
             case 'node':
                 return new node_test_any_1.NodeTestAny();
@@ -237,139 +237,135 @@ class XPath {
             case 'processing-instruction':
                 return new node_test_pi_1.NodeTestPI('');
         }
-    }
-    makeNodeTestExpr5(typeo, target) {
-        const type = typeo.replace(/\s*\($/, '');
+    };
+    XPath.prototype.makeNodeTestExpr5 = function (typeo, target) {
+        var type = typeo.replace(/\s*\($/, '');
         if (type != 'processing-instruction') {
             throw type;
         }
         return new node_test_pi_1.NodeTestPI(target.value);
-    }
-    makePredicateExpr(pareno, expr) {
+    };
+    XPath.prototype.makePredicateExpr = function (pareno, expr) {
         return new expressions_1.PredicateExpr(expr);
-    }
-    makePrimaryExpr(pareno, expr) {
+    };
+    XPath.prototype.makePrimaryExpr = function (pareno, expr) {
         return expr;
-    }
-    makeFunctionCallExpr1(name) {
+    };
+    XPath.prototype.makeFunctionCallExpr1 = function (name) {
         return new expressions_1.FunctionCallExpr(name);
-    }
-    makeFunctionCallExpr2(name, pareno, arg1, args) {
-        const ret = new expressions_1.FunctionCallExpr(name);
+    };
+    XPath.prototype.makeFunctionCallExpr2 = function (name, pareno, arg1, args) {
+        var ret = new expressions_1.FunctionCallExpr(name);
         ret.appendArg(arg1);
-        for (let i = 0; i < args.length; ++i) {
+        for (var i = 0; i < args.length; ++i) {
             ret.appendArg(args[i]);
         }
         return ret;
-    }
-    makeArgumentExpr(comma, expr) {
+    };
+    XPath.prototype.makeArgumentExpr = function (comma, expr) {
         return expr;
-    }
-    makeUnionExpr(expr1, pipe, expr2) {
+    };
+    XPath.prototype.makeUnionExpr = function (expr1, pipe, expr2) {
         return new expressions_1.UnionExpr(expr1, expr2);
-    }
-    makePathExpr1(filter, slash, rel) {
+    };
+    XPath.prototype.makePathExpr1 = function (filter, slash, rel) {
         return new expressions_1.PathExpr(filter, rel);
-    }
-    makePathExpr2(filter, dslash, rel) {
+    };
+    XPath.prototype.makePathExpr2 = function (filter, dslash, rel) {
         rel.prependStep(this.makeAbbrevStep(dslash.value));
         return new expressions_1.PathExpr(filter, rel);
-    }
-    makeFilterExpr(expr, predicates) {
+    };
+    XPath.prototype.makeFilterExpr = function (expr, predicates) {
         if (predicates.length > 0) {
             return new expressions_1.FilterExpr(expr, predicates);
         }
-        else {
-            return expr;
-        }
-    }
-    makeUnaryMinusExpr(minus, expr) {
+        return expr;
+    };
+    XPath.prototype.makeUnaryMinusExpr = function (minus, expr) {
         return new expressions_1.UnaryMinusExpr(expr);
-    }
-    makeBinaryExpr(expr1, op, expr2) {
+    };
+    XPath.prototype.makeBinaryExpr = function (expr1, op, expr2) {
         return new expressions_1.BinaryExpr(expr1, op, expr2);
-    }
-    makeLiteralExpr(token) {
+    };
+    XPath.prototype.makeLiteralExpr = function (token) {
         // remove quotes from the parsed value:
-        const value = token.value.substring(1, token.value.length - 1);
+        var value = token.value.substring(1, token.value.length - 1);
         return new expressions_1.LiteralExpr(value);
-    }
-    makeNumberExpr(token) {
+    };
+    XPath.prototype.makeNumberExpr = function (token) {
         return new expressions_1.NumberExpr(token.value);
-    }
-    makeVariableReference(dollar, name) {
+    };
+    XPath.prototype.makeVariableReference = function (dollar, name) {
         return new expressions_1.VariableExpr(name.value);
-    }
+    };
     // Used before parsing for optimization of common simple cases. See
     // the begin of xpathParse() for which they are.
-    makeSimpleExpr(expr) {
+    XPath.prototype.makeSimpleExpr = function (expr) {
         if (expr.charAt(0) == '$') {
             return new expressions_1.VariableExpr(expr.substr(1));
         }
-        else if (expr.charAt(0) == '@') {
-            let a = new node_test_name_1.NodeTestName(expr.substr(1));
-            let b = new expressions_1.StepExpr('attribute', a, this);
-            let c = new expressions_1.LocationExpr(this);
-            c.appendStep(b);
-            return c;
+        if (expr.charAt(0) == '@') {
+            var a_1 = new node_test_name_1.NodeTestName(expr.substr(1));
+            var b_1 = new expressions_1.StepExpr('attribute', a_1, this);
+            var c_1 = new expressions_1.LocationExpr(this);
+            c_1.appendStep(b_1);
+            return c_1;
         }
-        else if (expr.match(/^[0-9]+$/)) {
+        if (expr.match(/^[0-9]+$/)) {
             return new expressions_1.NumberExpr(expr);
         }
-        else {
-            let a = new node_test_name_1.NodeTestName(expr);
-            let b = new expressions_1.StepExpr('child', a, this);
-            let c = new expressions_1.LocationExpr(this);
-            c.appendStep(b);
-            return c;
-        }
-    }
-    makeSimpleExpr2(expr) {
-        const steps = expr.split('/');
-        const c = new expressions_1.LocationExpr(this);
-        for (let i = 0; i < steps.length; ++i) {
-            const a = new node_test_name_1.NodeTestName(steps[i]);
-            const b = new expressions_1.StepExpr('child', a, this);
+        var a = new node_test_name_1.NodeTestName(expr);
+        var b = new expressions_1.StepExpr('child', a, this);
+        var c = new expressions_1.LocationExpr(this);
+        c.appendStep(b);
+        return c;
+    };
+    XPath.prototype.makeSimpleExpr2 = function (expr) {
+        var steps = expr.split('/');
+        var c = new expressions_1.LocationExpr(this);
+        for (var i = 0; i < steps.length; ++i) {
+            var a = new node_test_name_1.NodeTestName(steps[i]);
+            var b = new expressions_1.StepExpr('child', a, this);
             c.appendStep(b);
         }
         return c;
-    }
-    stackToString(stack) {
-        let ret = '';
-        for (let i = 0; i < stack.length; ++i) {
+    };
+    XPath.prototype.stackToString = function (stack) {
+        var ret = '';
+        for (var i = 0; i < stack.length; ++i) {
             if (ret) {
                 ret += '\n';
             }
             ret += stack[i].tag.label;
         }
         return ret;
-    }
-    xPathCacheLookup(expr) {
+    };
+    XPath.prototype.xPathCacheLookup = function (expr) {
         return this.xPathParseCache[expr];
-    }
-    xPathCollectDescendants(nodelist, node, opt_tagName) {
+    };
+    XPath.prototype.xPathCollectDescendants = function (nodelist, node, opt_tagName) {
         if (opt_tagName && node.getElementsByTagName) {
             (0, util_1.copyArray)(nodelist, node.getElementsByTagName(opt_tagName));
             return;
         }
-        for (let n = node.firstChild; n; n = n.nextSibling) {
+        for (var n = node.firstChild; n; n = n.nextSibling) {
             nodelist.push(n);
             this.xPathCollectDescendants(nodelist, n);
         }
-    }
-    xPathCollectDescendantsReverse(nodelist, node) {
-        for (let n = node.lastChild; n; n = n.previousSibling) {
+    };
+    XPath.prototype.xPathCollectDescendantsReverse = function (nodelist, node) {
+        for (var n = node.lastChild; n; n = n.previousSibling) {
             nodelist.push(n);
             this.xPathCollectDescendantsReverse(nodelist, n);
         }
-    }
+    };
     // Parses and then evaluates the given XPath expression in the given
     // input context. Notice that parsed xpath expressions are cached.
-    xPathEval(select, context) {
-        const expr = this.xPathParse(select);
-        const ret = expr.evaluate(context);
+    XPath.prototype.xPathEval = function (select, context) {
+        var expr = this.xPathParse(select);
+        var ret = expr.evaluate(context);
         return ret;
-    }
+    };
     /**
      * DGF - extract a tag name suitable for getElementsByTagName
      *
@@ -379,7 +375,7 @@ class XPath {
      *                                     non-element nodes. This can boost
      *                                     performance. This is false by default.
      */
-    xPathExtractTagNameFromNodeTest(nodetest, ignoreNonElementNodesForNTA) {
+    XPath.prototype.xPathExtractTagNameFromNodeTest = function (nodetest, ignoreNonElementNodesForNTA) {
         if (nodetest instanceof node_test_name_1.NodeTestName) {
             return nodetest.name;
         }
@@ -387,24 +383,24 @@ class XPath {
             nodetest instanceof node_test_element_or_attribute_1.NodeTestElementOrAttribute) {
             return '*';
         }
-    }
-    xPathMatchStack(stack, pattern) {
+    };
+    XPath.prototype.xPathMatchStack = function (stack, pattern) {
         // NOTE(mesch): The stack matches for variable cardinality are
         // greedy but don't do backtracking. This would be an issue only
         // with rules of the form A* A, i.e. with an element with variable
         // cardinality followed by the same element. Since that doesn't
         // occur in the grammar at hand, all matches on the stack are
         // unambiguous.
-        const S = stack.length;
-        const P = pattern.length;
-        let p;
-        let s;
-        const match = [];
+        var S = stack.length;
+        var P = pattern.length;
+        var p;
+        var s;
+        var match = [];
         match.matchlength = 0;
-        let ds = 0;
+        var ds = 0;
         for (p = P - 1, s = S - 1; p >= 0 && s >= 0; --p, s -= ds) {
             ds = 0;
-            const qmatch = [];
+            var qmatch = [];
             if (pattern[p] == tokens_1.Q_MM) {
                 p -= 1;
                 match.push(qmatch);
@@ -446,7 +442,7 @@ class XPath {
                 return [];
             }
             (0, util_1.reverseInplace)(qmatch);
-            qmatch.expr = (0, util_1.mapExpr)(qmatch, (m) => m.expr);
+            qmatch.expr = (0, util_1.mapExpr)(qmatch, function (m) { return m.expr; });
         }
         (0, util_1.reverseInplace)(match);
         if (p == -1) {
@@ -455,20 +451,23 @@ class XPath {
         else {
             return [];
         }
-    }
-    // The entry point for the parser.
-    //
-    // @param expr a string that contains an XPath expression.
-    // @return an expression object that can be evaluated with an
-    // expression context.
-    xPathParse(expr, xpathLog = (message) => {
-        // console.log(message);
-    }) {
-        xpathLog(`parse ${expr}`);
-        this.xPathParseInit(xpathLog);
-        const cached = this.xPathCacheLookup(expr);
+    };
+    /**
+     * The entry point for the parser.
+     * @param expr a string that contains an XPath expression.
+     * @param xPathLog TODO
+     * @returns an expression object that can be evaluated with an
+     * expression context.
+     */
+    XPath.prototype.xPathParse = function (expr, xPathLog) {
+        if (xPathLog === void 0) { xPathLog = function (message) {
+            // console.log(message);
+        }; }
+        xPathLog("parse ".concat(expr));
+        this.xPathParseInit(xPathLog);
+        var cached = this.xPathCacheLookup(expr);
         if (cached) {
-            xpathLog(' ... cached');
+            xPathLog(' ... cached');
             return cached;
         }
         // Optimize for a few common cases: simple attribute node tests
@@ -477,38 +476,38 @@ class XPath {
         // step is a plain element node test
         // (page/overlay/locations/location).
         if (expr.match(/^(\$|@)?\w+$/i)) {
-            let ret = this.makeSimpleExpr(expr);
+            var ret = this.makeSimpleExpr(expr);
             this.xPathParseCache[expr] = ret;
-            xpathLog(' ... simple');
+            xPathLog(' ... simple');
             return ret;
         }
         if (expr.match(/^\w+(\/\w+)*$/i)) {
-            let ret = this.makeSimpleExpr2(expr);
+            var ret = this.makeSimpleExpr2(expr);
             this.xPathParseCache[expr] = ret;
-            xpathLog(' ... simple 2');
+            xPathLog(' ... simple 2');
             return ret;
         }
-        const cachekey = expr; // expr is modified during parse
-        const stack = [];
-        let ahead = null;
-        let previous = null;
-        let done = false;
-        let parse_count = 0;
-        let lexer_count = 0;
-        let reduce_count = 0;
+        var cachekey = expr; // expr is modified during parse
+        var stack = [];
+        var ahead = null;
+        var previous = null;
+        var done = false;
+        var parse_count = 0;
+        var lexer_count = 0;
+        var reduce_count = 0;
         while (!done) {
             parse_count++;
             expr = expr.replace(/^\s*/, '');
             previous = ahead;
             ahead = null;
-            let rule = null;
-            let match = '';
-            for (let i = 0; i < tokens_1.xpathTokenRules.length; ++i) {
-                let result = tokens_1.xpathTokenRules[i].re.exec(expr);
+            var rule = null;
+            var match = '';
+            for (var i = 0; i < tokens_1.xpathTokenRules.length; ++i) {
+                var result_1 = tokens_1.xpathTokenRules[i].re.exec(expr);
                 lexer_count++;
-                if (result && result.length > 0 && result[0].length > match.length) {
+                if (result_1 && result_1.length > 0 && result_1[0].length > match.length) {
                     rule = tokens_1.xpathTokenRules[i];
-                    match = result[0];
+                    match = result_1[0];
                     break;
                 }
             }
@@ -536,38 +535,38 @@ class XPath {
             }
             if (rule) {
                 expr = expr.substr(match.length);
-                xpathLog(`token: ${match} -- ${rule.label}`);
+                xPathLog("token: ".concat(match, " -- ").concat(rule.label));
                 ahead = {
                     tag: rule,
-                    match,
+                    match: match,
                     prec: rule.prec ? rule.prec : 0,
                     expr: this.makeTokenExpr(match)
                 };
             }
             else {
-                xpathLog('DONE');
+                xPathLog('DONE');
                 done = true;
             }
-            while (this.xPathReduce(stack, ahead, xpathLog)) {
+            while (this.xPathReduce(stack, ahead, xPathLog)) {
                 reduce_count++;
-                xpathLog(`stack: ${this.stackToString(stack)}`);
+                xPathLog("stack: ".concat(this.stackToString(stack)));
             }
         }
-        xpathLog(`stack: ${this.stackToString(stack)}`);
+        xPathLog("stack: ".concat(this.stackToString(stack)));
         // DGF any valid XPath should "reduce" to a single Expr token
         if (stack.length != 1) {
-            throw `XPath parse error ${cachekey}:\n${this.stackToString(stack)}`;
+            throw "XPath parse error ".concat(cachekey, ":\n").concat(this.stackToString(stack));
         }
-        let result = stack[0].expr;
+        var result = stack[0].expr;
         this.xPathParseCache[cachekey] = result;
-        xpathLog(`XPath parse: ${parse_count} / ${lexer_count} / ${reduce_count}`);
+        xPathLog("XPath parse: ".concat(parse_count, " / ").concat(lexer_count, " / ").concat(reduce_count));
         return result;
-    }
-    xPathParseInit(xpathLog) {
+    };
+    XPath.prototype.xPathParseInit = function (xPathLog) {
         if (this.xPathRules.length) {
             return;
         }
-        let xpathNonTerminals = [
+        var xpathNonTerminals = [
             xpath_grammar_rules_1.XPathLocationPath,
             xpath_grammar_rules_1.XPathRelativeLocationPath,
             xpath_grammar_rules_1.XPathAbsoluteLocationPath,
@@ -589,9 +588,9 @@ class XPath {
         // Some simple optimizations for the xpath expression parser: sort
         // grammar rules descending by length, so that the longest match is
         // first found.
-        this.xPathGrammarRules.sort((a, b) => {
-            const la = a[1].length;
-            const lb = b[1].length;
+        this.xPathGrammarRules.sort(function (a, b) {
+            var la = a[1].length;
+            var lb = b[1].length;
             if (la < lb) {
                 return 1;
             }
@@ -602,14 +601,14 @@ class XPath {
                 return 0;
             }
         });
-        let k = 1;
-        for (let i = 0; i < xpathNonTerminals.length; ++i) {
+        var k = 1;
+        for (var i = 0; i < xpathNonTerminals.length; ++i) {
             xpathNonTerminals[i].key = k++;
         }
-        for (let i = 0; i < tokens_1.xpathTokenRules.length; ++i) {
+        for (var i = 0; i < tokens_1.xpathTokenRules.length; ++i) {
             tokens_1.xpathTokenRules[i].key = k++;
         }
-        xpathLog(`XPath parse INIT: ${k} rules`);
+        xPathLog("XPath parse INIT: ".concat(k, " rules"));
         // Another slight optimization: sort the rules into bins according
         // to the last element (observing quantifiers), so we can restrict
         // the match against the stack to the subest of rules that match the
@@ -624,10 +623,10 @@ class XPath {
             }
             array[position].push(element);
         }
-        for (let i = 0; i < this.xPathGrammarRules.length; ++i) {
-            const rule = this.xPathGrammarRules[i];
-            const pattern = rule[1];
-            for (let j = pattern.length - 1; j >= 0; --j) {
+        for (var i = 0; i < this.xPathGrammarRules.length; ++i) {
+            var rule = this.xPathGrammarRules[i];
+            var pattern = rule[1];
+            for (var j = pattern.length - 1; j >= 0; --j) {
                 if (pattern[j] == tokens_1.Q_1M) {
                     push_(this.xPathRules, pattern[j - 1].key, rule);
                     break;
@@ -642,15 +641,15 @@ class XPath {
                 }
             }
         }
-        xpathLog(`XPath parse INIT: ${this.xPathRules.length} rule bins`);
-        let sum = 0;
-        (0, util_1.mapExec)(this.xPathRules, (i) => {
+        xPathLog("XPath parse INIT: ".concat(this.xPathRules.length, " rule bins"));
+        var sum = 0;
+        (0, util_1.mapExec)(this.xPathRules, function (i) {
             if (i) {
                 sum += i.length;
             }
         });
-        xpathLog(`XPath parse INIT: ${sum / this.xPathRules.length} average bin size`);
-    }
+        xPathLog("XPath parse INIT: ".concat(sum / this.xPathRules.length, " average bin size"));
+    };
     /*DGF xpathReduce is where the magic happens in this parser.
     Skim down to the bottom of this file to find the table of
     grammatical rules and precedence numbers, "The productions of the grammar".
@@ -676,22 +675,23 @@ class XPath {
     Some tokens have left associativity, in which case we shift when they
     have LOWER precedence than the candidate.
     */
-    xPathReduce(stack, ahead, xpathLog = (message) => {
-        // console.log(message);
-    }) {
-        let cand = null;
+    XPath.prototype.xPathReduce = function (stack, ahead, xpathLog) {
+        if (xpathLog === void 0) { xpathLog = function (message) {
+            // console.log(message);
+        }; }
+        var cand = null;
         if (stack.length > 0) {
-            const top = stack[stack.length - 1];
-            const ruleset = this.xPathRules[top.tag.key];
+            var top_1 = stack[stack.length - 1];
+            var ruleset = this.xPathRules[top_1.tag.key];
             if (ruleset) {
-                for (let i = 0; i < ruleset.length; ++i) {
-                    const rule = ruleset[i];
-                    const match = this.xPathMatchStack(stack, rule[1]);
+                for (var i = 0; i < ruleset.length; ++i) {
+                    var rule = ruleset[i];
+                    var match = this.xPathMatchStack(stack, rule[1]);
                     if (match.length) {
                         cand = {
                             tag: rule[0],
-                            rule,
-                            match
+                            rule: rule,
+                            match: match
                         };
                         cand.prec = this.xPathGrammarPrecedence(cand);
                         break;
@@ -699,44 +699,45 @@ class XPath {
                 }
             }
         }
-        let ret;
+        var ret;
         if (cand && (!ahead || cand.prec > ahead.prec || (ahead.tag.left && cand.prec >= ahead.prec))) {
-            for (let i = 0; i < cand.match.matchlength; ++i) {
+            for (var i = 0; i < cand.match.matchlength; ++i) {
                 stack.pop();
             }
-            xpathLog(`reduce ${cand.tag.label} ${cand.prec} ahead ${ahead ? ahead.tag.label + ' ' + ahead.prec + (ahead.tag.left ? ' left' : '') : ' none '}`);
-            const matchexpr = (0, util_1.mapExpr)(cand.match, (m) => m.expr);
-            xpathLog(`going to apply ${cand.rule[3]}`);
+            xpathLog("reduce ".concat(cand.tag.label, " ").concat(cand.prec, " ahead ").concat(ahead ? ahead.tag.label + ' ' + ahead.prec + (ahead.tag.left ? ' left' : '') : ' none '));
+            var matchexpr = (0, util_1.mapExpr)(cand.match, function (m) { return m.expr; });
+            xpathLog("going to apply ".concat(cand.rule[3]));
             cand.expr = cand.rule[3].apply(this, matchexpr);
             stack.push(cand);
             ret = true;
         }
         else {
             if (ahead) {
-                xpathLog(`shift ${ahead.tag.label} ${ahead.prec}${ahead.tag.left ? ' left' : ''} over ${cand ? cand.tag.label + ' ' + cand.prec : ' none'}`);
+                xpathLog("shift ".concat(ahead.tag.label, " ").concat(ahead.prec).concat(ahead.tag.left ? ' left' : '', " over ").concat(cand ? cand.tag.label + ' ' + cand.prec : ' none'));
                 stack.push(ahead);
             }
             ret = false;
         }
         return ret;
-    }
+    };
     // Utility function to sort a list of nodes. Used by xsltSort() and
     // nxslSelect().
-    xPathSort(input, sort) {
+    XPath.prototype.xPathSort = function (context, sort) {
         if (sort.length == 0) {
             return;
         }
-        const sortlist = [];
-        for (let i = 0; i < input.contextSize(); ++i) {
-            const node = input.nodelist[i];
-            const sortitem = {
-                node,
+        var sortlist = [];
+        for (var i = 0; i < context.contextSize(); ++i) {
+            var node = context.nodelist[i];
+            var sortitem = {
+                node: node,
                 key: []
             };
-            const context = input.clone(node, 0, [node]);
-            for (const s of sort) {
-                const value = s.expr.evaluate(context);
-                let evalue;
+            var clonedContext = context.clone([node], 0);
+            for (var _i = 0, sort_1 = sort; _i < sort_1.length; _i++) {
+                var s = sort_1[_i];
+                var value = s.expr.evaluate(clonedContext);
+                var evalue = void 0;
                 if (s.type == 'text') {
                     evalue = value.stringValue();
                 }
@@ -758,13 +759,13 @@ class XPath {
             sortlist.push(sortitem);
         }
         sortlist.sort(this.xPathSortByKey);
-        const nodes = [];
-        for (let i = 0; i < sortlist.length; ++i) {
+        var nodes = [];
+        for (var i = 0; i < sortlist.length; ++i) {
             nodes.push(sortlist[i].node);
         }
-        input.nodelist = nodes;
-        input.setNode(0);
-    }
+        context.nodelist = nodes;
+        context.setNode(0);
+    };
     // Sorts by all order criteria defined. According to the JavaScript
     // spec ([ECMA] Section 11.8.5), the compare operators compare strings
     // as strings and numbers as numbers.
@@ -772,25 +773,25 @@ class XPath {
     // NOTE: In browsers which do not follow the spec, this breaks only in
     // the case that numbers should be sorted as strings, which is very
     // uncommon.
-    xPathSortByKey(v1, v2) {
+    XPath.prototype.xPathSortByKey = function (v1, v2) {
         // NOTE: Sort key vectors of different length never occur in
         // xsltSort.
-        for (let i = 0; i < v1.key.length; ++i) {
-            const o = v1.key[i].order == 'descending' ? -1 : 1;
+        for (var i = 0; i < v1.key.length; ++i) {
+            var o = v1.key[i].order == 'descending' ? -1 : 1;
             if (v1.key[i].value > v2.key[i].value) {
                 return +1 * o;
             }
-            else if (v1.key[i].value < v2.key[i].value) {
+            if (v1.key[i].value < v2.key[i].value) {
                 return -1 * o;
             }
         }
         return 0;
-    }
-    xPathStep(nodes, steps, step, input, ctx) {
-        const s = steps[step];
-        const ctx2 = ctx.clone(input);
+    };
+    XPath.prototype.xPathStep = function (nodes, steps, step, input, ctx) {
+        var s = steps[step];
+        var ctx2 = ctx.clone([input], 0);
         if (ctx.returnOnFirstMatch && !s.hasPositionalPredicate) {
-            let nodelist = s.evaluate(ctx2).nodeSetValue();
+            var nodelist = s.evaluate(ctx2).nodeSetValue();
             // the predicates were not processed in the last evaluate(), so that we can
             // process them here with the returnOnFirstMatch optimization. We do a
             // depth-first grab at any nodes that pass the predicate tests. There is no
@@ -798,21 +799,20 @@ class XPath {
             // indexes or uses of the last() or position() functions, because they
             // typically require the entire nodelist for context. Process without
             // optimization if we encounter such selectors.
-            const nLength = nodelist.length;
-            const pLength = s.predicate.length;
-            nodelistLoop: for (let i = 0; i < nLength; ++i) {
-                const n = nodelist[i];
-                for (let j = 0; j < pLength; ++j) {
-                    if (!s.predicate[j].evaluate(ctx.clone(n, i, nodelist)).booleanValue()) {
+            var nLength = nodelist.length;
+            var pLength = s.predicate.length;
+            nodelistLoop: for (var i = 0; i < nLength; ++i) {
+                for (var j = 0; j < pLength; ++j) {
+                    if (!s.predicate[j].evaluate(ctx.clone(nodelist, i)).booleanValue()) {
                         continue nodelistLoop;
                     }
                 }
                 // n survived the predicate tests!
                 if (step == steps.length - 1) {
-                    nodes.push(n);
+                    nodes.push(nodelist[i]);
                 }
                 else {
-                    this.xPathStep(nodes, steps, step + 1, n, ctx);
+                    this.xPathStep(nodes, steps, step + 1, nodelist[i], ctx);
                 }
                 if (nodes.length > 0) {
                     break;
@@ -824,8 +824,8 @@ class XPath {
             // behavior in StepExpr.prototype.evaluate is driven off its value. Note
             // that the original context may still have true for this value.
             ctx2.returnOnFirstMatch = false;
-            let nodelist = s.evaluate(ctx2).nodeSetValue();
-            for (let i = 0; i < nodelist.length; ++i) {
+            var nodelist = s.evaluate(ctx2).nodeSetValue();
+            for (var i = 0; i < nodelist.length; ++i) {
                 if (step == steps.length - 1) {
                     nodes.push(nodelist[i]);
                 }
@@ -834,17 +834,17 @@ class XPath {
                 }
             }
         }
-    }
-    xPathGrammarPrecedence(frame) {
-        let ret = 0;
+    };
+    XPath.prototype.xPathGrammarPrecedence = function (frame) {
+        var ret = 0;
         if (frame.rule) {
             /* normal reduce */
             if (frame.rule.length >= 3 && frame.rule[2] >= 0) {
                 ret = frame.rule[2];
             }
             else {
-                for (let i = 0; i < frame.rule[1].length; ++i) {
-                    let p = this.xPathTokenPrecedence(frame.rule[1][i]);
+                for (var i = 0; i < frame.rule[1].length; ++i) {
+                    var p = this.xPathTokenPrecedence(frame.rule[1][i]);
                     ret = Math.max(ret, p);
                 }
             }
@@ -855,16 +855,17 @@ class XPath {
         }
         else if (frame.length) {
             /* Q_ match */
-            for (let j = 0; j < frame.length; ++j) {
-                let p = this.xPathGrammarPrecedence(frame[j]);
+            for (var j = 0; j < frame.length; ++j) {
+                var p = this.xPathGrammarPrecedence(frame[j]);
                 ret = Math.max(ret, p);
             }
         }
         return ret;
-    }
-    xPathTokenPrecedence(tag) {
+    };
+    XPath.prototype.xPathTokenPrecedence = function (tag) {
         return tag.prec || 2;
-    }
-}
+    };
+    return XPath;
+}());
 exports.XPath = XPath;
 //# sourceMappingURL=xpath.js.map