pdfjs-dist 2.0.489 → 2.2.228

package/lib/test/unit/colorspace_spec.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2017 Mozilla Foundation
+ * Copyright 2019 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,17 +19,17 @@
  * @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");
 
-var _stream = require('../../core/stream');
+var _stream = require("../../core/stream");
 
-var _colorspace = require('../../core/colorspace');
+var _colorspace = require("../../core/colorspace");
 
-var _function = require('../../core/function');
+var _function = require("../../core/function");
 
-var _test_utils = require('./test_utils');
+var _test_utils = require("./test_utils");
 
 describe('colorspace', function () {
   describe('ColorSpace', function () {
@@ -53,36 +53,46 @@ describe('colorspace', function () {
   describe('DeviceGrayCS', function () {
     it('should handle the case when cs is a Name object', function () {
       var cs = _primitives.Name.get('DeviceGray');
+
       var xref = new _test_utils.XRefMock([{
-        ref: new _primitives.Ref(10, 0),
+        ref: _primitives.Ref.get(10, 0),
         data: new _primitives.Dict()
       }]);
       var res = new _primitives.Dict();
-      var pdfFunctionFactory = new _function.PDFFunctionFactory({ xref: xref });
+      var pdfFunctionFactory = new _function.PDFFunctionFactory({
+        xref: xref
+      });
+
       var colorSpace = _colorspace.ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
+
       var testSrc = new Uint8Array([27, 125, 250, 131]);
-      var testDest = new Uint8Array(4 * 4 * 3);
-      var expectedDest = new Uint8Array([27, 27, 27, 27, 27, 27, 125, 125, 125, 125, 125, 125, 27, 27, 27, 27, 27, 27, 125, 125, 125, 125, 125, 125, 250, 250, 250, 250, 250, 250, 131, 131, 131, 131, 131, 131, 250, 250, 250, 250, 250, 250, 131, 131, 131, 131, 131, 131]);
+      var testDest = new Uint8ClampedArray(4 * 4 * 3);
+      var expectedDest = new Uint8ClampedArray([27, 27, 27, 27, 27, 27, 125, 125, 125, 125, 125, 125, 27, 27, 27, 27, 27, 27, 125, 125, 125, 125, 125, 125, 250, 250, 250, 250, 250, 250, 131, 131, 131, 131, 131, 131, 250, 250, 250, 250, 250, 250, 131, 131, 131, 131, 131, 131]);
       colorSpace.fillRgb(testDest, 2, 2, 4, 4, 4, 8, testSrc, 0);
-      expect(colorSpace.getRgb(new Float32Array([0.1]), 0)).toEqual(new Uint8Array([25, 25, 25]));
+      expect(colorSpace.getRgb(new Float32Array([0.1]), 0)).toEqual(new Uint8ClampedArray([26, 26, 26]));
       expect(colorSpace.getOutputLength(2, 0)).toEqual(6);
       expect(colorSpace.isPassthrough(8)).toBeFalsy();
       expect(testDest).toEqual(expectedDest);
     });
     it('should handle the case when cs is an indirect object', function () {
-      var cs = new _primitives.Ref(10, 0);
+      var cs = _primitives.Ref.get(10, 0);
+
       var xref = new _test_utils.XRefMock([{
         ref: cs,
         data: _primitives.Name.get('DeviceGray')
       }]);
       var res = new _primitives.Dict();
-      var pdfFunctionFactory = new _function.PDFFunctionFactory({ xref: xref });
+      var pdfFunctionFactory = new _function.PDFFunctionFactory({
+        xref: xref
+      });
+
       var colorSpace = _colorspace.ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
+
       var testSrc = new Uint8Array([27, 125, 250, 131]);
-      var testDest = new Uint8Array(3 * 3 * 3);
-      var expectedDest = new Uint8Array([27, 27, 27, 27, 27, 27, 125, 125, 125, 27, 27, 27, 27, 27, 27, 125, 125, 125, 250, 250, 250, 250, 250, 250, 131, 131, 131]);
+      var testDest = new Uint8ClampedArray(3 * 3 * 3);
+      var expectedDest = new Uint8ClampedArray([27, 27, 27, 27, 27, 27, 125, 125, 125, 27, 27, 27, 27, 27, 27, 125, 125, 125, 250, 250, 250, 250, 250, 250, 131, 131, 131]);
       colorSpace.fillRgb(testDest, 2, 2, 3, 3, 3, 8, testSrc, 0);
-      expect(colorSpace.getRgb(new Float32Array([0.2]), 0)).toEqual(new Uint8Array([51, 51, 51]));
+      expect(colorSpace.getRgb(new Float32Array([0.2]), 0)).toEqual(new Uint8ClampedArray([51, 51, 51]));
       expect(colorSpace.getOutputLength(3, 1)).toEqual(12);
       expect(colorSpace.isPassthrough(8)).toBeFalsy();
       expect(testDest).toEqual(expectedDest);
@@ -91,36 +101,46 @@ describe('colorspace', function () {
   describe('DeviceRgbCS', function () {
     it('should handle the case when cs is a Name object', function () {
       var cs = _primitives.Name.get('DeviceRGB');
+
       var xref = new _test_utils.XRefMock([{
-        ref: new _primitives.Ref(10, 0),
+        ref: _primitives.Ref.get(10, 0),
         data: new _primitives.Dict()
       }]);
       var res = new _primitives.Dict();
-      var pdfFunctionFactory = new _function.PDFFunctionFactory({ xref: xref });
+      var pdfFunctionFactory = new _function.PDFFunctionFactory({
+        xref: xref
+      });
+
       var colorSpace = _colorspace.ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
+
       var testSrc = new Uint8Array([27, 125, 250, 131, 139, 140, 111, 25, 198, 21, 147, 255]);
-      var testDest = new Uint8Array(4 * 4 * 3);
-      var expectedDest = new Uint8Array([27, 125, 250, 27, 125, 250, 131, 139, 140, 131, 139, 140, 27, 125, 250, 27, 125, 250, 131, 139, 140, 131, 139, 140, 111, 25, 198, 111, 25, 198, 21, 147, 255, 21, 147, 255, 111, 25, 198, 111, 25, 198, 21, 147, 255, 21, 147, 255]);
+      var testDest = new Uint8ClampedArray(4 * 4 * 3);
+      var expectedDest = new Uint8ClampedArray([27, 125, 250, 27, 125, 250, 131, 139, 140, 131, 139, 140, 27, 125, 250, 27, 125, 250, 131, 139, 140, 131, 139, 140, 111, 25, 198, 111, 25, 198, 21, 147, 255, 21, 147, 255, 111, 25, 198, 111, 25, 198, 21, 147, 255, 21, 147, 255]);
       colorSpace.fillRgb(testDest, 2, 2, 4, 4, 4, 8, testSrc, 0);
-      expect(colorSpace.getRgb(new Float32Array([0.1, 0.2, 0.3]), 0)).toEqual(new Uint8Array([25, 51, 76]));
+      expect(colorSpace.getRgb(new Float32Array([0.1, 0.2, 0.3]), 0)).toEqual(new Uint8ClampedArray([26, 51, 77]));
       expect(colorSpace.getOutputLength(4, 0)).toEqual(4);
       expect(colorSpace.isPassthrough(8)).toBeTruthy();
       expect(testDest).toEqual(expectedDest);
     });
     it('should handle the case when cs is an indirect object', function () {
-      var cs = new _primitives.Ref(10, 0);
+      var cs = _primitives.Ref.get(10, 0);
+
       var xref = new _test_utils.XRefMock([{
         ref: cs,
         data: _primitives.Name.get('DeviceRGB')
       }]);
       var res = new _primitives.Dict();
-      var pdfFunctionFactory = new _function.PDFFunctionFactory({ xref: xref });
+      var pdfFunctionFactory = new _function.PDFFunctionFactory({
+        xref: xref
+      });
+
       var colorSpace = _colorspace.ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
+
       var testSrc = new Uint8Array([27, 125, 250, 131, 139, 140, 111, 25, 198, 21, 147, 255]);
-      var testDest = new Uint8Array(3 * 3 * 3);
-      var expectedDest = new Uint8Array([27, 125, 250, 27, 125, 250, 131, 139, 140, 27, 125, 250, 27, 125, 250, 131, 139, 140, 111, 25, 198, 111, 25, 198, 21, 147, 255]);
+      var testDest = new Uint8ClampedArray(3 * 3 * 3);
+      var expectedDest = new Uint8ClampedArray([27, 125, 250, 27, 125, 250, 131, 139, 140, 27, 125, 250, 27, 125, 250, 131, 139, 140, 111, 25, 198, 111, 25, 198, 21, 147, 255]);
       colorSpace.fillRgb(testDest, 2, 2, 3, 3, 3, 8, testSrc, 0);
-      expect(colorSpace.getRgb(new Float32Array([0.1, 0.2, 0.3]), 0)).toEqual(new Uint8Array([25, 51, 76]));
+      expect(colorSpace.getRgb(new Float32Array([0.1, 0.2, 0.3]), 0)).toEqual(new Uint8ClampedArray([26, 51, 77]));
       expect(colorSpace.getOutputLength(4, 1)).toEqual(5);
       expect(colorSpace.isPassthrough(8)).toBeTruthy();
       expect(testDest).toEqual(expectedDest);
@@ -129,36 +149,46 @@ describe('colorspace', function () {
   describe('DeviceCmykCS', function () {
     it('should handle the case when cs is a Name object', function () {
       var cs = _primitives.Name.get('DeviceCMYK');
+
       var xref = new _test_utils.XRefMock([{
-        ref: new _primitives.Ref(10, 0),
+        ref: _primitives.Ref.get(10, 0),
         data: new _primitives.Dict()
       }]);
       var res = new _primitives.Dict();
-      var pdfFunctionFactory = new _function.PDFFunctionFactory({ xref: xref });
+      var pdfFunctionFactory = new _function.PDFFunctionFactory({
+        xref: xref
+      });
+
       var colorSpace = _colorspace.ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
+
       var testSrc = new Uint8Array([27, 125, 250, 128, 131, 139, 140, 45, 111, 25, 198, 78, 21, 147, 255, 69]);
-      var testDest = new Uint8Array(4 * 4 * 3);
-      var expectedDest = new Uint8Array([135, 80, 18, 135, 80, 18, 113, 102, 97, 113, 102, 97, 135, 80, 18, 135, 80, 18, 113, 102, 97, 113, 102, 97, 112, 143, 75, 112, 143, 75, 188, 98, 27, 188, 98, 27, 112, 143, 75, 112, 143, 75, 188, 98, 27, 188, 98, 27]);
+      var testDest = new Uint8ClampedArray(4 * 4 * 3);
+      var expectedDest = new Uint8ClampedArray([135, 81, 18, 135, 81, 18, 114, 102, 97, 114, 102, 97, 135, 81, 18, 135, 81, 18, 114, 102, 97, 114, 102, 97, 112, 144, 75, 112, 144, 75, 188, 98, 27, 188, 98, 27, 112, 144, 75, 112, 144, 75, 188, 98, 27, 188, 98, 27]);
       colorSpace.fillRgb(testDest, 2, 2, 4, 4, 4, 8, testSrc, 0);
-      expect(colorSpace.getRgb(new Float32Array([0.1, 0.2, 0.3, 1]), 0)).toEqual(new Uint8Array([31, 27, 20]));
+      expect(colorSpace.getRgb(new Float32Array([0.1, 0.2, 0.3, 1]), 0)).toEqual(new Uint8ClampedArray([32, 28, 21]));
       expect(colorSpace.getOutputLength(4, 0)).toEqual(3);
       expect(colorSpace.isPassthrough(8)).toBeFalsy();
       expect(testDest).toEqual(expectedDest);
     });
     it('should handle the case when cs is an indirect object', function () {
-      var cs = new _primitives.Ref(10, 0);
+      var cs = _primitives.Ref.get(10, 0);
+
       var xref = new _test_utils.XRefMock([{
         ref: cs,
         data: _primitives.Name.get('DeviceCMYK')
       }]);
       var res = new _primitives.Dict();
-      var pdfFunctionFactory = new _function.PDFFunctionFactory({ xref: xref });
+      var pdfFunctionFactory = new _function.PDFFunctionFactory({
+        xref: xref
+      });
+
       var colorSpace = _colorspace.ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
+
       var testSrc = new Uint8Array([27, 125, 250, 128, 131, 139, 140, 45, 111, 25, 198, 78, 21, 147, 255, 69]);
-      var testDest = new Uint8Array(3 * 3 * 3);
-      var expectedDest = new Uint8Array([135, 80, 18, 135, 80, 18, 113, 102, 97, 135, 80, 18, 135, 80, 18, 113, 102, 97, 112, 143, 75, 112, 143, 75, 188, 98, 27]);
+      var testDest = new Uint8ClampedArray(3 * 3 * 3);
+      var expectedDest = new Uint8ClampedArray([135, 81, 18, 135, 81, 18, 114, 102, 97, 135, 81, 18, 135, 81, 18, 114, 102, 97, 112, 144, 75, 112, 144, 75, 188, 98, 27]);
       colorSpace.fillRgb(testDest, 2, 2, 3, 3, 3, 8, testSrc, 0);
-      expect(colorSpace.getRgb(new Float32Array([0.1, 0.2, 0.3, 1]), 0)).toEqual(new Uint8Array([31, 27, 20]));
+      expect(colorSpace.getRgb(new Float32Array([0.1, 0.2, 0.3, 1]), 0)).toEqual(new Uint8ClampedArray([32, 28, 21]));
       expect(colorSpace.getOutputLength(4, 1)).toEqual(4);
       expect(colorSpace.isPassthrough(8)).toBeFalsy();
       expect(testDest).toEqual(expectedDest);
@@ -172,17 +202,21 @@ describe('colorspace', function () {
       params.set('Gamma', 2.0);
       var cs = [_primitives.Name.get('CalGray'), params];
       var xref = new _test_utils.XRefMock([{
-        ref: new _primitives.Ref(10, 0),
+        ref: _primitives.Ref.get(10, 0),
         data: new _primitives.Dict()
       }]);
       var res = new _primitives.Dict();
-      var pdfFunctionFactory = new _function.PDFFunctionFactory({ xref: xref });
+      var pdfFunctionFactory = new _function.PDFFunctionFactory({
+        xref: xref
+      });
+
       var colorSpace = _colorspace.ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
+
       var testSrc = new Uint8Array([27, 125, 250, 131]);
-      var testDest = new Uint8Array(4 * 4 * 3);
-      var expectedDest = new Uint8Array([25, 25, 25, 25, 25, 25, 143, 143, 143, 143, 143, 143, 25, 25, 25, 25, 25, 25, 143, 143, 143, 143, 143, 143, 251, 251, 251, 251, 251, 251, 148, 148, 148, 148, 148, 148, 251, 251, 251, 251, 251, 251, 148, 148, 148, 148, 148, 148]);
+      var testDest = new Uint8ClampedArray(4 * 4 * 3);
+      var expectedDest = new Uint8ClampedArray([25, 25, 25, 25, 25, 25, 143, 143, 143, 143, 143, 143, 25, 25, 25, 25, 25, 25, 143, 143, 143, 143, 143, 143, 251, 251, 251, 251, 251, 251, 149, 149, 149, 149, 149, 149, 251, 251, 251, 251, 251, 251, 149, 149, 149, 149, 149, 149]);
       colorSpace.fillRgb(testDest, 2, 2, 4, 4, 4, 8, testSrc, 0);
-      expect(colorSpace.getRgb(new Float32Array([1.0]), 0)).toEqual(new Uint8Array([255, 255, 255]));
+      expect(colorSpace.getRgb(new Float32Array([1.0]), 0)).toEqual(new Uint8ClampedArray([255, 255, 255]));
       expect(colorSpace.getOutputLength(4, 0)).toEqual(12);
       expect(colorSpace.isPassthrough(8)).toBeFalsy();
       expect(testDest).toEqual(expectedDest);
@@ -197,17 +231,21 @@ describe('colorspace', function () {
       params.set('Matrix', [1, 0, 0, 0, 1, 0, 0, 0, 1]);
       var cs = [_primitives.Name.get('CalRGB'), params];
       var xref = new _test_utils.XRefMock([{
-        ref: new _primitives.Ref(10, 0),
+        ref: _primitives.Ref.get(10, 0),
         data: new _primitives.Dict()
       }]);
       var res = new _primitives.Dict();
-      var pdfFunctionFactory = new _function.PDFFunctionFactory({ xref: xref });
+      var pdfFunctionFactory = new _function.PDFFunctionFactory({
+        xref: xref
+      });
+
       var colorSpace = _colorspace.ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
+
       var testSrc = new Uint8Array([27, 125, 250, 131, 139, 140, 111, 25, 198, 21, 147, 255]);
-      var testDest = new Uint8Array(3 * 3 * 3);
-      var expectedDest = new Uint8Array([0, 238, 255, 0, 238, 255, 185, 196, 195, 0, 238, 255, 0, 238, 255, 185, 196, 195, 235, 0, 243, 235, 0, 243, 0, 255, 255]);
+      var testDest = new Uint8ClampedArray(3 * 3 * 3);
+      var expectedDest = new Uint8ClampedArray([0, 238, 255, 0, 238, 255, 185, 196, 195, 0, 238, 255, 0, 238, 255, 185, 196, 195, 235, 0, 243, 235, 0, 243, 0, 255, 255]);
       colorSpace.fillRgb(testDest, 2, 2, 3, 3, 3, 8, testSrc, 0);
-      expect(colorSpace.getRgb(new Float32Array([0.1, 0.2, 0.3]), 0)).toEqual(new Uint8Array([0, 147, 151]));
+      expect(colorSpace.getRgb(new Float32Array([0.1, 0.2, 0.3]), 0)).toEqual(new Uint8ClampedArray([0, 147, 151]));
       expect(colorSpace.getOutputLength(4, 0)).toEqual(4);
       expect(colorSpace.isPassthrough(8)).toBeFalsy();
       expect(testDest).toEqual(expectedDest);
@@ -221,17 +259,21 @@ describe('colorspace', function () {
       params.set('Range', [-100, 100, -100, 100]);
       var cs = [_primitives.Name.get('Lab'), params];
       var xref = new _test_utils.XRefMock([{
-        ref: new _primitives.Ref(10, 0),
+        ref: _primitives.Ref.get(10, 0),
         data: new _primitives.Dict()
       }]);
       var res = new _primitives.Dict();
-      var pdfFunctionFactory = new _function.PDFFunctionFactory({ xref: xref });
+      var pdfFunctionFactory = new _function.PDFFunctionFactory({
+        xref: xref
+      });
+
       var colorSpace = _colorspace.ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
+
       var testSrc = new Uint8Array([27, 25, 50, 31, 19, 40, 11, 25, 98, 21, 47, 55]);
-      var testDest = new Uint8Array(3 * 3 * 3);
-      var expectedDest = new Uint8Array([0, 49, 101, 0, 49, 101, 0, 53, 116, 0, 49, 101, 0, 49, 101, 0, 53, 116, 0, 40, 39, 0, 40, 39, 0, 43, 90]);
+      var testDest = new Uint8ClampedArray(3 * 3 * 3);
+      var expectedDest = new Uint8ClampedArray([0, 49, 101, 0, 49, 101, 0, 53, 117, 0, 49, 101, 0, 49, 101, 0, 53, 117, 0, 41, 40, 0, 41, 40, 0, 43, 90]);
       colorSpace.fillRgb(testDest, 2, 2, 3, 3, 3, 8, testSrc, 0);
-      expect(colorSpace.getRgb([55, 25, 35], 0)).toEqual(new Uint8Array([188, 99, 61]));
+      expect(colorSpace.getRgb([55, 25, 35], 0)).toEqual(new Uint8ClampedArray([188, 100, 61]));
       expect(colorSpace.getOutputLength(4, 0)).toEqual(4);
       expect(colorSpace.isPassthrough(8)).toBeFalsy();
       expect(colorSpace.isDefaultDecode([0, 1])).toBeTruthy();
@@ -243,19 +285,23 @@ describe('colorspace', function () {
       var lookup = new Uint8Array([23, 155, 35, 147, 69, 93, 255, 109, 70]);
       var cs = [_primitives.Name.get('Indexed'), _primitives.Name.get('DeviceRGB'), 2, lookup];
       var xref = new _test_utils.XRefMock([{
-        ref: new _primitives.Ref(10, 0),
+        ref: _primitives.Ref.get(10, 0),
         data: new _primitives.Dict()
       }]);
       var res = new _primitives.Dict();
-      var pdfFunctionFactory = new _function.PDFFunctionFactory({ xref: xref });
+      var pdfFunctionFactory = new _function.PDFFunctionFactory({
+        xref: xref
+      });
+
       var colorSpace = _colorspace.ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
+
       var testSrc = new Uint8Array([2, 2, 0, 1]);
-      var testDest = new Uint8Array(3 * 3 * 3);
-      var expectedDest = new Uint8Array([255, 109, 70, 255, 109, 70, 255, 109, 70, 255, 109, 70, 255, 109, 70, 255, 109, 70, 23, 155, 35, 23, 155, 35, 147, 69, 93]);
+      var testDest = new Uint8ClampedArray(3 * 3 * 3);
+      var expectedDest = new Uint8ClampedArray([255, 109, 70, 255, 109, 70, 255, 109, 70, 255, 109, 70, 255, 109, 70, 255, 109, 70, 23, 155, 35, 23, 155, 35, 147, 69, 93]);
       colorSpace.fillRgb(testDest, 2, 2, 3, 3, 3, 8, testSrc, 0);
-      expect(colorSpace.getRgb([2], 0)).toEqual(new Uint8Array([255, 109, 70]));
+      expect(colorSpace.getRgb([2], 0)).toEqual(new Uint8ClampedArray([255, 109, 70]));
       expect(colorSpace.isPassthrough(8)).toBeFalsy();
-      expect(colorSpace.isDefaultDecode([0, 1])).toBeTruthy();
+      expect(colorSpace.isDefaultDecode([0, 1], 1)).toBeTruthy();
       expect(testDest).toEqual(expectedDest);
     });
   });
@@ -268,20 +314,26 @@ describe('colorspace', function () {
       fnDict.set('Length', 58);
       var fn = new _stream.StringStream('{ dup 0.84 mul ' + 'exch 0.00 exch ' + 'dup 0.44 mul ' + 'exch 0.21 mul }');
       fn = new _stream.Stream(fn.bytes, 0, 58, fnDict);
-      var fnRef = new _primitives.Ref(10, 0);
+
+      var fnRef = _primitives.Ref.get(10, 0);
+
       var cs = [_primitives.Name.get('Separation'), _primitives.Name.get('LogoGreen'), _primitives.Name.get('DeviceCMYK'), fnRef];
       var xref = new _test_utils.XRefMock([{
         ref: fnRef,
         data: fn
       }]);
       var res = new _primitives.Dict();
-      var pdfFunctionFactory = new _function.PDFFunctionFactory({ xref: xref });
+      var pdfFunctionFactory = new _function.PDFFunctionFactory({
+        xref: xref
+      });
+
       var colorSpace = _colorspace.ColorSpace.parse(cs, xref, res, pdfFunctionFactory);
+
       var testSrc = new Uint8Array([27, 25, 50, 31]);
-      var testDest = new Uint8Array(3 * 3 * 3);
-      var expectedDest = new Uint8Array([227, 243, 242, 227, 243, 242, 228, 243, 242, 227, 243, 242, 227, 243, 242, 228, 243, 242, 203, 233, 229, 203, 233, 229, 222, 241, 239]);
+      var testDest = new Uint8ClampedArray(3 * 3 * 3);
+      var expectedDest = new Uint8ClampedArray([226, 242, 241, 226, 242, 241, 229, 244, 242, 226, 242, 241, 226, 242, 241, 229, 244, 242, 203, 232, 229, 203, 232, 229, 222, 241, 238]);
       colorSpace.fillRgb(testDest, 2, 2, 3, 3, 3, 8, testSrc, 0);
-      expect(colorSpace.getRgb([0.1], 0)).toEqual(new Uint8Array([228, 243, 241]));
+      expect(colorSpace.getRgb([0.1], 0)).toEqual(new Uint8ClampedArray([228, 243, 242]));
       expect(colorSpace.isPassthrough(8)).toBeFalsy();
       expect(colorSpace.isDefaultDecode([0, 1])).toBeTruthy();
       expect(testDest).toEqual(expectedDest);

package/lib/test/unit/core_utils_spec.js

@@ -0,0 +1,191 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * Copyright 2019 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+"use strict";
+
+var _primitives = require("../../core/primitives");
+
+var _core_utils = require("../../core/core_utils");
+
+var _test_utils = require("./test_utils");
+
+describe('core_utils', function () {
+  describe('getInheritableProperty', function () {
+    it('handles non-dictionary arguments', function () {
+      expect((0, _core_utils.getInheritableProperty)({
+        dict: null,
+        key: 'foo'
+      })).toEqual(undefined);
+      expect((0, _core_utils.getInheritableProperty)({
+        dict: undefined,
+        key: 'foo'
+      })).toEqual(undefined);
+    });
+    it('handles dictionaries that do not contain the property', function () {
+      var emptyDict = new _primitives.Dict();
+      expect((0, _core_utils.getInheritableProperty)({
+        dict: emptyDict,
+        key: 'foo'
+      })).toEqual(undefined);
+      var filledDict = new _primitives.Dict();
+      filledDict.set('bar', 'baz');
+      expect((0, _core_utils.getInheritableProperty)({
+        dict: filledDict,
+        key: 'foo'
+      })).toEqual(undefined);
+    });
+    it('fetches the property if it is not inherited', function () {
+      var ref = _primitives.Ref.get(10, 0);
+
+      var xref = new _test_utils.XRefMock([{
+        ref: ref,
+        data: 'quux'
+      }]);
+      var dict = new _primitives.Dict(xref);
+      dict.set('foo', 'bar');
+      expect((0, _core_utils.getInheritableProperty)({
+        dict: dict,
+        key: 'foo'
+      })).toEqual('bar');
+      dict.set('baz', ['qux', ref]);
+      expect((0, _core_utils.getInheritableProperty)({
+        dict: dict,
+        key: 'baz',
+        getArray: true
+      })).toEqual(['qux', 'quux']);
+    });
+    it('fetches the property if it is inherited and present on one level', function () {
+      var ref = _primitives.Ref.get(10, 0);
+
+      var xref = new _test_utils.XRefMock([{
+        ref: ref,
+        data: 'quux'
+      }]);
+      var firstDict = new _primitives.Dict(xref);
+      var secondDict = new _primitives.Dict(xref);
+      firstDict.set('Parent', secondDict);
+      secondDict.set('foo', 'bar');
+      expect((0, _core_utils.getInheritableProperty)({
+        dict: firstDict,
+        key: 'foo'
+      })).toEqual('bar');
+      secondDict.set('baz', ['qux', ref]);
+      expect((0, _core_utils.getInheritableProperty)({
+        dict: firstDict,
+        key: 'baz',
+        getArray: true
+      })).toEqual(['qux', 'quux']);
+    });
+    it('fetches the property if it is inherited and present on multiple levels', function () {
+      var ref = _primitives.Ref.get(10, 0);
+
+      var xref = new _test_utils.XRefMock([{
+        ref: ref,
+        data: 'quux'
+      }]);
+      var firstDict = new _primitives.Dict(xref);
+      var secondDict = new _primitives.Dict(xref);
+      firstDict.set('Parent', secondDict);
+      firstDict.set('foo', 'bar1');
+      secondDict.set('foo', 'bar2');
+      expect((0, _core_utils.getInheritableProperty)({
+        dict: firstDict,
+        key: 'foo'
+      })).toEqual('bar1');
+      expect((0, _core_utils.getInheritableProperty)({
+        dict: firstDict,
+        key: 'foo',
+        getArray: false,
+        stopWhenFound: false
+      })).toEqual(['bar1', 'bar2']);
+      firstDict.set('baz', ['qux1', ref]);
+      secondDict.set('baz', ['qux2', ref]);
+      expect((0, _core_utils.getInheritableProperty)({
+        dict: firstDict,
+        key: 'baz',
+        getArray: true,
+        stopWhenFound: false
+      })).toEqual([['qux1', 'quux'], ['qux2', 'quux']]);
+    });
+    it('stops searching when the loop limit is reached', function () {
+      var dict = new _primitives.Dict();
+      var currentDict = dict;
+      var parentDict = null;
+
+      for (var i = 0; i < 150; i++) {
+        parentDict = new _primitives.Dict();
+        currentDict.set('Parent', parentDict);
+        currentDict = parentDict;
+      }
+
+      parentDict.set('foo', 'bar');
+      expect((0, _core_utils.getInheritableProperty)({
+        dict: dict,
+        key: 'foo'
+      })).toEqual(undefined);
+      dict.set('foo', 'baz');
+      expect((0, _core_utils.getInheritableProperty)({
+        dict: dict,
+        key: 'foo',
+        getArray: false,
+        stopWhenFound: false
+      })).toEqual(['baz']);
+    });
+  });
+  describe('toRomanNumerals', function () {
+    it('handles invalid arguments', function () {
+      var _loop = function _loop() {
+        var input = _arr[_i];
+        expect(function () {
+          (0, _core_utils.toRomanNumerals)(input);
+        }).toThrow(new Error('The number should be a positive integer.'));
+      };
+
+      for (var _i = 0, _arr = ['foo', -1, 0]; _i < _arr.length; _i++) {
+        _loop();
+      }
+    });
+    it('converts numbers to uppercase Roman numerals', function () {
+      expect((0, _core_utils.toRomanNumerals)(1)).toEqual('I');
+      expect((0, _core_utils.toRomanNumerals)(6)).toEqual('VI');
+      expect((0, _core_utils.toRomanNumerals)(7)).toEqual('VII');
+      expect((0, _core_utils.toRomanNumerals)(8)).toEqual('VIII');
+      expect((0, _core_utils.toRomanNumerals)(10)).toEqual('X');
+      expect((0, _core_utils.toRomanNumerals)(40)).toEqual('XL');
+      expect((0, _core_utils.toRomanNumerals)(100)).toEqual('C');
+      expect((0, _core_utils.toRomanNumerals)(500)).toEqual('D');
+      expect((0, _core_utils.toRomanNumerals)(1000)).toEqual('M');
+      expect((0, _core_utils.toRomanNumerals)(2019)).toEqual('MMXIX');
+    });
+    it('converts numbers to lowercase Roman numerals', function () {
+      expect((0, _core_utils.toRomanNumerals)(1, true)).toEqual('i');
+      expect((0, _core_utils.toRomanNumerals)(6, true)).toEqual('vi');
+      expect((0, _core_utils.toRomanNumerals)(7, true)).toEqual('vii');
+      expect((0, _core_utils.toRomanNumerals)(8, true)).toEqual('viii');
+      expect((0, _core_utils.toRomanNumerals)(10, true)).toEqual('x');
+      expect((0, _core_utils.toRomanNumerals)(40, true)).toEqual('xl');
+      expect((0, _core_utils.toRomanNumerals)(100, true)).toEqual('c');
+      expect((0, _core_utils.toRomanNumerals)(500, true)).toEqual('d');
+      expect((0, _core_utils.toRomanNumerals)(1000, true)).toEqual('m');
+      expect((0, _core_utils.toRomanNumerals)(2019, true)).toEqual('mmxix');
+    });
+  });
+});

package/lib/test/unit/crypto_spec.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2017 Mozilla Foundation
+ * Copyright 2019 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 _crypto = require('../../core/crypto');
+var _crypto = require("../../core/crypto");
 
-var _primitives = require('../../core/primitives');
+var _primitives = require("../../core/primitives");
 
-var _util = require('../../shared/util');
+var _util = require("../../shared/util");
 
 describe('crypto', function () {
   function hex2binary(s) {
@@ -35,14 +35,17 @@ describe('crypto', function () {
         i,
         j;
     var result = new Uint8Array(n);
+
     for (i = 0, j = 0; i < n; ++i) {
       var d1 = s.charAt(j++);
       var d2 = s.charAt(j++);
       var value = digits.indexOf(d1) << 4 | digits.indexOf(d2);
       result[i] = value;
     }
+
     return result;
   }
+
   describe('calculateMD5', function () {
     it('should pass RFC 1321 test #1', function () {
       var input, result, expected;
@@ -357,11 +360,14 @@ describe('crypto', function () {
 describe('CipherTransformFactory', function () {
   function buildDict(map) {
     var dict = new _primitives.Dict();
+
     for (var key in map) {
       dict.set(key, map[key]);
     }
+
     return dict;
   }
+
   function ensurePasswordCorrect(done, dict, fileId, password) {
     try {
       var factory = new _crypto.CipherTransformFactory(dict, fileId, password);
@@ -370,8 +376,10 @@ describe('CipherTransformFactory', function () {
       done.fail('Password should be accepted: ' + ex);
       return;
     }
+
     done();
   }
+
   function ensurePasswordNeeded(done, dict, fileId, password) {
     try {
       new _crypto.CipherTransformFactory(dict, fileId, password);
@@ -381,8 +389,10 @@ describe('CipherTransformFactory', function () {
       done();
       return;
     }
+
     done.fail('Password should be rejected.');
   }
+
   function ensurePasswordIncorrect(done, dict, fileId, password) {
     try {
       new _crypto.CipherTransformFactory(dict, fileId, password);
@@ -392,8 +402,10 @@ describe('CipherTransformFactory', function () {
       done();
       return;
     }
+
     done.fail('Password should be rejected.');
   }
+
   var fileId1, fileId2, dict1, dict2;
   var aes256Dict, aes256IsoDict, aes256BlankDict, aes256IsoBlankDict;
   beforeAll(function (done) {