https://www.akishima.or.jp/monodukuri4/javascript/pdf.js

1/**
2 * @licstart The following is the entire license notice for the
3 * Javascript code in this page
4 *
5 * Copyright 2021 Mozilla Foundation
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *     http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * @licend The above is the entire license notice for the
20 * Javascript code in this page
21 */
22
23(function webpackUniversalModuleDefinition(root, factory) {
24	if(typeof exports === 'object' && typeof module === 'object')
25		module.exports = factory();
26	else if(typeof define === 'function' && define.amd)
27		define("pdfjs-dist/build/pdf", [], factory);
28	else if(typeof exports === 'object')
29		exports["pdfjs-dist/build/pdf"] = factory();
30	else
31		root["pdfjs-dist/build/pdf"] = root.pdfjsLib = factory();
32})(this, function() {
33return /******/ (() => { // webpackBootstrap
34/******/ 	"use strict";
35/******/ 	var __webpack_modules__ = ([
36/* 0 */,
37/* 1 */
38/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
39
40
41
42Object.defineProperty(exports, "__esModule", ({
43  value: true
44}));
45exports.addLinkAttributes = addLinkAttributes;
46exports.deprecated = deprecated;
47exports.getFilenameFromUrl = getFilenameFromUrl;
48exports.getPdfFilenameFromUrl = getPdfFilenameFromUrl;
49exports.isDataScheme = isDataScheme;
50exports.isFetchSupported = isFetchSupported;
51exports.isPdfFile = isPdfFile;
52exports.isValidFetchUrl = isValidFetchUrl;
53exports.loadScript = loadScript;
54exports.StatTimer = exports.RenderingCancelledException = exports.PDFDateString = exports.PageViewport = exports.LinkTarget = exports.DOMSVGFactory = exports.DOMCMapReaderFactory = exports.DOMCanvasFactory = exports.DEFAULT_LINK_REL = exports.BaseCMapReaderFactory = exports.BaseCanvasFactory = void 0;
55
56var _util = __w_pdfjs_require__(2);
57
58const DEFAULT_LINK_REL = "noopener noreferrer nofollow";
59exports.DEFAULT_LINK_REL = DEFAULT_LINK_REL;
60const SVG_NS = "http://www.w3.org/2000/svg";
61
62class BaseCanvasFactory {
63  constructor() {
64    if (this.constructor === BaseCanvasFactory) {
65      (0, _util.unreachable)("Cannot initialize BaseCanvasFactory.");
66    }
67  }
68
69  create(width, height) {
70    (0, _util.unreachable)("Abstract method `create` called.");
71  }
72
73  reset(canvasAndContext, width, height) {
74    if (!canvasAndContext.canvas) {
75      throw new Error("Canvas is not specified");
76    }
77
78    if (width <= 0 || height <= 0) {
79      throw new Error("Invalid canvas size");
80    }
81
82    canvasAndContext.canvas.width = width;
83    canvasAndContext.canvas.height = height;
84  }
85
86  destroy(canvasAndContext) {
87    if (!canvasAndContext.canvas) {
88      throw new Error("Canvas is not specified");
89    }
90
91    canvasAndContext.canvas.width = 0;
92    canvasAndContext.canvas.height = 0;
93    canvasAndContext.canvas = null;
94    canvasAndContext.context = null;
95  }
96
97}
98
99exports.BaseCanvasFactory = BaseCanvasFactory;
100
101class DOMCanvasFactory extends BaseCanvasFactory {
102  constructor({
103    ownerDocument = globalThis.document
104  } = {}) {
105    super();
106    this._document = ownerDocument;
107  }
108
109  create(width, height) {
110    if (width <= 0 || height <= 0) {
111      throw new Error("Invalid canvas size");
112    }
113
114    const canvas = this._document.createElement("canvas");
115
116    const context = canvas.getContext("2d");
117    canvas.width = width;
118    canvas.height = height;
119    return {
120      canvas,
121      context
122    };
123  }
124
125}
126
127exports.DOMCanvasFactory = DOMCanvasFactory;
128
129class BaseCMapReaderFactory {
130  constructor({
131    baseUrl = null,
132    isCompressed = false
133  }) {
134    if (this.constructor === BaseCMapReaderFactory) {
135      (0, _util.unreachable)("Cannot initialize BaseCMapReaderFactory.");
136    }
137
138    this.baseUrl = baseUrl;
139    this.isCompressed = isCompressed;
140  }
141
142  async fetch({
143    name
144  }) {
145    if (!this.baseUrl) {
146      throw new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.');
147    }
148
149    if (!name) {
150      throw new Error("CMap name must be specified.");
151    }
152
153    const url = this.baseUrl + name + (this.isCompressed ? ".bcmap" : "");
154    const compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE;
155    return this._fetchData(url, compressionType).catch(reason => {
156      throw new Error(`Unable to load ${this.isCompressed ? "binary " : ""}CMap at: ${url}`);
157    });
158  }
159
160  _fetchData(url, compressionType) {
161    (0, _util.unreachable)("Abstract method `_fetchData` called.");
162  }
163
164}
165
166exports.BaseCMapReaderFactory = BaseCMapReaderFactory;
167
168class DOMCMapReaderFactory extends BaseCMapReaderFactory {
169  _fetchData(url, compressionType) {
170    if (isFetchSupported() && isValidFetchUrl(url, document.baseURI)) {
171      return fetch(url).then(async response => {
172        if (!response.ok) {
173          throw new Error(response.statusText);
174        }
175
176        let cMapData;
177
178        if (this.isCompressed) {
179          cMapData = new Uint8Array(await response.arrayBuffer());
180        } else {
181          cMapData = (0, _util.stringToBytes)(await response.text());
182        }
183
184        return {
185          cMapData,
186          compressionType
187        };
188      });
189    }
190
191    return new Promise((resolve, reject) => {
192      const request = new XMLHttpRequest();
193      request.open("GET", url, true);
194
195      if (this.isCompressed) {
196        request.responseType = "arraybuffer";
197      }
198
199      request.onreadystatechange = () => {
200        if (request.readyState !== XMLHttpRequest.DONE) {
201          return;
202        }
203
204        if (request.status === 200 || request.status === 0) {
205          let cMapData;
206
207          if (this.isCompressed && request.response) {
208            cMapData = new Uint8Array(request.response);
209          } else if (!this.isCompressed && request.responseText) {
210            cMapData = (0, _util.stringToBytes)(request.responseText);
211          }
212
213          if (cMapData) {
214            resolve({
215              cMapData,
216              compressionType
217            });
218            return;
219          }
220        }
221
222        reject(new Error(request.statusText));
223      };
224
225      request.send(null);
226    });
227  }
228
229}
230
231exports.DOMCMapReaderFactory = DOMCMapReaderFactory;
232
233class DOMSVGFactory {
234  create(width, height) {
235    (0, _util.assert)(width > 0 && height > 0, "Invalid SVG dimensions");
236    const svg = document.createElementNS(SVG_NS, "svg:svg");
237    svg.setAttribute("version", "1.1");
238    svg.setAttribute("width", width + "px");
239    svg.setAttribute("height", height + "px");
240    svg.setAttribute("preserveAspectRatio", "none");
241    svg.setAttribute("viewBox", "0 0 " + width + " " + height);
242    return svg;
243  }
244
245  createElement(type) {
246    (0, _util.assert)(typeof type === "string", "Invalid SVG element type");
247    return document.createElementNS(SVG_NS, type);
248  }
249
250}
251
252exports.DOMSVGFactory = DOMSVGFactory;
253
254class PageViewport {
255  constructor({

256    viewBox,
257    scale,
258    rotation,
259    offsetX = 0,
260    offsetY = 0,
261    dontFlip = false
262  }) {
263    this.viewBox = viewBox;
264    this.scale = scale;
265    this.rotation = rotation;
266    this.offsetX = offsetX;
267    this.offsetY = offsetY;
268    const centerX = (viewBox[2] + viewBox[0]) / 2;
269    const centerY = (viewBox[3] + viewBox[1]) / 2;
270    let rotateA, rotateB, rotateC, rotateD;
271    rotation %= 360;
272
273    if (rotation < 0) {
274      rotation += 360;
275    }
276
277    switch (rotation) {
278      case 180:
279        rotateA = -1;
280        rotateB = 0;
281        rotateC = 0;
282        rotateD = 1;
283        break;
284
285      case 90:
286        rotateA = 0;
287        rotateB = 1;
288        rotateC = 1;
289        rotateD = 0;
290        break;
291
292      case 270:
293        rotateA = 0;
294        rotateB = -1;
295        rotateC = -1;
296        rotateD = 0;
297        break;
298
299      case 0:
300        rotateA = 1;
301        rotateB = 0;
302        rotateC = 0;
303        rotateD = -1;
304        break;
305
306      default:
307        throw new Error("PageViewport: Invalid rotation, must be a multiple of 90 degrees.");
308    }
309
310    if (dontFlip) {
311      rotateC = -rotateC;
312      rotateD = -rotateD;
313    }
314
315    let offsetCanvasX, offsetCanvasY;
316    let width, height;
317
318    if (rotateA === 0) {
319      offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
320      offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
321      width = Math.abs(viewBox[3] - viewBox[1]) * scale;
322      height = Math.abs(viewBox[2] - viewBox[0]) * scale;
323    } else {
324      offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
325      offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
326      width = Math.abs(viewBox[2] - viewBox[0]) * scale;
327      height = Math.abs(viewBox[3] - viewBox[1]) * scale;
328    }
329
330    this.transform = [rotateA * scale, rotateB * scale, rotateC * scale, rotateD * scale, offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY, offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY];
331    this.width = width;
332    this.height = height;
333  }
334
335  clone({
336    scale = this.scale,
337    rotation = this.rotation,
338    offsetX = this.offsetX,
339    offsetY = this.offsetY,
340    dontFlip = false
341  } = {}) {
342    return new PageViewport({
343      viewBox: this.viewBox.slice(),
344      scale,
345      rotation,
346      offsetX,
347      offsetY,
348      dontFlip
349    });
350  }
351
352  convertToViewportPoint(x, y) {
353    return _util.Util.applyTransform([x, y], this.transform);
354  }
355
356  convertToViewportRectangle(rect) {
357    const topLeft = _util.Util.applyTransform([rect[0], rect[1]], this.transform);
358
359    const bottomRight = _util.Util.applyTransform([rect[2], rect[3]], this.transform);
360
361    return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]];
362  }
363
364  convertToPdfPoint(x, y) {
365    return _util.Util.applyInverseTransform([x, y], this.transform);
366  }
367
368}
369
370exports.PageViewport = PageViewport;
371
372class RenderingCancelledException extends _util.BaseException {
373  constructor(msg, type) {
374    super(msg);
375    this.type = type;
376  }
377
378}
379
380exports.RenderingCancelledException = RenderingCancelledException;
381const LinkTarget = {
382  NONE: 0,
383  SELF: 1,
384  BLANK: 2,
385  PARENT: 3,
386  TOP: 4
387};
388exports.LinkTarget = LinkTarget;
389
390function addLinkAttributes(link, {
391  url,
392  target,
393  rel,
394  enabled = true
395} = {}) {
396  (0, _util.assert)(url && typeof url === "string", 'addLinkAttributes: A valid "url" parameter must provided.');
397  const urlNullRemoved = (0, _util.removeNullCharacters)(url);
398
399  if (enabled) {
400    link.href = link.title = urlNullRemoved;
401  } else {
402    link.href = "";
403    link.title = `Disabled: ${urlNullRemoved}`;
404
405    link.onclick = () => {
406      return false;
407    };
408  }
409
410  let targetStr = "";
411
412  switch (target) {
413    case LinkTarget.NONE:
414      break;
415
416    case LinkTarget.SELF:
417      targetStr = "_self";
418      break;
419
420    case LinkTarget.BLANK:
421      targetStr = "_blank";
422      break;
423
424    case LinkTarget.PARENT:
425      targetStr = "_parent";
426      break;
427
428    case LinkTarget.TOP:
429      targetStr = "_top";
430      break;
431  }
432
433  link.target = targetStr;
434  link.rel = typeof rel === "string" ? rel : DEFAULT_LINK_REL;
435}
436
437function isDataScheme(url) {
438  const ii = url.length;
439  let i = 0;
440
441  while (i < ii && url[i].trim() === "") {
442    i++;
443  }
444
445  return url.substring(i, i + 5).toLowerCase() === "data:";
446}
447
448function isPdfFile(filename) {
449  return typeof filename === "string" && /\.pdf$/i.test(filename);
450}
451
452function getFilenameFromUrl(url) {
453  const anchor = url.indexOf("#");
454  const query = url.indexOf("?");
455  const end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length);
456  return url.substring(url.lastIndexOf("/", end) + 1, end);
457}
458
459function getPdfFilenameFromUrl(url, defaultFilename = "document.pdf") {
460  if (typeof url !== "string") {
461    return defaultFilename;
462  }
463
464  if (isDataScheme(url)) {
465    (0, _util.warn)('getPdfFilenameFromUrl: ignore "data:"-URL for performance reasons.');
466    return defaultFilename;
467  }
468
469  const reURI = /^(?:(?:[^:]+:)?\/\/[^/]+)?([^?#]*)(\?[^#]*)?(#.*)?$/;
470  const reFilename = /[^/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
471  const splitURI = reURI.exec(url);
472  let suggestedFilename = reFilename.exec(splitURI[1]) || reFilename.exec(splitURI[2]) || reFilename.exec(splitURI[3]);
473
474  if (suggestedFilename) {
475    suggestedFilename = suggestedFilename[0];
476
477    if (suggestedFilename.includes("%")) {

478      try {
479        suggestedFilename = reFilename.exec(decodeURIComponent(suggestedFilename))[0];
480      } catch (ex) {}
481    }
482  }
483
484  return suggestedFilename || defaultFilename;
485}
486
487class StatTimer {
488  constructor() {
489    this.started = Object.create(null);
490    this.times = [];
491  }
492
493  time(name) {
494    if (name in this.started) {
495      (0, _util.warn)(`Timer is already running for ${name}`);
496    }
497
498    this.started[name] = Date.now();
499  }
500
501  timeEnd(name) {
502    if (!(name in this.started)) {
503      (0, _util.warn)(`Timer has not been started for ${name}`);
504    }
505
506    this.times.push({
507      name,
508      start: this.started[name],
509      end: Date.now()
510    });
511    delete this.started[name];
512  }
513
514  toString() {
515    const outBuf = [];
516    let longest = 0;
517
518    for (const time of this.times) {
519      const name = time.name;
520
521      if (name.length > longest) {
522        longest = name.length;
523      }
524    }
525
526    for (const time of this.times) {
527      const duration = time.end - time.start;
528      outBuf.push(`${time.name.padEnd(longest)} ${duration}ms\n`);
529    }
530
531    return outBuf.join("");
532  }
533
534}
535
536exports.StatTimer = StatTimer;
537
538function isFetchSupported() {
539  return typeof fetch !== "undefined" && typeof Response !== "undefined" && "body" in Response.prototype && typeof ReadableStream !== "undefined";
540}
541
542function isValidFetchUrl(url, baseUrl) {
543  try {
544    const {
545      protocol
546    } = baseUrl ? new URL(url, baseUrl) : new URL(url);
547    return protocol === "http:" || protocol === "https:";
548  } catch (ex) {
549    return false;
550  }
551}
552
553function loadScript(src, removeScriptElement = false) {
554  return new Promise((resolve, reject) => {
555    const script = document.createElement("script");
556    script.src = src;
557
558    script.onload = function (evt) {
559      if (removeScriptElement) {
560        script.remove();
561      }
562
563      resolve(evt);
564    };
565
566    script.onerror = function () {
567      reject(new Error(`Cannot load script at: ${script.src}`));
568    };
569
570    (document.head || document.documentElement).appendChild(script);
571  });
572}
573
574function deprecated(details) {
575  console.log("Deprecated API usage: " + details);
576}
577
578let pdfDateStringRegex;
579
580class PDFDateString {
581  static toDateObject(input) {
582    if (!input || !(0, _util.isString)(input)) {
583      return null;
584    }
585
586    if (!pdfDateStringRegex) {
587      pdfDateStringRegex = new RegExp("^D:" + "(\\d{4})" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "([Z|+|-])?" + "(\\d{2})?" + "'?" + "(\\d{2})?" + "'?");
588    }
589
590    const matches = pdfDateStringRegex.exec(input);
591
592    if (!matches) {
593      return null;
594    }
595
596    const year = parseInt(matches[1], 10);
597    let month = parseInt(matches[2], 10);

598    month = month >= 1 && month <= 12 ? month - 1 : 0;
599    let day = parseInt(matches[3], 10);
600    day = day >= 1 && day <= 31 ? day : 1;
601    let hour = parseInt(matches[4], 10);
602    hour = hour >= 0 && hour <= 23 ? hour : 0;
603    let minute = parseInt(matches[5], 10);
604    minute = minute >= 0 && minute <= 59 ? minute : 0;
605    let second = parseInt(matches[6], 10);
606    second = second >= 0 && second <= 59 ? second : 0;
607    const universalTimeRelation = matches[7] || "Z";
608    let offsetHour = parseInt(matches[8], 10);
609    offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0;
610    let offsetMinute = parseInt(matches[9], 10) || 0;
611    offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0;
612
613    if (universalTimeRelation === "-") {
614      hour += offsetHour;
615      minute += offsetMinute;
616    } else if (universalTimeRelation === "+") {
617      hour -= offsetHour;
618      minute -= offsetMinute;
619    }
620
621    return new Date(Date.UTC(year, month, day, hour, minute, second));
622  }
623
624}
625
626exports.PDFDateString = PDFDateString;
627
628/***/ }),
629/* 2 */
630/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
631
632
633
634Object.defineProperty(exports, "__esModule", ({
635  value: true
636}));
637exports.arrayByteLength = arrayByteLength;
638exports.arraysToBytes = arraysToBytes;
639exports.assert = assert;
640exports.bytesToString = bytesToString;
641exports.createObjectURL = createObjectURL;
642exports.createPromiseCapability = createPromiseCapability;
643exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
644exports.escapeString = escapeString;
645exports.getModificationDate = getModificationDate;
646exports.getVerbosityLevel = getVerbosityLevel;
647exports.info = info;
648exports.isArrayBuffer = isArrayBuffer;
649exports.isArrayEqual = isArrayEqual;
650exports.isAscii = isAscii;
651exports.isBool = isBool;
652exports.isNum = isNum;
653exports.isSameOrigin = isSameOrigin;
654exports.isString = isString;
655exports.objectFromMap = objectFromMap;
656exports.objectSize = objectSize;
657exports.removeNullCharacters = removeNullCharacters;
658exports.setVerbosityLevel = setVerbosityLevel;
659exports.shadow = shadow;
660exports.string32 = string32;
661exports.stringToBytes = stringToBytes;
662exports.stringToPDFString = stringToPDFString;
663exports.stringToUTF16BEString = stringToUTF16BEString;
664exports.stringToUTF8String = stringToUTF8String;
665exports.unreachable = unreachable;
666exports.utf8StringToString = utf8StringToString;
667exports.warn = warn;
668exports.VerbosityLevel = exports.Util = exports.UNSUPPORTED_FEATURES = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.TextRenderingMode = exports.StreamType = exports.PermissionFlag = exports.PasswordResponses = exports.PasswordException = exports.PageActionEventType = exports.OPS = exports.MissingPDFException = exports.IsLittleEndianCached = exports.IsEvalSupportedCached = exports.InvalidPDFException = exports.ImageKind = exports.IDENTITY_MATRIX = exports.FormatError = exports.FontType = exports.FONT_IDENTITY_MATRIX = exports.DocumentActionEventType = exports.CMapCompressionType = exports.BaseException = exports.AnnotationType = exports.AnnotationStateModelType = exports.AnnotationReviewState = exports.AnnotationReplyType = exports.AnnotationMarkedState = exports.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationBorderStyleType = exports.AnnotationActionEventType = exports.AbortException = void 0;
669
670__w_pdfjs_require__(3);
671
672const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
673exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
674const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
675exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
676const PermissionFlag = {
677  PRINT: 0x04,
678  MODIFY_CONTENTS: 0x08,
679  COPY: 0x10,
680  MODIFY_ANNOTATIONS: 0x20,
681  FILL_INTERACTIVE_FORMS: 0x100,
682  COPY_FOR_ACCESSIBILITY: 0x200,
683  ASSEMBLE: 0x400,
684  PRINT_HIGH_QUALITY: 0x800
685};
686exports.PermissionFlag = PermissionFlag;
687const TextRenderingMode = {
688  FILL: 0,
689  STROKE: 1,
690  FILL_STROKE: 2,
691  INVISIBLE: 3,
692  FILL_ADD_TO_PATH: 4,
693  STROKE_ADD_TO_PATH: 5,
694  FILL_STROKE_ADD_TO_PATH: 6,
695  ADD_TO_PATH: 7,
696  FILL_STROKE_MASK: 3,
697  ADD_TO_PATH_FLAG: 4
698};
699exports.TextRenderingMode = TextRenderingMode;
700const ImageKind = {
701  GRAYSCALE_1BPP: 1,
702  RGB_24BPP: 2,
703  RGBA_32BPP: 3
704};
705exports.ImageKind = ImageKind;
706const AnnotationType = {
707  TEXT: 1,
708  LINK: 2,
709  FREETEXT: 3,
710  LINE: 4,
711  SQUARE: 5,
712  CIRCLE: 6,
713  POLYGON: 7,
714  POLYLINE: 8,
715  HIGHLIGHT: 9,
716  UNDERLINE: 10,
717  SQUIGGLY: 11,
718  STRIKEOUT: 12,
719  STAMP: 13,
720  CARET: 14,
721  INK: 15,
722  POPUP: 16,
723  FILEATTACHMENT: 17,
724  SOUND: 18,
725  MOVIE: 19,
726  WIDGET: 20,
727  SCREEN: 21,
728  PRINTERMARK: 22,
729  TRAPNET: 23,
730  WATERMARK: 24,
731  THREED: 25,
732  REDACT: 26
733};
734exports.AnnotationType = AnnotationType;
735const AnnotationStateModelType = {
736  MARKED: "Marked",
737  REVIEW: "Review"
738};
739exports.AnnotationStateModelType = AnnotationStateModelType;
740const AnnotationMarkedState = {
741  MARKED: "Marked",
742  UNMARKED: "Unmarked"
743};
744exports.AnnotationMarkedState = AnnotationMarkedState;
745const AnnotationReviewState = {
746  ACCEPTED: "Accepted",
747  REJECTED: "Rejected",
748  CANCELLED: "Cancelled",
749  COMPLETED: "Completed",
750  NONE: "None"
751};
752exports.AnnotationReviewState = AnnotationReviewState;
753const AnnotationReplyType = {
754  GROUP: "Group",
755  REPLY: "R"
756};
757exports.AnnotationReplyType = AnnotationReplyType;
758const AnnotationFlag = {
759  INVISIBLE: 0x01,
760  HIDDEN: 0x02,
761  PRINT: 0x04,
762  NOZOOM: 0x08,

763  NOROTATE: 0x10,
764  NOVIEW: 0x20,
765  READONLY: 0x40,
766  LOCKED: 0x80,
767  TOGGLENOVIEW: 0x100,
768  LOCKEDCONTENTS: 0x200
769};
770exports.AnnotationFlag = AnnotationFlag;
771const AnnotationFieldFlag = {
772  READONLY: 0x0000001,
773  REQUIRED: 0x0000002,
774  NOEXPORT: 0x0000004,
775  MULTILINE: 0x0001000,
776  PASSWORD: 0x0002000,
777  NOTOGGLETOOFF: 0x0004000,
778  RADIO: 0x0008000,
779  PUSHBUTTON: 0x0010000,
780  COMBO: 0x0020000,
781  EDIT: 0x0040000,
782  SORT: 0x0080000,
783  FILESELECT: 0x0100000,
784  MULTISELECT: 0x0200000,
785  DONOTSPELLCHECK: 0x0400000,
786  DONOTSCROLL: 0x0800000,
787  COMB: 0x1000000,
788  RICHTEXT: 0x2000000,
789  RADIOSINUNISON: 0x2000000,
790  COMMITONSELCHANGE: 0x4000000
791};
792exports.AnnotationFieldFlag = AnnotationFieldFlag;
793const AnnotationBorderStyleType = {
794  SOLID: 1,
795  DASHED: 2,
796  BEVELED: 3,
797  INSET: 4,
798  UNDERLINE: 5
799};
800exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
801const AnnotationActionEventType = {
802  E: "Mouse Enter",
803  X: "Mouse Exit",
804  D: "Mouse Down",
805  U: "Mouse Up",
806  Fo: "Focus",
807  Bl: "Blur",
808  PO: "PageOpen",
809  PC: "PageClose",
810  PV: "PageVisible",
811  PI: "PageInvisible",
812  K: "Keystroke",
813  F: "Format",
814  V: "Validate",
815  C: "Calculate"
816};
817exports.AnnotationActionEventType = AnnotationActionEventType;
818const DocumentActionEventType = {
819  WC: "WillClose",
820  WS: "WillSave",
821  DS: "DidSave",
822  WP: "WillPrint",
823  DP: "DidPrint"
824};
825exports.DocumentActionEventType = DocumentActionEventType;
826const PageActionEventType = {
827  O: "PageOpen",
828  C: "PageClose"
829};
830exports.PageActionEventType = PageActionEventType;
831const StreamType = {
832  UNKNOWN: "UNKNOWN",
833  FLATE: "FLATE",
834  LZW: "LZW",
835  DCT: "DCT",
836  JPX: "JPX",
837  JBIG: "JBIG",
838  A85: "A85",
839  AHX: "AHX",
840  CCF: "CCF",
841  RLX: "RLX"
842};
843exports.StreamType = StreamType;
844const FontType = {
845  UNKNOWN: "UNKNOWN",
846  TYPE1: "TYPE1",
847  TYPE1C: "TYPE1C",
848  CIDFONTTYPE0: "CIDFONTTYPE0",
849  CIDFONTTYPE0C: "CIDFONTTYPE0C",
850  TRUETYPE: "TRUETYPE",
851  CIDFONTTYPE2: "CIDFONTTYPE2",
852  TYPE3: "TYPE3",
853  OPENTYPE: "OPENTYPE",
854  TYPE0: "TYPE0",
855  MMTYPE1: "MMTYPE1"
856};
857exports.FontType = FontType;
858const VerbosityLevel = {
859  ERRORS: 0,
860  WARNINGS: 1,
861  INFOS: 5
862};
863exports.VerbosityLevel = VerbosityLevel;
864const CMapCompressionType = {
865  NONE: 0,
866  BINARY: 1,
867  STREAM: 2
868};
869exports.CMapCompressionType = CMapCompressionType;
870const OPS = {
871  dependency: 1,
872  setLineWidth: 2,
873  setLineCap: 3,
874  setLineJoin: 4,
875  setMiterLimit: 5,
876  setDash: 6,
877  setRenderingIntent: 7,
878  setFlatness: 8,
879  setGState: 9,
880  save: 10,
881  restore: 11,
882  transform: 12,
883  moveTo: 13,
884  lineTo: 14,
885  curveTo: 15,
886  curveTo2: 16,

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

1188  }
1189
1190  return bytes;
1191}
1192
1193function arrayByteLength(arr) {
1194  if (arr.length !== undefined) {
1195    return arr.length;
1196  }
1197
1198  assert(arr.byteLength !== undefined, "arrayByteLength - invalid argument.");
1199  return arr.byteLength;
1200}
1201
1202function arraysToBytes(arr) {
1203  const length = arr.length;
1204
1205  if (length === 1 && arr[0] instanceof Uint8Array) {
1206    return arr[0];
1207  }
1208
1209  let resultLength = 0;
1210
1211  for (let i = 0; i < length; i++) {
1212    resultLength += arrayByteLength(arr[i]);
1213  }
1214
1215  let pos = 0;
1216  const data = new Uint8Array(resultLength);
1217
1218  for (let i = 0; i < length; i++) {
1219    let item = arr[i];
1220
1221    if (!(item instanceof Uint8Array)) {
1222      if (typeof item === "string") {
1223        item = stringToBytes(item);
1224      } else {
1225        item = new Uint8Array(item);
1226      }
1227    }
1228
1229    const itemLength = item.byteLength;
1230    data.set(item, pos);
1231    pos += itemLength;
1232  }
1233
1234  return data;
1235}
1236
1237function string32(value) {
1238  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
1239}
1240
1241function objectSize(obj) {
1242  return Object.keys(obj).length;
1243}
1244
1245function objectFromMap(map) {
1246  const obj = Object.create(null);
1247
1248  for (const [key, value] of map) {
1249    obj[key] = value;
1250  }
1251
1252  return obj;
1253}
1254
1255function isLittleEndian() {
1256  const buffer8 = new Uint8Array(4);
1257  buffer8[0] = 1;
1258  const view32 = new Uint32Array(buffer8.buffer, 0, 1);
1259  return view32[0] === 1;
1260}
1261
1262const IsLittleEndianCached = {
1263  get value() {
1264    return shadow(this, "value", isLittleEndian());
1265  }
1266
1267};
1268exports.IsLittleEndianCached = IsLittleEndianCached;
1269
1270function isEvalSupported() {
1271  try {
1272    new Function("");
1273    return true;
1274  } catch (e) {
1275    return false;
1276  }
1277}
1278
1279const IsEvalSupportedCached = {
1280  get value() {
1281    return shadow(this, "value", isEvalSupported());
1282  }
1283
1284};
1285exports.IsEvalSupportedCached = IsEvalSupportedCached;
1286const hexNumbers = [...Array(256).keys()].map(n => n.toString(16).padStart(2, "0"));
1287
1288class Util {
1289  static makeHexColor(r, g, b) {
1290    return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`;
1291  }
1292
1293  static transform(m1, m2) {
1294    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]];
1295  }
1296
1297  static applyTransform(p, m) {
1298    const xt = p[0] * m[0] + p[1] * m[2] + m[4];
1299    const yt = p[0] * m[1] + p[1] * m[3] + m[5];
1300    return [xt, yt];
1301  }
1302
1303  static applyInverseTransform(p, m) {
1304    const d = m[0] * m[3] - m[1] * m[2];
1305    const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
1306    const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
1307    return [xt, yt];
1308  }
1309
1310  static getAxialAlignedBoundingBox(r, m) {
1311    const p1 = Util.applyTransform(r, m);
1312    const p2 = Util.applyTransform(r.slice(2, 4), m);
1313    const p3 = Util.applyTransform([r[0], r[3]], m);
1314    const p4 = Util.applyTransform([r[2], r[1]], m);
1315    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])];
1316  }
1317
1318  static inverseTransform(m) {
1319    const d = m[0] * m[3] - m[1] * m[2];
1320    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];
1321  }
1322
1323  static apply3dTransform(m, v) {
1324    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]];
1325  }
1326
1327  static singularValueDecompose2dScale(m) {
1328    const transpose = [m[0], m[2], m[1], m[3]];
1329    const a = m[0] * transpose[0] + m[1] * transpose[2];
1330    const b = m[0] * transpose[1] + m[1] * transpose[3];
1331    const c = m[2] * transpose[0] + m[3] * transpose[2];
1332    const d = m[2] * transpose[1] + m[3] * transpose[3];
1333    const first = (a + d) / 2;
1334    const second = Math.sqrt((a + d) ** 2 - 4 * (a * d - c * b)) / 2;
1335    const sx = first + second || 1;
1336    const sy = first - second || 1;
1337    return [Math.sqrt(sx), Math.sqrt(sy)];
1338  }
1339
1340  static normalizeRect(rect) {
1341    const r = rect.slice(0);
1342
1343    if (rect[0] > rect[2]) {
1344      r[0] = rect[2];
1345      r[2] = rect[0];
1346    }
1347
1348    if (rect[1] > rect[3]) {
1349      r[1] = rect[3];
1350      r[3] = rect[1];
1351    }
1352
1353    return r;
1354  }
1355
1356  static intersect(rect1, rect2) {
1357    function compare(a, b) {
1358      return a - b;
1359    }
1360
1361    const orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare);

1362    const orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare);
1363    const result = [];
1364    rect1 = Util.normalizeRect(rect1);
1365    rect2 = Util.normalizeRect(rect2);
1366
1367    if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
1368      result[0] = orderedX[1];
1369      result[2] = orderedX[2];
1370    } else {
1371      return null;
1372    }
1373
1374    if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
1375      result[1] = orderedY[1];
1376      result[3] = orderedY[2];
1377    } else {
1378      return null;
1379    }
1380
1381    return result;
1382  }
1383
1384}
1385
1386exports.Util = Util;
1387const 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];
1388
1389function stringToPDFString(str) {
1390  const length = str.length,
1391        strBuf = [];
1392
1393  if (str[0] === "\xFE" && str[1] === "\xFF") {
1394    for (let i = 2; i < length; i += 2) {
1395      strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
1396    }
1397  } else if (str[0] === "\xFF" && str[1] === "\xFE") {
1398    for (let i = 2; i < length; i += 2) {
1399      strBuf.push(String.fromCharCode(str.charCodeAt(i + 1) << 8 | str.charCodeAt(i)));
1400    }
1401  } else {
1402    for (let i = 0; i < length; ++i) {
1403      const code = PDFStringTranslateTable[str.charCodeAt(i)];
1404      strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
1405    }
1406  }
1407
1408  return strBuf.join("");
1409}
1410
1411function escapeString(str) {
1412  return str.replace(/([()\\\n\r])/g, match => {
1413    if (match === "\n") {
1414      return "\\n";
1415    } else if (match === "\r") {
1416      return "\\r";
1417    }
1418
1419    return `\\${match}`;
1420  });
1421}
1422
1423function isAscii(str) {
1424  return /^[\x00-\x7F]*$/.test(str);
1425}
1426
1427function stringToUTF16BEString(str) {
1428  const buf = ["\xFE\xFF"];
1429
1430  for (let i = 0, ii = str.length; i < ii; i++) {
1431    const char = str.charCodeAt(i);
1432    buf.push(String.fromCharCode(char >> 8 & 0xff), String.fromCharCode(char & 0xff));
1433  }
1434
1435  return buf.join("");
1436}
1437
1438function stringToUTF8String(str) {
1439  return decodeURIComponent(escape(str));
1440}
1441
1442function utf8StringToString(str) {
1443  return unescape(encodeURIComponent(str));
1444}
1445
1446function isBool(v) {
1447  return typeof v === "boolean";
1448}
1449
1450function isNum(v) {
1451  return typeof v === "number";
1452}
1453
1454function isString(v) {
1455  return typeof v === "string";
1456}
1457
1458function isArrayBuffer(v) {
1459  return typeof v === "object" && v !== null && v.byteLength !== undefined;
1460}
1461
1462function isArrayEqual(arr1, arr2) {
1463  if (arr1.length !== arr2.length) {
1464    return false;
1465  }
1466
1467  for (let i = 0, ii = arr1.length; i < ii; i++) {
1468    if (arr1[i] !== arr2[i]) {
1469      return false;
1470    }
1471  }
1472
1473  return true;
1474}
1475
1476function getModificationDate(date = new Date()) {
1477  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")];
1478  return buffer.join("");
1479}
1480
1481function createPromiseCapability() {
1482  const capability = Object.create(null);
1483  let isSettled = false;
1484  Object.defineProperty(capability, "settled", {
1485    get() {
1486      return isSettled;
1487    }
1488
1489  });
1490  capability.promise = new Promise(function (resolve, reject) {
1491    capability.resolve = function (data) {
1492      isSettled = true;
1493      resolve(data);
1494    };
1495
1496    capability.reject = function (reason) {
1497      isSettled = true;
1498      reject(reason);
1499    };
1500  });
1501  return capability;
1502}
1503
1504function createObjectURL(data, contentType = "", forceDataSchema = false) {
1505  if (URL.createObjectURL && !forceDataSchema) {
1506    return URL.createObjectURL(new Blob([data], {
1507      type: contentType
1508    }));
1509  }
1510
1511  const digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789

1511+/=";
1512  let buffer = `data:${contentType};base64,`;
1513
1514  for (let i = 0, ii = data.length; i < ii; i += 3) {
1515    const b1 = data[i] & 0xff;
1516    const b2 = data[i + 1] & 0xff;
1517    const b3 = data[i + 2] & 0xff;
1518    const d1 = b1 >> 2,
1519          d2 = (b1 & 3) << 4 | b2 >> 4;
1520    const d3 = i + 1 < ii ? (b2 & 0xf) << 2 | b3 >> 6 : 64;
1521    const d4 = i + 2 < ii ? b3 & 0x3f : 64;
1522    buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];
1523  }
1524
1525  return buffer;
1526}
1527
1528/***/ }),
1529/* 3 */
1530/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
1531
1532
1533
1534var _is_node = __w_pdfjs_require__(4);
1535
1536;
1537
1538/***/ }),
1539/* 4 */
1540/***/ ((__unused_webpack_module, exports) => {
1541
1542
1543
1544Object.defineProperty(exports, "__esModule", ({
1545  value: true
1546}));
1547exports.isNodeJS = void 0;
1548const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
1549exports.isNodeJS = isNodeJS;
1550
1551/***/ }),
1552/* 5 */
1553/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
1554
1555
1556
1557Object.defineProperty(exports, "__esModule", ({
1558  value: true
1559}));
1560exports.getDocument = getDocument;
1561exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory;
1562exports.version = exports.PDFWorker = exports.PDFPageProxy = exports.PDFDocumentProxy = exports.PDFDataRangeTransport = exports.LoopbackPort = exports.DefaultCMapReaderFactory = exports.DefaultCanvasFactory = exports.build = void 0;
1563
1564var _util = __w_pdfjs_require__(2);
1565
1566var _display_utils = __w_pdfjs_require__(1);
1567
1568var _font_loader = __w_pdfjs_require__(6);
1569
1570var _node_utils = __w_pdfjs_require__(7);
1571
1572var _annotation_storage = __w_pdfjs_require__(8);
1573
1574var _api_compatibility = __w_pdfjs_require__(9);
1575
1576var _canvas = __w_pdfjs_require__(10);
1577
1578var _worker_options = __w_pdfjs_require__(12);
1579
1580var _is_node = __w_pdfjs_require__(4);
1581
1582var _message_handler = __w_pdfjs_require__(13);
1583
1584var _metadata = __w_pdfjs_require__(14);
1585
1586var _optional_content_config = __w_pdfjs_require__(15);
1587
1588var _transport_stream = __w_pdfjs_require__(16);
1589
1590const DEFAULT_RANGE_CHUNK_SIZE = 65536;
1591const RENDERING_CANCELLED_TIMEOUT = 100;
1592const DefaultCanvasFactory = _is_node.isNodeJS ? _node_utils.NodeCanvasFactory : _display_utils.DOMCanvasFactory;
1593exports.DefaultCanvasFactory = DefaultCanvasFactory;
1594const DefaultCMapReaderFactory = _is_node.isNodeJS ? _node_utils.NodeCMapReaderFactory : _display_utils.DOMCMapReaderFactory;
1595exports.DefaultCMapReaderFactory = DefaultCMapReaderFactory;
1596let createPDFNetworkStream;
1597
1598function setPDFNetworkStreamFactory(pdfNetworkStreamFactory) {
1599  createPDFNetworkStream = pdfNetworkStreamFactory;
1600}
1601
1602function getDocument(src) {
1603  const task = new PDFDocumentLoadingTask();
1604  let source;
1605
1606  if (typeof src === "string" || src instanceof URL) {
1607    source = {
1608      url: src
1609    };
1610  } else if ((0, _util.isArrayBuffer)(src)) {
1611    source = {
1612      data: src
1613    };
1614  } else if (src instanceof PDFDataRangeTransport) {
1615    source = {
1616      range: src
1617    };
1618  } else {
1619    if (typeof src !== "object") {
1620      throw new Error("Invalid parameter in getDocument, " + "need either string, URL, Uint8Array, or parameter object.");
1621    }
1622
1623    if (!src.url && !src.data && !src.range) {
1624      throw new Error("Invalid parameter object: need either .data, .range or .url");
1625    }
1626
1627    source = src;
1628  }
1629
1630  const params = Object.create(null);
1631  let rangeTransport = null,
1632      worker = null;
1633
1634  for (const key in source) {
1635    const value = source[key];
1636
1637    switch (key) {
1638      case "url":
1639        if (typeof window !== "undefined") {
1640          try {
1641            params[key] = new URL(value, window.location).href;
1642            continue;
1643          } catch (ex) {
1644            (0, _util.warn)(`Cannot create valid URL: "${ex}".`);
1645          }
1646        } else if (typeof value === "string" || value instanceof URL) {
1647          params[key] = value.toString();
1648          continue;
1649        }
1650
1651        throw new Error("Invalid PDF url data: " + "either string or URL-object is expected in the url property.");
1652
1653      case "range":
1654        rangeTransport = value;
1655        continue;
1656
1657      case "worker":
1658        worker = value;
1659        continue;
1660
1661      case "data":
1662        if (_is_node.isNodeJS && typeof Buffer !== "undefined" && value instanceof Buffer) {
1663          params[key] = new Uint8Array(value);
1664        } else if (value instanceof Uint8Array) {
1665          break;
1666        } else if (typeof value === "string") {
1667          params[key] = (0, _util.stringToBytes)(value);
1668        } else if (typeof value === "object" && value !== null && !isNaN(value.length)) {
1669          params[key] = new Uint8Array(value);
1670        } else if ((0, _util.isArrayBuffer)(value)) {
1671          params[key] = new Uint8Array(value);
1672        } else {
1673          throw new Error("Invalid PDF binary data: either typed array, " + "string, or array-like object is expected in the data property.");
1674        }
1675
1676        continue;
1677    }
1678
1679    params[key] = value;
1680  }
1681
1682  params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE;
1683  params.CMapReaderFactory = params.CMapReaderFactory || DefaultCMapReaderFactory;
1684  params.ignoreErrors = params.stopAtErrors !== true;
1685  params.fontExtraProperties = params.fontExtraProperties === true;
1686  params.pdfBug = params.pdfBug === true;
1687  params.enableXfa = params.enableXfa === true;
1688
1689  if (typeof params.docBaseUrl !== "string" || (0, _display_utils.isDataScheme)(params.docBaseUrl)) {
1690    params.docBaseUrl = null;
1691  }
1692
1693  if (!Number.isInteger(params.maxImageSize)) {
1694    params.maxImageSize = -1;
1695  }
1696
1697  if (typeof params.isEvalSupported !== "boolean") {
1698    params.isEvalSupported = true;
1699  }
1700
1701  if (typeof params.disableFontFace !== "boolean") {
1702    params.disableFontFace = _api_compatibility.apiCompatibilityParams.disableFontFace || false;
1703  }
1704
1705  if (typeof params.ownerDocument === "undefined") {
1706    params.ownerDocument = globalThis.document;
1707  }
1708
1709  if (typeof params.disableRange !== "boolean") {
1710    params.disableRange = false;

1711  }
1712
1713  if (typeof params.disableStream !== "boolean") {
1714    params.disableStream = false;
1715  }
1716
1717  if (typeof params.disableAutoFetch !== "boolean") {
1718    params.disableAutoFetch = false;
1719  }
1720
1721  (0, _util.setVerbosityLevel)(params.verbosity);
1722
1723  if (!worker) {
1724    const workerParams = {
1725      verbosity: params.verbosity,
1726      port: _worker_options.GlobalWorkerOptions.workerPort
1727    };
1728    worker = workerParams.port ? PDFWorker.fromPort(workerParams) : new PDFWorker(workerParams);
1729    task._worker = worker;
1730  }
1731
1732  const docId = task.docId;
1733  worker.promise.then(function () {
1734    if (task.destroyed) {
1735      throw new Error("Loading aborted");
1736    }
1737
1738    const workerIdPromise = _fetchDocument(worker, params, rangeTransport, docId);
1739
1740    const networkStreamPromise = new Promise(function (resolve) {
1741      let networkStream;
1742
1743      if (rangeTransport) {
1744        networkStream = new _transport_stream.PDFDataTransportStream({
1745          length: params.length,
1746          initialData: params.initialData,
1747          progressiveDone: params.progressiveDone,
1748          contentDispositionFilename: params.contentDispositionFilename,
1749          disableRange: params.disableRange,
1750          disableStream: params.disableStream
1751        }, rangeTransport);
1752      } else if (!params.data) {
1753        networkStream = createPDFNetworkStream({
1754          url: params.url,
1755          length: params.length,
1756          httpHeaders: params.httpHeaders,
1757          withCredentials: params.withCredentials,
1758          rangeChunkSize: params.rangeChunkSize,
1759          disableRange: params.disableRange,
1760          disableStream: params.disableStream
1761        });
1762      }
1763
1764      resolve(networkStream);
1765    });
1766    return Promise.all([workerIdPromise, networkStreamPromise]).then(function ([workerId, networkStream]) {
1767      if (task.destroyed) {
1768        throw new Error("Loading aborted");
1769      }
1770
1771      const messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port);
1772      messageHandler.postMessageTransfers = worker.postMessageTransfers;
1773      const transport = new WorkerTransport(messageHandler, task, networkStream, params);
1774      task._transport = transport;
1775      messageHandler.send("Ready", null);
1776    });
1777  }).catch(task._capability.reject);
1778  return task;
1779}
1780
1781function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {
1782  if (worker.destroyed) {
1783    return Promise.reject(new Error("Worker was destroyed"));
1784  }
1785
1786  if (pdfDataRangeTransport) {
1787    source.length = pdfDataRangeTransport.length;
1788    source.initialData = pdfDataRangeTransport.initialData;
1789    source.progressiveDone = pdfDataRangeTransport.progressiveDone;
1790    source.contentDispositionFilename = pdfDataRangeTransport.contentDispositionFilename;
1791  }
1792
1793  return worker.messageHandler.sendWithPromise("GetDocRequest", {
1794    docId,
1795    apiVersion: '2.9.359',
1796    source: {
1797      data: source.data,
1798      url: source.url,
1799      password: source.password,
1800      disableAutoFetch: source.disableAutoFetch,
1801      rangeChunkSize: source.rangeChunkSize,
1802      length: source.length
1803    },
1804    maxImageSize: source.maxImageSize,
1805    disableFontFace: source.disableFontFace,
1806    postMessageTransfers: worker.postMessageTransfers,
1807    docBaseUrl: source.docBaseUrl,
1808    ignoreErrors: source.ignoreErrors,
1809    isEvalSupported: source.isEvalSupported,
1810    fontExtraProperties: source.fontExtraProperties,
1811    enableXfa: source.enableXfa
1812  }).then(function (workerId) {
1813    if (worker.destroyed) {
1814      throw new Error("Worker was destroyed");
1815    }
1816
1817    return workerId;
1818  });
1819}
1820
1821const PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() {
1822  let nextDocumentId = 0;
1823
1824  class PDFDocumentLoadingTask {
1825    constructor() {
1826      this._capability = (0, _util.createPromiseCapability)();
1827      this._transport = null;
1828      this._worker = null;
1829      this.docId = "d" + nextDocumentId++;
1830      this.destroyed = false;
1831      this.onPassword = null;
1832      this.onProgress = null;
1833      this.onUnsupportedFeature = null;
1834    }
1835
1836    get promise() {
1837      return this._capability.promise;
1838    }
1839
1840    destroy() {
1841      this.destroyed = true;
1842      const transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy();
1843      return transportDestroyed.then(() => {
1844        this._transport = null;
1845
1846        if (this._worker) {
1847          this._worker.destroy();
1848
1849          this._worker = null;
1850        }
1851      });
1852    }
1853
1854  }
1855
1856  return PDFDocumentLoadingTask;
1857}();
1858
1859class PDFDataRangeTransport {
1860  constructor(length, initialData, progressiveDone = false, contentDispositionFilename = null) {
1861    this.length = length;
1862    this.initialData = initialData;
1863    this.progressiveDone = progressiveDone;
1864    this.contentDispositionFilename = contentDispositionFilename;
1865    this._rangeListeners = [];
1866    this._progressListeners = [];
1867    this._progressiveReadListeners = [];
1868    this._progressiveDoneListeners = [];
1869    this._readyCapability = (0, _util.createPromiseCapability)();
1870  }
1871
1872  addRangeListener(listener) {
1873    this._rangeListeners.push(listener);
1874  }
1875
1876  addProgressListener(listener) {
1877    this._progressListeners.push(listener);
1878  }
1879
1880  addProgressiveReadListener(listener) {
1881    this._progressiveReadListeners.push(listener);
1882  }
1883
1884  addProgressiveDoneListener(listener) {
1885    this._progressiveDoneListeners.push(listener);
1886  }
1887
1888  onDataRange(begin, chunk) {
1889    for (const listener of this._rangeListeners) {
1890      listener(begin, chunk);
1891    }
1892  }
1893
1894  onDataProgress(loaded, total) {
1895    this._readyCapability.promise.then(() => {
1896      for (const listener of this._progressListeners) {
1897        listener(loaded, total);
1898      }
1899    });
1900  }
1901
1902  onDataProgressiveRead(chunk) {
1903    this._readyCapability.promise.then(() => {
1904      for (const listener of this._progressiveReadListeners) {
1905        listener(chunk);
1906      }
1907    });
1908  }
1909
1910  onDataProgressiveDone() {
1911    this._readyCapability.promise.then(() => {
1912      for (const listener of this._progressiveDoneListeners) {
1913        listener();
1914      }
1915    });
1916  }
1917
1918  transportReady() {
1919    this._readyCapability.resolve();
1920  }
1921
1922  requestDataRange(begin, end) {
1923    (0, _util.unreachable)("Abstract method PDFDataRangeTransport.requestDataRange");
1924  }
1925
1926  abort() {}
1927
1928}
1929
1930exports.PDFDataRangeTransport = PDFDataRangeTransport;
1931
1932class PDFDocumentProxy {
1933  constructor(pdfInfo, transport) {
1934    this._pdfInfo = pdfInfo;
1935    this._transport = transport;
1936  }
1937
1938  get annotationStorage() {
1939    return this._transport.annotationStorage;
1940  }
1941
1942  get numPages() {
1943    return this._pdfInfo.numPages;
1944  }
1945
1946  get fingerprint() {
1947    return this._pdfInfo.fingerprint;
1948  }
1949
1950  get isPureXfa() {
1951    return this._pdfInfo.isPureXfa;
1952  }
1953
1954  getPage(pageNumber) {
1955    return this._transport.getPage(pageNumber);
1956  }
1957
1958  getPageIndex(ref) {
1959    return this._transport.getPageIndex(ref);
1960  }
1961
1962  getDestinations() {
1963    return this._transport.getDestinations();
1964  }
1965
1966  getDestination(id) {
1967    return this._transport.getDestination(id);
1968  }
1969
1970  getPageLabels() {
1971    return this._transport.getPageLabels();
1972  }
1973
1974  getPageLayout() {
1975    return this._transport.getPageLayout();
1976  }
1977
1978  getPageMode() {
1979    return this._transport.getPageMode();
1980  }
1981
1982  getViewerPreferences() {
1983    return this._transport.getViewerPreferences();
1984  }
1985
1986  getOpenAction() {
1987    return this._transport.getOpenAction();
1988  }
1989
1990  getAttachments() {
1991    return this._transport.getAttachments();
1992  }
1993
1994  getJavaScript() {
1995    return this._transport.getJavaScript();
1996  }
1997
1998  getJSActions() {
1999    return this._transport.getDocJSActions();
2000  }
2001
2002  getOutline() {
2003    return this._transport.getOutline();
2004  }
2005
2006  getOptionalContentConfig() {
2007    return this._transport.getOptionalContentConfig();
2008  }
2009
2010  getPermissions() {
2011    return this._transport.getPermissions();
2012  }
2013
2014  getMetadata() {
2015    return this._transport.getMetadata();
2016  }
2017
2018  getMarkInfo() {
2019    return this._transport.getMarkInfo();
2020  }
2021
2022  getData() {
2023    return this._transport.getData();
2024  }
2025
2026  getDownloadInfo() {
2027    return this._transport.downloadInfoCapability.promise;
2028  }
2029
2030  getStats() {
2031    return this._transport.getStats();
2032  }
2033
2034  cleanup(keepLoadedFonts = false) {
2035    return this._transport.startCleanup(keepLoadedFonts || this.isPureXfa);
2036  }
2037
2038  destroy() {
2039    return this.loadingTask.destroy();
2040  }
2041
2042  get loadingParams() {
2043    return this._transport.loadingParams;
2044  }
2045
2046  get loadingTask() {
2047    return this._transport.loadingTask;
2048  }
2049
2050  saveDocument() {
2051    if (arguments.length > 0) {
2052      (0, _display_utils.deprecated)("saveDocument no longer accepts any options.");
2053    }
2054
2055    if (this._transport.annotationStorage.size <= 0) {
2056      (0, _display_utils.deprecated)("saveDocument called while `annotationStorage` is empty, " + "please use the getData-method instead.");
2057    }
2058
2059    return this._transport.saveDocument();
2060  }
2061
2062  getFieldObjects() {
2063    return this._transport.getFieldObjects();
2064  }
2065
2066  hasJSActions() {
2067    return this._transport.hasJSActions();
2068  }
2069
2070  getCalculationOrderIds() {
2071    return this._transport.getCalculationOrderIds();
2072  }
2073
2074}
2075
2076exports.PDFDocumentProxy = PDFDocumentProxy;
2077
2078class PDFPageProxy {
2079  constructor(pageIndex, pageInfo, transport, ownerDocument, pdfBug = false) {
2080    this._pageIndex = pageIndex;
2081    this._pageInfo = pageInfo;
2082    this._ownerDocument = ownerDocument;
2083    this._transport = transport;
2084    this._stats = pdfBug ? new _display_utils.StatTimer() : null;
2085    this._pdfBug = pdfBug;
2086    this.commonObjs = transport.commonObjs;
2087    this.objs = new PDFObjects();
2088    this.cleanupAfterRender = false;

2089    this.pendingCleanup = false;
2090    this._intentStates = new Map();
2091    this.destroyed = false;
2092  }
2093
2094  get pageNumber() {
2095    return this._pageIndex + 1;
2096  }
2097
2098  get rotate() {
2099    return this._pageInfo.rotate;
2100  }
2101
2102  get ref() {
2103    return this._pageInfo.ref;
2104  }
2105
2106  get userUnit() {
2107    return this._pageInfo.userUnit;
2108  }
2109
2110  get view() {
2111    return this._pageInfo.view;
2112  }
2113
2114  getViewport({
2115    scale,
2116    rotation = this.rotate,
2117    offsetX = 0,
2118    offsetY = 0,
2119    dontFlip = false
2120  } = {}) {
2121    return new _display_utils.PageViewport({
2122      viewBox: this.view,
2123      scale,
2124      rotation,
2125      offsetX,
2126      offsetY,
2127      dontFlip
2128    });
2129  }
2130
2131  getAnnotations({
2132    intent = null
2133  } = {}) {
2134    if (!this._annotationsPromise || this._annotationsIntent !== intent) {
2135      this._annotationsPromise = this._transport.getAnnotations(this._pageIndex, intent);
2136      this._annotationsIntent = intent;
2137    }
2138
2139    return this._annotationsPromise;
2140  }
2141
2142  getJSActions() {
2143    return this._jsActionsPromise || (this._jsActionsPromise = this._transport.getPageJSActions(this._pageIndex));
2144  }
2145
2146  getXfa() {
2147    return this._xfaPromise || (this._xfaPromise = this._transport.getPageXfa(this._pageIndex));
2148  }
2149
2150  render({
2151    canvasContext,
2152    viewport,
2153    intent = "display",
2154    renderInteractiveForms = false,
2155    transform = null,
2156    imageLayer = null,
2157    canvasFactory = null,
2158    background = null,
2159    includeAnnotationStorage = false,
2160    optionalContentConfigPromise = null
2161  }) {
2162    var _intentState;
2163
2164    if (arguments[0]?.annotationStorage !== undefined) {
2165      (0, _display_utils.deprecated)("render no longer accepts an `annotationStorage` option, " + "please use the `includeAnnotationStorage`-boolean instead.");
2166      includeAnnotationStorage || (includeAnnotationStorage = !!arguments[0].annotationStorage);
2167    }
2168
2169    if (this._stats) {
2170      this._stats.time("Overall");
2171    }
2172
2173    const renderingIntent = intent === "print" ? "print" : "display";
2174    this.pendingCleanup = false;
2175
2176    if (!optionalContentConfigPromise) {
2177      optionalContentConfigPromise = this._transport.getOptionalContentConfig();
2178    }
2179
2180    let intentState = this._intentStates.get(renderingIntent);
2181
2182    if (!intentState) {
2183      intentState = Object.create(null);
2184
2185      this._intentStates.set(renderingIntent, intentState);
2186    }
2187
2188    if (intentState.streamReaderCancelTimeout) {
2189      clearTimeout(intentState.streamReaderCancelTimeout);
2190      intentState.streamReaderCancelTimeout = null;
2191    }
2192
2193    const canvasFactoryInstance = canvasFactory || new DefaultCanvasFactory({
2194      ownerDocument: this._ownerDocument
2195    });
2196    const annotationStorage = includeAnnotationStorage ? this._transport.annotationStorage.serializable : null;
2197
2198    if (!intentState.displayReadyCapability) {
2199      intentState.displayReadyCapability = (0, _util.createPromiseCapability)();
2200      intentState.operatorList = {
2201        fnArray: [],
2202        argsArray: [],
2203        lastChunk: false
2204      };
2205
2206      if (this._stats) {
2207        this._stats.time("Page Request");
2208      }
2209
2210      this._pumpOperatorList({
2211        pageIndex: this._pageIndex,
2212        intent: renderingIntent,
2213        renderInteractiveForms: renderInteractiveForms === true,
2214        annotationStorage
2215      });
2216    }
2217
2218    const complete = error => {
2219      intentState.renderTasks.delete(internalRenderTask);
2220
2221      if (this.cleanupAfterRender || renderingIntent === "print") {
2222        this.pendingCleanup = true;
2223      }
2224
2225      this._tryCleanup();
2226
2227      if (error) {
2228        internalRenderTask.capability.reject(error);
2229
2230        this._abortOperatorList({
2231          intentState,
2232          reason: error
2233        });
2234      } else {
2235        internalRenderTask.capability.resolve();
2236      }
2237
2238      if (this._stats) {
2239        this._stats.timeEnd("Rendering");
2240
2241        this._stats.timeEnd("Overall");
2242      }
2243    };
2244
2245    const internalRenderTask = new InternalRenderTask({
2246      callback: complete,
2247      params: {
2248        canvasContext,
2249        viewport,
2250        transform,
2251        imageLayer,
2252        background
2253      },
2254      objs: this.objs,
2255      commonObjs: this.commonObjs,
2256      operatorList: intentState.operatorList,
2257      pageIndex: this._pageIndex,
2258      canvasFactory: canvasFactoryInstance,
2259      useRequestAnimationFrame: renderingIntent !== "print",
2260      pdfBug: this._pdfBug
2261    });
2262    ((_intentState = intentState).renderTasks || (_intentState.renderTasks = new Set())).add(internalRenderTask);
2263    const renderTask = internalRenderTask.task;
2264    Promise.all([intentState.displayReadyCapability.promise, optionalContentConfigPromise]).then(([transparency, optionalContentConfig]) => {
2265      if (this.pendingCleanup) {
2266        complete();
2267        return;
2268      }
2269
2270      if (this._stats) {

2271        this._stats.time("Rendering");
2272      }
2273
2274      internalRenderTask.initializeGraphics({
2275        transparency,
2276        optionalContentConfig
2277      });
2278      internalRenderTask.operatorListChanged();
2279    }).catch(complete);
2280    return renderTask;
2281  }
2282
2283  getOperatorList() {
2284    function operatorListChanged() {
2285      if (intentState.operatorList.lastChunk) {
2286        intentState.opListReadCapability.resolve(intentState.operatorList);
2287        intentState.renderTasks.delete(opListTask);
2288      }
2289    }
2290
2291    const renderingIntent = "oplist";
2292
2293    let intentState = this._intentStates.get(renderingIntent);
2294
2295    if (!intentState) {
2296      intentState = Object.create(null);
2297
2298      this._intentStates.set(renderingIntent, intentState);
2299    }
2300
2301    let opListTask;
2302
2303    if (!intentState.opListReadCapability) {
2304      var _intentState2;
2305
2306      opListTask = Object.create(null);
2307      opListTask.operatorListChanged = operatorListChanged;
2308      intentState.opListReadCapability = (0, _util.createPromiseCapability)();
2309      ((_intentState2 = intentState).renderTasks || (_intentState2.renderTasks = new Set())).add(opListTask);
2310      intentState.operatorList = {
2311        fnArray: [],
2312        argsArray: [],
2313        lastChunk: false
2314      };
2315
2316      if (this._stats) {
2317        this._stats.time("Page Request");
2318      }
2319
2320      this._pumpOperatorList({
2321        pageIndex: this._pageIndex,
2322        intent: renderingIntent
2323      });
2324    }
2325
2326    return intentState.opListReadCapability.promise;
2327  }
2328
2329  streamTextContent({
2330    normalizeWhitespace = false,
2331    disableCombineTextItems = false,
2332    includeMarkedContent = false
2333  } = {}) {
2334    const TEXT_CONTENT_CHUNK_SIZE = 100;
2335    return this._transport.messageHandler.sendWithStream("GetTextContent", {
2336      pageIndex: this._pageIndex,
2337      normalizeWhitespace: normalizeWhitespace === true,
2338      combineTextItems: disableCombineTextItems !== true,
2339      includeMarkedContent: includeMarkedContent === true
2340    }, {
2341      highWaterMark: TEXT_CONTENT_CHUNK_SIZE,
2342
2343      size(textContent) {
2344        return textContent.items.length;
2345      }
2346
2347    });
2348  }
2349
2350  getTextContent(params = {}) {
2351    const readableStream = this.streamTextContent(params);
2352    return new Promise(function (resolve, reject) {
2353      function pump() {
2354        reader.read().then(function ({
2355          value,
2356          done
2357        }) {
2358          if (done) {
2359            resolve(textContent);
2360            return;
2361          }
2362
2363          Object.assign(textContent.styles, value.styles);
2364          textContent.items.push(...value.items);
2365          pump();
2366        }, reject);
2367      }
2368
2369      const reader = readableStream.getReader();
2370      const textContent = {
2371        items: [],
2372        styles: Object.create(null)
2373      };
2374      pump();
2375    });
2376  }
2377
2378  getStructTree() {
2379    return this._structTreePromise || (this._structTreePromise = this._transport.getStructTree(this._pageIndex));
2380  }
2381
2382  _destroy() {
2383    this.destroyed = true;
2384    this._transport.pageCache[this._pageIndex] = null;
2385    const waitOn = [];
2386
2387    for (const [intent, intentState] of this._intentStates) {
2388      this._abortOperatorList({
2389        intentState,
2390        reason: new Error("Page was destroyed."),
2391        force: true
2392      });
2393
2394      if (intent === "oplist") {
2395        continue;
2396      }
2397
2398      for (const internalRenderTask of intentState.renderTasks) {
2399        waitOn.push(internalRenderTask.completed);
2400        internalRenderTask.cancel();
2401      }
2402    }
2403
2404    this.objs.clear();
2405    this._annotationsPromise = null;
2406    this._jsActionsPromise = null;
2407    this._xfaPromise = null;
2408    this._structTreePromise = null;
2409    this.pendingCleanup = false;
2410    return Promise.all(waitOn);
2411  }
2412
2413  cleanup(resetStats = false) {
2414    this.pendingCleanup = true;
2415    return this._tryCleanup(resetStats);
2416  }
2417
2418  _tryCleanup(resetStats = false) {
2419    if (!this.pendingCleanup) {
2420      return false;
2421    }
2422
2423    for (const {
2424      renderTasks,
2425      operatorList
2426    } of this._intentStates.values()) {
2427      if (renderTasks.size > 0 || !operatorList.lastChunk) {
2428        return false;
2429      }
2430    }
2431
2432    this._intentStates.clear();
2433
2434    this.objs.clear();

2435    this._annotationsPromise = null;
2436    this._jsActionsPromise = null;
2437    this._xfaPromise = null;
2438    this._structTreePromise = null;
2439
2440    if (resetStats && this._stats) {
2441      this._stats = new _display_utils.StatTimer();
2442    }
2443
2444    this.pendingCleanup = false;
2445    return true;
2446  }
2447
2448  _startRenderPage(transparency, intent) {
2449    const intentState = this._intentStates.get(intent);
2450
2451    if (!intentState) {
2452      return;
2453    }
2454
2455    if (this._stats) {
2456      this._stats.timeEnd("Page Request");
2457    }
2458
2459    if (intentState.displayReadyCapability) {
2460      intentState.displayReadyCapability.resolve(transparency);
2461    }
2462  }
2463
2464  _renderPageChunk(operatorListChunk, intentState) {
2465    for (let i = 0, ii = operatorListChunk.length; i < ii; i++) {
2466      intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);
2467      intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);
2468    }
2469
2470    intentState.operatorList.lastChunk = operatorListChunk.lastChunk;
2471
2472    for (const internalRenderTask of intentState.renderTasks) {
2473      internalRenderTask.operatorListChanged();
2474    }
2475
2476    if (operatorListChunk.lastChunk) {
2477      this._tryCleanup();
2478    }
2479  }
2480
2481  _pumpOperatorList(args) {
2482    (0, _util.assert)(args.intent, 'PDFPageProxy._pumpOperatorList: Expected "intent" argument.');
2483
2484    const readableStream = this._transport.messageHandler.sendWithStream("GetOperatorList", args);
2485
2486    const reader = readableStream.getReader();
2487
2488    const intentState = this._intentStates.get(args.intent);
2489
2490    intentState.streamReader = reader;
2491
2492    const pump = () => {
2493      reader.read().then(({
2494        value,
2495        done
2496      }) => {
2497        if (done) {
2498          intentState.streamReader = null;
2499          return;
2500        }
2501
2502        if (this._transport.destroyed) {
2503          return;
2504        }
2505
2506        this._renderPageChunk(value, intentState);
2507
2508        pump();
2509      }, reason => {
2510        intentState.streamReader = null;
2511
2512        if (this._transport.destroyed) {
2513          return;
2514        }
2515
2516        if (intentState.operatorList) {
2517          intentState.operatorList.lastChunk = true;
2518
2519          for (const internalRenderTask of intentState.renderTasks) {
2520            internalRenderTask.operatorListChanged();
2521          }
2522
2523          this._tryCleanup();
2524        }
2525
2526        if (intentState.displayReadyCapability) {
2527          intentState.displayReadyCapability.reject(reason);
2528        } else if (intentState.opListReadCapability) {
2529          intentState.opListReadCapability.reject(reason);
2530        } else {
2531          throw reason;
2532        }
2533      });
2534    };
2535
2536    pump();
2537  }
2538
2539  _abortOperatorList({
2540    intentState,
2541    reason,
2542    force = false
2543  }) {
2544    (0, _util.assert)(reason instanceof Error || typeof reason === "object" && reason !== null, 'PDFPageProxy._abortOperatorList: Expected "reason" argument.');
2545
2546    if (!intentState.streamReader) {
2547      return;
2548    }
2549
2550    if (!force) {
2551      if (intentState.renderTasks.size > 0) {
2552        return;
2553      }
2554
2555      if (reason instanceof _display_utils.RenderingCancelledException) {
2556        intentState.streamReaderCancelTimeout = setTimeout(() => {
2557          this._abortOperatorList({
2558            intentState,
2559            reason,
2560            force: true
2561          });
2562
2563          intentState.streamReaderCancelTimeout = null;
2564        }, RENDERING_CANCELLED_TIMEOUT);
2565        return;
2566      }
2567    }
2568
2569    intentState.streamReader.cancel(new _util.AbortException(reason?.message));
2570    intentState.streamReader = null;
2571
2572    if (this._transport.destroyed) {
2573      return;
2574    }
2575
2576    for (const [intent, curIntentState] of this._intentStates) {
2577      if (curIntentState === intentState) {
2578        this._intentStates.delete(intent);
2579
2580        break;
2581      }
2582    }
2583
2584    this.cleanup();
2585  }
2586
2587  get stats() {
2588    return this._stats;
2589  }
2590
2591}
2592
2593exports.PDFPageProxy = PDFPageProxy;
2594
2595class LoopbackPort {
2596  constructor() {
2597    this._listeners = [];
2598    this._deferred = Promise.resolve(undefined);
2599  }
2600
2601  postMessage(obj, transfers) {
2602    function cloneValue(value) {
2603      if (typeof value !== "object" || value === null) {
2604        return value;
2605      }
2606
2607      if (cloned.has(value)) {
2608        return cloned.get(value);
2609      }
2610
2611      let buffer, result;
2612
2613      if ((buffer = value.buffer) && (0, _util.isArrayBuffer)(buffer)) {
2614        if (transfers?.includes(buffer)) {
2615          result = new value.constructor(buffer, value.byteOffset, value.byteLength);
2616        } else {
2617          result = new value.constructor(value);
2618        }
2619
2620        cloned.set(value, result);
2621        return result;
2622      }
2623
2624      if (value instanceof Map) {
2625        result = new Map();
2626        cloned.set(value, result);
2627
2628        for (const [key, val] of value) {
2629          result.set(key, cloneValue(val));
2630        }
2631
2632        return result;
2633      }
2634
2635      if (value instanceof Set) {
2636        result = new Set();
2637        cloned.set(value, result);
2638
2639        for (const val of value) {
2640          result.add(cloneValue(val));
2641        }
2642
2643        return result;
2644      }
2645
2646      if (value instanceof URL) {
2647        throw new Error(`LoopbackPort.postMessage - cannot clone: ${value}`);
2648      }
2649
2650      result = Array.isArray(value) ? [] : Object.create(null);
2651      cloned.set(value, result);
2652
2653      for (const i in value) {
2654        let desc,
2655            p = value;
2656
2657        while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {
2658          p = Object.getPrototypeOf(p);
2659        }
2660
2661        if (typeof desc.value === "undefined") {
2662          continue;
2663        }
2664
2665        if (typeof desc.value === "function") {
2666          if (value.hasOwnProperty?.(i)) {
2667            throw new Error(`LoopbackPort.postMessage - cannot clone: ${value[i]}`);
2668          }
2669
2670          continue;
2671        }
2672
2673        result[i] = cloneValue(desc.value);
2674      }
2675
2676      return result;
2677    }
2678
2679    const cloned = new WeakMap();
2680    const event = {
2681      data: cloneValue(obj)
2682    };
2683
2684    this._deferred.then(() => {
2685      for (const listener of this._listeners) {
2686        listener.call(this, event);
2687      }
2688    });
2689  }
2690
2691  addEventListener(name, listener) {
2692    this._listeners.push(listener);
2693  }
2694
2695  removeEventListener(name, listener) {
2696    const i = this._listeners.indexOf(listener);
2697
2698    this._listeners.splice(i, 1);
2699  }
2700
2701  terminate() {
2702    this._listeners.length = 0;
2703  }
2704
2705}
2706
2707exports.LoopbackPort = LoopbackPort;
2708
2709const PDFWorker = function PDFWorkerClosure() {
2710  const pdfWorkerPorts = new WeakMap();
2711  let isWorkerDisabled = false;