xslt-processor 3.0.2 → 3.2.0

package/xslt/xslt.js

@@ -4,9 +4,6 @@
 // Copyright 2005 Google Inc.
 // All Rights Reserved
 //
-// TODO(mesch): add jsdoc comments. Use more coherent naming. Finish
-// remaining XSLT features.
-//
 // Original author: Steffen Meschkat <mesch@google.com>
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -88,7 +85,7 @@ var match_resolver_1 = require("../xpath/match-resolver");
  * <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
+ * `xsltProcess()`. 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.
  *
@@ -130,6 +127,7 @@ var Xslt = /** @class */ (function () {
             digit: '#',
             patternSeparator: ';'
         };
+        this.firstTemplateRan = false;
     }
     /**
      * The exported entry point of the XSL-T processor.
@@ -174,7 +172,7 @@ var Xslt = /** @class */ (function () {
      */
     Xslt.prototype.xsltProcessContext = function (context, template, output) {
         return __awaiter(this, void 0, void 0, function () {
-            var name_1, top_1, nameExpr, node, select, value, nodes, paramContext, commentData, commentNode, test_1, match, text, _a, i, childNode, destinationCopyNode, destinationNode, i, node_1, decimalSeparator, groupingSeparator, infinity, minusSign, naN, percent, perMille, zeroDigit, digit, patternSeparator, clonedContext, templateContext, disableOutputEscaping, destinationTextNode, attribute;
+            var node, select, value, nodes, _a, destinationCopyNode, destinationNode, i, node_1;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -182,9 +180,9 @@ var Xslt = /** @class */ (function () {
                         return [4 /*yield*/, this.xsltPassThrough(context, template, output)];
                     case 1:
                         _b.sent();
-                        return [3 /*break*/, 59];
+                        return [3 /*break*/, 54];
                     case 2:
-                        nameExpr = void 0, node = void 0, select = void 0, value = void 0, nodes = void 0, paramContext = void 0, commentData = void 0, commentNode = void 0, match = void 0, text = void 0;
+                        node = void 0, select = void 0, value = void 0, nodes = void 0;
                         _a = template.localName;
                         switch (_a) {
                             case 'apply-imports': return [3 /*break*/, 3];
@@ -192,94 +190,70 @@ var Xslt = /** @class */ (function () {
                             case 'attribute': return [3 /*break*/, 6];
                             case 'attribute-set': return [3 /*break*/, 8];
                             case 'call-template': return [3 /*break*/, 9];
-                            case 'choose': return [3 /*break*/, 15];
-                            case 'comment': return [3 /*break*/, 17];
-                            case 'copy': return [3 /*break*/, 19];
-                            case 'copy-of': return [3 /*break*/, 22];
-                            case 'decimal-format': return [3 /*break*/, 23];
-                            case 'element': return [3 /*break*/, 24];
-                            case 'fallback': return [3 /*break*/, 26];
-                            case 'for-each': return [3 /*break*/, 27];
-                            case 'if': return [3 /*break*/, 29];
-                            case 'import': return [3 /*break*/, 32];
-                            case 'include': return [3 /*break*/, 33];
-                            case 'key': return [3 /*break*/, 35];
-                            case 'message': return [3 /*break*/, 36];
-                            case 'namespace-alias': return [3 /*break*/, 37];
-                            case 'number': return [3 /*break*/, 38];
-                            case 'otherwise': return [3 /*break*/, 39];
-                            case 'output': return [3 /*break*/, 40];
-                            case 'param': return [3 /*break*/, 41];
-                            case 'preserve-space': return [3 /*break*/, 43];
-                            case 'processing-instruction': return [3 /*break*/, 44];
-                            case 'sort': return [3 /*break*/, 45];
-                            case 'strip-space': return [3 /*break*/, 46];
-                            case 'stylesheet': return [3 /*break*/, 47];
-                            case 'transform': return [3 /*break*/, 47];
-                            case 'template': return [3 /*break*/, 49];
-                            case 'text': return [3 /*break*/, 52];
-                            case 'value-of': return [3 /*break*/, 53];
-                            case 'variable': return [3 /*break*/, 54];
-                            case 'when': return [3 /*break*/, 56];
-                            case 'with-param': return [3 /*break*/, 57];
+                            case 'choose': return [3 /*break*/, 11];
+                            case 'comment': return [3 /*break*/, 13];
+                            case 'copy': return [3 /*break*/, 15];
+                            case 'copy-of': return [3 /*break*/, 18];
+                            case 'decimal-format': return [3 /*break*/, 19];
+                            case 'element': return [3 /*break*/, 20];
+                            case 'fallback': return [3 /*break*/, 22];
+                            case 'for-each': return [3 /*break*/, 23];
+                            case 'if': return [3 /*break*/, 25];
+                            case 'import': return [3 /*break*/, 27];
+                            case 'include': return [3 /*break*/, 29];
+                            case 'key': return [3 /*break*/, 31];
+                            case 'message': return [3 /*break*/, 32];
+                            case 'namespace-alias': return [3 /*break*/, 33];
+                            case 'number': return [3 /*break*/, 34];
+                            case 'otherwise': return [3 /*break*/, 35];
+                            case 'output': return [3 /*break*/, 36];
+                            case 'param': return [3 /*break*/, 37];
+                            case 'preserve-space': return [3 /*break*/, 39];
+                            case 'processing-instruction': return [3 /*break*/, 40];
+                            case 'sort': return [3 /*break*/, 41];
+                            case 'strip-space': return [3 /*break*/, 42];
+                            case 'stylesheet': return [3 /*break*/, 43];
+                            case 'transform': return [3 /*break*/, 43];
+                            case 'template': return [3 /*break*/, 45];
+                            case 'text': return [3 /*break*/, 47];
+                            case 'value-of': return [3 /*break*/, 48];
+                            case 'variable': return [3 /*break*/, 49];
+                            case 'when': return [3 /*break*/, 51];
+                            case 'with-param': return [3 /*break*/, 52];
                         }
-                        return [3 /*break*/, 58];
+                        return [3 /*break*/, 53];
                     case 3: throw new Error("not implemented: ".concat(template.localName));
                     case 4: return [4 /*yield*/, this.xsltApplyTemplates(context, template, output)];
                     case 5:
                         _b.sent();
-                        return [3 /*break*/, 59];
+                        return [3 /*break*/, 54];
                     case 6: return [4 /*yield*/, this.xsltAttribute(context, template, output)];
                     case 7:
                         _b.sent();
-                        return [3 /*break*/, 59];
+                        return [3 /*break*/, 54];
                     case 8: throw new Error("not implemented: ".concat(template.localName));
-                    case 9:
-                        name_1 = (0, dom_1.xmlGetAttribute)(template, 'name');
-                        top_1 = template.ownerDocument.documentElement;
-                        paramContext = context.clone();
-                        return [4 /*yield*/, this.xsltWithParam(paramContext, template)];
+                    case 9: return [4 /*yield*/, this.xsltCallTemplate(context, template, output)];
                     case 10:
                         _b.sent();
-                        i = 0;
-                        _b.label = 11;
-                    case 11:
-                        if (!(i < top_1.childNodes.length)) return [3 /*break*/, 14];
-                        childNode = top_1.childNodes[i];
-                        if (!(childNode.nodeType === constants_1.DOM_ELEMENT_NODE &&
-                            this.isXsltElement(childNode, 'template') &&
-                            (0, dom_1.domGetAttributeValue)(childNode, 'name') == name_1)) return [3 /*break*/, 13];
-                        return [4 /*yield*/, this.xsltChildNodes(paramContext, childNode, output)];
+                        return [3 /*break*/, 54];
+                    case 11: return [4 /*yield*/, this.xsltChoose(context, template, output)];
                     case 12:
                         _b.sent();
-                        return [3 /*break*/, 14];
-                    case 13:
-                        ++i;
-                        return [3 /*break*/, 11];
-                    case 14: return [3 /*break*/, 59];
-                    case 15: return [4 /*yield*/, this.xsltChoose(context, template, output)];
-                    case 16:
+                        return [3 /*break*/, 54];
+                    case 13: return [4 /*yield*/, this.xsltComment(context, template, output)];
+                    case 14:
                         _b.sent();
-                        return [3 /*break*/, 59];
-                    case 17:
-                        node = (0, dom_1.domCreateDocumentFragment)(this.outputDocument);
-                        return [4 /*yield*/, this.xsltChildNodes(context, template, node)];
-                    case 18:
-                        _b.sent();
-                        commentData = (0, dom_1.xmlValue)(node);
-                        commentNode = (0, dom_1.domCreateComment)(this.outputDocument, commentData);
-                        output.appendChild(commentNode);
-                        return [3 /*break*/, 59];
-                    case 19:
+                        return [3 /*break*/, 54];
+                    case 15:
                         destinationCopyNode = output || context.outputNodeList[context.outputPosition];
                         node = this.xsltCopy(destinationCopyNode, context.nodeList[context.position]);
-                        if (!node) return [3 /*break*/, 21];
+                        if (!node) return [3 /*break*/, 17];
                         return [4 /*yield*/, this.xsltChildNodes(context, template, node)];
-                    case 20:
+                    case 16:
                         _b.sent();
-                        _b.label = 21;
-                    case 21: return [3 /*break*/, 59];
-                    case 22:
+                        _b.label = 17;
+                    case 17: return [3 /*break*/, 54];
+                    case 18:
                         select = (0, dom_1.xmlGetAttribute)(template, 'select');
                         value = this.xPath.xPathEval(select, context);
                         destinationNode = context.outputNodeList[context.outputPosition] || output;
@@ -293,142 +267,74 @@ var Xslt = /** @class */ (function () {
                             node_1 = (0, dom_1.domCreateTextNode)(this.outputDocument, value.stringValue());
                             (0, dom_1.domAppendChild)(destinationNode, node_1);
                         }
-                        return [3 /*break*/, 59];
-                    case 23:
-                        name_1 = (0, dom_1.xmlGetAttribute)(template, 'name');
-                        decimalSeparator = (0, dom_1.xmlGetAttribute)(template, 'decimal-separator');
-                        groupingSeparator = (0, dom_1.xmlGetAttribute)(template, 'grouping-separator');
-                        infinity = (0, dom_1.xmlGetAttribute)(template, 'infinity');
-                        minusSign = (0, dom_1.xmlGetAttribute)(template, 'minus-sign');
-                        naN = (0, dom_1.xmlGetAttribute)(template, 'NaN');
-                        percent = (0, dom_1.xmlGetAttribute)(template, 'percent');
-                        perMille = (0, dom_1.xmlGetAttribute)(template, 'per-mille');
-                        zeroDigit = (0, dom_1.xmlGetAttribute)(template, 'zero-digit');
-                        digit = (0, dom_1.xmlGetAttribute)(template, 'digit');
-                        patternSeparator = (0, dom_1.xmlGetAttribute)(template, 'pattern-separator');
-                        this.decimalFormatSettings = {
-                            name: name_1 || this.decimalFormatSettings.name,
-                            decimalSeparator: decimalSeparator || this.decimalFormatSettings.decimalSeparator,
-                            groupingSeparator: groupingSeparator || this.decimalFormatSettings.groupingSeparator,
-                            infinity: infinity || this.decimalFormatSettings.infinity,
-                            minusSign: minusSign || this.decimalFormatSettings.minusSign,
-                            naN: naN || this.decimalFormatSettings.naN,
-                            percent: percent || this.decimalFormatSettings.percent,
-                            perMille: perMille || this.decimalFormatSettings.perMille,
-                            zeroDigit: zeroDigit || this.decimalFormatSettings.zeroDigit,
-                            digit: digit || this.decimalFormatSettings.digit,
-                            patternSeparator: patternSeparator || this.decimalFormatSettings.patternSeparator
-                        };
-                        context.decimalFormatSettings = this.decimalFormatSettings;
-                        return [3 /*break*/, 59];
+                        return [3 /*break*/, 54];
+                    case 19:
+                        this.xsltDecimalFormat(context, template);
+                        return [3 /*break*/, 54];
+                    case 20: return [4 /*yield*/, this.xsltElement(context, template)];
+                    case 21:
+                        _b.sent();
+                        return [3 /*break*/, 54];
+                    case 22: throw new Error("not implemented: ".concat(template.localName));
+                    case 23: return [4 /*yield*/, this.xsltForEach(context, template, output)];
                     case 24:
-                        nameExpr = (0, dom_1.xmlGetAttribute)(template, 'name');
-                        name_1 = this.xsltAttributeValue(nameExpr, context);
-                        node = (0, dom_1.domCreateElement)(this.outputDocument, name_1);
-                        node.transformedNodeName = name_1;
-                        (0, dom_1.domAppendTransformedChild)(context.outputNodeList[context.outputPosition], node);
-                        // The element becomes the output node of the source node.
-                        context.nodeList[context.position].outputNode = node;
-                        clonedContext = context.clone(undefined, [node], undefined, 0);
-                        return [4 /*yield*/, this.xsltChildNodes(clonedContext, template)];
-                    case 25:
                         _b.sent();
-                        return [3 /*break*/, 59];
-                    case 26: throw new Error("not implemented: ".concat(template.localName));
-                    case 27: return [4 /*yield*/, this.xsltForEach(context, template, output)];
+                        return [3 /*break*/, 54];
+                    case 25: return [4 /*yield*/, this.xsltIf(context, template, output)];
+                    case 26:
+                        _b.sent();
+                        return [3 /*break*/, 54];
+                    case 27: return [4 /*yield*/, this.xsltImport(context, template, output)];
                     case 28:
                         _b.sent();
-                        return [3 /*break*/, 59];
-                    case 29:
-                        test_1 = (0, dom_1.xmlGetAttribute)(template, 'test');
-                        if (!this.xPath.xPathEval(test_1, context).booleanValue()) return [3 /*break*/, 31];
-                        return [4 /*yield*/, this.xsltChildNodes(context, template, output)];
+                        return [3 /*break*/, 54];
+                    case 29: return [4 /*yield*/, this.xsltInclude(context, template, output)];
                     case 30:
                         _b.sent();
-                        _b.label = 31;
-                    case 31: return [3 /*break*/, 59];
+                        return [3 /*break*/, 54];
+                    case 31:
+                        this.xsltKey(context, template);
+                        return [3 /*break*/, 54];
                     case 32: throw new Error("not implemented: ".concat(template.localName));
-                    case 33: return [4 /*yield*/, this.xsltInclude(context, template, output)];
-                    case 34:
-                        _b.sent();
-                        return [3 /*break*/, 59];
-                    case 35: throw new Error("not implemented: ".concat(template.localName));
-                    case 36: throw new Error("not implemented: ".concat(template.localName));
-                    case 37: throw new Error("not implemented: ".concat(template.localName));
-                    case 38: throw new Error("not implemented: ".concat(template.localName));
-                    case 39: throw "error if here: ".concat(template.localName);
-                    case 40:
+                    case 33: throw new Error("not implemented: ".concat(template.localName));
+                    case 34: throw new Error("not implemented: ".concat(template.localName));
+                    case 35: throw new Error("xsl:otherwise can't be used outside of xsl:choose.");
+                    case 36:
                         this.outputMethod = (0, dom_1.xmlGetAttribute)(template, 'method');
                         this.outputOmitXmlDeclaration = (0, dom_1.xmlGetAttribute)(template, 'omit-xml-declaration');
-                        return [3 /*break*/, 59];
-                    case 41: return [4 /*yield*/, this.xsltVariable(context, template, false)];
-                    case 42:
+                        return [3 /*break*/, 54];
+                    case 37: return [4 /*yield*/, this.xsltVariable(context, template, false)];
+                    case 38:
                         _b.sent();
-                        return [3 /*break*/, 59];
-                    case 43: throw new Error("not implemented: ".concat(template.localName));
-                    case 44: throw new Error("not implemented: ".concat(template.localName));
-                    case 45:
+                        return [3 /*break*/, 54];
+                    case 39: throw new Error("not implemented: ".concat(template.localName));
+                    case 40: throw new Error("not implemented: ".concat(template.localName));
+                    case 41:
                         this.xsltSort(context, template);
-                        return [3 /*break*/, 59];
-                    case 46: throw new Error("not implemented: ".concat(template.localName));
-                    case 47: return [4 /*yield*/, this.xsltTransformOrStylesheet(template, context, output)];
-                    case 48:
+                        return [3 /*break*/, 54];
+                    case 42: throw new Error("not implemented: ".concat(template.localName));
+                    case 43: return [4 /*yield*/, this.xsltTransformOrStylesheet(context, template, output)];
+                    case 44:
                         _b.sent();
-                        return [3 /*break*/, 59];
-                    case 49:
-                        // 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) {
-                            return [3 /*break*/, 59];
-                        }
-                        match = (0, dom_1.xmlGetAttribute)(template, 'match');
-                        if (!match)
-                            return [3 /*break*/, 59];
-                        // 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, 'self-and-siblings');
-                        if (!(nodes.length > 0)) return [3 /*break*/, 51];
-                        if (!context.inApplyTemplates) {
-                            context.baseTemplateMatched = true;
-                        }
-                        templateContext = context.clone(nodes, undefined, 0);
-                        return [4 /*yield*/, this.xsltChildNodes(templateContext, template, output)];
-                    case 50:
+                        return [3 /*break*/, 54];
+                    case 45: return [4 /*yield*/, this.xsltTemplate(context, template, output)];
+                    case 46:
                         _b.sent();
-                        _b.label = 51;
-                    case 51: return [3 /*break*/, 59];
-                    case 52:
-                        text = (0, dom_1.xmlValue)(template);
-                        node = (0, dom_1.domCreateTransformedTextNode)(this.outputDocument, text);
-                        disableOutputEscaping = template.childNodes.filter(function (a) { return a.nodeType === constants_1.DOM_ATTRIBUTE_NODE && a.nodeName === 'disable-output-escaping'; });
-                        if (disableOutputEscaping.length > 0 && disableOutputEscaping[0].nodeValue === 'yes') {
-                            node.escape = false;
-                        }
-                        destinationTextNode = output || context.outputNodeList[context.outputPosition];
-                        destinationTextNode.appendTransformedChild(node);
-                        return [3 /*break*/, 59];
-                    case 53:
-                        select = (0, dom_1.xmlGetAttribute)(template, 'select');
-                        attribute = this.xPath.xPathEval(select, context);
-                        value = attribute.stringValue();
-                        node = (0, dom_1.domCreateTransformedTextNode)(this.outputDocument, value);
-                        node.siblingPosition = context.nodeList[context.position].siblingPosition;
-                        if (output && output.nodeType === constants_1.DOM_DOCUMENT_FRAGMENT_NODE) {
-                            output.appendTransformedChild(node);
-                        }
-                        else {
-                            context.outputNodeList[context.outputPosition].appendTransformedChild(node);
-                        }
-                        return [3 /*break*/, 59];
-                    case 54: return [4 /*yield*/, this.xsltVariable(context, template, true)];
-                    case 55:
+                        return [3 /*break*/, 54];
+                    case 47:
+                        this.xsltText(context, template, output);
+                        return [3 /*break*/, 54];
+                    case 48:
+                        this.xsltValueOf(context, template, output);
+                        return [3 /*break*/, 54];
+                    case 49: return [4 /*yield*/, this.xsltVariable(context, template, true)];
+                    case 50:
                         _b.sent();
-                        return [3 /*break*/, 59];
-                    case 56: throw new Error("error if here: ".concat(template.localName));
-                    case 57: throw new Error("error if here: ".concat(template.localName));
-                    case 58: throw new Error("error if here: ".concat(template.localName));
-                    case 59: return [2 /*return*/];
+                        return [3 /*break*/, 54];
+                    case 51: throw new Error("xsl:when can't be used outside of xsl:choose.");
+                    case 52: throw new Error("error if here: ".concat(template.localName));
+                    case 53: throw new Error("error if here: ".concat(template.localName));
+                    case 54: return [2 /*return*/];
                 }
             });
         });
@@ -581,6 +487,44 @@ var Xslt = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Implements `xsl:call-template`.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output, used when a fragment is passed by a previous step.
+     */
+    Xslt.prototype.xsltCallTemplate = function (context, template, output) {
+        return __awaiter(this, void 0, void 0, function () {
+            var name, top, paramContext, i, childNode;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        name = (0, dom_1.xmlGetAttribute)(template, 'name');
+                        top = template.ownerDocument.documentElement;
+                        paramContext = context.clone();
+                        return [4 /*yield*/, this.xsltWithParam(paramContext, template)];
+                    case 1:
+                        _a.sent();
+                        i = 0;
+                        _a.label = 2;
+                    case 2:
+                        if (!(i < top.childNodes.length)) return [3 /*break*/, 5];
+                        childNode = top.childNodes[i];
+                        if (!(childNode.nodeType === constants_1.DOM_ELEMENT_NODE &&
+                            this.isXsltElement(childNode, 'template') &&
+                            (0, dom_1.domGetAttributeValue)(childNode, 'name') === name)) return [3 /*break*/, 4];
+                        return [4 /*yield*/, this.xsltChildNodes(paramContext, childNode, output)];
+                    case 3:
+                        _a.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        ++i;
+                        return [3 /*break*/, 2];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Implements `xsl:choose`, its child nodes `xsl:when`, and
      * `xsl:otherwise`.
@@ -590,7 +534,7 @@ var Xslt = /** @class */ (function () {
      */
     Xslt.prototype.xsltChoose = function (context, template, output) {
         return __awaiter(this, void 0, void 0, function () {
-            var _i, _a, childNode, test_2;
+            var _i, _a, childNode, test_1;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
@@ -603,8 +547,8 @@ var Xslt = /** @class */ (function () {
                             return [3 /*break*/, 6];
                         }
                         if (!this.isXsltElement(childNode, 'when')) return [3 /*break*/, 4];
-                        test_2 = (0, dom_1.xmlGetAttribute)(childNode, 'test');
-                        if (!this.xPath.xPathEval(test_2, context).booleanValue()) return [3 /*break*/, 3];
+                        test_1 = (0, dom_1.xmlGetAttribute)(childNode, 'test');
+                        if (!this.xPath.xPathEval(test_1, context).booleanValue()) return [3 /*break*/, 3];
                         return [4 /*yield*/, this.xsltChildNodes(context, childNode, output)];
                     case 2:
                         _b.sent();
@@ -657,6 +601,31 @@ var Xslt = /** @class */ (function () {
         }
         return null;
     };
+    /**
+     * Implements `xsl:comment`.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output. Only used if there's no corresponding output node already defined.
+     */
+    Xslt.prototype.xsltComment = function (context, template, output) {
+        return __awaiter(this, void 0, void 0, function () {
+            var node, commentData, commentNode, resolvedOutput;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        node = (0, dom_1.domCreateDocumentFragment)(this.outputDocument);
+                        return [4 /*yield*/, this.xsltChildNodes(context, template, node)];
+                    case 1:
+                        _a.sent();
+                        commentData = (0, dom_1.xmlValue)(node);
+                        commentNode = (0, dom_1.domCreateComment)(this.outputDocument, commentData);
+                        resolvedOutput = output || context.outputNodeList[context.outputPosition];
+                        resolvedOutput.appendChild(commentNode);
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Implements `xsl:copy-of` for node-set values of the select
      * expression. Recurses down the source node tree, which is part of
@@ -679,6 +648,66 @@ var Xslt = /** @class */ (function () {
             }
         }
     };
+    /**
+     * Implements `xsl:decimal-format`, registering the settings in this instance
+     * and the current context.
+     * @param context The Expression Context.
+     * @param template The template.
+     */
+    Xslt.prototype.xsltDecimalFormat = function (context, template) {
+        var name = (0, dom_1.xmlGetAttribute)(template, 'name');
+        var decimalSeparator = (0, dom_1.xmlGetAttribute)(template, 'decimal-separator');
+        var groupingSeparator = (0, dom_1.xmlGetAttribute)(template, 'grouping-separator');
+        var infinity = (0, dom_1.xmlGetAttribute)(template, 'infinity');
+        var minusSign = (0, dom_1.xmlGetAttribute)(template, 'minus-sign');
+        var naN = (0, dom_1.xmlGetAttribute)(template, 'NaN');
+        var percent = (0, dom_1.xmlGetAttribute)(template, 'percent');
+        var perMille = (0, dom_1.xmlGetAttribute)(template, 'per-mille');
+        var zeroDigit = (0, dom_1.xmlGetAttribute)(template, 'zero-digit');
+        var digit = (0, dom_1.xmlGetAttribute)(template, 'digit');
+        var patternSeparator = (0, dom_1.xmlGetAttribute)(template, 'pattern-separator');
+        this.decimalFormatSettings = {
+            name: name || this.decimalFormatSettings.name,
+            decimalSeparator: decimalSeparator || this.decimalFormatSettings.decimalSeparator,
+            groupingSeparator: groupingSeparator || this.decimalFormatSettings.groupingSeparator,
+            infinity: infinity || this.decimalFormatSettings.infinity,
+            minusSign: minusSign || this.decimalFormatSettings.minusSign,
+            naN: naN || this.decimalFormatSettings.naN,
+            percent: percent || this.decimalFormatSettings.percent,
+            perMille: perMille || this.decimalFormatSettings.perMille,
+            zeroDigit: zeroDigit || this.decimalFormatSettings.zeroDigit,
+            digit: digit || this.decimalFormatSettings.digit,
+            patternSeparator: patternSeparator || this.decimalFormatSettings.patternSeparator
+        };
+        context.decimalFormatSettings = this.decimalFormatSettings;
+    };
+    /**
+     * Implements `xsl:element`.
+     * @param context The Expression Context.
+     * @param template The template.
+     */
+    Xslt.prototype.xsltElement = function (context, template) {
+        return __awaiter(this, void 0, void 0, function () {
+            var nameExpr, name, node, clonedContext;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        nameExpr = (0, dom_1.xmlGetAttribute)(template, 'name');
+                        name = this.xsltAttributeValue(nameExpr, context);
+                        node = (0, dom_1.domCreateElement)(this.outputDocument, name);
+                        node.transformedNodeName = name;
+                        (0, dom_1.domAppendTransformedChild)(context.outputNodeList[context.outputPosition], node);
+                        // The element becomes the output node of the source node.
+                        context.nodeList[context.position].outputNode = node;
+                        clonedContext = context.clone(undefined, [node], undefined, 0);
+                        return [4 /*yield*/, this.xsltChildNodes(clonedContext, template)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Implements `xsl:for-each`.
      * @param context The Expression Context.
@@ -718,6 +747,74 @@ var Xslt = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Implements `xsl:if`.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output.
+     */
+    Xslt.prototype.xsltIf = function (context, template, output) {
+        return __awaiter(this, void 0, void 0, function () {
+            var test;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        test = (0, dom_1.xmlGetAttribute)(template, 'test');
+                        if (!this.xPath.xPathEval(test, context).booleanValue()) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.xsltChildNodes(context, template, output)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Implements `<xsl:import>`. For now the code is nearly identical to `<xsl:include>`, but there's
+     * no precedence evaluation implemented yet.
+     * @param context The Expression Context.
+     * @param template The template.
+     * @param output The output.
+     */
+    Xslt.prototype.xsltImport = function (context, template, output) {
+        return __awaiter(this, void 0, void 0, function () {
+            var hrefAttributeFind, hrefAttribute, fetchTest, fetchResponse, includedXslt;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.firstTemplateRan) {
+                            throw new Error('<xsl:import> should be the first child node of <xsl:stylesheet> or <xsl:transform>.');
+                        }
+                        // We need to test here whether `window.fetch` is available or not.
+                        // If it is a browser environemnt, it should be.
+                        // Otherwise, we will need to import an equivalent library, like 'node-fetch'.
+                        if (!global.globalThis.fetch) {
+                            global.globalThis.fetch = node_fetch_1.default;
+                            global.globalThis.Headers = node_fetch_1.Headers;
+                            global.globalThis.Request = node_fetch_1.Request;
+                            global.globalThis.Response = node_fetch_1.Response;
+                        }
+                        hrefAttributeFind = template.childNodes.filter(function (n) { return n.nodeName === 'href'; });
+                        if (hrefAttributeFind.length <= 0) {
+                            throw new Error('<xsl:import> with no href attribute defined.');
+                        }
+                        hrefAttribute = hrefAttributeFind[0];
+                        return [4 /*yield*/, global.globalThis.fetch(hrefAttribute.nodeValue)];
+                    case 1:
+                        fetchTest = _a.sent();
+                        return [4 /*yield*/, fetchTest.text()];
+                    case 2:
+                        fetchResponse = _a.sent();
+                        includedXslt = this.xmlParser.xmlParse(fetchResponse);
+                        return [4 /*yield*/, this.xsltChildNodes(context, includedXslt.childNodes[0], output)];
+                    case 3:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Implements `xsl:include`.
      * @param context The Expression Context.
@@ -759,6 +856,49 @@ var Xslt = /** @class */ (function () {
             });
         });
     };
+    /**
+     * Implements `xsl:key`.
+     * @param context The Expression Context.
+     * @param template The template.
+     */
+    Xslt.prototype.xsltKey = function (context, template) {
+        // `name`, `match`, and `use` are required.
+        var name = (0, dom_1.xmlGetAttribute)(template, 'name');
+        var match = (0, dom_1.xmlGetAttribute)(template, 'match');
+        var use = (0, dom_1.xmlGetAttribute)(template, 'use');
+        if (!name || !match || !use) {
+            var errorMessage = '<xsl:key> missing required parameters: ';
+            if (!name) {
+                errorMessage += 'name, ';
+            }
+            if (!match) {
+                errorMessage += 'match, ';
+            }
+            if (!use) {
+                errorMessage += 'use, ';
+            }
+            errorMessage = errorMessage.slice(0, -2);
+            throw new Error(errorMessage);
+        }
+        var keyContext;
+        if (context.nodeList[context.position].nodeName === '#document') {
+            keyContext = context.clone(context.nodeList[context.position].childNodes);
+        }
+        else {
+            keyContext = context;
+        }
+        var nodes = this.xsltMatch(match, keyContext);
+        if (!(name in context.keys)) {
+            context.keys[name] = {};
+        }
+        for (var _i = 0, nodes_1 = nodes; _i < nodes_1.length; _i++) {
+            var node = nodes_1[_i];
+            var nodeContext = context.clone([node]);
+            var attribute = this.xPath.xPathEval(use, nodeContext);
+            var attributeValue = attribute.stringValue();
+            context.keys[name][attributeValue] = new values_1.NodeSetValue([node]);
+        }
+    };
     /**
      * Orders the current node list in the input context according to the
      * sort order specified by xsl:sort child nodes of the current
@@ -786,14 +926,62 @@ var Xslt = /** @class */ (function () {
         }
         this.xPath.xPathSort(context, sort);
     };
+    /**
+     * Implements `xsl:template`.
+     * @param context The Expression Context.
+     * @param template The `<xsl:template>` node.
+     * @param output The output. In general, a fragment that will be used by
+     *               the caller.
+     */
+    Xslt.prototype.xsltTemplate = function (context, template, output) {
+        return __awaiter(this, void 0, void 0, function () {
+            var match, nodes, templateContext;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        // 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) {
+                            return [2 /*return*/];
+                        }
+                        match = (0, dom_1.xmlGetAttribute)(template, 'match');
+                        if (!match)
+                            return [2 /*return*/];
+                        nodes = this.xsltMatch(match, context, 'self-and-siblings');
+                        if (!(nodes.length > 0)) return [3 /*break*/, 2];
+                        this.firstTemplateRan = true;
+                        if (!context.inApplyTemplates) {
+                            context.baseTemplateMatched = true;
+                        }
+                        templateContext = context.clone(nodes, undefined, 0);
+                        return [4 /*yield*/, this.xsltChildNodes(templateContext, template, output)];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    Xslt.prototype.xsltText = function (context, template, output) {
+        var text = (0, dom_1.xmlValue)(template);
+        var node = (0, dom_1.domCreateTransformedTextNode)(this.outputDocument, text);
+        var disableOutputEscaping = template.childNodes.filter(function (a) { return a.nodeType === constants_1.DOM_ATTRIBUTE_NODE && a.nodeName === 'disable-output-escaping'; });
+        if (disableOutputEscaping.length > 0 && disableOutputEscaping[0].nodeValue === 'yes') {
+            node.escape = false;
+        }
+        var destinationTextNode = output || context.outputNodeList[context.outputPosition];
+        destinationTextNode.appendTransformedChild(node);
+    };
     /**
      * Implements `<xsl:stylesheet>` and `<xsl:transform>`, and its corresponding
      * validations.
-     * @param template The `<xsl:stylesheet>` or `<xsl:transform>` node.
      * @param context The Expression Context.
-     * @param output The output XML.
+     * @param template The `<xsl:stylesheet>` or `<xsl:transform>` node.
+     * @param output The output. In general, a fragment that will be used by
+     *               the caller.
      */
-    Xslt.prototype.xsltTransformOrStylesheet = function (template, context, output) {
+    Xslt.prototype.xsltTransformOrStylesheet = function (context, template, output) {
         return __awaiter(this, void 0, void 0, function () {
             var _i, _a, stylesheetAttribute;
             return __generator(this, function (_b) {
@@ -824,6 +1012,19 @@ var Xslt = /** @class */ (function () {
             });
         });
     };
+    Xslt.prototype.xsltValueOf = function (context, template, output) {
+        var select = (0, dom_1.xmlGetAttribute)(template, 'select');
+        var attribute = this.xPath.xPathEval(select, context);
+        var value = attribute.stringValue();
+        var node = (0, dom_1.domCreateTransformedTextNode)(this.outputDocument, value);
+        node.siblingPosition = context.nodeList[context.position].siblingPosition;
+        if (output && output.nodeType === constants_1.DOM_DOCUMENT_FRAGMENT_NODE) {
+            output.appendTransformedChild(node);
+        }
+        else {
+            context.outputNodeList[context.outputPosition].appendTransformedChild(node);
+        }
+    };
     /**
      * Evaluates a variable or parameter and set it in the current input
      * context. Implements `xsl:variable`, `xsl:param`, and `xsl:with-param`.
@@ -908,6 +1109,8 @@ var Xslt = /** @class */ (function () {
      * This logic is used in two different places:
      * - `xsltPassThrough`, if the template asks this library to write a text node;
      * - `xsltProcessContext`, `apply-templates` operation, when the current node is text.
+     *
+     * Text nodes always require a parent, and they never have children.
      * @param context The Expression Context.
      * @param template The template, that contains the node value to be written.
      * @param output The output.
@@ -918,15 +1121,17 @@ var Xslt = /** @class */ (function () {
             (0, dom_1.domAppendTransformedChild)(output, node);
         }
         else {
-            var textNodeList = context.outputNodeList[context.outputPosition].transformedChildNodes.filter(function (n) { return n.nodeType === constants_1.DOM_TEXT_NODE; });
+            var parentNode = context.outputNodeList[context.outputPosition];
+            var textNodeList = parentNode.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)(this.outputDocument, template.nodeValue);
-                node.transformedParentNode = context.outputNodeList[context.outputPosition];
-                (0, dom_1.domAppendTransformedChild)(context.outputNodeList[context.outputPosition], node);
+                node.transformedParentNode = parentNode;
+                // context.nodeList[context.position].outputNode = node;
+                (0, dom_1.domAppendTransformedChild)(parentNode, node);
             }
         }
     };
@@ -941,7 +1146,7 @@ var Xslt = /** @class */ (function () {
      */
     Xslt.prototype.xsltPassThrough = function (context, template, output) {
         return __awaiter(this, void 0, void 0, function () {
-            var node, elementContext, newNode, transformedChildNodes, _i, transformedChildNodes_1, previouslyTransformedAttribute, name_2, value, transformedAttributes, _a, transformedAttributes_1, previouslyTransformedAttribute, name_3, value, templateAttributes, _b, templateAttributes_1, attribute, name_4, value, outputNode, clonedContext;
+            var node, elementContext, newNode, outputNode, clonedContext, transformedChildNodes, _i, transformedChildNodes_1, previouslyTransformedAttribute, name_1, value, transformedAttributes, _a, transformedAttributes_1, previouslyTransformedAttribute, name_2, value, templateAttributes, _b, templateAttributes_1, attribute, name_3, value;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
@@ -974,33 +1179,33 @@ var Xslt = /** @class */ (function () {
                         }
                         newNode.transformedNodeName = template.nodeName;
                         newNode.transformedLocalName = template.localName;
+                        outputNode = context.outputNodeList[context.outputPosition];
+                        (0, dom_1.domAppendTransformedChild)(outputNode, newNode);
+                        clonedContext = elementContext.cloneByOutput(outputNode.transformedChildNodes, outputNode.transformedChildNodes.length - 1, ++elementContext.outputDepth);
+                        return [4 /*yield*/, this.xsltChildNodes(clonedContext, template)];
+                    case 2:
+                        _c.sent();
                         transformedChildNodes = node.transformedChildNodes.filter(function (n) { return n.nodeType === constants_1.DOM_ATTRIBUTE_NODE; });
                         for (_i = 0, transformedChildNodes_1 = transformedChildNodes; _i < transformedChildNodes_1.length; _i++) {
                             previouslyTransformedAttribute = transformedChildNodes_1[_i];
-                            name_2 = previouslyTransformedAttribute.transformedNodeName;
+                            name_1 = previouslyTransformedAttribute.transformedNodeName;
                             value = previouslyTransformedAttribute.transformedNodeValue;
-                            (0, dom_1.domSetTransformedAttribute)(newNode, name_2, value);
+                            (0, dom_1.domSetTransformedAttribute)(newNode, name_1, value);
                         }
                         transformedAttributes = node.childNodes.filter(function (n) { return n.nodeType === constants_1.DOM_ATTRIBUTE_NODE && n.transformedNodeName; });
                         for (_a = 0, transformedAttributes_1 = transformedAttributes; _a < transformedAttributes_1.length; _a++) {
                             previouslyTransformedAttribute = transformedAttributes_1[_a];
-                            name_3 = previouslyTransformedAttribute.transformedNodeName;
+                            name_2 = previouslyTransformedAttribute.transformedNodeName;
                             value = previouslyTransformedAttribute.transformedNodeValue;
-                            (0, dom_1.domSetTransformedAttribute)(newNode, name_3, value);
+                            (0, dom_1.domSetTransformedAttribute)(newNode, name_2, value);
                         }
                         templateAttributes = template.childNodes.filter(function (a) { return (a === null || a === void 0 ? void 0 : a.nodeType) === constants_1.DOM_ATTRIBUTE_NODE; });
                         for (_b = 0, templateAttributes_1 = templateAttributes; _b < templateAttributes_1.length; _b++) {
                             attribute = templateAttributes_1[_b];
-                            name_4 = attribute.nodeName;
+                            name_3 = attribute.nodeName;
                             value = this.xsltAttributeValue(attribute.nodeValue, elementContext);
-                            (0, dom_1.domSetTransformedAttribute)(newNode, name_4, value);
+                            (0, dom_1.domSetTransformedAttribute)(newNode, name_3, value);
                         }
-                        outputNode = context.outputNodeList[context.outputPosition];
-                        (0, dom_1.domAppendTransformedChild)(outputNode, newNode);
-                        clonedContext = elementContext.cloneByOutput(outputNode.transformedChildNodes, outputNode.transformedChildNodes.length - 1, ++elementContext.outputDepth);
-                        return [4 /*yield*/, this.xsltChildNodes(clonedContext, template)];
-                    case 2:
-                        _c.sent();
                         return [3 /*break*/, 5];
                     case 3: 
                     // This applies also to the DOCUMENT_NODE of the XSL stylesheet,