pdfjs-dist 2.2.228 → 2.6.347

package/lib/test/unit/unicode_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,22 +21,22 @@
  */
 "use strict";
 
-var _glyphlist = require("../../core/glyphlist");
+var _glyphlist = require("../../core/glyphlist.js");
 
-var _unicode = require("../../core/unicode");
+var _unicode = require("../../core/unicode.js");
 
-describe('unicode', function () {
-  describe('mapSpecialUnicodeValues', function () {
-    it('should not re-map normal Unicode values', function () {
+describe("unicode", function () {
+  describe("mapSpecialUnicodeValues", function () {
+    it("should not re-map normal Unicode values", function () {
       expect((0, _unicode.mapSpecialUnicodeValues)(0x0041)).toEqual(0x0041);
-      expect((0, _unicode.mapSpecialUnicodeValues)(0xFB01)).toEqual(0xFB01);
+      expect((0, _unicode.mapSpecialUnicodeValues)(0xfb01)).toEqual(0xfb01);
     });
-    it('should re-map special Unicode values', function () {
-      expect((0, _unicode.mapSpecialUnicodeValues)(0xF8E9)).toEqual(0x00A9);
-      expect((0, _unicode.mapSpecialUnicodeValues)(0xFFFF)).toEqual(0);
+    it("should re-map special Unicode values", function () {
+      expect((0, _unicode.mapSpecialUnicodeValues)(0xf8e9)).toEqual(0x00a9);
+      expect((0, _unicode.mapSpecialUnicodeValues)(0xffff)).toEqual(0);
     });
   });
-  describe('getUnicodeForGlyph', function () {
+  describe("getUnicodeForGlyph", function () {
     var standardMap, dingbatsMap;
     beforeAll(function (done) {
       standardMap = (0, _glyphlist.getGlyphsUnicode)();
@@ -46,31 +46,31 @@ describe('unicode', function () {
     afterAll(function () {
       standardMap = dingbatsMap = null;
     });
-    it('should get Unicode values for valid glyph names', function () {
-      expect((0, _unicode.getUnicodeForGlyph)('A', standardMap)).toEqual(0x0041);
-      expect((0, _unicode.getUnicodeForGlyph)('a1', dingbatsMap)).toEqual(0x2701);
+    it("should get Unicode values for valid glyph names", function () {
+      expect((0, _unicode.getUnicodeForGlyph)("A", standardMap)).toEqual(0x0041);
+      expect((0, _unicode.getUnicodeForGlyph)("a1", dingbatsMap)).toEqual(0x2701);
     });
-    it('should recover Unicode values from uniXXXX/uXXXX{XX} glyph names', function () {
-      expect((0, _unicode.getUnicodeForGlyph)('uni0041', standardMap)).toEqual(0x0041);
-      expect((0, _unicode.getUnicodeForGlyph)('u0041', standardMap)).toEqual(0x0041);
-      expect((0, _unicode.getUnicodeForGlyph)('uni2701', dingbatsMap)).toEqual(0x2701);
-      expect((0, _unicode.getUnicodeForGlyph)('u2701', dingbatsMap)).toEqual(0x2701);
+    it("should recover Unicode values from uniXXXX/uXXXX{XX} glyph names", function () {
+      expect((0, _unicode.getUnicodeForGlyph)("uni0041", standardMap)).toEqual(0x0041);
+      expect((0, _unicode.getUnicodeForGlyph)("u0041", standardMap)).toEqual(0x0041);
+      expect((0, _unicode.getUnicodeForGlyph)("uni2701", dingbatsMap)).toEqual(0x2701);
+      expect((0, _unicode.getUnicodeForGlyph)("u2701", dingbatsMap)).toEqual(0x2701);
     });
-    it('should not get Unicode values for invalid glyph names', function () {
-      expect((0, _unicode.getUnicodeForGlyph)('Qwerty', standardMap)).toEqual(-1);
-      expect((0, _unicode.getUnicodeForGlyph)('Qwerty', dingbatsMap)).toEqual(-1);
+    it("should not get Unicode values for invalid glyph names", function () {
+      expect((0, _unicode.getUnicodeForGlyph)("Qwerty", standardMap)).toEqual(-1);
+      expect((0, _unicode.getUnicodeForGlyph)("Qwerty", dingbatsMap)).toEqual(-1);
     });
   });
-  describe('getUnicodeRangeFor', function () {
-    it('should get correct Unicode range', function () {
+  describe("getUnicodeRangeFor", function () {
+    it("should get correct Unicode range", function () {
       expect((0, _unicode.getUnicodeRangeFor)(0x0041)).toEqual(0);
-      expect((0, _unicode.getUnicodeRangeFor)(0xFB01)).toEqual(62);
+      expect((0, _unicode.getUnicodeRangeFor)(0xfb01)).toEqual(62);
     });
-    it('should not get a Unicode range', function () {
-      expect((0, _unicode.getUnicodeRangeFor)(0x05FF)).toEqual(-1);
+    it("should not get a Unicode range", function () {
+      expect((0, _unicode.getUnicodeRangeFor)(0x05ff)).toEqual(-1);
     });
   });
-  describe('getNormalizedUnicodes', function () {
+  describe("getNormalizedUnicodes", function () {
     var NormalizedUnicodes;
     beforeAll(function (done) {
       NormalizedUnicodes = (0, _unicode.getNormalizedUnicodes)();
@@ -79,23 +79,23 @@ describe('unicode', function () {
     afterAll(function () {
       NormalizedUnicodes = null;
     });
-    it('should get normalized Unicode values for ligatures', function () {
-      expect(NormalizedUnicodes["\uFB01"]).toEqual('fi');
+    it("should get normalized Unicode values for ligatures", function () {
+      expect(NormalizedUnicodes["\uFB01"]).toEqual("fi");
       expect(NormalizedUnicodes["\u0675"]).toEqual("\u0627\u0674");
     });
-    it('should not normalize standard characters', function () {
-      expect(NormalizedUnicodes['A']).toEqual(undefined);
+    it("should not normalize standard characters", function () {
+      expect(NormalizedUnicodes.A).toEqual(undefined);
     });
   });
-  describe('reverseIfRtl', function () {
+  describe("reverseIfRtl", function () {
     var NormalizedUnicodes;
 
-    function getGlyphUnicode(_char) {
-      if (NormalizedUnicodes[_char] !== undefined) {
-        return NormalizedUnicodes[_char];
+    function getGlyphUnicode(char) {
+      if (NormalizedUnicodes[char] !== undefined) {
+        return NormalizedUnicodes[char];
       }
 
-      return _char;
+      return char;
     }
 
     beforeAll(function (done) {
@@ -105,13 +105,13 @@ describe('unicode', function () {
     afterAll(function () {
       NormalizedUnicodes = null;
     });
-    it('should not reverse LTR characters', function () {
-      var A = getGlyphUnicode('A');
-      expect((0, _unicode.reverseIfRtl)(A)).toEqual('A');
+    it("should not reverse LTR characters", function () {
+      var A = getGlyphUnicode("A");
+      expect((0, _unicode.reverseIfRtl)(A)).toEqual("A");
       var fi = getGlyphUnicode("\uFB01");
-      expect((0, _unicode.reverseIfRtl)(fi)).toEqual('fi');
+      expect((0, _unicode.reverseIfRtl)(fi)).toEqual("fi");
     });
-    it('should reverse RTL characters', function () {
+    it("should reverse RTL characters", function () {
       var heAlef = getGlyphUnicode("\u05D0");
       expect((0, _unicode.reverseIfRtl)(heAlef)).toEqual("\u05D0");
       var arAlef = getGlyphUnicode("\u0675");

package/lib/test/unit/util_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,242 +21,222 @@
  */
 "use strict";
 
-var _util = require("../../shared/util");
+var _util = require("../../shared/util.js");
 
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-describe('util', function () {
-  describe('bytesToString', function () {
-    it('handles non-array arguments', function () {
+describe("util", function () {
+  describe("bytesToString", function () {
+    it("handles non-array arguments", function () {
       expect(function () {
         (0, _util.bytesToString)(null);
-      }).toThrow(new Error('Invalid argument for bytesToString'));
+      }).toThrow(new Error("Invalid argument for bytesToString"));
     });
-    it('handles array arguments with a length not exceeding the maximum', function () {
-      expect((0, _util.bytesToString)(new Uint8Array([]))).toEqual('');
-      expect((0, _util.bytesToString)(new Uint8Array([102, 111, 111]))).toEqual('foo');
+    it("handles array arguments with a length not exceeding the maximum", function () {
+      expect((0, _util.bytesToString)(new Uint8Array([]))).toEqual("");
+      expect((0, _util.bytesToString)(new Uint8Array([102, 111, 111]))).toEqual("foo");
     });
-    it('handles array arguments with a length exceeding the maximum', function () {
-      var length = 10000;
-      var bytes = new Uint8Array(length);
+    it("handles array arguments with a length exceeding the maximum", function () {
+      const length = 10000;
+      const bytes = new Uint8Array(length);
 
-      for (var i = 0; i < length; i++) {
-        bytes[i] = 'a'.charCodeAt(0);
+      for (let i = 0; i < length; i++) {
+        bytes[i] = "a".charCodeAt(0);
       }
 
-      var string = Array(length + 1).join('a');
+      const string = Array(length + 1).join("a");
       expect((0, _util.bytesToString)(bytes)).toEqual(string);
     });
   });
-  describe('isArrayBuffer', function () {
-    it('handles array buffer values', function () {
+  describe("isArrayBuffer", function () {
+    it("handles array buffer values", function () {
       expect((0, _util.isArrayBuffer)(new ArrayBuffer(0))).toEqual(true);
       expect((0, _util.isArrayBuffer)(new Uint8Array(0))).toEqual(true);
     });
-    it('handles non-array buffer values', function () {
-      expect((0, _util.isArrayBuffer)('true')).toEqual(false);
+    it("handles non-array buffer values", function () {
+      expect((0, _util.isArrayBuffer)("true")).toEqual(false);
       expect((0, _util.isArrayBuffer)(1)).toEqual(false);
       expect((0, _util.isArrayBuffer)(null)).toEqual(false);
       expect((0, _util.isArrayBuffer)(undefined)).toEqual(false);
     });
   });
-  describe('isBool', function () {
-    it('handles boolean values', function () {
+  describe("isBool", function () {
+    it("handles boolean values", function () {
       expect((0, _util.isBool)(true)).toEqual(true);
       expect((0, _util.isBool)(false)).toEqual(true);
     });
-    it('handles non-boolean values', function () {
-      expect((0, _util.isBool)('true')).toEqual(false);
-      expect((0, _util.isBool)('false')).toEqual(false);
+    it("handles non-boolean values", function () {
+      expect((0, _util.isBool)("true")).toEqual(false);
+      expect((0, _util.isBool)("false")).toEqual(false);
       expect((0, _util.isBool)(1)).toEqual(false);
       expect((0, _util.isBool)(0)).toEqual(false);
       expect((0, _util.isBool)(null)).toEqual(false);
       expect((0, _util.isBool)(undefined)).toEqual(false);
     });
   });
-  describe('isEmptyObj', function () {
-    it('handles empty objects', function () {
-      expect((0, _util.isEmptyObj)({})).toEqual(true);
-    });
-    it('handles non-empty objects', function () {
-      expect((0, _util.isEmptyObj)({
-        foo: 'bar'
-      })).toEqual(false);
-    });
-  });
-  describe('isNum', function () {
-    it('handles numeric values', function () {
+  describe("isNum", function () {
+    it("handles numeric values", function () {
       expect((0, _util.isNum)(1)).toEqual(true);
       expect((0, _util.isNum)(0)).toEqual(true);
       expect((0, _util.isNum)(-1)).toEqual(true);
       expect((0, _util.isNum)(1000000000000000000)).toEqual(true);
       expect((0, _util.isNum)(12.34)).toEqual(true);
     });
-    it('handles non-numeric values', function () {
-      expect((0, _util.isNum)('true')).toEqual(false);
+    it("handles non-numeric values", function () {
+      expect((0, _util.isNum)("true")).toEqual(false);
       expect((0, _util.isNum)(true)).toEqual(false);
       expect((0, _util.isNum)(null)).toEqual(false);
       expect((0, _util.isNum)(undefined)).toEqual(false);
     });
   });
-  describe('isSpace', function () {
-    it('handles space characters', function () {
-      expect((0, _util.isSpace)(0x20)).toEqual(true);
-      expect((0, _util.isSpace)(0x09)).toEqual(true);
-      expect((0, _util.isSpace)(0x0D)).toEqual(true);
-      expect((0, _util.isSpace)(0x0A)).toEqual(true);
-    });
-    it('handles non-space characters', function () {
-      expect((0, _util.isSpace)(0x0B)).toEqual(false);
-      expect((0, _util.isSpace)(null)).toEqual(false);
-      expect((0, _util.isSpace)(undefined)).toEqual(false);
+  describe("isString", function () {
+    it("handles string values", function () {
+      expect((0, _util.isString)("foo")).toEqual(true);
+      expect((0, _util.isString)("")).toEqual(true);
     });
-  });
-  describe('isString', function () {
-    it('handles string values', function () {
-      expect((0, _util.isString)('foo')).toEqual(true);
-      expect((0, _util.isString)('')).toEqual(true);
-    });
-    it('handles non-string values', function () {
+    it("handles non-string values", function () {
       expect((0, _util.isString)(true)).toEqual(false);
       expect((0, _util.isString)(1)).toEqual(false);
       expect((0, _util.isString)(null)).toEqual(false);
       expect((0, _util.isString)(undefined)).toEqual(false);
     });
   });
-  describe('log2', function () {
-    it('handles values smaller than/equal to zero', function () {
-      expect((0, _util.log2)(0)).toEqual(0);
-      expect((0, _util.log2)(-1)).toEqual(0);
-    });
-    it('handles values larger than zero', function () {
-      expect((0, _util.log2)(1)).toEqual(0);
-      expect((0, _util.log2)(2)).toEqual(1);
-      expect((0, _util.log2)(3)).toEqual(2);
-      expect((0, _util.log2)(3.14)).toEqual(2);
-    });
-  });
-  describe('string32', function () {
-    it('converts unsigned 32-bit integers to strings', function () {
-      expect((0, _util.string32)(0x74727565)).toEqual('true');
-      expect((0, _util.string32)(0x74797031)).toEqual('typ1');
-      expect((0, _util.string32)(0x4F54544F)).toEqual('OTTO');
+  describe("string32", function () {
+    it("converts unsigned 32-bit integers to strings", function () {
+      expect((0, _util.string32)(0x74727565)).toEqual("true");
+      expect((0, _util.string32)(0x74797031)).toEqual("typ1");
+      expect((0, _util.string32)(0x4f54544f)).toEqual("OTTO");
     });
   });
-  describe('stringToBytes', function () {
-    it('handles non-string arguments', function () {
+  describe("stringToBytes", function () {
+    it("handles non-string arguments", function () {
       expect(function () {
         (0, _util.stringToBytes)(null);
-      }).toThrow(new Error('Invalid argument for stringToBytes'));
+      }).toThrow(new Error("Invalid argument for stringToBytes"));
     });
-    it('handles string arguments', function () {
-      expect((0, _util.stringToBytes)('')).toEqual(new Uint8Array([]));
-      expect((0, _util.stringToBytes)('foo')).toEqual(new Uint8Array([102, 111, 111]));
+    it("handles string arguments", function () {
+      expect((0, _util.stringToBytes)("")).toEqual(new Uint8Array([]));
+      expect((0, _util.stringToBytes)("foo")).toEqual(new Uint8Array([102, 111, 111]));
     });
   });
-  describe('stringToPDFString', function () {
-    it('handles ISO Latin 1 strings', function () {
-      var str = '\x8Dstring\x8E';
+  describe("stringToPDFString", function () {
+    it("handles ISO Latin 1 strings", function () {
+      const str = "\x8Dstring\x8E";
       expect((0, _util.stringToPDFString)(str)).toEqual("\u201Cstring\u201D");
     });
-    it('handles UTF-16BE strings', function () {
-      var str = '\xFE\xFF\x00\x73\x00\x74\x00\x72\x00\x69\x00\x6E\x00\x67';
-      expect((0, _util.stringToPDFString)(str)).toEqual('string');
+    it("handles UTF-16 big-endian strings", function () {
+      const str = "\xFE\xFF\x00\x73\x00\x74\x00\x72\x00\x69\x00\x6E\x00\x67";
+      expect((0, _util.stringToPDFString)(str)).toEqual("string");
+    });
+    it("handles UTF-16 little-endian strings", function () {
+      const str = "\xFF\xFE\x73\x00\x74\x00\x72\x00\x69\x00\x6E\x00\x67\x00";
+      expect((0, _util.stringToPDFString)(str)).toEqual("string");
     });
-    it('handles empty strings', function () {
-      var str1 = '';
-      expect((0, _util.stringToPDFString)(str1)).toEqual('');
-      var str2 = '\xFE\xFF';
-      expect((0, _util.stringToPDFString)(str2)).toEqual('');
+    it("handles empty strings", function () {
+      const str1 = "";
+      expect((0, _util.stringToPDFString)(str1)).toEqual("");
+      const str2 = "\xFE\xFF";
+      expect((0, _util.stringToPDFString)(str2)).toEqual("");
+      const str3 = "\xFF\xFE";
+      expect((0, _util.stringToPDFString)(str3)).toEqual("");
     });
   });
-  describe('removeNullCharacters', function () {
-    it('should not modify string without null characters', function () {
-      var str = 'string without null chars';
-      expect((0, _util.removeNullCharacters)(str)).toEqual('string without null chars');
+  describe("removeNullCharacters", function () {
+    it("should not modify string without null characters", function () {
+      const str = "string without null chars";
+      expect((0, _util.removeNullCharacters)(str)).toEqual("string without null chars");
     });
-    it('should modify string with null characters', function () {
-      var str = 'string\x00With\x00Null\x00Chars';
-      expect((0, _util.removeNullCharacters)(str)).toEqual('stringWithNullChars');
+    it("should modify string with null characters", function () {
+      const str = "string\x00With\x00Null\x00Chars";
+      expect((0, _util.removeNullCharacters)(str)).toEqual("stringWithNullChars");
     });
   });
-  describe('ReadableStream', function () {
-    it('should return an Object', function () {
-      var readable = new _util.ReadableStream();
-      expect(_typeof(readable)).toEqual('object');
+  describe("ReadableStream", function () {
+    it("should return an Object", function () {
+      const readable = new ReadableStream();
+      expect(typeof readable).toEqual("object");
     });
-    it('should have property getReader', function () {
-      var readable = new _util.ReadableStream();
-      expect(_typeof(readable.getReader)).toEqual('function');
+    it("should have property getReader", function () {
+      const readable = new ReadableStream();
+      expect(typeof readable.getReader).toEqual("function");
     });
   });
-  describe('URL', function () {
-    it('should return an Object', function () {
-      var url = new _util.URL('https://example.com');
-      expect(_typeof(url)).toEqual('object');
+  describe("URL", function () {
+    it("should return an Object", function () {
+      const url = new URL("https://example.com");
+      expect(typeof url).toEqual("object");
     });
-    it('should have property `href`', function () {
-      var url = new _util.URL('https://example.com');
-      expect(_typeof(url.href)).toEqual('string');
+    it("should have property `href`", function () {
+      const url = new URL("https://example.com");
+      expect(typeof url.href).toEqual("string");
     });
   });
-  describe('isSameOrigin', function () {
-    it('handles invalid base URLs', function () {
-      expect((0, _util.isSameOrigin)('/foo', '/bar')).toEqual(false);
-      expect((0, _util.isSameOrigin)('blob:foo', '/bar')).toEqual(false);
+  describe("isSameOrigin", function () {
+    it("handles invalid base URLs", function () {
+      expect((0, _util.isSameOrigin)("/foo", "/bar")).toEqual(false);
+      expect((0, _util.isSameOrigin)("blob:foo", "/bar")).toEqual(false);
     });
-    it('correctly checks if the origin of both URLs matches', function () {
-      expect((0, _util.isSameOrigin)('https://www.mozilla.org/foo', 'https://www.mozilla.org/bar')).toEqual(true);
-      expect((0, _util.isSameOrigin)('https://www.mozilla.org/foo', 'https://www.example.com/bar')).toEqual(false);
+    it("correctly checks if the origin of both URLs matches", function () {
+      expect((0, _util.isSameOrigin)("https://www.mozilla.org/foo", "https://www.mozilla.org/bar")).toEqual(true);
+      expect((0, _util.isSameOrigin)("https://www.mozilla.org/foo", "https://www.example.com/bar")).toEqual(false);
     });
   });
-  describe('createValidAbsoluteUrl', function () {
-    it('handles invalid URLs', function () {
+  describe("createValidAbsoluteUrl", function () {
+    it("handles invalid URLs", function () {
       expect((0, _util.createValidAbsoluteUrl)(undefined, undefined)).toEqual(null);
       expect((0, _util.createValidAbsoluteUrl)(null, null)).toEqual(null);
-      expect((0, _util.createValidAbsoluteUrl)('/foo', '/bar')).toEqual(null);
-    });
-    it('handles URLs that do not use a whitelisted protocol', function () {
-      expect((0, _util.createValidAbsoluteUrl)('magnet:?foo', null)).toEqual(null);
-    });
-    it('correctly creates a valid URL for whitelisted protocols', function () {
-      expect((0, _util.createValidAbsoluteUrl)('http://www.mozilla.org/foo', null)).toEqual(new _util.URL('http://www.mozilla.org/foo'));
-      expect((0, _util.createValidAbsoluteUrl)('/foo', 'http://www.mozilla.org')).toEqual(new _util.URL('http://www.mozilla.org/foo'));
-      expect((0, _util.createValidAbsoluteUrl)('https://www.mozilla.org/foo', null)).toEqual(new _util.URL('https://www.mozilla.org/foo'));
-      expect((0, _util.createValidAbsoluteUrl)('/foo', 'https://www.mozilla.org')).toEqual(new _util.URL('https://www.mozilla.org/foo'));
-      expect((0, _util.createValidAbsoluteUrl)('ftp://www.mozilla.org/foo', null)).toEqual(new _util.URL('ftp://www.mozilla.org/foo'));
-      expect((0, _util.createValidAbsoluteUrl)('/foo', 'ftp://www.mozilla.org')).toEqual(new _util.URL('ftp://www.mozilla.org/foo'));
-      expect((0, _util.createValidAbsoluteUrl)('mailto:foo@bar.baz', null)).toEqual(new _util.URL('mailto:foo@bar.baz'));
-      expect((0, _util.createValidAbsoluteUrl)('/foo', 'mailto:foo@bar.baz')).toEqual(null);
-      expect((0, _util.createValidAbsoluteUrl)('tel:+0123456789', null)).toEqual(new _util.URL('tel:+0123456789'));
-      expect((0, _util.createValidAbsoluteUrl)('/foo', 'tel:0123456789')).toEqual(null);
-    });
-  });
-  describe('createPromiseCapability', function () {
-    it('should resolve with correct data', function (done) {
-      var promiseCapability = (0, _util.createPromiseCapability)();
+      expect((0, _util.createValidAbsoluteUrl)("/foo", "/bar")).toEqual(null);
+    });
+    it("handles URLs that do not use an allowed protocol", function () {
+      expect((0, _util.createValidAbsoluteUrl)("magnet:?foo", null)).toEqual(null);
+    });
+    it("correctly creates a valid URL for allowed protocols", function () {
+      expect((0, _util.createValidAbsoluteUrl)("http://www.mozilla.org/foo", null)).toEqual(new URL("http://www.mozilla.org/foo"));
+      expect((0, _util.createValidAbsoluteUrl)("/foo", "http://www.mozilla.org")).toEqual(new URL("http://www.mozilla.org/foo"));
+      expect((0, _util.createValidAbsoluteUrl)("https://www.mozilla.org/foo", null)).toEqual(new URL("https://www.mozilla.org/foo"));
+      expect((0, _util.createValidAbsoluteUrl)("/foo", "https://www.mozilla.org")).toEqual(new URL("https://www.mozilla.org/foo"));
+      expect((0, _util.createValidAbsoluteUrl)("ftp://www.mozilla.org/foo", null)).toEqual(new URL("ftp://www.mozilla.org/foo"));
+      expect((0, _util.createValidAbsoluteUrl)("/foo", "ftp://www.mozilla.org")).toEqual(new URL("ftp://www.mozilla.org/foo"));
+      expect((0, _util.createValidAbsoluteUrl)("mailto:foo@bar.baz", null)).toEqual(new URL("mailto:foo@bar.baz"));
+      expect((0, _util.createValidAbsoluteUrl)("/foo", "mailto:foo@bar.baz")).toEqual(null);
+      expect((0, _util.createValidAbsoluteUrl)("tel:+0123456789", null)).toEqual(new URL("tel:+0123456789"));
+      expect((0, _util.createValidAbsoluteUrl)("/foo", "tel:0123456789")).toEqual(null);
+    });
+  });
+  describe("createPromiseCapability", function () {
+    it("should resolve with correct data", function (done) {
+      const promiseCapability = (0, _util.createPromiseCapability)();
       expect(promiseCapability.settled).toEqual(false);
       promiseCapability.resolve({
-        test: 'abc'
+        test: "abc"
       });
       promiseCapability.promise.then(function (data) {
         expect(promiseCapability.settled).toEqual(true);
         expect(data).toEqual({
-          test: 'abc'
+          test: "abc"
         });
         done();
       }, done.fail);
     });
-    it('should reject with correct reason', function (done) {
-      var promiseCapability = (0, _util.createPromiseCapability)();
+    it("should reject with correct reason", function (done) {
+      const promiseCapability = (0, _util.createPromiseCapability)();
       expect(promiseCapability.settled).toEqual(false);
-      promiseCapability.reject(new Error('reason'));
+      promiseCapability.reject(new Error("reason"));
       promiseCapability.promise.then(done.fail, function (reason) {
         expect(promiseCapability.settled).toEqual(true);
         expect(reason instanceof Error).toEqual(true);
-        expect(reason.message).toEqual('reason');
+        expect(reason.message).toEqual("reason");
         done();
       });
     });
   });
+  describe("escapeString", function () {
+    it("should escape (, ) and \\", function () {
+      expect((0, _util.escapeString)("((a\\a))(b(b\\b)b)")).toEqual("\\(\\(a\\\\a\\)\\)\\(b\\(b\\\\b\\)b\\)");
+    });
+  });
+  describe("getModificationDate", function () {
+    it("should get a correctly formatted date", function () {
+      const date = new Date(Date.UTC(3141, 5, 9, 2, 6, 53));
+      expect((0, _util.getModificationDate)(date)).toEqual("31410610020653");
+    });
+  });
 });

package/lib/test/unit/writer_spec.js

@@ -0,0 +1,84 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * 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.
+ * 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.js");
+
+var _writer = require("../../core/writer.js");
+
+var _util = require("../../shared/util.js");
+
+var _stream = require("../../core/stream.js");
+
+describe("Writer", function () {
+  describe("Incremental update", function () {
+    it("should update a file with new objects", function (done) {
+      const originalData = new Uint8Array();
+      const newRefs = [{
+        ref: _primitives.Ref.get(123, 0x2d),
+        data: "abc\n"
+      }, {
+        ref: _primitives.Ref.get(456, 0x4e),
+        data: "defg\n"
+      }];
+      const xrefInfo = {
+        newRef: _primitives.Ref.get(789, 0),
+        startXRef: 314,
+        fileIds: ["id", ""],
+        rootRef: null,
+        infoRef: null,
+        encrypt: null,
+        filename: "foo.pdf",
+        info: {}
+      };
+      let data = (0, _writer.incrementalUpdate)(originalData, xrefInfo, newRefs);
+      data = (0, _util.bytesToString)(data);
+      const expected = "\nabc\n" + "defg\n" + "789 0 obj\n" + "<< /Size 790 /Prev 314 /Type /XRef /Index [0 1 123 1 456 1 789 1] " + "/ID [(id) (\x01#Eg\x89\xab\xcd\xef\xfe\xdc\xba\x98vT2\x10)] " + "/W [1 1 2] /Length 16>> stream\n" + "\x00\x01\xff\xff" + "\x01\x01\x00\x2d" + "\x01\x05\x00\x4e" + "\x01\x0a\x00\x00\n" + "endstream\n" + "endobj\n" + "startxref\n" + "10\n" + "%%EOF\n";
+      expect(data).toEqual(expected);
+      done();
+    });
+  });
+  describe("writeDict", function () {
+    it("should write a Dict", function (done) {
+      const dict = new _primitives.Dict(null);
+      dict.set("A", _primitives.Name.get("B"));
+      dict.set("B", _primitives.Ref.get(123, 456));
+      dict.set("C", 789);
+      dict.set("D", "hello world");
+      dict.set("E", "(hello\\world)");
+      dict.set("F", [1.23001, 4.50001, 6]);
+      const gdict = new _primitives.Dict(null);
+      gdict.set("H", 123.00001);
+      const string = "a stream";
+      const stream = new _stream.StringStream(string);
+      stream.dict = new _primitives.Dict(null);
+      stream.dict.set("Length", string.length);
+      gdict.set("I", stream);
+      dict.set("G", gdict);
+      const buffer = [];
+      (0, _writer.writeDict)(dict, buffer, null);
+      const expected = "<< /A /B /B 123 456 R /C 789 /D (hello world) " + "/E (\\(hello\\\\world\\)) /F [1.23 4.5 6] " + "/G << /H 123 /I << /Length 8>> stream\n" + "a stream\n" + "endstream\n>>>>";
+      expect(buffer.join("")).toEqual(expected);
+      done();
+    });
+  });
+});