pdfjs-dist 2.0.943 → 2.4.456

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.
@@ -19,25 +19,13 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-
-var _slicedToArray = function () { function sliceIterator(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"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();
-
-var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };
-
-var _createClass = 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); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();
-
-function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-var XMLParserErrorCode = {
+exports.SimpleXMLParser = void 0;
+const XMLParserErrorCode = {
   NoError: 0,
   EndOfDocument: -1,
   UnterminatedCdat: -2,
@@ -50,388 +38,421 @@ var XMLParserErrorCode = {
   UnterminatedElement: -9,
   ElementNeverBegun: -10
 };
+
 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;
     }
   }
+
   return true;
 }
 
-var XMLParserBase = function () {
-  function XMLParserBase() {
-    _classCallCheck(this, XMLParserBase);
-  }
+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));
+      }
 
-  _createClass(XMLParserBase, [{
-    key: '_resolveEntities',
-    value: function _resolveEntities(s) {
-      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 '<';
-          case 'gt':
-            return '>';
-          case 'amp':
-            return '&';
-          case 'quot':
-            return '\"';
-        }
-        return this.onResolveEntity(entity);
-      });
-    }
-  }, {
-    key: '_parseContent',
-    value: function _parseContent(s, start) {
-      var pos = start,
-          name = void 0,
-          attributes = [];
-      function skipWs() {
-        while (pos < s.length && isWhitespace(s, pos)) {
-          ++pos;
-        }
+      switch (entity) {
+        case "lt":
+          return "<";
+
+        case "gt":
+          return ">";
+
+        case "amp":
+          return "&";
+
+        case "quot":
+          return '"';
       }
-      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== '>' && s[pos] !== '/') {
+
+      return this.onResolveEntity(entity);
+    });
+  }
+
+  _parseContent(s, start) {
+    const attributes = [];
+    let pos = start;
+
+    function skipWs() {
+      while (pos < s.length && isWhitespace(s, pos)) {
         ++pos;
       }
-      name = s.substring(start, pos);
+    }
+
+    while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") {
+      ++pos;
+    }
+
+    const name = s.substring(start, pos);
+    skipWs();
+
+    while (pos < s.length && s[pos] !== ">" && s[pos] !== "/" && s[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;
-        }
-        skipWs();
-        if (s[pos] !== '=') {
-          return null;
-        }
+      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;
-        }
-        var attrEndIndex = s.indexOf(attrEndChar, ++pos);
-        if (attrEndIndex < 0) {
-          return null;
-        }
-        attrValue = s.substring(pos, attrEndIndex);
-        attributes.push({
-          name: attrName,
-          value: this._resolveEntities(attrValue)
-        });
-        pos = attrEndIndex + 1;
-        skipWs();
       }
