pdfjs-dist 2.3.200 → 2.4.456

package/lib/test/unit/stream_spec.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2019 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.
@@ -21,21 +21,21 @@
  */
 "use strict";
 
-var _stream = require("../../core/stream");
+var _stream = require("../../core/stream.js");
 
-var _primitives = require("../../core/primitives");
+var _primitives = require("../../core/primitives.js");
 
-describe('stream', function () {
+describe("stream", function () {
   beforeEach(function () {
     jasmine.addMatchers({
-      toMatchTypedArray: function toMatchTypedArray(util, customEqualityTesters) {
+      toMatchTypedArray(util, customEqualityTesters) {
         return {
-          compare: function compare(actual, expected) {
+          compare(actual, expected) {
             var result = {};
 
             if (actual.length !== expected.length) {
               result.pass = false;
-              result.message = 'Array length: ' + actual.length + ', expected: ' + expected.length;
+              result.message = "Array length: " + actual.length + ", expected: " + expected.length;
               return result;
             }
 
@@ -53,23 +53,25 @@ describe('stream', function () {
 
             return result;
           }
+
         };
       }
+
     });
   });
-  describe('PredictorStream', function () {
-    it('should decode simple predictor data', function () {
+  describe("PredictorStream", function () {
+    it("should decode simple predictor data", function () {
       var dict = new _primitives.Dict();
-      dict.set('Predictor', 12);
-      dict.set('Colors', 1);
-      dict.set('BitsPerComponent', 8);
-      dict.set('Columns', 2);
+      dict.set("Predictor", 12);
+      dict.set("Colors", 1);
+      dict.set("BitsPerComponent", 8);
+      dict.set("Columns", 2);
       var input = new _stream.Stream(new Uint8Array([2, 100, 3, 2, 1, 255, 2, 1, 255]), 0, 9, dict);
       var predictor = new _stream.PredictorStream(input, 9, dict);
       var result = predictor.getBytes(6);
       expect(result).toMatchTypedArray(new Uint8Array([100, 3, 101, 2, 102, 1]));
       predictor.reset();
-      var clampedResult = predictor.getBytes(6, true);
+      const clampedResult = predictor.getBytes(6, true);
       expect(clampedResult).toEqual(new Uint8ClampedArray([100, 3, 101, 2, 102, 1]));
     });
   });

package/lib/test/unit/test_utils.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2019 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.
@@ -28,356 +28,190 @@ exports.buildGetDocumentParams = buildGetDocumentParams;
 exports.createIdFactory = createIdFactory;
 exports.TEST_PDFS_PATH = exports.XRefMock = exports.NodeCMapReaderFactory = exports.NodeCanvasFactory = exports.NodeFileReaderFactory = exports.DOMFileReaderFactory = void 0;
 
-var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
+var _util = require("../../shared/util.js");
 
-var _util = require("../../shared/util");
+var _is_node = require("../../shared/is_node.js");
 
-var _is_node = _interopRequireDefault(require("../../shared/is_node"));
+var _primitives = require("../../core/primitives.js");
 
-var _primitives = require("../../core/primitives");
+var _document = require("../../core/document.js");
 
-var _document = require("../../core/document");
+class DOMFileReaderFactory {
+  static async fetch(params) {
+    const response = await fetch(params.path);
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-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; }
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
 
-var DOMFileReaderFactory =
-/*#__PURE__*/
-function () {
-  function DOMFileReaderFactory() {
-    _classCallCheck(this, DOMFileReaderFactory);
+    return new Uint8Array((await response.arrayBuffer()));
   }
 
-  _createClass(DOMFileReaderFactory, null, [{
-    key: "fetch",
-    value: function (_fetch) {
-      function fetch(_x) {
-        return _fetch.apply(this, arguments);
-      }
-
-      fetch.toString = function () {
-        return _fetch.toString();
-      };
-
-      return fetch;
-    }(
-    /*#__PURE__*/
-    function () {
-      var _ref = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee(params) {
-        var response;
-        return _regenerator["default"].wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                _context.next = 2;
-                return fetch(params.path);
-
-              case 2:
-                response = _context.sent;
-
-                if (response.ok) {
-                  _context.next = 5;
-                  break;
-                }
-
-                throw new Error(response.statusText);
-
-              case 5:
-                _context.t0 = Uint8Array;
-                _context.next = 8;
-                return response.arrayBuffer();
-
-              case 8:
-                _context.t1 = _context.sent;
-                return _context.abrupt("return", new _context.t0(_context.t1));
-
-              case 10:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee);
-      }));
-
-      return function (_x2) {
-        return _ref.apply(this, arguments);
-      };
-    }())
-  }]);
-
-  return DOMFileReaderFactory;
-}();
+}
 
 exports.DOMFileReaderFactory = DOMFileReaderFactory;
 
-var NodeFileReaderFactory =
-/*#__PURE__*/
-function () {
-  function NodeFileReaderFactory() {
-    _classCallCheck(this, NodeFileReaderFactory);
-  }
+class NodeFileReaderFactory {
+  static async fetch(params) {
+    const fs = require("fs");
 
-  _createClass(NodeFileReaderFactory, null, [{
-    key: "fetch",
-    value: function () {
-      var _fetch2 = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee2(params) {
-        var fs;
-        return _regenerator["default"].wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                fs = require('fs');
-                return _context2.abrupt("return", new Promise(function (resolve, reject) {
-                  fs.readFile(params.path, function (error, data) {
-                    if (error || !data) {
-                      reject(error || new Error("Empty file for: ".concat(params.path)));
-                      return;
-                    }
-
-                    resolve(new Uint8Array(data));
-                  });
-                }));
-
-              case 2:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2);
-      }));
-
-      function fetch(_x3) {
-        return _fetch2.apply(this, arguments);
-      }
+    return new Promise((resolve, reject) => {
+      fs.readFile(params.path, (error, data) => {
+        if (error || !data) {
+          reject(error || new Error(`Empty file for: ${params.path}`));
+          return;
+        }
 
-      return fetch;
-    }()
-  }]);
+        resolve(new Uint8Array(data));
+      });
+    });
+  }
 
-  return NodeFileReaderFactory;
-}();
+}
 
 exports.NodeFileReaderFactory = NodeFileReaderFactory;
-var TEST_PDFS_PATH = {
-  dom: '../pdfs/',
-  node: './test/pdfs/'
+const TEST_PDFS_PATH = {
+  dom: "../pdfs/",
+  node: "./test/pdfs/"
 };
 exports.TEST_PDFS_PATH = TEST_PDFS_PATH;
 
 function buildGetDocumentParams(filename, options) {
-  var params = Object.create(null);
+  const params = Object.create(null);
 
-  if ((0, _is_node["default"])()) {
+  if (_is_node.isNodeJS) {
     params.url = TEST_PDFS_PATH.node + filename;
   } else {
     params.url = new URL(TEST_PDFS_PATH.dom + filename, window.location).href;
   }
 
-  for (var option in options) {
+  for (const option in options) {
     params[option] = options[option];
   }
 
   return params;
 }
 
-var NodeCanvasFactory =
-/*#__PURE__*/
-function () {
-  function NodeCanvasFactory() {
-    _classCallCheck(this, NodeCanvasFactory);
-  }
-
-  _createClass(NodeCanvasFactory, [{
-    key: "create",
-    value: function create(width, height) {
-      (0, _util.assert)(width > 0 && height > 0, 'Invalid canvas size');
+class NodeCanvasFactory {
+  create(width, height) {
+    (0, _util.assert)(width > 0 && height > 0, "Invalid canvas size");
 
-      var Canvas = require('canvas');
+    const Canvas = require("canvas");
 
-      var canvas = Canvas.createCanvas(width, height);
-      return {
-        canvas: canvas,
-        context: canvas.getContext('2d')
-      };
-    }
-  }, {
-    key: "reset",
-    value: function reset(canvasAndContext, width, height) {
-      (0, _util.assert)(canvasAndContext.canvas, 'Canvas is not specified');
-      (0, _util.assert)(width > 0 && height > 0, 'Invalid canvas size');
-      canvasAndContext.canvas.width = width;
-      canvasAndContext.canvas.height = height;
-    }
-  }, {
-    key: "destroy",
-    value: function destroy(canvasAndContext) {
-      (0, _util.assert)(canvasAndContext.canvas, 'Canvas is not specified');
-      canvasAndContext.canvas.width = 0;
-      canvasAndContext.canvas.height = 0;
-      canvasAndContext.canvas = null;
-      canvasAndContext.context = null;
-    }
-  }]);
+    const canvas = Canvas.createCanvas(width, height);
+    return {
+      canvas,
+      context: canvas.getContext("2d")
+    };
+  }
 
-  return NodeCanvasFactory;
-}();
+  reset(canvasAndContext, width, height) {
+    (0, _util.assert)(canvasAndContext.canvas, "Canvas is not specified");
+    (0, _util.assert)(width > 0 && height > 0, "Invalid canvas size");
+    canvasAndContext.canvas.width = width;
+    canvasAndContext.canvas.height = height;
+  }
 
-exports.NodeCanvasFactory = NodeCanvasFactory;
+  destroy(canvasAndContext) {
+    (0, _util.assert)(canvasAndContext.canvas, "Canvas is not specified");
+    canvasAndContext.canvas.width = 0;
+    canvasAndContext.canvas.height = 0;
+    canvasAndContext.canvas = null;
+    canvasAndContext.context = null;
+  }
 
-var NodeCMapReaderFactory =
-/*#__PURE__*/
-function () {
-  function NodeCMapReaderFactory(_ref2) {
-    var _ref2$baseUrl = _ref2.baseUrl,
-        baseUrl = _ref2$baseUrl === void 0 ? null : _ref2$baseUrl,
-        _ref2$isCompressed = _ref2.isCompressed,
-        isCompressed = _ref2$isCompressed === void 0 ? false : _ref2$isCompressed;
+}
 
-    _classCallCheck(this, NodeCMapReaderFactory);
+exports.NodeCanvasFactory = NodeCanvasFactory;
 
+class NodeCMapReaderFactory {
+  constructor({
+    baseUrl = null,
+    isCompressed = false
+  }) {
     this.baseUrl = baseUrl;
     this.isCompressed = isCompressed;
   }
 
-  _createClass(NodeCMapReaderFactory, [{
-    key: "fetch",
-    value: function () {
-      var _fetch3 = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee3(_ref3) {
-        var _this = this;
-
-        var name, url, compressionType;
-        return _regenerator["default"].wrap(function _callee3$(_context3) {
-          while (1) {
-            switch (_context3.prev = _context3.next) {
-              case 0:
-                name = _ref3.name;
-
-                if (this.baseUrl) {
-                  _context3.next = 3;
-                  break;
-                }
-
-                throw new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.');
-
-              case 3:
-                if (name) {
-                  _context3.next = 5;
-                  break;
-                }
-
-                throw new Error('CMap name must be specified.');
-
-              case 5:
-                url = this.baseUrl + name + (this.isCompressed ? '.bcmap' : '');
-                compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE;
-                return _context3.abrupt("return", new Promise(function (resolve, reject) {
-                  var fs = require('fs');
-
-                  fs.readFile(url, function (error, data) {
-                    if (error || !data) {
-                      reject(new Error(error));
-                      return;
-                    }
-
-                    resolve({
-                      cMapData: new Uint8Array(data),
-                      compressionType: compressionType
-                    });
-                  });
-                })["catch"](function (reason) {
-                  throw new Error("Unable to load ".concat(_this.isCompressed ? 'binary ' : '') + "CMap at: ".concat(url));
-                }));
-
-              case 8:
-              case "end":
-                return _context3.stop();
-            }
-          }
-        }, _callee3, this);
-      }));
-
-      function fetch(_x4) {
-        return _fetch3.apply(this, arguments);
-      }
+  async fetch({
+    name
+  }) {
+    if (!this.baseUrl) {
+      throw new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.');
+    }
 
-      return fetch;
-    }()
-  }]);
+    if (!name) {
+      throw new Error("CMap name must be specified.");
+    }
 
-  return NodeCMapReaderFactory;
-}();
+    const url = this.baseUrl + name + (this.isCompressed ? ".bcmap" : "");
+    const compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE;
+    return new Promise((resolve, reject) => {
+      const fs = require("fs");
+
+      fs.readFile(url, (error, data) => {
+        if (error || !data) {
+          reject(new Error(error));
+          return;
+        }
+
+        resolve({
+          cMapData: new Uint8Array(data),
+          compressionType
+        });
+      });
+    }).catch(reason => {
+      throw new Error(`Unable to load ${this.isCompressed ? "binary " : ""}` + `CMap at: ${url}`);
+    });
+  }
 
-exports.NodeCMapReaderFactory = NodeCMapReaderFactory;
+}
 
-var XRefMock =
-/*#__PURE__*/
-function () {
-  function XRefMock(array) {
-    _classCallCheck(this, XRefMock);
+exports.NodeCMapReaderFactory = NodeCMapReaderFactory;
 
+class XRefMock {
+  constructor(array) {
     this._map = Object.create(null);
 
-    for (var key in array) {
-      var obj = array[key];
+    for (const key in array) {
+      const obj = array[key];
       this._map[obj.ref.toString()] = obj.data;
     }
   }
 
-  _createClass(XRefMock, [{
-    key: "fetch",
-    value: function fetch(ref) {
-      return this._map[ref.toString()];
-    }
-  }, {
-    key: "fetchAsync",
-    value: function fetchAsync(ref) {
-      return Promise.resolve(this.fetch(ref));
-    }
-  }, {
-    key: "fetchIfRef",
-    value: function fetchIfRef(obj) {
-      if (!(0, _primitives.isRef)(obj)) {
-        return obj;
-      }
+  fetch(ref) {
+    return this._map[ref.toString()];
+  }
 
-      return this.fetch(obj);
-    }
-  }, {
-    key: "fetchIfRefAsync",
-    value: function fetchIfRefAsync(obj) {
-      return Promise.resolve(this.fetchIfRef(obj));
+  fetchAsync(ref) {
+    return Promise.resolve(this.fetch(ref));
+  }
+
+  fetchIfRef(obj) {
+    if (!(0, _primitives.isRef)(obj)) {
+      return obj;
     }
-  }]);
 
-  return XRefMock;
-}();
+    return this.fetch(obj);
+  }
+
+  fetchIfRefAsync(obj) {
+    return Promise.resolve(this.fetchIfRef(obj));
+  }
+
+}
 
 exports.XRefMock = XRefMock;
 
 function createIdFactory(pageIndex) {
-  var page = new _document.Page({
+  const page = new _document.Page({
     pdfManager: {
       get docId() {
-        return 'd0';
+        return "d0";
       }
 
     },
-    pageIndex: pageIndex
+    pageIndex
   });
   return page.idFactory;
 }

package/lib/test/unit/testreporter.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2019 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,13 +19,13 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
-var TestReporter = function TestReporter(browser, appPath) {
+var TestReporter = function (browser, appPath) {
   function send(action, json, cb) {
     var r = new XMLHttpRequest();
-    r.open('POST', action, true);
-    r.setRequestHeader('Content-Type', 'application/json');
+    r.open("POST", action, true);
+    r.setRequestHeader("Content-Type", "application/json");
 
     r.onreadystatechange = function sendTaskResultOnreadystatechange(e) {
       if (r.readyState === 4) {
@@ -39,31 +39,31 @@ var TestReporter = function TestReporter(browser, appPath) {
       }
     };
 
-    json['browser'] = browser;
+    json["browser"] = browser;
     r.send(JSON.stringify(json));
   }
 
   function sendInfo(message) {
-    send('/info', {
-      message: message
+    send("/info", {
+      message
     });
   }
 
   function sendResult(status, description, error) {
     var message = {
-      status: status,
-      description: description
+      status,
+      description
     };
 
-    if (typeof error !== 'undefined') {
-      message['error'] = error;
+    if (typeof error !== "undefined") {
+      message["error"] = error;
     }
 
-    send('/submit_task_results', message);
+    send("/submit_task_results", message);
   }
 
   function sendQuitRequest() {
-    send('/tellMeToQuit?path=' + escape(appPath), {});
+    send("/tellMeToQuit?path=" + escape(appPath), {});
   }
 
   this.now = function () {
@@ -72,7 +72,7 @@ var TestReporter = function TestReporter(browser, appPath) {
 
   this.jasmineStarted = function (suiteInfo) {
     this.runnerStartTime = this.now();
-    sendInfo('Started tests for ' + browser + '.');
+    sendInfo("Started tests for " + browser + ".");
   };
 
   this.suiteStarted = function (result) {};
@@ -81,16 +81,16 @@ var TestReporter = function TestReporter(browser, appPath) {
 
   this.specDone = function (result) {
     if (result.failedExpectations.length === 0) {
-      sendResult('TEST-PASSED', result.description);
+      sendResult("TEST-PASSED", result.description);
     } else {
-      var failedMessages = '';
+      var failedMessages = "";
       var items = result.failedExpectations;
 
       for (var i = 0, ii = items.length; i < ii; i++) {
-        failedMessages += items[i].message + ' ';
+        failedMessages += items[i].message + " ";
       }
 
-      sendResult('TEST-UNEXPECTED-FAIL', result.description, failedMessages);
+      sendResult("TEST-UNEXPECTED-FAIL", result.description, failedMessages);
     }
   };