xslt-processor 1.1.5 → 1.2.0

package/xslt/xslt.js

@@ -42,9 +42,17 @@ var expressions_1 = require("../xpath/expressions");
  */
 var Xslt = /** @class */ (function () {
     function Xslt(options) {
-        if (options === void 0) { options = { escape: true }; }
+        if (options === void 0) { options = {
+            escape: true,
+            selfClosingTags: true,
+            parameters: []
+        }; }
         this.xPath = new xpath_1.XPath();
-        this.options = options;
+        this.options = {
+            escape: options.escape || true,
+            selfClosingTags: options.selfClosingTags || true,
+            parameters: options.parameters || []
+        };
         this.outputMethod = 'xml';
         this.outputOmitXmlDeclaration = 'no';
     }
@@ -52,23 +60,24 @@ var Xslt = /** @class */ (function () {
      * 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 && parameters.length > 0) {
-            for (var _i = 0, parameters_1 = parameters; _i < parameters_1.length; _i++) {
-                var parameter = parameters_1[_i];
+    Xslt.prototype.xsltProcess = function (xmlDoc, stylesheet) {
+        var outputDocument = new dom_1.XDocument();
+        this.outputDocument = outputDocument;
+        // output.appendChild(XNode.clone(xmlDoc.childNodes[0], output));
+        var expressionContext = new xpath_1.ExprContext([xmlDoc], [outputDocument]);
+        if (this.options.parameters.length > 0) {
+            for (var _i = 0, _a = this.options.parameters; _i < _a.length; _i++) {
+                var parameter = _a[_i];
                 expressionContext.setVariable(parameter.name, new values_1.StringValue(parameter.value));
             }
         }
-        this.xsltProcessContext(expressionContext, stylesheet, output, parameters || []);
-        var ret = (0, dom_1.xmlTransformedText)(output, {
+        this.xsltProcessContext(expressionContext, stylesheet, outputDocument);
+        var ret = (0, dom_1.xmlTransformedText)(outputDocument, {
             cData: false,
-            escape: this.options.escape
+            escape: this.options.escape,
+            selfClosingTags: this.options.selfClosingTags
         });
         return ret;
     };
@@ -77,90 +86,101 @@ var Xslt = /** @class */ (function () {
      * @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);
+    Xslt.prototype.xsltProcessContext = function (context, template, output) {
+        var _this = this;
         if (!this.isXsltElement(template)) {
-            this.xsltPassThrough(context, template, output, outputDocument);
+            this.xsltPassThrough(context, template, output);
         }
         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;
+            var name_1, top_1, nameExpr = void 0, node = void 0, select = void 0, value = void 0, nodes = 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);
+                    throw new Error("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;
+                        nodes = context.nodeList[context.position].childNodes;
                     }
-                    sortContext = context.clone(nodes, 0);
-                    this.xsltWithParam(sortContext, template, _parameters);
-                    this.xsltSort(sortContext, template);
+                    // TODO: Check why apply-templates was sorting and filing parameters
+                    // automatically.
+                    /* 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('/')) {
+                    for (var _i = 0, _a = top_1.childNodes
+                        .filter(function (c) { return c.nodeType == constants_1.DOM_ELEMENT_NODE &&
+                        _this.isXsltElement(c, 'template'); }); _i < _a.length; _i++) {
+                        var element = _a[_i];
+                        // Actual template should be executed.
+                        // `<xsl:apply-templates>` should have an ancestor `<xsl:template>`
+                        // for comparison.
+                        var templateAncestor = template.getAncestorByLocalName("template");
+                        if (templateAncestor === undefined) {
                             continue;
                         }
-                        if (c.nodeType == constants_1.DOM_ELEMENT_NODE &&
-                            this.isXsltElement(c, 'template') &&
-                            (!mode || c.getAttributeValue('mode') == mode)) {
-                            templates.push(c);
+                        if (templateAncestor.id === element.id) {
+                            continue;
+                        }
+                        if (!mode || element.getAttributeValue('mode') === mode) {
+                            templates.push(element);
                         }
                     }
-                    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, _parameters);
+                    var modifiedContext = context.clone(nodes);
+                    for (var i = 0; i < templates.length; ++i) {
+                        for (var j = 0; j < modifiedContext.contextSize(); ++j) {
+                            var clonedContext_1 = modifiedContext.clone([modifiedContext.nodeList[j]], undefined, 0, undefined);
+                            clonedContext_1.inApplyTemplates = true;
+                            // The output depth should be restarted, since
+                            // another template is being applied from this point.
+                            clonedContext_1.outputDepth = 0;
+                            this.xsltProcessContext(clonedContext_1, 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, _parameters);
+                    node = (0, dom_1.domCreateDocumentFragment)(this.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);
+                    throw new Error("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, _parameters);
+                    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, _parameters);
+                            this.xsltChildNodes(paramContext, c, output);
                             break;
                         }
                     }
                     break;
                 case 'choose':
-                    this.xsltChoose(context, template, output, _parameters);
+                    this.xsltChoose(context, template, output);
                     break;
                 case 'comment':
-                    node = (0, dom_1.domCreateDocumentFragment)(outputDocument);
-                    this.xsltChildNodes(context, template, node, _parameters);
+                    node = (0, dom_1.domCreateDocumentFragment)(this.outputDocument);
+                    this.xsltChildNodes(context, template, node);
                     commentData = (0, dom_1.xmlValue)(node);
-                    commentNode = (0, dom_1.domCreateComment)(outputDocument, commentData);
+                    commentNode = (0, dom_1.domCreateComment)(this.outputDocument, commentData);
                     output.appendChild(commentNode);
                     break;
                 case 'copy':
-                    node = this.xsltCopy(output, context.nodelist[context.position], outputDocument);
+                    node = this.xsltCopy(output, context.nodeList[context.position], this.outputDocument);
                     if (node) {
-                        this.xsltChildNodes(context, template, node, _parameters);
+                        this.xsltChildNodes(context, template, node);
                     }
                     break;
                 case 'copy-of':
@@ -169,80 +189,94 @@ var Xslt = /** @class */ (function () {
                     if (value.type == 'node-set') {
                         nodes = value.nodeSetValue();
                         for (var i = 0; i < nodes.length; ++i) {
-                            this.xsltCopyOf(output, nodes[i], outputDocument);
+                            this.xsltCopyOf(output, nodes[i], this.outputDocument);
                         }
                     }
                     else {
-                        var node_1 = (0, dom_1.domCreateTextNode)(outputDocument, value.stringValue());
+                        var node_1 = (0, dom_1.domCreateTextNode)(this.outputDocument, value.stringValue());
                         (0, dom_1.domAppendChild)(output, node_1);
                     }
                     break;
                 case 'decimal-format':
-                    throw "not implemented: ".concat(template.localName);
+                    throw new Error("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 = (0, dom_1.domCreateElement)(this.outputDocument, name_1);
                     node.transformedNodeName = name_1;
-                    (0, dom_1.domAppendTransformedChild)(output, node);
-                    this.xsltChildNodes(context, template, node, _parameters);
+                    (0, dom_1.domAppendTransformedChild)(context.outputNodeList[context.outputPosition], node);
+                    var clonedContext = context.clone(undefined, [node], undefined, 0);
+                    this.xsltChildNodes(clonedContext, template, node);
                     break;
                 case 'fallback':
-                    throw "not implemented: ".concat(template.localName);
+                    throw new Error("not implemented: ".concat(template.localName));
                 case 'for-each':
-                    this.xsltForEach(context, template, output, _parameters);
+                    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, _parameters);
+                        this.xsltChildNodes(context, template, output);
                     }
                     break;
                 case 'import':
-                    throw "not implemented: ".concat(template.localName);
+                    throw new Error("not implemented: ".concat(template.localName));
                 case 'include':
-                    throw "not implemented: ".concat(template.localName);
+                    throw new Error("not implemented: ".concat(template.localName));
                 case 'key':
-                    throw "not implemented: ".concat(template.localName);
+                    throw new Error("not implemented: ".concat(template.localName));
                 case 'message':
-                    throw "not implemented: ".concat(template.localName);
+                    throw new Error("not implemented: ".concat(template.localName));
                 case 'namespace-alias':
-                    throw "not implemented: ".concat(template.localName);
+                    throw new Error("not implemented: ".concat(template.localName));
                 case 'number':
-                    throw "not implemented: ".concat(template.localName);
+                    throw new Error("not implemented: ".concat(template.localName));
                 case 'otherwise':
                     throw "error if here: ".concat(template.localName);
                 case 'output':
                     this.outputMethod = (0, dom_1.xmlGetAttribute)(template, 'method');
                     this.outputOmitXmlDeclaration = (0, dom_1.xmlGetAttribute)(template, 'omit-xml-declaration');
                     break;
+                case 'param':
+                    this.xsltVariable(context, template, false);
+                    break;
                 case 'preserve-space':
-                    throw "not implemented: ".concat(template.localName);
+                    throw new Error("not implemented: ".concat(template.localName));
                 case 'processing-instruction':
-                    throw "not implemented: ".concat(template.localName);
+                    throw new Error("not implemented: ".concat(template.localName));
                 case 'sort':
-                    // just ignore -- was handled by xsltSort()
+                    this.xsltSort(context, template);
                     break;
                 case 'strip-space':
-                    throw "not implemented: ".concat(template.localName);
+                    throw new Error("not implemented: ".concat(template.localName));
                 case 'stylesheet':
                 case 'transform':
-                    this.xsltChildNodes(context, template, output, _parameters);
+                    this.xsltChildNodes(context, template, output);
                     break;
                 case 'template':
+                    // If `<xsl:template>` is executed outside `<xsl:apply-templates>`,
+                    // only one match is accepted per level (or per context here).
+                    if (!context.inApplyTemplates && context.baseTemplateMatched) {
+                        break;
+                    }
                     match = (0, dom_1.xmlGetAttribute)(template, 'match');
-                    if (match && this.xsltMatch(match, context)) {
-                        this.xsltChildNodes(context, template, output, _parameters);
+                    if (!match)
+                        break;
+                    // XPath doesn't have an axis to select "self and siblings", and
+                    // the default axis is "child", so to select the correct children
+                    // in relative path, we force a 'self-and-siblings' axis.
+                    // nodes = this.xsltMatch(match, context, context.inApplyTemplates ? 'self-and-siblings' : undefined);
+                    nodes = this.xsltMatch(match, context, 'self-and-siblings');
+                    if (nodes.length > 0) {
+                        if (!context.inApplyTemplates) {
+                            context.baseTemplateMatched = true;
+                        }
+                        this.xsltChildNodes(context, template, output);
                     }
                     break;
                 case 'text':
                     text = (0, dom_1.xmlValue)(template);
-                    node = (0, dom_1.domCreateTransformedTextNode)(outputDocument, text);
+                    node = (0, dom_1.domCreateTransformedTextNode)(this.outputDocument, text);
                     var disableOutputEscaping = template.attributes.filter(function (a) { return a.nodeName === 'disable-output-escaping'; });
                     if (disableOutputEscaping.length > 0 && disableOutputEscaping[0].nodeValue === 'yes') {
                         node.escape = false;
@@ -253,21 +287,19 @@ var Xslt = /** @class */ (function () {
                     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, _parameters);
+                    node = (0, dom_1.domCreateTransformedTextNode)(this.outputDocument, value);
+                    node.siblingPosition = context.nodeList[context.position].siblingPosition;
+                    context.outputNodeList[context.outputPosition].appendTransformedChild(node);
                     break;
                 case 'variable':
-                    this.xsltVariable(context, template, true, _parameters);
+                    this.xsltVariable(context, template, true);
                     break;
                 case 'when':
-                    throw "error if here: ".concat(template.localName);
+                    throw new Error("error if here: ".concat(template.localName));
                 case 'with-param':
-                    throw "error if here: ".concat(template.localName);
+                    throw new Error("error if here: ".concat(template.localName));
                 default:
-                    throw "error if here: ".concat(template.localName);
+                    throw new Error("error if here: ".concat(template.localName));
             }
         }
     };
@@ -314,14 +346,14 @@ var Xslt = /** @class */ (function () {
     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';
+            var childNode = _a[_i];
+            if (childNode.nodeType == constants_1.DOM_ELEMENT_NODE && this.isXsltElement(childNode, 'sort')) {
+                var select = (0, dom_1.xmlGetAttribute)(childNode, 'select');
+                var expression = this.xPath.xPathParse(select);
+                var type = (0, dom_1.xmlGetAttribute)(childNode, 'data-type') || 'text';
+                var order = (0, dom_1.xmlGetAttribute)(childNode, 'order') || 'ascending';
                 sort.push({
-                    expr: expr,
+                    expr: expression,
                     type: type,
                     order: order
                 });
@@ -340,13 +372,13 @@ var Xslt = /** @class */ (function () {
      * 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, _parameters) {
+    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, _parameters);
+            this.xsltChildNodes(input, template, root);
             value = new values_1.NodeSetValue([root]);
         }
         else if (select) {
@@ -354,7 +386,7 @@ var Xslt = /** @class */ (function () {
         }
         else {
             var parameterValue = '';
-            var filteredParameter = _parameters.filter(function (p) { return p.name === name; });
+            var filteredParameter = this.options.parameters.filter(function (p) { return p.name === name; });
             if (filteredParameter.length > 0) {
                 parameterValue = filteredParameter[0].value;
             }
@@ -371,7 +403,7 @@ var Xslt = /** @class */ (function () {
      * @param template The template.
      * @param output The output.
      */
-    Xslt.prototype.xsltChoose = function (input, template, output, _parameters) {
+    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) {
@@ -380,12 +412,12 @@ var Xslt = /** @class */ (function () {
             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, _parameters);
+                    this.xsltChildNodes(input, childNode, output);
                     break;
                 }
             }
             else if (this.isXsltElement(childNode, 'otherwise')) {
-                this.xsltChildNodes(input, childNode, output, _parameters);
+                this.xsltChildNodes(input, childNode, output);
                 break;
             }
         }
@@ -396,19 +428,19 @@ var Xslt = /** @class */ (function () {
      * @param template The template.
      * @param output The output.
      */
-    Xslt.prototype.xsltForEach = function (context, template, output, _parameters) {
+    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);
+        var sortContext = context.clone(nodes);
         this.xsltSort(sortContext, template);
-        var nodesWithParent = sortContext.nodelist.filter(function (n) { return n.parentNode !== null && n.parentNode !== undefined; });
+        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;
+        parent.childNodes = sortContext.nodeList;
         for (var i = 0; i < sortContext.contextSize(); ++i) {
-            this.xsltChildNodes(sortContext.clone(sortContext.nodelist, i), template, output, _parameters);
+            this.xsltChildNodes(sortContext.clone(sortContext.nodeList, undefined, i), template, output);
         }
         // TODO: group nodes by parent node.
         // const nodeGroups = this.groupBy(nodes, 'parentNode');
@@ -417,7 +449,7 @@ var Xslt = /** @class */ (function () {
             this.xsltSort(sortContext, template);
 
             for (let i = 0; i < sortContext.contextSize(); ++i) {
-                this.xsltChildNodes(sortContext.clone(sortContext.nodelist, i), template, output);
+                this.xsltChildNodes(sortContext.clone(sortContext.nodeList, i), template, output);
             }
         } */
     };
@@ -435,12 +467,12 @@ var Xslt = /** @class */ (function () {
      * @param template The XSL-T definition.
      * @param output The XML output.
      */
-    Xslt.prototype.xsltChildNodes = function (context, template, output, _parameters) {
+    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, _parameters);
+            this.xsltProcessContext(contextClone, template.childNodes[i], output);
         }
     };
     /**
@@ -451,52 +483,65 @@ var Xslt = /** @class */ (function () {
      * @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, _parameters) {
+    Xslt.prototype.xsltPassThrough = function (context, template, output) {
         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; });
+                var textNodeList = context.outputNodeList[context.outputPosition].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.domCreateTransformedTextNode)(outputDocument, template.nodeValue);
-                    (0, dom_1.domAppendTransformedChild)(context.nodelist[context.position], node);
+                    var node = (0, dom_1.domCreateTransformedTextNode)(this.outputDocument, template.nodeValue);
+                    node.transformedParentNode = context.outputNodeList[context.outputPosition];
+                    (0, dom_1.domAppendTransformedChild)(context.outputNodeList[context.outputPosition], node);
                 }
             }
         }
         else if (template.nodeType == constants_1.DOM_ELEMENT_NODE) {
             var node = void 0;
+            // let node = domCreateElement(outputDocument, template.nodeName);
             var elementContext = context;
-            if (context.nodelist[context.position].nodeName === '#document') {
-                node = context.nodelist[context.position].firstChild;
-                elementContext = context.clone([node], 0);
+            if (context.nodeList[context.position].nodeName === '#document') {
+                node = context.nodeList[context.position].firstChild;
+                elementContext = context.clone([node]);
+            }
+            else {
+                node = context.nodeList[context.position];
+            }
+            var newNode = void 0;
+            if (node.outputNode === undefined || node.outputNode === null || context.outputDepth > 0) {
+                newNode = (0, dom_1.domCreateElement)(this.outputDocument, template.nodeName);
+                newNode.siblingPosition = node.siblingPosition;
+                node.outputNode = newNode;
             }
             else {
-                node = context.nodelist[context.position];
+                newNode = node.outputNode;
             }
-            node.transformedNodeName = template.nodeName;
-            node.transformedLocalName = template.localName;
+            newNode.transformedNodeName = template.nodeName;
+            newNode.transformedLocalName = template.localName;
             var templateAttributes = template.attributes.filter(function (a) { return a; });
             if (templateAttributes.length === 0) {
-                node.transformedAttributes = [];
+                newNode.transformedAttributes = [];
             }
             else {
                 for (var _i = 0, templateAttributes_1 = templateAttributes; _i < templateAttributes_1.length; _i++) {
                     var attribute = templateAttributes_1[_i];
                     var name_2 = attribute.nodeName;
                     var value = this.xsltAttributeValue(attribute.nodeValue, elementContext);
-                    (0, dom_1.domSetTransformedAttribute)(node, name_2, value);
+                    (0, dom_1.domSetTransformedAttribute)(newNode, name_2, value);
                 }
             }
-            this.xsltChildNodes(context, template, node, _parameters);
+            var outputNode = context.outputNodeList[context.outputPosition];
+            (0, dom_1.domAppendTransformedChild)(outputNode, newNode);
+            var clonedContext = elementContext.cloneByOutput(outputNode.transformedChildNodes, outputNode.transformedChildNodes.length - 1, ++elementContext.outputDepth);
+            this.xsltChildNodes(clonedContext, 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, _parameters);
+            this.xsltChildNodes(context, template, output);
         }
     };
     /**
@@ -541,7 +586,7 @@ var Xslt = /** @class */ (function () {
      */
     Xslt.prototype.xsltAttributeValue = function (value, context) {
         var parts = value.split('{');
-        if (parts.length == 1) {
+        if (parts.length === 1) {
             return value;
         }
         var ret = '';
@@ -590,39 +635,79 @@ var Xslt = /** @class */ (function () {
      * match.
      * @see [XSLT] section 5.2, paragraph 1
      * @param match TODO
-     * @param context TODO
-     * @returns TODO
+     * @param context The Expression Context.
+     * @param axis The XPath axis. Used when the match does not start with the parent.
+     * @returns {XNode[]} A list of the found nodes.
      */
-    Xslt.prototype.xsltMatch = function (match, context) {
-        var expr = this.xPath.xPathParse(match);
-        if (expr instanceof expressions_1.LocationExpr) {
-            return this.xsltLocationExpressionMatch(match, expr, context);
+    Xslt.prototype.xsltMatch = function (match, context, axis) {
+        var expression = this.xPath.xPathParse(match, axis);
+        if (expression instanceof expressions_1.LocationExpr) {
+            return this.xsltLocationExpressionMatch(expression, context);
+        }
+        if (expression instanceof expressions_1.UnionExpr) {
+            // TODO: What about if `expr1` and `expr2` are not `LocationExpr`?
+            return this.xsltLocationExpressionMatch(expression.expr1, context) ||
+                this.xsltLocationExpressionMatch(expression.expr2, context);
         }
         // TODO: Other expressions
-        return true;
+        return [];
     };
-    Xslt.prototype.xsltLocationExpressionMatch = function (match, expression, context) {
+    Xslt.prototype.xsltLocationExpressionMatch = function (expression, context) {
         if (expression === undefined || expression.steps === undefined || expression.steps.length <= 0) {
             throw new Error('Error resolving XSLT match: Location Expression should have steps.');
         }
-        var firstStep = expression.steps[0];
-        // Shortcut for the most common case.
-        if (expression.steps &&
-            !expression.absolute &&
-            expression.steps.length == 1 &&
-            firstStep.axis == 'child' &&
-            firstStep.predicate.length === 0) {
-            return firstStep.nodetest.evaluate(context).booleanValue();
-        }
-        if (expression.absolute && firstStep.axis !== 'self') {
-            // TODO: `xPathCollectDescendants()`?
-            var levels = match.split('/');
-            if (levels.length > 1) {
-                return this.absoluteXsltMatch(levels, expression, context);
-            }
+        if (expression.absolute) {
+            return this.absoluteXsltMatch(expression, context);
         }
         return this.relativeXsltMatch(expression, context);
     };
+    /**
+     * Finds all the nodes through absolute xPath search.
+     * Returns only nodes that match either the context position node,
+     * or an ancestor.
+     * @param expression The Expression.
+     * @param context The Expression Context.
+     * @returns The list of found nodes.
+     */
+    Xslt.prototype.absoluteXsltMatch = function (expression, context) {
+        var clonedContext = context.clone([context.root], undefined, 0, undefined);
+        var matchedNodes = expression.evaluate(clonedContext).nodeSetValue();
+        var finalList = [];
+        for (var _i = 0, matchedNodes_1 = matchedNodes; _i < matchedNodes_1.length; _i++) {
+            var element = matchedNodes_1[_i];
+            if (element.id === context.nodeList[context.position].id) {
+                finalList.push(element);
+                continue;
+            }
+            if (element.getAncestorById(context.nodeList[context.position].id) !== undefined) {
+                finalList.push(element);
+            }
+        }
+        return finalList;
+    };
+    /**
+     * Tries to find relative nodes from the actual context position.
+     * If found nodes are already in the context, or if they are children of
+     * nodes in the context, they are returned.
+     * @param expression The expression used.
+     * @param context The Expression Context.
+     * @returns The list of found nodes.
+     */
+    Xslt.prototype.relativeXsltMatch = function (expression, context) {
+        // For some reason, XPath understands a default as 'child axis'.
+        // There's no "self + siblings" axis, so what is expected at this point
+        // is to have in the expression context the parent that should
+        // have the nodes we are interested in.
+        var clonedContext = context.clone();
+        var nodes = expression.evaluate(clonedContext).nodeSetValue();
+        if (nodes.length === 1 && nodes[0].nodeName === "#document") {
+            // As we don't work with the #document node directly, this part
+            // returns its first sibling.
+            // By the way, it should be *always* one sibling here.
+            return [nodes[0].childNodes[0]];
+        }
+        return nodes;
+    };
     /**
      * Sets parameters defined by xsl:with-param child nodes of the
      * current template node, in the current input context. This happens
@@ -631,44 +716,20 @@ var Xslt = /** @class */ (function () {
      * @param input TODO
      * @param template TODO
      */
-    Xslt.prototype.xsltWithParam = function (input, template, _parameters) {
+    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, _parameters);
+                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';
+        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;