pdfjs-dist 2.1.266 → 2.5.207

package/lib/display/xml_parser.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2018 Mozilla Foundation
+ * Copyright 2020 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -25,38 +25,7 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.SimpleXMLParser = void 0;
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-var XMLParserErrorCode = {
+const XMLParserErrorCode = {
   NoError: 0,
   EndOfDocument: -1,
   UnterminatedCdat: -2,
@@ -71,12 +40,12 @@ var XMLParserErrorCode = {
 };
 
 function isWhitespace(s, index) {
-  var ch = s[index];
-  return ch === ' ' || ch === '\n' || ch === '\r' || ch === '\t';
+  const ch = s[index];
+  return ch === " " || ch === "\n" || ch === "\r" || ch === "\t";
 }
 
 function isWhitespaceString(s) {
-  for (var i = 0, ii = s.length; i < ii; i++) {
+  for (let i = 0, ii = s.length; i < ii; i++) {
     if (!isWhitespace(s, i)) {
       return false;
     }
@@ -85,463 +54,405 @@ function isWhitespaceString(s) {
   return true;
 }
 
-var XMLParserBase =
-/*#__PURE__*/
-function () {
-  function XMLParserBase() {
-    _classCallCheck(this, XMLParserBase);
-  }
-
-  _createClass(XMLParserBase, [{
-    key: "_resolveEntities",
-    value: function _resolveEntities(s) {
-      var _this = this;
+class XMLParserBase {
+  _resolveEntities(s) {
+    return s.replace(/&([^;]+);/g, (all, entity) => {
+      if (entity.substring(0, 2) === "#x") {
+        return String.fromCharCode(parseInt(entity.substring(2), 16));
+      } else if (entity.substring(0, 1) === "#") {
+        return String.fromCharCode(parseInt(entity.substring(1), 10));
+      }
 
-      return s.replace(/&([^;]+);/g, function (all, entity) {
-        if (entity.substring(0, 2) === '#x') {
-          return String.fromCharCode(parseInt(entity.substring(2), 16));
-        } else if (entity.substring(0, 1) === '#') {
-          return String.fromCharCode(parseInt(entity.substring(1), 10));
-        }
+      switch (entity) {
+        case "lt":
+          return "<";
 
-        switch (entity) {
-          case 'lt':
-            return '<';
+        case "gt":
+          return ">";
 
-          case 'gt':
-            return '>';
+        case "amp":
+          return "&";
 
-          case 'amp':
-            return '&';
+        case "quot":
+          return '"';
+      }
 
-          case 'quot':
-            return '\"';
-        }
+      return this.onResolveEntity(entity);
+    });
+  }
 
-        return _this.onResolveEntity(entity);
-      });
-    }
-  }, {
-    key: "_parseContent",
-    value: function _parseContent(s, start) {
-      var pos = start,
-          name,
-          attributes = [];
-
-      function skipWs() {
-        while (pos < s.length && isWhitespace(s, pos)) {
-          ++pos;
-        }
-      }
+  _parseContent(s, start) {
+    const attributes = [];
+    let pos = start;
 
-      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== '>' && s[pos] !== '/') {
+    function skipWs() {
+      while (pos < s.length && isWhitespace(s, pos)) {
         ++pos;
       }
+    }
 
-      name = s.substring(start, pos);
-      skipWs();
-
-      while (pos < s.length && s[pos] !== '>' && s[pos] !== '/' && s[pos] !== '?') {
-        skipWs();
-        var attrName = '',
-            attrValue = '';
-
-        while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== '=') {
-          attrName += s[pos];
-          ++pos;
-        }
+    while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") {
+      ++pos;
+    }
 
-        skipWs();
+    const name = s.substring(start, pos);
+    skipWs();
 
-        if (s[pos] !== '=') {
-          return null;
-        }
+    while (pos < s.length && s[pos] !== ">" && s[pos] !== "/" && s[pos] !== "?") {
+      skipWs();
+      let attrName = "",
+          attrValue = "";
 
+      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== "=") {
+        attrName += s[pos];
         ++pos;
-        skipWs();
-        var attrEndChar = s[pos];
+      }
 
-        if (attrEndChar !== '\"' && attrEndChar !== '\'') {
-          return null;
-        }
+      skipWs();
 
-        var attrEndIndex = s.indexOf(attrEndChar, ++pos);
+      if (s[pos] !== "=") {
+        return null;
+      }
 
-        if (attrEndIndex < 0) {
-          return null;
-        }
+      ++pos;
+      skipWs();
+      const attrEndChar = s[pos];
 
-        attrValue = s.substring(pos, attrEndIndex);
-        attributes.push({
-          name: attrName,
-          value: this._resolveEntities(attrValue)
-        });
-        pos = attrEndIndex + 1;
-        skipWs();
+      if (attrEndChar !== '"' && attrEndChar !== "'") {
+        return null;
       }
 
-      return {
-        name: name,
-        attributes: attributes,
-        parsed: pos - start
-      };
-    }
-  }, {
-    key: "_parseProcessingInstruction",
-    value: function _parseProcessingInstruction(s, start) {
-      var pos = start,
-          name,
-          value;
-
-      function skipWs() {
-        while (pos < s.length && isWhitespace(s, pos)) {
-          ++pos;
-        }
-      }
+      const attrEndIndex = s.indexOf(attrEndChar, ++pos);
 
-      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== '>' && s[pos] !== '/') {
-        ++pos;
+      if (attrEndIndex < 0) {
+        return null;
       }
 
-      name = s.substring(start, pos);
+      attrValue = s.substring(pos, attrEndIndex);
+      attributes.push({
+        name: attrName,
+        value: this._resolveEntities(attrValue)
+      });
+      pos = attrEndIndex + 1;
       skipWs();
-      var attrStart = pos;
+    }
+
+    return {
+      name,
+      attributes,
+      parsed: pos - start
+    };
+  }
 
-      while (pos < s.length && (s[pos] !== '?' || s[pos + 1] !== '>')) {
+  _parseProcessingInstruction(s, start) {
+    let pos = start;
+
+    function skipWs() {
+      while (pos < s.length && isWhitespace(s, pos)) {
         ++pos;
       }
+    }
 
-      value = s.substring(attrStart, pos);
-      return {
-        name: name,
-        value: value,
-        parsed: pos - start
-      };
+    while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") {
+      ++pos;
     }
-  }, {
-    key: "parseXml",
-    value: function parseXml(s) {
-      var i = 0;
 
-      while (i < s.length) {
-        var ch = s[i];
-        var j = i;
+    const name = s.substring(start, pos);
+    skipWs();
+    const attrStart = pos;
 
-        if (ch === '<') {
-          ++j;
-          var ch2 = s[j];
-          var q = void 0;
+    while (pos < s.length && (s[pos] !== "?" || s[pos + 1] !== ">")) {
+      ++pos;
+    }
 
-          switch (ch2) {
-            case '/':
-              ++j;
-              q = s.indexOf('>', j);
+    const value = s.substring(attrStart, pos);
+    return {
+      name,
+      value,
+      parsed: pos - start
+    };
+  }
+
+  parseXml(s) {
+    let i = 0;
+
+    while (i < s.length) {
+      const ch = s[i];
+      let j = i;
+
+      if (ch === "<") {
+        ++j;
+        const ch2 = s[j];
+        let q;
+
+        switch (ch2) {
+          case "/":
+            ++j;
+            q = s.indexOf(">", j);
+
+            if (q < 0) {
+              this.onError(XMLParserErrorCode.UnterminatedElement);
+              return;
+            }
+
+            this.onEndElement(s.substring(j, q));
+            j = q + 1;
+            break;
+
+          case "?":
+            ++j;
+
+            const pi = this._parseProcessingInstruction(s, j);
+
+            if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== "?>") {
+              this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration);
+              return;
+            }
+
+            this.onPi(pi.name, pi.value);
+            j += pi.parsed + 2;
+            break;
+
+          case "!":
+            if (s.substring(j + 1, j + 3) === "--") {
+              q = s.indexOf("-->", j + 3);
 
               if (q < 0) {
-                this.onError(XMLParserErrorCode.UnterminatedElement);
+                this.onError(XMLParserErrorCode.UnterminatedComment);
                 return;
               }
 
-              this.onEndElement(s.substring(j, q));
-              j = q + 1;
-              break;
+              this.onComment(s.substring(j + 3, q));
+              j = q + 3;
+            } else if (s.substring(j + 1, j + 8) === "[CDATA[") {
+              q = s.indexOf("]]>", j + 8);
 
-            case '?':
-              ++j;
+              if (q < 0) {
+                this.onError(XMLParserErrorCode.UnterminatedCdat);
+                return;
+              }
 
-              var pi = this._parseProcessingInstruction(s, j);
+              this.onCdata(s.substring(j + 8, q));
+              j = q + 3;
+            } else if (s.substring(j + 1, j + 8) === "DOCTYPE") {
+              const q2 = s.indexOf("[", j + 8);
+              let complexDoctype = false;
+              q = s.indexOf(">", j + 8);
 
-              if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== '?>') {
-                this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration);
+              if (q < 0) {
+                this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
                 return;
               }
 
-              this.onPi(pi.name, pi.value);
-              j += pi.parsed + 2;
-              break;
-
-            case '!':
-              if (s.substring(j + 1, j + 3) === '--') {
-                q = s.indexOf('-->', j + 3);
+              if (q2 > 0 && q > q2) {
+                q = s.indexOf("]>", j + 8);
 
                 if (q < 0) {
-                  this.onError(XMLParserErrorCode.UnterminatedComment);
+                  this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
                   return;
                 }
 
-                this.onComment(s.substring(j + 3, q));
-                j = q + 3;
-              } else if (s.substring(j + 1, j + 8) === '[CDATA[') {
-                q = s.indexOf(']]>', j + 8);
+                complexDoctype = true;
+              }
 
-                if (q < 0) {
-                  this.onError(XMLParserErrorCode.UnterminatedCdat);
-                  return;
-                }
+              const doctypeContent = s.substring(j + 8, q + (complexDoctype ? 1 : 0));
+              this.onDoctype(doctypeContent);
+              j = q + (complexDoctype ? 2 : 1);
+            } else {
+              this.onError(XMLParserErrorCode.MalformedElement);
+              return;
+            }
 
-                this.onCdata(s.substring(j + 8, q));
-                j = q + 3;
-              } else if (s.substring(j + 1, j + 8) === 'DOCTYPE') {
-                var q2 = s.indexOf('[', j + 8);
-                var complexDoctype = false;
-                q = s.indexOf('>', j + 8);
+            break;
 
-                if (q < 0) {
-                  this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
-                  return;
-                }
+          default:
+            const content = this._parseContent(s, j);
 
-                if (q2 > 0 && q > q2) {
-                  q = s.indexOf(']>', j + 8);
+            if (content === null) {
+              this.onError(XMLParserErrorCode.MalformedElement);
+              return;
+            }
 
-                  if (q < 0) {
-                    this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
-                    return;
-                  }
+            let isClosed = false;
 
-                  complexDoctype = true;
-                }
+            if (s.substring(j + content.parsed, j + content.parsed + 2) === "/>") {
+              isClosed = true;
+            } else if (s.substring(j + content.parsed, j + content.parsed + 1) !== ">") {
+              this.onError(XMLParserErrorCode.UnterminatedElement);
+              return;
+            }
 
-                var doctypeContent = s.substring(j + 8, q + (complexDoctype ? 1 : 0));
-                this.onDoctype(doctypeContent);
-                j = q + (complexDoctype ? 2 : 1);
-              } else {
-                this.onError(XMLParserErrorCode.MalformedElement);
-                return;
-              }
+            this.onBeginElement(content.name, content.attributes, isClosed);
+            j += content.parsed + (isClosed ? 2 : 1);
+            break;
+        }
+      } else {
+        while (j < s.length && s[j] !== "<") {
+          j++;
+        }
 
-              break;
+        const text = s.substring(i, j);
+        this.onText(this._resolveEntities(text));
+      }
 
-            default:
-              var content = this._parseContent(s, j);
+      i = j;
+    }
+  }
 
-              if (content === null) {
-                this.onError(XMLParserErrorCode.MalformedElement);
-                return;
-              }
+  onResolveEntity(name) {
+    return `&${name};`;
+  }
 
-              var isClosed = false;
+  onPi(name, value) {}
 
-              if (s.substring(j + content.parsed, j + content.parsed + 2) === '/>') {
-                isClosed = true;
-              } else if (s.substring(j + content.parsed, j + content.parsed + 1) !== '>') {
-                this.onError(XMLParserErrorCode.UnterminatedElement);
-                return;
-              }
+  onComment(text) {}
 
-              this.onBeginElement(content.name, content.attributes, isClosed);
-              j += content.parsed + (isClosed ? 2 : 1);
-              break;
-          }
-        } else {
-          while (j < s.length && s[j] !== '<') {
-            j++;
-          }
-
-          var text = s.substring(i, j);
-          this.onText(this._resolveEntities(text));
-        }
+  onCdata(text) {}
 
-        i = j;
-      }
-    }
-  }, {
-    key: "onResolveEntity",
-    value: function onResolveEntity(name) {
-      return "&".concat(name, ";");
-    }
-  }, {
-    key: "onPi",
-    value: function onPi(name, value) {}
-  }, {
-    key: "onComment",
-    value: function onComment(text) {}
-  }, {
-    key: "onCdata",
-    value: function onCdata(text) {}
-  }, {
-    key: "onDoctype",
-    value: function onDoctype(doctypeContent) {}
-  }, {
-    key: "onText",
-    value: function onText(text) {}
-  }, {
-    key: "onBeginElement",
-    value: function onBeginElement(name, attributes, isEmpty) {}
-  }, {
-    key: "onEndElement",
-    value: function onEndElement(name) {}
-  }, {
-    key: "onError",
-    value: function onError(code) {}
-  }]);
-
-  return XMLParserBase;
-}();
-
-var SimpleDOMNode =
-/*#__PURE__*/
-function () {
-  function SimpleDOMNode(nodeName, nodeValue) {
-    _classCallCheck(this, SimpleDOMNode);
+  onDoctype(doctypeContent) {}
+
+  onText(text) {}
+
+  onBeginElement(name, attributes, isEmpty) {}
 
+  onEndElement(name) {}
+
+  onError(code) {}
+
+}
+
+class SimpleDOMNode {
+  constructor(nodeName, nodeValue) {
     this.nodeName = nodeName;
     this.nodeValue = nodeValue;
-    Object.defineProperty(this, 'parentNode', {
+    Object.defineProperty(this, "parentNode", {
       value: null,
       writable: true
     });
   }
 
-  _createClass(SimpleDOMNode, [{
-    key: "hasChildNodes",
-    value: function hasChildNodes() {
-      return this.childNodes && this.childNodes.length > 0;
-    }
-  }, {
-    key: "firstChild",
-    get: function get() {
-      return this.childNodes && this.childNodes[0];
-    }
-  }, {
-    key: "nextSibling",
-    get: function get() {
-      var childNodes = this.parentNode.childNodes;
+  get firstChild() {
+    return this.childNodes && this.childNodes[0];
+  }
 
-      if (!childNodes) {
-        return undefined;
-      }
+  get nextSibling() {
+    const childNodes = this.parentNode.childNodes;
 
-      var index = childNodes.indexOf(this);
+    if (!childNodes) {
+      return undefined;
+    }
 
-      if (index === -1) {
-        return undefined;
-      }
+    const index = childNodes.indexOf(this);
 
-      return childNodes[index + 1];
+    if (index === -1) {
+      return undefined;
     }
-  }, {
-    key: "textContent",
-    get: function get() {
-      if (!this.childNodes) {
-        return this.nodeValue || '';
-      }
 
-      return this.childNodes.map(function (child) {
-        return child.textContent;
-      }).join('');
-    }
-  }]);
+    return childNodes[index + 1];
+  }
 
-  return SimpleDOMNode;
-}();
+  get textContent() {
+    if (!this.childNodes) {
+      return this.nodeValue || "";
+    }
 
-var SimpleXMLParser =
-/*#__PURE__*/
-function (_XMLParserBase) {
-  _inherits(SimpleXMLParser, _XMLParserBase);
+    return this.childNodes.map(function (child) {
+      return child.textContent;
+    }).join("");
+  }
 
-  function SimpleXMLParser() {
-    var _this2;
+  hasChildNodes() {
+    return this.childNodes && this.childNodes.length > 0;
+  }
 
-    _classCallCheck(this, SimpleXMLParser);
+}
 
-    _this2 = _possibleConstructorReturn(this, _getPrototypeOf(SimpleXMLParser).call(this));
-    _this2._currentFragment = null;
-    _this2._stack = null;
-    _this2._errorCode = XMLParserErrorCode.NoError;
-    return _this2;
+class SimpleXMLParser extends XMLParserBase {
+  constructor() {
+    super();
+    this._currentFragment = null;
+    this._stack = null;
+    this._errorCode = XMLParserErrorCode.NoError;
   }
 
-  _createClass(SimpleXMLParser, [{
-    key: "parseFromString",
-    value: function parseFromString(data) {
-      this._currentFragment = [];
-      this._stack = [];
-      this._errorCode = XMLParserErrorCode.NoError;
-      this.parseXml(data);
+  parseFromString(data) {
+    this._currentFragment = [];
+    this._stack = [];
+    this._errorCode = XMLParserErrorCode.NoError;
+    this.parseXml(data);
 
-      if (this._errorCode !== XMLParserErrorCode.NoError) {
-        return undefined;
-      }
+    if (this._errorCode !== XMLParserErrorCode.NoError) {
+      return undefined;
+    }
 
-      var _this$_currentFragmen = _slicedToArray(this._currentFragment, 1),
-          documentElement = _this$_currentFragmen[0];
+    const [documentElement] = this._currentFragment;
 
-      if (!documentElement) {
-        return undefined;
-      }
-
-      return {
-        documentElement: documentElement
-      };
+    if (!documentElement) {
+      return undefined;
     }
-  }, {
-    key: "onResolveEntity",
-    value: function onResolveEntity(name) {
-      switch (name) {
-        case 'apos':
-          return '\'';
-      }
 
-      return _get(_getPrototypeOf(SimpleXMLParser.prototype), "onResolveEntity", this).call(this, name);
+    return {
+      documentElement
+    };
+  }
+
+  onResolveEntity(name) {
+    switch (name) {
+      case "apos":
+        return "'";
     }
-  }, {
-    key: "onText",
-    value: function onText(text) {
-      if (isWhitespaceString(text)) {
-        return;
-      }
 
-      var node = new SimpleDOMNode('#text', text);
+    return super.onResolveEntity(name);
+  }
 
-      this._currentFragment.push(node);
+  onText(text) {
+    if (isWhitespaceString(text)) {
+      return;
     }
-  }, {
-    key: "onCdata",
-    value: function onCdata(text) {
-      var node = new SimpleDOMNode('#text', text);
 
-      this._currentFragment.push(node);
-    }
-  }, {
-    key: "onBeginElement",
-    value: function onBeginElement(name, attributes, isEmpty) {
-      var node = new SimpleDOMNode(name);
-      node.childNodes = [];
+    const node = new SimpleDOMNode("#text", text);
 
-      this._currentFragment.push(node);
+    this._currentFragment.push(node);
+  }
 
-      if (isEmpty) {
-        return;
-      }
+  onCdata(text) {
+    const node = new SimpleDOMNode("#text", text);
+
+    this._currentFragment.push(node);
+  }
 
-      this._stack.push(this._currentFragment);
+  onBeginElement(name, attributes, isEmpty) {
+    const node = new SimpleDOMNode(name);
+    node.childNodes = [];
 
-      this._currentFragment = node.childNodes;
+    this._currentFragment.push(node);
+
+    if (isEmpty) {
+      return;
     }
-  }, {
-    key: "onEndElement",
-    value: function onEndElement(name) {
-      this._currentFragment = this._stack.pop() || [];
-      var lastElement = this._currentFragment[this._currentFragment.length - 1];
-
-      if (!lastElement) {
-        return;
-      }
 
-      for (var i = 0, ii = lastElement.childNodes.length; i < ii; i++) {
-        lastElement.childNodes[i].parentNode = lastElement;
-      }
+    this._stack.push(this._currentFragment);
+
+    this._currentFragment = node.childNodes;
+  }
+
+  onEndElement(name) {
+    this._currentFragment = this._stack.pop() || [];
+    const lastElement = this._currentFragment[this._currentFragment.length - 1];
+
+    if (!lastElement) {
+      return;
     }
-  }, {
-    key: "onError",
-    value: function onError(code) {
-      this._errorCode = code;
+
+    for (let i = 0, ii = lastElement.childNodes.length; i < ii; i++) {
+      lastElement.childNodes[i].parentNode = lastElement;
     }
-  }]);
+  }
+
+  onError(code) {
+    this._errorCode = code;
+  }
 
-  return SimpleXMLParser;
-}(XMLParserBase);
+}
 
 exports.SimpleXMLParser = SimpleXMLParser;