https://fedme.es/wp-content/plugins/wp-file-download/app/site/assets/js/pdf-embed/pdf.worker.js

1/**
2 * @licstart The following is the entire license notice for the
3 * JavaScript code in this page
4 *
5 * Copyright 2023 Mozilla Foundation
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *     http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * @licend The above is the entire license notice for the
20 * JavaScript code in this page
21 */
22
23(function webpackUniversalModuleDefinition(root, factory) {
24	if(typeof exports === 'object' && typeof module === 'object')
25		module.exports = root.pdfjsWorker = factory();
26	else if(typeof define === 'function' && define.amd)
27		define("pdfjs-dist/build/pdf.worker", [], () => { return (root.pdfjsWorker = factory()); });
28	else if(typeof exports === 'object')
29		exports["pdfjs-dist/build/pdf.worker"] = root.pdfjsWorker = factory();
30	else
31		root["pdfjs-dist/build/pdf.worker"] = root.pdfjsWorker = factory();
32})(globalThis, () => {
33return /******/ (() => { // webpackBootstrap
34/******/ 	"use strict";
35/******/ 	var __webpack_modules__ = ([
36/* 0 */,
37/* 1 */
38/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
39
40
41
42Object.defineProperty(exports, "__esModule", ({
43  value: true
44}));
45exports.WorkerTask = exports.WorkerMessageHandler = void 0;
46var _util = __w_pdfjs_require__(2);
47var _core_utils = __w_pdfjs_require__(3);
48var _primitives = __w_pdfjs_require__(4);
49var _pdf_manager = __w_pdfjs_require__(6);
50var _annotation = __w_pdfjs_require__(10);
51var _cleanup_helper = __w_pdfjs_require__(68);
52var _writer = __w_pdfjs_require__(73);
53var _message_handler = __w_pdfjs_require__(104);
54var _worker_stream = __w_pdfjs_require__(105);
55var _struct_tree = __w_pdfjs_require__(72);
56class WorkerTask {
57  constructor(name) {
58    this.name = name;
59    this.terminated = false;
60    this._capability = new _util.PromiseCapability();
61  }
62  get finished() {
63    return this._capability.promise;
64  }
65  finish() {
66    this._capability.resolve();
67  }
68  terminate() {
69    this.terminated = true;
70  }
71  ensureNotTerminated() {
72    if (this.terminated) {
73      throw new Error("Worker task was terminated");
74    }
75  }
76}
77exports.WorkerTask = WorkerTask;
78class WorkerMessageHandler {
79  static setup(handler, port) {
80    let testMessageProcessed = false;
81    handler.on("test", function (data) {
82      if (testMessageProcessed) {
83        return;
84      }
85      testMessageProcessed = true;
86      handler.send("test", data instanceof Uint8Array);
87    });
88    handler.on("configure", function (data) {
89      (0, _util.setVerbosityLevel)(data.verbosity);
90    });
91    handler.on("GetDocRequest", function (data) {
92      return WorkerMessageHandler.createDocumentHandler(data, port);
93    });
94  }
95  static createDocumentHandler(docParams, port) {
96    let pdfManager;
97    let terminated = false;
98    let cancelXHRs = null;
99    const WorkerTasks = new Set();
100    const verbosity = (0, _util.getVerbosityLevel)();
101    const {
102      docId,
103      apiVersion
104    } = docParams;
105    const workerVersion = '3.11.174';
106    if (apiVersion !== workerVersion) {
107      throw new Error(`The API version "${apiVersion}" does not match ` + `the Worker version "${workerVersion}".`);
108    }
109    const enumerableProperties = [];
110    for (const property in []) {
111      enumerableProperties.push(property);
112    }
113    if (enumerableProperties.length) {
114      throw new Error("The `Array.prototype` contains unexpected enumerable properties: " + enumerableProperties.join(", ") + "; thus breaking e.g. `for...in` iteration of `Array`s.");
115    }
116    const workerHandlerName = docId + "_worker";
117    let handler = new _message_handler.MessageHandler(workerHandlerName, docId, port);
118    function ensureNotTerminated() {
119      if (terminated) {
120        throw new Error("Worker was terminated");
121      }
122    }
123    function startWorkerTask(task) {
124      WorkerTasks.add(task);
125    }
126    function finishWorkerTask(task) {
127      task.finish();
128      WorkerTasks.delete(task);
129    }
130    async function loadDocument(recoveryMode) {
131      await pdfManager.ensureDoc("checkHeader");
132      await pdfManager.ensureDoc("parseStartXRef");
133      await pdfManager.ensureDoc("parse", [recoveryMode]);
134      await pdfManager.ensureDoc("checkFirstPage", [recoveryMode]);
135      await pdfManager.ensureDoc("checkLastPage", [recoveryMode]);
136      const isPureXfa = await pdfManager.ensureDoc("isPureXfa");
137      if (isPureXfa) {
138        const task = new WorkerTask("loadXfaFonts");
139        startWorkerTask(task);
140        await Promise.all([pdfManager.loadXfaFonts(handler, task).catch(reason => {}).then(() => finishWorkerTask(task)), pdfManager.loadXfaImages()]);
141      }
142      const [numPages, fingerprints] = await Promise.all([pdfManager.ensureDoc("numPages"), pdfManager.ensureDoc("fingerprints")]);
143      const htmlForXfa = isPureXfa ? await pdfManager.ensureDoc("htmlForXfa") : null;
144      return {
145        numPages,
146        fingerprints,
147        htmlForXfa
148      };
149    }
150    function getPdfManager({
151      data,
152      password,
153      disableAutoFetch,
154      rangeChunkSize,
155      length,
156      docBaseUrl,
157      enableXfa,
158      evaluatorOptions
159    }) {
160      const pdfManagerArgs = {
161        source: null,
162        disableAutoFetch,
163        docBaseUrl,
164        docId,
165        enableXfa,
166        evaluatorOptions,
167        handler,
168        length,
169        password,
170        rangeChunkSize
171      };
172      const pdfManagerCapability = new _util.PromiseCapability();
173      let newPdfManager;
174      if (data) {
175        try {
176          pdfManagerArgs.source = data;
177          newPdfManager = new _pdf_manager.LocalPdfManager(pdfManagerArgs);
178          pdfManagerCapability.resolve(newPdfManager);
179        } catch (ex) {
180          pdfManagerCapability.reject(ex);
181        }
182        return pdfManagerCapability.promise;
183      }
184      let pdfStream,
185        cachedChunks = [];

186      try {
187        pdfStream = new _worker_stream.PDFWorkerStream(handler);
188      } catch (ex) {
189        pdfManagerCapability.reject(ex);
190        return pdfManagerCapability.promise;
191      }
192      const fullRequest = pdfStream.getFullReader();
193      fullRequest.headersReady.then(function () {
194        if (!fullRequest.isRangeSupported) {
195          return;
196        }
197        pdfManagerArgs.source = pdfStream;
198        pdfManagerArgs.length = fullRequest.contentLength;
199        pdfManagerArgs.disableAutoFetch ||= fullRequest.isStreamingSupported;
200        newPdfManager = new _pdf_manager.NetworkPdfManager(pdfManagerArgs);
201        for (const chunk of cachedChunks) {
202          newPdfManager.sendProgressiveData(chunk);
203        }
204        cachedChunks = [];
205        pdfManagerCapability.resolve(newPdfManager);
206        cancelXHRs = null;
207      }).catch(function (reason) {
208        pdfManagerCapability.reject(reason);
209        cancelXHRs = null;
210      });
211      let loaded = 0;
212      const flushChunks = function () {
213        const pdfFile = (0, _core_utils.arrayBuffersToBytes)(cachedChunks);
214        if (length && pdfFile.length !== length) {
215          (0, _util.warn)("reported HTTP length is different from actual");
216        }
217        try {
218          pdfManagerArgs.source = pdfFile;
219          newPdfManager = new _pdf_manager.LocalPdfManager(pdfManagerArgs);
220          pdfManagerCapability.resolve(newPdfManager);
221        } catch (ex) {
222          pdfManagerCapability.reject(ex);
223        }
224        cachedChunks = [];
225      };
226      new Promise(function (resolve, reject) {
227        const readChunk = function ({
228          value,
229          done
230        }) {
231          try {
232            ensureNotTerminated();
233            if (done) {
234              if (!newPdfManager) {
235                flushChunks();
236              }
237              cancelXHRs = null;
238              return;
239            }
240            loaded += value.byteLength;
241            if (!fullRequest.isStreamingSupported) {
242              handler.send("DocProgress", {
243                loaded,
244                total: Math.max(loaded, fullRequest.contentLength || 0)
245              });
246            }
247            if (newPdfManager) {
248              newPdfManager.sendProgressiveData(value);
249            } else {
250              cachedChunks.push(value);
251            }
252            fullRequest.read().then(readChunk, reject);
253          } catch (e) {
254            reject(e);
255          }
256        };
257        fullRequest.read().then(readChunk, reject);
258      }).catch(function (e) {
259        pdfManagerCapability.reject(e);
260        cancelXHRs = null;
261      });
262      cancelXHRs = function (reason) {
263        pdfStream.cancelAllRequests(reason);
264      };
265      return pdfManagerCapability.promise;
266    }
267    function setupDoc(data) {
268      function onSuccess(doc) {
269        ensureNotTerminated();
270        handler.send("GetDoc", {
271          pdfInfo: doc
272        });
273      }
274      function onFailure(ex) {
275        ensureNotTerminated();
276        if (ex instanceof _util.PasswordException) {
277          const task = new WorkerTask(`PasswordException: response ${ex.code}`);
278          startWorkerTask(task);
279          handler.sendWithPromise("PasswordRequest", ex).then(function ({
280            password
281          }) {
282            finishWorkerTask(task);
283            pdfManager.updatePassword(password);
284            pdfManagerReady();
285          }).catch(function () {
286            finishWorkerTask(task);
287            handler.send("DocException", ex);
288          });
289        } else if (ex instanceof _util.InvalidPDFException || ex instanceof _util.MissingPDFException || ex instanceof _util.UnexpectedResponseException || ex instanceof _util.UnknownErrorException) {
290          handler.send("DocException", ex);
291        } else {
292          handler.send("DocException", new _util.UnknownErrorException(ex.message, ex.toString()));
293        }
294      }
295      function pdfManagerReady() {
296        ensureNotTerminated();
297        loadDocument(false).then(onSuccess, function (reason) {
298          ensureNotTerminated();
299          if (!(reason instanceof _core_utils.XRefParseException)) {
300            onFailure(reason);
301            return;
302          }
303          pdfManager.requestLoadedStream().then(function () {
304            ensureNotTerminated();

305            loadDocument(true).then(onSuccess, onFailure);
306          });
307        });
308      }
309      ensureNotTerminated();
310      getPdfManager(data).then(function (newPdfManager) {
311        if (terminated) {
312          newPdfManager.terminate(new _util.AbortException("Worker was terminated."));
313          throw new Error("Worker was terminated");
314        }
315        pdfManager = newPdfManager;
316        pdfManager.requestLoadedStream(true).then(stream => {
317          handler.send("DataLoaded", {
318            length: stream.bytes.byteLength
319          });
320        });
321      }).then(pdfManagerReady, onFailure);
322    }
323    handler.on("GetPage", function (data) {
324      return pdfManager.getPage(data.pageIndex).then(function (page) {
325        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]) {
326          return {
327            rotate,
328            ref,
329            userUnit,
330            view
331          };
332        });
333      });
334    });
335    handler.on("GetPageIndex", function (data) {
336      const pageRef = _primitives.Ref.get(data.num, data.gen);
337      return pdfManager.ensureCatalog("getPageIndex", [pageRef]);
338    });
339    handler.on("GetDestinations", function (data) {
340      return pdfManager.ensureCatalog("destinations");
341    });
342    handler.on("GetDestination", function (data) {
343      return pdfManager.ensureCatalog("getDestination", [data.id]);
344    });
345    handler.on("GetPageLabels", function (data) {
346      return pdfManager.ensureCatalog("pageLabels");
347    });
348    handler.on("GetPageLayout", function (data) {
349      return pdfManager.ensureCatalog("pageLayout");
350    });
351    handler.on("GetPageMode", function (data) {
352      return pdfManager.ensureCatalog("pageMode");
353    });
354    handler.on("GetViewerPreferences", function (data) {
355      return pdfManager.ensureCatalog("viewerPreferences");
356    });
357    handler.on("GetOpenAction", function (data) {
358      return pdfManager.ensureCatalog("openAction");
359    });
360    handler.on("GetAttachments", function (data) {
361      return pdfManager.ensureCatalog("attachments");
362    });
363    handler.on("GetDocJSActions", function (data) {
364      return pdfManager.ensureCatalog("jsActions");
365    });
366    handler.on("GetPageJSActions", function ({
367      pageIndex
368    }) {
369      return pdfManager.getPage(pageIndex).then(function (page) {
370        return pdfManager.ensure(page, "jsActions");
371      });
372    });
373    handler.on("GetOutline", function (data) {
374      return pdfManager.ensureCatalog("documentOutline");
375    });
376    handler.on("GetOptionalContentConfig", function (data) {
377      return pdfManager.ensureCatalog("optionalContentConfig");
378    });
379    handler.on("GetPermissions", function (data) {
380      return pdfManager.ensureCatalog("permissions");
381    });
382    handler.on("GetMetadata", function (data) {
383      return Promise.all([pdfManager.ensureDoc("documentInfo"), pdfManager.ensureCatalog("metadata")]);
384    });
385    handler.on("GetMarkInfo", function (data) {
386      return pdfManager.ensureCatalog("markInfo");
387    });
388    handler.on("GetData", function (data) {
389      return pdfManager.requestLoadedStream().then(function (stream) {
390        return stream.bytes;
391      });
392    });
393    handler.on("GetAnnotations", function ({
394      pageIndex,
395      intent
396    }) {
397      return pdfManager.getPage(pageIndex).then(function (page) {
398        const task = new WorkerTask(`GetAnnotations: page ${pageIndex}`);
399        startWorkerTask(task);
400        return page.getAnnotationsData(handler, task, intent).then(data => {
401          finishWorkerTask(task);
402          return data;
403        }, reason => {
404          finishWorkerTask(task);
405          throw reason;
406        });
407      });
408    });
409    handler.on("GetFieldObjects", function (data) {
410      return pdfManager.ensureDoc("fieldObjects");
411    });
412    handler.on("HasJSActions", function (data) {
413      return pdfManager.ensureDoc("hasJSActions");
414    });
415    handler.on("GetCalculationOrderIds", function (data) {
416      return pdfManager.ensureDoc("calculationOrderIds");
417    });
418    handler.on("SaveDocument", async function ({
419      isPureXfa,
420      numPages,
421      annotationStorage,
422      filename
423    }) {
424      const globalPromises = [pdfManager.requestLoadedStream(), pdfManager.ensureCatalog("acroForm"), pdfManager.ensureCatalog("acroFormRef"), pdfManager.ensureDoc("startXRef"), pdfManager.ensureDoc("xref"), pdfManager.ensureDoc("linearization"), pdfManager.ensureCatalog("structTreeRoot")];
425      const promises = [];
426      const newAnnotationsByPage = !isPureXfa ? (0, _core_utils.getNewAnnotationsMap)(annotationStorage) : null;
427      const [stream, acroForm, acroFormRef, startXRef, xref, linearization, _structTreeRoot] = await Promise.all(globalPromises);
428      const catalogRef = xref.trailer.getRaw("Root") || null;
429      let structTreeRoot;
430      if (newAnnotationsByPage) {
431        if (!_structTreeRoot) {
432          if (await _struct_tree.StructTreeRoot.canCreateStructureTree({
433            catalogRef,
434            pdfManager,
435            newAnnotationsByPage
436          })) {
437            structTreeRoot = null;
438          }
439        } else if (await _structTreeRoot.canUpdateStructTree({
440          pdfManager,
441          newAnnotationsByPage
442        })) {
443          structTreeRoot = _structTreeRoot;
444        }
445        const imagePromises = _annotation.AnnotationFactory.generateImages(annotationStorage.values(), xref, pdfManager.evaluatorOptions.isOffscreenCanvasSupported);
446        const newAnnotationPromises = structTreeRoot === undefined ? promises : [];
447        for (const [pageIndex, annotations] of newAnnotationsByPage) {
448          newAnnotationPromises.push(pdfManager.getPage(pageIndex).then(page => {
449            const task = new WorkerTask(`Save (editor): page ${pageIndex}`);
450            return page.saveNewAnnotations(handler, task, annotations, imagePromises).finally(function () {
451              finishWorkerTask(task);
452            });
453          }));
454        }
455        if (structTreeRoot === null) {

456          promises.push(Promise.all(newAnnotationPromises).then(async newRefs => {
457            await _struct_tree.StructTreeRoot.createStructureTree({
458              newAnnotationsByPage,
459              xref,
460              catalogRef,
461              pdfManager,
462              newRefs
463            });
464            return newRefs;
465          }));
466        } else if (structTreeRoot) {
467          promises.push(Promise.all(newAnnotationPromises).then(async newRefs => {
468            await structTreeRoot.updateStructureTree({
469              newAnnotationsByPage,
470              pdfManager,
471              newRefs
472            });
473            return newRefs;
474          }));
475        }
476      }
477      if (isPureXfa) {
478        promises.push(pdfManager.serializeXfaData(annotationStorage));
479      } else {
480        for (let pageIndex = 0; pageIndex < numPages; pageIndex++) {
481          promises.push(pdfManager.getPage(pageIndex).then(function (page) {
482            const task = new WorkerTask(`Save: page ${pageIndex}`);
483            return page.save(handler, task, annotationStorage).finally(function () {
484              finishWorkerTask(task);
485            });
486          }));
487        }
488      }
489      const refs = await Promise.all(promises);
490      let newRefs = [];
491      let xfaData = null;
492      if (isPureXfa) {
493        xfaData = refs[0];
494        if (!xfaData) {
495          return stream.bytes;
496        }
497      } else {
498        newRefs = refs.flat(2);
499        if (newRefs.length === 0) {
500          return stream.bytes;
501        }
502      }
503      const needAppearances = acroFormRef && acroForm instanceof _primitives.Dict && newRefs.some(ref => ref.needAppearances);
504      const xfa = acroForm instanceof _primitives.Dict && acroForm.get("XFA") || null;
505      let xfaDatasetsRef = null;
506      let hasXfaDatasetsEntry = false;
507      if (Array.isArray(xfa)) {
508        for (let i = 0, ii = xfa.length; i < ii; i += 2) {
509          if (xfa[i] === "datasets") {
510            xfaDatasetsRef = xfa[i + 1];
511            hasXfaDatasetsEntry = true;
512          }
513        }
514        if (xfaDatasetsRef === null) {
515          xfaDatasetsRef = xref.getNewTemporaryRef();
516        }
517      } else if (xfa) {
518        (0, _util.warn)("Unsupported XFA type.");
519      }
520      let newXrefInfo = Object.create(null);
521      if (xref.trailer) {
522        const infoObj = Object.create(null);
523        const xrefInfo = xref.trailer.get("Info") || null;
524        if (xrefInfo instanceof _primitives.Dict) {
525          xrefInfo.forEach((key, value) => {
526            if (typeof value === "string") {
527              infoObj[key] = (0, _util.stringToPDFString)(value);
528            }
529          });
530        }
531        newXrefInfo = {
532          rootRef: catalogRef,
533          encryptRef: xref.trailer.getRaw("Encrypt") || null,
534          newRef: xref.getNewTemporaryRef(),
535          infoRef: xref.trailer.getRaw("Info") || null,
536          info: infoObj,
537          fileIds: xref.trailer.get("ID") || null,
538          startXRef: linearization ? startXRef : xref.lastXRefStreamPos ?? startXRef,
539          filename
540        };
541      }
542      return (0, _writer.incrementalUpdate)({
543        originalData: stream.bytes,
544        xrefInfo: newXrefInfo,
545        newRefs,
546        xref,
547        hasXfa: !!xfa,
548        xfaDatasetsRef,
549        hasXfaDatasetsEntry,
550        needAppearances,
551        acroFormRef,
552        acroForm,
553        xfaData
554      }).finally(() => {
555        xref.resetNewTemporaryRef();
556      });
557    });
558    handler.on("GetOperatorList", function (data, sink) {
559      const pageIndex = data.pageIndex;
560      pdfManager.getPage(pageIndex).then(function (page) {
561        const task = new WorkerTask(`GetOperatorList: page ${pageIndex}`);
562        startWorkerTask(task);
563        const start = verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
564        page.getOperatorList({
565          handler,
566          sink,
567          task,
568          intent: data.intent,
569          cacheKey: data.cacheKey,
570          annotationStorage: data.annotationStorage
571        }).then(function (operatorListInfo) {
572          finishWorkerTask(task);
573          if (start) {
574            (0, _util.info)(`page=${pageIndex + 1} - getOperatorList: time=` + `${Date.now() - start}

574ms, len=${operatorListInfo.length}`);
575          }
576          sink.close();
577        }, function (reason) {
578          finishWorkerTask(task);
579          if (task.terminated) {
580            return;
581          }
582          sink.error(reason);
583        });
584      });
585    });
586    handler.on("GetTextContent", function (data, sink) {
587      const {
588        pageIndex,
589        includeMarkedContent,
590        disableNormalization
591      } = data;
592      pdfManager.getPage(pageIndex).then(function (page) {
593        const task = new WorkerTask("GetTextContent: page " + pageIndex);
594        startWorkerTask(task);
595        const start = verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
596        page.extractTextContent({
597          handler,
598          task,
599          sink,
600          includeMarkedContent,
601          disableNormalization
602        }).then(function () {
603          finishWorkerTask(task);
604          if (start) {
605            (0, _util.info)(`page=${pageIndex + 1} - getTextContent: time=` + `${Date.now() - start}ms`);
606          }
607          sink.close();
608        }, function (reason) {
609          finishWorkerTask(task);
610          if (task.terminated) {
611            return;
612          }
613          sink.error(reason);
614        });
615      });
616    });
617    handler.on("GetStructTree", function (data) {
618      return pdfManager.getPage(data.pageIndex).then(function (page) {
619        return pdfManager.ensure(page, "getStructTree");
620      });
621    });
622    handler.on("FontFallback", function (data) {
623      return pdfManager.fontFallback(data.id, handler);
624    });
625    handler.on("Cleanup", function (data) {
626      return pdfManager.cleanup(true);
627    });
628    handler.on("Terminate", function (data) {
629      terminated = true;
630      const waitOn = [];
631      if (pdfManager) {
632        pdfManager.terminate(new _util.AbortException("Worker was terminated."));
633        const cleanupPromise = pdfManager.cleanup();
634        waitOn.push(cleanupPromise);
635        pdfManager = null;
636      } else {
637        (0, _cleanup_helper.clearGlobalCaches)();
638      }
639      if (cancelXHRs) {
640        cancelXHRs(new _util.AbortException("Worker was terminated."));
641      }
642      for (const task of WorkerTasks) {
643        waitOn.push(task.finished);
644        task.terminate();
645      }
646      return Promise.all(waitOn).then(function () {
647        handler.destroy();
648        handler = null;
649      });
650    });
651    handler.on("Ready", function (data) {
652      setupDoc(docParams);
653      docParams = null;
654    });
655    return workerHandlerName;
656  }
657  static initializeFromPort(port) {
658    const handler = new _message_handler.MessageHandler("worker", "main", port);
659    WorkerMessageHandler.setup(handler, port);
660    handler.send("ready", null);
661  }
662}
663exports.WorkerMessageHandler = WorkerMessageHandler;
664function isMessagePort(maybePort) {
665  return typeof maybePort.postMessage === "function" && "onmessage" in maybePort;
666}
667if (typeof window === "undefined" && !_util.isNodeJS && typeof self !== "undefined" && isMessagePort(self)) {
668  WorkerMessageHandler.initializeFromPort(self);
669}
670
671/***/ }),
672/* 2 */
673/***/ ((__unused_webpack_module, exports) => {
674
675
676
677Object.defineProperty(exports, "__esModule", ({
678  value: true
679}));
680exports.VerbosityLevel = exports.Util = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.TextRenderingMode = exports.RenderingIntentFlag = exports.PromiseCapability = exp

680orts.PermissionFlag = exports.PasswordResponses = exports.PasswordException = exports.PageActionEventType = exports.OPS = exports.MissingPDFException = exports.MAX_IMAGE_SIZE_TO_CACHE = exports.LINE_FACTOR = exports.LINE_DESCENT_FACTOR = exports.InvalidPDFException = exports.ImageKind = exports.IDENTITY_MATRIX = exports.FormatError = exports.FeatureTest = exports.FONT_IDENTITY_MATRIX = exports.DocumentActionEventType = exports.CMapCompressionType = exports.BaseException = exports.BASELINE_FACTOR = exports.AnnotationType = exports.AnnotationReplyType = exports.AnnotationPrefix = exports.AnnotationMode = exports.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationEditorType = exports.AnnotationEditorPrefix = exports.AnnotationEditorParamsType = exports.AnnotationBorderStyleType = exports.AnnotationActionEventType = exports.AbortException = void 0;
681exports.assert = assert;
682exports.bytesToString = bytesToString;
683exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
684exports.getModificationDate = getModificationDate;
685exports.getUuid = getUuid;
686exports.getVerbosityLevel = getVerbosityLevel;
687exports.info = info;
688exports.isArrayBuffer = isArrayBuffer;
689exports.isArrayEqual = isArrayEqual;
690exports.isNodeJS = void 0;
691exports.normalizeUnicode = normalizeUnicode;
692exports.objectFromMap = objectFromMap;
693exports.objectSize = objectSize;
694exports.setVerbosityLevel = setVerbosityLevel;
695exports.shadow = shadow;
696exports.string32 = string32;
697exports.stringToBytes = stringToBytes;
698exports.stringToPDFString = stringToPDFString;
699exports.stringToUTF8String = stringToUTF8String;
700exports.unreachable = unreachable;
701exports.utf8StringToString = utf8StringToString;
702exports.warn = warn;
703const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");

704exports.isNodeJS = isNodeJS;
705const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
706exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
707const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
708exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
709const MAX_IMAGE_SIZE_TO_CACHE = 10e6;
710exports.MAX_IMAGE_SIZE_TO_CACHE = MAX_IMAGE_SIZE_TO_CACHE;
711const LINE_FACTOR = 1.35;
712exports.LINE_FACTOR = LINE_FACTOR;
713const LINE_DESCENT_FACTOR = 0.35;
714exports.LINE_DESCENT_FACTOR = LINE_DESCENT_FACTOR;
715const BASELINE_FACTOR = LINE_DESCENT_FACTOR / LINE_FACTOR;
716exports.BASELINE_FACTOR = BASELINE_FACTOR;
717const RenderingIntentFlag = {
718  ANY: 0x01,
719  DISPLAY: 0x02,
720  PRINT: 0x04,
721  SAVE: 0x08,
722  ANNOTATIONS_FORMS: 0x10,
723  ANNOTATIONS_STORAGE: 0x20,
724  ANNOTATIONS_DISABLE: 0x40,
725  OPLIST: 0x100
726};
727exports.RenderingIntentFlag = RenderingIntentFlag;
728const AnnotationMode = {
729  DISABLE: 0,
730  ENABLE: 1,
731  ENABLE_FORMS: 2,
732  ENABLE_STORAGE: 3
733};
734exports.AnnotationMode = AnnotationMode;
735const AnnotationEditorPrefix = "pdfjs_internal_editor_";
736exports.AnnotationEditorPrefix = AnnotationEditorPrefix;
737const AnnotationEditorType = {
738  DISABLE: -1,
739  NONE: 0,
740  FREETEXT: 3,
741  STAMP: 13,
742  INK: 15
743};
744exports.AnnotationEditorType = AnnotationEditorType;
745const AnnotationEditorParamsType = {
746  RESIZE: 1,
747  CREATE: 2,
748  FREETEXT_SIZE: 11,
749  FREETEXT_COLOR: 12,
750  FREETEXT_OPACITY: 13,
751  INK_COLOR: 21,
752  INK_THICKNESS: 22,
753  INK_OPACITY: 23
754};
755exports.AnnotationEditorParamsType = AnnotationEditorParamsType;
756const PermissionFlag = {
757  PRINT: 0x04,
758  MODIFY_CONTENTS: 0x08,
759  COPY: 0x10,
760  MODIFY_ANNOTATIONS: 0x20,
761  FILL_INTERACTIVE_FORMS: 0x100,
762  COPY_FOR_ACCESSIBILITY: 0x200,
763  ASSEMBLE: 0x400,
764  PRINT_HIGH_QUALITY: 0x800
765};
766exports.PermissionFlag = PermissionFlag;
767const TextRenderingMode = {
768  FILL: 0,
769  STROKE: 1,
770  FILL_STROKE: 2,
771  INVISIBLE: 3,
772  FILL_ADD_TO_PATH: 4,
773  STROKE_ADD_TO_PATH: 5,
774  FILL_STROKE_ADD_TO_PATH: 6,
775  ADD_TO_PATH: 7,
776  FILL_STROKE_MASK: 3,
777  ADD_TO_PATH_FLAG: 4
778};
779exports.TextRenderingMode = TextRenderingMode;
780const ImageKind = {
781  GRAYSCALE_1BPP: 1,
782  RGB_24BPP: 2,
783  RGBA_32BPP: 3
784};
785exports.ImageKind = ImageKind;
786const AnnotationType = {
787  TEXT: 1,
788  LINK: 2,
789  FREETEXT: 3,
790  LINE: 4,
791  SQUARE: 5,
792  CIRCLE: 6,
793  POLYGON: 7,
794  POLYLINE: 8,
795  HIGHLIGHT: 9,
796  UNDERLINE: 10,
797  SQUIGGLY: 11,
798  STRIKEOUT: 12,
799  STAMP: 13,
800  CARET: 14,
801  INK: 15,
802  POPUP: 16,
803  FILEATTACHMENT: 17,
804  SOUND: 18,
805  MOVIE: 19,
806  WIDGET: 20,
807  SCREEN: 21,
808  PRINTERMARK: 22,
809  TRAPNET: 23,
810  WATERMARK: 24,
811  THREED: 25,
812  REDACT: 26
813};
814exports.AnnotationType = AnnotationType;
815const AnnotationReplyType = {
816  GROUP: "Group",
817  REPLY: "R"
818};
819exports.AnnotationReplyType = AnnotationReplyType;
820const AnnotationFlag = {
821  INVISIBLE: 0x01,
822  HIDDEN: 0x02,
823  PRINT: 0x04,
824  NOZOOM: 0x08,
825  NOROTATE: 0x10,
826  NOVIEW: 0x20,
827  READONLY: 0x40,
828  LOCKED: 0x80,
829  TOGGLENOVIEW: 0x100,
830  LOCKEDCONTENTS: 0x200
831};
832exports.AnnotationFlag = AnnotationFlag;
833const AnnotationFieldFlag = {
834  READONLY: 0x0000001,
835  REQUIRED: 0x0000002,
836  NOEXPORT: 0x0000004,
837  MULTILINE: 0x0001000,
838  PASSWORD: 0x0002000,
839  NOTOGGLETOOFF: 0x0004000,
840  RADIO: 0x0008000,
841  PUSHBUTTON: 0x0010000,
842  COMBO: 0x0020000,
843  EDIT: 0x0040000,
844  SORT: 0x0080000,
845  FILESELECT: 0x0100000,
846  MULTISELECT: 0x0200000,
847  DONOTSPELLCHECK: 0x0400000,
848  DONOTSCROLL: 0x0800000,
849  COMB: 0x1000000,
850  RICHTEXT: 0x2000000,
851  RADIOSINUNISON: 0x2000000,
852  COMMITONSELCHANGE: 0x4000000
853};
854exports.AnnotationFieldFlag = AnnotationFieldFlag;
855const AnnotationBorderStyleType = {
856  SOLID: 1,
857  DASHED: 2,
858  BEVELED: 3,
859  INSET: 4,
860  UNDERLINE: 5
861};
862exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
863const AnnotationActionEventType = {
864  E: "Mouse Enter",
865  X: "Mouse Exit",
866  D: "Mouse Down",
867  U: "Mouse Up",
868  Fo: "Focus",
869  Bl: "Blur",
870  PO: "PageOpen",
871  PC: "PageClose",
872  PV: "PageVisible",
873  PI: "PageInvisible",
874  K: "Keystroke",
875  F: "Format",
876  V: "Validate",
877  C: "Calculate"
878};
879exports.AnnotationActionEventType = AnnotationActionEventType;
880const DocumentActionEventType = {
881  WC: "WillClose",
882  WS: "WillSave",
883  DS: "DidSave",
884  WP: "WillPrint",
885  DP: "DidPrint"
886};
887exports.DocumentActionEventType = DocumentActionEventType;
888const PageActionEventType = {
889  O: "PageOpen",
890  C: "PageClose"
891};
892exports.PageActionEventType = PageActionEventType;
893const VerbosityLevel = {
894  ERRORS: 0,
895  WARNINGS: 1,
896  INFOS: 5
897};
898exports.VerbosityLevel = VerbosityLevel;
899const CMapCompressionType = {
900  NONE: 0,
901  BINARY: 1
902};
903exports.CMapCompressionType = CMapCompressionType;
904const OPS = {
905  dependency: 1,
906  setLineWidth: 2,
907  setLineCap: 3,
908  setLineJoin: 4,
909  setMiterLimit: 5,
910  setDash: 6,
911  setRenderingIntent: 7,

912  setFlatness: 8,
913  setGState: 9,
914  save: 10,
915  restore: 11,
916  transform: 12,
917  moveTo: 13,
918  lineTo: 14,
919  curveTo: 15,
920  curveTo2: 16,
921  curveTo3: 17,
922  closePath: 18,
923  rectangle: 19,
924  stroke: 20,
925  closeStroke: 21,
926  fill: 22,
927  eoFill: 23,
928  fillStroke: 24,
929  eoFillStroke: 25,
930  closeFillStroke: 26,
931  closeEOFillStroke: 27,
932  endPath: 28,
933  clip: 29,
934  eoClip: 30,
935  beginText: 31,
936  endText: 32,
937  setCharSpacing: 33,
938  setWordSpacing: 34,
939  setHScale: 35,
940  setLeading: 36,
941  setFont: 37,
942  setTextRenderingMode: 38,
943  setTextRise: 39,
944  moveText: 40,
945  setLeadingMoveText: 41,
946  setTextMatrix: 42,
947  nextLine: 43,
948  showText: 44,
949  showSpacedText: 45,
950  nextLineShowText: 46,
951  nextLineSetSpacingShowText: 47,
952  setCharWidth: 48,
953  setCharWidthAndBounds: 49,
954  setStrokeColorSpace: 50,
955  setFillColorSpace: 51,
956  setStrokeColor: 52,
957  setStrokeColorN: 53,
958  setFillColor: 54,
959  setFillColorN: 55,
960  setStrokeGray: 56,
961  setFillGray: 57,
962  setStrokeRGBColor: 58,
963  setFillRGBColor: 59,
964  setStrokeCMYKColor: 60,
965  setFillCMYKColor: 61,
966  shadingFill: 62,
967  beginInlineImage: 63,
968  beginImageData: 64,
969  endInlineImage: 65,
970  paintXObject: 66,
971  markPoint: 67,
972  markPointProps: 68,
973  beginMarkedContent: 69,
974  beginMarkedContentProps: 70,
975  endMarkedContent: 71,
976  beginCompat: 72,
977  endCompat: 73,
978  paintFormXObjectBegin: 74,
979  paintFormXObjectEnd: 75,
980  beginGroup: 76,
981  endGroup: 77,
982  beginAnnotation: 80,
983  endAnnotation: 81,
984  paintImageMaskXObject: 83,
985  paintImageMaskXObjectGroup: 84,
986  paintImageXObject: 85,
987  paintInlineImageXObject: 86,
988  paintInlineImageXObjectGroup: 87,
989  paintImageXObjectRepeat: 88,
990  paintImageMaskXObjectRepeat: 89,
991  paintSolidColorImageMask: 90,
992  constructPath: 91
993};
994exports.OPS = OPS;
995const PasswordResponses = {
996  NEED_PASSWORD: 1,
997  INCORRECT_PASSWORD: 2
998};
999exports.PasswordResponses = PasswordResponses;
1000let verbosity = VerbosityLevel.WARNINGS;
1001function setVerbosityLevel(level) {
1002  if (Number.isInteger(level)) {
1003    verbosity = level;
1004  }
1005}
1006function getVerbosityLevel() {
1007  return verbosity;
1008}
1009function info(msg) {
1010  if (verbosity >= VerbosityLevel.INFOS) {
1011    console.log(`Info: ${msg}`);
1012  }
1013}
1014function warn(msg) {
1015  if (verbosity >= VerbosityLevel.WARNINGS) {
1016    console.log(`Warning: ${msg}`);
1017  }
1018}
1019function unreachable(msg) {
1020  throw new Error(msg);
1021}
1022function assert(cond, msg) {
1023  if (!cond) {
1024    unreachable(msg);
1025  }
1026}
1027function _isValidProtocol(url) {
1028  switch (url?.protocol) {
1029    case "http:":
1030    case "https:":
1031    case "ftp:":
1032    case "mailto:":
1033    case "tel:":
1034      return true;
1035    default:
1036      return false;
1037  }
1038}
1039function createValidAbsoluteUrl(url, baseUrl = null, options = null) {
1040  if (!url) {
1041    return null;
1042  }
1043  try {
1044    if (options && typeof url === "string") {
1045      if (options.addDefaultProtocol && url.startsWith("www.")) {
1046        const dots = url.match(/\./g);
1047        if (dots?.length >= 2) {
1048          url = `http://${url}`;
1049        }
1050      }
1051      if (options.tryConvertEncoding) {
1052        try {
1053          url = stringToUTF8String(url);
1054        } catch {}
1055      }
1056    }
1057    const absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);
1058    if (_isValidProtocol(absoluteUrl)) {
1059      return absoluteUrl;
1060    }
1061  } catch {}
1062  return null;
1063}
1064function shadow(obj, prop, value, nonSerializable = false) {
1065  Object.defineProperty(obj, prop, {
1066    value,
1067    enumerable: !nonSerializable,
1068    configurable: true,
1069    writable: false
1070  });
1071  return value;
1072}
1073const BaseException = function BaseExceptionClosure() {
1074  function BaseException(message, name) {
1075    if (this.constructor === BaseException) {
1076      unreachable("Cannot initialize BaseException.");
1077    }
1078    this.message = message;
1079    this.name = name;
1080  }
1081  BaseException.prototype = new Error();
1082  BaseException.constructor = BaseException;
1083  return BaseException;
1084}();
1085exports.BaseException = BaseException;
1086class PasswordException extends BaseException {
1087  constructor(msg, code) {
1088    super(msg, "PasswordException");
1089    this.code = code;
1090  }
1091}
1092exports.PasswordException = PasswordException;
1093class UnknownErrorException extends BaseException {
1094  constructor(msg, details) {
1095    super(msg, "UnknownErrorException");
1096    this.details = details;
1097  }
1098}
1099exports.UnknownErrorException = UnknownErrorException;
1100class InvalidPDFException extends BaseException {
1101  constructor(msg) {
1102    super(msg, "InvalidPDFException");
1103  }
1104}
1105exports.InvalidPDFException = InvalidPDFException;
1106class MissingPDFException extends BaseException {
1107  constructor(msg) {
1108    super(msg, "MissingPDFException");
1109  }
1110}
1111exports.MissingPDFException = MissingPDFException;
1112class UnexpectedResponseException extends BaseException {
1113  constructor(msg, status) {
1114    super(msg, "UnexpectedResponseException");
1115    this.status = status;
1116  }
1117}
1118exports.UnexpectedResponseException = UnexpectedResponseException;
1119class FormatError extends BaseException {
1120  constructor(msg) {
1121    super(msg, "FormatError");
1122  }
1123}
1124exports.FormatError = FormatError;
1125class AbortException extends BaseException {
1126  constructor(msg) {
1127    super(msg, "AbortException");
1128  }
1129}
1130exports.AbortException = AbortException;
1131function bytesToString(bytes) {
1132  if (typeof bytes !== "object" || bytes?.length === undefined) {
1133    unreachable("Invalid argument for bytesToString");
1134  }
1135  const length = bytes.length;
1136  const MAX_ARGUMENT_COUNT = 8192;
1137  if (length < MAX_ARGUMENT_COUNT) {
1138    return String.fromCharCode.apply(null, bytes);
1139  }
1140  const strBuf = [];
1141  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
1142    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
1143    const chunk = bytes.subarray(i, chunkEnd);
1144    strBuf.push(String.fromCharCode.apply(null, chunk));
1145  }
1146  return strBuf.join("");
1147}
1148function stringToBytes(str) {
1149  if (typeof str !== "string") {
1150    unreachable("Invalid argument for stringToBytes");
1151  }
1152  const length = str.length;
1153  const bytes = new Uint8Array(length);
1154  for (let i = 0; i < length; ++i) {
1155    bytes[i] = str.charCodeAt(i) & 0xff;

1156  }
1157  return bytes;
1158}
1159function string32(value) {
1160  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
1161}
1162function objectSize(obj) {
1163  return Object.keys(obj).length;
1164}
1165function objectFromMap(map) {
1166  const obj = Object.create(null);
1167  for (const [key, value] of map) {
1168    obj[key] = value;
1169  }
1170  return obj;
1171}
1172function isLittleEndian() {
1173  const buffer8 = new Uint8Array(4);
1174  buffer8[0] = 1;
1175  const view32 = new Uint32Array(buffer8.buffer, 0, 1);
1176  return view32[0] === 1;
1177}
1178function isEvalSupported() {
1179  try {
1180    new Function("");
1181    return true;
1182  } catch {
1183    return false;
1184  }
1185}
1186class FeatureTest {
1187  static get isLittleEndian() {
1188    return shadow(this, "isLittleEndian", isLittleEndian());
1189  }
1190  static get isEvalSupported() {
1191    return shadow(this, "isEvalSupported", isEvalSupported());
1192  }
1193  static get isOffscreenCanvasSupported() {
1194    return shadow(this, "isOffscreenCanvasSupported", typeof OffscreenCanvas !== "undefined");
1195  }
1196  static get platform() {
1197    if (typeof navigator === "undefined") {
1198      return shadow(this, "platform", {
1199        isWin: false,
1200        isMac: false
1201      });
1202    }
1203    return shadow(this, "platform", {
1204      isWin: navigator.platform.includes("Win"),
1205      isMac: navigator.platform.includes("Mac")
1206    });
1207  }
1208  static get isCSSRoundSupported() {
1209    return shadow(this, "isCSSRoundSupported", globalThis.CSS?.supports?.("width: round(1.5px, 1px)"));
1210  }
1211}
1212exports.FeatureTest = FeatureTest;
1213const hexNumbers = [...Array(256).keys()].map(n => n.toString(16).padStart(2, "0"));
1214class Util {
1215  static makeHexColor(r, g, b) {
1216    return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`;
1217  }
1218  static scaleMinMax(transform, minMax) {
1219    let temp;
1220    if (transform[0]) {
1221      if (transform[0] < 0) {
1222        temp = minMax[0];
1223        minMax[0] = minMax[1];
1224        minMax[1] = temp;
1225      }
1226      minMax[0] *= transform[0];
1227      minMax[1] *= transform[0];
1228      if (transform[3] < 0) {
1229        temp = minMax[2];
1230        minMax[2] = minMax[3];
1231        minMax[3] = temp;
1232      }
1233      minMax[2] *= transform[3];
1234      minMax[3] *= transform[3];
1235    } else {
1236      temp = minMax[0];
1237      minMax[0] = minMax[2];
1238      minMax[2] = temp;
1239      temp = minMax[1];
1240      minMax[1] = minMax[3];
1241      minMax[3] = temp;
1242      if (transform[1] < 0) {
1243        temp = minMax[2];
1244        minMax[2] = minMax[3];
1245        minMax[3] = temp;
1246      }
1247      minMax[2] *= transform[1];
1248      minMax[3] *= transform[1];
1249      if (transform[2] < 0) {
1250        temp = minMax[0];
1251        minMax[0] = minMax[1];
1252        minMax[1] = temp;
1253      }
1254      minMax[0] *= transform[2];
1255      minMax[1] *= transform[2];
1256    }
1257    minMax[0] += transform[4];
1258    minMax[1] += transform[4];
1259    minMax[2] += transform[5];
1260    minMax[3] += transform[5];
1261  }
1262  static transform(m1, m2) {
1263    return [m1[0] * m2[0] + m1[2] * m2[1], m1[1] * m2[0] + m1[3] * m2[1], m1[0] * m2[2] + m1[2] * m2[3], m1[1] * m2[2] + m1[3] * m2[3], m1[0] * m2[4] + m1[2] * m2[5] + m1[4], m1[1] * m2[4] + m1[3] * m2[5] + m1[5]];
1264  }
1265  static applyTransform(p, m) {
1266    const xt = p[0] * m[0] + p[1] * m[2] + m[4];
1267    const yt = p[0] * m[1] + p[1] * m[3] + m[5];
1268    return [xt, yt];
1269  }
1270  static applyInverseTransform(p, m) {
1271    const d = m[0] * m[3] - m[1] * m[2];
1272    const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
1273    const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
1274    return [xt, yt];
1275  }
1276  static getAxialAlignedBoundingBox(r, m) {
1277    const p1 = this.applyTransform(r, m);
1278    const p2 = this.applyTransform(r.slice(2, 4), m);
1279    const p3 = this.applyTransform([r[0], r[3]], m);
1280    const p4 = this.applyTransform([r[2], r[1]], m);
1281    return [Math.min(p1[0], p2[0], p3[0], p4[0]), Math.min(p1[1], p2[1], p3[1], p4[1]), Math.max(p1[0], p2[0], p3[0], p4[0]), Math.max(p1[1], p2[1], p3[1], p4[1])];
1282  }
1283  static inverseTransform(m) {
1284    const d = m[0] * m[3] - m[1] * m[2];
1285    return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d, (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d];
1286  }
1287  static singularValueDecompose2dScale(m) {
1288    const transpose = [m[0], m[2], m[1], m[3]];
1289    const a = m[0] * transpose[0] + m[1] * transpose[2];
1290    const b = m[0] * transpose[1] + m[1] * transpose[3];
1291    const c = m[2] * transpose[0] + m[3] * transpose[2];
1292    const d = m[2] * transpose[1] + m[3] * transpose[3];
1293    const first = (a + d) / 2;
1294    const second = Math.sqrt((a + d) ** 2 - 4 * (a * d - c * b)) / 2;
1295    const sx = first + second || 1;
1296    const sy = first - second || 1;
1297    return [Math.sqrt(sx), Math.sqrt(sy)];
1298  }
1299  static normalizeRect(rect) {
1300    const r = rect.slice(0);
1301    if (rect[0] > rect[2]) {
1302      r[0] = rect[2];
1303      r[2] = rect[0];
1304    }
1305    if (rect[1] > rect[3]) {
1306      r[1] = rect[3];
1307      r[3] = rect[1];
1308    }
1309    return r;
1310  }
1311  static intersect(rect1, rect2) {
1312    const xLow = Math.max(Math.min(rect1[0], rect1[2]), Math.min(rect2[0], rect2[2]));
1313    const xHigh = Math.min(Math.max(rect1[0], rect1[2]), Math.max(rect2[0], rect2[2]));
1314    if (xLow > xHigh) {
1315      return null;
1316    }
1317    const yLow = Math.max(Math.min(rect1[1], rect1[3]), Math.min(rect2[1], rect2[3]));
1318    const yHigh = Math.min(Math.max(rect1[1], rect1[3]), Math.max(rect2[1], rect2[3]));
1319    if (yLow > yHigh) {
1320      return null;
1321    }
1322    return [xLow, yLow, xHigh, yHigh];
1323  }
1324  static bezierBoundingBox(x0, y0, x1, y1, x2, y2, x3, y3) {
1325    const tvalues = [],
1326      bounds = [[], []];
1327    let a, b, c, t, t1, t2, b2ac, sqrtb2ac;
1328    for (let i = 0; i < 2; ++i) {
1329      if (i === 0) {
1330        b = 6 * x0 - 12 * x1 + 6 * x2;
1331        a = -3 * x0 + 9 * x1 - 9 * x2 + 3 * x3;
1332        c = 3 * x1 - 3 * x0;
1333      } else {
1334        b = 6 * y0 - 12 * y1 + 6 * y2;
1335        a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3;
1336        c = 3 * y1 - 3 * y0;
1337      }
1338      if (Math.abs(a) < 1e-12) {
1339        if (Math.abs(b) < 1e-12) {
1340          continue;
1341        }
1342        t = -c / b;
1343        if (0 < t && t < 1) {
1344          tvalues.push(t);
1345        }
1346        continue;
1347      }
1348      b2ac = b * b - 4 * c * a;
1349      sqrtb2ac = Math.sqrt(b2ac);
1350      if (b2ac < 0) {
1351        continue;
1352      }
1353      t1 = (-b + sqrtb2ac) / (2 * a);
1354      if (0 < t1 && t1 < 1) {
1355        tvalues.push(t1);
1356      }
1357      t2 = (-b - sqrtb2ac) / (2 * a);
1358      if (0 < t2 && t2 < 1) {
1359        tvalues.push(t2);
1360      }
1361    }
1362    let j = tvalues.length,
1363      mt;
1364    const jlen = j;
1365    while (j--) {
1366      t = tvalues[j];
1367      mt = 1 - t;
1368      bounds[0][j] = mt * mt * mt * x0 + 3 * mt * mt * t * x1 + 3 * mt * t * t * x2 + t * t * t * x3;
1369      bounds[1][j] = mt * mt * mt * y0 + 3 * mt * mt * t * y1 + 3 * mt * t * t * y2 + t * t * t * y3;
1370    }
1371    bounds[0][jlen] = x0;
1372    bounds[1][jlen] = y0;
1373    bounds[0][jlen + 1] = x3;
1374    bounds[1][jlen + 1] = y3;
1375    bounds[0].length = bounds[1].length = jlen + 2;
1376    return [Math.min(...bounds[0]), Math.min(...bounds[1]), Math.max(...bounds[0]), Math.max(...bounds[1])];
1377  }
1378}
1379exports.Util = Util;
1380const PDFStringTranslateTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2d8, 0x2c7, 0x2c6, 0x2d9, 0x2dd, 0x2db, 0x2da, 0x2dc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192, 0x2044, 0x2039, 0x203a, 0x2212, 0x2030, 0x201e, 0x201c, 0x201d, 0x2018, 0x2019, 0x201a, 0x2122, 0xfb01, 0xfb02, 0x141, 0x152, 0x160, 0x178, 0x17d, 0x131, 0x142, 0x153, 0x161, 0x17e, 0, 0x20ac];
1381function stringToPDFString(str) {
1382  if (str[0] >= "\xEF") {
1383    let encoding;
1384    if (str[0] === "\xFE" && str[1] === "\xFF") {
1385      encoding = "utf-16be";
1386    } else if (str[0] === "\xFF" && str[1] === "\xFE") {
1387      encoding = "utf-16le";
1388    } else if (str[0] === "\xEF" && str[1] === "\xBB" && str[2] === "\xBF") {
1389      encoding = "utf-8";
1390    }
1391    if (encoding) {

1392      try {
1393        const decoder = new TextDecoder(encoding, {
1394          fatal: true
1395        });
1396        const buffer = stringToBytes(str);
1397        return decoder.decode(buffer);
1398      } catch (ex) {
1399        warn(`stringToPDFString: "${ex}".`);
1400      }
1401    }
1402  }
1403  const strBuf = [];
1404  for (let i = 0, ii = str.length; i < ii; i++) {
1405    const code = PDFStringTranslateTable[str.charCodeAt(i)];
1406    strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
1407  }
1408  return strBuf.join("");
1409}
1410function stringToUTF8String(str) {
1411  return decodeURIComponent(escape(str));
1412}
1413function utf8StringToString(str) {
1414  return unescape(encodeURIComponent(str));
1415}
1416function isArrayBuffer(v) {
1417  return typeof v === "object" && v?.byteLength !== undefined;
1418}
1419function isArrayEqual(arr1, arr2) {
1420  if (arr1.length !== arr2.length) {
1421    return false;
1422  }
1423  for (let i = 0, ii = arr1.length; i < ii; i++) {
1424    if (arr1[i] !== arr2[i]) {
1425      return false;
1426    }
1427  }
1428  return true;
1429}
1430function getModificationDate(date = new Date()) {
1431  const buffer = [date.getUTCFullYear().toString(), (date.getUTCMonth() + 1).toString().padStart(2, "0"), date.getUTCDate().toString().padStart(2, "0"), date.getUTCHours().toString().padStart(2, "0"), date.getUTCMinutes().toString().padStart(2, "0"), date.getUTCSeconds().toString().padStart(2, "0")];
1432  return buffer.join("");
1433}
1434class PromiseCapability {
1435  #settled = false;
1436  constructor() {
1437    this.promise = new Promise((resolve, reject) => {
1438      this.resolve = data => {
1439        this.#settled = true;
1440        resolve(data);
1441      };
1442      this.reject = reason => {
1443        this.#settled = true;
1444        reject(reason);
1445      };
1446    });
1447  }
1448  get settled() {
1449    return this.#settled;
1450  }
1451}
1452exports.PromiseCapability = PromiseCapability;
1453let NormalizeRegex = null;
1454let NormalizationMap = null;
1455function normalizeUnicode(str) {
1456  if (!NormalizeRegex) {
1457    NormalizeRegex = /([\u00a0\u00b5\u037e\u0eb3\u2000-\u200a\u202f\u2126\ufb00-\ufb04\ufb06\ufb20-\ufb36\ufb38-\ufb3c\ufb3e\ufb40-\ufb41\ufb43-\ufb44\ufb46-\ufba1\ufba4-\ufba9\ufbae-\ufbb1\ufbd3-\ufbdc\ufbde-\ufbe7\ufbea-\ufbf8\ufbfc-\ufbfd\ufc00-\ufc5d\ufc64-\ufcf1\ufcf5-\ufd3d\ufd88\ufdf4\ufdfa-\ufdfb\ufe71\ufe77\ufe79\ufe7b\ufe7d]+)|(\ufb05+)/gu;
1458    NormalizationMap = new Map([["ſt", "ſt"]]);
1459  }
1460  return str.replaceAll(NormalizeRegex, (_, p1, p2) => {
1461    return p1 ? p1.normalize("NFKC") : NormalizationMap.get(p2);
1462  });
1463}
1464function getUuid() {
1465  if (typeof crypto !== "undefined" && typeof crypto?.randomUUID === "function") {
1466    return crypto.randomUUID();
1467  }
1468  const buf = new Uint8Array(32);
1469  if (typeof crypto !== "undefined" && typeof crypto?.getRandomValues === "function") {
1470    crypto.getRandomValues(buf);
1471  } else {
1472    for (let i = 0; i < 32; i++) {
1473      buf[i] = Math.floor(Math.random() * 255);
1474    }
1475  }
1476  return bytesToString(buf);
1477}
1478const AnnotationPrefix = "pdfjs_internal_id_";
1479exports.AnnotationPrefix = AnnotationPrefix;
1480
1481/***/ }),
1482/* 3 */
1483/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
1484
1485
1486
1487Object.defineProperty(exports, "__esModule", ({
1488  value: true
1489}));
1490exports.XRefParseException = exports.XRefEntryException = exports.ParserEOFException = exports.PDF_VERSION_REGEXP = exports.MissingDataException = void 0;
1491exports.arrayBuffersToBytes = arrayBuffersToBytes;
1492exports.collectActions = collectActions;
1493exports.encodeToXmlString = encodeToXmlString;
1494exports.escapePDFName = escapePDFName;
1495exports.escapeString = escapeString;
1496exports.getInheritableProperty = getInheritableProperty;
1497exports.getLookupTableFactory = getLookupTableFactory;
1498exports.getNewAnnotationsMap = getNewAnnotationsMap;
1499exports.getRotationMatrix = getRotationMatrix;
1500exports.isAscii = isAscii;
1501exports.isWhiteSpace = isWhiteSpace;
1502exports.log2 = log2;
1503exports.numberToString = numberToString;
1504exports.parseXFAPath = parseXFAPath;
1505exports.readInt8 = readInt8;
1506exports.readUint16 = readUint16;
1507exports.readUint32 = readUint32;
1508exports.recoverJsURL = recoverJsURL;
1509exports.stringToUTF16HexString = stringToUTF16HexString;
1510exports.stringToUTF16String = stringToUTF16String;
1511exports.toRomanNumerals = toRomanNumerals;
1512exports.validateCSSFont = validateCSSFont;
1513exports.validateFontName = validateFontName;
1514var _util = __w_pdfjs_require__(2);
1515var _primitives = __w_pdfjs_require__(4);
1516var _base_stream = __w_pdfjs_require__(5);
1517const PDF_VERSION_REGEXP = /^[1-9]\.\d$/;
1518exports.PDF_VERSION_REGEXP = PDF_VERSION_REGEXP;
1519function getLookupTableFactory(initializer) {
1520  let lookup;
1521  return function () {
1522    if (initializer) {
1523      lookup = Object.create(null);
1524      initializer(lookup);
1525      initializer = null;
1526    }
1527    return lookup;
1528  };
1529}
1530class MissingDataException extends _util.BaseException {
1531  constructor(begin, end) {
1532    super(`Missing data [${begin}, ${end})`, "MissingDataException");
1533    this.begin = begin;
1534    this.end = end;
1535  }
1536}
1537exports.MissingDataException = MissingDataException;
1538class ParserEOFException extends _util.BaseException {
1539  constructor(msg) {
1540    super(msg, "ParserEOFException");
1541  }
1542}
1543exports.ParserEOFException = ParserEOFException;
1544class XRefEntryException extends _util.BaseException {
1545  constructor(msg) {

1546    super(msg, "XRefEntryException");
1547  }
1548}
1549exports.XRefEntryException = XRefEntryException;
1550class XRefParseException extends _util.BaseException {
1551  constructor(msg) {
1552    super(msg, "XRefParseException");
1553  }
1554}
1555exports.XRefParseException = XRefParseException;
1556function arrayBuffersToBytes(arr) {
1557  const length = arr.length;
1558  if (length === 0) {
1559    return new Uint8Array(0);
1560  }
1561  if (length === 1) {
1562    return new Uint8Array(arr[0]);
1563  }
1564  let dataLength = 0;
1565  for (let i = 0; i < length; i++) {
1566    dataLength += arr[i].byteLength;
1567  }
1568  const data = new Uint8Array(dataLength);
1569  let pos = 0;
1570  for (let i = 0; i < length; i++) {
1571    const item = new Uint8Array(arr[i]);
1572    data.set(item, pos);
1573    pos += item.byteLength;
1574  }
1575  return data;
1576}
1577function getInheritableProperty({
1578  dict,
1579  key,
1580  getArray = false,
1581  stopWhenFound = true
1582}) {
1583  let values;
1584  const visited = new _primitives.RefSet();
1585  while (dict instanceof _primitives.Dict && !(dict.objId && visited.has(dict.objId))) {
1586    if (dict.objId) {
1587      visited.put(dict.objId);
1588    }
1589    const value = getArray ? dict.getArray(key) : dict.get(key);
1590    if (value !== undefined) {
1591      if (stopWhenFound) {
1592        return value;
1593      }
1594      (values ||= []).push(value);
1595    }
1596    dict = dict.get("Parent");
1597  }
1598  return values;
1599}
1600const ROMAN_NUMBER_MAP = ["", "C", "CC", "CCC", "CD", "D", "DC", "DCC", "DCCC", "CM", "", "X", "XX", "XXX", "XL", "L", "LX", "LXX", "LXXX", "XC", "", "I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX"];
1601function toRomanNumerals(number, lowerCase = false) {
1602  (0, _util.assert)(Number.isInteger(number) && number > 0, "The number should be a positive integer.");
1603  const romanBuf = [];
1604  let pos;
1605  while (number >= 1000) {
1606    number -= 1000;
1607    romanBuf.push("M");
1608  }
1609  pos = number / 100 | 0;
1610  number %= 100;
1611  romanBuf.push(ROMAN_NUMBER_MAP[pos]);
1612  pos = number / 10 | 0;
1613  number %= 10;
1614  romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]);
1615  romanBuf.push(ROMAN_NUMBER_MAP[20 + number]);
1616  const romanStr = romanBuf.join("");
1617  return lowerCase ? romanStr.toLowerCase() : romanStr;
1618}
1619function log2(x) {
1620  if (x <= 0) {
1621    return 0;
1622  }
1623  return Math.ceil(Math.log2(x));
1624}
1625function readInt8(data, offset) {
1626  return data[offset] << 24 >> 24;
1627}
1628function readUint16(data, offset) {
1629  return data[offset] << 8 | data[offset + 1];
1630}
1631function readUint32(data, offset) {
1632  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
1633}
1634function isWhiteSpace(ch) {
1635  return ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
1636}
1637function parseXFAPath(path) {
1638  const positionPattern = /(.+)\[(\d+)\]$/;
1639  return path.split(".").map(component => {
1640    const m = component.match(positionPattern);
1641    if (m) {
1642      return {
1643        name: m[1],
1644        pos: parseInt(m[2], 10)
1645      };
1646    }
1647    return {
1648      name: component,
1649      pos: 0
1650    };
1651  });
1652}
1653function escapePDFName(str) {
1654  const buffer = [];
1655  let start = 0;
1656  for (let i = 0, ii = str.length; i < ii; i++) {
1657    const char = str.charCodeAt(i);
1658    if (char < 0x21 || char > 0x7e || char === 0x23 || char === 0x28 || char === 0x29 || char === 0x3c || char === 0x3e || char === 0x5b || char === 0x5d || char === 0x7b || char === 0x7d || char === 0x2f || char === 0x25) {
1659      if (start < i) {
1660        buffer.push(str.substring(start, i));
1661      }
1662      buffer.push(`#${char.toString(16)}`);
1663      start = i + 1;
1664    }
1665  }
1666  if (buffer.length === 0) {
1667    return str;
1668  }
1669  if (start < str.length) {
1670    buffer.push(str.substring(start, str.length));
1671  }
1672  return buffer.join("");
1673}
1674function escapeString(str) {
1675  return str.replaceAll(/([()\\\n\r])/g, match => {
1676    if (match === "\n") {
1677      return "\\n";
1678    } else if (match === "\r") {
1679      return "\\r";
1680    }
1681    return `\\${match}`;
1682  });
1683}
1684function _collectJS(entry, xref, list, parents) {
1685  if (!entry) {
1686    return;
1687  }
1688  let parent = null;
1689  if (entry instanceof _primitives.Ref) {
1690    if (parents.has(entry)) {
1691      return;
1692    }
1693    parent = entry;
1694    parents.put(parent);
1695    entry = xref.fetch(entry);
1696  }
1697  if (Array.isArray(entry)) {
1698    for (const element of entry) {
1699      _collectJS(element, xref, list, parents);
1700    }
1701  } else if (entry instanceof _primitives.Dict) {
1702    if ((0, _primitives.isName)(entry.get("S"), "JavaScript")) {
1703      const js = entry.get("JS");
1704      let code;
1705      if (js instanceof _base_stream.BaseStream) {
1706        code = js.getString();
1707      } else if (typeof js === "string") {
1708        code = js;
1709      }
1710      code &&= (0, _util.stringToPDFString)(code).replaceAll("\x00", "");
1711      if (code) {
1712        list.push(code);
1713      }
1714    }
1715    _collectJS(entry.getRaw("Next"), xref, list, parents);
1716  }
1717  if (parent) {
1718    parents.remove(parent);
1719  }
1720}
1721function collectActions(xref, dict, eventType) {
1722  const actions = Object.create(null);
1723  const additionalActionsDicts = getInheritableProperty({
1724    dict,
1725    key: "AA",
1726    stopWhenFound: false
1727  });
1728  if (additionalActionsDicts) {
1729    for (let i = additionalActionsDicts.length - 1; i >= 0; i--) {
1730      const additionalActions = additionalActionsDicts[i];
1731      if (!(additionalActions instanceof _primitives.Dict)) {
1732        continue;
1733      }
1734      for (const key of additionalActions.getKeys()) {
1735        const action = eventType[key];
1736        if (!action) {
1737          continue;
1738        }
1739        const actionDict = additionalActions.getRaw(key);
1740        const parents = new _primitives.RefSet();
1741        const list = [];
1742        _collectJS(actionDict, xref, list, parents);
1743        if (list.length > 0) {
1744          actions[action] = list;
1745        }
1746      }
1747    }
1748  }
1749  if (dict.has("A")) {
1750    const actionDict = dict.get("A");
1751    const parents = new _primitives.RefSet();
1752    const list = [];
1753    _collectJS(actionDict, xref, list, parents);
1754    if (list.length > 0) {
1755      actions.Action = list;
1756    }
1757  }
1758  return (0, _util.objectSize)(actions) > 0 ? actions : null;
1759}
1760const XMLEntities = {
1761  0x3c: "&lt;",
1762  0x3e: "&gt;",
1763  0x26: "&amp;",
1764  0x22: "&quot;",
1765  0x27: "&apos;"
1766};
1767function encodeToXmlString(str) {
1768  const buffer = [];
1769  let start = 0;
1770  for (let i = 0, ii = str.length; i < ii; i++) {
1771    const char = str.codePointAt(i);
1772    if (0x20 <= char && char <= 0x7e) {
1773      const entity = XMLEntities[char];
1774      if (entity) {
1775        if (start < i) {
1776          buffer.push(str.substring(start, i));
1777        }
1778        buffer.push(entity);
1779        start = i + 1;
1780      }
1781    } else {
1782      if (start < i) {
1783        buffer.push(str.substring(start, i));
1784      }
1785      buffer.push(`&#x${char.toString(16).toUpperCase()};`);
1786      if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
1787        i++;
1788      }
1789      start = i + 1;
1790    }
1791  }
1792  if (buffer.length === 0) {
1793    return str;
1794  }
1795  if (start < str.length) {
1796    buffer.push(str.substring(start, str.length));
1797  }
1798  return buffer.join("");
1799}
1800function validateFontName(fontFamily, mustWarn = false) {
1801  const m = /^("|').*("|')$/.exec(fontFamily);
1802  if (m && m[1] === m[2]) {
1803    const re = new RegExp(`[^\\\\]${m[1]}`);
1804    if (re.test(fontFamily.slice(1, -1))) {
1805      if (mustWarn) {
1806        (0, _util.warn)(`FontFamily contains unescaped ${m[1]}: ${fontFamily}.`);
1807      }
1808      return false;
1809    }
1810  } else {
1811    for (const ident of fontFamily.split(/[ \t]+/)) {
1812      if (/^(\d|(-(\d|-)))/.test(ident) || !/^[\w-\\]+$/.test(ident)) {
1813        if (mustWarn) {
1814          (0, _util.warn)(`FontFamily contains invalid <custom-ident>: ${fontFamily}.`);
1815        }
1816        return false;
1817      }
1818    }
1819  }
1820  return true;
1821}
1822function validateCSSFont(cssFontInfo) {
1823  const DEFAULT_CSS_FONT_OBLIQUE = "14";
1824  const DEFAULT_CSS_FONT_WEIGHT = "400";
1825  const CSS_FONT_WEIGHT_VALUES = new Set(["100", "200", "300", "400", "500", "600", "700", "800", "900", "1000", "normal", "bold", "bolder", "lighter"]);
1826  const {
1827    fontFamily,
1828    fontWeight,
1829    italicAngle
1830  } = cssFontInfo;
1831  if (!validateFontName(fontFamily, true)) {
1832    return false;
1833  }
1834  const weight = fontWeight ? fontWeight.toString() : "";
1835  cssFontInfo.fontWeight = CSS_FONT_WEIGHT_VALUES.has(weight) ? weight : DEFAULT_CSS_FONT_WEIGHT;
1836  const angle = parseFloat(italicAngle);
1837  cssFontInfo.italicAngle = isNaN(angle) || angle < -90 || angle > 90 ? DEFAULT_CSS_FONT_OBLIQUE : italicAngle.toString();
1838  return true;
1839}
1840function recoverJsURL(str) {
1841  const URL_OPEN_METHODS = ["app.launchURL", "window.open", "xfa.host.gotoURL"];
1842  const regex = new RegExp("^\\s*(" + URL_OPEN_METHODS.join("|").replaceAll(".", "\\.") + ")\\((?:'|\")([^'\"]*)(?:'|\")(?:,\\s*(\\w+)\\)|\\))", "i");
1843  const jsUrl = regex.exec(str);
1844  if (jsUrl?.[2]) {
1845    const url = jsUrl[2];
1846    let newWindow = false;
1847    if (jsUrl[3] === "true" && jsUrl[1] === "app.launchURL") {
1848      newWindow = true;
1849    }
1850    return {
1851      url,
1852      newWindow
1853    };
1854  }
1855  return null;
1856}
1857function numberToString(value) {
1858  if (Number.isInteger(value)) {
1859    return value.toString();
1860  }
1861  const roundedValue = Math.round(value * 100);
1862  if (roundedValue % 100 === 0) {
1863    return (roundedValue / 100).toString();
1864  }
1865  if (roundedValue % 10 === 0) {
1866    return value.toFixed(1);
1867  }
1868  return value.toFixed(2);
1869}
1870function getNewAnnotationsMap(annotationStorage) {
1871  if (!annotationStorage) {
1872    return null;
1873  }
1874  const newAnnotationsByPage = new Map();
1875  for (const [key, value] of annotationStorage) {
1876    if (!key.startsWith(_util.AnnotationEditorPrefix)) {
1877      continue;
1878    }
1879    let annotations = newAnnotationsByPage.get(value.pageIndex);
1880    if (!annotations) {
1881      annotations = [];
1882      newAnnotationsByPage.set(value.pageIndex, annotations);
1883    }
1884    annotations.push(value);
1885  }
1886  return newAnnotationsByPage.size > 0 ? newAnnotationsByPage : null;
1887}
1888function isAscii(str) {
1889  return /^[\x00-\x7F]*$/.test(str);
1890}
1891function stringToUTF16HexString(str) {
1892  const buf = [];
1893  for (let i = 0, ii = str.length; i < ii; i++) {
1894    const char = str.charCodeAt(i);
1895    buf.push((char >> 8 & 0xff).toString(16).padStart(2, "0"), (char & 0xff).toString(16).padStart(2, "0"));
1896  }
1897  return buf.join("");
1898}
1899function stringToUTF16String(str, bigEndian = false) {
1900  const buf = [];
1901  if (bigEndian) {
1902    buf.push("\xFE\xFF");
1903  }
1904  for (let i = 0, ii = str.length; i < ii; i++) {
1905    const char = str.charCodeAt(i);
1906    buf.push(String.fromCharCode(char >> 8 & 0xff), String.fromCharCode(char & 0xff));
1907  }
1908  return buf.join("");
1909}
1910function getRotationMatrix(rotation, width, height) {
1911  switch (rotation) {
1912    case 90:
1913      return [0, 1, -1, 0, width, 0];
1914    case 180:
1915      return [-1, 0, 0, -1, width, height];
1916    case 270:
1917      return [0, -1, 1, 0, 0, height];
1918    default:
1919      throw new Error("Invalid rotation");
1920  }
1921}
1922
1923/***/ }),
1924/* 4 */
1925/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
1926
1927
1928
1929Object.defineProperty(exports, "__esModule", ({
1930  value: true
1931}));
1932exports.RefSetCache = exports.RefSet = exports.Ref = exports.Name = exports.EOF = exports.Dict = exports.Cmd = exports.CIRCULAR_REF = void 0;
1933exports.clearPrimitiveCaches = clearPrimitiveCaches;
1934exports.isCmd = isCmd;
1935exports.isDict = isDict;
1936exports.isName = isName;
1937exports.isRefsEqual = isRefsEqual;
1938var _util = __w_pdfjs_require__(2);
1939const CIRCULAR_REF = Symbol("CIRCULAR_REF");
1940exports.CIRCULAR_REF = CIRCULAR_REF;
1941const EOF = Symbol("EOF");
1942exports.EOF = EOF;
1943let CmdCache = Object.create(null);
1944let NameCache = Object.create(null);
1945let RefCache = Object.create(null);
1946function clearPrimitiveCaches() {
1947  CmdCache = Object.create(null);
1948  NameCache = Object.create(null);
1949  RefCache = Object.create(null);
1950}
1951class Name {
1952  constructor(name) {
1953    this.name = name;
1954  }
1955  static get(name) {

1956    return NameCache[name] ||= new Name(name);
1957  }
1958}
1959exports.Name = Name;
1960class Cmd {
1961  constructor(cmd) {
1962    this.cmd = cmd;
1963  }
1964  static get(cmd) {
1965    return CmdCache[cmd] ||= new Cmd(cmd);
1966  }
1967}
1968exports.Cmd = Cmd;
1969const nonSerializable = function nonSerializableClosure() {
1970  return nonSerializable;
1971};
1972class Dict {
1973  constructor(xref = null) {
1974    this._map = Object.create(null);
1975    this.xref = xref;
1976    this.objId = null;
1977    this.suppressEncryption = false;
1978    this.__nonSerializable__ = nonSerializable;
1979  }
1980  assignXref(newXref) {
1981    this.xref = newXref;
1982  }
1983  get size() {
1984    return Object.keys(this._map).length;
1985  }
1986  get(key1, key2, key3) {
1987    let value = this._map[key1];
1988    if (value === undefined && key2 !== undefined) {
1989      value = this._map[key2];
1990      if (value === undefined && key3 !== undefined) {
1991        value = this._map[key3];
1992      }
1993    }
1994    if (value instanceof Ref && this.xref) {
1995      return this.xref.fetch(value, this.suppressEncryption);
1996    }
1997    return value;
1998  }
1999  async getAsync(key1, key2, key3) {
2000    let value = this._map[key1];
2001    if (value === undefined && key2 !== undefined) {
2002      value = this._map[key2];
2003      if (value === undefined && key3 !== undefined) {
2004        value = this._map[key3];
2005      }
2006    }
2007    if (value instanceof Ref && this.xref) {
2008      return this.xref.fetchAsync(value, this.suppressEncryption);
2009    }
2010    return value;
2011  }
2012  getArray(key1, key2, key3) {
2013    let value = this._map[key1];
2014    if (value === undefined && key2 !== undefined) {
2015      value = this._map[key2];
2016      if (value === undefined && key3 !== undefined) {
2017        value = this._map[key3];
2018      }
2019    }
2020    if (value instanceof Ref && this.xref) {
2021      value = this.xref.fetch(value, this.suppressEncryption);
2022    }
2023    if (Array.isArray(value)) {
2024      value = value.slice();
2025      for (let i = 0, ii = value.length; i < ii; i++) {
2026        if (value[i] instanceof Ref && this.xref) {
2027          value[i] = this.xref.fetch(value[i], this.suppressEncryption);
2028        }
2029      }
2030    }
2031    return value;
2032  }
2033  getRaw(key) {
2034    return this._map[key];
2035  }
2036  getKeys() {
2037    return Object.keys(this._map);
2038  }
2039  getRawValues() {
2040    return Object.values(this._map);
2041  }
2042  set(key, value) {
2043    this._map[key] = value;
2044  }
2045  has(key) {
2046    return this._map[key] !== undefined;
2047  }
2048  forEach(callback) {
2049    for (const key in this._map) {
2050      callback(key, this.get(key));
2051    }
2052  }
2053  static get empty() {
2054    const emptyDict = new Dict(null);
2055    emptyDict.set = (key, value) => {
2056      (0, _util.unreachable)("Should not call `set` on the empty dictionary.");
2057    };
2058    return (0, _util.shadow)(this, "empty", emptyDict);
2059  }
2060  static merge({
2061    xref,
2062    dictArray,
2063    mergeSubDicts = false
2064  }) {
2065    const mergedDict = new Dict(xref),
2066      properties = new Map();
2067    for (const dict of dictArray) {
2068      if (!(dict instanceof Dict)) {
2069        continue;
2070      }
2071      for (const [key, value] of Object.entries(dict._map)) {
2072        let property = properties.get(key);
2073        if (property === undefined) {
2074          property = [];
2075          properties.set(key, property);
2076        } else if (!mergeSubDicts || !(value instanceof Dict)) {
2077          continue;
2078        }
2079        property.push(value);
2080      }
2081    }
2082    for (const [name, values] of properties) {
2083      if (values.length === 1 || !(values[0] instanceof Dict)) {
2084        mergedDict._map[name] = values[0];
2085        continue;
2086      }
2087      const subDict = new Dict(xref);
2088      for (const dict of values) {
2089        for (const [key, value] of Object.entries(dict._map)) {
2090          if (subDict._map[key] === undefined) {
2091            subDict._map[key] = value;
2092          }
2093        }
2094      }
2095      if (subDict.size > 0) {
2096        mergedDict._map[name] = subDict;
2097      }
2098    }
2099    properties.clear();
2100    return mergedDict.size > 0 ? mergedDict : Dict.empty;
2101  }
2102  clone() {
2103    const dict = new Dict(this.xref);
2104    for (const key of this.getKeys()) {
2105      dict.set(key, this.getRaw(key));
2106    }
2107    return dict;
2108  }
2109}
2110exports.Dict = Dict;
2111class Ref {
2112  constructor(num, gen) {
2113    this.num = num;
2114    this.gen = gen;
2115  }
2116  toString() {
2117    if (this.gen === 0) {
2118      return `${this.num}R`;
2119    }
2120    return `${this.num}R${this.gen}`;
2121  }
2122  static fromString(str) {
2123    const ref = RefCache[str];
2124    if (ref) {
2125      return ref;
2126    }
2127    const m = /^(\d+)R(\d*)$/.exec(str);
2128    if (!m || m[1] === "0") {
2129      return null;
2130    }
2131    return RefCache[str] = new Ref(parseInt(m[1]), !m[2] ? 0 : parseInt(m[2]));
2132  }
2133  static get(num, gen) {

2134    const key = gen === 0 ? `${num}R` : `${num}R${gen}`;
2135    return RefCache[key] ||= new Ref(num, gen);
2136  }
2137}
2138exports.Ref = Ref;
2139class RefSet {
2140  constructor(parent = null) {
2141    this._set = new Set(parent?._set);
2142  }
2143  has(ref) {
2144    return this._set.has(ref.toString());
2145  }
2146  put(ref) {
2147    this._set.add(ref.toString());
2148  }
2149  remove(ref) {
2150    this._set.delete(ref.toString());
2151  }
2152  [Symbol.iterator]() {
2153    return this._set.values();
2154  }
2155  clear() {
2156    this._set.clear();
2157  }
2158}
2159exports.RefSet = RefSet;
2160class RefSetCache {
2161  constructor() {
2162    this._map = new Map();
2163  }
2164  get size() {
2165    return this._map.size;
2166  }
2167  get(ref) {
2168    return this._map.get(ref.toString());
2169  }
2170  has(ref) {
2171    return this._map.has(ref.toString());
2172  }
2173  put(ref, obj) {
2174    this._map.set(ref.toString(), obj);
2175  }
2176  putAlias(ref, aliasRef) {
2177    this._map.set(ref.toString(), this.get(aliasRef));
2178  }
2179  [Symbol.iterator]() {
2180    return this._map.values();
2181  }
2182  clear() {
2183    this._map.clear();
2184  }
2185}
2186exports.RefSetCache = RefSetCache;
2187function isName(v, name) {
2188  return v instanceof Name && (name === undefined || v.name === name);
2189}
2190function isCmd(v, cmd) {
2191  return v instanceof Cmd && (cmd === undefined || v.cmd === cmd);
2192}
2193function isDict(v, type) {
2194  return v instanceof Dict && (type === undefined || isName(v.get("Type"), type));
2195}
2196function isRefsEqual(v1, v2) {
2197  return v1.num === v2.num && v1.gen === v2.gen;
2198}
2199
2200/***/ }),
2201/* 5 */
2202/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
2203
2204
2205
2206Object.defineProperty(exports, "__esModule", ({
2207  value: true
2208}));
2209exports.BaseStream = void 0;
2210var _util = __w_pdfjs_require__(2);
2211class BaseStream {
2212  constructor() {
2213    if (this.constructor === BaseStream) {
2214      (0, _util.unreachable)("Cannot initialize BaseStream.");
2215    }
2216  }
2217  get length() {
2218    (0, _util.unreachable)("Abstract getter `length` accessed");
2219  }
2220  get isEmpty() {
2221    (0, _util.unreachable)("Abstract getter `isEmpty` accessed");
2222  }
2223  get isDataLoaded() {
2224    return (0, _util.shadow)(this, "isDataLoaded", true);
2225  }
2226  getByte() {
2227    (0, _util.unreachable)("Abstract method `getByte` called");
2228  }
2229  getBytes(length) {
2230    (0, _util.unreachable)("Abstract method `getBytes` called");
2231  }
2232  peekByte() {
2233    const peekedByte = this.getByte();
2234    if (peekedByte !== -1) {
2235      this.pos--;
2236    }
2237    return peekedByte;
2238  }
2239  peekBytes(length) {
2240    const bytes = this.getBytes(length);
2241    this.pos -= bytes.length;
2242    return bytes;
2243  }
2244  getUint16() {
2245    const b0 = this.getByte();
2246    const b1 = this.getByte();
2247    if (b0 === -1 || b1 === -1) {
2248      return -1;
2249    }
2250    return (b0 << 8) + b1;
2251  }
2252  getInt32() {
2253    const b0 = this.getByte();
2254    const b1 = this.getByte();
2255    const b2 = this.getByte();
2256    const b3 = this.getByte();
2257    return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
2258  }
2259  getByteRange(begin, end) {
2260    (0, _util.unreachable)("Abstract method `getByteRange` called");
2261  }
2262  getString(length) {
2263    return (0, _util.bytesToString)(this.getBytes(length));
2264  }
2265  skip(n) {
2266    this.pos += n || 1;
2267  }
2268  reset() {
2269    (0, _util.unreachable)("Abstract method `reset` called");
2270  }
2271  moveStart() {
2272    (0, _util.unreachable)("Abstract method `moveStart` called");
2273  }
2274  makeSubStream(start, length, dict = null) {
2275    (0, _util.unreachable)("Abstract method `makeSubStream` called");
2276  }
2277  getBaseStreams() {
2278    return null;
2279  }
2280}
2281exports.BaseStream = BaseStream;
2282
2283/***/ }),
2284/* 6 */
2285/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
2286
2287
2288
2289Object.defineProperty(exports, "__esModule", ({
2290  value: true
2291}));
2292exports.NetworkPdfManager = exports.LocalPdfManager = void 0;
2293var _util = __w_pdfjs_require__(2);
2294var _chunked_stream = __w_pdfjs_require__(7);
2295var _core_utils = __w_pdfjs_require__(3);
2296var _document = __w_pdfjs_require__(9);
2297var _stream = __w_pdfjs_require__(8);
2298function parseDocBaseUrl(url) {
2299  if (url) {
2300    const absoluteUrl = (0, _util.createValidAbsoluteUrl)(url);
2301    if (absoluteUrl) {
2302      return absoluteUrl.href;
2303    }
2304    (0, _util.warn)(`Invalid absolute docBaseUrl: "${url}".`);
2305  }
2306  return null;
2307}
2308class BasePdfManager {
2309  constructor(args) {
2310    if (this.constructor === BasePdfManager) {
2311      (0, _util.unreachable)("Cannot initialize BasePdfManager.");
2312    }
2313    this._docBaseUrl = parseDocBaseUrl(args.docBaseUrl);
2314    this._docId = args.docId;
2315    this._password = args.password;
2316    this.enableXfa = args.enableXfa;
2317    args.evaluatorOptions.isOffscreenCanvasSupported &&= _util.FeatureTest.isOffscreenCanvasSupported;
2318    this.evaluatorOptions = args.evaluatorOptions;
2319  }
2320  get docId() {
2321    return this._docId;
2322  }
2323  get password() {
2324    return this._password;
2325  }
2326  get docBaseUrl() {
2327    return this._docBaseUrl;
2328  }
2329  get catalog() {
2330    return this.pdfDocument.catalog;
2331  }
2332  ensureDoc(prop, args) {
2333    return this.ensure(this.pdfDocument, prop, args);
2334  }
2335  ensureXRef(prop, args) {
2336    return this.ensure(this.pdfDocument.xref, prop, args);
2337  }
2338  ensureCatalog(prop, args) {
2339    return this.ensure(this.pdfDocument.catalog, prop, args);
2340  }
2341  getPage(pageIndex) {
2342    return this.pdfDocument.getPage(pageIndex);
2343  }
2344  fontFallback(id, handler) {
2345    return this.pdfDocument.fontFallback(id, handler);
2346  }
2347  loadXfaFonts(handler, task) {
2348    return this.pdfDocument.loadXfaFonts(handler, task);
2349  }
2350  loadXfaImages() {
2351    return this.pdfDocument.loadXfaImages();
2352  }
2353  serializeXfaData(annotationStorage) {
2354    return this.pdfDocument.serializeXfaData(annotationStorage);
2355  }
2356  cleanup(manuallyTriggered = false) {
2357    return this.pdfDocument.cleanup(manuallyTriggered);
2358  }
2359  async ensure(obj, prop, args) {
2360    (0, _util.unreachable)("Abstract method `ensure` called");
2361  }
2362  requestRange(begin, end) {
2363    (0, _util.unreachable)("Abstract method `requestRange` called");
2364  }
2365  requestLoadedStream(noFetch = false) {
2366    (0, _util.unreachable)("Abstract method `requestLoadedStream` called");
2367  }
2368  sendProgressiveData(chunk) {
2369    (0, _util.unreachable)("Abstract method `sendProgressiveData` called");
2370  }
2371  updatePassword(password) {
2372    this._password = password;
2373  }
2374  terminate(reason) {
2375    (0, _util.unreachable)("Abstract method `terminate` called");
2376  }
2377}
2378class LocalPdfManager extends BasePdfManager {
2379  constructor(args) {
2380    super(args);
2381    const stream = new _stream.Stream(args.source);
2382    this.pdfDocument = new _document.PDFDocument(this, stream);
2383    this._loadedStreamPromise = Promise.resolve(stream);
2384  }
2385  async ensure(obj, prop, args) {
2386    const value = obj[prop];
2387    if (typeof value === "function") {

2388      return value.apply(obj, args);
2389    }
2390    return value;
2391  }
2392  requestRange(begin, end) {
2393    return Promise.resolve();
2394  }
2395  requestLoadedStream(noFetch = false) {
2396    return this._loadedStreamPromise;
2397  }
2398  terminate(reason) {}
2399}
2400exports.LocalPdfManager = LocalPdfManager;
2401class NetworkPdfManager extends BasePdfManager {
2402  constructor(args) {
2403    super(args);
2404    this.streamManager = new _chunked_stream.ChunkedStreamManager(args.source, {
2405      msgHandler: args.handler,
2406      length: args.length,
2407      disableAutoFetch: args.disableAutoFetch,
2408      rangeChunkSize: args.rangeChunkSize
2409    });
2410    this.pdfDocument = new _document.PDFDocument(this, this.streamManager.getStream());
2411  }
2412  async ensure(obj, prop, args) {
2413    try {
2414      const value = obj[prop];
2415      if (typeof value === "function") {
2416        return value.apply(obj, args);
2417      }
2418      return value;
2419    } catch (ex) {
2420      if (!(ex instanceof _core_utils.MissingDataException)) {
2421        throw ex;
2422      }
2423      await this.requestRange(ex.begin, ex.end);
2424      return this.ensure(obj, prop, args);
2425    }
2426  }
2427  requestRange(begin, end) {
2428    return this.streamManager.requestRange(begin, end);
2429  }
2430  requestLoadedStream(noFetch = false) {
2431    return this.streamManager.requestAllChunks(noFetch);
2432  }
2433  sendProgressiveData(chunk) {
2434    this.streamManager.onReceiveData({
2435      chunk
2436    });
2437  }
2438  terminate(reason) {
2439    this.streamManager.abort(reason);
2440  }
2441}
2442exports.NetworkPdfManager = NetworkPdfManager;
2443
2444/***/ }),
2445/* 7 */
2446/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
2447
2448
2449
2450Object.defineProperty(exports, "__esModule", ({
2451  value: true
2452}));
2453exports.ChunkedStreamManager = exports.ChunkedStream = void 0;
2454var _core_utils = __w_pdfjs_require__(3);
2455var _util = __w_pdfjs_require__(2);
2456var _stream = __w_pdfjs_require__(8);
2457class ChunkedStream extends _stream.Stream {
2458  constructor(length, chunkSize, manager) {
2459    super(new Uint8Array(length), 0, length, null);
2460    this.chunkSize = chunkSize;
2461    this._loadedChunks = new Set();
2462    this.numChunks = Math.ceil(length / chunkSize);
2463    this.manager = manager;
2464    this.progressiveDataLength = 0;
2465    this.lastSuccessfulEnsureByteChunk = -1;
2466  }
2467  getMissingChunks() {
2468    const chunks = [];
2469    for (let chunk = 0, n = this.numChunks; chunk < n; ++chunk) {
2470      if (!this._loadedChunks.has(chunk)) {
2471        chunks.push(chunk);
2472      }
2473    }
2474    return chunks;
2475  }
2476  get numChunksLoaded() {
2477    return this._loadedChunks.size;
2478  }
2479  get isDataLoaded() {
2480    return this.numChunksLoaded === this.numChunks;
2481  }
2482  onReceiveData(begin, chunk) {
2483    const chunkSize = this.chunkSize;
2484    if (begin % chunkSize !== 0) {
2485      throw new Error(`Bad begin offset: ${begin}`);
2486    }
2487    const end = begin + chunk.byteLength;
2488    if (end % chunkSize !== 0 && end !== this.bytes.length) {
2489      throw new Error(`Bad end offset: ${end}`);
2490    }
2491    this.bytes.set(new Uint8Array(chunk), begin);
2492    const beginChunk = Math.floor(begin / chunkSize);
2493    const endChunk = Math.floor((end - 1) / chunkSize) + 1;
2494    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
2495      this._loadedChunks.add(curChunk);
2496    }
2497  }
2498  onReceiveProgressiveData(data) {
2499    let position = this.progressiveDataLength;
2500    const beginChunk = Math.floor(position / this.chunkSize);
2501    this.bytes.set(new Uint8Array(data), position);
2502    position += data.byteLength;
2503    this.progressiveDataLength = position;
2504    const endChunk = position >= this.end ? this.numChunks : Math.floor(position / this.chunkSize);
2505    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
2506      this._loadedChunks.add(curChunk);
2507    }
2508  }
2509  ensureByte(pos) {
2510    if (pos < this.progressiveDataLength) {
2511      return;
2512    }
2513    const chunk = Math.floor(pos / this.chunkSize);
2514    if (chunk > this.numChunks) {
2515      return;
2516    }
2517    if (chunk === this.lastSuccessfulEnsureByteChunk) {
2518      return;
2519    }
2520    if (!this._loadedChunks.has(chunk)) {
2521      throw new _core_utils.MissingDataException(pos, pos + 1);
2522    }
2523    this.lastSuccessfulEnsureByteChunk = chunk;
2524  }
2525  ensureRange(begin, end) {
2526    if (begin >= end) {
2527      return;
2528    }
2529    if (end <= this.progressiveDataLength) {
2530      return;
2531    }
2532    const beginChunk = Math.floor(begin / this.chunkSize);
2533    if (beginChunk > this.numChunks) {
2534      return;
2535    }
2536    const endChunk = Math.min(Math.floor((end - 1) / this.chunkSize) + 1, this.numChunks);
2537    for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
2538      if (!this._loadedChunks.has(chunk)) {
2539        throw new _core_utils.MissingDataException(begin, end);
2540      }
2541    }
2542  }
2543  nextEmptyChunk(beginChunk) {
2544    const numChunks = this.numChunks;
2545    for (let i = 0; i < numChunks; ++i) {
2546      const chunk = (beginChunk + i) % numChunks;
2547      if (!this._loadedChunks.has(chunk)) {
2548        return chunk;
2549      }
2550    }
2551    return null;
2552  }
2553  hasChunk(chunk) {
2554    return this._loadedChunks.has(chunk);
2555  }
2556  getByte() {
2557    const pos = this.pos;
2558    if (pos >= this.end) {
2559      return -1;
2560    }
2561    if (pos >= this.progressiveDataLength) {
2562      this.ensureByte(pos);
2563    }
2564    return this.bytes[this.pos++];
2565  }
2566  getBytes(length) {
2567    const bytes = this.bytes;
2568    const pos = this.pos;
2569    const strEnd = this.end;
2570    if (!length) {
2571      if (strEnd > this.progressiveDataLength) {
2572        this.ensureRange(pos, strEnd);
2573      }
2574      return bytes.subarray(pos, strEnd);
2575    }
2576    let end = pos + length;
2577    if (end > strEnd) {
2578      end = strEnd;
2579    }
2580    if (end > this.progressiveDataLength) {
2581      this.ensureRange(pos, end);
2582    }
2583    this.pos = end;
2584    return bytes.subarray(pos, end);
2585  }
2586  getByteRange(begin, end) {
2587    if (begin < 0) {
2588      begin = 0;
2589    }
2590    if (end > this.end) {
2591      end = this.end;
2592    }
2593    if (end > this.progressiveDataLength) {
2594      this.ensureRange(begin, end);
2595    }
2596    return this.bytes.subarray(begin, end);
2597  }
2598  makeSubStream(start, length, dict = null) {
2599    if (length) {
2600      if (start + length > this.progressiveDataLength) {
2601        this.ensureRange(start, start + length);
2602      }
2603    } else if (start >= this.progressiveDataLength) {
2604      this.ensureByte(start);
2605    }
2606    function ChunkedStreamSubstream() {}
2607    ChunkedStreamSubstream.prototype = Object.create(this);
2608    ChunkedStreamSubstream.prototype.getMissingChunks = function () {
2609      const chunkSize = this.chunkSize;
2610      const beginChunk = Math.floor(this.start / chunkSize);
2611      const endChunk = Math.floor((this.end - 1) / chunkSize) + 1;
2612      const missingChunks = [];
2613      for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
2614        if (!this._loadedChunks.has(chunk)) {
2615          missingChunks.push(chunk);
2616        }
2617      }
2618      return missingChunks;
2619    };
2620    Object.defineProperty(ChunkedStreamSubstream.prototype, "isDataLoaded", {
2621      get() {
2622        if (this.numChunksLoaded === this.numChunks) {
2623          return true;
2624        }
2625        return this.getMissingChunks().length === 0;
2626      },
2627      configurable: true
2628    });
2629    const subStream = new ChunkedStreamSubstream();
2630    subStream.pos = subStream.start = start;
2631    subStream.end = start + length || this.end;
2632    subStream.dict = dict;
2633    return subStream;
2634  }
2635  getBaseStreams() {
2636    return [this];
2637  }
2638}
2639exports.ChunkedStream = ChunkedStream;
2640class ChunkedStreamManager {
2641  constructor(pdfNetworkStream, args) {
2642    this.length = args.length;
2643    this.chunkSize = args.rangeChunkSize;
2644    this.stream = new ChunkedStream(this.length, this.chunkSize, this);
2645    this.pdfNetworkStream = pdfNetworkStream;
2646    this.disableAutoFetch = args.disableAutoFetch;
2647    this.msgHandler = args.msgHandler;
2648    this.currRequestId = 0;
2649    this._chunksNeededByRequest = new Map();
2650    this._requestsByChunk = new Map();
2651    this._promisesByRequest = new Map();
2652    this.progressiveDataLength = 0;
2653    this.aborted = false;
2654    this._loadedStreamCapability = new _util.PromiseCapability();
2655  }
2656  sendRequest(begin, end) {
2657    const rangeReader = this.pdfNetworkStream.getRangeReader(begin, end);
2658    if (!rangeReader.isStreamingSupported) {
2659      rangeReader.onProgress = this.onProgress.bind(this);
2660    }
2661    let chunks = [],
2662      loaded = 0;
2663    return new Promise((resolve, reject) => {
2664      const readChunk = ({
2665        value,
2666        done
2667      }) => {
2668        try {
2669          if (done) {
2670            const chunkData = (0, _core_utils.arrayBuffersToBytes)(chunks);
2671            chunks = null;
2672            resolve(chunkData);
2673            return;
2674          }
2675          loaded += value.byteLength;
2676          if (rangeReader.isStreamingSupported) {
2677            this.onProgress({
2678              loaded
2679            });
2680          }
2681          chunks.push(value);
2682          rangeReader.read().then(readChunk, reject);
2683        } catch (e) {
2684          reject(e);
2685        }
2686      };
2687      rangeReader.read().then(readChunk, reject);
2688    }).then(data => {
2689      if (this.aborted) {
2690        return;
2691      }
2692      this.onReceiveData({
2693        chunk: data,
2694        begin
2695      });
2696    });
2697  }
2698  requestAllChunks(noFetch = false) {
2699    if (!noFetch) {
2700      const missingChunks = this.stream.getMissingChunks();
2701      this._requestChunks(missingChunks);
2702    }
2703    return this._loadedStreamCapability.promise;
2704  }
2705  _requestChunks(chunks) {
2706    const requestId = this.currRequestId++;
2707    const chunksNeeded = new Set();
2708    this._chunksNeededByRequest.set(requestId, chunksNeeded);
2709    for (const chunk of chunks) {
2710      if (!this.stream.hasChunk(chunk)) {
2711        chunksNeeded.add(chunk);
2712      }
2713    }
2714    if (chunksNeeded.size === 0) {
2715      return Promise.resolve();
2716    }
2717    const capability = new _util.PromiseCapability();
2718    this._promisesByRequest.set(requestId, capability);
2719    const chunksToRequest = [];
2720    for (const chunk of chunksNeeded) {
2721      let requestIds = this._requestsByChunk.get(chunk);
2722      if (!requestIds) {
2723        requestIds = [];
2724        this._requestsByChunk.set(chunk, requestIds);
2725        chunksToRequest.push(chunk);
2726      }
2727      requestIds.push(requestId);
2728    }
2729    if (chunksToRequest.length > 0) {
2730      const groupedChunksToRequest = this.groupChunks(chunksToRequest);
2731      for (const groupedChunk of groupedChunksToRequest) {
2732        const begin = groupedChunk.beginChunk * this.chunkSize;
2733        const end = Math.min(groupedChunk.endChunk * this.chunkSize, this.length);
2734        this.sendRequest(begin, end).catch(capability.reject);
2735      }
2736    }
2737    return capability.promise.catch(reason => {
2738      if (this.aborted) {
2739        return;
2740      }
2741      throw reason;
2742    });
2743  }
2744  getStream() {
2745    return this.stream;
2746  }
2747  requestRange(begin, end) {
2748    end = Math.min(end, this.length);
2749    const beginChunk = this.getBeginChunk(begin);
2750    const endChunk = this.getEndChunk(end);
2751    const chunks = [];
2752    for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
2753      chunks.push(chunk);
2754    }
2755    return this._requestChunks(chunks);
2756  }
2757  requestRanges(ranges = []) {
2758    const chunksToRequest = [];
2759    for (const range of ranges) {
2760      const beginChunk = this.getBeginChunk(range.begin);
2761      const endChunk = this.getEndChunk(range.end);
2762      for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
2763        if (!chunksToRequest.includes(chunk)) {
2764          chunksToRequest.push(chunk);
2765        }
2766      }
2767    }
2768    chunksToRequest.sort(function (a, b) {
2769      return a - b;
2770    });
2771    return this._requestChunks(chunksToRequest);
2772  }
2773  groupChunks(chunks) {
2774    const groupedChunks = [];
2775    let beginChunk = -1;
2776    let prevChunk = -1;
2777    for (let i = 0, ii = chunks.length; i < ii; ++i) {
2778      const chunk = chunks[i];
2779      if (beginChunk < 0) {
2780        beginChunk = chunk;
2781      }
2782      if (prevChunk >= 0 && prevChunk + 1 !== chunk) {
2783        groupedChunks.push({
2784          beginChunk,
2785          endChunk: prevChunk + 1
2786        });
2787        beginChunk = chunk;
2788      }
2789      if (i + 1 === chunks.length) {
2790        groupedChunks.push({
2791          beginChunk,
2792          endChunk: chunk + 1
2793        });
2794      }
2795      prevChunk = chunk;
2796    }
2797    return groupedChunks;
2798  }
2799  onProgress(args) {
2800    this.msgHandler.send("DocProgress", {
2801      loaded: this.stream.numChunksLoaded * this.chunkSize + args.loaded,
2802      total: this.length
2803    });
2804  }
2805  onReceiveData(args) {
2806    const chunk = args.chunk;
2807    const isProgressive = args.begin === undefined;
2808    const begin = isProgressive ? this.progressiveDataLength : args.begin;
2809    const end = begin + chunk.byteLength;
2810    const beginChunk = Math.floor(begin / this.chunkSize);
2811    const endChunk = end < this.length ? Math.floor(end / this.chunkSize) : Math.ceil(end / this.chunkSize);
2812    if (isProgressive) {
2813      this.stream.onReceiveProgressiveData(chunk);
2814      this.progressiveDataLength = end;
2815    } else {
2816      this.stream.onReceiveData(begin, chunk);
2817    }
2818    if (this.stream.isDataLoaded) {
2819      this._loadedStreamCapability.resolve(this.stream);
2820    }
2821    const loadedRequests = [];
2822    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
2823      const requestIds = this._requestsByChunk.get(curChunk);
2824      if (!requestIds) {
2825        continue;
2826      }
2827      this._requestsByChunk.delete(curChunk);
2828      for (const requestId of requestIds) {
2829        const chunksNeeded = this._chunksNeededByRequest.get(requestId);
2830        if (chunksNeeded.has(curChunk)) {
2831          chunksNeeded.delete(curChunk);
2832        }
2833        if (chunksNeeded.size > 0) {
2834          continue;
2835        }
2836        loadedRequests.push(requestId);
2837      }
2838    }
2839    if (!this.disableAutoFetch && this._requestsByChunk.size === 0) {
2840      let nextEmptyChunk;
2841      if (this.stream.numChunksLoaded === 1) {
2842        const lastChunk = this.stream.numChunks - 1;
2843        if (!this.stream.hasChunk(lastChunk)) {
2844          nextEmptyChunk = lastChunk;
2845        }
2846      } else {
2847        nextEmptyChunk = this.stream.nextEmptyChunk(endChunk);
2848      }
2849      if (Number.isInteger(nextEmptyChunk)) {
2850        this._requestChunks([nextEmptyChunk]);
2851      }
2852    }
2853    for (const requestId of loadedRequests) {
2854      const capability = this._promisesByRequest.get(requestId);
2855      this._promisesByRequest.delete(requestId);
2856      capability.resolve();
2857    }
2858    this.msgHandler.send("DocProgress", {
2859      loaded: this.stream.numChunksLoaded * this.chunkSize,
2860      total: this.length
2861    });
2862  }
2863  onError(err) {
2864    this._loadedStreamCapability.reject(err);
2865  }
2866  getBeginChunk(begin) {
2867    return Math.floor(begin / this.chunkSize);
2868  }
2869  getEndChunk(end) {
2870    return Math.floor((end - 1) / this.chunkSize) + 1;
2871  }
2872  abort(reason) {
2873    this.aborted = true;
2874    this.pdfNetworkStream?.cancelAllRequests(reason);
2875    for (const capability of this._promisesByRequest.values()) {
2876      capability.reject(reason);
2877    }
2878  }
2879}
2880exports.ChunkedStreamManager = ChunkedStreamManager;
2881
2882/***/ }),
2883/* 8 */
2884/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
2885
2886
2887
2888Object.defineProperty(exports, "__esModule", ({
2889  value: true
2890}));
2891exports.StringStream = exports.Stream = exports.NullStream = void 0;
2892var _base_stream = __w_pdfjs_require__(5);
2893var _util = __w_pdfjs_require__(2);
2894class Stream extends _base_stream.BaseStream {
2895  constructor(arrayBuffer, start, length, dict) {
2896    super();
2897    this.bytes = arrayBuffer instanceof Uint8Array ? arrayBuffer : new Uint8Array(arrayBuffer);
2898    this.start = start || 0;
2899    this.pos = this.start;
2900    this.end = start + length || this.bytes.length;
2901    this.dict = dict;
2902  }
2903  get length() {