https://berkeleysciencereview.com/pdf.worker.js

1/**
2 * @licstart The following is the entire license notice for the
3 * Javascript code in this page
4 *
5 * Copyright 2021 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 = factory();
26	else if(typeof define === 'function' && define.amd)
27		define("pdfjs-dist/build/pdf.worker", [], factory);
28	else if(typeof exports === 'object')
29		exports["pdfjs-dist/build/pdf.worker"] = factory();
30	else
31		root["pdfjs-dist/build/pdf.worker"] = root.pdfjsWorker = factory();
32})(this, function() {
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;
46
47var _util = __w_pdfjs_require__(2);
48
49var _primitives = __w_pdfjs_require__(5);
50
51var _pdf_manager = __w_pdfjs_require__(7);
52
53var _writer = __w_pdfjs_require__(71);
54
55var _is_node = __w_pdfjs_require__(4);
56
57var _message_handler = __w_pdfjs_require__(99);
58
59var _worker_stream = __w_pdfjs_require__(100);
60
61var _core_utils = __w_pdfjs_require__(9);
62
63class WorkerTask {
64  constructor(name) {
65    this.name = name;
66    this.terminated = false;
67    this._capability = (0, _util.createPromiseCapability)();
68  }
69
70  get finished() {
71    return this._capability.promise;
72  }
73
74  finish() {
75    this._capability.resolve();
76  }
77
78  terminate() {
79    this.terminated = true;
80  }
81
82  ensureNotTerminated() {
83    if (this.terminated) {
84      throw new Error("Worker task was terminated");
85    }
86  }
87
88}
89
90exports.WorkerTask = WorkerTask;
91
92class WorkerMessageHandler {
93  static setup(handler, port) {
94    let testMessageProcessed = false;
95    handler.on("test", function wphSetupTest(data) {
96      if (testMessageProcessed) {
97        return;
98      }
99
100      testMessageProcessed = true;
101      handler.send("test", data instanceof Uint8Array && data[0] === 255);
102    });
103    handler.on("configure", function wphConfigure(data) {
104      (0, _util.setVerbosityLevel)(data.verbosity);
105    });
106    handler.on("GetDocRequest", function wphSetupDoc(data) {
107      return WorkerMessageHandler.createDocumentHandler(data, port);
108    });
109  }
110
111  static createDocumentHandler(docParams, port) {
112    let pdfManager;
113    let terminated = false;
114    let cancelXHRs = null;
115    const WorkerTasks = [];
116    const verbosity = (0, _util.getVerbosityLevel)();
117    const apiVersion = docParams.apiVersion;
118    const workerVersion = '2.12.313';
119
120    if (apiVersion !== workerVersion) {
121      throw new Error(`The API version "${apiVersion}" does not match ` + `the Worker version "${workerVersion}".`);
122    }
123
124    const enumerableProperties = [];
125
126    for (const property in []) {
127      enumerableProperties.push(property);
128    }
129
130    if (enumerableProperties.length) {
131      throw new Error("The `Array.prototype` contains unexpected enumerable properties: " + enumerableProperties.join(", ") + "; thus breaking e.g. `for...in` iteration of `Array`s.");
132    }
133
134    if (typeof ReadableStream === "undefined") {
135      throw new Error("The browser/environment lacks native support for critical " + "functionality used by the PDF.js library (e.g. `ReadableStream`); " + "please use a `legacy`-build instead.");
136    }
137
138    const docId = docParams.docId;
139    const docBaseUrl = docParams.docBaseUrl;
140    const workerHandlerName = docParams.docId + "_worker";
141    let handler = new _message_handler.MessageHandler(workerHandlerName, docId, port);
142
143    function ensureNotTerminated() {
144      if (terminated) {
145        throw new Error("Worker was terminated");
146      }
147    }
148
149    function startWorkerTask(task) {
150      WorkerTasks.push(task);
151    }
152
153    function finishWorkerTask(task) {
154      task.finish();
155      const i = WorkerTasks.indexOf(task);
156      WorkerTasks.splice(i, 1);
157    }
158
159    async function loadDocument(recoveryMode) {
160      await pdfManager.ensureDoc("checkHeader");
161      await pdfManager.ensureDoc("parseStartXRef");
162      await pdfManager.ensureDoc("parse", [recoveryMode]);
163      await pdfManager.ensureDoc("checkFirstPage", [recoveryMode]);
164      await pdfManager.ensureDoc("checkLastPage", [recoveryMode]);
165      const isPureXfa = await pdfManager.ensureDoc("isPureXfa");
166
167      if (isPureXfa) {
168        const task = new WorkerTask("loadXfaFonts");
169        startWorkerTask(task);
170        await Promise.all([pdfManager.loadXfaFonts(handler, task).catch(reason => {}).then(() => finishWorkerTask(task)), pdfManager.loadXfaImages()]);
171      }
172
173      const [numPages, fingerprints] = await Promise.all([pdfManager.ensureDoc("numPages"), pdfManager.ensureDoc("fingerprints")]);
174      const htmlForXfa = isPureXfa ? await pdfManager.ensureDoc("htmlForXfa") : null;
175      return {
176        numPages,
177        fingerprints,
178        htmlForXfa
179      };
180    }
181
182    function getPdfManager(data, evaluatorOptions, enableXfa) {
183      const pdfManagerCapability = (0, _util.createPromiseCapability)();
184      let newPdfManager;
185      const source = data.source;
186
187      if (source.data) {
188        try {
189          newPdfManager = new _pdf_manager.LocalPdfManager(docId, source.data, source.password, handler, evaluatorOptions, enableXfa, docBaseUrl);
190          pdfManagerCapability.resolve(newPdfManager);
191        } catch (ex) {
192          pdfManagerCapability.reject(ex);
193        }
194
195        return pdfManagerCapability.promise;
196      }
197
198      let pdfStream,
199          cachedChunks = [];
200

201      try {
202        pdfStream = new _worker_stream.PDFWorkerStream(handler);
203      } catch (ex) {
204        pdfManagerCapability.reject(ex);
205        return pdfManagerCapability.promise;
206      }
207
208      const fullRequest = pdfStream.getFullReader();
209      fullRequest.headersReady.then(function () {
210        if (!fullRequest.isRangeSupported) {
211          return;
212        }
213
214        const disableAutoFetch = source.disableAutoFetch || fullRequest.isStreamingSupported;
215        newPdfManager = new _pdf_manager.NetworkPdfManager(docId, pdfStream, {
216          msgHandler: handler,
217          password: source.password,
218          length: fullRequest.contentLength,
219          disableAutoFetch,
220          rangeChunkSize: source.rangeChunkSize
221        }, evaluatorOptions, enableXfa, docBaseUrl);
222
223        for (let i = 0; i < cachedChunks.length; i++) {
224          newPdfManager.sendProgressiveData(cachedChunks[i]);
225        }
226
227        cachedChunks = [];
228        pdfManagerCapability.resolve(newPdfManager);
229        cancelXHRs = null;
230      }).catch(function (reason) {
231        pdfManagerCapability.reject(reason);
232        cancelXHRs = null;
233      });
234      let loaded = 0;
235
236      const flushChunks = function () {
237        const pdfFile = (0, _util.arraysToBytes)(cachedChunks);
238
239        if (source.length && pdfFile.length !== source.length) {
240          (0, _util.warn)("reported HTTP length is different from actual");
241        }
242
243        try {
244          newPdfManager = new _pdf_manager.LocalPdfManager(docId, pdfFile, source.password, handler, evaluatorOptions, enableXfa, docBaseUrl);
245          pdfManagerCapability.resolve(newPdfManager);
246        } catch (ex) {
247          pdfManagerCapability.reject(ex);
248        }
249
250        cachedChunks = [];
251      };
252
253      const readPromise = new Promise(function (resolve, reject) {
254        const readChunk = function ({
255          value,
256          done
257        }) {
258          try {
259            ensureNotTerminated();
260
261            if (done) {
262              if (!newPdfManager) {
263                flushChunks();
264              }
265
266              cancelXHRs = null;
267              return;
268            }
269
270            loaded += (0, _util.arrayByteLength)(value);
271
272            if (!fullRequest.isStreamingSupported) {
273              handler.send("DocProgress", {
274                loaded,
275                total: Math.max(loaded, fullRequest.contentLength || 0)
276              });
277            }
278
279            if (newPdfManager) {
280              newPdfManager.sendProgressiveData(value);
281            } else {
282              cachedChunks.push(value);
283            }
284
285            fullRequest.read().then(readChunk, reject);
286          } catch (e) {
287            reject(e);
288          }
289        };
290
291        fullRequest.read().then(readChunk, reject);
292      });
293      readPromise.catch(function (e) {
294        pdfManagerCapability.reject(e);
295        cancelXHRs = null;
296      });
297
298      cancelXHRs = function (reason) {
299        pdfStream.cancelAllRequests(reason);
300      };
301
302      return pdfManagerCapability.promise;
303    }
304
305    function setupDoc(data) {
306      function onSuccess(doc) {
307        ensureNotTerminated();
308        handler.send("GetDoc", {
309          pdfInfo: doc
310        });
311      }
312
313      function onFailure(ex) {
314        ensureNotTerminated();
315
316        if (ex instanceof _util.PasswordException) {
317          const task = new WorkerTask(`PasswordException: response ${ex.code}`);
318          startWorkerTask(task);
319          handler.sendWithPromise("PasswordRequest", ex).then(function ({
320            password
321          }) {
322            finishWorkerTask(task);
323            pdfManager.updatePassword(password);
324            pdfManagerReady();
325          }).catch(function () {
326            finishWorkerTask(task);
327            handler.send("DocException", ex);
328          });
329        } else if (ex instanceof _util.InvalidPDFException || ex instanceof _util.MissingPDFException || ex instanceof _util.UnexpectedResponseException || ex instanceof _util.UnknownErrorException) {
330          handler.send("DocException", ex);
331        } else {
332          handler.send("DocException", new _util.UnknownErrorException(ex.message, ex.toString()));
333        }
334      }
335
336      function pdfManagerReady() {
337        ensureNotTerminated();
338        loadDocument(false).then(onSuccess, function (reason) {
339          ensureNotTerminated();
340
341          if (!(reason instanceof _core_utils.XRefParseException)) {
342            onFailure(reason);
343            return;
344          }
345
346          pdfManager.requestLoadedStream();
347          pdfManager.onLoadedStream().then(function () {
348            ensureNotTerminated();

349            loadDocument(true).then(onSuccess, onFailure);
350          });
351        });
352      }
353
354      ensureNotTerminated();
355      const evaluatorOptions = {
356        maxImageSize: data.maxImageSize,
357        disableFontFace: data.disableFontFace,
358        ignoreErrors: data.ignoreErrors,
359        isEvalSupported: data.isEvalSupported,
360        fontExtraProperties: data.fontExtraProperties,
361        useSystemFonts: data.useSystemFonts,
362        cMapUrl: data.cMapUrl,
363        standardFontDataUrl: data.standardFontDataUrl
364      };
365      getPdfManager(data, evaluatorOptions, data.enableXfa).then(function (newPdfManager) {
366        if (terminated) {
367          newPdfManager.terminate(new _util.AbortException("Worker was terminated."));
368          throw new Error("Worker was terminated");
369        }
370
371        pdfManager = newPdfManager;
372        pdfManager.onLoadedStream().then(function (stream) {
373          handler.send("DataLoaded", {
374            length: stream.bytes.byteLength
375          });
376        });
377      }).then(pdfManagerReady, onFailure);
378    }
379
380    handler.on("GetPage", function wphSetupGetPage(data) {
381      return pdfManager.getPage(data.pageIndex).then(function (page) {
382        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]) {
383          return {
384            rotate,
385            ref,
386            userUnit,
387            view
388          };
389        });
390      });
391    });
392    handler.on("GetPageIndex", function wphSetupGetPageIndex({
393      ref
394    }) {
395      const pageRef = _primitives.Ref.get(ref.num, ref.gen);
396
397      return pdfManager.ensureCatalog("getPageIndex", [pageRef]);
398    });
399    handler.on("GetDestinations", function wphSetupGetDestinations(data) {
400      return pdfManager.ensureCatalog("destinations");
401    });
402    handler.on("GetDestination", function wphSetupGetDestination(data) {
403      return pdfManager.ensureCatalog("getDestination", [data.id]);
404    });
405    handler.on("GetPageLabels", function wphSetupGetPageLabels(data) {
406      return pdfManager.ensureCatalog("pageLabels");
407    });
408    handler.on("GetPageLayout", function wphSetupGetPageLayout(data) {
409      return pdfManager.ensureCatalog("pageLayout");
410    });
411    handler.on("GetPageMode", function wphSetupGetPageMode(data) {
412      return pdfManager.ensureCatalog("pageMode");
413    });
414    handler.on("GetViewerPreferences", function (data) {
415      return pdfManager.ensureCatalog("viewerPreferences");
416    });
417    handler.on("GetOpenAction", function (data) {
418      return pdfManager.ensureCatalog("openAction");
419    });
420    handler.on("GetAttachments", function wphSetupGetAttachments(data) {
421      return pdfManager.ensureCatalog("attachments");
422    });
423    handler.on("GetJavaScript", function wphSetupGetJavaScript(data) {
424      return pdfManager.ensureCatalog("javaScript");
425    });
426    handler.on("GetDocJSActions", function wphSetupGetDocJSActions(data) {
427      return pdfManager.ensureCatalog("jsActions");
428    });
429    handler.on("GetPageJSActions", function ({
430      pageIndex
431    }) {
432      return pdfManager.getPage(pageIndex).then(function (page) {
433        return pdfManager.ensure(page, "jsActions");
434      });
435    });
436    handler.on("GetOutline", function wphSetupGetOutline(data) {
437      return pdfManager.ensureCatalog("documentOutline");
438    });
439    handler.on("GetOptionalContentConfig", function (data) {
440      return pdfManager.ensureCatalog("optionalContentConfig");
441    });
442    handler.on("GetPermissions", function (data) {
443      return pdfManager.ensureCatalog("permissions");
444    });
445    handler.on("GetMetadata", function wphSetupGetMetadata(data) {
446      return Promise.all([pdfManager.ensureDoc("documentInfo"), pdfManager.ensureCatalog("metadata")]);
447    });
448    handler.on("GetMarkInfo", function wphSetupGetMarkInfo(data) {
449      return pdfManager.ensureCatalog("markInfo");
450    });
451    handler.on("GetData", function wphSetupGetData(data) {
452      pdfManager.requestLoadedStream();
453      return pdfManager.onLoadedStream().then(function (stream) {
454        return stream.bytes;
455      });
456    });
457    handler.on("GetAnnotations", function ({
458      pageIndex,
459      intent
460    }) {
461      return pdfManager.getPage(pageIndex).then(function (page) {
462        return page.getAnnotationsData(intent);
463      });
464    });
465    handler.on("GetFieldObjects", function (data) {
466      return pdfManager.ensureDoc("fieldObjects");
467    });
468    handler.on("HasJSActions", function (data) {
469      return pdfManager.ensureDoc("hasJSActions");
470    });
471    handler.on("GetCalculationOrderIds", function (data) {
472      return pdfManager.ensureDoc("calculationOrderIds");
473    });
474    handler.on("SaveDocument", function ({
475      isPureXfa,
476      numPages,
477      annotationStorage,
478      filename
479    }) {
480      pdfManager.requestLoadedStream();
481      const promises = [pdfManager.onLoadedStream(), pdfManager.ensureCatalog("acroForm"), pdfManager.ensureCatalog("acroFormRef"), pdfManager.ensureDoc("xref"), pdfManager.ensureDoc("startXRef")];
482
483      if (isPureXfa) {
484        promises.push(pdfManager.serializeXfaData(annotationStorage));
485      } else {
486        for (let pageIndex = 0; pageIndex < numPages; pageIndex++) {
487          promises.push(pdfManager.getPage(pageIndex).then(function (page) {
488            const task = new WorkerTask(`Save: page ${pageIndex}`);
489            return page.save(handler, task, annotationStorage).finally(function () {
490              finishWorkerTask(task);
491            });
492          }));
493        }
494      }
495
496      return Promise.all(promises).then(function ([stream, acroForm, acroFormRef, xref, startXRef, ...refs]) {
497        let newRefs = [];
498        let xfaData = null;
499
500        if (isPureXfa) {
501          xfaData = refs[0];
502
503          if (!xfaData) {
504            return stream.bytes;
505          }
506        } else {
507          for (const ref of refs) {
508            newRefs = ref.filter(x => x !== null).reduce((a, b) =>

508 a.concat(b), newRefs);
509          }
510
511          if (newRefs.length === 0) {
512            return stream.bytes;
513          }
514        }
515
516        const xfa = acroForm instanceof _primitives.Dict && acroForm.get("XFA") || null;
517        let xfaDatasetsRef = null;
518        let hasXfaDatasetsEntry = false;
519
520        if (Array.isArray(xfa)) {
521          for (let i = 0, ii = xfa.length; i < ii; i += 2) {
522            if (xfa[i] === "datasets") {
523              xfaDatasetsRef = xfa[i + 1];
524              acroFormRef = null;
525              hasXfaDatasetsEntry = true;
526            }
527          }
528
529          if (xfaDatasetsRef === null) {
530            xfaDatasetsRef = xref.getNewRef();
531          }
532        } else if (xfa) {
533          acroFormRef = null;
534          (0, _util.warn)("Unsupported XFA type.");
535        }
536
537        let newXrefInfo = Object.create(null);
538
539        if (xref.trailer) {
540          const infoObj = Object.create(null);
541          const xrefInfo = xref.trailer.get("Info") || null;
542
543          if (xrefInfo instanceof _primitives.Dict) {
544            xrefInfo.forEach((key, value) => {
545              if ((0, _util.isString)(key) && (0, _util.isString)(value)) {
546                infoObj[key] = (0, _util.stringToPDFString)(value);
547              }
548            });
549          }
550
551          newXrefInfo = {
552            rootRef: xref.trailer.getRaw("Root") || null,
553            encryptRef: xref.trailer.getRaw("Encrypt") || null,
554            newRef: xref.getNewRef(),
555            infoRef: xref.trailer.getRaw("Info") || null,
556            info: infoObj,
557            fileIds: xref.trailer.get("ID") || null,
558            startXRef,
559            filename
560          };
561        }
562
563        xref.resetNewRef();
564        return (0, _writer.incrementalUpdate)({
565          originalData: stream.bytes,
566          xrefInfo: newXrefInfo,
567          newRefs,
568          xref,
569          hasXfa: !!xfa,
570          xfaDatasetsRef,
571          hasXfaDatasetsEntry,
572          acroFormRef,
573          acroForm,
574          xfaData
575        });
576      });
577    });
578    handler.on("GetOperatorList", function wphSetupRenderPage(data, sink) {
579      const pageIndex = data.pageIndex;
580      pdfManager.getPage(pageIndex).then(function (page) {
581        const task = new WorkerTask(`GetOperatorList: page ${pageIndex}`);
582        startWorkerTask(task);
583        const start = verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
584        page.getOperatorList({
585          handler,
586          sink,
587          task,
588          intent: data.intent,
589          cacheKey: data.cacheKey,
590          annotationStorage: data.annotationStorage
591        }).then(function (operatorListInfo) {
592          finishWorkerTask(task);
593
594          if (start) {
595            (0, _util.info)(`page=${pageIndex + 1} - getOperatorList: time=` + `${Date.now() - start}ms, len=${operatorListInfo.length}`);
596          }
597
598          sink.close();
599        }, function (reason) {
600          finishWorkerTask(task);
601
602          if (task.terminated) {
603            return;
604          }
605
606          handler.send("UnsupportedFeature", {
607            featureId: _util.UNSUPPORTED_FEATURES.errorOperatorList
608          });
609          sink.error(reason);
610        });
611      });
612    });
613    handler.on("GetTextContent", function wphExtractText(data, sink) {
614      const pageIndex = data.pageIndex;
615      pdfManager.getPage(pageIndex).then(function (page) {
616        const task = new WorkerTask("GetTextContent: page " + pageIndex);
617        startWorkerTask(task);
618        const start = verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
619        page.extractTextContent({
620          handler,
621          task,
622          sink,
623          normalizeWhitespace: data.normalizeWhitespace,
624          includeMarkedContent: data.includeMarkedContent,
625          combineTextItems: data.combineTextItems
626        }).then(function () {
627          finishWorkerTask(task);
628
629          if (start) {
630            (0, _util.info)(`page=${pageIndex + 1} - getTextContent: time=` + `${Date.now() - start}ms`);
631          }
632
633          sink.close();
634        }, function (reason) {
635          finishWorkerTask(task);
636
637          if (task.terminated) {
638            return;
639          }
640
641          sink.error(reason);
642        });
643      });
644    });
645    handler.on("GetStructTree", function wphGetStructTree(data) {
646      return pdfManager.getPage(data.pageIndex).then(function (page) {
647        return pdfManager.ensure(page, "getStructTree");
648      });
649    });
650    handler.on("FontFallback", function (data) {
651      return pdfManager.fontFallback(data.id, handler);
652    });
653    handler.on("Cleanup", function wphCleanup(data) {
654      return pdfManager.cleanup(true);
655    });
656    handler.on("Terminate", function wphTerminate(data) {
657      terminated = true;
658      const waitOn = [];
659
660      if (pdfManager) {
661        pdfManager.terminate(new _util.AbortException("Worker was terminated."));
662        const cleanupPromise = pdfManager.cleanup();
663        waitOn.push(cleanupPromise);
664        pdfManager = null;
665      } else {
666        (0, _primitives.clearPrimitiveCaches)();
667      }
668
669      if (cancelXHRs) {
670        cancelXHRs(new _util.AbortException("Worker was terminated."));
671      }
672
673      for (const task of WorkerTasks) {
674        waitOn.push(task.finished);
675        task.terminate();
676      }
677
678      return Promise.all(waitOn).then(function () {
679        handler.destroy();
680        handler = null;
681      });
682    });
683    handler.on("Ready", function wphReady(data) {
684      setupDoc(docParams);
685      docParams = null;
686    });
687    return workerHandlerName;
688  }
689
690  static initializeFromPort(port) {
691    const handler = new _message_handler.MessageHandler("worker", "main", port);
692    WorkerMessageHandler.setup(handler, port);
693    handler.send("ready", null);
694  }
695
696}
697
698exports.WorkerMessageHandler = WorkerMessageHandler;
699
700function isMessagePort(maybePort) {
701  return typeof maybePort.postMessage === "function" && "onmessage" in maybePort;
702}
703
704if (typeof window === "undefined" && !_is_node.isNodeJS && typeof self !== "undefined" && isMessagePort(self)) {
705  WorkerMessageHandler.initializeFromPort(self);
706}
707
708/***/ }),
709/* 2 */
710/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
711
712
713
714Object.defineProperty(exports, "__esModule", ({
715  value: true
716}));
717exports.VerbosityLevel = exports.Util = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.UNSUPPORTED_FEATURES = exports.TextRenderingMode = exports.StreamType = exports.RenderingIntentFlag = exports.PermissionFlag = exports.PasswordResponses = exports.PasswordException = exports.PageActionEventType = exports.OPS = exports.MissingPDFException = exports.IsLittleEndianCached = exports.IsEvalSupportedCached = exports.InvalidPDFException = exports.ImageKind = exp

