2462 lines
63 KiB
JavaScript
2462 lines
63 KiB
JavaScript
/**
|
|
* @licstart The following is the entire license notice for the
|
|
* JavaScript code in this page
|
|
*
|
|
* Copyright 2022 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.build = exports.RenderTask = exports.PDFWorkerUtil = exports.PDFWorker = exports.PDFPageProxy = exports.PDFDocumentProxy = exports.PDFDocumentLoadingTask = exports.PDFDataRangeTransport = exports.LoopbackPort = exports.DefaultStandardFontDataFactory = exports.DefaultCanvasFactory = exports.DefaultCMapReaderFactory = void 0;
|
|
exports.getDocument = getDocument;
|
|
exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory;
|
|
exports.version = void 0;
|
|
|
|
var _util = require("../shared/util.js");
|
|
|
|
var _annotation_storage = require("./annotation_storage.js");
|
|
|
|
var _display_utils = require("./display_utils.js");
|
|
|
|
var _font_loader = require("./font_loader.js");
|
|
|
|
var _canvas = require("./canvas.js");
|
|
|
|
var _worker_options = require("./worker_options.js");
|
|
|
|
var _is_node = require("../shared/is_node.js");
|
|
|
|
var _message_handler = require("../shared/message_handler.js");
|
|
|
|
var _metadata = require("./metadata.js");
|
|
|
|
var _optional_content_config = require("./optional_content_config.js");
|
|
|
|
var _transport_stream = require("./transport_stream.js");
|
|
|
|
var _xfa_text = require("./xfa_text.js");
|
|
|
|
const DEFAULT_RANGE_CHUNK_SIZE = 65536;
|
|
const RENDERING_CANCELLED_TIMEOUT = 100;
|
|
let DefaultCanvasFactory = _display_utils.DOMCanvasFactory;
|
|
exports.DefaultCanvasFactory = DefaultCanvasFactory;
|
|
let DefaultCMapReaderFactory = _display_utils.DOMCMapReaderFactory;
|
|
exports.DefaultCMapReaderFactory = DefaultCMapReaderFactory;
|
|
let DefaultStandardFontDataFactory = _display_utils.DOMStandardFontDataFactory;
|
|
exports.DefaultStandardFontDataFactory = DefaultStandardFontDataFactory;
|
|
|
|
if (_is_node.isNodeJS) {
|
|
const {
|
|
NodeCanvasFactory,
|
|
NodeCMapReaderFactory,
|
|
NodeStandardFontDataFactory
|
|
} = require("./node_utils.js");
|
|
|
|
exports.DefaultCanvasFactory = DefaultCanvasFactory = NodeCanvasFactory;
|
|
exports.DefaultCMapReaderFactory = DefaultCMapReaderFactory = NodeCMapReaderFactory;
|
|
exports.DefaultStandardFontDataFactory = DefaultStandardFontDataFactory = NodeStandardFontDataFactory;
|
|
}
|
|
|
|
let createPDFNetworkStream;
|
|
|
|
function setPDFNetworkStreamFactory(pdfNetworkStreamFactory) {
|
|
createPDFNetworkStream = pdfNetworkStreamFactory;
|
|
}
|
|
|
|
function getDocument(src) {
|
|
const task = new PDFDocumentLoadingTask();
|
|
let source;
|
|
|
|
if (typeof src === "string" || src instanceof URL) {
|
|
source = {
|
|
url: src
|
|
};
|
|
} else if ((0, _util.isArrayBuffer)(src)) {
|
|
source = {
|
|
data: src
|
|
};
|
|
} else if (src instanceof PDFDataRangeTransport) {
|
|
source = {
|
|
range: src
|
|
};
|
|
} else {
|
|
if (typeof src !== "object") {
|
|
throw new Error("Invalid parameter in getDocument, " + "need either string, URL, TypedArray, or parameter object.");
|
|
}
|
|
|
|
if (!src.url && !src.data && !src.range) {
|
|
throw new Error("Invalid parameter object: need either .data, .range or .url");
|
|
}
|
|
|
|
source = src;
|
|
}
|
|
|
|
const params = Object.create(null);
|
|
let rangeTransport = null,
|
|
worker = null;
|
|
|
|
for (const key in source) {
|
|
const value = source[key];
|
|
|
|
switch (key) {
|
|
case "url":
|
|
if (typeof window !== "undefined") {
|
|
try {
|
|
params[key] = new URL(value, window.location).href;
|
|
continue;
|
|
} catch (ex) {
|
|
(0, _util.warn)(`Cannot create valid URL: "${ex}".`);
|
|
}
|
|
} else if (typeof value === "string" || value instanceof URL) {
|
|
params[key] = value.toString();
|
|
continue;
|
|
}
|
|
|
|
throw new Error("Invalid PDF url data: " + "either string or URL-object is expected in the url property.");
|
|
|
|
case "range":
|
|
rangeTransport = value;
|
|
continue;
|
|
|
|
case "worker":
|
|
worker = value;
|
|
continue;
|
|
|
|
case "data":
|
|
if (_is_node.isNodeJS && typeof Buffer !== "undefined" && value instanceof Buffer) {
|
|
params[key] = new Uint8Array(value);
|
|
} else if (value instanceof Uint8Array) {
|
|
break;
|
|
} else if (typeof value === "string") {
|
|
params[key] = (0, _util.stringToBytes)(value);
|
|
} else if (typeof value === "object" && value !== null && !isNaN(value.length)) {
|
|
params[key] = new Uint8Array(value);
|
|
} else if ((0, _util.isArrayBuffer)(value)) {
|
|
params[key] = new Uint8Array(value);
|
|
} else {
|
|
throw new Error("Invalid PDF binary data: either TypedArray, " + "string, or array-like object is expected in the data property.");
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
params[key] = value;
|
|
}
|
|
|
|
params.CMapReaderFactory = params.CMapReaderFactory || DefaultCMapReaderFactory;
|
|
params.StandardFontDataFactory = params.StandardFontDataFactory || DefaultStandardFontDataFactory;
|
|
params.ignoreErrors = params.stopAtErrors !== true;
|
|
params.fontExtraProperties = params.fontExtraProperties === true;
|
|
params.pdfBug = params.pdfBug === true;
|
|
params.enableXfa = params.enableXfa === true;
|
|
|
|
if (!Number.isInteger(params.rangeChunkSize) || params.rangeChunkSize < 1) {
|
|
params.rangeChunkSize = DEFAULT_RANGE_CHUNK_SIZE;
|
|
}
|
|
|
|
if (typeof params.docBaseUrl !== "string" || (0, _display_utils.isDataScheme)(params.docBaseUrl)) {
|
|
params.docBaseUrl = null;
|
|
}
|
|
|
|
if (!Number.isInteger(params.maxImageSize) || params.maxImageSize < -1) {
|
|
params.maxImageSize = -1;
|
|
}
|
|
|
|
if (typeof params.cMapUrl !== "string") {
|
|
params.cMapUrl = null;
|
|
}
|
|
|
|
if (typeof params.standardFontDataUrl !== "string") {
|
|
params.standardFontDataUrl = null;
|
|
}
|
|
|
|
if (typeof params.useWorkerFetch !== "boolean") {
|
|
params.useWorkerFetch = params.CMapReaderFactory === _display_utils.DOMCMapReaderFactory && params.StandardFontDataFactory === _display_utils.DOMStandardFontDataFactory;
|
|
}
|
|
|
|
if (typeof params.isEvalSupported !== "boolean") {
|
|
params.isEvalSupported = true;
|
|
}
|
|
|
|
if (typeof params.disableFontFace !== "boolean") {
|
|
params.disableFontFace = _is_node.isNodeJS;
|
|
}
|
|
|
|
if (typeof params.useSystemFonts !== "boolean") {
|
|
params.useSystemFonts = !_is_node.isNodeJS && !params.disableFontFace;
|
|
}
|
|
|
|
if (typeof params.ownerDocument !== "object" || params.ownerDocument === null) {
|
|
params.ownerDocument = globalThis.document;
|
|
}
|
|
|
|
if (typeof params.disableRange !== "boolean") {
|
|
params.disableRange = false;
|
|
}
|
|
|
|
if (typeof params.disableStream !== "boolean") {
|
|
params.disableStream = false;
|
|
}
|
|
|
|
if (typeof params.disableAutoFetch !== "boolean") {
|
|
params.disableAutoFetch = false;
|
|
}
|
|
|
|
(0, _util.setVerbosityLevel)(params.verbosity);
|
|
|
|
if (!worker) {
|
|
const workerParams = {
|
|
verbosity: params.verbosity,
|
|
port: _worker_options.GlobalWorkerOptions.workerPort
|
|
};
|
|
worker = workerParams.port ? PDFWorker.fromPort(workerParams) : new PDFWorker(workerParams);
|
|
task._worker = worker;
|
|
}
|
|
|
|
const docId = task.docId;
|
|
worker.promise.then(function () {
|
|
if (task.destroyed) {
|
|
throw new Error("Loading aborted");
|
|
}
|
|
|
|
const workerIdPromise = _fetchDocument(worker, params, rangeTransport, docId);
|
|
|
|
const networkStreamPromise = new Promise(function (resolve) {
|
|
let networkStream;
|
|
|
|
if (rangeTransport) {
|
|
networkStream = new _transport_stream.PDFDataTransportStream({
|
|
length: params.length,
|
|
initialData: params.initialData,
|
|
progressiveDone: params.progressiveDone,
|
|
contentDispositionFilename: params.contentDispositionFilename,
|
|
disableRange: params.disableRange,
|
|
disableStream: params.disableStream
|
|
}, rangeTransport);
|
|
} else if (!params.data) {
|
|
networkStream = createPDFNetworkStream({
|
|
url: params.url,
|
|
length: params.length,
|
|
httpHeaders: params.httpHeaders,
|
|
withCredentials: params.withCredentials,
|
|
rangeChunkSize: params.rangeChunkSize,
|
|
disableRange: params.disableRange,
|
|
disableStream: params.disableStream
|
|
});
|
|
}
|
|
|
|
resolve(networkStream);
|
|
});
|
|
return Promise.all([workerIdPromise, networkStreamPromise]).then(function ([workerId, networkStream]) {
|
|
if (task.destroyed) {
|
|
throw new Error("Loading aborted");
|
|
}
|
|
|
|
const messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port);
|
|
const transport = new WorkerTransport(messageHandler, task, networkStream, params);
|
|
task._transport = transport;
|
|
messageHandler.send("Ready", null);
|
|
});
|
|
}).catch(task._capability.reject);
|
|
return task;
|
|
}
|
|
|
|
async function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {
|
|
if (worker.destroyed) {
|
|
throw new Error("Worker was destroyed");
|
|
}
|
|
|
|
if (pdfDataRangeTransport) {
|
|
source.length = pdfDataRangeTransport.length;
|
|
source.initialData = pdfDataRangeTransport.initialData;
|
|
source.progressiveDone = pdfDataRangeTransport.progressiveDone;
|
|
source.contentDispositionFilename = pdfDataRangeTransport.contentDispositionFilename;
|
|
}
|
|
|
|
const workerId = await worker.messageHandler.sendWithPromise("GetDocRequest", {
|
|
docId,
|
|
apiVersion: '2.16.105',
|
|
source: {
|
|
data: source.data,
|
|
url: source.url,
|
|
password: source.password,
|
|
disableAutoFetch: source.disableAutoFetch,
|
|
rangeChunkSize: source.rangeChunkSize,
|
|
length: source.length
|
|
},
|
|
maxImageSize: source.maxImageSize,
|
|
disableFontFace: source.disableFontFace,
|
|
docBaseUrl: source.docBaseUrl,
|
|
ignoreErrors: source.ignoreErrors,
|
|
isEvalSupported: source.isEvalSupported,
|
|
fontExtraProperties: source.fontExtraProperties,
|
|
enableXfa: source.enableXfa,
|
|
useSystemFonts: source.useSystemFonts,
|
|
cMapUrl: source.useWorkerFetch ? source.cMapUrl : null,
|
|
standardFontDataUrl: source.useWorkerFetch ? source.standardFontDataUrl : null
|
|
});
|
|
|
|
if (source.data) {
|
|
source.data = null;
|
|
}
|
|
|
|
if (worker.destroyed) {
|
|
throw new Error("Worker was destroyed");
|
|
}
|
|
|
|
return workerId;
|
|
}
|
|
|
|
class PDFDocumentLoadingTask {
|
|
static #docId = 0;
|
|
|
|
constructor() {
|
|
this._capability = (0, _util.createPromiseCapability)();
|
|
this._transport = null;
|
|
this._worker = null;
|
|
this.docId = `d${PDFDocumentLoadingTask.#docId++}`;
|
|
this.destroyed = false;
|
|
this.onPassword = null;
|
|
this.onProgress = null;
|
|
this.onUnsupportedFeature = null;
|
|
}
|
|
|
|
get promise() {
|
|
return this._capability.promise;
|
|
}
|
|
|
|
async destroy() {
|
|
this.destroyed = true;
|
|
await this._transport?.destroy();
|
|
this._transport = null;
|
|
|
|
if (this._worker) {
|
|
this._worker.destroy();
|
|
|
|
this._worker = null;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
exports.PDFDocumentLoadingTask = PDFDocumentLoadingTask;
|
|
|
|
class PDFDataRangeTransport {
|
|
constructor(length, initialData, progressiveDone = false, contentDispositionFilename = null) {
|
|
this.length = length;
|
|
this.initialData = initialData;
|
|
this.progressiveDone = progressiveDone;
|
|
this.contentDispositionFilename = contentDispositionFilename;
|
|
this._rangeListeners = [];
|
|
this._progressListeners = [];
|
|
this._progressiveReadListeners = [];
|
|
this._progressiveDoneListeners = [];
|
|
this._readyCapability = (0, _util.createPromiseCapability)();
|
|
}
|
|
|
|
addRangeListener(listener) {
|
|
this._rangeListeners.push(listener);
|
|
}
|
|
|
|
addProgressListener(listener) {
|
|
this._progressListeners.push(listener);
|
|
}
|
|
|
|
addProgressiveReadListener(listener) {
|
|
this._progressiveReadListeners.push(listener);
|
|
}
|
|
|
|
addProgressiveDoneListener(listener) {
|
|
this._progressiveDoneListeners.push(listener);
|
|
}
|
|
|
|
onDataRange(begin, chunk) {
|
|
for (const listener of this._rangeListeners) {
|
|
listener(begin, chunk);
|
|
}
|
|
}
|
|
|
|
onDataProgress(loaded, total) {
|
|
this._readyCapability.promise.then(() => {
|
|
for (const listener of this._progressListeners) {
|
|
listener(loaded, total);
|
|
}
|
|
});
|
|
}
|
|
|
|
onDataProgressiveRead(chunk) {
|
|
this._readyCapability.promise.then(() => {
|
|
for (const listener of this._progressiveReadListeners) {
|
|
listener(chunk);
|
|
}
|
|
});
|
|
}
|
|
|
|
onDataProgressiveDone() {
|
|
this._readyCapability.promise.then(() => {
|
|
for (const listener of this._progressiveDoneListeners) {
|
|
listener();
|
|
}
|
|
});
|
|
}
|
|
|
|
transportReady() {
|
|
this._readyCapability.resolve();
|
|
}
|
|
|
|
requestDataRange(begin, end) {
|
|
(0, _util.unreachable)("Abstract method PDFDataRangeTransport.requestDataRange");
|
|
}
|
|
|
|
abort() {}
|
|
|
|
}
|
|
|
|
exports.PDFDataRangeTransport = PDFDataRangeTransport;
|
|
|
|
class PDFDocumentProxy {
|
|
constructor(pdfInfo, transport) {
|
|
this._pdfInfo = pdfInfo;
|
|
this._transport = transport;
|
|
Object.defineProperty(this, "fingerprint", {
|
|
get() {
|
|
(0, _display_utils.deprecated)("`PDFDocumentProxy.fingerprint`, " + "please use `PDFDocumentProxy.fingerprints` instead.");
|
|
return this.fingerprints[0];
|
|
}
|
|
|
|
});
|
|
Object.defineProperty(this, "getStats", {
|
|
value: async () => {
|
|
(0, _display_utils.deprecated)("`PDFDocumentProxy.getStats`, " + "please use the `PDFDocumentProxy.stats`-getter instead.");
|
|
return this.stats || {
|
|
streamTypes: {},
|
|
fontTypes: {}
|
|
};
|
|
}
|
|
});
|
|
}
|
|
|
|
get annotationStorage() {
|
|
return this._transport.annotationStorage;
|
|
}
|
|
|
|
get numPages() {
|
|
return this._pdfInfo.numPages;
|
|
}
|
|
|
|
get fingerprints() {
|
|
return this._pdfInfo.fingerprints;
|
|
}
|
|
|
|
get stats() {
|
|
return this._transport.stats;
|
|
}
|
|
|
|
get isPureXfa() {
|
|
return !!this._transport._htmlForXfa;
|
|
}
|
|
|
|
get allXfaHtml() {
|
|
return this._transport._htmlForXfa;
|
|
}
|
|
|
|
getPage(pageNumber) {
|
|
return this._transport.getPage(pageNumber);
|
|
}
|
|
|
|
getPageIndex(ref) {
|
|
return this._transport.getPageIndex(ref);
|
|
}
|
|
|
|
getDestinations() {
|
|
return this._transport.getDestinations();
|
|
}
|
|
|
|
getDestination(id) {
|
|
return this._transport.getDestination(id);
|
|
}
|
|
|
|
getPageLabels() {
|
|
return this._transport.getPageLabels();
|
|
}
|
|
|
|
getPageLayout() {
|
|
return this._transport.getPageLayout();
|
|
}
|
|
|
|
getPageMode() {
|
|
return this._transport.getPageMode();
|
|
}
|
|
|
|
getViewerPreferences() {
|
|
return this._transport.getViewerPreferences();
|
|
}
|
|
|
|
getOpenAction() {
|
|
return this._transport.getOpenAction();
|
|
}
|
|
|
|
getAttachments() {
|
|
return this._transport.getAttachments();
|
|
}
|
|
|
|
getJavaScript() {
|
|
return this._transport.getJavaScript();
|
|
}
|
|
|
|
getJSActions() {
|
|
return this._transport.getDocJSActions();
|
|
}
|
|
|
|
getOutline() {
|
|
return this._transport.getOutline();
|
|
}
|
|
|
|
getOptionalContentConfig() {
|
|
return this._transport.getOptionalContentConfig();
|
|
}
|
|
|
|
getPermissions() {
|
|
return this._transport.getPermissions();
|
|
}
|
|
|
|
getMetadata() {
|
|
return this._transport.getMetadata();
|
|
}
|
|
|
|
getMarkInfo() {
|
|
return this._transport.getMarkInfo();
|
|
}
|
|
|
|
getData() {
|
|
return this._transport.getData();
|
|
}
|
|
|
|
getDownloadInfo() {
|
|
return this._transport.downloadInfoCapability.promise;
|
|
}
|
|
|
|
cleanup(keepLoadedFonts = false) {
|
|
return this._transport.startCleanup(keepLoadedFonts || this.isPureXfa);
|
|
}
|
|
|
|
destroy() {
|
|
return this.loadingTask.destroy();
|
|
}
|
|
|
|
get loadingParams() {
|
|
return this._transport.loadingParams;
|
|
}
|
|
|
|
get loadingTask() {
|
|
return this._transport.loadingTask;
|
|
}
|
|
|
|
saveDocument() {
|
|
if (this._transport.annotationStorage.size <= 0) {
|
|
(0, _display_utils.deprecated)("saveDocument called while `annotationStorage` is empty, " + "please use the getData-method instead.");
|
|
}
|
|
|
|
return this._transport.saveDocument();
|
|
}
|
|
|
|
getFieldObjects() {
|
|
return this._transport.getFieldObjects();
|
|
}
|
|
|
|
hasJSActions() {
|
|
return this._transport.hasJSActions();
|
|
}
|
|
|
|
getCalculationOrderIds() {
|
|
return this._transport.getCalculationOrderIds();
|
|
}
|
|
|
|
}
|
|
|
|
exports.PDFDocumentProxy = PDFDocumentProxy;
|
|
|
|
class PDFPageProxy {
|
|
constructor(pageIndex, pageInfo, transport, ownerDocument, pdfBug = false) {
|
|
this._pageIndex = pageIndex;
|
|
this._pageInfo = pageInfo;
|
|
this._ownerDocument = ownerDocument;
|
|
this._transport = transport;
|
|
this._stats = pdfBug ? new _display_utils.StatTimer() : null;
|
|
this._pdfBug = pdfBug;
|
|
this.commonObjs = transport.commonObjs;
|
|
this.objs = new PDFObjects();
|
|
this._bitmaps = new Set();
|
|
this.cleanupAfterRender = false;
|
|
this.pendingCleanup = false;
|
|
this._intentStates = new Map();
|
|
this._annotationPromises = new Map();
|
|
this.destroyed = false;
|
|
}
|
|
|
|
get pageNumber() {
|
|
return this._pageIndex + 1;
|
|
}
|
|
|
|
get rotate() {
|
|
return this._pageInfo.rotate;
|
|
}
|
|
|
|
get ref() {
|
|
return this._pageInfo.ref;
|
|
}
|
|
|
|
get userUnit() {
|
|
return this._pageInfo.userUnit;
|
|
}
|
|
|
|
get view() {
|
|
return this._pageInfo.view;
|
|
}
|
|
|
|
getViewport({
|
|
scale,
|
|
rotation = this.rotate,
|
|
offsetX = 0,
|
|
offsetY = 0,
|
|
dontFlip = false
|
|
} = {}) {
|
|
return new _display_utils.PageViewport({
|
|
viewBox: this.view,
|
|
scale,
|
|
rotation,
|
|
offsetX,
|
|
offsetY,
|
|
dontFlip
|
|
});
|
|
}
|
|
|
|
getAnnotations({
|
|
intent = "display"
|
|
} = {}) {
|
|
const intentArgs = this._transport.getRenderingIntent(intent);
|
|
|
|
let promise = this._annotationPromises.get(intentArgs.cacheKey);
|
|
|
|
if (!promise) {
|
|
promise = this._transport.getAnnotations(this._pageIndex, intentArgs.renderingIntent);
|
|
|
|
this._annotationPromises.set(intentArgs.cacheKey, promise);
|
|
|
|
promise = promise.then(annotations => {
|
|
for (const annotation of annotations) {
|
|
if (annotation.titleObj !== undefined) {
|
|
Object.defineProperty(annotation, "title", {
|
|
get() {
|
|
(0, _display_utils.deprecated)("`title`-property on annotation, please use `titleObj` instead.");
|
|
return annotation.titleObj.str;
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
if (annotation.contentsObj !== undefined) {
|
|
Object.defineProperty(annotation, "contents", {
|
|
get() {
|
|
(0, _display_utils.deprecated)("`contents`-property on annotation, please use `contentsObj` instead.");
|
|
return annotation.contentsObj.str;
|
|
}
|
|
|
|
});
|
|
}
|
|
}
|
|
|
|
return annotations;
|
|
});
|
|
}
|
|
|
|
return promise;
|
|
}
|
|
|
|
getJSActions() {
|
|
return this._jsActionsPromise ||= this._transport.getPageJSActions(this._pageIndex);
|
|
}
|
|
|
|
async getXfa() {
|
|
return this._transport._htmlForXfa?.children[this._pageIndex] || null;
|
|
}
|
|
|
|
render({
|
|
canvasContext,
|
|
viewport,
|
|
intent = "display",
|
|
annotationMode = _util.AnnotationMode.ENABLE,
|
|
transform = null,
|
|
imageLayer = null,
|
|
canvasFactory = null,
|
|
background = null,
|
|
optionalContentConfigPromise = null,
|
|
annotationCanvasMap = null,
|
|
pageColors = null,
|
|
printAnnotationStorage = null
|
|
}) {
|
|
if (arguments[0]?.renderInteractiveForms !== undefined) {
|
|
(0, _display_utils.deprecated)("render no longer accepts the `renderInteractiveForms`-option, " + "please use the `annotationMode`-option instead.");
|
|
|
|
if (arguments[0].renderInteractiveForms === true && annotationMode === _util.AnnotationMode.ENABLE) {
|
|
annotationMode = _util.AnnotationMode.ENABLE_FORMS;
|
|
}
|
|
}
|
|
|
|
if (arguments[0]?.includeAnnotationStorage !== undefined) {
|
|
(0, _display_utils.deprecated)("render no longer accepts the `includeAnnotationStorage`-option, " + "please use the `annotationMode`-option instead.");
|
|
|
|
if (arguments[0].includeAnnotationStorage === true && annotationMode === _util.AnnotationMode.ENABLE) {
|
|
annotationMode = _util.AnnotationMode.ENABLE_STORAGE;
|
|
}
|
|
}
|
|
|
|
if (this._stats) {
|
|
this._stats.time("Overall");
|
|
}
|
|
|
|
const intentArgs = this._transport.getRenderingIntent(intent, annotationMode, printAnnotationStorage);
|
|
|
|
this.pendingCleanup = false;
|
|
|
|
if (!optionalContentConfigPromise) {
|
|
optionalContentConfigPromise = this._transport.getOptionalContentConfig();
|
|
}
|
|
|
|
let intentState = this._intentStates.get(intentArgs.cacheKey);
|
|
|
|
if (!intentState) {
|
|
intentState = Object.create(null);
|
|
|
|
this._intentStates.set(intentArgs.cacheKey, intentState);
|
|
}
|
|
|
|
if (intentState.streamReaderCancelTimeout) {
|
|
clearTimeout(intentState.streamReaderCancelTimeout);
|
|
intentState.streamReaderCancelTimeout = null;
|
|
}
|
|
|
|
const canvasFactoryInstance = canvasFactory || new DefaultCanvasFactory({
|
|
ownerDocument: this._ownerDocument
|
|
});
|
|
const intentPrint = !!(intentArgs.renderingIntent & _util.RenderingIntentFlag.PRINT);
|
|
|
|
if (!intentState.displayReadyCapability) {
|
|
intentState.displayReadyCapability = (0, _util.createPromiseCapability)();
|
|
intentState.operatorList = {
|
|
fnArray: [],
|
|
argsArray: [],
|
|
lastChunk: false,
|
|
separateAnnots: null
|
|
};
|
|
|
|
if (this._stats) {
|
|
this._stats.time("Page Request");
|
|
}
|
|
|
|
this._pumpOperatorList(intentArgs);
|
|
}
|
|
|
|
const complete = error => {
|
|
intentState.renderTasks.delete(internalRenderTask);
|
|
|
|
if (this.cleanupAfterRender || intentPrint) {
|
|
this.pendingCleanup = true;
|
|
}
|
|
|
|
this._tryCleanup();
|
|
|
|
if (error) {
|
|
internalRenderTask.capability.reject(error);
|
|
|
|
this._abortOperatorList({
|
|
intentState,
|
|
reason: error instanceof Error ? error : new Error(error)
|
|
});
|
|
} else {
|
|
internalRenderTask.capability.resolve();
|
|
}
|
|
|
|
if (this._stats) {
|
|
this._stats.timeEnd("Rendering");
|
|
|
|
this._stats.timeEnd("Overall");
|
|
}
|
|
};
|
|
|
|
const internalRenderTask = new InternalRenderTask({
|
|
callback: complete,
|
|
params: {
|
|
canvasContext,
|
|
viewport,
|
|
transform,
|
|
imageLayer,
|
|
background
|
|
},
|
|
objs: this.objs,
|
|
commonObjs: this.commonObjs,
|
|
annotationCanvasMap,
|
|
operatorList: intentState.operatorList,
|
|
pageIndex: this._pageIndex,
|
|
canvasFactory: canvasFactoryInstance,
|
|
useRequestAnimationFrame: !intentPrint,
|
|
pdfBug: this._pdfBug,
|
|
pageColors
|
|
});
|
|
(intentState.renderTasks ||= new Set()).add(internalRenderTask);
|
|
const renderTask = internalRenderTask.task;
|
|
Promise.all([intentState.displayReadyCapability.promise, optionalContentConfigPromise]).then(([transparency, optionalContentConfig]) => {
|
|
if (this.pendingCleanup) {
|
|
complete();
|
|
return;
|
|
}
|
|
|
|
if (this._stats) {
|
|
this._stats.time("Rendering");
|
|
}
|
|
|
|
internalRenderTask.initializeGraphics({
|
|
transparency,
|
|
optionalContentConfig
|
|
});
|
|
internalRenderTask.operatorListChanged();
|
|
}).catch(complete);
|
|
return renderTask;
|
|
}
|
|
|
|
getOperatorList({
|
|
intent = "display",
|
|
annotationMode = _util.AnnotationMode.ENABLE,
|
|
printAnnotationStorage = null
|
|
} = {}) {
|
|
function operatorListChanged() {
|
|
if (intentState.operatorList.lastChunk) {
|
|
intentState.opListReadCapability.resolve(intentState.operatorList);
|
|
intentState.renderTasks.delete(opListTask);
|
|
}
|
|
}
|
|
|
|
const intentArgs = this._transport.getRenderingIntent(intent, annotationMode, printAnnotationStorage, true);
|
|
|
|
let intentState = this._intentStates.get(intentArgs.cacheKey);
|
|
|
|
if (!intentState) {
|
|
intentState = Object.create(null);
|
|
|
|
this._intentStates.set(intentArgs.cacheKey, intentState);
|
|
}
|
|
|
|
let opListTask;
|
|
|
|
if (!intentState.opListReadCapability) {
|
|
opListTask = Object.create(null);
|
|
opListTask.operatorListChanged = operatorListChanged;
|
|
intentState.opListReadCapability = (0, _util.createPromiseCapability)();
|
|
(intentState.renderTasks ||= new Set()).add(opListTask);
|
|
intentState.operatorList = {
|
|
fnArray: [],
|
|
argsArray: [],
|
|
lastChunk: false,
|
|
separateAnnots: null
|
|
};
|
|
|
|
if (this._stats) {
|
|
this._stats.time("Page Request");
|
|
}
|
|
|
|
this._pumpOperatorList(intentArgs);
|
|
}
|
|
|
|
return intentState.opListReadCapability.promise;
|
|
}
|
|
|
|
streamTextContent({
|
|
disableCombineTextItems = false,
|
|
includeMarkedContent = false
|
|
} = {}) {
|
|
const TEXT_CONTENT_CHUNK_SIZE = 100;
|
|
return this._transport.messageHandler.sendWithStream("GetTextContent", {
|
|
pageIndex: this._pageIndex,
|
|
combineTextItems: disableCombineTextItems !== true,
|
|
includeMarkedContent: includeMarkedContent === true
|
|
}, {
|
|
highWaterMark: TEXT_CONTENT_CHUNK_SIZE,
|
|
|
|
size(textContent) {
|
|
return textContent.items.length;
|
|
}
|
|
|
|
});
|
|
}
|
|
|
|
getTextContent(params = {}) {
|
|
if (this._transport._htmlForXfa) {
|
|
return this.getXfa().then(xfa => {
|
|
return _xfa_text.XfaText.textContent(xfa);
|
|
});
|
|
}
|
|
|
|
const readableStream = this.streamTextContent(params);
|
|
return new Promise(function (resolve, reject) {
|
|
function pump() {
|
|
reader.read().then(function ({
|
|
value,
|
|
done
|
|
}) {
|
|
if (done) {
|
|
resolve(textContent);
|
|
return;
|
|
}
|
|
|
|
Object.assign(textContent.styles, value.styles);
|
|
textContent.items.push(...value.items);
|
|
pump();
|
|
}, reject);
|
|
}
|
|
|
|
const reader = readableStream.getReader();
|
|
const textContent = {
|
|
items: [],
|
|
styles: Object.create(null)
|
|
};
|
|
pump();
|
|
});
|
|
}
|
|
|
|
getStructTree() {
|
|
return this._structTreePromise ||= this._transport.getStructTree(this._pageIndex);
|
|
}
|
|
|
|
_destroy() {
|
|
this.destroyed = true;
|
|
const waitOn = [];
|
|
|
|
for (const intentState of this._intentStates.values()) {
|
|
this._abortOperatorList({
|
|
intentState,
|
|
reason: new Error("Page was destroyed."),
|
|
force: true
|
|
});
|
|
|
|
if (intentState.opListReadCapability) {
|
|
continue;
|
|
}
|
|
|
|
for (const internalRenderTask of intentState.renderTasks) {
|
|
waitOn.push(internalRenderTask.completed);
|
|
internalRenderTask.cancel();
|
|
}
|
|
}
|
|
|
|
this.objs.clear();
|
|
|
|
for (const bitmap of this._bitmaps) {
|
|
bitmap.close();
|
|
}
|
|
|
|
this._bitmaps.clear();
|
|
|
|
this._annotationPromises.clear();
|
|
|
|
this._jsActionsPromise = null;
|
|
this._structTreePromise = null;
|
|
this.pendingCleanup = false;
|
|
return Promise.all(waitOn);
|
|
}
|
|
|
|
cleanup(resetStats = false) {
|
|
this.pendingCleanup = true;
|
|
return this._tryCleanup(resetStats);
|
|
}
|
|
|
|
_tryCleanup(resetStats = false) {
|
|
if (!this.pendingCleanup) {
|
|
return false;
|
|
}
|
|
|
|
for (const {
|
|
renderTasks,
|
|
operatorList
|
|
} of this._intentStates.values()) {
|
|
if (renderTasks.size > 0 || !operatorList.lastChunk) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
this._intentStates.clear();
|
|
|
|
this.objs.clear();
|
|
|
|
this._annotationPromises.clear();
|
|
|
|
this._jsActionsPromise = null;
|
|
this._structTreePromise = null;
|
|
|
|
if (resetStats && this._stats) {
|
|
this._stats = new _display_utils.StatTimer();
|
|
}
|
|
|
|
for (const bitmap of this._bitmaps) {
|
|
bitmap.close();
|
|
}
|
|
|
|
this._bitmaps.clear();
|
|
|
|
this.pendingCleanup = false;
|
|
return true;
|
|
}
|
|
|
|
_startRenderPage(transparency, cacheKey) {
|
|
const intentState = this._intentStates.get(cacheKey);
|
|
|
|
if (!intentState) {
|
|
return;
|
|
}
|
|
|
|
if (this._stats) {
|
|
this._stats.timeEnd("Page Request");
|
|
}
|
|
|
|
if (intentState.displayReadyCapability) {
|
|
intentState.displayReadyCapability.resolve(transparency);
|
|
}
|
|
}
|
|
|
|
_renderPageChunk(operatorListChunk, intentState) {
|
|
for (let i = 0, ii = operatorListChunk.length; i < ii; i++) {
|
|
intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);
|
|
intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);
|
|
}
|
|
|
|
intentState.operatorList.lastChunk = operatorListChunk.lastChunk;
|
|
intentState.operatorList.separateAnnots = operatorListChunk.separateAnnots;
|
|
|
|
for (const internalRenderTask of intentState.renderTasks) {
|
|
internalRenderTask.operatorListChanged();
|
|
}
|
|
|
|
if (operatorListChunk.lastChunk) {
|
|
this._tryCleanup();
|
|
}
|
|
}
|
|
|
|
_pumpOperatorList({
|
|
renderingIntent,
|
|
cacheKey,
|
|
annotationStorageMap
|
|
}) {
|
|
const readableStream = this._transport.messageHandler.sendWithStream("GetOperatorList", {
|
|
pageIndex: this._pageIndex,
|
|
intent: renderingIntent,
|
|
cacheKey,
|
|
annotationStorage: annotationStorageMap
|
|
});
|
|
|
|
const reader = readableStream.getReader();
|
|
|
|
const intentState = this._intentStates.get(cacheKey);
|
|
|
|
intentState.streamReader = reader;
|
|
|
|
const pump = () => {
|
|
reader.read().then(({
|
|
value,
|
|
done
|
|
}) => {
|
|
if (done) {
|
|
intentState.streamReader = null;
|
|
return;
|
|
}
|
|
|
|
if (this._transport.destroyed) {
|
|
return;
|
|
}
|
|
|
|
this._renderPageChunk(value, intentState);
|
|
|
|
pump();
|
|
}, reason => {
|
|
intentState.streamReader = null;
|
|
|
|
if (this._transport.destroyed) {
|
|
return;
|
|
}
|
|
|
|
if (intentState.operatorList) {
|
|
intentState.operatorList.lastChunk = true;
|
|
|
|
for (const internalRenderTask of intentState.renderTasks) {
|
|
internalRenderTask.operatorListChanged();
|
|
}
|
|
|
|
this._tryCleanup();
|
|
}
|
|
|
|
if (intentState.displayReadyCapability) {
|
|
intentState.displayReadyCapability.reject(reason);
|
|
} else if (intentState.opListReadCapability) {
|
|
intentState.opListReadCapability.reject(reason);
|
|
} else {
|
|
throw reason;
|
|
}
|
|
});
|
|
};
|
|
|
|
pump();
|
|
}
|
|
|
|
_abortOperatorList({
|
|
intentState,
|
|
reason,
|
|
force = false
|
|
}) {
|
|
if (!intentState.streamReader) {
|
|
return;
|
|
}
|
|
|
|
if (!force) {
|
|
if (intentState.renderTasks.size > 0) {
|
|
return;
|
|
}
|
|
|
|
if (reason instanceof _display_utils.RenderingCancelledException) {
|
|
intentState.streamReaderCancelTimeout = setTimeout(() => {
|
|
this._abortOperatorList({
|
|
intentState,
|
|
reason,
|
|
force: true
|
|
});
|
|
|
|
intentState.streamReaderCancelTimeout = null;
|
|
}, RENDERING_CANCELLED_TIMEOUT);
|
|
return;
|
|
}
|
|
}
|
|
|
|
intentState.streamReader.cancel(new _util.AbortException(reason.message)).catch(() => {});
|
|
intentState.streamReader = null;
|
|
|
|
if (this._transport.destroyed) {
|
|
return;
|
|
}
|
|
|
|
for (const [curCacheKey, curIntentState] of this._intentStates) {
|
|
if (curIntentState === intentState) {
|
|
this._intentStates.delete(curCacheKey);
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
this.cleanup();
|
|
}
|
|
|
|
get stats() {
|
|
return this._stats;
|
|
}
|
|
|
|
}
|
|
|
|
exports.PDFPageProxy = PDFPageProxy;
|
|
|
|
class LoopbackPort {
|
|
constructor() {
|
|
this._listeners = [];
|
|
this._deferred = Promise.resolve();
|
|
}
|
|
|
|
postMessage(obj, transfers) {
|
|
const event = {
|
|
data: structuredClone(obj, transfers)
|
|
};
|
|
|
|
this._deferred.then(() => {
|
|
for (const listener of this._listeners) {
|
|
listener.call(this, event);
|
|
}
|
|
});
|
|
}
|
|
|
|
addEventListener(name, listener) {
|
|
this._listeners.push(listener);
|
|
}
|
|
|
|
removeEventListener(name, listener) {
|
|
const i = this._listeners.indexOf(listener);
|
|
|
|
this._listeners.splice(i, 1);
|
|
}
|
|
|
|
terminate() {
|
|
this._listeners.length = 0;
|
|
}
|
|
|
|
}
|
|
|
|
exports.LoopbackPort = LoopbackPort;
|
|
const PDFWorkerUtil = {
|
|
isWorkerDisabled: false,
|
|
fallbackWorkerSrc: null,
|
|
fakeWorkerId: 0
|
|
};
|
|
exports.PDFWorkerUtil = PDFWorkerUtil;
|
|
{
|
|
if (_is_node.isNodeJS && typeof require === "function") {
|
|
PDFWorkerUtil.isWorkerDisabled = true;
|
|
PDFWorkerUtil.fallbackWorkerSrc = "../pdf.worker.js";
|
|
} else if (typeof document === "object") {
|
|
const pdfjsFilePath = document?.currentScript?.src;
|
|
|
|
if (pdfjsFilePath) {
|
|
PDFWorkerUtil.fallbackWorkerSrc = pdfjsFilePath.replace(/(\.(?:min\.)?js)(\?.*)?$/i, ".worker$1$2");
|
|
}
|
|
}
|
|
|
|
PDFWorkerUtil.isSameOrigin = function (baseUrl, otherUrl) {
|
|
let base;
|
|
|
|
try {
|
|
base = new URL(baseUrl);
|
|
|
|
if (!base.origin || base.origin === "null") {
|
|
return false;
|
|
}
|
|
} catch (e) {
|
|
return false;
|
|
}
|
|
|
|
const other = new URL(otherUrl, base);
|
|
return base.origin === other.origin;
|
|
};
|
|
|
|
PDFWorkerUtil.createCDNWrapper = function (url) {
|
|
const wrapper = `importScripts("${url}");`;
|
|
return URL.createObjectURL(new Blob([wrapper]));
|
|
};
|
|
}
|
|
|
|
class PDFWorker {
|
|
static #workerPorts = new WeakMap();
|
|
|
|
constructor({
|
|
name = null,
|
|
port = null,
|
|
verbosity = (0, _util.getVerbosityLevel)()
|
|
} = {}) {
|
|
if (port && PDFWorker.#workerPorts.has(port)) {
|
|
throw new Error("Cannot use more than one PDFWorker per port.");
|
|
}
|
|
|
|
this.name = name;
|
|
this.destroyed = false;
|
|
this.verbosity = verbosity;
|
|
this._readyCapability = (0, _util.createPromiseCapability)();
|
|
this._port = null;
|
|
this._webWorker = null;
|
|
this._messageHandler = null;
|
|
|
|
if (port) {
|
|
PDFWorker.#workerPorts.set(port, this);
|
|
|
|
this._initializeFromPort(port);
|
|
|
|
return;
|
|
}
|
|
|
|
this._initialize();
|
|
}
|
|
|
|
get promise() {
|
|
return this._readyCapability.promise;
|
|
}
|
|
|
|
get port() {
|
|
return this._port;
|
|
}
|
|
|
|
get messageHandler() {
|
|
return this._messageHandler;
|
|
}
|
|
|
|
_initializeFromPort(port) {
|
|
this._port = port;
|
|
this._messageHandler = new _message_handler.MessageHandler("main", "worker", port);
|
|
|
|
this._messageHandler.on("ready", function () {});
|
|
|
|
this._readyCapability.resolve();
|
|
}
|
|
|
|
_initialize() {
|
|
if (!PDFWorkerUtil.isWorkerDisabled && !PDFWorker._mainThreadWorkerMessageHandler) {
|
|
let {
|
|
workerSrc
|
|
} = PDFWorker;
|
|
|
|
try {
|
|
if (!PDFWorkerUtil.isSameOrigin(window.location.href, workerSrc)) {
|
|
workerSrc = PDFWorkerUtil.createCDNWrapper(new URL(workerSrc, window.location).href);
|
|
}
|
|
|
|
const worker = new Worker(workerSrc);
|
|
const messageHandler = new _message_handler.MessageHandler("main", "worker", worker);
|
|
|
|
const terminateEarly = () => {
|
|
worker.removeEventListener("error", onWorkerError);
|
|
messageHandler.destroy();
|
|
worker.terminate();
|
|
|
|
if (this.destroyed) {
|
|
this._readyCapability.reject(new Error("Worker was destroyed"));
|
|
} else {
|
|
this._setupFakeWorker();
|
|
}
|
|
};
|
|
|
|
const onWorkerError = () => {
|
|
if (!this._webWorker) {
|
|
terminateEarly();
|
|
}
|
|
};
|
|
|
|
worker.addEventListener("error", onWorkerError);
|
|
messageHandler.on("test", data => {
|
|
worker.removeEventListener("error", onWorkerError);
|
|
|
|
if (this.destroyed) {
|
|
terminateEarly();
|
|
return;
|
|
}
|
|
|
|
if (data) {
|
|
this._messageHandler = messageHandler;
|
|
this._port = worker;
|
|
this._webWorker = worker;
|
|
|
|
this._readyCapability.resolve();
|
|
|
|
messageHandler.send("configure", {
|
|
verbosity: this.verbosity
|
|
});
|
|
} else {
|
|
this._setupFakeWorker();
|
|
|
|
messageHandler.destroy();
|
|
worker.terminate();
|
|
}
|
|
});
|
|
messageHandler.on("ready", data => {
|
|
worker.removeEventListener("error", onWorkerError);
|
|
|
|
if (this.destroyed) {
|
|
terminateEarly();
|
|
return;
|
|
}
|
|
|
|
try {
|
|
sendTest();
|
|
} catch (e) {
|
|
this._setupFakeWorker();
|
|
}
|
|
});
|
|
|
|
const sendTest = () => {
|
|
const testObj = new Uint8Array();
|
|
messageHandler.send("test", testObj, [testObj.buffer]);
|
|
};
|
|
|
|
sendTest();
|
|
return;
|
|
} catch (e) {
|
|
(0, _util.info)("The worker has been disabled.");
|
|
}
|
|
}
|
|
|
|
this._setupFakeWorker();
|
|
}
|
|
|
|
_setupFakeWorker() {
|
|
if (!PDFWorkerUtil.isWorkerDisabled) {
|
|
(0, _util.warn)("Setting up fake worker.");
|
|
PDFWorkerUtil.isWorkerDisabled = true;
|
|
}
|
|
|
|
PDFWorker._setupFakeWorkerGlobal.then(WorkerMessageHandler => {
|
|
if (this.destroyed) {
|
|
this._readyCapability.reject(new Error("Worker was destroyed"));
|
|
|
|
return;
|
|
}
|
|
|
|
const port = new LoopbackPort();
|
|
this._port = port;
|
|
const id = `fake${PDFWorkerUtil.fakeWorkerId++}`;
|
|
const workerHandler = new _message_handler.MessageHandler(id + "_worker", id, port);
|
|
WorkerMessageHandler.setup(workerHandler, port);
|
|
const messageHandler = new _message_handler.MessageHandler(id, id + "_worker", port);
|
|
this._messageHandler = messageHandler;
|
|
|
|
this._readyCapability.resolve();
|
|
|
|
messageHandler.send("configure", {
|
|
verbosity: this.verbosity
|
|
});
|
|
}).catch(reason => {
|
|
this._readyCapability.reject(new Error(`Setting up fake worker failed: "${reason.message}".`));
|
|
});
|
|
}
|
|
|
|
destroy() {
|
|
this.destroyed = true;
|
|
|
|
if (this._webWorker) {
|
|
this._webWorker.terminate();
|
|
|
|
this._webWorker = null;
|
|
}
|
|
|
|
PDFWorker.#workerPorts.delete(this._port);
|
|
this._port = null;
|
|
|
|
if (this._messageHandler) {
|
|
this._messageHandler.destroy();
|
|
|
|
this._messageHandler = null;
|
|
}
|
|
}
|
|
|
|
static fromPort(params) {
|
|
if (!params?.port) {
|
|
throw new Error("PDFWorker.fromPort - invalid method signature.");
|
|
}
|
|
|
|
if (this.#workerPorts.has(params.port)) {
|
|
return this.#workerPorts.get(params.port);
|
|
}
|
|
|
|
return new PDFWorker(params);
|
|
}
|
|
|
|
static get workerSrc() {
|
|
if (_worker_options.GlobalWorkerOptions.workerSrc) {
|
|
return _worker_options.GlobalWorkerOptions.workerSrc;
|
|
}
|
|
|
|
if (PDFWorkerUtil.fallbackWorkerSrc !== null) {
|
|
if (!_is_node.isNodeJS) {
|
|
(0, _display_utils.deprecated)('No "GlobalWorkerOptions.workerSrc" specified.');
|
|
}
|
|
|
|
return PDFWorkerUtil.fallbackWorkerSrc;
|
|
}
|
|
|
|
throw new Error('No "GlobalWorkerOptions.workerSrc" specified.');
|
|
}
|
|
|
|
static get _mainThreadWorkerMessageHandler() {
|
|
try {
|
|
return globalThis.pdfjsWorker?.WorkerMessageHandler || null;
|
|
} catch (ex) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
static get _setupFakeWorkerGlobal() {
|
|
const loader = async () => {
|
|
const mainWorkerMessageHandler = this._mainThreadWorkerMessageHandler;
|
|
|
|
if (mainWorkerMessageHandler) {
|
|
return mainWorkerMessageHandler;
|
|
}
|
|
|
|
if (_is_node.isNodeJS && typeof require === "function") {
|
|
const worker = eval("require")(this.workerSrc);
|
|
return worker.WorkerMessageHandler;
|
|
}
|
|
|
|
await (0, _display_utils.loadScript)(this.workerSrc);
|
|
return window.pdfjsWorker.WorkerMessageHandler;
|
|
};
|
|
|
|
return (0, _util.shadow)(this, "_setupFakeWorkerGlobal", loader());
|
|
}
|
|
|
|
}
|
|
|
|
exports.PDFWorker = PDFWorker;
|
|
{
|
|
PDFWorker.getWorkerSrc = function () {
|
|
(0, _display_utils.deprecated)("`PDFWorker.getWorkerSrc()`, please use `PDFWorker.workerSrc` instead.");
|
|
return this.workerSrc;
|
|
};
|
|
}
|
|
|
|
class WorkerTransport {
|
|
#docStats = null;
|
|
#pageCache = new Map();
|
|
#pagePromises = new Map();
|
|
#metadataPromise = null;
|
|
|
|
constructor(messageHandler, loadingTask, networkStream, params) {
|
|
this.messageHandler = messageHandler;
|
|
this.loadingTask = loadingTask;
|
|
this.commonObjs = new PDFObjects();
|
|
this.fontLoader = new _font_loader.FontLoader({
|
|
docId: loadingTask.docId,
|
|
onUnsupportedFeature: this._onUnsupportedFeature.bind(this),
|
|
ownerDocument: params.ownerDocument,
|
|
styleElement: params.styleElement
|
|
});
|
|
this._params = params;
|
|
|
|
if (!params.useWorkerFetch) {
|
|
this.CMapReaderFactory = new params.CMapReaderFactory({
|
|
baseUrl: params.cMapUrl,
|
|
isCompressed: params.cMapPacked
|
|
});
|
|
this.StandardFontDataFactory = new params.StandardFontDataFactory({
|
|
baseUrl: params.standardFontDataUrl
|
|
});
|
|
}
|
|
|
|
this.destroyed = false;
|
|
this.destroyCapability = null;
|
|
this._passwordCapability = null;
|
|
this._networkStream = networkStream;
|
|
this._fullReader = null;
|
|
this._lastProgress = null;
|
|
this.downloadInfoCapability = (0, _util.createPromiseCapability)();
|
|
this.setupMessageHandler();
|
|
}
|
|
|
|
get annotationStorage() {
|
|
return (0, _util.shadow)(this, "annotationStorage", new _annotation_storage.AnnotationStorage());
|
|
}
|
|
|
|
get stats() {
|
|
return this.#docStats;
|
|
}
|
|
|
|
getRenderingIntent(intent, annotationMode = _util.AnnotationMode.ENABLE, printAnnotationStorage = null, isOpList = false) {
|
|
let renderingIntent = _util.RenderingIntentFlag.DISPLAY;
|
|
let annotationMap = null;
|
|
|
|
switch (intent) {
|
|
case "any":
|
|
renderingIntent = _util.RenderingIntentFlag.ANY;
|
|
break;
|
|
|
|
case "display":
|
|
break;
|
|
|
|
case "print":
|
|
renderingIntent = _util.RenderingIntentFlag.PRINT;
|
|
break;
|
|
|
|
default:
|
|
(0, _util.warn)(`getRenderingIntent - invalid intent: ${intent}`);
|
|
}
|
|
|
|
switch (annotationMode) {
|
|
case _util.AnnotationMode.DISABLE:
|
|
renderingIntent += _util.RenderingIntentFlag.ANNOTATIONS_DISABLE;
|
|
break;
|
|
|
|
case _util.AnnotationMode.ENABLE:
|
|
break;
|
|
|
|
case _util.AnnotationMode.ENABLE_FORMS:
|
|
renderingIntent += _util.RenderingIntentFlag.ANNOTATIONS_FORMS;
|
|
break;
|
|
|
|
case _util.AnnotationMode.ENABLE_STORAGE:
|
|
renderingIntent += _util.RenderingIntentFlag.ANNOTATIONS_STORAGE;
|
|
const annotationStorage = renderingIntent & _util.RenderingIntentFlag.PRINT && printAnnotationStorage instanceof _annotation_storage.PrintAnnotationStorage ? printAnnotationStorage : this.annotationStorage;
|
|
annotationMap = annotationStorage.serializable;
|
|
break;
|
|
|
|
default:
|
|
(0, _util.warn)(`getRenderingIntent - invalid annotationMode: ${annotationMode}`);
|
|
}
|
|
|
|
if (isOpList) {
|
|
renderingIntent += _util.RenderingIntentFlag.OPLIST;
|
|
}
|
|
|
|
return {
|
|
renderingIntent,
|
|
cacheKey: `${renderingIntent}_${_annotation_storage.AnnotationStorage.getHash(annotationMap)}`,
|
|
annotationStorageMap: annotationMap
|
|
};
|
|
}
|
|
|
|
destroy() {
|
|
if (this.destroyCapability) {
|
|
return this.destroyCapability.promise;
|
|
}
|
|
|
|
this.destroyed = true;
|
|
this.destroyCapability = (0, _util.createPromiseCapability)();
|
|
|
|
if (this._passwordCapability) {
|
|
this._passwordCapability.reject(new Error("Worker was destroyed during onPassword callback"));
|
|
}
|
|
|
|
const waitOn = [];
|
|
|
|
for (const page of this.#pageCache.values()) {
|
|
waitOn.push(page._destroy());
|
|
}
|
|
|
|
this.#pageCache.clear();
|
|
this.#pagePromises.clear();
|
|
|
|
if (this.hasOwnProperty("annotationStorage")) {
|
|
this.annotationStorage.resetModified();
|
|
}
|
|
|
|
const terminated = this.messageHandler.sendWithPromise("Terminate", null);
|
|
waitOn.push(terminated);
|
|
Promise.all(waitOn).then(() => {
|
|
this.commonObjs.clear();
|
|
this.fontLoader.clear();
|
|
this.#metadataPromise = null;
|
|
this._getFieldObjectsPromise = null;
|
|
this._hasJSActionsPromise = null;
|
|
|
|
if (this._networkStream) {
|
|
this._networkStream.cancelAllRequests(new _util.AbortException("Worker was terminated."));
|
|
}
|
|
|
|
if (this.messageHandler) {
|
|
this.messageHandler.destroy();
|
|
this.messageHandler = null;
|
|
}
|
|
|
|
this.destroyCapability.resolve();
|
|
}, this.destroyCapability.reject);
|
|
return this.destroyCapability.promise;
|
|
}
|
|
|
|
setupMessageHandler() {
|
|
const {
|
|
messageHandler,
|
|
loadingTask
|
|
} = this;
|
|
messageHandler.on("GetReader", (data, sink) => {
|
|
(0, _util.assert)(this._networkStream, "GetReader - no `IPDFStream` instance available.");
|
|
this._fullReader = this._networkStream.getFullReader();
|
|
|
|
this._fullReader.onProgress = evt => {
|
|
this._lastProgress = {
|
|
loaded: evt.loaded,
|
|
total: evt.total
|
|
};
|
|
};
|
|
|
|
sink.onPull = () => {
|
|
this._fullReader.read().then(function ({
|
|
value,
|
|
done
|
|
}) {
|
|
if (done) {
|
|
sink.close();
|
|
return;
|
|
}
|
|
|
|
(0, _util.assert)((0, _util.isArrayBuffer)(value), "GetReader - expected an ArrayBuffer.");
|
|
sink.enqueue(new Uint8Array(value), 1, [value]);
|
|
}).catch(reason => {
|
|
sink.error(reason);
|
|
});
|
|
};
|
|
|
|
sink.onCancel = reason => {
|
|
this._fullReader.cancel(reason);
|
|
|
|
sink.ready.catch(readyReason => {
|
|
if (this.destroyed) {
|
|
return;
|
|
}
|
|
|
|
throw readyReason;
|
|
});
|
|
};
|
|
});
|
|
messageHandler.on("ReaderHeadersReady", data => {
|
|
const headersCapability = (0, _util.createPromiseCapability)();
|
|
const fullReader = this._fullReader;
|
|
fullReader.headersReady.then(() => {
|
|
if (!fullReader.isStreamingSupported || !fullReader.isRangeSupported) {
|
|
if (this._lastProgress) {
|
|
loadingTask.onProgress?.(this._lastProgress);
|
|
}
|
|
|
|
fullReader.onProgress = evt => {
|
|
loadingTask.onProgress?.({
|
|
loaded: evt.loaded,
|
|
total: evt.total
|
|
});
|
|
};
|
|
}
|
|
|
|
headersCapability.resolve({
|
|
isStreamingSupported: fullReader.isStreamingSupported,
|
|
isRangeSupported: fullReader.isRangeSupported,
|
|
contentLength: fullReader.contentLength
|
|
});
|
|
}, headersCapability.reject);
|
|
return headersCapability.promise;
|
|
});
|
|
messageHandler.on("GetRangeReader", (data, sink) => {
|
|
(0, _util.assert)(this._networkStream, "GetRangeReader - no `IPDFStream` instance available.");
|
|
|
|
const rangeReader = this._networkStream.getRangeReader(data.begin, data.end);
|
|
|
|
if (!rangeReader) {
|
|
sink.close();
|
|
return;
|
|
}
|
|
|
|
sink.onPull = () => {
|
|
rangeReader.read().then(function ({
|
|
value,
|
|
done
|
|
}) {
|
|
if (done) {
|
|
sink.close();
|
|
return;
|
|
}
|
|
|
|
(0, _util.assert)((0, _util.isArrayBuffer)(value), "GetRangeReader - expected an ArrayBuffer.");
|
|
sink.enqueue(new Uint8Array(value), 1, [value]);
|
|
}).catch(reason => {
|
|
sink.error(reason);
|
|
});
|
|
};
|
|
|
|
sink.onCancel = reason => {
|
|
rangeReader.cancel(reason);
|
|
sink.ready.catch(readyReason => {
|
|
if (this.destroyed) {
|
|
return;
|
|
}
|
|
|
|
throw readyReason;
|
|
});
|
|
};
|
|
});
|
|
messageHandler.on("GetDoc", ({
|
|
pdfInfo
|
|
}) => {
|
|
this._numPages = pdfInfo.numPages;
|
|
this._htmlForXfa = pdfInfo.htmlForXfa;
|
|
delete pdfInfo.htmlForXfa;
|
|
|
|
loadingTask._capability.resolve(new PDFDocumentProxy(pdfInfo, this));
|
|
});
|
|
messageHandler.on("DocException", function (ex) {
|
|
let reason;
|
|
|
|
switch (ex.name) {
|
|
case "PasswordException":
|
|
reason = new _util.PasswordException(ex.message, ex.code);
|
|
break;
|
|
|
|
case "InvalidPDFException":
|
|
reason = new _util.InvalidPDFException(ex.message);
|
|
break;
|
|
|
|
case "MissingPDFException":
|
|
reason = new _util.MissingPDFException(ex.message);
|
|
break;
|
|
|
|
case "UnexpectedResponseException":
|
|
reason = new _util.UnexpectedResponseException(ex.message, ex.status);
|
|
break;
|
|
|
|
case "UnknownErrorException":
|
|
reason = new _util.UnknownErrorException(ex.message, ex.details);
|
|
break;
|
|
|
|
default:
|
|
(0, _util.unreachable)("DocException - expected a valid Error.");
|
|
}
|
|
|
|
loadingTask._capability.reject(reason);
|
|
});
|
|
messageHandler.on("PasswordRequest", exception => {
|
|
this._passwordCapability = (0, _util.createPromiseCapability)();
|
|
|
|
if (loadingTask.onPassword) {
|
|
const updatePassword = password => {
|
|
if (password instanceof Error) {
|
|
this._passwordCapability.reject(password);
|
|
} else {
|
|
this._passwordCapability.resolve({
|
|
password
|
|
});
|
|
}
|
|
};
|
|
|
|
try {
|
|
loadingTask.onPassword(updatePassword, exception.code);
|
|
} catch (ex) {
|
|
this._passwordCapability.reject(ex);
|
|
}
|
|
} else {
|
|
this._passwordCapability.reject(new _util.PasswordException(exception.message, exception.code));
|
|
}
|
|
|
|
return this._passwordCapability.promise;
|
|
});
|
|
messageHandler.on("DataLoaded", data => {
|
|
loadingTask.onProgress?.({
|
|
loaded: data.length,
|
|
total: data.length
|
|
});
|
|
this.downloadInfoCapability.resolve(data);
|
|
});
|
|
messageHandler.on("StartRenderPage", data => {
|
|
if (this.destroyed) {
|
|
return;
|
|
}
|
|
|
|
const page = this.#pageCache.get(data.pageIndex);
|
|
|
|
page._startRenderPage(data.transparency, data.cacheKey);
|
|
});
|
|
messageHandler.on("commonobj", ([id, type, exportedData]) => {
|
|
if (this.destroyed) {
|
|
return;
|
|
}
|
|
|
|
if (this.commonObjs.has(id)) {
|
|
return;
|
|
}
|
|
|
|
switch (type) {
|
|
case "Font":
|
|
const params = this._params;
|
|
|
|
if ("error" in exportedData) {
|
|
const exportedError = exportedData.error;
|
|
(0, _util.warn)(`Error during font loading: ${exportedError}`);
|
|
this.commonObjs.resolve(id, exportedError);
|
|
break;
|
|
}
|
|
|
|
let fontRegistry = null;
|
|
|
|
if (params.pdfBug && globalThis.FontInspector?.enabled) {
|
|
fontRegistry = {
|
|
registerFont(font, url) {
|
|
globalThis.FontInspector.fontAdded(font, url);
|
|
}
|
|
|
|
};
|
|
}
|
|
|
|
const font = new _font_loader.FontFaceObject(exportedData, {
|
|
isEvalSupported: params.isEvalSupported,
|
|
disableFontFace: params.disableFontFace,
|
|
ignoreErrors: params.ignoreErrors,
|
|
onUnsupportedFeature: this._onUnsupportedFeature.bind(this),
|
|
fontRegistry
|
|
});
|
|
this.fontLoader.bind(font).catch(reason => {
|
|
return messageHandler.sendWithPromise("FontFallback", {
|
|
id
|
|
});
|
|
}).finally(() => {
|
|
if (!params.fontExtraProperties && font.data) {
|
|
font.data = null;
|
|
}
|
|
|
|
this.commonObjs.resolve(id, font);
|
|
});
|
|
break;
|
|
|
|
case "FontPath":
|
|
case "Image":
|
|
this.commonObjs.resolve(id, exportedData);
|
|
break;
|
|
|
|
default:
|
|
throw new Error(`Got unknown common object type ${type}`);
|
|
}
|
|
});
|
|
messageHandler.on("obj", ([id, pageIndex, type, imageData]) => {
|
|
if (this.destroyed) {
|
|
return;
|
|
}
|
|
|
|
const pageProxy = this.#pageCache.get(pageIndex);
|
|
|
|
if (pageProxy.objs.has(id)) {
|
|
return;
|
|
}
|
|
|
|
switch (type) {
|
|
case "Image":
|
|
pageProxy.objs.resolve(id, imageData);
|
|
const MAX_IMAGE_SIZE_TO_STORE = 8000000;
|
|
|
|
if (imageData) {
|
|
let length;
|
|
|
|
if (imageData.bitmap) {
|
|
const {
|
|
bitmap,
|
|
width,
|
|
height
|
|
} = imageData;
|
|
length = width * height * 4;
|
|
|
|
pageProxy._bitmaps.add(bitmap);
|
|
} else {
|
|
length = imageData.data?.length || 0;
|
|
}
|
|
|
|
if (length > MAX_IMAGE_SIZE_TO_STORE) {
|
|
pageProxy.cleanupAfterRender = true;
|
|
}
|
|
}
|
|
|
|
break;
|
|
|
|
case "Pattern":
|
|
pageProxy.objs.resolve(id, imageData);
|
|
break;
|
|
|
|
default:
|
|
throw new Error(`Got unknown object type ${type}`);
|
|
}
|
|
});
|
|
messageHandler.on("DocProgress", data => {
|
|
if (this.destroyed) {
|
|
return;
|
|
}
|
|
|
|
loadingTask.onProgress?.({
|
|
loaded: data.loaded,
|
|
total: data.total
|
|
});
|
|
});
|
|
messageHandler.on("DocStats", data => {
|
|
if (this.destroyed) {
|
|
return;
|
|
}
|
|
|
|
this.#docStats = Object.freeze({
|
|
streamTypes: Object.freeze(data.streamTypes),
|
|
fontTypes: Object.freeze(data.fontTypes)
|
|
});
|
|
});
|
|
messageHandler.on("UnsupportedFeature", this._onUnsupportedFeature.bind(this));
|
|
messageHandler.on("FetchBuiltInCMap", data => {
|
|
if (this.destroyed) {
|
|
return Promise.reject(new Error("Worker was destroyed."));
|
|
}
|
|
|
|
if (!this.CMapReaderFactory) {
|
|
return Promise.reject(new Error("CMapReaderFactory not initialized, see the `useWorkerFetch` parameter."));
|
|
}
|
|
|
|
return this.CMapReaderFactory.fetch(data);
|
|
});
|
|
messageHandler.on("FetchStandardFontData", data => {
|
|
if (this.destroyed) {
|
|
return Promise.reject(new Error("Worker was destroyed."));
|
|
}
|
|
|
|
if (!this.StandardFontDataFactory) {
|
|
return Promise.reject(new Error("StandardFontDataFactory not initialized, see the `useWorkerFetch` parameter."));
|
|
}
|
|
|
|
return this.StandardFontDataFactory.fetch(data);
|
|
});
|
|
}
|
|
|
|
_onUnsupportedFeature({
|
|
featureId
|
|
}) {
|
|
if (this.destroyed) {
|
|
return;
|
|
}
|
|
|
|
this.loadingTask.onUnsupportedFeature?.(featureId);
|
|
}
|
|
|
|
getData() {
|
|
return this.messageHandler.sendWithPromise("GetData", null);
|
|
}
|
|
|
|
getPage(pageNumber) {
|
|
if (!Number.isInteger(pageNumber) || pageNumber <= 0 || pageNumber > this._numPages) {
|
|
return Promise.reject(new Error("Invalid page request."));
|
|
}
|
|
|
|
const pageIndex = pageNumber - 1,
|
|
cachedPromise = this.#pagePromises.get(pageIndex);
|
|
|
|
if (cachedPromise) {
|
|
return cachedPromise;
|
|
}
|
|
|
|
const promise = this.messageHandler.sendWithPromise("GetPage", {
|
|
pageIndex
|
|
}).then(pageInfo => {
|
|
if (this.destroyed) {
|
|
throw new Error("Transport destroyed");
|
|
}
|
|
|
|
const page = new PDFPageProxy(pageIndex, pageInfo, this, this._params.ownerDocument, this._params.pdfBug);
|
|
this.#pageCache.set(pageIndex, page);
|
|
return page;
|
|
});
|
|
this.#pagePromises.set(pageIndex, promise);
|
|
return promise;
|
|
}
|
|
|
|
getPageIndex(ref) {
|
|
if (typeof ref !== "object" || ref === null || !Number.isInteger(ref.num) || ref.num < 0 || !Number.isInteger(ref.gen) || ref.gen < 0) {
|
|
return Promise.reject(new Error("Invalid pageIndex request."));
|
|
}
|
|
|
|
return this.messageHandler.sendWithPromise("GetPageIndex", {
|
|
num: ref.num,
|
|
gen: ref.gen
|
|
});
|
|
}
|
|
|
|
getAnnotations(pageIndex, intent) {
|
|
return this.messageHandler.sendWithPromise("GetAnnotations", {
|
|
pageIndex,
|
|
intent
|
|
});
|
|
}
|
|
|
|
saveDocument() {
|
|
return this.messageHandler.sendWithPromise("SaveDocument", {
|
|
isPureXfa: !!this._htmlForXfa,
|
|
numPages: this._numPages,
|
|
annotationStorage: this.annotationStorage.serializable,
|
|
filename: this._fullReader?.filename ?? null
|
|
}).finally(() => {
|
|
this.annotationStorage.resetModified();
|
|
});
|
|
}
|
|
|
|
getFieldObjects() {
|
|
return this._getFieldObjectsPromise ||= this.messageHandler.sendWithPromise("GetFieldObjects", null);
|
|
}
|
|
|
|
hasJSActions() {
|
|
return this._hasJSActionsPromise ||= this.messageHandler.sendWithPromise("HasJSActions", null);
|
|
}
|
|
|
|
getCalculationOrderIds() {
|
|
return this.messageHandler.sendWithPromise("GetCalculationOrderIds", null);
|
|
}
|
|
|
|
getDestinations() {
|
|
return this.messageHandler.sendWithPromise("GetDestinations", null);
|
|
}
|
|
|
|
getDestination(id) {
|
|
if (typeof id !== "string") {
|
|
return Promise.reject(new Error("Invalid destination request."));
|
|
}
|
|
|
|
return this.messageHandler.sendWithPromise("GetDestination", {
|
|
id
|
|
});
|
|
}
|
|
|
|
getPageLabels() {
|
|
return this.messageHandler.sendWithPromise("GetPageLabels", null);
|
|
}
|
|
|
|
getPageLayout() {
|
|
return this.messageHandler.sendWithPromise("GetPageLayout", null);
|
|
}
|
|
|
|
getPageMode() {
|
|
return this.messageHandler.sendWithPromise("GetPageMode", null);
|
|
}
|
|
|
|
getViewerPreferences() {
|
|
return this.messageHandler.sendWithPromise("GetViewerPreferences", null);
|
|
}
|
|
|
|
getOpenAction() {
|
|
return this.messageHandler.sendWithPromise("GetOpenAction", null);
|
|
}
|
|
|
|
getAttachments() {
|
|
return this.messageHandler.sendWithPromise("GetAttachments", null);
|
|
}
|
|
|
|
getJavaScript() {
|
|
return this.messageHandler.sendWithPromise("GetJavaScript", null);
|
|
}
|
|
|
|
getDocJSActions() {
|
|
return this.messageHandler.sendWithPromise("GetDocJSActions", null);
|
|
}
|
|
|
|
getPageJSActions(pageIndex) {
|
|
return this.messageHandler.sendWithPromise("GetPageJSActions", {
|
|
pageIndex
|
|
});
|
|
}
|
|
|
|
getStructTree(pageIndex) {
|
|
return this.messageHandler.sendWithPromise("GetStructTree", {
|
|
pageIndex
|
|
});
|
|
}
|
|
|
|
getOutline() {
|
|
return this.messageHandler.sendWithPromise("GetOutline", null);
|
|
}
|
|
|
|
getOptionalContentConfig() {
|
|
return this.messageHandler.sendWithPromise("GetOptionalContentConfig", null).then(results => {
|
|
return new _optional_content_config.OptionalContentConfig(results);
|
|
});
|
|
}
|
|
|
|
getPermissions() {
|
|
return this.messageHandler.sendWithPromise("GetPermissions", null);
|
|
}
|
|
|
|
getMetadata() {
|
|
return this.#metadataPromise ||= this.messageHandler.sendWithPromise("GetMetadata", null).then(results => {
|
|
return {
|
|
info: results[0],
|
|
metadata: results[1] ? new _metadata.Metadata(results[1]) : null,
|
|
contentDispositionFilename: this._fullReader?.filename ?? null,
|
|
contentLength: this._fullReader?.contentLength ?? null
|
|
};
|
|
});
|
|
}
|
|
|
|
getMarkInfo() {
|
|
return this.messageHandler.sendWithPromise("GetMarkInfo", null);
|
|
}
|
|
|
|
async startCleanup(keepLoadedFonts = false) {
|
|
await this.messageHandler.sendWithPromise("Cleanup", null);
|
|
|
|
if (this.destroyed) {
|
|
return;
|
|
}
|
|
|
|
for (const page of this.#pageCache.values()) {
|
|
const cleanupSuccessful = page.cleanup();
|
|
|
|
if (!cleanupSuccessful) {
|
|
throw new Error(`startCleanup: Page ${page.pageNumber} is currently rendering.`);
|
|
}
|
|
}
|
|
|
|
this.commonObjs.clear();
|
|
|
|
if (!keepLoadedFonts) {
|
|
this.fontLoader.clear();
|
|
}
|
|
|
|
this.#metadataPromise = null;
|
|
this._getFieldObjectsPromise = null;
|
|
this._hasJSActionsPromise = null;
|
|
}
|
|
|
|
get loadingParams() {
|
|
const params = this._params;
|
|
return (0, _util.shadow)(this, "loadingParams", {
|
|
disableAutoFetch: params.disableAutoFetch,
|
|
enableXfa: params.enableXfa
|
|
});
|
|
}
|
|
|
|
}
|
|
|
|
class PDFObjects {
|
|
#objs = Object.create(null);
|
|
|
|
#ensureObj(objId) {
|
|
const obj = this.#objs[objId];
|
|
|
|
if (obj) {
|
|
return obj;
|
|
}
|
|
|
|
return this.#objs[objId] = {
|
|
capability: (0, _util.createPromiseCapability)(),
|
|
data: null
|
|
};
|
|
}
|
|
|
|
get(objId, callback = null) {
|
|
if (callback) {
|
|
const obj = this.#ensureObj(objId);
|
|
obj.capability.promise.then(() => callback(obj.data));
|
|
return null;
|
|
}
|
|
|
|
const obj = this.#objs[objId];
|
|
|
|
if (!obj?.capability.settled) {
|
|
throw new Error(`Requesting object that isn't resolved yet ${objId}.`);
|
|
}
|
|
|
|
return obj.data;
|
|
}
|
|
|
|
has(objId) {
|
|
const obj = this.#objs[objId];
|
|
return obj?.capability.settled || false;
|
|
}
|
|
|
|
resolve(objId, data = null) {
|
|
const obj = this.#ensureObj(objId);
|
|
obj.data = data;
|
|
obj.capability.resolve();
|
|
}
|
|
|
|
clear() {
|
|
this.#objs = Object.create(null);
|
|
}
|
|
|
|
}
|
|
|
|
class RenderTask {
|
|
#internalRenderTask = null;
|
|
|
|
constructor(internalRenderTask) {
|
|
this.#internalRenderTask = internalRenderTask;
|
|
this.onContinue = null;
|
|
}
|
|
|
|
get promise() {
|
|
return this.#internalRenderTask.capability.promise;
|
|
}
|
|
|
|
cancel() {
|
|
this.#internalRenderTask.cancel();
|
|
}
|
|
|
|
get separateAnnots() {
|
|
const {
|
|
separateAnnots
|
|
} = this.#internalRenderTask.operatorList;
|
|
|
|
if (!separateAnnots) {
|
|
return false;
|
|
}
|
|
|
|
const {
|
|
annotationCanvasMap
|
|
} = this.#internalRenderTask;
|
|
return separateAnnots.form || separateAnnots.canvas && annotationCanvasMap?.size > 0;
|
|
}
|
|
|
|
}
|
|
|
|
exports.RenderTask = RenderTask;
|
|
|
|
class InternalRenderTask {
|
|
static #canvasInUse = new WeakSet();
|
|
|
|
constructor({
|
|
callback,
|
|
params,
|
|
objs,
|
|
commonObjs,
|
|
annotationCanvasMap,
|
|
operatorList,
|
|
pageIndex,
|
|
canvasFactory,
|
|
useRequestAnimationFrame = false,
|
|
pdfBug = false,
|
|
pageColors = null
|
|
}) {
|
|
this.callback = callback;
|
|
this.params = params;
|
|
this.objs = objs;
|
|
this.commonObjs = commonObjs;
|
|
this.annotationCanvasMap = annotationCanvasMap;
|
|
this.operatorListIdx = null;
|
|
this.operatorList = operatorList;
|
|
this._pageIndex = pageIndex;
|
|
this.canvasFactory = canvasFactory;
|
|
this._pdfBug = pdfBug;
|
|
this.pageColors = pageColors;
|
|
this.running = false;
|
|
this.graphicsReadyCallback = null;
|
|
this.graphicsReady = false;
|
|
this._useRequestAnimationFrame = useRequestAnimationFrame === true && typeof window !== "undefined";
|
|
this.cancelled = false;
|
|
this.capability = (0, _util.createPromiseCapability)();
|
|
this.task = new RenderTask(this);
|
|
this._cancelBound = this.cancel.bind(this);
|
|
this._continueBound = this._continue.bind(this);
|
|
this._scheduleNextBound = this._scheduleNext.bind(this);
|
|
this._nextBound = this._next.bind(this);
|
|
this._canvas = params.canvasContext.canvas;
|
|
}
|
|
|
|
get completed() {
|
|
return this.capability.promise.catch(function () {});
|
|
}
|
|
|
|
initializeGraphics({
|
|
transparency = false,
|
|
optionalContentConfig
|
|
}) {
|
|
if (this.cancelled) {
|
|
return;
|
|
}
|
|
|
|
if (this._canvas) {
|
|
if (InternalRenderTask.#canvasInUse.has(this._canvas)) {
|
|
throw new Error("Cannot use the same canvas during multiple render() operations. " + "Use different canvas or ensure previous operations were " + "cancelled or completed.");
|
|
}
|
|
|
|
InternalRenderTask.#canvasInUse.add(this._canvas);
|
|
}
|
|
|
|
if (this._pdfBug && globalThis.StepperManager?.enabled) {
|
|
this.stepper = globalThis.StepperManager.create(this._pageIndex);
|
|
this.stepper.init(this.operatorList);
|
|
this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();
|
|
}
|
|
|
|
const {
|
|
canvasContext,
|
|
viewport,
|
|
transform,
|
|
imageLayer,
|
|
background
|
|
} = this.params;
|
|
this.gfx = new _canvas.CanvasGraphics(canvasContext, this.commonObjs, this.objs, this.canvasFactory, imageLayer, optionalContentConfig, this.annotationCanvasMap, this.pageColors);
|
|
this.gfx.beginDrawing({
|
|
transform,
|
|
viewport,
|
|
transparency,
|
|
background
|
|
});
|
|
this.operatorListIdx = 0;
|
|
this.graphicsReady = true;
|
|
|
|
if (this.graphicsReadyCallback) {
|
|
this.graphicsReadyCallback();
|
|
}
|
|
}
|
|
|
|
cancel(error = null) {
|
|
this.running = false;
|
|
this.cancelled = true;
|
|
|
|
if (this.gfx) {
|
|
this.gfx.endDrawing();
|
|
}
|
|
|
|
if (this._canvas) {
|
|
InternalRenderTask.#canvasInUse.delete(this._canvas);
|
|
}
|
|
|
|
this.callback(error || new _display_utils.RenderingCancelledException(`Rendering cancelled, page ${this._pageIndex + 1}`, "canvas"));
|
|
}
|
|
|
|
operatorListChanged() {
|
|
if (!this.graphicsReady) {
|
|
if (!this.graphicsReadyCallback) {
|
|
this.graphicsReadyCallback = this._continueBound;
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
if (this.stepper) {
|
|
this.stepper.updateOperatorList(this.operatorList);
|
|
}
|
|
|
|
if (this.running) {
|
|
return;
|
|
}
|
|
|
|
this._continue();
|
|
}
|
|
|
|
_continue() {
|
|
this.running = true;
|
|
|
|
if (this.cancelled) {
|
|
return;
|
|
}
|
|
|
|
if (this.task.onContinue) {
|
|
this.task.onContinue(this._scheduleNextBound);
|
|
} else {
|
|
this._scheduleNext();
|
|
}
|
|
}
|
|
|
|
_scheduleNext() {
|
|
if (this._useRequestAnimationFrame) {
|
|
window.requestAnimationFrame(() => {
|
|
this._nextBound().catch(this._cancelBound);
|
|
});
|
|
} else {
|
|
Promise.resolve().then(this._nextBound).catch(this._cancelBound);
|
|
}
|
|
}
|
|
|
|
async _next() {
|
|
if (this.cancelled) {
|
|
return;
|
|
}
|
|
|
|
this.operatorListIdx = this.gfx.executeOperatorList(this.operatorList, this.operatorListIdx, this._continueBound, this.stepper);
|
|
|
|
if (this.operatorListIdx === this.operatorList.argsArray.length) {
|
|
this.running = false;
|
|
|
|
if (this.operatorList.lastChunk) {
|
|
this.gfx.endDrawing();
|
|
|
|
if (this._canvas) {
|
|
InternalRenderTask.#canvasInUse.delete(this._canvas);
|
|
}
|
|
|
|
this.callback();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
const version = '2.16.105';
|
|
exports.version = version;
|
|
const build = '172ccdbe5';
|
|
exports.build = build; |