d637b25e36
This is based on a real-world PDF file I encountered very recently[1], although I'm currently unable to recall where I saw it. Note that different PDF viewers handle these sort of errors differently, with Adobe Reader outright failing to render the attached PDF file whereas PDFium mostly handles it "correctly". The patch makes the following notable changes: - Refactor the `cropBox` and `mediaBox` getters, on the `Page`, to reduce unnecessary duplication. (This will also help in the future, if support for extracting additional page bounding boxes are added to the API.) - Ensure that the page bounding boxes, i.e. `cropBox` and `mediaBox`, are never empty to prevent issues/weirdness in the viewer. - Ensure that the `view` getter on the `Page` will never return an empty intersection of the `cropBox` and `mediaBox`. - Add an *optional* parameter to `Util.intersect`, to allow checking that the computed intersection isn't actually empty. - Change `Util.intersect` to have consistent return types, since Arrays are of type `Object` and falling back to returning a `Boolean` thus seem strange. --- [1] In that case I believe that only the `cropBox` was empty, but it seemed like a good idea to attempt to fix a bunch of related cases all at once.
696 lines
21 KiB
JavaScript
696 lines
21 KiB
JavaScript
/* Copyright 2012 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.
|
|
*/
|
|
/* eslint no-var: error */
|
|
|
|
import {
|
|
assert, bytesToString, FormatError, info, isArrayBuffer, isArrayEqual, isBool,
|
|
isNum, isSpace, isString, OPS, shadow, stringToBytes, stringToPDFString, Util,
|
|
warn
|
|
} from '../shared/util';
|
|
import { Catalog, ObjectLoader, XRef } from './obj';
|
|
import { Dict, isDict, isName, isStream, Ref } from './primitives';
|
|
import {
|
|
getInheritableProperty, MissingDataException, XRefEntryException,
|
|
XRefParseException
|
|
} from './core_utils';
|
|
import { NullStream, Stream, StreamsSequenceStream } from './stream';
|
|
import { AnnotationFactory } from './annotation';
|
|
import { calculateMD5 } from './crypto';
|
|
import { Linearization } from './parser';
|
|
import { OperatorList } from './operator_list';
|
|
import { PartialEvaluator } from './evaluator';
|
|
import { PDFFunctionFactory } from './function';
|
|
|
|
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, fontCache,
|
|
builtInCMapCache, pdfFunctionFactory, }) {
|
|
this.pdfManager = pdfManager;
|
|
this.pageIndex = pageIndex;
|
|
this.pageDict = pageDict;
|
|
this.xref = xref;
|
|
this.ref = ref;
|
|
this.fontCache = fontCache;
|
|
this.builtInCMapCache = builtInCMapCache;
|
|
this.pdfFunctionFactory = pdfFunctionFactory;
|
|
this.evaluatorOptions = pdfManager.evaluatorOptions;
|
|
this.resourcesPromise = null;
|
|
|
|
const idCounters = {
|
|
obj: 0,
|
|
};
|
|
this.idFactory = {
|
|
createObjId() {
|
|
return `p${pageIndex}_${++idCounters.obj}`;
|
|
},
|
|
getDocId() {
|
|
return `g_${pdfManager.docId}`;
|
|
},
|
|
};
|
|
}
|
|
|
|
/**
|
|
* @private
|
|
*/
|
|
_getInheritableProperty(key, getArray = false) {
|
|
const value = getInheritableProperty({ dict: this.pageDict, key, getArray,
|
|
stopWhenFound: false, });
|
|
if (!Array.isArray(value)) {
|
|
return value;
|
|
}
|
|
if (value.length === 1 || !isDict(value[0])) {
|
|
return value[0];
|
|
}
|
|
return Dict.merge(this.xref, value);
|
|
}
|
|
|
|
get content() {
|
|
return this.pageDict.get('Contents');
|
|
}
|
|
|
|
get resources() {
|
|
// For robustness: The spec states that a \Resources entry has to be
|
|
// present, but can be empty. Some documents still omit it; in this case
|
|
// we return an empty dictionary.
|
|
return shadow(this, 'resources',
|
|
this._getInheritableProperty('Resources') || Dict.empty);
|
|
}
|
|
|
|
_getBoundingBox(name) {
|
|
const box = this._getInheritableProperty(name, /* getArray = */ true);
|
|
|
|
if (Array.isArray(box) && box.length === 4) {
|
|
if ((box[2] - box[0]) !== 0 && (box[3] - box[1]) !== 0) {
|
|
return box;
|
|
}
|
|
warn(`Empty /${name} entry.`);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
get mediaBox() {
|
|
// Reset invalid media box to letter size.
|
|
return shadow(this, 'mediaBox',
|
|
this._getBoundingBox('MediaBox') || LETTER_SIZE_MEDIABOX);
|
|
}
|
|
|
|
get cropBox() {
|
|
// Reset invalid crop box to media box.
|
|
return shadow(this, 'cropBox',
|
|
this._getBoundingBox('CropBox') || this.mediaBox);
|
|
}
|
|
|
|
get userUnit() {
|
|
let obj = this.pageDict.get('UserUnit');
|
|
if (!isNum(obj) || obj <= 0) {
|
|
obj = DEFAULT_USER_UNIT;
|
|
}
|
|
return shadow(this, 'userUnit', obj);
|
|
}
|
|
|
|
get view() {
|
|
// From the spec, 6th ed., p.963:
|
|
// "The crop, bleed, trim, and art boxes should not ordinarily
|
|
// extend beyond the boundaries of the media box. If they do, they are
|
|
// effectively reduced to their intersection with the media box."
|
|
const { cropBox, mediaBox, } = this;
|
|
let view;
|
|
if (cropBox === mediaBox || isArrayEqual(cropBox, mediaBox)) {
|
|
view = mediaBox;
|
|
} else {
|
|
const box = Util.intersect(cropBox, mediaBox, /* skipEmpty = */ true);
|
|
if (box) {
|
|
view = box;
|
|
} else {
|
|
warn('Empty /CropBox and /MediaBox intersection.');
|
|
}
|
|
}
|
|
return shadow(this, 'view', view || mediaBox);
|
|
}
|
|
|
|
get rotate() {
|
|
let rotate = this._getInheritableProperty('Rotate') || 0;
|
|
|
|
// Normalize rotation so it's a multiple of 90 and between 0 and 270.
|
|
if (rotate % 90 !== 0) {
|
|
rotate = 0;
|
|
} else if (rotate >= 360) {
|
|
rotate = rotate % 360;
|
|
} else if (rotate < 0) {
|
|
// The spec doesn't cover negatives. Assume it's counterclockwise
|
|
// rotation. The following is the other implementation of modulo.
|
|
rotate = ((rotate % 360) + 360) % 360;
|
|
}
|
|
return shadow(this, 'rotate', rotate);
|
|
}
|
|
|
|
getContentStream() {
|
|
const content = this.content;
|
|
let stream;
|
|
|
|
if (Array.isArray(content)) {
|
|
// Fetching the individual streams from the array.
|
|
const xref = this.xref;
|
|
const streams = [];
|
|
for (const stream of content) {
|
|
streams.push(xref.fetchIfRef(stream));
|
|
}
|
|
stream = new StreamsSequenceStream(streams);
|
|
} else if (isStream(content)) {
|
|
stream = content;
|
|
} else {
|
|
// Replace non-existent page content with empty content.
|
|
stream = new NullStream();
|
|
}
|
|
return stream;
|
|
}
|
|
|
|
loadResources(keys) {
|
|
if (!this.resourcesPromise) {
|
|
// TODO: add async `_getInheritableProperty` and remove this.
|
|
this.resourcesPromise = this.pdfManager.ensure(this, 'resources');
|
|
}
|
|
return this.resourcesPromise.then(() => {
|
|
const objectLoader = new ObjectLoader(this.resources, keys, this.xref);
|
|
return objectLoader.load();
|
|
});
|
|
}
|
|
|
|
getOperatorList({ handler, task, intent, renderInteractiveForms, }) {
|
|
const contentStreamPromise = this.pdfManager.ensure(this,
|
|
'getContentStream');
|
|
const resourcesPromise = this.loadResources([
|
|
'ExtGState',
|
|
'ColorSpace',
|
|
'Pattern',
|
|
'Shading',
|
|
'XObject',
|
|
'Font',
|
|
]);
|
|
|
|
const partialEvaluator = new PartialEvaluator({
|
|
xref: this.xref,
|
|
handler,
|
|
pageIndex: this.pageIndex,
|
|
idFactory: this.idFactory,
|
|
fontCache: this.fontCache,
|
|
builtInCMapCache: this.builtInCMapCache,
|
|
options: this.evaluatorOptions,
|
|
pdfFunctionFactory: this.pdfFunctionFactory,
|
|
});
|
|
|
|
const dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
|
|
const pageListPromise = dataPromises.then(([contentStream]) => {
|
|
const opList = new OperatorList(intent, handler, this.pageIndex);
|
|
|
|
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;
|
|
});
|
|
});
|
|
|
|
// Fetch the page's annotations and add their operator lists to the
|
|
// page's operator list to render them.
|
|
return Promise.all([pageListPromise, this._parsedAnnotations]).then(
|
|
function([pageOpList, annotations]) {
|
|
if (annotations.length === 0) {
|
|
pageOpList.flush(true);
|
|
return pageOpList;
|
|
}
|
|
|
|
// Collect the operator list promises for the annotations. Each promise
|
|
// is resolved with the complete operator list for a single annotation.
|
|
const opListPromises = [];
|
|
for (const annotation of annotations) {
|
|
if (isAnnotationRenderable(annotation, intent)) {
|
|
opListPromises.push(annotation.getOperatorList(
|
|
partialEvaluator, task, renderInteractiveForms));
|
|
}
|
|
}
|
|
|
|
return Promise.all(opListPromises).then(function(opLists) {
|
|
pageOpList.addOp(OPS.beginAnnotations, []);
|
|
for (const opList of opLists) {
|
|
pageOpList.addOpList(opList);
|
|
}
|
|
pageOpList.addOp(OPS.endAnnotations, []);
|
|
pageOpList.flush(true);
|
|
return pageOpList;
|
|
});
|
|
});
|
|
}
|
|
|
|
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 PartialEvaluator({
|
|
xref: this.xref,
|
|
handler,
|
|
pageIndex: this.pageIndex,
|
|
idFactory: this.idFactory,
|
|
fontCache: this.fontCache,
|
|
builtInCMapCache: this.builtInCMapCache,
|
|
options: this.evaluatorOptions,
|
|
pdfFunctionFactory: this.pdfFunctionFactory,
|
|
});
|
|
|
|
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 shadow(this, 'annotations',
|
|
this._getInheritableProperty('Annots') || []);
|
|
}
|
|
|
|
get _parsedAnnotations() {
|
|
const parsedAnnotations =
|
|
this.pdfManager.ensure(this, 'annotations').then(() => {
|
|
const annotationRefs = this.annotations;
|
|
const annotationPromises = [];
|
|
for (let i = 0, ii = annotationRefs.length; i < ii; i++) {
|
|
annotationPromises.push(AnnotationFactory.create(
|
|
this.xref, annotationRefs[i], this.pdfManager, this.idFactory));
|
|
}
|
|
|
|
return Promise.all(annotationPromises).then(function(annotations) {
|
|
return annotations.filter(function isDefined(annotation) {
|
|
return !!annotation;
|
|
});
|
|
}, function(reason) {
|
|
warn(`_parsedAnnotations: "${reason}".`);
|
|
return [];
|
|
});
|
|
});
|
|
|
|
return shadow(this, '_parsedAnnotations', parsedAnnotations);
|
|
}
|
|
}
|
|
|
|
const FINGERPRINT_FIRST_BYTES = 1024;
|
|
const EMPTY_FINGERPRINT = '\x00\x00\x00\x00\x00\x00\x00' +
|
|
'\x00\x00\x00\x00\x00\x00\x00\x00\x00';
|
|
|
|
function find(stream, needle, limit, backwards = false) {
|
|
assert(limit > 0, 'The "limit" must be a positive integer.');
|
|
|
|
const str = bytesToString(stream.peekBytes(limit));
|
|
|
|
const index = backwards ? str.lastIndexOf(needle) : str.indexOf(needle);
|
|
if (index === -1) {
|
|
return false;
|
|
}
|
|
stream.pos += index;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* The `PDFDocument` class holds all the data of the PDF file. There exists
|
|
* one `PDFDocument` object on the main thread and one object for each worker.
|
|
* If no worker support is enabled, two `PDFDocument` objects are created on
|
|
* the main thread.
|
|
*/
|
|
class PDFDocument {
|
|
constructor(pdfManager, arg) {
|
|
let stream;
|
|
if (isStream(arg)) {
|
|
stream = arg;
|
|
} else if (isArrayBuffer(arg)) {
|
|
stream = new Stream(arg);
|
|
} else {
|
|
throw new Error('PDFDocument: Unknown argument type');
|
|
}
|
|
if (stream.length <= 0) {
|
|
throw new Error('PDFDocument: Stream must have data');
|
|
}
|
|
|
|
this.pdfManager = pdfManager;
|
|
this.stream = stream;
|
|
this.xref = new XRef(stream, pdfManager);
|
|
|
|
this.pdfFunctionFactory = new PDFFunctionFactory({
|
|
xref: this.xref,
|
|
isEvalSupported: pdfManager.evaluatorOptions.isEvalSupported,
|
|
});
|
|
this._pagePromises = [];
|
|
}
|
|
|
|
parse(recoveryMode) {
|
|
this.setup(recoveryMode);
|
|
|
|
const version = this.catalog.catDict.get('Version');
|
|
if (isName(version)) {
|
|
this.pdfFormatVersion = version.name;
|
|
}
|
|
|
|
// Check if AcroForms are present in the document.
|
|
try {
|
|
this.acroForm = this.catalog.catDict.get('AcroForm');
|
|
if (this.acroForm) {
|
|
this.xfa = this.acroForm.get('XFA');
|
|
const fields = this.acroForm.get('Fields');
|
|
if ((!Array.isArray(fields) || fields.length === 0) && !this.xfa) {
|
|
this.acroForm = null; // No fields and no XFA, so it's not a form.
|
|
}
|
|
}
|
|
} catch (ex) {
|
|
if (ex instanceof MissingDataException) {
|
|
throw ex;
|
|
}
|
|
info('Cannot fetch AcroForm entry; assuming no AcroForms are present');
|
|
this.acroForm = null;
|
|
}
|
|
|
|
// Check if a Collection dictionary is present in the document.
|
|
try {
|
|
const collection = this.catalog.catDict.get('Collection');
|
|
if (isDict(collection) && collection.getKeys().length > 0) {
|
|
this.collection = collection;
|
|
}
|
|
} catch (ex) {
|
|
if (ex instanceof MissingDataException) {
|
|
throw ex;
|
|
}
|
|
info('Cannot fetch Collection dictionary.');
|
|
}
|
|
}
|
|
|
|
get linearization() {
|
|
let linearization = null;
|
|
try {
|
|
linearization = Linearization.create(this.stream);
|
|
} catch (err) {
|
|
if (err instanceof MissingDataException) {
|
|
throw err;
|
|
}
|
|
info(err);
|
|
}
|
|
return shadow(this, 'linearization', linearization);
|
|
}
|
|
|
|
get startXRef() {
|
|
const stream = this.stream;
|
|
let startXRef = 0;
|
|
|
|
if (this.linearization) {
|
|
// Find the end of the first object.
|
|
stream.reset();
|
|
if (find(stream, 'endobj', 1024)) {
|
|
startXRef = stream.pos + 6;
|
|
}
|
|
} else {
|
|
// Find `startxref` by checking backwards from the end of the file.
|
|
const step = 1024;
|
|
const startXRefLength = 'startxref'.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', step, true);
|
|
}
|
|
|
|
if (found) {
|
|
stream.skip(9);
|
|
let ch;
|
|
do {
|
|
ch = stream.getByte();
|
|
} while (isSpace(ch));
|
|
let str = '';
|
|
while (ch >= 0x20 && ch <= 0x39) { // < '9'
|
|
str += String.fromCharCode(ch);
|
|
ch = stream.getByte();
|
|
}
|
|
startXRef = parseInt(str, 10);
|
|
if (isNaN(startXRef)) {
|
|
startXRef = 0;
|
|
}
|
|
}
|
|
}
|
|
return shadow(this, 'startXRef', startXRef);
|
|
}
|
|
|
|
// Find the header, get the PDF format version and setup the
|
|
// stream to start from the header.
|
|
checkHeader() {
|
|
const stream = this.stream;
|
|
stream.reset();
|
|
|
|
if (!find(stream, '%PDF-', 1024)) {
|
|
// May not be a PDF file, but don't throw an error and let
|
|
// parsing continue.
|
|
return;
|
|
}
|
|
stream.moveStart();
|
|
|
|
// Read the PDF format version.
|
|
const MAX_PDF_VERSION_LENGTH = 12;
|
|
let version = '', ch;
|
|
while ((ch = stream.getByte()) > 0x20) { // Space
|
|
if (version.length >= MAX_PDF_VERSION_LENGTH) {
|
|
break;
|
|
}
|
|
version += String.fromCharCode(ch);
|
|
}
|
|
if (!this.pdfFormatVersion) {
|
|
// Remove the "%PDF-" prefix.
|
|
this.pdfFormatVersion = version.substring(5);
|
|
}
|
|
}
|
|
|
|
parseStartXRef() {
|
|
this.xref.setStartXRef(this.startXRef);
|
|
}
|
|
|
|
setup(recoveryMode) {
|
|
this.xref.parse(recoveryMode);
|
|
this.catalog = new Catalog(this.pdfManager, this.xref);
|
|
}
|
|
|
|
get numPages() {
|
|
const linearization = this.linearization;
|
|
const num = linearization ? linearization.numPages : this.catalog.numPages;
|
|
return shadow(this, 'numPages', num);
|
|
}
|
|
|
|
get documentInfo() {
|
|
const DocumentInfoValidators = {
|
|
Title: isString,
|
|
Author: isString,
|
|
Subject: isString,
|
|
Keywords: isString,
|
|
Creator: isString,
|
|
Producer: isString,
|
|
CreationDate: isString,
|
|
ModDate: isString,
|
|
Trapped: isName,
|
|
};
|
|
|
|
const docInfo = {
|
|
PDFFormatVersion: this.pdfFormatVersion,
|
|
IsLinearized: !!this.linearization,
|
|
IsAcroFormPresent: !!this.acroForm,
|
|
IsXFAPresent: !!this.xfa,
|
|
IsCollectionPresent: !!this.collection,
|
|
};
|
|
|
|
let infoDict;
|
|
try {
|
|
infoDict = this.xref.trailer.get('Info');
|
|
} catch (err) {
|
|
if (err instanceof MissingDataException) {
|
|
throw err;
|
|
}
|
|
info('The document information dictionary is invalid.');
|
|
}
|
|
|
|
if (isDict(infoDict)) {
|
|
// Fill the document info with valid entries from the specification,
|
|
// as well as any existing well-formed custom entries.
|
|
for (const key of infoDict.getKeys()) {
|
|
const value = infoDict.get(key);
|
|
|
|
if (DocumentInfoValidators[key]) {
|
|
// Make sure the (standard) value conforms to the specification.
|
|
if (DocumentInfoValidators[key](value)) {
|
|
docInfo[key] = (typeof value !== 'string' ?
|
|
value : stringToPDFString(value));
|
|
} else {
|
|
info(`Bad value in document info for "${key}".`);
|
|
}
|
|
} else if (typeof key === 'string') {
|
|
// For custom values, only accept white-listed types to prevent
|
|
// errors that would occur when trying to send non-serializable
|
|
// objects to the main-thread (for example `Dict` or `Stream`).
|
|
let customValue;
|
|
if (isString(value)) {
|
|
customValue = stringToPDFString(value);
|
|
} else if (isName(value) || isNum(value) || isBool(value)) {
|
|
customValue = value;
|
|
} else {
|
|
info(`Unsupported value in document info for (custom) "${key}".`);
|
|
continue;
|
|
}
|
|
|
|
if (!docInfo['Custom']) {
|
|
docInfo['Custom'] = Object.create(null);
|
|
}
|
|
docInfo['Custom'][key] = customValue;
|
|
}
|
|
}
|
|
}
|
|
return shadow(this, 'documentInfo', docInfo);
|
|
}
|
|
|
|
get fingerprint() {
|
|
let hash;
|
|
const idArray = this.xref.trailer.get('ID');
|
|
if (Array.isArray(idArray) && idArray[0] && isString(idArray[0]) &&
|
|
idArray[0] !== EMPTY_FINGERPRINT) {
|
|
hash = stringToBytes(idArray[0]);
|
|
} else {
|
|
hash = 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 shadow(this, 'fingerprint', fingerprintBuf.join(''));
|
|
}
|
|
|
|
_getLinearizationPage(pageIndex) {
|
|
const { catalog, linearization, } = this;
|
|
assert(linearization && linearization.pageFirst === pageIndex);
|
|
|
|
const ref = Ref.get(linearization.objectNumberFirst, 0);
|
|
return this.xref.fetchAsync(ref).then((obj) => {
|
|
// Ensure that the object that was found is actually a Page dictionary.
|
|
if (isDict(obj, 'Page') ||
|
|
(isDict(obj) && !obj.has('Type') && obj.has('Contents'))) {
|
|
if (ref && !catalog.pageKidsCountCache.has(ref)) {
|
|
catalog.pageKidsCountCache.put(ref, 1); // Cache the Page reference.
|
|
}
|
|
return [obj, ref];
|
|
}
|
|
throw new FormatError('The Linearization dictionary doesn\'t point ' +
|
|
'to a valid Page dictionary.');
|
|
}).catch((reason) => {
|
|
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,
|
|
fontCache: catalog.fontCache,
|
|
builtInCMapCache: catalog.builtInCMapCache,
|
|
pdfFunctionFactory: this.pdfFunctionFactory,
|
|
});
|
|
});
|
|
}
|
|
|
|
checkFirstPage() {
|
|
return this.getPage(0).catch((reason) => {
|
|
if (reason instanceof XRefEntryException) {
|
|
// Clear out the various caches to ensure that we haven't stored any
|
|
// inconsistent and/or incorrect state, since that could easily break
|
|
// subsequent `this.getPage` calls.
|
|
this._pagePromises.length = 0;
|
|
this.cleanup();
|
|
|
|
throw new XRefParseException();
|
|
}
|
|
});
|
|
}
|
|
|
|
fontFallback(id, handler) {
|
|
return this.catalog.fontFallback(id, handler);
|
|
}
|
|
|
|
cleanup() {
|
|
return this.catalog.cleanup();
|
|
}
|
|
}
|
|
|
|
export {
|
|
Page,
|
|
PDFDocument,
|
|
};
|