717orts.IDENTITY_MATRIX = exports.FormatError = exports.FontType = exports.FONT_IDENTITY_MATRIX = exports.DocumentActionEventType = exports.CMapCompressionType = exports.BaseException = exports.AnnotationType = exports.AnnotationStateModelType = exports.AnnotationReviewState = exports.AnnotationReplyType = exports.AnnotationMode = exports.AnnotationMarkedState = exports.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationBorderStyleType = exports.AnnotationActionEventType = exports.AbortException = void 0;
718exports.arrayByteLength = arrayByteLength;
719exports.arraysToBytes = arraysToBytes;
720exports.assert = assert;
721exports.bytesToString = bytesToString;
722exports.createObjectURL = createObjectURL;
723exports.createPromiseCapability = createPromiseCapability;
724exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
725exports.escapeString = escapeString;
726exports.getModificationDate = getModificationDate;
727exports.getVerbosityLevel = getVerbosityLevel;
728exports.info = info;
729exports.isArrayBuffer = isArrayBuffer;
730exports.isArrayEqual = isArrayEqual;
731exports.isAscii = isAscii;
732exports.isBool = isBool;
733exports.isNum = isNum;
734exports.isSameOrigin = isSameOrigin;
735exports.isString = isString;
736exports.objectFromMap = objectFromMap;
737exports.objectSize = objectSize;
738exports.removeNullCharacters = removeNullCharacters;
739exports.setVerbosityLevel = setVerbosityLevel;
740exports.shadow = shadow;
741exports.string32 = string32;
742exports.stringToBytes = stringToBytes;
743exports.stringToPDFString = stringToPDFString;
744exports.stringToUTF16BEString = stringToUTF16BEString;
745exports.stringToUTF8String = stringToUTF8String;
746exports.unreachable = unreachable;
747exports.utf8StringToString = utf8StringToString;
748exports.warn = warn;
749
750__w_pdfjs_require__(3);
751
752const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
753exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
754const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
755exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
756const RenderingIntentFlag = {
757  ANY: 0x01,
758  DISPLAY: 0x02,
759  PRINT: 0x04,
760  ANNOTATIONS_FORMS: 0x10,
761  ANNOTATIONS_STORAGE: 0x20,
762  ANNOTATIONS_DISABLE: 0x40,
763  OPLIST: 0x100
764};
765exports.RenderingIntentFlag = RenderingIntentFlag;
766const AnnotationMode = {
767  DISABLE: 0,
768  ENABLE: 1,
769  ENABLE_FORMS: 2,
770  ENABLE_STORAGE: 3
771};
772exports.AnnotationMode = AnnotationMode;
773const PermissionFlag = {
774  PRINT: 0x04,
775  MODIFY_CONTENTS: 0x08,
776  COPY: 0x10,
777  MODIFY_ANNOTATIONS: 0x20,
778  FILL_INTERACTIVE_FORMS: 0x100,
779  COPY_FOR_ACCESSIBILITY: 0x200,
780  ASSEMBLE: 0x400,
781  PRINT_HIGH_QUALITY: 0x800
782};
783exports.PermissionFlag = PermissionFlag;
784const TextRenderingMode = {
785  FILL: 0,
786  STROKE: 1,
787  FILL_STROKE: 2,
788  INVISIBLE: 3,
789  FILL_ADD_TO_PATH: 4,
790  STROKE_ADD_TO_PATH: 5,
791  FILL_STROKE_ADD_TO_PATH: 6,
792  ADD_TO_PATH: 7,
793  FILL_STROKE_MASK: 3,
794  ADD_TO_PATH_FLAG: 4
795};
796exports.TextRenderingMode = TextRenderingMode;
797const ImageKind = {
798  GRAYSCALE_1BPP: 1,
799  RGB_24BPP: 2,
800  RGBA_32BPP: 3
801};
802exports.ImageKind = ImageKind;
803const AnnotationType = {
804  TEXT: 1,
805  LINK: 2,
806  FREETEXT: 3,
807  LINE: 4,
808  SQUARE: 5,
809  CIRCLE: 6,
810  POLYGON: 7,
811  POLYLINE: 8,
812  HIGHLIGHT: 9,
813  UNDERLINE: 10,
814  SQUIGGLY: 11,
815  STRIKEOUT: 12,
816  STAMP: 13,
817  CARET: 14,
818  INK: 15,
819  POPUP: 16,
820  FILEATTACHMENT: 17,
821  SOUND: 18,
822  MOVIE: 19,
823  WIDGET: 20,
824  SCREEN: 21,
825  PRINTERMARK: 22,
826  TRAPNET: 23,
827  WATERMARK: 24,
828  THREED: 25,
829  REDACT: 26
830};
831exports.AnnotationType = AnnotationType;
832const AnnotationStateModelType = {
833  MARKED: "Marked",
834  REVIEW: "Review"
835};
836exports.AnnotationStateModelType = AnnotationStateModelType;
837const AnnotationMarkedState = {
838  MARKED: "Marked",
839  UNMARKED: "Unmarked"
840};
841exports.AnnotationMarkedState = AnnotationMarkedState;
842const AnnotationReviewState = {
843  ACCEPTED: "Accepted",
844  REJECTED: "Rejected",
845  CANCELLED: "Cancelled",
846  COMPLETED: "Completed",
847  NONE: "None"
848};
849exports.AnnotationReviewState = AnnotationReviewState;
850const AnnotationReplyType = {
851  GROUP: "Group",
852  REPLY: "R"
853};
854exports.AnnotationReplyType = AnnotationReplyType;
855const AnnotationFlag = {
856  INVISIBLE: 0x01,
857  HIDDEN: 0x02,
858  PRINT: 0x04,
859  NOZOOM: 0x08,
860  NOROTATE: 0x10,
861  NOVIEW: 0x20,
862  READONLY: 0x40,
863  LOCKED: 0x80,
864  TOGGLENOVIEW: 0x100,
865  LOCKEDCONTENTS: 0x200
866};
867exports.AnnotationFlag = AnnotationFlag;
868const AnnotationFieldFlag = {
869  READONLY: 0x0000001,

870  REQUIRED: 0x0000002,
871  NOEXPORT: 0x0000004,
872  MULTILINE: 0x0001000,
873  PASSWORD: 0x0002000,
874  NOTOGGLETOOFF: 0x0004000,
875  RADIO: 0x0008000,
876  PUSHBUTTON: 0x0010000,
877  COMBO: 0x0020000,
878  EDIT: 0x0040000,
879  SORT: 0x0080000,
880  FILESELECT: 0x0100000,
881  MULTISELECT: 0x0200000,
882  DONOTSPELLCHECK: 0x0400000,
883  DONOTSCROLL: 0x0800000,
884  COMB: 0x1000000,
885  RICHTEXT: 0x2000000,
886  RADIOSINUNISON: 0x2000000,
887  COMMITONSELCHANGE: 0x4000000
888};
889exports.AnnotationFieldFlag = AnnotationFieldFlag;
890const AnnotationBorderStyleType = {
891  SOLID: 1,
892  DASHED: 2,
893  BEVELED: 3,
894  INSET: 4,
895  UNDERLINE: 5
896};
897exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
898const AnnotationActionEventType = {
899  E: "Mouse Enter",
900  X: "Mouse Exit",
901  D: "Mouse Down",
902  U: "Mouse Up",
903  Fo: "Focus",
904  Bl: "Blur",
905  PO: "PageOpen",
906  PC: "PageClose",
907  PV: "PageVisible",
908  PI: "PageInvisible",
909  K: "Keystroke",
910  F: "Format",
911  V: "Validate",
912  C: "Calculate"
913};
914exports.AnnotationActionEventType = AnnotationActionEventType;
915const DocumentActionEventType = {
916  WC: "WillClose",
917  WS: "WillSave",
918  DS: "DidSave",
919  WP: "WillPrint",
920  DP: "DidPrint"
921};
922exports.DocumentActionEventType = DocumentActionEventType;
923const PageActionEventType = {
924  O: "PageOpen",
925  C: "PageClose"
926};
927exports.PageActionEventType = PageActionEventType;
928const StreamType = {
929  UNKNOWN: "UNKNOWN",
930  FLATE: "FLATE",
931  LZW: "LZW",
932  DCT: "DCT",
933  JPX: "JPX",
934  JBIG: "JBIG",
935  A85: "A85",
936  AHX: "AHX",
937  CCF: "CCF",
938  RLX: "RLX"
939};
940exports.StreamType = StreamType;
941const FontType = {
942  UNKNOWN: "UNKNOWN",
943  TYPE1: "TYPE1",
944  TYPE1STANDARD: "TYPE1STANDARD",
945  TYPE1C: "TYPE1C",
946  CIDFONTTYPE0: "CIDFONTTYPE0",
947  CIDFONTTYPE0C: "CIDFONTTYPE0C",
948  TRUETYPE: "TRUETYPE",
949  CIDFONTTYPE2: "CIDFONTTYPE2",
950  TYPE3: "TYPE3",
951  OPENTYPE: "OPENTYPE",
952  TYPE0: "TYPE0",
953  MMTYPE1: "MMTYPE1"
954};
955exports.FontType = FontType;
956const VerbosityLevel = {
957  ERRORS: 0,
958  WARNINGS: 1,
959  INFOS: 5
960};
961exports.VerbosityLevel = VerbosityLevel;
962const CMapCompressionType = {
963  NONE: 0,
964  BINARY: 1,
965  STREAM: 2
966};
967exports.CMapCompressionType = CMapCompressionType;
968const OPS = {
969  dependency: 1,
970  setLineWidth: 2,
971  setLineCap: 3,
972  setLineJoin: 4,
973  setMiterLimit: 5,
974  setDash: 6,
975  setRenderingIntent: 7,
976  setFlatness: 8,
977  setGState: 9,
978  save: 10,
979  restore: 11,
980  transform: 12,
981  moveTo: 13,
982  lineTo: 14,
983  curveTo: 15,
984  curveTo2: 16,

985  curveTo3: 17,
986  closePath: 18,
987  rectangle: 19,
988  stroke: 20,
989  closeStroke: 21,
990  fill: 22,
991  eoFill: 23,
992  fillStroke: 24,
993  eoFillStroke: 25,
994  closeFillStroke: 26,
995  closeEOFillStroke: 27,
996  endPath: 28,
997  clip: 29,
998  eoClip: 30,
999  beginText: 31,
1000  endText: 32,
1001  setCharSpacing: 33,
1002  setWordSpacing: 34,
1003  setHScale: 35,
1004  setLeading: 36,
1005  setFont: 37,
1006  setTextRenderingMode: 38,
1007  setTextRise: 39,
1008  moveText: 40,
1009  setLeadingMoveText: 41,
1010  setTextMatrix: 42,
1011  nextLine: 43,
1012  showText: 44,
1013  showSpacedText: 45,
1014  nextLineShowText: 46,
1015  nextLineSetSpacingShowText: 47,
1016  setCharWidth: 48,
1017  setCharWidthAndBounds: 49,
1018  setStrokeColorSpace: 50,
1019  setFillColorSpace: 51,
1020  setStrokeColor: 52,
1021  setStrokeColorN: 53,
1022  setFillColor: 54,
1023  setFillColorN: 55,
1024  setStrokeGray: 56,
1025  setFillGray: 57,
1026  setStrokeRGBColor: 58,
1027  setFillRGBColor: 59,
1028  setStrokeCMYKColor: 60,
1029  setFillCMYKColor: 61,
1030  shadingFill: 62,
1031  beginInlineImage: 63,
1032  beginImageData: 64,
1033  endInlineImage: 65,
1034  paintXObject: 66,
1035  markPoint: 67,
1036  markPointProps: 68,
1037  beginMarkedContent: 69,
1038  beginMarkedContentProps: 70,
1039  endMarkedContent: 71,
1040  beginCompat: 72,
1041  endCompat: 73,
1042  paintFormXObjectBegin: 74,
1043  paintFormXObjectEnd: 75,
1044  beginGroup: 76,
1045  endGroup: 77,
1046  beginAnnotations: 78,
1047  endAnnotations: 79,
1048  beginAnnotation: 80,
1049  endAnnotation: 81,
1050  paintJpegXObject: 82,
1051  paintImageMaskXObject: 83,
1052  paintImageMaskXObjectGroup: 84,
1053  paintImageXObject: 85,
1054  paintInlineImageXObject: 86,
1055  paintInlineImageXObjectGroup: 87,
1056  paintImageXObjectRepeat: 88,
1057  paintImageMaskXObjectRepeat: 89,
1058  paintSolidColorImageMask: 90,
1059  constructPath: 91
1060};
1061exports.OPS = OPS;
1062const UNSUPPORTED_FEATURES = {
1063  unknown: "unknown",
1064  forms: "forms",
1065  javaScript: "javaScript",
1066  signatures: "signatures",
1067  smask: "smask",
1068  shadingPattern: "shadingPattern",
1069  font: "font",
1070  errorTilingPattern: "errorTilingPattern",
1071  errorExtGState: "errorExtGState",
1072  errorXObject: "errorXObject",
1073  errorFontLoadType3: "errorFontLoadType3",
1074  errorFontState: "errorFontState",
1075  errorFontMissing: "errorFontMissing",
1076  errorFontTranslate: "errorFontTranslate",
1077  errorColorSpace: "errorColorSpace",
1078  errorOperatorList: "errorOperatorList",
1079  errorFontToUnicode: "errorFontToUnicode",
1080  errorFontLoadNative: "errorFontLoadNative",
1081  errorFontBuildPath: "errorFontBuildPath",
1082  errorFontGetPath: "errorFontGetPath",
1083  errorMarkedContent: "errorMarkedContent",
1084  errorContentSubStream: "errorContentSubStream"
1085};
1086exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
1087const PasswordResponses = {
1088  NEED_PASSWORD: 1,
1089  INCORRECT_PASSWORD: 2
1090};
1091exports.PasswordResponses = PasswordResponses;
1092let verbosity = VerbosityLevel.WARNINGS;
1093
1094function setVerbosityLevel(level) {
1095  if (Number.isInteger(level)) {
1096    verbosity = level;
1097  }
1098}
1099
1100function getVerbosityLevel() {
1101  return verbosity;
1102}
1103
1104function info(msg) {
1105  if (verbosity >= VerbosityLevel.INFOS) {
1106    console.log(`Info: ${msg}`);
1107  }
1108}
1109
1110function warn(msg) {
1111  if (verbosity >= VerbosityLevel.WARNINGS) {
1112    console.log(`Warning: ${msg}`);
1113  }
1114}
1115
1116function unreachable(msg) {
1117  throw new Error(msg);
1118}
1119
1120function assert(cond, msg) {
1121  if (!cond) {
1122    unreachable(msg);
1123  }
1124}
1125
1126function isSameOrigin(baseUrl, otherUrl) {
1127  let base;
1128
1129  try {
1130    base = new URL(baseUrl);
1131
1132    if (!base.origin || base.origin === "null") {
1133      return false;
1134    }
1135  } catch (e) {
1136    return false;
1137  }
1138
1139  const other = new URL(otherUrl, base);
1140  return base.origin === other.origin;
1141}
1142
1143function _isValidProtocol(url) {
1144  if (!url) {
1145    return false;
1146  }
1147
1148  switch (url.protocol) {
1149    case "http:":
1150    case "https:":
1151    case "ftp:":
1152    case "mailto:":
1153    case "tel:":
1154      return true;
1155
1156    default:
1157      return false;
1158  }
1159}
1160
1161function createValidAbsoluteUrl(url, baseUrl = null, options = null) {
1162  if (!url) {
1163    return null;
1164  }
1165
1166  try {
1167    if (options && typeof url === "string") {
1168      if (options.addDefaultProtocol && url.startsWith("www.")) {
1169        const dots = url.match(/\./g);
1170
1171        if (dots && dots.length >= 2) {
1172          url = `http://${url}`;
1173        }
1174      }
1175
1176      if (options.tryConvertEncoding) {
1177        try {
1178          url = stringToUTF8String(url);
1179        } catch (ex) {}
1180      }
1181    }
1182
1183    const absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);
1184
1185    if (_isValidProtocol(absoluteUrl)) {
1186      return absoluteUrl;
1187    }
1188  } catch (ex) {}
1189
1190  return null;
1191}
1192
1193function shadow(obj, prop, value) {
1194  Object.defineProperty(obj, prop, {
1195    value,
1196    enumerable: true,
1197    configurable: true,
1198    writable: false
1199  });
1200  return value;
1201}
1202
1203const BaseException = function BaseExceptionClosure() {
1204  function BaseException(message, name) {
1205    if (this.constructor === BaseException) {
1206      unreachable("Cannot initialize BaseException.");
1207    }
1208
1209    this.message = message;
1210    this.name = name;
1211  }
1212
1213  BaseException.prototype = new Error();
1214  BaseException.constructor = BaseException;
1215  return BaseException;
1216}();
1217
1218exports.BaseException = BaseException;
1219
1220class PasswordException extends BaseException {
1221  constructor(msg, code) {
1222    super(msg, "PasswordException");
1223    this.code = code;
1224  }
1225
1226}
1227
1228exports.PasswordException = PasswordException;
1229
1230class UnknownErrorException extends BaseException {
1231  constructor(msg, details) {
1232    super(msg, "UnknownErrorException");
1233    this.details = details;
1234  }
1235
1236}
1237
1238exports.UnknownErrorException = UnknownErrorException;
1239
1240class InvalidPDFException extends BaseException {
1241  constructor(msg) {
1242    super(msg, "InvalidPDFException");
1243  }
1244
1245}
1246
1247exports.InvalidPDFException = InvalidPDFException;
1248
1249class MissingPDFException extends BaseException {
1250  constructor(msg) {
1251    super(msg, "MissingPDFException");
1252  }
1253
1254}
1255
1256exports.MissingPDFException = MissingPDFException;
1257
1258class UnexpectedResponseException extends BaseException {
1259  constructor(msg, status) {
1260    super(msg, "UnexpectedResponseException");
1261    this.status = status;
1262  }
1263
1264}
1265
1266exports.UnexpectedResponseException = UnexpectedResponseException;
1267
1268class FormatError extends BaseException {
1269  constructor(msg) {
1270    super(msg, "FormatError");
1271  }
1272
1273}
1274
1275exports.FormatError = FormatError;
1276
1277class AbortException extends BaseException {
1278  constructor(msg) {
1279    super(msg, "AbortException");
1280  }
1281
1282}
1283
1284exports.AbortException = AbortException;
1285const NullCharactersRegExp = /\x00+/g;
1286const InvisibleCharactersRegExp = /[\x01-\x1F]/g;
1287
1288function removeNullCharacters(str, replaceInvisible = false) {
1289  if (typeof str !== "string") {
1290    warn("The argument for removeNullCharacters must be a string.");
1291    return str;
1292  }
1293
1294  if (replaceInvisible) {
1295    str = str.replace(InvisibleCharactersRegExp, " ");
1296  }
1297
1298  return str.replace(NullCharactersRegExp, "");
1299}
1300
1301function bytesToString(bytes) {
1302  assert(bytes !== null && typeof bytes === "object" && bytes.length !== undefined, "Invalid argument for bytesToString");
1303  const length = bytes.length;
1304  const MAX_ARGUMENT_COUNT = 8192;
1305
1306  if (length < MAX_ARGUMENT_COUNT) {
1307    return String.fromCharCode.apply(null, bytes);
1308  }
1309
1310  const strBuf = [];
1311
1312  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
1313    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
1314    const chunk = bytes.subarray(i, chunkEnd);
1315    strBuf.push(String.fromCharCode.apply(null, chunk));
1316  }
1317
1318  return strBuf.join("");
1319}
1320
1321function stringToBytes(str) {
1322  assert(typeof str === "string", "Invalid argument for stringToBytes");
1323  const length = str.length;
1324  const bytes = new Uint8Array(length);
1325
1326  for (let i = 0; i < length; ++i) {
1327    bytes[i] = str.charCodeAt(i) & 0xff;

1328  }
1329
1330  return bytes;
1331}
1332
1333function arrayByteLength(arr) {
1334  if (arr.length !== undefined) {
1335    return arr.length;
1336  }
1337
1338  assert(arr.byteLength !== undefined, "arrayByteLength - invalid argument.");
1339  return arr.byteLength;
1340}
1341
1342function arraysToBytes(arr) {
1343  const length = arr.length;
1344
1345  if (length === 1 && arr[0] instanceof Uint8Array) {
1346    return arr[0];
1347  }
1348
1349  let resultLength = 0;
1350
1351  for (let i = 0; i < length; i++) {
1352    resultLength += arrayByteLength(arr[i]);
1353  }
1354
1355  let pos = 0;
1356  const data = new Uint8Array(resultLength);
1357
1358  for (let i = 0; i < length; i++) {
1359    let item = arr[i];
1360
1361    if (!(item instanceof Uint8Array)) {
1362      if (typeof item === "string") {
1363        item = stringToBytes(item);
1364      } else {
1365        item = new Uint8Array(item);
1366      }
1367    }
1368
1369    const itemLength = item.byteLength;
1370    data.set(item, pos);
1371    pos += itemLength;
1372  }
1373
1374  return data;
1375}
1376
1377function string32(value) {
1378  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
1379}
1380
1381function objectSize(obj) {
1382  return Object.keys(obj).length;
1383}
1384
1385function objectFromMap(map) {
1386  const obj = Object.create(null);
1387
1388  for (const [key, value] of map) {
1389    obj[key] = value;
1390  }
1391
1392  return obj;
1393}
1394
1395function isLittleEndian() {
1396  const buffer8 = new Uint8Array(4);
1397  buffer8[0] = 1;
1398  const view32 = new Uint32Array(buffer8.buffer, 0, 1);
1399  return view32[0] === 1;
1400}
1401
1402const IsLittleEndianCached = {
1403  get value() {
1404    return shadow(this, "value", isLittleEndian());
1405  }
1406
1407};
1408exports.IsLittleEndianCached = IsLittleEndianCached;
1409
1410function isEvalSupported() {
1411  try {
1412    new Function("");
1413    return true;
1414  } catch (e) {
1415    return false;
1416  }
1417}
1418
1419const IsEvalSupportedCached = {
1420  get value() {
1421    return shadow(this, "value", isEvalSupported());
1422  }
1423
1424};
1425exports.IsEvalSupportedCached = IsEvalSupportedCached;
1426const hexNumbers = [...Array(256).keys()].map(n => n.toString(16).padStart(2, "0"));
1427
1428class Util {
1429  static makeHexColor(r, g, b) {
1430    return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`;
1431  }
1432
1433  static transform(m1, m2) {
1434    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]];
1435  }
1436
1437  static applyTransform(p, m) {
1438    const xt = p[0] * m[0] + p[1] * m[2] + m[4];
1439    const yt = p[0] * m[1] + p[1] * m[3] + m[5];
1440    return [xt, yt];
1441  }
1442
1443  static applyInverseTransform(p, m) {
1444    const d = m[0] * m[3] - m[1] * m[2];
1445    const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
1446    const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
1447    return [xt, yt];
1448  }
1449
1450  static getAxialAlignedBoundingBox(r, m) {
1451    const p1 = Util.applyTransform(r, m);
1452    const p2 = Util.applyTransform(r.slice(2, 4), m);
1453    const p3 = Util.applyTransform([r[0], r[3]], m);
1454    const p4 = Util.applyTransform([r[2], r[1]], m);
1455    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])];
1456  }
1457
1458  static inverseTransform(m) {
1459    const d = m[0] * m[3] - m[1] * m[2];
1460    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];
1461  }
1462
1463  static apply3dTransform(m, v) {
1464    return [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]];
1465  }
1466
1467  static singularValueDecompose2dScale(m) {
1468    const transpose = [m[0], m[2], m[1], m[3]];
1469    const a = m[0] * transpose[0] + m[1] * transpose[2];
1470    const b = m[0] * transpose[1] + m[1] * transpose[3];
1471    const c = m[2] * transpose[0] + m[3] * transpose[2];
1472    const d = m[2] * transpose[1] + m[3] * transpose[3];
1473    const first = (a + d) / 2;
1474    const second = Math.sqrt((a + d) ** 2 - 4 * (a * d - c * b)) / 2;
1475    const sx = first + second || 1;
1476    const sy = first - second || 1;
1477    return [Math.sqrt(sx), Math.sqrt(sy)];
1478  }
1479
1480  static normalizeRect(rect) {
1481    const r = rect.slice(0);
1482
1483    if (rect[0] > rect[2]) {
1484      r[0] = rect[2];
1485      r[2] = rect[0];
1486    }
1487
1488    if (rect[1] > rect[3]) {
1489      r[1] = rect[3];
1490      r[3] = rect[1];
1491    }
1492
1493    return r;
1494  }
1495
1496  static intersect(rect1, rect2) {
1497    function compare(a, b) {
1498      return a - b;
1499    }
1500
1501    const orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare);

1502    const orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare);
1503    const result = [];
1504    rect1 = Util.normalizeRect(rect1);
1505    rect2 = Util.normalizeRect(rect2);
1506
1507    if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
1508      result[0] = orderedX[1];
1509      result[2] = orderedX[2];
1510    } else {
1511      return null;
1512    }
1513
1514    if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
1515      result[1] = orderedY[1];
1516      result[3] = orderedY[2];
1517    } else {
1518      return null;
1519    }
1520
1521    return result;
1522  }
1523
1524  static bezierBoundingBox(x0, y0, x1, y1, x2, y2, x3, y3) {
1525    const tvalues = [],
1526          bounds = [[], []];
1527    let a, b, c, t, t1, t2, b2ac, sqrtb2ac;
1528
1529    for (let i = 0; i < 2; ++i) {
1530      if (i === 0) {
1531        b = 6 * x0 - 12 * x1 + 6 * x2;
1532        a = -3 * x0 + 9 * x1 - 9 * x2 + 3 * x3;
1533        c = 3 * x1 - 3 * x0;
1534      } else {
1535        b = 6 * y0 - 12 * y1 + 6 * y2;
1536        a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3;
1537        c = 3 * y1 - 3 * y0;
1538      }
1539
1540      if (Math.abs(a) < 1e-12) {
1541        if (Math.abs(b) < 1e-12) {
1542          continue;
1543        }
1544
1545        t = -c / b;
1546
1547        if (0 < t && t < 1) {
1548          tvalues.push(t);
1549        }
1550
1551        continue;
1552      }
1553
1554      b2ac = b * b - 4 * c * a;
1555      sqrtb2ac = Math.sqrt(b2ac);
1556
1557      if (b2ac < 0) {
1558        continue;
1559      }
1560
1561      t1 = (-b + sqrtb2ac) / (2 * a);
1562
1563      if (0 < t1 && t1 < 1) {
1564        tvalues.push(t1);
1565      }
1566
1567      t2 = (-b - sqrtb2ac) / (2 * a);
1568
1569      if (0 < t2 && t2 < 1) {
1570        tvalues.push(t2);
1571      }
1572    }
1573
1574    let j = tvalues.length,
1575        mt;
1576    const jlen = j;
1577
1578    while (j--) {
1579      t = tvalues[j];
1580      mt = 1 - t;
1581      bounds[0][j] = mt * mt * mt * x0 + 3 * mt * mt * t * x1 + 3 * mt * t * t * x2 + t * t * t * x3;
1582      bounds[1][j] = mt * mt * mt * y0 + 3 * mt * mt * t * y1 + 3 * mt * t * t * y2 + t * t * t * y3;
1583    }
1584
1585    bounds[0][jlen] = x0;
1586    bounds[1][jlen] = y0;
1587    bounds[0][jlen + 1] = x3;
1588    bounds[1][jlen + 1] = y3;
1589    bounds[0].length = bounds[1].length = jlen + 2;
1590    return [Math.min(...bounds[0]), Math.min(...bounds[1]), Math.max(...bounds[0]), Math.max(...bounds[1])];
1591  }
1592
1593}
1594
1595exports.Util = Util;
1596const 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];
1597
1598function stringToPDFString(str) {
1599  const length = str.length,
1600        strBuf = [];
1601
1602  if (str[0] === "\xFE" && str[1] === "\xFF") {
1603    for (let i = 2; i < length; i += 2) {
1604      strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
1605    }
1606  } else if (str[0] === "\xFF" && str[1] === "\xFE") {
1607    for (let i = 2; i < length; i += 2) {
1608      strBuf.push(String.fromCharCode(str.charCodeAt(i + 1) << 8 | str.charCodeAt(i)));
1609    }
1610  } else {
1611    for (let i = 0; i < length; ++i) {
1612      const code = PDFStringTranslateTable[str.charCodeAt(i)];
1613      strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
1614    }
1615  }
1616
1617  return strBuf.join("");
1618}
1619
1620function escapeString(str) {
1621  return str.replace(/([()\\\n\r])/g, match => {
1622    if (match === "\n") {
1623      return "\\n";
1624    } else if (match === "\r") {
1625      return "\\r";
1626    }
1627
1628    return `\\${match}`;
1629  });
1630}
1631
1632function isAscii(str) {
1633  return /^[\x00-\x7F]*$/.test(str);
1634}
1635
1636function stringToUTF16BEString(str) {
1637  const buf = ["\xFE\xFF"];
1638
1639  for (let i = 0, ii = str.length; i < ii; i++) {
1640    const char = str.charCodeAt(i);
1641    buf.push(String.fromCharCode(char >> 8 & 0xff), String.fromCharCode(char & 0xff));
1642  }
1643
1644  return buf.join("");
1645}
1646
1647function stringToUTF8String(str) {
1648  return decodeURIComponent(escape(str));
1649}
1650
1651function utf8StringToString(str) {
1652  return unescape(encodeURIComponent(str));
1653}
1654
1655function isBool(v) {
1656  return typeof v === "boolean";
1657}
1658
1659function isNum(v) {
1660  return typeof v === "number";
1661}
1662
1663function isString(v) {
1664  return typeof v === "string";
1665}
1666
1667function isArrayBuffer(v) {
1668  return typeof v === "object" && v !== null && v.byteLength !== undefined;
1669}
1670
1671function isArrayEqual(arr1, arr2) {
1672  if (arr1.length !== arr2.length) {
1673    return false;

1674  }
1675
1676  for (let i = 0, ii = arr1.length; i < ii; i++) {
1677    if (arr1[i] !== arr2[i]) {
1678      return false;
1679    }
1680  }
1681
1682  return true;
1683}
1684
1685function getModificationDate(date = new Date()) {
1686  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")];
1687  return buffer.join("");
1688}
1689
1690function createPromiseCapability() {
1691  const capability = Object.create(null);
1692  let isSettled = false;
1693  Object.defineProperty(capability, "settled", {
1694    get() {
1695      return isSettled;
1696    }
1697
1698  });
1699  capability.promise = new Promise(function (resolve, reject) {
1700    capability.resolve = function (data) {
1701      isSettled = true;
1702      resolve(data);
1703    };
1704
1705    capability.reject = function (reason) {
1706      isSettled = true;
1707      reject(reason);
1708    };
1709  });
1710  return capability;
1711}
1712
1713function createObjectURL(data, contentType = "", forceDataSchema = false) {
1714  if (URL.createObjectURL && typeof Blob !== "undefined" && !forceDataSchema) {
1715    return URL.createObjectURL(new Blob([data], {
1716      type: contentType
1717    }));
1718  }
1719
1720  const digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
1721  let buffer = `data:${contentType};base64,`;
1722
1723  for (let i = 0, ii = data.length; i < ii; i += 3) {
1724    const b1 = data[i] & 0xff;
1725    const b2 = data[i + 1] & 0xff;
1726    const b3 = data[i + 2] & 0xff;

1727    const d1 = b1 >> 2,
1728          d2 = (b1 & 3) << 4 | b2 >> 4;
1729    const d3 = i + 1 < ii ? (b2 & 0xf) << 2 | b3 >> 6 : 64;
1730    const d4 = i + 2 < ii ? b3 & 0x3f : 64;
1731    buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];
1732  }
1733
1734  return buffer;
1735}
1736
1737/***/ }),
1738/* 3 */
1739/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
1740
1741
1742
1743var _is_node = __w_pdfjs_require__(4);
1744
1745;
1746
1747/***/ }),
1748/* 4 */
1749/***/ ((__unused_webpack_module, exports) => {
1750
1751
1752
1753Object.defineProperty(exports, "__esModule", ({
1754  value: true
1755}));
1756exports.isNodeJS = void 0;
1757const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
1758exports.isNodeJS = isNodeJS;
1759
1760/***/ }),
1761/* 5 */
1762/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
1763
1764
1765
1766Object.defineProperty(exports, "__esModule", ({
1767  value: true
1768}));
1769exports.RefSetCache = exports.RefSet = exports.Ref = exports.Name = exports.EOF = exports.Dict = exports.Cmd = exports.CIRCULAR_REF = void 0;
1770exports.clearPrimitiveCaches = clearPrimitiveCaches;
1771exports.isCmd = isCmd;
1772exports.isDict = isDict;
1773exports.isName = isName;
1774exports.isRef = isRef;
1775exports.isRefsEqual = isRefsEqual;
1776exports.isStream = isStream;
1777
1778var _util = __w_pdfjs_require__(2);
1779
1780var _base_stream = __w_pdfjs_require__(6);
1781
1782const CIRCULAR_REF = Symbol("CIRCULAR_REF");
1783exports.CIRCULAR_REF = CIRCULAR_REF;
1784const EOF = Symbol("EOF");
1785exports.EOF = EOF;
1786
1787const Name = function NameClosure() {
1788  let nameCache = Object.create(null);
1789
1790  class Name {
1791    constructor(name) {
1792      this.name = name;
1793    }
1794
1795    static get(name) {
1796      const nameValue = nameCache[name];
1797      return nameValue ? nameValue : nameCache[name] = new Name(name);
1798    }
1799
1800    static _clearCache() {
1801      nameCache = Object.create(null);
1802    }
1803
1804  }
1805
1806  return Name;
1807}();
1808
1809exports.Name = Name;
1810
1811const Cmd = function CmdClosure() {
1812  let cmdCache = Object.create(null);
1813
1814  class Cmd {
1815    constructor(cmd) {
1816      this.cmd = cmd;
1817    }
1818
1819    static get(cmd) {
1820      const cmdValue = cmdCache[cmd];
1821      return cmdValue ? cmdValue : cmdCache[cmd] = new Cmd(cmd);
1822    }
1823
1824    static _clearCache() {
1825      cmdCache = Object.create(null);
1826    }
1827
1828  }
1829
1830  return Cmd;
1831}();
1832
1833exports.Cmd = Cmd;
1834
1835const nonSerializable = function nonSerializableClosure() {
1836  return nonSerializable;
1837};
1838
1839class Dict {
1840  constructor(xref = null) {
1841    this._map = Object.create(null);
1842    this.xref = xref;
1843    this.objId = null;
1844    this.suppressEncryption = false;
1845    this.__nonSerializable__ = nonSerializable;
1846  }
1847
1848  assignXref(newXref) {
1849    this.xref = newXref;
1850  }
1851
1852  get size() {
1853    return Object.keys(this._map).length;
1854  }
1855
1856  get(key1, key2, key3) {
1857    let value = this._map[key1];
1858
1859    if (value === undefined && key2 !== undefined) {
1860      value = this._map[key2];
1861
1862      if (value === undefined && key3 !== undefined) {
1863        value = this._map[key3];
1864      }
1865    }
1866
1867    if (value instanceof Ref && this.xref) {
1868      return this.xref.fetch(value, this.suppressEncryption);
1869    }
1870
1871    return value;
1872  }
1873
1874  async getAsync(key1, key2, key3) {
1875    let value = this._map[key1];
1876
1877    if (value === undefined && key2 !== undefined) {
1878      value = this._map[key2];
1879
1880      if (value === undefined && key3 !== undefined) {
1881        value = this._map[key3];
1882      }
1883    }
1884
1885    if (value instanceof Ref && this.xref) {
1886      return this.xref.fetchAsync(value, this.suppressEncryption);
1887    }
1888
1889    return value;
1890  }
1891
1892  getArray(key1, key2, key3) {
1893    let value = this._map[key1];
1894
1895    if (value === undefined && key2 !== undefined) {
1896      value = this._map[key2];
1897
1898      if (value === undefined && key3 !== undefined) {
1899        value = this._map[key3];
1900      }
1901    }
1902
1903    if (value instanceof Ref && this.xref) {
1904      value = this.xref.fetch(value, this.suppressEncryption);
1905    }
1906
1907    if (Array.isArray(value)) {
1908      value = value.slice();
1909
1910      for (let i = 0, ii = value.length; i < ii; i++) {
1911        if (value[i] instanceof Ref && this.xref) {
1912          value[i] = this.xref.fetch(value[i], this.suppressEncryption);
1913        }
1914      }
1915    }
1916
1917    return value;
1918  }
1919
1920  getRaw(key) {
1921    return this._map[key];
1922  }
1923
1924  getKeys() {
1925    return Object.keys(this._map);
1926  }
1927
1928  getRawValues() {
1929    return Object.values(this._map);
1930  }
1931
1932  set(key, value) {
1933    this._map[key] = value;
1934  }
1935
1936  has(key) {
1937    return this._map[key] !== undefined;
1938  }
1939
1940  forEach(callback) {
1941    for (const key in this._map) {
1942      callback(key, this.get(key));
1943    }
1944  }
1945
1946  static get empty() {
1947    const emptyDict = new Dict(null);
1948
1949    emptyDict.set = (key, value) => {
1950      (0, _util.unreachable)("Should not call `set` on the empty dictionary.");
1951    };
1952
1953    return (0, _util.shadow)(this, "empty", emptyDict);
1954  }
1955
1956  static merge({
1957    xref,
1958    dictArray,
1959    mergeSubDicts = false
1960  }) {
1961    const mergedDict = new Dict(xref),
1962          properties = new Map();
1963
1964    for (const dict of dictArray) {
1965      if (!(dict instanceof Dict)) {
1966        continue;
1967      }
1968
1969      for (const [key, value] of Object.entries(dict._map)) {
1970        let property = properties.get(key);
1971
1972        if (property === undefined) {
1973          property = [];
1974          properties.set(key, property);
1975        } else if (!mergeSubDicts || !(value instanceof Dict)) {
1976          continue;
1977        }
1978
1979        property.push(value);
1980      }
1981    }
1982
1983    for (const [name, values] of properties) {
1984      if (values.length === 1 || !(values[0] instanceof Dict)) {
1985        mergedDict._map[name] = values[0];
1986        continue;
1987      }
1988
1989      const subDict = new Dict(xref);
1990
1991      for (const dict of values) {
1992        for (const [key, value] of Object.entries(dict._map)) {
1993          if (subDict._map[key] === undefined) {
1994            subDict._map[key] = value;
1995          }
1996        }
1997      }
1998
1999      if (subDict.size > 0) {
2000        mergedDict._map[name] = subDict;
2001      }
2002    }
2003
2004    properties.clear();
2005    return mergedDict.size > 0 ? mergedDict : Dict.empty;
2006  }
2007
2008}
2009
2010exports.Dict = Dict;
2011
2012const Ref = function RefClosure() {
2013  let refCache = Object.create(null);
2014
2015  class Ref {
2016    constructor(num, gen) {
2017      this.num = num;
2018      this.gen = gen;
2019    }
2020
2021    toString() {
2022      if (this.gen === 0) {
2023        return `${this.num}R`;
2024      }
2025
2026      return `${this.num}R${this.gen}`;
2027    }
2028
2029    static get(num, gen) {

2030      const key = gen === 0 ? `${num}R` : `${num}R${gen}`;
2031      const refValue = refCache[key];
2032      return refValue ? refValue : refCache[key] = new Ref(num, gen);
2033    }
2034
2035    static _clearCache() {
2036      refCache = Object.create(null);
2037    }
2038
2039  }
2040
2041  return Ref;
2042}();
2043
2044exports.Ref = Ref;
2045
2046class RefSet {
2047  constructor(parent = null) {
2048    this._set = new Set(parent && parent._set);
2049  }
2050
2051  has(ref) {
2052    return this._set.has(ref.toString());
2053  }
2054
2055  put(ref) {
2056    this._set.add(ref.toString());
2057  }
2058
2059  remove(ref) {
2060    this._set.delete(ref.toString());
2061  }
2062
2063  forEach(callback) {
2064    for (const ref of this._set.values()) {
2065      callback(ref);
2066    }
2067  }
2068
2069  clear() {
2070    this._set.clear();
2071  }
2072
2073}
2074
2075exports.RefSet = RefSet;
2076
2077class RefSetCache {
2078  constructor() {
2079    this._map = new Map();
2080  }
2081
2082  get size() {
2083    return this._map.size;
2084  }
2085
2086  get(ref) {
2087    return this._map.get(ref.toString());
2088  }
2089
2090  has(ref) {
2091    return this._map.has(ref.toString());
2092  }
2093
2094  put(ref, obj) {
2095    this._map.set(ref.toString(), obj);
2096  }
2097
2098  putAlias(ref, aliasRef) {
2099    this._map.set(ref.toString(), this.get(aliasRef));
2100  }
2101
2102  forEach(callback) {
2103    for (const value of this._map.values()) {
2104      callback(value);
2105    }
2106  }
2107
2108  clear() {
2109    this._map.clear();
2110  }
2111
2112}
2113
2114exports.RefSetCache = RefSetCache;
2115
2116function isName(v, name) {
2117  return v instanceof Name && (name === undefined || v.name === name);
2118}
2119
2120function isCmd(v, cmd) {
2121  return v instanceof Cmd && (cmd === undefined || v.cmd === cmd);
2122}
2123
2124function isDict(v, type) {
2125  return v instanceof Dict && (type === undefined || isName(v.get("Type"), type));
2126}
2127
2128function isRef(v) {
2129  return v instanceof Ref;
2130}
2131
2132function isRefsEqual(v1, v2) {
2133  return v1.num === v2.num && v1.gen === v2.gen;
2134}
2135
2136function isStream(v) {
2137  return v instanceof _base_stream.BaseStream;
2138}
2139
2140function clearPrimitiveCaches() {
2141  Cmd._clearCache();
2142
2143  Name._clearCache();
2144
2145  Ref._clearCache();
2146}
2147
2148/***/ }),
2149/* 6 */
2150/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
2151
2152
2153
2154Object.defineProperty(exports, "__esModule", ({
2155  value: true
2156}));
2157exports.BaseStream = void 0;
2158
2159var _util = __w_pdfjs_require__(2);
2160
2161class BaseStream {
2162  constructor() {
2163    if (this.constructor === BaseStream) {
2164      (0, _util.unreachable)("Cannot initialize BaseStream.");
2165    }
2166  }
2167
2168  get length() {
2169    (0, _util.unreachable)("Abstract getter `length` accessed");
2170  }
2171
2172  get isEmpty() {
2173    (0, _util.unreachable)("Abstract getter `isEmpty` accessed");
2174  }
2175
2176  get isDataLoaded() {
2177    return (0, _util.shadow)(this, "isDataLoaded", true);
2178  }
2179
2180  getByte() {
2181    (0, _util.unreachable)("Abstract method `getByte` called");
2182  }
2183
2184  getBytes(length, forceClamped = false) {
2185    (0, _util.unreachable)("Abstract method `getBytes` called");
2186  }
2187
2188  peekByte() {
2189    const peekedByte = this.getByte();
2190
2191    if (peekedByte !== -1) {
2192      this.pos--;
2193    }
2194
2195    return peekedByte;
2196  }
2197
2198  peekBytes(length, forceClamped = false) {
2199    const bytes = this.getBytes(length, forceClamped);
2200    this.pos -= bytes.length;
2201    return bytes;
2202  }
2203
2204  getUint16() {
2205    const b0 = this.getByte();
2206    const b1 = this.getByte();
2207
2208    if (b0 === -1 || b1 === -1) {
2209      return -1;
2210    }
2211
2212    return (b0 << 8) + b1;
2213  }
2214
2215  getInt32() {
2216    const b0 = this.getByte();
2217    const b1 = this.getByte();
2218    const b2 = this.getByte();
2219    const b3 = this.getByte();
2220    return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
2221  }
2222
2223  getByteRange(begin, end) {
2224    (0, _util.unreachable)("Abstract method `getByteRange` called");
2225  }
2226
2227  getString(length) {
2228    return (0, _util.bytesToString)(this.getBytes(length, false));
2229  }
2230
2231  skip(n) {
2232    this.pos += n || 1;
2233  }
2234
2235  reset() {
2236    (0, _util.unreachable)("Abstract method `reset` called");
2237  }
2238
2239  moveStart() {
2240    (0, _util.unreachable)("Abstract method `moveStart` called");
2241  }
2242
2243  makeSubStream(start, length, dict = null) {
2244    (0, _util.unreachable)("Abstract method `makeSubStream` called");
2245  }
2246
2247  getBaseStreams() {
2248    return null;
2249  }
2250
2251}
2252
2253exports.BaseStream = BaseStream;
2254
2255/***/ }),
2256/* 7 */
2257/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
2258
2259
2260
2261Object.defineProperty(exports, "__esModule", ({
2262  value: true
2263}));
2264exports.NetworkPdfManager = exports.LocalPdfManager = void 0;
2265
2266var _util = __w_pdfjs_require__(2);
2267
2268var _chunked_stream = __w_pdfjs_require__(8);
2269
2270var _core_utils = __w_pdfjs_require__(9);
2271
2272var _document = __w_pdfjs_require__(11);
2273
2274var _stream = __w_pdfjs_require__(10);
2275
2276function parseDocBaseUrl(url) {
2277  if (url) {
2278    const absoluteUrl = (0, _util.createValidAbsoluteUrl)(url);
2279
2280    if (absoluteUrl) {
2281      return absoluteUrl.href;
2282    }
2283
2284    (0, _util.warn)(`Invalid absolute docBaseUrl: "${url}".`);
2285  }
2286
2287  return null;
2288}
2289
2290class BasePdfManager {
2291  constructor() {
2292    if (this.constructor === BasePdfManager) {
2293      (0, _util.unreachable)("Cannot initialize BasePdfManager.");
2294    }
2295  }
2296
2297  get docId() {
2298    return this._docId;
2299  }
2300
2301  get password() {
2302    return this._password;
2303  }
2304
2305  get docBaseUrl() {
2306    return this._docBaseUrl;
2307  }
2308
2309  onLoadedStream() {
2310    (0, _util.unreachable)("Abstract method `onLoadedStream` called");
2311  }
2312
2313  ensureDoc(prop, args) {
2314    return this.ensure(this.pdfDocument, prop, args);
2315  }
2316
2317  ensureXRef(prop, args) {
2318    return this.ensure(this.pdfDocument.xref, prop, args);
2319  }
2320
2321  ensureCatalog(prop, args) {
2322    return this.ensure(this.pdfDocument.catalog, prop, args);
2323  }
2324
2325  getPage(pageIndex) {
2326    return this.pdfDocument.getPage(pageIndex);
2327  }
2328
2329  fontFallback(id, handler) {
2330    return this.pdfDocument.fontFallback(id, handler);
2331  }
2332
2333  loadXfaFonts(handler, task) {
2334    return this.pdfDocument.loadXfaFonts(handler, task);
2335  }
2336
2337  loadXfaImages() {
2338    return this.pdfDocument.loadXfaImages();
2339  }
2340
2341  serializeXfaData(annotationStorage) {
2342    return this.pdfDocument.serializeXfaData(annotationStorage);
2343  }
2344
2345  cleanup(manuallyTriggered = false) {
2346    return this.pdfDocument.cleanup(manuallyTriggered);
2347  }
2348
2349  async ensure(obj, prop, args) {
2350    (0, _util.unreachable)("Abstract method `ensure` called");
2351  }
2352
2353  requestRange(begin, end) {
2354    (0, _util.unreachable)("Abstract method `requestRange` called");
2355  }
2356
2357  requestLoadedStream() {
2358    (0, _util.unreachable)("Abstract method `requestLoadedStream` called");
2359  }
2360
2361  sendProgressiveData(chunk) {
2362    (0, _util.unreachable)("Abstract method `sendProgressiveData` called");
2363  }
2364
2365  updatePassword(password) {
2366    this._password = password;
2367  }
2368
2369  terminate(reason) {
2370    (0, _util.unreachable)("Abstract method `terminate` called");
2371  }
2372
2373}
2374
2375class LocalPdfManager extends BasePdfManager {
2376  constructor(docId, data, password, msgHandler, evaluatorOptions, enableXfa, docBaseUrl) {
2377    super();
2378    this._docId = docId;
2379    this._password = password;
2380    this._docBaseUrl = parseDocBaseUrl(docBaseUrl);
2381    this.msgHandler = msgHandler;
2382    this.evaluatorOptions = evaluatorOptions;
2383    this.enableXfa = enableXfa;
2384    const stream = new _stream.Stream(data);
2385    this.pdfDocument = new _document.PDFDocument(this, stream);
2386    this._loadedStreamPromise = Promise.resolve(stream);
2387  }
2388
2389  async ensure(obj, prop, args) {
2390    const value = obj[prop];
2391
2392    if (typeof value === "function") {

2393      return value.apply(obj, args);
2394    }
2395
2396    return value;
2397  }
2398
2399  requestRange(begin, end) {
2400    return Promise.resolve();
2401  }
2402
2403  requestLoadedStream() {}
2404
2405  onLoadedStream() {
2406    return this._loadedStreamPromise;
2407  }
2408
2409  terminate(reason) {}
2410
2411}
2412
2413exports.LocalPdfManager = LocalPdfManager;
2414
2415class NetworkPdfManager extends BasePdfManager {
2416  constructor(docId, pdfNetworkStream, args, evaluatorOptions, enableXfa, docBaseUrl) {
2417    super();
2418    this._docId = docId;
2419    this._password = args.password;
2420    this._docBaseUrl = parseDocBaseUrl(docBaseUrl);
2421    this.msgHandler = args.msgHandler;
2422    this.evaluatorOptions = evaluatorOptions;
2423    this.enableXfa = enableXfa;
2424    this.streamManager = new _chunked_stream.ChunkedStreamManager(pdfNetworkStream, {
2425      msgHandler: args.msgHandler,
2426      length: args.length,
2427      disableAutoFetch: args.disableAutoFetch,
2428      rangeChunkSize: args.rangeChunkSize
2429    });
2430    this.pdfDocument = new _document.PDFDocument(this, this.streamManager.getStream());
2431  }
2432
2433  async ensure(obj, prop, args) {
2434    try {
2435      const value = obj[prop];
2436
2437      if (typeof value === "function") {
2438        return value.apply(obj, args);
2439      }
2440
2441      return value;
2442    } catch (ex) {
2443      if (!(ex instanceof _core_utils.MissingDataException)) {
2444        throw ex;
2445      }
2446
2447      await this.requestRange(ex.begin, ex.end);
2448      return this.ensure(obj, prop, args);
2449    }
2450  }
2451
2452  requestRange(begin, end) {
2453    return this.streamManager.requestRange(begin, end);
2454  }
2455
2456  requestLoadedStream() {
2457    this.streamManager.requestAllChunks();
2458  }
2459
2460  sendProgressiveData(chunk) {
2461    this.streamManager.onReceiveData({
2462      chunk
2463    });
2464  }
2465
2466  onLoadedStream() {
2467    return this.streamManager.onLoadedStream();
2468  }
2469
2470  terminate(reason) {
2471    this.streamManager.abort(reason);
2472  }
2473
2474}
2475
2476exports.NetworkPdfManager = NetworkPdfManager;
2477
2478/***/ }),
2479/* 8 */
2480/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
2481
2482
2483
2484Object.defineProperty(exports, "__esModule", ({
2485  value: true
2486}));
2487exports.ChunkedStreamManager = exports.ChunkedStream = void 0;
2488
2489var _util = __w_pdfjs_require__(2);
2490
2491var _core_utils = __w_pdfjs_require__(9);
2492
2493var _stream = __w_pdfjs_require__(10);
2494
2495class ChunkedStream extends _stream.Stream {
2496  constructor(length, chunkSize, manager) {
2497    super(new Uint8Array(length), 0, length, null);
2498    this.chunkSize = chunkSize;
2499    this._loadedChunks = new Set();
2500    this.numChunks = Math.ceil(length / chunkSize);
2501    this.manager = manager;
2502    this.progressiveDataLength = 0;
2503    this.lastSuccessfulEnsureByteChunk = -1;
2504  }
2505
2506  getMissingChunks() {
2507    const chunks = [];
2508
2509    for (let chunk = 0, n = this.numChunks; chunk < n; ++chunk) {
2510      if (!this._loadedChunks.has(chunk)) {
2511        chunks.push(chunk);
2512      }
2513    }
2514
2515    return chunks;
2516  }
2517
2518  get numChunksLoaded() {
2519    return this._loadedChunks.size;
2520  }
2521
2522  get isDataLoaded() {
2523    return this.numChunksLoaded === this.numChunks;
2524  }
2525
2526  onReceiveData(begin, chunk) {
2527    const chunkSize = this.chunkSize;
2528
2529    if (begin % chunkSize !== 0) {
2530      throw new Error(`Bad begin offset: ${begin}`);
2531    }
2532
2533    const end = begin + chunk.byteLength;
2534
2535    if (end % chunkSize !== 0 && end !== this.bytes.length) {
2536      throw new Error(`Bad end offset: ${end}`);
2537    }
2538
2539    this.bytes.set(new Uint8Array(chunk), begin);
2540    const beginChunk = Math.floor(begin / chunkSize);
2541    const endChunk = Math.floor((end - 1) / chunkSize) + 1;
2542
2543    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
2544      this._loadedChunks.add(curChunk);
2545    }
2546  }
2547
2548  onReceiveProgressiveData(data) {
2549    let position = this.progressiveDataLength;
2550    const beginChunk = Math.floor(position / this.chunkSize);
2551    this.bytes.set(new Uint8Array(data), position);
2552    position += data.byteLength;
2553    this.progressiveDataLength = position;
2554    const endChunk = position >= this.end ? this.numChunks : Math.floor(position / this.chunkSize);
2555
2556    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
2557      this._loadedChunks.add(curChunk);
2558    }
2559  }
2560
2561  ensureByte(pos) {
2562    if (pos < this.progressiveDataLength) {
2563      return;
2564    }
2565
2566    const chunk = Math.floor(pos / this.chunkSize);
2567
2568    if (chunk > this.numChunks) {
2569      return;
2570    }
2571
2572    if (chunk === this.lastSuccessfulEnsureByteChunk) {
2573      return;
2574    }
2575
2576    if (!this._loadedChunks.has(chunk)) {
2577      throw new _core_utils.MissingDataException(pos, pos + 1);
2578    }
2579
2580    this.lastSuccessfulEnsureByteChunk = chunk;
2581  }
2582
2583  ensureRange(begin, end) {
2584    if (begin >= end) {
2585      return;
2586    }
2587
2588    if (end <= this.progressiveDataLength) {
2589      return;
2590    }
2591
2592    const beginChunk = Math.floor(begin / this.chunkSize);
2593
2594    if (beginChunk > this.numChunks) {
2595      return;
2596    }
2597
2598    const endChunk = Math.min(Math.floor((end - 1) / this.chunkSize) + 1, this.numChunks);
2599
2600    for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
2601      if (!this._loadedChunks.has(chunk)) {
2602        throw new _core_utils.MissingDataException(begin, end);
2603      }
2604    }
2605  }
2606
2607  nextEmptyChunk(beginChunk) {
2608    const numChunks = this.numChunks;
2609
2610    for (let i = 0; i < numChunks; ++i) {
2611      const chunk = (beginChunk + i) % numChunks;
2612
2613      if (!this._loadedChunks.has(chunk)) {
2614        return chunk;
2615      }
2616    }
2617
2618    return null;
2619  }
2620
2621  hasChunk(chunk) {
2622    return this._loadedChunks.has(chunk);
2623  }
2624
2625  getByte() {
2626    const pos = this.pos;
2627
2628    if (pos >= this.end) {
2629      return -1;
2630    }
2631
2632    if (pos >= this.progressiveDataLength) {
2633      this.ensureByte(pos);
2634    }
2635
2636    return this.bytes[this.pos++];
2637  }
2638
2639  getBytes(length, forceClamped = false) {
2640    const bytes = this.bytes;
2641    const pos = this.pos;
2642    const strEnd = this.end;
2643
2644    if (!length) {
2645      if (strEnd > this.progressiveDataLength) {
2646        this.ensureRange(pos, strEnd);
2647      }
2648
2649      const subarray = bytes.subarray(pos, strEnd);
2650      return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
2651    }
2652
2653    let end = pos + length;
2654
2655    if (end > strEnd) {
2656      end = strEnd;
2657    }
2658
2659    if (end > this.progressiveDataLength) {
2660      this.ensureRange(pos, end);
2661    }
2662
2663    this.pos = end;
2664    const subarray = bytes.subarray(pos, end);
2665    return forceClamped ? new Uint8ClampedArray(subarray) : subarray;
2666  }
2667
2668  getByteRange(begin, end) {
2669    if (begin < 0) {
2670      begin = 0;
2671    }
2672
2673    if (end > this.end) {
2674      end = this.end;
2675    }
2676
2677    if (end > this.progressiveDataLength) {
2678      this.ensureRange(begin, end);
2679    }
2680
2681    return this.bytes.subarray(begin, end);
2682  }
2683
2684  makeSubStream(start, length, dict = null) {
2685    if (length) {
2686      if (start + length > this.progressiveDataLength) {
2687        this.ensureRange(start, start + length);
2688      }
2689    } else {
2690      if (start >= this.progressiveDataLength) {
2691        this.ensureByte(start);
2692      }
2693    }
2694
2695    function ChunkedStreamSubstream() {}
2696
2697    ChunkedStreamSubstream.prototype = Object.create(this);
2698
2699    ChunkedStreamSubstream.prototype.getMissingChunks = function () {
2700      const chunkSize = this.chunkSize;
2701      const beginChunk = Math.floor(this.start / chunkSize);