: str_replace(): Passing null to parameter #2 ($replace) of type array|string is deprecated in
this._reader = readableStream.getReader();
get isStreamingSupported() {
} = await this._reader.read();
this._reader.cancel(reason);
;// CONCATENATED MODULE: ./src/core/worker.js
this._capability = Promise.withResolvers();
return this._capability.promise;
this._capability.resolve();
throw new Error("Worker task was terminated");
class WorkerMessageHandler {
static setup(handler, port) {
let testMessageProcessed = false;
handler.on("test", function (data) {
if (testMessageProcessed) {
testMessageProcessed = true;
handler.send("test", data instanceof Uint8Array);
handler.on("configure", function (data) {
setVerbosityLevel(data.verbosity);
handler.on("GetDocRequest", function (data) {
return WorkerMessageHandler.createDocumentHandler(data, port);
static createDocumentHandler(docParams, port) {
const WorkerTasks = new Set();
const verbosity = getVerbosityLevel();
const workerVersion = "4.3.136";
if (apiVersion !== workerVersion) {
throw new Error(`The API version "${apiVersion}" does not match ` + `the Worker version "${workerVersion}".`);
const enumerableProperties = [];
for (const property in []) {
enumerableProperties.push(property);
if (enumerableProperties.length) {
throw new Error("The `Array.prototype` contains unexpected enumerable properties: " + enumerableProperties.join(", ") + "; thus breaking e.g. `for...in` iteration of `Array`s.");
const workerHandlerName = docId + "_worker";
let handler = new MessageHandler(workerHandlerName, docId, port);
function ensureNotTerminated() {
throw new Error("Worker was terminated");
function startWorkerTask(task) {
function finishWorkerTask(task) {
WorkerTasks.delete(task);
async function loadDocument(recoveryMode) {
await pdfManager.ensureDoc("checkHeader");
await pdfManager.ensureDoc("parseStartXRef");
await pdfManager.ensureDoc("parse", [recoveryMode]);
await pdfManager.ensureDoc("checkFirstPage", [recoveryMode]);
await pdfManager.ensureDoc("checkLastPage", [recoveryMode]);
const isPureXfa = await pdfManager.ensureDoc("isPureXfa");
const task = new WorkerTask("loadXfaFonts");
await Promise.all([pdfManager.loadXfaFonts(handler, task).catch(reason => {}).then(() => finishWorkerTask(task)), pdfManager.loadXfaImages()]);
const [numPages, fingerprints] = await Promise.all([pdfManager.ensureDoc("numPages"), pdfManager.ensureDoc("fingerprints")]);
const htmlForXfa = isPureXfa ? await pdfManager.ensureDoc("htmlForXfa") : null;
const pdfManagerCapability = Promise.withResolvers();
pdfManagerArgs.source = data;
newPdfManager = new LocalPdfManager(pdfManagerArgs);
pdfManagerCapability.resolve(newPdfManager);
pdfManagerCapability.reject(ex);
return pdfManagerCapability.promise;
pdfStream = new PDFWorkerStream(handler);
pdfManagerCapability.reject(ex);
return pdfManagerCapability.promise;
const fullRequest = pdfStream.getFullReader();
fullRequest.headersReady.then(function () {
if (!fullRequest.isRangeSupported) {
pdfManagerArgs.source = pdfStream;
pdfManagerArgs.length = fullRequest.contentLength;
pdfManagerArgs.disableAutoFetch ||= fullRequest.isStreamingSupported;
newPdfManager = new NetworkPdfManager(pdfManagerArgs);
for (const chunk of cachedChunks) {
newPdfManager.sendProgressiveData(chunk);
pdfManagerCapability.resolve(newPdfManager);
}).catch(function (reason) {
pdfManagerCapability.reject(reason);
const flushChunks = function () {
const pdfFile = arrayBuffersToBytes(cachedChunks);
if (length && pdfFile.length !== length) {
warn("reported HTTP length is different from actual");
pdfManagerArgs.source = pdfFile;
newPdfManager = new LocalPdfManager(pdfManagerArgs);
pdfManagerCapability.resolve(newPdfManager);
pdfManagerCapability.reject(ex);
new Promise(function (resolve, reject) {
const readChunk = function ({
loaded += value.byteLength;
if (!fullRequest.isStreamingSupported) {
handler.send("DocProgress", {
total: Math.max(loaded, fullRequest.contentLength || 0)
newPdfManager.sendProgressiveData(value);
cachedChunks.push(value);
fullRequest.read().then(readChunk, reject);
fullRequest.read().then(readChunk, reject);
pdfManagerCapability.reject(e);
cancelXHRs = function (reason) {
pdfStream.cancelAllRequests(reason);
return pdfManagerCapability.promise;
function setupDoc(data) {
function onSuccess(doc) {
if (ex instanceof PasswordException) {
const task = new WorkerTask(`PasswordException: response ${ex.code}`);
handler.sendWithPromise("PasswordRequest", ex).then(function ({
pdfManager.updatePassword(password);
handler.send("DocException", ex);
} else if (ex instanceof InvalidPDFException || ex instanceof MissingPDFException || ex instanceof UnexpectedResponseException || ex instanceof UnknownErrorException) {
handler.send("DocException", ex);
handler.send("DocException", new UnknownErrorException(ex.message, ex.toString()));
function pdfManagerReady() {
loadDocument(false).then(onSuccess, function (reason) {
if (!(reason instanceof XRefParseException)) {
pdfManager.requestLoadedStream().then(function () {
loadDocument(true).then(onSuccess, onFailure);
getPdfManager(data).then(function (newPdfManager) {
newPdfManager.terminate(new AbortException("Worker was terminated."));
throw new Error("Worker was terminated");
pdfManager = newPdfManager;
pdfManager.requestLoadedStream(true).then(stream => {
handler.send("DataLoaded", {
length: stream.bytes.byteLength
}).then(pdfManagerReady, onFailure);
handler.on("GetPage", function (data) {
return pdfManager.getPage(data.pageIndex).then(function (page) {
return Promise.all([pdfManager.ensure(page, "rotate"), pdfManager.ensure(page, "ref"), pdfManager.ensure(page, "userUnit"), pdfManager.ensure(page, "view")]).then(function ([rotate, ref, userUnit, view]) {
refStr: ref?.toString() ?? null,
handler.on("GetPageIndex", function (data) {
const pageRef = Ref.get(data.num, data.gen);
return pdfManager.ensureCatalog("getPageIndex", [pageRef]);
handler.on("GetDestinations", function (data) {
return pdfManager.ensureCatalog("destinations");
handler.on("GetDestination", function (data) {
return pdfManager.ensureCatalog("getDestination", [data.id]);
handler.on("GetPageLabels", function (data) {
return pdfManager.ensureCatalog("pageLabels");
handler.on("GetPageLayout", function (data) {
return pdfManager.ensureCatalog("pageLayout");
handler.on("GetPageMode", function (data) {
return pdfManager.ensureCatalog("pageMode");
handler.on("GetViewerPreferences", function (data) {
return pdfManager.ensureCatalog("viewerPreferences");
handler.on("GetOpenAction", function (data) {
return pdfManager.ensureCatalog("openAction");
handler.on("GetAttachments", function (data) {
return pdfManager.ensureCatalog("attachments");
handler.on("GetDocJSActions", function (data) {
return pdfManager.ensureCatalog("jsActions");
handler.on("GetPageJSActions", function ({
return pdfManager.getPage(pageIndex).then(function (page) {
return pdfManager.ensure(page, "jsActions");
handler.on("GetOutline", function (data) {
return pdfManager.ensureCatalog("documentOutline");
handler.on("GetOptionalContentConfig", function (data) {
return pdfManager.ensureCatalog("optionalContentConfig");
handler.on("GetPermissions", function (data) {
return pdfManager.ensureCatalog("permissions");
handler.on("GetMetadata", function (data) {
return Promise.all([pdfManager.ensureDoc("documentInfo"), pdfManager.ensureCatalog("metadata")]);
handler.on("GetMarkInfo", function (data) {
return pdfManager.ensureCatalog("markInfo");
handler.on("GetData", function (data) {
return pdfManager.requestLoadedStream().then(function (stream) {
handler.on("GetAnnotations", function ({
return pdfManager.getPage(pageIndex).then(function (page) {
const task = new WorkerTask(`GetAnnotations: page ${pageIndex}`);
return page.getAnnotationsData(handler, task, intent).then(data => {
handler.on("GetFieldObjects", function (data) {
return pdfManager.ensureDoc("fieldObjects");
handler.on("HasJSActions", function (data) {
return pdfManager.ensureDoc("hasJSActions");
handler.on("GetCalculationOrderIds", function (data) {
return pdfManager.ensureDoc("calculationOrderIds");
handler.on("SaveDocument", async function ({
const globalPromises = [pdfManager.requestLoadedStream(), pdfManager.ensureCatalog("acroForm"), pdfManager.ensureCatalog("acroFormRef"), pdfManager.ensureDoc("startXRef"), pdfManager.ensureDoc("xref"), pdfManager.ensureDoc("linearization"), pdfManager.ensureCatalog("structTreeRoot")];
const newAnnotationsByPage = !isPureXfa ? getNewAnnotationsMap(annotationStorage) : null;
const [stream, acroForm, acroFormRef, startXRef, xref, linearization, _structTreeRoot] = await Promise.all(globalPromises);
const catalogRef = xref.trailer.getRaw("Root") || null;
if (newAnnotationsByPage) {
if (await StructTreeRoot.canCreateStructureTree({
} else if (await _structTreeRoot.canUpdateStructTree({
structTreeRoot = _structTreeRoot;
const imagePromises = AnnotationFactory.generateImages(annotationStorage.values(), xref, pdfManager.evaluatorOptions.isOffscreenCanvasSupported);
const newAnnotationPromises = structTreeRoot === undefined ? promises : [];
for (const [pageIndex, annotations] of newAnnotationsByPage) {
newAnnotationPromises.push(pdfManager.getPage(pageIndex).then(page => {
const task = new WorkerTask(`Save (editor): page ${pageIndex}`);
return page.saveNewAnnotations(handler, task, annotations, imagePromises).finally(function () {
if (structTreeRoot === null) {
promises.push(Promise.all(newAnnotationPromises).then(async newRefs => {
await StructTreeRoot.createStructureTree({
} else if (structTreeRoot) {
promises.push(Promise.all(newAnnotationPromises).then(async newRefs => {
await structTreeRoot.updateStructureTree({
promises.push(pdfManager.serializeXfaData(annotationStorage));
for (let pageIndex = 0; pageIndex < numPages; pageIndex++) {
promises.push(pdfManager.getPage(pageIndex).then(function (page) {
const task = new WorkerTask(`Save: page ${pageIndex}`);
return page.save(handler, task, annotationStorage).finally(function () {
const refs = await Promise.all(promises);