pdfjs-dist 2.5.207 → 2.6.347

package/lib/test/unit/primitives_spec.js

@@ -23,25 +23,27 @@
 
 var _primitives = require("../../core/primitives.js");
 
+var _stream = require("../../core/stream.js");
+
 var _test_utils = require("./test_utils.js");
 
 describe("primitives", function () {
   describe("Name", function () {
     it("should retain the given name", function () {
-      var givenName = "Font";
+      const givenName = "Font";
 
-      var name = _primitives.Name.get(givenName);
+      const 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");
+      const firstFont = _primitives.Name.get("Font");
 
-      var secondFont = _primitives.Name.get("Font");
+      const secondFont = _primitives.Name.get("Font");
 
-      var firstSubtype = _primitives.Name.get("Subtype");
+      const firstSubtype = _primitives.Name.get("Subtype");
 
-      var secondSubtype = _primitives.Name.get("Subtype");
+      const secondSubtype = _primitives.Name.get("Subtype");
 
       expect(firstFont).toBe(secondFont);
       expect(firstSubtype).toBe(secondSubtype);
@@ -50,20 +52,20 @@ describe("primitives", function () {
   });
   describe("Cmd", function () {
     it("should retain the given cmd name", function () {
-      var givenCmd = "BT";
+      const givenCmd = "BT";
 
-      var cmd = _primitives.Cmd.get(givenCmd);
+      const 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");
+      const firstBT = _primitives.Cmd.get("BT");
 
-      var secondBT = _primitives.Cmd.get("BT");
+      const secondBT = _primitives.Cmd.get("BT");
 
-      var firstET = _primitives.Cmd.get("ET");
+      const firstET = _primitives.Cmd.get("ET");
 
-      var secondET = _primitives.Cmd.get("ET");
+      const secondET = _primitives.Cmd.get("ET");
 
       expect(firstBT).toBe(secondBT);
       expect(firstET).toBe(secondET);
@@ -71,23 +73,23 @@ describe("primitives", function () {
     });
   });
   describe("Dict", function () {
-    var checkInvalidHasValues = function (dict) {
+    const checkInvalidHasValues = function (dict) {
       expect(dict.has()).toBeFalsy();
       expect(dict.has("Prev")).toBeFalsy();
     };
 
-    var checkInvalidKeyValues = function (dict) {
+    const checkInvalidKeyValues = function (dict) {
       expect(dict.get()).toBeUndefined();
       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";
+    let emptyDict, dictWithSizeKey, dictWithManyKeys;
+    const storedSize = 42;
+    const testFontFile = "file1";
+    const testFontFile2 = "file2";
+    const testFontFile3 = "file3";
     beforeAll(function (done) {
       emptyDict = new _primitives.Dict();
       dictWithSizeKey = new _primitives.Dict();
@@ -101,6 +103,21 @@ describe("primitives", function () {
     afterAll(function () {
       emptyDict = dictWithSizeKey = dictWithManyKeys = null;
     });
+    it("should allow assigning an XRef table after creation", function () {
+      const dict = new _primitives.Dict(null);
+      expect(dict.xref).toEqual(null);
+      const xref = new _test_utils.XRefMock([]);
+      dict.assignXref(xref);
+      expect(dict.xref).toEqual(xref);
+    });
+    it("should return correct size", function () {
+      const dict = new _primitives.Dict(null);
+      expect(dict.size).toEqual(0);
+      dict.set("Type", _primitives.Name.get("Page"));
+      expect(dict.size).toEqual(1);
+      dict.set("Contents", _primitives.Ref.get(10, 0));
+      expect(dict.size).toEqual(2);
+    });
     it("should return invalid values for unknown keys", function () {
       checkInvalidHasValues(emptyDict);
       checkInvalidKeyValues(emptyDict);
@@ -132,7 +149,7 @@ describe("primitives", function () {
       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")];
+      const keyPromises = [dictWithManyKeys.getAsync("Size"), dictWithSizeKey.getAsync("FontFile", "FontFile2", "FontFile3")];
       Promise.all(keyPromises).then(function (values) {
         expect(values[0]).toBeUndefined();
         expect(values[1]).toBeUndefined();
@@ -142,7 +159,7 @@ describe("primitives", function () {
       });
     });
     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")];
+      const 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);
@@ -153,23 +170,23 @@ describe("primitives", function () {
       });
     });
     it("should callback for each stored key", function () {
-      var callbackSpy = jasmine.createSpy("spy on callback in dictionary");
+      const callbackSpy = jasmine.createSpy("spy on callback in dictionary");
       dictWithManyKeys.forEach(callbackSpy);
       expect(callbackSpy).toHaveBeenCalled();
-      var callbackSpyCalls = callbackSpy.calls;
+      const 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.count()).toEqual(3);
     });
     it("should handle keys pointing to indirect objects, both sync and async", function (done) {
-      var fontRef = _primitives.Ref.get(1, 0);
+      const fontRef = _primitives.Ref.get(1, 0);
 
-      var xref = new _test_utils.XRefMock([{
+      const xref = new _test_utils.XRefMock([{
         ref: fontRef,
         data: testFontFile
       }]);
-      var fontDict = new _primitives.Dict(xref);
+      const fontDict = new _primitives.Dict(xref);
       fontDict.set("FontFile", fontRef);
       expect(fontDict.getRaw("FontFile")).toEqual(fontRef);
       expect(fontDict.get("FontFile", "FontFile2", "FontFile3")).toEqual(testFontFile);
@@ -181,89 +198,241 @@ describe("primitives", function () {
       });
     });
     it("should handle arrays containing indirect objects", function () {
-      var minCoordRef = _primitives.Ref.get(1, 0),
-          maxCoordRef = _primitives.Ref.get(2, 0);
+      const minCoordRef = _primitives.Ref.get(1, 0);
+
+      const maxCoordRef = _primitives.Ref.get(2, 0);
 
-      var minCoord = 0,
-          maxCoord = 1;
-      var xref = new _test_utils.XRefMock([{
+      const minCoord = 0;
+      const maxCoord = 1;
+      const xref = new _test_utils.XRefMock([{
         ref: minCoordRef,
         data: minCoord
       }, {
         ref: maxCoordRef,
         data: maxCoord
       }]);
-      var xObjectDict = new _primitives.Dict(xref);
+      const 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]);
     });
     it("should get all key names", function () {
-      var expectedKeys = ["FontFile", "FontFile2", "FontFile3"];
-      var keys = dictWithManyKeys.getKeys();
+      const expectedKeys = ["FontFile", "FontFile2", "FontFile3"];
+      const keys = dictWithManyKeys.getKeys();
       expect(keys.sort()).toEqual(expectedKeys);
     });
+    it("should get all raw values", function () {
+      const expectedRawValues1 = [testFontFile, testFontFile2, testFontFile3];
+      const rawValues1 = dictWithManyKeys.getRawValues();
+      expect(rawValues1.sort()).toEqual(expectedRawValues1);
+
+      const typeName = _primitives.Name.get("Page");
+
+      const resources = new _primitives.Dict(null),
+            resourcesRef = _primitives.Ref.get(5, 0);
+
+      const contents = new _stream.StringStream("data"),
+            contentsRef = _primitives.Ref.get(10, 0);
+
+      const xref = new _test_utils.XRefMock([{
+        ref: resourcesRef,
+        data: resources
+      }, {
+        ref: contentsRef,
+        data: contents
+      }]);
+      const dict = new _primitives.Dict(xref);
+      dict.set("Type", typeName);
+      dict.set("Resources", resourcesRef);
+      dict.set("Contents", contentsRef);
+      const expectedRawValues2 = [contentsRef, resourcesRef, typeName];
+      const rawValues2 = dict.getRawValues();
+      expect(rawValues2.sort()).toEqual(expectedRawValues2);
+    });
     it("should create only one object for Dict.empty", function () {
-      var firstDictEmpty = _primitives.Dict.empty;
-      var secondDictEmpty = _primitives.Dict.empty;
+      const firstDictEmpty = _primitives.Dict.empty;
+      const 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"];
-      var fontFileDict = new _primitives.Dict();
+      const expectedKeys = ["FontFile", "FontFile2", "FontFile3", "Size"];
+      const fontFileDict = new _primitives.Dict();
       fontFileDict.set("FontFile", "Type1 font file");
 
-      var mergedDict = _primitives.Dict.merge(null, [dictWithManyKeys, dictWithSizeKey, fontFileDict]);
+      const mergedDict = _primitives.Dict.merge({
+        xref: null,
+        dictArray: [dictWithManyKeys, dictWithSizeKey, fontFileDict]
+      });
 
-      var mergedKeys = mergedDict.getKeys();
+      const mergedKeys = mergedDict.getKeys();
       expect(mergedKeys.sort()).toEqual(expectedKeys);
       expect(mergedDict.get("FontFile")).toEqual(testFontFile);
     });
+    it("should correctly merge sub-dictionaries", function () {
+      const localFontDict = new _primitives.Dict();
+      localFontDict.set("F1", "Local font one");
+      const globalFontDict = new _primitives.Dict();
+      globalFontDict.set("F1", "Global font one");
+      globalFontDict.set("F2", "Global font two");
+      globalFontDict.set("F3", "Global font three");
+      const localDict = new _primitives.Dict();
+      localDict.set("Font", localFontDict);
+      const globalDict = new _primitives.Dict();
+      globalDict.set("Font", globalFontDict);
+
+      const mergedDict = _primitives.Dict.merge({
+        xref: null,
+        dictArray: [localDict, globalDict]
+      });
+
+      const mergedSubDict = _primitives.Dict.merge({
+        xref: null,
+        dictArray: [localDict, globalDict],
+        mergeSubDicts: true
+      });
+
+      const mergedFontDict = mergedDict.get("Font");
+      const mergedSubFontDict = mergedSubDict.get("Font");
+      expect(mergedFontDict instanceof _primitives.Dict).toEqual(true);
+      expect(mergedSubFontDict instanceof _primitives.Dict).toEqual(true);
+      const mergedFontDictKeys = mergedFontDict.getKeys();
+      const mergedSubFontDictKeys = mergedSubFontDict.getKeys();
+      expect(mergedFontDictKeys).toEqual(["F1"]);
+      expect(mergedSubFontDictKeys).toEqual(["F1", "F2", "F3"]);
+      const mergedFontDictValues = mergedFontDict.getRawValues();
+      const mergedSubFontDictValues = mergedSubFontDict.getRawValues();
+      expect(mergedFontDictValues).toEqual(["Local font one"]);
+      expect(mergedSubFontDictValues).toEqual(["Local font one", "Global font two", "Global font three"]);
+    });
   });
   describe("Ref", function () {
+    it("should get a string representation", function () {
+      const nonZeroRef = _primitives.Ref.get(4, 2);
+
+      expect(nonZeroRef.toString()).toEqual("4R2");
+
+      const zeroRef = _primitives.Ref.get(4, 0);
+
+      expect(zeroRef.toString()).toEqual("4R");
+    });
     it("should retain the stored values", function () {
-      var storedNum = 4;
-      var storedGen = 2;
+      const storedNum = 4;
+      const storedGen = 2;
 
-      var ref = _primitives.Ref.get(storedNum, storedGen);
+      const ref = _primitives.Ref.get(storedNum, storedGen);
 
       expect(ref.num).toEqual(storedNum);
       expect(ref.gen).toEqual(storedGen);
     });
+    it("should create only one object for a reference and cache it", function () {
+      const firstRef = _primitives.Ref.get(4, 2);
+
+      const secondRef = _primitives.Ref.get(4, 2);
+
+      const firstOtherRef = _primitives.Ref.get(5, 2);
+
+      const secondOtherRef = _primitives.Ref.get(5, 2);
+
+      expect(firstRef).toBe(secondRef);
+      expect(firstOtherRef).toBe(secondOtherRef);
+      expect(firstRef).not.toBe(firstOtherRef);
+    });
   });
   describe("RefSet", function () {
     it("should have a stored value", function () {
-      var ref = _primitives.Ref.get(4, 2);
+      const ref = _primitives.Ref.get(4, 2);
 
-      var refset = new _primitives.RefSet();
+      const refset = new _primitives.RefSet();
       refset.put(ref);
       expect(refset.has(ref)).toBeTruthy();
     });
     it("should not have an unknown value", function () {
-      var ref = _primitives.Ref.get(4, 2);
+      const ref = _primitives.Ref.get(4, 2);
 
-      var refset = new _primitives.RefSet();
+      const refset = new _primitives.RefSet();
       expect(refset.has(ref)).toBeFalsy();
       refset.put(ref);
 
-      var anotherRef = _primitives.Ref.get(2, 4);
+      const anotherRef = _primitives.Ref.get(2, 4);
 
       expect(refset.has(anotherRef)).toBeFalsy();
     });
   });
+  describe("RefSetCache", function () {
+    const ref1 = _primitives.Ref.get(4, 2);
+
+    const ref2 = _primitives.Ref.get(5, 2);
+
+    const obj1 = _primitives.Name.get("foo");
+
+    const obj2 = _primitives.Name.get("bar");
+
+    let cache;
+    beforeEach(function (done) {
+      cache = new _primitives.RefSetCache();
+      done();
+    });
+    afterEach(function () {
+      cache = null;
+    });
+    it("should put, have and get a value", function () {
+      cache.put(ref1, obj1);
+      expect(cache.has(ref1)).toBeTruthy();
+      expect(cache.has(ref2)).toBeFalsy();
+      expect(cache.get(ref1)).toBe(obj1);
+    });
+    it("should put, have and get a value by alias", function () {
+      cache.put(ref1, obj1);
+      cache.putAlias(ref2, ref1);
+      expect(cache.has(ref1)).toBeTruthy();
+      expect(cache.has(ref2)).toBeTruthy();
+      expect(cache.get(ref1)).toBe(obj1);
+      expect(cache.get(ref2)).toBe(obj1);
+    });
+    it("should report the size of the cache", function () {
+      cache.put(ref1, obj1);
+      expect(cache.size).toEqual(1);
+      cache.put(ref2, obj2);
+      expect(cache.size).toEqual(2);
+    });
+    it("should clear the cache", function () {
+      cache.put(ref1, obj1);
+      expect(cache.size).toEqual(1);
+      cache.clear();
+      expect(cache.size).toEqual(0);
+    });
+    it("should support iteration", function () {
+      cache.put(ref1, obj1);
+      cache.put(ref2, obj2);
+      const values = [];
+      cache.forEach(function (value) {
+        values.push(value);
+      });
+      expect(values).toEqual([obj1, obj2]);
+    });
+  });
+  describe("isEOF", function () {
+    it("handles non-EOF", function () {
+      const nonEOF = "foo";
+      expect((0, _primitives.isEOF)(nonEOF)).toEqual(false);
+    });
+    it("handles EOF", function () {
+      expect((0, _primitives.isEOF)(_primitives.EOF)).toEqual(true);
+    });
+  });
   describe("isName", function () {
     it("handles non-names", function () {
-      var nonName = {};
+      const nonName = {};
       expect((0, _primitives.isName)(nonName)).toEqual(false);
     });
     it("handles names", function () {
-      var name = _primitives.Name.get("Font");
+      const 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");
+      const name = _primitives.Name.get("Font");
 
       expect((0, _primitives.isName)(name, "Font")).toEqual(true);
       expect((0, _primitives.isName)(name, "Subtype")).toEqual(false);
@@ -271,16 +440,16 @@ describe("primitives", function () {
   });
   describe("isCmd", function () {
     it("handles non-commands", function () {
-      var nonCmd = {};
+      const nonCmd = {};
       expect((0, _primitives.isCmd)(nonCmd)).toEqual(false);
     });
     it("handles commands", function () {
-      var cmd = _primitives.Cmd.get("BT");
+      const 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");
+      const cmd = _primitives.Cmd.get("BT");
 
       expect((0, _primitives.isCmd)(cmd, "BT")).toEqual(true);
       expect((0, _primitives.isCmd)(cmd, "ET")).toEqual(false);
@@ -288,16 +457,16 @@ describe("primitives", function () {
   });
   describe("isDict", function () {
     it("handles non-dictionaries", function () {
-      var nonDict = {};
+      const nonDict = {};
       expect((0, _primitives.isDict)(nonDict)).toEqual(false);
     });
     it("handles empty dictionaries with type check", function () {
-      var dict = _primitives.Dict.empty;
+      const dict = _primitives.Dict.empty;
       expect((0, _primitives.isDict)(dict)).toEqual(true);
       expect((0, _primitives.isDict)(dict, "Page")).toEqual(false);
     });
     it("handles dictionaries with type check", function () {
-      var dict = new _primitives.Dict();
+      const 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);
@@ -305,29 +474,39 @@ describe("primitives", function () {
   });
   describe("isRef", function () {
     it("handles non-refs", function () {
-      var nonRef = {};
+      const nonRef = {};
       expect((0, _primitives.isRef)(nonRef)).toEqual(false);
     });
     it("handles refs", function () {
-      var ref = _primitives.Ref.get(1, 0);
+      const ref = _primitives.Ref.get(1, 0);
 
       expect((0, _primitives.isRef)(ref)).toEqual(true);
     });
   });
   describe("isRefsEqual", function () {
     it("should handle Refs pointing to the same object", function () {
-      var ref1 = _primitives.Ref.get(1, 0);
+      const ref1 = _primitives.Ref.get(1, 0);
 
-      var ref2 = _primitives.Ref.get(1, 0);
+      const 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 = _primitives.Ref.get(1, 0);
+      const ref1 = _primitives.Ref.get(1, 0);
 
-      var ref2 = _primitives.Ref.get(2, 0);
+      const ref2 = _primitives.Ref.get(2, 0);
 
       expect((0, _primitives.isRefsEqual)(ref1, ref2)).toEqual(false);
     });
   });
+  describe("isStream", function () {
+    it("handles non-streams", function () {
+      const nonStream = {};
+      expect((0, _primitives.isStream)(nonStream)).toEqual(false);
+    });
+    it("handles streams", function () {
+      const stream = new _stream.StringStream("foo");
+      expect((0, _primitives.isStream)(stream)).toEqual(true);
+    });
+  });
 });

package/lib/test/unit/test_utils.js

@@ -26,15 +26,18 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.buildGetDocumentParams = buildGetDocumentParams;
 exports.createIdFactory = createIdFactory;
-exports.TEST_PDFS_PATH = exports.XRefMock = exports.NodeCMapReaderFactory = exports.NodeCanvasFactory = exports.NodeFileReaderFactory = exports.DOMFileReaderFactory = void 0;
+exports.isEmptyObj = isEmptyObj;
+exports.TEST_PDFS_PATH = exports.XRefMock = exports.NodeFileReaderFactory = exports.DOMFileReaderFactory = void 0;
+
+var _primitives = require("../../core/primitives.js");
+
+var _document = require("../../core/document.js");
 
 var _util = require("../../shared/util.js");
 
 var _is_node = require("../../shared/is_node.js");
 
-var _primitives = require("../../core/primitives.js");
-
-var _document = require("../../core/document.js");
+var _stream = require("../../core/stream.js");
 
 class DOMFileReaderFactory {
   static async fetch(params) {
@@ -92,86 +95,14 @@ function buildGetDocumentParams(filename, options) {
   return params;
 }
 
-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;
-  }
-
-}
-
-exports.NodeCanvasFactory = NodeCanvasFactory;
-
-class NodeCMapReaderFactory {
-  constructor({
-    baseUrl = null,
-    isCompressed = false
-  }) {
-    this.baseUrl = baseUrl;
-    this.isCompressed = isCompressed;
-  }
-
-  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.");
-    }
-
-    const url = this.baseUrl + name + (this.isCompressed ? ".bcmap" : "");
-    const compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE;
-    return new Promise((resolve, reject) => {
-      const fs = require("fs");
-
-      fs.readFile(url, (error, data) => {
-        if (error || !data) {
-          reject(new Error(error));
-          return;
-        }
-
-        resolve({
-          cMapData: new Uint8Array(data),
-          compressionType
-        });
-      });
-    }).catch(reason => {
-      throw new Error(`Unable to load ${this.isCompressed ? "binary " : ""}` + `CMap at: ${url}`);
-    });
-  }
-
-}
-
-exports.NodeCMapReaderFactory = NodeCMapReaderFactory;
-
 class XRefMock {
   constructor(array) {
     this._map = Object.create(null);
+    this.stats = {
+      streamTypes: Object.create(null),
+      fontTypes: Object.create(null)
+    };
+    this._newRefNum = null;
 
     for (const key in array) {
       const obj = array[key];
@@ -179,6 +110,18 @@ class XRefMock {
     }
   }
 
+  getNewRef() {
+    if (this._newRefNum === null) {
+      this._newRefNum = Object.keys(this._map).length;
+    }
+
+    return _primitives.Ref.get(this._newRefNum++, 0);
+  }
+
+  resetNewRef() {
+    this.newRef = null;
+  }
+
   fetch(ref) {
     return this._map[ref.toString()];
   }
@@ -204,14 +147,24 @@ class XRefMock {
 exports.XRefMock = XRefMock;
 
 function createIdFactory(pageIndex) {
-  const page = new _document.Page({
-    pdfManager: {
-      get docId() {
-        return "d0";
-      }
+  const pdfManager = {
+    get docId() {
+      return "d0";
+    }
 
-    },
-    pageIndex
+  };
+  const stream = new _stream.StringStream("Dummy_PDF_data");
+  const pdfDocument = new _document.PDFDocument(pdfManager, stream);
+  const page = new _document.Page({
+    pdfManager: pdfDocument.pdfManager,
+    xref: pdfDocument.xref,
+    pageIndex,
+    globalIdFactory: pdfDocument._globalIdFactory
   });
-  return page.idFactory;
+  return page._localIdFactory;
+}
+
+function isEmptyObj(obj) {
+  (0, _util.assert)(typeof obj === "object" && obj !== null, "isEmptyObj - invalid argument.");
+  return Object.keys(obj).length === 0;
 }