Fixing issue with infinite loops if apply-templates uses an absolute match.

Author: leonelsanchesdasilva

README.md

@@ -1,18 +1,50 @@
 # XSLT-processor
 
-[![Build Status](https://travis-ci.com/fiduswriter/xslt-processor.svg?branch=master)](https://travis-ci.com/fiduswriter/xslt-processor)
-
 _A JavaScript XSLT processor without native library dependencies._
 
-## Howto
+## How to
 
 Install xslt-processor using npm:
 
 ```
 npm install xslt-processor
 ```
 
-Within your ES2015+ code, import the two main functions and apply them:
+Within your ES2015+ code, import the `Xslt` class, the `xmlParse` function and use this way:
+
+```js
+import { Xslt, xmlParse } from 'xslt-processor'
+
+// xmlString: string of xml file contents
+// xsltString: string of xslt file contents
+// outXmlString: output xml string.
+const xslt = new Xslt();
+const outXmlString = xslt.xsltProcess(
+	xmlParse(xmlString),
+	xmlParse(xsltString)
+);
+```
+
+To access the XPath parser, you can use the instance present at `Xslt` class:
+
+```js
+const xslt = new Xslt();
+const xPath = xslt.xPath;
+```
+
+Or ou can import it like this:
+
+```js
+import { XPath } from 'xslt-processor'
+
+const xPath = new XPath();
+```
+
+If you write pre-2015 JS code, make adjustments as needed.
+
+### Breaking Changes
+
+Until version 0.17, use like the example below:
 
 ```js
 import { xsltProcess, xmlParse } from 'xslt-processor'
@@ -26,14 +58,13 @@ const outXmlString = xsltProcess(
 );
 ```
 
-To access the Xpath-parser, import it like this:
+and to access the XPath parser:
 
 ```js
 import { xpathParse } from 'xslt-processor'
 ```
 
-If you write pre-2015 JS code, make adjustments as needed.
-
+These functions are part of `Xslt` and `XPath` classes, respectively, at version 1.x onward.
 
 ## Introduction
 
@@ -75,8 +106,7 @@ Issues are also marked in the source code using throw-statements.
 The DOM implementation is minimal so as to support the XSLT processing, and not intended to be complete.
 
 The implementation is all agnostic about namespaces. It just expects
-XSLT elements to have tags that carry the xsl: prefix, but we
-disregard all namespace declaration for them.
+XSLT elements to have tags that carry the `xsl:` prefix, but we disregard all namespace declaration for them.
 
 There are a few nonstandard XPath functions. Grep `xpath.js` for `ext-` to see their definitions.
 

TODO.md

@@ -2,7 +2,8 @@ XSLT-processor TODO
 =====
 
 * Deal with namespaces (if namespaces are not the same in XSLT and XML document, matches do no occur.)
-
+* XSLT validation
 * XSL:number
+* `attribute-set`, `decimal-format`, etc. (check `src/xslt.ts`)
 
 Help is much appreciated. It seems to currently work for most of our purposes, but fixes and additions are always welcome!

src/dom/util.ts

@@ -23,7 +23,7 @@ import { XDocument } from './xdocument';
 // Throws an exception if false.
 export function assert(b) {
     if (!b) {
-        throw 'Assertion failed';
+        throw new Error('Assertion failed');
     }
 }
 
@@ -209,31 +209,31 @@ export function xmlOwnerDocument(node) {
 }
 
 // Wrapper around DOM methods so we can condense their invocations.
-export function domGetAttribute(node, name) {
+export function domGetAttribute(node: any, name: any) {
     return node.getAttribute(name);
 }
 
-export function domSetAttribute(node, name, value) {
+export function domSetAttribute(node: any, name: any, value: any) {
     return node.setAttribute(name, value);
 }
 
-export function domAppendChild(node, child) {
+export function domAppendChild(node: any, child: any) {
     return node.appendChild(child);
 }
 
-export function domCreateTextNode(doc, text) {
+export function domCreateTextNode(doc: any, text: any) {
     return doc.createTextNode(text);
 }
 
-export function domCreateElement(doc, name) {
+export function domCreateElement(doc: any, name: any) {
     return doc.createElement(name);
 }
 
-export function domCreateCDATASection(doc, data) {
+export function domCreateCDATASection(doc: any, data: any) {
     return doc.createCDATASection(data);
 }
 
-export function domCreateComment(doc, text) {
+export function domCreateComment(doc: any, text: any) {
     return doc.createComment(text);
 }
 
@@ -251,7 +251,7 @@ const regExpSpecials = ['/', '.', '*', '+', '?', '|', '^', '$', '(', ')', '[', '
 
 const sRE = new RegExp(`(\\${regExpSpecials.join('|\\')})`, 'g');
 
-export function regExpEscape(text) {
+export function regExpEscape(text: string) {
     return text.replace(sRE, '\\$1');
 }
 

src/xslt.ts

@@ -98,7 +98,7 @@ export class Xslt {
     // @param template The stylesheet document root, as DOM node.
     // @param the root of the generated output, as DOM node.
 
-    xsltProcessContext(input: any, template: any, output: any, _parameters?: any) {
+    xsltProcessContext(input: any, template: XNode, output: any, _parameters?: any) {
         const outputDocument = xmlOwnerDocument(output);
 
         if (!this.isXsltElement(template)) {
@@ -137,9 +137,17 @@ export class Xslt {
 
                     mode = this.xmlGetAttribute(template, 'mode');
                     top = template.ownerDocument.documentElement;
+
                     templates = [];
                     for (let i = 0; i < top.childNodes.length; ++i) {
                         let c = top.childNodes[i];
+                        let matchAttribute = c.getAttribute('match');
+
+                        // Avoiding infinite loops.
+                        if (matchAttribute && matchAttribute.startsWith('/')) {
+                            continue;
+                        }
+
                         if (
                             c.nodeType == DOM_ELEMENT_NODE &&
                             this.isXsltElement(c, 'template') &&
@@ -299,27 +307,32 @@ export class Xslt {
         }
     }
 
-    // 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.
-
-    xsltWithParam(input, template) {
+    /**
+     * 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
+     */
+    xsltWithParam(input: any, template: any) {
         for (const c of template.childNodes) {
             if (c.nodeType == DOM_ELEMENT_NODE && this.isXsltElement(c, 'with-param')) {
                 this.xsltVariable(input, c, true);
             }
         }
     }
 
-    // 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.
-    //
-    // TODO(mesch): case-order is not implemented.
-
-    xsltSort(input, template) {
+    /**
+     * 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 input TODO
+     * @param template TODO
+     * @todo case-order is not implemented.
+     */
+    xsltSort(input: any, template: any) {
         const sort = [];
 
         for (const c of template.childNodes) {
@@ -690,7 +703,7 @@ export class Xslt {
     // Test if the given element is an XSLT element, optionally the one with the given name
     isXsltElement(element: any, opt_wantedName?: string) {
         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
+        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
     }
 }