-      return {
-        name: name,
-        attributes: attributes,
-        parsed: pos - start
-      };
-    }
-  }, {
-    key: '_parseProcessingInstruction',
-    value: function _parseProcessingInstruction(s, start) {
-      var pos = start,
-          name = void 0,
-          value = void 0;
-      function skipWs() {
-        while (pos < s.length && isWhitespace(s, pos)) {
-          ++pos;
-        }
+
+      skipWs();
+
+      if (s[pos] !== "=") {
+        return null;
       }
-      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== '>' && s[pos] !== '/') {
-        ++pos;
+
+      ++pos;
+      skipWs();
+      const attrEndChar = s[pos];
+
+      if (attrEndChar !== '"' && attrEndChar !== "'") {
+        return null;
+      }
+
+      const attrEndIndex = s.indexOf(attrEndChar, ++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;
-      while (pos < s.length && (s[pos] !== '?' || s[pos + 1] !== '>')) {
+    }
+
+    return {
+      name,
+      attributes,
+      parsed: pos - start
+    };
+  }
+
+  _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
-      };
     }
-  }, {
-    key: 'parseXml',
-    value: function parseXml(s) {
-      var i = 0;
-      while (i < s.length) {
-        var ch = s[i];
-        var j = i;
-        if (ch === '<') {
-          ++j;
-          var ch2 = s[j];
-          var q = void 0;
-          switch (ch2) {
-            case '/':
-              ++j;
-              q = s.indexOf('>', j);
+
+    while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== ">" && s[pos] !== "/") {
+      ++pos;
+    }
+
+    const name = s.substring(start, pos);
+    skipWs();
+    const attrStart = pos;
+
+    while (pos < s.length && (s[pos] !== "?" || s[pos + 1] !== ">")) {
+      ++pos;
+    }
+
+    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;
-            case '?':
-              ++j;
-              var pi = this._parseProcessingInstruction(s, j);
-              if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== '?>') {
-                this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration);
+
+              this.onComment(s.substring(j + 3, q));
+              j = q + 3;
+            } else if (s.substring(j + 1, j + 8) === "[CDATA[") {
+              q = s.indexOf("]]>", j + 8);
+
+              if (q < 0) {
+                this.onError(XMLParserErrorCode.UnterminatedCdat);
                 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.UnterminatedComment);
-                  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);
-                if (q < 0) {
-                  this.onError(XMLParserErrorCode.UnterminatedCdat);
-                  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);
+
+              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 (q < 0) {
+                this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
+                return;
+              }
+
+              if (q2 > 0 && q > q2) {
+                q = s.indexOf("]>", j + 8);
+
                 if (q < 0) {
                   this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
                   return;
                 }
-                if (q2 > 0 && q > q2) {
-                  q = s.indexOf(']>', j + 8);
-                  if (q < 0) {
-                    this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
-                    return;
-                  }
-                  complexDoctype = true;
-                }
-                var doctypeContent = s.substring(j + 8, q + (complexDoctype ? 1 : 0));
-                this.onDoctype(doctypeContent);
-                j = q + (complexDoctype ? 2 : 1);
-              } else {
-                this.onError(XMLParserErrorCode.MalformedElement);
-                return;
-              }
-              break;
-            default:
-              var content = this._parseContent(s, j);
-              if (content === null) {
-                this.onError(XMLParserErrorCode.MalformedElement);
-                return;
-              }
-              var isClosed = false;
-              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;
+
+                complexDoctype = true;
               }
-              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));
+
+              const doctypeContent = s.substring(j + 8, q + (complexDoctype ? 1 : 0));
+              this.onDoctype(doctypeContent);
+              j = q + (complexDoctype ? 2 : 1);
+            } else {
+              this.onError(XMLParserErrorCode.MalformedElement);
+              return;
+            }
+
+            break;
+
+          default:
+            const content = this._parseContent(s, j);
+
+            if (content === null) {
+              this.onError(XMLParserErrorCode.MalformedElement);
+              return;
+            }
+
+            let isClosed = false;
+
+            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;
+            }
+
+            this.onBeginElement(content.name, content.attributes, isClosed);
+            j += content.parsed + (isClosed ? 2 : 1);
+            break;
         }
-        i = j;
+      } else {
+        while (j < s.length && s[j] !== "<") {
+          j++;
+        }
+
+        const text = s.substring(i, j);
+        this.onText(this._resolveEntities(text));
       }
+
+      i = j;
     }
-  }, {
-    key: 'onResolveEntity',
-    value: function onResolveEntity(name) {
-      return '&' + 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 = function () {
-  function SimpleDOMNode(nodeName, nodeValue) {
-    _classCallCheck(this, SimpleDOMNode);
+  }
+
+  onResolveEntity(name) {
+    return `&${name};`;
+  }
+
+  onPi(name, value) {}
+
+  onComment(text) {}
+
+  onCdata(text) {}
+
+  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[0];
-    }
-  }, {
-    key: 'nextSibling',
-    get: function get() {
-      var index = this.parentNode.childNodes.indexOf(this);
-      return this.parentNode.childNodes[index + 1];
-    }
-  }, {
-    key: 'textContent',
-    get: function get() {
-      if (!this.childNodes) {
-        return this.nodeValue || '';
-      }
-      return this.childNodes.map(function (child) {
-        return child.textContent;
-      }).join('');
+  get firstChild() {
+    return this.childNodes && this.childNodes[0];
+  }
+
+  get nextSibling() {
+    const childNodes = this.parentNode.childNodes;
+
+    if (!childNodes) {
+      return undefined;
     }
-  }]);
 
-  return SimpleDOMNode;
-}();
+    const index = childNodes.indexOf(this);
 
