https://cruonline.crugroup.com/assets/pdf.worker-6b078827.js

1/**
2 * @licstart The following is the entire license notice for the
3 * JavaScript code in this page
4 *
5 * Copyright 2022 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})(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;
46
47var _util = __w_pdfjs_require__(2);
48
49var _primitives = __w_pdfjs_require__(5);
50
51var _core_utils = __w_pdfjs_require__(6);
52
53var _pdf_manager = __w_pdfjs_require__(8);
54
55var _cleanup_helper = __w_pdfjs_require__(71);
56
57var _writer = __w_pdfjs_require__(65);
58
59var _is_node = __w_pdfjs_require__(4);
60
61var _message_handler = __w_pdfjs_require__(102);
62
63var _worker_stream = __w_pdfjs_require__(103);
64
65class WorkerTask {
66  constructor(name) {
67    this.name = name;
68    this.terminated = false;
69    this._capability = (0, _util.createPromiseCapability)();
70  }
71
72  get finished() {
73    return this._capability.promise;
74  }
75
76  finish() {
77    this._capability.resolve();
78  }
79
80  terminate() {
81    this.terminated = true;
82  }
83
84  ensureNotTerminated() {
85    if (this.terminated) {
86      throw new Error("Worker task was terminated");
87    }
88  }
89
90}
91
92exports.WorkerTask = WorkerTask;
93
94class WorkerMessageHandler {
95  static setup(handler, port) {
96    let testMessageProcessed = false;
97    handler.on("test", function wphSetupTest(data) {
98      if (testMessageProcessed) {
99        return;
100      }
101
102      testMessageProcessed = true;
103      handler.send("test", data instanceof Uint8Array);
104    });
105    handler.on("configure", function wphConfigure(data) {
106      (0, _util.setVerbosityLevel)(data.verbosity);
107    });
108    handler.on("GetDocRequest", function wphSetupDoc(data) {
109      return WorkerMessageHandler.createDocumentHandler(data, port);
110    });
111  }
112
113  static createDocumentHandler(docParams, port) {
114    let pdfManager;
115    let terminated = false;
116    let cancelXHRs = null;
117    const WorkerTasks = [];
118    const verbosity = (0, _util.getVerbosityLevel)();
119    const apiVersion = docParams.apiVersion;
120    const workerVersion = '2.16.105';
121
122    if (apiVersion !== workerVersion) {
123      throw new Error(`The API version "${apiVersion}" does not match ` + `the Worker version "${workerVersion}".`);
124    }
125
126    const enumerableProperties = [];
127
128    for (const property in []) {
129      enumerableProperties.push(property);
130    }
131
132    if (enumerableProperties.length) {
133      throw new Error("The `Array.prototype` contains unexpected enumerable properties: " + enumerableProperties.join(", ") + "; thus breaking e.g. `for...in` iteration of `Array`s.");
134    }
135
136    if (typeof ReadableStream === "undefined") {
137      const partialMsg = "The browser/environment lacks native support for critical " + "functionality used by the PDF.js library (e.g. `ReadableStream`); ";
138
139      if (_is_node.isNodeJS) {
140        throw new Error(partialMsg + "please use a `legacy`-build instead.");
141      }
142
143      throw new Error(partialMsg + "please update to a supported browser.");
144    }
145
146    const docId = docParams.docId;
147    const docBaseUrl = docParams.docBaseUrl;
148    const workerHandlerName = docParams.docId + "_worker";
149    let handler = new _message_handler.MessageHandler(workerHandlerName, docId, port);
150
151    function ensureNotTerminated() {
152      if (terminated) {
153        throw new Error("Worker was terminated");
154      }
155    }
156
157    function startWorkerTask(task) {
158      WorkerTasks.push(task);
159    }
160
161    function finishWorkerTask(task) {
162      task.finish();
163      const i = WorkerTasks.indexOf(task);
164      WorkerTasks.splice(i, 1);
165    }
166
167    async function loadDocument(recoveryMode) {
168      await pdfManager.ensureDoc("checkHeader");
169      await pdfManager.ensureDoc("parseStartXRef");
170      await pdfManager.ensureDoc("parse", [recoveryMode]);
171      await pdfManager.ensureDoc("checkFirstPage", [recoveryMode]);
172      await pdfManager.ensureDoc("checkLastPage", [recoveryMode]);
173      const isPureXfa = await pdfManager.ensureDoc("isPureXfa");
174
175      if (isPureXfa) {
176        const task = new WorkerTask("loadXfaFonts");
177        startWorkerTask(task);
178        await Promise.all([pdfManager.loadXfaFonts(handler, task).catch(reason => {}).then(() => finishWorkerTask(task)), pdfManager.loadXfaImages()]);
179      }
180
181      const [numPages, fingerprints] = await Promise.all([pdfManager.ensureDoc("numPages"), pdfManager.ensureDoc("fingerprints")]);
182      const htmlForXfa = isPureXfa ? await pdfManager.ensureDoc("htmlForXfa") : null;
183      return {
184        numPages,
185        fingerprints,
186        htmlForXfa
187      };
188    }
189
190    function getPdfManager(data, evaluatorOptions, enableXfa) {
191      const pdfManagerCapability = (0, _util.createPromiseCapability)();
192      let newPdfManager;
193      const source = data.source;
194
195      if (source.data) {
196        try {
197          newPdfManager = new _pdf_manager.LocalPdfManager(docId, source.data, source.password, handler, evaluatorOptions, enableXfa, docBaseUrl);
198          pdfManagerCapability.resolve(newPdfManager);
199        } catch (ex) {
200          pdfManagerCapability.reject(ex);
201        }
202
203        return pdfManagerCapability.promise;
204      }
205
206      let pdfStream,
207          cachedChunks = [];
208
209      try {
210        pdfStream = new _worker_stream.PDFWorkerStream(handler);
211      } catch (ex) {
212        pdfManagerCapability.reject(ex);
213        return pdfManagerCapability.promise;
214      }
215
216      const fullRequest = pdfStream.getFullReader();
217      fullRequest.headersReady.then(function () {
218        if (!fullRequest.isRangeSupported) {
219          return;
220        }
221
222        const disableAutoFetch = source.disableAutoFetch || fullRequest.isStreamingSupported;
223        newPdfManager = new _pdf_manager.NetworkPdfManager(docId, pdfStream, {
224          msgHandler: handler,
225          password: source.password,
226          length: fullRequest.contentLength,
227          disableAutoFetch,
228          rangeChunkSize: source.rangeChunkSize
229        }, evaluatorOptions, enableXfa, docBaseUrl);
230
231        for (const chunk of cachedChunks) {
232          newPdfManager.sendProgressiveData(chunk);
233        }
234
235        cachedChunks = [];
236        pdfManagerCapability.resolve(newPdfManager);
237        cancelXHRs = null;
238      }).catch(function (reason) {
239        pdfManagerCapability.reject(reason);
240        cancelXHRs = null;
241      });
242      let loaded = 0;
243
244      const flushChunks = function () {
245        const pdfFile = (0, _util.arraysToBytes)(cachedChunks);
246
247        if (source.length && pdfFile.length !== source.length) {
248          (0, _util.warn)("reported HTTP length is different from actual");
249        }
250
251        try {
252          newPdfManager = new _pdf_manager.LocalPdfManager(docId, pdfFile, source.password, handler, evaluatorOptions, enableXfa, docBaseUrl);
253          pdfManagerCapability.resolve(newPdfManager);
254        } catch (ex) {
255          pdfManagerCapability.reject(ex);
256        }
257
258        cachedChunks = [];
259      };
260
261      const readPromise = new Promise(function (resolve, reject) {
262        const readChunk = function ({
263          value,
264          done
265        }) {
266          try {
267            ensureNotTerminated();
268
269            if (done) {
270              if (!newPdfManager) {
271                flushChunks();
272              }
273
274              cancelXHRs = null;
275              return;
276            }
277
278            loaded += (0, _util.arrayByteLength)(value);
279
280            if (!fullRequest.isStreamingSupported) {
281              handler.send("DocProgress", {
282                loaded,
283                total: Math.max(loaded, fullRequest.contentLength || 0)
284              });
285            }
286
287            if (newPdfManager) {
288              newPdfManager.sendProgressiveData(value);
289            } else {
290              cachedChunks.push(value);
291            }
292
293            fullRequest.read().then(readChunk, reject);
294          } catch (e) {
295            reject(e);
296          }
297        };
298
299        fullRequest.read().then(readChunk, reject);
300      });
301      readPromise.catch(function (e) {
302        pdfManagerCapability.reject(e);
303        cancelXHRs = null;
304      });
305
306      cancelXHRs = function (reason) {
307        pdfStream.cancelAllRequests(reason);
308      };
309
310      return pdfManagerCapability.promise;
311    }
312
313    function setupDoc(data) {
314      function onSuccess(doc) {
315        ensureNotTerminated();
316        handler.send("GetDoc", {
317          pdfInfo: doc
318        });
319      }
320
321      function onFailure(ex) {
322        ensureNotTerminated();
323
324        if (ex instanceof _util.PasswordException) {
325          const task = new WorkerTask(`PasswordException: response ${ex.code}`);
326          startWorkerTask(task);
327          handler.sendWithPromise("PasswordRequest", ex).then(function ({
328            password
329          }) {
330            finishWorkerTask(task);
331            pdfManager.updatePassword(password);
332            pdfManagerReady();
333          }).catch(function () {
334            finishWorkerTask(task);
335            handler.send("DocException", ex);
336          });
337        } else if (ex instanceof _util.InvalidPDFException || ex instanceof _util.MissingPDFException || ex instanceof _util.UnexpectedResponseException || ex instanceof _util.UnknownErrorException) {
338          handler.send("DocException", ex);
339        } else {
340          handler.send("DocException", new _util.UnknownErrorException(ex.message, ex.toString()));
341        }
342      }
343
344      function pdfManagerReady() {
345        ensureNotTerminated();
346        loadDocument(false).then(onSuccess, function (reason) {
347          ensureNotTerminated();
348
349          if (!(reason instanceof _core_utils.XRefParseException)) {
350            onFailure(reason);
351            return;
352          }
353
354          pdfManager.requestLoadedStream();
355          pdfManager.onLoadedStream().then(function () {
356            ensureNotTerminated();

542
543        if (Array.isArray(xfa)) {
544          for (let i = 0, ii = xfa.length; i < ii; i += 2) {
545            if (xfa[i] === "datasets") {
546              xfaDatasetsRef = xfa[i + 1];
547              acroFormRef = null;
548              hasXfaDatasetsEntry = true;
549            }
550          }
551
552          if (xfaDatasetsRef === null) {
553            xfaDatasetsRef = xref.getNewRef();
554          }
555        } else if (xfa) {
556          acroFormRef = null;
557          (0, _util.warn)("Unsupported XFA type.");
558        }
559
560        let newXrefInfo = Object.create(null);
561
562        if (xref.trailer) {
563          const infoObj = Object.create(null);
564          const xrefInfo = xref.trailer.get("Info") || null;
565
566          if (xrefInfo instanceof _primitives.Dict) {
567            xrefInfo.forEach((key, value) => {
568              if (typeof value === "string") {
569                infoObj[key] = (0, _util.stringToPDFString)(value);
570              }
571            });
572          }
573
574          newXrefInfo = {
575            rootRef: xref.trailer.getRaw("Root") || null,
576            encryptRef: xref.trailer.getRaw("Encrypt") || null,
577            newRef: xref.getNewRef(),
578            infoRef: xref.trailer.getRaw("Info") || null,
579            info: infoObj,
580            fileIds: xref.trailer.get("ID") || null,
581            startXRef,
582            filename
583          };
584        }
585
586        xref.resetNewRef();
587        return (0, _writer.incrementalUpdate)({
588          originalData: stream.bytes,
589          xrefInfo: newXrefInfo,
590          newRefs,
591          xref,
592          hasXfa: !!xfa,
593          xfaDatasetsRef,
594          hasXfaDatasetsEntry,
595          acroFormRef,
596          acroForm,
597          xfaData
598        });
599      });
600    });
601    handler.on("GetOperatorList", function wphSetupRenderPage(data, sink) {
602      const pageIndex = data.pageIndex;
603      pdfManager.getPage(pageIndex).then(function (page) {
604        const task = new WorkerTask(`GetOperatorList: page ${pageIndex}`);
605        startWorkerTask(task);
606        const start = verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
607        page.getOperatorList({
608          handler,
609          sink,
610          task,
611          intent: data.intent,
612          cacheKey: data.cacheKey,
613          annotationStorage: data.annotationStorage
614        }).then(function (operatorListInfo) {
615          finishWorkerTask(task);
616
617          if (start) {
618            (0, _util.info)(`page=${pageIndex + 1} - getOperatorList: time=` + `${Date.now() - start}ms, len=${operatorListInfo.length}`);
619          }
620
621          sink.close();
622        }, function (reason) {
623          finishWorkerTask(task);
624
625          if (task.terminated) {
626            return;
627          }
628
629          handler.send("UnsupportedFeature", {
630            featureId: _util.UNSUPPORTED_FEATURES.errorOperatorList
631          });
632          sink.error(reason);
633        });
634      });
635    });
636    handler.on("GetTextContent", function wphExtractText(data, sink) {
637      const pageIndex = data.pageIndex;
638      pdfManager.getPage(pageIndex).then(function (page) {
639        const task = new WorkerTask("GetTextContent: page " + pageIndex);
640        startWorkerTask(task);
641        const start = verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
642        page.extractTextContent({
643          handler,
644          task,
645          sink,
646          includeMarkedContent: data.includeMarkedContent,
647          combineTextItems: data.combineTextItems
648        }).then(function () {
649          finishWorkerTask(task);
650
651          if (start) {
652            (0, _util.info)(`page=${pageIndex + 1} - getTextContent: time=` + `${Date.now() - start}ms`);
653          }
654
655          sink.close();
656        }, function (reason) {
657          finishWorkerTask(task);
658
659          if (task.terminated) {
660            return;
661          }
662
663          sink.error(reason);
664        });
665      });
666    });
667    handler.on("GetStructTree", function wphGetStructTree(data) {
668      return pdfManager.getPage(data.pageIndex).then(function (page) {
669        return pdfManager.ensure(page, "getStructTree");
670      });
671    });
672    handler.on("FontFallback", function (data) {
673      return pdfManager.fontFallback(data.id, handler);
674    });
675    handler.on("Cleanup", function wphCleanup(data) {
676      return pdfManager.cleanup(true);
677    });
678    handler.on("Terminate", function wphTerminate(data) {
679      terminated = true;
680      const waitOn = [];
681
682      if (pdfManager) {
683        pdfManager.terminate(new _util.AbortException("Worker was terminated."));
684        const cleanupPromise = pdfManager.cleanup();
685        waitOn.push(cleanupPromise);
686        pdfManager = null;
687      } else {
688        (0, _cleanup_helper.clearGlobalCaches)();
689      }
690
691      if (cancelXHRs) {
692        cancelXHRs(new _util.AbortException("Worker was terminated."));
693      }
694
695      for (const task of WorkerTasks) {
696        waitOn.push(task.finished);
697        task.terminate();
698      }
699
700      return Promise.all(waitOn).then(function () {
701        handler.destroy();
702        handler = null;
703      });
704    });
705    handler.on("Ready", function wphReady(data) {
706      setupDoc(docParams);
707      docParams = null;
708    });
709    return workerHandlerName;
710  }
711
712  static initializeFromPort(port) {
713    const handler = new _message_handler.MessageHandler("worker", "main", port);
714    WorkerMessageHandler.setup(handler, port);
715    handler.send("ready", null);
716  }
717
718}
719
720exports.WorkerMessageHandler = WorkerMessageHandler;
721
722function isMessagePort(maybePort) {
723  return typeof maybePort.postMessage === "function" && "onmessage" in maybePort;
724}
725
726if (typeof window === "undefined" && !_is_node.isNodeJS && typeof self !== "undefined" && isMessagePort(self)) {
727  WorkerMessageHandler.initializeFromPort(self);
728}
729
730/***/ }),
731/* 2 */
732/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
733
734
735
736Object.defineProperty(exports, "__esModule", ({
737  value: true
738}));
739exports.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.LINE_FACTOR = exports.LINE_DESCENT_FACTOR = exports.InvalidPDFException = exports.ImageKind = exports.IDENTITY_MATRIX = exports.FormatError = exports.FontType = exports.FeatureTest = 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.AnnotationEditorType = exports.AnnotationEditorPrefix = exports.AnnotationEditorParamsType = exports.AnnotationBorderStyleType = exports.AnnotationActionEventType = exports.AbortException = void 0;
740exports.arrayByteLength = arrayByteLength;
741exports.arraysToBytes = arraysToBytes;
742exports.assert = assert;
743exports.bytesToString = bytesToString;
744exports.createPromiseCapability = createPromiseCapability;
745exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
746exports.escapeString = escapeString;
747exports.getModificationDate = getModificationDate;
748exports.getVerbosityLevel = getVerbosityLevel;
749exports.info = info;
750exports.isArrayBuffer = isArrayBuffer;
751exports.isArrayEqual = isArrayEqual;
752exports.isAscii = isAscii;
753exports.objectFromMap = objectFromMap;
754exports.objectSize = objectSize;
755exports.setVerbosityLevel = setVerbosityLevel;
756exports.shadow = shadow;
757exports.string32 = string32;
758exports.stringToBytes = stringToBytes;
759exports.stringToPDFString = stringToPDFString;
760exports.stringToUTF16BEString = stringToUTF16BEString;
761exports.stringToUTF8String = stringToUTF8String;
762exports.unreachable = unreachable;
763exports.utf8StringToString = utf8StringToString;
764exports.warn = warn;
765
766__w_pdfjs_require__(3);
767
768const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
769exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
770const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
771exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
772const LINE_FACTOR = 1.35;
773exports.LINE_FACTOR = LINE_FACTOR;
774const LINE_DESCENT_FACTOR = 0.35;
775exports.LINE_DESCENT_FACTOR = LINE_DESCENT_FACTOR;
776const RenderingIntentFlag = {
777  ANY: 0x01,
778  DISPLAY: 0x02,
779  PRINT: 0x04,
780  ANNOTATIONS_FORMS: 0x10,
781  ANNOTATIONS_STORAGE: 0x20,
782  ANNOTATIONS_DISABLE: 0x40,
783  OPLIST: 0x100
784};
785exports.RenderingIntentFlag = RenderingIntentFlag;
786const AnnotationMode = {
787  DISABLE: 0,
788  ENABLE: 1,
789  ENABLE_FORMS: 2,
790  ENABLE_STORAGE: 3
791};
792exports.AnnotationMode = AnnotationMode;
793const AnnotationEditorPrefix = "pdfjs_internal_editor_";
794exports.AnnotationEditorPrefix = AnnotationEditorPrefix;
795const AnnotationEditorType = {
796  DISABLE: -1,
797  NONE: 0,
798  FREETEXT: 3,
799  INK: 15
800};
801exports.AnnotationEditorType = AnnotationEditorType;
802const AnnotationEditorParamsType = {
803  FREETEXT_SIZE: 1,
804  FREETEXT_COLOR: 2,
805  FREETEXT_OPACITY: 3,
806  INK_COLOR: 11,
807  INK_THICKNESS: 12,
808  INK_OPACITY: 13
809};
810exports.AnnotationEditorParamsType = AnnotationEditorParamsType;
811const PermissionFlag = {
812  PRINT: 0x04,
813  MODIFY_CONTENTS: 0x08,
814  COPY: 0x10,
815  MODIFY_ANNOTATIONS: 0x20,
816  FILL_INTERACTIVE_FORMS: 0x100,
817  COPY_FOR_ACCESSIBILITY: 0x200,
818  ASSEMBLE: 0x400,
819  PRINT_HIGH_QUALITY: 0x800
820};
821exports.PermissionFlag = PermissionFlag;
822const TextRenderingMode = {
823  FILL: 0,
824  STROKE: 1,
825  FILL_STROKE: 2,
826  INVISIBLE: 3,
827  FILL_ADD_TO_PATH: 4,
828  STROKE_ADD_TO_PATH: 5,
829  FILL_STROKE_ADD_TO_PATH: 6,
830  ADD_TO_PATH: 7,
831  FILL_STROKE_MASK: 3,
832  ADD_TO_PATH_FLAG: 4
833};
834exports.TextRenderingMode = TextRenderingMode;
835const ImageKind = {
836  GRAYSCALE_1BPP: 1,
837  RGB_24BPP: 2,
838  RGBA_32BPP: 3
839};
840exports.ImageKind = ImageKind;
841const AnnotationType = {
842  TEXT: 1,
843  LINK: 2,
844  FREETEXT: 3,
845  LINE: 4,
846  SQUARE: 5,
847  CIRCLE: 6,
848  POLYGON: 7,
849  POLYLINE: 8,
850  HIGHLIGHT: 9,
851  UNDERLINE: 10,
852  SQUIGGLY: 11,
853  STRIKEOUT: 12,
854  STAMP: 13,
855  CARET: 14,
856  INK: 15,
857  POPUP: 16,
858  FILEATTACHMENT: 17,
859  SOUND: 18,
860  MOVIE: 19,
861  WIDGET: 20,
862  SCREEN: 21,
863  PRINTERMARK: 22,
864  TRAPNET: 23,
865  WATERMARK: 24,
866  THREED: 25,
867  REDACT: 26
868};
869exports.AnnotationType = AnnotationType;
870const AnnotationStateModelType = {
871  MARKED: "Marked",
872  REVIEW: "Review"
873};
874exports.AnnotationStateModelType = AnnotationStateModelType;
875const AnnotationMarkedState = {
876  MARKED: "Marked",
877  UNMARKED: "Unmarked"
878};
879exports.AnnotationMarkedState = AnnotationMarkedState;
880const AnnotationReviewState = {
881  ACCEPTED: "Accepted",
882  REJECTED: "Rejected",
883  CANCELLED: "Cancelled",
884  COMPLETED: "Completed",
885  NONE: "None"
886};
887exports.AnnotationReviewState = AnnotationReviewState;
888const AnnotationReplyType = {
889  GROUP: "Group",
890  REPLY: "R"
891};
892exports.AnnotationReplyType = AnnotationReplyType;
893const AnnotationFlag = {
894  INVISIBLE: 0x01,
895  HIDDEN: 0x02,
896  PRINT: 0x04,
897  NOZOOM: 0x08,

1023  curveTo3: 17,
1024  closePath: 18,
1025  rectangle: 19,
1026  stroke: 20,
1027  closeStroke: 21,
1028  fill: 22,
1029  eoFill: 23,
1030  fillStroke: 24,
1031  eoFillStroke: 25,
1032  closeFillStroke: 26,
1033  closeEOFillStroke: 27,
1034  endPath: 28,
1035  clip: 29,
1036  eoClip: 30,
1037  beginText: 31,
1038  endText: 32,
1039  setCharSpacing: 33,
1040  setWordSpacing: 34,
1041  setHScale: 35,
1042  setLeading: 36,
1043  setFont: 37,
1044  setTextRenderingMode: 38,
1045  setTextRise: 39,
1046  moveText: 40,
1047  setLeadingMoveText: 41,
1048  setTextMatrix: 42,
1049  nextLine: 43,
1050  showText: 44,
1051  showSpacedText: 45,
1052  nextLineShowText: 46,
1053  nextLineSetSpacingShowText: 47,
1054  setCharWidth: 48,
1055  setCharWidthAndBounds: 49,
1056  setStrokeColorSpace: 50,
1057  setFillColorSpace: 51,
1058  setStrokeColor: 52,
1059  setStrokeColorN: 53,
1060  setFillColor: 54,
1061  setFillColorN: 55,
1062  setStrokeGray: 56,
1063  setFillGray: 57,
1064  setStrokeRGBColor: 58,
1065  setFillRGBColor: 59,
1066  setStrokeCMYKColor: 60,
1067  setFillCMYKColor: 61,
1068  shadingFill: 62,
1069  beginInlineImage: 63,
1070  beginImageData: 64,
1071  endInlineImage: 65,
1072  paintXObject: 66,
1073  markPoint: 67,
1074  markPointProps: 68,
1075  beginMarkedContent: 69,
1076  beginMarkedContentProps: 70,
1077  endMarkedContent: 71,
1078  beginCompat: 72,
1079  endCompat: 73,
1080  paintFormXObjectBegin: 74,
1081  paintFormXObjectEnd: 75,
1082  beginGroup: 76,
1083  endGroup: 77,
1084  beginAnnotations: 78,
1085  endAnnotations: 79,
1086  beginAnnotation: 80,
1087  endAnnotation: 81,
1088  paintJpegXObject: 82,
1089  paintImageMaskXObject: 83,
1090  paintImageMaskXObjectGroup: 84,
1091  paintImageXObject: 85,
1092  paintInlineImageXObject: 86,
1093  paintInlineImageXObjectGroup: 87,
1094  paintImageXObjectRepeat: 88,
1095  paintImageMaskXObjectRepeat: 89,
1096  paintSolidColorImageMask: 90,
1097  constructPath: 91
1098};
1099exports.OPS = OPS;
1100const UNSUPPORTED_FEATURES = {
1101  unknown: "unknown",
1102  forms: "forms",
1103  javaScript: "javaScript",
1104  signatures: "signatures",
1105  smask: "smask",
1106  shadingPattern: "shadingPattern",
1107  font: "font",
1108  errorTilingPattern: "errorTilingPattern",
1109  errorExtGState: "errorExtGState",
1110  errorXObject: "errorXObject",
1111  errorFontLoadType3: "errorFontLoadType3",
1112  errorFontState: "errorFontState",
1113  errorFontMissing: "errorFontMissing",
1114  errorFontTranslate: "errorFontTranslate",
1115  errorColorSpace: "errorColorSpace",
1116  errorOperatorList: "errorOperatorList",
1117  errorFontToUnicode: "errorFontToUnicode",
1118  errorFontLoadNative: "errorFontLoadNative",
1119  errorFontBuildPath: "errorFontBuildPath",
1120  errorFontGetPath: "errorFontGetPath",
1121  errorMarkedContent: "errorMarkedContent",
1122  errorContentSubStream: "errorContentSubStream"
1123};
1124exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
1125const PasswordResponses = {
1126  NEED_PASSWORD: 1,
1127  INCORRECT_PASSWORD: 2
1128};
1129exports.PasswordResponses = PasswordResponses;
1130let verbosity = VerbosityLevel.WARNINGS;
1131
1132function setVerbosityLevel(level) {
1133  if (Number.isInteger(level)) {
1134    verbosity = level;
1135  }
1136}
1137
1138function getVerbosityLevel() {
1139  return verbosity;
1140}
1141
1142function info(msg) {
1143  if (verbosity >= VerbosityLevel.INFOS) {
1144    console.log(`Info: ${msg}`);
1145  }
1146}
1147
1148function warn(msg) {
1149  if (verbosity >= VerbosityLevel.WARNINGS) {
1150    console.log(`Warning: ${msg}`);
1151  }
1152}
1153
1154function unreachable(msg) {
1155  throw new Error(msg);
1156}
1157
1158function assert(cond, msg) {
1159  if (!cond) {
1160    unreachable(msg);
1161  }
1162}
1163
1164function _isValidProtocol(url) {
1165  if (!url) {
1166    return false;
1167  }
1168
1169  switch (url.protocol) {
1170    case "http:":
1171    case "https:":
1172    case "ftp:":
1173    case "mailto:":
1174    case "tel:":
1175      return true;
1176
1177    default:
1178      return false;
1179  }
1180}
1181
1182function createValidAbsoluteUrl(url, baseUrl = null, options = null) {
1183  if (!url) {
1184    return null;
1185  }
1186
1187  try {
1188    if (options && typeof url === "string") {
1189      if (options.addDefaultProtocol && url.startsWith("www.")) {
1190        const dots = url.match(/\./g);
1191
1192        if (dots && dots.length >= 2) {
1193          url = `http://${url}`;
1194        }
1195      }
1196
1197      if (options.tryConvertEncoding) {
1198        try {
1199          url = stringToUTF8String(url);
1200        } catch (ex) {}
1201      }
1202    }
1203
1204    const absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);
1205
1206    if (_isValidProtocol(absoluteUrl)) {
1207      return absoluteUrl;
1208    }
1209  } catch (ex) {}
1210
1211  return null;
1212}
1213
1214function shadow(obj, prop, value) {
1215  Object.defineProperty(obj, prop, {
1216    value,
1217    enumerable: true,
1218    configurable: true,
1219    writable: false
1220  });
1221  return value;
1222}
1223
1224const BaseException = function BaseExceptionClosure() {
1225  function BaseException(message, name) {
1226    if (this.constructor === BaseException) {
1227      unreachable("Cannot initialize BaseException.");
1228    }
1229
1230    this.message = message;
1231    this.name = name;
1232  }
1233
1234  BaseException.prototype = new Error();
1235  BaseException.constructor = BaseException;
1236  return BaseException;
1237}();
1238
1239exports.BaseException = BaseException;
1240
1241class PasswordException extends BaseException {
1242  constructor(msg, code) {
1243    super(msg, "PasswordException");
1244    this.code = code;
1245  }
1246
1247}
1248
1249exports.PasswordException = PasswordException;
1250
1251class UnknownErrorException extends BaseException {
1252  constructor(msg, details) {
1253    super(msg, "UnknownErrorException");
1254    this.details = details;
1255  }
1256
1257}
1258
1259exports.UnknownErrorException = UnknownErrorException;
1260
1261class InvalidPDFException extends BaseException {
1262  constructor(msg) {
1263    super(msg, "InvalidPDFException");
1264  }
1265
1266}
1267
1268exports.InvalidPDFException = InvalidPDFException;
1269
1270class MissingPDFException extends BaseException {
1271  constructor(msg) {
1272    super(msg, "MissingPDFException");
1273  }
1274
1275}
1276
1277exports.MissingPDFException = MissingPDFException;
1278
1279class UnexpectedResponseException extends BaseException {
1280  constructor(msg, status) {
1281    super(msg, "UnexpectedResponseException");
1282    this.status = status;
1283  }
1284
1285}
1286
1287exports.UnexpectedResponseException = UnexpectedResponseException;
1288
1289class FormatError extends BaseException {
1290  constructor(msg) {
1291    super(msg, "FormatError");
1292  }
1293
1294}
1295
1296exports.FormatError = FormatError;
1297
1298class AbortException extends BaseException {
1299  constructor(msg) {
1300    super(msg, "AbortException");
1301  }
1302
1303}
1304
1305exports.AbortException = AbortException;
1306
1307function bytesToString(bytes) {
1308  if (typeof bytes !== "object" || bytes === null || bytes.length === undefined) {
1309    unreachable("Invalid argument for bytesToString");
1310  }
1311
1312  const length = bytes.length;
1313  const MAX_ARGUMENT_COUNT = 8192;
1314
1315  if (length < MAX_ARGUMENT_COUNT) {
1316    return String.fromCharCode.apply(null, bytes);
1317  }
1318
1319  const strBuf = [];
1320
1321  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
1322    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
1323    const chunk = bytes.subarray(i, chunkEnd);
1324    strBuf.push(String.fromCharCode.apply(null, chunk));
1325  }
1326
1327  return strBuf.join("");
1328}
1329
1330function stringToBytes(str) {
1331  if (typeof str !== "string") {
1332    unreachable("Invalid argument for stringToBytes");
1333  }
1334
1335  const length = str.length;
1336  const bytes = new Uint8Array(length);
1337
1338  for (let i = 0; i < length; ++i) {
1339    bytes[i] = str.charCodeAt(i) & 0xff;
1340  }
1341
1342  return bytes;
1343}
1344
1345function arrayByteLength(arr) {
1346  if (arr.length !== undefined) {
1347    return arr.length;
1348  }
1349
1350  if (arr.byteLength !== undefined) {
1351    return arr.byteLength;
1352  }
1353
1354  unreachable("Invalid argument for arrayByteLength");
1355}
1356
1357function arraysToBytes(arr) {
1358  const length = arr.length;
1359
1360  if (length === 1 && arr[0] instanceof Uint8Array) {
1361    return arr[0];
1362  }
1363
1364  let resultLength = 0;
1365
1366  for (let i = 0; i < length; i++) {
1367    resultLength += arrayByteLength(arr[i]);
1368  }
1369
1370  let pos = 0;
1371  const data = new Uint8Array(resultLength);
1372
1373  for (let i = 0; i < length; i++) {
1374    let item = arr[i];
1375
1376    if (!(item instanceof Uint8Array)) {
1377      if (typeof item === "string") {
1378        item = stringToBytes(item);
1379      } else {
1380        item = new Uint8Array(item);
1381      }
1382    }
1383
1384    const itemLength = item.byteLength;
1385    data.set(item, pos);
1386    pos += itemLength;
1387  }
1388
1389  return data;
1390}
1391
1392function string32(value) {
1393  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
1394}
1395
1396function objectSize(obj) {
1397  return Object.keys(obj).length;
1398}
1399
1400function objectFromMap(map) {
1401  const obj = Object.create(null);
1402
1403  for (const [key, value] of map) {
1404    obj[key] = value;
1405  }
1406
1407  return obj;
1408}
1409
1410function isLittleEndian() {
1411  const buffer8 = new Uint8Array(4);
1412  buffer8[0] = 1;
1413  const view32 = new Uint32Array(buffer8.buffer, 0, 1);
1414  return view32[0] === 1;
1415}
1416
1417function isEvalSupported() {
1418  try {
1419    new Function("");
1420    return true;
1421  } catch (e) {
1422    return false;
1423  }
1424}
1425
1426class FeatureTest {
1427  static get isLittleEndian() {
1428    return shadow(this, "isLittleEndian", isLittleEndian());
1429  }
1430
1431  static get isEvalSupported() {
1432    return shadow(this, "isEvalSupported", isEvalSupported());
1433  }
1434
1435  static get isOffscreenCanvasSupported() {
1436    return shadow(this, "isOffscreenCanvasSupported", typeof OffscreenCanvas !== "undefined");
1437  }
1438
1439}
1440
1441exports.FeatureTest = FeatureTest;
1442const hexNumbers = [...Array(256).keys()].map(n => n.toString(16).padStart(2, "0"));
1443
1444class Util {
1445  static makeHexColor(r, g, b) {
1446    return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`;
1447  }
1448
1449  static scaleMinMax(transform, minMax) {
1450    let temp;
1451
1452    if (transform[0]) {
1453      if (transform[0] < 0) {
1454        temp = minMax[0];
1455        minMax[0] = minMax[1];
1456        minMax[1] = temp;
1457      }
1458
1459      minMax[0] *= transform[0];
1460      minMax[1] *= transform[0];
1461
1462      if (transform[3] < 0) {
1463        temp = minMax[2];
1464        minMax[2] = minMax[3];
1465        minMax[3] = temp;
1466      }
1467
1468      minMax[2] *= transform[3];
1469      minMax[3] *= transform[3];
1470    } else {
1471      temp = minMax[0];
1472      minMax[0] = minMax[2];
1473      minMax[2] = temp;
1474      temp = minMax[1];
1475      minMax[1] = minMax[3];
1476      minMax[3] = temp;
1477
1478      if (transform[1] < 0) {
1479        temp = minMax[2];
1480        minMax[2] = minMax[3];
1481        minMax[3] = temp;
1482      }
1483
1484      minMax[2] *= transform[1];
1485      minMax[3] *= transform[1];
1486
1487      if (transform[2] < 0) {
1488        temp = minMax[0];
1489        minMax[0] = minMax[1];
1490        minMax[1] = temp;
1491      }
1492
1493      minMax[0] *= transform[2];
1494      minMax[1] *= transform[2];
1495    }
1496
1497    minMax[0] += transform[4];
1498    minMax[1] += transform[4];
1499    minMax[2] += transform[5];
1500    minMax[3] += transform[5];
1501  }
1502
1503  static transform(m1, m2) {
1504    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]];
1505  }
1506
1507  static applyTransform(p, m) {
1508    const xt = p[0] * m[0] + p[1] * m[2] + m[4];
1509    const yt = p[0] * m[1] + p[1] * m[3] + m[5];
1510    return [xt, yt];
1511  }
1512
1513  static applyInverseTransform(p, m) {
1514    const d = m[0] * m[3] - m[1] * m[2];
1515    const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
1516    const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
1517    return [xt, yt];
1518  }
1519
1520  static getAxialAlignedBoundingBox(r, m) {
1521    const p1 = Util.applyTransform(r, m);
1522    const p2 = Util.applyTransform(r.slice(2, 4), m);
1523    const p3 = Util.applyTransform([r[0], r[3]], m);
1524    const p4 = Util.applyTransform([r[2], r[1]], m);
1525    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])];
1526  }
1527
1528  static inverseTransform(m) {
1529    const d = m[0] * m[3] - m[1] * m[2];
1530    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];
1531  }
1532
1533  static apply3dTransform(m, v) {
1534    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]];
1535  }
1536
1537  static singularValueDecompose2dScale(m) {
1538    const transpose = [m[0], m[2], m[1], m[3]];
1539    const a = m[0] * transpose[0] + m[1] * transpose[2];
1540    const b = m[0] * transpose[1] + m[1] * transpose[3];
1541    const c = m[2] * transpose[0] + m[3] * transpose[2];
1542    const d = m[2] * transpose[1] + m[3] * transpose[3];
1543    const first = (a + d) / 2;
1544    const second = Math.sqrt((a + d) ** 2 - 4 * (a * d - c * b)) / 2;
1545    const sx = first + second || 1;
1546    const sy = first - second || 1;
1547    return [Math.sqrt(sx), Math.sqrt(sy)];
1548  }
1549
1550  static normalizeRect(rect) {
1551    const r = rect.slice(0);
1552
1553    if (rect[0] > rect[2]) {
1554      r[0] = rect[2];
1555      r[2] = rect[0];
1556    }
1557
1558    if (rect[1] > rect[3]) {
1559      r[1] = rect[3];
1560      r[3] = rect[1];
1561    }
1562
1563    return r;
1564  }
1565
1566  static intersect(rect1, rect2) {
1567    const xLow = Math.max(Math.min(rect1[0], rect1[2]), Math.min(rect2[0], rect2[2]));
1568    const xHigh = Math.min(Math.max(rect1[0], rect1[2]), Math.max(rect2[0], rect2[2]));
1569
1570    if (xLow > xHigh) {
1571      return null;
1572    }
1573
1574    const yLow = Math.max(Math.min(rect1[1], rect1[3]), Math.min(rect2[1], rect2[3]));
1575    const yHigh = Math.min(Math.max(rect1[1], rect1[3]), Math.max(rect2[1], rect2[3]));
1576
1577    if (yLow > yHigh) {
1578      return null;
1579    }
1580
1581    return [xLow, yLow, xHigh, yHigh];
1582  }
1583
1584  static bezierBoundingBox(x0, y0, x1, y1, x2, y2, x3, y3) {
1585    const tvalues = [],
1586          bounds = [[], []];
1587    let a, b, c, t, t1, t2, b2ac, sqrtb2ac;
1588
1589    for (let i = 0; i < 2; ++i) {
1590      if (i === 0) {
1591        b = 6 * x0 - 12 * x1 + 6 * x2;
1592        a = -3 * x0 + 9 * x1 - 9 * x2 + 3 * x3;
1593        c = 3 * x1 - 3 * x0;
1594      } else {
1595        b = 6 * y0 - 12 * y1 + 6 * y2;
1596        a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3;
1597        c = 3 * y1 - 3 * y0;
1598      }
1599
1600      if (Math.abs(a) < 1e-12) {
1601        if (Math.abs(b) < 1e-12) {
1602          continue;
1603        }
1604
1605        t = -c / b;
1606
1607        if (0 < t && t < 1) {
1608          tvalues.push(t);
1609        }
1610
1611        continue;
1612      }
1613
1614      b2ac = b * b - 4 * c * a;
1615      sqrtb2ac = Math.sqrt(b2ac);
1616
1617      if (b2ac < 0) {
1618        continue;
1619      }
1620
1621      t1 = (-b + sqrtb2ac) / (2 * a);
1622
1623      if (0 < t1 && t1 < 1) {
1624        tvalues.push(t1);
1625      }
1626
1627      t2 = (-b - sqrtb2ac) / (2 * a);
1628
1629      if (0 < t2 && t2 < 1) {
1630        tvalues.push(t2);
1631      }
1632    }
1633
1634    let j = tvalues.length,
1635        mt;
1636    const jlen = j;
1637
1638    while (j--) {
1639      t = tvalues[j];
1640      mt = 1 - t;
1641      bounds[0][j] = mt * mt * mt * x0 + 3 * mt * mt * t * x1 + 3 * mt * t * t * x2 + t * t * t * x3;
1642      bounds[1][j] = mt * mt * mt * y0 + 3 * mt * mt * t * y1 + 3 * mt * t * t * y2 + t * t * t * y3;
1643    }
1644
1645    bounds[0][jlen] = x0;
1646    bounds[1][jlen] = y0;
1647    bounds[0][jlen + 1] = x3;
1648    bounds[1][jlen + 1] = y3;
1649    bounds[0].length = bounds[1].length = jlen + 2;
1650    return [Math.min(...bounds[0]), Math.min(...bounds[1]), Math.max(...bounds[0]), Math.max(...bounds[1])];
1651  }
1652
1653}
1654
1655exports.Util = Util;
1656const 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];
1657
1658function stringToPDFString(str) {
1659  if (str[0] >= "\xEF") {
1660    let encoding;
1661
1662    if (str[0] === "\xFE" && str[1] === "\xFF") {
1663      encoding = "utf-16be";
1664    } else if (str[0] === "\xFF" && str[1] === "\xFE") {
1665      encoding = "utf-16le";
1666    } else if (str[0] === "\xEF" && str[1] === "\xBB" && str[2] === "\xBF") {
1667      encoding = "utf-8";
1668    }
1669
1670    if (encoding) {
1671      try {
1672        const decoder = new TextDecoder(encoding, {
1673          fatal: true
1674        });
1675        const buffer = stringToBytes(str);
1676        return decoder.decode(buffer);
1677      } catch (ex) {
1678        warn(`stringToPDFString: "${ex}".`);
1679      }
1680    }
1681  }
1682
1683  const strBuf = [];
1684
1685  for (let i = 0, ii = str.length; i < ii; i++) {
1686    const code = PDFStringTranslateTable[str.charCodeAt(i)];
1687    strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
1688  }
1689
1690  return strBuf.join("");
1691}
1692
1693function escapeString(str) {
1694  return str.replace(/([()\\\n\r])/g, match => {
1695    if (match === "\n") {
1696      return "\\n";
1697    } else if (match === "\r") {
1698      return "\\r";
1699    }
1700
1701    return `\\${match}`;
1702  });
1703}
1704
1705function isAscii(str) {
1706  return /^[\x00-\x7F]*$/.test(str);
1707}
1708
1709function stringToUTF16BEString(str) {
1710  const buf = ["\xFE\xFF"];
1711
1712  for (let i = 0, ii = str.length; i < ii; i++) {
1713    const char = str.charCodeAt(i);
1714    buf.push(String.fromCharCode(char >> 8 & 0xff), String.fromCharCode(char & 0xff));
1715  }
1716
1717  return buf.join("");
1718}
1719
1720function stringToUTF8String(str) {
1721  return decodeURIComponent(escape(str));
1722}
1723
1724function utf8StringToString(str) {
1725  return unescape(encodeURIComponent(str));
1726}
1727
1728function isArrayBuffer(v) {
1729  return typeof v === "object" && v !== null && v.byteLength !== undefined;
1730}
1731
1732function isArrayEqual(arr1, arr2) {
1733  if (arr1.length !== arr2.length) {
1734    return false;
1735  }
1736
1737  for (let i = 0, ii = arr1.length; i < ii; i++) {
1738    if (arr1[i] !== arr2[i]) {
1739      return false;
1740    }
1741  }
1742
1743  return true;
1744}
1745
1746function getModificationDate(date = new Date()) {
1747  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")];
1748  return buffer.join("");
1749}
1750
1751function createPromiseCapability() {
1752  const capability = Object.create(null);
1753  let isSettled = false;
1754  Object.defineProperty(capability, "settled", {
1755    get() {
1756      return isSettled;
1757    }
1758
1759  });
1760  capability.promise = new Promise(function (resolve, reject) {
1761    capability.resolve = function (data) {
1762      isSettled = true;
1763      resolve(data);
1764    };
1765
1766    capability.reject = function (reason) {
1767      isSettled = true;
1768      reject(reason);
1769    };
1770  });
1771  return capability;
1772}
1773
1774/***/ }),
1775/* 3 */
1776/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
1777
1778
1779
1780var _is_node = __w_pdfjs_require__(4);
1781
1782;
1783
1784/***/ }),
1785/* 4 */
1786/***/ ((__unused_webpack_module, exports) => {
1787
1788
1789
1790Object.defineProperty(exports, "__esModule", ({
1791  value: true
1792}));
1793exports.isNodeJS = void 0;
1794const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
1795exports.isNodeJS = isNodeJS;
1796
1797/***/ }),
1798/* 5 */
1799/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
1800
1801
1802
1803Object.defineProperty(exports, "__esModule", ({
1804  value: true
1805}));
1806exports.RefSetCache = exports.RefSet = exports.Ref = exports.Name = exports.EOF = exports.Dict = exports.Cmd = exports.CIRCULAR_REF = void 0;
1807exports.clearPrimitiveCaches = clearPrimitiveCaches;
1808exports.isCmd = isCmd;
1809exports.isDict = isDict;
1810exports.isName = isName;
1811exports.isRefsEqual = isRefsEqual;
1812
1813var _util = __w_pdfjs_require__(2);
1814
1815const CIRCULAR_REF = Symbol("CIRCULAR_REF");
1816exports.CIRCULAR_REF = CIRCULAR_REF;
1817const EOF = Symbol("EOF");
1818exports.EOF = EOF;
1819
1820const Name = function NameClosure() {
1821  let nameCache = Object.create(null);
1822
1823  class Name {
1824    constructor(name) {
1825      this.name = name;
1826    }
1827
1828    static get(name) {
1829      return nameCache[name] || (nameCache[name] = new Name(name));
1830    }
1831
1832    static _clearCache() {
1833      nameCache = Object.create(null);
1834    }
1835
1836  }
1837
1838  return Name;
1839}();
1840
1841exports.Name = Name;
1842
1843const Cmd = function CmdClosure() {
1844  let cmdCache = Object.create(null);
1845
1846  class Cmd {
1847    constructor(cmd) {
1848      this.cmd = cmd;
1849    }
1850
1851    static get(cmd) {
1852      return cmdCache[cmd] || (cmdCache[cmd] = new Cmd(cmd));
1853    }
1854
1855    static _clearCache() {
1856      cmdCache = Object.create(null);
1857    }
1858
1859  }
1860
1861  return Cmd;
1862}();
1863
1864exports.Cmd = Cmd;
1865
1866const nonSerializable = function nonSerializableClosure() {
1867  return nonSerializable;
1868};
1869
1870class Dict {
1871  constructor(xref = null) {
1872    this._map = Object.create(null);
1873    this.xref = xref;
1874    this.objId = null;
1875    this.suppressEncryption = false;
1876    this.__nonSerializable__ = nonSerializable;
1877  }
1878
1879  assignXref(newXref) {
1880    this.xref = newXref;
1881  }
1882
1883  get size() {
1884    return Object.keys(this._map).length;
1885  }
1886
1887  get(key1, key2, key3) {
1888    let value = this._map[key1];
1889
1890    if (value === undefined && key2 !== undefined) {
1891      value = this._map[key2];
1892
1893      if (value === undefined && key3 !== undefined) {
1894        value = this._map[key3];
1895      }
1896    }
1897
1898    if (value instanceof Ref && this.xref) {
1899      return this.xref.fetch(value, this.suppressEncryption);
1900    }
1901
1902    return value;
1903  }
1904
1905  async getAsync(key1, key2, key3) {
1906    let value = this._map[key1];
1907
1908    if (value === undefined && key2 !== undefined) {
1909      value = this._map[key2];
1910
1911      if (value === undefined && key3 !== undefined) {
1912        value = this._map[key3];
1913      }
1914    }
1915
1916    if (value instanceof Ref && this.xref) {
1917      return this.xref.fetchAsync(value, this.suppressEncryption);
1918    }
1919
1920    return value;
1921  }
1922
1923  getArray(key1, key2, key3) {
1924    let value = this._map[key1];
1925
1926    if (value === undefined && key2 !== undefined) {
1927      value = this._map[key2];
1928
1929      if (value === undefined && key3 !== undefined) {
1930        value = this._map[key3];
1931      }
1932    }
1933
1934    if (value instanceof Ref && this.xref) {
1935      value = this.xref.fetch(value, this.suppressEncryption);
1936    }
1937
1938    if (Array.isArray(value)) {
1939      value = value.slice();
1940
1941      for (let i = 0, ii = value.length; i < ii; i++) {
1942        if (value[i] instanceof Ref && this.xref) {
1943          value[i] = this.xref.fetch(value[i], this.suppressEncryption);
1944        }
1945      }
1946    }
1947
1948    return value;
1949  }
1950
1951  getRaw(key) {
1952    return this._map[key];
1953  }
1954
1955  getKeys() {
1956    return Object.keys(this._map);
1957  }
1958
1959  getRawValues() {
1960    return Object.values(this._map);
1961  }
1962
1963  set(key, value) {
1964    this._map[key] = value;
1965  }
1966
1967  has(key) {
1968    return this._map[key] !== undefined;
1969  }
1970
1971  forEach(callback) {
1972    for (const key in this._map) {
1973      callback(key, this.get(key));
1974    }
1975  }
1976
1977  static get empty() {
1978    const emptyDict = new Dict(null);
1979
1980    emptyDict.set = (key, value) => {
1981      (0, _util.unreachable)("Should not call `set` on the empty dictionary.");
1982    };
1983
1984    return (0, _util.shadow)(this, "empty", emptyDict);
1985  }
1986
1987  static merge({
1988    xref,
1989    dictArray,
1990    mergeSubDicts = false
1991  }) {
1992    const mergedDict = new Dict(xref),
1993          properties = new Map();
1994
1995    for (const dict of dictArray) {
1996      if (!(dict instanceof Dict)) {
1997        continue;
1998      }
1999
2000      for (const [key, value] of Object.entries(dict._map)) {
2001        let property = properties.get(key);
2002
2003        if (property === undefined) {
2004          property = [];
2005          properties.set(key, property);
2006        } else if (!mergeSubDicts || !(value instanceof Dict)) {
2007          continue;
2008        }
2009
2010        property.push(value);
2011      }
2012    }
2013
2014    for (const [name, values] of properties) {
2015      if (values.length === 1 || !(values[0] instanceof Dict)) {
2016        mergedDict._map[name] = values[0];
2017        continue;
2018      }
2019
2020      const subDict = new Dict(xref);
2021
2022      for (const dict of values) {
2023        for (const [key, value] of Object.entries(dict._map)) {
2024          if (subDict._map[key] === undefined) {
2025            subDict._map[key] = value;
2026          }
2027        }
2028      }
2029
2030      if (subDict.size > 0) {
2031        mergedDict._map[name] = subDict;
2032      }
2033    }
2034
2035    properties.clear();
2036    return mergedDict.size > 0 ? mergedDict : Dict.empty;
2037  }
2038
2039}
2040
2041exports.Dict = Dict;
2042
2043const Ref = function RefClosure() {
2044  let refCache = Object.create(null);
2045
2046  class Ref {
2047    constructor(num, gen) {
2048      this.num = num;
2049      this.gen = gen;
2050    }
2051
2052    toString() {
2053      if (this.gen === 0) {
2054        return `${this.num}R`;
2055      }
2056
2057      return `${this.num}R${this.gen}`;
2058    }
2059
2060    static get(num, gen) {
2061      const key = gen === 0 ? `${num}R` : `${num}R${gen}`;
2062      return refCache[key] || (refCache[key] = new Ref(num, gen));
2063    }
2064
2065    static _clearCache() {
2066      refCache = Object.create(null);
2067    }
2068
2069  }
2070
2071  return Ref;
2072}();
2073
2074exports.Ref = Ref;
2075
2076class RefSet {
2077  constructor(parent = null) {
2078    this._set = new Set(parent && parent._set);
2079  }
2080
2081  has(ref) {
2082    return this._set.has(ref.toString());
2083  }
2084
2085  put(ref) {
2086    this._set.add(ref.toString());
2087  }
2088
2089  remove(ref) {
2090    this._set.delete(ref.toString());
2091  }
2092
2093  [Symbol.iterator]() {
2094    return this._set.values();
2095  }
2096
2097  clear() {
2098    this._set.clear();
2099  }
2100
2101}
2102
2103exports.RefSet = RefSet;
2104
2105class RefSetCache {
2106  constructor() {
2107    this._map = new Map();
2108  }
2109
2110  get size() {
2111    return this._map.size;
2112  }
2113
2114  get(ref) {
2115    return this._map.get(ref.toString());
2116  }
2117
2118  has(ref) {
2119    return this._map.has(ref.toString());
2120  }
2121
2122  put(ref, obj) {
2123    this._map.set(ref.toString(), obj);
2124  }
2125
2126  putAlias(ref, aliasRef) {
2127    this._map.set(ref.toString(), this.get(aliasRef));
2128  }
2129
2130  [Symbol.iterator]() {
2131    return this._map.values();
2132  }
2133
2134  clear() {
2135    this._map.clear();
2136  }
2137
2138}
2139
2140exports.RefSetCache = RefSetCache;
2141
2142function isName(v, name) {
2143  return v instanceof Name && (name === undefined || v.name === name);
2144}
2145
2146function isCmd(v, cmd) {
2147  return v instanceof Cmd && (cmd === undefined || v.cmd === cmd);
2148}
2149
2150function isDict(v, type) {
2151  return v instanceof Dict && (type === undefined || isName(v.get("Type"), type));
2152}
2153
2154function isRefsEqual(v1, v2) {
2155  return v1.num === v2.num && v1.gen === v2.gen;
2156}
2157
2158function clearPrimitiveCaches() {
2159  Cmd._clearCache();
2160
2161  Name._clearCache();
2162
2163  Ref._clearCache();
2164}
2165
2166/***/ }),
2167/* 6 */
2168/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
2169
2170
2171
2172Object.defineProperty(exports, "__esModule", ({
2173  value: true
2174}));
2175exports.XRefParseException = exports.XRefEntryException = exports.ParserEOFException = exports.MissingDataException = exports.DocStats = void 0;
2176exports.collectActions = collectActions;
2177exports.encodeToXmlString = encodeToXmlString;
2178exports.escapePDFName = escapePDFName;
2179exports.getArrayLookupTableFactory = getArrayLookupTableFactory;
2180exports.getInheritableProperty = getInheritableProperty;
2181exports.getLookupTableFactory = getLookupTableFactory;
2182exports.getNewAnnotationsMap = getNewAnnotationsMap;
2183exports.isWhiteSpace = isWhiteSpace;
2184exports.log2 = log2;
2185exports.numberToString = numberToString;
2186exports.parseXFAPath = parseXFAPath;
2187exports.readInt8 = readInt8;
2188exports.readUint16 = readUint16;
2189exports.readUint32 = readUint32;
2190exports.recoverJsURL = recoverJsURL;
2191exports.toRomanNumerals = toRomanNumerals;
2192exports.validateCSSFont = validateCSSFont;
2193
2194var _util = __w_pdfjs_require__(2);
2195
2196var _primitives = __w_pdfjs_require__(5);
2197
2198var _base_stream = __w_pdfjs_require__(7);
2199
2200function getLookupTableFactory(initializer) {
2201  let lookup;
2202  return function () {
2203    if (initializer) {
2204      lookup = Object.create(null);
2205      initializer(lookup);
2206      initializer = null;
2207    }
2208
2209    return lookup;
2210  };
2211}
2212
2213function getArrayLookupTableFactory(initializer) {
2214  let lookup;
2215  return function () {
2216    if (initializer) {
2217      let arr = initializer();
2218      initializer = null;
2219      lookup = Object.create(null);
2220
2221      for (let i = 0, ii = arr.length; i < ii; i += 2) {
2222        lookup[arr[i]] = arr[i + 1];
2223      }
2224
2225      arr = null;
2226    }
2227
2228    return lookup;
2229  };
2230}
2231
2232class MissingDataException extends _util.BaseException {
2233  constructor(begin, end) {
2234    super(`Missing data [${begin}, ${end})`, "MissingDataException");
2235    this.begin = begin;
2236    this.end = end;
2237  }
2238
2239}
2240
2241exports.MissingDataException = MissingDataException;
2242
2243class ParserEOFException extends _util.BaseException {
2244  constructor(msg) {
2245    super(msg, "ParserEOFException");
2246  }
2247
2248}
2249
2250exports.ParserEOFException = ParserEOFException;
2251
2252class XRefEntryException extends _util.BaseException {
2253  constructor(msg) {
2254    super(msg, "XRefEntryException");
2255  }
2256
2257}
2258
2259exports.XRefEntryException = XRefEntryException;
2260
2261class XRefParseException extends _util.BaseException {
2262  constructor(msg) {
2263    super(msg, "XRefParseException");
2264  }
2265
2266}
2267
2268exports.XRefParseException = XRefParseException;
2269
2270class DocStats {
2271  constructor(handler) {
2272    this._handler = handler;
2273    this._streamTypes = new Set();
2274    this._fontTypes = new Set();
2275  }
2276
2277  _send() {
2278    const streamTypes = Object.create(null),
2279          fontTypes = Object.create(null);
2280
2281    for (const type of this._streamTypes) {
2282      streamTypes[type] = true;
2283    }
2284
2285    for (const type of this._fontTypes) {
2286      fontTypes[type] = true;
2287    }
2288
2289    this._handler.send("DocStats", {
2290      streamTypes,
2291      fontTypes
2292    });
2293  }
2294
2295  addStreamType(type) {
2296    if (this._streamTypes.has(type)) {
2297      return;
2298    }
2299
2300    this._streamTypes.add(type);
2301
2302    this._send();
2303  }
2304
2305  addFontType(type) {
2306    if (this._fontTypes.has(type)) {
2307      return;
2308    }
2309
2310    this._fontTypes.add(type);
2311
2312    this._send();
2313  }
2314
2315}
2316
2317exports.DocStats = DocStats;
2318
2319function getInheritableProperty({
2320  dict,
2321  key,
2322  getArray = false,
2323  stopWhenFound = true
2324}) {
2325  let values;
2326  const visited = new _primitives.RefSet();
2327
2328  while (dict instanceof _primitives.Dict && !(dict.objId && visited.has(dict.objId))) {
2329    if (dict.objId) {
2330      visited.put(dict.objId);
2331    }
2332
2333    const value = getArray ? dict.getArray(key) : dict.get(key);
2334
2335    if (value !== undefined) {
2336      if (stopWhenFound) {
2337        return value;
2338      }
2339
2340      if (!values) {
2341        values = [];
2342      }
2343
2344      values.push(value);
2345    }
2346
2347    dict = dict.get("Parent");
2348  }
2349
2350  return values;
2351}
2352
2353const 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"];
2354
2355function toRomanNumerals(number, lowerCase = false) {
2356  (0, _util.assert)(Number.isInteger(number) && number > 0, "The number should be a positive integer.");
2357  const romanBuf = [];
2358  let pos;
2359
2360  while (number >= 1000) {
2361    number -= 1000;
2362    romanBuf.push("M");
2363  }
2364
2365  pos = number / 100 | 0;
2366  number %= 100;
2367  romanBuf.push(ROMAN_NUMBER_MAP[pos]);
2368  pos = number / 10 | 0;
2369  number %= 10;
2370  romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]);
2371  romanBuf.push(ROMAN_NUMBER_MAP[20 + number]);
2372  const romanStr = romanBuf.join("");
2373  return lowerCase ? romanStr.toLowerCase() : romanStr;
2374}
2375
2376function log2(x) {
2377  if (x <= 0) {
2378    return 0;
2379  }
2380
2381  return Math.ceil(Math.log2(x));
2382}
2383
2384function readInt8(data, offset) {
2385  return data[offset] << 24 >> 24;
2386}
2387
2388function readUint16(data, offset) {
2389  return data[offset] << 8 | data[offset + 1];
2390}
2391
2392function readUint32(data, offset) {
2393  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
2394}
2395
2396function isWhiteSpace(ch) {
2397  return ch === 0x20 || ch === 0x09 || ch === 0x0d || ch === 0x0a;
2398}
2399
2400function parseXFAPath(path) {
2401  const positionPattern = /(.+)\[(\d+)\]$/;
2402  return path.split(".").map(component => {
2403    const m = component.match(positionPattern);
2404
2405    if (m) {
2406      return {
2407        name: m[1],
2408        pos: parseInt(m[2], 10)
2409      };
2410    }
2411
2412    return {
2413      name: component,
2414      pos: 0
2415    };
2416  });
2417}
2418
2419function escapePDFName(str) {
2420  const buffer = [];
2421  let start = 0;
2422
2423  for (let i = 0, ii = str.length; i < ii; i++) {
2424    const char = str.charCodeAt(i);
2425
2426    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) {
2427      if (start < i) {
2428        buffer.push(str.substring(start, i));
2429      }
2430
2431      buffer.push(`#${char.toString(16)}`);
2432      start = i + 1;
2433    }
2434  }
2435
2436  if (buffer.length === 0) {
2437    return str;
2438  }
2439
2440  if (start < str.length) {
2441    buffer.push(str.substring(start, str.length));
2442  }
2443
2444  return buffer.join("");
2445}
2446
2447function _collectJS(entry, xref, list, parents) {
2448  if (!entry) {
2449    return;
2450  }
2451
2452  let parent = null;
2453
2454  if (entry instanceof _primitives.Ref) {
2455    if (parents.has(entry)) {
2456      return;
2457    }
2458
2459    parent = entry;
2460    parents.put(parent);
2461    entry = xref.fetch(entry);
2462  }
2463
2464  if (Array.isArray(entry)) {
2465    for (const element of entry) {
2466      _collectJS(element, xref, list, parents);
2467    }
2468  } else if (entry instanceof _primitives.Dict) {
2469    if ((0, _primitives.isName)(entry.get("S"), "JavaScript")) {
2470      const js = entry.get("JS");
2471      let code;
2472
2473      if (js instanceof _base_stream.BaseStream) {
2474        code = js.getString();
2475      } else if (typeof js === "string") {
2476        code = js;
2477      }
2478
2479      code = code && (0, _util.stringToPDFString)(code).replace(/\u0000/g, "");
2480
2481      if (code) {
2482        list.push(code);
2483      }
2484    }
2485
2486    _collectJS(entry.getRaw("Next"), xref, list, parents);
2487  }
2488
2489  if (parent) {
2490    parents.remove(parent);
2491  }
2492}
2493
2494function collectActions(xref, dict, eventType) {
2495  const actions = Object.create(null);
2496  const additionalActionsDicts = getInheritableProperty({
2497    dict,
2498    key: "AA",
2499    stopWhenFound: false
2500  });
2501
2502  if (additionalActionsDicts) {
2503    for (let i = additionalActionsDicts.length - 1; i >= 0; i--) {
2504      const additionalActions = additionalActionsDicts[i];
2505
2506      if (!(additionalActions instanceof _primitives.Dict)) {
2507        continue;
2508      }
2509
2510      for (const key of additionalActions.getKeys()) {
2511        const action = eventType[key];
2512
2513        if (!action) {
2514          continue;
2515        }
2516
2517        const actionDict = additionalActions.getRaw(key);
2518        const parents = new _primitives.RefSet();
2519        const list = [];
2520
2521        _collectJS(actionDict, xref, list, parents);
2522
2523        if (list.length > 0) {
2524          actions[action] = list;
2525        }
2526      }
2527    }
2528  }
2529
2530  if (dict.has("A")) {
2531    const actionDict = dict.get("A");
2532    const parents = new _primitives.RefSet();
2533    const list = [];
2534
2535    _collectJS(actionDict, xref, list, parents);
2536
2537    if (list.length > 0) {
2538      actions.Action = list;
2539    }
2540  }
2541
2542  return (0, _util.objectSize)(actions) > 0 ? actions : null;
2543}
2544
2545const XMLEntities = {
2546  0x3c: "&lt;",
2547  0x3e: "&gt;",
2548  0x26: "&amp;",
2549  0x22: "&quot;",
2550  0x27: "&apos;"
2551};
2552
2553function encodeToXmlString(str) {
2554  const buffer = [];
2555  let start = 0;
2556
2557  for (let i = 0, ii = str.length; i < ii; i++) {
2558    const char = str.codePointAt(i);
2559
2560    if (0x20 <= char && char <= 0x7e) {
2561      const entity = XMLEntities[char];
2562
2563      if (entity) {
2564        if (start < i) {
2565          buffer.push(str.substring(start, i));
2566        }
2567
2568        buffer.push(entity);
2569        start = i + 1;
2570      }
2571    } else {
2572      if (start < i) {
2573        buffer.push(str.substring(start, i));
2574      }
2575
2576      buffer.push(`&#x${char.toString(16).toUpperCase()};`);
2577
2578      if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {
2579        i++;
2580      }
2581
2582      start = i + 1;
2583    }
2584  }
2585
2586  if (buffer.length === 0) {
2587    return str;
2588  }
2589
2590  if (start < str.length) {
2591    buffer.push(str.substring(start, str.length));
2592  }
2593
2594  return buffer.join("");
2595}
2596
2597function validateCSSFont(cssFontInfo) {
2598  const DEFAULT_CSS_FONT_OBLIQUE = "14";
2599  const DEFAULT_CSS_FONT_WEIGHT = "400";
2600  const CSS_FONT_WEIGHT_VALUES = new Set(["100", "200", "300", "400", "500", "600", "700", "800", "900", "1000", "normal", "bold", "bolder", "lighter"]);
2601  const {
2602    fontFamily,
2603    fontWeight,
2604    italicAngle
2605  } = cssFontInfo;
2606
2607  if (/^".*"$/.test(fontFamily)) {
2608    if (/[^\\]"/.test(fontFamily.slice(1, fontFamily.length - 1))) {
2609      (0, _util.warn)(`XFA - FontFamily contains some unescaped ": ${fontFamily}.`);
2610      return false;
2611    }
2612  } else if (/^'.*'$/.test(fontFamily)) {
2613    if (/[^\\]'/.test(fontFamily.slice(1, fontFamily.length - 1))) {
2614      (0, _util.warn)(`XFA - FontFamily contains some unescaped ': ${fontFamily}.`);
2615      return false;
2616    }
2617  } else {
2618    for (const ident of fontFamily.split(/[ \t]+/)) {
2619      if (/^(\d|(-(\d|-)))/.test(ident) || !/^[\w-\\]+$/.test(ident)) {
2620        (0, _util.warn)(`XFA - FontFamily contains some invalid <custom-ident>: ${fontFamily}.`);
2621        return false;
2622      }
2623    }
2624  }
2625
2626  const weight = fontWeight ? fontWeight.toString() : "";
2627  cssFontInfo.fontWeight = CSS_FONT_WEIGHT_VALUES.has(weight) ? weight : DEFAULT_CSS_FONT_WEIGHT;
2628  const angle = parseFloat(italicAngle);
2629  cssFontInfo.italicAngle = isNaN(angle) || angle < -90 || angle > 90 ? DEFAULT_CSS_FONT_OBLIQUE : italicAngle.toString();
2630  return true;
2631}
2632
2633function recoverJsURL(str) {
2634  const URL_OPEN_METHODS = ["app.launchURL", "window.open", "xfa.host.gotoURL"];
2635  const regex = new RegExp("^\\s*(" + URL_OPEN_METHODS.join("|").split(".").join("\\.") + ")\\((?:'|\")([^'\"]*)(?:'|\")(?:,\\s*(\\w+)\\)|\\))", "i");
2636  const jsUrl = regex.exec(str);
2637
2638  if (jsUrl && jsUrl[2]) {
2639    const url = jsUrl[2];
2640    let newWindow = false;
2641
2642    if (jsUrl[3] === "true" && jsUrl[1] === "app.launchURL") {
2643      newWindow = true;
2644    }
2645
2646    return {
2647      url,
2648      newWindow
2649    };
2650  }
2651
2652  return null;
2653}
2654
2655function numberToString(value) {
2656  if (Number.isInteger(value)) {
2657    return value.toString();
2658  }
2659
2660  const roundedValue = Math.round(value * 100);
2661
2662  if (roundedValue % 100 === 0) {
2663    return (roundedValue / 100).toString();
2664  }
2665
2666  if (roundedValue % 10 === 0) {
2667    return value.toFixed(1);
2668  }
2669
2670  return value.toFixed(2);
2671}
2672
2673function getNewAnnotationsMap(annotationStorage) {
2674  if (!annotationStorage) {
2675    return null;
2676  }
2677
2678  const newAnnotationsByPage = new Map();
2679
2680  for (const [key, value] of annotationStorage) {
2681    if (!key.startsWith(_util.AnnotationEditorPrefix)) {
2682      continue;
2683    }
2684
2685    let annotations = newAnnotationsByPage.get(value.pageIndex);
2686
2687    if (!annotations) {
2688      annotations = [];
2689      newAnnotationsByPage.set(value.pageIndex, annotations);
2690    }
2691
2692    annotations.push(value);
2693  }
2694
2695  return newAnnotationsByPage.size > 0 ? newAnnotationsByPage : null;
2696}
2697
2698/***/ }),
2699/* 7 */
2700/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
2701
2702
2703
2704Object.defineProperty(exports, "__esModule", ({
2705  value: true
2706}));
2707exports.BaseStream = void 0;
2708
2709var _util = __w_pdfjs_require__(2);
2710
2711class BaseStream {
2712  constructor() {
2713    if (this.constructor === BaseStream) {
2714      (0, _util.unreachable)("Cannot initialize BaseStream.");
2715    }
2716  }
2717
2718  get length() {
2719    (0, _util.unreachable)("Abstract getter `length` accessed");
2720  }
2721
2722  get isEmpty() {
2723    (0, _util.unreachable)("Abstract getter `isEmpty` accessed");
2724  }
2725
2726  get isDataLoaded() {
2727    return (0, _util.shadow)(this, "isDataLoaded", true);
2728  }
2729
2730  getByte() {
2731    (0, _util.unreachable)("Abstract method `getByte` called");
2732  }
2733
2734  getBytes(length) {
2735    (0, _util.unreachable)("Abstract method `getBytes` called");
2736  }
2737
2738  peekByte() {
2739    const peekedByte = this.getByte();
2740
2741    if (peekedByte !== -1) {
2742      this.pos--;
2743    }
2744
2745    return peekedByte;
2746  }
2747
2748  peekBytes(length) {
2749    const bytes = this.getBytes(length);
2750    this.pos -= bytes.length;
2751    return bytes;
2752  }
2753
2754  getUint16() {
2755    const b0 = this.getByte();
2756    const b1 = this.getByte();
2757
2758    if (b0 === -1 || b1 === -1) {
2759      return -1;
2760    }
2761
2762    return (b0 << 8) + b1;
2763  }
2764
2765  getInt32() {
2766    const b0 = this.getByte();
2767    const b1 = this.getByte();
2768    const b2 = this.getByte();
2769    const b3 = this.getByte();
2770    return (b0 << 24) + (b1 << 16) + (b2 << 8) + b3;
2771  }
2772
2773  getByteRange(begin, end) {
2774    (0, _util.unreachable)("Abstract method `getByteRange` called");
2775  }
2776
2777  getString(length) {
2778    return (0, _util.bytesToString)(this.getBytes(length));
2779  }
2780
2781  skip(n) {
2782    this.pos += n || 1;
2783  }
2784
2785  reset() {
2786    (0, _util.unreachable)("Abstract method `reset` called");
2787  }
2788
2789  moveStart() {
2790    (0, _util.unreachable)("Abstract method `moveStart` called");
2791  }
2792
2793  makeSubStream(start, length, dict = null) {
2794    (0, _util.unreachable)("Abstract method `makeSubStream` called");
2795  }
2796
2797  getBaseStreams() {
2798    return null;
2799  }
2800
2801}
2802
2803exports.BaseStream = BaseStream;
2804
2805/***/ }),
2806/* 8 */
2807/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
2808
2809
2810
2811Object.defineProperty(exports, "__esModule", ({
2812  value: true
2813}));
2814exports.NetworkPdfManager = exports.LocalPdfManager = void 0;
2815
2816var _util = __w_pdfjs_require__(2);
2817
2818var _chunked_stream = __w_pdfjs_require__(9);
2819
2820var _core_utils = __w_pdfjs_require__(6);
2821
2822var _document = __w_pdfjs_require__(11);
2823
2824var _stream = __w_pdfjs_require__(10);
2825
2826function parseDocBaseUrl(url) {
2827  if (url) {
2828    const absoluteUrl = (0, _util.createValidAbsoluteUrl)(url);
2829
2830    if (absoluteUrl) {
2831      return absoluteUrl.href;
2832    }
2833
2834    (0, _util.warn)(`Invalid absolute docBaseUrl: "${url}".`);
2835  }
2836
2837  return null;
2838}
2839
2840class BasePdfManager {
2841  constructor() {
2842    if (this.constructor === BasePdfManager) {
2843      (0, _util.unreachable)("Cannot initialize BasePdfManager.");
2844    }
2845  }
2846
2847  get docId() {
2848    return this._docId;
2849  }
2850
2851  get password() {
2852    return this._password;
2853  }
2854
2855  get docBaseUrl() {
2856    const catalog = this.pdfDocument.catalog;
2857    return (0, _util.shadow)(this, "docBaseUrl", catalog.baseUrl || this._docBaseUrl);
2858  }
2859
2860  onLoadedStream() {
2861    (0, _util.unreachable)("Abstract method `onLoadedStream` called");
2862  }
2863
2864  ensureDoc(prop, args) {
2865    return this.ensure(this.pdfDocument, prop, args);
2866  }
2867
2868  ensureXRef(prop, args) {
2869    return this.ensure(this.pdfDocument.xref, prop, args);
2870  }
2871
2872  ensureCatalog(prop, args) {
2873    return this.ensure(this.pdfDocument.catalog, prop, args);
2874  }
2875
2876  getPage(pageIndex) {
2877    return this.pdfDocument.getPage(pageIndex);
2878  }
2879
2880  fontFallback(id, handler) {
2881    return this.pdfDocument.fontFallback(id, handler);
2882  }
2883
2884  loadXfaFonts(handler, task) {
2885    return this.pdfDocument.loadXfaFonts(handler, task);
2886  }
2887
2888  loadXfaImages() {
2889    return this.pdfDocument.loadXfaImages();
2890  }
2891
2892  serializeXfaData(annotationStorage) {
2893    return this.pdfDocument.serializeXfaData(annotationStorage);
2894  }
2895
2896  cleanup(manuallyTriggered = false) {
2897    return this.pdfDocument.cleanup(manuallyTriggered);
2898  }
2899
2900  async ensure(obj, prop, args) {
2901    (0, _util.unreachable)("Abstract method `ensure` called");
2902  }
2903
2904  requestRange(begin, end) {
2905    (0, _util.unreachable)("Abstract method `requestRange` called");
2906  }
2907
2908  requestLoadedStream() {
2909    (0, _util.unreachable)("Abstract method `requestLoadedStream` called");
2910  }
2911
2912  sendProgressiveData(chunk) {
2913    (0, _util.unreachable)("Abstract method `sendProgressiveData` called");
2914  }
2915
2916  updatePassword(password) {
2917    this._password = password;
2918  }
2919
2920  terminate(reason) {
2921    (0, _util.unreachable)("Abstract method `terminate` called");
2922  }
2923
2924}
2925
2926class LocalPdfManager extends BasePdfManager {
2927  constructor(docId, data, password, msgHandler, evaluatorOptions, enableXfa, docBaseUrl) {
2928    super();
2929    this._docId = docId;
2930    this._password = password;
2931    this._docBaseUrl = parseDocBaseUrl(docBaseUrl);
2932    this.msgHandler = msgHandler;
2933    this.evaluatorOptions = evaluatorOptions;
2934    this.enableXfa = enableXfa;
2935    const stream = new _stream.Stream(data);
2936    this.pdfDocument = new _document.PDFDocument(this, stream);
2937    this._loadedStreamPromise = Promise.resolve(stream);
2938  }
2939
2940  async ensure(obj, prop, args) {
2941    const value = obj[prop];
2942
2943    if (typeof value === "function") {
2944      return value.apply(obj, args);
2945    }
2946
2947    return value;
2948  }
2949
2950  requestRange(begin, end) {
2951    return Promise.resolve();
2952  }
2953
2954  requestLoadedStream() {}
2955
2956  onLoadedStream() {
2957    return this._loadedStreamPromise;
2958  }
2959
2960  terminate(reason) {}
2961
2962}
2963
2964exports.LocalPdfManager = LocalPdfManager;
2965
2966class NetworkPdfManager extends BasePdfManager {
2967  constructor(docId, pdfNetworkStream, args, evaluatorOptions, enableXfa, docBaseUrl) {
2968    super();
2969    this._docId = docId;
2970    this._password = args.password;
2971    this._docBaseUrl = parseDocBaseUrl(docBaseUrl);
2972    this.msgHandler = args.msgHandler;
2973    this.evaluatorOptions = evaluatorOptions;
2974    this.enableXfa = enableXfa;
2975    this.streamManager = new _chunked_stream.ChunkedStreamManager(pdfNetworkStream, {
2976      msgHandler: args.msgHandler,
2977      length: args.length,
2978      disableAutoFetch: args.disableAutoFetch,
2979      rangeChunkSize: args.rangeChunkSize
2980    });
2981    this.pdfDocument = new _document.PDFDocument(this, this.streamManager.getStream());
2982  }
2983
2984  async ensure(obj, prop, args) {
2985    try {
2986      const value = obj[prop];
2987
2988      if (typeof value === "function") {
2989        return value.apply(obj, args);
2990      }
2991
2992      return value;
2993    } catch (ex) {
2994      if (!(ex instanceof _core_utils.MissingDataException)) {
2995        throw ex;
2996      }
2997
2998      await this.requestRange(ex.begin, ex.end);
2999      return this.ensure(obj, prop, args);
3000    }
3001  }
3002
3003  requestRange(begin, end) {
3004    return this.streamManager.requestRange(begin, end);
3005  }
3006
3007  requestLoadedStream() {
3008    this.streamManager.requestAllChunks();
3009  }
3010
3011  sendProgressiveData(chunk) {
3012    this.streamManager.onReceiveData({
3013      chunk
3014    });
3015  }
3016
3017  onLoadedStream() {
3018    return this.streamManager.onLoadedStream();
3019  }
3020
3021  terminate(reason) {
3022    this.streamManager.abort(reason);
3023  }
3024
3025}
3026
3027exports.NetworkPdfManager = NetworkPdfManager;
3028
3029/***/ }),
3030/* 9 */
3031/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
3032
3033
3034
3035Object.defineProperty(exports, "__esModule", ({
3036  value: true
3037}));
3038exports.ChunkedStreamManager = exports.ChunkedStream = void 0;
3039
3040var _util = __w_pdfjs_require__(2);
3041
3042var _core_utils = __w_pdfjs_require__(6);
3043
3044var _stream = __w_pdfjs_require__(10);
3045
3046class ChunkedStream extends _stream.Stream {
3047  constructor(length, chunkSize, manager) {
3048    super(new Uint8Array(length), 0, length, null);
3049    this.chunkSize = chunkSize;
3050    this._loadedChunks = new Set();
3051    this.numChunks = Math.ceil(length / chunkSize);
3052    this.manager = manager;
3053    this.progressiveDataLength = 0;
3054    this.lastSuccessfulEnsureByteChunk = -1;
3055  }
3056
3057  getMissingChunks() {
3058    const chunks = [];
3059
3060    for (let chunk = 0, n = this.numChunks; chunk < n; ++chunk) {
3061      if (!this._loadedChunks.has(chunk)) {
3062        chunks.push(chunk);
3063      }
3064    }
3065
3066    return chunks;
3067  }
3068
3069  get numChunksLoaded() {
3070    return this._loadedChunks.size;
3071  }
3072
3073  get isDataLoaded() {
3074    return this.numChunksLoaded === this.numChunks;
3075  }
3076
3077  onReceiveData(begin, chunk) {
3078    const chunkSize = this.chunkSize;
3079
3080    if (begin % chunkSize !== 0) {
3081      throw new Error(`Bad begin offset: ${begin}`);
3082    }
3083
3084    const end = begin + chunk.byteLength;
3085
3086    if (end % chunkSize !== 0 && end !== this.bytes.length) {
3087      throw new Error(`Bad end offset: ${end}`);
3088    }
3089
3090    this.bytes.set(new Uint8Array(chunk), begin);
3091    const beginChunk = Math.floor(begin / chunkSize);
3092    const endChunk = Math.floor((end - 1) / chunkSize) + 1;
3093
3094    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
3095      this._loadedChunks.add(curChunk);
3096    }
3097  }
3098
3099  onReceiveProgressiveData(data) {
3100    let position = this.progressiveDataLength;
3101    const beginChunk = Math.floor(position / this.chunkSize);
3102    this.bytes.set(new Uint8Array(data), position);
3103    position += data.byteLength;
3104    this.progressiveDataLength = position;
3105    const endChunk = position >= this.end ? this.numChunks : Math.floor(position / this.chunkSize);
3106
3107    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
3108      this._loadedChunks.add(curChunk);
3109    }
3110  }
3111
3112  ensureByte(pos) {
3113    if (pos < this.progressiveDataLength) {
3114      return;
3115    }
3116
3117    const chunk = Math.floor(pos / this.chunkSize);
3118
3119    if (chunk > this.numChunks) {
3120      return;
3121    }
3122
3123    if (chunk === this.lastSuccessfulEnsureByteChunk) {
3124      return;
3125    }
3126
3127    if (!this._loadedChunks.has(chunk)) {
3128      throw new _core_utils.MissingDataException(pos, pos + 1);
3129    }
3130
3131    this.lastSuccessfulEnsureByteChunk = chunk;
3132  }
3133
3134  ensureRange(begin, end) {
3135    if (begin >= end) {
3136      return;
3137    }
3138
3139    if (end <= this.progressiveDataLength) {
3140      return;
3141    }
3142
3143    const beginChunk = Math.floor(begin / this.chunkSize);
3144
3145    if (beginChunk > this.numChunks) {
3146      return;
3147    }
3148
3149    const endChunk = Math.min(Math.floor((end - 1) / this.chunkSize) + 1, this.numChunks);
3150
3151    for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
3152      if (!this._loadedChunks.has(chunk)) {
3153        throw new _core_utils.MissingDataException(begin, end);
3154      }
3155    }
3156  }
3157
3158  nextEmptyChunk(beginChunk) {
3159    const numChunks = this.numChunks;
3160
3161    for (let i = 0; i < numChunks; ++i) {
3162      const chunk = (beginChunk + i) % numChunks;
3163
3164      if (!this._loadedChunks.has(chunk)) {
3165        return chunk;
3166      }
3167    }
3168
3169    return null;
3170  }
3171
3172  hasChunk(chunk) {
3173    return this._loadedChunks.has(chunk);
3174  }
3175
3176  getByte() {
3177    const pos = this.pos;
3178
3179    if (pos >= this.end) {
3180      return -1;
3181    }
3182
3183    if (pos >= this.progressiveDataLength) {
3184      this.ensureByte(pos);
3185    }
3186
3187    return this.bytes[this.pos++];
3188  }
3189
3190  getBytes(length) {
3191    const bytes = this.bytes;
3192    const pos = this.pos;
3193    const strEnd = this.end;
3194
3195    if (!length) {
3196      if (strEnd > this.progressiveDataLength) {
3197        this.ensureRange(pos, strEnd);
3198      }
3199
3200      return bytes.subarray(pos, strEnd);
3201    }
3202
3203    let end = pos + length;
3204
3205    if (end > strEnd) {
3206      end = strEnd;
3207    }
3208
3209    if (end > this.progressiveDataLength) {
3210      this.ensureRange(pos, end);
3211    }
3212
3213    this.pos = end;
3214    return bytes.subarray(pos, end);
3215  }
3216
3217  getByteRange(begin, end) {
3218    if (begin < 0) {
3219      begin = 0;
3220    }
3221
3222    if (end > this.end) {
3223      end = this.end;
3224    }
3225
3226    if (end > this.progressiveDataLength) {
3227      this.ensureRange(begin, end);
3228    }
3229
3230    return this.bytes.subarray(begin, end);
3231  }
3232
3233  makeSubStream(start, length, dict = null) {
3234    if (length) {
3235      if (start + length > this.progressiveDataLength) {
3236        this.ensureRange(start, start + length);
3237      }
3238    } else {
3239      if (start >= this.progressiveDataLength) {
3240        this.ensureByte(start);
3241      }
3242    }
3243
3244    function ChunkedStreamSubstream() {}
3245
3246    ChunkedStreamSubstream.prototype = Object.create(this);
3247
3248    ChunkedStreamSubstream.prototype.getMissingChunks = function () {
3249      const chunkSize = this.chunkSize;
3250      const beginChunk = Math.floor(this.start / chunkSize);
3251      const endChunk = Math.floor((this.end - 1) / chunkSize) + 1;
3252      const missingChunks = [];
3253
3254      for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
3255        if (!this._loadedChunks.has(chunk)) {
3256          missingChunks.push(chunk);
3257        }
3258      }
3259
3260      return missingChunks;
3261    };
3262
3263    Object.defineProperty(ChunkedStreamSubstream.prototype, "isDataLoaded", {
3264      get() {
3265        if (this.numChunksLoaded === this.numChunks) {
3266          return true;
3267        }
3268
3269        return this.getMissingChunks().length === 0;
3270      },
3271
3272      configurable: true
3273    });
3274    const subStream = new ChunkedStreamSubstream();
3275    subStream.pos = subStream.start = start;
3276    subStream.end = start + length || this.end;
3277    subStream.dict = dict;
3278    return subStream;
3279  }
3280
3281  getBaseStreams() {
3282    return [this];
3283  }
3284
3285}
3286
3287exports.ChunkedStream = ChunkedStream;
3288
3289class ChunkedStreamManager {
3290  constructor(pdfNetworkStream, args) {
3291    this.length = args.length;
3292    this.chunkSize = args.rangeChunkSize;
3293    this.stream = new ChunkedStream(this.length, this.chunkSize, this);
3294    this.pdfNetworkStream = pdfNetworkStream;
3295    this.disableAutoFetch = args.disableAutoFetch;
3296    this.msgHandler = args.msgHandler;
3297    this.currRequestId = 0;
3298    this._chunksNeededByRequest = new Map();
3299    this._requestsByChunk = new Map();
3300    this._promisesByRequest = new Map();
3301    this.progressiveDataLength = 0;
3302    this.aborted = false;
3303    this._loadedStreamCapability = (0, _util.createPromiseCapability)();
3304  }
3305
3306  onLoadedStream() {
3307    return this._loadedStreamCapability.promise;
3308  }
3309
3310  sendRequest(begin, end) {
3311    const rangeReader = this.pdfNetworkStream.getRangeReader(begin, end);
3312
3313    if (!rangeReader.isStreamingSupported) {
3314      rangeReader.onProgress = this.onProgress.bind(this);
3315    }
3316
3317    let chunks = [],
3318        loaded = 0;
3319    return new Promise((resolve, reject) => {
3320      const readChunk = chunk => {
3321        try {
3322          if (!chunk.done) {
3323            const data = chunk.value;
3324            chunks.push(data);
3325            loaded += (0, _util.arrayByteLength)(data);
3326
3327            if (rangeReader.isStreamingSupported) {
3328              this.onProgress({
3329                loaded
3330              });
3331            }
3332
3333            rangeReader.read().then(readChunk, reject);
3334            return;
3335          }
3336
3337          const chunkData = (0, _util.arraysToBytes)(chunks);
3338          chunks = null;
3339          resolve(chunkData);
3340        } catch (e) {
3341          reject(e);
3342        }
3343      };
3344
3345      rangeReader.read().then(readChunk, reject);
3346    }).then(data => {
3347      if (this.aborted) {
3348        return;
3349      }
3350
3351      this.onReceiveData({
3352        chunk: data,
3353        begin
3354      });
3355    });
3356  }
3357
3358  requestAllChunks() {
3359    const missingChunks = this.stream.getMissingChunks();
3360
3361    this._requestChunks(missingChunks);
3362
3363    return this._loadedStreamCapability.promise;
3364  }
3365
3366  _requestChunks(chunks) {
3367    const requestId = this.currRequestId++;
3368    const chunksNeeded = new Set();
3369
3370    this._chunksNeededByRequest.set(requestId, chunksNeeded);
3371
3372    for (const chunk of chunks) {
3373      if (!this.stream.hasChunk(chunk)) {
3374        chunksNeeded.add(chunk);
3375      }
3376    }
3377
3378    if (chunksNeeded.size === 0) {
3379      return Promise.resolve();
3380    }
3381
3382    const capability = (0, _util.createPromiseCapability)();
3383
3384    this._promisesByRequest.set(requestId, capability);
3385
3386    const chunksToRequest = [];
3387
3388    for (const chunk of chunksNeeded) {
3389      let requestIds = this._requestsByChunk.get(chunk);
3390
3391      if (!requestIds) {
3392        requestIds = [];
3393
3394        this._requestsByChunk.set(chunk, requestIds);
3395
3396        chunksToRequest.push(chunk);
3397      }
3398
3399      requestIds.push(requestId);
3400    }
3401
3402    if (chunksToRequest.length > 0) {
3403      const groupedChunksToRequest = this.groupChunks(chunksToRequest);
3404
3405      for (const groupedChunk of groupedChunksToRequest) {
3406        const begin = groupedChunk.beginChunk * this.chunkSize;
3407        const end = Math.min(groupedChunk.endChunk * this.chunkSize, this.length);
3408        this.sendRequest(begin, end).catch(capability.reject);
3409      }
3410    }
3411
3412    return capability.promise.catch(reason => {
3413      if (this.aborted) {
3414        return;
3415      }
3416
3417      throw reason;
3418    });
3419  }
3420
3421  getStream() {
3422    return this.stream;
3423  }
3424
3425  requestRange(begin, end) {
3426    end = Math.min(end, this.length);
3427    const beginChunk = this.getBeginChunk(begin);
3428    const endChunk = this.getEndChunk(end);
3429    const chunks = [];
3430
3431    for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
3432      chunks.push(chunk);
3433    }
3434
3435    return this._requestChunks(chunks);
3436  }
3437
3438  requestRanges(ranges = []) {
3439    const chunksToRequest = [];
3440
3441    for (const range of ranges) {
3442      const beginChunk = this.getBeginChunk(range.begin);
3443      const endChunk = this.getEndChunk(range.end);
3444
3445      for (let chunk = beginChunk; chunk < endChunk; ++chunk) {
3446        if (!chunksToRequest.includes(chunk)) {
3447          chunksToRequest.push(chunk);
3448        }
3449      }
3450    }
3451
3452    chunksToRequest.sort(function (a, b) {
3453      return a - b;
3454    });
3455    return this._requestChunks(chunksToRequest);
3456  }
3457
3458  groupChunks(chunks) {
3459    const groupedChunks = [];
3460    let beginChunk = -1;
3461    let prevChunk = -1;
3462
3463    for (let i = 0, ii = chunks.length; i < ii; ++i) {
3464      const chunk = chunks[i];
3465
3466      if (beginChunk < 0) {
3467        beginChunk = chunk;
3468      }
3469
3470      if (prevChunk >= 0 && prevChunk + 1 !== chunk) {
3471        groupedChunks.push({
3472          beginChunk,
3473          endChunk: prevChunk + 1
3474        });
3475        beginChunk = chunk;
3476      }
3477
3478      if (i + 1 === chunks.length) {
3479        groupedChunks.push({
3480          beginChunk,
3481          endChunk: chunk + 1
3482        });
3483      }
3484
3485      prevChunk = chunk;
3486    }
3487
3488    return groupedChunks;
3489  }
3490
3491  onProgress(args) {
3492    this.msgHandler.send("DocProgress", {
3493      loaded: this.stream.numChunksLoaded * this.chunkSize + args.loaded,
3494      total: this.length
3495    });
3496  }
3497
3498  onReceiveData(args) {
3499    const chunk = args.chunk;
3500    const isProgressive = args.begin === undefined;
3501    const begin = isProgressive ? this.progressiveDataLength : args.begin;
3502    const end = begin + chunk.byteLength;
3503    const beginChunk = Math.floor(begin / this.chunkSize);
3504    const endChunk = end < this.length ? Math.floor(end / this.chunkSize) : Math.ceil(end / this.chunkSize);
3505
3506    if (isProgressive) {
3507      this.stream.onReceiveProgressiveData(chunk);
3508      this.progressiveDataLength = end;
3509    } else {
3510      this.stream.onReceiveData(begin, chunk);
3511    }
3512
3513    if (this.stream.isDataLoaded) {
3514      this._loadedStreamCapability.resolve(this.stream);
3515    }
3516
3517    const loadedRequests = [];
3518
3519    for (let curChunk = beginChunk; curChunk < endChunk; ++curChunk) {
3520      const requestIds = this._requestsByChunk.get(curChunk);
3521
3522      if (!requestIds) {
3523        continue;
3524      }
3525
3526      this._requestsByChunk.delete(curChunk);
3527
3528      for (const requestId of requestIds) {
3529        const chunksNeeded = this._chunksNeededByRequest.get(requestId);
3530
3531        if (chunksNeeded.has(curChunk)) {
3532          chunksNeeded.delete(curChunk);
3533        }
3534
3535        if (chunksNeeded.size > 0) {
3536          continue;
3537        }
3538
3539        loadedRequests.push(requestId);
3540      }
3541    }
3542
3543    if (!this.disableAutoFetch && this._requestsByChunk.size === 0) {
3544      let nextEmptyChunk;
3545
3546      if (this.stream.numChunksLoaded === 1) {
3547        const lastChunk = this.stream.numChunks - 1;
3548
3549        if (!this.stream.hasChunk(lastChunk)) {
3550          nextEmptyChunk = lastChunk;
3551        }
3552      } else {
3553        nextEmptyChunk = this.stream.nextEmptyChunk(endChunk);
3554      }
3555
3556      if (Number.isInteger(nextEmptyChunk)) {
3557        this._requestChunks([nextEmptyChunk]);
3558      }
3559    }
3560
3561    for (const requestId of loadedRequests) {
3562      const capability = this._promisesByRequest.get(requestId);
3563
3564      this._promisesByRequest.delete(requestId);
3565
3566      capability.resolve();
3567    }
3568
3569    this.msgHandler.send("DocProgress", {
3570      loaded: this.stream.numChunksLoaded * this.chunkSize,
3571      total: this.length
3572    });
3573  }
3574
3575  onError(err) {
3576    this._loadedStreamCapability.reject(err);
3577  }
3578
3579  getBeginChunk(begin) {
3580    return Math.floor(begin / this.chunkSize);
3581  }
3582
3583  getEndChunk(end) {
3584    return Math.floor((end - 1) / this.chunkSize) + 1;
3585  }
3586
3587  abort(reason) {
3588    this.aborted = true;
3589
3590    if (this.pdfNetworkStream) {
3591      this.pdfNetworkStream.cancelAllRequests(reason);
3592    }
3593
3594    for (const capability of this._promisesByRequest.values()) {
3595      capability.reject(reason);
3596    }
3597  }
3598
3599}
3600
3601exports.ChunkedStreamManager = ChunkedStreamManager;
3602
3603/***/ }),
3604/* 10 */
3605/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
3606
3607
3608
3609Object.defineProperty(exports, "__esModule", ({
3610  value: true
3611}));
3612exports.StringStream = exports.Stream = exports.NullStream = void 0;
3613
3614var _base_stream = __w_pdfjs_require__(7);
3615
3616var _util = __w_pdfjs_require__(2);
3617
3618class Stream extends _base_stream.BaseStream {
3619  constructor(arrayBuffer, start, length, dict) {
3620    super();
3621    this.bytes = arrayBuffer instanceof Uint8Array ? arrayBuffer : new Uint8Array(arrayBuffer);
3622    this.start = start || 0;
3623    this.pos = this.start;
3624    this.end = start + length || this.bytes.length;
3625    this.dict = dict;
3626  }
3627
3628  get length() {
3629    return this.end - this.start;
3630  }
3631
3632  get isEmpty() {
3633    return this.length === 0;
3634  }
3635
3636  getByte() {
3637    if (this.pos >= this.end) {
3638      return -1;
3639    }
3640
3641    return this.bytes[this.pos++];
3642  }
3643
3644  getBytes(length) {
3645    const bytes = this.bytes;
3646    const pos = this.pos;
3647    const strEnd = this.end;
3648
3649    if (!length) {
3650      return bytes.subarray(pos, strEnd);
3651    }
3652
3653    let end = pos + length;
3654
3655    if (end > strEnd) {
3656      end = strEnd;
3657    }
3658
3659    this.pos = end;
3660    return bytes.subarray(pos, end);
3661  }
3662
3663  getByteRange(begin, end) {
3664    if (begin < 0) {
3665      begin = 0;
3666    }
3667
3668    if (end > this.end) {
3669      end = this.end;
3670    }
3671
3672    return this.bytes.subarray(begin, end);
3673  }
3674
3675  reset() {
3676    this.pos = this.start;
3677  }
3678
3679  moveStart() {
3680    this.start = this.pos;
3681  }
3682
3683  makeSubStream(start, length, dict = null) {
3684    return new Stream(this.bytes.buffer, start, length, dict);
3685  }
3686
3687}
3688
3689exports.Stream = Stream;
3690
3691class StringStream extends Stream {
3692  constructor(str) {
3693    super((0, _util.stringToBytes)(str));
3694  }
3695
3696}
3697
3698exports.StringStream = StringStream;
3699
3700class NullStream extends Stream {
3701  constructor() {
3702    super(new Uint8Array(0));
3703  }
3704
3705}
3706
3707exports.NullStream = NullStream;
3708
3709/***/ }),
3710/* 11 */
3711/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
3712
3713
3714
3715Object.defineProperty(exports, "__esModule", ({
3716  value: true
3717}));
3718exports.Page = exports.PDFDocument = void 0;
3719
3720var _annotation = __w_pdfjs_require__(12);
3721
3722var _util = __w_pdfjs_require__(2);
3723
3724var _core_utils = __w_pdfjs_require__(6);
3725
3726var _primitives = __w_pdfjs_require__(5);
3727
3728var _xfa_fonts = __w_pdfjs_require__(51);
3729
3730var _base_stream = __w_pdfjs_require__(7);
3731
3732var _crypto = __w_pdfjs_require__(67);
3733
3734var _catalog = __w_pdfjs_require__(69);
3735
3736var _cleanup_helper = __w_pdfjs_require__(71);
3737
3738var _dataset_reader = __w_pdfjs_require__(100);
3739
3740var _parser = __w_pdfjs_require__(17);
3741
3742var _stream = __w_pdfjs_require__(10);
3743
3744var _object_loader = __w_pdfjs_require__(75);
3745
3746var _operator_list = __w_pdfjs_require__(62);
3747
3748var _evaluator = __w_pdfjs_require__(15);
3749
3750var _decode_stream = __w_pdfjs_require__(19);
3751
3752var _struct_tree = __w_pdfjs_require__(74);
3753
3754var _writer = __w_pdfjs_require__(65);
3755
3756var _factory = __w_pdfjs_require__(76);
3757
3758var _xref = __w_pdfjs_require__(101);
3759
3760const DEFAULT_USER_UNIT = 1.0;
3761const LETTER_SIZE_MEDIABOX = [0, 0, 612, 792];
3762
3763class Page {
3764  constructor({
3765    pdfManager,
3766    xref,
3767    pageIndex,
3768    pageDict,
3769    ref,
3770    globalIdFactory,
3771    fontCache,
3772    builtInCMapCache,
3773    standardFontDataCache,
3774    globalImageCache,
3775    nonBlendModesSet,
3776    xfaFactory
3777  }) {
3778    this.pdfManager = pdfManager;
3779    this.pageIndex = pageIndex;
3780    this.pageDict = pageDict;
3781    this.xref = xref;
3782    this.ref = ref;
3783    this.fontCache = fontCache;
3784    this.builtInCMapCache = builtInCMapCache;
3785    this.standardFontDataCache = standardFontDataCache;
3786    this.globalImageCache = globalImageCache;
3787    this.nonBlendModesSet = nonBlendModesSet;
3788    this.evaluatorOptions = pdfManager.evaluatorOptions;
3789    this.resourcesPromise = null;
3790    this.xfaFactory = xfaFactory;
3791    const idCounters = {
3792      obj: 0
3793    };
3794    this._localIdFactory = class extends globalIdFactory {
3795      static createObjId() {
3796        return `p${pageIndex}_${++idCounters.obj}`;
3797      }
3798
3799      static getPageObjId() {
3800        return `page${ref.toString()}`;
3801      }
3802
3803    };
3804  }
3805
3806  _getInheritableProperty(key, getArray = false) {
3807    const value = (0, _core_utils.getInheritableProperty)({
3808      dict: this.pageDict,
3809      key,
3810      getArray,
3811      stopWhenFound: false
3812    });
3813
3814    if (!Array.isArray(value)) {
3815      return value;
3816    }
3817
3818    if (value.length === 1 || !(value[0] instanceof _primitives.Dict)) {
3819      return value[0];
3820    }
3821
3822    return _primitives.Dict.merge({
3823      xref: this.xref,
3824      dictArray: value
3825    });
3826  }
3827
3828  get content() {
3829    return this.pageDict.getArray("Contents");
3830  }
3831
3832  get resources() {
3833    const resources = this._getInheritableProperty("Resources");
3834
3835    return (0, _util.shadow)(this, "resources", resources instanceof _primitives.Dict ? resources : _primitives.Dict.empty);
3836  }
3837
3838  _getBoundingBox(name) {
3839    if (this.xfaData) {
3840      return this.xfaData.bbox;
3841    }
3842
3843    const box = this._getInheritableProperty(name, true);
3844
3845    if (Array.isArray(box) && box.length === 4) {
3846      if (box[2] - box[0] !== 0 && box[3] - box[1] !== 0) {
3847        return box;
3848      }
3849
3850      (0, _util.warn)(`Empty /${name} entry.`);
3851    }
3852
3853    return null;
3854  }
3855
3856  get mediaBox() {
3857    return (0, _util.shadow)(this, "mediaBox", this._getBoundingBox("MediaBox") || LETTER_SIZE_MEDIABOX);
3858  }
3859
3860  get cropBox() {
3861    return (0, _util.shadow)(this, "cropBox", this._getBoundingBox("CropBox") || this.mediaBox);
3862  }
3863
3864  get userUnit() {
3865    let obj = this.pageDict.get("UserUnit");
3866
3867    if (typeof obj !== "number" || obj <= 0) {
3868      obj = DEFAULT_USER_UNIT;
3869    }
3870
3871    return (0, _util.shadow)(this, "userUnit", obj);
3872  }
3873
3874  get view() {
3875    const {
3876      cropBox,
3877      mediaBox
3878    } = this;
3879    let view;
3880
3881    if (cropBox === mediaBox || (0, _util.isArrayEqual)(cropBox, mediaBox)) {
3882      view = mediaBox;
3883    } else {
3884      const box = _util.Util.intersect(cropBox, mediaBox);
3885
3886      if (box && box[2] - box[0] !== 0 && box[3] - box[1] !== 0) {
3887        view = box;
3888      } else {
3889        (0, _util.warn)("Empty /CropBox and /MediaBox intersection.");
3890      }
3891    }
3892
3893    return (0, _util.shadow)(this, "view", view || mediaBox);
3894  }
3895
3896  get rotate() {
3897    let rotate = this._getInheritableProperty("Rotate") || 0;
3898
3899    if (rotate % 90 !== 0) {
3900      rotate = 0;
3901    } else if (rotate >= 360) {
3902      rotate %= 360;
3903    } else if (rotate < 0) {
3904      rotate = (rotate % 360 + 360) % 360;
3905    }
3906
3907    return (0, _util.shadow)(this, "rotate", rotate);
3908  }
3909
3910  _onSubStreamError(handler, reason, objId) {
3911    if (this.evaluatorOptions.ignoreErrors) {
3912      handler.send("UnsupportedFeature", {
3913        featureId: _util.UNSUPPORTED_FEATURES.errorContentSubStream
3914      });
3915      (0, _util.warn)(`getContentStream - ignoring sub-stream (${objId}): "${reason}".`);
3916      return;
3917    }
3918
3919    throw reason;
3920  }
3921
3922  getContentStream(handler) {
3923    return this.pdfManager.ensure(this, "content").then(content => {
3924      if (content instanceof _base_stream.BaseStream) {
3925        return content;
3926      }
3927
3928      if (Array.isArray(content)) {
3929        return new _decode_stream.StreamsSequenceStream(content, this._onSubStreamError.bind(this, handler));
3930      }
3931
3932      return new _stream.NullStream();
3933    });
3934  }
3935
3936  get xfaData() {
3937    return (0, _util.shadow)(this, "xfaData", this.xfaFactory ? {
3938      bbox: this.xfaFactory.getBoundingBox(this.pageIndex)
3939    } : null);
3940  }
3941
3942  async saveNewAnnotations(handler, task, annotations) {
3943    if (this.xfaFactory) {
3944      throw new Error("XFA: Cannot save new annotations.");
3945    }
3946
3947    const partialEvaluator = new _evaluator.PartialEvaluator({
3948      xref: this.xref,
3949      handler,
3950      pageIndex: this.pageIndex,
3951      idFactory: this._localIdFactory,
3952      fontCache: this.fontCache,
3953      builtInCMapCache: this.builtInCMapCache,
3954      standardFontDataCache: this.standardFontDataCache,
3955      globalImageCache: this.globalImageCache,
3956      options: this.evaluatorOptions
3957    });
3958    const pageDict = this.pageDict;
3959    const annotationsArray = this.annotations.slice();
3960    const newData = await _annotation.AnnotationFactory.saveNewAnnotations(partialEvaluator, task, annotations);
3961
3962    for (const {
3963      ref
3964    } of newData.annotations) {
3965      annotationsArray.push(ref);
3966    }
3967
3968    const savedDict = pageDict.get("Annots");
3969    pageDict.set("Annots", annotationsArray);
3970    const buffer = [];
3971    let transform = null;
3972
3973    if (this.xref.encrypt) {
3974      transform = this.xref.encrypt.createCipherTransform(this.ref.num, this.ref.gen);
3975    }
3976
3977    (0, _writer.writeObject)(this.ref, pageDict, buffer, transform);
3978
3979    if (savedDict) {
3980      pageDict.set("Annots", savedDict);
3981    }
3982
3983    const objects = newData.dependencies;
3984    objects.push({
3985      ref: this.ref,
3986      data: buffer.join("")
3987    }, ...newData.annotations);
3988    return objects;
3989  }
3990
3991  save(handler, task, annotationStorage) {
3992    const partialEvaluator = new _evaluator.PartialEvaluator({
3993      xref: this.xref,
3994      handler,
3995      pageIndex: this.pageIndex,
3996      idFactory: this._localIdFactory,
3997      fontCache: this.fontCache,
3998      builtInCMapCache: this.builtInCMapCache,
3999      standardFontDataCache: this.standardFontDataCache,
4000      globalImageCache: this.globalImageCache,
4001      options: this.evaluatorOptions
4002    });
4003    return this._parsedAnnotations.then(function (annotations) {
4004      const newRefsPromises = [];
4005
4006      for (const annotation of annotations) {
4007        if (!annotation.mustBePrinted(annotationStorage)) {
4008          continue;
4009        }
4010
4011        newRefsPromises.push(annotation.save(partialEvaluator, task, annotationStorage).catch(function (reason) {
4012          (0, _util.warn)("save - ignoring annotation data during " + `"${task.name}" task: "${reason}".`);
4013          return null;
4014        }));
4015      }
4016
4017      return Promise.all(newRefsPromises).then(function (newRefs) {
4018        return newRefs.filter(newRef => !!newRef);
4019      });
4020    });
4021  }
4022
4023  loadResources(keys) {
4024    if (!this.resourcesPromise) {
4025      this.resourcesPromise = this.pdfManager.ensure(this, "resources");
4026    }
4027
4028    return this.resourcesPromise.then(() => {
4029      const objectLoader = new _object_loader.ObjectLoader(this.resources, keys, this.xref);
4030      return objectLoader.load();
4031    });
4032  }
4033
4034  getOperatorList({
4035    handler,
4036    sink,
4037    task,
4038    intent,
4039    cacheKey,
4040    annotationStorage = null
4041  }) {
4042    const contentStreamPromise = this.getContentStream(handler);
4043    const resourcesPromise = this.loadResources(["ColorSpace", "ExtGState", "Font", "Pattern", "Properties", "Shading", "XObject"]);
4044    const partialEvaluator = new _evaluator.PartialEvaluator({
4045      xref: this.xref,
4046      handler,
4047      pageIndex: this.pageIndex,
4048      idFactory: this._localIdFactory,
4049      fontCache: this.fontCache,
4050      builtInCMapCache: this.builtInCMapCache,
4051      standardFontDataCache: this.standardFontDataCache,
4052      globalImageCache: this.globalImageCache,
4053      options: this.evaluatorOptions
4054    });
4055    const newAnnotationsByPage = !this.xfaFactory ? (0, _core_utils.getNewAnnotationsMap)(annotationStorage) : null;
4056    let newAnnotationsPromise = Promise.resolve(null);
4057
4058    if (newAnnotationsByPage) {
4059      const newAnnotations = newAnnotationsByPage.get(this.pageIndex);
4060
4061      if (newAnnotations) {
4062        newAnnotationsPromise = _annotation.AnnotationFactory.printNewAnnotations(partialEvaluator, task, newAnnotations);
4063      }
4064    }
4065
4066    const dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
4067    const pageListPromise = dataPromises.then(([contentStream]) => {
4068      const opList = new _operator_list.OperatorList(intent, sink);
4069      handler.send("StartRenderPage", {
4070        transparency: partialEvaluator.hasBlendModes(this.resources, this.nonBlendModesSet),
4071        pageIndex: this.pageIndex,
4072        cacheKey
4073      });
4074      return partialEvaluator.getOperatorList({
4075        stream: contentStream,
4076        task,
4077        resources: this.resources,
4078        operatorList: opList
4079      }).then(function () {
4080        return opList;
4081      });
4082    });
4083    return Promise.all([pageListPromise, this._parsedAnnotations, newAnnotationsPromise]).then(function ([pageOpList, annotations, newAnnotations]) {
4084      if (newAnnotations) {
4085        annotations = annotations.concat(newAnnotations);
4086      }
4087
4088      if (annotations.length === 0 || intent & _util.RenderingIntentFlag.ANNOTATIONS_DISABLE) {
4089        pageOpList.flush(true);
4090        return {
4091          length: pageOpList.totalLength
4092        };
4093      }
4094
4095      const renderForms = !!(intent & _util.RenderingIntentFlag.ANNOTATIONS_FORMS),
4096            intentAny = !!(intent & _util.RenderingIntentFlag.ANY),
4097            intentDisplay = !!(intent & _util.RenderingIntentFlag.DISPLAY),
4098            intentPrint = !!(intent & _util.RenderingIntentFlag.PRINT);
4099      const opListPromises = [];
4100
4101      for (const annotation of annotations) {
4102        if (intentAny || intentDisplay && annotation.mustBeViewed(annotationStorage) || intentPrint && annotation.mustBePrinted(annotationStorage)) {
4103          opListPromises.push(annotation.getOperatorList(partialEvaluator, task, intent, renderForms, annotationStorage).catch(function (reason) {
4104            (0, _util.warn)("getOperatorList - ignoring annotation data during " + `"${task.name}" task: "${reason}".`);
4105            return null;
4106          }));
4107        }
4108      }
4109
4110      return Promise.all(opListPromises).then(function (opLists) {
4111        let form = false,
4112            canvas = false;
4113
4114        for (const {
4115          opList,
4116          separateForm,
4117          separateCanvas
4118        } of opLists) {
4119          pageOpList.addOpList(opList);
4120
4121          if (separateForm) {
4122            form = separateForm;
4123          }
4124
4125          if (separateCanvas) {
4126            canvas = separateCanvas;
4127          }
4128        }
4129
4130        pageOpList.flush(true, {
4131          form,
4132          canvas
4133        });
4134        return {
4135          length: pageOpList.totalLength
4136        };
4137      });
4138    });
4139  }
4140
4141  extractTextContent({
4142    handler,
4143    task,
4144    includeMarkedContent,
4145    sink,
4146    combineTextItems
4147  }) {
4148    const contentStreamPromise = this.getContentStream(handler);
4149    const resourcesPromise = this.loadResources(["ExtGState", "Font", "Properties", "XObject"]);
4150    const dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
4151    return dataPromises.then(([contentStream]) => {
4152      const partialEvaluator = new _evaluator.PartialEvaluator({
4153        xref: this.xref,
4154        handler,
4155        pageIndex: this.pageIndex,
4156        idFactory: this._localIdFactory,
4157        fontCache: this.fontCache,
4158        builtInCMapCache: this.builtInCMapCache,
4159        standardFontDataCache: this.standardFontDataCache,
4160        globalImageCache: this.globalImageCache,
4161        options: this.evaluatorOptions
4162      });
4163      return partialEvaluator.getTextContent({
4164        stream: contentStream,
4165        task,
4166        resources: this.resources,
4167        includeMarkedContent,
4168        combineTextItems,
4169        sink,
4170        viewBox: this.view
4171      });
4172    });
4173  }
4174
4175  async getStructTree() {
4176    const structTreeRoot = await this.pdfManager.ensureCatalog("structTreeRoot");
4177
4178    if (!structTreeRoot) {
4179      return null;
4180    }
4181
4182    const structTree = await this.pdfManager.ensure(this, "_parseStructTree", [structTreeRoot]);
4183    return structTree.serializable;
4184  }
4185
4186  _parseStructTree(structTreeRoot) {
4187    const tree = new _struct_tree.StructTreePage(structTreeRoot, this.pageDict);
4188    tree.parse();
4189    return tree;
4190  }
4191
4192  async getAnnotationsData(handler, task, intent) {
4193    const annotations = await this._parsedAnnotations;
4194
4195    if (annotations.length === 0) {
4196      return [];
4197    }
4198
4199    const textContentPromises = [];
4200    const annotationsData = [];
4201    let partialEvaluator;
4202    const intentAny = !!(intent & _util.RenderingIntentFlag.ANY),
4203          intentDisplay = !!(intent & _util.RenderingIntentFlag.DISPLAY),
4204          intentPrint = !!(intent & _util.RenderingIntentFlag.PRINT);
4205
4206    for (const annotation of annotations) {
4207      const isVisible = intentAny || intentDisplay && annotation.viewable;
4208
4209      if (isVisible || intentPrint && annotation.printable) {
4210        annotationsData.push(annotation.data);
4211      }
4212
4213      if (annotation.hasTextContent && isVisible) {
4214        if (!partialEvaluator) {
4215          partialEvaluator = new _evaluator.PartialEvaluator({
4216            xref: this.xref,
4217            handler,
4218            pageIndex: this.pageIndex,
4219            idFactory: this._localIdFactory,
4220            fontCache: this.fontCache,
4221            builtInCMapCache: this.builtInCMapCache,
4222            standardFontDataCache: this.standardFontDataCache,
4223            globalImageCache: this.globalImageCache,
4224            options: this.evaluatorOptions
4225          });
4226        }
4227
4228        textContentPromises.push(annotation.extractTextContent(partialEvaluator, task, this.view).catch(function (reason) {
4229          (0, _util.warn)(`getAnnotationsData - ignoring textContent during "${task.name}" task: "${reason}".`);
4230        }));
4231      }
4232    }
4233
4234    await Promise.all(textContentPromises);
4235    return annotationsData;
4236  }
4237
4238  get annotations() {
4239    const annots = this._getInheritableProperty("Annots");
4240
4241    return (0, _util.shadow)(this, "annotations", Array.isArray(annots) ? annots : []);
4242  }
4243
4244  get _parsedAnnotations() {
4245    const parsedAnnotations = this.pdfManager.ensure(this, "annotations").then(() => {
4246      const annotationPromises = [];
4247
4248      for (const annotationRef of this.annotations) {
4249        annotationPromises.push(_annotation.AnnotationFactory.create(this.xref, annotationRef, this.pdfManager, this._localIdFactory, false).catch(function (reason) {
4250          (0, _util.warn)(`_parsedAnnotations: "${reason}".`);
4251          return null;
4252        }));
4253      }
4254
4255      return Promise.all(annotationPromises).then(function (annotations) {
4256        if (annotations.length === 0) {
4257          return annotations;
4258        }
4259
4260        const sortedAnnotations = [];
4261        let popupAnnotations;
4262
4263        for (const annotation of annotations) {
4264          if (!annotation) {
4265            continue;
4266          }
4267
4268          if (annotation instanceof _annotation.PopupAnnotation) {
4269            if (!popupAnnotations) {
4270              popupAnnotations = [];
4271            }
4272
4273            popupAnnotations.push(annotation);
4274            continue;
4275          }
4276
4277          sortedAnnotations.push(annotation);
4278        }
4279
4280        if (popupAnnotations) {
4281          sortedAnnotations.push(...popupAnnotations);
4282        }
4283
4284        return sortedAnnotations;
4285      });
4286    });
4287    return (0, _util.shadow)(this, "_parsedAnnotations", parsedAnnotations);
4288  }
4289
4290  get jsActions() {
4291    const actions = (0, _core_utils.collectActions)(this.xref, this.pageDict, _util.PageActionEventType);
4292    return (0, _util.shadow)(this, "jsActions", actions);
4293  }
4294
4295}
4296
4297exports.Page = Page;
4298const PDF_HEADER_SIGNATURE = new Uint8Array([0x25, 0x50, 0x44, 0x46, 0x2d]);
4299const STARTXREF_SIGNATURE = new Uint8Array([0x73, 0x74, 0x61, 0x72, 0x74, 0x78, 0x72, 0x65, 0x66]);
4300const ENDOBJ_SIGNATURE = new Uint8Array([0x65, 0x6e, 0x64, 0x6f, 0x62, 0x6a]);
4301const FINGERPRINT_FIRST_BYTES = 1024;
4302const EMPTY_FINGERPRINT = "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
4303const PDF_HEADER_VERSION_REGEXP = /^[1-9]\.\d$/;
4304
4305function find(stream, signature, limit = 1024, backwards = false) {
4306  const signatureLength = signature.length;
4307  const scanBytes = stream.peekBytes(limit);
4308  const scanLength = scanBytes.length - signatureLength;
4309
4310  if (scanLength <= 0) {
4311    return false;
4312  }
4313
4314  if (backwards) {
4315    const signatureEnd = signatureLength - 1;
4316    let pos = scanBytes.length - 1;
4317
4318    while (pos >= signatureEnd) {
4319      let j = 0;
4320
4321      while (j < signatureLength && scanBytes[pos - j] === signature[signatureEnd - j]) {
4322        j++;
4323      }
4324
4325      if (j >= signatureLength) {
4326        stream.pos += pos - signatureEnd;
4327        return true;
4328      }
4329
4330      pos--;
4331    }
4332  } else {
4333    let pos = 0;
4334
4335    while (pos <= scanLength) {
4336      let j = 0;
4337
4338      while (j < signatureLength && scanBytes[pos + j] === signature[j]) {
4339        j++;
4340      }
4341
4342      if (j >= signatureLength) {
4343        stream.pos += pos;
4344        return true;
4345      }
4346
4347      pos++;
4348    }
4349  }
4350
4351  return false;
4352}
4353
4354class PDFDocument {
4355  constructor(pdfManager, stream) {
4356    if (stream.length <= 0) {
4357      throw new _util.InvalidPDFException("The PDF file is empty, i.e. its size is zero bytes.");
4358    }
4359
4360    this.pdfManager = pdfManager;
4361    this.stream = stream;
4362    this.xref = new _xref.XRef(stream, pdfManager);
4363    this._pagePromises = new Map();
4364    this._version = null;
4365    const idCounters = {
4366      font: 0
4367    };
4368    this._globalIdFactory = class {
4369      static getDocId() {
4370        return `g_${pdfManager.docId}`;
4371      }
4372
4373      static createFontId() {
4374        return `f${++idCounters.font}`;
4375      }
4376
4377      static createObjId() {
4378        (0, _util.unreachable)("Abstract method `createObjId` called.");
4379      }
4380
4381      static getPageObjId() {
4382        (0, _util.unreachable)("Abstract method `getPageObjId` called.");
4383      }
4384
4385    };
4386  }
4387
4388  parse(recoveryMode) {
4389    this.xref.parse(recoveryMode);
4390    this.catalog = new _catalog.Catalog(this.pdfManager, this.xref);
4391
4392    if (this.catalog.version) {
4393      this._version = this.catalog.version;
4394    }
4395  }
4396
4397  get linearization() {
4398    let linearization = null;
4399
4400    try {
4401      linearization = _parser.Linearization.create(this.stream);
4402    } catch (err) {
4403      if (err instanceof _core_utils.MissingDataException) {
4404        throw err;
4405      }
4406
4407      (0, _util.info)(err);
4408    }
4409
4410    return (0, _util.shadow)(this, "linearization", linearization);
4411  }
4412
4413  get startXRef() {
4414    const stream = this.stream;
4415    let startXRef = 0;
4416
4417    if (this.linearization) {
4418      stream.reset();
4419
4420      if (find(stream, ENDOBJ_SIGNATURE)) {
4421        startXRef = stream.pos + 6 - stream.start;
4422      }
4423    } else {
4424      const step = 1024;
4425      const startXRefLength = STARTXREF_SIGNATURE.length;
4426      let found = false,
4427          pos = stream.end;
4428
4429      while (!found && pos > 0) {
4430        pos -= step - startXRefLength;
4431
4432        if (pos < 0) {
4433          pos = 0;
4434        }
4435
4436        stream.pos = pos;
4437        found = find(stream, STARTXREF_SIGNATURE, step, true);
4438      }
4439
4440      if (found) {
4441        stream.skip(9);
4442        let ch;
4443
4444        do {
4445          ch = stream.getByte();
4446        } while ((0, _core_utils.isWhiteSpace)(ch));
4447
4448        let str = "";
4449
4450        while (ch >= 0x20 && ch <= 0x39) {
4451          str += String.fromCharCode(ch);
4452          ch = stream.getByte();
4453        }
4454
4455        startXRef = parseInt(str, 10);
4456
4457        if (isNaN(startXRef)) {
4458          startXRef = 0;
4459        }
4460      }
4461    }
4462
4463    return (0, _util.shadow)(this, "startXRef", startXRef);
4464  }
4465
4466  checkHeader() {
4467    const stream = this.stream;
4468    stream.reset();
4469
4470    if (!find(stream, PDF_HEADER_SIGNATURE)) {
4471      return;
4472    }
4473
4474    stream.moveStart();
4475    const MAX_PDF_VERSION_LENGTH = 12;
4476    let version = "",
4477        ch;
4478
4479    while ((ch = stream.getByte()) > 0x20) {
4480      if (version.length >= MAX_PDF_VERSION_LENGTH) {
4481        break;
4482      }
4483
4484      version += String.fromCharCode(ch);
4485    }
4486
4487    if (!this._version) {
4488      this._version = version.substring(5);
4489    }
4490  }
4491
4492  parseStartXRef() {
4493    this.xref.setStartXRef(this.startXRef);
4494  }
4495
4496  get numPages() {
4497    let num = 0;
4498
4499    if (this.catalog.hasActualNumPages) {
4500      num = this.catalog.numPages;
4501    } else if (this.xfaFactory) {
4502      num = this.xfaFactory.getNumPages();
4503    } else if (this.linearization) {
4504      num = this.linearization.numPages;
4505    } else {
4506      num = this.catalog.numPages;
4507    }
4508
4509    return (0, _util.shadow)(this, "numPages", num);
4510  }
4511
4512  _hasOnlyDocumentSignatures(fields, recursionDepth = 0) {
4513    const RECURSION_LIMIT = 10;
4514
4515    if (!Array.isArray(fields)) {
4516      return false;
4517    }
4518
4519    return fields.every(field => {
4520      field = this.xref.fetchIfRef(field);
4521
4522      if (!(field instanceof _primitives.Dict)) {
4523        return false;
4524      }
4525
4526      if (field.has("Kids")) {
4527        if (++recursionDepth > RECURSION_LIMIT) {
4528          (0, _util.warn)("_hasOnlyDocumentSignatures: maximum recursion depth reached");
4529          return false;
4530        }
4531
4532        return this._hasOnlyDocumentSignatures(field.get("Kids"), recursionDepth);
4533      }
4534
4535      const isSignature = (0, _primitives.isName)(field.get("FT"), "Sig");
4536      const rectangle = field.get("Rect");
4537      const isInvisible = Array.isArray(rectangle) && rectangle.every(value => value === 0);
4538      return isSignature && isInvisible;
4539    });
4540  }
4541
4542  get _xfaStreams() {
4543    const acroForm = this.catalog.acroForm;
4544
4545    if (!acroForm) {
4546      return null;
4547    }
4548
4549    const xfa = acroForm.get("XFA");
4550    const entries = {
4551      "xdp:xdp": "",
4552      template: "",
4553      datasets: "",
4554      config: "",
4555      connectionSet: "",
4556      localeSet: "",
4557      stylesheet: "",
4558      "/xdp:xdp": ""
4559    };
4560
4561    if (xfa instanceof _base_stream.BaseStream && !xfa.isEmpty) {
4562      entries["xdp:xdp"] = xfa;
4563      return entries;
4564    }
4565
4566    if (!Array.isArray(xfa) || xfa.length === 0) {
4567      return null;
4568    }
4569
4570    for (let i = 0, ii = xfa.length; i < ii; i += 2) {
4571      let name;
4572
4573      if (i === 0) {
4574        name = "xdp:xdp";
4575      } else if (i === ii - 2) {
4576        name = "/xdp:xdp";
4577      } else {
4578        name = xfa[i];
4579      }
4580
4581      if (!entries.hasOwnProperty(name)) {
4582        continue;
4583      }
4584
4585      const data = this.xref.fetchIfRef(xfa[i + 1]);
4586
4587      if (!(data instanceof _base_stream.BaseStream) || data.isEmpty) {
4588        continue;
4589      }
4590
4591      entries[name] = data;
4592    }
4593
4594    return entries;
4595  }
4596
4597  get xfaDatasets() {
4598    const streams = this._xfaStreams;
4599
4600    if (!streams) {
4601      return (0, _util.shadow)(this, "xfaDatasets", null);
4602    }
4603
4604    for (const key of ["datasets", "xdp:xdp"]) {
4605      const stream = streams[key];
4606
4607      if (!stream) {
4608        continue;
4609      }
4610
4611      try {
4612        const str = (0, _util.stringToUTF8String)(stream.getString());
4613        const data = {
4614          [key]: str
4615        };
4616        return (0, _util.shadow)(this, "xfaDatasets", new _dataset_reader.DatasetReader(data));
4617      } catch (_) {
4618        (0, _util.warn)("XFA - Invalid utf-8 string.");
4619        break;
4620      }
4621    }
4622
4623    return (0, _util.shadow)(this, "xfaDatasets", null);
4624  }
4625
4626  get xfaData() {
4627    const streams = this._xfaStreams;
4628
4629    if (!streams) {
4630      return null;
4631    }
4632
4633    const data = Object.create(null);
4634
4635    for (const [key, stream] of Object.entries(streams)) {
4636      if (!stream) {
4637        continue;
4638      }
4639
4640      try {
4641        data[key] = (0, _util.stringToUTF8String)(stream.getString());
4642      } catch (_) {
4643        (0, _util.warn)("XFA - Invalid utf-8 string.");
4644        return null;
4645      }
4646    }
4647
4648    return data;
4649  }
4650
4651  get xfaFactory() {
4652    let data;
4653
4654    if (this.pdfManager.enableXfa && this.catalog.needsRendering && this.formInfo.hasXfa && !this.formInfo.hasAcroForm) {
4655      data = this.xfaData;
4656    }
4657
4658    return (0, _util.shadow)(this, "xfaFactory", data ? new _factory.XFAFactory(data) : null);
4659  }
4660
4661  get isPureXfa() {
4662    return this.xfaFactory ? this.xfaFactory.isValid() : false;
4663  }
4664
4665  get htmlForXfa() {
4666    return this.xfaFactory ? this.xfaFactory.getPages() : null;
4667  }
4668
4669  async loadXfaImages() {
4670    const xfaImagesDict = await this.pdfManager.ensureCatalog("xfaImages");
4671
4672    if (!xfaImagesDict) {
4673      return;
4674    }
4675
4676    const keys = xfaImagesDict.getKeys();
4677    const objectLoader = new _object_loader.ObjectLoader(xfaImagesDict, keys, this.xref);
4678    await objectLoader.load();
4679    const xfaImages = new Map();
4680
4681    for (const key of keys) {
4682      const stream = xfaImagesDict.get(key);
4683
4684      if (stream instanceof _base_stream.BaseStream) {
4685        xfaImages.set(key, stream.getBytes());
4686      }
4687    }
4688
4689    this.xfaFactory.setImages(xfaImages);
4690  }
4691
4692  async loadXfaFonts(handler, task) {
4693    const acroForm = await this.pdfManager.ensureCatalog("acroForm");
4694
4695    if (!acroForm) {
4696      return;
4697    }
4698
4699    const resources = await acroForm.getAsync("DR");
4700
4701    if (!(resources instanceof _primitives.Dict)) {
4702      return;
4703    }
4704
4705    const objectLoader = new _object_loader.ObjectLoader(resources, ["Font"], this.xref);
4706    await objectLoader.load();
4707    const fontRes = resources.get("Font");
4708
4709    if (!(fontRes instanceof _primitives.Dict)) {
4710      return;
4711    }
4712
4713    const options = Object.assign(Object.create(null), this.pdfManager.evaluatorOptions);
4714    options.useSystemFonts = false;
4715    const partialEvaluator = new _evaluator.PartialEvaluator({
4716      xref: this.xref,
4717      handler,
4718      pageIndex: -1,
4719      idFactory: this._globalIdFactory,
4720      fontCache: this.catalog.fontCache,
4721      builtInCMapCache: this.catalog.builtInCMapCache,
4722      standardFontDataCache: this.catalog.standardFontDataCache,
4723      options
4724    });
4725    const operatorList = new _operator_list.OperatorList();
4726    const pdfFonts = [];
4727    const initialState = {
4728      get font() {
4729        return pdfFonts.at(-1);
4730      },
4731
4732      set font(font) {
4733        pdfFonts.push(font);
4734      },
4735
4736      clone() {
4737        return this;
4738      }
4739
4740    };
4741    const fonts = new Map();
4742    fontRes.forEach((fontName, font) => {
4743      fonts.set(fontName, font);
4744    });
4745    const promises = [];
4746
4747    for (const [fontName, font] of fonts) {
4748      const descriptor = font.get("FontDescriptor");
4749
4750      if (!(descriptor instanceof _primitives.Dict)) {
4751        continue;
4752      }
4753
4754      let fontFamily = descriptor.get("FontFamily");
4755      fontFamily = fontFamily.replace(/[ ]+(\d)/g, "$1");
4756      const fontWeight = descriptor.get("FontWeight");
4757      const italicAngle = -descriptor.get("ItalicAngle");
4758      const cssFontInfo = {
4759        fontFamily,
4760        fontWeight,
4761        italicAngle
4762      };
4763
4764      if (!(0, _core_utils.validateCSSFont)(cssFontInfo)) {
4765        continue;
4766      }
4767
4768      promises.push(partialEvaluator.handleSetFont(resources, [_primitives.Name.get(fontName), 1], null, operatorList, task, initialState, null, cssFontInfo).catch(function (reason) {
4769        (0, _util.warn)(`loadXfaFonts: "${reason}".`);
4770        return null;
4771      }));
4772    }
4773
4774    await Promise.all(promises);
4775    const missingFonts = this.xfaFactory.setFonts(pdfFonts);
4776
4777    if (!missingFonts) {
4778      return;
4779    }
4780
4781    options.ignoreErrors = true;
4782    promises.length = 0;
4783    pdfFonts.length = 0;
4784    const reallyMissingFonts = new Set();
4785
4786    for (const missing of missingFonts) {
4787      if (!(0, _xfa_fonts.getXfaFontName)(`${missing}-Regular`)) {
4788        reallyMissingFonts.add(missing);
4789      }
4790    }
4791
4792    if (reallyMissingFonts.size) {
4793      missingFonts.push("PdfJS-Fallback");
4794    }
4795
4796    for (const missing of missingFonts) {
4797      if (reallyMissingFonts.has(missing)) {
4798        continue;
4799      }
4800
4801      for (const fontInfo of [{
4802        name: "Regular",
4803        fontWeight: 400,
4804        italicAngle: 0
4805      }, {
4806        name: "Bold",
4807        fontWeight: 700,
4808        italicAngle: 0
4809      }, {
4810        name: "Italic",
4811        fontWeight: 400,
4812        italicAngle: 12
4813      }, {
4814        name: "BoldItalic",
4815        fontWeight: 700,
4816        italicAngle: 12
4817      }]) {
4818        const name = `${missing}-${fontInfo.name}`;
4819        const dict = (0, _xfa_fonts.getXfaFontDict)(name);
4820        promises.push(partialEvaluator.handleSetFont(resources, [_primitives.Name.get(name), 1], null, operatorList, task, initialState, dict, {
4821          fontFamily: missing,
4822          fontWeight: fontInfo.fontWeight,
4823          italicAngle: fontInfo.italicAngle
4824        }).catch(function (reason) {
4825          (0, _util.warn)(`loadXfaFonts: "${reason}".`);
4826          return null;
4827        }));
4828      }
4829    }
4830
4831    await Promise.all(promises);
4832    this.xfaFactory.appendFonts(pdfFonts, reallyMissingFonts);
4833  }
4834
4835  async serializeXfaData(annotationStorage) {
4836    return this.xfaFactory ? this.xfaFactory.serializeData(annotationStorage) : null;
4837  }
4838
4839  get formInfo() {
4840    const formInfo = {
4841      hasFields: false,
4842      hasAcroForm: false,
4843      hasXfa: false,
4844      hasSignatures: false
4845    };
4846    const acroForm = this.catalog.acroForm;
4847
4848    if (!acroForm) {
4849      return (0, _util.shadow)(this, "formInfo", formInfo);
4850    }
4851
4852    try {
4853      const fields = acroForm.get("Fields");
4854      const hasFields = Array.isArray(fields) && fields.length > 0;
4855      formInfo.hasFields = hasFields;
4856      const xfa = acroForm.get("XFA");
4857      formInfo.hasXfa = Array.isArray(xfa) && xfa.length > 0 || xfa instanceof _base_stream.BaseStream && !xfa.isEmpty;
4858      const sigFlags = acroForm.get("SigFlags");
4859      const hasSignatures = !!(sigFlags & 0x1);
4860
4861      const hasOnlyDocumentSignatures = hasSignatures && this._hasOnlyDocumentSignatures(fields);
4862
4863      formInfo.hasAcroForm = hasFields && !hasOnlyDocumentSignatures;
4864      formInfo.hasSignatures = hasSignatures;
4865    } catch (ex) {
4866      if (ex instanceof _core_utils.MissingDataException) {
4867        throw ex;
4868      }
4869
4870      (0, _util.warn)(`Cannot fetch form information: "${ex}".`);
4871    }
4872
4873    return (0, _util.shadow)(this, "formInfo", formInfo);
4874  }
4875
4876  get documentInfo() {
4877    let version = this._version;
4878
4879    if (typeof version !== "string" || !PDF_HEADER_VERSION_REGEXP.test(version)) {
4880      (0, _util.warn)(`Invalid PDF header version number: ${version}`);
4881      version = null;
4882    }
4883
4884    const docInfo = {
4885      PDFFormatVersion: version,
4886      Language: this.catalog.lang,
4887      EncryptFilterName: this.xref.encrypt ? this.xref.encrypt.filterName : null,
4888      IsLinearized: !!this.linearization,
4889      IsAcroFormPresent: this.formInfo.hasAcroForm,
4890      IsXFAPresent: this.formInfo.hasXfa,
4891      IsCollectionPresent: !!this.catalog.collection,
4892      IsSignaturesPresent: this.formInfo.hasSignatures
4893    };
4894    let infoDict;
4895
4896    try {
4897      infoDict = this.xref.trailer.get("Info");
4898    } catch (err) {
4899      if (err instanceof _core_utils.MissingDataException) {
4900        throw err;
4901      }
4902
4903      (0, _util.info)("The document information dictionary is invalid.");
4904    }
4905
4906    if (!(infoDict instanceof _primitives.Dict)) {
4907      return (0, _util.shadow)(this, "documentInfo", docInfo);
4908    }
4909
4910    for (const key of infoDict.getKeys()) {
4911      const value = infoDict.get(key);
4912
4913      switch (key) {
4914        case "Title":
4915        case "Author":
4916        case "Subject":
4917        case "Keywords":
4918        case "Creator":
4919        case "Producer":
4920        case "CreationDate":
4921        case "ModDate":
4922          if (typeof value === "string") {
4923            docInfo[key] = (0, _util.stringToPDFString)(value);
4924            continue;
4925          }
4926
4927          break;
4928
4929        case "Trapped":
4930          if (value instanceof _primitives.Name) {
4931            docInfo[key] = value;
4932            continue;
4933          }
4934
4935          break;
4936
4937        default:
4938          let customValue;
4939
4940          switch (typeof value) {
4941            case "string":
4942              customValue = (0, _util.stringToPDFString)(value);
4943              break;
4944
4945            case "number":
4946            case "boolean":
4947              customValue = value;
4948              break;
4949
4950            default:
4951              if (value instanceof _primitives.Name) {
4952                customValue = value;
4953              }
4954
4955              break;
4956          }
4957
4958          if (customValue === undefined) {
4959            (0, _util.warn)(`Bad value, for custom key "${key}", in Info: ${value}.`);
4960            continue;
4961          }
4962
4963          if (!docInfo.Custom) {
4964            docInfo.Custom = Object.create(null);
4965          }
4966
4967          docInfo.Custom[key] = customValue;
4968          continue;
4969      }
4970
4971      (0, _util.warn)(`Bad value, for key "${key}", in Info: ${value}.`);
4972    }
4973
4974    return (0, _util.shadow)(this, "documentInfo", docInfo);
4975  }
4976
4977  get fingerprints() {
4978    function validate(data) {
4979      return typeof data === "string" && data.length > 0 && data !== EMPTY_FINGERPRINT;
4980    }
4981
4982    function hexString(hash) {
4983      const buf = [];
4984
4985      for (let i = 0, ii = hash.length; i < ii; i++) {
4986        const hex = hash[i].toString(16);
4987        buf.push(hex.padStart(2, "0"));
4988      }
4989
4990      return buf.join("");
4991    }
4992
4993    const idArray = this.xref.trailer.get("ID");
4994    let hashOriginal, hashModified;
4995
4996    if (Array.isArray(idArray) && validate(idArray[0])) {
4997      hashOriginal = (0, _util.stringToBytes)(idArray[0]);
4998
4999      if (idArray[1] !== idArray[0] && validate(idArray[1])) {
5000        hashModified = (0, _util.stringToBytes)(idArray[1]);
5001      }
5002    } else {
5003      hashOriginal = (0, _crypto.calculateMD5)(this.stream.getByteRange(0, FINGERPRINT_FIRST_BYTES), 0, FINGERPRINT_FIRST_BYTES);
5004    }
5005
5006    return (0, _util.shadow)(this, "fingerprints", [hexString(hashOriginal), hashModified ? hexString(hashModified) : null]);
5007  }
5008
5009  async _getLinearizationPage(pageIndex) {
5010    const {
5011      catalog,
5012      linearization,
5013      xref
5014    } = this;
5015
5016    const ref = _primitives.Ref.get(linearization.objectNumberFirst, 0);
5017
5018    try {
5019      const obj = await xref.fetchAsync(ref);
5020
5021      if (obj instanceof _primitives.Dict) {
5022        let type = obj.getRaw("Type");
5023
5024        if (type instanceof _primitives.Ref) {
5025          type = await xref.fetchAsync(type);
5026        }
5027
5028        if ((0, _primitives.isName)(type, "Page") || !obj.has("Type") && !obj.has("Kids")) {
5029          if (!catalog.pageKidsCountCache.has(ref)) {
5030            catalog.pageKidsCountCache.put(ref, 1);
5031          }
5032
5033          if (!catalog.pageIndexCache.has(ref)) {
5034            catalog.pageIndexCache.put(ref, 0);
5035          }
5036
5037          return [obj, ref];
5038        }
5039      }
5040
5041      throw new _util.FormatError("The Linearization dictionary doesn't point to a valid Page dictionary.");
5042    } catch (reason) {
5043      (0, _util.warn)(`_getLinearizationPage: "${reason.message}".`);
5044      return catalog.getPageDict(pageIndex);
5045    }
5046  }
5047
5048  getPage(pageIndex) {
5049    const cachedPromise = this._pagePromises.get(pageIndex);
5050
5051    if (cachedPromise) {
5052      return cachedPromise;
5053    }
5054
5055    const {
5056      catalog,
5057      linearization,
5058      xfaFactory
5059    } = this;
5060    let promise;
5061
5062    if (xfaFactory) {
5063      promise = Promise.resolve([_primitives.Dict.empty, null]);
5064    } else if (linearization && linearization.pageFirst === pageIndex) {
5065      promise = this._getLinearizationPage(pageIndex);
5066    } else {
5067      promise = catalog.getPageDict(pageIndex);
5068    }
5069
5070    promise = promise.then(([pageDict, ref]) => {
5071      return new Page({
5072        pdfManager: this.pdfManager,
5073        xref: this.xref,
5074        pageIndex,
5075        pageDict,
5076        ref,
5077        globalIdFactory: this._globalIdFactory,
5078        fontCache: catalog.fontCache,
5079        builtInCMapCache: catalog.builtInCMapCache,
5080        standardFontDataCache: catalog.standardFontDataCache,
5081        globalImageCache: catalog.globalImageCache,
5082        nonBlendModesSet: catalog.nonBlendModesSet,
5083        xfaFactory
5084      });
5085    });
5086
5087    this._pagePromises.set(pageIndex, promise);
5088
5089    return promise;
5090  }
5091
5092  async checkFirstPage(recoveryMode = false) {
5093    if (recoveryMode) {
5094      return;
5095    }
5096
5097    try {
5098      await this.getPage(0);
5099    } catch (reason) {
5100      if (reason instanceof _core_utils.XRefEntryException) {
5101        this._pagePromises.delete(0);
5102
5103        await this.cleanup();
5104        throw new _core_utils.XRefParseException();
5105      }
5106    }
5107  }
5108
5109  async checkLastPage(recoveryMode = false) {
5110    const {
5111      catalog,
5112      pdfManager
5113    } = this;
5114    catalog.setActualNumPages();
5115    let numPages;
5116
5117    try {
5118      await Promise.all([pdfManager.ensureDoc("xfaFactory"), pdfManager.ensureDoc("linearization"), pdfManager.ensureCatalog("numPages")]);
5119
5120      if (this.xfaFactory) {
5121        return;
5122      } else if (this.linearization) {
5123        numPages = this.linearization.numPages;
5124      } else {
5125        numPages = catalog.numPages;
5126      }
5127
5128      if (!Number.isInteger(numPages)) {
5129        throw new _util.FormatError("Page count is not an integer.");
5130      } else if (numPages <= 1) {
5131        return;
5132      }
5133
5134      await this.getPage(numPages - 1);
5135    } catch (reason) {
5136      this._pagePromises.delete(numPages - 1);
5137
5138      await this.cleanup();
5139
5140      if (reason instanceof _core_utils.XRefEntryException && !recoveryMode) {
5141        throw new _core_utils.XRefParseException();
5142      }
5143
5144      (0, _util.warn)(`checkLastPage - invalid /Pages tree /Count: ${numPages}.`);
5145      let pagesTree;
5146
5147      try {
5148        pagesTree = await catalog.getAllPageDicts(recoveryMode);
5149      } catch (reasonAll) {
5150        if (reasonAll instanceof _core_utils.XRefEntryException && !recoveryMode) {
5151          throw new _core_utils.XRefParseException();
5152        }
5153
5154        catalog.setActualNumPages(1);
5155        return;
5156      }
5157
5158      for (const [pageIndex, [pageDict, ref]] of pagesTree) {
5159        let promise;
5160
5161        if (pageDict instanceof Error) {
5162          promise = Promise.reject(pageDict);
5163          promise.catch(() => {});
5164        } else {
5165          promise = Promise.resolve(new Page({
5166            pdfManager,
5167            xref: this.xref,
5168            pageIndex,
5169            pageDict,
5170            ref,
5171            globalIdFactory: this._globalIdFactory,
5172            fontCache: catalog.fontCache,
5173            builtInCMapCache: catalog.builtInCMapCache,
5174            standardFontDataCache: catalog.standardFontDataCache,
5175            globalImageCache: catalog.globalImageCache,
5176            nonBlendModesSet: catalog.nonBlendModesSet,
5177            xfaFactory: null
5178          }));
5179        }
5180
5181        this._pagePromises.set(pageIndex, promise);
5182      }
5183
5184      catalog.setActualNumPages(pagesTree.size);
5185    }
5186  }
5187
5188  fontFallback(id, handler) {
5189    return this.catalog.fontFallback(id, handler);
5190  }
5191
5192  async cleanup(manuallyTriggered = false) {
5193    return this.catalog ? this.catalog.cleanup(manuallyTriggered) : (0, _cleanup_helper.clearGlobalCaches)();
5194  }
5195
5196  _collectFieldObjects(name, fieldRef, promises) {
5197    const field = this.xref.fetchIfRef(fieldRef);
5198
5199    if (field.has("T")) {
5200      const partName = (0, _util.stringToPDFString)(field.get("T"));
5201
5202      if (name === "") {
5203        name = partName;
5204      } else {
5205        name = `${name}.${partName}`;
5206      }
5207    }
5208
5209    if (!promises.has(name)) {
5210      promises.set(name, []);
5211    }
5212
5213    promises.get(name).push(_annotation.AnnotationFactory.create(this.xref, fieldRef, this.pdfManager, this._localIdFactory, true).then(annotation => annotation && annotation.getFieldObject()).catch(function (reason) {
5214      (0, _util.warn)(`_collectFieldObjects: "${reason}".`);
5215      return null;
5216    }));
5217
5218    if (field.has("Kids")) {
5219      const kids = field.get("Kids");
5220
5221      for (const kid of kids) {
5222        this._collectFieldObjects(name, kid, promises);
5223      }
5224    }
5225  }
5226
5227  get fieldObjects() {
5228    if (!this.formInfo.hasFields) {
5229      return (0, _util.shadow)(this, "fieldObjects", Promise.resolve(null));
5230    }
5231
5232    const allFields = Object.create(null);
5233    const fieldPromises = new Map();
5234
5235    for (const fieldRef of this.catalog.acroForm.get("Fields")) {
5236      this._collectFieldObjects("", fieldRef, fieldPromises);
5237    }
5238
5239    const allPromises = [];
5240
5241    for (const [name, promises] of fieldPromises) {
5242      allPromises.push(Promise.all(promises).then(fields => {
5243        fields = fields.filter(field => !!field);
5244
5245        if (fields.length > 0) {
5246          allFields[name] = fields;
5247        }
5248      }));
5249    }
5250
5251    return (0, _util.shadow)(this, "fieldObjects", Promise.all(allPromises).then(() => allFields));
5252  }
5253
5254  get hasJSActions() {
5255    const promise = this.pdfManager.ensureDoc("_parseHasJSActions");
5256    return (0, _util.shadow)(this, "hasJSActions", promise);
5257  }
5258
5259  async _parseHasJSActions() {
5260    const [catalogJsActions, fieldObjects] = await Promise.all([this.pdfManager.ensureCatalog("jsActions"), this.pdfManager.ensureDoc("fieldObjects")]);
5261
5262    if (catalogJsActions) {
5263      return true;
5264    }
5265
5266    if (fieldObjects) {
5267      return Object.values(fieldObjects).some(fieldObject => fieldObject.some(object => object.actions !== null));
5268    }
5269
5270    return false;
5271  }
5272
5273  get calculationOrderIds() {
5274    const acroForm = this.catalog.acroForm;
5275
5276    if (!acroForm || !acroForm.has("CO")) {
5277      return (0, _util.shadow)(this, "calculationOrderIds", null);
5278    }
5279
5280    const calculationOrder = acroForm.get("CO");
5281
5282    if (!Array.isArray(calculationOrder) || calculationOrder.length === 0) {
5283      return (0, _util.shadow)(this, "calculationOrderIds", null);
5284    }
5285
5286    const ids = [];
5287
5288    for (const id of calculationOrder) {
5289      if (id instanceof _primitives.Ref) {
5290        ids.push(id.toString());
5291      }
5292    }
5293
5294    if (ids.length === 0) {
5295      return (0, _util.shadow)(this, "calculationOrderIds", null);
5296    }
5297
5298    return (0, _util.shadow)(this, "calculationOrderIds", ids);
5299  }
5300
5301}
5302
5303exports.PDFDocument = PDFDocument;
5304
5305/***/ }),
5306/* 12 */
5307/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
5308
5309
5310
5311Object.defineProperty(exports, "__esModule", ({
5312  value: true
5313}));
5314exports.PopupAnnotation = exports.MarkupAnnotation = exports.AnnotationFactory = exports.AnnotationBorderStyle = exports.Annotation = void 0;
5315exports.getQuadPoints = getQuadPoints;
5316
5317var _util = __w_pdfjs_require__(2);
5318
5319var _core_utils = __w_pdfjs_require__(6);
5320
5321var _default_appearance = __w_pdfjs_require__(13);
5322
5323var _primitives = __w_pdfjs_require__(5);
5324
5325var _writer = __w_pdfjs_require__(65);
5326
5327var _base_stream = __w_pdfjs_require__(7);
5328
5329var _bidi = __w_pdfjs_require__(60);
5330
5331var _catalog = __w_pdfjs_require__(69);
5332
5333var _colorspace = __w_pdfjs_require__(14);
5334
5335var _file_spec = __w_pdfjs_require__(72);
5336
5337var _object_loader = __w_pdfjs_require__(75);
5338
5339var _operator_list = __w_pdfjs_require__(62);
5340
5341var _stream = __w_pdfjs_require__(10);
5342
5343var _factory = __w_pdfjs_require__(76);
5344
5345class AnnotationFactory {
5346  static create(xref, ref, pdfManager, idFactory, collectFields) {
5347    return Promise.all([pdfManager.ensureCatalog("acroForm"), pdfManager.ensureCatalog("baseUrl"), pdfManager.ensureDoc("xfaDatasets"), collectFields ? this._getPageIndex(xref, ref, pdfManager) : -1]).then(([acroForm, baseUrl, xfaDatasets, pageIndex]) => pdfManager.ensure(this, "_create", [xref, ref, pdfManager, idFactory, acroForm, xfaDatasets, collectFields, pageIndex]));
5348  }
5349
5350  static _create(xref, ref, pdfManager, idFactory, acroForm, xfaDatasets, collectFields, pageIndex = -1) {
5351    const dict = xref.fetchIfRef(ref);
5352
5353    if (!(dict instanceof _primitives.Dict)) {
5354      return undefined;
5355    }
5356
5357    const id = ref instanceof _primitives.Ref ? ref.toString() : `annot_${idFactory.createObjId()}`;
5358    let subtype = dict.get("Subtype");
5359    subtype = subtype instanceof _primitives.Name ? subtype.name : null;
5360    const parameters = {
5361      xref,
5362      ref,
5363      dict,
5364      subtype,
5365      id,
5366      pdfManager,
5367      acroForm: acroForm instanceof _primitives.Dict ? acroForm : _primitives.Dict.empty,
5368      xfaDatasets,
5369      collectFields,
5370      pageIndex
5371    };
5372
5373    switch (subtype) {
5374      case "Link":
5375        return new LinkAnnotation(parameters);
5376
5377      case "Text":
5378        return new TextAnnotation(parameters);
5379
5380      case "Widget":
5381        let fieldType = (0, _core_utils.getInheritableProperty)({
5382          dict,
5383          key: "FT"
5384        });
5385        fieldType = fieldType instanceof _primitives.Name ? fieldType.name : null;
5386
5387        switch (fieldType) {
5388          case "Tx":
5389            return new TextWidgetAnnotation(parameters);
5390
5391          case "Btn":
5392            return new ButtonWidgetAnnotation(parameters);
5393
5394          case "Ch":
5395            return new ChoiceWidgetAnnotation(parameters);
5396
5397          case "Sig":
5398            return new SignatureWidgetAnnotation(parameters);
5399        }
5400
5401        (0, _util.warn)(`Unimplemented widget field type "${fieldType}", ` + "falling back to base field type.");
5402        return new WidgetAnnotation(parameters);
5403
5404      case "Popup":
5405        return new PopupAnnotation(parameters);
5406
5407      case "FreeText":
5408        return new FreeTextAnnotation(parameters);
5409
5410      case "Line":
5411        return new LineAnnotation(parameters);
5412
5413      case "Square":
5414        return new SquareAnnotation(parameters);
5415
5416      case "Circle":
5417        return new CircleAnnotation(parameters);
5418
5419      case "PolyLine":
5420        return new PolylineAnnotation(parameters);
5421
5422      case "Polygon":
5423        return new PolygonAnnotation(parameters);
5424
5425      case "Caret":
5426        return new CaretAnnotation(parameters);
5427
5428      case "Ink":
5429        return new InkAnnotation(parameters);
5430
5431      case "Highlight":
5432        return new HighlightAnnotation(parameters);
5433
5434      case "Underline":
5435        return new UnderlineAnnotation(parameters);
5436
5437      case "Squiggly":
5438        return new SquigglyAnnotation(parameters);
5439
5440      case "StrikeOut":
5441        return new StrikeOutAnnotation(parameters);
5442
5443      case "Stamp":
5444        return new StampAnnotation(parameters);
5445
5446      case "FileAttachment":
5447        return new FileAttachmentAnnotation(parameters);
5448
5449      default:
5450        if (!collectFields) {
5451          if (!subtype) {
5452            (0, _util.warn)("Annotation is missing the required /Subtype.");
5453          } else {
5454            (0, _util.warn)(`Unimplemented annotation type "${subtype}", ` + "falling back to base annotation.");
5455          }
5456        }
5457
5458        return new Annotation(parameters);
5459    }
5460  }
5461
5462  static async _getPageIndex(xref, ref, pdfManager) {
5463    try {
5464      const annotDict = await xref.fetchIfRefAsync(ref);
5465
5466      if (!(annotDict instanceof _primitives.Dict)) {
5467        return -1;
5468      }
5469
5470      const pageRef = annotDict.getRaw("P");
5471
5472      if (!(pageRef instanceof _primitives.Ref)) {
5473        return -1;
5474      }
5475
5476      const pageIndex = await pdfManager.ensureCatalog("getPageIndex", [pageRef]);
5477      return pageIndex;
5478    } catch (ex) {
5479      (0, _util.warn)(`_getPageIndex: "${ex}".`);
5480      return -1;
5481    }
5482  }
5483
5484  static async saveNewAnnotations(evaluator, task, annotations) {
5485    const xref = evaluator.xref;
5486    let baseFontRef;
5487    const dependencies = [];
5488    const promises = [];
5489
5490    for (const annotation of annotations) {
5491      switch (annotation.annotationType) {
5492        case _util.AnnotationEditorType.FREETEXT:
5493          if (!baseFontRef) {
5494            const baseFont = new _primitives.Dict(xref);
5495            baseFont.set("BaseFont", _primitives.Name.get("Helvetica"));
5496            baseFont.set("Type", _primitives.Name.get("Font"));
5497            baseFont.set("Subtype", _primitives.Name.get("Type1"));
5498            baseFont.set("Encoding", _primitives.Name.get("WinAnsiEncoding"));
5499            const buffer = [];
5500            baseFontRef = xref.getNewRef();
5501            (0, _writer.writeObject)(baseFontRef, baseFont, buffer, null);
5502            dependencies.push({
5503              ref: baseFontRef,
5504              data: buffer.join("")
5505            });
5506          }
5507
5508          promises.push(FreeTextAnnotation.createNewAnnotation(xref, annotation, dependencies, {
5509            evaluator,
5510            task,
5511            baseFontRef
5512          }));
5513          break;
5514
5515        case _util.AnnotationEditorType.INK:
5516          promises.push(InkAnnotation.createNewAnnotation(xref, annotation, dependencies));
5517      }
5518    }
5519
5520    return {
5521      annotations: await Promise.all(promises),
5522      dependencies
5523    };
5524  }
5525
5526  static async printNewAnnotations(evaluator, task, annotations) {
5527    if (!annotations) {
5528      return null;
5529    }
5530
5531    const xref = evaluator.xref;
5532    const promises = [];
5533
5534    for (const annotation of annotations) {
5535      switch (annotation.annotationType) {
5536        case _util.AnnotationEditorType.FREETEXT:
5537          promises.push(FreeTextAnnotation.createNewPrintAnnotation(xref, annotation, {
5538            evaluator,
5539            task
5540          }));
5541          break;
5542
5543        case _util.AnnotationEditorType.INK:
5544          promises.push(InkAnnotation.createNewPrintAnnotation(xref, annotation));
5545          break;
5546      }
5547    }
5548
5549    return Promise.all(promises);
5550  }
5551
5552}
5553
5554exports.AnnotationFactory = AnnotationFactory;
5555
5556function getRgbColor(color, defaultColor = new Uint8ClampedArray(3)) {
5557  if (!Array.isArray(color)) {
5558    return defaultColor;
5559  }
5560
5561  const rgbColor = defaultColor || new Uint8ClampedArray(3);
5562
5563  switch (color.length) {
5564    case 0:
5565      return null;
5566
5567    case 1:
5568      _colorspace.ColorSpace.singletons.gray.getRgbItem(color, 0, rgbColor, 0);
5569
5570      return rgbColor;
5571
5572    case 3:
5573      _colorspace.ColorSpace.singletons.rgb.getRgbItem(color, 0, rgbColor, 0);
5574
5575      return rgbColor;
5576
5577    case 4:
5578      _colorspace.ColorSpace.singletons.cmyk.getRgbItem(color, 0, rgbColor, 0);
5579
5580      return rgbColor;
5581
5582    default:
5583      return defaultColor;
5584  }
5585}
5586
5587function getQuadPoints(dict, rect) {
5588  if (!dict.has("QuadPoints")) {
5589    return null;
5590  }
5591
5592  const quadPoints = dict.getArray("QuadPoints");
5593
5594  if (!Array.isArray(quadPoints) || quadPoints.length === 0 || quadPoints.length % 8 > 0) {
5595    return null;
5596  }
5597
5598  const quadPointsLists = [];
5599
5600  for (let i = 0, ii = quadPoints.length / 8; i < ii; i++) {
5601    quadPointsLists.push([]);
5602
5603    for (let j = i * 8, jj = i * 8 + 8; j < jj; j += 2) {
5604      const x = quadPoints[j];
5605      const y = quadPoints[j + 1];
5606
5607      if (rect !== null && (x < rect[0] || x > rect[2] || y < rect[1] || y > rect[3])) {
5608        return null;
5609      }
5610
5611      quadPointsLists[i].push({
5612        x,
5613        y
5614      });
5615    }
5616  }
5617
5618  return quadPointsLists.map(quadPointsList => {
5619    const [minX, maxX, minY, maxY] = quadPointsList.reduce(([mX, MX, mY, MY], quadPoint) => [Math.min(mX, quadPoint.x), Math.max(MX, quadPoint.x), Math.min(mY, quadPoint.y), Math.max(MY, quadPoint.y)], [Number.MAX_VALUE, Number.MIN_VALUE, Number.MAX_VALUE, Number.MIN_VALUE]);
5620    return [{
5621      x: minX,
5622      y: maxY
5623    }, {
5624      x: maxX,
5625      y: maxY
5626    }, {
5627      x: minX,
5628      y: minY
5629    }, {
5630      x: maxX,
5631      y: minY
5632    }];
5633  });
5634}
5635
5636function getTransformMatrix(rect, bbox, matrix) {
5637  const [minX, minY, maxX, maxY] = _util.Util.getAxialAlignedBoundingBox(bbox, matrix);
5638
5639  if (minX === maxX || minY === maxY) {
5640    return [1, 0, 0, 1, rect[0], rect[1]];
5641  }
5642
5643  const xRatio = (rect[2] - rect[0]) / (maxX - minX);
5644  const yRatio = (rect[3] - rect[1]) / (maxY - minY);
5645  return [xRatio, 0, 0, yRatio, rect[0] - minX * xRatio, rect[1] - minY * yRatio];
5646}
5647
5648class Annotation {
5649  constructor(params) {
5650    const dict = params.dict;
5651    this.setTitle(dict.get("T"));
5652    this.setContents(dict.get("Contents"));
5653    this.setModificationDate(dict.get("M"));
5654    this.setFlags(dict.get("F"));
5655    this.setRectangle(dict.getArray("Rect"));
5656    this.setColor(dict.getArray("C"));
5657    this.setBorderStyle(dict);
5658    this.setAppearance(dict);
5659    this.setOptionalContent(dict);
5660    const MK = dict.get("MK");
5661    this.setBorderAndBackgroundColors(MK);
5662    this.setRotation(MK);
5663    this._streams = [];
5664
5665    if (this.appearance) {
5666      this._streams.push(this.appearance);
5667    }
5668
5669    this.data = {
5670      annotationFlags: this.flags,
5671      borderStyle: this.borderStyle,
5672      color: this.color,
5673      backgroundColor: this.backgroundColor,
5674      borderColor: this.borderColor,
5675      rotation: this.rotation,
5676      contentsObj: this._contents,
5677      hasAppearance: !!this.appearance,
5678      id: params.id,
5679      modificationDate: this.modificationDate,
5680      rect: this.rectangle,
5681      subtype: params.subtype,
5682      hasOwnCanvas: false
5683    };
5684
5685    if (params.collectFields) {
5686      const kids = dict.get("Kids");
5687
5688      if (Array.isArray(kids)) {
5689        const kidIds = [];
5690
5691        for (const kid of kids) {
5692          if (kid instanceof _primitives.Ref) {
5693            kidIds.push(kid.toString());
5694          }
5695        }
5696
5697        if (kidIds.length !== 0) {
5698          this.data.kidIds = kidIds;
5699        }
5700      }
5701
5702      this.data.actions = (0, _core_utils.collectActions)(params.xref, dict, _util.AnnotationActionEventType);
5703      this.data.fieldName = this._constructFieldName(dict);
5704      this.data.pageIndex = params.pageIndex;
5705    }
5706
5707    this._fallbackFontDict = null;
5708  }
5709
5710  _hasFlag(flags, flag) {
5711    return !!(flags & flag);
5712  }
5713
5714  _isViewable(flags) {
5715    return !this._hasFlag(flags, _util.AnnotationFlag.INVISIBLE) && !this._hasFlag(flags, _util.AnnotationFlag.NOVIEW);
5716  }
5717
5718  _isPrintable(flags) {
5719    return this._hasFlag(flags, _util.AnnotationFlag.PRINT) && !this._hasFlag(flags, _util.AnnotationFlag.INVISIBLE);
5720  }
5721
5722  mustBeViewed(annotationStorage) {
5723    const storageEntry = annotationStorage && annotationStorage.get(this.data.id);
5724
5725    if (storageEntry && storageEntry.hidden !== undefined) {
5726      return !storageEntry.hidden;
5727    }
5728
5729    return this.viewable && !this._hasFlag(this.flags, _util.AnnotationFlag.HIDDEN);
5730  }
5731
5732  mustBePrinted(annotationStorage) {
5733    const storageEntry = annotationStorage && annotationStorage.get(this.data.id);
5734
5735    if (storageEntry && storageEntry.print !== undefined) {
5736      return storageEntry.print;
5737    }
5738
5739    return this.printable;
5740  }
5741
5742  get viewable() {
5743    if (this.data.quadPoints === null) {
5744      return false;
5745    }
5746
5747    if (this.flags === 0) {
5748      return true;
5749    }
5750
5751    return this._isViewable(this.flags);
5752  }
5753
5754  get printable() {
5755    if (this.data.quadPoints === null) {
5756      return false;
5757    }
5758
5759    if (this.flags === 0) {
5760      return false;
5761    }
5762
5763    return this._isPrintable(this.flags);
5764  }
5765
5766  _parseStringHelper(data) {
5767    const str = typeof data === "string" ? (0, _util.stringToPDFString)(data) : "";
5768    const dir = str && (0, _bidi.bidi)(str).dir === "rtl" ? "rtl" : "ltr";
5769    return {
5770      str,
5771      dir
5772    };
5773  }
5774
5775  setTitle(title) {
5776    this._title = this._parseStringHelper(title);
5777  }
5778
5779  setContents(contents) {
5780    this._contents = this._parseStringHelper(contents);
5781  }
5782
5783  setModificationDate(modificationDate) {
5784    this.modificationDate = typeof modificationDate === "string" ? modificationDate : null;
5785  }
5786
5787  setFlags(flags) {
5788    this.flags = Number.isInteger(flags) && flags > 0 ? flags : 0;
5789  }
5790
5791  hasFlag(flag) {
5792    return this._hasFlag(this.flags, flag);
5793  }
5794
5795  setRectangle(rectangle) {
5796    if (Array.isArray(rectangle) && rectangle.length === 4) {
5797      this.rectangle = _util.Util.normalizeRect(rectangle);
5798    } else {
5799      this.rectangle = [0, 0, 0, 0];
5800    }
5801  }
5802
5803  setColor(color) {
5804    this.color = getRgbColor(color);
5805  }
5806
5807  setLineEndings(lineEndings) {
5808    this.lineEndings = ["None", "None"];
5809
5810    if (Array.isArray(lineEndings) && lineEndings.length === 2) {
5811      for (let i = 0; i < 2; i++) {
5812        const obj = lineEndings[i];
5813
5814        if (obj instanceof _primitives.Name) {
5815          switch (obj.name) {
5816            case "None":
5817              continue;
5818
5819            case "Square":
5820            case "Circle":
5821            case "Diamond":
5822            case "OpenArrow":
5823            case "ClosedArrow":
5824            case "Butt":
5825            case "ROpenArrow":
5826            case "RClosedArrow":
5827            case "Slash":
5828              this.lineEndings[i] = obj.name;
5829              continue;
5830          }
5831        }
5832
5833        (0, _util.warn)(`Ignoring invalid lineEnding: ${obj}`);
5834      }
5835    }
5836  }
5837
5838  setRotation(mk) {
5839    this.rotation = 0;
5840
5841    if (mk instanceof _primitives.Dict) {
5842      let angle = mk.get("R") || 0;
5843
5844      if (Number.isInteger(angle) && angle !== 0) {
5845        angle %= 360;
5846
5847        if (angle < 0) {
5848          angle += 360;
5849        }
5850
5851        if (angle % 90 === 0) {
5852          this.rotation = angle;
5853        }
5854      }
5855    }
5856  }
5857
5858  setBorderAndBackgroundColors(mk) {
5859    if (mk instanceof _primitives.Dict) {
5860      this.borderColor = getRgbColor(mk.getArray("BC"), null);
5861      this.backgroundColor = getRgbColor(mk.getArray("BG"), null);
5862    } else {
5863      this.borderColor = this.backgroundColor = null;
5864    }
5865  }
5866
5867  setBorderStyle(borderStyle) {
5868    this.borderStyle = new AnnotationBorderStyle();
5869
5870    if (!(borderStyle instanceof _primitives.Dict)) {
5871      return;
5872    }
5873
5874    if (borderStyle.has("BS")) {
5875      const dict = borderStyle.get("BS");
5876      const dictType = dict.get("Type");
5877
5878      if (!dictType || (0, _primitives.isName)(dictType, "Border")) {
5879        this.borderStyle.setWidth(dict.get("W"), this.rectangle);
5880        this.borderStyle.setStyle(dict.get("S"));
5881        this.borderStyle.setDashArray(dict.getArray("D"));
5882      }
5883    } else if (borderStyle.has("Border")) {
5884      const array = borderStyle.getArray("Border");
5885
5886      if (Array.isArray(array) && array.length >= 3) {
5887        this.borderStyle.setHorizontalCornerRadius(array[0]);
5888        this.borderStyle.setVerticalCornerRadius(array[1]);
5889        this.borderStyle.setWidth(array[2], this.rectangle);
5890
5891        if (array.length === 4) {
5892          this.borderStyle.setDashArray(array[3], true);
5893        }
5894      }
5895    } else {
5896      this.borderStyle.setWidth(0);
5897    }
5898  }
5899
5900  setAppearance(dict) {
5901    this.appearance = null;
5902    const appearanceStates = dict.get("AP");
5903
5904    if (!(appearanceStates instanceof _primitives.Dict)) {
5905      return;
5906    }
5907
5908    const normalAppearanceState = appearanceStates.get("N");
5909
5910    if (normalAppearanceState instanceof _base_stream.BaseStream) {
5911      this.appearance = normalAppearanceState;
5912      return;
5913    }
5914
5915    if (!(normalAppearanceState instanceof _primitives.Dict)) {
5916      return;
5917    }
5918
5919    const as = dict.get("AS");
5920
5921    if (!(as instanceof _primitives.Name) || !normalAppearanceState.has(as.name)) {
5922      return;
5923    }
5924
5925    this.appearance = normalAppearanceState.get(as.name);
5926  }
5927
5928  setOptionalContent(dict) {
5929    this.oc = null;
5930    const oc = dict.get("OC");
5931
5932    if (oc instanceof _primitives.Name) {
5933      (0, _util.warn)("setOptionalContent: Support for /Name-entry is not implemented.");
5934    } else if (oc instanceof _primitives.Dict) {
5935      this.oc = oc;
5936    }
5937  }
5938
5939  loadResources(keys, appearance) {
5940    return appearance.dict.getAsync("Resources").then(resources => {
5941      if (!resources) {
5942        return undefined;
5943      }
5944
5945      const objectLoader = new _object_loader.ObjectLoader(resources, keys, resources.xref);
5946      return objectLoader.load().then(function () {
5947        return resources;
5948      });
5949    });
5950  }
5951
5952  async getOperatorList(evaluator, task, intent, renderForms, annotationStorage) {
5953    const data = this.data;
5954    let appearance = this.appearance;
5955    const isUsingOwnCanvas = !!(this.data.hasOwnCanvas && intent & _util.RenderingIntentFlag.DISPLAY);
5956
5957    if (!appearance) {
5958      if (!isUsingOwnCanvas) {
5959        return {
5960          opList: new _operator_list.OperatorList(),
5961          separateForm: false,
5962          separateCanvas: false
5963        };
5964      }
5965
5966      appearance = new _stream.StringStream("");
5967      appearance.dict = new _primitives.Dict();
5968    }
5969
5970    const appearanceDict = appearance.dict;
5971    const resources = await this.loadResources(["ExtGState", "ColorSpace", "Pattern", "Shading", "XObject", "Font"], appearance);
5972    const bbox = appearanceDict.getArray("BBox") || [0, 0, 1, 1];
5973    const matrix = appearanceDict.getArray("Matrix") || [1, 0, 0, 1, 0, 0];
5974    const transform = getTransformMatrix(data.rect, bbox, matrix);
5975    const opList = new _operator_list.OperatorList();
5976    let optionalContent;
5977
5978    if (this.oc) {
5979      optionalContent = await evaluator.parseMarkedContentProps(this.oc, null);
5980    }
5981
5982    if (optionalContent !== undefined) {
5983      opList.addOp(_util.OPS.beginMarkedContentProps, ["OC", optionalContent]);
5984    }
5985
5986    opList.addOp(_util.OPS.beginAnnotation, [data.id, data.rect, transform, matrix, isUsingOwnCanvas]);
5987    await evaluator.getOperatorList({
5988      stream: appearance,
5989      task,
5990      resources,
5991      operatorList: opList,
5992      fallbackFontDict: this._fallbackFontDict
5993    });
5994    opList.addOp(_util.OPS.endAnnotation, []);
5995
5996    if (optionalContent !== undefined) {
5997      opList.addOp(_util.OPS.endMarkedContent, []);
5998    }
5999
6000    this.reset();
6001    return {
6002      opList,
6003      separateForm: false,
6004      separateCanvas: isUsingOwnCanvas
6005    };
6006  }
6007
6008  async save(evaluator, task, annotationStorage) {
6009    return null;
6010  }
6011
6012  get hasTextContent() {
6013    return false;
6014  }
6015
6016  async extractTextContent(evaluator, task, viewBox) {
6017    if (!this.appearance) {
6018      return;
6019    }
6020
6021    const resources = await this.loadResources(["ExtGState", "Font", "Properties", "XObject"], this.appearance);
6022    const text = [];
6023    const buffer = [];
6024    const sink = {
6025      desiredSize: Math.Infinity,
6026      ready: true,
6027
6028      enqueue(chunk, size) {
6029        for (const item of chunk.items) {
6030          buffer.push(item.str);
6031
6032          if (item.hasEOL) {
6033            text.push(buffer.join(""));
6034            buffer.length = 0;
6035          }
6036        }
6037      }
6038
6039    };
6040    await evaluator.getTextContent({
6041      stream: this.appearance,
6042      task,
6043      resources,
6044      includeMarkedContent: true,
6045      combineTextItems: true,
6046      sink,
6047      viewBox
6048    });
6049    this.reset();
6050
6051    if (buffer.length) {
6052      text.push(buffer.join(""));
6053    }
6054
6055    if (text.length > 0) {
6056      this.data.textContent = text;
6057    }
6058  }
6059
6060  getFieldObject() {
6061    if (this.data.kidIds) {
6062      return {
6063        id: this.data.id,
6064        actions: this.data.actions,
6065        name: this.data.fieldName,
6066        strokeColor: this.data.borderColor,
6067        fillColor: this.data.backgroundColor,
6068        type: "",
6069        kidIds: this.data.kidIds,
6070        page: this.data.pageIndex,
6071        rotation: this.rotation
6072      };
6073    }
6074
6075    return null;
6076  }
6077
6078  reset() {
6079    for (const stream of this._streams) {
6080      stream.reset();
6081    }
6082  }
6083
6084  _constructFieldName(dict) {
6085    if (!dict.has("T") && !dict.has("Parent")) {
6086      (0, _util.warn)("Unknown field name, falling back to empty field name.");
6087      return "";
6088    }
6089
6090    if (!dict.has("Parent")) {
6091      return (0, _util.stringToPDFString)(dict.get("T"));
6092    }
6093
6094    const fieldName = [];
6095
6096    if (dict.has("T")) {
6097      fieldName.unshift((0, _util.stringToPDFString)(dict.get("T")));
6098    }
6099
6100    let loopDict = dict;
6101    const visited = new _primitives.RefSet();
6102
6103    if (dict.objId) {
6104      visited.put(dict.objId);
6105    }
6106
6107    while (loopDict.has("Parent")) {
6108      loopDict = loopDict.get("Parent");
6109
6110      if (!(loopDict instanceof _primitives.Dict) || loopDict.objId && visited.has(loopDict.objId)) {
6111        break;
6112      }
6113
6114      if (loopDict.objId) {
6115        visited.put(loopDict.objId);
6116      }
6117
6118      if (loopDict.has("T")) {
6119        fieldName.unshift((0, _util.stringToPDFString)(loopDict.get("T")));
6120      }
6121    }
6122
6123    return fieldName.join(".");
6124  }
6125
6126}
6127
6128exports.Annotation = Annotation;
6129
6130class AnnotationBorderStyle {
6131  constructor() {
6132    this.width = 1;
6133    this.style = _util.AnnotationBorderStyleType.SOLID;
6134    this.dashArray = [3];
6135    this.horizontalCornerRadius = 0;
6136    this.verticalCornerRadius = 0;
6137  }
6138
6139  setWidth(width, rect = [0, 0, 0, 0]) {
6140    if (width instanceof _primitives.Name) {
6141      this.width = 0;
6142      return;
6143    }
6144
6145    if (typeof width === "number") {
6146      if (width > 0) {
6147        const maxWidth = (rect[2] - rect[0]) / 2;
6148        const maxHeight = (rect[3] - rect[1]) / 2;
6149
6150        if (maxWidth > 0 && maxHeight > 0 && (width > maxWidth || width > maxHeight)) {
6151          (0, _util.warn)(`AnnotationBorderStyle.setWidth - ignoring width: ${width}`);
6152          width = 1;
6153        }
6154      }
6155
6156      this.width = width;
6157    }
6158  }
6159
6160  setStyle(style) {
6161    if (!(style instanceof _primitives.Name)) {
6162      return;
6163    }
6164
6165    switch (style.name) {
6166      case "S":
6167        this.style = _util.AnnotationBorderStyleType.SOLID;
6168        break;
6169
6170      case "D":
6171        this.style = _util.AnnotationBorderStyleType.DASHED;
6172        break;
6173
6174      case "B":
6175        this.style = _util.AnnotationBorderStyleType.BEVELED;
6176        break;
6177
6178      case "I":
6179        this.style = _util.AnnotationBorderStyleType.INSET;
6180        break;
6181
6182      case "U":
6183        this.style = _util.AnnotationBorderStyleType.UNDERLINE;
6184        break;
6185
6186      default:
6187        break;
6188    }
6189  }
6190
6191  setDashArray(dashArray, forceStyle = false) {
6192    if (Array.isArray(dashArray) && dashArray.length > 0) {
6193      let isValid = true;
6194      let allZeros = true;
6195
6196      for (const element of dashArray) {
6197        const validNumber = +element >= 0;
6198
6199        if (!validNumber) {
6200          isValid = false;
6201          break;
6202        } else if (element > 0) {
6203          allZeros = false;
6204        }
6205      }
6206
6207      if (isValid && !allZeros) {
6208        this.dashArray = dashArray;
6209
6210        if (forceStyle) {
6211          this.setStyle(_primitives.Name.get("D"));
6212        }
6213      } else {
6214        this.width = 0;
6215      }
6216    } else if (dashArray) {
6217      this.width = 0;
6218    }
6219  }
6220
6221  setHorizontalCornerRadius(radius) {
6222    if (Number.isInteger(radius)) {
6223      this.horizontalCornerRadius = radius;
6224    }
6225  }
6226
6227  setVerticalCornerRadius(radius) {
6228    if (Number.isInteger(radius)) {
6229      this.verticalCornerRadius = radius;
6230    }
6231  }
6232
6233}
6234
6235exports.AnnotationBorderStyle = AnnotationBorderStyle;
6236
6237class MarkupAnnotation extends Annotation {
6238  constructor(parameters) {
6239    super(parameters);
6240    const dict = parameters.dict;
6241
6242    if (dict.has("IRT")) {
6243      const rawIRT = dict.getRaw("IRT");
6244      this.data.inReplyTo = rawIRT instanceof _primitives.Ref ? rawIRT.toString() : null;
6245      const rt = dict.get("RT");
6246      this.data.replyType = rt instanceof _primitives.Name ? rt.name : _util.AnnotationReplyType.REPLY;
6247    }
6248
6249    if (this.data.replyType === _util.AnnotationReplyType.GROUP) {
6250      const parent = dict.get("IRT");
6251      this.setTitle(parent.get("T"));
6252      this.data.titleObj = this._title;
6253      this.setContents(parent.get("Contents"));
6254      this.data.contentsObj = this._contents;
6255
6256      if (!parent.has("CreationDate")) {
6257        this.data.creationDate = null;
6258      } else {
6259        this.setCreationDate(parent.get("CreationDate"));
6260        this.data.creationDate = this.creationDate;
6261      }
6262
6263      if (!parent.has("M")) {
6264        this.data.modificationDate = null;
6265      } else {
6266        this.setModificationDate(parent.get("M"));
6267        this.data.modificationDate = this.modificationDate;
6268      }
6269
6270      this.data.hasPopup = parent.has("Popup");
6271
6272      if (!parent.has("C")) {
6273        this.data.color = null;
6274      } else {
6275        this.setColor(parent.getArray("C"));
6276        this.data.color = this.color;
6277      }
6278    } else {
6279      this.data.titleObj = this._title;
6280      this.setCreationDate(dict.get("CreationDate"));
6281      this.data.creationDate = this.creationDate;
6282      this.data.hasPopup = dict.has("Popup");
6283
6284      if (!dict.has("C")) {
6285        this.data.color = null;
6286      }
6287    }
6288
6289    if (dict.has("RC")) {
6290      this.data.richText = _factory.XFAFactory.getRichTextAsHtml(dict.get("RC"));
6291    }
6292  }
6293
6294  setCreationDate(creationDate) {
6295    this.creationDate = typeof creationDate === "string" ? creationDate : null;
6296  }
6297
6298  _setDefaultAppearance({
6299    xref,
6300    extra,
6301    strokeColor,
6302    fillColor,
6303    blendMode,
6304    strokeAlpha,
6305    fillAlpha,
6306    pointsCallback
6307  }) {
6308    let minX = Number.MAX_VALUE;
6309    let minY = Number.MAX_VALUE;
6310    let maxX = Number.MIN_VALUE;
6311    let maxY = Number.MIN_VALUE;
6312    const buffer = ["q"];
6313
6314    if (extra) {
6315      buffer.push(extra);
6316    }
6317
6318    if (strokeColor) {
6319      buffer.push(`${strokeColor[0]} ${strokeColor[1]} ${strokeColor[2]} RG`);
6320    }
6321
6322    if (fillColor) {
6323      buffer.push(`${fillColor[0]} ${fillColor[1]} ${fillColor[2]} rg`);
6324    }
6325
6326    let pointsArray = this.data.quadPoints;
6327
6328    if (!pointsArray) {
6329      pointsArray = [[{
6330        x: this.rectangle[0],
6331        y: this.rectangle[3]
6332      }, {
6333        x: this.rectangle[2],
6334        y: this.rectangle[3]
6335      }, {
6336        x: this.rectangle[0],
6337        y: this.rectangle[1]
6338      }, {
6339        x: this.rectangle[2],
6340        y: this.rectangle[1]
6341      }]];
6342    }
6343
6344    for (const points of pointsArray) {
6345      const [mX, MX, mY, MY] = pointsCallback(buffer, points);
6346      minX = Math.min(minX, mX);
6347      maxX = Math.max(maxX, MX);
6348      minY = Math.min(minY, mY);
6349      maxY = Math.max(maxY, MY);
6350    }
6351
6352    buffer.push("Q");
6353    const formDict = new _primitives.Dict(xref);
6354    const appearanceStreamDict = new _primitives.Dict(xref);
6355    appearanceStreamDict.set("Subtype", _primitives.Name.get("Form"));
6356    const appearanceStream = new _stream.StringStream(buffer.join(" "));
6357    appearanceStream.dict = appearanceStreamDict;
6358    formDict.set("Fm0", appearanceStream);
6359    const gsDict = new _primitives.Dict(xref);
6360
6361    if (blendMode) {
6362      gsDict.set("BM", _primitives.Name.get(blendMode));
6363    }
6364
6365    if (typeof strokeAlpha === "number") {
6366      gsDict.set("CA", strokeAlpha);
6367    }
6368
6369    if (typeof fillAlpha === "number") {
6370      gsDict.set("ca", fillAlpha);
6371    }
6372
6373    const stateDict = new _primitives.Dict(xref);
6374    stateDict.set("GS0", gsDict);
6375    const resources = new _primitives.Dict(xref);
6376    resources.set("ExtGState", stateDict);
6377    resources.set("XObject", formDict);
6378    const appearanceDict = new _primitives.Dict(xref);
6379    appearanceDict.set("Resources", resources);
6380    const bbox = this.data.rect = [minX, minY, maxX, maxY];
6381    appearanceDict.set("BBox", bbox);
6382    this.appearance = new _stream.StringStream("/GS0 gs /Fm0 Do");
6383    this.appearance.dict = appearanceDict;
6384
6385    this._streams.push(this.appearance, appearanceStream);
6386  }
6387
6388  static async createNewAnnotation(xref, annotation, dependencies, params) {
6389    const annotationRef = xref.getNewRef();
6390    const apRef = xref.getNewRef();
6391    const annotationDict = this.createNewDict(annotation, xref, {
6392      apRef
6393    });
6394    const ap = await this.createNewAppearanceStream(annotation, xref, params);
6395    const buffer = [];
6396    let transform = xref.encrypt ? xref.encrypt.createCipherTransform(apRef.num, apRef.gen) : null;
6397    (0, _writer.writeObject)(apRef, ap, buffer, transform);
6398    dependencies.push({
6399      ref: apRef,
6400      data: buffer.join("")
6401    });
6402    buffer.length = 0;
6403    transform = xref.encrypt ? xref.encrypt.createCipherTransform(annotationRef.num, annotationRef.gen) : null;
6404    (0, _writer.writeObject)(annotationRef, annotationDict, buffer, transform);
6405    return {
6406      ref: annotationRef,
6407      data: buffer.join("")
6408    };
6409  }
6410
6411  static async createNewPrintAnnotation(xref, annotation, params) {
6412    const ap = await this.createNewAppearanceStream(annotation, xref, params);
6413    const annotationDict = this.createNewDict(annotation, xref, {
6414      ap
6415    });
6416    return new this.prototype.constructor({
6417      dict: annotationDict,
6418      xref
6419    });
6420  }
6421
6422}
6423
6424exports.MarkupAnnotation = MarkupAnnotation;
6425
6426class WidgetAnnotation extends Annotation {
6427  constructor(params) {
6428    super(params);
6429    const dict = params.dict;
6430    const data = this.data;
6431    this.ref = params.ref;
6432    data.annotationType = _util.AnnotationType.WIDGET;
6433
6434    if (data.fieldName === undefined) {
6435      data.fieldName = this._constructFieldName(dict);
6436    }
6437
6438    if (data.actions === undefined) {
6439      data.actions = (0, _core_utils.collectActions)(params.xref, dict, _util.AnnotationActionEventType);
6440    }
6441
6442    let fieldValue = (0, _core_utils.getInheritableProperty)({
6443      dict,
6444      key: "V",
6445      getArray: true
6446    });
6447    data.fieldValue = this._decodeFormValue(fieldValue);
6448    const defaultFieldValue = (0, _core_utils.getInheritableProperty)({
6449      dict,
6450      key: "DV",
6451      getArray: true
6452    });
6453    data.defaultFieldValue = this._decodeFormValue(defaultFieldValue);
6454
6455    if (fieldValue === undefined && params.xfaDatasets) {
6456      const path = this._title.str;
6457
6458      if (path) {
6459        this._hasValueFromXFA = true;
6460        data.fieldValue = fieldValue = params.xfaDatasets.getValue(path);
6461      }
6462    }
6463
6464    if (fieldValue === undefined && data.defaultFieldValue !== null) {
6465      data.fieldValue = data.defaultFieldValue;
6466    }
6467
6468    data.alternativeText = (0, _util.stringToPDFString)(dict.get("TU") || "");
6469    const defaultAppearance = (0, _core_utils.getInheritableProperty)({
6470      dict,
6471      key: "DA"
6472    }) || params.acroForm.get("DA");
6473    this._defaultAppearance = typeof defaultAppearance === "string" ? defaultAppearance : "";
6474    data.defaultAppearanceData = (0, _default_appearance.parseDefaultAppearance)(this._defaultAppearance);
6475    const fieldType = (0, _core_utils.getInheritableProperty)({
6476      dict,
6477      key: "FT"
6478    });
6479    data.fieldType = fieldType instanceof _primitives.Name ? fieldType.name : null;
6480    const localResources = (0, _core_utils.getInheritableProperty)({
6481      dict,
6482      key: "DR"
6483    });
6484    const acroFormResources = params.acroForm.get("DR");
6485    const appearanceResources = this.appearance && this.appearance.dict.get("Resources");
6486    this._fieldResources = {
6487      localResources,
6488      acroFormResources,
6489      appearanceResources,
6490      mergedResources: _primitives.Dict.merge({
6491        xref: params.xref,
6492        dictArray: [localResources, appearanceResources, acroFormResources],
6493        mergeSubDicts: true
6494      })
6495    };
6496    data.fieldFlags = (0, _core_utils.getInheritableProperty)({
6497      dict,
6498      key: "Ff"
6499    });
6500
6501    if (!Number.isInteger(data.fieldFlags) || data.fieldFlags < 0) {
6502      data.fieldFlags = 0;
6503    }
6504
6505    data.readOnly = this.hasFieldFlag(_util.AnnotationFieldFlag.READONLY);
6506    data.required = this.hasFieldFlag(_util.AnnotationFieldFlag.REQUIRED);
6507    data.hidden = this._hasFlag(data.annotationFlags, _util.AnnotationFlag.HIDDEN);
6508  }
6509
6510  _decodeFormValue(formValue) {
6511    if (Array.isArray(formValue)) {
6512      return formValue.filter(item => typeof item === "string").map(item => (0, _util.stringToPDFString)(item));
6513    } else if (formValue instanceof _primitives.Name) {
6514      return (0, _util.stringToPDFString)(formValue.name);
6515    } else if (typeof formValue === "string") {
6516      return (0, _util.stringToPDFString)(formValue);
6517    }
6518
6519    return null;
6520  }
6521
6522  hasFieldFlag(flag) {
6523    return !!(this.data.fieldFlags & flag);
6524  }
6525
6526  static _getRotationMatrix(rotation, width, height) {
6527    switch (rotation) {
6528      case 90:
6529        return [0, 1, -1, 0, width, 0];
6530
6531      case 180:
6532        return [-1, 0, 0, -1, width, height];
6533
6534      case 270:
6535        return [0, -1, 1, 0, 0, height];
6536
6537      default:
6538        throw new Error("Invalid rotation");
6539    }
6540  }
6541
6542  getRotationMatrix(annotationStorage) {
6543    const storageEntry = annotationStorage ? annotationStorage.get(this.data.id) : undefined;
6544    let rotation = storageEntry && storageEntry.rotation;
6545
6546    if (rotation === undefined) {
6547      rotation = this.rotation;
6548    }
6549
6550    if (rotation === 0) {
6551      return _util.IDENTITY_MATRIX;
6552    }
6553
6554    const width = this.data.rect[2] - this.data.rect[0];
6555    const height = this.data.rect[3] - this.data.rect[1];
6556    return WidgetAnnotation._getRotationMatrix(rotation, width, height);
6557  }
6558
6559  getBorderAndBackgroundAppearances(annotationStorage) {
6560    const storageEntry = annotationStorage ? annotationStorage.get(this.data.id) : undefined;
6561    let rotation = storageEntry && storageEntry.rotation;
6562
6563    if (rotation === undefined) {
6564      rotation = this.rotation;
6565    }
6566
6567    if (!this.backgroundColor && !this.borderColor) {
6568      return "";
6569    }
6570
6571    const width = this.data.rect[2] - this.data.rect[0];
6572    const height = this.data.rect[3] - this.data.rect[1];
6573    const rect = rotation === 0 || rotation === 180 ? `0 0 ${width} ${height} re` : `0 0 ${height} ${width} re`;
6574    let str = "";
6575
6576    if (this.backgroundColor) {
6577      str = `${(0, _default_appearance.getPdfColor)(this.backgroundColor, true)} ${rect} f `;
6578    }
6579
6580    if (this.borderColor) {
6581      const borderWidth = this.borderStyle.width || 1;
6582      str += `${borderWidth} w ${(0, _default_appearance.getPdfColor)(this.borderColor, false)} ${rect} S `;
6583    }
6584
6585    return str;
6586  }
6587
6588  async getOperatorList(evaluator, task, intent, renderForms, annotationStorage) {
6589    if (renderForms && !(this instanceof SignatureWidgetAnnotation)) {
6590      return {
6591        opList: new _operator_list.OperatorList(),
6592        separateForm: true,
6593        separateCanvas: false
6594      };
6595    }
6596
6597    if (!this._hasText) {
6598      return super.getOperatorList(evaluator, task, intent, renderForms, annotationStorage);
6599    }
6600
6601    const content = await this._getAppearance(evaluator, task, annotationStorage);
6602
6603    if (this.appearance && content === null) {
6604      return super.getOperatorList(evaluator, task, intent, renderForms, annotationStorage);
6605    }
6606
6607    const opList = new _operator_list.OperatorList();
6608
6609    if (!this._defaultAppearance || content === null) {
6610      return {
6611        opList,
6612        separateForm: false,