pdfjs-dist 2.0.943 → 2.4.456

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 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,148 +19,199 @@
  * @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
 });
-exports.TEST_PDFS_PATH = exports.buildGetDocumentParams = exports.XRefMock = exports.NodeCMapReaderFactory = exports.NodeFileReaderFactory = undefined;
-
-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; }; }();
+exports.buildGetDocumentParams = buildGetDocumentParams;
+exports.createIdFactory = createIdFactory;
+exports.TEST_PDFS_PATH = exports.XRefMock = exports.NodeCMapReaderFactory = exports.NodeCanvasFactory = exports.NodeFileReaderFactory = exports.DOMFileReaderFactory = void 0;
 
-var _util = require('../../shared/util');
+var _util = require("../../shared/util.js");
 
-var _is_node = require('../../shared/is_node');
+var _is_node = require("../../shared/is_node.js");
 
-var _is_node2 = _interopRequireDefault(_is_node);
+var _primitives = require("../../core/primitives.js");
 
-var _primitives = require('../../core/primitives');
+var _document = require("../../core/document.js");
 
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class DOMFileReaderFactory {
+  static async fetch(params) {
+    const response = await fetch(params.path);
 
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+    if (!response.ok) {
+      throw new Error(response.statusText);
+    }
 
-var NodeFileReaderFactory = function () {
-  function NodeFileReaderFactory() {
-    _classCallCheck(this, NodeFileReaderFactory);
+    return new Uint8Array((await response.arrayBuffer()));
   }
 
-  _createClass(NodeFileReaderFactory, null, [{
-    key: 'fetch',
-    value: function fetch(params) {
-      var fs = require('fs');
-      var file = fs.readFileSync(params.path);
-      return new Uint8Array(file);
-    }
-  }]);
+}
+
+exports.DOMFileReaderFactory = DOMFileReaderFactory;
+
+class NodeFileReaderFactory {
+  static async fetch(params) {
+    const fs = require("fs");
 
-  return NodeFileReaderFactory;
-}();
+    return new Promise((resolve, reject) => {
+      fs.readFile(params.path, (error, data) => {
+        if (error || !data) {
+          reject(error || new Error(`Empty file for: ${params.path}`));
+          return;
+        }
 
-var TEST_PDFS_PATH = {
-  dom: '../pdfs/',
-  node: './test/pdfs/'
+        resolve(new Uint8Array(data));
+      });
+    });
+  }
+
+}
+
+exports.NodeFileReaderFactory = NodeFileReaderFactory;
+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);
-  if ((0, _is_node2.default)()) {
+  const params = Object.create(null);
+
+  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 NodeCMapReaderFactory = function () {
-  function NodeCMapReaderFactory(_ref) {
-    var _ref$baseUrl = _ref.baseUrl,
-        baseUrl = _ref$baseUrl === undefined ? null : _ref$baseUrl,
-        _ref$isCompressed = _ref.isCompressed,
-        isCompressed = _ref$isCompressed === undefined ? false : _ref$isCompressed;
+class NodeCanvasFactory {
+  create(width, height) {
+    (0, _util.assert)(width > 0 && height > 0, "Invalid canvas size");
+
+    const Canvas = require("canvas");
+
+    const canvas = Canvas.createCanvas(width, height);
+    return {
+      canvas,
+      context: canvas.getContext("2d")
+    };
+  }
+
+  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;
+  }
+
+  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;
+  }
 
-    _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 fetch(_ref2) {
-      var _this = this;
+  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.');
+    }
+
+    if (!name) {
+      throw new Error("CMap name must be specified.");
+    }
 
-      var name = _ref2.name;
+    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");
 
-      if (!this.baseUrl) {
-        return Promise.reject(new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.'));
-      }
-      if (!name) {
-        return Promise.reject(new Error('CMap name must be specified.'));
-      }
-      return new Promise(function (resolve, reject) {
-        var url = _this.baseUrl + name + (_this.isCompressed ? '.bcmap' : '');
-        var fs = require('fs');
-        fs.readFile(url, function (error, data) {
-          if (error || !data) {
-            reject(new Error('Unable to load ' + (_this.isCompressed ? 'binary ' : '') + 'CMap at: ' + url));
-            return;
-          }
-          resolve({
-            cMapData: new Uint8Array(data),
-            compressionType: _this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE
-          });
+      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}`);
+    });
+  }
 
-  return NodeCMapReaderFactory;
-}();
+}
 
-var XRefMock = 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;
-      }
-      return this.fetch(obj);
-    }
-  }, {
-    key: 'fetchIfRefAsync',
-    value: function fetchIfRefAsync(obj) {
-      return Promise.resolve(this.fetchIfRef(obj));
+  fetch(ref) {
+    return this._map[ref.toString()];
+  }
+
+  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.NodeFileReaderFactory = NodeFileReaderFactory;
-exports.NodeCMapReaderFactory = NodeCMapReaderFactory;
 exports.XRefMock = XRefMock;
-exports.buildGetDocumentParams = buildGetDocumentParams;
-exports.TEST_PDFS_PATH = TEST_PDFS_PATH;
+
+function createIdFactory(pageIndex) {
+  const page = new _document.Page({
+    pdfManager: {
+      get docId() {
+        return "d0";
+      }
+
+    },
+    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 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,13 +19,14 @@
  * @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) {
         if (r.status !== 200) {
@@ -37,47 +38,64 @@ 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 () {
     return new Date().getTime();
   };
+
   this.jasmineStarted = function (suiteInfo) {
     this.runnerStartTime = this.now();
-    sendInfo('Started tests for ' + browser + '.');
+    sendInfo("Started tests for " + browser + ".");
   };
+
   this.suiteStarted = function (result) {};
+
   this.specStarted = function (result) {};
+
   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);
     }
   };
+
   this.suiteDone = function (result) {};
+
   this.jasmineDone = function () {
     setTimeout(sendQuitRequest, 500);
   };

package/lib/test/unit/type1_parser_spec.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,84 +19,86 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
-var _fonts = require('../../core/fonts');
+var _fonts = require("../../core/fonts.js");
 
-var _stream = require('../../core/stream');
+var _stream = require("../../core/stream.js");
 
-var _type1_parser = require('../../core/type1_parser');
+var _type1_parser = require("../../core/type1_parser.js");
 
-describe('Type1Parser', function () {
-  it('splits tokens', function () {
-    var stream = new _stream.StringStream('/BlueValues[-17 0]noaccess def');
+describe("Type1Parser", function () {
+  it("splits tokens", function () {
+    var stream = new _stream.StringStream("/BlueValues[-17 0]noaccess def");
     var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
-    expect(parser.getToken()).toEqual('/');
-    expect(parser.getToken()).toEqual('BlueValues');
-    expect(parser.getToken()).toEqual('[');
-    expect(parser.getToken()).toEqual('-17');
-    expect(parser.getToken()).toEqual('0');
-    expect(parser.getToken()).toEqual(']');
-    expect(parser.getToken()).toEqual('noaccess');
-    expect(parser.getToken()).toEqual('def');
+    expect(parser.getToken()).toEqual("/");
+    expect(parser.getToken()).toEqual("BlueValues");
+    expect(parser.getToken()).toEqual("[");
+    expect(parser.getToken()).toEqual("-17");
+    expect(parser.getToken()).toEqual("0");
+    expect(parser.getToken()).toEqual("]");
+    expect(parser.getToken()).toEqual("noaccess");
+    expect(parser.getToken()).toEqual("def");
     expect(parser.getToken()).toEqual(null);
   });
-  it('handles glued tokens', function () {
-    var stream = new _stream.StringStream('dup/CharStrings');
+  it("handles glued tokens", function () {
+    var stream = new _stream.StringStream("dup/CharStrings");
     var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
-    expect(parser.getToken()).toEqual('dup');
-    expect(parser.getToken()).toEqual('/');
-    expect(parser.getToken()).toEqual('CharStrings');
+    expect(parser.getToken()).toEqual("dup");
+    expect(parser.getToken()).toEqual("/");
+    expect(parser.getToken()).toEqual("CharStrings");
   });
-  it('ignores whitespace', function () {
-    var stream = new _stream.StringStream('\nab   c\t');
+  it("ignores whitespace", function () {
+    var stream = new _stream.StringStream("\nab   c\t");
     var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
-    expect(parser.getToken()).toEqual('ab');
-    expect(parser.getToken()).toEqual('c');
+    expect(parser.getToken()).toEqual("ab");
+    expect(parser.getToken()).toEqual("c");
   });
-  it('parses numbers', function () {
-    var stream = new _stream.StringStream('123');
+  it("parses numbers", function () {
+    var stream = new _stream.StringStream("123");
     var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
     expect(parser.readNumber()).toEqual(123);
   });
-  it('parses booleans', function () {
-    var stream = new _stream.StringStream('true false');
+  it("parses booleans", function () {
+    var stream = new _stream.StringStream("true false");
     var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
     expect(parser.readBoolean()).toEqual(1);
     expect(parser.readBoolean()).toEqual(0);
   });
-  it('parses number arrays', function () {
-    var stream = new _stream.StringStream('[1 2]');
+  it("parses number arrays", function () {
+    var stream = new _stream.StringStream("[1 2]");
     var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
     expect(parser.readNumberArray()).toEqual([1, 2]);
-    stream = new _stream.StringStream('[ 1 2 ]');
+    stream = new _stream.StringStream("[ 1 2 ]");
     parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
     expect(parser.readNumberArray()).toEqual([1, 2]);
   });
-  it('skips comments', function () {
-    var stream = new _stream.StringStream('%!PS-AdobeFont-1.0: CMSY10 003.002\n' + '%%Title: CMSY10\n' + '%Version: 003.002\n' + 'FontDirectory');
+  it("skips comments", function () {
+    var stream = new _stream.StringStream("%!PS-AdobeFont-1.0: CMSY10 003.002\n" + "%%Title: CMSY10\n" + "%Version: 003.002\n" + "FontDirectory");
     var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
-    expect(parser.getToken()).toEqual('FontDirectory');
+    expect(parser.getToken()).toEqual("FontDirectory");
   });
-  it('parses font program', function () {
-    var stream = new _stream.StringStream('/ExpansionFactor  99\n' + '/Subrs 1 array\n' + 'dup 0 1 RD x noaccess put\n' + 'end\n' + '/CharStrings 46 dict dup begin\n' + '/.notdef 1 RD x ND\n' + 'end');
+  it("parses font program", function () {
+    var stream = new _stream.StringStream("/ExpansionFactor  99\n" + "/Subrs 1 array\n" + "dup 0 1 RD x noaccess put\n" + "end\n" + "/CharStrings 46 dict dup begin\n" + "/.notdef 1 RD x ND\n" + "end");
     var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
-    var program = parser.extractFontProgram();
+    var program = parser.extractFontProgram({});
     expect(program.charstrings.length).toEqual(1);
     expect(program.properties.privateData.ExpansionFactor).toEqual(99);
   });
-  it('parses font header font matrix', function () {
-    var stream = new _stream.StringStream('/FontMatrix [0.001 0 0 0.001 0 0 ]readonly def\n');
+  it("parses font header font matrix", function () {
+    var stream = new _stream.StringStream("/FontMatrix [0.001 0 0 0.001 0 0 ]readonly def\n");
     var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
     var props = {};
     parser.extractFontHeader(props);
     expect(props.fontMatrix).toEqual([0.001, 0, 0, 0.001, 0, 0]);
   });
-  it('parses font header encoding', function () {
-    var stream = new _stream.StringStream('/Encoding 256 array\n' + '0 1 255 {1 index exch /.notdef put} for\n' + 'dup 33 /arrowright put\n' + 'readonly def\n');
+  it("parses font header encoding", function () {
+    var stream = new _stream.StringStream("/Encoding 256 array\n" + "0 1 255 {1 index exch /.notdef put} for\n" + "dup 33 /arrowright put\n" + "readonly def\n");
     var parser = new _type1_parser.Type1Parser(stream, false, _fonts.SEAC_ANALYSIS_ENABLED);
-    var props = { overridableEncoding: true };
+    var props = {
+      overridableEncoding: true
+    };
     parser.extractFontHeader(props);
-    expect(props.builtInEncoding[33]).toEqual('arrowright');
+    expect(props.builtInEncoding[33]).toEqual("arrowright");
   });
 });