xslt-processor 1.0.0 → 1.1.0

package/xslt.js

@@ -0,0 +1,643 @@
+"use strict";
+// Copyright 2023 Design Liquido
+// Copyright 2018 Johannes Wilm
+// Copyright 2005 Google Inc.
+// All Rights Reserved
+//
+//
+// An XSL-T processor written in JavaScript. The implementation is NOT
+// complete; some xsl element are left out.
+//
+// References:
+//
+// [XSLT] XSL-T Specification
+// <http://www.w3.org/TR/1999/REC-xslt-19991116>.
+//
+// [ECMA] ECMAScript Language Specification
+// <http://www.ecma-international.org/publications/standards/Ecma-262.htm>.
+//
+// The XSL processor API has one entry point, the function
+// xsltProcessContext(). It receives as arguments the starting point in the
+// input document as an XPath expression context, the DOM root node of
+// the XSL-T stylesheet, and a DOM node that receives the output.
+//
+// NOTE: Actually, XSL-T processing according to the specification is
+// defined as operation on text documents, not as operation on DOM
+// trees. So, strictly speaking, this implementation is not an XSL-T
+// processor, but the processing engine that needs to be complemented
+// by an XML parser and serializer in order to be complete. Those two
+// are found in the file xml.js.
+//
+//
+// TODO(mesch): add jsdoc comments. Use more coherent naming. Finish
+// remaining XSLT features.
+//
+//
+// Original author: Steffen Meschkat <mesch@google.com>
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Xslt = void 0;
+var dom_1 = require("./dom");
+var xpath_1 = require("./xpath");
+var constants_1 = require("./constants");
+var values_1 = require("./xpath/values");
+var Xslt = /** @class */ (function () {
+    function Xslt() {
+        this.xPath = new xpath_1.XPath();
+    }
+    /**
+     * The exported entry point of the XSL-T processor.
+     * @param xmlDoc The input document root, as DOM node.
+     * @param stylesheet The stylesheet document root, as DOM node.
+     * @param parameters Additional parameters to be set as variables.
+     * @returns the processed document, as XML text in a string.
+     */
+    Xslt.prototype.xsltProcess = function (xmlDoc, stylesheet, parameters) {
+        var output = new dom_1.XDocument();
+        output.appendChild(dom_1.XNode.clone(xmlDoc.childNodes[0], output));
+        var expressionContext = new xpath_1.ExprContext([output]);
+        if (parameters && typeof parameters === 'object') {
+            for (var _i = 0, _a = Object.entries(parameters); _i < _a.length; _i++) {
+                var _b = _a[_i], key = _b[0], value = _b[1];
+                expressionContext.setVariable(key, new values_1.StringValue(value));
+            }
+        }
+        this.xsltProcessContext(expressionContext, stylesheet, output, parameters);
+        var ret = (0, dom_1.xmlTransformedText)(output);
+        return ret;
+    };
+    /**
+     * The main entry point of the XSL-T processor, as explained on the top of the file.
+     * @param context The input document root, as XPath ExprContext.
+     * @param template The stylesheet document root, as DOM node.
+     * @param output the root of the generated output, as DOM node.
+     * @param _parameters Extra parameters.
+     */
+    Xslt.prototype.xsltProcessContext = function (context, template, output, _parameters) {
+        var outputDocument = (0, dom_1.xmlOwnerDocument)(output);
+        if (!this.isXsltElement(template)) {
+            this.xsltPassThrough(context, template, output, outputDocument);
+        }
+        else {
+            var name_1, top_1, nameExpr = void 0, node = void 0, select = void 0, value = void 0, nodes = void 0, sortContext = void 0, mode = void 0, templates = void 0, paramContext = void 0, commentData = void 0, commentNode = void 0, test_1, match = void 0, text = void 0;
+            switch (template.localName) {
+                case 'apply-imports':
+                    throw "not implemented: ".concat(template.localName);
+                case 'apply-templates':
+                    select = (0, dom_1.xmlGetAttribute)(template, 'select');
+                    if (select) {
+                        nodes = this.xPath.xPathEval(select, context).nodeSetValue();
+                    }
+                    else {
+                        nodes = context.nodelist[context.position].childNodes;
+                    }
+                    sortContext = context.clone(nodes, 0);
+                    this.xsltWithParam(sortContext, template);
+                    this.xsltSort(sortContext, template);
+                    mode = (0, dom_1.xmlGetAttribute)(template, 'mode');
+                    top_1 = template.ownerDocument.documentElement;
+                    templates = [];
+                    for (var i = 0; i < top_1.childNodes.length; ++i) {
+                        var c = top_1.childNodes[i];
+                        var matchAttribute = c.getAttributeValue('match');
+                        // Avoiding infinite loops.
+                        if (matchAttribute && matchAttribute.startsWith('/')) {
+                            continue;
+                        }
+                        if (c.nodeType == constants_1.DOM_ELEMENT_NODE &&
+                            this.isXsltElement(c, 'template') &&
+                            (!mode || c.getAttributeValue('mode') == mode)) {
+                            templates.push(c);
+                        }
+                    }
+                    for (var j = 0; j < sortContext.contextSize(); ++j) {
+                        for (var i = 0; i < templates.length; ++i) {
+                            this.xsltProcessContext(sortContext.clone(sortContext.nodelist, j), templates[i], output);
+                        }
+                    }
+                    break;
+                case 'attribute':
+                    nameExpr = (0, dom_1.xmlGetAttribute)(template, 'name');
+                    name_1 = this.xsltAttributeValue(nameExpr, context);
+                    node = (0, dom_1.domCreateDocumentFragment)(outputDocument);
+                    this.xsltChildNodes(context, template, node);
+                    value = (0, dom_1.xmlValue2)(node);
+                    (0, dom_1.domSetTransformedAttribute)(output, name_1, value);
+                    break;
+                case 'attribute-set':
+                    throw "not implemented: ".concat(template.localName);
+                case 'call-template':
+                    name_1 = (0, dom_1.xmlGetAttribute)(template, 'name');
+                    top_1 = template.ownerDocument.documentElement;
+                    paramContext = context.clone();
+                    this.xsltWithParam(paramContext, template);
+                    for (var i = 0; i < top_1.childNodes.length; ++i) {
+                        var c = top_1.childNodes[i];
+                        if (c.nodeType == constants_1.DOM_ELEMENT_NODE &&
+                            this.isXsltElement(c, 'template') &&
+                            (0, dom_1.domGetAttributeValue)(c, 'name') == name_1) {
+                            this.xsltChildNodes(paramContext, c, output);
+                            break;
+                        }
+                    }
+                    break;
+                case 'choose':
+                    this.xsltChoose(context, template, output);
+                    break;
+                case 'comment':
+                    node = (0, dom_1.domCreateDocumentFragment)(outputDocument);
+                    this.xsltChildNodes(context, template, node);
+                    commentData = (0, dom_1.xmlValue)(node);
+                    commentNode = (0, dom_1.domCreateComment)(outputDocument, commentData);
+                    output.appendChild(commentNode);
+                    break;
+                case 'copy':
+                    node = this.xsltCopy(output, context.nodelist[context.position], outputDocument);
+                    if (node) {
+                        this.xsltChildNodes(context, template, node);
+                    }
+                    break;
+                case 'copy-of':
+                    select = (0, dom_1.xmlGetAttribute)(template, 'select');
+                    value = this.xPath.xPathEval(select, context);
+                    if (value.type == 'node-set') {
+                        nodes = value.nodeSetValue();
+                        for (var i = 0; i < nodes.length; ++i) {
+                            this.xsltCopyOf(output, nodes[i], outputDocument);
+                        }
+                    }
+                    else {
+                        var node_1 = (0, dom_1.domCreateTextNode)(outputDocument, value.stringValue());
+                        (0, dom_1.domAppendChild)(output, node_1);
+                    }
+                    break;
+                case 'decimal-format':
+                    throw "not implemented: ".concat(template.localName);
+                case 'element':
+                    nameExpr = (0, dom_1.xmlGetAttribute)(template, 'name');
+                    name_1 = this.xsltAttributeValue(nameExpr, context);
+                    node = (0, dom_1.domCreateElement)(outputDocument, name_1);
+                    // Adds context children reference to this new node,
+                    // so then further transformations are also observed
+                    // by this new node.
+                    var contextNode = context.nodelist[context.position];
+                    node.childNodes = contextNode.childNodes;
+                    node.transformedNodeName = name_1;
+                    (0, dom_1.domAppendTransformedChild)(output, node);
+                    this.xsltChildNodes(context, template, node);
+                    break;
+                case 'fallback':
+                    throw "not implemented: ".concat(template.localName);
+                case 'for-each':
+                    this.xsltForEach(context, template, output);
+                    break;
+                case 'if':
+                    test_1 = (0, dom_1.xmlGetAttribute)(template, 'test');
+                    if (this.xPath.xPathEval(test_1, context).booleanValue()) {
+                        this.xsltChildNodes(context, template, output);
+                    }
+                    break;
+                case 'import':
+                    throw "not implemented: ".concat(template.localName);
+                case 'include':
+                    throw "not implemented: ".concat(template.localName);
+                case 'key':
+                    throw "not implemented: ".concat(template.localName);
+                case 'message':
+                    throw "not implemented: ".concat(template.localName);
+                case 'namespace-alias':
+                    throw "not implemented: ".concat(template.localName);
+                case 'number':
+                    throw "not implemented: ".concat(template.localName);
+                case 'otherwise':
+                    throw "error if here: ".concat(template.localName);
+                case 'output':
+                    // Ignored. -- Since we operate on the DOM, and all further use
+                    // of the output of the XSL transformation is determined by the
+                    // browser that we run in, this parameter is not applicable to
+                    // this implementation.
+                    break;
+                case 'preserve-space':
+                    throw "not implemented: ".concat(template.localName);
+                case 'processing-instruction':
+                    throw "not implemented: ".concat(template.localName);
+                case 'sort':
+                    // just ignore -- was handled by xsltSort()
+                    break;
+                case 'strip-space':
+                    throw "not implemented: ".concat(template.localName);
+                case 'stylesheet':
+                case 'transform':
+                    this.xsltChildNodes(context, template, output);
+                    break;
+                case 'template':
+                    match = (0, dom_1.xmlGetAttribute)(template, 'match');
+                    if (match && this.xsltMatch(match, context)) {
+                        this.xsltChildNodes(context, template, output);
+                    }
+                    break;
+                case 'text':
+                    text = (0, dom_1.xmlValue)(template);
+                    node = (0, dom_1.domCreateTransformedTextNode)(outputDocument, text);
+                    output.appendTransformedChild(node);
+                    break;
+                case 'value-of':
+                    select = (0, dom_1.xmlGetAttribute)(template, 'select');
+                    var attribute = this.xPath.xPathEval(select, context);
+                    value = attribute.stringValue();
+                    node = (0, dom_1.domCreateTransformedTextNode)(outputDocument, value);
+                    context.nodelist[context.position].appendTransformedChild(node);
+                    break;
+                case 'param':
+                    this.xsltVariable(context, template, false);
+                    break;
+                case 'variable':
+                    this.xsltVariable(context, template, true);
+                    break;
+                case 'when':
+                    throw "error if here: ".concat(template.localName);
+                case 'with-param':
+                    throw "error if here: ".concat(template.localName);
+                default:
+                    throw "error if here: ".concat(template.localName);
+            }
+        }
+    };
+    /**
+     * Implements `xsl:copy` for all node types.
+     * @param {XNode} destination the node being copied to, part of output document
+     * @param {XNode} source the node being copied, part in input document
+     * @param {XDocument} destinationDocument dstDocument
+     * @returns {XNode|null} If an element node was created, the element node. Otherwise null.
+     */
+    Xslt.prototype.xsltCopy = function (destination, source, destinationDocument) {
+        if (source.nodeType == constants_1.DOM_ELEMENT_NODE) {
+            var node = (0, dom_1.domCreateElement)(destinationDocument, source.nodeName);
+            node.transformedNodeName = source.nodeName;
+            (0, dom_1.domAppendTransformedChild)(destination, node);
+            return node;
+        }
+        if (source.nodeType == constants_1.DOM_TEXT_NODE) {
+            var node = (0, dom_1.domCreateTransformedTextNode)(destinationDocument, source.nodeValue);
+            (0, dom_1.domAppendTransformedChild)(destination, node);
+        }
+        else if (source.nodeType == constants_1.DOM_CDATA_SECTION_NODE) {
+            var node = (0, dom_1.domCreateCDATASection)(destinationDocument, source.nodeValue);
+            (0, dom_1.domAppendTransformedChild)(destination, node);
+        }
+        else if (source.nodeType == constants_1.DOM_COMMENT_NODE) {
+            var node = (0, dom_1.domCreateComment)(destinationDocument, source.nodeValue);
+            (0, dom_1.domAppendTransformedChild)(destination, node);
+        }
+        else if (source.nodeType == constants_1.DOM_ATTRIBUTE_NODE) {
+            (0, dom_1.domSetTransformedAttribute)(destination, source.nodeName, source.nodeValue);
+        }
+        return null;
+    };
+    /**
+     * Orders the current node list in the input context according to the
+     * sort order specified by xsl:sort child nodes of the current
+     * template node. This happens before the operation specified by the
+     * current template node is executed.
+     * @param context TODO
+     * @param template TODO
+     * @todo case-order is not implemented.
+     */
+    Xslt.prototype.xsltSort = function (context, template) {
+        var sort = [];
+        for (var _i = 0, _a = template.childNodes; _i < _a.length; _i++) {
+            var c = _a[_i];
+            if (c.nodeType == constants_1.DOM_ELEMENT_NODE && this.isXsltElement(c, 'sort')) {
+                var select = (0, dom_1.xmlGetAttribute)(c, 'select');
+                var expr = this.xPath.xPathParse(select);
+                var type = (0, dom_1.xmlGetAttribute)(c, 'data-type') || 'text';
+                var order = (0, dom_1.xmlGetAttribute)(c, 'order') || 'ascending';
+                sort.push({
+                    expr: expr,
+                    type: type,
+                    order: order
+                });
+            }
+        }
+        this.xPath.xPathSort(context, sort);
+    };
+    /**
+     * Evaluates a variable or parameter and set it in the current input
+     * context. Implements `xsl:variable`, `xsl:param`, and `xsl:with-param`.
+     *
+     * @param input TODO
+     * @param template TODO
+     * @param override flag that defines if the value computed here
+     * overrides the one already in the input context if that is the
+     * case. I.e. decides if this is a default value or a local
+     * value. xsl:variable and xsl:with-param override; xsl:param doesn't.
+     */
+    Xslt.prototype.xsltVariable = function (input, template, override) {
+        var name = (0, dom_1.xmlGetAttribute)(template, 'name');
+        var select = (0, dom_1.xmlGetAttribute)(template, 'select');
+        var value;
+        if (template.childNodes.length > 0) {
+            var root = (0, dom_1.domCreateDocumentFragment)(template.ownerDocument);
+            this.xsltChildNodes(input, template, root);
+            value = new values_1.NodeSetValue([root]);
+        }
+        else if (select) {
+            value = this.xPath.xPathEval(select, input);
+        }
+        else {
+            value = new values_1.StringValue('');
+        }
+        if (override || !input.getVariable(name)) {
+            input.setVariable(name, value);
+        }
+    };
+    // Implements xsl:chose and its child nodes xsl:when and
+    // xsl:otherwise.
+    Xslt.prototype.xsltChoose = function (input, template, output) {
+        for (var _i = 0, _a = template.childNodes; _i < _a.length; _i++) {
+            var childNode = _a[_i];
+            if (childNode.nodeType !== constants_1.DOM_ELEMENT_NODE) {
+                continue;
+            }
+            if (this.isXsltElement(childNode, 'when')) {
+                var test_2 = (0, dom_1.xmlGetAttribute)(childNode, 'test');
+                if (this.xPath.xPathEval(test_2, input).booleanValue()) {
+                    this.xsltChildNodes(input, childNode, output);
+                    break;
+                }
+            }
+            else if (this.isXsltElement(childNode, 'otherwise')) {
+                this.xsltChildNodes(input, childNode, output);
+                break;
+            }
+        }
+    };
+    /**
+     * Implements `xsl:for-each`.
+     * @param context TODO
+     * @param template TODO
+     * @param output TODO
+     */
+    Xslt.prototype.xsltForEach = function (context, template, output) {
+        var select = (0, dom_1.xmlGetAttribute)(template, 'select');
+        var nodes = this.xPath.xPathEval(select, context).nodeSetValue();
+        var sortContext = context.clone(nodes, 0);
+        this.xsltSort(sortContext, template);
+        var nodesWithParent = sortContext.nodelist.filter(function (n) { return n.parentNode !== null && n.parentNode !== undefined; });
+        if (nodesWithParent.length <= 0) {
+            throw new Error('Nodes with no parents defined.');
+        }
+        var parent = nodesWithParent[0].parentNode;
+        parent.childNodes = sortContext.nodelist;
+        for (var i = 0; i < sortContext.contextSize(); ++i) {
+            this.xsltChildNodes(sortContext.clone(sortContext.nodelist, i), template, output);
+        }
+        // TODO: group nodes by parent node.
+        // const nodeGroups = this.groupBy(nodes, 'parentNode');
+        /* for (let [group, _nodes] of Object.entries(nodeGroups)) {
+            const sortContext = context.clone(_nodes, 0);
+            this.xsltSort(sortContext, template);
+
+            for (let i = 0; i < sortContext.contextSize(); ++i) {
+                this.xsltChildNodes(sortContext.clone(sortContext.nodelist, i), template, output);
+            }
+        } */
+    };
+    Xslt.prototype.groupBy = function (xs, key) {
+        return xs.reduce(function (rv, x) {
+            (rv[x[key]] = rv[x[key]] || []).push(x);
+            return rv;
+        }, {});
+    };
+    /**
+     * Traverses the template node tree. Calls the main processing
+     * function with the current input context for every child node of the
+     * current template node.
+     * @param context Normally the Expression Context.
+     * @param template The XSL-T definition.
+     * @param output The XML output.
+     */
+    Xslt.prototype.xsltChildNodes = function (context, template, output) {
+        // Clone input context to keep variables declared here local to the
+        // siblings of the children.
+        var contextClone = context.clone();
+        for (var i = 0; i < template.childNodes.length; ++i) {
+            this.xsltProcessContext(contextClone, template.childNodes[i], output);
+        }
+    };
+    /**
+     * Passes template text to the output. The current template node does
+     * not specify an XSL-T operation and therefore is appended to the
+     * output with all its attributes. Then continues traversing the
+     * template node tree.
+     * @param context The Expression Context.
+     * @param template The XSLT stylesheet or transformation.
+     * @param output The output.
+     * @param outputDocument The output document, if the case.
+     */
+    Xslt.prototype.xsltPassThrough = function (context, template, output, outputDocument) {
+        if (template.nodeType == constants_1.DOM_TEXT_NODE) {
+            if (this.xsltPassText(template)) {
+                var textNodeList = context.nodelist[context.position].transformedChildNodes.filter(function (n) { return n.nodeType === constants_1.DOM_TEXT_NODE; });
+                if (textNodeList.length > 0) {
+                    var node = textNodeList[0];
+                    node.transformedNodeValue = template.nodeValue;
+                }
+                else {
+                    var node = (0, dom_1.domCreateTextNode)(outputDocument, template.nodeValue);
+                    (0, dom_1.domAppendTransformedChild)(context.nodelist[context.position], node);
+                }
+            }
+        }
+        else if (template.nodeType == constants_1.DOM_ELEMENT_NODE) {
+            var node = void 0;
+            if (context.nodelist[context.position].nodeName === '#document') {
+                node = context.nodelist[context.position].firstChild;
+            }
+            else {
+                node = context.nodelist[context.position];
+            }
+            node.transformedNodeName = template.nodeName;
+            node.transformedLocalName = template.localName;
+            for (var _i = 0, _a = template.attributes.filter(function (a) { return a; }); _i < _a.length; _i++) {
+                var attribute = _a[_i];
+                var name_2 = attribute.nodeName;
+                var value = this.xsltAttributeValue(attribute.nodeValue, context);
+                (0, dom_1.domSetTransformedAttribute)(node, name_2, value);
+            }
+            this.xsltChildNodes(context, template, node);
+        }
+        else {
+            // This applies also to the DOCUMENT_NODE of the XSL stylesheet,
+            // so we don't have to treat it specially.
+            this.xsltChildNodes(context, template, output);
+        }
+    };
+    /**
+     * Determines if a text node in the XSLT template document is to be
+     * stripped according to XSLT whitespace stripping rules.
+     * @see [XSLT], section 3.4.
+     * @param template The XSLT template.
+     * @returns TODO
+     * @todo Whitespace stripping on the input document is
+     * currently not implemented.
+     */
+    Xslt.prototype.xsltPassText = function (template) {
+        if (!template.nodeValue.match(/^\s*$/)) {
+            return true;
+        }
+        var element = template.parentNode;
+        if (this.isXsltElement(element, 'text')) {
+            return true;
+        }
+        while (element && element.nodeType == constants_1.DOM_ELEMENT_NODE) {
+            var xmlspace = (0, dom_1.domGetAttributeValue)(element, 'xml:space');
+            if (xmlspace) {
+                if (xmlspace == 'default') {
+                    return false;
+                }
+                if (xmlspace == 'preserve') {
+                    return true;
+                }
+            }
+            element = element.parentNode;
+        }
+        return false;
+    };
+    /**
+     * Evaluates an XSL-T attribute value template. Attribute value
+     * templates are attributes on XSL-T elements that contain XPath
+     * expressions in braces {}. The XSL-T expressions are evaluated in
+     * the current input context.
+     * @param value TODO
+     * @param context TODO
+     * @returns TODO
+     */
+    Xslt.prototype.xsltAttributeValue = function (value, context) {
+        var parts = value.split('{');
+        if (parts.length == 1) {
+            return value;
+        }
+        var ret = '';
+        for (var i = 0; i < parts.length; ++i) {
+            var rp = parts[i].split('}');
+            if (rp.length != 2) {
+                // first literal part of the value
+                ret += parts[i];
+                continue;
+            }
+            var val = this.xPath.xPathEval(rp[0], context).stringValue();
+            ret += val + rp[1];
+        }
+        return ret;
+    };
+    /**
+     * Implements xsl:copy-of for node-set values of the select
+     * expression. Recurses down the source node tree, which is part of
+     * the input document.
+     * @param {XNode} dst the node being copied to, part of output document
+     * @param {XNode} src the node being copied, part in input document
+     * @param {XDocument} dstDocument dstDocument
+     */
+    Xslt.prototype.xsltCopyOf = function (dst, src, dstDocument) {
+        if (src.nodeType == constants_1.DOM_DOCUMENT_FRAGMENT_NODE || src.nodeType == constants_1.DOM_DOCUMENT_NODE) {
+            for (var i = 0; i < src.childNodes.length; ++i) {
+                this.xsltCopyOf(dst, src.childNodes[i], dstDocument);
+            }
+        }
+        else {
+            var node = this.xsltCopy(dst, src, dstDocument);
+            if (node) {
+                // This was an element node -- recurse to attributes and
+                // children.
+                for (var i = 0; i < src.attributes.length; ++i) {
+                    this.xsltCopyOf(node, src.attributes[i], dstDocument);
+                }
+                for (var i = 0; i < src.childNodes.length; ++i) {
+                    this.xsltCopyOf(node, src.childNodes[i], dstDocument);
+                }
+            }
+        }
+    };
+    /**
+     * Evaluates an XPath expression in the current input context as a
+     * match.
+     * @see [XSLT] section 5.2, paragraph 1
+     * @param match TODO
+     * @param context TODO
+     * @returns TODO
+     */
+    Xslt.prototype.xsltMatch = function (match, context) {
+        var expr = this.xPath.xPathParse(match);
+        if (expr.steps.length <= 0) {
+            throw new Error('Error resolving XSLT match: Location Expression should have steps.');
+        }
+        var firstStep = expr.steps[0];
+        // Shortcut for the most common case.
+        if (expr.steps &&
+            !expr.absolute &&
+            expr.steps.length == 1 &&
+            firstStep.axis == 'child' &&
+            firstStep.predicate.length === 0) {
+            return firstStep.nodetest.evaluate(context).booleanValue();
+        }
+        if (expr.absolute && firstStep.axis !== 'self') {
+            // TODO: `xPathCollectDescendants()`?
+            var levels = match.split('/');
+            if (levels.length > 1) {
+                return this.absoluteXsltMatch(levels, expr, context);
+            }
+        }
+        return this.relativeXsltMatch(expr, context);
+    };
+    /**
+     * Sets parameters defined by xsl:with-param child nodes of the
+     * current template node, in the current input context. This happens
+     * before the operation specified by the current template node is
+     * executed.
+     * @param input TODO
+     * @param template TODO
+     */
+    Xslt.prototype.xsltWithParam = function (input, template) {
+        for (var _i = 0, _a = template.childNodes; _i < _a.length; _i++) {
+            var c = _a[_i];
+            if (c.nodeType === constants_1.DOM_ELEMENT_NODE && this.isXsltElement(c, 'with-param')) {
+                this.xsltVariable(input, c, true);
+            }
+        }
+    };
+    Xslt.prototype.absoluteXsltMatch = function (levels, expr, context) {
+        var result = expr.evaluate(context.clone([context.nodelist[context.position]], 0)).nodeSetValue();
+        if (result.length > 0) {
+            context.nodelist = result;
+            return true;
+        }
+        return false;
+    };
+    Xslt.prototype.relativeXsltMatch = function (expr, context) {
+        var node = context.nodelist[context.position];
+        while (node) {
+            var result = expr.evaluate(context.clone([node], 0)).nodeSetValue();
+            for (var i = 0; i < result.length; ++i) {
+                if (result[i] == context.nodelist[context.position]) {
+                    /* if (context.node.nodeName === "#document") {
+                        context.node = con
+                    } */
+                    return true;
+                }
+            }
+            node = node.parentNode;
+        }
+        return false;
+    };
+    // Test if the given element is an XSLT element, optionally the one with the given name
+    Xslt.prototype.isXsltElement = function (element, opt_wantedName) {
+        if (opt_wantedName && element.localName != opt_wantedName)
+            return false;
+        if (element.namespaceURI)
+            return element.namespaceURI === 'http://www.w3.org/1999/XSL/Transform';
+        return element.prefix === 'xsl'; // backwards compatibility with earlier versions of xslt-processor
+    };
+    return Xslt;
+}());
+exports.Xslt = Xslt;
+//# sourceMappingURL=xslt.js.map