lib/core/document.js - pdfjs-dist - Git at Google

 /**
  * @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";

 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.PDFDocument = exports.Page = void 0;

 var _util = require("../shared/util.js");

 var _obj = require("./obj.js");

 var _primitives = require("./primitives.js");

 var _core_utils = require("./core_utils.js");

 var _stream = require("./stream.js");

 var _annotation = require("./annotation.js");

 var _crypto = require("./crypto.js");

 var _parser = require("./parser.js");

 var _operator_list = require("./operator_list.js");

 var _evaluator = require("./evaluator.js");

 const DEFAULT_USER_UNIT = 1.0;
 const LETTER_SIZE_MEDIABOX = [0, 0, 612, 792];

 function isAnnotationRenderable(annotation, intent) {
   return intent === "display" && annotation.viewable || intent === "print" && annotation.printable;
 }

 class Page {
   constructor({
     pdfManager,
     xref,
     pageIndex,
     pageDict,
     ref,
     globalIdFactory,
     fontCache,
     builtInCMapCache,
     globalImageCache
   }) {
     this.pdfManager = pdfManager;
     this.pageIndex = pageIndex;
     this.pageDict = pageDict;
     this.xref = xref;
     this.ref = ref;
     this.fontCache = fontCache;
     this.builtInCMapCache = builtInCMapCache;
     this.globalImageCache = globalImageCache;
     this.evaluatorOptions = pdfManager.evaluatorOptions;
     this.resourcesPromise = null;
     const idCounters = {
       obj: 0
     };
     this._localIdFactory = class extends globalIdFactory {
       static createObjId() {
         return `p${pageIndex}_${++idCounters.obj}`;
       }

     };
   }

   _getInheritableProperty(key, getArray = false) {
     const value = (0, _core_utils.getInheritableProperty)({
       dict: this.pageDict,
       key,
       getArray,
       stopWhenFound: false
     });

     if (!Array.isArray(value)) {
       return value;
     }

     if (value.length === 1 || !(0, _primitives.isDict)(value[0])) {
       return value[0];
     }

     return _primitives.Dict.merge({
       xref: this.xref,
       dictArray: value
     });
   }

   get content() {
     return this.pageDict.get("Contents");
   }

   get resources() {
     return (0, _util.shadow)(this, "resources", this._getInheritableProperty("Resources") || _primitives.Dict.empty);
   }

   _getBoundingBox(name) {
     const box = this._getInheritableProperty(name, true);

     if (Array.isArray(box) && box.length === 4) {
       if (box[2] - box[0] !== 0 && box[3] - box[1] !== 0) {
         return box;
       }

       (0, _util.warn)(`Empty /${name} entry.`);
     }

     return null;
   }

   get mediaBox() {
     return (0, _util.shadow)(this, "mediaBox", this._getBoundingBox("MediaBox") || LETTER_SIZE_MEDIABOX);
   }

   get cropBox() {
     return (0, _util.shadow)(this, "cropBox", this._getBoundingBox("CropBox") || this.mediaBox);
   }

   get userUnit() {
     let obj = this.pageDict.get("UserUnit");

     if (!(0, _util.isNum)(obj) || obj <= 0) {
       obj = DEFAULT_USER_UNIT;
     }

     return (0, _util.shadow)(this, "userUnit", obj);
   }

   get view() {
     const {
       cropBox,
       mediaBox
     } = this;
     let view;

     if (cropBox === mediaBox || (0, _util.isArrayEqual)(cropBox, mediaBox)) {
       view = mediaBox;
     } else {
       const box = _util.Util.intersect(cropBox, mediaBox);

       if (box && box[2] - box[0] !== 0 && box[3] - box[1] !== 0) {
         view = box;
       } else {
         (0, _util.warn)("Empty /CropBox and /MediaBox intersection.");
       }
     }

     return (0, _util.shadow)(this, "view", view || mediaBox);
   }

   get rotate() {
     let rotate = this._getInheritableProperty("Rotate") || 0;

     if (rotate % 90 !== 0) {
       rotate = 0;
     } else if (rotate >= 360) {
       rotate = rotate % 360;
     } else if (rotate < 0) {
       rotate = (rotate % 360 + 360) % 360;
     }

     return (0, _util.shadow)(this, "rotate", rotate);
   }

   getContentStream() {
     const content = this.content;
     let stream;

     if (Array.isArray(content)) {
       const xref = this.xref;
       const streams = [];

       for (const subStream of content) {
         streams.push(xref.fetchIfRef(subStream));
       }

       stream = new _stream.StreamsSequenceStream(streams);
     } else if ((0, _primitives.isStream)(content)) {
       stream = content;
     } else {
       stream = new _stream.NullStream();
     }

     return stream;
   }

   save(handler, task, annotationStorage) {
     const partialEvaluator = new _evaluator.PartialEvaluator({
       xref: this.xref,
       handler,
       pageIndex: this.pageIndex,
       idFactory: this._localIdFactory,
       fontCache: this.fontCache,
       builtInCMapCache: this.builtInCMapCache,
       globalImageCache: this.globalImageCache,
       options: this.evaluatorOptions
     });
     return this._parsedAnnotations.then(function (annotations) {
       const newRefsPromises = [];

       for (const annotation of annotations) {
         if (!isAnnotationRenderable(annotation, "print")) {
           continue;
         }

         newRefsPromises.push(annotation.save(partialEvaluator, task, annotationStorage).catch(function (reason) {
           (0, _util.warn)("save - ignoring annotation data during " + `"${task.name}" task: "${reason}".`);
           return null;
         }));
       }

       return Promise.all(newRefsPromises);
     });
   }

   loadResources(keys) {
     if (!this.resourcesPromise) {
       this.resourcesPromise = this.pdfManager.ensure(this, "resources");
     }

     return this.resourcesPromise.then(() => {
       const objectLoader = new _obj.ObjectLoader(this.resources, keys, this.xref);
       return objectLoader.load();
     });
   }

   getOperatorList({
     handler,
     sink,
     task,
     intent,
     renderInteractiveForms,
     annotationStorage
   }) {
     const contentStreamPromise = this.pdfManager.ensure(this, "getContentStream");
     const resourcesPromise = this.loadResources(["ExtGState", "ColorSpace", "Pattern", "Shading", "XObject", "Font"]);
     const partialEvaluator = new _evaluator.PartialEvaluator({
       xref: this.xref,
       handler,
       pageIndex: this.pageIndex,
       idFactory: this._localIdFactory,
       fontCache: this.fontCache,
       builtInCMapCache: this.builtInCMapCache,
       globalImageCache: this.globalImageCache,
       options: this.evaluatorOptions
     });
     const dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
     const pageListPromise = dataPromises.then(([contentStream]) => {
       const opList = new _operator_list.OperatorList(intent, sink);
       handler.send("StartRenderPage", {
         transparency: partialEvaluator.hasBlendModes(this.resources),
         pageIndex: this.pageIndex,
         intent
       });
       return partialEvaluator.getOperatorList({
         stream: contentStream,
         task,
         resources: this.resources,
         operatorList: opList
       }).then(function () {
         return opList;
       });
     });
     return Promise.all([pageListPromise, this._parsedAnnotations]).then(function ([pageOpList, annotations]) {
       if (annotations.length === 0) {
         pageOpList.flush(true);
         return {
           length: pageOpList.totalLength
         };
       }

       const opListPromises = [];

       for (const annotation of annotations) {
         if (isAnnotationRenderable(annotation, intent)) {
           opListPromises.push(annotation.getOperatorList(partialEvaluator, task, renderInteractiveForms, annotationStorage).catch(function (reason) {
             (0, _util.warn)("getOperatorList - ignoring annotation data during " + `"${task.name}" task: "${reason}".`);
             return null;
           }));
         }
       }

       return Promise.all(opListPromises).then(function (opLists) {
         pageOpList.addOp(_util.OPS.beginAnnotations, []);

         for (const opList of opLists) {
           pageOpList.addOpList(opList);
         }

         pageOpList.addOp(_util.OPS.endAnnotations, []);
         pageOpList.flush(true);
         return {
           length: pageOpList.totalLength
         };
       });
     });
   }

   extractTextContent({
     handler,
     task,
     normalizeWhitespace,
     sink,
     combineTextItems
   }) {
     const contentStreamPromise = this.pdfManager.ensure(this, "getContentStream");
     const resourcesPromise = this.loadResources(["ExtGState", "XObject", "Font"]);
     const dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
     return dataPromises.then(([contentStream]) => {
       const partialEvaluator = new _evaluator.PartialEvaluator({
         xref: this.xref,
         handler,
         pageIndex: this.pageIndex,
         idFactory: this._localIdFactory,
         fontCache: this.fontCache,
         builtInCMapCache: this.builtInCMapCache,
         globalImageCache: this.globalImageCache,
         options: this.evaluatorOptions
       });
       return partialEvaluator.getTextContent({
         stream: contentStream,
         task,
         resources: this.resources,
         normalizeWhitespace,
         combineTextItems,
         sink
       });
     });
   }

   getAnnotationsData(intent) {
     return this._parsedAnnotations.then(function (annotations) {
       const annotationsData = [];

       for (let i = 0, ii = annotations.length; i < ii; i++) {
         if (!intent || isAnnotationRenderable(annotations[i], intent)) {
           annotationsData.push(annotations[i].data);
         }
       }

       return annotationsData;
     });
   }

   get annotations() {
     return (0, _util.shadow)(this, "annotations", this._getInheritableProperty("Annots") || []);
   }

   get _parsedAnnotations() {
     const parsedAnnotations = this.pdfManager.ensure(this, "annotations").then(() => {
       const annotationPromises = [];

       for (const annotationRef of this.annotations) {
         annotationPromises.push(_annotation.AnnotationFactory.create(this.xref, annotationRef, this.pdfManager, this._localIdFactory).catch(function (reason) {
           (0, _util.warn)(`_parsedAnnotations: "${reason}".`);
           return null;
         }));
       }

       return Promise.all(annotationPromises).then(function (annotations) {
         return annotations.filter(annotation => !!annotation);
       });
     });
     return (0, _util.shadow)(this, "_parsedAnnotations", parsedAnnotations);
   }

 }

 exports.Page = Page;
 const PDF_HEADER_SIGNATURE = new Uint8Array([0x25, 0x50, 0x44, 0x46, 0x2d]);
 const STARTXREF_SIGNATURE = new Uint8Array([0x73, 0x74, 0x61, 0x72, 0x74, 0x78, 0x72, 0x65, 0x66]);
 const ENDOBJ_SIGNATURE = new Uint8Array([0x65, 0x6e, 0x64, 0x6f, 0x62, 0x6a]);
 const FINGERPRINT_FIRST_BYTES = 1024;
 const EMPTY_FINGERPRINT = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
 const PDF_HEADER_VERSION_REGEXP = /^[1-9]\.[0-9]$/;

 function find(stream, signature, limit = 1024, backwards = false) {
   const signatureLength = signature.length;
   const scanBytes = stream.peekBytes(limit);
   const scanLength = scanBytes.length - signatureLength;

   if (scanLength <= 0) {
     return false;
   }

   if (backwards) {
     const signatureEnd = signatureLength - 1;
     let pos = scanBytes.length - 1;

     while (pos >= signatureEnd) {
       let j = 0;

       while (j < signatureLength && scanBytes[pos - j] === signature[signatureEnd - j]) {
         j++;
       }

       if (j >= signatureLength) {
         stream.pos += pos - signatureEnd;
         return true;
       }

       pos--;
     }
   } else {
     let pos = 0;

     while (pos <= scanLength) {
       let j = 0;

       while (j < signatureLength && scanBytes[pos + j] === signature[j]) {
         j++;
       }

       if (j >= signatureLength) {
         stream.pos += pos;
         return true;
       }

       pos++;
     }
   }

   return false;
 }

 class PDFDocument {
   constructor(pdfManager, arg) {
     let stream;

     if ((0, _primitives.isStream)(arg)) {
       stream = arg;
     } else if ((0, _util.isArrayBuffer)(arg)) {
       stream = new _stream.Stream(arg);
     } else {
       throw new Error("PDFDocument: Unknown argument type");
     }

     if (stream.length <= 0) {
       throw new _util.InvalidPDFException("The PDF file is empty, i.e. its size is zero bytes.");
     }

     this.pdfManager = pdfManager;
     this.stream = stream;
     this.xref = new _obj.XRef(stream, pdfManager);
     this._pagePromises = [];
     this._version = null;
     const idCounters = {
       font: 0
     };
     this._globalIdFactory = class {
       static getDocId() {
         return `g_${pdfManager.docId}`;
       }

       static createFontId() {
         return `f${++idCounters.font}`;
       }

       static createObjId() {
         (0, _util.unreachable)("Abstract method `createObjId` called.");
       }

     };
   }

   parse(recoveryMode) {
     this.xref.parse(recoveryMode);
     this.catalog = new _obj.Catalog(this.pdfManager, this.xref);

     if (this.catalog.version) {
       this._version = this.catalog.version;
     }
   }

   get linearization() {
     let linearization = null;

     try {
       linearization = _parser.Linearization.create(this.stream);
     } catch (err) {
       if (err instanceof _core_utils.MissingDataException) {
         throw err;
       }

       (0, _util.info)(err);
     }

     return (0, _util.shadow)(this, "linearization", linearization);
   }

   get startXRef() {
     const stream = this.stream;
     let startXRef = 0;

     if (this.linearization) {
       stream.reset();

       if (find(stream, ENDOBJ_SIGNATURE)) {
         startXRef = stream.pos + 6 - stream.start;
       }
     } else {
       const step = 1024;
       const startXRefLength = STARTXREF_SIGNATURE.length;
       let found = false,
           pos = stream.end;

       while (!found && pos > 0) {
         pos -= step - startXRefLength;

         if (pos < 0) {
           pos = 0;
         }

         stream.pos = pos;
         found = find(stream, STARTXREF_SIGNATURE, step, true);
       }

       if (found) {
         stream.skip(9);
         let ch;

         do {
           ch = stream.getByte();
         } while ((0, _core_utils.isWhiteSpace)(ch));

         let str = "";

         while (ch >= 0x20 && ch <= 0x39) {
           str += String.fromCharCode(ch);
           ch = stream.getByte();
         }

         startXRef = parseInt(str, 10);

         if (isNaN(startXRef)) {
           startXRef = 0;
         }
       }
     }

     return (0, _util.shadow)(this, "startXRef", startXRef);
   }

   checkHeader() {
     const stream = this.stream;
     stream.reset();

     if (!find(stream, PDF_HEADER_SIGNATURE)) {
       return;
     }

     stream.moveStart();
     const MAX_PDF_VERSION_LENGTH = 12;
     let version = "",
         ch;

     while ((ch = stream.getByte()) > 0x20) {
       if (version.length >= MAX_PDF_VERSION_LENGTH) {
         break;
       }

       version += String.fromCharCode(ch);
     }

     if (!this._version) {
       this._version = version.substring(5);
     }
   }

   parseStartXRef() {
     this.xref.setStartXRef(this.startXRef);
   }

   get numPages() {
     const linearization = this.linearization;
     const num = linearization ? linearization.numPages : this.catalog.numPages;
     return (0, _util.shadow)(this, "numPages", num);
   }

   _hasOnlyDocumentSignatures(fields, recursionDepth = 0) {
     const RECURSION_LIMIT = 10;
     return fields.every(field => {
       field = this.xref.fetchIfRef(field);

       if (field.has("Kids")) {
         if (++recursionDepth > RECURSION_LIMIT) {
           (0, _util.warn)("_hasOnlyDocumentSignatures: maximum recursion depth reached");
           return false;
         }

         return this._hasOnlyDocumentSignatures(field.get("Kids"), recursionDepth);
       }

       const isSignature = (0, _primitives.isName)(field.get("FT"), "Sig");
       const rectangle = field.get("Rect");
       const isInvisible = Array.isArray(rectangle) && rectangle.every(value => value === 0);
       return isSignature && isInvisible;
     });
   }

   get formInfo() {
     const formInfo = {
       hasAcroForm: false,
       hasXfa: false
     };
     const acroForm = this.catalog.acroForm;

     if (!acroForm) {
       return (0, _util.shadow)(this, "formInfo", formInfo);
     }

     try {
       const xfa = acroForm.get("XFA");
       const hasXfa = Array.isArray(xfa) && xfa.length > 0 || (0, _primitives.isStream)(xfa) && !xfa.isEmpty;
       formInfo.hasXfa = hasXfa;
       const fields = acroForm.get("Fields");
       const hasFields = Array.isArray(fields) && fields.length > 0;
       const sigFlags = acroForm.get("SigFlags");

       const hasOnlyDocumentSignatures = !!(sigFlags & 0x1) && this._hasOnlyDocumentSignatures(fields);

       formInfo.hasAcroForm = hasFields && !hasOnlyDocumentSignatures;
     } catch (ex) {
       if (ex instanceof _core_utils.MissingDataException) {
         throw ex;
       }

       (0, _util.info)("Cannot fetch form information.");
     }

     return (0, _util.shadow)(this, "formInfo", formInfo);
   }

   get documentInfo() {
     const DocumentInfoValidators = {
       Title: _util.isString,
       Author: _util.isString,
       Subject: _util.isString,
       Keywords: _util.isString,
       Creator: _util.isString,
       Producer: _util.isString,
       CreationDate: _util.isString,
       ModDate: _util.isString,
       Trapped: _primitives.isName
     };
     let version = this._version;

     if (typeof version !== "string" || !PDF_HEADER_VERSION_REGEXP.test(version)) {
       (0, _util.warn)(`Invalid PDF header version number: ${version}`);
       version = null;
     }

     const docInfo = {
       PDFFormatVersion: version,
       IsLinearized: !!this.linearization,
       IsAcroFormPresent: this.formInfo.hasAcroForm,
       IsXFAPresent: this.formInfo.hasXfa,
       IsCollectionPresent: !!this.catalog.collection
     };
     let infoDict;

     try {
       infoDict = this.xref.trailer.get("Info");
     } catch (err) {
       if (err instanceof _core_utils.MissingDataException) {
         throw err;
       }

       (0, _util.info)("The document information dictionary is invalid.");
     }

     if ((0, _primitives.isDict)(infoDict)) {
       for (const key of infoDict.getKeys()) {
         const value = infoDict.get(key);

         if (DocumentInfoValidators[key]) {
           if (DocumentInfoValidators[key](value)) {
             docInfo[key] = typeof value !== "string" ? value : (0, _util.stringToPDFString)(value);
           } else {
             (0, _util.info)(`Bad value in document info for "${key}".`);
           }
         } else if (typeof key === "string") {
           let customValue;

           if ((0, _util.isString)(value)) {
             customValue = (0, _util.stringToPDFString)(value);
           } else if ((0, _primitives.isName)(value) || (0, _util.isNum)(value) || (0, _util.isBool)(value)) {
             customValue = value;
           } else {
             (0, _util.info)(`Unsupported value in document info for (custom) "${key}".`);
             continue;
           }

           if (!docInfo.Custom) {
             docInfo.Custom = Object.create(null);
           }

           docInfo.Custom[key] = customValue;
         }
       }
     }

     return (0, _util.shadow)(this, "documentInfo", docInfo);
   }

   get fingerprint() {
     let hash;
     const idArray = this.xref.trailer.get("ID");

     if (Array.isArray(idArray) && idArray[0] && (0, _util.isString)(idArray[0]) && idArray[0] !== EMPTY_FINGERPRINT) {
       hash = (0, _util.stringToBytes)(idArray[0]);
     } else {
       hash = (0, _crypto.calculateMD5)(this.stream.getByteRange(0, FINGERPRINT_FIRST_BYTES), 0, FINGERPRINT_FIRST_BYTES);
     }

     const fingerprintBuf = [];

     for (let i = 0, ii = hash.length; i < ii; i++) {
       const hex = hash[i].toString(16);
       fingerprintBuf.push(hex.padStart(2, "0"));
     }

     return (0, _util.shadow)(this, "fingerprint", fingerprintBuf.join(""));
   }

   _getLinearizationPage(pageIndex) {
     const {
       catalog,
       linearization
     } = this;

     const ref = _primitives.Ref.get(linearization.objectNumberFirst, 0);

     return this.xref.fetchAsync(ref).then(obj => {
       if ((0, _primitives.isDict)(obj, "Page") || (0, _primitives.isDict)(obj) && !obj.has("Type") && obj.has("Contents")) {
         if (ref && !catalog.pageKidsCountCache.has(ref)) {
           catalog.pageKidsCountCache.put(ref, 1);
         }

         return [obj, ref];
       }

       throw new _util.FormatError("The Linearization dictionary doesn't point " + "to a valid Page dictionary.");
     }).catch(reason => {
       (0, _util.info)(reason);
       return catalog.getPageDict(pageIndex);
     });
   }

   getPage(pageIndex) {
     if (this._pagePromises[pageIndex] !== undefined) {
       return this._pagePromises[pageIndex];
     }

     const {
       catalog,
       linearization
     } = this;
     const promise = linearization && linearization.pageFirst === pageIndex ? this._getLinearizationPage(pageIndex) : catalog.getPageDict(pageIndex);
     return this._pagePromises[pageIndex] = promise.then(([pageDict, ref]) => {
       return new Page({
         pdfManager: this.pdfManager,
         xref: this.xref,
         pageIndex,
         pageDict,
         ref,
         globalIdFactory: this._globalIdFactory,
         fontCache: catalog.fontCache,
         builtInCMapCache: catalog.builtInCMapCache,
         globalImageCache: catalog.globalImageCache
       });
     });
   }

   checkFirstPage() {
     return this.getPage(0).catch(async reason => {
       if (reason instanceof _core_utils.XRefEntryException) {
         this._pagePromises.length = 0;
         await this.cleanup();
         throw new _core_utils.XRefParseException();
       }
     });
   }

   fontFallback(id, handler) {
     return this.catalog.fontFallback(id, handler);
   }

   async cleanup(manuallyTriggered = false) {
     return this.catalog ? this.catalog.cleanup(manuallyTriggered) : (0, _primitives.clearPrimitiveCaches)();
   }

 }

 exports.PDFDocument = PDFDocument;
	/**
	* @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";

	Object.defineProperty(exports, "__esModule", {
	value: true
	});
	exports.PDFDocument = exports.Page = void 0;

	var _util = require("../shared/util.js");

	var _obj = require("./obj.js");

	var _primitives = require("./primitives.js");

	var _core_utils = require("./core_utils.js");

	var _stream = require("./stream.js");

	var _annotation = require("./annotation.js");

	var _crypto = require("./crypto.js");

	var _parser = require("./parser.js");

	var _operator_list = require("./operator_list.js");

	var _evaluator = require("./evaluator.js");

	const DEFAULT_USER_UNIT = 1.0;
	const LETTER_SIZE_MEDIABOX = [0, 0, 612, 792];

	function isAnnotationRenderable(annotation, intent) {
	return intent === "display" && annotation.viewable \|\| intent === "print" && annotation.printable;
	}

	class Page {
	constructor({
	pdfManager,
	xref,
	pageIndex,
	pageDict,
	ref,
	globalIdFactory,
	fontCache,
	builtInCMapCache,
	globalImageCache
	}) {
	this.pdfManager = pdfManager;
	this.pageIndex = pageIndex;
	this.pageDict = pageDict;
	this.xref = xref;
	this.ref = ref;
	this.fontCache = fontCache;
	this.builtInCMapCache = builtInCMapCache;
	this.globalImageCache = globalImageCache;
	this.evaluatorOptions = pdfManager.evaluatorOptions;
	this.resourcesPromise = null;
	const idCounters = {
	obj: 0
	};
	this._localIdFactory = class extends globalIdFactory {
	static createObjId() {
	return `p${pageIndex}_${++idCounters.obj}`;
	}

	};
	}

	_getInheritableProperty(key, getArray = false) {
	const value = (0, _core_utils.getInheritableProperty)({
	dict: this.pageDict,
	key,
	getArray,
	stopWhenFound: false
	});

	if (!Array.isArray(value)) {
	return value;
	}

	if (value.length === 1 \|\| !(0, _primitives.isDict)(value[0])) {
	return value[0];
	}

	return _primitives.Dict.merge({
	xref: this.xref,
	dictArray: value
	});
	}

	get content() {
	return this.pageDict.get("Contents");
	}

	get resources() {
	return (0, _util.shadow)(this, "resources", this._getInheritableProperty("Resources") \|\| _primitives.Dict.empty);
	}

	_getBoundingBox(name) {
	const box = this._getInheritableProperty(name, true);

	if (Array.isArray(box) && box.length === 4) {
	if (box[2] - box[0] !== 0 && box[3] - box[1] !== 0) {
	return box;
	}

	(0, _util.warn)(`Empty /${name} entry.`);
	}

	return null;
	}

	get mediaBox() {
	return (0, _util.shadow)(this, "mediaBox", this._getBoundingBox("MediaBox") \|\| LETTER_SIZE_MEDIABOX);
	}

	get cropBox() {
	return (0, _util.shadow)(this, "cropBox", this._getBoundingBox("CropBox") \|\| this.mediaBox);
	}

	get userUnit() {
	let obj = this.pageDict.get("UserUnit");

	if (!(0, _util.isNum)(obj) \|\| obj <= 0) {
	obj = DEFAULT_USER_UNIT;
	}

	return (0, _util.shadow)(this, "userUnit", obj);
	}

	get view() {
	const {
	cropBox,
	mediaBox
	} = this;
	let view;

	if (cropBox === mediaBox \|\| (0, _util.isArrayEqual)(cropBox, mediaBox)) {
	view = mediaBox;
	} else {
	const box = _util.Util.intersect(cropBox, mediaBox);

	if (box && box[2] - box[0] !== 0 && box[3] - box[1] !== 0) {
	view = box;
	} else {
	(0, _util.warn)("Empty /CropBox and /MediaBox intersection.");
	}
	}

	return (0, _util.shadow)(this, "view", view \|\| mediaBox);
	}

	get rotate() {
	let rotate = this._getInheritableProperty("Rotate") \|\| 0;

	if (rotate % 90 !== 0) {
	rotate = 0;
	} else if (rotate >= 360) {
	rotate = rotate % 360;
	} else if (rotate < 0) {
	rotate = (rotate % 360 + 360) % 360;
	}

	return (0, _util.shadow)(this, "rotate", rotate);
	}

	getContentStream() {
	const content = this.content;
	let stream;

	if (Array.isArray(content)) {
	const xref = this.xref;
	const streams = [];

	for (const subStream of content) {
	streams.push(xref.fetchIfRef(subStream));
	}

	stream = new _stream.StreamsSequenceStream(streams);
	} else if ((0, _primitives.isStream)(content)) {
	stream = content;
	} else {
	stream = new _stream.NullStream();
	}

	return stream;
	}

	save(handler, task, annotationStorage) {
	const partialEvaluator = new _evaluator.PartialEvaluator({
	xref: this.xref,
	handler,
	pageIndex: this.pageIndex,
	idFactory: this._localIdFactory,
	fontCache: this.fontCache,
	builtInCMapCache: this.builtInCMapCache,
	globalImageCache: this.globalImageCache,
	options: this.evaluatorOptions
	});
	return this._parsedAnnotations.then(function (annotations) {
	const newRefsPromises = [];

	for (const annotation of annotations) {
	if (!isAnnotationRenderable(annotation, "print")) {
	continue;
	}

	newRefsPromises.push(annotation.save(partialEvaluator, task, annotationStorage).catch(function (reason) {
	(0, _util.warn)("save - ignoring annotation data during " + `"${task.name}" task: "${reason}".`);
	return null;
	}));
	}

	return Promise.all(newRefsPromises);
	});
	}

	loadResources(keys) {
	if (!this.resourcesPromise) {
	this.resourcesPromise = this.pdfManager.ensure(this, "resources");
	}

	return this.resourcesPromise.then(() => {
	const objectLoader = new _obj.ObjectLoader(this.resources, keys, this.xref);
	return objectLoader.load();
	});
	}

	getOperatorList({
	handler,
	sink,
	task,
	intent,
	renderInteractiveForms,
	annotationStorage
	}) {
	const contentStreamPromise = this.pdfManager.ensure(this, "getContentStream");
	const resourcesPromise = this.loadResources(["ExtGState", "ColorSpace", "Pattern", "Shading", "XObject", "Font"]);
	const partialEvaluator = new _evaluator.PartialEvaluator({
	xref: this.xref,
	handler,
	pageIndex: this.pageIndex,
	idFactory: this._localIdFactory,
	fontCache: this.fontCache,
	builtInCMapCache: this.builtInCMapCache,
	globalImageCache: this.globalImageCache,
	options: this.evaluatorOptions
	});
	const dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
	const pageListPromise = dataPromises.then(([contentStream]) => {
	const opList = new _operator_list.OperatorList(intent, sink);
	handler.send("StartRenderPage", {
	transparency: partialEvaluator.hasBlendModes(this.resources),
	pageIndex: this.pageIndex,
	intent
	});
	return partialEvaluator.getOperatorList({
	stream: contentStream,
	task,
	resources: this.resources,
	operatorList: opList
	}).then(function () {
	return opList;
	});
	});
	return Promise.all([pageListPromise, this._parsedAnnotations]).then(function ([pageOpList, annotations]) {
	if (annotations.length === 0) {
	pageOpList.flush(true);
	return {
	length: pageOpList.totalLength
	};
	}

	const opListPromises = [];

	for (const annotation of annotations) {
	if (isAnnotationRenderable(annotation, intent)) {
	opListPromises.push(annotation.getOperatorList(partialEvaluator, task, renderInteractiveForms, annotationStorage).catch(function (reason) {
	(0, _util.warn)("getOperatorList - ignoring annotation data during " + `"${task.name}" task: "${reason}".`);
	return null;
	}));
	}
	}

	return Promise.all(opListPromises).then(function (opLists) {
	pageOpList.addOp(_util.OPS.beginAnnotations, []);

	for (const opList of opLists) {
	pageOpList.addOpList(opList);
	}

	pageOpList.addOp(_util.OPS.endAnnotations, []);
	pageOpList.flush(true);
	return {
	length: pageOpList.totalLength
	};
	});
	});
	}

	extractTextContent({
	handler,
	task,
	normalizeWhitespace,
	sink,
	combineTextItems
	}) {
	const contentStreamPromise = this.pdfManager.ensure(this, "getContentStream");
	const resourcesPromise = this.loadResources(["ExtGState", "XObject", "Font"]);
	const dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
	return dataPromises.then(([contentStream]) => {
	const partialEvaluator = new _evaluator.PartialEvaluator({
	xref: this.xref,
	handler,
	pageIndex: this.pageIndex,
	idFactory: this._localIdFactory,
	fontCache: this.fontCache,
	builtInCMapCache: this.builtInCMapCache,
	globalImageCache: this.globalImageCache,
	options: this.evaluatorOptions
	});
	return partialEvaluator.getTextContent({
	stream: contentStream,
	task,
	resources: this.resources,
	normalizeWhitespace,
	combineTextItems,
	sink
	});
	});
	}

	getAnnotationsData(intent) {
	return this._parsedAnnotations.then(function (annotations) {
	const annotationsData = [];

	for (let i = 0, ii = annotations.length; i < ii; i++) {
	if (!intent \|\| isAnnotationRenderable(annotations[i], intent)) {
	annotationsData.push(annotations[i].data);
	}
	}

	return annotationsData;
	});
	}

	get annotations() {
	return (0, _util.shadow)(this, "annotations", this._getInheritableProperty("Annots") \|\| []);
	}

	get _parsedAnnotations() {
	const parsedAnnotations = this.pdfManager.ensure(this, "annotations").then(() => {
	const annotationPromises = [];

	for (const annotationRef of this.annotations) {
	annotationPromises.push(_annotation.AnnotationFactory.create(this.xref, annotationRef, this.pdfManager, this._localIdFactory).catch(function (reason) {
	(0, _util.warn)(`_parsedAnnotations: "${reason}".`);
	return null;
	}));
	}

	return Promise.all(annotationPromises).then(function (annotations) {
	return annotations.filter(annotation => !!annotation);
	});
	});
	return (0, _util.shadow)(this, "_parsedAnnotations", parsedAnnotations);
	}

	}

	exports.Page = Page;
	const PDF_HEADER_SIGNATURE = new Uint8Array([0x25, 0x50, 0x44, 0x46, 0x2d]);
	const STARTXREF_SIGNATURE = new Uint8Array([0x73, 0x74, 0x61, 0x72, 0x74, 0x78, 0x72, 0x65, 0x66]);
	const ENDOBJ_SIGNATURE = new Uint8Array([0x65, 0x6e, 0x64, 0x6f, 0x62, 0x6a]);
	const FINGERPRINT_FIRST_BYTES = 1024;
	const EMPTY_FINGERPRINT = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
	const PDF_HEADER_VERSION_REGEXP = /^[1-9]\.[0-9]$/;

	function find(stream, signature, limit = 1024, backwards = false) {
	const signatureLength = signature.length;
	const scanBytes = stream.peekBytes(limit);
	const scanLength = scanBytes.length - signatureLength;

	if (scanLength <= 0) {
	return false;
	}

	if (backwards) {
	const signatureEnd = signatureLength - 1;
	let pos = scanBytes.length - 1;

	while (pos >= signatureEnd) {
	let j = 0;

	while (j < signatureLength && scanBytes[pos - j] === signature[signatureEnd - j]) {
	j++;
	}

	if (j >= signatureLength) {
	stream.pos += pos - signatureEnd;
	return true;
	}

	pos--;
	}
	} else {
	let pos = 0;

	while (pos <= scanLength) {
	let j = 0;

	while (j < signatureLength && scanBytes[pos + j] === signature[j]) {
	j++;
	}

	if (j >= signatureLength) {
	stream.pos += pos;
	return true;
	}

	pos++;
	}
	}

	return false;
	}

	class PDFDocument {
	constructor(pdfManager, arg) {
	let stream;

	if ((0, _primitives.isStream)(arg)) {
	stream = arg;
	} else if ((0, _util.isArrayBuffer)(arg)) {
	stream = new _stream.Stream(arg);
	} else {
	throw new Error("PDFDocument: Unknown argument type");
	}

	if (stream.length <= 0) {
	throw new _util.InvalidPDFException("The PDF file is empty, i.e. its size is zero bytes.");
	}

	this.pdfManager = pdfManager;
	this.stream = stream;
	this.xref = new _obj.XRef(stream, pdfManager);
	this._pagePromises = [];
	this._version = null;
	const idCounters = {
	font: 0
	};
	this._globalIdFactory = class {
	static getDocId() {
	return `g_${pdfManager.docId}`;
	}

	static createFontId() {
	return `f${++idCounters.font}`;
	}

	static createObjId() {
	(0, _util.unreachable)("Abstract method `createObjId` called.");
	}

	};
	}

	parse(recoveryMode) {
	this.xref.parse(recoveryMode);
	this.catalog = new _obj.Catalog(this.pdfManager, this.xref);

	if (this.catalog.version) {
	this._version = this.catalog.version;
	}
	}

	get linearization() {
	let linearization = null;

	try {
	linearization = _parser.Linearization.create(this.stream);
	} catch (err) {
	if (err instanceof _core_utils.MissingDataException) {
	throw err;
	}

	(0, _util.info)(err);
	}

	return (0, _util.shadow)(this, "linearization", linearization);
	}

	get startXRef() {
	const stream = this.stream;
	let startXRef = 0;

	if (this.linearization) {
	stream.reset();

	if (find(stream, ENDOBJ_SIGNATURE)) {
	startXRef = stream.pos + 6 - stream.start;
	}
	} else {
	const step = 1024;
	const startXRefLength = STARTXREF_SIGNATURE.length;
	let found = false,
	pos = stream.end;

	while (!found && pos > 0) {
	pos -= step - startXRefLength;

	if (pos < 0) {
	pos = 0;
	}

	stream.pos = pos;
	found = find(stream, STARTXREF_SIGNATURE, step, true);
	}

	if (found) {
	stream.skip(9);
	let ch;

	do {
	ch = stream.getByte();
	} while ((0, _core_utils.isWhiteSpace)(ch));

	let str = "";

	while (ch >= 0x20 && ch <= 0x39) {
	str += String.fromCharCode(ch);
	ch = stream.getByte();
	}

	startXRef = parseInt(str, 10);

	if (isNaN(startXRef)) {
	startXRef = 0;
	}
	}
	}

	return (0, _util.shadow)(this, "startXRef", startXRef);
	}

	checkHeader() {
	const stream = this.stream;
	stream.reset();

	if (!find(stream, PDF_HEADER_SIGNATURE)) {
	return;
	}

	stream.moveStart();
	const MAX_PDF_VERSION_LENGTH = 12;
	let version = "",
	ch;

	while ((ch = stream.getByte()) > 0x20) {
	if (version.length >= MAX_PDF_VERSION_LENGTH) {
	break;
	}

	version += String.fromCharCode(ch);
	}

	if (!this._version) {
	this._version = version.substring(5);
	}
	}

	parseStartXRef() {
	this.xref.setStartXRef(this.startXRef);
	}

	get numPages() {
	const linearization = this.linearization;
	const num = linearization ? linearization.numPages : this.catalog.numPages;
	return (0, _util.shadow)(this, "numPages", num);
	}

	_hasOnlyDocumentSignatures(fields, recursionDepth = 0) {
	const RECURSION_LIMIT = 10;
	return fields.every(field => {
	field = this.xref.fetchIfRef(field);

	if (field.has("Kids")) {
	if (++recursionDepth > RECURSION_LIMIT) {
	(0, _util.warn)("_hasOnlyDocumentSignatures: maximum recursion depth reached");
	return false;
	}

	return this._hasOnlyDocumentSignatures(field.get("Kids"), recursionDepth);
	}

	const isSignature = (0, _primitives.isName)(field.get("FT"), "Sig");
	const rectangle = field.get("Rect");
	const isInvisible = Array.isArray(rectangle) && rectangle.every(value => value === 0);
	return isSignature && isInvisible;
	});
	}

	get formInfo() {
	const formInfo = {
	hasAcroForm: false,
	hasXfa: false
	};
	const acroForm = this.catalog.acroForm;

	if (!acroForm) {
	return (0, _util.shadow)(this, "formInfo", formInfo);
	}

	try {
	const xfa = acroForm.get("XFA");
	const hasXfa = Array.isArray(xfa) && xfa.length > 0 \|\| (0, _primitives.isStream)(xfa) && !xfa.isEmpty;
	formInfo.hasXfa = hasXfa;
	const fields = acroForm.get("Fields");
	const hasFields = Array.isArray(fields) && fields.length > 0;
	const sigFlags = acroForm.get("SigFlags");

	const hasOnlyDocumentSignatures = !!(sigFlags & 0x1) && this._hasOnlyDocumentSignatures(fields);

	formInfo.hasAcroForm = hasFields && !hasOnlyDocumentSignatures;
	} catch (ex) {
	if (ex instanceof _core_utils.MissingDataException) {
	throw ex;
	}

	(0, _util.info)("Cannot fetch form information.");
	}

	return (0, _util.shadow)(this, "formInfo", formInfo);
	}

	get documentInfo() {
	const DocumentInfoValidators = {
	Title: _util.isString,
	Author: _util.isString,
	Subject: _util.isString,
	Keywords: _util.isString,
	Creator: _util.isString,
	Producer: _util.isString,
	CreationDate: _util.isString,
	ModDate: _util.isString,
	Trapped: _primitives.isName
	};
	let version = this._version;

	if (typeof version !== "string" \|\| !PDF_HEADER_VERSION_REGEXP.test(version)) {
	(0, _util.warn)(`Invalid PDF header version number: ${version}`);
	version = null;
	}

	const docInfo = {
	PDFFormatVersion: version,
	IsLinearized: !!this.linearization,
	IsAcroFormPresent: this.formInfo.hasAcroForm,
	IsXFAPresent: this.formInfo.hasXfa,
	IsCollectionPresent: !!this.catalog.collection
	};
	let infoDict;

	try {
	infoDict = this.xref.trailer.get("Info");
	} catch (err) {
	if (err instanceof _core_utils.MissingDataException) {
	throw err;
	}

	(0, _util.info)("The document information dictionary is invalid.");
	}

	if ((0, _primitives.isDict)(infoDict)) {
	for (const key of infoDict.getKeys()) {
	const value = infoDict.get(key);

	if (DocumentInfoValidators[key]) {
	if (DocumentInfoValidators[key](value)) {
	docInfo[key] = typeof value !== "string" ? value : (0, _util.stringToPDFString)(value);
	} else {
	(0, _util.info)(`Bad value in document info for "${key}".`);
	}
	} else if (typeof key === "string") {
	let customValue;

	if ((0, _util.isString)(value)) {
	customValue = (0, _util.stringToPDFString)(value);
	} else if ((0, _primitives.isName)(value) \|\| (0, _util.isNum)(value) \|\| (0, _util.isBool)(value)) {
	customValue = value;
	} else {
	(0, _util.info)(`Unsupported value in document info for (custom) "${key}".`);
	continue;
	}

	if (!docInfo.Custom) {
	docInfo.Custom = Object.create(null);
	}

	docInfo.Custom[key] = customValue;
	}
	}
	}

	return (0, _util.shadow)(this, "documentInfo", docInfo);
	}

	get fingerprint() {
	let hash;
	const idArray = this.xref.trailer.get("ID");

	if (Array.isArray(idArray) && idArray[0] && (0, _util.isString)(idArray[0]) && idArray[0] !== EMPTY_FINGERPRINT) {
	hash = (0, _util.stringToBytes)(idArray[0]);
	} else {
	hash = (0, _crypto.calculateMD5)(this.stream.getByteRange(0, FINGERPRINT_FIRST_BYTES), 0, FINGERPRINT_FIRST_BYTES);
	}

	const fingerprintBuf = [];

	for (let i = 0, ii = hash.length; i < ii; i++) {
	const hex = hash[i].toString(16);
	fingerprintBuf.push(hex.padStart(2, "0"));
	}

	return (0, _util.shadow)(this, "fingerprint", fingerprintBuf.join(""));
	}

	_getLinearizationPage(pageIndex) {
	const {
	catalog,
	linearization
	} = this;

	const ref = _primitives.Ref.get(linearization.objectNumberFirst, 0);

	return this.xref.fetchAsync(ref).then(obj => {
	if ((0, _primitives.isDict)(obj, "Page") \|\| (0, _primitives.isDict)(obj) && !obj.has("Type") && obj.has("Contents")) {
	if (ref && !catalog.pageKidsCountCache.has(ref)) {
	catalog.pageKidsCountCache.put(ref, 1);
	}

	return [obj, ref];
	}

	throw new _util.FormatError("The Linearization dictionary doesn't point " + "to a valid Page dictionary.");
	}).catch(reason => {
	(0, _util.info)(reason);
	return catalog.getPageDict(pageIndex);
	});
	}

	getPage(pageIndex) {
	if (this._pagePromises[pageIndex] !== undefined) {
	return this._pagePromises[pageIndex];
	}

	const {
	catalog,
	linearization
	} = this;
	const promise = linearization && linearization.pageFirst === pageIndex ? this._getLinearizationPage(pageIndex) : catalog.getPageDict(pageIndex);
	return this._pagePromises[pageIndex] = promise.then(([pageDict, ref]) => {
	return new Page({
	pdfManager: this.pdfManager,
	xref: this.xref,
	pageIndex,
	pageDict,
	ref,
	globalIdFactory: this._globalIdFactory,
	fontCache: catalog.fontCache,
	builtInCMapCache: catalog.builtInCMapCache,
	globalImageCache: catalog.globalImageCache
	});
	});
	}

	checkFirstPage() {
	return this.getPage(0).catch(async reason => {
	if (reason instanceof _core_utils.XRefEntryException) {
	this._pagePromises.length = 0;
	await this.cleanup();
	throw new _core_utils.XRefParseException();
	}
	});
	}

	fontFallback(id, handler) {
	return this.catalog.fontFallback(id, handler);
	}

	async cleanup(manuallyTriggered = false) {
	return this.catalog ? this.catalog.cleanup(manuallyTriggered) : (0, _primitives.clearPrimitiveCaches)();
	}

	}

	exports.PDFDocument = PDFDocument;