pdfjs-dist 2.0.943 → 2.4.456

package/lib/test/unit/primitives_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,114 +19,130 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
-var _primitives = require('../../core/primitives');
+var _primitives = require("../../core/primitives.js");
 
-var _test_utils = require('./test_utils');
+var _test_utils = require("./test_utils.js");
+
+describe("primitives", function () {
+  describe("Name", function () {
+    it("should retain the given name", function () {
+      var givenName = "Font";
 
-describe('primitives', function () {
-  describe('Name', function () {
-    it('should retain the given name', function () {
-      var givenName = 'Font';
       var name = _primitives.Name.get(givenName);
+
       expect(name.name).toEqual(givenName);
     });
-    it('should create only one object for a name and cache it', function () {
-      var firstFont = _primitives.Name.get('Font');
-      var secondFont = _primitives.Name.get('Font');
-      var firstSubtype = _primitives.Name.get('Subtype');
-      var secondSubtype = _primitives.Name.get('Subtype');
+    it("should create only one object for a name and cache it", function () {
+      var firstFont = _primitives.Name.get("Font");
+
+      var secondFont = _primitives.Name.get("Font");
+
+      var firstSubtype = _primitives.Name.get("Subtype");
+
+      var secondSubtype = _primitives.Name.get("Subtype");
+
       expect(firstFont).toBe(secondFont);
       expect(firstSubtype).toBe(secondSubtype);
       expect(firstFont).not.toBe(firstSubtype);
     });
   });
-  describe('Cmd', function () {
-    it('should retain the given cmd name', function () {
-      var givenCmd = 'BT';
+  describe("Cmd", function () {
+    it("should retain the given cmd name", function () {
+      var givenCmd = "BT";
+
       var cmd = _primitives.Cmd.get(givenCmd);
+
       expect(cmd.cmd).toEqual(givenCmd);
     });
-    it('should create only one object for a command and cache it', function () {
-      var firstBT = _primitives.Cmd.get('BT');
-      var secondBT = _primitives.Cmd.get('BT');
-      var firstET = _primitives.Cmd.get('ET');
-      var secondET = _primitives.Cmd.get('ET');
+    it("should create only one object for a command and cache it", function () {
+      var firstBT = _primitives.Cmd.get("BT");
+
+      var secondBT = _primitives.Cmd.get("BT");
+
+      var firstET = _primitives.Cmd.get("ET");
+
+      var secondET = _primitives.Cmd.get("ET");
+
       expect(firstBT).toBe(secondBT);
       expect(firstET).toBe(secondET);
       expect(firstBT).not.toBe(firstET);
     });
   });
-  describe('Dict', function () {
-    var checkInvalidHasValues = function checkInvalidHasValues(dict) {
+  describe("Dict", function () {
+    var checkInvalidHasValues = function (dict) {
       expect(dict.has()).toBeFalsy();
-      expect(dict.has('Prev')).toBeFalsy();
+      expect(dict.has("Prev")).toBeFalsy();
     };
-    var checkInvalidKeyValues = function checkInvalidKeyValues(dict) {
+
+    var checkInvalidKeyValues = function (dict) {
       expect(dict.get()).toBeUndefined();
-      expect(dict.get('Prev')).toBeUndefined();
-      expect(dict.get('Decode', 'D')).toBeUndefined();
-      expect(dict.get('FontFile', 'FontFile2', 'FontFile3')).toBeNull();
+      expect(dict.get("Prev")).toBeUndefined();
+      expect(dict.get("Decode", "D")).toBeUndefined();
+      expect(dict.get("FontFile", "FontFile2", "FontFile3")).toBeUndefined();
     };
+
     var emptyDict, dictWithSizeKey, dictWithManyKeys;
     var storedSize = 42;
-    var testFontFile = 'file1';
-    var testFontFile2 = 'file2';
-    var testFontFile3 = 'file3';
+    var testFontFile = "file1";
+    var testFontFile2 = "file2";
+    var testFontFile3 = "file3";
     beforeAll(function (done) {
       emptyDict = new _primitives.Dict();
       dictWithSizeKey = new _primitives.Dict();
-      dictWithSizeKey.set('Size', storedSize);
+      dictWithSizeKey.set("Size", storedSize);
       dictWithManyKeys = new _primitives.Dict();
-      dictWithManyKeys.set('FontFile', testFontFile);
-      dictWithManyKeys.set('FontFile2', testFontFile2);
-      dictWithManyKeys.set('FontFile3', testFontFile3);
+      dictWithManyKeys.set("FontFile", testFontFile);
+      dictWithManyKeys.set("FontFile2", testFontFile2);
+      dictWithManyKeys.set("FontFile3", testFontFile3);
       done();
     });
     afterAll(function () {
       emptyDict = dictWithSizeKey = dictWithManyKeys = null;
     });
-    it('should return invalid values for unknown keys', function () {
+    it("should return invalid values for unknown keys", function () {
       checkInvalidHasValues(emptyDict);
       checkInvalidKeyValues(emptyDict);
     });
-    it('should return correct value for stored Size key', function () {
-      expect(dictWithSizeKey.has('Size')).toBeTruthy();
-      expect(dictWithSizeKey.get('Size')).toEqual(storedSize);
-      expect(dictWithSizeKey.get('Prev', 'Size')).toEqual(storedSize);
-      expect(dictWithSizeKey.get('Prev', 'Root', 'Size')).toEqual(storedSize);
+    it("should return correct value for stored Size key", function () {
+      expect(dictWithSizeKey.has("Size")).toBeTruthy();
+      expect(dictWithSizeKey.get("Size")).toEqual(storedSize);
+      expect(dictWithSizeKey.get("Prev", "Size")).toEqual(storedSize);
+      expect(dictWithSizeKey.get("Prev", "Root", "Size")).toEqual(storedSize);
     });
-    it('should return invalid values for unknown keys when Size key is stored', function () {
+    it("should return invalid values for unknown keys when Size key is stored", function () {
       checkInvalidHasValues(dictWithSizeKey);
       checkInvalidKeyValues(dictWithSizeKey);
     });
-    it('should return correct value for stored Size key with undefined value', function () {
-      var dict = new _primitives.Dict();
-      dict.set('Size');
-      expect(dict.has('Size')).toBeTruthy();
+    it("should not accept to set a key with an undefined value", function () {
+      const dict = new _primitives.Dict();
+      expect(function () {
+        dict.set("Size");
+      }).toThrow(new Error('Dict.set: The "value" cannot be undefined.'));
+      expect(dict.has("Size")).toBeFalsy();
       checkInvalidKeyValues(dict);
     });
-    it('should return correct values for multiple stored keys', function () {
-      expect(dictWithManyKeys.has('FontFile')).toBeTruthy();
-      expect(dictWithManyKeys.has('FontFile2')).toBeTruthy();
-      expect(dictWithManyKeys.has('FontFile3')).toBeTruthy();
-      expect(dictWithManyKeys.get('FontFile3')).toEqual(testFontFile3);
-      expect(dictWithManyKeys.get('FontFile2', 'FontFile3')).toEqual(testFontFile2);
-      expect(dictWithManyKeys.get('FontFile', 'FontFile2', 'FontFile3')).toEqual(testFontFile);
+    it("should return correct values for multiple stored keys", function () {
+      expect(dictWithManyKeys.has("FontFile")).toBeTruthy();
+      expect(dictWithManyKeys.has("FontFile2")).toBeTruthy();
+      expect(dictWithManyKeys.has("FontFile3")).toBeTruthy();
+      expect(dictWithManyKeys.get("FontFile3")).toEqual(testFontFile3);
+      expect(dictWithManyKeys.get("FontFile2", "FontFile3")).toEqual(testFontFile2);
+      expect(dictWithManyKeys.get("FontFile", "FontFile2", "FontFile3")).toEqual(testFontFile);
     });
-    it('should asynchronously fetch unknown keys', function (done) {
-      var keyPromises = [dictWithManyKeys.getAsync('Size'), dictWithSizeKey.getAsync('FontFile', 'FontFile2', 'FontFile3')];
+    it("should asynchronously fetch unknown keys", function (done) {
+      var keyPromises = [dictWithManyKeys.getAsync("Size"), dictWithSizeKey.getAsync("FontFile", "FontFile2", "FontFile3")];
       Promise.all(keyPromises).then(function (values) {
         expect(values[0]).toBeUndefined();
-        expect(values[1]).toBeNull();
+        expect(values[1]).toBeUndefined();
         done();
       }).catch(function (reason) {
         done.fail(reason);
       });
     });
-    it('should asynchronously fetch correct values for multiple stored keys', function (done) {
-      var keyPromises = [dictWithManyKeys.getAsync('FontFile3'), dictWithManyKeys.getAsync('FontFile2', 'FontFile3'), dictWithManyKeys.getAsync('FontFile', 'FontFile2', 'FontFile3')];
+    it("should asynchronously fetch correct values for multiple stored keys", function (done) {
+      var keyPromises = [dictWithManyKeys.getAsync("FontFile3"), dictWithManyKeys.getAsync("FontFile2", "FontFile3"), dictWithManyKeys.getAsync("FontFile", "FontFile2", "FontFile3")];
       Promise.all(keyPromises).then(function (values) {
         expect(values[0]).toEqual(testFontFile3);
         expect(values[1]).toEqual(testFontFile2);
@@ -136,36 +152,38 @@ describe('primitives', function () {
         done.fail(reason);
       });
     });
-    it('should callback for each stored key', function () {
-      var callbackSpy = jasmine.createSpy('spy on callback in dictionary');
+    it("should callback for each stored key", function () {
+      var callbackSpy = jasmine.createSpy("spy on callback in dictionary");
       dictWithManyKeys.forEach(callbackSpy);
       expect(callbackSpy).toHaveBeenCalled();
       var callbackSpyCalls = callbackSpy.calls;
-      expect(callbackSpyCalls.argsFor(0)).toEqual(['FontFile', testFontFile]);
-      expect(callbackSpyCalls.argsFor(1)).toEqual(['FontFile2', testFontFile2]);
-      expect(callbackSpyCalls.argsFor(2)).toEqual(['FontFile3', testFontFile3]);
+      expect(callbackSpyCalls.argsFor(0)).toEqual(["FontFile", testFontFile]);
+      expect(callbackSpyCalls.argsFor(1)).toEqual(["FontFile2", testFontFile2]);
+      expect(callbackSpyCalls.argsFor(2)).toEqual(["FontFile3", testFontFile3]);
       expect(callbackSpyCalls.count()).toEqual(3);
     });
-    it('should handle keys pointing to indirect objects, both sync and async', function (done) {
-      var fontRef = new _primitives.Ref(1, 0);
+    it("should handle keys pointing to indirect objects, both sync and async", function (done) {
+      var fontRef = _primitives.Ref.get(1, 0);
+
       var xref = new _test_utils.XRefMock([{
         ref: fontRef,
         data: testFontFile
       }]);
       var fontDict = new _primitives.Dict(xref);
-      fontDict.set('FontFile', fontRef);
-      expect(fontDict.getRaw('FontFile')).toEqual(fontRef);
-      expect(fontDict.get('FontFile', 'FontFile2', 'FontFile3')).toEqual(testFontFile);
-      fontDict.getAsync('FontFile', 'FontFile2', 'FontFile3').then(function (value) {
+      fontDict.set("FontFile", fontRef);
+      expect(fontDict.getRaw("FontFile")).toEqual(fontRef);
+      expect(fontDict.get("FontFile", "FontFile2", "FontFile3")).toEqual(testFontFile);
+      fontDict.getAsync("FontFile", "FontFile2", "FontFile3").then(function (value) {
         expect(value).toEqual(testFontFile);
         done();
       }).catch(function (reason) {
         done.fail(reason);
       });
     });
-    it('should handle arrays containing indirect objects', function () {
-      var minCoordRef = new _primitives.Ref(1, 0),
-          maxCoordRef = new _primitives.Ref(2, 0);
+    it("should handle arrays containing indirect objects", function () {
+      var minCoordRef = _primitives.Ref.get(1, 0),
+          maxCoordRef = _primitives.Ref.get(2, 0);
+
       var minCoord = 0,
           maxCoord = 1;
       var xref = new _test_utils.XRefMock([{
@@ -176,122 +194,139 @@ describe('primitives', function () {
         data: maxCoord
       }]);
       var xObjectDict = new _primitives.Dict(xref);
-      xObjectDict.set('BBox', [minCoord, maxCoord, minCoordRef, maxCoordRef]);
-      expect(xObjectDict.get('BBox')).toEqual([minCoord, maxCoord, minCoordRef, maxCoordRef]);
-      expect(xObjectDict.getArray('BBox')).toEqual([minCoord, maxCoord, minCoord, maxCoord]);
+      xObjectDict.set("BBox", [minCoord, maxCoord, minCoordRef, maxCoordRef]);
+      expect(xObjectDict.get("BBox")).toEqual([minCoord, maxCoord, minCoordRef, maxCoordRef]);
+      expect(xObjectDict.getArray("BBox")).toEqual([minCoord, maxCoord, minCoord, maxCoord]);
     });
-    it('should get all key names', function () {
-      var expectedKeys = ['FontFile', 'FontFile2', 'FontFile3'];
+    it("should get all key names", function () {
+      var expectedKeys = ["FontFile", "FontFile2", "FontFile3"];
       var keys = dictWithManyKeys.getKeys();
       expect(keys.sort()).toEqual(expectedKeys);
     });
-    it('should create only one object for Dict.empty', function () {
+    it("should create only one object for Dict.empty", function () {
       var firstDictEmpty = _primitives.Dict.empty;
       var secondDictEmpty = _primitives.Dict.empty;
       expect(firstDictEmpty).toBe(secondDictEmpty);
       expect(firstDictEmpty).not.toBe(emptyDict);
     });
-    it('should correctly merge dictionaries', function () {
-      var expectedKeys = ['FontFile', 'FontFile2', 'FontFile3', 'Size'];
+    it("should correctly merge dictionaries", function () {
+      var expectedKeys = ["FontFile", "FontFile2", "FontFile3", "Size"];
       var fontFileDict = new _primitives.Dict();
-      fontFileDict.set('FontFile', 'Type1 font file');
+      fontFileDict.set("FontFile", "Type1 font file");
+
       var mergedDict = _primitives.Dict.merge(null, [dictWithManyKeys, dictWithSizeKey, fontFileDict]);
+
       var mergedKeys = mergedDict.getKeys();
       expect(mergedKeys.sort()).toEqual(expectedKeys);
-      expect(mergedDict.get('FontFile')).toEqual(testFontFile);
+      expect(mergedDict.get("FontFile")).toEqual(testFontFile);
     });
   });
-  describe('Ref', function () {
-    it('should retain the stored values', function () {
+  describe("Ref", function () {
+    it("should retain the stored values", function () {
       var storedNum = 4;
       var storedGen = 2;
-      var ref = new _primitives.Ref(storedNum, storedGen);
+
+      var ref = _primitives.Ref.get(storedNum, storedGen);
+
       expect(ref.num).toEqual(storedNum);
       expect(ref.gen).toEqual(storedGen);
     });
   });
-  describe('RefSet', function () {
-    it('should have a stored value', function () {
-      var ref = new _primitives.Ref(4, 2);
+  describe("RefSet", function () {
+    it("should have a stored value", function () {
+      var ref = _primitives.Ref.get(4, 2);
+
       var refset = new _primitives.RefSet();
       refset.put(ref);
       expect(refset.has(ref)).toBeTruthy();
     });
-    it('should not have an unknown value', function () {
-      var ref = new _primitives.Ref(4, 2);
+    it("should not have an unknown value", function () {
+      var ref = _primitives.Ref.get(4, 2);
+
       var refset = new _primitives.RefSet();
       expect(refset.has(ref)).toBeFalsy();
       refset.put(ref);
-      var anotherRef = new _primitives.Ref(2, 4);
+
+      var anotherRef = _primitives.Ref.get(2, 4);
+
       expect(refset.has(anotherRef)).toBeFalsy();
     });
   });
-  describe('isName', function () {
-    it('handles non-names', function () {
+  describe("isName", function () {
+    it("handles non-names", function () {
       var nonName = {};
       expect((0, _primitives.isName)(nonName)).toEqual(false);
     });
-    it('handles names', function () {
-      var name = _primitives.Name.get('Font');
+    it("handles names", function () {
+      var name = _primitives.Name.get("Font");
+
       expect((0, _primitives.isName)(name)).toEqual(true);
     });
-    it('handles names with name check', function () {
-      var name = _primitives.Name.get('Font');
-      expect((0, _primitives.isName)(name, 'Font')).toEqual(true);
-      expect((0, _primitives.isName)(name, 'Subtype')).toEqual(false);
+    it("handles names with name check", function () {
+      var name = _primitives.Name.get("Font");
+
+      expect((0, _primitives.isName)(name, "Font")).toEqual(true);
+      expect((0, _primitives.isName)(name, "Subtype")).toEqual(false);
     });
   });
-  describe('isCmd', function () {
-    it('handles non-commands', function () {
+  describe("isCmd", function () {
+    it("handles non-commands", function () {
       var nonCmd = {};
       expect((0, _primitives.isCmd)(nonCmd)).toEqual(false);
     });
-    it('handles commands', function () {
-      var cmd = _primitives.Cmd.get('BT');
+    it("handles commands", function () {
+      var cmd = _primitives.Cmd.get("BT");
+
       expect((0, _primitives.isCmd)(cmd)).toEqual(true);
     });
-    it('handles commands with cmd check', function () {
-      var cmd = _primitives.Cmd.get('BT');
-      expect((0, _primitives.isCmd)(cmd, 'BT')).toEqual(true);
-      expect((0, _primitives.isCmd)(cmd, 'ET')).toEqual(false);
+    it("handles commands with cmd check", function () {
+      var cmd = _primitives.Cmd.get("BT");
+
+      expect((0, _primitives.isCmd)(cmd, "BT")).toEqual(true);
+      expect((0, _primitives.isCmd)(cmd, "ET")).toEqual(false);
     });
   });
-  describe('isDict', function () {
-    it('handles non-dictionaries', function () {
+  describe("isDict", function () {
+    it("handles non-dictionaries", function () {
       var nonDict = {};
       expect((0, _primitives.isDict)(nonDict)).toEqual(false);
     });
-    it('handles empty dictionaries with type check', function () {
+    it("handles empty dictionaries with type check", function () {
       var dict = _primitives.Dict.empty;
       expect((0, _primitives.isDict)(dict)).toEqual(true);
-      expect((0, _primitives.isDict)(dict, 'Page')).toEqual(false);
+      expect((0, _primitives.isDict)(dict, "Page")).toEqual(false);
     });
-    it('handles dictionaries with type check', function () {
+    it("handles dictionaries with type check", function () {
       var dict = new _primitives.Dict();
-      dict.set('Type', _primitives.Name.get('Page'));
-      expect((0, _primitives.isDict)(dict, 'Page')).toEqual(true);
-      expect((0, _primitives.isDict)(dict, 'Contents')).toEqual(false);
+      dict.set("Type", _primitives.Name.get("Page"));
+      expect((0, _primitives.isDict)(dict, "Page")).toEqual(true);
+      expect((0, _primitives.isDict)(dict, "Contents")).toEqual(false);
     });
   });
-  describe('isRef', function () {
-    it('handles non-refs', function () {
+  describe("isRef", function () {
+    it("handles non-refs", function () {
       var nonRef = {};
       expect((0, _primitives.isRef)(nonRef)).toEqual(false);
     });
-    it('handles refs', function () {
-      var ref = new _primitives.Ref(1, 0);
+    it("handles refs", function () {
+      var ref = _primitives.Ref.get(1, 0);
+
       expect((0, _primitives.isRef)(ref)).toEqual(true);
     });
   });
-  describe('isRefsEqual', function () {
-    it('should handle different Refs pointing to the same object', function () {
-      var ref1 = new _primitives.Ref(1, 0);
-      var ref2 = new _primitives.Ref(1, 0);
+  describe("isRefsEqual", function () {
+    it("should handle Refs pointing to the same object", function () {
+      var ref1 = _primitives.Ref.get(1, 0);
+
+      var ref2 = _primitives.Ref.get(1, 0);
+
       expect((0, _primitives.isRefsEqual)(ref1, ref2)).toEqual(true);
     });
-    it('should handle Refs pointing to different objects', function () {
-      var ref1 = new _primitives.Ref(1, 0);
-      var ref2 = new _primitives.Ref(2, 0);
+    it("should handle Refs pointing to different objects", function () {
+      var ref1 = _primitives.Ref.get(1, 0);
+
+      var ref2 = _primitives.Ref.get(2, 0);
+
       expect((0, _primitives.isRefsEqual)(ref1, ref2)).toEqual(false);
     });
   });

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 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,52 +19,59 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"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;
             }
+
             result.pass = true;
+
             for (var i = 0, ii = expected.length; i < ii; i++) {
               var a = actual[i],
                   b = expected[i];
+
               if (a !== b) {
                 result.pass = false;
                 break;
               }
             }
+
             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]));
     });
   });