pdf2svg.js: Serialize the SVG to a stream

Implement a serialization "generator" for `DOMElement` in domutils.js
that yields the serialization of the SVG element. This method is used by
a newly added `ReadableSVGStream` class, which can be used like any
other readable stream in Node.js.

This reduces the memory requirements. Now, it is not needed to require
the serialization to fully fit in memory.

Note: The implementation of the serializer is a state machine in ES5
since the rest of the file is also in ES5. Its functionality is
equivalent to:

```
function* serializeSVGElement(elem) {
  yield '<' + elem.nodeName;
  if (elem.nodeName === 'svg:svg') {
    yield ' xmlns:xlink="http://www.w3.org/1999/xlink"' +
          ' xmlns:svg="http://www.w3.org/2000/svg"';
  }
  for (let i in elem.attributes) {
    yield ' ' + i + '="' + xmlEncode(elem.attributes[i]) + '"';
  }

  yield '>';

  if (elem.nodeName === 'svg:tspan' || elem.nodeName === 'svg:style') {
    yield xmlEncode(elem.textContent);
  } else {
    for (let childNode of elem.childNodes) {
      yield* serializeSVGElement(childNode);
    }
  }
  yield '</' + elem.nodeName + '>';
}
```

examples/node/domstubs.js

@@ -91,30 +91,6 @@ DOMElement.prototype = {
     }
   },
 
-  toString: function DOMElement_toString() {
-    var buf = [];
-    buf.push('<' + this.nodeName);
-    if (this.nodeName === 'svg:svg') {
-      buf.push(' xmlns:xlink="http://www.w3.org/1999/xlink"' +
-               ' xmlns:svg="http://www.w3.org/2000/svg"');
-    }
-    for (var i in this.attributes) {
-      buf.push(' ' + i + '="' + xmlEncode(this.attributes[i]) + '"');
-    }
-
-    buf.push('>');
-
-    if (this.nodeName === 'svg:tspan' || this.nodeName === 'svg:style') {
-      buf.push(xmlEncode(this.textContent));
-    } else {
-      this.childNodes.forEach(function(childNode) {
-        buf.push(childNode.toString());
-      });
-    }
-    buf.push('</' + this.nodeName + '>');
-    return buf.join('');
-  },
-
   cloneNode: function DOMElement_cloneNode() {
     var newNode = new DOMElement(this.nodeName);
     newNode.childNodes = this.childNodes;
@@ -122,8 +98,95 @@ DOMElement.prototype = {
     newNode.textContent = this.textContent;
     return newNode;
   },
+
+  // This method is offered for convenience. It is recommended to directly use
+  // getSerializer because that allows you to process the chunks as they come
+  // instead of requiring the whole image to fit in memory.
+  toString: function DOMElement_toString() {
+    var buf = [];
+    var serializer = this.getSerializer();
+    var chunk;
+    while ((chunk = serializer.getNext()) !== null) {
+      buf.push(chunk);
+    }
+    return buf.join('');
+  },
+
+  getSerializer: function DOMElement_getSerializer() {
+    return new DOMElementSerializer(this);
+  }
 }
 
+function DOMElementSerializer(node) {
+  this._node = node;
+  this._state = 0;
+  this._loopIndex = 0;
+  this._attributeKeys = null;
+  this._childSerializer = null;
+}
+DOMElementSerializer.prototype = {
+  /**
+   * Yields the next chunk in the serialization of the element.
+   *
+   * @returns {string|null} null if the element has fully been serialized.
+   */
+  getNext: function DOMElementSerializer_getNext() {
+    var node = this._node;
+    switch (this._state) {
+      case 0:  // Start opening tag.
+        ++this._state;
+        return '<' + node.nodeName;
+      case 1:  // Add SVG namespace if this is the root element.
+        ++this._state;
+        if (node.nodeName === 'svg:svg') {
+          return ' xmlns:xlink="http://www.w3.org/1999/xlink"' +
+                 ' xmlns:svg="http://www.w3.org/2000/svg"';
+        }
+      case 2:  // Initialize variables for looping over attributes.
+        ++this._state;
+        this._loopIndex = 0;
+        this._attributeKeys = Object.keys(node.attributes);
+      case 3:  // Serialize any attributes and end opening tag.
+        if (this._loopIndex < this._attributeKeys.length) {
+          var name = this._attributeKeys[this._loopIndex++];
+          return ' ' + name + '="' + xmlEncode(node.attributes[name]) + '"';
+        }
+        ++this._state;
+        return '>';
+      case 4:  // Serialize textContent for tspan/style elements.
+        if (node.nodeName === 'svg:tspan' || node.nodeName === 'svg:style') {
+          this._state = 6;
+          return xmlEncode(node.textContent);
+        }
+        ++this._state;
+        this._loopIndex = 0;
+      case 5:  // Serialize child nodes (only for non-tspan/style elements).
+        var value;
+        while (true) {
+          value = this._childSerializer && this._childSerializer.getNext();
+          if (value !== null) {
+            return value;
+          }
+          var nextChild = node.childNodes[this._loopIndex++];
+          if (nextChild) {
+            this._childSerializer = new DOMElementSerializer(nextChild);
+          } else {
+            this._childSerializer = null;
+            ++this._state;
+            break;
+          }
+        }
+      case 6:  // Ending tag.
+        ++this._state;
+        return '</' + node.nodeName + '>';
+      case 7:  // Done.
+        return null;
+      default:
+        throw new Error('Unexpected serialization state: ' + this._state);
+    }
+  },
+};
+
 const document = {
   childNodes : [],