-var SimpleXMLParser = function (_XMLParserBase) {
-  _inherits(SimpleXMLParser, _XMLParserBase);
+    if (index === -1) {
+      return undefined;
+    }
 
-  function SimpleXMLParser() {
-    _classCallCheck(this, SimpleXMLParser);
+    return childNodes[index + 1];
+  }
 
-    var _this = _possibleConstructorReturn(this, (SimpleXMLParser.__proto__ || Object.getPrototypeOf(SimpleXMLParser)).call(this));
+  get textContent() {
+    if (!this.childNodes) {
+      return this.nodeValue || "";
+    }
 
-    _this._currentFragment = null;
-    _this._stack = null;
-    _this._errorCode = XMLParserErrorCode.NoError;
-    return _this;
+    return this.childNodes.map(function (child) {
+      return child.textContent;
+    }).join("");
   }
 
-  _createClass(SimpleXMLParser, [{
-    key: 'parseFromString',
-    value: function parseFromString(data) {
-      this._currentFragment = [];
-      this._stack = [];
-      this._errorCode = XMLParserErrorCode.NoError;
-      this.parseXml(data);
-      if (this._errorCode !== XMLParserErrorCode.NoError) {
-        return undefined;
-      }
+  hasChildNodes() {
+    return this.childNodes && this.childNodes.length > 0;
+  }
 
-      var _currentFragment = _slicedToArray(this._currentFragment, 1),
-          documentElement = _currentFragment[0];
+}
 
-      if (!documentElement) {
-        return undefined;
-      }
-      return { documentElement: documentElement };
+class SimpleXMLParser extends XMLParserBase {
+  constructor() {
+    super();
+    this._currentFragment = null;
+    this._stack = null;
+    this._errorCode = XMLParserErrorCode.NoError;
+  }
+
+  parseFromString(data) {
+    this._currentFragment = [];
+    this._stack = [];
+    this._errorCode = XMLParserErrorCode.NoError;
+    this.parseXml(data);
+
+    if (this._errorCode !== XMLParserErrorCode.NoError) {
+      return undefined;
     }
-  }, {
-    key: 'onResolveEntity',
-    value: function onResolveEntity(name) {
-      switch (name) {
-        case 'apos':
-          return '\'';
-      }
-      return _get(SimpleXMLParser.prototype.__proto__ || Object.getPrototypeOf(SimpleXMLParser.prototype), 'onResolveEntity', this).call(this, name);
+
+    const [documentElement] = this._currentFragment;
+
+    if (!documentElement) {
+      return undefined;
     }
-  }, {
-    key: 'onText',
-    value: function onText(text) {
-      if (isWhitespaceString(text)) {
-        return;
-      }
-      var node = new SimpleDOMNode('#text', text);
-      this._currentFragment.push(node);
+
+    return {
+      documentElement
+    };
+  }
+
+  onResolveEntity(name) {
+    switch (name) {
+      case "apos":
+        return "'";
     }
-  }, {
-    key: 'onCdata',
-    value: function onCdata(text) {
-      var node = new SimpleDOMNode('#text', text);
-      this._currentFragment.push(node);
+
+    return super.onResolveEntity(name);
+  }
+
+  onText(text) {
+    if (isWhitespaceString(text)) {
+      return;
     }
-  }, {
-    key: 'onBeginElement',
-    value: function onBeginElement(name, attributes, isEmpty) {
-      var node = new SimpleDOMNode(name);
-      node.childNodes = [];
-      this._currentFragment.push(node);
-      if (isEmpty) {
-        return;
-      }
-      this._stack.push(this._currentFragment);
-      this._currentFragment = node.childNodes;
+
+    const node = new SimpleDOMNode("#text", text);
+
+    this._currentFragment.push(node);
+  }
+
+  onCdata(text) {
+    const node = new SimpleDOMNode("#text", text);
+
+    this._currentFragment.push(node);
+  }
+
+  onBeginElement(name, attributes, isEmpty) {
+    const node = new SimpleDOMNode(name);
+    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];
-      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;
     }
-  }]);
+  }
 
-  return SimpleXMLParser;
-}(XMLParserBase);
+  onError(code) {
+    this._errorCode = code;
+  }
+
+}
 
 exports.SimpleXMLParser = SimpleXMLParser;