https://www.moog.com/etc.clientlibs/moog/light-redesign/components/master-tiles/clientlibs-pdf.min.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.getXfaPageViewport = getXfaPageViewport;
50exports.isDataScheme = isDataScheme;
51exports.isPdfFile = isPdfFile;
52exports.isValidFetchUrl = isValidFetchUrl;
53exports.loadScript = loadScript;
54exports.StatTimer = exports.RenderingCancelledException = exports.PDFDateString = exports.PageViewport = exports.LinkTarget = exports.DOMSVGFactory = exports.DOMStandardFontDataFactory = exports.DOMCMapReaderFactory = exports.DOMCanvasFactory = exports.DEFAULT_LINK_REL = void 0;
55
56var _util = __w_pdfjs_require__(2);
57
58var _base_factory = __w_pdfjs_require__(5);
59
60const DEFAULT_LINK_REL = "noopener noreferrer nofollow";
61exports.DEFAULT_LINK_REL = DEFAULT_LINK_REL;
62const SVG_NS = "http://www.w3.org/2000/svg";
63
64class DOMCanvasFactory extends _base_factory.BaseCanvasFactory {
65  constructor({
66    ownerDocument = globalThis.document
67  } = {}) {
68    super();
69    this._document = ownerDocument;
70  }
71
72  _createCanvas(width, height) {
73    const canvas = this._document.createElement("canvas");
74
75    canvas.width = width;
76    canvas.height = height;
77    return canvas;
78  }
79
80}
81
82exports.DOMCanvasFactory = DOMCanvasFactory;
83
84async function fetchData(url, asTypedArray = false) {
85  if (isValidFetchUrl(url, document.baseURI)) {
86    const response = await fetch(url);
87
88    if (!response.ok) {
89      throw new Error(response.statusText);
90    }
91
92    return asTypedArray ? new Uint8Array(await response.arrayBuffer()) : (0, _util.stringToBytes)(await response.text());
93  }
94
95  return new Promise((resolve, reject) => {
96    const request = new XMLHttpRequest();
97    request.open("GET", url, true);
98
99    if (asTypedArray) {
100      request.responseType = "arraybuffer";
101    }
102
103    request.onreadystatechange = () => {
104      if (request.readyState !== XMLHttpRequest.DONE) {
105        return;
106      }
107
108      if (request.status === 200 || request.status === 0) {
109        let data;
110
111        if (asTypedArray && request.response) {
112          data = new Uint8Array(request.response);
113        } else if (!asTypedArray && request.responseText) {
114          data = (0, _util.stringToBytes)(request.responseText);
115        }
116
117        if (data) {
118          resolve(data);
119          return;
120        }
121      }
122
123      reject(new Error(request.statusText));
124    };
125
126    request.send(null);
127  });
128}
129
130class DOMCMapReaderFactory extends _base_factory.BaseCMapReaderFactory {
131  _fetchData(url, compressionType) {
132    return fetchData(url, this.isCompressed).then(data => {
133      return {
134        cMapData: data,
135        compressionType
136      };
137    });
138  }
139
140}
141
142exports.DOMCMapReaderFactory = DOMCMapReaderFactory;
143
144class DOMStandardFontDataFactory extends _base_factory.BaseStandardFontDataFactory {
145  _fetchData(url) {
146    return fetchData(url, true);
147  }
148
149}
150
151exports.DOMStandardFontDataFactory = DOMStandardFontDataFactory;
152
153class DOMSVGFactory extends _base_factory.BaseSVGFactory {
154  _createSVG(type) {
155    return document.createElementNS(SVG_NS, type);
156  }
157
158}
159
160exports.DOMSVGFactory = DOMSVGFactory;
161
162class PageViewport {
163  constructor({

164    viewBox,
165    scale,
166    rotation,
167    offsetX = 0,
168    offsetY = 0,
169    dontFlip = false
170  }) {
171    this.viewBox = viewBox;
172    this.scale = scale;
173    this.rotation = rotation;
174    this.offsetX = offsetX;
175    this.offsetY = offsetY;
176    const centerX = (viewBox[2] + viewBox[0]) / 2;
177    const centerY = (viewBox[3] + viewBox[1]) / 2;
178    let rotateA, rotateB, rotateC, rotateD;
179    rotation %= 360;
180
181    if (rotation < 0) {
182      rotation += 360;
183    }
184
185    switch (rotation) {
186      case 180:
187        rotateA = -1;
188        rotateB = 0;
189        rotateC = 0;
190        rotateD = 1;
191        break;
192
193      case 90:
194        rotateA = 0;
195        rotateB = 1;
196        rotateC = 1;
197        rotateD = 0;
198        break;
199
200      case 270:
201        rotateA = 0;
202        rotateB = -1;
203        rotateC = -1;
204        rotateD = 0;
205        break;
206
207      case 0:
208        rotateA = 1;
209        rotateB = 0;
210        rotateC = 0;
211        rotateD = -1;
212        break;
213
214      default:
215        throw new Error("PageViewport: Invalid rotation, must be a multiple of 90 degrees.");
216    }
217
218    if (dontFlip) {
219      rotateC = -rotateC;
220      rotateD = -rotateD;
221    }
222
223    let offsetCanvasX, offsetCanvasY;
224    let width, height;
225
226    if (rotateA === 0) {
227      offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
228      offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
229      width = Math.abs(viewBox[3] - viewBox[1]) * scale;
230      height = Math.abs(viewBox[2] - viewBox[0]) * scale;
231    } else {
232      offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
233      offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
234      width = Math.abs(viewBox[2] - viewBox[0]) * scale;
235      height = Math.abs(viewBox[3] - viewBox[1]) * scale;
236    }
237
238    this.transform = [rotateA * scale, rotateB * scale, rotateC * scale, rotateD * scale, offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY, offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY];
239    this.width = width;
240    this.height = height;
241  }
242
243  clone({
244    scale = this.scale,
245    rotation = this.rotation,
246    offsetX = this.offsetX,
247    offsetY = this.offsetY,
248    dontFlip = false
249  } = {}) {
250    return new PageViewport({
251      viewBox: this.viewBox.slice(),
252      scale,
253      rotation,
254      offsetX,
255      offsetY,
256      dontFlip
257    });
258  }
259
260  convertToViewportPoint(x, y) {
261    return _util.Util.applyTransform([x, y], this.transform);
262  }
263
264  convertToViewportRectangle(rect) {
265    const topLeft = _util.Util.applyTransform([rect[0], rect[1]], this.transform);
266
267    const bottomRight = _util.Util.applyTransform([rect[2], rect[3]], this.transform);
268
269    return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]];
270  }
271
272  convertToPdfPoint(x, y) {
273    return _util.Util.applyInverseTransform([x, y], this.transform);
274  }
275
276}
277
278exports.PageViewport = PageViewport;
279
280class RenderingCancelledException extends _util.BaseException {
281  constructor(msg, type) {
282    super(msg);
283    this.type = type;
284  }
285
286}
287
288exports.RenderingCancelledException = RenderingCancelledException;
289const LinkTarget = {
290  NONE: 0,
291  SELF: 1,
292  BLANK: 2,
293  PARENT: 3,
294  TOP: 4
295};
296exports.LinkTarget = LinkTarget;
297
298function addLinkAttributes(link, {
299  url,
300  target,
301  rel,
302  enabled = true
303} = {}) {
304  (0, _util.assert)(url && typeof url === "string", 'addLinkAttributes: A valid "url" parameter must provided.');
305  const urlNullRemoved = (0, _util.removeNullCharacters)(url);
306
307  if (enabled) {
308    link.href = link.title = urlNullRemoved;
309  } else {
310    link.href = "";
311    link.title = `Disabled: ${urlNullRemoved}`;
312
313    link.onclick = () => {
314      return false;
315    };
316  }
317
318  let targetStr = "";
319
320  switch (target) {
321    case LinkTarget.NONE:
322      break;
323
324    case LinkTarget.SELF:
325      targetStr = "_self";
326      break;
327
328    case LinkTarget.BLANK:
329      targetStr = "_blank";
330      break;
331
332    case LinkTarget.PARENT:
333      targetStr = "_parent";
334      break;
335
336    case LinkTarget.TOP:
337      targetStr = "_top";
338      break;
339  }
340
341  link.target = targetStr;
342  link.rel = typeof rel === "string" ? rel : DEFAULT_LINK_REL;
343}
344
345function isDataScheme(url) {
346  const ii = url.length;
347  let i = 0;
348
349  while (i < ii && url[i].trim() === "") {
350    i++;
351  }
352
353  return url.substring(i, i + 5).toLowerCase() === "data:";
354}
355
356function isPdfFile(filename) {
357  return typeof filename === "string" && /\.pdf$/i.test(filename);
358}
359
360function getFilenameFromUrl(url) {
361  const anchor = url.indexOf("#");
362  const query = url.indexOf("?");
363  const end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length);
364  return url.substring(url.lastIndexOf("/", end) + 1, end);
365}
366
367function getPdfFilenameFromUrl(url, defaultFilename = "document.pdf") {
368  if (typeof url !== "string") {
369    return defaultFilename;
370  }
371
372  if (isDataScheme(url)) {
373    (0, _util.warn)('getPdfFilenameFromUrl: ignore "data:"-URL for performance reasons.');
374    return defaultFilename;
375  }
376
377  const reURI = /^(?:(?:[^:]+:)?\/\/[^/]+)?([^?#]*)(\?[^#]*)?(#.*)?$/;
378  const reFilename = /[^/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
379  const splitURI = reURI.exec(url);
380  let suggestedFilename = reFilename.exec(splitURI[1]) || reFilename.exec(splitURI[2]) || reFilename.exec(splitURI[3]);
381
382  if (suggestedFilename) {
383    suggestedFilename = suggestedFilename[0];
384
385    if (suggestedFilename.includes("%")) {

386      try {
387        suggestedFilename = reFilename.exec(decodeURIComponent(suggestedFilename))[0];
388      } catch (ex) {}
389    }
390  }
391
392  return suggestedFilename || defaultFilename;
393}
394
395class StatTimer {
396  constructor() {
397    this.started = Object.create(null);
398    this.times = [];
399  }
400
401  time(name) {
402    if (name in this.started) {
403      (0, _util.warn)(`Timer is already running for ${name}`);
404    }
405
406    this.started[name] = Date.now();
407  }
408
409  timeEnd(name) {
410    if (!(name in this.started)) {
411      (0, _util.warn)(`Timer has not been started for ${name}`);
412    }
413
414    this.times.push({
415      name,
416      start: this.started[name],
417      end: Date.now()
418    });
419    delete this.started[name];
420  }
421
422  toString() {
423    const outBuf = [];
424    let longest = 0;
425
426    for (const time of this.times) {
427      const name = time.name;
428
429      if (name.length > longest) {
430        longest = name.length;
431      }
432    }
433
434    for (const time of this.times) {
435      const duration = time.end - time.start;
436      outBuf.push(`${time.name.padEnd(longest)} ${duration}ms\n`);
437    }
438
439    return outBuf.join("");
440  }
441
442}
443
444exports.StatTimer = StatTimer;
445
446function isValidFetchUrl(url, baseUrl) {
447  try {
448    const {
449      protocol
450    } = baseUrl ? new URL(url, baseUrl) : new URL(url);
451    return protocol === "http:" || protocol === "https:";
452  } catch (ex) {
453    return false;
454  }
455}
456
457function loadScript(src, removeScriptElement = false) {
458  return new Promise((resolve, reject) => {
459    const script = document.createElement("script");
460    script.src = src;
461
462    script.onload = function (evt) {
463      if (removeScriptElement) {
464        script.remove();
465      }
466
467      resolve(evt);
468    };
469
470    script.onerror = function () {
471      reject(new Error(`Cannot load script at: ${script.src}`));
472    };
473
474    (document.head || document.documentElement).appendChild(script);
475  });
476}
477
478function deprecated(details) {
479  console.log("Deprecated API usage: " + details);
480}
481
482let pdfDateStringRegex;
483
484class PDFDateString {
485  static toDateObject(input) {
486    if (!input || !(0, _util.isString)(input)) {
487      return null;
488    }
489
490    if (!pdfDateStringRegex) {
491      pdfDateStringRegex = new RegExp("^D:" + "(\\d{4})" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "([Z|+|-])?" + "(\\d{2})?" + "'?" + "(\\d{2})?" + "'?");
492    }
493
494    const matches = pdfDateStringRegex.exec(input);
495
496    if (!matches) {
497      return null;
498    }
499
500    const year = parseInt(matches[1], 10);
501    let month = parseInt(matches[2], 10);

502    month = month >= 1 && month <= 12 ? month - 1 : 0;
503    let day = parseInt(matches[3], 10);
504    day = day >= 1 && day <= 31 ? day : 1;
505    let hour = parseInt(matches[4], 10);
506    hour = hour >= 0 && hour <= 23 ? hour : 0;
507    let minute = parseInt(matches[5], 10);
508    minute = minute >= 0 && minute <= 59 ? minute : 0;
509    let second = parseInt(matches[6], 10);
510    second = second >= 0 && second <= 59 ? second : 0;
511    const universalTimeRelation = matches[7] || "Z";
512    let offsetHour = parseInt(matches[8], 10);
513    offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0;
514    let offsetMinute = parseInt(matches[9], 10) || 0;
515    offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0;
516
517    if (universalTimeRelation === "-") {
518      hour += offsetHour;
519      minute += offsetMinute;
520    } else if (universalTimeRelation === "+") {
521      hour -= offsetHour;
522      minute -= offsetMinute;
523    }
524
525    return new Date(Date.UTC(year, month, day, hour, minute, second));
526  }
527
528}
529
530exports.PDFDateString = PDFDateString;
531
532function getXfaPageViewport(xfaPage, {
533  scale = 1,
534  rotation = 0
535}) {
536  const {
537    width,
538    height
539  } = xfaPage.attributes.style;
540  const viewBox = [0, 0, parseInt(width), parseInt(height)];
541  return new PageViewport({
542    viewBox,
543    scale,
544    rotation
545  });
546}
547
548/***/ }),
549/* 2 */
550/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
551
552
553
554Object.defineProperty(exports, "__esModule", ({
555  value: true
556}));
557exports.arrayByteLength = arrayByteLength;
558exports.arraysToBytes = arraysToBytes;
559exports.assert = assert;
560exports.bytesToString = bytesToString;
561exports.createObjectURL = createObjectURL;
562exports.createPromiseCapability = createPromiseCapability;
563exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
564exports.escapeString = escapeString;
565exports.getModificationDate = getModificationDate;
566exports.getVerbosityLevel = getVerbosityLevel;
567exports.info = info;
568exports.isArrayBuffer = isArrayBuffer;
569exports.isArrayEqual = isArrayEqual;
570exports.isAscii = isAscii;
571exports.isBool = isBool;
572exports.isNum = isNum;
573exports.isSameOrigin = isSameOrigin;
574exports.isString = isString;
575exports.objectFromMap = objectFromMap;
576exports.objectSize = objectSize;
577exports.removeNullCharacters = removeNullCharacters;
578exports.setVerbosityLevel = setVerbosityLevel;
579exports.shadow = shadow;
580exports.string32 = string32;
581exports.stringToBytes = stringToBytes;
582exports.stringToPDFString = stringToPDFString;
583exports.stringToUTF16BEString = stringToUTF16BEString;
584exports.stringToUTF8String = stringToUTF8String;
585exports.unreachable = unreachable;
586exports.utf8StringToString = utf8StringToString;
587exports.warn = warn;
588exports.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;
589
590__w_pdfjs_require__(3);
591
592const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
593exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
594const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
595exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
596const PermissionFlag = {
597  PRINT: 0x04,
598  MODIFY_CONTENTS: 0x08,
599  COPY: 0x10,
600  MODIFY_ANNOTATIONS: 0x20,
601  FILL_INTERACTIVE_FORMS: 0x100,
602  COPY_FOR_ACCESSIBILITY: 0x200,
603  ASSEMBLE: 0x400,
604  PRINT_HIGH_QUALITY: 0x800
605};
606exports.PermissionFlag = PermissionFlag;
607const TextRenderingMode = {
608  FILL: 0,
609  STROKE: 1,
610  FILL_STROKE: 2,
611  INVISIBLE: 3,
612  FILL_ADD_TO_PATH: 4,
613  STROKE_ADD_TO_PATH: 5,
614  FILL_STROKE_ADD_TO_PATH: 6,
615  ADD_TO_PATH: 7,
616  FILL_STROKE_MASK: 3,
617  ADD_TO_PATH_FLAG: 4
618};
619exports.TextRenderingMode = TextRenderingMode;
620const ImageKind = {
621  GRAYSCALE_1BPP: 1,
622  RGB_24BPP: 2,
623  RGBA_32BPP: 3
624};
625exports.ImageKind = ImageKind;
626const AnnotationType = {
627  TEXT: 1,
628  LINK: 2,
629  FREETEXT: 3,
630  LINE: 4,
631  SQUARE: 5,
632  CIRCLE: 6,
633  POLYGON: 7,
634  POLYLINE: 8,
635  HIGHLIGHT: 9,
636  UNDERLINE: 10,
637  SQUIGGLY: 11,
638  STRIKEOUT: 12,
639  STAMP: 13,
640  CARET: 14,
641  INK: 15,
642  POPUP: 16,
643  FILEATTACHMENT: 17,
644  SOUND: 18,
645  MOVIE: 19,
646  WIDGET: 20,
647  SCREEN: 21,
648  PRINTERMARK: 22,
649  TRAPNET: 23,
650  WATERMARK: 24,
651  THREED: 25,
652  REDACT: 26
653};
654exports.AnnotationType = AnnotationType;
655const AnnotationStateModelType = {
656  MARKED: "Marked",
657  REVIEW: "Review"
658};
659exports.AnnotationStateModelType = AnnotationStateModelType;
660const AnnotationMarkedState = {
661  MARKED: "Marked",
662  UNMARKED: "Unmarked"
663};
664exports.AnnotationMarkedState = AnnotationMarkedState;
665const AnnotationReviewState = {
666  ACCEPTED: "Accepted",
667  REJECTED: "Rejected",
668  CANCELLED: "Cancelled",
669  COMPLETED: "Completed",
670  NONE: "None"
671};
672exports.AnnotationReviewState = AnnotationReviewState;
673const AnnotationReplyType = {
674  GROUP: "Group",
675  REPLY: "R"
676};
677exports.AnnotationReplyType = AnnotationReplyType;
678const AnnotationFlag = {
679  INVISIBLE: 0x01,
680  HIDDEN: 0x02,
681  PRINT: 0x04,
682  NOZOOM: 0x08,

683  NOROTATE: 0x10,
684  NOVIEW: 0x20,
685  READONLY: 0x40,
686  LOCKED: 0x80,
687  TOGGLENOVIEW: 0x100,
688  LOCKEDCONTENTS: 0x200
689};
690exports.AnnotationFlag = AnnotationFlag;
691const AnnotationFieldFlag = {
692  READONLY: 0x0000001,
693  REQUIRED: 0x0000002,
694  NOEXPORT: 0x0000004,
695  MULTILINE: 0x0001000,
696  PASSWORD: 0x0002000,
697  NOTOGGLETOOFF: 0x0004000,
698  RADIO: 0x0008000,
699  PUSHBUTTON: 0x0010000,
700  COMBO: 0x0020000,
701  EDIT: 0x0040000,
702  SORT: 0x0080000,
703  FILESELECT: 0x0100000,
704  MULTISELECT: 0x0200000,
705  DONOTSPELLCHECK: 0x0400000,
706  DONOTSCROLL: 0x0800000,
707  COMB: 0x1000000,
708  RICHTEXT: 0x2000000,
709  RADIOSINUNISON: 0x2000000,
710  COMMITONSELCHANGE: 0x4000000
711};
712exports.AnnotationFieldFlag = AnnotationFieldFlag;
713const AnnotationBorderStyleType = {
714  SOLID: 1,
715  DASHED: 2,
716  BEVELED: 3,
717  INSET: 4,
718  UNDERLINE: 5
719};
720exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
721const AnnotationActionEventType = {
722  E: "Mouse Enter",
723  X: "Mouse Exit",
724  D: "Mouse Down",
725  U: "Mouse Up",
726  Fo: "Focus",
727  Bl: "Blur",
728  PO: "PageOpen",
729  PC: "PageClose",
730  PV: "PageVisible",
731  PI: "PageInvisible",
732  K: "Keystroke",
733  F: "Format",
734  V: "Validate",
735  C: "Calculate"
736};
737exports.AnnotationActionEventType = AnnotationActionEventType;
738const DocumentActionEventType = {
739  WC: "WillClose",
740  WS: "WillSave",
741  DS: "DidSave",
742  WP: "WillPrint",
743  DP: "DidPrint"
744};
745exports.DocumentActionEventType = DocumentActionEventType;
746const PageActionEventType = {
747  O: "PageOpen",
748  C: "PageClose"
749};
750exports.PageActionEventType = PageActionEventType;
751const StreamType = {
752  UNKNOWN: "UNKNOWN",
753  FLATE: "FLATE",
754  LZW: "LZW",
755  DCT: "DCT",
756  JPX: "JPX",
757  JBIG: "JBIG",
758  A85: "A85",
759  AHX: "AHX",
760  CCF: "CCF",
761  RLX: "RLX"
762};
763exports.StreamType = StreamType;
764const FontType = {
765  UNKNOWN: "UNKNOWN",
766  TYPE1: "TYPE1",
767  TYPE1STANDARD: "TYPE1STANDARD",
768  TYPE1C: "TYPE1C",
769  CIDFONTTYPE0: "CIDFONTTYPE0",
770  CIDFONTTYPE0C: "CIDFONTTYPE0C",
771  TRUETYPE: "TRUETYPE",
772  CIDFONTTYPE2: "CIDFONTTYPE2",
773  TYPE3: "TYPE3",
774  OPENTYPE: "OPENTYPE",
775  TYPE0: "TYPE0",
776  MMTYPE1: "MMTYPE1"
777};
778exports.FontType = FontType;
779const VerbosityLevel = {
780  ERRORS: 0,
781  WARNINGS: 1,
782  INFOS: 5
783};
784exports.VerbosityLevel = VerbosityLevel;
785const CMapCompressionType = {
786  NONE: 0,
787  BINARY: 1,
788  STREAM: 2
789};
790exports.CMapCompressionType = CMapCompressionType;
791const OPS = {
792  dependency: 1,
793  setLineWidth: 2,
794  setLineCap: 3,
795  setLineJoin: 4,
796  setMiterLimit: 5,
797  setDash: 6,
798  setRenderingIntent: 7,
799  setFlatness: 8,
800  setGState: 9,
801  save: 10,
802  restore: 11,
803  transform: 12,
804  moveTo: 13,
805  lineTo: 14,
806  curveTo: 15,
807  curveTo2: 16,

808  curveTo3: 17,
809  closePath: 18,
810  rectangle: 19,
811  stroke: 20,
812  closeStroke: 21,
813  fill: 22,
814  eoFill: 23,
815  fillStroke: 24,
816  eoFillStroke: 25,
817  closeFillStroke: 26,
818  closeEOFillStroke: 27,
819  endPath: 28,
820  clip: 29,
821  eoClip: 30,
822  beginText: 31,
823  endText: 32,
824  setCharSpacing: 33,
825  setWordSpacing: 34,
826  setHScale: 35,
827  setLeading: 36,
828  setFont: 37,
829  setTextRenderingMode: 38,
830  setTextRise: 39,
831  moveText: 40,
832  setLeadingMoveText: 41,
833  setTextMatrix: 42,
834  nextLine: 43,
835  showText: 44,
836  showSpacedText: 45,
837  nextLineShowText: 46,
838  nextLineSetSpacingShowText: 47,
839  setCharWidth: 48,
840  setCharWidthAndBounds: 49,
841  setStrokeColorSpace: 50,
842  setFillColorSpace: 51,
843  setStrokeColor: 52,
844  setStrokeColorN: 53,
845  setFillColor: 54,
846  setFillColorN: 55,
847  setStrokeGray: 56,
848  setFillGray: 57,
849  setStrokeRGBColor: 58,
850  setFillRGBColor: 59,
851  setStrokeCMYKColor: 60,
852  setFillCMYKColor: 61,
853  shadingFill: 62,
854  beginInlineImage: 63,
855  beginImageData: 64,
856  endInlineImage: 65,
857  paintXObject: 66,
858  markPoint: 67,
859  markPointProps: 68,
860  beginMarkedContent: 69,
861  beginMarkedContentProps: 70,
862  endMarkedContent: 71,
863  beginCompat: 72,
864  endCompat: 73,
865  paintFormXObjectBegin: 74,
866  paintFormXObjectEnd: 75,
867  beginGroup: 76,
868  endGroup: 77,
869  beginAnnotations: 78,
870  endAnnotations: 79,
871  beginAnnotation: 80,
872  endAnnotation: 81,
873  paintJpegXObject: 82,
874  paintImageMaskXObject: 83,
875  paintImageMaskXObjectGroup: 84,
876  paintImageXObject: 85,
877  paintInlineImageXObject: 86,
878  paintInlineImageXObjectGroup: 87,
879  paintImageXObjectRepeat: 88,
880  paintImageMaskXObjectRepeat: 89,
881  paintSolidColorImageMask: 90,
882  constructPath: 91
883};
884exports.OPS = OPS;
885const UNSUPPORTED_FEATURES = {
886  unknown: "unknown",
887  forms: "forms",
888  javaScript: "javaScript",
889  signatures: "signatures",
890  smask: "smask",
891  shadingPattern: "shadingPattern",
892  font: "font",
893  errorTilingPattern: "errorTilingPattern",
894  errorExtGState: "errorExtGState",
895  errorXObject: "errorXObject",
896  errorFontLoadType3: "errorFontLoadType3",
897  errorFontState: "errorFontState",
898  errorFontMissing: "errorFontMissing",
899  errorFontTranslate: "errorFontTranslate",
900  errorColorSpace: "errorColorSpace",
901  errorOperatorList: "errorOperatorList",
902  errorFontToUnicode: "errorFontToUnicode",
903  errorFontLoadNative: "errorFontLoadNative",
904  errorFontBuildPath: "errorFontBuildPath",
905  errorFontGetPath: "errorFontGetPath",
906  errorMarkedContent: "errorMarkedContent"
907};
908exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
909const PasswordResponses = {
910  NEED_PASSWORD: 1,
911  INCORRECT_PASSWORD: 2
912};
913exports.PasswordResponses = PasswordResponses;
914let verbosity = VerbosityLevel.WARNINGS;
915
916function setVerbosityLevel(level) {
917  if (Number.isInteger(level)) {
918    verbosity = level;
919  }
920}
921
922function getVerbosityLevel() {
923  return verbosity;
924}
925
926function info(msg) {
927  if (verbosity >= VerbosityLevel.INFOS) {
928    console.log(`Info: ${msg}`);
929  }
930}
931
932function warn(msg) {
933  if (verbosity >= VerbosityLevel.WARNINGS) {
934    console.log(`Warning: ${msg}`);
935  }
936}
937
938function unreachable(msg) {
939  throw new Error(msg);
940}
941
942function assert(cond, msg) {
943  if (!cond) {
944    unreachable(msg);
945  }
946}
947
948function isSameOrigin(baseUrl, otherUrl) {
949  let base;
950
951  try {
952    base = new URL(baseUrl);
953
954    if (!base.origin || base.origin === "null") {
955      return false;
956    }
957  } catch (e) {
958    return false;
959  }
960
961  const other = new URL(otherUrl, base);
962  return base.origin === other.origin;
963}
964
965function _isValidProtocol(url) {
966  if (!url) {
967    return false;
968  }
969
970  switch (url.protocol) {
971    case "http:":
972    case "https:":
973    case "ftp:":
974    case "mailto:":
975    case "tel:":
976      return true;
977
978    default:
979      return false;
980  }
981}
982
983function createValidAbsoluteUrl(url, baseUrl) {
984  if (!url) {
985    return null;
986  }
987
988  try {
989    const absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);
990
991    if (_isValidProtocol(absoluteUrl)) {
992      return absoluteUrl;
993    }
994  } catch (ex) {}
995
996  return null;
997}
998
999function shadow(obj, prop, value) {
1000  Object.defineProperty(obj, prop, {
1001    value,
1002    enumerable: true,
1003    configurable: true,
1004    writable: false
1005  });
1006  return value;
1007}
1008
1009const BaseException = function BaseExceptionClosure() {
1010  function BaseException(message) {
1011    if (this.constructor === BaseException) {
1012      unreachable("Cannot initialize BaseException.");
1013    }
1014
1015    this.message = message;
1016    this.name = this.constructor.name;
1017  }
1018
1019  BaseException.prototype = new Error();
1020  BaseException.constructor = BaseException;
1021  return BaseException;
1022}();
1023
1024exports.BaseException = BaseException;
1025
1026class PasswordException extends BaseException {
1027  constructor(msg, code) {
1028    super(msg);
1029    this.code = code;
1030  }
1031
1032}
1033
1034exports.PasswordException = PasswordException;
1035
1036class UnknownErrorException extends BaseException {
1037  constructor(msg, details) {
1038    super(msg);
1039    this.details = details;
1040  }
1041
1042}
1043
1044exports.UnknownErrorException = UnknownErrorException;
1045
1046class InvalidPDFException extends BaseException {}
1047
1048exports.InvalidPDFException = InvalidPDFException;
1049
1050class MissingPDFException extends BaseException {}
1051
1052exports.MissingPDFException = MissingPDFException;
1053
1054class UnexpectedResponseException extends BaseException {
1055  constructor(msg, status) {
1056    super(msg);
1057    this.status = status;
1058  }
1059
1060}
1061
1062exports.UnexpectedResponseException = UnexpectedResponseException;
1063
1064class FormatError extends BaseException {}
1065
1066exports.FormatError = FormatError;
1067
1068class AbortException extends BaseException {}
1069
1070exports.AbortException = AbortException;
1071const NullCharactersRegExp = /\x00/g;
1072
1073function removeNullCharacters(str) {
1074  if (typeof str !== "string") {
1075    warn("The argument for removeNullCharacters must be a string.");
1076    return str;
1077  }
1078
1079  return str.replace(NullCharactersRegExp, "");
1080}
1081
1082function bytesToString(bytes) {
1083  assert(bytes !== null && typeof bytes === "object" && bytes.length !== undefined, "Invalid argument for bytesToString");
1084  const length = bytes.length;
1085  const MAX_ARGUMENT_COUNT = 8192;
1086
1087  if (length < MAX_ARGUMENT_COUNT) {
1088    return String.fromCharCode.apply(null, bytes);
1089  }
1090
1091  const strBuf = [];
1092
1093  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
1094    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
1095    const chunk = bytes.subarray(i, chunkEnd);
1096    strBuf.push(String.fromCharCode.apply(null, chunk));
1097  }
1098
1099  return strBuf.join("");
1100}
1101
1102function stringToBytes(str) {
1103  assert(typeof str === "string", "Invalid argument for stringToBytes");
1104  const length = str.length;
1105  const bytes = new Uint8Array(length);
1106
1107  for (let i = 0; i < length; ++i) {
1108    bytes[i] = str.charCodeAt(i) & 0xff;

1109  }
1110
1111  return bytes;
1112}
1113
1114function arrayByteLength(arr) {
1115  if (arr.length !== undefined) {
1116    return arr.length;
1117  }
1118
1119  assert(arr.byteLength !== undefined, "arrayByteLength - invalid argument.");
1120  return arr.byteLength;
1121}
1122
1123function arraysToBytes(arr) {
1124  const length = arr.length;
1125
1126  if (length === 1 && arr[0] instanceof Uint8Array) {
1127    return arr[0];
1128  }
1129
1130  let resultLength = 0;
1131
1132  for (let i = 0; i < length; i++) {
1133    resultLength += arrayByteLength(arr[i]);
1134  }
1135
1136  let pos = 0;
1137  const data = new Uint8Array(resultLength);
1138
1139  for (let i = 0; i < length; i++) {
1140    let item = arr[i];
1141
1142    if (!(item instanceof Uint8Array)) {
1143      if (typeof item === "string") {
1144        item = stringToBytes(item);
1145      } else {
1146        item = new Uint8Array(item);
1147      }
1148    }
1149
1150    const itemLength = item.byteLength;
1151    data.set(item, pos);
1152    pos += itemLength;
1153  }
1154
1155  return data;
1156}
1157
1158function string32(value) {
1159  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
1160}
1161
1162function objectSize(obj) {
1163  return Object.keys(obj).length;
1164}
1165
1166function objectFromMap(map) {
1167  const obj = Object.create(null);
1168
1169  for (const [key, value] of map) {
1170    obj[key] = value;
1171  }
1172
1173  return obj;
1174}
1175
1176function isLittleEndian() {
1177  const buffer8 = new Uint8Array(4);
1178  buffer8[0] = 1;
1179  const view32 = new Uint32Array(buffer8.buffer, 0, 1);
1180  return view32[0] === 1;
1181}
1182
1183const IsLittleEndianCached = {
1184  get value() {
1185    return shadow(this, "value", isLittleEndian());
1186  }
1187
1188};
1189exports.IsLittleEndianCached = IsLittleEndianCached;
1190
1191function isEvalSupported() {
1192  try {
1193    new Function("");
1194    return true;
1195  } catch (e) {
1196    return false;
1197  }
1198}
1199
1200const IsEvalSupportedCached = {
1201  get value() {
1202    return shadow(this, "value", isEvalSupported());
1203  }
1204
1205};
1206exports.IsEvalSupportedCached = IsEvalSupportedCached;
1207const hexNumbers = [...Array(256).keys()].map(n => n.toString(16).padStart(2, "0"));
1208
1209class Util {
1210  static makeHexColor(r, g, b) {
1211    return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`;
1212  }
1213
1214  static transform(m1, m2) {
1215    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]];
1216  }
1217
1218  static applyTransform(p, m) {
1219    const xt = p[0] * m[0] + p[1] * m[2] + m[4];
1220    const yt = p[0] * m[1] + p[1] * m[3] + m[5];
1221    return [xt, yt];
1222  }
1223
1224  static applyInverseTransform(p, m) {
1225    const d = m[0] * m[3] - m[1] * m[2];
1226    const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
1227    const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
1228    return [xt, yt];
1229  }
1230
1231  static getAxialAlignedBoundingBox(r, m) {
1232    const p1 = Util.applyTransform(r, m);
1233    const p2 = Util.applyTransform(r.slice(2, 4), m);
1234    const p3 = Util.applyTransform([r[0], r[3]], m);
1235    const p4 = Util.applyTransform([r[2], r[1]], m);
1236    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])];
1237  }
1238
1239  static inverseTransform(m) {
1240    const d = m[0] * m[3] - m[1] * m[2];
1241    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];
1242  }
1243
1244  static apply3dTransform(m, v) {
1245    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]];
1246  }
1247
1248  static singularValueDecompose2dScale(m) {
1249    const transpose = [m[0], m[2], m[1], m[3]];
1250    const a = m[0] * transpose[0] + m[1] * transpose[2];
1251    const b = m[0] * transpose[1] + m[1] * transpose[3];
1252    const c = m[2] * transpose[0] + m[3] * transpose[2];
1253    const d = m[2] * transpose[1] + m[3] * transpose[3];
1254    const first = (a + d) / 2;
1255    const second = Math.sqrt((a + d) ** 2 - 4 * (a * d - c * b)) / 2;
1256    const sx = first + second || 1;
1257    const sy = first - second || 1;
1258    return [Math.sqrt(sx), Math.sqrt(sy)];
1259  }
1260
1261  static normalizeRect(rect) {
1262    const r = rect.slice(0);
1263
1264    if (rect[0] > rect[2]) {
1265      r[0] = rect[2];
1266      r[2] = rect[0];
1267    }
1268
1269    if (rect[1] > rect[3]) {
1270      r[1] = rect[3];
1271      r[3] = rect[1];
1272    }
1273
1274    return r;
1275  }
1276
1277  static intersect(rect1, rect2) {
1278    function compare(a, b) {
1279      return a - b;
1280    }
1281
1282    const orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare);

1283    const orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare);
1284    const result = [];
1285    rect1 = Util.normalizeRect(rect1);
1286    rect2 = Util.normalizeRect(rect2);
1287
1288    if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
1289      result[0] = orderedX[1];
1290      result[2] = orderedX[2];
1291    } else {
1292      return null;
1293    }
1294
1295    if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
1296      result[1] = orderedY[1];
1297      result[3] = orderedY[2];
1298    } else {
1299      return null;
1300    }
1301
1302    return result;
1303  }
1304
1305}
1306
1307exports.Util = Util;
1308const 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];
1309
1310function stringToPDFString(str) {
1311  const length = str.length,
1312        strBuf = [];
1313
1314  if (str[0] === "\xFE" && str[1] === "\xFF") {
1315    for (let i = 2; i < length; i += 2) {
1316      strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
1317    }
1318  } else if (str[0] === "\xFF" && str[1] === "\xFE") {
1319    for (let i = 2; i < length; i += 2) {
1320      strBuf.push(String.fromCharCode(str.charCodeAt(i + 1) << 8 | str.charCodeAt(i)));
1321    }
1322  } else {
1323    for (let i = 0; i < length; ++i) {
1324      const code = PDFStringTranslateTable[str.charCodeAt(i)];
1325      strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
1326    }
1327  }
1328
1329  return strBuf.join("");
1330}
1331
1332function escapeString(str) {
1333  return str.replace(/([()\\\n\r])/g, match => {
1334    if (match === "\n") {
1335      return "\\n";
1336    } else if (match === "\r") {
1337      return "\\r";
1338    }
1339
1340    return `\\${match}`;
1341  });
1342}
1343
1344function isAscii(str) {
1345  return /^[\x00-\x7F]*$/.test(str);
1346}
1347
1348function stringToUTF16BEString(str) {
1349  const buf = ["\xFE\xFF"];
1350
1351  for (let i = 0, ii = str.length; i < ii; i++) {
1352    const char = str.charCodeAt(i);
1353    buf.push(String.fromCharCode(char >> 8 & 0xff), String.fromCharCode(char & 0xff));
1354  }
1355
1356  return buf.join("");
1357}
1358
1359function stringToUTF8String(str) {
1360  return decodeURIComponent(escape(str));
1361}
1362
1363function utf8StringToString(str) {
1364  return unescape(encodeURIComponent(str));
1365}
1366
1367function isBool(v) {
1368  return typeof v === "boolean";
1369}
1370
1371function isNum(v) {
1372  return typeof v === "number";
1373}
1374
1375function isString(v) {
1376  return typeof v === "string";
1377}
1378
1379function isArrayBuffer(v) {
1380  return typeof v === "object" && v !== null && v.byteLength !== undefined;
1381}
1382
1383function isArrayEqual(arr1, arr2) {
1384  if (arr1.length !== arr2.length) {
1385    return false;
1386  }
1387
1388  for (let i = 0, ii = arr1.length; i < ii; i++) {
1389    if (arr1[i] !== arr2[i]) {
1390      return false;
1391    }
1392  }
1393
1394  return true;
1395}
1396
1397function getModificationDate(date = new Date()) {
1398  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")];
1399  return buffer.join("");
1400}
1401
1402function createPromiseCapability() {
1403  const capability = Object.create(null);
1404  let isSettled = false;
1405  Object.defineProperty(capability, "settled", {
1406    get() {
1407      return isSettled;
1408    }
1409
1410  });
1411  capability.promise = new Promise(function (resolve, reject) {
1412    capability.resolve = function (data) {
1413      isSettled = true;
1414      resolve(data);
1415    };
1416
1417    capability.reject = function (reason) {
1418      isSettled = true;
1419      reject(reason);
1420    };
1421  });
1422  return capability;
1423}
1424
1425function createObjectURL(data, contentType = "", forceDataSchema = false) {
1426  if (URL.createObjectURL && !forceDataSchema) {
1427    return URL.createObjectURL(new Blob([data], {
1428      type: contentType
1429    }));
1430  }
1431
1432  const digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789

1432+/=";
1433  let buffer = `data:${contentType};base64,`;
1434
1435  for (let i = 0, ii = data.length; i < ii; i += 3) {
1436    const b1 = data[i] & 0xff;
1437    const b2 = data[i + 1] & 0xff;
1438    const b3 = data[i + 2] & 0xff;
1439    const d1 = b1 >> 2,
1440          d2 = (b1 & 3) << 4 | b2 >> 4;
1441    const d3 = i + 1 < ii ? (b2 & 0xf) << 2 | b3 >> 6 : 64;
1442    const d4 = i + 2 < ii ? b3 & 0x3f : 64;
1443    buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];
1444  }
1445
1446  return buffer;
1447}
1448
1449/***/ }),
1450/* 3 */
1451/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
1452
1453
1454
1455var _is_node = __w_pdfjs_require__(4);
1456
1457;
1458
1459/***/ }),
1460/* 4 */
1461/***/ ((__unused_webpack_module, exports) => {
1462
1463
1464
1465Object.defineProperty(exports, "__esModule", ({
1466  value: true
1467}));
1468exports.isNodeJS = void 0;
1469const isNodeJS = typeof process === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
1470exports.isNodeJS = isNodeJS;
1471
1472/***/ }),
1473/* 5 */
1474/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
1475
1476
1477
1478Object.defineProperty(exports, "__esModule", ({
1479  value: true
1480}));
1481exports.BaseSVGFactory = exports.BaseStandardFontDataFactory = exports.BaseCMapReaderFactory = exports.BaseCanvasFactory = void 0;
1482
1483var _util = __w_pdfjs_require__(2);
1484
1485class BaseCanvasFactory {
1486  constructor() {
1487    if (this.constructor === BaseCanvasFactory) {
1488      (0, _util.unreachable)("Cannot initialize BaseCanvasFactory.");
1489    }
1490  }
1491
1492  create(width, height) {
1493    if (width <= 0 || height <= 0) {
1494      throw new Error("Invalid canvas size");
1495    }
1496
1497    const canvas = this._createCanvas(width, height);
1498
1499    return {
1500      canvas,
1501      context: canvas.getContext("2d")
1502    };
1503  }
1504
1505  reset(canvasAndContext, width, height) {
1506    if (!canvasAndContext.canvas) {
1507      throw new Error("Canvas is not specified");
1508    }
1509
1510    if (width <= 0 || height <= 0) {
1511      throw new Error("Invalid canvas size");
1512    }
1513
1514    canvasAndContext.canvas.width = width;
1515    canvasAndContext.canvas.height = height;
1516  }
1517
1518  destroy(canvasAndContext) {
1519    if (!canvasAndContext.canvas) {
1520      throw new Error("Canvas is not specified");
1521    }
1522
1523    canvasAndContext.canvas.width = 0;
1524    canvasAndContext.canvas.height = 0;
1525    canvasAndContext.canvas = null;
1526    canvasAndContext.context = null;
1527  }
1528
1529  _createCanvas(width, height) {
1530    (0, _util.unreachable)("Abstract method `_createCanvas` called.");
1531  }
1532
1533}
1534
1535exports.BaseCanvasFactory = BaseCanvasFactory;
1536
1537class BaseCMapReaderFactory {
1538  constructor({
1539    baseUrl = null,
1540    isCompressed = false
1541  }) {
1542    if (this.constructor === BaseCMapReaderFactory) {
1543      (0, _util.unreachable)("Cannot initialize BaseCMapReaderFactory.");
1544    }
1545
1546    this.baseUrl = baseUrl;
1547    this.isCompressed = isCompressed;
1548  }
1549
1550  async fetch({
1551    name
1552  }) {
1553    if (!this.baseUrl) {
1554      throw new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.');
1555    }
1556
1557    if (!name) {
1558      throw new Error("CMap name must be specified.");
1559    }
1560
1561    const url = this.baseUrl + name + (this.isCompressed ? ".bcmap" : "");
1562    const compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE;
1563    return this._fetchData(url, compressionType).catch(reason => {
1564      throw new Error(`Unable to load ${this.isCompressed ? "binary " : ""}CMap at: ${url}`);
1565    });
1566  }
1567
1568  _fetchData(url, compressionType) {
1569    (0, _util.unreachable)("Abstract method `_fetchData` called.");
1570  }
1571
1572}
1573
1574exports.BaseCMapReaderFactory = BaseCMapReaderFactory;
1575
1576class BaseStandardFontDataFactory {
1577  constructor({
1578    baseUrl = null
1579  }) {
1580    if (this.constructor === BaseStandardFontDataFactory) {
1581      (0, _util.unreachable)("Cannot initialize BaseStandardFontDataFactory.");
1582    }
1583
1584    this.baseUrl = baseUrl;
1585  }
1586
1587  async fetch({
1588    filename
1589  }) {
1590    if (!this.baseUrl) {
1591      throw new Error('The standard font "baseUrl" parameter must be specified, ensure that ' + 'the "standardFontDataUrl" API parameter is provided.');
1592    }
1593
1594    if (!filename) {
1595      throw new Error("Font filename must be specified.");
1596    }
1597
1598    const url = `${this.baseUrl}${filename}`;
1599    return this._fetchData(url).catch(reason => {
1600      throw new Error(`Unable to load font data at: ${url}`);
1601    });
1602  }
1603
1604  _fetchData(url) {
1605    (0, _util.unreachable)("Abstract method `_fetchData` called.");
1606  }
1607
1608}
1609
1610exports.BaseStandardFontDataFactory = BaseStandardFontDataFactory;
1611
1612class BaseSVGFactory {
1613  constructor() {
1614    if (this.constructor === BaseSVGFactory) {
1615      (0, _util.unreachable)("Cannot initialize BaseSVGFactory.");
1616    }
1617  }
1618
1619  create(width, height) {
1620    if (width <= 0 || height <= 0) {
1621      throw new Error("Invalid SVG dimensions");
1622    }
1623
1624    const svg = this._createSVG("svg:svg");
1625
1626    svg.setAttribute("version", "1.1");
1627    svg.setAttribute("width", `${width}px`);
1628    svg.setAttribute("height", `${height}px`);
1629    svg.setAttribute("preserveAspectRatio", "none");
1630    svg.setAttribute("viewBox", `0 0 ${width} ${height}`);
1631    return svg;
1632  }
1633
1634  createElement(type) {
1635    if (typeof type !== "string") {
1636      throw new Error("Invalid SVG element type");
1637    }
1638
1639    return this._createSVG(type);
1640  }
1641
1642  _createSVG(type) {
1643    (0, _util.unreachable)("Abstract method `_createSVG` called.");
1644  }
1645
1646}
1647
1648exports.BaseSVGFactory = BaseSVGFactory;
1649
1650/***/ }),
1651/* 6 */
1652/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
1653
1654
1655
1656Object.defineProperty(exports, "__esModule", ({
1657  value: true
1658}));
1659exports.getDocument = getDocument;
1660exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory;
1661exports.version = exports.PDFWorker = exports.PDFPageProxy = exports.PDFDocumentProxy = exports.PDFDataRangeTransport = exports.LoopbackPort = exports.DefaultStandardFontDataFactory = exp

1661orts.DefaultCMapReaderFactory = exports.DefaultCanvasFactory = exports.build = void 0;
1662
1663var _util = __w_pdfjs_require__(2);
1664
1665var _display_utils = __w_pdfjs_require__(1);
1666
1667var _font_loader = __w_pdfjs_require__(7);
1668
1669var _node_utils = __w_pdfjs_require__(8);
1670
1671var _annotation_storage = __w_pdfjs_require__(9);
1672
1673var _canvas = __w_pdfjs_require__(10);
1674
1675var _worker_options = __w_pdfjs_require__(12);
1676
1677var _is_node = __w_pdfjs_require__(4);
1678
1679var _message_handler = __w_pdfjs_require__(13);
1680
1681var _metadata = __w_pdfjs_require__(14);
1682
1683var _optional_content_config = __w_pdfjs_require__(15);
1684
1685var _transport_stream = __w_pdfjs_require__(16);
1686
1687const DEFAULT_RANGE_CHUNK_SIZE = 65536;
1688const RENDERING_CANCELLED_TIMEOUT = 100;
1689const DefaultCanvasFactory = _is_node.isNodeJS ? _node_utils.NodeCanvasFactory : _display_utils.DOMCanvasFactory;
1690exports.DefaultCanvasFactory = DefaultCanvasFactory;
1691const DefaultCMapReaderFactory = _is_node.isNodeJS ? _node_utils.NodeCMapReaderFactory : _display_utils.DOMCMapReaderFactory;
1692exports.DefaultCMapReaderFactory = DefaultCMapReaderFactory;
1693const DefaultStandardFontDataFactory = _is_node.isNodeJS ? _node_utils.NodeStandardFontDataFactory : _display_utils.DOMStandardFontDataFactory;
1694exports.DefaultStandardFontDataFactory = DefaultStandardFontDataFactory;
1695let createPDFNetworkStream;
1696
1697function setPDFNetworkStreamFactory(pdfNetworkStreamFactory) {
1698  createPDFNetworkStream = pdfNetworkStreamFactory;
1699}
1700
1701function getDocument(src) {
1702  const task = new PDFDocumentLoadingTask();
1703  let source;
1704
1705  if (typeof src === "string" || src instanceof URL) {
1706    source = {
1707      url: src
1708    };
1709  } else if ((0, _util.isArrayBuffer)(src)) {
1710    source = {
1711      data: src
1712    };
1713  } else if (src instanceof PDFDataRangeTransport) {
1714    source = {
1715      range: src
1716    };
1717  } else {
1718    if (typeof src !== "object") {
1719      throw new Error("Invalid parameter in getDocument, " + "need either string, URL, Uint8Array, or parameter object.");
1720    }
1721
1722    if (!src.url && !src.data && !src.range) {
1723      throw new Error("Invalid parameter object: need either .data, .range or .url");
1724    }
1725
1726    source = src;
1727  }
1728
1729  const params = Object.create(null);
1730  let rangeTransport = null,
1731      worker = null;
1732
1733  for (const key in source) {
1734    const value = source[key];
1735
1736    switch (key) {
1737      case "url":
1738        if (typeof window !== "undefined") {
1739          try {
1740            params[key] = new URL(value, window.location).href;
1741            continue;
1742          } catch (ex) {
1743            (0, _util.warn)(`Cannot create valid URL: "${ex}".`);
1744          }
1745        } else if (typeof value === "string" || value instanceof URL) {
1746          params[key] = value.toString();
1747          continue;
1748        }
1749
1750        throw new Error("Invalid PDF url data: " + "either string or URL-object is expected in the url property.");
1751
1752      case "range":
1753        rangeTransport = value;
1754        continue;
1755
1756      case "worker":
1757        worker = value;
1758        continue;
1759
1760      case "data":
1761        if (_is_node.isNodeJS && typeof Buffer !== "undefined" && value instanceof Buffer) {
1762          params[key] = new Uint8Array(value);
1763        } else if (value instanceof Uint8Array) {
1764          break;
1765        } else if (typeof value === "string") {
1766          params[key] = (0, _util.stringToBytes)(value);
1767        } else if (typeof value === "object" && value !== null && !isNaN(value.length)) {
1768          params[key] = new Uint8Array(value);
1769        } else if ((0, _util.isArrayBuffer)(value)) {
1770          params[key] = new Uint8Array(value);
1771        } else {
1772          throw new Error("Invalid PDF binary data: either typed array, " + "string, or array-like object is expected in the data property.");
1773        }
1774
1775        continue;
1776    }
1777
1778    params[key] = value;
1779  }
1780
1781  params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE;
1782  params.CMapReaderFactory = params.CMapReaderFactory || DefaultCMapReaderFactory;
1783  params.StandardFontDataFactory = params.StandardFontDataFactory || DefaultStandardFontDataFactory;
1784  params.ignoreErrors = params.stopAtErrors !== true;
1785  params.fontExtraProperties = params.fontExtraProperties === true;
1786  params.pdfBug = params.pdfBug === true;
1787  params.enableXfa = params.enableXfa === true;
1788
1789  if (typeof params.docBaseUrl !== "string" || (0, _display_utils.isDataScheme)(params.docBaseUrl)) {
1790    params.docBaseUrl = null;
1791  }
1792
1793  if (!Number.isInteger(params.maxImageSize)) {
1794    params.maxImageSize = -1;
1795  }
1796
1797  if (typeof params.useWorkerFetch !== "boolean") {
1798    params.useWorkerFetch = params.CMapReaderFactory === _display_utils.DOMCMapReaderFactory && params.StandardFontDataFactory === _display_utils.DOMStandardFontDataFactory;
1799  }
1800
1801  if (typeof params.isEvalSupported !== "boolean") {
1802    params.isEvalSupported = true;
1803  }
1804
1805  if (typeof params.disableFontFace !== "boolean") {
1806    params.disableFontFace = _is_node.isNodeJS;
1807  }
1808
1809  if (typeof params.useSystemFonts !== "boolean") {
1810    params.useSystemFonts = !_is_node.isNodeJS && !params.disableFontFace;
1811  }
1812
1813  if (typeof params.ownerDocument === "undefined") {
1814    params.ownerDocument = globalThis.document;
1815  }
1816
1817  if (typeof params.disableRange !== "boolean") {
1818    params.disableRange = false;

1819  }
1820
1821  if (typeof params.disableStream !== "boolean") {
1822    params.disableStream = false;
1823  }
1824
1825  if (typeof params.disableAutoFetch !== "boolean") {
1826    params.disableAutoFetch = false;
1827  }
1828
1829  (0, _util.setVerbosityLevel)(params.verbosity);
1830
1831  if (!worker) {
1832    const workerParams = {
1833      verbosity: params.verbosity,
1834      port: _worker_options.GlobalWorkerOptions.workerPort
1835    };
1836    worker = workerParams.port ? PDFWorker.fromPort(workerParams) : new PDFWorker(workerParams);
1837    task._worker = worker;
1838  }
1839
1840  const docId = task.docId;
1841  worker.promise.then(function () {
1842    if (task.destroyed) {
1843      throw new Error("Loading aborted");
1844    }
1845
1846    const workerIdPromise = _fetchDocument(worker, params, rangeTransport, docId);
1847
1848    const networkStreamPromise = new Promise(function (resolve) {
1849      let networkStream;
1850
1851      if (rangeTransport) {
1852        networkStream = new _transport_stream.PDFDataTransportStream({
1853          length: params.length,
1854          initialData: params.initialData,
1855          progressiveDone: params.progressiveDone,
1856          contentDispositionFilename: params.contentDispositionFilename,
1857          disableRange: params.disableRange,
1858          disableStream: params.disableStream
1859        }, rangeTransport);
1860      } else if (!params.data) {
1861        networkStream = createPDFNetworkStream({
1862          url: params.url,
1863          length: params.length,
1864          httpHeaders: params.httpHeaders,
1865          withCredentials: params.withCredentials,
1866          rangeChunkSize: params.rangeChunkSize,
1867          disableRange: params.disableRange,
1868          disableStream: params.disableStream
1869        });
1870      }
1871
1872      resolve(networkStream);
1873    });
1874    return Promise.all([workerIdPromise, networkStreamPromise]).then(function ([workerId, networkStream]) {
1875      if (task.destroyed) {
1876        throw new Error("Loading aborted");
1877      }
1878
1879      const messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port);
1880      messageHandler.postMessageTransfers = worker.postMessageTransfers;
1881      const transport = new WorkerTransport(messageHandler, task, networkStream, params);
1882      task._transport = transport;
1883      messageHandler.send("Ready", null);
1884    });
1885  }).catch(task._capability.reject);
1886  return task;
1887}
1888
1889function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {
1890  if (worker.destroyed) {
1891    return Promise.reject(new Error("Worker was destroyed"));
1892  }
1893
1894  if (pdfDataRangeTransport) {
1895    source.length = pdfDataRangeTransport.length;
1896    source.initialData = pdfDataRangeTransport.initialData;
1897    source.progressiveDone = pdfDataRangeTransport.progressiveDone;
1898    source.contentDispositionFilename = pdfDataRangeTransport.contentDispositionFilename;
1899  }
1900
1901  return worker.messageHandler.sendWithPromise("GetDocRequest", {
1902    docId,
1903    apiVersion: '2.10.377',
1904    source: {
1905      data: source.data,
1906      url: source.url,
1907      password: source.password,
1908      disableAutoFetch: source.disableAutoFetch,
1909      rangeChunkSize: source.rangeChunkSize,
1910      length: source.length
1911    },
1912    maxImageSize: source.maxImageSize,
1913    disableFontFace: source.disableFontFace,
1914    postMessageTransfers: worker.postMessageTransfers,
1915    docBaseUrl: source.docBaseUrl,
1916    ignoreErrors: source.ignoreErrors,
1917    isEvalSupported: source.isEvalSupported,
1918    fontExtraProperties: source.fontExtraProperties,
1919    enableXfa: source.enableXfa,
1920    useSystemFonts: source.useSystemFonts,
1921    cMapUrl: source.useWorkerFetch ? source.cMapUrl : null,
1922    standardFontDataUrl: source.useWorkerFetch ? source.standardFontDataUrl : null
1923  }).then(function (workerId) {
1924    if (worker.destroyed) {
1925      throw new Error("Worker was destroyed");
1926    }
1927
1928    return workerId;
1929  });
1930}
1931
1932const PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() {
1933  let nextDocumentId = 0;
1934
1935  class PDFDocumentLoadingTask {
1936    constructor() {
1937      this._capability = (0, _util.createPromiseCapability)();
1938      this._transport = null;
1939      this._worker = null;
1940      this.docId = "d" + nextDocumentId++;
1941      this.destroyed = false;
1942      this.onPassword = null;
1943      this.onProgress = null;
1944      this.onUnsupportedFeature = null;
1945    }
1946
1947    get promise() {
1948      return this._capability.promise;
1949    }
1950
1951    destroy() {
1952      this.destroyed = true;
1953      const transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy();
1954      return transportDestroyed.then(() => {
1955        this._transport = null;
1956
1957        if (this._worker) {
1958          this._worker.destroy();
1959
1960          this._worker = null;
1961        }
1962      });
1963    }
1964
1965  }
1966
1967  return PDFDocumentLoadingTask;
1968}();
1969
1970class PDFDataRangeTransport {
1971  constructor(length, initialData, progressiveDone = false, contentDispositionFilename = null) {
1972    this.length = length;
1973    this.initialData = initialData;
1974    this.progressiveDone = progressiveDone;
1975    this.contentDispositionFilename = contentDispositionFilename;
1976    this._rangeListeners = [];
1977    this._progressListeners = [];
1978    this._progressiveReadListeners = [];
1979    this._progressiveDoneListeners = [];
1980    this._readyCapability = (0, _util.createPromiseCapability)();
1981  }
1982
1983  addRangeListener(listener) {
1984    this._rangeListeners.push(listener);
1985  }
1986
1987  addProgressListener(listener) {
1988    this._progressListeners.push(listener);
1989  }
1990
1991  addProgressiveReadListener(listener) {
1992    this._progressiveReadListeners.push(listener);
1993  }
1994
1995  addProgressiveDoneListener(listener) {
1996    this._progressiveDoneListeners.push(listener);
1997  }
1998
1999  onDataRange(begin, chunk) {
2000    for (const listener of this._rangeListeners) {
2001      listener(begin, chunk);
2002    }
2003  }
2004
2005  onDataProgress(loaded, total) {
2006    this._readyCapability.promise.then(() => {
2007      for (const listener of this._progressListeners) {
2008        listener(loaded, total);
2009      }
2010    });
2011  }
2012
2013  onDataProgressiveRead(chunk) {
2014    this._readyCapability.promise.then(() => {
2015      for (const listener of this._progressiveReadListeners) {
2016        listener(chunk);
2017      }
2018    });
2019  }
2020
2021  onDataProgressiveDone() {
2022    this._readyCapability.promise.then(() => {
2023      for (const listener of this._progressiveDoneListeners) {
2024        listener();
2025      }
2026    });
2027  }
2028
2029  transportReady() {
2030    this._readyCapability.resolve();
2031  }
2032
2033  requestDataRange(begin, end) {
2034    (0, _util.unreachable)("Abstract method PDFDataRangeTransport.requestDataRange");
2035  }
2036
2037  abort() {}
2038
2039}
2040
2041exports.PDFDataRangeTransport = PDFDataRangeTransport;
2042
2043class PDFDocumentProxy {
2044  constructor(pdfInfo, transport) {
2045    this._pdfInfo = pdfInfo;
2046    this._transport = transport;
2047    Object.defineProperty(this, "fingerprint", {
2048      get() {
2049        (0, _display_utils.deprecated)("`PDFDocumentProxy.fingerprint`, " + "please use `PDFDocumentProxy.fingerprints` instead.");
2050        return this.fingerprints[0];
2051      }
2052
2053    });
2054  }
2055
2056  get annotationStorage() {
2057    return this._transport.annotationStorage;
2058  }
2059
2060  get numPages() {
2061    return this._pdfInfo.numPages;
2062  }
2063
2064  get fingerprints() {
2065    return this._pdfInfo.fingerprints;
2066  }
2067
2068  get isPureXfa() {
2069    return !!this._transport._htmlForXfa;
2070  }
2071
2072  get allXfaHtml() {
2073    return this._transport._htmlForXfa;
2074  }
2075
2076  getPage(pageNumber) {
2077    return this._transport.getPage(pageNumber);
2078  }
2079
2080  getPageIndex(ref) {
2081    return this._transport.getPageIndex(ref);
2082  }
2083
2084  getDestinations() {
2085    return this._transport.getDestinations();
2086  }
2087
2088  getDestination(id) {
2089    return this._transport.getDestination(id);
2090  }
2091
2092  getPageLabels() {
2093    return this._transport.getPageLabels();
2094  }
2095
2096  getPageLayout() {
2097    return this._transport.getPageLayout();
2098  }
2099
2100  getPageMode() {
2101    return this._transport.getPageMode();
2102  }
2103
2104  getViewerPreferences() {
2105    return this._transport.getViewerPreferences();
2106  }
2107
2108  getOpenAction() {
2109    return this._transport.getOpenAction();
2110  }
2111
2112  getAttachments() {
2113    return this._transport.getAttachments();
2114  }
2115
2116  getJavaScript() {
2117    return this._transport.getJavaScript();
2118  }
2119
2120  getJSActions() {
2121    return this._transport.getDocJSActions();
2122  }
2123
2124  getOutline() {
2125    return this._transport.getOutline();
2126  }
2127
2128  getOptionalContentConfig() {
2129    return this._transport.getOptionalContentConfig();
2130  }
2131
2132  getPermissions() {
2133    return this._transport.getPermissions();
2134  }
2135
2136  getMetadata() {
2137    return this._transport.getMetadata();
2138  }
2139
2140  getMarkInfo() {
2141    return this._transport.getMarkInfo();
2142  }
2143
2144  getData() {
2145    return this._transport.getData();
2146  }
2147
2148  getDownloadInfo() {
2149    return this._transport.downloadInfoCapability.promise;
2150  }
2151
2152  getStats() {
2153    return this._transport.getStats();
2154  }
2155
2156  cleanup(keepLoadedFonts = false) {
2157    return this._transport.startCleanup(keepLoadedFonts || this.isPureXfa);
2158  }
2159
2160  destroy() {
2161    return this.loadingTask.destroy();
2162  }
2163
2164  get loadingParams() {
2165    return this._transport.loadingParams;
2166  }
2167
2168  get loadingTask() {
2169    return this._transport.loadingTask;
2170  }
2171
2172  saveDocument() {
2173    if (this._transport.annotationStorage.size <= 0) {
2174      (0, _display_utils.deprecated)("saveDocument called while `annotationStorage` is empty, " + "please use the getData-method instead.");
2175    }
2176
2177    return this._transport.saveDocument();
2178  }
2179
2180  getFieldObjects() {
2181    return this._transport.getFieldObjects();
2182  }
2183
2184  hasJSActions() {
2185    return this._transport.hasJSActions();
2186  }
2187
2188  getCalculationOrderIds() {
2189    return this._transport.getCalculationOrderIds();
2190  }
2191
2192}
2193
2194exports.PDFDocumentProxy = PDFDocumentProxy;
2195
2196class PDFPageProxy {
2197  constructor(pageIndex, pageInfo, transport, ownerDocument, pdfBug = false) {
2198    this._pageIndex = pageIndex;
2199    this._pageInfo = pageInfo;
2200    this._ownerDocument = ownerDocument;
2201    this._transport = transport;
2202    this._stats = pdfBug ? new _display_utils.StatTimer() : null;
2203    this._pdfBug = pdfBug;
2204    this.commonObjs = transport.commonObjs;
2205    this.objs = new PDFObjects();
2206    this.cleanupAfterRender = false;

2207    this.pendingCleanup = false;
2208    this._intentStates = new Map();
2209    this.destroyed = false;
2210  }
2211
2212  get pageNumber() {
2213    return this._pageIndex + 1;
2214  }
2215
2216  get rotate() {
2217    return this._pageInfo.rotate;
2218  }
2219
2220  get ref() {
2221    return this._pageInfo.ref;
2222  }
2223
2224  get userUnit() {
2225    return this._pageInfo.userUnit;
2226  }
2227
2228  get view() {
2229    return this._pageInfo.view;
2230  }
2231
2232  getViewport({
2233    scale,
2234    rotation = this.rotate,
2235    offsetX = 0,
2236    offsetY = 0,
2237    dontFlip = false
2238  } = {}) {
2239    return new _display_utils.PageViewport({
2240      viewBox: this.view,
2241      scale,
2242      rotation,
2243      offsetX,
2244      offsetY,
2245      dontFlip
2246    });
2247  }
2248
2249  getAnnotations({
2250    intent = null
2251  } = {}) {
2252    const renderingIntent = intent === "display" || intent === "print" ? intent : null;
2253
2254    if (!this._annotationsPromise || this._annotationsIntent !== renderingIntent) {
2255      this._annotationsPromise = this._transport.getAnnotations(this._pageIndex, renderingIntent);
2256      this._annotationsIntent = renderingIntent;
2257    }
2258
2259    return this._annotationsPromise;
2260  }
2261
2262  getJSActions() {
2263    return this._jsActionsPromise || (this._jsActionsPromise = this._transport.getPageJSActions(this._pageIndex));
2264  }
2265
2266  async getXfa() {
2267    return this._transport._htmlForXfa?.children[this._pageIndex] || null;
2268  }
2269
2270  render({
2271    canvasContext,
2272    viewport,
2273    intent = "display",
2274    renderInteractiveForms = false,
2275    transform = null,
2276    imageLayer = null,
2277    canvasFactory = null,
2278    background = null,
2279    includeAnnotationStorage = false,
2280    optionalContentConfigPromise = null
2281  }) {
2282    var _intentState;
2283
2284    if (this._stats) {
2285      this._stats.time("Overall");
2286    }
2287
2288    const renderingIntent = intent === "print" ? "print" : "display";
2289    this.pendingCleanup = false;
2290
2291    if (!optionalContentConfigPromise) {
2292      optionalContentConfigPromise = this._transport.getOptionalContentConfig();
2293    }
2294
2295    let intentState = this._intentStates.get(renderingIntent);
2296
2297    if (!intentState) {
2298      intentState = Object.create(null);
2299
2300      this._intentStates.set(renderingIntent, intentState);
2301    }
2302
2303    if (intentState.streamReaderCancelTimeout) {
2304      clearTimeout(intentState.streamReaderCancelTimeout);
2305      intentState.streamReaderCancelTimeout = null;
2306    }
2307
2308    const canvasFactoryInstance = canvasFactory || new DefaultCanvasFactory({
2309      ownerDocument: this._ownerDocument
2310    });
2311    const annotationStorage = includeAnnotationStorage ? this._transport.annotationStorage.serializable : null;
2312
2313    if (!intentState.displayReadyCapability) {
2314      intentState.displayReadyCapability = (0, _util.createPromiseCapability)();
2315      intentState.operatorList = {
2316        fnArray: [],
2317        argsArray: [],
2318        lastChunk: false
2319      };
2320
2321      if (this._stats) {
2322        this._stats.time("Page Request");
2323      }
2324
2325      this._pumpOperatorList({
2326        pageIndex: this._pageIndex,
2327        intent: renderingIntent,
2328        renderInteractiveForms: renderInteractiveForms === true,
2329        annotationStorage
2330      });
2331    }
2332
2333    const complete = error => {
2334      intentState.renderTasks.delete(internalRenderTask);
2335
2336      if (this.cleanupAfterRender || renderingIntent === "print") {
2337        this.pendingCleanup = true;
2338      }
2339
2340      this._tryCleanup();
2341
2342      if (error) {
2343        internalRenderTask.capability.reject(error);
2344
2345        this._abortOperatorList({
2346          intentState,
2347          reason: error
2348        });
2349      } else {
2350        internalRenderTask.capability.resolve();
2351      }
2352
2353      if (this._stats) {
2354        this._stats.timeEnd("Rendering");
2355
2356        this._stats.timeEnd("Overall");
2357      }
2358    };
2359
2360    const internalRenderTask = new InternalRenderTask({
2361      callback: complete,
2362      params: {
2363        canvasContext,
2364        viewport,
2365        transform,
2366        imageLayer,
2367        background
2368      },
2369      objs: this.objs,
2370      commonObjs: this.commonObjs,
2371      operatorList: intentState.operatorList,
2372      pageIndex: this._pageIndex,
2373      canvasFactory: canvasFactoryInstance,
2374      useRequestAnimationFrame: renderingIntent !== "print",
2375      pdfBug: this._pdfBug
2376    });
2377    ((_intentState = intentState).renderTasks || (_intentState.renderTasks = new Set())).add(internalRenderTask);
2378    const renderTask = internalRenderTask.task;
2379    Promise.all([intentState.displayReadyCapability.promise, optionalContentConfigPromise]).then(([transparency, optionalContentConfig]) => {
2380      if (this.pendingCleanup) {
2381        complete();
2382        return;
2383      }
2384
2385      if (this._stats) {

2386        this._stats.time("Rendering");
2387      }
2388
2389      internalRenderTask.initializeGraphics({
2390        transparency,
2391        optionalContentConfig
2392      });
2393      internalRenderTask.operatorListChanged();
2394    }).catch(complete);
2395    return renderTask;
2396  }
2397
2398  getOperatorList({
2399    intent = "display"
2400  } = {}) {
2401    function operatorListChanged() {
2402      if (intentState.operatorList.lastChunk) {
2403        intentState.opListReadCapability.resolve(intentState.operatorList);
2404        intentState.renderTasks.delete(opListTask);
2405      }
2406    }
2407
2408    const renderingIntent = `oplist-${intent === "print" ? "print" : "display"}`;
2409
2410    let intentState = this._intentStates.get(renderingIntent);
2411
2412    if (!intentState) {
2413      intentState = Object.create(null);
2414
2415      this._intentStates.set(renderingIntent, intentState);
2416    }
2417
2418    let opListTask;
2419
2420    if (!intentState.opListReadCapability) {
2421      var _intentState2;
2422
2423      opListTask = Object.create(null);
2424      opListTask.operatorListChanged = operatorListChanged;
2425      intentState.opListReadCapability = (0, _util.createPromiseCapability)();
2426      ((_intentState2 = intentState).renderTasks || (_intentState2.renderTasks = new Set())).add(opListTask);
2427      intentState.operatorList = {
2428        fnArray: [],
2429        argsArray: [],
2430        lastChunk: false
2431      };
2432
2433      if (this._stats) {
2434        this._stats.time("Page Request");
2435      }
2436
2437      this._pumpOperatorList({
2438        pageIndex: this._pageIndex,
2439        intent: renderingIntent
2440      });
2441    }
2442
2443    return intentState.opListReadCapability.promise;
2444  }
2445
2446  streamTextContent({
2447    normalizeWhitespace = false,
2448    disableCombineTextItems = false,
2449    includeMarkedContent = false
2450  } = {}) {
2451    const TEXT_CONTENT_CHUNK_SIZE = 100;
2452    return this._transport.messageHandler.sendWithStream("GetTextContent", {
2453      pageIndex: this._pageIndex,
2454      normalizeWhitespace: normalizeWhitespace === true,
2455      combineTextItems: disableCombineTextItems !== true,
2456      includeMarkedContent: includeMarkedContent === true
2457    }, {
2458      highWaterMark: TEXT_CONTENT_CHUNK_SIZE,
2459
2460      size(textContent) {
2461        return textContent.items.length;
2462      }
2463
2464    });
2465  }
2466
2467  getTextContent(params = {}) {
2468    const readableStream = this.streamTextContent(params);
2469    return new Promise(function (resolve, reject) {
2470      function pump() {
2471        reader.read().then(function ({
2472          value,
2473          done
2474        }) {
2475          if (done) {
2476            resolve(textContent);
2477            return;
2478          }
2479
2480          Object.assign(textContent.styles, value.styles);
2481          textContent.items.push(...value.items);
2482          pump();
2483        }, reject);
2484      }
2485
2486      const reader = readableStream.getReader();
2487      const textContent = {
2488        items: [],
2489        styles: Object.create(null)
2490      };
2491      pump();
2492    });
2493  }
2494
2495  getStructTree() {
2496    return this._structTreePromise || (this._structTreePromise = this._transport.getStructTree(this._pageIndex));
2497  }
2498
2499  _destroy() {
2500    this.destroyed = true;
2501    this._transport.pageCache[this._pageIndex] = null;
2502    const waitOn = [];
2503
2504    for (const [intent, intentState] of this._intentStates) {
2505      this._abortOperatorList({
2506        intentState,
2507        reason: new Error("Page was destroyed."),
2508        force: true
2509      });
2510
2511      if (intent.startsWith("oplist-")) {
2512        continue;
2513      }
2514
2515      for (const internalRenderTask of intentState.renderTasks) {
2516        waitOn.push(internalRenderTask.completed);
2517        internalRenderTask.cancel();
2518      }
2519    }
2520
2521    this.objs.clear();
2522    this._annotationsPromise = null;
2523    this._jsActionsPromise = null;
2524    this._structTreePromise = null;
2525    this.pendingCleanup = false;
2526    return Promise.all(waitOn);
2527  }
2528
2529  cleanup(resetStats = false) {
2530    this.pendingCleanup = true;
2531    return this._tryCleanup(resetStats);
2532  }
2533
2534  _tryCleanup(resetStats = false) {
2535    if (!this.pendingCleanup) {
2536      return false;
2537    }
2538
2539    for (const {
2540      renderTasks,
2541      operatorList
2542    } of this._intentStates.values()) {
2543      if (renderTasks.size > 0 || !operatorList.lastChunk) {
2544        return false;

2545      }
2546    }
2547
2548    this._intentStates.clear();
2549
2550    this.objs.clear();
2551    this._annotationsPromise = null;
2552    this._jsActionsPromise = null;
2553    this._structTreePromise = null;
2554
2555    if (resetStats && this._stats) {
2556      this._stats = new _display_utils.StatTimer();
2557    }
2558
2559    this.pendingCleanup = false;
2560    return true;
2561  }
2562
2563  _startRenderPage(transparency, intent) {
2564    const intentState = this._intentStates.get(intent);
2565
2566    if (!intentState) {
2567      return;
2568    }
2569
2570    if (this._stats) {
2571      this._stats.timeEnd("Page Request");
2572    }
2573
2574    if (intentState.displayReadyCapability) {
2575      intentState.displayReadyCapability.resolve(transparency);
2576    }
2577  }
2578
2579  _renderPageChunk(operatorListChunk, intentState) {
2580    for (let i = 0, ii = operatorListChunk.length; i < ii; i++) {
2581      intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);
2582      intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);
2583    }
2584
2585    intentState.operatorList.lastChunk = operatorListChunk.lastChunk;
2586
2587    for (const internalRenderTask of intentState.renderTasks) {
2588      internalRenderTask.operatorListChanged();
2589    }
2590
2591    if (operatorListChunk.lastChunk) {
2592      this._tryCleanup();
2593    }
2594  }
2595
2596  _pumpOperatorList(args) {
2597    (0, _util.assert)(args.intent, 'PDFPageProxy._pumpOperatorList: Expected "intent" argument.');
2598
2599    const readableStream = this._transport.messageHandler.sendWithStream("GetOperatorList", args);
2600
2601    const reader = readableStream.getReader();
2602
2603    const intentState = this._intentStates.get(args.intent);
2604
2605    intentState.streamReader = reader;
2606
2607    const pump = () => {
2608      reader.read().then(({
2609        value,
2610        done
2611      }) => {
2612        if (done) {
2613          intentState.streamReader = null;
2614          return;
2615        }
2616
2617        if (this._transport.destroyed) {
2618          return;
2619        }
2620
2621        this._renderPageChunk(value, intentState);
2622
2623        pump();
2624      }, reason => {
2625        intentState.streamReader = null;
2626
2627        if (this._transport.destroyed) {
2628          return;
2629        }
2630
2631        if (intentState.operatorList) {
2632          intentState.operatorList.lastChunk = true;
2633
2634          for (const internalRenderTask of intentState.renderTasks) {
2635            internalRenderTask.operatorListChanged();
2636          }
2637
2638          this._tryCleanup();
2639        }
2640
2641        if (intentState.displayReadyCapability) {
2642          intentState.displayReadyCapability.reject(reason);
2643        } else if (intentState.opListReadCapability) {
2644          intentState.opListReadCapability.reject(reason);
2645        } else {
2646          throw reason;
2647        }
2648      });
2649    };
2650
2651    pump();
2652  }
2653
2654  _abortOperatorList({
2655    intentState,
2656    reason,
2657    force = false
2658  }) {
2659    (0, _util.assert)(reason instanceof Error || typeof reason === "object" && reason !== null, 'PDFPageProxy._abortOperatorList: Expected "reason" argument.');
2660
2661    if (!intentState.streamReader) {
2662      return;
2663    }
2664
2665    if (!force) {
2666      if (intentState.renderTasks.size > 0) {
2667        return;
2668      }
2669
2670      if (reason instanceof _display_utils.RenderingCancelledException) {
2671        intentState.streamReaderCancelTimeout = setTimeout(() => {
2672          this._abortOperatorList({
2673            intentState,
2674            reason,
2675            force: true
2676          });
2677
2678          intentState.streamReaderCancelTimeout = null;
2679        }, RENDERING_CANCELLED_TIMEOUT);
2680        return;
2681      }
2682    }
2683
2684    intentState.streamReader.cancel(new _util.AbortException(reason?.message));
2685    intentState.streamReader = null;
2686
2687    if (this._transport.destroyed) {
2688      return;
2689    }
2690
2691    for (const [intent, curIntentState] of this._intentStates) {
2692      if (curIntentState === intentState) {
2693        this._intentStates.delete(intent);
2694
2695        break;
2696      }
2697    }
2698
2699    this.cleanup();
2700  }
2701
2702  get stats() {
2703    return this._stats;
2704  }
2705
2706}
2707
2708exports.PDFPageProxy = PDFPageProxy;
2709
2710class LoopbackPort {
2711  constructor() {
2712    this._listeners = [];
2713    this._deferred = Promise.resolve(undefined);
2714  }
2715
2716  postMessage(obj, transfers) {
2717    function cloneValue(value) {
2718      if (typeof value === "function" || typeof value === "symbol" || value instanceof URL) {
2719        throw new Error(`LoopbackPort.postMessage - cannot clone: ${value?.toString()}`);
2720      }
2721
2722      if (typeof value !== "object" || value === null) {
2723        return value;
2724      }
2725
2726      if (cloned.has(value)) {
2727        return cloned.get(value);
2728      }
2729
2730      let buffer, result;
2731
2732      if ((buffer = value.buffer) && (0, _util.isArrayBuffer)(buffer)) {
2733        if (transfers?.includes(buffer)) {
2734          result = new value.constructor(buffer, value.byteOffset, value.byteLength);
2735        } else {
2736          result = new value.constructor(value);
2737        }
2738
2739        cloned.set(value, result);
2740        return result;
2741      }
2742
2743      if (value instanceof Map) {
2744        result = new Map();
2745        cloned.set(value, result);
2746
2747        for (const [key, val] of value) {
2748          result.set(key, cloneValue(val));
2749        }
2750
2751        return result;
2752      }
2753
2754      if (value instanceof Set) {
2755        result = new Set();
2756        cloned.set(value, result);
2757
2758        for (const val of value) {
2759          result.add(cloneValue(val));
2760        }
2761
2762        return result;
2763      }
2764
2765      result = Array.isArray(value) ? [] : Object.create(null);
2766      cloned.set(value, result);
2767
2768      for (const i in value) {
2769        let desc,
2770            p = value;
2771
2772        while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {
2773          p = Object.getPrototypeOf(p);
2774        }
2775
2776        if (typeof desc.value === "undefined") {
2777          continue;
2778        }
2779
2780        if (typeof desc.value === "function" && !value.hasOwnProperty?.(i)) {
2781          continue;
2782        }
2783
2784        result[i] = cloneValue(desc.value);
2785      }
2786
2787      return result;
2788    }
2789
2790    const cloned = new WeakMap();
2791    const event = {
2792      data: cloneValue(obj)
2793    };
2794
2795    this._deferred.then(() => {
2796      for (const listener of this._listeners) {
2797        listener.call(this, event);
2798      }
2799    });
2800  }
2801
2802  addEventListener(name, listener) {
2803    this._listeners.push(listener);
2804  }
2805
2806  removeEventListener(name, listener) {
2807    const i = this._listeners.indexOf(listener);
2808
2809    this._listeners.splice(i, 1);
2810  }
2811
2812  terminate() {
2813    this._listeners.length = 0;
2814  }
2815
2816}
2817
2818exports.LoopbackPort = LoopbackPort;
2819
2820const PDFWorker = function PDFWorkerClosure() {
2821  const pdfWorkerPorts = new WeakMap();
2822  let isWorkerDisabled = false;