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() {
33
return /******/ (() => { // webpackBootstrap
34
/******/ 	var __webpack_modules__ = ([
35
/* 0 */,
36
/* 1 */
37
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
38

39
"use strict";
40

41

42
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
43

44
Object.defineProperty(exports, "__esModule", ({
45
  value: true
46
}));
47
exports.addLinkAttributes = addLinkAttributes;
48
exports.deprecated = deprecated;
49
exports.getFilenameFromUrl = getFilenameFromUrl;
50
exports.getPdfFilenameFromUrl = getPdfFilenameFromUrl;
51
exports.isDataScheme = isDataScheme;
52
exports.isFetchSupported = isFetchSupported;
53
exports.isPdfFile = isPdfFile;
54
exports.isValidFetchUrl = isValidFetchUrl;
55
exports.loadScript = loadScript;
56
exports.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;
57

58
var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
59

60
var _util = __w_pdfjs_require__(4);
61

62
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
63

64
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
65

66
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
67

68
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
69

70
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
71

72
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
73

74
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
75

76
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
77

78
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
79

80
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
81

82
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
83

84
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
85

86
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
87

88
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
89

90
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
91

92
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
93

94
var DEFAULT_LINK_REL = "noopener noreferrer nofollow";
95
exports.DEFAULT_LINK_REL = DEFAULT_LINK_REL;
96
var SVG_NS = "http://www.w3.org/2000/svg";
97

98
var BaseCanvasFactory = /*#__PURE__*/function () {
99
  function BaseCanvasFactory() {
100
    _classCallCheck(this, BaseCanvasFactory);
101

102
    if (this.constructor === BaseCanvasFactory) {
103
      (0, _util.unreachable)("Cannot initialize BaseCanvasFactory.");
104
    }
105
  }
106

107
  _createClass(BaseCanvasFactory, [{
108
    key: "create",
109
    value: function create(width, height) {
110
      (0, _util.unreachable)("Abstract method `create` called.");
111
    }
112
  }, {
113
    key: "reset",
114
    value: function reset(canvasAndContext, width, height) {
115
      if (!canvasAndContext.canvas) {
116
        throw new Error("Canvas is not specified");
117
      }
118

119
      if (width <= 0 || height <= 0) {
120
        throw new Error("Invalid canvas size");
121
      }
122

123
      canvasAndContext.canvas.width = width;
124
      canvasAndContext.canvas.height = height;
125
    }
126
  }, {
127
    key: "destroy",
128
    value: function destroy(canvasAndContext) {
129
      if (!canvasAndContext.canvas) {
130
        throw new Error("Canvas is not specified");
131
      }
132

133
      canvasAndContext.canvas.width = 0;
134
      canvasAndContext.canvas.height = 0;
135
      canvasAndContext.canvas = null;
136
      canvasAndContext.context = null;
137
    }
138
  }]);
139

140
  return BaseCanvasFactory;
141
}();
142

143
exports.BaseCanvasFactory = BaseCanvasFactory;
144

145
var DOMCanvasFactory = /*#__PURE__*/function (_BaseCanvasFactory) {
146
  _inherits(DOMCanvasFactory, _BaseCanvasFactory);
147

148
  var _super = _createSuper(DOMCanvasFactory);
149

150
  function DOMCanvasFactory() {
151
    var _this;
152

153
    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
154
        _ref$ownerDocument = _ref.ownerDocument,
155
        ownerDocument = _ref$ownerDocument === void 0 ? globalThis.document : _ref$ownerDocument;
156

157
    _classCallCheck(this, DOMCanvasFactory);
158

159
    _this = _super.call(this);
160
    _this._document = ownerDocument;
161
    return _this;
162
  }
163

164
  _createClass(DOMCanvasFactory, [{
165
    key: "create",
166
    value: function create(width, height) {
167
      if (width <= 0 || height <= 0) {
168
        throw new Error("Invalid canvas size");
169
      }
170

171
      var canvas = this._document.createElement("canvas");
172

173
      var context = canvas.getContext("2d");
174
      canvas.width = width;
175
      canvas.height = height;
176
      return {
177
        canvas: canvas,
178
        context: context
179
      };
180
    }
181
  }]);
182

183
  return DOMCanvasFactory;
184
}(BaseCanvasFactory);
185

186
exports.DOMCanvasFactory = DOMCanvasFactory;
187

188
var BaseCMapReaderFactory = /*#__PURE__*/function () {
189
  function BaseCMapReaderFactory(_ref2) {
190
    var _ref2$baseUrl = _ref2.baseUrl,
191
        baseUrl = _ref2$baseUrl === void 0 ? null : _ref2$baseUrl,
192
        _ref2$isCompressed = _ref2.isCompressed,
193
        isCompressed = _ref2$isCompressed === void 0 ? false : _ref2$isCompressed;
194

195
    _classCallCheck(this, BaseCMapReaderFactory);
196

197
    if (this.constructor === BaseCMapReaderFactory) {
198
      (0, _util.unreachable)("Cannot initialize BaseCMapReaderFactory.");
199
    }
200

201
    this.baseUrl = baseUrl;
202
    this.isCompressed = isCompressed;
203
  }
204

205
  _createClass(BaseCMapReaderFactory, [{
206
    key: "fetch",
207
    value: function () {
208
      var _fetch = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee(_ref3) {
209
        var _this2 = this;
210

211
        var name, url, compressionType;
212
        return _regenerator["default"].wrap(function _callee$(_context) {
213
          while (1) {
214
            switch (_context.prev = _context.next) {
215
              case 0:
216
                name = _ref3.name;
217

218
                if (this.baseUrl) {
219
                  _context.next = 3;
220
                  break;
221
                }
222

223
                throw new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.');
224

225
              case 3:
226
                if (name) {
227
                  _context.next = 5;
228
                  break;
229
                }
230

231
                throw new Error("CMap name must be specified.");
232

233
              case 5:
234
                url = this.baseUrl + name + (this.isCompressed ? ".bcmap" : "");
235
                compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE;
236
                return _context.abrupt("return", this._fetchData(url, compressionType)["catch"](function (reason) {
237
                  throw new Error("Unable to load ".concat(_this2.isCompressed ? "binary " : "", "CMap at: ").concat(url));
238
                }));
239

240
              case 8:
241
              case "end":
242
                return _context.stop();
243
            }
244
          }
245
        }, _callee, this);
246
      }));
247

248
      function fetch(_x) {
249
        return _fetch.apply(this, arguments);
250
      }
251

252
      return fetch;
253
    }()
254
  }, {
255
    key: "_fetchData",
256
    value: function _fetchData(url, compressionType) {
257
      (0, _util.unreachable)("Abstract method `_fetchData` called.");
258
    }
259
  }]);
260

261
  return BaseCMapReaderFactory;
262
}();
263

264
exports.BaseCMapReaderFactory = BaseCMapReaderFactory;
265

266
var DOMCMapReaderFactory = /*#__PURE__*/function (_BaseCMapReaderFactor) {
267
  _inherits(DOMCMapReaderFactory, _BaseCMapReaderFactor);
268

269
  var _super2 = _createSuper(DOMCMapReaderFactory);
270

271
  function DOMCMapReaderFactory() {
272
    _classCallCheck(this, DOMCMapReaderFactory);
273

274
    return _super2.apply(this, arguments);
275
  }
276

277
  _createClass(DOMCMapReaderFactory, [{
278
    key: "_fetchData",
279
    value: function _fetchData(url, compressionType) {
280
      var _this3 = this;
281

282
      if (isFetchSupported() && isValidFetchUrl(url, document.baseURI)) {
283
        return fetch(url).then( /*#__PURE__*/function () {
284
          var _ref4 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2(response) {
285
            var cMapData;
286
            return _regenerator["default"].wrap(function _callee2$(_context2) {
287
              while (1) {
288
                switch (_context2.prev = _context2.next) {
289
                  case 0:
290
                    if (response.ok) {
291
                      _context2.next = 2;
292
                      break;
293
                    }
294

295
                    throw new Error(response.statusText);
296

297
                  case 2:
298
                    if (!_this3.isCompressed) {
299
                      _context2.next = 10;
300
                      break;
301
                    }
302

303
                    _context2.t0 = Uint8Array;
304
                    _context2.next = 6;
305
                    return response.arrayBuffer();
306

307
                  case 6:
308
                    _context2.t1 = _context2.sent;
309
                    cMapData = new _context2.t0(_context2.t1);
310
                    _context2.next = 15;
311
                    break;
312

313
                  case 10:
314
                    _context2.t2 = _util.stringToBytes;
315
                    _context2.next = 13;
316
                    return response.text();
317

318
                  case 13:
319
                    _context2.t3 = _context2.sent;
320
                    cMapData = (0, _context2.t2)(_context2.t3);
321

322
                  case 15:
323
                    return _context2.abrupt("return", {
324
                      cMapData: cMapData,
325
                      compressionType: compressionType
326
                    });
327

328
                  case 16:
329
                  case "end":
330
                    return _context2.stop();
331
                }
332
              }
333
            }, _callee2);
334
          }));
335

336
          return function (_x2) {
337
            return _ref4.apply(this, arguments);
338
          };
339
        }());
340
      }
341

342
      return new Promise(function (resolve, reject) {
343
        var request = new XMLHttpRequest();
344
        request.open("GET", url, true);
345

346
        if (_this3.isCompressed) {
347
          request.responseType = "arraybuffer";
348
        }
349

350
        request.onreadystatechange = function () {
351
          if (request.readyState !== XMLHttpRequest.DONE) {
352
            return;
353
          }
354

355
          if (request.status === 200 || request.status === 0) {
356
            var cMapData;
357

358
            if (_this3.isCompressed && request.response) {
359
              cMapData = new Uint8Array(request.response);
360
            } else if (!_this3.isCompressed && request.responseText) {
361
              cMapData = (0, _util.stringToBytes)(request.responseText);
362
            }
363

364
            if (cMapData) {
365
              resolve({
366
                cMapData: cMapData,
367
                compressionType: compressionType
368
              });
369
              return;
370
            }
371
          }
372

373
          reject(new Error(request.statusText));
374
        };
375

376
        request.send(null);
377
      });
378
    }
379
  }]);
380

381
  return DOMCMapReaderFactory;
382
}(BaseCMapReaderFactory);
383

384
exports.DOMCMapReaderFactory = DOMCMapReaderFactory;
385

386
var DOMSVGFactory = /*#__PURE__*/function () {
387
  function DOMSVGFactory() {
388
    _classCallCheck(this, DOMSVGFactory);
389
  }
390

391
  _createClass(DOMSVGFactory, [{
392
    key: "create",
393
    value: function create(width, height) {
394
      (0, _util.assert)(width > 0 && height > 0, "Invalid SVG dimensions");
395
      var svg = document.createElementNS(SVG_NS, "svg:svg");
396
      svg.setAttribute("version", "1.1");
397
      svg.setAttribute("width", width + "px");
398
      svg.setAttribute("height", height + "px");
399
      svg.setAttribute("preserveAspectRatio", "none");
400
      svg.setAttribute("viewBox", "0 0 " + width + " " + height);
401
      return svg;
402
    }
403
  }, {
404
    key: "createElement",
405
    value: function createElement(type) {
406
      (0, _util.assert)(typeof type === "string", "Invalid SVG element type");
407
      return document.createElementNS(SVG_NS, type);
408
    }
409
  }]);
410

411
  return DOMSVGFactory;
412
}();
413

414
exports.DOMSVGFactory = DOMSVGFactory;
415

416
var PageViewport = /*#__PURE__*/function () {
417
  function PageViewport(_ref5) {
418
    var viewBox = _ref5.viewBox,
419
        scale = _ref5.scale,
420
        rotation = _ref5.rotation,
421
        _ref5$offsetX = _ref5.offsetX,
422
        offsetX = _ref5$offsetX === void 0 ? 0 : _ref5$offsetX,
423
        _ref5$offsetY = _ref5.offsetY,
424
        offsetY = _ref5$offsetY === void 0 ? 0 : _ref5$offsetY,
425
        _ref5$dontFlip = _ref5.dontFlip,
426
        dontFlip = _ref5$dontFlip === void 0 ? false : _ref5$dontFlip;
427

428
    _classCallCheck(this, PageViewport);
429

430
    this.viewBox = viewBox;
431
    this.scale = scale;
432
    this.rotation = rotation;
433
    this.offsetX = offsetX;
434
    this.offsetY = offsetY;
435
    var centerX = (viewBox[2] + viewBox[0]) / 2;
436
    var centerY = (viewBox[3] + viewBox[1]) / 2;
437
    var rotateA, rotateB, rotateC, rotateD;
438
    rotation %= 360;
439

440
    if (rotation < 0) {
441
      rotation += 360;
442
    }
443

444
    switch (rotation) {
445
      case 180:
446
        rotateA = -1;
447
        rotateB = 0;
448
        rotateC = 0;
449
        rotateD = 1;
450
        break;
451

452
      case 90:
453
        rotateA = 0;
454
        rotateB = 1;
455
        rotateC = 1;
456
        rotateD = 0;
457
        break;
458

459
      case 270:
460
        rotateA = 0;
461
        rotateB = -1;
462
        rotateC = -1;
463
        rotateD = 0;
464
        break;
465

466
      case 0:
467
        rotateA = 1;
468
        rotateB = 0;
469
        rotateC = 0;
470
        rotateD = -1;
471
        break;
472

473
      default:
474
        throw new Error("PageViewport: Invalid rotation, must be a multiple of 90 degrees.");
475
    }
476

477
    if (dontFlip) {
478
      rotateC = -rotateC;
479
      rotateD = -rotateD;
480
    }
481

482
    var offsetCanvasX, offsetCanvasY;
483
    var width, height;
484

485
    if (rotateA === 0) {
486
      offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
487
      offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
488
      width = Math.abs(viewBox[3] - viewBox[1]) * scale;
489
      height = Math.abs(viewBox[2] - viewBox[0]) * scale;
490
    } else {
491
      offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
492
      offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
493
      width = Math.abs(viewBox[2] - viewBox[0]) * scale;
494
      height = Math.abs(viewBox[3] - viewBox[1]) * scale;
495
    }
496

497
    this.transform = [rotateA * scale, rotateB * scale, rotateC * scale, rotateD * scale, offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY, offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY];
498
    this.width = width;
499
    this.height = height;
500
  }
501

502
  _createClass(PageViewport, [{
503
    key: "clone",
504
    value: function clone() {
505
      var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
506
          _ref6$scale = _ref6.scale,
507
          scale = _ref6$scale === void 0 ? this.scale : _ref6$scale,
508
          _ref6$rotation = _ref6.rotation,
509
          rotation = _ref6$rotation === void 0 ? this.rotation : _ref6$rotation,
510
          _ref6$offsetX = _ref6.offsetX,
511
          offsetX = _ref6$offsetX === void 0 ? this.offsetX : _ref6$offsetX,
512
          _ref6$offsetY = _ref6.offsetY,
513
          offsetY = _ref6$offsetY === void 0 ? this.offsetY : _ref6$offsetY,
514
          _ref6$dontFlip = _ref6.dontFlip,
515
          dontFlip = _ref6$dontFlip === void 0 ? false : _ref6$dontFlip;
516

517
      return new PageViewport({
518
        viewBox: this.viewBox.slice(),
519
        scale: scale,
520
        rotation: rotation,
521
        offsetX: offsetX,
522
        offsetY: offsetY,
523
        dontFlip: dontFlip
524
      });
525
    }
526
  }, {
527
    key: "convertToViewportPoint",
528
    value: function convertToViewportPoint(x, y) {
529
      return _util.Util.applyTransform([x, y], this.transform);
530
    }
531
  }, {
532
    key: "convertToViewportRectangle",
533
    value: function convertToViewportRectangle(rect) {
534
      var topLeft = _util.Util.applyTransform([rect[0], rect[1]], this.transform);
535

536
      var bottomRight = _util.Util.applyTransform([rect[2], rect[3]], this.transform);
537

538
      return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]];
539
    }
540
  }, {
541
    key: "convertToPdfPoint",
542
    value: function convertToPdfPoint(x, y) {
543
      return _util.Util.applyInverseTransform([x, y], this.transform);
544
    }
545
  }]);
546

547
  return PageViewport;
548
}();
549

550
exports.PageViewport = PageViewport;
551

552
var RenderingCancelledException = /*#__PURE__*/function (_BaseException) {
553
  _inherits(RenderingCancelledException, _BaseException);
554

555
  var _super3 = _createSuper(RenderingCancelledException);
556

557
  function RenderingCancelledException(msg, type) {
558
    var _this4;
559

560
    _classCallCheck(this, RenderingCancelledException);
561

562
    _this4 = _super3.call(this, msg);
563
    _this4.type = type;
564
    return _this4;
565
  }
566

567
  return RenderingCancelledException;
568
}(_util.BaseException);
569

570
exports.RenderingCancelledException = RenderingCancelledException;
571
var LinkTarget = {
572
  NONE: 0,
573
  SELF: 1,
574
  BLANK: 2,
575
  PARENT: 3,
576
  TOP: 4
577
};
578
exports.LinkTarget = LinkTarget;
579

580
function addLinkAttributes(link) {
581
  var _ref7 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
582
      url = _ref7.url,
583
      target = _ref7.target,
584
      rel = _ref7.rel,
585
      _ref7$enabled = _ref7.enabled,
586
      enabled = _ref7$enabled === void 0 ? true : _ref7$enabled;
587

588
  (0, _util.assert)(url && typeof url === "string", 'addLinkAttributes: A valid "url" parameter must provided.');
589
  var urlNullRemoved = (0, _util.removeNullCharacters)(url);
590

591
  if (enabled) {
592
    link.href = link.title = urlNullRemoved;
593
  } else {
594
    link.href = "";
595
    link.title = "Disabled: ".concat(urlNullRemoved);
596

597
    link.onclick = function () {
598
      return false;
599
    };
600
  }
601

602
  var targetStr = "";
603

604
  switch (target) {
605
    case LinkTarget.NONE:
606
      break;
607

608
    case LinkTarget.SELF:
609
      targetStr = "_self";
610
      break;
611

612
    case LinkTarget.BLANK:
613
      targetStr = "_blank";
614
      break;
615

616
    case LinkTarget.PARENT:
617
      targetStr = "_parent";
618
      break;
619

620
    case LinkTarget.TOP:
621
      targetStr = "_top";
622
      break;
623
  }
624

625
  link.target = targetStr;
626
  link.rel = typeof rel === "string" ? rel : DEFAULT_LINK_REL;
627
}
628

629
function isDataScheme(url) {
630
  var ii = url.length;
631
  var i = 0;
632

633
  while (i < ii && url[i].trim() === "") {
634
    i++;
635
  }
636

637
  return url.substring(i, i + 5).toLowerCase() === "data:";
638
}
639

640
function isPdfFile(filename) {
641
  return typeof filename === "string" && /\.pdf$/i.test(filename);
642
}
643

644
function getFilenameFromUrl(url) {
645
  var anchor = url.indexOf("#");
646
  var query = url.indexOf("?");
647
  var end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length);
648
  return url.substring(url.lastIndexOf("/", end) + 1, end);
649
}
650

651
function getPdfFilenameFromUrl(url) {
652
  var defaultFilename = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "document.pdf";
653

654
  if (typeof url !== "string") {
655
    return defaultFilename;
656
  }
657

658
  if (isDataScheme(url)) {
659
    (0, _util.warn)('getPdfFilenameFromUrl: ignore "data:"-URL for performance reasons.');
660
    return defaultFilename;
661
  }
662

663
  var reURI = /^(?:(?:[^:]+:)?\/\/[^/]+)?([^?#]*)(\?[^#]*)?(#.*)?$/;
664
  var reFilename = /[^/?#=]+\.pdf\b(?!.*\.pdf\b)/i;
665
  var splitURI = reURI.exec(url);
666
  var suggestedFilename = reFilename.exec(splitURI[1]) || reFilename.exec(splitURI[2]) || reFilename.exec(splitURI[3]);
667

668
  if (suggestedFilename) {
669
    suggestedFilename = suggestedFilename[0];
670

671
    if (suggestedFilename.includes("%")) {
672
      try {
673
        suggestedFilename = reFilename.exec(decodeURIComponent(suggestedFilename))[0];
674
      } catch (ex) {}
675
    }
676
  }
677

678
  return suggestedFilename || defaultFilename;
679
}
680

681
var StatTimer = /*#__PURE__*/function () {
682
  function StatTimer() {
683
    _classCallCheck(this, StatTimer);
684

685
    this.started = Object.create(null);
686
    this.times = [];
687
  }
688

689
  _createClass(StatTimer, [{
690
    key: "time",
691
    value: function time(name) {
692
      if (name in this.started) {
693
        (0, _util.warn)("Timer is already running for ".concat(name));
694
      }
695

696
      this.started[name] = Date.now();
697
    }
698
  }, {
699
    key: "timeEnd",
700
    value: function timeEnd(name) {
701
      if (!(name in this.started)) {
702
        (0, _util.warn)("Timer has not been started for ".concat(name));
703
      }
704

705
      this.times.push({
706
        name: name,
707
        start: this.started[name],
708
        end: Date.now()
709
      });
710
      delete this.started[name];
711
    }
712
  }, {
713
    key: "toString",
714
    value: function toString() {
715
      var outBuf = [];
716
      var longest = 0;
717

718
      var _iterator = _createForOfIteratorHelper(this.times),
719
          _step;
720

721
      try {
722
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
723
          var time = _step.value;
724
          var name = time.name;
725

726
          if (name.length > longest) {
727
            longest = name.length;
728
          }
729
        }
730
      } catch (err) {
731
        _iterator.e(err);
732
      } finally {
733
        _iterator.f();
734
      }
735

736
      var _iterator2 = _createForOfIteratorHelper(this.times),
737
          _step2;
738

739
      try {
740
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
741
          var _time = _step2.value;
742
          var duration = _time.end - _time.start;
743
          outBuf.push("".concat(_time.name.padEnd(longest), " ").concat(duration, "ms\n"));
744
        }
745
      } catch (err) {
746
        _iterator2.e(err);
747
      } finally {
748
        _iterator2.f();
749
      }
750

751
      return outBuf.join("");
752
    }
753
  }]);
754

755
  return StatTimer;
756
}();
757

758
exports.StatTimer = StatTimer;
759

760
function isFetchSupported() {
761
  return typeof fetch !== "undefined" && typeof Response !== "undefined" && "body" in Response.prototype && typeof ReadableStream !== "undefined";
762
}
763

764
function isValidFetchUrl(url, baseUrl) {
765
  try {
766
    var _ref8 = baseUrl ? new URL(url, baseUrl) : new URL(url),
767
        protocol = _ref8.protocol;
768

769
    return protocol === "http:" || protocol === "https:";
770
  } catch (ex) {
771
    return false;
772
  }
773
}
774

775
function loadScript(src) {
776
  var removeScriptElement = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
777
  return new Promise(function (resolve, reject) {
778
    var script = document.createElement("script");
779
    script.src = src;
780

781
    script.onload = function (evt) {
782
      if (removeScriptElement) {
783
        script.remove();
784
      }
785

786
      resolve(evt);
787
    };
788

789
    script.onerror = function () {
790
      reject(new Error("Cannot load script at: ".concat(script.src)));
791
    };
792

793
    (document.head || document.documentElement).appendChild(script);
794
  });
795
}
796

797
function deprecated(details) {
798
  console.log("Deprecated API usage: " + details);
799
}
800

801
var pdfDateStringRegex;
802

803
var PDFDateString = /*#__PURE__*/function () {
804
  function PDFDateString() {
805
    _classCallCheck(this, PDFDateString);
806
  }
807

808
  _createClass(PDFDateString, null, [{
809
    key: "toDateObject",
810
    value: function toDateObject(input) {
811
      if (!input || !(0, _util.isString)(input)) {
812
        return null;
813
      }
814

815
      if (!pdfDateStringRegex) {
816
        pdfDateStringRegex = new RegExp("^D:" + "(\\d{4})" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "(\\d{2})?" + "([Z|+|-])?" + "(\\d{2})?" + "'?" + "(\\d{2})?" + "'?");
817
      }
818

819
      var matches = pdfDateStringRegex.exec(input);
820

821
      if (!matches) {
822
        return null;
823
      }
824

825
      var year = parseInt(matches[1], 10);
826
      var month = parseInt(matches[2], 10);
827
      month = month >= 1 && month <= 12 ? month - 1 : 0;
828
      var day = parseInt(matches[3], 10);
829
      day = day >= 1 && day <= 31 ? day : 1;
830
      var hour = parseInt(matches[4], 10);
831
      hour = hour >= 0 && hour <= 23 ? hour : 0;
832
      var minute = parseInt(matches[5], 10);
833
      minute = minute >= 0 && minute <= 59 ? minute : 0;
834
      var second = parseInt(matches[6], 10);
835
      second = second >= 0 && second <= 59 ? second : 0;
836
      var universalTimeRelation = matches[7] || "Z";
837
      var offsetHour = parseInt(matches[8], 10);
838
      offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0;
839
      var offsetMinute = parseInt(matches[9], 10) || 0;
840
      offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0;
841

842
      if (universalTimeRelation === "-") {
843
        hour += offsetHour;
844
        minute += offsetMinute;
845
      } else if (universalTimeRelation === "+") {
846
        hour -= offsetHour;
847
        minute -= offsetMinute;
848
      }
849

850
      return new Date(Date.UTC(year, month, day, hour, minute, second));
851
    }
852
  }]);
853

854
  return PDFDateString;
855
}();
856

857
exports.PDFDateString = PDFDateString;
858

859
/***/ }),
860
/* 2 */
861
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
862

863
"use strict";
864

865

866
module.exports = __w_pdfjs_require__(3);
867

868
/***/ }),
869
/* 3 */
870
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
871

872
"use strict";
873
/* module decorator */ module = __w_pdfjs_require__.nmd(module);
874

875

876
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
877

878
var runtime = function (exports) {
879
  "use strict";
880

881
  var Op = Object.prototype;
882
  var hasOwn = Op.hasOwnProperty;
883
  var undefined;
884
  var $Symbol = typeof Symbol === "function" ? Symbol : {};
885
  var iteratorSymbol = $Symbol.iterator || "@@iterator";
886
  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
887
  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
888

889
  function define(obj, key, value) {
890
    Object.defineProperty(obj, key, {
891
      value: value,
892
      enumerable: true,
893
      configurable: true,
894
      writable: true
895
    });
896
    return obj[key];
897
  }
898

899
  try {
900
    define({}, "");
901
  } catch (err) {
902
    define = function define(obj, key, value) {
903
      return obj[key] = value;
904
    };
905
  }
906

907
  function wrap(innerFn, outerFn, self, tryLocsList) {
908
    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
909
    var generator = Object.create(protoGenerator.prototype);
910
    var context = new Context(tryLocsList || []);
911
    generator._invoke = makeInvokeMethod(innerFn, self, context);
912
    return generator;
913
  }
914

915
  exports.wrap = wrap;
916

917
  function tryCatch(fn, obj, arg) {
918
    try {
919
      return {
920
        type: "normal",
921
        arg: fn.call(obj, arg)
922
      };
923
    } catch (err) {
924
      return {
925
        type: "throw",
926
        arg: err
927
      };
928
    }
929
  }
930

931
  var GenStateSuspendedStart = "suspendedStart";
932
  var GenStateSuspendedYield = "suspendedYield";
933
  var GenStateExecuting = "executing";
934
  var GenStateCompleted = "completed";
935
  var ContinueSentinel = {};
936

937
  function Generator() {}
938

939
  function GeneratorFunction() {}
940

941
  function GeneratorFunctionPrototype() {}
942

943
  var IteratorPrototype = {};
944

945
  IteratorPrototype[iteratorSymbol] = function () {
946
    return this;
947
  };
948

949
  var getProto = Object.getPrototypeOf;
950
  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
951

952
  if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
953
    IteratorPrototype = NativeIteratorPrototype;
954
  }
955

956
  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
957
  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
958
  GeneratorFunctionPrototype.constructor = GeneratorFunction;
959
  GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, "GeneratorFunction");
960

961
  function defineIteratorMethods(prototype) {
962
    ["next", "throw", "return"].forEach(function (method) {
963
      define(prototype, method, function (arg) {
964
        return this._invoke(method, arg);
965
      });
966
    });
967
  }
968

969
  exports.isGeneratorFunction = function (genFun) {
970
    var ctor = typeof genFun === "function" && genFun.constructor;
971
    return ctor ? ctor === GeneratorFunction || (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
972
  };
973

974
  exports.mark = function (genFun) {
975
    if (Object.setPrototypeOf) {
976
      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
977
    } else {
978
      genFun.__proto__ = GeneratorFunctionPrototype;
979
      define(genFun, toStringTagSymbol, "GeneratorFunction");
980
    }
981

982
    genFun.prototype = Object.create(Gp);
983
    return genFun;
984
  };
985

986
  exports.awrap = function (arg) {
987
    return {
988
      __await: arg
989
    };
990
  };
991

992
  function AsyncIterator(generator, PromiseImpl) {
993
    function invoke(method, arg, resolve, reject) {
994
      var record = tryCatch(generator[method], generator, arg);
995

996
      if (record.type === "throw") {
997
        reject(record.arg);
998
      } else {
999
        var result = record.arg;
1000
        var value = result.value;
1001

1002
        if (value && _typeof(value) === "object" && hasOwn.call(value, "__await")) {
1003
          return PromiseImpl.resolve(value.__await).then(function (value) {
1004
            invoke("next", value, resolve, reject);
1005
          }, function (err) {
1006
            invoke("throw", err, resolve, reject);
1007
          });
1008
        }
1009

1010
        return PromiseImpl.resolve(value).then(function (unwrapped) {
1011
          result.value = unwrapped;
1012
          resolve(result);
1013
        }, function (error) {
1014
          return invoke("throw", error, resolve, reject);
1015
        });
1016
      }
1017
    }
1018

1019
    var previousPromise;
1020

1021
    function enqueue(method, arg) {
1022
      function callInvokeWithMethodAndArg() {
1023
        return new PromiseImpl(function (resolve, reject) {
1024
          invoke(method, arg, resolve, reject);
1025
        });
1026
      }
1027

1028
      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
1029
    }
1030

1031
    this._invoke = enqueue;
1032
  }
1033

1034
  defineIteratorMethods(AsyncIterator.prototype);
1035

1036
  AsyncIterator.prototype[asyncIteratorSymbol] = function () {
1037
    return this;
1038
  };
1039

1040
  exports.AsyncIterator = AsyncIterator;
1041

1042
  exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {
1043
    if (PromiseImpl === void 0) PromiseImpl = Promise;
1044
    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);
1045
    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
1046
      return result.done ? result.value : iter.next();
1047
    });
1048
  };
1049

1050
  function makeInvokeMethod(innerFn, self, context) {
1051
    var state = GenStateSuspendedStart;
1052
    return function invoke(method, arg) {
1053
      if (state === GenStateExecuting) {
1054
        throw new Error("Generator is already running");
1055
      }
1056

1057
      if (state === GenStateCompleted) {
1058
        if (method === "throw") {
1059
          throw arg;
1060
        }
1061

1062
        return doneResult();
1063
      }
1064

1065
      context.method = method;
1066
      context.arg = arg;
1067

1068
      while (true) {
1069
        var delegate = context.delegate;
1070

1071
        if (delegate) {
1072
          var delegateResult = maybeInvokeDelegate(delegate, context);
1073

1074
          if (delegateResult) {
1075
            if (delegateResult === ContinueSentinel) continue;
1076
            return delegateResult;
1077
          }
1078
        }
1079

1080
        if (context.method === "next") {
1081
          context.sent = context._sent = context.arg;
1082
        } else if (context.method === "throw") {
1083
          if (state === GenStateSuspendedStart) {
1084
            state = GenStateCompleted;
1085
            throw context.arg;
1086
          }
1087

1088
          context.dispatchException(context.arg);
1089
        } else if (context.method === "return") {
1090
          context.abrupt("return", context.arg);
1091
        }
1092

1093
        state = GenStateExecuting;
1094
        var record = tryCatch(innerFn, self, context);
1095

1096
        if (record.type === "normal") {
1097
          state = context.done ? GenStateCompleted : GenStateSuspendedYield;
1098

1099
          if (record.arg === ContinueSentinel) {
1100
            continue;
1101
          }
1102

1103
          return {
1104
            value: record.arg,
1105
            done: context.done
1106
          };
1107
        } else if (record.type === "throw") {
1108
          state = GenStateCompleted;
1109
          context.method = "throw";
1110
          context.arg = record.arg;
1111
        }
1112
      }
1113
    };
1114
  }
1115

1116
  function maybeInvokeDelegate(delegate, context) {
1117
    var method = delegate.iterator[context.method];
1118

1119
    if (method === undefined) {
1120
      context.delegate = null;
1121

1122
      if (context.method === "throw") {
1123
        if (delegate.iterator["return"]) {
1124
          context.method = "return";
1125
          context.arg = undefined;
1126
          maybeInvokeDelegate(delegate, context);
1127

1128
          if (context.method === "throw") {
1129
            return ContinueSentinel;
1130
          }
1131
        }
1132

1133
        context.method = "throw";
1134
        context.arg = new TypeError("The iterator does not provide a 'throw' method");
1135
      }
1136

1137
      return ContinueSentinel;
1138
    }
1139

1140
    var record = tryCatch(method, delegate.iterator, context.arg);
1141

1142
    if (record.type === "throw") {
1143
      context.method = "throw";
1144
      context.arg = record.arg;
1145
      context.delegate = null;
1146
      return ContinueSentinel;
1147
    }
1148

1149
    var info = record.arg;
1150

1151
    if (!info) {
1152
      context.method = "throw";
1153
      context.arg = new TypeError("iterator result is not an object");
1154
      context.delegate = null;
1155
      return ContinueSentinel;
1156
    }
1157

1158
    if (info.done) {
1159
      context[delegate.resultName] = info.value;
1160
      context.next = delegate.nextLoc;
1161

1162
      if (context.method !== "return") {
1163
        context.method = "next";
1164
        context.arg = undefined;
1165
      }
1166
    } else {
1167
      return info;
1168
    }
1169

1170
    context.delegate = null;
1171
    return ContinueSentinel;
1172
  }
1173

1174
  defineIteratorMethods(Gp);
1175
  define(Gp, toStringTagSymbol, "Generator");
1176

1177
  Gp[iteratorSymbol] = function () {
1178
    return this;
1179
  };
1180

1181
  Gp.toString = function () {
1182
    return "[object Generator]";
1183
  };
1184

1185
  function pushTryEntry(locs) {
1186
    var entry = {
1187
      tryLoc: locs[0]
1188
    };
1189

1190
    if (1 in locs) {
1191
      entry.catchLoc = locs[1];
1192
    }
1193

1194
    if (2 in locs) {
1195
      entry.finallyLoc = locs[2];
1196
      entry.afterLoc = locs[3];
1197
    }
1198

1199
    this.tryEntries.push(entry);
1200
  }
1201

1202
  function resetTryEntry(entry) {
1203
    var record = entry.completion || {};
1204
    record.type = "normal";
1205
    delete record.arg;
1206
    entry.completion = record;
1207
  }
1208

1209
  function Context(tryLocsList) {
1210
    this.tryEntries = [{
1211
      tryLoc: "root"
1212
    }];
1213
    tryLocsList.forEach(pushTryEntry, this);
1214
    this.reset(true);
1215
  }
1216

1217
  exports.keys = function (object) {
1218
    var keys = [];
1219

1220
    for (var key in object) {
1221
      keys.push(key);
1222
    }
1223

1224
    keys.reverse();
1225
    return function next() {
1226
      while (keys.length) {
1227
        var key = keys.pop();
1228

1229
        if (key in object) {
1230
          next.value = key;
1231
          next.done = false;
1232
          return next;
1233
        }
1234
      }
1235

1236
      next.done = true;
1237
      return next;
1238
    };
1239
  };
1240

1241
  function values(iterable) {
1242
    if (iterable) {
1243
      var iteratorMethod = iterable[iteratorSymbol];
1244

1245
      if (iteratorMethod) {
1246
        return iteratorMethod.call(iterable);
1247
      }
1248

1249
      if (typeof iterable.next === "function") {
1250
        return iterable;
1251
      }
1252

1253
      if (!isNaN(iterable.length)) {
1254
        var i = -1,
1255
            next = function next() {
1256
          while (++i < iterable.length) {
1257
            if (hasOwn.call(iterable, i)) {
1258
              next.value = iterable[i];
1259
              next.done = false;
1260
              return next;
1261
            }
1262
          }
1263

1264
          next.value = undefined;
1265
          next.done = true;
1266
          return next;
1267
        };
1268

1269
        return next.next = next;
1270
      }
1271
    }
1272

1273
    return {
1274
      next: doneResult
1275
    };
1276
  }
1277

1278
  exports.values = values;
1279

1280
  function doneResult() {
1281
    return {
1282
      value: undefined,
1283
      done: true
1284
    };
1285
  }
1286

1287
  Context.prototype = {
1288
    constructor: Context,
1289
    reset: function reset(skipTempReset) {
1290
      this.prev = 0;
1291
      this.next = 0;
1292
      this.sent = this._sent = undefined;
1293
      this.done = false;
1294
      this.delegate = null;
1295
      this.method = "next";
1296
      this.arg = undefined;
1297
      this.tryEntries.forEach(resetTryEntry);
1298

1299
      if (!skipTempReset) {
1300
        for (var name in this) {
1301
          if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
1302
            this[name] = undefined;
1303
          }
1304
        }
1305
      }
1306
    },
1307
    stop: function stop() {
1308
      this.done = true;
1309
      var rootEntry = this.tryEntries[0];
1310
      var rootRecord = rootEntry.completion;
1311

1312
      if (rootRecord.type === "throw") {
1313
        throw rootRecord.arg;
1314
      }
1315

1316
      return this.rval;
1317
    },
1318
    dispatchException: function dispatchException(exception) {
1319
      if (this.done) {
1320
        throw exception;
1321
      }
1322

1323
      var context = this;
1324

1325
      function handle(loc, caught) {
1326
        record.type = "throw";
1327
        record.arg = exception;
1328
        context.next = loc;
1329

1330
        if (caught) {
1331
          context.method = "next";
1332
          context.arg = undefined;
1333
        }
1334

1335
        return !!caught;
1336
      }
1337

1338
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1339
        var entry = this.tryEntries[i];
1340
        var record = entry.completion;
1341

1342
        if (entry.tryLoc === "root") {
1343
          return handle("end");
1344
        }
1345

1346
        if (entry.tryLoc <= this.prev) {
1347
          var hasCatch = hasOwn.call(entry, "catchLoc");
1348
          var hasFinally = hasOwn.call(entry, "finallyLoc");
1349

1350
          if (hasCatch && hasFinally) {
1351
            if (this.prev < entry.catchLoc) {
1352
              return handle(entry.catchLoc, true);
1353
            } else if (this.prev < entry.finallyLoc) {
1354
              return handle(entry.finallyLoc);
1355
            }
1356
          } else if (hasCatch) {
1357
            if (this.prev < entry.catchLoc) {
1358
              return handle(entry.catchLoc, true);
1359
            }
1360
          } else if (hasFinally) {
1361
            if (this.prev < entry.finallyLoc) {
1362
              return handle(entry.finallyLoc);
1363
            }
1364
          } else {
1365
            throw new Error("try statement without catch or finally");
1366
          }
1367
        }
1368
      }
1369
    },
1370
    abrupt: function abrupt(type, arg) {
1371
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1372
        var entry = this.tryEntries[i];
1373

1374
        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
1375
          var finallyEntry = entry;
1376
          break;
1377
        }
1378
      }
1379

1380
      if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
1381
        finallyEntry = null;
1382
      }
1383

1384
      var record = finallyEntry ? finallyEntry.completion : {};
1385
      record.type = type;
1386
      record.arg = arg;
1387

1388
      if (finallyEntry) {
1389
        this.method = "next";
1390
        this.next = finallyEntry.finallyLoc;
1391
        return ContinueSentinel;
1392
      }
1393

1394
      return this.complete(record);
1395
    },
1396
    complete: function complete(record, afterLoc) {
1397
      if (record.type === "throw") {
1398
        throw record.arg;
1399
      }
1400

1401
      if (record.type === "break" || record.type === "continue") {
1402
        this.next = record.arg;
1403
      } else if (record.type === "return") {
1404
        this.rval = this.arg = record.arg;
1405
        this.method = "return";
1406
        this.next = "end";
1407
      } else if (record.type === "normal" && afterLoc) {
1408
        this.next = afterLoc;
1409
      }
1410

1411
      return ContinueSentinel;
1412
    },
1413
    finish: function finish(finallyLoc) {
1414
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1415
        var entry = this.tryEntries[i];
1416

1417
        if (entry.finallyLoc === finallyLoc) {
1418
          this.complete(entry.completion, entry.afterLoc);
1419
          resetTryEntry(entry);
1420
          return ContinueSentinel;
1421
        }
1422
      }
1423
    },
1424
    "catch": function _catch(tryLoc) {
1425
      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1426
        var entry = this.tryEntries[i];
1427

1428
        if (entry.tryLoc === tryLoc) {
1429
          var record = entry.completion;
1430

1431
          if (record.type === "throw") {
1432
            var thrown = record.arg;
1433
            resetTryEntry(entry);
1434
          }
1435

1436
          return thrown;
1437
        }
1438
      }
1439

1440
      throw new Error("illegal catch attempt");
1441
    },
1442
    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
1443
      this.delegate = {
1444
        iterator: values(iterable),
1445
        resultName: resultName,
1446
        nextLoc: nextLoc
1447
      };
1448

1449
      if (this.method === "next") {
1450
        this.arg = undefined;
1451
      }
1452

1453
      return ContinueSentinel;
1454
    }
1455
  };
1456
  return exports;
1457
}(( false ? 0 : _typeof(module)) === "object" ? module.exports : {});
1458

1459
try {
1460
  regeneratorRuntime = runtime;
1461
} catch (accidentalStrictMode) {
1462
  Function("r", "regeneratorRuntime = r")(runtime);
1463
}
1464

1465
/***/ }),
1466
/* 4 */
1467
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
1468

1469
"use strict";
1470

1471

1472
Object.defineProperty(exports, "__esModule", ({
1473
  value: true
1474
}));
1475
exports.arrayByteLength = arrayByteLength;
1476
exports.arraysToBytes = arraysToBytes;
1477
exports.assert = assert;
1478
exports.bytesToString = bytesToString;
1479
exports.createObjectURL = createObjectURL;
1480
exports.createPromiseCapability = createPromiseCapability;
1481
exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
1482
exports.escapeString = escapeString;
1483
exports.getModificationDate = getModificationDate;
1484
exports.getVerbosityLevel = getVerbosityLevel;
1485
exports.info = info;
1486
exports.isArrayBuffer = isArrayBuffer;
1487
exports.isArrayEqual = isArrayEqual;
1488
exports.isAscii = isAscii;
1489
exports.isBool = isBool;
1490
exports.isNum = isNum;
1491
exports.isSameOrigin = isSameOrigin;
1492
exports.isString = isString;
1493
exports.objectFromMap = objectFromMap;
1494
exports.objectSize = objectSize;
1495
exports.removeNullCharacters = removeNullCharacters;
1496
exports.setVerbosityLevel = setVerbosityLevel;
1497
exports.shadow = shadow;
1498
exports.string32 = string32;
1499
exports.stringToBytes = stringToBytes;
1500
exports.stringToPDFString = stringToPDFString;
1501
exports.stringToUTF16BEString = stringToUTF16BEString;
1502
exports.stringToUTF8String = stringToUTF8String;
1503
exports.unreachable = unreachable;
1504
exports.utf8StringToString = utf8StringToString;
1505
exports.warn = warn;
1506
exports.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;
1507

1508
__w_pdfjs_require__(5);
1509

1510
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
1511

1512
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
1513

1514
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
1515

1516
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
1517

1518
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
1519

1520
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
1521

1522
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
1523

1524
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
1525

1526
function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
1527

1528
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
1529

1530
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
1531

1532
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
1533

1534
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
1535

1536
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
1537

1538
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
1539

1540
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
1541

1542
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
1543

1544
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
1545

1546
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
1547

1548
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
1549

1550
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
1551

1552
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
1553

1554
var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
1555
exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
1556
var FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
1557
exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
1558
var PermissionFlag = {
1559
  PRINT: 0x04,
1560
  MODIFY_CONTENTS: 0x08,
1561
  COPY: 0x10,
1562
  MODIFY_ANNOTATIONS: 0x20,
1563
  FILL_INTERACTIVE_FORMS: 0x100,
1564
  COPY_FOR_ACCESSIBILITY: 0x200,
1565
  ASSEMBLE: 0x400,
1566
  PRINT_HIGH_QUALITY: 0x800
1567
};
1568
exports.PermissionFlag = PermissionFlag;
1569
var TextRenderingMode = {
1570
  FILL: 0,
1571
  STROKE: 1,
1572
  FILL_STROKE: 2,
1573
  INVISIBLE: 3,
1574
  FILL_ADD_TO_PATH: 4,
1575
  STROKE_ADD_TO_PATH: 5,
1576
  FILL_STROKE_ADD_TO_PATH: 6,
1577
  ADD_TO_PATH: 7,
1578
  FILL_STROKE_MASK: 3,
1579
  ADD_TO_PATH_FLAG: 4
1580
};
1581
exports.TextRenderingMode = TextRenderingMode;
1582
var ImageKind = {
1583
  GRAYSCALE_1BPP: 1,
1584
  RGB_24BPP: 2,
1585
  RGBA_32BPP: 3
1586
};
1587
exports.ImageKind = ImageKind;
1588
var AnnotationType = {
1589
  TEXT: 1,
1590
  LINK: 2,
1591
  FREETEXT: 3,
1592
  LINE: 4,
1593
  SQUARE: 5,
1594
  CIRCLE: 6,
1595
  POLYGON: 7,
1596
  POLYLINE: 8,
1597
  HIGHLIGHT: 9,
1598
  UNDERLINE: 10,
1599
  SQUIGGLY: 11,
1600
  STRIKEOUT: 12,
1601
  STAMP: 13,
1602
  CARET: 14,
1603
  INK: 15,
1604
  POPUP: 16,
1605
  FILEATTACHMENT: 17,
1606
  SOUND: 18,
1607
  MOVIE: 19,
1608
  WIDGET: 20,
1609
  SCREEN: 21,
1610
  PRINTERMARK: 22,
1611
  TRAPNET: 23,
1612
  WATERMARK: 24,
1613
  THREED: 25,
1614
  REDACT: 26
1615
};
1616
exports.AnnotationType = AnnotationType;
1617
var AnnotationStateModelType = {
1618
  MARKED: "Marked",
1619
  REVIEW: "Review"
1620
};
1621
exports.AnnotationStateModelType = AnnotationStateModelType;
1622
var AnnotationMarkedState = {
1623
  MARKED: "Marked",
1624
  UNMARKED: "Unmarked"
1625
};
1626
exports.AnnotationMarkedState = AnnotationMarkedState;
1627
var AnnotationReviewState = {
1628
  ACCEPTED: "Accepted",
1629
  REJECTED: "Rejected",
1630
  CANCELLED: "Cancelled",
1631
  COMPLETED: "Completed",
1632
  NONE: "None"
1633
};
1634
exports.AnnotationReviewState = AnnotationReviewState;
1635
var AnnotationReplyType = {
1636
  GROUP: "Group",
1637
  REPLY: "R"
1638
};
1639
exports.AnnotationReplyType = AnnotationReplyType;
1640
var AnnotationFlag = {
1641
  INVISIBLE: 0x01,
1642
  HIDDEN: 0x02,
1643
  PRINT: 0x04,
1644
  NOZOOM: 0x08,
1645
  NOROTATE: 0x10,
1646
  NOVIEW: 0x20,
1647
  READONLY: 0x40,
1648
  LOCKED: 0x80,
1649
  TOGGLENOVIEW: 0x100,
1650
  LOCKEDCONTENTS: 0x200
1651
};
1652
exports.AnnotationFlag = AnnotationFlag;
1653
var AnnotationFieldFlag = {
1654
  READONLY: 0x0000001,
1655
  REQUIRED: 0x0000002,
1656
  NOEXPORT: 0x0000004,
1657
  MULTILINE: 0x0001000,
1658
  PASSWORD: 0x0002000,
1659
  NOTOGGLETOOFF: 0x0004000,
1660
  RADIO: 0x0008000,
1661
  PUSHBUTTON: 0x0010000,
1662
  COMBO: 0x0020000,
1663
  EDIT: 0x0040000,
1664
  SORT: 0x0080000,
1665
  FILESELECT: 0x0100000,
1666
  MULTISELECT: 0x0200000,
1667
  DONOTSPELLCHECK: 0x0400000,
1668
  DONOTSCROLL: 0x0800000,
1669
  COMB: 0x1000000,
1670
  RICHTEXT: 0x2000000,
1671
  RADIOSINUNISON: 0x2000000,
1672
  COMMITONSELCHANGE: 0x4000000
1673
};
1674
exports.AnnotationFieldFlag = AnnotationFieldFlag;
1675
var AnnotationBorderStyleType = {
1676
  SOLID: 1,
1677
  DASHED: 2,
1678
  BEVELED: 3,
1679
  INSET: 4,
1680
  UNDERLINE: 5
1681
};
1682
exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
1683
var AnnotationActionEventType = {
1684
  E: "Mouse Enter",
1685
  X: "Mouse Exit",
1686
  D: "Mouse Down",
1687
  U: "Mouse Up",
1688
  Fo: "Focus",
1689
  Bl: "Blur",
1690
  PO: "PageOpen",
1691
  PC: "PageClose",
1692
  PV: "PageVisible",
1693
  PI: "PageInvisible",
1694
  K: "Keystroke",
1695
  F: "Format",
1696
  V: "Validate",
1697
  C: "Calculate"
1698
};
1699
exports.AnnotationActionEventType = AnnotationActionEventType;
1700
var DocumentActionEventType = {
1701
  WC: "WillClose",
1702
  WS: "WillSave",
1703
  DS: "DidSave",
1704
  WP: "WillPrint",
1705
  DP: "DidPrint"
1706
};
1707
exports.DocumentActionEventType = DocumentActionEventType;
1708
var PageActionEventType = {
1709
  O: "PageOpen",
1710
  C: "PageClose"
1711
};
1712
exports.PageActionEventType = PageActionEventType;
1713
var StreamType = {
1714
  UNKNOWN: "UNKNOWN",
1715
  FLATE: "FLATE",
1716
  LZW: "LZW",
1717
  DCT: "DCT",
1718
  JPX: "JPX",
1719
  JBIG: "JBIG",
1720
  A85: "A85",
1721
  AHX: "AHX",
1722
  CCF: "CCF",
1723
  RLX: "RLX"
1724
};
1725
exports.StreamType = StreamType;
1726
var FontType = {
1727
  UNKNOWN: "UNKNOWN",
1728
  TYPE1: "TYPE1",
1729
  TYPE1C: "TYPE1C",
1730
  CIDFONTTYPE0: "CIDFONTTYPE0",
1731
  CIDFONTTYPE0C: "CIDFONTTYPE0C",
1732
  TRUETYPE: "TRUETYPE",
1733
  CIDFONTTYPE2: "CIDFONTTYPE2",
1734
  TYPE3: "TYPE3",
1735
  OPENTYPE: "OPENTYPE",
1736
  TYPE0: "TYPE0",
1737
  MMTYPE1: "MMTYPE1"
1738
};
1739
exports.FontType = FontType;
1740
var VerbosityLevel = {
1741
  ERRORS: 0,
1742
  WARNINGS: 1,
1743
  INFOS: 5
1744
};
1745
exports.VerbosityLevel = VerbosityLevel;
1746
var CMapCompressionType = {
1747
  NONE: 0,
1748
  BINARY: 1,
1749
  STREAM: 2
1750
};
1751
exports.CMapCompressionType = CMapCompressionType;
1752
var OPS = {
1753
  dependency: 1,
1754
  setLineWidth: 2,
1755
  setLineCap: 3,
1756
  setLineJoin: 4,
1757
  setMiterLimit: 5,
1758
  setDash: 6,
1759
  setRenderingIntent: 7,
1760
  setFlatness: 8,
1761
  setGState: 9,
1762
  save: 10,
1763
  restore: 11,
1764
  transform: 12,
1765
  moveTo: 13,
1766
  lineTo: 14,
1767
  curveTo: 15,
1768
  curveTo2: 16,
1769
  curveTo3: 17,
1770
  closePath: 18,
1771
  rectangle: 19,
1772
  stroke: 20,
1773
  closeStroke: 21,
1774
  fill: 22,
1775
  eoFill: 23,
1776
  fillStroke: 24,
1777
  eoFillStroke: 25,
1778
  closeFillStroke: 26,
1779
  closeEOFillStroke: 27,
1780
  endPath: 28,
1781
  clip: 29,
1782
  eoClip: 30,
1783
  beginText: 31,
1784
  endText: 32,
1785
  setCharSpacing: 33,
1786
  setWordSpacing: 34,
1787
  setHScale: 35,
1788
  setLeading: 36,
1789
  setFont: 37,
1790
  setTextRenderingMode: 38,
1791
  setTextRise: 39,
1792
  moveText: 40,
1793
  setLeadingMoveText: 41,
1794
  setTextMatrix: 42,
1795
  nextLine: 43,
1796
  showText: 44,
1797
  showSpacedText: 45,
1798
  nextLineShowText: 46,
1799
  nextLineSetSpacingShowText: 47,
1800
  setCharWidth: 48,
1801
  setCharWidthAndBounds: 49,
1802
  setStrokeColorSpace: 50,
1803
  setFillColorSpace: 51,
1804
  setStrokeColor: 52,
1805
  setStrokeColorN: 53,
1806
  setFillColor: 54,
1807
  setFillColorN: 55,
1808
  setStrokeGray: 56,
1809
  setFillGray: 57,
1810
  setStrokeRGBColor: 58,
1811
  setFillRGBColor: 59,
1812
  setStrokeCMYKColor: 60,
1813
  setFillCMYKColor: 61,
1814
  shadingFill: 62,
1815
  beginInlineImage: 63,
1816
  beginImageData: 64,
1817
  endInlineImage: 65,
1818
  paintXObject: 66,
1819
  markPoint: 67,
1820
  markPointProps: 68,
1821
  beginMarkedContent: 69,
1822
  beginMarkedContentProps: 70,
1823
  endMarkedContent: 71,
1824
  beginCompat: 72,
1825
  endCompat: 73,
1826
  paintFormXObjectBegin: 74,
1827
  paintFormXObjectEnd: 75,
1828
  beginGroup: 76,
1829
  endGroup: 77,
1830
  beginAnnotations: 78,
1831
  endAnnotations: 79,
1832
  beginAnnotation: 80,
1833
  endAnnotation: 81,
1834
  paintJpegXObject: 82,
1835
  paintImageMaskXObject: 83,
1836
  paintImageMaskXObjectGroup: 84,
1837
  paintImageXObject: 85,
1838
  paintInlineImageXObject: 86,
1839
  paintInlineImageXObjectGroup: 87,
1840
  paintImageXObjectRepeat: 88,
1841
  paintImageMaskXObjectRepeat: 89,
1842
  paintSolidColorImageMask: 90,
1843
  constructPath: 91
1844
};
1845
exports.OPS = OPS;
1846
var UNSUPPORTED_FEATURES = {
1847
  unknown: "unknown",
1848
  forms: "forms",
1849
  javaScript: "javaScript",
1850
  smask: "smask",
1851
  shadingPattern: "shadingPattern",
1852
  font: "font",
1853
  errorTilingPattern: "errorTilingPattern",
1854
  errorExtGState: "errorExtGState",
1855
  errorXObject: "errorXObject",
1856
  errorFontLoadType3: "errorFontLoadType3",
1857
  errorFontState: "errorFontState",
1858
  errorFontMissing: "errorFontMissing",
1859
  errorFontTranslate: "errorFontTranslate",
1860
  errorColorSpace: "errorColorSpace",
1861
  errorOperatorList: "errorOperatorList",
1862
  errorFontToUnicode: "errorFontToUnicode",
1863
  errorFontLoadNative: "errorFontLoadNative",
1864
  errorFontGetPath: "errorFontGetPath",
1865
  errorMarkedContent: "errorMarkedContent"
1866
};
1867
exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
1868
var PasswordResponses = {
1869
  NEED_PASSWORD: 1,
1870
  INCORRECT_PASSWORD: 2
1871
};
1872
exports.PasswordResponses = PasswordResponses;
1873
var verbosity = VerbosityLevel.WARNINGS;
1874

1875
function setVerbosityLevel(level) {
1876
  if (Number.isInteger(level)) {
1877
    verbosity = level;
1878
  }
1879
}
1880

1881
function getVerbosityLevel() {
1882
  return verbosity;
1883
}
1884

1885
function info(msg) {
1886
  if (verbosity >= VerbosityLevel.INFOS) {
1887
    console.log("Info: ".concat(msg));
1888
  }
1889
}
1890

1891
function warn(msg) {
1892
  if (verbosity >= VerbosityLevel.WARNINGS) {
1893
    console.log("Warning: ".concat(msg));
1894
  }
1895
}
1896

1897
function unreachable(msg) {
1898
  throw new Error(msg);
1899
}
1900

1901
function assert(cond, msg) {
1902
  if (!cond) {
1903
    unreachable(msg);
1904
  }
1905
}
1906

1907
function isSameOrigin(baseUrl, otherUrl) {
1908
  var base;
1909

1910
  try {
1911
    base = new URL(baseUrl);
1912

1913
    if (!base.origin || base.origin === "null") {
1914
      return false;
1915
    }
1916
  } catch (e) {
1917
    return false;
1918
  }
1919

1920
  var other = new URL(otherUrl, base);
1921
  return base.origin === other.origin;
1922
}
1923

1924
function _isValidProtocol(url) {
1925
  if (!url) {
1926
    return false;
1927
  }
1928

1929
  switch (url.protocol) {
1930
    case "http:":
1931
    case "https:":
1932
    case "ftp:":
1933
    case "mailto:":
1934
    case "tel:":
1935
      return true;
1936

1937
    default:
1938
      return false;
1939
  }
1940
}
1941

1942
function createValidAbsoluteUrl(url, baseUrl) {
1943
  if (!url) {
1944
    return null;
1945
  }
1946

1947
  try {
1948
    var absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);
1949

1950
    if (_isValidProtocol(absoluteUrl)) {
1951
      return absoluteUrl;
1952
    }
1953
  } catch (ex) {}
1954

1955
  return null;
1956
}
1957

1958
function shadow(obj, prop, value) {
1959
  Object.defineProperty(obj, prop, {
1960
    value: value,
1961
    enumerable: true,
1962
    configurable: true,
1963
    writable: false
1964
  });
1965
  return value;
1966
}
1967

1968
var BaseException = function BaseExceptionClosure() {
1969
  function BaseException(message) {
1970
    if (this.constructor === BaseException) {
1971
      unreachable("Cannot initialize BaseException.");
1972
    }
1973

1974
    this.message = message;
1975
    this.name = this.constructor.name;
1976
  }
1977

1978
  BaseException.prototype = new Error();
1979
  BaseException.constructor = BaseException;
1980
  return BaseException;
1981
}();
1982

1983
exports.BaseException = BaseException;
1984

1985
var PasswordException = /*#__PURE__*/function (_BaseException) {
1986
  _inherits(PasswordException, _BaseException);
1987

1988
  var _super = _createSuper(PasswordException);
1989

1990
  function PasswordException(msg, code) {
1991
    var _this;
1992

1993
    _classCallCheck(this, PasswordException);
1994

1995
    _this = _super.call(this, msg);
1996
    _this.code = code;
1997
    return _this;
1998
  }
1999

2000
  return PasswordException;
2001
}(BaseException);
2002

2003
exports.PasswordException = PasswordException;
2004

2005
var UnknownErrorException = /*#__PURE__*/function (_BaseException2) {
2006
  _inherits(UnknownErrorException, _BaseException2);
2007

2008
  var _super2 = _createSuper(UnknownErrorException);
2009

2010
  function UnknownErrorException(msg, details) {
2011
    var _this2;
2012

2013
    _classCallCheck(this, UnknownErrorException);
2014

2015
    _this2 = _super2.call(this, msg);
2016
    _this2.details = details;
2017
    return _this2;
2018
  }
2019

2020
  return UnknownErrorException;
2021
}(BaseException);
2022

2023
exports.UnknownErrorException = UnknownErrorException;
2024

2025
var InvalidPDFException = /*#__PURE__*/function (_BaseException3) {
2026
  _inherits(InvalidPDFException, _BaseException3);
2027

2028
  var _super3 = _createSuper(InvalidPDFException);
2029

2030
  function InvalidPDFException() {
2031
    _classCallCheck(this, InvalidPDFException);
2032

2033
    return _super3.apply(this, arguments);
2034
  }
2035

2036
  return InvalidPDFException;
2037
}(BaseException);
2038

2039
exports.InvalidPDFException = InvalidPDFException;
2040

2041
var MissingPDFException = /*#__PURE__*/function (_BaseException4) {
2042
  _inherits(MissingPDFException, _BaseException4);
2043

2044
  var _super4 = _createSuper(MissingPDFException);
2045

2046
  function MissingPDFException() {
2047
    _classCallCheck(this, MissingPDFException);
2048

2049
    return _super4.apply(this, arguments);
2050
  }
2051

2052
  return MissingPDFException;
2053
}(BaseException);
2054

2055
exports.MissingPDFException = MissingPDFException;
2056

2057
var UnexpectedResponseException = /*#__PURE__*/function (_BaseException5) {
2058
  _inherits(UnexpectedResponseException, _BaseException5);
2059

2060
  var _super5 = _createSuper(UnexpectedResponseException);
2061

2062
  function UnexpectedResponseException(msg, status) {
2063
    var _this3;
2064

2065
    _classCallCheck(this, UnexpectedResponseException);
2066

2067
    _this3 = _super5.call(this, msg);
2068
    _this3.status = status;
2069
    return _this3;
2070
  }
2071

2072
  return UnexpectedResponseException;
2073
}(BaseException);
2074

2075
exports.UnexpectedResponseException = UnexpectedResponseException;
2076

2077
var FormatError = /*#__PURE__*/function (_BaseException6) {
2078
  _inherits(FormatError, _BaseException6);
2079

2080
  var _super6 = _createSuper(FormatError);
2081

2082
  function FormatError() {
2083
    _classCallCheck(this, FormatError);
2084

2085
    return _super6.apply(this, arguments);
2086
  }
2087

2088
  return FormatError;
2089
}(BaseException);
2090

2091
exports.FormatError = FormatError;
2092

2093
var AbortException = /*#__PURE__*/function (_BaseException7) {
2094
  _inherits(AbortException, _BaseException7);
2095

2096
  var _super7 = _createSuper(AbortException);
2097

2098
  function AbortException() {
2099
    _classCallCheck(this, AbortException);
2100

2101
    return _super7.apply(this, arguments);
2102
  }
2103

2104
  return AbortException;
2105
}(BaseException);
2106

2107
exports.AbortException = AbortException;
2108
var NullCharactersRegExp = /\x00/g;
2109

2110
function removeNullCharacters(str) {
2111
  if (typeof str !== "string") {
2112
    warn("The argument for removeNullCharacters must be a string.");
2113
    return str;
2114
  }
2115

2116
  return str.replace(NullCharactersRegExp, "");
2117
}
2118

2119
function bytesToString(bytes) {
2120
  assert(bytes !== null && _typeof(bytes) === "object" && bytes.length !== undefined, "Invalid argument for bytesToString");
2121
  var length = bytes.length;
2122
  var MAX_ARGUMENT_COUNT = 8192;
2123

2124
  if (length < MAX_ARGUMENT_COUNT) {
2125
    return String.fromCharCode.apply(null, bytes);
2126
  }
2127

2128
  var strBuf = [];
2129

2130
  for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
2131
    var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
2132
    var chunk = bytes.subarray(i, chunkEnd);
2133
    strBuf.push(String.fromCharCode.apply(null, chunk));
2134
  }
2135

2136
  return strBuf.join("");
2137
}
2138

2139
function stringToBytes(str) {
2140
  assert(typeof str === "string", "Invalid argument for stringToBytes");
2141
  var length = str.length;
2142
  var bytes = new Uint8Array(length);
2143

2144
  for (var i = 0; i < length; ++i) {
2145
    bytes[i] = str.charCodeAt(i) & 0xff;
2146
  }
2147

2148
  return bytes;
2149
}
2150

2151
function arrayByteLength(arr) {
2152
  if (arr.length !== undefined) {
2153
    return arr.length;
2154
  }
2155

2156
  assert(arr.byteLength !== undefined, "arrayByteLength - invalid argument.");
2157
  return arr.byteLength;
2158
}
2159

2160
function arraysToBytes(arr) {
2161
  var length = arr.length;
2162

2163
  if (length === 1 && arr[0] instanceof Uint8Array) {
2164
    return arr[0];
2165
  }
2166

2167
  var resultLength = 0;
2168

2169
  for (var i = 0; i < length; i++) {
2170
    resultLength += arrayByteLength(arr[i]);
2171
  }
2172

2173
  var pos = 0;
2174
  var data = new Uint8Array(resultLength);
2175

2176
  for (var _i = 0; _i < length; _i++) {
2177
    var item = arr[_i];
2178

2179
    if (!(item instanceof Uint8Array)) {
2180
      if (typeof item === "string") {
2181
        item = stringToBytes(item);
2182
      } else {
2183
        item = new Uint8Array(item);
2184
      }
2185
    }
2186

2187
    var itemLength = item.byteLength;
2188
    data.set(item, pos);
2189
    pos += itemLength;
2190
  }
2191

2192
  return data;
2193
}
2194

2195
function string32(value) {
2196
  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
2197
}
2198

2199
function objectSize(obj) {
2200
  return Object.keys(obj).length;
2201
}
2202

2203
function objectFromMap(map) {
2204
  var obj = Object.create(null);
2205

2206
  var _iterator = _createForOfIteratorHelper(map),
2207
      _step;
2208

2209
  try {
2210
    for (_iterator.s(); !(_step = _iterator.n()).done;) {
2211
      var _step$value = _slicedToArray(_step.value, 2),
2212
          key = _step$value[0],
2213
          value = _step$value[1];
2214

2215
      obj[key] = value;
2216
    }
2217
  } catch (err) {
2218
    _iterator.e(err);
2219
  } finally {
2220
    _iterator.f();
2221
  }
2222

2223
  return obj;
2224
}
2225

2226
function isLittleEndian() {
2227
  var buffer8 = new Uint8Array(4);
2228
  buffer8[0] = 1;
2229
  var view32 = new Uint32Array(buffer8.buffer, 0, 1);
2230
  return view32[0] === 1;
2231
}
2232

2233
var IsLittleEndianCached = {
2234
  get value() {
2235
    return shadow(this, "value", isLittleEndian());
2236
  }
2237

2238
};
2239
exports.IsLittleEndianCached = IsLittleEndianCached;
2240

2241
function isEvalSupported() {
2242
  try {
2243
    new Function("");
2244
    return true;
2245
  } catch (e) {
2246
    return false;
2247
  }
2248
}
2249

2250
var IsEvalSupportedCached = {
2251
  get value() {
2252
    return shadow(this, "value", isEvalSupported());
2253
  }
2254

2255
};
2256
exports.IsEvalSupportedCached = IsEvalSupportedCached;
2257

2258
var hexNumbers = _toConsumableArray(Array(256).keys()).map(function (n) {
2259
  return n.toString(16).padStart(2, "0");
2260
});
2261

2262
var Util = /*#__PURE__*/function () {
2263
  function Util() {
2264
    _classCallCheck(this, Util);
2265
  }
2266

2267
  _createClass(Util, null, [{
2268
    key: "makeHexColor",
2269
    value: function makeHexColor(r, g, b) {
2270
      return "#".concat(hexNumbers[r]).concat(hexNumbers[g]).concat(hexNumbers[b]);
2271
    }
2272
  }, {
2273
    key: "transform",
2274
    value: function transform(m1, m2) {
2275
      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]];
2276
    }
2277
  }, {
2278
    key: "applyTransform",
2279
    value: function applyTransform(p, m) {
2280
      var xt = p[0] * m[0] + p[1] * m[2] + m[4];
2281
      var yt = p[0] * m[1] + p[1] * m[3] + m[5];
2282
      return [xt, yt];
2283
    }
2284
  }, {
2285
    key: "applyInverseTransform",
2286
    value: function applyInverseTransform(p, m) {
2287
      var d = m[0] * m[3] - m[1] * m[2];
2288
      var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
2289
      var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
2290
      return [xt, yt];
2291
    }
2292
  }, {
2293
    key: "getAxialAlignedBoundingBox",
2294
    value: function getAxialAlignedBoundingBox(r, m) {
2295
      var p1 = Util.applyTransform(r, m);
2296
      var p2 = Util.applyTransform(r.slice(2, 4), m);
2297
      var p3 = Util.applyTransform([r[0], r[3]], m);
2298
      var p4 = Util.applyTransform([r[2], r[1]], m);
2299
      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])];
2300
    }
2301
  }, {
2302
    key: "inverseTransform",
2303
    value: function inverseTransform(m) {
2304
      var d = m[0] * m[3] - m[1] * m[2];
2305
      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];
2306
    }
2307
  }, {
2308
    key: "apply3dTransform",
2309
    value: function apply3dTransform(m, v) {
2310
      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]];
2311
    }
2312
  }, {
2313
    key: "singularValueDecompose2dScale",
2314
    value: function singularValueDecompose2dScale(m) {
2315
      var transpose = [m[0], m[2], m[1], m[3]];
2316
      var a = m[0] * transpose[0] + m[1] * transpose[2];
2317
      var b = m[0] * transpose[1] + m[1] * transpose[3];
2318
      var c = m[2] * transpose[0] + m[3] * transpose[2];
2319
      var d = m[2] * transpose[1] + m[3] * transpose[3];
2320
      var first = (a + d) / 2;
2321
      var second = Math.sqrt(Math.pow(a + d, 2) - 4 * (a * d - c * b)) / 2;
2322
      var sx = first + second || 1;
2323
      var sy = first - second || 1;
2324
      return [Math.sqrt(sx), Math.sqrt(sy)];
2325
    }
2326
  }, {
2327
    key: "normalizeRect",
2328
    value: function normalizeRect(rect) {
2329
      var r = rect.slice(0);
2330

2331
      if (rect[0] > rect[2]) {
2332
        r[0] = rect[2];
2333
        r[2] = rect[0];
2334
      }
2335

2336
      if (rect[1] > rect[3]) {
2337
        r[1] = rect[3];
2338
        r[3] = rect[1];
2339
      }
2340

2341
      return r;
2342
    }
2343
  }, {
2344
    key: "intersect",
2345
    value: function intersect(rect1, rect2) {
2346
      function compare(a, b) {
2347
        return a - b;
2348
      }
2349

2350
      var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare);
2351
      var orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare);
2352
      var result = [];
2353
      rect1 = Util.normalizeRect(rect1);
2354
      rect2 = Util.normalizeRect(rect2);
2355

2356
      if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
2357
        result[0] = orderedX[1];
2358
        result[2] = orderedX[2];
2359
      } else {
2360
        return null;
2361
      }
2362

2363
      if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
2364
        result[1] = orderedY[1];
2365
        result[3] = orderedY[2];
2366
      } else {
2367
        return null;
2368
      }
2369

2370
      return result;
2371
    }
2372
  }]);
2373

2374
  return Util;
2375
}();
2376

2377
exports.Util = Util;
2378
var 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];
2379

2380
function stringToPDFString(str) {
2381
  var length = str.length,
2382
      strBuf = [];
2383

2384
  if (str[0] === "\xFE" && str[1] === "\xFF") {
2385
    for (var i = 2; i < length; i += 2) {
2386
      strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
2387
    }
2388
  } else if (str[0] === "\xFF" && str[1] === "\xFE") {
2389
    for (var _i2 = 2; _i2 < length; _i2 += 2) {
2390
      strBuf.push(String.fromCharCode(str.charCodeAt(_i2 + 1) << 8 | str.charCodeAt(_i2)));
2391
    }
2392
  } else {
2393
    for (var _i3 = 0; _i3 < length; ++_i3) {
2394
      var code = PDFStringTranslateTable[str.charCodeAt(_i3)];
2395
      strBuf.push(code ? String.fromCharCode(code) : str.charAt(_i3));
2396
    }
2397
  }
2398

2399
  return strBuf.join("");
2400
}
2401

2402
function escapeString(str) {
2403
  return str.replace(/([()\\\n\r])/g, function (match) {
2404
    if (match === "\n") {
2405
      return "\\n";
2406
    } else if (match === "\r") {
2407
      return "\\r";
2408
    }
2409

2410
    return "\\".concat(match);
2411
  });
2412
}
2413

2414
function isAscii(str) {
2415
  return /^[\x00-\x7F]*$/.test(str);
2416
}
2417

2418
function stringToUTF16BEString(str) {
2419
  var buf = ["\xFE\xFF"];
2420

2421
  for (var i = 0, ii = str.length; i < ii; i++) {
2422
    var _char = str.charCodeAt(i);
2423

2424
    buf.push(String.fromCharCode(_char >> 8 & 0xff));
2425
    buf.push(String.fromCharCode(_char & 0xff));
2426
  }
2427

2428
  return buf.join("");
2429
}
2430

2431
function stringToUTF8String(str) {
2432
  return decodeURIComponent(escape(str));
2433
}
2434

2435
function utf8StringToString(str) {
2436
  return unescape(encodeURIComponent(str));
2437
}
2438

2439
function isBool(v) {
2440
  return typeof v === "boolean";
2441
}
2442

2443
function isNum(v) {
2444
  return typeof v === "number";
2445
}
2446

2447
function isString(v) {
2448
  return typeof v === "string";
2449
}
2450

2451
function isArrayBuffer(v) {
2452
  return _typeof(v) === "object" && v !== null && v.byteLength !== undefined;
2453
}
2454

2455
function isArrayEqual(arr1, arr2) {
2456
  if (arr1.length !== arr2.length) {
2457
    return false;
2458
  }
2459

2460
  for (var i = 0, ii = arr1.length; i < ii; i++) {
2461
    if (arr1[i] !== arr2[i]) {
2462
      return false;
2463
    }
2464
  }
2465

2466
  return true;
2467
}
2468

2469
function getModificationDate() {
2470
  var date = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Date();
2471
  var 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")];
2472
  return buffer.join("");
2473
}
2474

2475
function createPromiseCapability() {
2476
  var capability = Object.create(null);
2477
  var isSettled = false;
2478
  Object.defineProperty(capability, "settled", {
2479
    get: function get() {
2480
      return isSettled;
2481
    }
2482
  });
2483
  capability.promise = new Promise(function (resolve, reject) {
2484
    capability.resolve = function (data) {
2485
      isSettled = true;
2486
      resolve(data);
2487
    };
2488

2489
    capability.reject = function (reason) {
2490
      isSettled = true;
2491
      reject(reason);
2492
    };
2493
  });
2494
  return capability;
2495
}
2496

2497
function createObjectURL(data) {
2498
  var contentType = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
2499
  var forceDataSchema = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
2500

2501
  if (URL.createObjectURL && !forceDataSchema) {
2502
    return URL.createObjectURL(new Blob([data], {
2503
      type: contentType
2504
    }));
2505
  }
2506

2507
  var digits = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
2508
  var buffer = "data:".concat(contentType, ";base64,");
2509

2510
  for (var i = 0, ii = data.length; i < ii; i += 3) {
2511
    var b1 = data[i] & 0xff;
2512
    var b2 = data[i + 1] & 0xff;
2513
    var b3 = data[i + 2] & 0xff;
2514
    var d1 = b1 >> 2,
2515
        d2 = (b1 & 3) << 4 | b2 >> 4;
2516
    var d3 = i + 1 < ii ? (b2 & 0xf) << 2 | b3 >> 6 : 64;
2517
    var d4 = i + 2 < ii ? b3 & 0x3f : 64;
2518
    buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];
2519
  }
2520

2521
  return buffer;
2522
}
2523

2524
/***/ }),
2525
/* 5 */
2526
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
2527

2528
"use strict";
2529

2530

2531
var _is_node = __w_pdfjs_require__(6);
2532

2533
if (typeof globalThis === "undefined" || !globalThis._pdfjsCompatibilityChecked) {
2534
  if (typeof globalThis === "undefined" || globalThis.Math !== Math) {
2535
    globalThis = __w_pdfjs_require__(7);
2536
  }
2537

2538
  globalThis._pdfjsCompatibilityChecked = true;
2539

2540
  (function checkNodeBtoa() {
2541
    if (globalThis.btoa || !_is_node.isNodeJS) {
2542
      return;
2543
    }
2544

2545
    globalThis.btoa = function (chars) {
2546
      return Buffer.from(chars, "binary").toString("base64");
2547
    };
2548
  })();
2549

2550
  (function checkNodeAtob() {
2551
    if (globalThis.atob || !_is_node.isNodeJS) {
2552
      return;
2553
    }
2554

2555
    globalThis.atob = function (input) {
2556
      return Buffer.from(input, "base64").toString("binary");
2557
    };
2558
  })();
2559

2560
  (function checkObjectFromEntries() {
2561
    if (Object.fromEntries) {
2562
      return;
2563
    }
2564

2565
    __w_pdfjs_require__(52);
2566
  })();
2567

2568
  (function checkPromise() {
2569
    if (globalThis.Promise.allSettled) {
2570
      return;
2571
    }
2572

2573
    globalThis.Promise = __w_pdfjs_require__(85);
2574
  })();
2575

2576
  (function checkReadableStream() {
2577
    var isReadableStreamSupported = false;
2578

2579
    if (typeof ReadableStream !== "undefined") {
2580
      try {
2581
        new ReadableStream({
2582
          start: function start(controller) {
2583
            controller.close();
2584
          }
2585
        });
2586
        isReadableStreamSupported = true;
2587
      } catch (e) {}
2588
    }
2589

2590
    if (isReadableStreamSupported) {
2591
      return;
2592
    }
2593

2594
    globalThis.ReadableStream = __w_pdfjs_require__(111).ReadableStream;
2595
  })();
2596

2597
  (function checkStringPadStart() {
2598
    if (String.prototype.padStart) {
2599
      return;
2600
    }
2601

2602
    __w_pdfjs_require__(112);
2603
  })();
2604

2605
  (function checkStringPadEnd() {
2606
    if (String.prototype.padEnd) {
2607
      return;
2608
    }
2609

2610
    __w_pdfjs_require__(118);
2611
  })();
2612

2613
  (function checkObjectValues() {
2614
    if (Object.values) {
2615
      return;
2616
    }
2617

2618
    Object.values = __w_pdfjs_require__(120);
2619
  })();
2620

2621
  (function checkObjectEntries() {
2622
    if (Object.entries) {
2623
      return;
2624
    }
2625

2626
    Object.entries = __w_pdfjs_require__(123);
2627
  })();
2628
}
2629

2630
/***/ }),
2631
/* 6 */
2632
/***/ ((__unused_webpack_module, exports) => {
2633

2634
"use strict";
2635

2636

2637
Object.defineProperty(exports, "__esModule", ({
2638
  value: true
2639
}));
2640
exports.isNodeJS = void 0;
2641

2642
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
2643

2644
var isNodeJS = (typeof process === "undefined" ? "undefined" : _typeof(process)) === "object" && process + "" === "[object process]" && !process.versions.nw && !(process.versions.electron && process.type && process.type !== "browser");
2645
exports.isNodeJS = isNodeJS;
2646

2647
/***/ }),
2648
/* 7 */
2649
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
2650

2651
__w_pdfjs_require__(8);
2652
module.exports = __w_pdfjs_require__(10);
2653

2654
/***/ }),
2655
/* 8 */
2656
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
2657

2658
var $ = __w_pdfjs_require__(9);
2659
var global = __w_pdfjs_require__(10);
2660
$({ global: true }, { globalThis: global });
2661

2662
/***/ }),
2663
/* 9 */
2664
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
2665

2666
var global = __w_pdfjs_require__(10);
2667
var getOwnPropertyDescriptor = __w_pdfjs_require__(11).f;
2668
var createNonEnumerableProperty = __w_pdfjs_require__(25);
2669
var redefine = __w_pdfjs_require__(28);
2670
var setGlobal = __w_pdfjs_require__(29);
2671
var copyConstructorProperties = __w_pdfjs_require__(39);
2672
var isForced = __w_pdfjs_require__(51);
2673
module.exports = function (options, source) {
2674
 var TARGET = options.target;
2675
 var GLOBAL = options.global;
2676
 var STATIC = options.stat;
2677
 var FORCED, target, key, targetProperty, sourceProperty, descriptor;
2678
 if (GLOBAL) {
2679
  target = global;
2680
 } else if (STATIC) {
2681
  target = global[TARGET] || setGlobal(TARGET, {});
2682
 } else {
2683
  target = (global[TARGET] || {}).prototype;
2684
 }
2685
 if (target)
2686
  for (key in source) {
2687
   sourceProperty = source[key];
2688
   if (options.noTargetGet) {
2689
    descriptor = getOwnPropertyDescriptor(target, key);
2690
    targetProperty = descriptor && descriptor.value;
2691
   } else
2692
    targetProperty = target[key];
2693
   FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
2694
   if (!FORCED && targetProperty !== undefined) {
2695
    if (typeof sourceProperty === typeof targetProperty)
2696
     continue;
2697
    copyConstructorProperties(sourceProperty, targetProperty);
2698
   }
2699
   if (options.sham || targetProperty && targetProperty.sham) {
2700
    createNonEnumerableProperty(sourceProperty, 'sham', true);
2701
   }
2702
   redefine(target, key, sourceProperty, options);
2703
  }
2704
};
2705

2706
/***/ }),
2707
/* 10 */
2708
/***/ ((module) => {
2709

2710
var check = function (it) {
2711
 return it && it.Math == Math && it;
2712
};
2713
module.exports = check(typeof globalThis == 'object' && globalThis) || check(typeof window == 'object' && window) || check(typeof self == 'object' && self) || check(typeof global == 'object' && global) || function () {
2714
 return this;
2715
}() || Function('return this')();
2716

2717
/***/ }),
2718
/* 11 */
2719
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
2720

2721
var DESCRIPTORS = __w_pdfjs_require__(12);
2722
var propertyIsEnumerableModule = __w_pdfjs_require__(14);
2723
var createPropertyDescriptor = __w_pdfjs_require__(15);
2724
var toIndexedObject = __w_pdfjs_require__(16);
2725
var toPrimitive = __w_pdfjs_require__(20);
2726
var has = __w_pdfjs_require__(22);
2727
var IE8_DOM_DEFINE = __w_pdfjs_require__(23);
2728
var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
2729
exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
2730
 O = toIndexedObject(O);
2731
 P = toPrimitive(P, true);
2732
 if (IE8_DOM_DEFINE)
2733
  try {
2734
   return $getOwnPropertyDescriptor(O, P);
2735
  } catch (error) {
2736
  }
2737
 if (has(O, P))
2738
  return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);
2739
};
2740

2741
/***/ }),
2742
/* 12 */
2743
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
2744

2745
var fails = __w_pdfjs_require__(13);
2746
module.exports = !fails(function () {
2747
 return Object.defineProperty({}, 1, {
2748
  get: function () {
2749
   return 7;
2750
  }
2751
 })[1] != 7;
2752
});
2753

2754
/***/ }),
2755
/* 13 */
2756
/***/ ((module) => {
2757

2758
module.exports = function (exec) {
2759
 try {
2760
  return !!exec();
2761
 } catch (error) {
2762
  return true;
2763
 }
2764
};
2765

2766
/***/ }),
2767
/* 14 */
2768
/***/ ((__unused_webpack_module, exports) => {
2769

2770
"use strict";
2771

2772
var $propertyIsEnumerable = {}.propertyIsEnumerable;
2773
var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
2774
var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
2775
exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
2776
 var descriptor = getOwnPropertyDescriptor(this, V);
2777
 return !!descriptor && descriptor.enumerable;
2778
} : $propertyIsEnumerable;
2779

2780
/***/ }),
2781
/* 15 */
2782
/***/ ((module) => {
2783

2784
module.exports = function (bitmap, value) {
2785
 return {
2786
  enumerable: !(bitmap & 1),
2787
  configurable: !(bitmap & 2),
2788
  writable: !(bitmap & 4),
2789
  value: value
2790
 };
2791
};
2792

2793
/***/ }),
2794
/* 16 */
2795
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
2796

2797
var IndexedObject = __w_pdfjs_require__(17);
2798
var requireObjectCoercible = __w_pdfjs_require__(19);
2799
module.exports = function (it) {
2800
 return IndexedObject(requireObjectCoercible(it));
2801
};
2802

2803
/***/ }),
2804
/* 17 */
2805
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
2806

2807
var fails = __w_pdfjs_require__(13);
2808
var classof = __w_pdfjs_require__(18);
2809
var split = ''.split;
2810
module.exports = fails(function () {
2811
 return !Object('z').propertyIsEnumerable(0);
2812
}) ? function (it) {
2813
 return classof(it) == 'String' ? split.call(it, '') : Object(it);
2814
} : Object;
2815

2816
/***/ }),
2817
/* 18 */
2818
/***/ ((module) => {
2819

2820
var toString = {}.toString;
2821
module.exports = function (it) {
2822
 return toString.call(it).slice(8, -1);
2823
};
2824

2825
/***/ }),
2826
/* 19 */
2827
/***/ ((module) => {
2828

2829
module.exports = function (it) {
2830
 if (it == undefined)
2831
  throw TypeError("Can't call method on " + it);
2832
 return it;
2833
};
2834

2835
/***/ }),
2836
/* 20 */
2837
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
2838

2839
var isObject = __w_pdfjs_require__(21);
2840
module.exports = function (input, PREFERRED_STRING) {
2841
 if (!isObject(input))
2842
  return input;
2843
 var fn, val;
2844
 if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input)))
2845
  return val;
2846
 if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input)))
2847
  return val;
2848
 if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input)))
2849
  return val;
2850
 throw TypeError("Can't convert object to primitive value");
2851
};
2852

2853
/***/ }),
2854
/* 21 */
2855
/***/ ((module) => {
2856

2857
module.exports = function (it) {
2858
 return typeof it === 'object' ? it !== null : typeof it === 'function';
2859
};
2860

2861
/***/ }),
2862
/* 22 */
2863
/***/ ((module) => {
2864

2865
var hasOwnProperty = {}.hasOwnProperty;
2866
module.exports = function (it, key) {
2867
 return hasOwnProperty.call(it, key);
2868
};
2869

2870
/***/ }),
2871
/* 23 */
2872
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
2873

2874
var DESCRIPTORS = __w_pdfjs_require__(12);
2875
var fails = __w_pdfjs_require__(13);
2876
var createElement = __w_pdfjs_require__(24);
2877
module.exports = !DESCRIPTORS && !fails(function () {
2878
 return Object.defineProperty(createElement('div'), 'a', {
2879
  get: function () {
2880
   return 7;
2881
  }
2882
 }).a != 7;
2883
});
2884

2885
/***/ }),
2886
/* 24 */
2887
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
2888

2889
var global = __w_pdfjs_require__(10);
2890
var isObject = __w_pdfjs_require__(21);
2891
var document = global.document;
2892
var EXISTS = isObject(document) && isObject(document.createElement);
2893
module.exports = function (it) {
2894
 return EXISTS ? document.createElement(it) : {};
2895
};
2896

2897
/***/ }),
2898
/* 25 */
2899
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
2900

2901
var DESCRIPTORS = __w_pdfjs_require__(12);
2902
var definePropertyModule = __w_pdfjs_require__(26);
2903
var createPropertyDescriptor = __w_pdfjs_require__(15);
2904
module.exports = DESCRIPTORS ? function (object, key, value) {
2905
 return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
2906
} : function (object, key, value) {
2907
 object[key] = value;
2908
 return object;
2909
};
2910

2911
/***/ }),
2912
/* 26 */
2913
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
2914

2915
var DESCRIPTORS = __w_pdfjs_require__(12);
2916
var IE8_DOM_DEFINE = __w_pdfjs_require__(23);
2917
var anObject = __w_pdfjs_require__(27);
2918
var toPrimitive = __w_pdfjs_require__(20);
2919
var $defineProperty = Object.defineProperty;
2920
exports.f = DESCRIPTORS ? $defineProperty : function defineProperty(O, P, Attributes) {
2921
 anObject(O);
2922
 P = toPrimitive(P, true);
2923
 anObject(Attributes);
2924
 if (IE8_DOM_DEFINE)
2925
  try {
2926
   return $defineProperty(O, P, Attributes);
2927
  } catch (error) {
2928
  }
2929
 if ('get' in Attributes || 'set' in Attributes)
2930
  throw TypeError('Accessors not supported');
2931
 if ('value' in Attributes)
2932
  O[P] = Attributes.value;
2933
 return O;
2934
};
2935

2936
/***/ }),
2937
/* 27 */
2938
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
2939

2940
var isObject = __w_pdfjs_require__(21);
2941
module.exports = function (it) {
2942
 if (!isObject(it)) {
2943
  throw TypeError(String(it) + ' is not an object');
2944
 }
2945
 return it;
2946
};
2947

2948
/***/ }),
2949
/* 28 */
2950
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
2951

2952
var global = __w_pdfjs_require__(10);
2953
var createNonEnumerableProperty = __w_pdfjs_require__(25);
2954
var has = __w_pdfjs_require__(22);
2955
var setGlobal = __w_pdfjs_require__(29);
2956
var inspectSource = __w_pdfjs_require__(30);
2957
var InternalStateModule = __w_pdfjs_require__(32);
2958
var getInternalState = InternalStateModule.get;
2959
var enforceInternalState = InternalStateModule.enforce;
2960
var TEMPLATE = String(String).split('String');
2961
(module.exports = function (O, key, value, options) {
2962
 var unsafe = options ? !!options.unsafe : false;
2963
 var simple = options ? !!options.enumerable : false;
2964
 var noTargetGet = options ? !!options.noTargetGet : false;
2965
 var state;
2966
 if (typeof value == 'function') {
2967
  if (typeof key == 'string' && !has(value, 'name')) {
2968
   createNonEnumerableProperty(value, 'name', key);
2969
  }
2970
  state = enforceInternalState(value);
2971
  if (!state.source) {
2972
   state.source = TEMPLATE.join(typeof key == 'string' ? key : '');
2973
  }
2974
 }
2975
 if (O === global) {
2976
  if (simple)
2977
   O[key] = value;
2978
  else
2979
   setGlobal(key, value);
2980
  return;
2981
 } else if (!unsafe) {
2982
  delete O[key];
2983
 } else if (!noTargetGet && O[key]) {
2984
  simple = true;
2985
 }
2986
 if (simple)
2987
  O[key] = value;
2988
 else
2989
  createNonEnumerableProperty(O, key, value);
2990
})(Function.prototype, 'toString', function toString() {
2991
 return typeof this == 'function' && getInternalState(this).source || inspectSource(this);
2992
});
2993

2994
/***/ }),
2995
/* 29 */
2996
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
2997

2998
var global = __w_pdfjs_require__(10);
2999
var createNonEnumerableProperty = __w_pdfjs_require__(25);
3000
module.exports = function (key, value) {
3001
 try {
3002
  createNonEnumerableProperty(global, key, value);
3003
 } catch (error) {
3004
  global[key] = value;
3005
 }
3006
 return value;
3007
};
3008

3009
/***/ }),
3010
/* 30 */
3011
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3012

3013
var store = __w_pdfjs_require__(31);
3014
var functionToString = Function.toString;
3015
if (typeof store.inspectSource != 'function') {
3016
 store.inspectSource = function (it) {
3017
  return functionToString.call(it);
3018
 };
3019
}
3020
module.exports = store.inspectSource;
3021

3022
/***/ }),
3023
/* 31 */
3024
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3025

3026
var global = __w_pdfjs_require__(10);
3027
var setGlobal = __w_pdfjs_require__(29);
3028
var SHARED = '__core-js_shared__';
3029
var store = global[SHARED] || setGlobal(SHARED, {});
3030
module.exports = store;
3031

3032
/***/ }),
3033
/* 32 */
3034
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3035

3036
var NATIVE_WEAK_MAP = __w_pdfjs_require__(33);
3037
var global = __w_pdfjs_require__(10);
3038
var isObject = __w_pdfjs_require__(21);
3039
var createNonEnumerableProperty = __w_pdfjs_require__(25);
3040
var objectHas = __w_pdfjs_require__(22);
3041
var shared = __w_pdfjs_require__(31);
3042
var sharedKey = __w_pdfjs_require__(34);
3043
var hiddenKeys = __w_pdfjs_require__(38);
3044
var WeakMap = global.WeakMap;
3045
var set, get, has;
3046
var enforce = function (it) {
3047
 return has(it) ? get(it) : set(it, {});
3048
};
3049
var getterFor = function (TYPE) {
3050
 return function (it) {
3051
  var state;
3052
  if (!isObject(it) || (state = get(it)).type !== TYPE) {
3053
   throw TypeError('Incompatible receiver, ' + TYPE + ' required');
3054
  }
3055
  return state;
3056
 };
3057
};
3058
if (NATIVE_WEAK_MAP) {
3059
 var store = shared.state || (shared.state = new WeakMap());
3060
 var wmget = store.get;
3061
 var wmhas = store.has;
3062
 var wmset = store.set;
3063
 set = function (it, metadata) {
3064
  metadata.facade = it;
3065
  wmset.call(store, it, metadata);
3066
  return metadata;
3067
 };
3068
 get = function (it) {
3069
  return wmget.call(store, it) || {};
3070
 };
3071
 has = function (it) {
3072
  return wmhas.call(store, it);
3073
 };
3074
} else {
3075
 var STATE = sharedKey('state');
3076
 hiddenKeys[STATE] = true;
3077
 set = function (it, metadata) {
3078
  metadata.facade = it;
3079
  createNonEnumerableProperty(it, STATE, metadata);
3080
  return metadata;
3081
 };
3082
 get = function (it) {
3083
  return objectHas(it, STATE) ? it[STATE] : {};
3084
 };
3085
 has = function (it) {
3086
  return objectHas(it, STATE);
3087
 };
3088
}
3089
module.exports = {
3090
 set: set,
3091
 get: get,
3092
 has: has,
3093
 enforce: enforce,
3094
 getterFor: getterFor
3095
};
3096

3097
/***/ }),
3098
/* 33 */
3099
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3100

3101
var global = __w_pdfjs_require__(10);
3102
var inspectSource = __w_pdfjs_require__(30);
3103
var WeakMap = global.WeakMap;
3104
module.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));
3105

3106
/***/ }),
3107
/* 34 */
3108
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3109

3110
var shared = __w_pdfjs_require__(35);
3111
var uid = __w_pdfjs_require__(37);
3112
var keys = shared('keys');
3113
module.exports = function (key) {
3114
 return keys[key] || (keys[key] = uid(key));
3115
};
3116

3117
/***/ }),
3118
/* 35 */
3119
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3120

3121
var IS_PURE = __w_pdfjs_require__(36);
3122
var store = __w_pdfjs_require__(31);
3123
(module.exports = function (key, value) {
3124
 return store[key] || (store[key] = value !== undefined ? value : {});
3125
})('versions', []).push({
3126
 version: '3.10.0',
3127
 mode: IS_PURE ? 'pure' : 'global',
3128
 copyright: '© 2021 Denis Pushkarev (zloirock.ru)'
3129
});
3130

3131
/***/ }),
3132
/* 36 */
3133
/***/ ((module) => {
3134

3135
module.exports = false;
3136

3137
/***/ }),
3138
/* 37 */
3139
/***/ ((module) => {
3140

3141
var id = 0;
3142
var postfix = Math.random();
3143
module.exports = function (key) {
3144
 return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);
3145
};
3146

3147
/***/ }),
3148
/* 38 */
3149
/***/ ((module) => {
3150

3151
module.exports = {};
3152

3153
/***/ }),
3154
/* 39 */
3155
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3156

3157
var has = __w_pdfjs_require__(22);
3158
var ownKeys = __w_pdfjs_require__(40);
3159
var getOwnPropertyDescriptorModule = __w_pdfjs_require__(11);
3160
var definePropertyModule = __w_pdfjs_require__(26);
3161
module.exports = function (target, source) {
3162
 var keys = ownKeys(source);
3163
 var defineProperty = definePropertyModule.f;
3164
 var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
3165
 for (var i = 0; i < keys.length; i++) {
3166
  var key = keys[i];
3167
  if (!has(target, key))
3168
   defineProperty(target, key, getOwnPropertyDescriptor(source, key));
3169
 }
3170
};
3171

3172
/***/ }),
3173
/* 40 */
3174
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3175

3176
var getBuiltIn = __w_pdfjs_require__(41);
3177
var getOwnPropertyNamesModule = __w_pdfjs_require__(43);
3178
var getOwnPropertySymbolsModule = __w_pdfjs_require__(50);
3179
var anObject = __w_pdfjs_require__(27);
3180
module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
3181
 var keys = getOwnPropertyNamesModule.f(anObject(it));
3182
 var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
3183
 return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;
3184
};
3185

3186
/***/ }),
3187
/* 41 */
3188
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3189

3190
var path = __w_pdfjs_require__(42);
3191
var global = __w_pdfjs_require__(10);
3192
var aFunction = function (variable) {
3193
 return typeof variable == 'function' ? variable : undefined;
3194
};
3195
module.exports = function (namespace, method) {
3196
 return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace]) : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];
3197
};
3198

3199
/***/ }),
3200
/* 42 */
3201
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3202

3203
var global = __w_pdfjs_require__(10);
3204
module.exports = global;
3205

3206
/***/ }),
3207
/* 43 */
3208
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
3209

3210
var internalObjectKeys = __w_pdfjs_require__(44);
3211
var enumBugKeys = __w_pdfjs_require__(49);
3212
var hiddenKeys = enumBugKeys.concat('length', 'prototype');
3213
exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
3214
 return internalObjectKeys(O, hiddenKeys);
3215
};
3216

3217
/***/ }),
3218
/* 44 */
3219
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3220

3221
var has = __w_pdfjs_require__(22);
3222
var toIndexedObject = __w_pdfjs_require__(16);
3223
var indexOf = __w_pdfjs_require__(45).indexOf;
3224
var hiddenKeys = __w_pdfjs_require__(38);
3225
module.exports = function (object, names) {
3226
 var O = toIndexedObject(object);
3227
 var i = 0;
3228
 var result = [];
3229
 var key;
3230
 for (key in O)
3231
  !has(hiddenKeys, key) && has(O, key) && result.push(key);
3232
 while (names.length > i)
3233
  if (has(O, key = names[i++])) {
3234
   ~indexOf(result, key) || result.push(key);
3235
  }
3236
 return result;
3237
};
3238

3239
/***/ }),
3240
/* 45 */
3241
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3242

3243
var toIndexedObject = __w_pdfjs_require__(16);
3244
var toLength = __w_pdfjs_require__(46);
3245
var toAbsoluteIndex = __w_pdfjs_require__(48);
3246
var createMethod = function (IS_INCLUDES) {
3247
 return function ($this, el, fromIndex) {
3248
  var O = toIndexedObject($this);
3249
  var length = toLength(O.length);
3250
  var index = toAbsoluteIndex(fromIndex, length);
3251
  var value;
3252
  if (IS_INCLUDES && el != el)
3253
   while (length > index) {
3254
    value = O[index++];
3255
    if (value != value)
3256
     return true;
3257
   }
3258
  else
3259
   for (; length > index; index++) {
3260
    if ((IS_INCLUDES || index in O) && O[index] === el)
3261
     return IS_INCLUDES || index || 0;
3262
   }
3263
  return !IS_INCLUDES && -1;
3264
 };
3265
};
3266
module.exports = {
3267
 includes: createMethod(true),
3268
 indexOf: createMethod(false)
3269
};
3270

3271
/***/ }),
3272
/* 46 */
3273
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3274

3275
var toInteger = __w_pdfjs_require__(47);
3276
var min = Math.min;
3277
module.exports = function (argument) {
3278
 return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0;
3279
};
3280

3281
/***/ }),
3282
/* 47 */
3283
/***/ ((module) => {
3284

3285
var ceil = Math.ceil;
3286
var floor = Math.floor;
3287
module.exports = function (argument) {
3288
 return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);
3289
};
3290

3291
/***/ }),
3292
/* 48 */
3293
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3294

3295
var toInteger = __w_pdfjs_require__(47);
3296
var max = Math.max;
3297
var min = Math.min;
3298
module.exports = function (index, length) {
3299
 var integer = toInteger(index);
3300
 return integer < 0 ? max(integer + length, 0) : min(integer, length);
3301
};
3302

3303
/***/ }),
3304
/* 49 */
3305
/***/ ((module) => {
3306

3307
module.exports = [
3308
 'constructor',
3309
 'hasOwnProperty',
3310
 'isPrototypeOf',
3311
 'propertyIsEnumerable',
3312
 'toLocaleString',
3313
 'toString',
3314
 'valueOf'
3315
];
3316

3317
/***/ }),
3318
/* 50 */
3319
/***/ ((__unused_webpack_module, exports) => {
3320

3321
exports.f = Object.getOwnPropertySymbols;
3322

3323
/***/ }),
3324
/* 51 */
3325
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3326

3327
var fails = __w_pdfjs_require__(13);
3328
var replacement = /#|\.prototype\./;
3329
var isForced = function (feature, detection) {
3330
 var value = data[normalize(feature)];
3331
 return value == POLYFILL ? true : value == NATIVE ? false : typeof detection == 'function' ? fails(detection) : !!detection;
3332
};
3333
var normalize = isForced.normalize = function (string) {
3334
 return String(string).replace(replacement, '.').toLowerCase();
3335
};
3336
var data = isForced.data = {};
3337
var NATIVE = isForced.NATIVE = 'N';
3338
var POLYFILL = isForced.POLYFILL = 'P';
3339
module.exports = isForced;
3340

3341
/***/ }),
3342
/* 52 */
3343
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3344

3345
__w_pdfjs_require__(53);
3346
__w_pdfjs_require__(75);
3347
var path = __w_pdfjs_require__(42);
3348
module.exports = path.Object.fromEntries;
3349

3350
/***/ }),
3351
/* 53 */
3352
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3353

3354
"use strict";
3355

3356
var toIndexedObject = __w_pdfjs_require__(16);
3357
var addToUnscopables = __w_pdfjs_require__(54);
3358
var Iterators = __w_pdfjs_require__(65);
3359
var InternalStateModule = __w_pdfjs_require__(32);
3360
var defineIterator = __w_pdfjs_require__(66);
3361
var ARRAY_ITERATOR = 'Array Iterator';
3362
var setInternalState = InternalStateModule.set;
3363
var getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);
3364
module.exports = defineIterator(Array, 'Array', function (iterated, kind) {
3365
 setInternalState(this, {
3366
  type: ARRAY_ITERATOR,
3367
  target: toIndexedObject(iterated),
3368
  index: 0,
3369
  kind: kind
3370
 });
3371
}, function () {
3372
 var state = getInternalState(this);
3373
 var target = state.target;
3374
 var kind = state.kind;
3375
 var index = state.index++;
3376
 if (!target || index >= target.length) {
3377
  state.target = undefined;
3378
  return {
3379
   value: undefined,
3380
   done: true
3381
  };
3382
 }
3383
 if (kind == 'keys')
3384
  return {
3385
   value: index,
3386
   done: false
3387
  };
3388
 if (kind == 'values')
3389
  return {
3390
   value: target[index],
3391
   done: false
3392
  };
3393
 return {
3394
  value: [
3395
   index,
3396
   target[index]
3397
  ],
3398
  done: false
3399
 };
3400
}, 'values');
3401
Iterators.Arguments = Iterators.Array;
3402
addToUnscopables('keys');
3403
addToUnscopables('values');
3404
addToUnscopables('entries');
3405

3406
/***/ }),
3407
/* 54 */
3408
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3409

3410
var wellKnownSymbol = __w_pdfjs_require__(55);
3411
var create = __w_pdfjs_require__(61);
3412
var definePropertyModule = __w_pdfjs_require__(26);
3413
var UNSCOPABLES = wellKnownSymbol('unscopables');
3414
var ArrayPrototype = Array.prototype;
3415
if (ArrayPrototype[UNSCOPABLES] == undefined) {
3416
 definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {
3417
  configurable: true,
3418
  value: create(null)
3419
 });
3420
}
3421
module.exports = function (key) {
3422
 ArrayPrototype[UNSCOPABLES][key] = true;
3423
};
3424

3425
/***/ }),
3426
/* 55 */
3427
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3428

3429
var global = __w_pdfjs_require__(10);
3430
var shared = __w_pdfjs_require__(35);
3431
var has = __w_pdfjs_require__(22);
3432
var uid = __w_pdfjs_require__(37);
3433
var NATIVE_SYMBOL = __w_pdfjs_require__(56);
3434
var USE_SYMBOL_AS_UID = __w_pdfjs_require__(60);
3435
var WellKnownSymbolsStore = shared('wks');
3436
var Symbol = global.Symbol;
3437
var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;
3438
module.exports = function (name) {
3439
 if (!has(WellKnownSymbolsStore, name) || !(NATIVE_SYMBOL || typeof WellKnownSymbolsStore[name] == 'string')) {
3440
  if (NATIVE_SYMBOL && has(Symbol, name)) {
3441
   WellKnownSymbolsStore[name] = Symbol[name];
3442
  } else {
3443
   WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);
3444
  }
3445
 }
3446
 return WellKnownSymbolsStore[name];
3447
};
3448

3449
/***/ }),
3450
/* 56 */
3451
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3452

3453
var IS_NODE = __w_pdfjs_require__(57);
3454
var V8_VERSION = __w_pdfjs_require__(58);
3455
var fails = __w_pdfjs_require__(13);
3456
module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
3457
 return !Symbol.sham && (IS_NODE ? V8_VERSION === 38 : V8_VERSION > 37 && V8_VERSION < 41);
3458
});
3459

3460
/***/ }),
3461
/* 57 */
3462
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3463

3464
var classof = __w_pdfjs_require__(18);
3465
var global = __w_pdfjs_require__(10);
3466
module.exports = classof(global.process) == 'process';
3467

3468
/***/ }),
3469
/* 58 */
3470
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3471

3472
var global = __w_pdfjs_require__(10);
3473
var userAgent = __w_pdfjs_require__(59);
3474
var process = global.process;
3475
var versions = process && process.versions;
3476
var v8 = versions && versions.v8;
3477
var match, version;
3478
if (v8) {
3479
 match = v8.split('.');
3480
 version = match[0] + match[1];
3481
} else if (userAgent) {
3482
 match = userAgent.match(/Edge\/(\d+)/);
3483
 if (!match || match[1] >= 74) {
3484
  match = userAgent.match(/Chrome\/(\d+)/);
3485
  if (match)
3486
   version = match[1];
3487
 }
3488
}
3489
module.exports = version && +version;
3490

3491
/***/ }),
3492
/* 59 */
3493
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3494

3495
var getBuiltIn = __w_pdfjs_require__(41);
3496
module.exports = getBuiltIn('navigator', 'userAgent') || '';
3497

3498
/***/ }),
3499
/* 60 */
3500
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3501

3502
var NATIVE_SYMBOL = __w_pdfjs_require__(56);
3503
module.exports = NATIVE_SYMBOL && !Symbol.sham && typeof Symbol.iterator == 'symbol';
3504

3505
/***/ }),
3506
/* 61 */
3507
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3508

3509
var anObject = __w_pdfjs_require__(27);
3510
var defineProperties = __w_pdfjs_require__(62);
3511
var enumBugKeys = __w_pdfjs_require__(49);
3512
var hiddenKeys = __w_pdfjs_require__(38);
3513
var html = __w_pdfjs_require__(64);
3514
var documentCreateElement = __w_pdfjs_require__(24);
3515
var sharedKey = __w_pdfjs_require__(34);
3516
var GT = '>';
3517
var LT = '<';
3518
var PROTOTYPE = 'prototype';
3519
var SCRIPT = 'script';
3520
var IE_PROTO = sharedKey('IE_PROTO');
3521
var EmptyConstructor = function () {
3522
};
3523
var scriptTag = function (content) {
3524
 return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
3525
};
3526
var NullProtoObjectViaActiveX = function (activeXDocument) {
3527
 activeXDocument.write(scriptTag(''));
3528
 activeXDocument.close();
3529
 var temp = activeXDocument.parentWindow.Object;
3530
 activeXDocument = null;
3531
 return temp;
3532
};
3533
var NullProtoObjectViaIFrame = function () {
3534
 var iframe = documentCreateElement('iframe');
3535
 var JS = 'java' + SCRIPT + ':';
3536
 var iframeDocument;
3537
 iframe.style.display = 'none';
3538
 html.appendChild(iframe);
3539
 iframe.src = String(JS);
3540
 iframeDocument = iframe.contentWindow.document;
3541
 iframeDocument.open();
3542
 iframeDocument.write(scriptTag('document.F=Object'));
3543
 iframeDocument.close();
3544
 return iframeDocument.F;
3545
};
3546
var activeXDocument;
3547
var NullProtoObject = function () {
3548
 try {
3549
  activeXDocument = document.domain && new ActiveXObject('htmlfile');
3550
 } catch (error) {
3551
 }
3552
 NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();
3553
 var length = enumBugKeys.length;
3554
 while (length--)
3555
  delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
3556
 return NullProtoObject();
3557
};
3558
hiddenKeys[IE_PROTO] = true;
3559
module.exports = Object.create || function create(O, Properties) {
3560
 var result;
3561
 if (O !== null) {
3562
  EmptyConstructor[PROTOTYPE] = anObject(O);
3563
  result = new EmptyConstructor();
3564
  EmptyConstructor[PROTOTYPE] = null;
3565
  result[IE_PROTO] = O;
3566
 } else
3567
  result = NullProtoObject();
3568
 return Properties === undefined ? result : defineProperties(result, Properties);
3569
};
3570

3571
/***/ }),
3572
/* 62 */
3573
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3574

3575
var DESCRIPTORS = __w_pdfjs_require__(12);
3576
var definePropertyModule = __w_pdfjs_require__(26);
3577
var anObject = __w_pdfjs_require__(27);
3578
var objectKeys = __w_pdfjs_require__(63);
3579
module.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {
3580
 anObject(O);
3581
 var keys = objectKeys(Properties);
3582
 var length = keys.length;
3583
 var index = 0;
3584
 var key;
3585
 while (length > index)
3586
  definePropertyModule.f(O, key = keys[index++], Properties[key]);
3587
 return O;
3588
};
3589

3590
/***/ }),
3591
/* 63 */
3592
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3593

3594
var internalObjectKeys = __w_pdfjs_require__(44);
3595
var enumBugKeys = __w_pdfjs_require__(49);
3596
module.exports = Object.keys || function keys(O) {
3597
 return internalObjectKeys(O, enumBugKeys);
3598
};
3599

3600
/***/ }),
3601
/* 64 */
3602
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3603

3604
var getBuiltIn = __w_pdfjs_require__(41);
3605
module.exports = getBuiltIn('document', 'documentElement');
3606

3607
/***/ }),
3608
/* 65 */
3609
/***/ ((module) => {
3610

3611
module.exports = {};
3612

3613
/***/ }),
3614
/* 66 */
3615
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3616

3617
"use strict";
3618

3619
var $ = __w_pdfjs_require__(9);
3620
var createIteratorConstructor = __w_pdfjs_require__(67);
3621
var getPrototypeOf = __w_pdfjs_require__(69);
3622
var setPrototypeOf = __w_pdfjs_require__(73);
3623
var setToStringTag = __w_pdfjs_require__(72);
3624
var createNonEnumerableProperty = __w_pdfjs_require__(25);
3625
var redefine = __w_pdfjs_require__(28);
3626
var wellKnownSymbol = __w_pdfjs_require__(55);
3627
var IS_PURE = __w_pdfjs_require__(36);
3628
var Iterators = __w_pdfjs_require__(65);
3629
var IteratorsCore = __w_pdfjs_require__(68);
3630
var IteratorPrototype = IteratorsCore.IteratorPrototype;
3631
var BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;
3632
var ITERATOR = wellKnownSymbol('iterator');
3633
var KEYS = 'keys';
3634
var VALUES = 'values';
3635
var ENTRIES = 'entries';
3636
var returnThis = function () {
3637
 return this;
3638
};
3639
module.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {
3640
 createIteratorConstructor(IteratorConstructor, NAME, next);
3641
 var getIterationMethod = function (KIND) {
3642
  if (KIND === DEFAULT && defaultIterator)
3643
   return defaultIterator;
3644
  if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype)
3645
   return IterablePrototype[KIND];
3646
  switch (KIND) {
3647
  case KEYS:
3648
   return function keys() {
3649
    return new IteratorConstructor(this, KIND);
3650
   };
3651
  case VALUES:
3652
   return function values() {
3653
    return new IteratorConstructor(this, KIND);
3654
   };
3655
  case ENTRIES:
3656
   return function entries() {
3657
    return new IteratorConstructor(this, KIND);
3658
   };
3659
  }
3660
  return function () {
3661
   return new IteratorConstructor(this);
3662
  };
3663
 };
3664
 var TO_STRING_TAG = NAME + ' Iterator';
3665
 var INCORRECT_VALUES_NAME = false;
3666
 var IterablePrototype = Iterable.prototype;
3667
 var nativeIterator = IterablePrototype[ITERATOR] || IterablePrototype['@@iterator'] || DEFAULT && IterablePrototype[DEFAULT];
3668
 var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);
3669
 var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;
3670
 var CurrentIteratorPrototype, methods, KEY;
3671
 if (anyNativeIterator) {
3672
  CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));
3673
  if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {
3674
   if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {
3675
    if (setPrototypeOf) {
3676
     setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);
3677
    } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') {
3678
     createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis);
3679
    }
3680
   }
3681
   setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);
3682
   if (IS_PURE)
3683
    Iterators[TO_STRING_TAG] = returnThis;
3684
  }
3685
 }
3686
 if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {
3687
  INCORRECT_VALUES_NAME = true;
3688
  defaultIterator = function values() {
3689
   return nativeIterator.call(this);
3690
  };
3691
 }
3692
 if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {
3693
  createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator);
3694
 }
3695
 Iterators[NAME] = defaultIterator;
3696
 if (DEFAULT) {
3697
  methods = {
3698
   values: getIterationMethod(VALUES),
3699
   keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),
3700
   entries: getIterationMethod(ENTRIES)
3701
  };
3702
  if (FORCED)
3703
   for (KEY in methods) {
3704
    if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {
3705
     redefine(IterablePrototype, KEY, methods[KEY]);
3706
    }
3707
   }
3708
  else
3709
   $({
3710
    target: NAME,
3711
    proto: true,
3712
    forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME
3713
   }, methods);
3714
 }
3715
 return methods;
3716
};
3717

3718
/***/ }),
3719
/* 67 */
3720
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3721

3722
"use strict";
3723

3724
var IteratorPrototype = __w_pdfjs_require__(68).IteratorPrototype;
3725
var create = __w_pdfjs_require__(61);
3726
var createPropertyDescriptor = __w_pdfjs_require__(15);
3727
var setToStringTag = __w_pdfjs_require__(72);
3728
var Iterators = __w_pdfjs_require__(65);
3729
var returnThis = function () {
3730
 return this;
3731
};
3732
module.exports = function (IteratorConstructor, NAME, next) {
3733
 var TO_STRING_TAG = NAME + ' Iterator';
3734
 IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });
3735
 setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);
3736
 Iterators[TO_STRING_TAG] = returnThis;
3737
 return IteratorConstructor;
3738
};
3739

3740
/***/ }),
3741
/* 68 */
3742
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3743

3744
"use strict";
3745

3746
var fails = __w_pdfjs_require__(13);
3747
var getPrototypeOf = __w_pdfjs_require__(69);
3748
var createNonEnumerableProperty = __w_pdfjs_require__(25);
3749
var has = __w_pdfjs_require__(22);
3750
var wellKnownSymbol = __w_pdfjs_require__(55);
3751
var IS_PURE = __w_pdfjs_require__(36);
3752
var ITERATOR = wellKnownSymbol('iterator');
3753
var BUGGY_SAFARI_ITERATORS = false;
3754
var returnThis = function () {
3755
 return this;
3756
};
3757
var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
3758
if ([].keys) {
3759
 arrayIterator = [].keys();
3760
 if (!('next' in arrayIterator))
3761
  BUGGY_SAFARI_ITERATORS = true;
3762
 else {
3763
  PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
3764
  if (PrototypeOfArrayIteratorPrototype !== Object.prototype)
3765
   IteratorPrototype = PrototypeOfArrayIteratorPrototype;
3766
 }
3767
}
3768
var NEW_ITERATOR_PROTOTYPE = IteratorPrototype == undefined || fails(function () {
3769
 var test = {};
3770
 return IteratorPrototype[ITERATOR].call(test) !== test;
3771
});
3772
if (NEW_ITERATOR_PROTOTYPE)
3773
 IteratorPrototype = {};
3774
if ((!IS_PURE || NEW_ITERATOR_PROTOTYPE) && !has(IteratorPrototype, ITERATOR)) {
3775
 createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis);
3776
}
3777
module.exports = {
3778
 IteratorPrototype: IteratorPrototype,
3779
 BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
3780
};
3781

3782
/***/ }),
3783
/* 69 */
3784
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3785

3786
var has = __w_pdfjs_require__(22);
3787
var toObject = __w_pdfjs_require__(70);
3788
var sharedKey = __w_pdfjs_require__(34);
3789
var CORRECT_PROTOTYPE_GETTER = __w_pdfjs_require__(71);
3790
var IE_PROTO = sharedKey('IE_PROTO');
3791
var ObjectPrototype = Object.prototype;
3792
module.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {
3793
 O = toObject(O);
3794
 if (has(O, IE_PROTO))
3795
  return O[IE_PROTO];
3796
 if (typeof O.constructor == 'function' && O instanceof O.constructor) {
3797
  return O.constructor.prototype;
3798
 }
3799
 return O instanceof Object ? ObjectPrototype : null;
3800
};
3801

3802
/***/ }),
3803
/* 70 */
3804
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3805

3806
var requireObjectCoercible = __w_pdfjs_require__(19);
3807
module.exports = function (argument) {
3808
 return Object(requireObjectCoercible(argument));
3809
};
3810

3811
/***/ }),
3812
/* 71 */
3813
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3814

3815
var fails = __w_pdfjs_require__(13);
3816
module.exports = !fails(function () {
3817
 function F() {
3818
 }
3819
 F.prototype.constructor = null;
3820
 return Object.getPrototypeOf(new F()) !== F.prototype;
3821
});
3822

3823
/***/ }),
3824
/* 72 */
3825
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3826

3827
var defineProperty = __w_pdfjs_require__(26).f;
3828
var has = __w_pdfjs_require__(22);
3829
var wellKnownSymbol = __w_pdfjs_require__(55);
3830
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
3831
module.exports = function (it, TAG, STATIC) {
3832
 if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {
3833
  defineProperty(it, TO_STRING_TAG, {
3834
   configurable: true,
3835
   value: TAG
3836
  });
3837
 }
3838
};
3839

3840
/***/ }),
3841
/* 73 */
3842
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3843

3844
var anObject = __w_pdfjs_require__(27);
3845
var aPossiblePrototype = __w_pdfjs_require__(74);
3846
module.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {
3847
 var CORRECT_SETTER = false;
3848
 var test = {};
3849
 var setter;
3850
 try {
3851
  setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;
3852
  setter.call(test, []);
3853
  CORRECT_SETTER = test instanceof Array;
3854
 } catch (error) {
3855
 }
3856
 return function setPrototypeOf(O, proto) {
3857
  anObject(O);
3858
  aPossiblePrototype(proto);
3859
  if (CORRECT_SETTER)
3860
   setter.call(O, proto);
3861
  else
3862
   O.__proto__ = proto;
3863
  return O;
3864
 };
3865
}() : undefined);
3866

3867
/***/ }),
3868
/* 74 */
3869
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3870

3871
var isObject = __w_pdfjs_require__(21);
3872
module.exports = function (it) {
3873
 if (!isObject(it) && it !== null) {
3874
  throw TypeError("Can't set " + String(it) + ' as a prototype');
3875
 }
3876
 return it;
3877
};
3878

3879
/***/ }),
3880
/* 75 */
3881
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
3882

3883
var $ = __w_pdfjs_require__(9);
3884
var iterate = __w_pdfjs_require__(76);
3885
var createProperty = __w_pdfjs_require__(84);
3886
$({
3887
 target: 'Object',
3888
 stat: true
3889
}, {
3890
 fromEntries: function fromEntries(iterable) {
3891
  var obj = {};
3892
  iterate(iterable, function (k, v) {
3893
   createProperty(obj, k, v);
3894
  }, { AS_ENTRIES: true });
3895
  return obj;
3896
 }
3897
});
3898

3899
/***/ }),
3900
/* 76 */
3901
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3902

3903
var anObject = __w_pdfjs_require__(27);
3904
var isArrayIteratorMethod = __w_pdfjs_require__(77);
3905
var toLength = __w_pdfjs_require__(46);
3906
var bind = __w_pdfjs_require__(78);
3907
var getIteratorMethod = __w_pdfjs_require__(80);
3908
var iteratorClose = __w_pdfjs_require__(83);
3909
var Result = function (stopped, result) {
3910
 this.stopped = stopped;
3911
 this.result = result;
3912
};
3913
module.exports = function (iterable, unboundFunction, options) {
3914
 var that = options && options.that;
3915
 var AS_ENTRIES = !!(options && options.AS_ENTRIES);
3916
 var IS_ITERATOR = !!(options && options.IS_ITERATOR);
3917
 var INTERRUPTED = !!(options && options.INTERRUPTED);
3918
 var fn = bind(unboundFunction, that, 1 + AS_ENTRIES + INTERRUPTED);
3919
 var iterator, iterFn, index, length, result, next, step;
3920
 var stop = function (condition) {
3921
  if (iterator)
3922
   iteratorClose(iterator);
3923
  return new Result(true, condition);
3924
 };
3925
 var callFn = function (value) {
3926
  if (AS_ENTRIES) {
3927
   anObject(value);
3928
   return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
3929
  }
3930
  return INTERRUPTED ? fn(value, stop) : fn(value);
3931
 };
3932
 if (IS_ITERATOR) {
3933
  iterator = iterable;
3934
 } else {
3935
  iterFn = getIteratorMethod(iterable);
3936
  if (typeof iterFn != 'function')
3937
   throw TypeError('Target is not iterable');
3938
  if (isArrayIteratorMethod(iterFn)) {
3939
   for (index = 0, length = toLength(iterable.length); length > index; index++) {
3940
    result = callFn(iterable[index]);
3941
    if (result && result instanceof Result)
3942
     return result;
3943
   }
3944
   return new Result(false);
3945
  }
3946
  iterator = iterFn.call(iterable);
3947
 }
3948
 next = iterator.next;
3949
 while (!(step = next.call(iterator)).done) {
3950
  try {
3951
   result = callFn(step.value);
3952
  } catch (error) {
3953
   iteratorClose(iterator);
3954
   throw error;
3955
  }
3956
  if (typeof result == 'object' && result && result instanceof Result)
3957
   return result;
3958
 }
3959
 return new Result(false);
3960
};
3961

3962
/***/ }),
3963
/* 77 */
3964
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3965

3966
var wellKnownSymbol = __w_pdfjs_require__(55);
3967
var Iterators = __w_pdfjs_require__(65);
3968
var ITERATOR = wellKnownSymbol('iterator');
3969
var ArrayPrototype = Array.prototype;
3970
module.exports = function (it) {
3971
 return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
3972
};
3973

3974
/***/ }),
3975
/* 78 */
3976
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
3977

3978
var aFunction = __w_pdfjs_require__(79);
3979
module.exports = function (fn, that, length) {
3980
 aFunction(fn);
3981
 if (that === undefined)
3982
  return fn;
3983
 switch (length) {
3984
 case 0:
3985
  return function () {
3986
   return fn.call(that);
3987
  };
3988
 case 1:
3989
  return function (a) {
3990
   return fn.call(that, a);
3991
  };
3992
 case 2:
3993
  return function (a, b) {
3994
   return fn.call(that, a, b);
3995
  };
3996
 case 3:
3997
  return function (a, b, c) {
3998
   return fn.call(that, a, b, c);
3999
  };
4000
 }
4001
 return function () {
4002
  return fn.apply(that, arguments);
4003
 };
4004
};
4005

4006
/***/ }),
4007
/* 79 */
4008
/***/ ((module) => {
4009

4010
module.exports = function (it) {
4011
 if (typeof it != 'function') {
4012
  throw TypeError(String(it) + ' is not a function');
4013
 }
4014
 return it;
4015
};
4016

4017
/***/ }),
4018
/* 80 */
4019
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4020

4021
var classof = __w_pdfjs_require__(81);
4022
var Iterators = __w_pdfjs_require__(65);
4023
var wellKnownSymbol = __w_pdfjs_require__(55);
4024
var ITERATOR = wellKnownSymbol('iterator');
4025
module.exports = function (it) {
4026
 if (it != undefined)
4027
  return it[ITERATOR] || it['@@iterator'] || Iterators[classof(it)];
4028
};
4029

4030
/***/ }),
4031
/* 81 */
4032
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4033

4034
var TO_STRING_TAG_SUPPORT = __w_pdfjs_require__(82);
4035
var classofRaw = __w_pdfjs_require__(18);
4036
var wellKnownSymbol = __w_pdfjs_require__(55);
4037
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
4038
var CORRECT_ARGUMENTS = classofRaw(function () {
4039
 return arguments;
4040
}()) == 'Arguments';
4041
var tryGet = function (it, key) {
4042
 try {
4043
  return it[key];
4044
 } catch (error) {
4045
 }
4046
};
4047
module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
4048
 var O, tag, result;
4049
 return it === undefined ? 'Undefined' : it === null ? 'Null' : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag : CORRECT_ARGUMENTS ? classofRaw(O) : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;
4050
};
4051

4052
/***/ }),
4053
/* 82 */
4054
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4055

4056
var wellKnownSymbol = __w_pdfjs_require__(55);
4057
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
4058
var test = {};
4059
test[TO_STRING_TAG] = 'z';
4060
module.exports = String(test) === '[object z]';
4061

4062
/***/ }),
4063
/* 83 */
4064
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4065

4066
var anObject = __w_pdfjs_require__(27);
4067
module.exports = function (iterator) {
4068
 var returnMethod = iterator['return'];
4069
 if (returnMethod !== undefined) {
4070
  return anObject(returnMethod.call(iterator)).value;
4071
 }
4072
};
4073

4074
/***/ }),
4075
/* 84 */
4076
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4077

4078
"use strict";
4079

4080
var toPrimitive = __w_pdfjs_require__(20);
4081
var definePropertyModule = __w_pdfjs_require__(26);
4082
var createPropertyDescriptor = __w_pdfjs_require__(15);
4083
module.exports = function (object, key, value) {
4084
 var propertyKey = toPrimitive(key);
4085
 if (propertyKey in object)
4086
  definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));
4087
 else
4088
  object[propertyKey] = value;
4089
};
4090

4091
/***/ }),
4092
/* 85 */
4093
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4094

4095
__w_pdfjs_require__(86);
4096
__w_pdfjs_require__(87);
4097
__w_pdfjs_require__(89);
4098
__w_pdfjs_require__(104);
4099
__w_pdfjs_require__(105);
4100
__w_pdfjs_require__(106);
4101
__w_pdfjs_require__(107);
4102
__w_pdfjs_require__(109);
4103
var path = __w_pdfjs_require__(42);
4104
module.exports = path.Promise;
4105

4106
/***/ }),
4107
/* 86 */
4108
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
4109

4110
"use strict";
4111

4112
var $ = __w_pdfjs_require__(9);
4113
var getPrototypeOf = __w_pdfjs_require__(69);
4114
var setPrototypeOf = __w_pdfjs_require__(73);
4115
var create = __w_pdfjs_require__(61);
4116
var createNonEnumerableProperty = __w_pdfjs_require__(25);
4117
var createPropertyDescriptor = __w_pdfjs_require__(15);
4118
var iterate = __w_pdfjs_require__(76);
4119
var $AggregateError = function AggregateError(errors, message) {
4120
 var that = this;
4121
 if (!(that instanceof $AggregateError))
4122
  return new $AggregateError(errors, message);
4123
 if (setPrototypeOf) {
4124
  that = setPrototypeOf(new Error(undefined), getPrototypeOf(that));
4125
 }
4126
 if (message !== undefined)
4127
  createNonEnumerableProperty(that, 'message', String(message));
4128
 var errorsArray = [];
4129
 iterate(errors, errorsArray.push, { that: errorsArray });
4130
 createNonEnumerableProperty(that, 'errors', errorsArray);
4131
 return that;
4132
};
4133
$AggregateError.prototype = create(Error.prototype, {
4134
 constructor: createPropertyDescriptor(5, $AggregateError),
4135
 message: createPropertyDescriptor(5, ''),
4136
 name: createPropertyDescriptor(5, 'AggregateError')
4137
});
4138
$({ global: true }, { AggregateError: $AggregateError });
4139

4140
/***/ }),
4141
/* 87 */
4142
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
4143

4144
var TO_STRING_TAG_SUPPORT = __w_pdfjs_require__(82);
4145
var redefine = __w_pdfjs_require__(28);
4146
var toString = __w_pdfjs_require__(88);
4147
if (!TO_STRING_TAG_SUPPORT) {
4148
 redefine(Object.prototype, 'toString', toString, { unsafe: true });
4149
}
4150

4151
/***/ }),
4152
/* 88 */
4153
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4154

4155
"use strict";
4156

4157
var TO_STRING_TAG_SUPPORT = __w_pdfjs_require__(82);
4158
var classof = __w_pdfjs_require__(81);
4159
module.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {
4160
 return '[object ' + classof(this) + ']';
4161
};
4162

4163
/***/ }),
4164
/* 89 */
4165
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
4166

4167
"use strict";
4168

4169
var $ = __w_pdfjs_require__(9);
4170
var IS_PURE = __w_pdfjs_require__(36);
4171
var global = __w_pdfjs_require__(10);
4172
var getBuiltIn = __w_pdfjs_require__(41);
4173
var NativePromise = __w_pdfjs_require__(90);
4174
var redefine = __w_pdfjs_require__(28);
4175
var redefineAll = __w_pdfjs_require__(91);
4176
var setToStringTag = __w_pdfjs_require__(72);
4177
var setSpecies = __w_pdfjs_require__(92);
4178
var isObject = __w_pdfjs_require__(21);
4179
var aFunction = __w_pdfjs_require__(79);
4180
var anInstance = __w_pdfjs_require__(93);
4181
var inspectSource = __w_pdfjs_require__(30);
4182
var iterate = __w_pdfjs_require__(76);
4183
var checkCorrectnessOfIteration = __w_pdfjs_require__(94);
4184
var speciesConstructor = __w_pdfjs_require__(95);
4185
var task = __w_pdfjs_require__(96).set;
4186
var microtask = __w_pdfjs_require__(98);
4187
var promiseResolve = __w_pdfjs_require__(100);
4188
var hostReportErrors = __w_pdfjs_require__(102);
4189
var newPromiseCapabilityModule = __w_pdfjs_require__(101);
4190
var perform = __w_pdfjs_require__(103);
4191
var InternalStateModule = __w_pdfjs_require__(32);
4192
var isForced = __w_pdfjs_require__(51);
4193
var wellKnownSymbol = __w_pdfjs_require__(55);
4194
var IS_NODE = __w_pdfjs_require__(57);
4195
var V8_VERSION = __w_pdfjs_require__(58);
4196
var SPECIES = wellKnownSymbol('species');
4197
var PROMISE = 'Promise';
4198
var getInternalState = InternalStateModule.get;
4199
var setInternalState = InternalStateModule.set;
4200
var getInternalPromiseState = InternalStateModule.getterFor(PROMISE);
4201
var PromiseConstructor = NativePromise;
4202
var TypeError = global.TypeError;
4203
var document = global.document;
4204
var process = global.process;
4205
var $fetch = getBuiltIn('fetch');
4206
var newPromiseCapability = newPromiseCapabilityModule.f;
4207
var newGenericPromiseCapability = newPromiseCapability;
4208
var DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);
4209
var NATIVE_REJECTION_EVENT = typeof PromiseRejectionEvent == 'function';
4210
var UNHANDLED_REJECTION = 'unhandledrejection';
4211
var REJECTION_HANDLED = 'rejectionhandled';
4212
var PENDING = 0;
4213
var FULFILLED = 1;
4214
var REJECTED = 2;
4215
var HANDLED = 1;
4216
var UNHANDLED = 2;
4217
var Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;
4218
var FORCED = isForced(PROMISE, function () {
4219
 var GLOBAL_CORE_JS_PROMISE = inspectSource(PromiseConstructor) !== String(PromiseConstructor);
4220
 if (!GLOBAL_CORE_JS_PROMISE) {
4221
  if (V8_VERSION === 66)
4222
   return true;
4223
  if (!IS_NODE && !NATIVE_REJECTION_EVENT)
4224
   return true;
4225
 }
4226
 if (IS_PURE && !PromiseConstructor.prototype['finally'])
4227
  return true;
4228
 if (V8_VERSION >= 51 && /native code/.test(PromiseConstructor))
4229
  return false;
4230
 var promise = PromiseConstructor.resolve(1);
4231
 var FakePromise = function (exec) {
4232
  exec(function () {
4233
  }, function () {
4234
  });
4235
 };
4236
 var constructor = promise.constructor = {};
4237
 constructor[SPECIES] = FakePromise;
4238
 return !(promise.then(function () {
4239
 }) instanceof FakePromise);
4240
});
4241
var INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {
4242
 PromiseConstructor.all(iterable)['catch'](function () {
4243
 });
4244
});
4245
var isThenable = function (it) {
4246
 var then;
4247
 return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
4248
};
4249
var notify = function (state, isReject) {
4250
 if (state.notified)
4251
  return;
4252
 state.notified = true;
4253
 var chain = state.reactions;
4254
 microtask(function () {
4255
  var value = state.value;
4256
  var ok = state.state == FULFILLED;
4257
  var index = 0;
4258
  while (chain.length > index) {
4259
   var reaction = chain[index++];
4260
   var handler = ok ? reaction.ok : reaction.fail;
4261
   var resolve = reaction.resolve;
4262
   var reject = reaction.reject;
4263
   var domain = reaction.domain;
4264
   var result, then, exited;
4265
   try {
4266
    if (handler) {
4267
     if (!ok) {
4268
      if (state.rejection === UNHANDLED)
4269
       onHandleUnhandled(state);
4270
      state.rejection = HANDLED;
4271
     }
4272
     if (handler === true)
4273
      result = value;
4274
     else {
4275
      if (domain)
4276
       domain.enter();
4277
      result = handler(value);
4278
      if (domain) {
4279
       domain.exit();
4280
       exited = true;
4281
      }
4282
     }
4283
     if (result === reaction.promise) {
4284
      reject(TypeError('Promise-chain cycle'));
4285
     } else if (then = isThenable(result)) {
4286
      then.call(result, resolve, reject);
4287
     } else
4288
      resolve(result);
4289
    } else
4290
     reject(value);
4291
   } catch (error) {
4292
    if (domain && !exited)
4293
     domain.exit();
4294
    reject(error);
4295
   }
4296
  }
4297
  state.reactions = [];
4298
  state.notified = false;
4299
  if (isReject && !state.rejection)
4300
   onUnhandled(state);
4301
 });
4302
};
4303
var dispatchEvent = function (name, promise, reason) {
4304
 var event, handler;
4305
 if (DISPATCH_EVENT) {
4306
  event = document.createEvent('Event');
4307
  event.promise = promise;
4308
  event.reason = reason;
4309
  event.initEvent(name, false, true);
4310
  global.dispatchEvent(event);
4311
 } else
4312
  event = {
4313
   promise: promise,
4314
   reason: reason
4315
  };
4316
 if (!NATIVE_REJECTION_EVENT && (handler = global['on' + name]))
4317
  handler(event);
4318
 else if (name === UNHANDLED_REJECTION)
4319
  hostReportErrors('Unhandled promise rejection', reason);
4320
};
4321
var onUnhandled = function (state) {
4322
 task.call(global, function () {
4323
  var promise = state.facade;
4324
  var value = state.value;
4325
  var IS_UNHANDLED = isUnhandled(state);
4326
  var result;
4327
  if (IS_UNHANDLED) {
4328
   result = perform(function () {
4329
    if (IS_NODE) {
4330
     process.emit('unhandledRejection', value, promise);
4331
    } else
4332
     dispatchEvent(UNHANDLED_REJECTION, promise, value);
4333
   });
4334
   state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;
4335
   if (result.error)
4336
    throw result.value;
4337
  }
4338
 });
4339
};
4340
var isUnhandled = function (state) {
4341
 return state.rejection !== HANDLED && !state.parent;
4342
};
4343
var onHandleUnhandled = function (state) {
4344
 task.call(global, function () {
4345
  var promise = state.facade;
4346
  if (IS_NODE) {
4347
   process.emit('rejectionHandled', promise);
4348
  } else
4349
   dispatchEvent(REJECTION_HANDLED, promise, state.value);
4350
 });
4351
};
4352
var bind = function (fn, state, unwrap) {
4353
 return function (value) {
4354
  fn(state, value, unwrap);
4355
 };
4356
};
4357
var internalReject = function (state, value, unwrap) {
4358
 if (state.done)
4359
  return;
4360
 state.done = true;
4361
 if (unwrap)
4362
  state = unwrap;
4363
 state.value = value;
4364
 state.state = REJECTED;
4365
 notify(state, true);
4366
};
4367
var internalResolve = function (state, value, unwrap) {
4368
 if (state.done)
4369
  return;
4370
 state.done = true;
4371
 if (unwrap)
4372
  state = unwrap;
4373
 try {
4374
  if (state.facade === value)
4375
   throw TypeError("Promise can't be resolved itself");
4376
  var then = isThenable(value);
4377
  if (then) {
4378
   microtask(function () {
4379
    var wrapper = { done: false };
4380
    try {
4381
     then.call(value, bind(internalResolve, wrapper, state), bind(internalReject, wrapper, state));
4382
    } catch (error) {
4383
     internalReject(wrapper, error, state);
4384
    }
4385
   });
4386
  } else {
4387
   state.value = value;
4388
   state.state = FULFILLED;
4389
   notify(state, false);
4390
  }
4391
 } catch (error) {
4392
  internalReject({ done: false }, error, state);
4393
 }
4394
};
4395
if (FORCED) {
4396
 PromiseConstructor = function Promise(executor) {
4397
  anInstance(this, PromiseConstructor, PROMISE);
4398
  aFunction(executor);
4399
  Internal.call(this);
4400
  var state = getInternalState(this);
4401
  try {
4402
   executor(bind(internalResolve, state), bind(internalReject, state));
4403
  } catch (error) {
4404
   internalReject(state, error);
4405
  }
4406
 };
4407
 Internal = function Promise(executor) {
4408
  setInternalState(this, {
4409
   type: PROMISE,
4410
   done: false,
4411
   notified: false,
4412
   parent: false,
4413
   reactions: [],
4414
   rejection: false,
4415
   state: PENDING,
4416
   value: undefined
4417
  });
4418
 };
4419
 Internal.prototype = redefineAll(PromiseConstructor.prototype, {
4420
  then: function then(onFulfilled, onRejected) {
4421
   var state = getInternalPromiseState(this);
4422
   var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));
4423
   reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
4424
   reaction.fail = typeof onRejected == 'function' && onRejected;
4425
   reaction.domain = IS_NODE ? process.domain : undefined;
4426
   state.parent = true;
4427
   state.reactions.push(reaction);
4428
   if (state.state != PENDING)
4429
    notify(state, false);
4430
   return reaction.promise;
4431
  },
4432
  'catch': function (onRejected) {
4433
   return this.then(undefined, onRejected);
4434
  }
4435
 });
4436
 OwnPromiseCapability = function () {
4437
  var promise = new Internal();
4438
  var state = getInternalState(promise);
4439
  this.promise = promise;
4440
  this.resolve = bind(internalResolve, state);
4441
  this.reject = bind(internalReject, state);
4442
 };
4443
 newPromiseCapabilityModule.f = newPromiseCapability = function (C) {
4444
  return C === PromiseConstructor || C === PromiseWrapper ? new OwnPromiseCapability(C) : newGenericPromiseCapability(C);
4445
 };
4446
 if (!IS_PURE && typeof NativePromise == 'function') {
4447
  nativeThen = NativePromise.prototype.then;
4448
  redefine(NativePromise.prototype, 'then', function then(onFulfilled, onRejected) {
4449
   var that = this;
4450
   return new PromiseConstructor(function (resolve, reject) {
4451
    nativeThen.call(that, resolve, reject);
4452
   }).then(onFulfilled, onRejected);
4453
  }, { unsafe: true });
4454
  if (typeof $fetch == 'function')
4455
   $({
4456
    global: true,
4457
    enumerable: true,
4458
    forced: true
4459
   }, {
4460
    fetch: function fetch(input) {
4461
     return promiseResolve(PromiseConstructor, $fetch.apply(global, arguments));
4462
    }
4463
   });
4464
 }
4465
}
4466
$({
4467
 global: true,
4468
 wrap: true,
4469
 forced: FORCED
4470
}, { Promise: PromiseConstructor });
4471
setToStringTag(PromiseConstructor, PROMISE, false, true);
4472
setSpecies(PROMISE);
4473
PromiseWrapper = getBuiltIn(PROMISE);
4474
$({
4475
 target: PROMISE,
4476
 stat: true,
4477
 forced: FORCED
4478
}, {
4479
 reject: function reject(r) {
4480
  var capability = newPromiseCapability(this);
4481
  capability.reject.call(undefined, r);
4482
  return capability.promise;
4483
 }
4484
});
4485
$({
4486
 target: PROMISE,
4487
 stat: true,
4488
 forced: IS_PURE || FORCED
4489
}, {
4490
 resolve: function resolve(x) {
4491
  return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x);
4492
 }
4493
});
4494
$({
4495
 target: PROMISE,
4496
 stat: true,
4497
 forced: INCORRECT_ITERATION
4498
}, {
4499
 all: function all(iterable) {
4500
  var C = this;
4501
  var capability = newPromiseCapability(C);
4502
  var resolve = capability.resolve;
4503
  var reject = capability.reject;
4504
  var result = perform(function () {
4505
   var $promiseResolve = aFunction(C.resolve);
4506
   var values = [];
4507
   var counter = 0;
4508
   var remaining = 1;
4509
   iterate(iterable, function (promise) {
4510
    var index = counter++;
4511
    var alreadyCalled = false;
4512
    values.push(undefined);
4513
    remaining++;
4514
    $promiseResolve.call(C, promise).then(function (value) {
4515
     if (alreadyCalled)
4516
      return;
4517
     alreadyCalled = true;
4518
     values[index] = value;
4519
     --remaining || resolve(values);
4520
    }, reject);
4521
   });
4522
   --remaining || resolve(values);
4523
  });
4524
  if (result.error)
4525
   reject(result.value);
4526
  return capability.promise;
4527
 },
4528
 race: function race(iterable) {
4529
  var C = this;
4530
  var capability = newPromiseCapability(C);
4531
  var reject = capability.reject;
4532
  var result = perform(function () {
4533
   var $promiseResolve = aFunction(C.resolve);
4534
   iterate(iterable, function (promise) {
4535
    $promiseResolve.call(C, promise).then(capability.resolve, reject);
4536
   });
4537
  });
4538
  if (result.error)
4539
   reject(result.value);
4540
  return capability.promise;
4541
 }
4542
});
4543

4544
/***/ }),
4545
/* 90 */
4546
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4547

4548
var global = __w_pdfjs_require__(10);
4549
module.exports = global.Promise;
4550

4551
/***/ }),
4552
/* 91 */
4553
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4554

4555
var redefine = __w_pdfjs_require__(28);
4556
module.exports = function (target, src, options) {
4557
 for (var key in src)
4558
  redefine(target, key, src[key], options);
4559
 return target;
4560
};
4561

4562
/***/ }),
4563
/* 92 */
4564
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4565

4566
"use strict";
4567

4568
var getBuiltIn = __w_pdfjs_require__(41);
4569
var definePropertyModule = __w_pdfjs_require__(26);
4570
var wellKnownSymbol = __w_pdfjs_require__(55);
4571
var DESCRIPTORS = __w_pdfjs_require__(12);
4572
var SPECIES = wellKnownSymbol('species');
4573
module.exports = function (CONSTRUCTOR_NAME) {
4574
 var Constructor = getBuiltIn(CONSTRUCTOR_NAME);
4575
 var defineProperty = definePropertyModule.f;
4576
 if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {
4577
  defineProperty(Constructor, SPECIES, {
4578
   configurable: true,
4579
   get: function () {
4580
    return this;
4581
   }
4582
  });
4583
 }
4584
};
4585

4586
/***/ }),
4587
/* 93 */
4588
/***/ ((module) => {
4589

4590
module.exports = function (it, Constructor, name) {
4591
 if (!(it instanceof Constructor)) {
4592
  throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');
4593
 }
4594
 return it;
4595
};
4596

4597
/***/ }),
4598
/* 94 */
4599
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4600

4601
var wellKnownSymbol = __w_pdfjs_require__(55);
4602
var ITERATOR = wellKnownSymbol('iterator');
4603
var SAFE_CLOSING = false;
4604
try {
4605
 var called = 0;
4606
 var iteratorWithReturn = {
4607
  next: function () {
4608
   return { done: !!called++ };
4609
  },
4610
  'return': function () {
4611
   SAFE_CLOSING = true;
4612
  }
4613
 };
4614
 iteratorWithReturn[ITERATOR] = function () {
4615
  return this;
4616
 };
4617
 Array.from(iteratorWithReturn, function () {
4618
  throw 2;
4619
 });
4620
} catch (error) {
4621
}
4622
module.exports = function (exec, SKIP_CLOSING) {
4623
 if (!SKIP_CLOSING && !SAFE_CLOSING)
4624
  return false;
4625
 var ITERATION_SUPPORT = false;
4626
 try {
4627
  var object = {};
4628
  object[ITERATOR] = function () {
4629
   return {
4630
    next: function () {
4631
     return { done: ITERATION_SUPPORT = true };
4632
    }
4633
   };
4634
  };
4635
  exec(object);
4636
 } catch (error) {
4637
 }
4638
 return ITERATION_SUPPORT;
4639
};
4640

4641
/***/ }),
4642
/* 95 */
4643
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4644

4645
var anObject = __w_pdfjs_require__(27);
4646
var aFunction = __w_pdfjs_require__(79);
4647
var wellKnownSymbol = __w_pdfjs_require__(55);
4648
var SPECIES = wellKnownSymbol('species');
4649
module.exports = function (O, defaultConstructor) {
4650
 var C = anObject(O).constructor;
4651
 var S;
4652
 return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aFunction(S);
4653
};
4654

4655
/***/ }),
4656
/* 96 */
4657
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4658

4659
var global = __w_pdfjs_require__(10);
4660
var fails = __w_pdfjs_require__(13);
4661
var bind = __w_pdfjs_require__(78);
4662
var html = __w_pdfjs_require__(64);
4663
var createElement = __w_pdfjs_require__(24);
4664
var IS_IOS = __w_pdfjs_require__(97);
4665
var IS_NODE = __w_pdfjs_require__(57);
4666
var location = global.location;
4667
var set = global.setImmediate;
4668
var clear = global.clearImmediate;
4669
var process = global.process;
4670
var MessageChannel = global.MessageChannel;
4671
var Dispatch = global.Dispatch;
4672
var counter = 0;
4673
var queue = {};
4674
var ONREADYSTATECHANGE = 'onreadystatechange';
4675
var defer, channel, port;
4676
var run = function (id) {
4677
 if (queue.hasOwnProperty(id)) {
4678
  var fn = queue[id];
4679
  delete queue[id];
4680
  fn();
4681
 }
4682
};
4683
var runner = function (id) {
4684
 return function () {
4685
  run(id);
4686
 };
4687
};
4688
var listener = function (event) {
4689
 run(event.data);
4690
};
4691
var post = function (id) {
4692
 global.postMessage(id + '', location.protocol + '//' + location.host);
4693
};
4694
if (!set || !clear) {
4695
 set = function setImmediate(fn) {
4696
  var args = [];
4697
  var i = 1;
4698
  while (arguments.length > i)
4699
   args.push(arguments[i++]);
4700
  queue[++counter] = function () {
4701
   (typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args);
4702
  };
4703
  defer(counter);
4704
  return counter;
4705
 };
4706
 clear = function clearImmediate(id) {
4707
  delete queue[id];
4708
 };
4709
 if (IS_NODE) {
4710
  defer = function (id) {
4711
   process.nextTick(runner(id));
4712
  };
4713
 } else if (Dispatch && Dispatch.now) {
4714
  defer = function (id) {
4715
   Dispatch.now(runner(id));
4716
  };
4717
 } else if (MessageChannel && !IS_IOS) {
4718
  channel = new MessageChannel();
4719
  port = channel.port2;
4720
  channel.port1.onmessage = listener;
4721
  defer = bind(port.postMessage, port, 1);
4722
 } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts && location && location.protocol !== 'file:' && !fails(post)) {
4723
  defer = post;
4724
  global.addEventListener('message', listener, false);
4725
 } else if (ONREADYSTATECHANGE in createElement('script')) {
4726
  defer = function (id) {
4727
   html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {
4728
    html.removeChild(this);
4729
    run(id);
4730
   };
4731
  };
4732
 } else {
4733
  defer = function (id) {
4734
   setTimeout(runner(id), 0);
4735
  };
4736
 }
4737
}
4738
module.exports = {
4739
 set: set,
4740
 clear: clear
4741
};
4742

4743
/***/ }),
4744
/* 97 */
4745
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4746

4747
var userAgent = __w_pdfjs_require__(59);
4748
module.exports = /(iphone|ipod|ipad).*applewebkit/i.test(userAgent);
4749

4750
/***/ }),
4751
/* 98 */
4752
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4753

4754
var global = __w_pdfjs_require__(10);
4755
var getOwnPropertyDescriptor = __w_pdfjs_require__(11).f;
4756
var macrotask = __w_pdfjs_require__(96).set;
4757
var IS_IOS = __w_pdfjs_require__(97);
4758
var IS_WEBOS_WEBKIT = __w_pdfjs_require__(99);
4759
var IS_NODE = __w_pdfjs_require__(57);
4760
var MutationObserver = global.MutationObserver || global.WebKitMutationObserver;
4761
var document = global.document;
4762
var process = global.process;
4763
var Promise = global.Promise;
4764
var queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');
4765
var queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;
4766
var flush, head, last, notify, toggle, node, promise, then;
4767
if (!queueMicrotask) {
4768
 flush = function () {
4769
  var parent, fn;
4770
  if (IS_NODE && (parent = process.domain))
4771
   parent.exit();
4772
  while (head) {
4773
   fn = head.fn;
4774
   head = head.next;
4775
   try {
4776
    fn();
4777
   } catch (error) {
4778
    if (head)
4779
     notify();
4780
    else
4781
     last = undefined;
4782
    throw error;
4783
   }
4784
  }
4785
  last = undefined;
4786
  if (parent)
4787
   parent.enter();
4788
 };
4789
 if (!IS_IOS && !IS_NODE && !IS_WEBOS_WEBKIT && MutationObserver && document) {
4790
  toggle = true;
4791
  node = document.createTextNode('');
4792
  new MutationObserver(flush).observe(node, { characterData: true });
4793
  notify = function () {
4794
   node.data = toggle = !toggle;
4795
  };
4796
 } else if (Promise && Promise.resolve) {
4797
  promise = Promise.resolve(undefined);
4798
  then = promise.then;
4799
  notify = function () {
4800
   then.call(promise, flush);
4801
  };
4802
 } else if (IS_NODE) {
4803
  notify = function () {
4804
   process.nextTick(flush);
4805
  };
4806
 } else {
4807
  notify = function () {
4808
   macrotask.call(global, flush);
4809
  };
4810
 }
4811
}
4812
module.exports = queueMicrotask || function (fn) {
4813
 var task = {
4814
  fn: fn,
4815
  next: undefined
4816
 };
4817
 if (last)
4818
  last.next = task;
4819
 if (!head) {
4820
  head = task;
4821
  notify();
4822
 }
4823
 last = task;
4824
};
4825

4826
/***/ }),
4827
/* 99 */
4828
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4829

4830
var userAgent = __w_pdfjs_require__(59);
4831
module.exports = /web0s(?!.*chrome)/i.test(userAgent);
4832

4833
/***/ }),
4834
/* 100 */
4835
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4836

4837
var anObject = __w_pdfjs_require__(27);
4838
var isObject = __w_pdfjs_require__(21);
4839
var newPromiseCapability = __w_pdfjs_require__(101);
4840
module.exports = function (C, x) {
4841
 anObject(C);
4842
 if (isObject(x) && x.constructor === C)
4843
  return x;
4844
 var promiseCapability = newPromiseCapability.f(C);
4845
 var resolve = promiseCapability.resolve;
4846
 resolve(x);
4847
 return promiseCapability.promise;
4848
};
4849

4850
/***/ }),
4851
/* 101 */
4852
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4853

4854
"use strict";
4855

4856
var aFunction = __w_pdfjs_require__(79);
4857
var PromiseCapability = function (C) {
4858
 var resolve, reject;
4859
 this.promise = new C(function ($$resolve, $$reject) {
4860
  if (resolve !== undefined || reject !== undefined)
4861
   throw TypeError('Bad Promise constructor');
4862
  resolve = $$resolve;
4863
  reject = $$reject;
4864
 });
4865
 this.resolve = aFunction(resolve);
4866
 this.reject = aFunction(reject);
4867
};
4868
module.exports.f = function (C) {
4869
 return new PromiseCapability(C);
4870
};
4871

4872
/***/ }),
4873
/* 102 */
4874
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
4875

4876
var global = __w_pdfjs_require__(10);
4877
module.exports = function (a, b) {
4878
 var console = global.console;
4879
 if (console && console.error) {
4880
  arguments.length === 1 ? console.error(a) : console.error(a, b);
4881
 }
4882
};
4883

4884
/***/ }),
4885
/* 103 */
4886
/***/ ((module) => {
4887

4888
module.exports = function (exec) {
4889
 try {
4890
  return {
4891
   error: false,
4892
   value: exec()
4893
  };
4894
 } catch (error) {
4895
  return {
4896
   error: true,
4897
   value: error
4898
  };
4899
 }
4900
};
4901

4902
/***/ }),
4903
/* 104 */
4904
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
4905

4906
"use strict";
4907

4908
var $ = __w_pdfjs_require__(9);
4909
var aFunction = __w_pdfjs_require__(79);
4910
var newPromiseCapabilityModule = __w_pdfjs_require__(101);
4911
var perform = __w_pdfjs_require__(103);
4912
var iterate = __w_pdfjs_require__(76);
4913
$({
4914
 target: 'Promise',
4915
 stat: true
4916
}, {
4917
 allSettled: function allSettled(iterable) {
4918
  var C = this;
4919
  var capability = newPromiseCapabilityModule.f(C);
4920
  var resolve = capability.resolve;
4921
  var reject = capability.reject;
4922
  var result = perform(function () {
4923
   var promiseResolve = aFunction(C.resolve);
4924
   var values = [];
4925
   var counter = 0;
4926
   var remaining = 1;
4927
   iterate(iterable, function (promise) {
4928
    var index = counter++;
4929
    var alreadyCalled = false;
4930
    values.push(undefined);
4931
    remaining++;
4932
    promiseResolve.call(C, promise).then(function (value) {
4933
     if (alreadyCalled)
4934
      return;
4935
     alreadyCalled = true;
4936
     values[index] = {
4937
      status: 'fulfilled',
4938
      value: value
4939
     };
4940
     --remaining || resolve(values);
4941
    }, function (error) {
4942
     if (alreadyCalled)
4943
      return;
4944
     alreadyCalled = true;
4945
     values[index] = {
4946
      status: 'rejected',
4947
      reason: error
4948
     };
4949
     --remaining || resolve(values);
4950
    });
4951
   });
4952
   --remaining || resolve(values);
4953
  });
4954
  if (result.error)
4955
   reject(result.value);
4956
  return capability.promise;
4957
 }
4958
});
4959

4960
/***/ }),
4961
/* 105 */
4962
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
4963

4964
"use strict";
4965

4966
var $ = __w_pdfjs_require__(9);
4967
var aFunction = __w_pdfjs_require__(79);
4968
var getBuiltIn = __w_pdfjs_require__(41);
4969
var newPromiseCapabilityModule = __w_pdfjs_require__(101);
4970
var perform = __w_pdfjs_require__(103);
4971
var iterate = __w_pdfjs_require__(76);
4972
var PROMISE_ANY_ERROR = 'No one promise resolved';
4973
$({
4974
 target: 'Promise',
4975
 stat: true
4976
}, {
4977
 any: function any(iterable) {
4978
  var C = this;
4979
  var capability = newPromiseCapabilityModule.f(C);
4980
  var resolve = capability.resolve;
4981
  var reject = capability.reject;
4982
  var result = perform(function () {
4983
   var promiseResolve = aFunction(C.resolve);
4984
   var errors = [];
4985
   var counter = 0;
4986
   var remaining = 1;
4987
   var alreadyResolved = false;
4988
   iterate(iterable, function (promise) {
4989
    var index = counter++;
4990
    var alreadyRejected = false;
4991
    errors.push(undefined);
4992
    remaining++;
4993
    promiseResolve.call(C, promise).then(function (value) {
4994
     if (alreadyRejected || alreadyResolved)
4995
      return;
4996
     alreadyResolved = true;
4997
     resolve(value);
4998
    }, function (error) {
4999
     if (alreadyRejected || alreadyResolved)
5000
      return;
5001
     alreadyRejected = true;
5002
     errors[index] = error;
5003
     --remaining || reject(new (getBuiltIn('AggregateError'))(errors, PROMISE_ANY_ERROR));
5004
    });
5005
   });
5006
   --remaining || reject(new (getBuiltIn('AggregateError'))(errors, PROMISE_ANY_ERROR));
5007
  });
5008
  if (result.error)
5009
   reject(result.value);
5010
  return capability.promise;
5011
 }
5012
});
5013

5014
/***/ }),
5015
/* 106 */
5016
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
5017

5018
"use strict";
5019

5020
var $ = __w_pdfjs_require__(9);
5021
var IS_PURE = __w_pdfjs_require__(36);
5022
var NativePromise = __w_pdfjs_require__(90);
5023
var fails = __w_pdfjs_require__(13);
5024
var getBuiltIn = __w_pdfjs_require__(41);
5025
var speciesConstructor = __w_pdfjs_require__(95);
5026
var promiseResolve = __w_pdfjs_require__(100);
5027
var redefine = __w_pdfjs_require__(28);
5028
var NON_GENERIC = !!NativePromise && fails(function () {
5029
 NativePromise.prototype['finally'].call({
5030
  then: function () {
5031
  }
5032
 }, function () {
5033
 });
5034
});
5035
$({
5036
 target: 'Promise',
5037
 proto: true,
5038
 real: true,
5039
 forced: NON_GENERIC
5040
}, {
5041
 'finally': function (onFinally) {
5042
  var C = speciesConstructor(this, getBuiltIn('Promise'));
5043
  var isFunction = typeof onFinally == 'function';
5044
  return this.then(isFunction ? function (x) {
5045
   return promiseResolve(C, onFinally()).then(function () {
5046
    return x;
5047
   });
5048
  } : onFinally, isFunction ? function (e) {
5049
   return promiseResolve(C, onFinally()).then(function () {
5050
    throw e;
5051
   });
5052
  } : onFinally);
5053
 }
5054
});
5055
if (!IS_PURE && typeof NativePromise == 'function' && !NativePromise.prototype['finally']) {
5056
 redefine(NativePromise.prototype, 'finally', getBuiltIn('Promise').prototype['finally']);
5057
}
5058

5059
/***/ }),
5060
/* 107 */
5061
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
5062

5063
"use strict";
5064

5065
var charAt = __w_pdfjs_require__(108).charAt;
5066
var InternalStateModule = __w_pdfjs_require__(32);
5067
var defineIterator = __w_pdfjs_require__(66);
5068
var STRING_ITERATOR = 'String Iterator';
5069
var setInternalState = InternalStateModule.set;
5070
var getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);
5071
defineIterator(String, 'String', function (iterated) {
5072
 setInternalState(this, {
5073
  type: STRING_ITERATOR,
5074
  string: String(iterated),
5075
  index: 0
5076
 });
5077
}, function next() {
5078
 var state = getInternalState(this);
5079
 var string = state.string;
5080
 var index = state.index;
5081
 var point;
5082
 if (index >= string.length)
5083
  return {
5084
   value: undefined,
5085
   done: true
5086
  };
5087
 point = charAt(string, index);
5088
 state.index += point.length;
5089
 return {
5090
  value: point,
5091
  done: false
5092
 };
5093
});
5094

5095
/***/ }),
5096
/* 108 */
5097
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
5098

5099
var toInteger = __w_pdfjs_require__(47);
5100
var requireObjectCoercible = __w_pdfjs_require__(19);
5101
var createMethod = function (CONVERT_TO_STRING) {
5102
 return function ($this, pos) {
5103
  var S = String(requireObjectCoercible($this));
5104
  var position = toInteger(pos);
5105
  var size = S.length;
5106
  var first, second;
5107
  if (position < 0 || position >= size)
5108
   return CONVERT_TO_STRING ? '' : undefined;
5109
  first = S.charCodeAt(position);
5110
  return first < 0xD800 || first > 0xDBFF || position + 1 === size || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF ? CONVERT_TO_STRING ? S.charAt(position) : first : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;
5111
 };
5112
};
5113
module.exports = {
5114
 codeAt: createMethod(false),
5115
 charAt: createMethod(true)
5116
};
5117

5118
/***/ }),
5119
/* 109 */
5120
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
5121

5122
var global = __w_pdfjs_require__(10);
5123
var DOMIterables = __w_pdfjs_require__(110);
5124
var ArrayIteratorMethods = __w_pdfjs_require__(53);
5125
var createNonEnumerableProperty = __w_pdfjs_require__(25);
5126
var wellKnownSymbol = __w_pdfjs_require__(55);
5127
var ITERATOR = wellKnownSymbol('iterator');
5128
var TO_STRING_TAG = wellKnownSymbol('toStringTag');
5129
var ArrayValues = ArrayIteratorMethods.values;
5130
for (var COLLECTION_NAME in DOMIterables) {
5131
 var Collection = global[COLLECTION_NAME];
5132
 var CollectionPrototype = Collection && Collection.prototype;
5133
 if (CollectionPrototype) {
5134
  if (CollectionPrototype[ITERATOR] !== ArrayValues)
5135
   try {
5136
    createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);
5137
   } catch (error) {
5138
    CollectionPrototype[ITERATOR] = ArrayValues;
5139
   }
5140
  if (!CollectionPrototype[TO_STRING_TAG]) {
5141
   createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);
5142
  }
5143
  if (DOMIterables[COLLECTION_NAME])
5144
   for (var METHOD_NAME in ArrayIteratorMethods) {
5145
    if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME])
5146
     try {
5147
      createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);
5148
     } catch (error) {
5149
      CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];
5150
     }
5151
   }
5152
 }
5153
}
5154

5155
/***/ }),
5156
/* 110 */
5157
/***/ ((module) => {
5158

5159
module.exports = {
5160
 CSSRuleList: 0,
5161
 CSSStyleDeclaration: 0,
5162
 CSSValueList: 0,
5163
 ClientRectList: 0,
5164
 DOMRectList: 0,
5165
 DOMStringList: 0,
5166
 DOMTokenList: 1,
5167
 DataTransferItemList: 0,
5168
 FileList: 0,
5169
 HTMLAllCollection: 0,
5170
 HTMLCollection: 0,
5171
 HTMLFormElement: 0,
5172
 HTMLSelectElement: 0,
5173
 MediaList: 0,
5174
 MimeTypeArray: 0,
5175
 NamedNodeMap: 0,
5176
 NodeList: 1,
5177
 PaintRequestList: 0,
5178
 Plugin: 0,
5179
 PluginArray: 0,
5180
 SVGLengthList: 0,
5181
 SVGNumberList: 0,
5182
 SVGPathSegList: 0,
5183
 SVGPointList: 0,
5184
 SVGStringList: 0,
5185
 SVGTransformList: 0,
5186
 SourceBufferList: 0,
5187
 StyleSheetList: 0,
5188
 TextTrackCueList: 0,
5189
 TextTrackList: 0,
5190
 TouchList: 0
5191
};
5192

5193
/***/ }),
5194
/* 111 */
5195
/***/ (function(__unused_webpack_module, exports) {
5196

5197
(function (global, factory) {
5198
  true ? factory(exports) : 0;
5199
}(this, function (exports) {
5200
 'use strict';
5201
 var SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ? Symbol : function (description) {
5202
  return "Symbol(" + description + ")";
5203
 };
5204
 function noop() {
5205
 }
5206
 function getGlobals() {
5207
  if (typeof self !== 'undefined') {
5208
   return self;
5209
  } else if (typeof window !== 'undefined') {
5210
   return window;
5211
  } else if (typeof global !== 'undefined') {
5212
   return global;
5213
  }
5214
  return undefined;
5215
 }
5216
 var globals = getGlobals();
5217
 function typeIsObject(x) {
5218
  return typeof x === 'object' && x !== null || typeof x === 'function';
5219
 }
5220
 var rethrowAssertionErrorRejection = noop;
5221
 var originalPromise = Promise;
5222
 var originalPromiseThen = Promise.prototype.then;
5223
 var originalPromiseResolve = Promise.resolve.bind(originalPromise);
5224
 var originalPromiseReject = Promise.reject.bind(originalPromise);
5225
 function newPromise(executor) {
5226
  return new originalPromise(executor);
5227
 }
5228
 function promiseResolvedWith(value) {
5229
  return originalPromiseResolve(value);
5230
 }
5231
 function promiseRejectedWith(reason) {
5232
  return originalPromiseReject(reason);
5233
 }
5234
 function PerformPromiseThen(promise, onFulfilled, onRejected) {
5235
  return originalPromiseThen.call(promise, onFulfilled, onRejected);
5236
 }
5237
 function uponPromise(promise, onFulfilled, onRejected) {
5238
  PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), undefined, rethrowAssertionErrorRejection);
5239
 }
5240
 function uponFulfillment(promise, onFulfilled) {
5241
  uponPromise(promise, onFulfilled);
5242
 }
5243
 function uponRejection(promise, onRejected) {
5244
  uponPromise(promise, undefined, onRejected);
5245
 }
5246
 function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {
5247
  return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);
5248
 }
5249
 function setPromiseIsHandledToTrue(promise) {
5250
  PerformPromiseThen(promise, undefined, rethrowAssertionErrorRejection);
5251
 }
5252
 var queueMicrotask = function () {
5253
  var globalQueueMicrotask = globals && globals.queueMicrotask;
5254
  if (typeof globalQueueMicrotask === 'function') {
5255
   return globalQueueMicrotask;
5256
  }
5257
  var resolvedPromise = promiseResolvedWith(undefined);
5258
  return function (fn) {
5259
   return PerformPromiseThen(resolvedPromise, fn);
5260
  };
5261
 }();
5262
 function reflectCall(F, V, args) {
5263
  if (typeof F !== 'function') {
5264
   throw new TypeError('Argument is not a function');
5265
  }
5266
  return Function.prototype.apply.call(F, V, args);
5267
 }
5268
 function promiseCall(F, V, args) {
5269
  try {
5270
   return promiseResolvedWith(reflectCall(F, V, args));
5271
  } catch (value) {
5272
   return promiseRejectedWith(value);
5273
  }
5274
 }
5275
 var QUEUE_MAX_ARRAY_SIZE = 16384;
5276
 var SimpleQueue = function () {
5277
  function SimpleQueue() {
5278
   this._cursor = 0;
5279
   this._size = 0;
5280
   this._front = {
5281
    _elements: [],
5282
    _next: undefined
5283
   };
5284
   this._back = this._front;
5285
   this._cursor = 0;
5286
   this._size = 0;
5287
  }
5288
  Object.defineProperty(SimpleQueue.prototype, "length", {
5289
   get: function () {
5290
    return this._size;
5291
   },
5292
   enumerable: false,
5293
   configurable: true
5294
  });
5295
  SimpleQueue.prototype.push = function (element) {
5296
   var oldBack = this._back;
5297
   var newBack = oldBack;
5298
   if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) {
5299
    newBack = {
5300
     _elements: [],
5301
     _next: undefined
5302
    };
5303
   }
5304
   oldBack._elements.push(element);
5305
   if (newBack !== oldBack) {
5306
    this._back = newBack;
5307
    oldBack._next = newBack;
5308
   }
5309
   ++this._size;
5310
  };
5311
  SimpleQueue.prototype.shift = function () {
5312
   var oldFront = this._front;
5313
   var newFront = oldFront;
5314
   var oldCursor = this._cursor;
5315
   var newCursor = oldCursor + 1;
5316
   var elements = oldFront._elements;
5317
   var element = elements[oldCursor];
5318
   if (newCursor === QUEUE_MAX_ARRAY_SIZE) {
5319
    newFront = oldFront._next;
5320
    newCursor = 0;
5321
   }
5322
   --this._size;
5323
   this._cursor = newCursor;
5324
   if (oldFront !== newFront) {
5325
    this._front = newFront;
5326
   }
5327
   elements[oldCursor] = undefined;
5328
   return element;
5329
  };
5330
  SimpleQueue.prototype.forEach = function (callback) {
5331
   var i = this._cursor;
5332
   var node = this._front;
5333
   var elements = node._elements;
5334
   while (i !== elements.length || node._next !== undefined) {
5335
    if (i === elements.length) {
5336
     node = node._next;
5337
     elements = node._elements;
5338
     i = 0;
5339
     if (elements.length === 0) {
5340
      break;
5341
     }
5342
    }
5343
    callback(elements[i]);
5344
    ++i;
5345
   }
5346
  };
5347
  SimpleQueue.prototype.peek = function () {
5348
   var front = this._front;
5349
   var cursor = this._cursor;
5350
   return front._elements[cursor];
5351
  };
5352
  return SimpleQueue;
5353
 }();
5354
 function ReadableStreamReaderGenericInitialize(reader, stream) {
5355
  reader._ownerReadableStream = stream;
5356
  stream._reader = reader;
5357
  if (stream._state === 'readable') {
5358
   defaultReaderClosedPromiseInitialize(reader);
5359
  } else if (stream._state === 'closed') {
5360
   defaultReaderClosedPromiseInitializeAsResolved(reader);
5361
  } else {
5362
   defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
5363
  }
5364
 }
5365
 function ReadableStreamReaderGenericCancel(reader, reason) {
5366
  var stream = reader._ownerReadableStream;
5367
  return ReadableStreamCancel(stream, reason);
5368
 }
5369
 function ReadableStreamReaderGenericRelease(reader) {
5370
  if (reader._ownerReadableStream._state === 'readable') {
5371
   defaultReaderClosedPromiseReject(reader, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness"));
5372
  } else {
5373
   defaultReaderClosedPromiseResetToRejected(reader, new TypeError("Reader was released and can no longer be used to monitor the stream's closedness"));
5374
  }
5375
  reader._ownerReadableStream._reader = undefined;
5376
  reader._ownerReadableStream = undefined;
5377
 }
5378
 function readerLockException(name) {
5379
  return new TypeError('Cannot ' + name + ' a stream using a released reader');
5380
 }
5381
 function defaultReaderClosedPromiseInitialize(reader) {
5382
  reader._closedPromise = newPromise(function (resolve, reject) {
5383
   reader._closedPromise_resolve = resolve;
5384
   reader._closedPromise_reject = reject;
5385
  });
5386
 }
5387
 function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
5388
  defaultReaderClosedPromiseInitialize(reader);
5389
  defaultReaderClosedPromiseReject(reader, reason);
5390
 }
5391
 function defaultReaderClosedPromiseInitializeAsResolved(reader) {
5392
  defaultReaderClosedPromiseInitialize(reader);
5393
  defaultReaderClosedPromiseResolve(reader);
5394
 }
5395
 function defaultReaderClosedPromiseReject(reader, reason) {
5396
  if (reader._closedPromise_reject === undefined) {
5397
   return;
5398
  }
5399
  setPromiseIsHandledToTrue(reader._closedPromise);
5400
  reader._closedPromise_reject(reason);
5401
  reader._closedPromise_resolve = undefined;
5402
  reader._closedPromise_reject = undefined;
5403
 }
5404
 function defaultReaderClosedPromiseResetToRejected(reader, reason) {
5405
  defaultReaderClosedPromiseInitializeAsRejected(reader, reason);
5406
 }
5407
 function defaultReaderClosedPromiseResolve(reader) {
5408
  if (reader._closedPromise_resolve === undefined) {
5409
   return;
5410
  }
5411
  reader._closedPromise_resolve(undefined);
5412
  reader._closedPromise_resolve = undefined;
5413
  reader._closedPromise_reject = undefined;
5414
 }
5415
 var AbortSteps = SymbolPolyfill('[[AbortSteps]]');
5416
 var ErrorSteps = SymbolPolyfill('[[ErrorSteps]]');
5417
 var CancelSteps = SymbolPolyfill('[[CancelSteps]]');
5418
 var PullSteps = SymbolPolyfill('[[PullSteps]]');
5419
 var NumberIsFinite = Number.isFinite || function (x) {
5420
  return typeof x === 'number' && isFinite(x);
5421
 };
5422
 var MathTrunc = Math.trunc || function (v) {
5423
  return v < 0 ? Math.ceil(v) : Math.floor(v);
5424
 };
5425
 function isDictionary(x) {
5426
  return typeof x === 'object' || typeof x === 'function';
5427
 }
5428
 function assertDictionary(obj, context) {
5429
  if (obj !== undefined && !isDictionary(obj)) {
5430
   throw new TypeError(context + " is not an object.");
5431
  }
5432
 }
5433
 function assertFunction(x, context) {
5434
  if (typeof x !== 'function') {
5435
   throw new TypeError(context + " is not a function.");
5436
  }
5437
 }
5438
 function isObject(x) {
5439
  return typeof x === 'object' && x !== null || typeof x === 'function';
5440
 }
5441
 function assertObject(x, context) {
5442
  if (!isObject(x)) {
5443
   throw new TypeError(context + " is not an object.");
5444
  }
5445
 }
5446
 function assertRequiredArgument(x, position, context) {
5447
  if (x === undefined) {
5448
   throw new TypeError("Parameter " + position + " is required in '" + context + "'.");
5449
  }
5450
 }
5451
 function assertRequiredField(x, field, context) {
5452
  if (x === undefined) {
5453
   throw new TypeError(field + " is required in '" + context + "'.");
5454
  }
5455
 }
5456
 function convertUnrestrictedDouble(value) {
5457
  return Number(value);
5458
 }
5459
 function censorNegativeZero(x) {
5460
  return x === 0 ? 0 : x;
5461
 }
5462
 function integerPart(x) {
5463
  return censorNegativeZero(MathTrunc(x));
5464
 }
5465
 function convertUnsignedLongLongWithEnforceRange(value, context) {
5466
  var lowerBound = 0;
5467
  var upperBound = Number.MAX_SAFE_INTEGER;
5468
  var x = Number(value);
5469
  x = censorNegativeZero(x);
5470
  if (!NumberIsFinite(x)) {
5471
   throw new TypeError(context + " is not a finite number");
5472
  }
5473
  x = integerPart(x);
5474
  if (x < lowerBound || x > upperBound) {
5475
   throw new TypeError(context + " is outside the accepted range of " + lowerBound + " to " + upperBound + ", inclusive");
5476
  }
5477
  if (!NumberIsFinite(x) || x === 0) {
5478
   return 0;
5479
  }
5480
  return x;
5481
 }
5482
 function assertReadableStream(x, context) {
5483
  if (!IsReadableStream(x)) {
5484
   throw new TypeError(context + " is not a ReadableStream.");
5485
  }
5486
 }
5487
 function AcquireReadableStreamDefaultReader(stream) {
5488
  return new ReadableStreamDefaultReader(stream);
5489
 }
5490
 function ReadableStreamAddReadRequest(stream, readRequest) {
5491
  stream._reader._readRequests.push(readRequest);
5492
 }
5493
 function ReadableStreamFulfillReadRequest(stream, chunk, done) {
5494
  var reader = stream._reader;
5495
  var readRequest = reader._readRequests.shift();
5496
  if (done) {
5497
   readRequest._closeSteps();
5498
  } else {
5499
   readRequest._chunkSteps(chunk);
5500
  }
5501
 }
5502
 function ReadableStreamGetNumReadRequests(stream) {
5503
  return stream._reader._readRequests.length;
5504
 }
5505
 function ReadableStreamHasDefaultReader(stream) {
5506
  var reader = stream._reader;
5507
  if (reader === undefined) {
5508
   return false;
5509
  }
5510
  if (!IsReadableStreamDefaultReader(reader)) {
5511
   return false;
5512
  }
5513
  return true;
5514
 }
5515
 var ReadableStreamDefaultReader = function () {
5516
  function ReadableStreamDefaultReader(stream) {
5517
   assertRequiredArgument(stream, 1, 'ReadableStreamDefaultReader');
5518
   assertReadableStream(stream, 'First parameter');
5519
   if (IsReadableStreamLocked(stream)) {
5520
    throw new TypeError('This stream has already been locked for exclusive reading by another reader');
5521
   }
5522
   ReadableStreamReaderGenericInitialize(this, stream);
5523
   this._readRequests = new SimpleQueue();
5524
  }
5525
  Object.defineProperty(ReadableStreamDefaultReader.prototype, "closed", {
5526
   get: function () {
5527
    if (!IsReadableStreamDefaultReader(this)) {
5528
     return promiseRejectedWith(defaultReaderBrandCheckException('closed'));
5529
    }
5530
    return this._closedPromise;
5531
   },
5532
   enumerable: false,
5533
   configurable: true
5534
  });
5535
  ReadableStreamDefaultReader.prototype.cancel = function (reason) {
5536
   if (reason === void 0) {
5537
    reason = undefined;
5538
   }
5539
   if (!IsReadableStreamDefaultReader(this)) {
5540
    return promiseRejectedWith(defaultReaderBrandCheckException('cancel'));
5541
   }
5542
   if (this._ownerReadableStream === undefined) {
5543
    return promiseRejectedWith(readerLockException('cancel'));
5544
   }
5545
   return ReadableStreamReaderGenericCancel(this, reason);
5546
  };
5547
  ReadableStreamDefaultReader.prototype.read = function () {
5548
   if (!IsReadableStreamDefaultReader(this)) {
5549
    return promiseRejectedWith(defaultReaderBrandCheckException('read'));
5550
   }
5551
   if (this._ownerReadableStream === undefined) {
5552
    return promiseRejectedWith(readerLockException('read from'));
5553
   }
5554
   var resolvePromise;
5555
   var rejectPromise;
5556
   var promise = newPromise(function (resolve, reject) {
5557
    resolvePromise = resolve;
5558
    rejectPromise = reject;
5559
   });
5560
   var readRequest = {
5561
    _chunkSteps: function (chunk) {
5562
     return resolvePromise({
5563
      value: chunk,
5564
      done: false
5565
     });
5566
    },
5567
    _closeSteps: function () {
5568
     return resolvePromise({
5569
      value: undefined,
5570
      done: true
5571
     });
5572
    },
5573
    _errorSteps: function (e) {
5574
     return rejectPromise(e);
5575
    }
5576
   };
5577
   ReadableStreamDefaultReaderRead(this, readRequest);
5578
   return promise;
5579
  };
5580
  ReadableStreamDefaultReader.prototype.releaseLock = function () {
5581
   if (!IsReadableStreamDefaultReader(this)) {
5582
    throw defaultReaderBrandCheckException('releaseLock');
5583
   }
5584
   if (this._ownerReadableStream === undefined) {
5585
    return;
5586
   }
5587
   if (this._readRequests.length > 0) {
5588
    throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
5589
   }
5590
   ReadableStreamReaderGenericRelease(this);
5591
  };
5592
  return ReadableStreamDefaultReader;
5593
 }();
5594
 Object.defineProperties(ReadableStreamDefaultReader.prototype, {
5595
  cancel: { enumerable: true },
5596
  read: { enumerable: true },
5597
  releaseLock: { enumerable: true },
5598
  closed: { enumerable: true }
5599
 });
5600
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
5601
  Object.defineProperty(ReadableStreamDefaultReader.prototype, SymbolPolyfill.toStringTag, {
5602
   value: 'ReadableStreamDefaultReader',
5603
   configurable: true
5604
  });
5605
 }
5606
 function IsReadableStreamDefaultReader(x) {
5607
  if (!typeIsObject(x)) {
5608
   return false;
5609
  }
5610
  if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
5611
   return false;
5612
  }
5613
  return true;
5614
 }
5615
 function ReadableStreamDefaultReaderRead(reader, readRequest) {
5616
  var stream = reader._ownerReadableStream;
5617
  stream._disturbed = true;
5618
  if (stream._state === 'closed') {
5619
   readRequest._closeSteps();
5620
  } else if (stream._state === 'errored') {
5621
   readRequest._errorSteps(stream._storedError);
5622
  } else {
5623
   stream._readableStreamController[PullSteps](readRequest);
5624
  }
5625
 }
5626
 function defaultReaderBrandCheckException(name) {
5627
  return new TypeError("ReadableStreamDefaultReader.prototype." + name + " can only be used on a ReadableStreamDefaultReader");
5628
 }
5629
 var _a;
5630
 var AsyncIteratorPrototype;
5631
 if (typeof SymbolPolyfill.asyncIterator === 'symbol') {
5632
  AsyncIteratorPrototype = (_a = {}, _a[SymbolPolyfill.asyncIterator] = function () {
5633
   return this;
5634
  }, _a);
5635
  Object.defineProperty(AsyncIteratorPrototype, SymbolPolyfill.asyncIterator, { enumerable: false });
5636
 }
5637
 var ReadableStreamAsyncIteratorImpl = function () {
5638
  function ReadableStreamAsyncIteratorImpl(reader, preventCancel) {
5639
   this._ongoingPromise = undefined;
5640
   this._isFinished = false;
5641
   this._reader = reader;
5642
   this._preventCancel = preventCancel;
5643
  }
5644
  ReadableStreamAsyncIteratorImpl.prototype.next = function () {
5645
   var _this = this;
5646
   var nextSteps = function () {
5647
    return _this._nextSteps();
5648
   };
5649
   this._ongoingPromise = this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, nextSteps, nextSteps) : nextSteps();
5650
   return this._ongoingPromise;
5651
  };
5652
  ReadableStreamAsyncIteratorImpl.prototype.return = function (value) {
5653
   var _this = this;
5654
   var returnSteps = function () {
5655
    return _this._returnSteps(value);
5656
   };
5657
   return this._ongoingPromise ? transformPromiseWith(this._ongoingPromise, returnSteps, returnSteps) : returnSteps();
5658
  };
5659
  ReadableStreamAsyncIteratorImpl.prototype._nextSteps = function () {
5660
   var _this = this;
5661
   if (this._isFinished) {
5662
    return Promise.resolve({
5663
     value: undefined,
5664
     done: true
5665
    });
5666
   }
5667
   var reader = this._reader;
5668
   if (reader._ownerReadableStream === undefined) {
5669
    return promiseRejectedWith(readerLockException('iterate'));
5670
   }
5671
   var resolvePromise;
5672
   var rejectPromise;
5673
   var promise = newPromise(function (resolve, reject) {
5674
    resolvePromise = resolve;
5675
    rejectPromise = reject;
5676
   });
5677
   var readRequest = {
5678
    _chunkSteps: function (chunk) {
5679
     _this._ongoingPromise = undefined;
5680
     queueMicrotask(function () {
5681
      return resolvePromise({
5682
       value: chunk,
5683
       done: false
5684
      });
5685
     });
5686
    },
5687
    _closeSteps: function () {
5688
     _this._ongoingPromise = undefined;
5689
     _this._isFinished = true;
5690
     ReadableStreamReaderGenericRelease(reader);
5691
     resolvePromise({
5692
      value: undefined,
5693
      done: true
5694
     });
5695
    },
5696
    _errorSteps: function (reason) {
5697
     _this._ongoingPromise = undefined;
5698
     _this._isFinished = true;
5699
     ReadableStreamReaderGenericRelease(reader);
5700
     rejectPromise(reason);
5701
    }
5702
   };
5703
   ReadableStreamDefaultReaderRead(reader, readRequest);
5704
   return promise;
5705
  };
5706
  ReadableStreamAsyncIteratorImpl.prototype._returnSteps = function (value) {
5707
   if (this._isFinished) {
5708
    return Promise.resolve({
5709
     value: value,
5710
     done: true
5711
    });
5712
   }
5713
   this._isFinished = true;
5714
   var reader = this._reader;
5715
   if (reader._ownerReadableStream === undefined) {
5716
    return promiseRejectedWith(readerLockException('finish iterating'));
5717
   }
5718
   if (!this._preventCancel) {
5719
    var result = ReadableStreamReaderGenericCancel(reader, value);
5720
    ReadableStreamReaderGenericRelease(reader);
5721
    return transformPromiseWith(result, function () {
5722
     return {
5723
      value: value,
5724
      done: true
5725
     };
5726
    });
5727
   }
5728
   ReadableStreamReaderGenericRelease(reader);
5729
   return promiseResolvedWith({
5730
    value: value,
5731
    done: true
5732
   });
5733
  };
5734
  return ReadableStreamAsyncIteratorImpl;
5735
 }();
5736
 var ReadableStreamAsyncIteratorPrototype = {
5737
  next: function () {
5738
   if (!IsReadableStreamAsyncIterator(this)) {
5739
    return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next'));
5740
   }
5741
   return this._asyncIteratorImpl.next();
5742
  },
5743
  return: function (value) {
5744
   if (!IsReadableStreamAsyncIterator(this)) {
5745
    return promiseRejectedWith(streamAsyncIteratorBrandCheckException('return'));
5746
   }
5747
   return this._asyncIteratorImpl.return(value);
5748
  }
5749
 };
5750
 if (AsyncIteratorPrototype !== undefined) {
5751
  Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);
5752
 }
5753
 function AcquireReadableStreamAsyncIterator(stream, preventCancel) {
5754
  var reader = AcquireReadableStreamDefaultReader(stream);
5755
  var impl = new ReadableStreamAsyncIteratorImpl(reader, preventCancel);
5756
  var iterator = Object.create(ReadableStreamAsyncIteratorPrototype);
5757
  iterator._asyncIteratorImpl = impl;
5758
  return iterator;
5759
 }
5760
 function IsReadableStreamAsyncIterator(x) {
5761
  if (!typeIsObject(x)) {
5762
   return false;
5763
  }
5764
  if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorImpl')) {
5765
   return false;
5766
  }
5767
  return true;
5768
 }
5769
 function streamAsyncIteratorBrandCheckException(name) {
5770
  return new TypeError("ReadableStreamAsyncIterator." + name + " can only be used on a ReadableSteamAsyncIterator");
5771
 }
5772
 var NumberIsNaN = Number.isNaN || function (x) {
5773
  return x !== x;
5774
 };
5775
 function IsFiniteNonNegativeNumber(v) {
5776
  if (!IsNonNegativeNumber(v)) {
5777
   return false;
5778
  }
5779
  if (v === Infinity) {
5780
   return false;
5781
  }
5782
  return true;
5783
 }
5784
 function IsNonNegativeNumber(v) {
5785
  if (typeof v !== 'number') {
5786
   return false;
5787
  }
5788
  if (NumberIsNaN(v)) {
5789
   return false;
5790
  }
5791
  if (v < 0) {
5792
   return false;
5793
  }
5794
  return true;
5795
 }
5796
 function DequeueValue(container) {
5797
  var pair = container._queue.shift();
5798
  container._queueTotalSize -= pair.size;
5799
  if (container._queueTotalSize < 0) {
5800
   container._queueTotalSize = 0;
5801
  }
5802
  return pair.value;
5803
 }
5804
 function EnqueueValueWithSize(container, value, size) {
5805
  size = Number(size);
5806
  if (!IsFiniteNonNegativeNumber(size)) {
5807
   throw new RangeError('Size must be a finite, non-NaN, non-negative number.');
5808
  }
5809
  container._queue.push({
5810
   value: value,
5811
   size: size
5812
  });
5813
  container._queueTotalSize += size;
5814
 }
5815
 function PeekQueueValue(container) {
5816
  var pair = container._queue.peek();
5817
  return pair.value;
5818
 }
5819
 function ResetQueue(container) {
5820
  container._queue = new SimpleQueue();
5821
  container._queueTotalSize = 0;
5822
 }
5823
 function CreateArrayFromList(elements) {
5824
  return elements.slice();
5825
 }
5826
 function CopyDataBlockBytes(dest, destOffset, src, srcOffset, n) {
5827
  new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
5828
 }
5829
 function TransferArrayBuffer(O) {
5830
  return O;
5831
 }
5832
 function IsDetachedBuffer(O) {
5833
  return false;
5834
 }
5835
 var ReadableStreamBYOBRequest = function () {
5836
  function ReadableStreamBYOBRequest() {
5837
   throw new TypeError('Illegal constructor');
5838
  }
5839
  Object.defineProperty(ReadableStreamBYOBRequest.prototype, "view", {
5840
   get: function () {
5841
    if (!IsReadableStreamBYOBRequest(this)) {
5842
     throw byobRequestBrandCheckException('view');
5843
    }
5844
    return this._view;
5845
   },
5846
   enumerable: false,
5847
   configurable: true
5848
  });
5849
  ReadableStreamBYOBRequest.prototype.respond = function (bytesWritten) {
5850
   if (!IsReadableStreamBYOBRequest(this)) {
5851
    throw byobRequestBrandCheckException('respond');
5852
   }
5853
   assertRequiredArgument(bytesWritten, 1, 'respond');
5854
   bytesWritten = convertUnsignedLongLongWithEnforceRange(bytesWritten, 'First parameter');
5855
   if (this._associatedReadableByteStreamController === undefined) {
5856
    throw new TypeError('This BYOB request has been invalidated');
5857
   }
5858
   if (IsDetachedBuffer(this._view.buffer));
5859
   ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
5860
  };
5861
  ReadableStreamBYOBRequest.prototype.respondWithNewView = function (view) {
5862
   if (!IsReadableStreamBYOBRequest(this)) {
5863
    throw byobRequestBrandCheckException('respondWithNewView');
5864
   }
5865
   assertRequiredArgument(view, 1, 'respondWithNewView');
5866
   if (!ArrayBuffer.isView(view)) {
5867
    throw new TypeError('You can only respond with array buffer views');
5868
   }
5869
   if (view.byteLength === 0) {
5870
    throw new TypeError('chunk must have non-zero byteLength');
5871
   }
5872
   if (view.buffer.byteLength === 0) {
5873
    throw new TypeError("chunk's buffer must have non-zero byteLength");
5874
   }
5875
   if (this._associatedReadableByteStreamController === undefined) {
5876
    throw new TypeError('This BYOB request has been invalidated');
5877
   }
5878
   ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
5879
  };
5880
  return ReadableStreamBYOBRequest;
5881
 }();
5882
 Object.defineProperties(ReadableStreamBYOBRequest.prototype, {
5883
  respond: { enumerable: true },
5884
  respondWithNewView: { enumerable: true },
5885
  view: { enumerable: true }
5886
 });
5887
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
5888
  Object.defineProperty(ReadableStreamBYOBRequest.prototype, SymbolPolyfill.toStringTag, {
5889
   value: 'ReadableStreamBYOBRequest',
5890
   configurable: true
5891
  });
5892
 }
5893
 var ReadableByteStreamController = function () {
5894
  function ReadableByteStreamController() {
5895
   throw new TypeError('Illegal constructor');
5896
  }
5897
  Object.defineProperty(ReadableByteStreamController.prototype, "byobRequest", {
5898
   get: function () {
5899
    if (!IsReadableByteStreamController(this)) {
5900
     throw byteStreamControllerBrandCheckException('byobRequest');
5901
    }
5902
    if (this._byobRequest === null && this._pendingPullIntos.length > 0) {
5903
     var firstDescriptor = this._pendingPullIntos.peek();
5904
     var view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
5905
     var byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);
5906
     SetUpReadableStreamBYOBRequest(byobRequest, this, view);
5907
     this._byobRequest = byobRequest;
5908
    }
5909
    return this._byobRequest;
5910
   },
5911
   enumerable: false,
5912
   configurable: true
5913
  });
5914
  Object.defineProperty(ReadableByteStreamController.prototype, "desiredSize", {
5915
   get: function () {
5916
    if (!IsReadableByteStreamController(this)) {
5917
     throw byteStreamControllerBrandCheckException('desiredSize');
5918
    }
5919
    return ReadableByteStreamControllerGetDesiredSize(this);
5920
   },
5921
   enumerable: false,
5922
   configurable: true
5923
  });
5924
  ReadableByteStreamController.prototype.close = function () {
5925
   if (!IsReadableByteStreamController(this)) {
5926
    throw byteStreamControllerBrandCheckException('close');
5927
   }
5928
   if (this._closeRequested) {
5929
    throw new TypeError('The stream has already been closed; do not close it again!');
5930
   }
5931
   var state = this._controlledReadableByteStream._state;
5932
   if (state !== 'readable') {
5933
    throw new TypeError("The stream (in " + state + " state) is not in the readable state and cannot be closed");
5934
   }
5935
   ReadableByteStreamControllerClose(this);
5936
  };
5937
  ReadableByteStreamController.prototype.enqueue = function (chunk) {
5938
   if (!IsReadableByteStreamController(this)) {
5939
    throw byteStreamControllerBrandCheckException('enqueue');
5940
   }
5941
   assertRequiredArgument(chunk, 1, 'enqueue');
5942
   if (!ArrayBuffer.isView(chunk)) {
5943
    throw new TypeError('chunk must be an array buffer view');
5944
   }
5945
   if (chunk.byteLength === 0) {
5946
    throw new TypeError('chunk must have non-zero byteLength');
5947
   }
5948
   if (chunk.buffer.byteLength === 0) {
5949
    throw new TypeError("chunk's buffer must have non-zero byteLength");
5950
   }
5951
   if (this._closeRequested) {
5952
    throw new TypeError('stream is closed or draining');
5953
   }
5954
   var state = this._controlledReadableByteStream._state;
5955
   if (state !== 'readable') {
5956
    throw new TypeError("The stream (in " + state + " state) is not in the readable state and cannot be enqueued to");
5957
   }
5958
   ReadableByteStreamControllerEnqueue(this, chunk);
5959
  };
5960
  ReadableByteStreamController.prototype.error = function (e) {
5961
   if (e === void 0) {
5962
    e = undefined;
5963
   }
5964
   if (!IsReadableByteStreamController(this)) {
5965
    throw byteStreamControllerBrandCheckException('error');
5966
   }
5967
   ReadableByteStreamControllerError(this, e);
5968
  };
5969
  ReadableByteStreamController.prototype[CancelSteps] = function (reason) {
5970
   if (this._pendingPullIntos.length > 0) {
5971
    var firstDescriptor = this._pendingPullIntos.peek();
5972
    firstDescriptor.bytesFilled = 0;
5973
   }
5974
   ResetQueue(this);
5975
   var result = this._cancelAlgorithm(reason);
5976
   ReadableByteStreamControllerClearAlgorithms(this);
5977
   return result;
5978
  };
5979
  ReadableByteStreamController.prototype[PullSteps] = function (readRequest) {
5980
   var stream = this._controlledReadableByteStream;
5981
   if (this._queueTotalSize > 0) {
5982
    var entry = this._queue.shift();
5983
    this._queueTotalSize -= entry.byteLength;
5984
    ReadableByteStreamControllerHandleQueueDrain(this);
5985
    var view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
5986
    readRequest._chunkSteps(view);
5987
    return;
5988
   }
5989
   var autoAllocateChunkSize = this._autoAllocateChunkSize;
5990
   if (autoAllocateChunkSize !== undefined) {
5991
    var buffer = void 0;
5992
    try {
5993
     buffer = new ArrayBuffer(autoAllocateChunkSize);
5994
    } catch (bufferE) {
5995
     readRequest._errorSteps(bufferE);
5996
     return;
5997
    }
5998
    var pullIntoDescriptor = {
5999
     buffer: buffer,
6000
     byteOffset: 0,
6001
     byteLength: autoAllocateChunkSize,
6002
     bytesFilled: 0,
6003
     elementSize: 1,
6004
     viewConstructor: Uint8Array,
6005
     readerType: 'default'
6006
    };
6007
    this._pendingPullIntos.push(pullIntoDescriptor);
6008
   }
6009
   ReadableStreamAddReadRequest(stream, readRequest);
6010
   ReadableByteStreamControllerCallPullIfNeeded(this);
6011
  };
6012
  return ReadableByteStreamController;
6013
 }();
6014
 Object.defineProperties(ReadableByteStreamController.prototype, {
6015
  close: { enumerable: true },
6016
  enqueue: { enumerable: true },
6017
  error: { enumerable: true },
6018
  byobRequest: { enumerable: true },
6019
  desiredSize: { enumerable: true }
6020
 });
6021
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
6022
  Object.defineProperty(ReadableByteStreamController.prototype, SymbolPolyfill.toStringTag, {
6023
   value: 'ReadableByteStreamController',
6024
   configurable: true
6025
  });
6026
 }
6027
 function IsReadableByteStreamController(x) {
6028
  if (!typeIsObject(x)) {
6029
   return false;
6030
  }
6031
  if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) {
6032
   return false;
6033
  }
6034
  return true;
6035
 }
6036
 function IsReadableStreamBYOBRequest(x) {
6037
  if (!typeIsObject(x)) {
6038
   return false;
6039
  }
6040
  if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {
6041
   return false;
6042
  }
6043
  return true;
6044
 }
6045
 function ReadableByteStreamControllerCallPullIfNeeded(controller) {
6046
  var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
6047
  if (!shouldPull) {
6048
   return;
6049
  }
6050
  if (controller._pulling) {
6051
   controller._pullAgain = true;
6052
   return;
6053
  }
6054
  controller._pulling = true;
6055
  var pullPromise = controller._pullAlgorithm();
6056
  uponPromise(pullPromise, function () {
6057
   controller._pulling = false;
6058
   if (controller._pullAgain) {
6059
    controller._pullAgain = false;
6060
    ReadableByteStreamControllerCallPullIfNeeded(controller);
6061
   }
6062
  }, function (e) {
6063
   ReadableByteStreamControllerError(controller, e);
6064
  });
6065
 }
6066
 function ReadableByteStreamControllerClearPendingPullIntos(controller) {
6067
  ReadableByteStreamControllerInvalidateBYOBRequest(controller);
6068
  controller._pendingPullIntos = new SimpleQueue();
6069
 }
6070
 function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
6071
  var done = false;
6072
  if (stream._state === 'closed') {
6073
   done = true;
6074
  }
6075
  var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
6076
  if (pullIntoDescriptor.readerType === 'default') {
6077
   ReadableStreamFulfillReadRequest(stream, filledView, done);
6078
  } else {
6079
   ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
6080
  }
6081
 }
6082
 function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
6083
  var bytesFilled = pullIntoDescriptor.bytesFilled;
6084
  var elementSize = pullIntoDescriptor.elementSize;
6085
  return new pullIntoDescriptor.viewConstructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);
6086
 }
6087
 function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {
6088
  controller._queue.push({
6089
   buffer: buffer,
6090
   byteOffset: byteOffset,
6091
   byteLength: byteLength
6092
  });
6093
  controller._queueTotalSize += byteLength;
6094
 }
6095
 function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
6096
  var elementSize = pullIntoDescriptor.elementSize;
6097
  var currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;
6098
  var maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
6099
  var maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
6100
  var maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;
6101
  var totalBytesToCopyRemaining = maxBytesToCopy;
6102
  var ready = false;
6103
  if (maxAlignedBytes > currentAlignedBytes) {
6104
   totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
6105
   ready = true;
6106
  }
6107
  var queue = controller._queue;
6108
  while (totalBytesToCopyRemaining > 0) {
6109
   var headOfQueue = queue.peek();
6110
   var bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);
6111
   var destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
6112
   CopyDataBlockBytes(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);
6113
   if (headOfQueue.byteLength === bytesToCopy) {
6114
    queue.shift();
6115
   } else {
6116
    headOfQueue.byteOffset += bytesToCopy;
6117
    headOfQueue.byteLength -= bytesToCopy;
6118
   }
6119
   controller._queueTotalSize -= bytesToCopy;
6120
   ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);
6121
   totalBytesToCopyRemaining -= bytesToCopy;
6122
  }
6123
  return ready;
6124
 }
6125
 function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
6126
  ReadableByteStreamControllerInvalidateBYOBRequest(controller);
6127
  pullIntoDescriptor.bytesFilled += size;
6128
 }
6129
 function ReadableByteStreamControllerHandleQueueDrain(controller) {
6130
  if (controller._queueTotalSize === 0 && controller._closeRequested) {
6131
   ReadableByteStreamControllerClearAlgorithms(controller);
6132
   ReadableStreamClose(controller._controlledReadableByteStream);
6133
  } else {
6134
   ReadableByteStreamControllerCallPullIfNeeded(controller);
6135
  }
6136
 }
6137
 function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
6138
  if (controller._byobRequest === null) {
6139
   return;
6140
  }
6141
  controller._byobRequest._associatedReadableByteStreamController = undefined;
6142
  controller._byobRequest._view = null;
6143
  controller._byobRequest = null;
6144
 }
6145
 function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
6146
  while (controller._pendingPullIntos.length > 0) {
6147
   if (controller._queueTotalSize === 0) {
6148
    return;
6149
   }
6150
   var pullIntoDescriptor = controller._pendingPullIntos.peek();
6151
   if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
6152
    ReadableByteStreamControllerShiftPendingPullInto(controller);
6153
    ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
6154
   }
6155
  }
6156
 }
6157
 function ReadableByteStreamControllerPullInto(controller, view, readIntoRequest) {
6158
  var stream = controller._controlledReadableByteStream;
6159
  var elementSize = 1;
6160
  if (view.constructor !== DataView) {
6161
   elementSize = view.constructor.BYTES_PER_ELEMENT;
6162
  }
6163
  var ctor = view.constructor;
6164
  var buffer = TransferArrayBuffer(view.buffer);
6165
  var pullIntoDescriptor = {
6166
   buffer: buffer,
6167
   byteOffset: view.byteOffset,
6168
   byteLength: view.byteLength,
6169
   bytesFilled: 0,
6170
   elementSize: elementSize,
6171
   viewConstructor: ctor,
6172
   readerType: 'byob'
6173
  };
6174
  if (controller._pendingPullIntos.length > 0) {
6175
   controller._pendingPullIntos.push(pullIntoDescriptor);
6176
   ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
6177
   return;
6178
  }
6179
  if (stream._state === 'closed') {
6180
   var emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
6181
   readIntoRequest._closeSteps(emptyView);
6182
   return;
6183
  }
6184
  if (controller._queueTotalSize > 0) {
6185
   if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor)) {
6186
    var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
6187
    ReadableByteStreamControllerHandleQueueDrain(controller);
6188
    readIntoRequest._chunkSteps(filledView);
6189
    return;
6190
   }
6191
   if (controller._closeRequested) {
6192
    var e = new TypeError('Insufficient bytes to fill elements in the given buffer');
6193
    ReadableByteStreamControllerError(controller, e);
6194
    readIntoRequest._errorSteps(e);
6195
    return;
6196
   }
6197
  }
6198
  controller._pendingPullIntos.push(pullIntoDescriptor);
6199
  ReadableStreamAddReadIntoRequest(stream, readIntoRequest);
6200
  ReadableByteStreamControllerCallPullIfNeeded(controller);
6201
 }
6202
 function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
6203
  firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
6204
  var stream = controller._controlledReadableByteStream;
6205
  if (ReadableStreamHasBYOBReader(stream)) {
6206
   while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
6207
    var pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);
6208
    ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
6209
   }
6210
  }
6211
 }
6212
 function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
6213
  if (pullIntoDescriptor.bytesFilled + bytesWritten > pullIntoDescriptor.byteLength) {
6214
   throw new RangeError('bytesWritten out of range');
6215
  }
6216
  ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
6217
  if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {
6218
   return;
6219
  }
6220
  ReadableByteStreamControllerShiftPendingPullInto(controller);
6221
  var remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
6222
  if (remainderSize > 0) {
6223
   var end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
6224
   var remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end);
6225
   ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
6226
  }
6227
  pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
6228
  pullIntoDescriptor.bytesFilled -= remainderSize;
6229
  ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);
6230
  ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
6231
 }
6232
 function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
6233
  var firstDescriptor = controller._pendingPullIntos.peek();
6234
  var state = controller._controlledReadableByteStream._state;
6235
  if (state === 'closed') {
6236
   if (bytesWritten !== 0) {
6237
    throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');
6238
   }
6239
   ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
6240
  } else {
6241
   ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
6242
  }
6243
  ReadableByteStreamControllerCallPullIfNeeded(controller);
6244
 }
6245
 function ReadableByteStreamControllerShiftPendingPullInto(controller) {
6246
  var descriptor = controller._pendingPullIntos.shift();
6247
  ReadableByteStreamControllerInvalidateBYOBRequest(controller);
6248
  return descriptor;
6249
 }
6250
 function ReadableByteStreamControllerShouldCallPull(controller) {
6251
  var stream = controller._controlledReadableByteStream;
6252
  if (stream._state !== 'readable') {
6253
   return false;
6254
  }
6255
  if (controller._closeRequested) {
6256
   return false;
6257
  }
6258
  if (!controller._started) {
6259
   return false;
6260
  }
6261
  if (ReadableStreamHasDefaultReader(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {
6262
   return true;
6263
  }
6264
  if (ReadableStreamHasBYOBReader(stream) && ReadableStreamGetNumReadIntoRequests(stream) > 0) {
6265
   return true;
6266
  }
6267
  var desiredSize = ReadableByteStreamControllerGetDesiredSize(controller);
6268
  if (desiredSize > 0) {
6269
   return true;
6270
  }
6271
  return false;
6272
 }
6273
 function ReadableByteStreamControllerClearAlgorithms(controller) {
6274
  controller._pullAlgorithm = undefined;
6275
  controller._cancelAlgorithm = undefined;
6276
 }
6277
 function ReadableByteStreamControllerClose(controller) {
6278
  var stream = controller._controlledReadableByteStream;
6279
  if (controller._closeRequested || stream._state !== 'readable') {
6280
   return;
6281
  }
6282
  if (controller._queueTotalSize > 0) {
6283
   controller._closeRequested = true;
6284
   return;
6285
  }
6286
  if (controller._pendingPullIntos.length > 0) {
6287
   var firstPendingPullInto = controller._pendingPullIntos.peek();
6288
   if (firstPendingPullInto.bytesFilled > 0) {
6289
    var e = new TypeError('Insufficient bytes to fill elements in the given buffer');
6290
    ReadableByteStreamControllerError(controller, e);
6291
    throw e;
6292
   }
6293
  }
6294
  ReadableByteStreamControllerClearAlgorithms(controller);
6295
  ReadableStreamClose(stream);
6296
 }
6297
 function ReadableByteStreamControllerEnqueue(controller, chunk) {
6298
  var stream = controller._controlledReadableByteStream;
6299
  if (controller._closeRequested || stream._state !== 'readable') {
6300
   return;
6301
  }
6302
  var buffer = chunk.buffer;
6303
  var byteOffset = chunk.byteOffset;
6304
  var byteLength = chunk.byteLength;
6305
  var transferredBuffer = TransferArrayBuffer(buffer);
6306
  if (ReadableStreamHasDefaultReader(stream)) {
6307
   if (ReadableStreamGetNumReadRequests(stream) === 0) {
6308
    ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
6309
   } else {
6310
    var transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
6311
    ReadableStreamFulfillReadRequest(stream, transferredView, false);
6312
   }
6313
  } else if (ReadableStreamHasBYOBReader(stream)) {
6314
   ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
6315
   ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
6316
  } else {
6317
   ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
6318
  }
6319
  ReadableByteStreamControllerCallPullIfNeeded(controller);
6320
 }
6321
 function ReadableByteStreamControllerError(controller, e) {
6322
  var stream = controller._controlledReadableByteStream;
6323
  if (stream._state !== 'readable') {
6324
   return;
6325
  }
6326
  ReadableByteStreamControllerClearPendingPullIntos(controller);
6327
  ResetQueue(controller);
6328
  ReadableByteStreamControllerClearAlgorithms(controller);
6329
  ReadableStreamError(stream, e);
6330
 }
6331
 function ReadableByteStreamControllerGetDesiredSize(controller) {
6332
  var state = controller._controlledReadableByteStream._state;
6333
  if (state === 'errored') {
6334
   return null;
6335
  }
6336
  if (state === 'closed') {
6337
   return 0;
6338
  }
6339
  return controller._strategyHWM - controller._queueTotalSize;
6340
 }
6341
 function ReadableByteStreamControllerRespond(controller, bytesWritten) {
6342
  bytesWritten = Number(bytesWritten);
6343
  if (!IsFiniteNonNegativeNumber(bytesWritten)) {
6344
   throw new RangeError('bytesWritten must be a finite');
6345
  }
6346
  ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
6347
 }
6348
 function ReadableByteStreamControllerRespondWithNewView(controller, view) {
6349
  var firstDescriptor = controller._pendingPullIntos.peek();
6350
  if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {
6351
   throw new RangeError('The region specified by view does not match byobRequest');
6352
  }
6353
  if (firstDescriptor.byteLength !== view.byteLength) {
6354
   throw new RangeError('The buffer of view has different capacity than byobRequest');
6355
  }
6356
  firstDescriptor.buffer = view.buffer;
6357
  ReadableByteStreamControllerRespondInternal(controller, view.byteLength);
6358
 }
6359
 function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {
6360
  controller._controlledReadableByteStream = stream;
6361
  controller._pullAgain = false;
6362
  controller._pulling = false;
6363
  controller._byobRequest = null;
6364
  controller._queue = controller._queueTotalSize = undefined;
6365
  ResetQueue(controller);
6366
  controller._closeRequested = false;
6367
  controller._started = false;
6368
  controller._strategyHWM = highWaterMark;
6369
  controller._pullAlgorithm = pullAlgorithm;
6370
  controller._cancelAlgorithm = cancelAlgorithm;
6371
  controller._autoAllocateChunkSize = autoAllocateChunkSize;
6372
  controller._pendingPullIntos = new SimpleQueue();
6373
  stream._readableStreamController = controller;
6374
  var startResult = startAlgorithm();
6375
  uponPromise(promiseResolvedWith(startResult), function () {
6376
   controller._started = true;
6377
   ReadableByteStreamControllerCallPullIfNeeded(controller);
6378
  }, function (r) {
6379
   ReadableByteStreamControllerError(controller, r);
6380
  });
6381
 }
6382
 function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {
6383
  var controller = Object.create(ReadableByteStreamController.prototype);
6384
  var startAlgorithm = function () {
6385
   return undefined;
6386
  };
6387
  var pullAlgorithm = function () {
6388
   return promiseResolvedWith(undefined);
6389
  };
6390
  var cancelAlgorithm = function () {
6391
   return promiseResolvedWith(undefined);
6392
  };
6393
  if (underlyingByteSource.start !== undefined) {
6394
   startAlgorithm = function () {
6395
    return underlyingByteSource.start(controller);
6396
   };
6397
  }
6398
  if (underlyingByteSource.pull !== undefined) {
6399
   pullAlgorithm = function () {
6400
    return underlyingByteSource.pull(controller);
6401
   };
6402
  }
6403
  if (underlyingByteSource.cancel !== undefined) {
6404
   cancelAlgorithm = function (reason) {
6405
    return underlyingByteSource.cancel(reason);
6406
   };
6407
  }
6408
  var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
6409
  if (autoAllocateChunkSize === 0) {
6410
   throw new TypeError('autoAllocateChunkSize must be greater than 0');
6411
  }
6412
  SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize);
6413
 }
6414
 function SetUpReadableStreamBYOBRequest(request, controller, view) {
6415
  request._associatedReadableByteStreamController = controller;
6416
  request._view = view;
6417
 }
6418
 function byobRequestBrandCheckException(name) {
6419
  return new TypeError("ReadableStreamBYOBRequest.prototype." + name + " can only be used on a ReadableStreamBYOBRequest");
6420
 }
6421
 function byteStreamControllerBrandCheckException(name) {
6422
  return new TypeError("ReadableByteStreamController.prototype." + name + " can only be used on a ReadableByteStreamController");
6423
 }
6424
 function AcquireReadableStreamBYOBReader(stream) {
6425
  return new ReadableStreamBYOBReader(stream);
6426
 }
6427
 function ReadableStreamAddReadIntoRequest(stream, readIntoRequest) {
6428
  stream._reader._readIntoRequests.push(readIntoRequest);
6429
 }
6430
 function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
6431
  var reader = stream._reader;
6432
  var readIntoRequest = reader._readIntoRequests.shift();
6433
  if (done) {
6434
   readIntoRequest._closeSteps(chunk);
6435
  } else {
6436
   readIntoRequest._chunkSteps(chunk);
6437
  }
6438
 }
6439
 function ReadableStreamGetNumReadIntoRequests(stream) {
6440
  return stream._reader._readIntoRequests.length;
6441
 }
6442
 function ReadableStreamHasBYOBReader(stream) {
6443
  var reader = stream._reader;
6444
  if (reader === undefined) {
6445
   return false;
6446
  }
6447
  if (!IsReadableStreamBYOBReader(reader)) {
6448
   return false;
6449
  }
6450
  return true;
6451
 }
6452
 var ReadableStreamBYOBReader = function () {
6453
  function ReadableStreamBYOBReader(stream) {
6454
   assertRequiredArgument(stream, 1, 'ReadableStreamBYOBReader');
6455
   assertReadableStream(stream, 'First parameter');
6456
   if (IsReadableStreamLocked(stream)) {
6457
    throw new TypeError('This stream has already been locked for exclusive reading by another reader');
6458
   }
6459
   if (!IsReadableByteStreamController(stream._readableStreamController)) {
6460
    throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte ' + 'source');
6461
   }
6462
   ReadableStreamReaderGenericInitialize(this, stream);
6463
   this._readIntoRequests = new SimpleQueue();
6464
  }
6465
  Object.defineProperty(ReadableStreamBYOBReader.prototype, "closed", {
6466
   get: function () {
6467
    if (!IsReadableStreamBYOBReader(this)) {
6468
     return promiseRejectedWith(byobReaderBrandCheckException('closed'));
6469
    }
6470
    return this._closedPromise;
6471
   },
6472
   enumerable: false,
6473
   configurable: true
6474
  });
6475
  ReadableStreamBYOBReader.prototype.cancel = function (reason) {
6476
   if (reason === void 0) {
6477
    reason = undefined;
6478
   }
6479
   if (!IsReadableStreamBYOBReader(this)) {
6480
    return promiseRejectedWith(byobReaderBrandCheckException('cancel'));
6481
   }
6482
   if (this._ownerReadableStream === undefined) {
6483
    return promiseRejectedWith(readerLockException('cancel'));
6484
   }
6485
   return ReadableStreamReaderGenericCancel(this, reason);
6486
  };
6487
  ReadableStreamBYOBReader.prototype.read = function (view) {
6488
   if (!IsReadableStreamBYOBReader(this)) {
6489
    return promiseRejectedWith(byobReaderBrandCheckException('read'));
6490
   }
6491
   if (!ArrayBuffer.isView(view)) {
6492
    return promiseRejectedWith(new TypeError('view must be an array buffer view'));
6493
   }
6494
   if (view.byteLength === 0) {
6495
    return promiseRejectedWith(new TypeError('view must have non-zero byteLength'));
6496
   }
6497
   if (view.buffer.byteLength === 0) {
6498
    return promiseRejectedWith(new TypeError("view's buffer must have non-zero byteLength"));
6499
   }
6500
   if (this._ownerReadableStream === undefined) {
6501
    return promiseRejectedWith(readerLockException('read from'));
6502
   }
6503
   var resolvePromise;
6504
   var rejectPromise;
6505
   var promise = newPromise(function (resolve, reject) {
6506
    resolvePromise = resolve;
6507
    rejectPromise = reject;
6508
   });
6509
   var readIntoRequest = {
6510
    _chunkSteps: function (chunk) {
6511
     return resolvePromise({
6512
      value: chunk,
6513
      done: false
6514
     });
6515
    },
6516
    _closeSteps: function (chunk) {
6517
     return resolvePromise({
6518
      value: chunk,
6519
      done: true
6520
     });
6521
    },
6522
    _errorSteps: function (e) {
6523
     return rejectPromise(e);
6524
    }
6525
   };
6526
   ReadableStreamBYOBReaderRead(this, view, readIntoRequest);
6527
   return promise;
6528
  };
6529
  ReadableStreamBYOBReader.prototype.releaseLock = function () {
6530
   if (!IsReadableStreamBYOBReader(this)) {
6531
    throw byobReaderBrandCheckException('releaseLock');
6532
   }
6533
   if (this._ownerReadableStream === undefined) {
6534
    return;
6535
   }
6536
   if (this._readIntoRequests.length > 0) {
6537
    throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
6538
   }
6539
   ReadableStreamReaderGenericRelease(this);
6540
  };
6541
  return ReadableStreamBYOBReader;
6542
 }();
6543
 Object.defineProperties(ReadableStreamBYOBReader.prototype, {
6544
  cancel: { enumerable: true },
6545
  read: { enumerable: true },
6546
  releaseLock: { enumerable: true },
6547
  closed: { enumerable: true }
6548
 });
6549
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
6550
  Object.defineProperty(ReadableStreamBYOBReader.prototype, SymbolPolyfill.toStringTag, {
6551
   value: 'ReadableStreamBYOBReader',
6552
   configurable: true
6553
  });
6554
 }
6555
 function IsReadableStreamBYOBReader(x) {
6556
  if (!typeIsObject(x)) {
6557
   return false;
6558
  }
6559
  if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
6560
   return false;
6561
  }
6562
  return true;
6563
 }
6564
 function ReadableStreamBYOBReaderRead(reader, view, readIntoRequest) {
6565
  var stream = reader._ownerReadableStream;
6566
  stream._disturbed = true;
6567
  if (stream._state === 'errored') {
6568
   readIntoRequest._errorSteps(stream._storedError);
6569
  } else {
6570
   ReadableByteStreamControllerPullInto(stream._readableStreamController, view, readIntoRequest);
6571
  }
6572
 }
6573
 function byobReaderBrandCheckException(name) {
6574
  return new TypeError("ReadableStreamBYOBReader.prototype." + name + " can only be used on a ReadableStreamBYOBReader");
6575
 }
6576
 function ExtractHighWaterMark(strategy, defaultHWM) {
6577
  var highWaterMark = strategy.highWaterMark;
6578
  if (highWaterMark === undefined) {
6579
   return defaultHWM;
6580
  }
6581
  if (NumberIsNaN(highWaterMark) || highWaterMark < 0) {
6582
   throw new RangeError('Invalid highWaterMark');
6583
  }
6584
  return highWaterMark;
6585
 }
6586
 function ExtractSizeAlgorithm(strategy) {
6587
  var size = strategy.size;
6588
  if (!size) {
6589
   return function () {
6590
    return 1;
6591
   };
6592
  }
6593
  return size;
6594
 }
6595
 function convertQueuingStrategy(init, context) {
6596
  assertDictionary(init, context);
6597
  var highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;
6598
  var size = init === null || init === void 0 ? void 0 : init.size;
6599
  return {
6600
   highWaterMark: highWaterMark === undefined ? undefined : convertUnrestrictedDouble(highWaterMark),
6601
   size: size === undefined ? undefined : convertQueuingStrategySize(size, context + " has member 'size' that")
6602
  };
6603
 }
6604
 function convertQueuingStrategySize(fn, context) {
6605
  assertFunction(fn, context);
6606
  return function (chunk) {
6607
   return convertUnrestrictedDouble(fn(chunk));
6608
  };
6609
 }
6610
 function convertUnderlyingSink(original, context) {
6611
  assertDictionary(original, context);
6612
  var abort = original === null || original === void 0 ? void 0 : original.abort;
6613
  var close = original === null || original === void 0 ? void 0 : original.close;
6614
  var start = original === null || original === void 0 ? void 0 : original.start;
6615
  var type = original === null || original === void 0 ? void 0 : original.type;
6616
  var write = original === null || original === void 0 ? void 0 : original.write;
6617
  return {
6618
   abort: abort === undefined ? undefined : convertUnderlyingSinkAbortCallback(abort, original, context + " has member 'abort' that"),
6619
   close: close === undefined ? undefined : convertUnderlyingSinkCloseCallback(close, original, context + " has member 'close' that"),
6620
   start: start === undefined ? undefined : convertUnderlyingSinkStartCallback(start, original, context + " has member 'start' that"),
6621
   write: write === undefined ? undefined : convertUnderlyingSinkWriteCallback(write, original, context + " has member 'write' that"),
6622
   type: type
6623
  };
6624
 }
6625
 function convertUnderlyingSinkAbortCallback(fn, original, context) {
6626
  assertFunction(fn, context);
6627
  return function (reason) {
6628
   return promiseCall(fn, original, [reason]);
6629
  };
6630
 }
6631
 function convertUnderlyingSinkCloseCallback(fn, original, context) {
6632
  assertFunction(fn, context);
6633
  return function () {
6634
   return promiseCall(fn, original, []);
6635
  };
6636
 }
6637
 function convertUnderlyingSinkStartCallback(fn, original, context) {
6638
  assertFunction(fn, context);
6639
  return function (controller) {
6640
   return reflectCall(fn, original, [controller]);
6641
  };
6642
 }
6643
 function convertUnderlyingSinkWriteCallback(fn, original, context) {
6644
  assertFunction(fn, context);
6645
  return function (chunk, controller) {
6646
   return promiseCall(fn, original, [
6647
    chunk,
6648
    controller
6649
   ]);
6650
  };
6651
 }
6652
 function assertWritableStream(x, context) {
6653
  if (!IsWritableStream(x)) {
6654
   throw new TypeError(context + " is not a WritableStream.");
6655
  }
6656
 }
6657
 var WritableStream = function () {
6658
  function WritableStream(rawUnderlyingSink, rawStrategy) {
6659
   if (rawUnderlyingSink === void 0) {
6660
    rawUnderlyingSink = {};
6661
   }
6662
   if (rawStrategy === void 0) {
6663
    rawStrategy = {};
6664
   }
6665
   if (rawUnderlyingSink === undefined) {
6666
    rawUnderlyingSink = null;
6667
   } else {
6668
    assertObject(rawUnderlyingSink, 'First parameter');
6669
   }
6670
   var strategy = convertQueuingStrategy(rawStrategy, 'Second parameter');
6671
   var underlyingSink = convertUnderlyingSink(rawUnderlyingSink, 'First parameter');
6672
   InitializeWritableStream(this);
6673
   var type = underlyingSink.type;
6674
   if (type !== undefined) {
6675
    throw new RangeError('Invalid type is specified');
6676
   }
6677
   var sizeAlgorithm = ExtractSizeAlgorithm(strategy);
6678
   var highWaterMark = ExtractHighWaterMark(strategy, 1);
6679
   SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);
6680
  }
6681
  Object.defineProperty(WritableStream.prototype, "locked", {
6682
   get: function () {
6683
    if (!IsWritableStream(this)) {
6684
     throw streamBrandCheckException('locked');
6685
    }
6686
    return IsWritableStreamLocked(this);
6687
   },
6688
   enumerable: false,
6689
   configurable: true
6690
  });
6691
  WritableStream.prototype.abort = function (reason) {
6692
   if (reason === void 0) {
6693
    reason = undefined;
6694
   }
6695
   if (!IsWritableStream(this)) {
6696
    return promiseRejectedWith(streamBrandCheckException('abort'));
6697
   }
6698
   if (IsWritableStreamLocked(this)) {
6699
    return promiseRejectedWith(new TypeError('Cannot abort a stream that already has a writer'));
6700
   }
6701
   return WritableStreamAbort(this, reason);
6702
  };
6703
  WritableStream.prototype.close = function () {
6704
   if (!IsWritableStream(this)) {
6705
    return promiseRejectedWith(streamBrandCheckException('close'));
6706
   }
6707
   if (IsWritableStreamLocked(this)) {
6708
    return promiseRejectedWith(new TypeError('Cannot close a stream that already has a writer'));
6709
   }
6710
   if (WritableStreamCloseQueuedOrInFlight(this)) {
6711
    return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));
6712
   }
6713
   return WritableStreamClose(this);
6714
  };
6715
  WritableStream.prototype.getWriter = function () {
6716
   if (!IsWritableStream(this)) {
6717
    throw streamBrandCheckException('getWriter');
6718
   }
6719
   return AcquireWritableStreamDefaultWriter(this);
6720
  };
6721
  return WritableStream;
6722
 }();
6723
 Object.defineProperties(WritableStream.prototype, {
6724
  abort: { enumerable: true },
6725
  close: { enumerable: true },
6726
  getWriter: { enumerable: true },
6727
  locked: { enumerable: true }
6728
 });
6729
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
6730
  Object.defineProperty(WritableStream.prototype, SymbolPolyfill.toStringTag, {
6731
   value: 'WritableStream',
6732
   configurable: true
6733
  });
6734
 }
6735
 function AcquireWritableStreamDefaultWriter(stream) {
6736
  return new WritableStreamDefaultWriter(stream);
6737
 }
6738
 function CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
6739
  if (highWaterMark === void 0) {
6740
   highWaterMark = 1;
6741
  }
6742
  if (sizeAlgorithm === void 0) {
6743
   sizeAlgorithm = function () {
6744
    return 1;
6745
   };
6746
  }
6747
  var stream = Object.create(WritableStream.prototype);
6748
  InitializeWritableStream(stream);
6749
  var controller = Object.create(WritableStreamDefaultController.prototype);
6750
  SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
6751
  return stream;
6752
 }
6753
 function InitializeWritableStream(stream) {
6754
  stream._state = 'writable';
6755
  stream._storedError = undefined;
6756
  stream._writer = undefined;
6757
  stream._writableStreamController = undefined;
6758
  stream._writeRequests = new SimpleQueue();
6759
  stream._inFlightWriteRequest = undefined;
6760
  stream._closeRequest = undefined;
6761
  stream._inFlightCloseRequest = undefined;
6762
  stream._pendingAbortRequest = undefined;
6763
  stream._backpressure = false;
6764
 }
6765
 function IsWritableStream(x) {
6766
  if (!typeIsObject(x)) {
6767
   return false;
6768
  }
6769
  if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {
6770
   return false;
6771
  }
6772
  return true;
6773
 }
6774
 function IsWritableStreamLocked(stream) {
6775
  if (stream._writer === undefined) {
6776
   return false;
6777
  }
6778
  return true;
6779
 }
6780
 function WritableStreamAbort(stream, reason) {
6781
  var state = stream._state;
6782
  if (state === 'closed' || state === 'errored') {
6783
   return promiseResolvedWith(undefined);
6784
  }
6785
  if (stream._pendingAbortRequest !== undefined) {
6786
   return stream._pendingAbortRequest._promise;
6787
  }
6788
  var wasAlreadyErroring = false;
6789
  if (state === 'erroring') {
6790
   wasAlreadyErroring = true;
6791
   reason = undefined;
6792
  }
6793
  var promise = newPromise(function (resolve, reject) {
6794
   stream._pendingAbortRequest = {
6795
    _promise: undefined,
6796
    _resolve: resolve,
6797
    _reject: reject,
6798
    _reason: reason,
6799
    _wasAlreadyErroring: wasAlreadyErroring
6800
   };
6801
  });
6802
  stream._pendingAbortRequest._promise = promise;
6803
  if (!wasAlreadyErroring) {
6804
   WritableStreamStartErroring(stream, reason);
6805
  }
6806
  return promise;
6807
 }
6808
 function WritableStreamClose(stream) {
6809
  var state = stream._state;
6810
  if (state === 'closed' || state === 'errored') {
6811
   return promiseRejectedWith(new TypeError("The stream (in " + state + " state) is not in the writable state and cannot be closed"));
6812
  }
6813
  var promise = newPromise(function (resolve, reject) {
6814
   var closeRequest = {
6815
    _resolve: resolve,
6816
    _reject: reject
6817
   };
6818
   stream._closeRequest = closeRequest;
6819
  });
6820
  var writer = stream._writer;
6821
  if (writer !== undefined && stream._backpressure && state === 'writable') {
6822
   defaultWriterReadyPromiseResolve(writer);
6823
  }
6824
  WritableStreamDefaultControllerClose(stream._writableStreamController);
6825
  return promise;
6826
 }
6827
 function WritableStreamAddWriteRequest(stream) {
6828
  var promise = newPromise(function (resolve, reject) {
6829
   var writeRequest = {
6830
    _resolve: resolve,
6831
    _reject: reject
6832
   };
6833
   stream._writeRequests.push(writeRequest);
6834
  });
6835
  return promise;
6836
 }
6837
 function WritableStreamDealWithRejection(stream, error) {
6838
  var state = stream._state;
6839
  if (state === 'writable') {
6840
   WritableStreamStartErroring(stream, error);
6841
   return;
6842
  }
6843
  WritableStreamFinishErroring(stream);
6844
 }
6845
 function WritableStreamStartErroring(stream, reason) {
6846
  var controller = stream._writableStreamController;
6847
  stream._state = 'erroring';
6848
  stream._storedError = reason;
6849
  var writer = stream._writer;
6850
  if (writer !== undefined) {
6851
   WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
6852
  }
6853
  if (!WritableStreamHasOperationMarkedInFlight(stream) && controller._started) {
6854
   WritableStreamFinishErroring(stream);
6855
  }
6856
 }
6857
 function WritableStreamFinishErroring(stream) {
6858
  stream._state = 'errored';
6859
  stream._writableStreamController[ErrorSteps]();
6860
  var storedError = stream._storedError;
6861
  stream._writeRequests.forEach(function (writeRequest) {
6862
   writeRequest._reject(storedError);
6863
  });
6864
  stream._writeRequests = new SimpleQueue();
6865
  if (stream._pendingAbortRequest === undefined) {
6866
   WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
6867
   return;
6868
  }
6869
  var abortRequest = stream._pendingAbortRequest;
6870
  stream._pendingAbortRequest = undefined;
6871
  if (abortRequest._wasAlreadyErroring) {
6872
   abortRequest._reject(storedError);
6873
   WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
6874
   return;
6875
  }
6876
  var promise = stream._writableStreamController[AbortSteps](abortRequest._reason);
6877
  uponPromise(promise, function () {
6878
   abortRequest._resolve();
6879
   WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
6880
  }, function (reason) {
6881
   abortRequest._reject(reason);
6882
   WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
6883
  });
6884
 }
6885
 function WritableStreamFinishInFlightWrite(stream) {
6886
  stream._inFlightWriteRequest._resolve(undefined);
6887
  stream._inFlightWriteRequest = undefined;
6888
 }
6889
 function WritableStreamFinishInFlightWriteWithError(stream, error) {
6890
  stream._inFlightWriteRequest._reject(error);
6891
  stream._inFlightWriteRequest = undefined;
6892
  WritableStreamDealWithRejection(stream, error);
6893
 }
6894
 function WritableStreamFinishInFlightClose(stream) {
6895
  stream._inFlightCloseRequest._resolve(undefined);
6896
  stream._inFlightCloseRequest = undefined;
6897
  var state = stream._state;
6898
  if (state === 'erroring') {
6899
   stream._storedError = undefined;
6900
   if (stream._pendingAbortRequest !== undefined) {
6901
    stream._pendingAbortRequest._resolve();
6902
    stream._pendingAbortRequest = undefined;
6903
   }
6904
  }
6905
  stream._state = 'closed';
6906
  var writer = stream._writer;
6907
  if (writer !== undefined) {
6908
   defaultWriterClosedPromiseResolve(writer);
6909
  }
6910
 }
6911
 function WritableStreamFinishInFlightCloseWithError(stream, error) {
6912
  stream._inFlightCloseRequest._reject(error);
6913
  stream._inFlightCloseRequest = undefined;
6914
  if (stream._pendingAbortRequest !== undefined) {
6915
   stream._pendingAbortRequest._reject(error);
6916
   stream._pendingAbortRequest = undefined;
6917
  }
6918
  WritableStreamDealWithRejection(stream, error);
6919
 }
6920
 function WritableStreamCloseQueuedOrInFlight(stream) {
6921
  if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) {
6922
   return false;
6923
  }
6924
  return true;
6925
 }
6926
 function WritableStreamHasOperationMarkedInFlight(stream) {
6927
  if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) {
6928
   return false;
6929
  }
6930
  return true;
6931
 }
6932
 function WritableStreamMarkCloseRequestInFlight(stream) {
6933
  stream._inFlightCloseRequest = stream._closeRequest;
6934
  stream._closeRequest = undefined;
6935
 }
6936
 function WritableStreamMarkFirstWriteRequestInFlight(stream) {
6937
  stream._inFlightWriteRequest = stream._writeRequests.shift();
6938
 }
6939
 function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
6940
  if (stream._closeRequest !== undefined) {
6941
   stream._closeRequest._reject(stream._storedError);
6942
   stream._closeRequest = undefined;
6943
  }
6944
  var writer = stream._writer;
6945
  if (writer !== undefined) {
6946
   defaultWriterClosedPromiseReject(writer, stream._storedError);
6947
  }
6948
 }
6949
 function WritableStreamUpdateBackpressure(stream, backpressure) {
6950
  var writer = stream._writer;
6951
  if (writer !== undefined && backpressure !== stream._backpressure) {
6952
   if (backpressure) {
6953
    defaultWriterReadyPromiseReset(writer);
6954
   } else {
6955
    defaultWriterReadyPromiseResolve(writer);
6956
   }
6957
  }
6958
  stream._backpressure = backpressure;
6959
 }
6960
 var WritableStreamDefaultWriter = function () {
6961
  function WritableStreamDefaultWriter(stream) {
6962
   assertRequiredArgument(stream, 1, 'WritableStreamDefaultWriter');
6963
   assertWritableStream(stream, 'First parameter');
6964
   if (IsWritableStreamLocked(stream)) {
6965
    throw new TypeError('This stream has already been locked for exclusive writing by another writer');
6966
   }
6967
   this._ownerWritableStream = stream;
6968
   stream._writer = this;
6969
   var state = stream._state;
6970
   if (state === 'writable') {
6971
    if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._backpressure) {
6972
     defaultWriterReadyPromiseInitialize(this);
6973
    } else {
6974
     defaultWriterReadyPromiseInitializeAsResolved(this);
6975
    }
6976
    defaultWriterClosedPromiseInitialize(this);
6977
   } else if (state === 'erroring') {
6978
    defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);
6979
    defaultWriterClosedPromiseInitialize(this);
6980
   } else if (state === 'closed') {
6981
    defaultWriterReadyPromiseInitializeAsResolved(this);
6982
    defaultWriterClosedPromiseInitializeAsResolved(this);
6983
   } else {
6984
    var storedError = stream._storedError;
6985
    defaultWriterReadyPromiseInitializeAsRejected(this, storedError);
6986
    defaultWriterClosedPromiseInitializeAsRejected(this, storedError);
6987
   }
6988
  }
6989
  Object.defineProperty(WritableStreamDefaultWriter.prototype, "closed", {
6990
   get: function () {
6991
    if (!IsWritableStreamDefaultWriter(this)) {
6992
     return promiseRejectedWith(defaultWriterBrandCheckException('closed'));
6993
    }
6994
    return this._closedPromise;
6995
   },
6996
   enumerable: false,
6997
   configurable: true
6998
  });
6999
  Object.defineProperty(WritableStreamDefaultWriter.prototype, "desiredSize", {
7000
   get: function () {
7001
    if (!IsWritableStreamDefaultWriter(this)) {
7002
     throw defaultWriterBrandCheckException('desiredSize');
7003
    }
7004
    if (this._ownerWritableStream === undefined) {
7005
     throw defaultWriterLockException('desiredSize');
7006
    }
7007
    return WritableStreamDefaultWriterGetDesiredSize(this);
7008
   },
7009
   enumerable: false,
7010
   configurable: true
7011
  });
7012
  Object.defineProperty(WritableStreamDefaultWriter.prototype, "ready", {
7013
   get: function () {
7014
    if (!IsWritableStreamDefaultWriter(this)) {
7015
     return promiseRejectedWith(defaultWriterBrandCheckException('ready'));
7016
    }
7017
    return this._readyPromise;
7018
   },
7019
   enumerable: false,
7020
   configurable: true
7021
  });
7022
  WritableStreamDefaultWriter.prototype.abort = function (reason) {
7023
   if (reason === void 0) {
7024
    reason = undefined;
7025
   }
7026
   if (!IsWritableStreamDefaultWriter(this)) {
7027
    return promiseRejectedWith(defaultWriterBrandCheckException('abort'));
7028
   }
7029
   if (this._ownerWritableStream === undefined) {
7030
    return promiseRejectedWith(defaultWriterLockException('abort'));
7031
   }
7032
   return WritableStreamDefaultWriterAbort(this, reason);
7033
  };
7034
  WritableStreamDefaultWriter.prototype.close = function () {
7035
   if (!IsWritableStreamDefaultWriter(this)) {
7036
    return promiseRejectedWith(defaultWriterBrandCheckException('close'));
7037
   }
7038
   var stream = this._ownerWritableStream;
7039
   if (stream === undefined) {
7040
    return promiseRejectedWith(defaultWriterLockException('close'));
7041
   }
7042
   if (WritableStreamCloseQueuedOrInFlight(stream)) {
7043
    return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));
7044
   }
7045
   return WritableStreamDefaultWriterClose(this);
7046
  };
7047
  WritableStreamDefaultWriter.prototype.releaseLock = function () {
7048
   if (!IsWritableStreamDefaultWriter(this)) {
7049
    throw defaultWriterBrandCheckException('releaseLock');
7050
   }
7051
   var stream = this._ownerWritableStream;
7052
   if (stream === undefined) {
7053
    return;
7054
   }
7055
   WritableStreamDefaultWriterRelease(this);
7056
  };
7057
  WritableStreamDefaultWriter.prototype.write = function (chunk) {
7058
   if (chunk === void 0) {
7059
    chunk = undefined;
7060
   }
7061
   if (!IsWritableStreamDefaultWriter(this)) {
7062
    return promiseRejectedWith(defaultWriterBrandCheckException('write'));
7063
   }
7064
   if (this._ownerWritableStream === undefined) {
7065
    return promiseRejectedWith(defaultWriterLockException('write to'));
7066
   }
7067
   return WritableStreamDefaultWriterWrite(this, chunk);
7068
  };
7069
  return WritableStreamDefaultWriter;
7070
 }();
7071
 Object.defineProperties(WritableStreamDefaultWriter.prototype, {
7072
  abort: { enumerable: true },
7073
  close: { enumerable: true },
7074
  releaseLock: { enumerable: true },
7075
  write: { enumerable: true },
7076
  closed: { enumerable: true },
7077
  desiredSize: { enumerable: true },
7078
  ready: { enumerable: true }
7079
 });
7080
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
7081
  Object.defineProperty(WritableStreamDefaultWriter.prototype, SymbolPolyfill.toStringTag, {
7082
   value: 'WritableStreamDefaultWriter',
7083
   configurable: true
7084
  });
7085
 }
7086
 function IsWritableStreamDefaultWriter(x) {
7087
  if (!typeIsObject(x)) {
7088
   return false;
7089
  }
7090
  if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {
7091
   return false;
7092
  }
7093
  return true;
7094
 }
7095
 function WritableStreamDefaultWriterAbort(writer, reason) {
7096
  var stream = writer._ownerWritableStream;
7097
  return WritableStreamAbort(stream, reason);
7098
 }
7099
 function WritableStreamDefaultWriterClose(writer) {
7100
  var stream = writer._ownerWritableStream;
7101
  return WritableStreamClose(stream);
7102
 }
7103
 function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
7104
  var stream = writer._ownerWritableStream;
7105
  var state = stream._state;
7106
  if (WritableStreamCloseQueuedOrInFlight(stream) || state === 'closed') {
7107
   return promiseResolvedWith(undefined);
7108
  }
7109
  if (state === 'errored') {
7110
   return promiseRejectedWith(stream._storedError);
7111
  }
7112
  return WritableStreamDefaultWriterClose(writer);
7113
 }
7114
 function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
7115
  if (writer._closedPromiseState === 'pending') {
7116
   defaultWriterClosedPromiseReject(writer, error);
7117
  } else {
7118
   defaultWriterClosedPromiseResetToRejected(writer, error);
7119
  }
7120
 }
7121
 function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
7122
  if (writer._readyPromiseState === 'pending') {
7123
   defaultWriterReadyPromiseReject(writer, error);
7124
  } else {
7125
   defaultWriterReadyPromiseResetToRejected(writer, error);
7126
  }
7127
 }
7128
 function WritableStreamDefaultWriterGetDesiredSize(writer) {
7129
  var stream = writer._ownerWritableStream;
7130
  var state = stream._state;
7131
  if (state === 'errored' || state === 'erroring') {
7132
   return null;
7133
  }
7134
  if (state === 'closed') {
7135
   return 0;
7136
  }
7137
  return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);
7138
 }
7139
 function WritableStreamDefaultWriterRelease(writer) {
7140
  var stream = writer._ownerWritableStream;
7141
  var releasedError = new TypeError("Writer was released and can no longer be used to monitor the stream's closedness");
7142
  WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);
7143
  WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);
7144
  stream._writer = undefined;
7145
  writer._ownerWritableStream = undefined;
7146
 }
7147
 function WritableStreamDefaultWriterWrite(writer, chunk) {
7148
  var stream = writer._ownerWritableStream;
7149
  var controller = stream._writableStreamController;
7150
  var chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);
7151
  if (stream !== writer._ownerWritableStream) {
7152
   return promiseRejectedWith(defaultWriterLockException('write to'));
7153
  }
7154
  var state = stream._state;
7155
  if (state === 'errored') {
7156
   return promiseRejectedWith(stream._storedError);
7157
  }
7158
  if (WritableStreamCloseQueuedOrInFlight(stream) || state === 'closed') {
7159
   return promiseRejectedWith(new TypeError('The stream is closing or closed and cannot be written to'));
7160
  }
7161
  if (state === 'erroring') {
7162
   return promiseRejectedWith(stream._storedError);
7163
  }
7164
  var promise = WritableStreamAddWriteRequest(stream);
7165
  WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);
7166
  return promise;
7167
 }
7168
 var closeSentinel = {};
7169
 var WritableStreamDefaultController = function () {
7170
  function WritableStreamDefaultController() {
7171
   throw new TypeError('Illegal constructor');
7172
  }
7173
  WritableStreamDefaultController.prototype.error = function (e) {
7174
   if (e === void 0) {
7175
    e = undefined;
7176
   }
7177
   if (!IsWritableStreamDefaultController(this)) {
7178
    throw new TypeError('WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController');
7179
   }
7180
   var state = this._controlledWritableStream._state;
7181
   if (state !== 'writable') {
7182
    return;
7183
   }
7184
   WritableStreamDefaultControllerError(this, e);
7185
  };
7186
  WritableStreamDefaultController.prototype[AbortSteps] = function (reason) {
7187
   var result = this._abortAlgorithm(reason);
7188
   WritableStreamDefaultControllerClearAlgorithms(this);
7189
   return result;
7190
  };
7191
  WritableStreamDefaultController.prototype[ErrorSteps] = function () {
7192
   ResetQueue(this);
7193
  };
7194
  return WritableStreamDefaultController;
7195
 }();
7196
 Object.defineProperties(WritableStreamDefaultController.prototype, { error: { enumerable: true } });
7197
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
7198
  Object.defineProperty(WritableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
7199
   value: 'WritableStreamDefaultController',
7200
   configurable: true
7201
  });
7202
 }
7203
 function IsWritableStreamDefaultController(x) {
7204
  if (!typeIsObject(x)) {
7205
   return false;
7206
  }
7207
  if (!Object.prototype.hasOwnProperty.call(x, '_controlledWritableStream')) {
7208
   return false;
7209
  }
7210
  return true;
7211
 }
7212
 function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {
7213
  controller._controlledWritableStream = stream;
7214
  stream._writableStreamController = controller;
7215
  controller._queue = undefined;
7216
  controller._queueTotalSize = undefined;
7217
  ResetQueue(controller);
7218
  controller._started = false;
7219
  controller._strategySizeAlgorithm = sizeAlgorithm;
7220
  controller._strategyHWM = highWaterMark;
7221
  controller._writeAlgorithm = writeAlgorithm;
7222
  controller._closeAlgorithm = closeAlgorithm;
7223
  controller._abortAlgorithm = abortAlgorithm;
7224
  var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
7225
  WritableStreamUpdateBackpressure(stream, backpressure);
7226
  var startResult = startAlgorithm();
7227
  var startPromise = promiseResolvedWith(startResult);
7228
  uponPromise(startPromise, function () {
7229
   controller._started = true;
7230
   WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
7231
  }, function (r) {
7232
   controller._started = true;
7233
   WritableStreamDealWithRejection(stream, r);
7234
  });
7235
 }
7236
 function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) {
7237
  var controller = Object.create(WritableStreamDefaultController.prototype);
7238
  var startAlgorithm = function () {
7239
   return undefined;
7240
  };
7241
  var writeAlgorithm = function () {
7242
   return promiseResolvedWith(undefined);
7243
  };
7244
  var closeAlgorithm = function () {
7245
   return promiseResolvedWith(undefined);
7246
  };
7247
  var abortAlgorithm = function () {
7248
   return promiseResolvedWith(undefined);
7249
  };
7250
  if (underlyingSink.start !== undefined) {
7251
   startAlgorithm = function () {
7252
    return underlyingSink.start(controller);
7253
   };
7254
  }
7255
  if (underlyingSink.write !== undefined) {
7256
   writeAlgorithm = function (chunk) {
7257
    return underlyingSink.write(chunk, controller);
7258
   };
7259
  }
7260
  if (underlyingSink.close !== undefined) {
7261
   closeAlgorithm = function () {
7262
    return underlyingSink.close();
7263
   };
7264
  }
7265
  if (underlyingSink.abort !== undefined) {
7266
   abortAlgorithm = function (reason) {
7267
    return underlyingSink.abort(reason);
7268
   };
7269
  }
7270
  SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);
7271
 }
7272
 function WritableStreamDefaultControllerClearAlgorithms(controller) {
7273
  controller._writeAlgorithm = undefined;
7274
  controller._closeAlgorithm = undefined;
7275
  controller._abortAlgorithm = undefined;
7276
  controller._strategySizeAlgorithm = undefined;
7277
 }
7278
 function WritableStreamDefaultControllerClose(controller) {
7279
  EnqueueValueWithSize(controller, closeSentinel, 0);
7280
  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
7281
 }
7282
 function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {
7283
  try {
7284
   return controller._strategySizeAlgorithm(chunk);
7285
  } catch (chunkSizeE) {
7286
   WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
7287
   return 1;
7288
  }
7289
 }
7290
 function WritableStreamDefaultControllerGetDesiredSize(controller) {
7291
  return controller._strategyHWM - controller._queueTotalSize;
7292
 }
7293
 function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
7294
  try {
7295
   EnqueueValueWithSize(controller, chunk, chunkSize);
7296
  } catch (enqueueE) {
7297
   WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
7298
   return;
7299
  }
7300
  var stream = controller._controlledWritableStream;
7301
  if (!WritableStreamCloseQueuedOrInFlight(stream) && stream._state === 'writable') {
7302
   var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
7303
   WritableStreamUpdateBackpressure(stream, backpressure);
7304
  }
7305
  WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
7306
 }
7307
 function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
7308
  var stream = controller._controlledWritableStream;
7309
  if (!controller._started) {
7310
   return;
7311
  }
7312
  if (stream._inFlightWriteRequest !== undefined) {
7313
   return;
7314
  }
7315
  var state = stream._state;
7316
  if (state === 'erroring') {
7317
   WritableStreamFinishErroring(stream);
7318
   return;
7319
  }
7320
  if (controller._queue.length === 0) {
7321
   return;
7322
  }
7323
  var value = PeekQueueValue(controller);
7324
  if (value === closeSentinel) {
7325
   WritableStreamDefaultControllerProcessClose(controller);
7326
  } else {
7327
   WritableStreamDefaultControllerProcessWrite(controller, value);
7328
  }
7329
 }
7330
 function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {
7331
  if (controller._controlledWritableStream._state === 'writable') {
7332
   WritableStreamDefaultControllerError(controller, error);
7333
  }
7334
 }
7335
 function WritableStreamDefaultControllerProcessClose(controller) {
7336
  var stream = controller._controlledWritableStream;
7337
  WritableStreamMarkCloseRequestInFlight(stream);
7338
  DequeueValue(controller);
7339
  var sinkClosePromise = controller._closeAlgorithm();
7340
  WritableStreamDefaultControllerClearAlgorithms(controller);
7341
  uponPromise(sinkClosePromise, function () {
7342
   WritableStreamFinishInFlightClose(stream);
7343
  }, function (reason) {
7344
   WritableStreamFinishInFlightCloseWithError(stream, reason);
7345
  });
7346
 }
7347
 function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
7348
  var stream = controller._controlledWritableStream;
7349
  WritableStreamMarkFirstWriteRequestInFlight(stream);
7350
  var sinkWritePromise = controller._writeAlgorithm(chunk);
7351
  uponPromise(sinkWritePromise, function () {
7352
   WritableStreamFinishInFlightWrite(stream);
7353
   var state = stream._state;
7354
   DequeueValue(controller);
7355
   if (!WritableStreamCloseQueuedOrInFlight(stream) && state === 'writable') {
7356
    var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
7357
    WritableStreamUpdateBackpressure(stream, backpressure);
7358
   }
7359
   WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
7360
  }, function (reason) {
7361
   if (stream._state === 'writable') {
7362
    WritableStreamDefaultControllerClearAlgorithms(controller);
7363
   }
7364
   WritableStreamFinishInFlightWriteWithError(stream, reason);
7365
  });
7366
 }
7367
 function WritableStreamDefaultControllerGetBackpressure(controller) {
7368
  var desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
7369
  return desiredSize <= 0;
7370
 }
7371
 function WritableStreamDefaultControllerError(controller, error) {
7372
  var stream = controller._controlledWritableStream;
7373
  WritableStreamDefaultControllerClearAlgorithms(controller);
7374
  WritableStreamStartErroring(stream, error);
7375
 }
7376
 function streamBrandCheckException(name) {
7377
  return new TypeError("WritableStream.prototype." + name + " can only be used on a WritableStream");
7378
 }
7379
 function defaultWriterBrandCheckException(name) {
7380
  return new TypeError("WritableStreamDefaultWriter.prototype." + name + " can only be used on a WritableStreamDefaultWriter");
7381
 }
7382
 function defaultWriterLockException(name) {
7383
  return new TypeError('Cannot ' + name + ' a stream using a released writer');
7384
 }
7385
 function defaultWriterClosedPromiseInitialize(writer) {
7386
  writer._closedPromise = newPromise(function (resolve, reject) {
7387
   writer._closedPromise_resolve = resolve;
7388
   writer._closedPromise_reject = reject;
7389
   writer._closedPromiseState = 'pending';
7390
  });
7391
 }
7392
 function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {
7393
  defaultWriterClosedPromiseInitialize(writer);
7394
  defaultWriterClosedPromiseReject(writer, reason);
7395
 }
7396
 function defaultWriterClosedPromiseInitializeAsResolved(writer) {
7397
  defaultWriterClosedPromiseInitialize(writer);
7398
  defaultWriterClosedPromiseResolve(writer);
7399
 }
7400
 function defaultWriterClosedPromiseReject(writer, reason) {
7401
  if (writer._closedPromise_reject === undefined) {
7402
   return;
7403
  }
7404
  setPromiseIsHandledToTrue(writer._closedPromise);
7405
  writer._closedPromise_reject(reason);
7406
  writer._closedPromise_resolve = undefined;
7407
  writer._closedPromise_reject = undefined;
7408
  writer._closedPromiseState = 'rejected';
7409
 }
7410
 function defaultWriterClosedPromiseResetToRejected(writer, reason) {
7411
  defaultWriterClosedPromiseInitializeAsRejected(writer, reason);
7412
 }
7413
 function defaultWriterClosedPromiseResolve(writer) {
7414
  if (writer._closedPromise_resolve === undefined) {
7415
   return;
7416
  }
7417
  writer._closedPromise_resolve(undefined);
7418
  writer._closedPromise_resolve = undefined;
7419
  writer._closedPromise_reject = undefined;
7420
  writer._closedPromiseState = 'resolved';
7421
 }
7422
 function defaultWriterReadyPromiseInitialize(writer) {
7423
  writer._readyPromise = newPromise(function (resolve, reject) {
7424
   writer._readyPromise_resolve = resolve;
7425
   writer._readyPromise_reject = reject;
7426
  });
7427
  writer._readyPromiseState = 'pending';
7428
 }
7429
 function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) {
7430
  defaultWriterReadyPromiseInitialize(writer);
7431
  defaultWriterReadyPromiseReject(writer, reason);
7432
 }
7433
 function defaultWriterReadyPromiseInitializeAsResolved(writer) {
7434
  defaultWriterReadyPromiseInitialize(writer);
7435
  defaultWriterReadyPromiseResolve(writer);
7436
 }
7437
 function defaultWriterReadyPromiseReject(writer, reason) {
7438
  if (writer._readyPromise_reject === undefined) {
7439
   return;
7440
  }
7441
  setPromiseIsHandledToTrue(writer._readyPromise);
7442
  writer._readyPromise_reject(reason);
7443
  writer._readyPromise_resolve = undefined;
7444
  writer._readyPromise_reject = undefined;
7445
  writer._readyPromiseState = 'rejected';
7446
 }
7447
 function defaultWriterReadyPromiseReset(writer) {
7448
  defaultWriterReadyPromiseInitialize(writer);
7449
 }
7450
 function defaultWriterReadyPromiseResetToRejected(writer, reason) {
7451
  defaultWriterReadyPromiseInitializeAsRejected(writer, reason);
7452
 }
7453
 function defaultWriterReadyPromiseResolve(writer) {
7454
  if (writer._readyPromise_resolve === undefined) {
7455
   return;
7456
  }
7457
  writer._readyPromise_resolve(undefined);
7458
  writer._readyPromise_resolve = undefined;
7459
  writer._readyPromise_reject = undefined;
7460
  writer._readyPromiseState = 'fulfilled';
7461
 }
7462
 function isAbortSignal(value) {
7463
  if (typeof value !== 'object' || value === null) {
7464
   return false;
7465
  }
7466
  try {
7467
   return typeof value.aborted === 'boolean';
7468
  } catch (_a) {
7469
   return false;
7470
  }
7471
 }
7472
 var NativeDOMException = typeof DOMException !== 'undefined' ? DOMException : undefined;
7473
 function isDOMExceptionConstructor(ctor) {
7474
  if (!(typeof ctor === 'function' || typeof ctor === 'object')) {
7475
   return false;
7476
  }
7477
  try {
7478
   new ctor();
7479
   return true;
7480
  } catch (_a) {
7481
   return false;
7482
  }
7483
 }
7484
 function createDOMExceptionPolyfill() {
7485
  var ctor = function DOMException(message, name) {
7486
   this.message = message || '';
7487
   this.name = name || 'Error';
7488
   if (Error.captureStackTrace) {
7489
    Error.captureStackTrace(this, this.constructor);
7490
   }
7491
  };
7492
  ctor.prototype = Object.create(Error.prototype);
7493
  Object.defineProperty(ctor.prototype, 'constructor', {
7494
   value: ctor,
7495
   writable: true,
7496
   configurable: true
7497
  });
7498
  return ctor;
7499
 }
7500
 var DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill();
7501
 function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {
7502
  var reader = AcquireReadableStreamDefaultReader(source);
7503
  var writer = AcquireWritableStreamDefaultWriter(dest);
7504
  source._disturbed = true;
7505
  var shuttingDown = false;
7506
  var currentWrite = promiseResolvedWith(undefined);
7507
  return newPromise(function (resolve, reject) {
7508
   var abortAlgorithm;
7509
   if (signal !== undefined) {
7510
    abortAlgorithm = function () {
7511
     var error = new DOMException$1('Aborted', 'AbortError');
7512
     var actions = [];
7513
     if (!preventAbort) {
7514
      actions.push(function () {
7515
       if (dest._state === 'writable') {
7516
        return WritableStreamAbort(dest, error);
7517
       }
7518
       return promiseResolvedWith(undefined);
7519
      });
7520
     }
7521
     if (!preventCancel) {
7522
      actions.push(function () {
7523
       if (source._state === 'readable') {
7524
        return ReadableStreamCancel(source, error);
7525
       }
7526
       return promiseResolvedWith(undefined);
7527
      });
7528
     }
7529
     shutdownWithAction(function () {
7530
      return Promise.all(actions.map(function (action) {
7531
       return action();
7532
      }));
7533
     }, true, error);
7534
    };
7535
    if (signal.aborted) {
7536
     abortAlgorithm();
7537
     return;
7538
    }
7539
    signal.addEventListener('abort', abortAlgorithm);
7540
   }
7541
   function pipeLoop() {
7542
    return newPromise(function (resolveLoop, rejectLoop) {
7543
     function next(done) {
7544
      if (done) {
7545
       resolveLoop();
7546
      } else {
7547
       PerformPromiseThen(pipeStep(), next, rejectLoop);
7548
      }
7549
     }
7550
     next(false);
7551
    });
7552
   }
7553
   function pipeStep() {
7554
    if (shuttingDown) {
7555
     return promiseResolvedWith(true);
7556
    }
7557
    return PerformPromiseThen(writer._readyPromise, function () {
7558
     return newPromise(function (resolveRead, rejectRead) {
7559
      ReadableStreamDefaultReaderRead(reader, {
7560
       _chunkSteps: function (chunk) {
7561
        currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, chunk), undefined, noop);
7562
        resolveRead(false);
7563
       },
7564
       _closeSteps: function () {
7565
        return resolveRead(true);
7566
       },
7567
       _errorSteps: rejectRead
7568
      });
7569
     });
7570
    });
7571
   }
7572
   isOrBecomesErrored(source, reader._closedPromise, function (storedError) {
7573
    if (!preventAbort) {
7574
     shutdownWithAction(function () {
7575
      return WritableStreamAbort(dest, storedError);
7576
     }, true, storedError);
7577
    } else {
7578
     shutdown(true, storedError);
7579
    }
7580
   });
7581
   isOrBecomesErrored(dest, writer._closedPromise, function (storedError) {
7582
    if (!preventCancel) {
7583
     shutdownWithAction(function () {
7584
      return ReadableStreamCancel(source, storedError);
7585
     }, true, storedError);
7586
    } else {
7587
     shutdown(true, storedError);
7588
    }
7589
   });
7590
   isOrBecomesClosed(source, reader._closedPromise, function () {
7591
    if (!preventClose) {
7592
     shutdownWithAction(function () {
7593
      return WritableStreamDefaultWriterCloseWithErrorPropagation(writer);
7594
     });
7595
    } else {
7596
     shutdown();
7597
    }
7598
   });
7599
   if (WritableStreamCloseQueuedOrInFlight(dest) || dest._state === 'closed') {
7600
    var destClosed_1 = new TypeError('the destination writable stream closed before all data could be piped to it');
7601
    if (!preventCancel) {
7602
     shutdownWithAction(function () {
7603
      return ReadableStreamCancel(source, destClosed_1);
7604
     }, true, destClosed_1);
7605
    } else {
7606
     shutdown(true, destClosed_1);
7607
    }
7608
   }
7609
   setPromiseIsHandledToTrue(pipeLoop());
7610
   function waitForWritesToFinish() {
7611
    var oldCurrentWrite = currentWrite;
7612
    return PerformPromiseThen(currentWrite, function () {
7613
     return oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined;
7614
    });
7615
   }
7616
   function isOrBecomesErrored(stream, promise, action) {
7617
    if (stream._state === 'errored') {
7618
     action(stream._storedError);
7619
    } else {
7620
     uponRejection(promise, action);
7621
    }
7622
   }
7623
   function isOrBecomesClosed(stream, promise, action) {
7624
    if (stream._state === 'closed') {
7625
     action();
7626
    } else {
7627
     uponFulfillment(promise, action);
7628
    }
7629
   }
7630
   function shutdownWithAction(action, originalIsError, originalError) {
7631
    if (shuttingDown) {
7632
     return;
7633
    }
7634
    shuttingDown = true;
7635
    if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) {
7636
     uponFulfillment(waitForWritesToFinish(), doTheRest);
7637
    } else {
7638
     doTheRest();
7639
    }
7640
    function doTheRest() {
7641
     uponPromise(action(), function () {
7642
      return finalize(originalIsError, originalError);
7643
     }, function (newError) {
7644
      return finalize(true, newError);
7645
     });
7646
    }
7647
   }
7648
   function shutdown(isError, error) {
7649
    if (shuttingDown) {
7650
     return;
7651
    }
7652
    shuttingDown = true;
7653
    if (dest._state === 'writable' && !WritableStreamCloseQueuedOrInFlight(dest)) {
7654
     uponFulfillment(waitForWritesToFinish(), function () {
7655
      return finalize(isError, error);
7656
     });
7657
    } else {
7658
     finalize(isError, error);
7659
    }
7660
   }
7661
   function finalize(isError, error) {
7662
    WritableStreamDefaultWriterRelease(writer);
7663
    ReadableStreamReaderGenericRelease(reader);
7664
    if (signal !== undefined) {
7665
     signal.removeEventListener('abort', abortAlgorithm);
7666
    }
7667
    if (isError) {
7668
     reject(error);
7669
    } else {
7670
     resolve(undefined);
7671
    }
7672
   }
7673
  });
7674
 }
7675
 var ReadableStreamDefaultController = function () {
7676
  function ReadableStreamDefaultController() {
7677
   throw new TypeError('Illegal constructor');
7678
  }
7679
  Object.defineProperty(ReadableStreamDefaultController.prototype, "desiredSize", {
7680
   get: function () {
7681
    if (!IsReadableStreamDefaultController(this)) {
7682
     throw defaultControllerBrandCheckException('desiredSize');
7683
    }
7684
    return ReadableStreamDefaultControllerGetDesiredSize(this);
7685
   },
7686
   enumerable: false,
7687
   configurable: true
7688
  });
7689
  ReadableStreamDefaultController.prototype.close = function () {
7690
   if (!IsReadableStreamDefaultController(this)) {
7691
    throw defaultControllerBrandCheckException('close');
7692
   }
7693
   if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {
7694
    throw new TypeError('The stream is not in a state that permits close');
7695
   }
7696
   ReadableStreamDefaultControllerClose(this);
7697
  };
7698
  ReadableStreamDefaultController.prototype.enqueue = function (chunk) {
7699
   if (chunk === void 0) {
7700
    chunk = undefined;
7701
   }
7702
   if (!IsReadableStreamDefaultController(this)) {
7703
    throw defaultControllerBrandCheckException('enqueue');
7704
   }
7705
   if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(this)) {
7706
    throw new TypeError('The stream is not in a state that permits enqueue');
7707
   }
7708
   return ReadableStreamDefaultControllerEnqueue(this, chunk);
7709
  };
7710
  ReadableStreamDefaultController.prototype.error = function (e) {
7711
   if (e === void 0) {
7712
    e = undefined;
7713
   }
7714
   if (!IsReadableStreamDefaultController(this)) {
7715
    throw defaultControllerBrandCheckException('error');
7716
   }
7717
   ReadableStreamDefaultControllerError(this, e);
7718
  };
7719
  ReadableStreamDefaultController.prototype[CancelSteps] = function (reason) {
7720
   ResetQueue(this);
7721
   var result = this._cancelAlgorithm(reason);
7722
   ReadableStreamDefaultControllerClearAlgorithms(this);
7723
   return result;
7724
  };
7725
  ReadableStreamDefaultController.prototype[PullSteps] = function (readRequest) {
7726
   var stream = this._controlledReadableStream;
7727
   if (this._queue.length > 0) {
7728
    var chunk = DequeueValue(this);
7729
    if (this._closeRequested && this._queue.length === 0) {
7730
     ReadableStreamDefaultControllerClearAlgorithms(this);
7731
     ReadableStreamClose(stream);
7732
    } else {
7733
     ReadableStreamDefaultControllerCallPullIfNeeded(this);
7734
    }
7735
    readRequest._chunkSteps(chunk);
7736
   } else {
7737
    ReadableStreamAddReadRequest(stream, readRequest);
7738
    ReadableStreamDefaultControllerCallPullIfNeeded(this);
7739
   }
7740
  };
7741
  return ReadableStreamDefaultController;
7742
 }();
7743
 Object.defineProperties(ReadableStreamDefaultController.prototype, {
7744
  close: { enumerable: true },
7745
  enqueue: { enumerable: true },
7746
  error: { enumerable: true },
7747
  desiredSize: { enumerable: true }
7748
 });
7749
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
7750
  Object.defineProperty(ReadableStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
7751
   value: 'ReadableStreamDefaultController',
7752
   configurable: true
7753
  });
7754
 }
7755
 function IsReadableStreamDefaultController(x) {
7756
  if (!typeIsObject(x)) {
7757
   return false;
7758
  }
7759
  if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {
7760
   return false;
7761
  }
7762
  return true;
7763
 }
7764
 function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
7765
  var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
7766
  if (!shouldPull) {
7767
   return;
7768
  }
7769
  if (controller._pulling) {
7770
   controller._pullAgain = true;
7771
   return;
7772
  }
7773
  controller._pulling = true;
7774
  var pullPromise = controller._pullAlgorithm();
7775
  uponPromise(pullPromise, function () {
7776
   controller._pulling = false;
7777
   if (controller._pullAgain) {
7778
    controller._pullAgain = false;
7779
    ReadableStreamDefaultControllerCallPullIfNeeded(controller);
7780
   }
7781
  }, function (e) {
7782
   ReadableStreamDefaultControllerError(controller, e);
7783
  });
7784
 }
7785
 function ReadableStreamDefaultControllerShouldCallPull(controller) {
7786
  var stream = controller._controlledReadableStream;
7787
  if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {
7788
   return false;
7789
  }
7790
  if (!controller._started) {
7791
   return false;
7792
  }
7793
  if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {
7794
   return true;
7795
  }
7796
  var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
7797
  if (desiredSize > 0) {
7798
   return true;
7799
  }
7800
  return false;
7801
 }
7802
 function ReadableStreamDefaultControllerClearAlgorithms(controller) {
7803
  controller._pullAlgorithm = undefined;
7804
  controller._cancelAlgorithm = undefined;
7805
  controller._strategySizeAlgorithm = undefined;
7806
 }
7807
 function ReadableStreamDefaultControllerClose(controller) {
7808
  if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {
7809
   return;
7810
  }
7811
  var stream = controller._controlledReadableStream;
7812
  controller._closeRequested = true;
7813
  if (controller._queue.length === 0) {
7814
   ReadableStreamDefaultControllerClearAlgorithms(controller);
7815
   ReadableStreamClose(stream);
7816
  }
7817
 }
7818
 function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
7819
  if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(controller)) {
7820
   return;
7821
  }
7822
  var stream = controller._controlledReadableStream;
7823
  if (IsReadableStreamLocked(stream) && ReadableStreamGetNumReadRequests(stream) > 0) {
7824
   ReadableStreamFulfillReadRequest(stream, chunk, false);
7825
  } else {
7826
   var chunkSize = void 0;
7827
   try {
7828
    chunkSize = controller._strategySizeAlgorithm(chunk);
7829
   } catch (chunkSizeE) {
7830
    ReadableStreamDefaultControllerError(controller, chunkSizeE);
7831
    throw chunkSizeE;
7832
   }
7833
   try {
7834
    EnqueueValueWithSize(controller, chunk, chunkSize);
7835
   } catch (enqueueE) {
7836
    ReadableStreamDefaultControllerError(controller, enqueueE);
7837
    throw enqueueE;
7838
   }
7839
  }
7840
  ReadableStreamDefaultControllerCallPullIfNeeded(controller);
7841
 }
7842
 function ReadableStreamDefaultControllerError(controller, e) {
7843
  var stream = controller._controlledReadableStream;
7844
  if (stream._state !== 'readable') {
7845
   return;
7846
  }
7847
  ResetQueue(controller);
7848
  ReadableStreamDefaultControllerClearAlgorithms(controller);
7849
  ReadableStreamError(stream, e);
7850
 }
7851
 function ReadableStreamDefaultControllerGetDesiredSize(controller) {
7852
  var state = controller._controlledReadableStream._state;
7853
  if (state === 'errored') {
7854
   return null;
7855
  }
7856
  if (state === 'closed') {
7857
   return 0;
7858
  }
7859
  return controller._strategyHWM - controller._queueTotalSize;
7860
 }
7861
 function ReadableStreamDefaultControllerHasBackpressure(controller) {
7862
  if (ReadableStreamDefaultControllerShouldCallPull(controller)) {
7863
   return false;
7864
  }
7865
  return true;
7866
 }
7867
 function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) {
7868
  var state = controller._controlledReadableStream._state;
7869
  if (!controller._closeRequested && state === 'readable') {
7870
   return true;
7871
  }
7872
  return false;
7873
 }
7874
 function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {
7875
  controller._controlledReadableStream = stream;
7876
  controller._queue = undefined;
7877
  controller._queueTotalSize = undefined;
7878
  ResetQueue(controller);
7879
  controller._started = false;
7880
  controller._closeRequested = false;
7881
  controller._pullAgain = false;
7882
  controller._pulling = false;
7883
  controller._strategySizeAlgorithm = sizeAlgorithm;
7884
  controller._strategyHWM = highWaterMark;
7885
  controller._pullAlgorithm = pullAlgorithm;
7886
  controller._cancelAlgorithm = cancelAlgorithm;
7887
  stream._readableStreamController = controller;
7888
  var startResult = startAlgorithm();
7889
  uponPromise(promiseResolvedWith(startResult), function () {
7890
   controller._started = true;
7891
   ReadableStreamDefaultControllerCallPullIfNeeded(controller);
7892
  }, function (r) {
7893
   ReadableStreamDefaultControllerError(controller, r);
7894
  });
7895
 }
7896
 function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {
7897
  var controller = Object.create(ReadableStreamDefaultController.prototype);
7898
  var startAlgorithm = function () {
7899
   return undefined;
7900
  };
7901
  var pullAlgorithm = function () {
7902
   return promiseResolvedWith(undefined);
7903
  };
7904
  var cancelAlgorithm = function () {
7905
   return promiseResolvedWith(undefined);
7906
  };
7907
  if (underlyingSource.start !== undefined) {
7908
   startAlgorithm = function () {
7909
    return underlyingSource.start(controller);
7910
   };
7911
  }
7912
  if (underlyingSource.pull !== undefined) {
7913
   pullAlgorithm = function () {
7914
    return underlyingSource.pull(controller);
7915
   };
7916
  }
7917
  if (underlyingSource.cancel !== undefined) {
7918
   cancelAlgorithm = function (reason) {
7919
    return underlyingSource.cancel(reason);
7920
   };
7921
  }
7922
  SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
7923
 }
7924
 function defaultControllerBrandCheckException(name) {
7925
  return new TypeError("ReadableStreamDefaultController.prototype." + name + " can only be used on a ReadableStreamDefaultController");
7926
 }
7927
 function ReadableStreamTee(stream, cloneForBranch2) {
7928
  var reader = AcquireReadableStreamDefaultReader(stream);
7929
  var reading = false;
7930
  var canceled1 = false;
7931
  var canceled2 = false;
7932
  var reason1;
7933
  var reason2;
7934
  var branch1;
7935
  var branch2;
7936
  var resolveCancelPromise;
7937
  var cancelPromise = newPromise(function (resolve) {
7938
   resolveCancelPromise = resolve;
7939
  });
7940
  function pullAlgorithm() {
7941
   if (reading) {
7942
    return promiseResolvedWith(undefined);
7943
   }
7944
   reading = true;
7945
   var readRequest = {
7946
    _chunkSteps: function (value) {
7947
     queueMicrotask(function () {
7948
      reading = false;
7949
      var value1 = value;
7950
      var value2 = value;
7951
      if (!canceled1) {
7952
       ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, value1);
7953
      }
7954
      if (!canceled2) {
7955
       ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, value2);
7956
      }
7957
      resolveCancelPromise(undefined);
7958
     });
7959
    },
7960
    _closeSteps: function () {
7961
     reading = false;
7962
     if (!canceled1) {
7963
      ReadableStreamDefaultControllerClose(branch1._readableStreamController);
7964
     }
7965
     if (!canceled2) {
7966
      ReadableStreamDefaultControllerClose(branch2._readableStreamController);
7967
     }
7968
    },
7969
    _errorSteps: function () {
7970
     reading = false;
7971
    }
7972
   };
7973
   ReadableStreamDefaultReaderRead(reader, readRequest);
7974
   return promiseResolvedWith(undefined);
7975
  }
7976
  function cancel1Algorithm(reason) {
7977
   canceled1 = true;
7978
   reason1 = reason;
7979
   if (canceled2) {
7980
    var compositeReason = CreateArrayFromList([
7981
     reason1,
7982
     reason2
7983
    ]);
7984
    var cancelResult = ReadableStreamCancel(stream, compositeReason);
7985
    resolveCancelPromise(cancelResult);
7986
   }
7987
   return cancelPromise;
7988
  }
7989
  function cancel2Algorithm(reason) {
7990
   canceled2 = true;
7991
   reason2 = reason;
7992
   if (canceled1) {
7993
    var compositeReason = CreateArrayFromList([
7994
     reason1,
7995
     reason2
7996
    ]);
7997
    var cancelResult = ReadableStreamCancel(stream, compositeReason);
7998
    resolveCancelPromise(cancelResult);
7999
   }
8000
   return cancelPromise;
8001
  }
8002
  function startAlgorithm() {
8003
  }
8004
  branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm);
8005
  branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm);
8006
  uponRejection(reader._closedPromise, function (r) {
8007
   ReadableStreamDefaultControllerError(branch1._readableStreamController, r);
8008
   ReadableStreamDefaultControllerError(branch2._readableStreamController, r);
8009
   resolveCancelPromise(undefined);
8010
  });
8011
  return [
8012
   branch1,
8013
   branch2
8014
  ];
8015
 }
8016
 function convertUnderlyingDefaultOrByteSource(source, context) {
8017
  assertDictionary(source, context);
8018
  var original = source;
8019
  var autoAllocateChunkSize = original === null || original === void 0 ? void 0 : original.autoAllocateChunkSize;
8020
  var cancel = original === null || original === void 0 ? void 0 : original.cancel;
8021
  var pull = original === null || original === void 0 ? void 0 : original.pull;
8022
  var start = original === null || original === void 0 ? void 0 : original.start;
8023
  var type = original === null || original === void 0 ? void 0 : original.type;
8024
  return {
8025
   autoAllocateChunkSize: autoAllocateChunkSize === undefined ? undefined : convertUnsignedLongLongWithEnforceRange(autoAllocateChunkSize, context + " has member 'autoAllocateChunkSize' that"),
8026
   cancel: cancel === undefined ? undefined : convertUnderlyingSourceCancelCallback(cancel, original, context + " has member 'cancel' that"),
8027
   pull: pull === undefined ? undefined : convertUnderlyingSourcePullCallback(pull, original, context + " has member 'pull' that"),
8028
   start: start === undefined ? undefined : convertUnderlyingSourceStartCallback(start, original, context + " has member 'start' that"),
8029
   type: type === undefined ? undefined : convertReadableStreamType(type, context + " has member 'type' that")
8030
  };
8031
 }
8032
 function convertUnderlyingSourceCancelCallback(fn, original, context) {
8033
  assertFunction(fn, context);
8034
  return function (reason) {
8035
   return promiseCall(fn, original, [reason]);
8036
  };
8037
 }
8038
 function convertUnderlyingSourcePullCallback(fn, original, context) {
8039
  assertFunction(fn, context);
8040
  return function (controller) {
8041
   return promiseCall(fn, original, [controller]);
8042
  };
8043
 }
8044
 function convertUnderlyingSourceStartCallback(fn, original, context) {
8045
  assertFunction(fn, context);
8046
  return function (controller) {
8047
   return reflectCall(fn, original, [controller]);
8048
  };
8049
 }
8050
 function convertReadableStreamType(type, context) {
8051
  type = "" + type;
8052
  if (type !== 'bytes') {
8053
   throw new TypeError(context + " '" + type + "' is not a valid enumeration value for ReadableStreamType");
8054
  }
8055
  return type;
8056
 }
8057
 function convertReaderOptions(options, context) {
8058
  assertDictionary(options, context);
8059
  var mode = options === null || options === void 0 ? void 0 : options.mode;
8060
  return { mode: mode === undefined ? undefined : convertReadableStreamReaderMode(mode, context + " has member 'mode' that") };
8061
 }
8062
 function convertReadableStreamReaderMode(mode, context) {
8063
  mode = "" + mode;
8064
  if (mode !== 'byob') {
8065
   throw new TypeError(context + " '" + mode + "' is not a valid enumeration value for ReadableStreamReaderMode");
8066
  }
8067
  return mode;
8068
 }
8069
 function convertIteratorOptions(options, context) {
8070
  assertDictionary(options, context);
8071
  var preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;
8072
  return { preventCancel: Boolean(preventCancel) };
8073
 }
8074
 function convertPipeOptions(options, context) {
8075
  assertDictionary(options, context);
8076
  var preventAbort = options === null || options === void 0 ? void 0 : options.preventAbort;
8077
  var preventCancel = options === null || options === void 0 ? void 0 : options.preventCancel;
8078
  var preventClose = options === null || options === void 0 ? void 0 : options.preventClose;
8079
  var signal = options === null || options === void 0 ? void 0 : options.signal;
8080
  if (signal !== undefined) {
8081
   assertAbortSignal(signal, context + " has member 'signal' that");
8082
  }
8083
  return {
8084
   preventAbort: Boolean(preventAbort),
8085
   preventCancel: Boolean(preventCancel),
8086
   preventClose: Boolean(preventClose),
8087
   signal: signal
8088
  };
8089
 }
8090
 function assertAbortSignal(signal, context) {
8091
  if (!isAbortSignal(signal)) {
8092
   throw new TypeError(context + " is not an AbortSignal.");
8093
  }
8094
 }
8095
 function convertReadableWritablePair(pair, context) {
8096
  assertDictionary(pair, context);
8097
  var readable = pair === null || pair === void 0 ? void 0 : pair.readable;
8098
  assertRequiredField(readable, 'readable', 'ReadableWritablePair');
8099
  assertReadableStream(readable, context + " has member 'readable' that");
8100
  var writable = pair === null || pair === void 0 ? void 0 : pair.writable;
8101
  assertRequiredField(writable, 'writable', 'ReadableWritablePair');
8102
  assertWritableStream(writable, context + " has member 'writable' that");
8103
  return {
8104
   readable: readable,
8105
   writable: writable
8106
  };
8107
 }
8108
 var ReadableStream = function () {
8109
  function ReadableStream(rawUnderlyingSource, rawStrategy) {
8110
   if (rawUnderlyingSource === void 0) {
8111
    rawUnderlyingSource = {};
8112
   }
8113
   if (rawStrategy === void 0) {
8114
    rawStrategy = {};
8115
   }
8116
   if (rawUnderlyingSource === undefined) {
8117
    rawUnderlyingSource = null;
8118
   } else {
8119
    assertObject(rawUnderlyingSource, 'First parameter');
8120
   }
8121
   var strategy = convertQueuingStrategy(rawStrategy, 'Second parameter');
8122
   var underlyingSource = convertUnderlyingDefaultOrByteSource(rawUnderlyingSource, 'First parameter');
8123
   InitializeReadableStream(this);
8124
   if (underlyingSource.type === 'bytes') {
8125
    if (strategy.size !== undefined) {
8126
     throw new RangeError('The strategy for a byte stream cannot have a size function');
8127
    }
8128
    var highWaterMark = ExtractHighWaterMark(strategy, 0);
8129
    SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, highWaterMark);
8130
   } else {
8131
    var sizeAlgorithm = ExtractSizeAlgorithm(strategy);
8132
    var highWaterMark = ExtractHighWaterMark(strategy, 1);
8133
    SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm);
8134
   }
8135
  }
8136
  Object.defineProperty(ReadableStream.prototype, "locked", {
8137
   get: function () {
8138
    if (!IsReadableStream(this)) {
8139
     throw streamBrandCheckException$1('locked');
8140
    }
8141
    return IsReadableStreamLocked(this);
8142
   },
8143
   enumerable: false,
8144
   configurable: true
8145
  });
8146
  ReadableStream.prototype.cancel = function (reason) {
8147
   if (reason === void 0) {
8148
    reason = undefined;
8149
   }
8150
   if (!IsReadableStream(this)) {
8151
    return promiseRejectedWith(streamBrandCheckException$1('cancel'));
8152
   }
8153
   if (IsReadableStreamLocked(this)) {
8154
    return promiseRejectedWith(new TypeError('Cannot cancel a stream that already has a reader'));
8155
   }
8156
   return ReadableStreamCancel(this, reason);
8157
  };
8158
  ReadableStream.prototype.getReader = function (rawOptions) {
8159
   if (rawOptions === void 0) {
8160
    rawOptions = undefined;
8161
   }
8162
   if (!IsReadableStream(this)) {
8163
    throw streamBrandCheckException$1('getReader');
8164
   }
8165
   var options = convertReaderOptions(rawOptions, 'First parameter');
8166
   if (options.mode === undefined) {
8167
    return AcquireReadableStreamDefaultReader(this);
8168
   }
8169
   return AcquireReadableStreamBYOBReader(this);
8170
  };
8171
  ReadableStream.prototype.pipeThrough = function (rawTransform, rawOptions) {
8172
   if (rawOptions === void 0) {
8173
    rawOptions = {};
8174
   }
8175
   if (!IsReadableStream(this)) {
8176
    throw streamBrandCheckException$1('pipeThrough');
8177
   }
8178
   assertRequiredArgument(rawTransform, 1, 'pipeThrough');
8179
   var transform = convertReadableWritablePair(rawTransform, 'First parameter');
8180
   var options = convertPipeOptions(rawOptions, 'Second parameter');
8181
   if (IsReadableStreamLocked(this)) {
8182
    throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream');
8183
   }
8184
   if (IsWritableStreamLocked(transform.writable)) {
8185
    throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream');
8186
   }
8187
   var promise = ReadableStreamPipeTo(this, transform.writable, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
8188
   setPromiseIsHandledToTrue(promise);
8189
   return transform.readable;
8190
  };
8191
  ReadableStream.prototype.pipeTo = function (destination, rawOptions) {
8192
   if (rawOptions === void 0) {
8193
    rawOptions = {};
8194
   }
8195
   if (!IsReadableStream(this)) {
8196
    return promiseRejectedWith(streamBrandCheckException$1('pipeTo'));
8197
   }
8198
   if (destination === undefined) {
8199
    return promiseRejectedWith("Parameter 1 is required in 'pipeTo'.");
8200
   }
8201
   if (!IsWritableStream(destination)) {
8202
    return promiseRejectedWith(new TypeError("ReadableStream.prototype.pipeTo's first argument must be a WritableStream"));
8203
   }
8204
   var options;
8205
   try {
8206
    options = convertPipeOptions(rawOptions, 'Second parameter');
8207
   } catch (e) {
8208
    return promiseRejectedWith(e);
8209
   }
8210
   if (IsReadableStreamLocked(this)) {
8211
    return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream'));
8212
   }
8213
   if (IsWritableStreamLocked(destination)) {
8214
    return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream'));
8215
   }
8216
   return ReadableStreamPipeTo(this, destination, options.preventClose, options.preventAbort, options.preventCancel, options.signal);
8217
  };
8218
  ReadableStream.prototype.tee = function () {
8219
   if (!IsReadableStream(this)) {
8220
    throw streamBrandCheckException$1('tee');
8221
   }
8222
   var branches = ReadableStreamTee(this);
8223
   return CreateArrayFromList(branches);
8224
  };
8225
  ReadableStream.prototype.values = function (rawOptions) {
8226
   if (rawOptions === void 0) {
8227
    rawOptions = undefined;
8228
   }
8229
   if (!IsReadableStream(this)) {
8230
    throw streamBrandCheckException$1('values');
8231
   }
8232
   var options = convertIteratorOptions(rawOptions, 'First parameter');
8233
   return AcquireReadableStreamAsyncIterator(this, options.preventCancel);
8234
  };
8235
  return ReadableStream;
8236
 }();
8237
 Object.defineProperties(ReadableStream.prototype, {
8238
  cancel: { enumerable: true },
8239
  getReader: { enumerable: true },
8240
  pipeThrough: { enumerable: true },
8241
  pipeTo: { enumerable: true },
8242
  tee: { enumerable: true },
8243
  values: { enumerable: true },
8244
  locked: { enumerable: true }
8245
 });
8246
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
8247
  Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.toStringTag, {
8248
   value: 'ReadableStream',
8249
   configurable: true
8250
  });
8251
 }
8252
 if (typeof SymbolPolyfill.asyncIterator === 'symbol') {
8253
  Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.asyncIterator, {
8254
   value: ReadableStream.prototype.values,
8255
   writable: true,
8256
   configurable: true
8257
  });
8258
 }
8259
 function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {
8260
  if (highWaterMark === void 0) {
8261
   highWaterMark = 1;
8262
  }
8263
  if (sizeAlgorithm === void 0) {
8264
   sizeAlgorithm = function () {
8265
    return 1;
8266
   };
8267
  }
8268
  var stream = Object.create(ReadableStream.prototype);
8269
  InitializeReadableStream(stream);
8270
  var controller = Object.create(ReadableStreamDefaultController.prototype);
8271
  SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);
8272
  return stream;
8273
 }
8274
 function InitializeReadableStream(stream) {
8275
  stream._state = 'readable';
8276
  stream._reader = undefined;
8277
  stream._storedError = undefined;
8278
  stream._disturbed = false;
8279
 }
8280
 function IsReadableStream(x) {
8281
  if (!typeIsObject(x)) {
8282
   return false;
8283
  }
8284
  if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
8285
   return false;
8286
  }
8287
  return true;
8288
 }
8289
 function IsReadableStreamLocked(stream) {
8290
  if (stream._reader === undefined) {
8291
   return false;
8292
  }
8293
  return true;
8294
 }
8295
 function ReadableStreamCancel(stream, reason) {
8296
  stream._disturbed = true;
8297
  if (stream._state === 'closed') {
8298
   return promiseResolvedWith(undefined);
8299
  }
8300
  if (stream._state === 'errored') {
8301
   return promiseRejectedWith(stream._storedError);
8302
  }
8303
  ReadableStreamClose(stream);
8304
  var sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);
8305
  return transformPromiseWith(sourceCancelPromise, noop);
8306
 }
8307
 function ReadableStreamClose(stream) {
8308
  stream._state = 'closed';
8309
  var reader = stream._reader;
8310
  if (reader === undefined) {
8311
   return;
8312
  }
8313
  defaultReaderClosedPromiseResolve(reader);
8314
  if (IsReadableStreamDefaultReader(reader)) {
8315
   reader._readRequests.forEach(function (readRequest) {
8316
    readRequest._closeSteps();
8317
   });
8318
   reader._readRequests = new SimpleQueue();
8319
  }
8320
 }
8321
 function ReadableStreamError(stream, e) {
8322
  stream._state = 'errored';
8323
  stream._storedError = e;
8324
  var reader = stream._reader;
8325
  if (reader === undefined) {
8326
   return;
8327
  }
8328
  defaultReaderClosedPromiseReject(reader, e);
8329
  if (IsReadableStreamDefaultReader(reader)) {
8330
   reader._readRequests.forEach(function (readRequest) {
8331
    readRequest._errorSteps(e);
8332
   });
8333
   reader._readRequests = new SimpleQueue();
8334
  } else {
8335
   reader._readIntoRequests.forEach(function (readIntoRequest) {
8336
    readIntoRequest._errorSteps(e);
8337
   });
8338
   reader._readIntoRequests = new SimpleQueue();
8339
  }
8340
 }
8341
 function streamBrandCheckException$1(name) {
8342
  return new TypeError("ReadableStream.prototype." + name + " can only be used on a ReadableStream");
8343
 }
8344
 function convertQueuingStrategyInit(init, context) {
8345
  assertDictionary(init, context);
8346
  var highWaterMark = init === null || init === void 0 ? void 0 : init.highWaterMark;
8347
  assertRequiredField(highWaterMark, 'highWaterMark', 'QueuingStrategyInit');
8348
  return { highWaterMark: convertUnrestrictedDouble(highWaterMark) };
8349
 }
8350
 var byteLengthSizeFunction = function size(chunk) {
8351
  return chunk.byteLength;
8352
 };
8353
 var ByteLengthQueuingStrategy = function () {
8354
  function ByteLengthQueuingStrategy(options) {
8355
   assertRequiredArgument(options, 1, 'ByteLengthQueuingStrategy');
8356
   options = convertQueuingStrategyInit(options, 'First parameter');
8357
   this._byteLengthQueuingStrategyHighWaterMark = options.highWaterMark;
8358
  }
8359
  Object.defineProperty(ByteLengthQueuingStrategy.prototype, "highWaterMark", {
8360
   get: function () {
8361
    if (!IsByteLengthQueuingStrategy(this)) {
8362
     throw byteLengthBrandCheckException('highWaterMark');
8363
    }
8364
    return this._byteLengthQueuingStrategyHighWaterMark;
8365
   },
8366
   enumerable: false,
8367
   configurable: true
8368
  });
8369
  Object.defineProperty(ByteLengthQueuingStrategy.prototype, "size", {
8370
   get: function () {
8371
    if (!IsByteLengthQueuingStrategy(this)) {
8372
     throw byteLengthBrandCheckException('size');
8373
    }
8374
    return byteLengthSizeFunction;
8375
   },
8376
   enumerable: false,
8377
   configurable: true
8378
  });
8379
  return ByteLengthQueuingStrategy;
8380
 }();
8381
 Object.defineProperties(ByteLengthQueuingStrategy.prototype, {
8382
  highWaterMark: { enumerable: true },
8383
  size: { enumerable: true }
8384
 });
8385
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
8386
  Object.defineProperty(ByteLengthQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {
8387
   value: 'ByteLengthQueuingStrategy',
8388
   configurable: true
8389
  });
8390
 }
8391
 function byteLengthBrandCheckException(name) {
8392
  return new TypeError("ByteLengthQueuingStrategy.prototype." + name + " can only be used on a ByteLengthQueuingStrategy");
8393
 }
8394
 function IsByteLengthQueuingStrategy(x) {
8395
  if (!typeIsObject(x)) {
8396
   return false;
8397
  }
8398
  if (!Object.prototype.hasOwnProperty.call(x, '_byteLengthQueuingStrategyHighWaterMark')) {
8399
   return false;
8400
  }
8401
  return true;
8402
 }
8403
 var countSizeFunction = function size() {
8404
  return 1;
8405
 };
8406
 var CountQueuingStrategy = function () {
8407
  function CountQueuingStrategy(options) {
8408
   assertRequiredArgument(options, 1, 'CountQueuingStrategy');
8409
   options = convertQueuingStrategyInit(options, 'First parameter');
8410
   this._countQueuingStrategyHighWaterMark = options.highWaterMark;
8411
  }
8412
  Object.defineProperty(CountQueuingStrategy.prototype, "highWaterMark", {
8413
   get: function () {
8414
    if (!IsCountQueuingStrategy(this)) {
8415
     throw countBrandCheckException('highWaterMark');
8416
    }
8417
    return this._countQueuingStrategyHighWaterMark;
8418
   },
8419
   enumerable: false,
8420
   configurable: true
8421
  });
8422
  Object.defineProperty(CountQueuingStrategy.prototype, "size", {
8423
   get: function () {
8424
    if (!IsCountQueuingStrategy(this)) {
8425
     throw countBrandCheckException('size');
8426
    }
8427
    return countSizeFunction;
8428
   },
8429
   enumerable: false,
8430
   configurable: true
8431
  });
8432
  return CountQueuingStrategy;
8433
 }();
8434
 Object.defineProperties(CountQueuingStrategy.prototype, {
8435
  highWaterMark: { enumerable: true },
8436
  size: { enumerable: true }
8437
 });
8438
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
8439
  Object.defineProperty(CountQueuingStrategy.prototype, SymbolPolyfill.toStringTag, {
8440
   value: 'CountQueuingStrategy',
8441
   configurable: true
8442
  });
8443
 }
8444
 function countBrandCheckException(name) {
8445
  return new TypeError("CountQueuingStrategy.prototype." + name + " can only be used on a CountQueuingStrategy");
8446
 }
8447
 function IsCountQueuingStrategy(x) {
8448
  if (!typeIsObject(x)) {
8449
   return false;
8450
  }
8451
  if (!Object.prototype.hasOwnProperty.call(x, '_countQueuingStrategyHighWaterMark')) {
8452
   return false;
8453
  }
8454
  return true;
8455
 }
8456
 function convertTransformer(original, context) {
8457
  assertDictionary(original, context);
8458
  var flush = original === null || original === void 0 ? void 0 : original.flush;
8459
  var readableType = original === null || original === void 0 ? void 0 : original.readableType;
8460
  var start = original === null || original === void 0 ? void 0 : original.start;
8461
  var transform = original === null || original === void 0 ? void 0 : original.transform;
8462
  var writableType = original === null || original === void 0 ? void 0 : original.writableType;
8463
  return {
8464
   flush: flush === undefined ? undefined : convertTransformerFlushCallback(flush, original, context + " has member 'flush' that"),
8465
   readableType: readableType,
8466
   start: start === undefined ? undefined : convertTransformerStartCallback(start, original, context + " has member 'start' that"),
8467
   transform: transform === undefined ? undefined : convertTransformerTransformCallback(transform, original, context + " has member 'transform' that"),
8468
   writableType: writableType
8469
  };
8470
 }
8471
 function convertTransformerFlushCallback(fn, original, context) {
8472
  assertFunction(fn, context);
8473
  return function (controller) {
8474
   return promiseCall(fn, original, [controller]);
8475
  };
8476
 }
8477
 function convertTransformerStartCallback(fn, original, context) {
8478
  assertFunction(fn, context);
8479
  return function (controller) {
8480
   return reflectCall(fn, original, [controller]);
8481
  };
8482
 }
8483
 function convertTransformerTransformCallback(fn, original, context) {
8484
  assertFunction(fn, context);
8485
  return function (chunk, controller) {
8486
   return promiseCall(fn, original, [
8487
    chunk,
8488
    controller
8489
   ]);
8490
  };
8491
 }
8492
 var TransformStream = function () {
8493
  function TransformStream(rawTransformer, rawWritableStrategy, rawReadableStrategy) {
8494
   if (rawTransformer === void 0) {
8495
    rawTransformer = {};
8496
   }
8497
   if (rawWritableStrategy === void 0) {
8498
    rawWritableStrategy = {};
8499
   }
8500
   if (rawReadableStrategy === void 0) {
8501
    rawReadableStrategy = {};
8502
   }
8503
   if (rawTransformer === undefined) {
8504
    rawTransformer = null;
8505
   }
8506
   var writableStrategy = convertQueuingStrategy(rawWritableStrategy, 'Second parameter');
8507
   var readableStrategy = convertQueuingStrategy(rawReadableStrategy, 'Third parameter');
8508
   var transformer = convertTransformer(rawTransformer, 'First parameter');
8509
   if (transformer.readableType !== undefined) {
8510
    throw new RangeError('Invalid readableType specified');
8511
   }
8512
   if (transformer.writableType !== undefined) {
8513
    throw new RangeError('Invalid writableType specified');
8514
   }
8515
   var readableHighWaterMark = ExtractHighWaterMark(readableStrategy, 0);
8516
   var readableSizeAlgorithm = ExtractSizeAlgorithm(readableStrategy);
8517
   var writableHighWaterMark = ExtractHighWaterMark(writableStrategy, 1);
8518
   var writableSizeAlgorithm = ExtractSizeAlgorithm(writableStrategy);
8519
   var startPromise_resolve;
8520
   var startPromise = newPromise(function (resolve) {
8521
    startPromise_resolve = resolve;
8522
   });
8523
   InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
8524
   SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);
8525
   if (transformer.start !== undefined) {
8526
    startPromise_resolve(transformer.start(this._transformStreamController));
8527
   } else {
8528
    startPromise_resolve(undefined);
8529
   }
8530
  }
8531
  Object.defineProperty(TransformStream.prototype, "readable", {
8532
   get: function () {
8533
    if (!IsTransformStream(this)) {
8534
     throw streamBrandCheckException$2('readable');
8535
    }
8536
    return this._readable;
8537
   },
8538
   enumerable: false,
8539
   configurable: true
8540
  });
8541
  Object.defineProperty(TransformStream.prototype, "writable", {
8542
   get: function () {
8543
    if (!IsTransformStream(this)) {
8544
     throw streamBrandCheckException$2('writable');
8545
    }
8546
    return this._writable;
8547
   },
8548
   enumerable: false,
8549
   configurable: true
8550
  });
8551
  return TransformStream;
8552
 }();
8553
 Object.defineProperties(TransformStream.prototype, {
8554
  readable: { enumerable: true },
8555
  writable: { enumerable: true }
8556
 });
8557
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
8558
  Object.defineProperty(TransformStream.prototype, SymbolPolyfill.toStringTag, {
8559
   value: 'TransformStream',
8560
   configurable: true
8561
  });
8562
 }
8563
 function InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) {
8564
  function startAlgorithm() {
8565
   return startPromise;
8566
  }
8567
  function writeAlgorithm(chunk) {
8568
   return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk);
8569
  }
8570
  function abortAlgorithm(reason) {
8571
   return TransformStreamDefaultSinkAbortAlgorithm(stream, reason);
8572
  }
8573
  function closeAlgorithm() {
8574
   return TransformStreamDefaultSinkCloseAlgorithm(stream);
8575
  }
8576
  stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm);
8577
  function pullAlgorithm() {
8578
   return TransformStreamDefaultSourcePullAlgorithm(stream);
8579
  }
8580
  function cancelAlgorithm(reason) {
8581
   TransformStreamErrorWritableAndUnblockWrite(stream, reason);
8582
   return promiseResolvedWith(undefined);
8583
  }
8584
  stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm);
8585
  stream._backpressure = undefined;
8586
  stream._backpressureChangePromise = undefined;
8587
  stream._backpressureChangePromise_resolve = undefined;
8588
  TransformStreamSetBackpressure(stream, true);
8589
  stream._transformStreamController = undefined;
8590
 }
8591
 function IsTransformStream(x) {
8592
  if (!typeIsObject(x)) {
8593
   return false;
8594
  }
8595
  if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {
8596
   return false;
8597
  }
8598
  return true;
8599
 }
8600
 function TransformStreamError(stream, e) {
8601
  ReadableStreamDefaultControllerError(stream._readable._readableStreamController, e);
8602
  TransformStreamErrorWritableAndUnblockWrite(stream, e);
8603
 }
8604
 function TransformStreamErrorWritableAndUnblockWrite(stream, e) {
8605
  TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);
8606
  WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e);
8607
  if (stream._backpressure) {
8608
   TransformStreamSetBackpressure(stream, false);
8609
  }
8610
 }
8611
 function TransformStreamSetBackpressure(stream, backpressure) {
8612
  if (stream._backpressureChangePromise !== undefined) {
8613
   stream._backpressureChangePromise_resolve();
8614
  }
8615
  stream._backpressureChangePromise = newPromise(function (resolve) {
8616
   stream._backpressureChangePromise_resolve = resolve;
8617
  });
8618
  stream._backpressure = backpressure;
8619
 }
8620
 var TransformStreamDefaultController = function () {
8621
  function TransformStreamDefaultController() {
8622
   throw new TypeError('Illegal constructor');
8623
  }
8624
  Object.defineProperty(TransformStreamDefaultController.prototype, "desiredSize", {
8625
   get: function () {
8626
    if (!IsTransformStreamDefaultController(this)) {
8627
     throw defaultControllerBrandCheckException$1('desiredSize');
8628
    }
8629
    var readableController = this._controlledTransformStream._readable._readableStreamController;
8630
    return ReadableStreamDefaultControllerGetDesiredSize(readableController);
8631
   },
8632
   enumerable: false,
8633
   configurable: true
8634
  });
8635
  TransformStreamDefaultController.prototype.enqueue = function (chunk) {
8636
   if (chunk === void 0) {
8637
    chunk = undefined;
8638
   }
8639
   if (!IsTransformStreamDefaultController(this)) {
8640
    throw defaultControllerBrandCheckException$1('enqueue');
8641
   }
8642
   TransformStreamDefaultControllerEnqueue(this, chunk);
8643
  };
8644
  TransformStreamDefaultController.prototype.error = function (reason) {
8645
   if (reason === void 0) {
8646
    reason = undefined;
8647
   }
8648
   if (!IsTransformStreamDefaultController(this)) {
8649
    throw defaultControllerBrandCheckException$1('error');
8650
   }
8651
   TransformStreamDefaultControllerError(this, reason);
8652
  };
8653
  TransformStreamDefaultController.prototype.terminate = function () {
8654
   if (!IsTransformStreamDefaultController(this)) {
8655
    throw defaultControllerBrandCheckException$1('terminate');
8656
   }
8657
   TransformStreamDefaultControllerTerminate(this);
8658
  };
8659
  return TransformStreamDefaultController;
8660
 }();
8661
 Object.defineProperties(TransformStreamDefaultController.prototype, {
8662
  enqueue: { enumerable: true },
8663
  error: { enumerable: true },
8664
  terminate: { enumerable: true },
8665
  desiredSize: { enumerable: true }
8666
 });
8667
 if (typeof SymbolPolyfill.toStringTag === 'symbol') {
8668
  Object.defineProperty(TransformStreamDefaultController.prototype, SymbolPolyfill.toStringTag, {
8669
   value: 'TransformStreamDefaultController',
8670
   configurable: true
8671
  });
8672
 }
8673
 function IsTransformStreamDefaultController(x) {
8674
  if (!typeIsObject(x)) {
8675
   return false;
8676
  }
8677
  if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {
8678
   return false;
8679
  }
8680
  return true;
8681
 }
8682
 function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) {
8683
  controller._controlledTransformStream = stream;
8684
  stream._transformStreamController = controller;
8685
  controller._transformAlgorithm = transformAlgorithm;
8686
  controller._flushAlgorithm = flushAlgorithm;
8687
 }
8688
 function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {
8689
  var controller = Object.create(TransformStreamDefaultController.prototype);
8690
  var transformAlgorithm = function (chunk) {
8691
   try {
8692
    TransformStreamDefaultControllerEnqueue(controller, chunk);
8693
    return promiseResolvedWith(undefined);
8694
   } catch (transformResultE) {
8695
    return promiseRejectedWith(transformResultE);
8696
   }
8697
  };
8698
  var flushAlgorithm = function () {
8699
   return promiseResolvedWith(undefined);
8700
  };
8701
  if (transformer.transform !== undefined) {
8702
   transformAlgorithm = function (chunk) {
8703
    return transformer.transform(chunk, controller);
8704
   };
8705
  }
8706
  if (transformer.flush !== undefined) {
8707
   flushAlgorithm = function () {
8708
    return transformer.flush(controller);
8709
   };
8710
  }
8711
  SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm);
8712
 }
8713
 function TransformStreamDefaultControllerClearAlgorithms(controller) {
8714
  controller._transformAlgorithm = undefined;
8715
  controller._flushAlgorithm = undefined;
8716
 }
8717
 function TransformStreamDefaultControllerEnqueue(controller, chunk) {
8718
  var stream = controller._controlledTransformStream;
8719
  var readableController = stream._readable._readableStreamController;
8720
  if (!ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController)) {
8721
   throw new TypeError('Readable side is not in a state that permits enqueue');
8722
  }
8723
  try {
8724
   ReadableStreamDefaultControllerEnqueue(readableController, chunk);
8725
  } catch (e) {
8726
   TransformStreamErrorWritableAndUnblockWrite(stream, e);
8727
   throw stream._readable._storedError;
8728
  }
8729
  var backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController);
8730
  if (backpressure !== stream._backpressure) {
8731
   TransformStreamSetBackpressure(stream, true);
8732
  }
8733
 }
8734
 function TransformStreamDefaultControllerError(controller, e) {
8735
  TransformStreamError(controller._controlledTransformStream, e);
8736
 }
8737
 function TransformStreamDefaultControllerPerformTransform(controller, chunk) {
8738
  var transformPromise = controller._transformAlgorithm(chunk);
8739
  return transformPromiseWith(transformPromise, undefined, function (r) {
8740
   TransformStreamError(controller._controlledTransformStream, r);
8741
   throw r;
8742
  });
8743
 }
8744
 function TransformStreamDefaultControllerTerminate(controller) {
8745
  var stream = controller._controlledTransformStream;
8746
  var readableController = stream._readable._readableStreamController;
8747
  ReadableStreamDefaultControllerClose(readableController);
8748
  var error = new TypeError('TransformStream terminated');
8749
  TransformStreamErrorWritableAndUnblockWrite(stream, error);
8750
 }
8751
 function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) {
8752
  var controller = stream._transformStreamController;
8753
  if (stream._backpressure) {
8754
   var backpressureChangePromise = stream._backpressureChangePromise;
8755
   return transformPromiseWith(backpressureChangePromise, function () {
8756
    var writable = stream._writable;
8757
    var state = writable._state;
8758
    if (state === 'erroring') {
8759
     throw writable._storedError;
8760
    }
8761
    return TransformStreamDefaultControllerPerformTransform(controller, chunk);
8762
   });
8763
  }
8764
  return TransformStreamDefaultControllerPerformTransform(controller, chunk);
8765
 }
8766
 function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {
8767
  TransformStreamError(stream, reason);
8768
  return promiseResolvedWith(undefined);
8769
 }
8770
 function TransformStreamDefaultSinkCloseAlgorithm(stream) {
8771
  var readable = stream._readable;
8772
  var controller = stream._transformStreamController;
8773
  var flushPromise = controller._flushAlgorithm();
8774
  TransformStreamDefaultControllerClearAlgorithms(controller);
8775
  return transformPromiseWith(flushPromise, function () {
8776
   if (readable._state === 'errored') {
8777
    throw readable._storedError;
8778
   }
8779
   ReadableStreamDefaultControllerClose(readable._readableStreamController);
8780
  }, function (r) {
8781
   TransformStreamError(stream, r);
8782
   throw readable._storedError;
8783
  });
8784
 }
8785
 function TransformStreamDefaultSourcePullAlgorithm(stream) {
8786
  TransformStreamSetBackpressure(stream, false);
8787
  return stream._backpressureChangePromise;
8788
 }
8789
 function defaultControllerBrandCheckException$1(name) {
8790
  return new TypeError("TransformStreamDefaultController.prototype." + name + " can only be used on a TransformStreamDefaultController");
8791
 }
8792
 function streamBrandCheckException$2(name) {
8793
  return new TypeError("TransformStream.prototype." + name + " can only be used on a TransformStream");
8794
 }
8795
 exports.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;
8796
 exports.CountQueuingStrategy = CountQueuingStrategy;
8797
 exports.ReadableByteStreamController = ReadableByteStreamController;
8798
 exports.ReadableStream = ReadableStream;
8799
 exports.ReadableStreamBYOBReader = ReadableStreamBYOBReader;
8800
 exports.ReadableStreamBYOBRequest = ReadableStreamBYOBRequest;
8801
 exports.ReadableStreamDefaultController = ReadableStreamDefaultController;
8802
 exports.ReadableStreamDefaultReader = ReadableStreamDefaultReader;
8803
 exports.TransformStream = TransformStream;
8804
 exports.TransformStreamDefaultController = TransformStreamDefaultController;
8805
 exports.WritableStream = WritableStream;
8806
 exports.WritableStreamDefaultController = WritableStreamDefaultController;
8807
 exports.WritableStreamDefaultWriter = WritableStreamDefaultWriter;
8808
 Object.defineProperty(exports, '__esModule', { value: true });
8809
}));
8810

8811
/***/ }),
8812
/* 112 */
8813
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
8814

8815
__w_pdfjs_require__(113);
8816
var entryUnbind = __w_pdfjs_require__(117);
8817
module.exports = entryUnbind('String', 'padStart');
8818

8819
/***/ }),
8820
/* 113 */
8821
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
8822

8823
"use strict";
8824

8825
var $ = __w_pdfjs_require__(9);
8826
var $padStart = __w_pdfjs_require__(114).start;
8827
var WEBKIT_BUG = __w_pdfjs_require__(116);
8828
$({
8829
 target: 'String',
8830
 proto: true,
8831
 forced: WEBKIT_BUG
8832
}, {
8833
 padStart: function padStart(maxLength) {
8834
  return $padStart(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);
8835
 }
8836
});
8837

8838
/***/ }),
8839
/* 114 */
8840
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
8841

8842
var toLength = __w_pdfjs_require__(46);
8843
var repeat = __w_pdfjs_require__(115);
8844
var requireObjectCoercible = __w_pdfjs_require__(19);
8845
var ceil = Math.ceil;
8846
var createMethod = function (IS_END) {
8847
 return function ($this, maxLength, fillString) {
8848
  var S = String(requireObjectCoercible($this));
8849
  var stringLength = S.length;
8850
  var fillStr = fillString === undefined ? ' ' : String(fillString);
8851
  var intMaxLength = toLength(maxLength);
8852
  var fillLen, stringFiller;
8853
  if (intMaxLength <= stringLength || fillStr == '')
8854
   return S;
8855
  fillLen = intMaxLength - stringLength;
8856
  stringFiller = repeat.call(fillStr, ceil(fillLen / fillStr.length));
8857
  if (stringFiller.length > fillLen)
8858
   stringFiller = stringFiller.slice(0, fillLen);
8859
  return IS_END ? S + stringFiller : stringFiller + S;
8860
 };
8861
};
8862
module.exports = {
8863
 start: createMethod(false),
8864
 end: createMethod(true)
8865
};
8866

8867
/***/ }),
8868
/* 115 */
8869
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
8870

8871
"use strict";
8872

8873
var toInteger = __w_pdfjs_require__(47);
8874
var requireObjectCoercible = __w_pdfjs_require__(19);
8875
module.exports = function repeat(count) {
8876
 var str = String(requireObjectCoercible(this));
8877
 var result = '';
8878
 var n = toInteger(count);
8879
 if (n < 0 || n == Infinity)
8880
  throw RangeError('Wrong number of repetitions');
8881
 for (; n > 0; (n >>>= 1) && (str += str))
8882
  if (n & 1)
8883
   result += str;
8884
 return result;
8885
};
8886

8887
/***/ }),
8888
/* 116 */
8889
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
8890

8891
var userAgent = __w_pdfjs_require__(59);
8892
module.exports = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(userAgent);
8893

8894
/***/ }),
8895
/* 117 */
8896
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
8897

8898
var global = __w_pdfjs_require__(10);
8899
var bind = __w_pdfjs_require__(78);
8900
var call = Function.call;
8901
module.exports = function (CONSTRUCTOR, METHOD, length) {
8902
 return bind(call, global[CONSTRUCTOR].prototype[METHOD], length);
8903
};
8904

8905
/***/ }),
8906
/* 118 */
8907
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
8908

8909
__w_pdfjs_require__(119);
8910
var entryUnbind = __w_pdfjs_require__(117);
8911
module.exports = entryUnbind('String', 'padEnd');
8912

8913
/***/ }),
8914
/* 119 */
8915
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
8916

8917
"use strict";
8918

8919
var $ = __w_pdfjs_require__(9);
8920
var $padEnd = __w_pdfjs_require__(114).end;
8921
var WEBKIT_BUG = __w_pdfjs_require__(116);
8922
$({
8923
 target: 'String',
8924
 proto: true,
8925
 forced: WEBKIT_BUG
8926
}, {
8927
 padEnd: function padEnd(maxLength) {
8928
  return $padEnd(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);
8929
 }
8930
});
8931

8932
/***/ }),
8933
/* 120 */
8934
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
8935

8936
__w_pdfjs_require__(121);
8937
var path = __w_pdfjs_require__(42);
8938
module.exports = path.Object.values;
8939

8940
/***/ }),
8941
/* 121 */
8942
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
8943

8944
var $ = __w_pdfjs_require__(9);
8945
var $values = __w_pdfjs_require__(122).values;
8946
$({
8947
 target: 'Object',
8948
 stat: true
8949
}, {
8950
 values: function values(O) {
8951
  return $values(O);
8952
 }
8953
});
8954

8955
/***/ }),
8956
/* 122 */
8957
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
8958

8959
var DESCRIPTORS = __w_pdfjs_require__(12);
8960
var objectKeys = __w_pdfjs_require__(63);
8961
var toIndexedObject = __w_pdfjs_require__(16);
8962
var propertyIsEnumerable = __w_pdfjs_require__(14).f;
8963
var createMethod = function (TO_ENTRIES) {
8964
 return function (it) {
8965
  var O = toIndexedObject(it);
8966
  var keys = objectKeys(O);
8967
  var length = keys.length;
8968
  var i = 0;
8969
  var result = [];
8970
  var key;
8971
  while (length > i) {
8972
   key = keys[i++];
8973
   if (!DESCRIPTORS || propertyIsEnumerable.call(O, key)) {
8974
    result.push(TO_ENTRIES ? [
8975
     key,
8976
     O[key]
8977
    ] : O[key]);
8978
   }
8979
  }
8980
  return result;
8981
 };
8982
};
8983
module.exports = {
8984
 entries: createMethod(true),
8985
 values: createMethod(false)
8986
};
8987

8988
/***/ }),
8989
/* 123 */
8990
/***/ ((module, __unused_webpack_exports, __w_pdfjs_require__) => {
8991

8992
__w_pdfjs_require__(124);
8993
var path = __w_pdfjs_require__(42);
8994
module.exports = path.Object.entries;
8995

8996
/***/ }),
8997
/* 124 */
8998
/***/ ((__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
8999

9000
var $ = __w_pdfjs_require__(9);
9001
var $entries = __w_pdfjs_require__(122).entries;
9002
$({
9003
 target: 'Object',
9004
 stat: true
9005
}, {
9006
 entries: function entries(O) {
9007
  return $entries(O);
9008
 }
9009
});
9010

9011
/***/ }),
9012
/* 125 */
9013
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
9014

9015
"use strict";
9016

9017

9018
Object.defineProperty(exports, "__esModule", ({
9019
  value: true
9020
}));
9021
exports.getDocument = getDocument;
9022
exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory;
9023
exports.version = exports.PDFWorker = exports.PDFPageProxy = exports.PDFDocumentProxy = exports.PDFDataRangeTransport = exports.LoopbackPort = exports.DefaultCMapReaderFactory = exports.DefaultCanvasFactory = exports.build = void 0;
9024

9025
var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
9026

9027
var _util = __w_pdfjs_require__(4);
9028

9029
var _display_utils = __w_pdfjs_require__(1);
9030

9031
var _font_loader = __w_pdfjs_require__(126);
9032

9033
var _node_utils = __w_pdfjs_require__(127);
9034

9035
var _annotation_storage = __w_pdfjs_require__(128);
9036

9037
var _api_compatibility = __w_pdfjs_require__(129);
9038

9039
var _canvas = __w_pdfjs_require__(130);
9040

9041
var _worker_options = __w_pdfjs_require__(132);
9042

9043
var _is_node = __w_pdfjs_require__(6);
9044

9045
var _message_handler = __w_pdfjs_require__(133);
9046

9047
var _metadata = __w_pdfjs_require__(134);
9048

9049
var _optional_content_config = __w_pdfjs_require__(135);
9050

9051
var _transport_stream = __w_pdfjs_require__(136);
9052

9053
var _webgl = __w_pdfjs_require__(137);
9054

9055
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
9056

9057
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
9058

9059
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
9060

9061
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
9062

9063
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
9064

9065
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
9066

9067
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
9068

9069
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
9070

9071
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
9072

9073
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
9074

9075
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
9076

9077
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
9078

9079
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
9080

9081
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
9082

9083
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
9084

9085
function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
9086

9087
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
9088

9089
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
9090

9091
var DEFAULT_RANGE_CHUNK_SIZE = 65536;
9092
var RENDERING_CANCELLED_TIMEOUT = 100;
9093
var DefaultCanvasFactory = _is_node.isNodeJS ? _node_utils.NodeCanvasFactory : _display_utils.DOMCanvasFactory;
9094
exports.DefaultCanvasFactory = DefaultCanvasFactory;
9095
var DefaultCMapReaderFactory = _is_node.isNodeJS ? _node_utils.NodeCMapReaderFactory : _display_utils.DOMCMapReaderFactory;
9096
exports.DefaultCMapReaderFactory = DefaultCMapReaderFactory;
9097
var createPDFNetworkStream;
9098

9099
function setPDFNetworkStreamFactory(pdfNetworkStreamFactory) {
9100
  createPDFNetworkStream = pdfNetworkStreamFactory;
9101
}
9102

9103
function getDocument(src) {
9104
  var task = new PDFDocumentLoadingTask();
9105
  var source;
9106

9107
  if (typeof src === "string" || src instanceof URL) {
9108
    source = {
9109
      url: src
9110
    };
9111
  } else if ((0, _util.isArrayBuffer)(src)) {
9112
    source = {
9113
      data: src
9114
    };
9115
  } else if (src instanceof PDFDataRangeTransport) {
9116
    source = {
9117
      range: src
9118
    };
9119
  } else {
9120
    if (_typeof(src) !== "object") {
9121
      throw new Error("Invalid parameter in getDocument, " + "need either string, URL, Uint8Array, or parameter object.");
9122
    }
9123

9124
    if (!src.url && !src.data && !src.range) {
9125
      throw new Error("Invalid parameter object: need either .data, .range or .url");
9126
    }
9127

9128
    source = src;
9129
  }
9130

9131
  var params = Object.create(null);
9132
  var rangeTransport = null,
9133
      worker = null;
9134

9135
  for (var key in source) {
9136
    var value = source[key];
9137

9138
    switch (key) {
9139
      case "url":
9140
        if (typeof window !== "undefined") {
9141
          try {
9142
            params[key] = new URL(value, window.location).href;
9143
            continue;
9144
          } catch (ex) {
9145
            (0, _util.warn)("Cannot create valid URL: \"".concat(ex, "\"."));
9146
          }
9147
        } else if (typeof value === "string" || value instanceof URL) {
9148
          params[key] = value.toString();
9149
          continue;
9150
        }
9151

9152
        throw new Error("Invalid PDF url data: " + "either string or URL-object is expected in the url property.");
9153

9154
      case "range":
9155
        rangeTransport = value;
9156
        continue;
9157

9158
      case "worker":
9159
        worker = value;
9160
        continue;
9161

9162
      case "data":
9163
        if (_is_node.isNodeJS && typeof Buffer !== "undefined" && value instanceof Buffer) {
9164
          params[key] = new Uint8Array(value);
9165
        } else if (value instanceof Uint8Array) {
9166
          break;
9167
        } else if (typeof value === "string") {
9168
          params[key] = (0, _util.stringToBytes)(value);
9169
        } else if (_typeof(value) === "object" && value !== null && !isNaN(value.length)) {
9170
          params[key] = new Uint8Array(value);
9171
        } else if ((0, _util.isArrayBuffer)(value)) {
9172
          params[key] = new Uint8Array(value);
9173
        } else {
9174
          throw new Error("Invalid PDF binary data: either typed array, " + "string, or array-like object is expected in the data property.");
9175
        }
9176

9177
        continue;
9178
    }
9179

9180
    params[key] = value;
9181
  }
9182

9183
  params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE;
9184
  params.CMapReaderFactory = params.CMapReaderFactory || DefaultCMapReaderFactory;
9185
  params.ignoreErrors = params.stopAtErrors !== true;
9186
  params.fontExtraProperties = params.fontExtraProperties === true;
9187
  params.pdfBug = params.pdfBug === true;
9188
  params.enableXfa = params.enableXfa === true;
9189

9190
  if (typeof params.docBaseUrl !== "string" || (0, _display_utils.isDataScheme)(params.docBaseUrl)) {
9191
    params.docBaseUrl = null;
9192
  }
9193

9194
  if (!Number.isInteger(params.maxImageSize)) {
9195
    params.maxImageSize = -1;
9196
  }
9197

9198
  if (typeof params.isEvalSupported !== "boolean") {
9199
    params.isEvalSupported = true;
9200
  }
9201

9202
  if (typeof params.disableFontFace !== "boolean") {
9203
    params.disableFontFace = _api_compatibility.apiCompatibilityParams.disableFontFace || false;
9204
  }
9205

9206
  if (typeof params.ownerDocument === "undefined") {
9207
    params.ownerDocument = globalThis.document;
9208
  }
9209

9210
  if (typeof params.disableRange !== "boolean") {
9211
    params.disableRange = false;
9212
  }
9213

9214
  if (typeof params.disableStream !== "boolean") {
9215
    params.disableStream = false;
9216
  }
9217

9218
  if (typeof params.disableAutoFetch !== "boolean") {
9219
    params.disableAutoFetch = false;
9220
  }
9221

9222
  (0, _util.setVerbosityLevel)(params.verbosity);
9223

9224
  if (!worker) {
9225
    var workerParams = {
9226
      verbosity: params.verbosity,
9227
      port: _worker_options.GlobalWorkerOptions.workerPort
9228
    };
9229
    worker = workerParams.port ? PDFWorker.fromPort(workerParams) : new PDFWorker(workerParams);
9230
    task._worker = worker;
9231
  }
9232

9233
  var docId = task.docId;
9234
  worker.promise.then(function () {
9235
    if (task.destroyed) {
9236
      throw new Error("Loading aborted");
9237
    }
9238

9239
    var workerIdPromise = _fetchDocument(worker, params, rangeTransport, docId);
9240

9241
    var networkStreamPromise = new Promise(function (resolve) {
9242
      var networkStream;
9243

9244
      if (rangeTransport) {
9245
        networkStream = new _transport_stream.PDFDataTransportStream({
9246
          length: params.length,
9247
          initialData: params.initialData,
9248
          progressiveDone: params.progressiveDone,
9249
          contentDispositionFilename: params.contentDispositionFilename,
9250
          disableRange: params.disableRange,
9251
          disableStream: params.disableStream
9252
        }, rangeTransport);
9253
      } else if (!params.data) {
9254
        networkStream = createPDFNetworkStream({
9255
          url: params.url,
9256
          length: params.length,
9257
          httpHeaders: params.httpHeaders,
9258
          withCredentials: params.withCredentials,
9259
          rangeChunkSize: params.rangeChunkSize,
9260
          disableRange: params.disableRange,
9261
          disableStream: params.disableStream
9262
        });
9263
      }
9264

9265
      resolve(networkStream);
9266
    });
9267
    return Promise.all([workerIdPromise, networkStreamPromise]).then(function (_ref) {
9268
      var _ref2 = _slicedToArray(_ref, 2),
9269
          workerId = _ref2[0],
9270
          networkStream = _ref2[1];
9271

9272
      if (task.destroyed) {
9273
        throw new Error("Loading aborted");
9274
      }
9275

9276
      var messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port);
9277
      messageHandler.postMessageTransfers = worker.postMessageTransfers;
9278
      var transport = new WorkerTransport(messageHandler, task, networkStream, params);
9279
      task._transport = transport;
9280
      messageHandler.send("Ready", null);
9281
    });
9282
  })["catch"](task._capability.reject);
9283
  return task;
9284
}
9285

9286
function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {
9287
  if (worker.destroyed) {
9288
    return Promise.reject(new Error("Worker was destroyed"));
9289
  }
9290

9291
  if (pdfDataRangeTransport) {
9292
    source.length = pdfDataRangeTransport.length;
9293
    source.initialData = pdfDataRangeTransport.initialData;
9294
    source.progressiveDone = pdfDataRangeTransport.progressiveDone;
9295
    source.contentDispositionFilename = pdfDataRangeTransport.contentDispositionFilename;
9296
  }
9297

9298
  return worker.messageHandler.sendWithPromise("GetDocRequest", {
9299
    docId: docId,
9300
    apiVersion: '2.8.335',
9301
    source: {
9302
      data: source.data,
9303
      url: source.url,
9304
      password: source.password,
9305
      disableAutoFetch: source.disableAutoFetch,
9306
      rangeChunkSize: source.rangeChunkSize,
9307
      length: source.length
9308
    },
9309
    maxImageSize: source.maxImageSize,
9310
    disableFontFace: source.disableFontFace,
9311
    postMessageTransfers: worker.postMessageTransfers,
9312
    docBaseUrl: source.docBaseUrl,
9313
    ignoreErrors: source.ignoreErrors,
9314
    isEvalSupported: source.isEvalSupported,
9315
    fontExtraProperties: source.fontExtraProperties,
9316
    enableXfa: source.enableXfa
9317
  }).then(function (workerId) {
9318
    if (worker.destroyed) {
9319
      throw new Error("Worker was destroyed");
9320
    }
9321

9322
    return workerId;
9323
  });
9324
}
9325

9326
var PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() {
9327
  var nextDocumentId = 0;
9328

9329
  var PDFDocumentLoadingTask = /*#__PURE__*/function () {
9330
    function PDFDocumentLoadingTask() {
9331
      _classCallCheck(this, PDFDocumentLoadingTask);
9332

9333
      this._capability = (0, _util.createPromiseCapability)();
9334
      this._transport = null;
9335
      this._worker = null;
9336
      this.docId = "d" + nextDocumentId++;
9337
      this.destroyed = false;
9338
      this.onPassword = null;
9339
      this.onProgress = null;
9340
      this.onUnsupportedFeature = null;
9341
    }
9342

9343
    _createClass(PDFDocumentLoadingTask, [{
9344
      key: "promise",
9345
      get: function get() {
9346
        return this._capability.promise;
9347
      }
9348
    }, {
9349
      key: "destroy",
9350
      value: function destroy() {
9351
        var _this = this;
9352

9353
        this.destroyed = true;
9354
        var transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy();
9355
        return transportDestroyed.then(function () {
9356
          _this._transport = null;
9357

9358
          if (_this._worker) {
9359
            _this._worker.destroy();
9360

9361
            _this._worker = null;
9362
          }
9363
        });
9364
      }
9365
    }]);
9366

9367
    return PDFDocumentLoadingTask;
9368
  }();
9369

9370
  return PDFDocumentLoadingTask;
9371
}();
9372

9373
var PDFDataRangeTransport = /*#__PURE__*/function () {
9374
  function PDFDataRangeTransport(length, initialData) {
9375
    var progressiveDone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
9376
    var contentDispositionFilename = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
9377

9378
    _classCallCheck(this, PDFDataRangeTransport);
9379

9380
    this.length = length;
9381
    this.initialData = initialData;
9382
    this.progressiveDone = progressiveDone;
9383
    this.contentDispositionFilename = contentDispositionFilename;
9384
    this._rangeListeners = [];
9385
    this._progressListeners = [];
9386
    this._progressiveReadListeners = [];
9387
    this._progressiveDoneListeners = [];
9388
    this._readyCapability = (0, _util.createPromiseCapability)();
9389
  }
9390

9391
  _createClass(PDFDataRangeTransport, [{
9392
    key: "addRangeListener",
9393
    value: function addRangeListener(listener) {
9394
      this._rangeListeners.push(listener);
9395
    }
9396
  }, {
9397
    key: "addProgressListener",
9398
    value: function addProgressListener(listener) {
9399
      this._progressListeners.push(listener);
9400
    }
9401
  }, {
9402
    key: "addProgressiveReadListener",
9403
    value: function addProgressiveReadListener(listener) {
9404
      this._progressiveReadListeners.push(listener);
9405
    }
9406
  }, {
9407
    key: "addProgressiveDoneListener",
9408
    value: function addProgressiveDoneListener(listener) {
9409
      this._progressiveDoneListeners.push(listener);
9410
    }
9411
  }, {
9412
    key: "onDataRange",
9413
    value: function onDataRange(begin, chunk) {
9414
      var _iterator = _createForOfIteratorHelper(this._rangeListeners),
9415
          _step;
9416

9417
      try {
9418
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
9419
          var listener = _step.value;
9420
          listener(begin, chunk);
9421
        }
9422
      } catch (err) {
9423
        _iterator.e(err);
9424
      } finally {
9425
        _iterator.f();
9426
      }
9427
    }
9428
  }, {
9429
    key: "onDataProgress",
9430
    value: function onDataProgress(loaded, total) {
9431
      var _this2 = this;
9432

9433
      this._readyCapability.promise.then(function () {
9434
        var _iterator2 = _createForOfIteratorHelper(_this2._progressListeners),
9435
            _step2;
9436

9437
        try {
9438
          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
9439
            var listener = _step2.value;
9440
            listener(loaded, total);
9441
          }
9442
        } catch (err) {
9443
          _iterator2.e(err);
9444
        } finally {
9445
          _iterator2.f();
9446
        }
9447
      });
9448
    }
9449
  }, {
9450
    key: "onDataProgressiveRead",
9451
    value: function onDataProgressiveRead(chunk) {
9452
      var _this3 = this;
9453

9454
      this._readyCapability.promise.then(function () {
9455
        var _iterator3 = _createForOfIteratorHelper(_this3._progressiveReadListeners),
9456
            _step3;
9457

9458
        try {
9459
          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
9460
            var listener = _step3.value;
9461
            listener(chunk);
9462
          }
9463
        } catch (err) {
9464
          _iterator3.e(err);
9465
        } finally {
9466
          _iterator3.f();
9467
        }
9468
      });
9469
    }
9470
  }, {
9471
    key: "onDataProgressiveDone",
9472
    value: function onDataProgressiveDone() {
9473
      var _this4 = this;
9474

9475
      this._readyCapability.promise.then(function () {
9476
        var _iterator4 = _createForOfIteratorHelper(_this4._progressiveDoneListeners),
9477
            _step4;
9478

9479
        try {
9480
          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
9481
            var listener = _step4.value;
9482
            listener();
9483
          }
9484
        } catch (err) {
9485
          _iterator4.e(err);
9486
        } finally {
9487
          _iterator4.f();
9488
        }
9489
      });
9490
    }
9491
  }, {
9492
    key: "transportReady",
9493
    value: function transportReady() {
9494
      this._readyCapability.resolve();
9495
    }
9496
  }, {
9497
    key: "requestDataRange",
9498
    value: function requestDataRange(begin, end) {
9499
      (0, _util.unreachable)("Abstract method PDFDataRangeTransport.requestDataRange");
9500
    }
9501
  }, {
9502
    key: "abort",
9503
    value: function abort() {}
9504
  }]);
9505

9506
  return PDFDataRangeTransport;
9507
}();
9508

9509
exports.PDFDataRangeTransport = PDFDataRangeTransport;
9510

9511
var PDFDocumentProxy = /*#__PURE__*/function () {
9512
  function PDFDocumentProxy(pdfInfo, transport) {
9513
    _classCallCheck(this, PDFDocumentProxy);
9514

9515
    this._pdfInfo = pdfInfo;
9516
    this._transport = transport;
9517
  }
9518

9519
  _createClass(PDFDocumentProxy, [{
9520
    key: "annotationStorage",
9521
    get: function get() {
9522
      return (0, _util.shadow)(this, "annotationStorage", new _annotation_storage.AnnotationStorage());
9523
    }
9524
  }, {
9525
    key: "numPages",
9526
    get: function get() {
9527
      return this._pdfInfo.numPages;
9528
    }
9529
  }, {
9530
    key: "fingerprint",
9531
    get: function get() {
9532
      return this._pdfInfo.fingerprint;
9533
    }
9534
  }, {
9535
    key: "isPureXfa",
9536
    get: function get() {
9537
      return this._pdfInfo.isPureXfa;
9538
    }
9539
  }, {
9540
    key: "getPage",
9541
    value: function getPage(pageNumber) {
9542
      return this._transport.getPage(pageNumber);
9543
    }
9544
  }, {
9545
    key: "getPageIndex",
9546
    value: function getPageIndex(ref) {
9547
      return this._transport.getPageIndex(ref);
9548
    }
9549
  }, {
9550
    key: "getDestinations",
9551
    value: function getDestinations() {
9552
      return this._transport.getDestinations();
9553
    }
9554
  }, {
9555
    key: "getDestination",
9556
    value: function getDestination(id) {
9557
      return this._transport.getDestination(id);
9558
    }
9559
  }, {
9560
    key: "getPageLabels",
9561
    value: function getPageLabels() {
9562
      return this._transport.getPageLabels();
9563
    }
9564
  }, {
9565
    key: "getPageLayout",
9566
    value: function getPageLayout() {
9567
      return this._transport.getPageLayout();
9568
    }
9569
  }, {
9570
    key: "getPageMode",
9571
    value: function getPageMode() {
9572
      return this._transport.getPageMode();
9573
    }
9574
  }, {
9575
    key: "getViewerPreferences",
9576
    value: function getViewerPreferences() {
9577
      return this._transport.getViewerPreferences();
9578
    }
9579
  }, {
9580
    key: "getOpenAction",
9581
    value: function getOpenAction() {
9582
      return this._transport.getOpenAction();
9583
    }
9584
  }, {
9585
    key: "getAttachments",
9586
    value: function getAttachments() {
9587
      return this._transport.getAttachments();
9588
    }
9589
  }, {
9590
    key: "getJavaScript",
9591
    value: function getJavaScript() {
9592
      return this._transport.getJavaScript();
9593
    }
9594
  }, {
9595
    key: "getJSActions",
9596
    value: function getJSActions() {
9597
      return this._transport.getDocJSActions();
9598
    }
9599
  }, {
9600
    key: "getOutline",
9601
    value: function getOutline() {
9602
      return this._transport.getOutline();
9603
    }
9604
  }, {
9605
    key: "getOptionalContentConfig",
9606
    value: function getOptionalContentConfig() {
9607
      return this._transport.getOptionalContentConfig();
9608
    }
9609
  }, {
9610
    key: "getPermissions",
9611
    value: function getPermissions() {
9612
      return this._transport.getPermissions();
9613
    }
9614
  }, {
9615
    key: "getMetadata",
9616
    value: function getMetadata() {
9617
      return this._transport.getMetadata();
9618
    }
9619
  }, {
9620
    key: "getMarkInfo",
9621
    value: function getMarkInfo() {
9622
      return this._transport.getMarkInfo();
9623
    }
9624
  }, {
9625
    key: "getData",
9626
    value: function getData() {
9627
      return this._transport.getData();
9628
    }
9629
  }, {
9630
    key: "getDownloadInfo",
9631
    value: function getDownloadInfo() {
9632
      return this._transport.downloadInfoCapability.promise;
9633
    }
9634
  }, {
9635
    key: "getStats",
9636
    value: function getStats() {
9637
      return this._transport.getStats();
9638
    }
9639
  }, {
9640
    key: "cleanup",
9641
    value: function cleanup() {
9642
      var keepLoadedFonts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
9643
      return this._transport.startCleanup(keepLoadedFonts || this.isPureXfa);
9644
    }
9645
  }, {
9646
    key: "destroy",
9647
    value: function destroy() {
9648
      return this.loadingTask.destroy();
9649
    }
9650
  }, {
9651
    key: "loadingParams",
9652
    get: function get() {
9653
      return this._transport.loadingParams;
9654
    }
9655
  }, {
9656
    key: "loadingTask",
9657
    get: function get() {
9658
      return this._transport.loadingTask;
9659
    }
9660
  }, {
9661
    key: "saveDocument",
9662
    value: function saveDocument(annotationStorage) {
9663
      return this._transport.saveDocument(annotationStorage);
9664
    }
9665
  }, {
9666
    key: "getFieldObjects",
9667
    value: function getFieldObjects() {
9668
      return this._transport.getFieldObjects();
9669
    }
9670
  }, {
9671
    key: "hasJSActions",
9672
    value: function hasJSActions() {
9673
      return this._transport.hasJSActions();
9674
    }
9675
  }, {
9676
    key: "getCalculationOrderIds",
9677
    value: function getCalculationOrderIds() {
9678
      return this._transport.getCalculationOrderIds();
9679
    }
9680
  }]);
9681

9682
  return PDFDocumentProxy;
9683
}();
9684

9685
exports.PDFDocumentProxy = PDFDocumentProxy;
9686

9687
var PDFPageProxy = /*#__PURE__*/function () {
9688
  function PDFPageProxy(pageIndex, pageInfo, transport, ownerDocument) {
9689
    var pdfBug = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;
9690

9691
    _classCallCheck(this, PDFPageProxy);
9692

9693
    this._pageIndex = pageIndex;
9694
    this._pageInfo = pageInfo;
9695
    this._ownerDocument = ownerDocument;
9696
    this._transport = transport;
9697
    this._stats = pdfBug ? new _display_utils.StatTimer() : null;
9698
    this._pdfBug = pdfBug;
9699
    this.commonObjs = transport.commonObjs;
9700
    this.objs = new PDFObjects();
9701
    this.cleanupAfterRender = false;
9702
    this.pendingCleanup = false;
9703
    this._intentStates = new Map();
9704
    this.destroyed = false;
9705
  }
9706

9707
  _createClass(PDFPageProxy, [{
9708
    key: "pageNumber",
9709
    get: function get() {
9710
      return this._pageIndex + 1;
9711
    }
9712
  }, {
9713
    key: "rotate",
9714
    get: function get() {
9715
      return this._pageInfo.rotate;
9716
    }
9717
  }, {
9718
    key: "ref",
9719
    get: function get() {
9720
      return this._pageInfo.ref;
9721
    }
9722
  }, {
9723
    key: "userUnit",
9724
    get: function get() {
9725
      return this._pageInfo.userUnit;
9726
    }
9727
  }, {
9728
    key: "view",
9729
    get: function get() {
9730
      return this._pageInfo.view;
9731
    }
9732
  }, {
9733
    key: "getViewport",
9734
    value: function getViewport() {
9735
      var _ref3 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
9736
          scale = _ref3.scale,
9737
          _ref3$rotation = _ref3.rotation,
9738
          rotation = _ref3$rotation === void 0 ? this.rotate : _ref3$rotation,
9739
          _ref3$offsetX = _ref3.offsetX,
9740
          offsetX = _ref3$offsetX === void 0 ? 0 : _ref3$offsetX,
9741
          _ref3$offsetY = _ref3.offsetY,
9742
          offsetY = _ref3$offsetY === void 0 ? 0 : _ref3$offsetY,
9743
          _ref3$dontFlip = _ref3.dontFlip,
9744
          dontFlip = _ref3$dontFlip === void 0 ? false : _ref3$dontFlip;
9745

9746
      return new _display_utils.PageViewport({
9747
        viewBox: this.view,
9748
        scale: scale,
9749
        rotation: rotation,
9750
        offsetX: offsetX,
9751
        offsetY: offsetY,
9752
        dontFlip: dontFlip
9753
      });
9754
    }
9755
  }, {
9756
    key: "getAnnotations",
9757
    value: function getAnnotations() {
9758
      var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
9759
          _ref4$intent = _ref4.intent,
9760
          intent = _ref4$intent === void 0 ? null : _ref4$intent;
9761

9762
      if (!this._annotationsPromise || this._annotationsIntent !== intent) {
9763
        this._annotationsPromise = this._transport.getAnnotations(this._pageIndex, intent);
9764
        this._annotationsIntent = intent;
9765
      }
9766

9767
      return this._annotationsPromise;
9768
    }
9769
  }, {
9770
    key: "getJSActions",
9771
    value: function getJSActions() {
9772
      return this._jsActionsPromise || (this._jsActionsPromise = this._transport.getPageJSActions(this._pageIndex));
9773
    }
9774
  }, {
9775
    key: "getXfa",
9776
    value: function getXfa() {
9777
      return this._xfaPromise || (this._xfaPromise = this._transport.getPageXfa(this._pageIndex));
9778
    }
9779
  }, {
9780
    key: "render",
9781
    value: function render(_ref5) {
9782
      var _this5 = this,
9783
          _intentState;
9784

9785
      var canvasContext = _ref5.canvasContext,
9786
          viewport = _ref5.viewport,
9787
          _ref5$intent = _ref5.intent,
9788
          intent = _ref5$intent === void 0 ? "display" : _ref5$intent,
9789
          _ref5$enableWebGL = _ref5.enableWebGL,
9790
          enableWebGL = _ref5$enableWebGL === void 0 ? false : _ref5$enableWebGL,
9791
          _ref5$renderInteracti = _ref5.renderInteractiveForms,
9792
          renderInteractiveForms = _ref5$renderInteracti === void 0 ? false : _ref5$renderInteracti,
9793
          _ref5$transform = _ref5.transform,
9794
          transform = _ref5$transform === void 0 ? null : _ref5$transform,
9795
          _ref5$imageLayer = _ref5.imageLayer,
9796
          imageLayer = _ref5$imageLayer === void 0 ? null : _ref5$imageLayer,
9797
          _ref5$canvasFactory = _ref5.canvasFactory,
9798
          canvasFactory = _ref5$canvasFactory === void 0 ? null : _ref5$canvasFactory,
9799
          _ref5$background = _ref5.background,
9800
          background = _ref5$background === void 0 ? null : _ref5$background,
9801
          _ref5$annotationStora = _ref5.annotationStorage,
9802
          annotationStorage = _ref5$annotationStora === void 0 ? null : _ref5$annotationStora,
9803
          _ref5$optionalContent = _ref5.optionalContentConfigPromise,
9804
          optionalContentConfigPromise = _ref5$optionalContent === void 0 ? null : _ref5$optionalContent;
9805

9806
      if (this._stats) {
9807
        this._stats.time("Overall");
9808
      }
9809

9810
      var renderingIntent = intent === "print" ? "print" : "display";
9811
      this.pendingCleanup = false;
9812

9813
      if (!optionalContentConfigPromise) {
9814
        optionalContentConfigPromise = this._transport.getOptionalContentConfig();
9815
      }
9816

9817
      var intentState = this._intentStates.get(renderingIntent);
9818

9819
      if (!intentState) {
9820
        intentState = Object.create(null);
9821

9822
        this._intentStates.set(renderingIntent, intentState);
9823
      }
9824

9825
      if (intentState.streamReaderCancelTimeout) {
9826
        clearTimeout(intentState.streamReaderCancelTimeout);
9827
        intentState.streamReaderCancelTimeout = null;
9828
      }
9829

9830
      var canvasFactoryInstance = canvasFactory || new DefaultCanvasFactory({
9831
        ownerDocument: this._ownerDocument
9832
      });
9833
      var webGLContext = new _webgl.WebGLContext({
9834
        enable: enableWebGL
9835
      });
9836

9837
      if (!intentState.displayReadyCapability) {
9838
        intentState.displayReadyCapability = (0, _util.createPromiseCapability)();
9839
        intentState.operatorList = {
9840
          fnArray: [],
9841
          argsArray: [],
9842
          lastChunk: false
9843
        };
9844

9845
        if (this._stats) {
9846
          this._stats.time("Page Request");
9847
        }
9848

9849
        this._pumpOperatorList({
9850
          pageIndex: this._pageIndex,
9851
          intent: renderingIntent,
9852
          renderInteractiveForms: renderInteractiveForms === true,
9853
          annotationStorage: (annotationStorage === null || annotationStorage === void 0 ? void 0 : annotationStorage.serializable) || null
9854
        });
9855
      }
9856

9857
      var complete = function complete(error) {
9858
        intentState.renderTasks["delete"](internalRenderTask);
9859

9860
        if (_this5.cleanupAfterRender || renderingIntent === "print") {
9861
          _this5.pendingCleanup = true;
9862
        }
9863

9864
        _this5._tryCleanup();
9865

9866
        if (error) {
9867
          internalRenderTask.capability.reject(error);
9868

9869
          _this5._abortOperatorList({
9870
            intentState: intentState,
9871
            reason: error
9872
          });
9873
        } else {
9874
          internalRenderTask.capability.resolve();
9875
        }
9876

9877
        if (_this5._stats) {
9878
          _this5._stats.timeEnd("Rendering");
9879

9880
          _this5._stats.timeEnd("Overall");
9881
        }
9882
      };
9883

9884
      var internalRenderTask = new InternalRenderTask({
9885
        callback: complete,
9886
        params: {
9887
          canvasContext: canvasContext,
9888
          viewport: viewport,
9889
          transform: transform,
9890
          imageLayer: imageLayer,
9891
          background: background
9892
        },
9893
        objs: this.objs,
9894
        commonObjs: this.commonObjs,
9895
        operatorList: intentState.operatorList,
9896
        pageIndex: this._pageIndex,
9897
        canvasFactory: canvasFactoryInstance,
9898
        webGLContext: webGLContext,
9899
        useRequestAnimationFrame: renderingIntent !== "print",
9900
        pdfBug: this._pdfBug
9901
      });
9902
      ((_intentState = intentState).renderTasks || (_intentState.renderTasks = new Set())).add(internalRenderTask);
9903
      var renderTask = internalRenderTask.task;
9904
      Promise.all([intentState.displayReadyCapability.promise, optionalContentConfigPromise]).then(function (_ref6) {
9905
        var _ref7 = _slicedToArray(_ref6, 2),
9906
            transparency = _ref7[0],
9907
            optionalContentConfig = _ref7[1];
9908

9909
        if (_this5.pendingCleanup) {
9910
          complete();
9911
          return;
9912
        }
9913

9914
        if (_this5._stats) {
9915
          _this5._stats.time("Rendering");
9916
        }
9917

9918
        internalRenderTask.initializeGraphics({
9919
          transparency: transparency,
9920
          optionalContentConfig: optionalContentConfig
9921
        });
9922
        internalRenderTask.operatorListChanged();
9923
      })["catch"](complete);
9924
      return renderTask;
9925
    }
9926
  }, {
9927
    key: "getOperatorList",
9928
    value: function getOperatorList() {
9929
      function operatorListChanged() {
9930
        if (intentState.operatorList.lastChunk) {
9931
          intentState.opListReadCapability.resolve(intentState.operatorList);
9932
          intentState.renderTasks["delete"](opListTask);
9933
        }
9934
      }
9935

9936
      var renderingIntent = "oplist";
9937

9938
      var intentState = this._intentStates.get(renderingIntent);
9939

9940
      if (!intentState) {
9941
        intentState = Object.create(null);
9942

9943
        this._intentStates.set(renderingIntent, intentState);
9944
      }
9945

9946
      var opListTask;
9947

9948
      if (!intentState.opListReadCapability) {
9949
        var _intentState2;
9950

9951
        opListTask = Object.create(null);
9952
        opListTask.operatorListChanged = operatorListChanged;
9953
        intentState.opListReadCapability = (0, _util.createPromiseCapability)();
9954
        ((_intentState2 = intentState).renderTasks || (_intentState2.renderTasks = new Set())).add(opListTask);
9955
        intentState.operatorList = {
9956
          fnArray: [],
9957
          argsArray: [],
9958
          lastChunk: false
9959
        };
9960

9961
        if (this._stats) {
9962
          this._stats.time("Page Request");
9963
        }
9964

9965
        this._pumpOperatorList({
9966
          pageIndex: this._pageIndex,
9967
          intent: renderingIntent
9968
        });
9969
      }
9970

9971
      return intentState.opListReadCapability.promise;
9972
    }
9973
  }, {
9974
    key: "streamTextContent",
9975
    value: function streamTextContent() {
9976
      var _ref8 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
9977
          _ref8$normalizeWhites = _ref8.normalizeWhitespace,
9978
          normalizeWhitespace = _ref8$normalizeWhites === void 0 ? false : _ref8$normalizeWhites,
9979
          _ref8$disableCombineT = _ref8.disableCombineTextItems,
9980
          disableCombineTextItems = _ref8$disableCombineT === void 0 ? false : _ref8$disableCombineT;
9981

9982
      var TEXT_CONTENT_CHUNK_SIZE = 100;
9983
      return this._transport.messageHandler.sendWithStream("GetTextContent", {
9984
        pageIndex: this._pageIndex,
9985
        normalizeWhitespace: normalizeWhitespace === true,
9986
        combineTextItems: disableCombineTextItems !== true
9987
      }, {
9988
        highWaterMark: TEXT_CONTENT_CHUNK_SIZE,
9989
        size: function size(textContent) {
9990
          return textContent.items.length;
9991
        }
9992
      });
9993
    }
9994
  }, {
9995
    key: "getTextContent",
9996
    value: function getTextContent() {
9997
      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
9998
      var readableStream = this.streamTextContent(params);
9999
      return new Promise(function (resolve, reject) {
10000
        function pump() {
10001
          reader.read().then(function (_ref9) {
10002
            var _textContent$items;
10003

10004
            var value = _ref9.value,
10005
                done = _ref9.done;
10006

10007
            if (done) {
10008
              resolve(textContent);
10009
              return;
10010
            }
10011

10012
            Object.assign(textContent.styles, value.styles);
10013

10014
            (_textContent$items = textContent.items).push.apply(_textContent$items, _toConsumableArray(value.items));
10015

10016
            pump();
10017
          }, reject);
10018
        }
10019

10020
        var reader = readableStream.getReader();
10021
        var textContent = {
10022
          items: [],
10023
          styles: Object.create(null)
10024
        };
10025
        pump();
10026
      });
10027
    }
10028
  }, {
10029
    key: "_destroy",
10030
    value: function _destroy() {
10031
      this.destroyed = true;
10032
      this._transport.pageCache[this._pageIndex] = null;
10033
      var waitOn = [];
10034

10035
      var _iterator5 = _createForOfIteratorHelper(this._intentStates),
10036
          _step5;
10037

10038
      try {
10039
        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
10040
          var _step5$value = _slicedToArray(_step5.value, 2),
10041
              intent = _step5$value[0],
10042
              intentState = _step5$value[1];
10043

10044
          this._abortOperatorList({
10045
            intentState: intentState,
10046
            reason: new Error("Page was destroyed."),
10047
            force: true
10048
          });
10049

10050
          if (intent === "oplist") {
10051
            continue;
10052
          }
10053

10054
          var _iterator6 = _createForOfIteratorHelper(intentState.renderTasks),
10055
              _step6;
10056

10057
          try {
10058
            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
10059
              var internalRenderTask = _step6.value;
10060
              waitOn.push(internalRenderTask.completed);
10061
              internalRenderTask.cancel();
10062
            }
10063
          } catch (err) {
10064
            _iterator6.e(err);
10065
          } finally {
10066
            _iterator6.f();
10067
          }
10068
        }
10069
      } catch (err) {
10070
        _iterator5.e(err);
10071
      } finally {
10072
        _iterator5.f();
10073
      }
10074

10075
      this.objs.clear();
10076
      this._annotationsPromise = null;
10077
      this._jsActionsPromise = null;
10078
      this._xfaPromise = null;
10079
      this.pendingCleanup = false;
10080
      return Promise.all(waitOn);
10081
    }
10082
  }, {
10083
    key: "cleanup",
10084
    value: function cleanup() {
10085
      var resetStats = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
10086
      this.pendingCleanup = true;
10087
      return this._tryCleanup(resetStats);
10088
    }
10089
  }, {
10090
    key: "_tryCleanup",
10091
    value: function _tryCleanup() {
10092
      var resetStats = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
10093

10094
      if (!this.pendingCleanup) {
10095
        return false;
10096
      }
10097

10098
      var _iterator7 = _createForOfIteratorHelper(this._intentStates.values()),
10099
          _step7;
10100

10101
      try {
10102
        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
10103
          var _step7$value = _step7.value,
10104
              renderTasks = _step7$value.renderTasks,
10105
              operatorList = _step7$value.operatorList;
10106

10107
          if (renderTasks.size > 0 || !operatorList.lastChunk) {
10108
            return false;
10109
          }
10110
        }
10111
      } catch (err) {
10112
        _iterator7.e(err);
10113
      } finally {
10114
        _iterator7.f();
10115
      }
10116

10117
      this._intentStates.clear();
10118

10119
      this.objs.clear();
10120
      this._annotationsPromise = null;
10121
      this._jsActionsPromise = null;
10122
      this._xfaPromise = null;
10123

10124
      if (resetStats && this._stats) {
10125
        this._stats = new _display_utils.StatTimer();
10126
      }
10127

10128
      this.pendingCleanup = false;
10129
      return true;
10130
    }
10131
  }, {
10132
    key: "_startRenderPage",
10133
    value: function _startRenderPage(transparency, intent) {
10134
      var intentState = this._intentStates.get(intent);
10135

10136
      if (!intentState) {
10137
        return;
10138
      }
10139

10140
      if (this._stats) {
10141
        this._stats.timeEnd("Page Request");
10142
      }
10143

10144
      if (intentState.displayReadyCapability) {
10145
        intentState.displayReadyCapability.resolve(transparency);
10146
      }
10147
    }
10148
  }, {
10149
    key: "_renderPageChunk",
10150
    value: function _renderPageChunk(operatorListChunk, intentState) {
10151
      for (var i = 0, ii = operatorListChunk.length; i < ii; i++) {
10152
        intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);
10153
        intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);
10154
      }
10155

10156
      intentState.operatorList.lastChunk = operatorListChunk.lastChunk;
10157

10158
      var _iterator8 = _createForOfIteratorHelper(intentState.renderTasks),
10159
          _step8;
10160

10161
      try {
10162
        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
10163
          var internalRenderTask = _step8.value;
10164
          internalRenderTask.operatorListChanged();
10165
        }
10166
      } catch (err) {
10167
        _iterator8.e(err);
10168
      } finally {
10169
        _iterator8.f();
10170
      }
10171

10172
      if (operatorListChunk.lastChunk) {
10173
        this._tryCleanup();
10174
      }
10175
    }
10176
  }, {
10177
    key: "_pumpOperatorList",
10178
    value: function _pumpOperatorList(args) {
10179
      var _this6 = this;
10180

10181
      (0, _util.assert)(args.intent, 'PDFPageProxy._pumpOperatorList: Expected "intent" argument.');
10182

10183
      var readableStream = this._transport.messageHandler.sendWithStream("GetOperatorList", args);
10184

10185
      var reader = readableStream.getReader();
10186

10187
      var intentState = this._intentStates.get(args.intent);
10188

10189
      intentState.streamReader = reader;
10190

10191
      var pump = function pump() {
10192
        reader.read().then(function (_ref10) {
10193
          var value = _ref10.value,
10194
              done = _ref10.done;
10195

10196
          if (done) {
10197
            intentState.streamReader = null;
10198
            return;
10199
          }
10200

10201
          if (_this6._transport.destroyed) {
10202
            return;
10203
          }
10204

10205
          _this6._renderPageChunk(value, intentState);
10206

10207
          pump();
10208
        }, function (reason) {
10209
          intentState.streamReader = null;
10210

10211
          if (_this6._transport.destroyed) {
10212
            return;
10213
          }
10214

10215
          if (intentState.operatorList) {
10216
            intentState.operatorList.lastChunk = true;
10217

10218
            var _iterator9 = _createForOfIteratorHelper(intentState.renderTasks),
10219
                _step9;
10220

10221
            try {
10222
              for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
10223
                var internalRenderTask = _step9.value;
10224
                internalRenderTask.operatorListChanged();
10225
              }
10226
            } catch (err) {
10227
              _iterator9.e(err);
10228
            } finally {
10229
              _iterator9.f();
10230
            }
10231

10232
            _this6._tryCleanup();
10233
          }
10234

10235
          if (intentState.displayReadyCapability) {
10236
            intentState.displayReadyCapability.reject(reason);
10237
          } else if (intentState.opListReadCapability) {
10238
            intentState.opListReadCapability.reject(reason);
10239
          } else {
10240
            throw reason;
10241
          }
10242
        });
10243
      };
10244

10245
      pump();
10246
    }
10247
  }, {
10248
    key: "_abortOperatorList",
10249
    value: function _abortOperatorList(_ref11) {
10250
      var _this7 = this;
10251

10252
      var intentState = _ref11.intentState,
10253
          reason = _ref11.reason,
10254
          _ref11$force = _ref11.force,
10255
          force = _ref11$force === void 0 ? false : _ref11$force;
10256
      (0, _util.assert)(reason instanceof Error || _typeof(reason) === "object" && reason !== null, 'PDFPageProxy._abortOperatorList: Expected "reason" argument.');
10257

10258
      if (!intentState.streamReader) {
10259
        return;
10260
      }
10261

10262
      if (!force) {
10263
        if (intentState.renderTasks.size > 0) {
10264
          return;
10265
        }
10266

10267
        if (reason instanceof _display_utils.RenderingCancelledException) {
10268
          intentState.streamReaderCancelTimeout = setTimeout(function () {
10269
            _this7._abortOperatorList({
10270
              intentState: intentState,
10271
              reason: reason,
10272
              force: true
10273
            });
10274

10275
            intentState.streamReaderCancelTimeout = null;
10276
          }, RENDERING_CANCELLED_TIMEOUT);
10277
          return;
10278
        }
10279
      }
10280

10281
      intentState.streamReader.cancel(new _util.AbortException(reason === null || reason === void 0 ? void 0 : reason.message));
10282
      intentState.streamReader = null;
10283

10284
      if (this._transport.destroyed) {
10285
        return;
10286
      }
10287

10288
      var _iterator10 = _createForOfIteratorHelper(this._intentStates),
10289
          _step10;
10290

10291
      try {
10292
        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
10293
          var _step10$value = _slicedToArray(_step10.value, 2),
10294
              intent = _step10$value[0],
10295
              curIntentState = _step10$value[1];
10296

10297
          if (curIntentState === intentState) {
10298
            this._intentStates["delete"](intent);
10299

10300
            break;
10301
          }
10302
        }
10303
      } catch (err) {
10304
        _iterator10.e(err);
10305
      } finally {
10306
        _iterator10.f();
10307
      }
10308

10309
      this.cleanup();
10310
    }
10311
  }, {
10312
    key: "stats",
10313
    get: function get() {
10314
      return this._stats;
10315
    }
10316
  }]);
10317

10318
  return PDFPageProxy;
10319
}();
10320

10321
exports.PDFPageProxy = PDFPageProxy;
10322

10323
var LoopbackPort = /*#__PURE__*/function () {
10324
  function LoopbackPort() {
10325
    _classCallCheck(this, LoopbackPort);
10326

10327
    this._listeners = [];
10328
    this._deferred = Promise.resolve(undefined);
10329
  }
10330

10331
  _createClass(LoopbackPort, [{
10332
    key: "postMessage",
10333
    value: function postMessage(obj, transfers) {
10334
      var _this8 = this;
10335

10336
      function cloneValue(value) {
10337
        if (_typeof(value) !== "object" || value === null) {
10338
          return value;
10339
        }
10340

10341
        if (cloned.has(value)) {
10342
          return cloned.get(value);
10343
        }
10344

10345
        var buffer, result;
10346

10347
        if ((buffer = value.buffer) && (0, _util.isArrayBuffer)(buffer)) {
10348
          if (transfers !== null && transfers !== void 0 && transfers.includes(buffer)) {
10349
            result = new value.constructor(buffer, value.byteOffset, value.byteLength);
10350
          } else {
10351
            result = new value.constructor(value);
10352
          }
10353

10354
          cloned.set(value, result);
10355
          return result;
10356
        }
10357

10358
        if (value instanceof Map) {
10359
          result = new Map();
10360
          cloned.set(value, result);
10361

10362
          var _iterator11 = _createForOfIteratorHelper(value),
10363
              _step11;
10364

10365
          try {
10366
            for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
10367
              var _step11$value = _slicedToArray(_step11.value, 2),
10368
                  key = _step11$value[0],
10369
                  val = _step11$value[1];
10370

10371
              result.set(key, cloneValue(val));
10372
            }
10373
          } catch (err) {
10374
            _iterator11.e(err);
10375
          } finally {
10376
            _iterator11.f();
10377
          }
10378

10379
          return result;
10380
        }
10381

10382
        if (value instanceof Set) {
10383
          result = new Set();
10384
          cloned.set(value, result);
10385

10386
          var _iterator12 = _createForOfIteratorHelper(value),
10387
              _step12;
10388

10389
          try {
10390
            for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
10391
              var _val = _step12.value;
10392
              result.add(cloneValue(_val));
10393
            }
10394
          } catch (err) {
10395
            _iterator12.e(err);
10396
          } finally {
10397
            _iterator12.f();
10398
          }
10399

10400
          return result;
10401
        }
10402

10403
        result = Array.isArray(value) ? [] : {};
10404
        cloned.set(value, result);
10405

10406
        for (var i in value) {
10407
          var desc = void 0,
10408
              p = value;
10409

10410
          while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {
10411
            p = Object.getPrototypeOf(p);
10412
          }
10413

10414
          if (typeof desc.value === "undefined") {
10415
            continue;
10416
          }
10417

10418
          if (typeof desc.value === "function") {
10419
            var _value$hasOwnProperty;
10420

10421
            if ((_value$hasOwnProperty = value.hasOwnProperty) !== null && _value$hasOwnProperty !== void 0 && _value$hasOwnProperty.call(value, i)) {
10422
              throw new Error("LoopbackPort.postMessage - cannot clone: ".concat(value[i]));
10423
            }
10424

10425
            continue;
10426
          }
10427

10428
          result[i] = cloneValue(desc.value);
10429
        }
10430

10431
        return result;
10432
      }
10433

10434
      var cloned = new WeakMap();
10435
      var event = {
10436
        data: cloneValue(obj)
10437
      };
10438

10439
      this._deferred.then(function () {
10440
        var _iterator13 = _createForOfIteratorHelper(_this8._listeners),
10441
            _step13;
10442

10443
        try {
10444
          for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
10445
            var listener = _step13.value;
10446
            listener.call(_this8, event);
10447
          }
10448
        } catch (err) {
10449
          _iterator13.e(err);
10450
        } finally {
10451
          _iterator13.f();
10452
        }
10453
      });
10454
    }
10455
  }, {
10456
    key: "addEventListener",
10457
    value: function addEventListener(name, listener) {
10458
      this._listeners.push(listener);
10459
    }
10460
  }, {
10461
    key: "removeEventListener",
10462
    value: function removeEventListener(name, listener) {
10463
      var i = this._listeners.indexOf(listener);
10464

10465
      this._listeners.splice(i, 1);
10466
    }
10467
  }, {
10468
    key: "terminate",
10469
    value: function terminate() {
10470
      this._listeners.length = 0;
10471
    }
10472
  }]);
10473

10474
  return LoopbackPort;
10475
}();
10476

10477
exports.LoopbackPort = LoopbackPort;
10478

10479
var PDFWorker = function PDFWorkerClosure() {
10480
  var pdfWorkerPorts = new WeakMap();
10481
  var isWorkerDisabled = false;
10482
  var fallbackWorkerSrc;
10483
  var nextFakeWorkerId = 0;
10484
  var fakeWorkerCapability;
10485

10486
  if (_is_node.isNodeJS && typeof require === "function") {
10487
    isWorkerDisabled = true;
10488
    fallbackWorkerSrc = "./pdf.worker.js";
10489
  } else if ((typeof document === "undefined" ? "undefined" : _typeof(document)) === "object" && "currentScript" in document) {
10490
    var _document$currentScri;
10491

10492
    var pdfjsFilePath = (_document$currentScri = document.currentScript) === null || _document$currentScri === void 0 ? void 0 : _document$currentScri.src;
10493

10494
    if (pdfjsFilePath) {
10495
      fallbackWorkerSrc = pdfjsFilePath.replace(/(\.(?:min\.)?js)(\?.*)?$/i, ".worker$1$2");
10496
    }
10497
  }
10498

10499
  function _getWorkerSrc() {
10500
    if (_worker_options.GlobalWorkerOptions.workerSrc) {
10501
      return _worker_options.GlobalWorkerOptions.workerSrc;
10502
    }
10503

10504
    if (typeof fallbackWorkerSrc !== "undefined") {
10505
      if (!_is_node.isNodeJS) {
10506
        (0, _display_utils.deprecated)('No "GlobalWorkerOptions.workerSrc" specified.');
10507
      }
10508

10509
      return fallbackWorkerSrc;
10510
    }
10511

10512
    throw new Error('No "GlobalWorkerOptions.workerSrc" specified.');
10513
  }
10514

10515
  function getMainThreadWorkerMessageHandler() {
10516
    var mainWorkerMessageHandler;
10517

10518
    try {
10519
      var _globalThis$pdfjsWork;
10520

10521
      mainWorkerMessageHandler = (_globalThis$pdfjsWork = globalThis.pdfjsWorker) === null || _globalThis$pdfjsWork === void 0 ? void 0 : _globalThis$pdfjsWork.WorkerMessageHandler;
10522
    } catch (ex) {}
10523

10524
    return mainWorkerMessageHandler || null;
10525
  }
10526

10527
  function setupFakeWorkerGlobal() {
10528
    if (fakeWorkerCapability) {
10529
      return fakeWorkerCapability.promise;
10530
    }
10531

10532
    fakeWorkerCapability = (0, _util.createPromiseCapability)();
10533

10534
    var loader = /*#__PURE__*/function () {
10535
      var _ref12 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
10536
        var mainWorkerMessageHandler, worker;
10537
        return _regenerator["default"].wrap(function _callee$(_context) {
10538
          while (1) {
10539
            switch (_context.prev = _context.next) {
10540
              case 0:
10541
                mainWorkerMessageHandler = getMainThreadWorkerMessageHandler();
10542

10543
                if (!mainWorkerMessageHandler) {
10544
                  _context.next = 3;
10545
                  break;
10546
                }
10547

10548
                return _context.abrupt("return", mainWorkerMessageHandler);
10549

10550
              case 3:
10551
                if (!(_is_node.isNodeJS && typeof require === "function")) {
10552
                  _context.next = 6;
10553
                  break;
10554
                }
10555

10556
                worker = eval("require")(_getWorkerSrc());
10557
                return _context.abrupt("return", worker.WorkerMessageHandler);
10558

10559
              case 6:
10560
                _context.next = 8;
10561
                return (0, _display_utils.loadScript)(_getWorkerSrc());
10562

10563
              case 8:
10564
                return _context.abrupt("return", window.pdfjsWorker.WorkerMessageHandler);
10565

10566
              case 9:
10567
              case "end":
10568
                return _context.stop();
10569
            }
10570
          }
10571
        }, _callee);
10572
      }));
10573

10574
      return function loader() {
10575
        return _ref12.apply(this, arguments);
10576
      };
10577
    }();
10578

10579
    loader().then(fakeWorkerCapability.resolve, fakeWorkerCapability.reject);
10580
    return fakeWorkerCapability.promise;
10581
  }
10582

10583
  function createCDNWrapper(url) {
10584
    var wrapper = "importScripts('" + url + "');";
10585
    return URL.createObjectURL(new Blob([wrapper]));
10586
  }
10587

10588
  var PDFWorker = /*#__PURE__*/function () {
10589
    function PDFWorker() {
10590
      var _ref13 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
10591
          _ref13$name = _ref13.name,
10592
          name = _ref13$name === void 0 ? null : _ref13$name,
10593
          _ref13$port = _ref13.port,
10594
          port = _ref13$port === void 0 ? null : _ref13$port,
10595
          _ref13$verbosity = _ref13.verbosity,
10596
          verbosity = _ref13$verbosity === void 0 ? (0, _util.getVerbosityLevel)() : _ref13$verbosity;
10597

10598
      _classCallCheck(this, PDFWorker);
10599

10600
      if (port && pdfWorkerPorts.has(port)) {
10601
        throw new Error("Cannot use more than one PDFWorker per port");
10602
      }
10603

10604
      this.name = name;
10605
      this.destroyed = false;
10606
      this.postMessageTransfers = true;
10607
      this.verbosity = verbosity;
10608
      this._readyCapability = (0, _util.createPromiseCapability)();
10609
      this._port = null;
10610
      this._webWorker = null;
10611
      this._messageHandler = null;
10612

10613
      if (port) {
10614
        pdfWorkerPorts.set(port, this);
10615

10616
        this._initializeFromPort(port);
10617

10618
        return;
10619
      }
10620

10621
      this._initialize();
10622
    }
10623

10624
    _createClass(PDFWorker, [{
10625
      key: "promise",
10626
      get: function get() {
10627
        return this._readyCapability.promise;
10628
      }
10629
    }, {
10630
      key: "port",
10631
      get: function get() {
10632
        return this._port;
10633
      }
10634
    }, {
10635
      key: "messageHandler",
10636
      get: function get() {
10637
        return this._messageHandler;
10638
      }
10639
    }, {
10640
      key: "_initializeFromPort",
10641
      value: function _initializeFromPort(port) {
10642
        this._port = port;
10643
        this._messageHandler = new _message_handler.MessageHandler("main", "worker", port);
10644

10645
        this._messageHandler.on("ready", function () {});
10646

10647
        this._readyCapability.resolve();
10648
      }
10649
    }, {
10650
      key: "_initialize",
10651
      value: function _initialize() {
10652
        var _this9 = this;
10653

10654
        if (typeof Worker !== "undefined" && !isWorkerDisabled && !getMainThreadWorkerMessageHandler()) {
10655
          var workerSrc = _getWorkerSrc();
10656

10657
          try {
10658
            if (!(0, _util.isSameOrigin)(window.location.href, workerSrc)) {
10659
              workerSrc = createCDNWrapper(new URL(workerSrc, window.location).href);
10660
            }
10661

10662
            var worker = new Worker(workerSrc);
10663
            var messageHandler = new _message_handler.MessageHandler("main", "worker", worker);
10664

10665
            var terminateEarly = function terminateEarly() {
10666
              worker.removeEventListener("error", onWorkerError);
10667
              messageHandler.destroy();
10668
              worker.terminate();
10669

10670
              if (_this9.destroyed) {
10671
                _this9._readyCapability.reject(new Error("Worker was destroyed"));
10672
              } else {
10673
                _this9._setupFakeWorker();
10674
              }
10675
            };
10676

10677
            var onWorkerError = function onWorkerError() {
10678
              if (!_this9._webWorker) {
10679
                terminateEarly();
10680
              }
10681
            };
10682

10683
            worker.addEventListener("error", onWorkerError);
10684
            messageHandler.on("test", function (data) {
10685
              worker.removeEventListener("error", onWorkerError);
10686

10687
              if (_this9.destroyed) {
10688
                terminateEarly();
10689
                return;
10690
              }
10691

10692
              if (data) {
10693
                _this9._messageHandler = messageHandler;
10694
                _this9._port = worker;
10695
                _this9._webWorker = worker;
10696

10697
                if (!data.supportTransfers) {
10698
                  _this9.postMessageTransfers = false;
10699
                }
10700

10701
                _this9._readyCapability.resolve();
10702

10703
                messageHandler.send("configure", {
10704
                  verbosity: _this9.verbosity
10705
                });
10706
              } else {
10707
                _this9._setupFakeWorker();
10708

10709
                messageHandler.destroy();
10710
                worker.terminate();
10711
              }
10712
            });
10713
            messageHandler.on("ready", function (data) {
10714
              worker.removeEventListener("error", onWorkerError);
10715

10716
              if (_this9.destroyed) {
10717
                terminateEarly();
10718
                return;
10719
              }
10720

10721
              try {
10722
                sendTest();
10723
              } catch (e) {
10724
                _this9._setupFakeWorker();
10725
              }
10726
            });
10727

10728
            var sendTest = function sendTest() {
10729
              var testObj = new Uint8Array([_this9.postMessageTransfers ? 255 : 0]);
10730

10731
              try {
10732
                messageHandler.send("test", testObj, [testObj.buffer]);
10733
              } catch (ex) {
10734
                (0, _util.warn)("Cannot use postMessage transfers.");
10735
                testObj[0] = 0;
10736
                messageHandler.send("test", testObj);
10737
              }
10738
            };
10739

10740
            sendTest();
10741
            return;
10742
          } catch (e) {
10743
            (0, _util.info)("The worker has been disabled.");
10744
          }
10745
        }
10746

10747
        this._setupFakeWorker();
10748
      }
10749
    }, {
10750
      key: "_setupFakeWorker",
10751
      value: function _setupFakeWorker() {
10752
        var _this10 = this;
10753

10754
        if (!isWorkerDisabled) {
10755
          (0, _util.warn)("Setting up fake worker.");
10756
          isWorkerDisabled = true;
10757
        }
10758

10759
        setupFakeWorkerGlobal().then(function (WorkerMessageHandler) {
10760
          if (_this10.destroyed) {
10761
            _this10._readyCapability.reject(new Error("Worker was destroyed"));
10762

10763
            return;
10764
          }
10765

10766
          var port = new LoopbackPort();
10767
          _this10._port = port;
10768
          var id = "fake" + nextFakeWorkerId++;
10769
          var workerHandler = new _message_handler.MessageHandler(id + "_worker", id, port);
10770
          WorkerMessageHandler.setup(workerHandler, port);
10771
          var messageHandler = new _message_handler.MessageHandler(id, id + "_worker", port);
10772
          _this10._messageHandler = messageHandler;
10773

10774
          _this10._readyCapability.resolve();
10775

10776
          messageHandler.send("configure", {
10777
            verbosity: _this10.verbosity
10778
          });
10779
        })["catch"](function (reason) {
10780
          _this10._readyCapability.reject(new Error("Setting up fake worker failed: \"".concat(reason.message, "\".")));
10781
        });
10782
      }
10783
    }, {
10784
      key: "destroy",
10785
      value: function destroy() {
10786
        this.destroyed = true;
10787

10788
        if (this._webWorker) {
10789
          this._webWorker.terminate();
10790

10791
          this._webWorker = null;
10792
        }
10793

10794
        pdfWorkerPorts["delete"](this._port);
10795
        this._port = null;
10796

10797
        if (this._messageHandler) {
10798
          this._messageHandler.destroy();
10799

10800
          this._messageHandler = null;
10801
        }
10802
      }
10803
    }], [{
10804
      key: "fromPort",
10805
      value: function fromPort(params) {
10806
        if (!params || !params.port) {
10807
          throw new Error("PDFWorker.fromPort - invalid method signature.");
10808
        }
10809

10810
        if (pdfWorkerPorts.has(params.port)) {
10811
          return pdfWorkerPorts.get(params.port);
10812
        }
10813

10814
        return new PDFWorker(params);
10815
      }
10816
    }, {
10817
      key: "getWorkerSrc",
10818
      value: function getWorkerSrc() {
10819
        return _getWorkerSrc();
10820
      }
10821
    }]);
10822

10823
    return PDFWorker;
10824
  }();
10825

10826
  return PDFWorker;
10827
}();
10828

10829
exports.PDFWorker = PDFWorker;
10830

10831
var WorkerTransport = /*#__PURE__*/function () {
10832
  function WorkerTransport(messageHandler, loadingTask, networkStream, params) {
10833
    _classCallCheck(this, WorkerTransport);
10834

10835
    this.messageHandler = messageHandler;
10836
    this.loadingTask = loadingTask;
10837
    this.commonObjs = new PDFObjects();
10838
    this.fontLoader = new _font_loader.FontLoader({
10839
      docId: loadingTask.docId,
10840
      onUnsupportedFeature: this._onUnsupportedFeature.bind(this),
10841
      ownerDocument: params.ownerDocument
10842
    });
10843
    this._params = params;
10844
    this.CMapReaderFactory = new params.CMapReaderFactory({
10845
      baseUrl: params.cMapUrl,
10846
      isCompressed: params.cMapPacked
10847
    });
10848
    this.destroyed = false;
10849
    this.destroyCapability = null;
10850
    this._passwordCapability = null;
10851
    this._networkStream = networkStream;
10852
    this._fullReader = null;
10853
    this._lastProgress = null;
10854
    this.pageCache = [];
10855
    this.pagePromises = [];
10856
    this.downloadInfoCapability = (0, _util.createPromiseCapability)();
10857
    this.setupMessageHandler();
10858
  }
10859

10860
  _createClass(WorkerTransport, [{
10861
    key: "loadingTaskSettled",
10862
    get: function get() {
10863
      return this.loadingTask._capability.settled;
10864
    }
10865
  }, {
10866
    key: "destroy",
10867
    value: function destroy() {
10868
      var _this11 = this;
10869

10870
      if (this.destroyCapability) {
10871
        return this.destroyCapability.promise;
10872
      }
10873

10874
      this.destroyed = true;
10875
      this.destroyCapability = (0, _util.createPromiseCapability)();
10876

10877
      if (this._passwordCapability) {
10878
        this._passwordCapability.reject(new Error("Worker was destroyed during onPassword callback"));
10879
      }
10880

10881
      var waitOn = [];
10882
      this.pageCache.forEach(function (page) {
10883
        if (page) {
10884
          waitOn.push(page._destroy());
10885
        }
10886
      });
10887
      this.pageCache.length = 0;
10888
      this.pagePromises.length = 0;
10889
      var terminated = this.messageHandler.sendWithPromise("Terminate", null);
10890
      waitOn.push(terminated);
10891

10892
      if (this.loadingTaskSettled) {
10893
        var annotationStorageResetModified = this.loadingTask.promise.then(function (pdfDocument) {
10894
          if (pdfDocument.hasOwnProperty("annotationStorage")) {
10895
            pdfDocument.annotationStorage.resetModified();
10896
          }
10897
        })["catch"](function () {});
10898
        waitOn.push(annotationStorageResetModified);
10899
      }
10900

10901
      Promise.all(waitOn).then(function () {
10902
        _this11.commonObjs.clear();
10903

10904
        _this11.fontLoader.clear();
10905

10906
        _this11._hasJSActionsPromise = null;
10907

10908
        if (_this11._networkStream) {
10909
          _this11._networkStream.cancelAllRequests(new _util.AbortException("Worker was terminated."));
10910
        }
10911

10912
        if (_this11.messageHandler) {
10913
          _this11.messageHandler.destroy();
10914

10915
          _this11.messageHandler = null;
10916
        }
10917

10918
        _this11.destroyCapability.resolve();
10919
      }, this.destroyCapability.reject);
10920
      return this.destroyCapability.promise;
10921
    }
10922
  }, {
10923
    key: "setupMessageHandler",
10924
    value: function setupMessageHandler() {
10925
      var _this12 = this;
10926

10927
      var messageHandler = this.messageHandler,
10928
          loadingTask = this.loadingTask;
10929
      messageHandler.on("GetReader", function (data, sink) {
10930
        (0, _util.assert)(_this12._networkStream, "GetReader - no `IPDFStream` instance available.");
10931
        _this12._fullReader = _this12._networkStream.getFullReader();
10932

10933
        _this12._fullReader.onProgress = function (evt) {
10934
          _this12._lastProgress = {
10935
            loaded: evt.loaded,
10936
            total: evt.total
10937
          };
10938
        };
10939

10940
        sink.onPull = function () {
10941
          _this12._fullReader.read().then(function (_ref14) {
10942
            var value = _ref14.value,
10943
                done = _ref14.done;
10944

10945
            if (done) {
10946
              sink.close();
10947
              return;
10948
            }
10949

10950
            (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetReader - expected an ArrayBuffer.");
10951
            sink.enqueue(new Uint8Array(value), 1, [value]);
10952
          })["catch"](function (reason) {
10953
            sink.error(reason);
10954
          });
10955
        };
10956

10957
        sink.onCancel = function (reason) {
10958
          _this12._fullReader.cancel(reason);
10959

10960
          sink.ready["catch"](function (readyReason) {
10961
            if (_this12.destroyed) {
10962
              return;
10963
            }
10964

10965
            throw readyReason;
10966
          });
10967
        };
10968
      });
10969
      messageHandler.on("ReaderHeadersReady", function (data) {
10970
        var headersCapability = (0, _util.createPromiseCapability)();
10971
        var fullReader = _this12._fullReader;
10972
        fullReader.headersReady.then(function () {
10973
          if (!fullReader.isStreamingSupported || !fullReader.isRangeSupported) {
10974
            if (_this12._lastProgress && loadingTask.onProgress) {
10975
              loadingTask.onProgress(_this12._lastProgress);
10976
            }
10977

10978
            fullReader.onProgress = function (evt) {
10979
              if (loadingTask.onProgress) {
10980
                loadingTask.onProgress({
10981
                  loaded: evt.loaded,
10982
                  total: evt.total
10983
                });
10984
              }
10985
            };
10986
          }
10987

10988
          headersCapability.resolve({
10989
            isStreamingSupported: fullReader.isStreamingSupported,
10990
            isRangeSupported: fullReader.isRangeSupported,
10991
            contentLength: fullReader.contentLength
10992
          });
10993
        }, headersCapability.reject);
10994
        return headersCapability.promise;
10995
      });
10996
      messageHandler.on("GetRangeReader", function (data, sink) {
10997
        (0, _util.assert)(_this12._networkStream, "GetRangeReader - no `IPDFStream` instance available.");
10998

10999
        var rangeReader = _this12._networkStream.getRangeReader(data.begin, data.end);
11000

11001
        if (!rangeReader) {
11002
          sink.close();
11003
          return;
11004
        }
11005

11006
        sink.onPull = function () {
11007
          rangeReader.read().then(function (_ref15) {
11008
            var value = _ref15.value,
11009
                done = _ref15.done;
11010

11011
            if (done) {
11012
              sink.close();
11013
              return;
11014
            }
11015

11016
            (0, _util.assert)((0, _util.isArrayBuffer)(value), "GetRangeReader - expected an ArrayBuffer.");
11017
            sink.enqueue(new Uint8Array(value), 1, [value]);
11018
          })["catch"](function (reason) {
11019
            sink.error(reason);
11020
          });
11021
        };
11022

11023
        sink.onCancel = function (reason) {
11024
          rangeReader.cancel(reason);
11025
          sink.ready["catch"](function (readyReason) {
11026
            if (_this12.destroyed) {
11027
              return;
11028
            }
11029

11030
            throw readyReason;
11031
          });
11032
        };
11033
      });
11034
      messageHandler.on("GetDoc", function (_ref16) {
11035
        var pdfInfo = _ref16.pdfInfo;
11036
        _this12._numPages = pdfInfo.numPages;
11037

11038
        loadingTask._capability.resolve(new PDFDocumentProxy(pdfInfo, _this12));
11039
      });
11040
      messageHandler.on("DocException", function (ex) {
11041
        var reason;
11042

11043
        switch (ex.name) {
11044
          case "PasswordException":
11045
            reason = new _util.PasswordException(ex.message, ex.code);
11046
            break;
11047

11048
          case "InvalidPDFException":
11049
            reason = new _util.InvalidPDFException(ex.message);
11050
            break;
11051

11052
          case "MissingPDFException":
11053
            reason = new _util.MissingPDFException(ex.message);
11054
            break;
11055

11056
          case "UnexpectedResponseException":
11057
            reason = new _util.UnexpectedResponseException(ex.message, ex.status);
11058
            break;
11059

11060
          case "UnknownErrorException":
11061
            reason = new _util.UnknownErrorException(ex.message, ex.details);
11062
            break;
11063
        }
11064

11065
        if (!(reason instanceof Error)) {
11066
          var msg = "DocException - expected a valid Error.";
11067
          (0, _util.warn)(msg);
11068
        }
11069

11070
        loadingTask._capability.reject(reason);
11071
      });
11072
      messageHandler.on("PasswordRequest", function (exception) {
11073
        _this12._passwordCapability = (0, _util.createPromiseCapability)();
11074

11075
        if (loadingTask.onPassword) {
11076
          var updatePassword = function updatePassword(password) {
11077
            _this12._passwordCapability.resolve({
11078
              password: password
11079
            });
11080
          };
11081

11082
          try {
11083
            loadingTask.onPassword(updatePassword, exception.code);
11084
          } catch (ex) {
11085
            _this12._passwordCapability.reject(ex);
11086
          }
11087
        } else {
11088
          _this12._passwordCapability.reject(new _util.PasswordException(exception.message, exception.code));
11089
        }
11090

11091
        return _this12._passwordCapability.promise;
11092
      });
11093
      messageHandler.on("DataLoaded", function (data) {
11094
        if (loadingTask.onProgress) {
11095
          loadingTask.onProgress({
11096
            loaded: data.length,
11097
            total: data.length
11098
          });
11099
        }
11100

11101
        _this12.downloadInfoCapability.resolve(data);
11102
      });
11103
      messageHandler.on("StartRenderPage", function (data) {
11104
        if (_this12.destroyed) {
11105
          return;
11106
        }
11107

11108
        var page = _this12.pageCache[data.pageIndex];
11109

11110
        page._startRenderPage(data.transparency, data.intent);
11111
      });
11112
      messageHandler.on("commonobj", function (data) {
11113
        var _globalThis$FontInspe;
11114

11115
        if (_this12.destroyed) {
11116
          return;
11117
        }
11118

11119
        var _data = _slicedToArray(data, 3),
11120
            id = _data[0],
11121
            type = _data[1],
11122
            exportedData = _data[2];
11123

11124
        if (_this12.commonObjs.has(id)) {
11125
          return;
11126
        }
11127

11128
        switch (type) {
11129
          case "Font":
11130
            var params = _this12._params;
11131

11132
            if ("error" in exportedData) {
11133
              var exportedError = exportedData.error;
11134
              (0, _util.warn)("Error during font loading: ".concat(exportedError));
11135

11136
              _this12.commonObjs.resolve(id, exportedError);
11137

11138
              break;
11139
            }
11140

11141
            var fontRegistry = null;
11142

11143
            if (params.pdfBug && (_globalThis$FontInspe = globalThis.FontInspector) !== null && _globalThis$FontInspe !== void 0 && _globalThis$FontInspe.enabled) {
11144
              fontRegistry = {
11145
                registerFont: function registerFont(font, url) {
11146
                  globalThis.FontInspector.fontAdded(font, url);
11147
                }
11148
              };
11149
            }
11150

11151
            var font = new _font_loader.FontFaceObject(exportedData, {
11152
              isEvalSupported: params.isEvalSupported,
11153
              disableFontFace: params.disableFontFace,
11154
              ignoreErrors: params.ignoreErrors,
11155
              onUnsupportedFeature: _this12._onUnsupportedFeature.bind(_this12),
11156
              fontRegistry: fontRegistry
11157
            });
11158

11159
            _this12.fontLoader.bind(font)["catch"](function (reason) {
11160
              return messageHandler.sendWithPromise("FontFallback", {
11161
                id: id
11162
              });
11163
            })["finally"](function () {
11164
              if (!params.fontExtraProperties && font.data) {
11165
                font.data = null;
11166
              }
11167

11168
              _this12.commonObjs.resolve(id, font);
11169
            });
11170

11171
            break;
11172

11173
          case "FontPath":
11174
          case "Image":
11175
            _this12.commonObjs.resolve(id, exportedData);
11176

11177
            break;
11178

11179
          default:
11180
            throw new Error("Got unknown common object type ".concat(type));
11181
        }
11182
      });
11183
      messageHandler.on("obj", function (data) {
11184
        var _imageData$data;
11185

11186
        if (_this12.destroyed) {
11187
          return undefined;
11188
        }
11189

11190
        var _data2 = _slicedToArray(data, 4),
11191
            id = _data2[0],
11192
            pageIndex = _data2[1],
11193
            type = _data2[2],
11194
            imageData = _data2[3];
11195

11196
        var pageProxy = _this12.pageCache[pageIndex];
11197

11198
        if (pageProxy.objs.has(id)) {
11199
          return undefined;
11200
        }
11201

11202
        switch (type) {
11203
          case "Image":
11204
            pageProxy.objs.resolve(id, imageData);
11205
            var MAX_IMAGE_SIZE_TO_STORE = 8000000;
11206

11207
            if ((imageData === null || imageData === void 0 ? void 0 : (_imageData$data = imageData.data) === null || _imageData$data === void 0 ? void 0 : _imageData$data.length) > MAX_IMAGE_SIZE_TO_STORE) {
11208
              pageProxy.cleanupAfterRender = true;
11209
            }
11210

11211
            break;
11212

11213
          default:
11214
            throw new Error("Got unknown object type ".concat(type));
11215
        }
11216

11217
        return undefined;
11218
      });
11219
      messageHandler.on("DocProgress", function (data) {
11220
        if (_this12.destroyed) {
11221
          return;
11222
        }
11223

11224
        if (loadingTask.onProgress) {
11225
          loadingTask.onProgress({
11226
            loaded: data.loaded,
11227
            total: data.total
11228
          });
11229
        }
11230
      });
11231
      messageHandler.on("UnsupportedFeature", this._onUnsupportedFeature.bind(this));
11232
      messageHandler.on("FetchBuiltInCMap", function (data, sink) {
11233
        if (_this12.destroyed) {
11234
          sink.error(new Error("Worker was destroyed"));
11235
          return;
11236
        }
11237

11238
        var fetched = false;
11239

11240
        sink.onPull = function () {
11241
          if (fetched) {
11242
            sink.close();
11243
            return;
11244
          }
11245

11246
          fetched = true;
11247

11248
          _this12.CMapReaderFactory.fetch(data).then(function (builtInCMap) {
11249
            sink.enqueue(builtInCMap, 1, [builtInCMap.cMapData.buffer]);
11250
          })["catch"](function (reason) {
11251
            sink.error(reason);
11252
          });
11253
        };
11254
      });
11255
    }
11256
  }, {
11257
    key: "_onUnsupportedFeature",
11258
    value: function _onUnsupportedFeature(_ref17) {
11259
      var featureId = _ref17.featureId;
11260

11261
      if (this.destroyed) {
11262
        return;
11263
      }
11264

11265
      if (this.loadingTask.onUnsupportedFeature) {
11266
        this.loadingTask.onUnsupportedFeature(featureId);
11267
      }
11268
    }
11269
  }, {
11270
    key: "getData",
11271
    value: function getData() {
11272
      return this.messageHandler.sendWithPromise("GetData", null);
11273
    }
11274
  }, {
11275
    key: "getPage",
11276
    value: function getPage(pageNumber) {
11277
      var _this13 = this;
11278

11279
      if (!Number.isInteger(pageNumber) || pageNumber <= 0 || pageNumber > this._numPages) {
11280
        return Promise.reject(new Error("Invalid page request"));
11281
      }
11282

11283
      var pageIndex = pageNumber - 1;
11284

11285
      if (pageIndex in this.pagePromises) {
11286
        return this.pagePromises[pageIndex];
11287
      }
11288

11289
      var promise = this.messageHandler.sendWithPromise("GetPage", {
11290
        pageIndex: pageIndex
11291
      }).then(function (pageInfo) {
11292
        if (_this13.destroyed) {
11293
          throw new Error("Transport destroyed");
11294
        }
11295

11296
        var page = new PDFPageProxy(pageIndex, pageInfo, _this13, _this13._params.ownerDocument, _this13._params.pdfBug);
11297
        _this13.pageCache[pageIndex] = page;
11298
        return page;
11299
      });
11300
      this.pagePromises[pageIndex] = promise;
11301
      return promise;
11302
    }
11303
  }, {
11304
    key: "getPageIndex",
11305
    value: function getPageIndex(ref) {
11306
      return this.messageHandler.sendWithPromise("GetPageIndex", {
11307
        ref: ref
11308
      })["catch"](function (reason) {
11309
        return Promise.reject(new Error(reason));
11310
      });
11311
    }
11312
  }, {
11313
    key: "getAnnotations",
11314
    value: function getAnnotations(pageIndex, intent) {
11315
      return this.messageHandler.sendWithPromise("GetAnnotations", {
11316
        pageIndex: pageIndex,
11317
        intent: intent
11318
      });
11319
    }
11320
  }, {
11321
    key: "saveDocument",
11322
    value: function saveDocument(annotationStorage) {
11323
      var _this$_fullReader$fil, _this$_fullReader;
11324

11325
      return this.messageHandler.sendWithPromise("SaveDocument", {
11326
        numPages: this._numPages,
11327
        annotationStorage: (annotationStorage === null || annotationStorage === void 0 ? void 0 : annotationStorage.serializable) || null,
11328
        filename: (_this$_fullReader$fil = (_this$_fullReader = this._fullReader) === null || _this$_fullReader === void 0 ? void 0 : _this$_fullReader.filename) !== null && _this$_fullReader$fil !== void 0 ? _this$_fullReader$fil : null
11329
      })["finally"](function () {
11330
        if (annotationStorage) {
11331
          annotationStorage.resetModified();
11332
        }
11333
      });
11334
    }
11335
  }, {
11336
    key: "getFieldObjects",
11337
    value: function getFieldObjects() {
11338
      return this.messageHandler.sendWithPromise("GetFieldObjects", null);
11339
    }
11340
  }, {
11341
    key: "hasJSActions",
11342
    value: function hasJSActions() {
11343
      return this._hasJSActionsPromise || (this._hasJSActionsPromise = this.messageHandler.sendWithPromise("HasJSActions", null));
11344
    }
11345
  }, {
11346
    key: "getCalculationOrderIds",
11347
    value: function getCalculationOrderIds() {
11348
      return this.messageHandler.sendWithPromise("GetCalculationOrderIds", null);
11349
    }
11350
  }, {
11351
    key: "getDestinations",
11352
    value: function getDestinations() {
11353
      return this.messageHandler.sendWithPromise("GetDestinations", null);
11354
    }
11355
  }, {
11356
    key: "getDestination",
11357
    value: function getDestination(id) {
11358
      if (typeof id !== "string") {
11359
        return Promise.reject(new Error("Invalid destination request."));
11360
      }
11361

11362
      return this.messageHandler.sendWithPromise("GetDestination", {
11363
        id: id
11364
      });
11365
    }
11366
  }, {
11367
    key: "getPageLabels",
11368
    value: function getPageLabels() {
11369
      return this.messageHandler.sendWithPromise("GetPageLabels", null);
11370
    }
11371
  }, {
11372
    key: "getPageLayout",
11373
    value: function getPageLayout() {
11374
      return this.messageHandler.sendWithPromise("GetPageLayout", null);
11375
    }
11376
  }, {
11377
    key: "getPageMode",
11378
    value: function getPageMode() {
11379
      return this.messageHandler.sendWithPromise("GetPageMode", null);
11380
    }
11381
  }, {
11382
    key: "getViewerPreferences",
11383
    value: function getViewerPreferences() {
11384
      return this.messageHandler.sendWithPromise("GetViewerPreferences", null);
11385
    }
11386
  }, {
11387
    key: "getOpenAction",
11388
    value: function getOpenAction() {
11389
      return this.messageHandler.sendWithPromise("GetOpenAction", null);
11390
    }
11391
  }, {
11392
    key: "getAttachments",
11393
    value: function getAttachments() {
11394
      return this.messageHandler.sendWithPromise("GetAttachments", null);
11395
    }
11396
  }, {
11397
    key: "getJavaScript",
11398
    value: function getJavaScript() {
11399
      return this.messageHandler.sendWithPromise("GetJavaScript", null);
11400
    }
11401
  }, {
11402
    key: "getDocJSActions",
11403
    value: function getDocJSActions() {
11404
      return this.messageHandler.sendWithPromise("GetDocJSActions", null);
11405
    }
11406
  }, {
11407
    key: "getPageJSActions",
11408
    value: function getPageJSActions(pageIndex) {
11409
      return this.messageHandler.sendWithPromise("GetPageJSActions", {
11410
        pageIndex: pageIndex
11411
      });
11412
    }
11413
  }, {
11414
    key: "getPageXfa",
11415
    value: function getPageXfa(pageIndex) {
11416
      return this.messageHandler.sendWithPromise("GetPageXfa", {
11417
        pageIndex: pageIndex
11418
      });
11419
    }
11420
  }, {
11421
    key: "getOutline",
11422
    value: function getOutline() {
11423
      return this.messageHandler.sendWithPromise("GetOutline", null);
11424
    }
11425
  }, {
11426
    key: "getOptionalContentConfig",
11427
    value: function getOptionalContentConfig() {
11428
      return this.messageHandler.sendWithPromise("GetOptionalContentConfig", null).then(function (results) {
11429
        return new _optional_content_config.OptionalContentConfig(results);
11430
      });
11431
    }
11432
  }, {
11433
    key: "getPermissions",
11434
    value: function getPermissions() {
11435
      return this.messageHandler.sendWithPromise("GetPermissions", null);
11436
    }
11437
  }, {
11438
    key: "getMetadata",
11439
    value: function getMetadata() {
11440
      var _this14 = this;
11441

11442
      return this.messageHandler.sendWithPromise("GetMetadata", null).then(function (results) {
11443
        var _this14$_fullReader$f, _this14$_fullReader, _this14$_fullReader$c, _this14$_fullReader2;
11444

11445
        return {
11446
          info: results[0],
11447
          metadata: results[1] ? new _metadata.Metadata(results[1]) : null,
11448
          contentDispositionFilename: (_this14$_fullReader$f = (_this14$_fullReader = _this14._fullReader) === null || _this14$_fullReader === void 0 ? void 0 : _this14$_fullReader.filename) !== null && _this14$_fullReader$f !== void 0 ? _this14$_fullReader$f : null,
11449
          contentLength: (_this14$_fullReader$c = (_this14$_fullReader2 = _this14._fullReader) === null || _this14$_fullReader2 === void 0 ? void 0 : _this14$_fullReader2.contentLength) !== null && _this14$_fullReader$c !== void 0 ? _this14$_fullReader$c : null
11450
        };
11451
      });
11452
    }
11453
  }, {
11454
    key: "getMarkInfo",
11455
    value: function getMarkInfo() {
11456
      return this.messageHandler.sendWithPromise("GetMarkInfo", null);
11457
    }
11458
  }, {
11459
    key: "getStats",
11460
    value: function getStats() {
11461
      return this.messageHandler.sendWithPromise("GetStats", null);
11462
    }
11463
  }, {
11464
    key: "startCleanup",
11465
    value: function () {
11466
      var _startCleanup = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
11467
        var keepLoadedFonts,
11468
            i,
11469
            ii,
11470
            page,
11471
            cleanupSuccessful,
11472
            _args2 = arguments;
11473
        return _regenerator["default"].wrap(function _callee2$(_context2) {
11474
          while (1) {
11475
            switch (_context2.prev = _context2.next) {
11476
              case 0:
11477
                keepLoadedFonts = _args2.length > 0 && _args2[0] !== undefined ? _args2[0] : false;
11478
                _context2.next = 3;
11479
                return this.messageHandler.sendWithPromise("Cleanup", null);
11480

11481
              case 3:
11482
                if (!this.destroyed) {
11483
                  _context2.next = 5;
11484
                  break;
11485
                }
11486

11487
                return _context2.abrupt("return");
11488

11489
              case 5:
11490
                i = 0, ii = this.pageCache.length;
11491

11492
              case 6:
11493
                if (!(i < ii)) {
11494
                  _context2.next = 16;
11495
                  break;
11496
                }
11497

11498
                page = this.pageCache[i];
11499

11500
                if (page) {
11501
                  _context2.next = 10;
11502
                  break;
11503
                }
11504

11505
                return _context2.abrupt("continue", 13);
11506

11507
              case 10:
11508
                cleanupSuccessful = page.cleanup();
11509

11510
                if (cleanupSuccessful) {
11511
                  _context2.next = 13;
11512
                  break;
11513
                }
11514

11515
                throw new Error("startCleanup: Page ".concat(i + 1, " is currently rendering."));
11516

11517
              case 13:
11518
                i++;
11519
                _context2.next = 6;
11520
                break;
11521

11522
              case 16:
11523
                this.commonObjs.clear();
11524

11525
                if (!keepLoadedFonts) {
11526
                  this.fontLoader.clear();
11527
                }
11528

11529
                this._hasJSActionsPromise = null;
11530

11531
              case 19:
11532
              case "end":
11533
                return _context2.stop();
11534
            }
11535
          }
11536
        }, _callee2, this);
11537
      }));
11538

11539
      function startCleanup() {
11540
        return _startCleanup.apply(this, arguments);
11541
      }
11542

11543
      return startCleanup;
11544
    }()
11545
  }, {
11546
    key: "loadingParams",
11547
    get: function get() {
11548
      var params = this._params;
11549
      return (0, _util.shadow)(this, "loadingParams", {
11550
        disableAutoFetch: params.disableAutoFetch,
11551
        disableFontFace: params.disableFontFace
11552
      });
11553
    }
11554
  }]);
11555

11556
  return WorkerTransport;
11557
}();
11558

11559
var PDFObjects = /*#__PURE__*/function () {
11560
  function PDFObjects() {
11561
    _classCallCheck(this, PDFObjects);
11562

11563
    this._objs = Object.create(null);
11564
  }
11565

11566
  _createClass(PDFObjects, [{
11567
    key: "_ensureObj",
11568
    value: function _ensureObj(objId) {
11569
      if (this._objs[objId]) {
11570
        return this._objs[objId];
11571
      }
11572

11573
      return this._objs[objId] = {
11574
        capability: (0, _util.createPromiseCapability)(),
11575
        data: null,
11576
        resolved: false
11577
      };
11578
    }
11579
  }, {
11580
    key: "get",
11581
    value: function get(objId) {
11582
      var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
11583

11584
      if (callback) {
11585
        this._ensureObj(objId).capability.promise.then(callback);
11586

11587
        return null;
11588
      }
11589

11590
      var obj = this._objs[objId];
11591

11592
      if (!obj || !obj.resolved) {
11593
        throw new Error("Requesting object that isn't resolved yet ".concat(objId, "."));
11594
      }
11595

11596
      return obj.data;
11597
    }
11598
  }, {
11599
    key: "has",
11600
    value: function has(objId) {
11601
      var obj = this._objs[objId];
11602
      return (obj === null || obj === void 0 ? void 0 : obj.resolved) || false;
11603
    }
11604
  }, {
11605
    key: "resolve",
11606
    value: function resolve(objId, data) {
11607
      var obj = this._ensureObj(objId);
11608

11609
      obj.resolved = true;
11610
      obj.data = data;
11611
      obj.capability.resolve(data);
11612
    }
11613
  }, {
11614
    key: "clear",
11615
    value: function clear() {
11616
      this._objs = Object.create(null);
11617
    }
11618
  }]);
11619

11620
  return PDFObjects;
11621
}();
11622

11623
var RenderTask = /*#__PURE__*/function () {
11624
  function RenderTask(internalRenderTask) {
11625
    _classCallCheck(this, RenderTask);
11626

11627
    this._internalRenderTask = internalRenderTask;
11628
    this.onContinue = null;
11629
  }
11630

11631
  _createClass(RenderTask, [{
11632
    key: "promise",
11633
    get: function get() {
11634
      return this._internalRenderTask.capability.promise;
11635
    }
11636
  }, {
11637
    key: "cancel",
11638
    value: function cancel() {
11639
      this._internalRenderTask.cancel();
11640
    }
11641
  }]);
11642

11643
  return RenderTask;
11644
}();
11645

11646
var InternalRenderTask = function InternalRenderTaskClosure() {
11647
  var canvasInRendering = new WeakSet();
11648

11649
  var InternalRenderTask = /*#__PURE__*/function () {
11650
    function InternalRenderTask(_ref18) {
11651
      var callback = _ref18.callback,
11652
          params = _ref18.params,
11653
          objs = _ref18.objs,
11654
          commonObjs = _ref18.commonObjs,
11655
          operatorList = _ref18.operatorList,
11656
          pageIndex = _ref18.pageIndex,
11657
          canvasFactory = _ref18.canvasFactory,
11658
          webGLContext = _ref18.webGLContext,
11659
          _ref18$useRequestAnim = _ref18.useRequestAnimationFrame,
11660
          useRequestAnimationFrame = _ref18$useRequestAnim === void 0 ? false : _ref18$useRequestAnim,
11661
          _ref18$pdfBug = _ref18.pdfBug,
11662
          pdfBug = _ref18$pdfBug === void 0 ? false : _ref18$pdfBug;
11663

11664
      _classCallCheck(this, InternalRenderTask);
11665

11666
      this.callback = callback;
11667
      this.params = params;
11668
      this.objs = objs;
11669
      this.commonObjs = commonObjs;
11670
      this.operatorListIdx = null;
11671
      this.operatorList = operatorList;
11672
      this._pageIndex = pageIndex;
11673
      this.canvasFactory = canvasFactory;
11674
      this.webGLContext = webGLContext;
11675
      this._pdfBug = pdfBug;
11676
      this.running = false;
11677
      this.graphicsReadyCallback = null;
11678
      this.graphicsReady = false;
11679
      this._useRequestAnimationFrame = useRequestAnimationFrame === true && typeof window !== "undefined";
11680
      this.cancelled = false;
11681
      this.capability = (0, _util.createPromiseCapability)();
11682
      this.task = new RenderTask(this);
11683
      this._cancelBound = this.cancel.bind(this);
11684
      this._continueBound = this._continue.bind(this);
11685
      this._scheduleNextBound = this._scheduleNext.bind(this);
11686
      this._nextBound = this._next.bind(this);
11687
      this._canvas = params.canvasContext.canvas;
11688
    }
11689

11690
    _createClass(InternalRenderTask, [{
11691
      key: "completed",
11692
      get: function get() {
11693
        return this.capability.promise["catch"](function () {});
11694
      }
11695
    }, {
11696
      key: "initializeGraphics",
11697
      value: function initializeGraphics(_ref19) {
11698
        var _globalThis$StepperMa;
11699

11700
        var _ref19$transparency = _ref19.transparency,
11701
            transparency = _ref19$transparency === void 0 ? false : _ref19$transparency,
11702
            optionalContentConfig = _ref19.optionalContentConfig;
11703

11704
        if (this.cancelled) {
11705
          return;
11706
        }
11707

11708
        if (this._canvas) {
11709
          if (canvasInRendering.has(this._canvas)) {
11710
            throw new Error("Cannot use the same canvas during multiple render() operations. " + "Use different canvas or ensure previous operations were " + "cancelled or completed.");
11711
          }
11712

11713
          canvasInRendering.add(this._canvas);
11714
        }
11715

11716
        if (this._pdfBug && (_globalThis$StepperMa = globalThis.StepperManager) !== null && _globalThis$StepperMa !== void 0 && _globalThis$StepperMa.enabled) {
11717
          this.stepper = globalThis.StepperManager.create(this._pageIndex);
11718
          this.stepper.init(this.operatorList);
11719
          this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();
11720
        }
11721

11722
        var _this$params = this.params,
11723
            canvasContext = _this$params.canvasContext,
11724
            viewport = _this$params.viewport,
11725
            transform = _this$params.transform,
11726
            imageLayer = _this$params.imageLayer,
11727
            background = _this$params.background;
11728
        this.gfx = new _canvas.CanvasGraphics(canvasContext, this.commonObjs, this.objs, this.canvasFactory, this.webGLContext, imageLayer, optionalContentConfig);
11729
        this.gfx.beginDrawing({
11730
          transform: transform,
11731
          viewport: viewport,
11732
          transparency: transparency,
11733
          background: background
11734
        });
11735
        this.operatorListIdx = 0;
11736
        this.graphicsReady = true;
11737

11738
        if (this.graphicsReadyCallback) {
11739
          this.graphicsReadyCallback();
11740
        }
11741
      }
11742
    }, {
11743
      key: "cancel",
11744
      value: function cancel() {
11745
        var error = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
11746
        this.running = false;
11747
        this.cancelled = true;
11748

11749
        if (this.gfx) {
11750
          this.gfx.endDrawing();
11751
        }
11752

11753
        if (this._canvas) {
11754
          canvasInRendering["delete"](this._canvas);
11755
        }
11756

11757
        this.callback(error || new _display_utils.RenderingCancelledException("Rendering cancelled, page ".concat(this._pageIndex + 1), "canvas"));
11758
      }
11759
    }, {
11760
      key: "operatorListChanged",
11761
      value: function operatorListChanged() {
11762
        if (!this.graphicsReady) {
11763
          if (!this.graphicsReadyCallback) {
11764
            this.graphicsReadyCallback = this._continueBound;
11765
          }
11766

11767
          return;
11768
        }
11769

11770
        if (this.stepper) {
11771
          this.stepper.updateOperatorList(this.operatorList);
11772
        }
11773

11774
        if (this.running) {
11775
          return;
11776
        }
11777

11778
        this._continue();
11779
      }
11780
    }, {
11781
      key: "_continue",
11782
      value: function _continue() {
11783
        this.running = true;
11784

11785
        if (this.cancelled) {
11786
          return;
11787
        }
11788

11789
        if (this.task.onContinue) {
11790
          this.task.onContinue(this._scheduleNextBound);
11791
        } else {
11792
          this._scheduleNext();
11793
        }
11794
      }
11795
    }, {
11796
      key: "_scheduleNext",
11797
      value: function _scheduleNext() {
11798
        var _this15 = this;
11799

11800
        if (this._useRequestAnimationFrame) {
11801
          window.requestAnimationFrame(function () {
11802
            _this15._nextBound()["catch"](_this15._cancelBound);
11803
          });
11804
        } else {
11805
          Promise.resolve().then(this._nextBound)["catch"](this._cancelBound);
11806
        }
11807
      }
11808
    }, {
11809
      key: "_next",
11810
      value: function () {
11811
        var _next2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee3() {
11812
          return _regenerator["default"].wrap(function _callee3$(_context3) {
11813
            while (1) {
11814
              switch (_context3.prev = _context3.next) {
11815
                case 0:
11816
                  if (!this.cancelled) {
11817
                    _context3.next = 2;
11818
                    break;
11819
                  }
11820

11821
                  return _context3.abrupt("return");
11822

11823
                case 2:
11824
                  this.operatorListIdx = this.gfx.executeOperatorList(this.operatorList, this.operatorListIdx, this._continueBound, this.stepper);
11825

11826
                  if (this.operatorListIdx === this.operatorList.argsArray.length) {
11827
                    this.running = false;
11828

11829
                    if (this.operatorList.lastChunk) {
11830
                      this.gfx.endDrawing();
11831

11832
                      if (this._canvas) {
11833
                        canvasInRendering["delete"](this._canvas);
11834
                      }
11835

11836
                      this.callback();
11837
                    }
11838
                  }
11839

11840
                case 4:
11841
                case "end":
11842
                  return _context3.stop();
11843
              }
11844
            }
11845
          }, _callee3, this);
11846
        }));
11847

11848
        function _next() {
11849
          return _next2.apply(this, arguments);
11850
        }
11851

11852
        return _next;
11853
      }()
11854
    }]);
11855

11856
    return InternalRenderTask;
11857
  }();
11858

11859
  return InternalRenderTask;
11860
}();
11861

11862
var version = '2.8.335';
11863
exports.version = version;
11864
var build = '228adbf67';
11865
exports.build = build;
11866

11867
/***/ }),
11868
/* 126 */
11869
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
11870

11871
"use strict";
11872

11873

11874
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
11875

11876
Object.defineProperty(exports, "__esModule", ({
11877
  value: true
11878
}));
11879
exports.FontLoader = exports.FontFaceObject = void 0;
11880

11881
var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
11882

11883
var _util = __w_pdfjs_require__(4);
11884

11885
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
11886

11887
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
11888

11889
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
11890

11891
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
11892

11893
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
11894

11895
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
11896

11897
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
11898

11899
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
11900

11901
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
11902

11903
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
11904

11905
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
11906

11907
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
11908

11909
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
11910

11911
var BaseFontLoader = /*#__PURE__*/function () {
11912
  function BaseFontLoader(_ref) {
11913
    var docId = _ref.docId,
11914
        onUnsupportedFeature = _ref.onUnsupportedFeature,
11915
        _ref$ownerDocument = _ref.ownerDocument,
11916
        ownerDocument = _ref$ownerDocument === void 0 ? globalThis.document : _ref$ownerDocument;
11917

11918
    _classCallCheck(this, BaseFontLoader);
11919

11920
    if (this.constructor === BaseFontLoader) {
11921
      (0, _util.unreachable)("Cannot initialize BaseFontLoader.");
11922
    }
11923

11924
    this.docId = docId;
11925
    this._onUnsupportedFeature = onUnsupportedFeature;
11926
    this._document = ownerDocument;
11927
    this.nativeFontFaces = [];
11928
    this.styleElement = null;
11929
  }
11930

11931
  _createClass(BaseFontLoader, [{
11932
    key: "addNativeFontFace",
11933
    value: function addNativeFontFace(nativeFontFace) {
11934
      this.nativeFontFaces.push(nativeFontFace);
11935

11936
      this._document.fonts.add(nativeFontFace);
11937
    }
11938
  }, {
11939
    key: "insertRule",
11940
    value: function insertRule(rule) {
11941
      var styleElement = this.styleElement;
11942

11943
      if (!styleElement) {
11944
        styleElement = this.styleElement = this._document.createElement("style");
11945
        styleElement.id = "PDFJS_FONT_STYLE_TAG_".concat(this.docId);
11946

11947
        this._document.documentElement.getElementsByTagName("head")[0].appendChild(styleElement);
11948
      }
11949

11950
      var styleSheet = styleElement.sheet;
11951
      styleSheet.insertRule(rule, styleSheet.cssRules.length);
11952
    }
11953
  }, {
11954
    key: "clear",
11955
    value: function clear() {
11956
      var _this = this;
11957

11958
      this.nativeFontFaces.forEach(function (nativeFontFace) {
11959
        _this._document.fonts["delete"](nativeFontFace);
11960
      });
11961
      this.nativeFontFaces.length = 0;
11962

11963
      if (this.styleElement) {
11964
        this.styleElement.remove();
11965
        this.styleElement = null;
11966
      }
11967
    }
11968
  }, {
11969
    key: "bind",
11970
    value: function () {
11971
      var _bind = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee(font) {
11972
        var _this2 = this;
11973

11974
        var nativeFontFace, rule;
11975
        return _regenerator["default"].wrap(function _callee$(_context) {
11976
          while (1) {
11977
            switch (_context.prev = _context.next) {
11978
              case 0:
11979
                if (!(font.attached || font.missingFile)) {
11980
                  _context.next = 2;
11981
                  break;
11982
                }
11983

11984
                return _context.abrupt("return");
11985

11986
              case 2:
11987
                font.attached = true;
11988

11989
                if (!this.isFontLoadingAPISupported) {
11990
                  _context.next = 19;
11991
                  break;
11992
                }
11993

11994
                nativeFontFace = font.createNativeFontFace();
11995

11996
                if (!nativeFontFace) {
11997
                  _context.next = 18;
11998
                  break;
11999
                }
12000

12001
                this.addNativeFontFace(nativeFontFace);
12002
                _context.prev = 7;
12003
                _context.next = 10;
12004
                return nativeFontFace.loaded;
12005

12006
              case 10:
12007
                _context.next = 18;
12008
                break;
12009

12010
              case 12:
12011
                _context.prev = 12;
12012
                _context.t0 = _context["catch"](7);
12013

12014
                this._onUnsupportedFeature({
12015
                  featureId: _util.UNSUPPORTED_FEATURES.errorFontLoadNative
12016
                });
12017

12018
                (0, _util.warn)("Failed to load font '".concat(nativeFontFace.family, "': '").concat(_context.t0, "'."));
12019
                font.disableFontFace = true;
12020
                throw _context.t0;
12021

12022
              case 18:
12023
                return _context.abrupt("return");
12024

12025
              case 19:
12026
                rule = font.createFontFaceRule();
12027

12028
                if (!rule) {
12029
                  _context.next = 26;
12030
                  break;
12031
                }
12032

12033
                this.insertRule(rule);
12034

12035
                if (!this.isSyncFontLoadingSupported) {
12036
                  _context.next = 24;
12037
                  break;
12038
                }
12039

12040
                return _context.abrupt("return");
12041

12042
              case 24:
12043
                _context.next = 26;
12044
                return new Promise(function (resolve) {
12045
                  var request = _this2._queueLoadingCallback(resolve);
12046

12047
                  _this2._prepareFontLoadEvent([rule], [font], request);
12048
                });
12049

12050
              case 26:
12051
              case "end":
12052
                return _context.stop();
12053
            }
12054
          }
12055
        }, _callee, this, [[7, 12]]);
12056
      }));
12057

12058
      function bind(_x) {
12059
        return _bind.apply(this, arguments);
12060
      }
12061

12062
      return bind;
12063
    }()
12064
  }, {
12065
    key: "_queueLoadingCallback",
12066
    value: function _queueLoadingCallback(callback) {
12067
      (0, _util.unreachable)("Abstract method `_queueLoadingCallback`.");
12068
    }
12069
  }, {
12070
    key: "isFontLoadingAPISupported",
12071
    get: function get() {
12072
      var _this$_document;
12073

12074
      return (0, _util.shadow)(this, "isFontLoadingAPISupported", !!((_this$_document = this._document) !== null && _this$_document !== void 0 && _this$_document.fonts));
12075
    }
12076
  }, {
12077
    key: "isSyncFontLoadingSupported",
12078
    get: function get() {
12079
      (0, _util.unreachable)("Abstract method `isSyncFontLoadingSupported`.");
12080
    }
12081
  }, {
12082
    key: "_loadTestFont",
12083
    get: function get() {
12084
      (0, _util.unreachable)("Abstract method `_loadTestFont`.");
12085
    }
12086
  }, {
12087
    key: "_prepareFontLoadEvent",
12088
    value: function _prepareFontLoadEvent(rules, fontsToLoad, request) {
12089
      (0, _util.unreachable)("Abstract method `_prepareFontLoadEvent`.");
12090
    }
12091
  }]);
12092

12093
  return BaseFontLoader;
12094
}();
12095

12096
var FontLoader;
12097
exports.FontLoader = FontLoader;
12098
{
12099
  exports.FontLoader = FontLoader = /*#__PURE__*/function (_BaseFontLoader) {
12100
    _inherits(GenericFontLoader, _BaseFontLoader);
12101

12102
    var _super = _createSuper(GenericFontLoader);
12103

12104
    function GenericFontLoader(params) {
12105
      var _this3;
12106

12107
      _classCallCheck(this, GenericFontLoader);
12108

12109
      _this3 = _super.call(this, params);
12110
      _this3.loadingContext = {
12111
        requests: [],
12112
        nextRequestId: 0
12113
      };
12114
      _this3.loadTestFontId = 0;
12115
      return _this3;
12116
    }
12117

12118
    _createClass(GenericFontLoader, [{
12119
      key: "isSyncFontLoadingSupported",
12120
      get: function get() {
12121
        var supported = false;
12122

12123
        if (typeof navigator === "undefined") {
12124
          supported = true;
12125
        } else {
12126
          var m = /Mozilla\/5.0.*?rv:(\d+).*? Gecko/.exec(navigator.userAgent);
12127

12128
          if ((m === null || m === void 0 ? void 0 : m[1]) >= 14) {
12129
            supported = true;
12130
          }
12131
        }
12132

12133
        return (0, _util.shadow)(this, "isSyncFontLoadingSupported", supported);
12134
      }
12135
    }, {
12136
      key: "_queueLoadingCallback",
12137
      value: function _queueLoadingCallback(callback) {
12138
        function completeRequest() {
12139
          (0, _util.assert)(!request.done, "completeRequest() cannot be called twice.");
12140
          request.done = true;
12141

12142
          while (context.requests.length > 0 && context.requests[0].done) {
12143
            var otherRequest = context.requests.shift();
12144
            setTimeout(otherRequest.callback, 0);
12145
          }
12146
        }
12147

12148
        var context = this.loadingContext;
12149
        var request = {
12150
          id: "pdfjs-font-loading-".concat(context.nextRequestId++),
12151
          done: false,
12152
          complete: completeRequest,
12153
          callback: callback
12154
        };
12155
        context.requests.push(request);
12156
        return request;
12157
      }
12158
    }, {
12159
      key: "_loadTestFont",
12160
      get: function get() {
12161
        var getLoadTestFont = function getLoadTestFont() {
12162
          return atob("T1RUTwALAIAAAwAwQ0ZGIDHtZg4AAAOYAAAAgUZGVE1lkzZwAAAEHAAAABxHREVGABQA" + "FQAABDgAAAAeT1MvMlYNYwkAAAEgAAAAYGNtYXABDQLUAAACNAAAAUJoZWFk/xVFDQAA" + "ALwAAAA2aGhlYQdkA+oAAAD0AAAAJGhtdHgD6AAAAAAEWAAAAAZtYXhwAAJQAAAAARgA" + "AAAGbmFtZVjmdH4AAAGAAAAAsXBvc3T/hgAzAAADeAAAACAAAQAAAAEAALZRFsRfDzz1" + "AAsD6AAAAADOBOTLAAAAAM4KHDwAAAAAA+gDIQAAAAgAAgAAAAAAAAABAAADIQAAAFoD" + "6AAAAAAD6AABAAAAAAAAAAAAAAAAAAAAAQAAUAAAAgAAAAQD6AH0AAUAAAKKArwAAACM" + "AooCvAAAAeAAMQECAAACAAYJAAAAAAAAAAAAAQAAAAAAAAAAAAAAAFBmRWQAwAAuAC4D" + "IP84AFoDIQAAAAAAAQAAAAAAAAAAACAAIAABAAAADgCuAAEAAAAAAAAAAQAAAAEAAAAA" + "AAEAAQAAAAEAAAAAAAIAAQAAAAEAAAAAAAMAAQAAAAEAAAAAAAQAAQAAAAEAAAAAAAUA" + "AQAAAAEAAAAAAAYAAQAAAAMAAQQJAAAAAgABAAMAAQQJAAEAAgABAAMAAQQJAAIAAgAB" + "AAMAAQQJAAMAAgABAAMAAQQJAAQAAgABAAMAAQQJAAUAAgABAAMAAQQJAAYAAgABWABY" + "AAAAAAAAAwAAAAMAAAAcAAEAAAAAADwAAwABAAAAHAAEACAAAAAEAAQAAQAAAC7//wAA" + "AC7////TAAEAAAAAAAABBgAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA" + "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAD/gwAyAAAAAQAAAAAAAAAAAAAAAAAA" + "AAABAAQEAAEBAQJYAAEBASH4DwD4GwHEAvgcA/gXBIwMAYuL+nz5tQXkD5j3CBLnEQAC" + "AQEBIVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYAAABAQAADwACAQEEE/t3" + "Dov6fAH6fAT+fPp8+nwHDosMCvm1Cvm1DAz6fBQAAAAAAAABAAAAAMmJbzEAAAAAzgTj" + "FQAAAADOBOQpAAEAAAAAAAAADAAUAAQAAAABAAAAAgABAAAAAAAAAAAD6AAAAAAAAA==");
12163
        };
12164

12165
        return (0, _util.shadow)(this, "_loadTestFont", getLoadTestFont());
12166
      }
12167
    }, {
12168
      key: "_prepareFontLoadEvent",
12169
      value: function _prepareFontLoadEvent(rules, fonts, request) {
12170
        var _this4 = this;
12171

12172
        function int32(data, offset) {
12173
          return data.charCodeAt(offset) << 24 | data.charCodeAt(offset + 1) << 16 | data.charCodeAt(offset + 2) << 8 | data.charCodeAt(offset + 3) & 0xff;
12174
        }
12175

12176
        function spliceString(s, offset, remove, insert) {
12177
          var chunk1 = s.substring(0, offset);
12178
          var chunk2 = s.substring(offset + remove);
12179
          return chunk1 + insert + chunk2;
12180
        }
12181

12182
        var i, ii;
12183

12184
        var canvas = this._document.createElement("canvas");
12185

12186
        canvas.width = 1;
12187
        canvas.height = 1;
12188
        var ctx = canvas.getContext("2d");
12189
        var called = 0;
12190

12191
        function isFontReady(name, callback) {
12192
          called++;
12193

12194
          if (called > 30) {
12195
            (0, _util.warn)("Load test font never loaded.");
12196
            callback();
12197
            return;
12198
          }
12199

12200
          ctx.font = "30px " + name;
12201
          ctx.fillText(".", 0, 20);
12202
          var imageData = ctx.getImageData(0, 0, 1, 1);
12203

12204
          if (imageData.data[3] > 0) {
12205
            callback();
12206
            return;
12207
          }
12208

12209
          setTimeout(isFontReady.bind(null, name, callback));
12210
        }
12211

12212
        var loadTestFontId = "lt".concat(Date.now()).concat(this.loadTestFontId++);
12213
        var data = this._loadTestFont;
12214
        var COMMENT_OFFSET = 976;
12215
        data = spliceString(data, COMMENT_OFFSET, loadTestFontId.length, loadTestFontId);
12216
        var CFF_CHECKSUM_OFFSET = 16;
12217
        var XXXX_VALUE = 0x58585858;
12218
        var checksum = int32(data, CFF_CHECKSUM_OFFSET);
12219

12220
        for (i = 0, ii = loadTestFontId.length - 3; i < ii; i += 4) {
12221
          checksum = checksum - XXXX_VALUE + int32(loadTestFontId, i) | 0;
12222
        }
12223

12224
        if (i < loadTestFontId.length) {
12225
          checksum = checksum - XXXX_VALUE + int32(loadTestFontId + "XXX", i) | 0;
12226
        }
12227

12228
        data = spliceString(data, CFF_CHECKSUM_OFFSET, 4, (0, _util.string32)(checksum));
12229
        var url = "url(data:font/opentype;base64,".concat(btoa(data), ");");
12230
        var rule = "@font-face {font-family:\"".concat(loadTestFontId, "\";src:").concat(url, "}");
12231
        this.insertRule(rule);
12232
        var names = [];
12233

12234
        for (i = 0, ii = fonts.length; i < ii; i++) {
12235
          names.push(fonts[i].loadedName);
12236
        }
12237

12238
        names.push(loadTestFontId);
12239

12240
        var div = this._document.createElement("div");
12241

12242
        div.style.visibility = "hidden";
12243
        div.style.width = div.style.height = "10px";
12244
        div.style.position = "absolute";
12245
        div.style.top = div.style.left = "0px";
12246

12247
        for (i = 0, ii = names.length; i < ii; ++i) {
12248
          var span = this._document.createElement("span");
12249

12250
          span.textContent = "Hi";
12251
          span.style.fontFamily = names[i];
12252
          div.appendChild(span);
12253
        }
12254

12255
        this._document.body.appendChild(div);
12256

12257
        isFontReady(loadTestFontId, function () {
12258
          _this4._document.body.removeChild(div);
12259

12260
          request.complete();
12261
        });
12262
      }
12263
    }]);
12264

12265
    return GenericFontLoader;
12266
  }(BaseFontLoader);
12267
}
12268

12269
var FontFaceObject = /*#__PURE__*/function () {
12270
  function FontFaceObject(translatedData, _ref2) {
12271
    var _ref2$isEvalSupported = _ref2.isEvalSupported,
12272
        isEvalSupported = _ref2$isEvalSupported === void 0 ? true : _ref2$isEvalSupported,
12273
        _ref2$disableFontFace = _ref2.disableFontFace,
12274
        disableFontFace = _ref2$disableFontFace === void 0 ? false : _ref2$disableFontFace,
12275
        _ref2$ignoreErrors = _ref2.ignoreErrors,
12276
        ignoreErrors = _ref2$ignoreErrors === void 0 ? false : _ref2$ignoreErrors,
12277
        onUnsupportedFeature = _ref2.onUnsupportedFeature,
12278
        _ref2$fontRegistry = _ref2.fontRegistry,
12279
        fontRegistry = _ref2$fontRegistry === void 0 ? null : _ref2$fontRegistry;
12280

12281
    _classCallCheck(this, FontFaceObject);
12282

12283
    this.compiledGlyphs = Object.create(null);
12284

12285
    for (var i in translatedData) {
12286
      this[i] = translatedData[i];
12287
    }
12288

12289
    this.isEvalSupported = isEvalSupported !== false;
12290
    this.disableFontFace = disableFontFace === true;
12291
    this.ignoreErrors = ignoreErrors === true;
12292
    this._onUnsupportedFeature = onUnsupportedFeature;
12293
    this.fontRegistry = fontRegistry;
12294
  }
12295

12296
  _createClass(FontFaceObject, [{
12297
    key: "createNativeFontFace",
12298
    value: function createNativeFontFace() {
12299
      if (!this.data || this.disableFontFace) {
12300
        return null;
12301
      }
12302

12303
      var nativeFontFace = new FontFace(this.loadedName, this.data, {});
12304

12305
      if (this.fontRegistry) {
12306
        this.fontRegistry.registerFont(this);
12307
      }
12308

12309
      return nativeFontFace;
12310
    }
12311
  }, {
12312
    key: "createFontFaceRule",
12313
    value: function createFontFaceRule() {
12314
      if (!this.data || this.disableFontFace) {
12315
        return null;
12316
      }
12317

12318
      var data = (0, _util.bytesToString)(new Uint8Array(this.data));
12319
      var url = "url(data:".concat(this.mimetype, ";base64,").concat(btoa(data), ");");
12320
      var rule = "@font-face {font-family:\"".concat(this.loadedName, "\";src:").concat(url, "}");
12321

12322
      if (this.fontRegistry) {
12323
        this.fontRegistry.registerFont(this, url);
12324
      }
12325

12326
      return rule;
12327
    }
12328
  }, {
12329
    key: "getPathGenerator",
12330
    value: function getPathGenerator(objs, character) {
12331
      if (this.compiledGlyphs[character] !== undefined) {
12332
        return this.compiledGlyphs[character];
12333
      }
12334

12335
      var cmds, current;
12336

12337
      try {
12338
        cmds = objs.get(this.loadedName + "_path_" + character);
12339
      } catch (ex) {
12340
        if (!this.ignoreErrors) {
12341
          throw ex;
12342
        }
12343

12344
        this._onUnsupportedFeature({
12345
          featureId: _util.UNSUPPORTED_FEATURES.errorFontGetPath
12346
        });
12347

12348
        (0, _util.warn)("getPathGenerator - ignoring character: \"".concat(ex, "\"."));
12349
        return this.compiledGlyphs[character] = function (c, size) {};
12350
      }
12351

12352
      if (this.isEvalSupported && _util.IsEvalSupportedCached.value) {
12353
        var args,
12354
            js = "";
12355

12356
        for (var i = 0, ii = cmds.length; i < ii; i++) {
12357
          current = cmds[i];
12358

12359
          if (current.args !== undefined) {
12360
            args = current.args.join(",");
12361
          } else {
12362
            args = "";
12363
          }
12364

12365
          js += "c." + current.cmd + "(" + args + ");\n";
12366
        }
12367

12368
        return this.compiledGlyphs[character] = new Function("c", "size", js);
12369
      }
12370

12371
      return this.compiledGlyphs[character] = function (c, size) {
12372
        for (var _i = 0, _ii = cmds.length; _i < _ii; _i++) {
12373
          current = cmds[_i];
12374

12375
          if (current.cmd === "scale") {
12376
            current.args = [size, -size];
12377
          }
12378

12379
          c[current.cmd].apply(c, current.args);
12380
        }
12381
      };
12382
    }
12383
  }]);
12384

12385
  return FontFaceObject;
12386
}();
12387

12388
exports.FontFaceObject = FontFaceObject;
12389

12390
/***/ }),
12391
/* 127 */
12392
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
12393

12394
"use strict";
12395

12396

12397
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
12398

12399
Object.defineProperty(exports, "__esModule", ({
12400
  value: true
12401
}));
12402
exports.NodeCMapReaderFactory = exports.NodeCanvasFactory = void 0;
12403

12404
var _display_utils = __w_pdfjs_require__(1);
12405

12406
var _is_node = __w_pdfjs_require__(6);
12407

12408
var _util = __w_pdfjs_require__(4);
12409

12410
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
12411

12412
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
12413

12414
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
12415

12416
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
12417

12418
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
12419

12420
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
12421

12422
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
12423

12424
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
12425

12426
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
12427

12428
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
12429

12430
var NodeCanvasFactory = function NodeCanvasFactory() {
12431
  _classCallCheck(this, NodeCanvasFactory);
12432

12433
  (0, _util.unreachable)("Not implemented: NodeCanvasFactory");
12434
};
12435

12436
exports.NodeCanvasFactory = NodeCanvasFactory;
12437

12438
var NodeCMapReaderFactory = function NodeCMapReaderFactory() {
12439
  _classCallCheck(this, NodeCMapReaderFactory);
12440

12441
  (0, _util.unreachable)("Not implemented: NodeCMapReaderFactory");
12442
};
12443

12444
exports.NodeCMapReaderFactory = NodeCMapReaderFactory;
12445

12446
if (_is_node.isNodeJS) {
12447
  exports.NodeCanvasFactory = NodeCanvasFactory = /*#__PURE__*/function (_BaseCanvasFactory) {
12448
    _inherits(NodeCanvasFactory, _BaseCanvasFactory);
12449

12450
    var _super = _createSuper(NodeCanvasFactory);
12451

12452
    function NodeCanvasFactory() {
12453
      _classCallCheck(this, NodeCanvasFactory);
12454

12455
      return _super.apply(this, arguments);
12456
    }
12457

12458
    _createClass(NodeCanvasFactory, [{
12459
      key: "create",
12460
      value: function create(width, height) {
12461
        if (width <= 0 || height <= 0) {
12462
          throw new Error("Invalid canvas size");
12463
        }
12464

12465
        var Canvas = require("canvas");
12466

12467
        var canvas = Canvas.createCanvas(width, height);
12468
        return {
12469
          canvas: canvas,
12470
          context: canvas.getContext("2d")
12471
        };
12472
      }
12473
    }]);
12474

12475
    return NodeCanvasFactory;
12476
  }(_display_utils.BaseCanvasFactory);
12477

12478
  exports.NodeCMapReaderFactory = NodeCMapReaderFactory = /*#__PURE__*/function (_BaseCMapReaderFactor) {
12479
    _inherits(NodeCMapReaderFactory, _BaseCMapReaderFactor);
12480

12481
    var _super2 = _createSuper(NodeCMapReaderFactory);
12482

12483
    function NodeCMapReaderFactory() {
12484
      _classCallCheck(this, NodeCMapReaderFactory);
12485

12486
      return _super2.apply(this, arguments);
12487
    }
12488

12489
    _createClass(NodeCMapReaderFactory, [{
12490
      key: "_fetchData",
12491
      value: function _fetchData(url, compressionType) {
12492
        return new Promise(function (resolve, reject) {
12493
          var fs = require("fs");
12494

12495
          fs.readFile(url, function (error, data) {
12496
            if (error || !data) {
12497
              reject(new Error(error));
12498
              return;
12499
            }
12500

12501
            resolve({
12502
              cMapData: new Uint8Array(data),
12503
              compressionType: compressionType
12504
            });
12505
          });
12506
        });
12507
      }
12508
    }]);
12509

12510
    return NodeCMapReaderFactory;
12511
  }(_display_utils.BaseCMapReaderFactory);
12512
}
12513

12514
/***/ }),
12515
/* 128 */
12516
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
12517

12518
"use strict";
12519

12520

12521
Object.defineProperty(exports, "__esModule", ({
12522
  value: true
12523
}));
12524
exports.AnnotationStorage = void 0;
12525

12526
var _display_utils = __w_pdfjs_require__(1);
12527

12528
var _util = __w_pdfjs_require__(4);
12529

12530
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
12531

12532
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
12533

12534
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
12535

12536
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
12537

12538
function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
12539

12540
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
12541

12542
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
12543

12544
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
12545

12546
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
12547

12548
var AnnotationStorage = /*#__PURE__*/function () {
12549
  function AnnotationStorage() {
12550
    _classCallCheck(this, AnnotationStorage);
12551

12552
    this._storage = new Map();
12553
    this._modified = false;
12554
    this.onSetModified = null;
12555
    this.onResetModified = null;
12556
  }
12557

12558
  _createClass(AnnotationStorage, [{
12559
    key: "getValue",
12560
    value: function getValue(key, defaultValue) {
12561
      var obj = this._storage.get(key);
12562

12563
      return obj !== undefined ? obj : defaultValue;
12564
    }
12565
  }, {
12566
    key: "getOrCreateValue",
12567
    value: function getOrCreateValue(key, defaultValue) {
12568
      (0, _display_utils.deprecated)("Use getValue instead.");
12569

12570
      if (this._storage.has(key)) {
12571
        return this._storage.get(key);
12572
      }
12573

12574
      this._storage.set(key, defaultValue);
12575

12576
      return defaultValue;
12577
    }
12578
  }, {
12579
    key: "setValue",
12580
    value: function setValue(key, value) {
12581
      var obj = this._storage.get(key);
12582

12583
      var modified = false;
12584

12585
      if (obj !== undefined) {
12586
        for (var _i = 0, _Object$entries = Object.entries(value); _i < _Object$entries.length; _i++) {
12587
          var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
12588
              entry = _Object$entries$_i[0],
12589
              val = _Object$entries$_i[1];
12590

12591
          if (obj[entry] !== val) {
12592
            modified = true;
12593
            obj[entry] = val;
12594
          }
12595
        }
12596
      } else {
12597
        this._storage.set(key, value);
12598

12599
        modified = true;
12600
      }
12601

12602
      if (modified) {
12603
        this._setModified();
12604
      }
12605
    }
12606
  }, {
12607
    key: "getAll",
12608
    value: function getAll() {
12609
      return this._storage.size > 0 ? (0, _util.objectFromMap)(this._storage) : null;
12610
    }
12611
  }, {
12612
    key: "size",
12613
    get: function get() {
12614
      return this._storage.size;
12615
    }
12616
  }, {
12617
    key: "_setModified",
12618
    value: function _setModified() {
12619
      if (!this._modified) {
12620
        this._modified = true;
12621

12622
        if (typeof this.onSetModified === "function") {
12623
          this.onSetModified();
12624
        }
12625
      }
12626
    }
12627
  }, {
12628
    key: "resetModified",
12629
    value: function resetModified() {
12630
      if (this._modified) {
12631
        this._modified = false;
12632

12633
        if (typeof this.onResetModified === "function") {
12634
          this.onResetModified();
12635
        }
12636
      }
12637
    }
12638
  }, {
12639
    key: "serializable",
12640
    get: function get() {
12641
      return this._storage.size > 0 ? this._storage : null;
12642
    }
12643
  }]);
12644

12645
  return AnnotationStorage;
12646
}();
12647

12648
exports.AnnotationStorage = AnnotationStorage;
12649

12650
/***/ }),
12651
/* 129 */
12652
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
12653

12654
"use strict";
12655

12656

12657
Object.defineProperty(exports, "__esModule", ({
12658
  value: true
12659
}));
12660
exports.apiCompatibilityParams = void 0;
12661

12662
var _is_node = __w_pdfjs_require__(6);
12663

12664
var compatibilityParams = Object.create(null);
12665
{
12666
  (function checkFontFace() {
12667
    if (_is_node.isNodeJS) {
12668
      compatibilityParams.disableFontFace = true;
12669
    }
12670
  })();
12671
}
12672
var apiCompatibilityParams = Object.freeze(compatibilityParams);
12673
exports.apiCompatibilityParams = apiCompatibilityParams;
12674

12675
/***/ }),
12676
/* 130 */
12677
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
12678

12679
"use strict";
12680

12681

12682
Object.defineProperty(exports, "__esModule", ({
12683
  value: true
12684
}));
12685
exports.CanvasGraphics = void 0;
12686

12687
var _util = __w_pdfjs_require__(4);
12688

12689
var _pattern_helper = __w_pdfjs_require__(131);
12690

12691
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
12692

12693
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
12694

12695
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
12696

12697
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
12698

12699
var MIN_FONT_SIZE = 16;
12700
var MAX_FONT_SIZE = 100;
12701
var MAX_GROUP_SIZE = 4096;
12702
var COMPILE_TYPE3_GLYPHS = true;
12703
var MAX_SIZE_TO_COMPILE = 1000;
12704
var FULL_CHUNK_HEIGHT = 16;
12705
var LINEWIDTH_SCALE_FACTOR = 1.000001;
12706

12707
function addContextCurrentTransform(ctx) {
12708
  if (!ctx.mozCurrentTransform) {
12709
    ctx._originalSave = ctx.save;
12710
    ctx._originalRestore = ctx.restore;
12711
    ctx._originalRotate = ctx.rotate;
12712
    ctx._originalScale = ctx.scale;
12713
    ctx._originalTranslate = ctx.translate;
12714
    ctx._originalTransform = ctx.transform;
12715
    ctx._originalSetTransform = ctx.setTransform;
12716
    ctx._originalResetTransform = ctx.resetTransform;
12717
    ctx._transformMatrix = ctx._transformMatrix || [1, 0, 0, 1, 0, 0];
12718
    ctx._transformStack = [];
12719

12720
    try {
12721
      var desc = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(ctx), "lineWidth");
12722
      ctx._setLineWidth = desc.set;
12723
      ctx._getLineWidth = desc.get;
12724
      Object.defineProperty(ctx, "lineWidth", {
12725
        set: function setLineWidth(width) {
12726
          this._setLineWidth(width * LINEWIDTH_SCALE_FACTOR);
12727
        },
12728
        get: function getLineWidth() {
12729
          return this._getLineWidth();
12730
        }
12731
      });
12732
    } catch (_) {}
12733

12734
    Object.defineProperty(ctx, "mozCurrentTransform", {
12735
      get: function getCurrentTransform() {
12736
        return this._transformMatrix;
12737
      }
12738
    });
12739
    Object.defineProperty(ctx, "mozCurrentTransformInverse", {
12740
      get: function getCurrentTransformInverse() {
12741
        var m = this._transformMatrix;
12742
        var a = m[0],
12743
            b = m[1],
12744
            c = m[2],
12745
            d = m[3],
12746
            e = m[4],
12747
            f = m[5];
12748
        var ad_bc = a * d - b * c;
12749
        var bc_ad = b * c - a * d;
12750
        return [d / ad_bc, b / bc_ad, c / bc_ad, a / ad_bc, (d * e - c * f) / bc_ad, (b * e - a * f) / ad_bc];
12751
      }
12752
    });
12753

12754
    ctx.save = function ctxSave() {
12755
      var old = this._transformMatrix;
12756

12757
      this._transformStack.push(old);
12758

12759
      this._transformMatrix = old.slice(0, 6);
12760

12761
      this._originalSave();
12762
    };
12763

12764
    ctx.restore = function ctxRestore() {
12765
      var prev = this._transformStack.pop();
12766

12767
      if (prev) {
12768
        this._transformMatrix = prev;
12769

12770
        this._originalRestore();
12771
      }
12772
    };
12773

12774
    ctx.translate = function ctxTranslate(x, y) {
12775
      var m = this._transformMatrix;
12776
      m[4] = m[0] * x + m[2] * y + m[4];
12777
      m[5] = m[1] * x + m[3] * y + m[5];
12778

12779
      this._originalTranslate(x, y);
12780
    };
12781

12782
    ctx.scale = function ctxScale(x, y) {
12783
      var m = this._transformMatrix;
12784
      m[0] = m[0] * x;
12785
      m[1] = m[1] * x;
12786
      m[2] = m[2] * y;
12787
      m[3] = m[3] * y;
12788

12789
      this._originalScale(x, y);
12790
    };
12791

12792
    ctx.transform = function ctxTransform(a, b, c, d, e, f) {
12793
      var m = this._transformMatrix;
12794
      this._transformMatrix = [m[0] * a + m[2] * b, m[1] * a + m[3] * b, m[0] * c + m[2] * d, m[1] * c + m[3] * d, m[0] * e + m[2] * f + m[4], m[1] * e + m[3] * f + m[5]];
12795

12796
      ctx._originalTransform(a, b, c, d, e, f);
12797
    };
12798

12799
    ctx.setTransform = function ctxSetTransform(a, b, c, d, e, f) {
12800
      this._transformMatrix = [a, b, c, d, e, f];
12801

12802
      ctx._originalSetTransform(a, b, c, d, e, f);
12803
    };
12804

12805
    ctx.resetTransform = function ctxResetTransform() {
12806
      this._transformMatrix = [1, 0, 0, 1, 0, 0];
12807

12808
      ctx._originalResetTransform();
12809
    };
12810

12811
    ctx.rotate = function ctxRotate(angle) {
12812
      var cosValue = Math.cos(angle);
12813
      var sinValue = Math.sin(angle);
12814
      var m = this._transformMatrix;
12815
      this._transformMatrix = [m[0] * cosValue + m[2] * sinValue, m[1] * cosValue + m[3] * sinValue, m[0] * -sinValue + m[2] * cosValue, m[1] * -sinValue + m[3] * cosValue, m[4], m[5]];
12816

12817
      this._originalRotate(angle);
12818
    };
12819
  }
12820
}
12821

12822
var CachedCanvases = function CachedCanvasesClosure() {
12823
  function CachedCanvases(canvasFactory) {
12824
    this.canvasFactory = canvasFactory;
12825
    this.cache = Object.create(null);
12826
  }
12827

12828
  CachedCanvases.prototype = {
12829
    getCanvas: function CachedCanvases_getCanvas(id, width, height, trackTransform) {
12830
      var canvasEntry;
12831

12832
      if (this.cache[id] !== undefined) {
12833
        canvasEntry = this.cache[id];
12834
        this.canvasFactory.reset(canvasEntry, width, height);
12835
        canvasEntry.context.setTransform(1, 0, 0, 1, 0, 0);
12836
      } else {
12837
        canvasEntry = this.canvasFactory.create(width, height);
12838
        this.cache[id] = canvasEntry;
12839
      }
12840

12841
      if (trackTransform) {
12842
        addContextCurrentTransform(canvasEntry.context);
12843
      }
12844

12845
      return canvasEntry;
12846
    },
12847
    clear: function clear() {
12848
      for (var id in this.cache) {
12849
        var canvasEntry = this.cache[id];
12850
        this.canvasFactory.destroy(canvasEntry);
12851
        delete this.cache[id];
12852
      }
12853
    }
12854
  };
12855
  return CachedCanvases;
12856
}();
12857

12858
function compileType3Glyph(imgData) {
12859
  var POINT_TO_PROCESS_LIMIT = 1000;
12860
  var width = imgData.width,
12861
      height = imgData.height,
12862
      width1 = width + 1;
12863
  var i, ii, j, j0;
12864
  var points = new Uint8Array(width1 * (height + 1));
12865
  var POINT_TYPES = new Uint8Array([0, 2, 4, 0, 1, 0, 5, 4, 8, 10, 0, 8, 0, 2, 1, 0]);
12866
  var lineSize = width + 7 & ~7,
12867
      data0 = imgData.data;
12868
  var data = new Uint8Array(lineSize * height);
12869
  var pos = 0;
12870

12871
  for (i = 0, ii = data0.length; i < ii; i++) {
12872
    var elem = data0[i];
12873
    var mask = 128;
12874

12875
    while (mask > 0) {
12876
      data[pos++] = elem & mask ? 0 : 255;
12877
      mask >>= 1;
12878
    }
12879
  }
12880

12881
  var count = 0;
12882
  pos = 0;
12883

12884
  if (data[pos] !== 0) {
12885
    points[0] = 1;
12886
    ++count;
12887
  }
12888

12889
  for (j = 1; j < width; j++) {
12890
    if (data[pos] !== data[pos + 1]) {
12891
      points[j] = data[pos] ? 2 : 1;
12892
      ++count;
12893
    }
12894

12895
    pos++;
12896
  }
12897

12898
  if (data[pos] !== 0) {
12899
    points[j] = 2;
12900
    ++count;
12901
  }
12902

12903
  for (i = 1; i < height; i++) {
12904
    pos = i * lineSize;
12905
    j0 = i * width1;
12906

12907
    if (data[pos - lineSize] !== data[pos]) {
12908
      points[j0] = data[pos] ? 1 : 8;
12909
      ++count;
12910
    }
12911

12912
    var sum = (data[pos] ? 4 : 0) + (data[pos - lineSize] ? 8 : 0);
12913

12914
    for (j = 1; j < width; j++) {
12915
      sum = (sum >> 2) + (data[pos + 1] ? 4 : 0) + (data[pos - lineSize + 1] ? 8 : 0);
12916

12917
      if (POINT_TYPES[sum]) {
12918
        points[j0 + j] = POINT_TYPES[sum];
12919
        ++count;
12920
      }
12921

12922
      pos++;
12923
    }
12924

12925
    if (data[pos - lineSize] !== data[pos]) {
12926
      points[j0 + j] = data[pos] ? 2 : 4;
12927
      ++count;
12928
    }
12929

12930
    if (count > POINT_TO_PROCESS_LIMIT) {
12931
      return null;
12932
    }
12933
  }
12934

12935
  pos = lineSize * (height - 1);
12936
  j0 = i * width1;
12937

12938
  if (data[pos] !== 0) {
12939
    points[j0] = 8;
12940
    ++count;
12941
  }
12942

12943
  for (j = 1; j < width; j++) {
12944
    if (data[pos] !== data[pos + 1]) {
12945
      points[j0 + j] = data[pos] ? 4 : 8;
12946
      ++count;
12947
    }
12948

12949
    pos++;
12950
  }
12951

12952
  if (data[pos] !== 0) {
12953
    points[j0 + j] = 4;
12954
    ++count;
12955
  }
12956

12957
  if (count > POINT_TO_PROCESS_LIMIT) {
12958
    return null;
12959
  }
12960

12961
  var steps = new Int32Array([0, width1, -1, 0, -width1, 0, 0, 0, 1]);
12962
  var outlines = [];
12963

12964
  for (i = 0; count && i <= height; i++) {
12965
    var p = i * width1;
12966
    var end = p + width;
12967

12968
    while (p < end && !points[p]) {
12969
      p++;
12970
    }
12971

12972
    if (p === end) {
12973
      continue;
12974
    }
12975

12976
    var coords = [p % width1, i];
12977
    var p0 = p;
12978
    var type = points[p];
12979

12980
    do {
12981
      var step = steps[type];
12982

12983
      do {
12984
        p += step;
12985
      } while (!points[p]);
12986

12987
      var pp = points[p];
12988

12989
      if (pp !== 5 && pp !== 10) {
12990
        type = pp;
12991
        points[p] = 0;
12992
      } else {
12993
        type = pp & 0x33 * type >> 4;
12994
        points[p] &= type >> 2 | type << 2;
12995
      }
12996

12997
      coords.push(p % width1);
12998
      coords.push(p / width1 | 0);
12999

13000
      if (!points[p]) {
13001
        --count;
13002
      }
13003
    } while (p0 !== p);
13004

13005
    outlines.push(coords);
13006
    --i;
13007
  }
13008

13009
  var drawOutline = function drawOutline(c) {
13010
    c.save();
13011
    c.scale(1 / width, -1 / height);
13012
    c.translate(0, -height);
13013
    c.beginPath();
13014

13015
    for (var k = 0, kk = outlines.length; k < kk; k++) {
13016
      var o = outlines[k];
13017
      c.moveTo(o[0], o[1]);
13018

13019
      for (var l = 2, ll = o.length; l < ll; l += 2) {
13020
        c.lineTo(o[l], o[l + 1]);
13021
      }
13022
    }
13023

13024
    c.fill();
13025
    c.beginPath();
13026
    c.restore();
13027
  };
13028

13029
  return drawOutline;
13030
}
13031

13032
var CanvasExtraState = function CanvasExtraStateClosure() {
13033
  function CanvasExtraState() {
13034
    this.alphaIsShape = false;
13035
    this.fontSize = 0;
13036
    this.fontSizeScale = 1;
13037
    this.textMatrix = _util.IDENTITY_MATRIX;
13038
    this.textMatrixScale = 1;
13039
    this.fontMatrix = _util.FONT_IDENTITY_MATRIX;
13040
    this.leading = 0;
13041
    this.x = 0;
13042
    this.y = 0;
13043
    this.lineX = 0;
13044
    this.lineY = 0;
13045
    this.charSpacing = 0;
13046
    this.wordSpacing = 0;
13047
    this.textHScale = 1;
13048
    this.textRenderingMode = _util.TextRenderingMode.FILL;
13049
    this.textRise = 0;
13050
    this.fillColor = "#000000";
13051
    this.strokeColor = "#000000";
13052
    this.patternFill = false;
13053
    this.fillAlpha = 1;
13054
    this.strokeAlpha = 1;
13055
    this.lineWidth = 1;
13056
    this.activeSMask = null;
13057
    this.resumeSMaskCtx = null;
13058
    this.transferMaps = null;
13059
  }
13060

13061
  CanvasExtraState.prototype = {
13062
    clone: function CanvasExtraState_clone() {
13063
      return Object.create(this);
13064
    },
13065
    setCurrentPoint: function CanvasExtraState_setCurrentPoint(x, y) {
13066
      this.x = x;
13067
      this.y = y;
13068
    }
13069
  };
13070
  return CanvasExtraState;
13071
}();
13072

13073
var CanvasGraphics = function CanvasGraphicsClosure() {
13074
  var EXECUTION_TIME = 15;
13075
  var EXECUTION_STEPS = 10;
13076

13077
  function CanvasGraphics(canvasCtx, commonObjs, objs, canvasFactory, webGLContext, imageLayer, optionalContentConfig) {
13078
    this.ctx = canvasCtx;
13079
    this.current = new CanvasExtraState();
13080
    this.stateStack = [];
13081
    this.pendingClip = null;
13082
    this.pendingEOFill = false;
13083
    this.res = null;
13084
    this.xobjs = null;
13085
    this.commonObjs = commonObjs;
13086
    this.objs = objs;
13087
    this.canvasFactory = canvasFactory;
13088
    this.webGLContext = webGLContext;
13089
    this.imageLayer = imageLayer;
13090
    this.groupStack = [];
13091
    this.processingType3 = null;
13092
    this.baseTransform = null;
13093
    this.baseTransformStack = [];
13094
    this.groupLevel = 0;
13095
    this.smaskStack = [];
13096
    this.smaskCounter = 0;
13097
    this.tempSMask = null;
13098
    this.contentVisible = true;
13099
    this.markedContentStack = [];
13100
    this.optionalContentConfig = optionalContentConfig;
13101
    this.cachedCanvases = new CachedCanvases(this.canvasFactory);
13102

13103
    if (canvasCtx) {
13104
      addContextCurrentTransform(canvasCtx);
13105
    }
13106

13107
    this._cachedGetSinglePixelWidth = null;
13108
  }
13109

13110
  function putBinaryImageData(ctx, imgData) {
13111
    var transferMaps = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
13112

13113
    if (typeof ImageData !== "undefined" && imgData instanceof ImageData) {
13114
      ctx.putImageData(imgData, 0, 0);
13115
      return;
13116
    }
13117

13118
    var height = imgData.height,
13119
        width = imgData.width;
13120
    var partialChunkHeight = height % FULL_CHUNK_HEIGHT;
13121
    var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;
13122
    var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;
13123
    var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);
13124
    var srcPos = 0,
13125
        destPos;
13126
    var src = imgData.data;
13127
    var dest = chunkImgData.data;
13128
    var i, j, thisChunkHeight, elemsInThisChunk;
13129
    var transferMapRed, transferMapGreen, transferMapBlue, transferMapGray;
13130

13131
    if (transferMaps) {
13132
      switch (transferMaps.length) {
13133
        case 1:
13134
          transferMapRed = transferMaps[0];
13135
          transferMapGreen = transferMaps[0];
13136
          transferMapBlue = transferMaps[0];
13137
          transferMapGray = transferMaps[0];
13138
          break;
13139

13140
        case 4:
13141
          transferMapRed = transferMaps[0];
13142
          transferMapGreen = transferMaps[1];
13143
          transferMapBlue = transferMaps[2];
13144
          transferMapGray = transferMaps[3];
13145
          break;
13146
      }
13147
    }
13148

13149
    if (imgData.kind === _util.ImageKind.GRAYSCALE_1BPP) {
13150
      var srcLength = src.byteLength;
13151
      var dest32 = new Uint32Array(dest.buffer, 0, dest.byteLength >> 2);
13152
      var dest32DataLength = dest32.length;
13153
      var fullSrcDiff = width + 7 >> 3;
13154
      var white = 0xffffffff;
13155
      var black = _util.IsLittleEndianCached.value ? 0xff000000 : 0x000000ff;
13156

13157
      if (transferMapGray) {
13158
        if (transferMapGray[0] === 0xff && transferMapGray[0xff] === 0) {
13159
          var _ref = [black, white];
13160
          white = _ref[0];
13161
          black = _ref[1];
13162
        }
13163
      }
13164

13165
      for (i = 0; i < totalChunks; i++) {
13166
        thisChunkHeight = i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;
13167
        destPos = 0;
13168

13169
        for (j = 0; j < thisChunkHeight; j++) {
13170
          var srcDiff = srcLength - srcPos;
13171
          var k = 0;
13172
          var kEnd = srcDiff > fullSrcDiff ? width : srcDiff * 8 - 7;
13173
          var kEndUnrolled = kEnd & ~7;
13174
          var mask = 0;
13175
          var srcByte = 0;
13176

13177
          for (; k < kEndUnrolled; k += 8) {
13178
            srcByte = src[srcPos++];
13179
            dest32[destPos++] = srcByte & 128 ? white : black;
13180
            dest32[destPos++] = srcByte & 64 ? white : black;
13181
            dest32[destPos++] = srcByte & 32 ? white : black;
13182
            dest32[destPos++] = srcByte & 16 ? white : black;
13183
            dest32[destPos++] = srcByte & 8 ? white : black;
13184
            dest32[destPos++] = srcByte & 4 ? white : black;
13185
            dest32[destPos++] = srcByte & 2 ? white : black;
13186
            dest32[destPos++] = srcByte & 1 ? white : black;
13187
          }
13188

13189
          for (; k < kEnd; k++) {
13190
            if (mask === 0) {
13191
              srcByte = src[srcPos++];
13192
              mask = 128;
13193
            }
13194

13195
            dest32[destPos++] = srcByte & mask ? white : black;
13196
            mask >>= 1;
13197
          }
13198
        }
13199

13200
        while (destPos < dest32DataLength) {
13201
          dest32[destPos++] = 0;
13202
        }
13203

13204
        ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
13205
      }
13206
    } else if (imgData.kind === _util.ImageKind.RGBA_32BPP) {
13207
      var hasTransferMaps = !!(transferMapRed || transferMapGreen || transferMapBlue);
13208
      j = 0;
13209
      elemsInThisChunk = width * FULL_CHUNK_HEIGHT * 4;
13210

13211
      for (i = 0; i < fullChunks; i++) {
13212
        dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
13213
        srcPos += elemsInThisChunk;
13214

13215
        if (hasTransferMaps) {
13216
          for (var _k = 0; _k < elemsInThisChunk; _k += 4) {
13217
            if (transferMapRed) {
13218
              dest[_k + 0] = transferMapRed[dest[_k + 0]];
13219
            }
13220

13221
            if (transferMapGreen) {
13222
              dest[_k + 1] = transferMapGreen[dest[_k + 1]];
13223
            }
13224

13225
            if (transferMapBlue) {
13226
              dest[_k + 2] = transferMapBlue[dest[_k + 2]];
13227
            }
13228
          }
13229
        }
13230

13231
        ctx.putImageData(chunkImgData, 0, j);
13232
        j += FULL_CHUNK_HEIGHT;
13233
      }
13234

13235
      if (i < totalChunks) {
13236
        elemsInThisChunk = width * partialChunkHeight * 4;
13237
        dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
13238

13239
        if (hasTransferMaps) {
13240
          for (var _k2 = 0; _k2 < elemsInThisChunk; _k2 += 4) {
13241
            if (transferMapRed) {
13242
              dest[_k2 + 0] = transferMapRed[dest[_k2 + 0]];
13243
            }
13244

13245
            if (transferMapGreen) {
13246
              dest[_k2 + 1] = transferMapGreen[dest[_k2 + 1]];
13247
            }
13248

13249
            if (transferMapBlue) {
13250
              dest[_k2 + 2] = transferMapBlue[dest[_k2 + 2]];
13251
            }
13252
          }
13253
        }
13254

13255
        ctx.putImageData(chunkImgData, 0, j);
13256
      }
13257
    } else if (imgData.kind === _util.ImageKind.RGB_24BPP) {
13258
      var _hasTransferMaps = !!(transferMapRed || transferMapGreen || transferMapBlue);
13259

13260
      thisChunkHeight = FULL_CHUNK_HEIGHT;
13261
      elemsInThisChunk = width * thisChunkHeight;
13262

13263
      for (i = 0; i < totalChunks; i++) {
13264
        if (i >= fullChunks) {
13265
          thisChunkHeight = partialChunkHeight;
13266
          elemsInThisChunk = width * thisChunkHeight;
13267
        }
13268

13269
        destPos = 0;
13270

13271
        for (j = elemsInThisChunk; j--;) {
13272
          dest[destPos++] = src[srcPos++];
13273
          dest[destPos++] = src[srcPos++];
13274
          dest[destPos++] = src[srcPos++];
13275
          dest[destPos++] = 255;
13276
        }
13277

13278
        if (_hasTransferMaps) {
13279
          for (var _k3 = 0; _k3 < destPos; _k3 += 4) {
13280
            if (transferMapRed) {
13281
              dest[_k3 + 0] = transferMapRed[dest[_k3 + 0]];
13282
            }
13283

13284
            if (transferMapGreen) {
13285
              dest[_k3 + 1] = transferMapGreen[dest[_k3 + 1]];
13286
            }
13287

13288
            if (transferMapBlue) {
13289
              dest[_k3 + 2] = transferMapBlue[dest[_k3 + 2]];
13290
            }
13291
          }
13292
        }
13293

13294
        ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
13295
      }
13296
    } else {
13297
      throw new Error("bad image kind: ".concat(imgData.kind));
13298
    }
13299
  }
13300

13301
  function putBinaryImageMask(ctx, imgData) {
13302
    var height = imgData.height,
13303
        width = imgData.width;
13304
    var partialChunkHeight = height % FULL_CHUNK_HEIGHT;
13305
    var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;
13306
    var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;
13307
    var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);
13308
    var srcPos = 0;
13309
    var src = imgData.data;
13310
    var dest = chunkImgData.data;
13311

13312
    for (var i = 0; i < totalChunks; i++) {
13313
      var thisChunkHeight = i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;
13314
      var destPos = 3;
13315

13316
      for (var j = 0; j < thisChunkHeight; j++) {
13317
        var elem = void 0,
13318
            mask = 0;
13319

13320
        for (var k = 0; k < width; k++) {
13321
          if (!mask) {
13322
            elem = src[srcPos++];
13323
            mask = 128;
13324
          }
13325

13326
          dest[destPos] = elem & mask ? 0 : 255;
13327
          destPos += 4;
13328
          mask >>= 1;
13329
        }
13330
      }
13331

13332
      ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
13333
    }
13334
  }
13335

13336
  function copyCtxState(sourceCtx, destCtx) {
13337
    var properties = ["strokeStyle", "fillStyle", "fillRule", "globalAlpha", "lineWidth", "lineCap", "lineJoin", "miterLimit", "globalCompositeOperation", "font"];
13338

13339
    for (var i = 0, ii = properties.length; i < ii; i++) {
13340
      var property = properties[i];
13341

13342
      if (sourceCtx[property] !== undefined) {
13343
        destCtx[property] = sourceCtx[property];
13344
      }
13345
    }
13346

13347
    if (sourceCtx.setLineDash !== undefined) {
13348
      destCtx.setLineDash(sourceCtx.getLineDash());
13349
      destCtx.lineDashOffset = sourceCtx.lineDashOffset;
13350
    }
13351
  }
13352

13353
  function resetCtxToDefault(ctx) {
13354
    ctx.strokeStyle = "#000000";
13355
    ctx.fillStyle = "#000000";
13356
    ctx.fillRule = "nonzero";
13357
    ctx.globalAlpha = 1;
13358
    ctx.lineWidth = 1;
13359
    ctx.lineCap = "butt";
13360
    ctx.lineJoin = "miter";
13361
    ctx.miterLimit = 10;
13362
    ctx.globalCompositeOperation = "source-over";
13363
    ctx.font = "10px sans-serif";
13364

13365
    if (ctx.setLineDash !== undefined) {
13366
      ctx.setLineDash([]);
13367
      ctx.lineDashOffset = 0;
13368
    }
13369
  }
13370

13371
  function composeSMaskBackdrop(bytes, r0, g0, b0) {
13372
    var length = bytes.length;
13373

13374
    for (var i = 3; i < length; i += 4) {
13375
      var alpha = bytes[i];
13376

13377
      if (alpha === 0) {
13378
        bytes[i - 3] = r0;
13379
        bytes[i - 2] = g0;
13380
        bytes[i - 1] = b0;
13381
      } else if (alpha < 255) {
13382
        var alpha_ = 255 - alpha;
13383
        bytes[i - 3] = bytes[i - 3] * alpha + r0 * alpha_ >> 8;
13384
        bytes[i - 2] = bytes[i - 2] * alpha + g0 * alpha_ >> 8;
13385
        bytes[i - 1] = bytes[i - 1] * alpha + b0 * alpha_ >> 8;
13386
      }
13387
    }
13388
  }
13389

13390
  function composeSMaskAlpha(maskData, layerData, transferMap) {
13391
    var length = maskData.length;
13392
    var scale = 1 / 255;
13393

13394
    for (var i = 3; i < length; i += 4) {
13395
      var alpha = transferMap ? transferMap[maskData[i]] : maskData[i];
13396
      layerData[i] = layerData[i] * alpha * scale | 0;
13397
    }
13398
  }
13399

13400
  function composeSMaskLuminosity(maskData, layerData, transferMap) {
13401
    var length = maskData.length;
13402

13403
    for (var i = 3; i < length; i += 4) {
13404
      var y = maskData[i - 3] * 77 + maskData[i - 2] * 152 + maskData[i - 1] * 28;
13405
      layerData[i] = transferMap ? layerData[i] * transferMap[y >> 8] >> 8 : layerData[i] * y >> 16;
13406
    }
13407
  }
13408

13409
  function genericComposeSMask(maskCtx, layerCtx, width, height, subtype, backdrop, transferMap) {
13410
    var hasBackdrop = !!backdrop;
13411
    var r0 = hasBackdrop ? backdrop[0] : 0;
13412
    var g0 = hasBackdrop ? backdrop[1] : 0;
13413
    var b0 = hasBackdrop ? backdrop[2] : 0;
13414
    var composeFn;
13415

13416
    if (subtype === "Luminosity") {
13417
      composeFn = composeSMaskLuminosity;
13418
    } else {
13419
      composeFn = composeSMaskAlpha;
13420
    }
13421

13422
    var PIXELS_TO_PROCESS = 1048576;
13423
    var chunkSize = Math.min(height, Math.ceil(PIXELS_TO_PROCESS / width));
13424

13425
    for (var row = 0; row < height; row += chunkSize) {
13426
      var chunkHeight = Math.min(chunkSize, height - row);
13427
      var maskData = maskCtx.getImageData(0, row, width, chunkHeight);
13428
      var layerData = layerCtx.getImageData(0, row, width, chunkHeight);
13429

13430
      if (hasBackdrop) {
13431
        composeSMaskBackdrop(maskData.data, r0, g0, b0);
13432
      }
13433

13434
      composeFn(maskData.data, layerData.data, transferMap);
13435
      maskCtx.putImageData(layerData, 0, row);
13436
    }
13437
  }
13438

13439
  function composeSMask(ctx, smask, layerCtx, webGLContext) {
13440
    var mask = smask.canvas;
13441
    var maskCtx = smask.context;
13442
    ctx.setTransform(smask.scaleX, 0, 0, smask.scaleY, smask.offsetX, smask.offsetY);
13443
    var backdrop = smask.backdrop || null;
13444

13445
    if (!smask.transferMap && webGLContext.isEnabled) {
13446
      var composed = webGLContext.composeSMask({
13447
        layer: layerCtx.canvas,
13448
        mask: mask,
13449
        properties: {
13450
          subtype: smask.subtype,
13451
          backdrop: backdrop
13452
        }
13453
      });
13454
      ctx.setTransform(1, 0, 0, 1, 0, 0);
13455
      ctx.drawImage(composed, smask.offsetX, smask.offsetY);
13456
      return;
13457
    }
13458

13459
    genericComposeSMask(maskCtx, layerCtx, mask.width, mask.height, smask.subtype, backdrop, smask.transferMap);
13460
    ctx.drawImage(mask, 0, 0);
13461
  }
13462

13463
  var LINE_CAP_STYLES = ["butt", "round", "square"];
13464
  var LINE_JOIN_STYLES = ["miter", "round", "bevel"];
13465
  var NORMAL_CLIP = {};
13466
  var EO_CLIP = {};
13467
  CanvasGraphics.prototype = {
13468
    beginDrawing: function beginDrawing(_ref2) {
13469
      var transform = _ref2.transform,
13470
          viewport = _ref2.viewport,
13471
          _ref2$transparency = _ref2.transparency,
13472
          transparency = _ref2$transparency === void 0 ? false : _ref2$transparency,
13473
          _ref2$background = _ref2.background,
13474
          background = _ref2$background === void 0 ? null : _ref2$background;
13475
      var width = this.ctx.canvas.width;
13476
      var height = this.ctx.canvas.height;
13477
      this.ctx.save();
13478
      this.ctx.fillStyle = background || "rgb(255, 255, 255)";
13479
      this.ctx.fillRect(0, 0, width, height);
13480
      this.ctx.restore();
13481

13482
      if (transparency) {
13483
        var transparentCanvas = this.cachedCanvases.getCanvas("transparent", width, height, true);
13484
        this.compositeCtx = this.ctx;
13485
        this.transparentCanvas = transparentCanvas.canvas;
13486
        this.ctx = transparentCanvas.context;
13487
        this.ctx.save();
13488
        this.ctx.transform.apply(this.ctx, this.compositeCtx.mozCurrentTransform);
13489
      }
13490

13491
      this.ctx.save();
13492
      resetCtxToDefault(this.ctx);
13493

13494
      if (transform) {
13495
        this.ctx.transform.apply(this.ctx, transform);
13496
      }
13497

13498
      this.ctx.transform.apply(this.ctx, viewport.transform);
13499
      this.baseTransform = this.ctx.mozCurrentTransform.slice();
13500
      this._combinedScaleFactor = Math.hypot(this.baseTransform[0], this.baseTransform[2]);
13501

13502
      if (this.imageLayer) {
13503
        this.imageLayer.beginLayout();
13504
      }
13505
    },
13506
    executeOperatorList: function CanvasGraphics_executeOperatorList(operatorList, executionStartIdx, continueCallback, stepper) {
13507
      var argsArray = operatorList.argsArray;
13508
      var fnArray = operatorList.fnArray;
13509
      var i = executionStartIdx || 0;
13510
      var argsArrayLen = argsArray.length;
13511

13512
      if (argsArrayLen === i) {
13513
        return i;
13514
      }
13515

13516
      var chunkOperations = argsArrayLen - i > EXECUTION_STEPS && typeof continueCallback === "function";
13517
      var endTime = chunkOperations ? Date.now() + EXECUTION_TIME : 0;
13518
      var steps = 0;
13519
      var commonObjs = this.commonObjs;
13520
      var objs = this.objs;
13521
      var fnId;
13522

13523
      while (true) {
13524
        if (stepper !== undefined && i === stepper.nextBreakPoint) {
13525
          stepper.breakIt(i, continueCallback);
13526
          return i;
13527
        }
13528

13529
        fnId = fnArray[i];
13530

13531
        if (fnId !== _util.OPS.dependency) {
13532
          this[fnId].apply(this, argsArray[i]);
13533
        } else {
13534
          var _iterator = _createForOfIteratorHelper(argsArray[i]),
13535
              _step;
13536

13537
          try {
13538
            for (_iterator.s(); !(_step = _iterator.n()).done;) {
13539
              var depObjId = _step.value;
13540
              var objsPool = depObjId.startsWith("g_") ? commonObjs : objs;
13541

13542
              if (!objsPool.has(depObjId)) {
13543
                objsPool.get(depObjId, continueCallback);
13544
                return i;
13545
              }
13546
            }
13547
          } catch (err) {
13548
            _iterator.e(err);
13549
          } finally {
13550
            _iterator.f();
13551
          }
13552
        }
13553

13554
        i++;
13555

13556
        if (i === argsArrayLen) {
13557
          return i;
13558
        }
13559

13560
        if (chunkOperations && ++steps > EXECUTION_STEPS) {
13561
          if (Date.now() > endTime) {
13562
            continueCallback();
13563
            return i;
13564
          }
13565

13566
          steps = 0;
13567
        }
13568
      }
13569
    },
13570
    endDrawing: function CanvasGraphics_endDrawing() {
13571
      while (this.stateStack.length || this.current.activeSMask !== null) {
13572
        this.restore();
13573
      }
13574

13575
      this.ctx.restore();
13576

13577
      if (this.transparentCanvas) {
13578
        this.ctx = this.compositeCtx;
13579
        this.ctx.save();
13580
        this.ctx.setTransform(1, 0, 0, 1, 0, 0);
13581
        this.ctx.drawImage(this.transparentCanvas, 0, 0);
13582
        this.ctx.restore();
13583
        this.transparentCanvas = null;
13584
      }
13585

13586
      this.cachedCanvases.clear();
13587
      this.webGLContext.clear();
13588

13589
      if (this.imageLayer) {
13590
        this.imageLayer.endLayout();
13591
      }
13592
    },
13593
    setLineWidth: function CanvasGraphics_setLineWidth(width) {
13594
      this.current.lineWidth = width;
13595
      this.ctx.lineWidth = width;
13596
    },
13597
    setLineCap: function CanvasGraphics_setLineCap(style) {
13598
      this.ctx.lineCap = LINE_CAP_STYLES[style];
13599
    },
13600
    setLineJoin: function CanvasGraphics_setLineJoin(style) {
13601
      this.ctx.lineJoin = LINE_JOIN_STYLES[style];
13602
    },
13603
    setMiterLimit: function CanvasGraphics_setMiterLimit(limit) {
13604
      this.ctx.miterLimit = limit;
13605
    },
13606
    setDash: function CanvasGraphics_setDash(dashArray, dashPhase) {
13607
      var ctx = this.ctx;
13608

13609
      if (ctx.setLineDash !== undefined) {
13610
        ctx.setLineDash(dashArray);
13611
        ctx.lineDashOffset = dashPhase;
13612
      }
13613
    },
13614
    setRenderingIntent: function setRenderingIntent(intent) {},
13615
    setFlatness: function setFlatness(flatness) {},
13616
    setGState: function CanvasGraphics_setGState(states) {
13617
      for (var i = 0, ii = states.length; i < ii; i++) {
13618
        var state = states[i];
13619
        var key = state[0];
13620
        var value = state[1];
13621

13622
        switch (key) {
13623
          case "LW":
13624
            this.setLineWidth(value);
13625
            break;
13626

13627
          case "LC":
13628
            this.setLineCap(value);
13629
            break;
13630

13631
          case "LJ":
13632
            this.setLineJoin(value);
13633
            break;
13634

13635
          case "ML":
13636
            this.setMiterLimit(value);
13637
            break;
13638

13639
          case "D":
13640
            this.setDash(value[0], value[1]);
13641
            break;
13642

13643
          case "RI":
13644
            this.setRenderingIntent(value);
13645
            break;
13646

13647
          case "FL":
13648
            this.setFlatness(value);
13649
            break;
13650

13651
          case "Font":
13652
            this.setFont(value[0], value[1]);
13653
            break;
13654

13655
          case "CA":
13656
            this.current.strokeAlpha = state[1];
13657
            break;
13658

13659
          case "ca":
13660
            this.current.fillAlpha = state[1];
13661
            this.ctx.globalAlpha = state[1];
13662
            break;
13663

13664
          case "BM":
13665
            this.ctx.globalCompositeOperation = value;
13666
            break;
13667

13668
          case "SMask":
13669
            if (this.current.activeSMask) {
13670
              if (this.stateStack.length > 0 && this.stateStack[this.stateStack.length - 1].activeSMask === this.current.activeSMask) {
13671
                this.suspendSMaskGroup();
13672
              } else {
13673
                this.endSMaskGroup();
13674
              }
13675
            }
13676

13677
            this.current.activeSMask = value ? this.tempSMask : null;
13678

13679
            if (this.current.activeSMask) {
13680
              this.beginSMaskGroup();
13681
            }
13682

13683
            this.tempSMask = null;
13684
            break;
13685

13686
          case "TR":
13687
            this.current.transferMaps = value;
13688
        }
13689
      }
13690
    },
13691
    beginSMaskGroup: function CanvasGraphics_beginSMaskGroup() {
13692
      var activeSMask = this.current.activeSMask;
13693
      var drawnWidth = activeSMask.canvas.width;
13694
      var drawnHeight = activeSMask.canvas.height;
13695
      var cacheId = "smaskGroupAt" + this.groupLevel;
13696
      var scratchCanvas = this.cachedCanvases.getCanvas(cacheId, drawnWidth, drawnHeight, true);
13697
      var currentCtx = this.ctx;
13698
      var currentTransform = currentCtx.mozCurrentTransform;
13699
      this.ctx.save();
13700
      var groupCtx = scratchCanvas.context;
13701
      groupCtx.scale(1 / activeSMask.scaleX, 1 / activeSMask.scaleY);
13702
      groupCtx.translate(-activeSMask.offsetX, -activeSMask.offsetY);
13703
      groupCtx.transform.apply(groupCtx, currentTransform);
13704
      activeSMask.startTransformInverse = groupCtx.mozCurrentTransformInverse;
13705
      copyCtxState(currentCtx, groupCtx);
13706
      this.ctx = groupCtx;
13707
      this.setGState([["BM", "source-over"], ["ca", 1], ["CA", 1]]);
13708
      this.groupStack.push(currentCtx);
13709
      this.groupLevel++;
13710
    },
13711
    suspendSMaskGroup: function CanvasGraphics_endSMaskGroup() {
13712
      var groupCtx = this.ctx;
13713
      this.groupLevel--;
13714
      this.ctx = this.groupStack.pop();
13715
      composeSMask(this.ctx, this.current.activeSMask, groupCtx, this.webGLContext);
13716
      this.ctx.restore();
13717
      this.ctx.save();
13718
      copyCtxState(groupCtx, this.ctx);
13719
      this.current.resumeSMaskCtx = groupCtx;
13720

13721
      var deltaTransform = _util.Util.transform(this.current.activeSMask.startTransformInverse, groupCtx.mozCurrentTransform);
13722

13723
      this.ctx.transform.apply(this.ctx, deltaTransform);
13724
      groupCtx.save();
13725
      groupCtx.setTransform(1, 0, 0, 1, 0, 0);
13726
      groupCtx.clearRect(0, 0, groupCtx.canvas.width, groupCtx.canvas.height);
13727
      groupCtx.restore();
13728
    },
13729
    resumeSMaskGroup: function CanvasGraphics_resumeSMaskGroup() {
13730
      var groupCtx = this.current.resumeSMaskCtx;
13731
      var currentCtx = this.ctx;
13732
      this.ctx = groupCtx;
13733
      this.groupStack.push(currentCtx);
13734
      this.groupLevel++;
13735
    },
13736
    endSMaskGroup: function CanvasGraphics_endSMaskGroup() {
13737
      var groupCtx = this.ctx;
13738
      this.groupLevel--;
13739
      this.ctx = this.groupStack.pop();
13740
      composeSMask(this.ctx, this.current.activeSMask, groupCtx, this.webGLContext);
13741
      this.ctx.restore();
13742
      copyCtxState(groupCtx, this.ctx);
13743

13744
      var deltaTransform = _util.Util.transform(this.current.activeSMask.startTransformInverse, groupCtx.mozCurrentTransform);
13745

13746
      this.ctx.transform.apply(this.ctx, deltaTransform);
13747
    },
13748
    save: function CanvasGraphics_save() {
13749
      this.ctx.save();
13750
      var old = this.current;
13751
      this.stateStack.push(old);
13752
      this.current = old.clone();
13753
      this.current.resumeSMaskCtx = null;
13754
    },
13755
    restore: function CanvasGraphics_restore() {
13756
      if (this.current.resumeSMaskCtx) {
13757
        this.resumeSMaskGroup();
13758
      }
13759

13760
      if (this.current.activeSMask !== null && (this.stateStack.length === 0 || this.stateStack[this.stateStack.length - 1].activeSMask !== this.current.activeSMask)) {
13761
        this.endSMaskGroup();
13762
      }
13763

13764
      if (this.stateStack.length !== 0) {
13765
        this.current = this.stateStack.pop();
13766
        this.ctx.restore();
13767
        this.pendingClip = null;
13768
        this._cachedGetSinglePixelWidth = null;
13769
      } else {
13770
        this.current.activeSMask = null;
13771
      }
13772
    },
13773
    transform: function CanvasGraphics_transform(a, b, c, d, e, f) {
13774
      this.ctx.transform(a, b, c, d, e, f);
13775
      this._cachedGetSinglePixelWidth = null;
13776
    },
13777
    constructPath: function CanvasGraphics_constructPath(ops, args) {
13778
      var ctx = this.ctx;
13779
      var current = this.current;
13780
      var x = current.x,
13781
          y = current.y;
13782

13783
      for (var i = 0, j = 0, ii = ops.length; i < ii; i++) {
13784
        switch (ops[i] | 0) {
13785
          case _util.OPS.rectangle:
13786
            x = args[j++];
13787
            y = args[j++];
13788
            var width = args[j++];
13789
            var height = args[j++];
13790
            var xw = x + width;
13791
            var yh = y + height;
13792
            ctx.moveTo(x, y);
13793

13794
            if (width === 0 || height === 0) {
13795
              ctx.lineTo(xw, yh);
13796
            } else {
13797
              ctx.lineTo(xw, y);
13798
              ctx.lineTo(xw, yh);
13799
              ctx.lineTo(x, yh);
13800
            }
13801

13802
            ctx.closePath();
13803
            break;
13804

13805
          case _util.OPS.moveTo:
13806
            x = args[j++];
13807
            y = args[j++];
13808
            ctx.moveTo(x, y);
13809
            break;
13810

13811
          case _util.OPS.lineTo:
13812
            x = args[j++];
13813
            y = args[j++];
13814
            ctx.lineTo(x, y);
13815
            break;
13816

13817
          case _util.OPS.curveTo:
13818
            x = args[j + 4];
13819
            y = args[j + 5];
13820
            ctx.bezierCurveTo(args[j], args[j + 1], args[j + 2], args[j + 3], x, y);
13821
            j += 6;
13822
            break;
13823

13824
          case _util.OPS.curveTo2:
13825
            ctx.bezierCurveTo(x, y, args[j], args[j + 1], args[j + 2], args[j + 3]);
13826
            x = args[j + 2];
13827
            y = args[j + 3];
13828
            j += 4;
13829
            break;
13830

13831
          case _util.OPS.curveTo3:
13832
            x = args[j + 2];
13833
            y = args[j + 3];
13834
            ctx.bezierCurveTo(args[j], args[j + 1], x, y, x, y);
13835
            j += 4;
13836
            break;
13837

13838
          case _util.OPS.closePath:
13839
            ctx.closePath();
13840
            break;
13841
        }
13842
      }
13843

13844
      current.setCurrentPoint(x, y);
13845
    },
13846
    closePath: function CanvasGraphics_closePath() {
13847
      this.ctx.closePath();
13848
    },
13849
    stroke: function CanvasGraphics_stroke(consumePath) {
13850
      consumePath = typeof consumePath !== "undefined" ? consumePath : true;
13851
      var ctx = this.ctx;
13852
      var strokeColor = this.current.strokeColor;
13853
      ctx.globalAlpha = this.current.strokeAlpha;
13854

13855
      if (this.contentVisible) {
13856
        if (_typeof(strokeColor) === "object" && strokeColor !== null && strokeColor !== void 0 && strokeColor.getPattern) {
13857
          ctx.save();
13858
          var transform = ctx.mozCurrentTransform;
13859

13860
          var scale = _util.Util.singularValueDecompose2dScale(transform)[0];
13861

13862
          ctx.strokeStyle = strokeColor.getPattern(ctx, this);
13863
          var lineWidth = this.getSinglePixelWidth();
13864
          var scaledLineWidth = this.current.lineWidth * scale;
13865

13866
          if (lineWidth < 0 && -lineWidth >= scaledLineWidth) {
13867
            ctx.resetTransform();
13868
            ctx.lineWidth = Math.round(this._combinedScaleFactor);
13869
          } else {
13870
            ctx.lineWidth = Math.max(lineWidth, scaledLineWidth);
13871
          }
13872

13873
          ctx.stroke();
13874
          ctx.restore();
13875
        } else {
13876
          var _lineWidth = this.getSinglePixelWidth();
13877

13878
          if (_lineWidth < 0 && -_lineWidth >= this.current.lineWidth) {
13879
            ctx.save();
13880
            ctx.resetTransform();
13881
            ctx.lineWidth = Math.round(this._combinedScaleFactor);
13882
            ctx.stroke();
13883
            ctx.restore();
13884
          } else {
13885
            ctx.lineWidth = Math.max(_lineWidth, this.current.lineWidth);
13886
            ctx.stroke();
13887
          }
13888
        }
13889
      }
13890

13891
      if (consumePath) {
13892
        this.consumePath();
13893
      }
13894

13895
      ctx.globalAlpha = this.current.fillAlpha;
13896
    },
13897
    closeStroke: function CanvasGraphics_closeStroke() {
13898
      this.closePath();
13899
      this.stroke();
13900
    },
13901
    fill: function CanvasGraphics_fill(consumePath) {
13902
      consumePath = typeof consumePath !== "undefined" ? consumePath : true;
13903
      var ctx = this.ctx;
13904
      var fillColor = this.current.fillColor;
13905
      var isPatternFill = this.current.patternFill;
13906
      var needRestore = false;
13907

13908
      if (isPatternFill) {
13909
        ctx.save();
13910

13911
        if (this.baseTransform) {
13912
          ctx.setTransform.apply(ctx, this.baseTransform);
13913
        }
13914

13915
        ctx.fillStyle = fillColor.getPattern(ctx, this);
13916
        needRestore = true;
13917
      }
13918

13919
      if (this.contentVisible) {
13920
        if (this.pendingEOFill) {
13921
          ctx.fill("evenodd");
13922
          this.pendingEOFill = false;
13923
        } else {
13924
          ctx.fill();
13925
        }
13926
      }
13927

13928
      if (needRestore) {
13929
        ctx.restore();
13930
      }
13931

13932
      if (consumePath) {
13933
        this.consumePath();
13934
      }
13935
    },
13936
    eoFill: function CanvasGraphics_eoFill() {
13937
      this.pendingEOFill = true;
13938
      this.fill();
13939
    },
13940
    fillStroke: function CanvasGraphics_fillStroke() {
13941
      this.fill(false);
13942
      this.stroke(false);
13943
      this.consumePath();
13944
    },
13945
    eoFillStroke: function CanvasGraphics_eoFillStroke() {
13946
      this.pendingEOFill = true;
13947
      this.fillStroke();
13948
    },
13949
    closeFillStroke: function CanvasGraphics_closeFillStroke() {
13950
      this.closePath();
13951
      this.fillStroke();
13952
    },
13953
    closeEOFillStroke: function CanvasGraphics_closeEOFillStroke() {
13954
      this.pendingEOFill = true;
13955
      this.closePath();
13956
      this.fillStroke();
13957
    },
13958
    endPath: function CanvasGraphics_endPath() {
13959
      this.consumePath();
13960
    },
13961
    clip: function CanvasGraphics_clip() {
13962
      this.pendingClip = NORMAL_CLIP;
13963
    },
13964
    eoClip: function CanvasGraphics_eoClip() {
13965
      this.pendingClip = EO_CLIP;
13966
    },
13967
    beginText: function CanvasGraphics_beginText() {
13968
      this.current.textMatrix = _util.IDENTITY_MATRIX;
13969
      this.current.textMatrixScale = 1;
13970
      this.current.x = this.current.lineX = 0;
13971
      this.current.y = this.current.lineY = 0;
13972
    },
13973
    endText: function CanvasGraphics_endText() {
13974
      var paths = this.pendingTextPaths;
13975
      var ctx = this.ctx;
13976

13977
      if (paths === undefined) {
13978
        ctx.beginPath();
13979
        return;
13980
      }
13981

13982
      ctx.save();
13983
      ctx.beginPath();
13984

13985
      for (var i = 0; i < paths.length; i++) {
13986
        var path = paths[i];
13987
        ctx.setTransform.apply(ctx, path.transform);
13988
        ctx.translate(path.x, path.y);
13989
        path.addToPath(ctx, path.fontSize);
13990
      }
13991

13992
      ctx.restore();
13993
      ctx.clip();
13994
      ctx.beginPath();
13995
      delete this.pendingTextPaths;
13996
    },
13997
    setCharSpacing: function CanvasGraphics_setCharSpacing(spacing) {
13998
      this.current.charSpacing = spacing;
13999
    },
14000
    setWordSpacing: function CanvasGraphics_setWordSpacing(spacing) {
14001
      this.current.wordSpacing = spacing;
14002
    },
14003
    setHScale: function CanvasGraphics_setHScale(scale) {
14004
      this.current.textHScale = scale / 100;
14005
    },
14006
    setLeading: function CanvasGraphics_setLeading(leading) {
14007
      this.current.leading = -leading;
14008
    },
14009
    setFont: function CanvasGraphics_setFont(fontRefName, size) {
14010
      var fontObj = this.commonObjs.get(fontRefName);
14011
      var current = this.current;
14012

14013
      if (!fontObj) {
14014
        throw new Error("Can't find font for ".concat(fontRefName));
14015
      }
14016

14017
      current.fontMatrix = fontObj.fontMatrix || _util.FONT_IDENTITY_MATRIX;
14018

14019
      if (current.fontMatrix[0] === 0 || current.fontMatrix[3] === 0) {
14020
        (0, _util.warn)("Invalid font matrix for font " + fontRefName);
14021
      }
14022

14023
      if (size < 0) {
14024
        size = -size;
14025
        current.fontDirection = -1;
14026
      } else {
14027
        current.fontDirection = 1;
14028
      }
14029

14030
      this.current.font = fontObj;
14031
      this.current.fontSize = size;
14032

14033
      if (fontObj.isType3Font) {
14034
        return;
14035
      }
14036

14037
      var name = fontObj.loadedName || "sans-serif";
14038
      var bold = "normal";
14039

14040
      if (fontObj.black) {
14041
        bold = "900";
14042
      } else if (fontObj.bold) {
14043
        bold = "bold";
14044
      }
14045

14046
      var italic = fontObj.italic ? "italic" : "normal";
14047
      var typeface = "\"".concat(name, "\", ").concat(fontObj.fallbackName);
14048
      var browserFontSize = size;
14049

14050
      if (size < MIN_FONT_SIZE) {
14051
        browserFontSize = MIN_FONT_SIZE;
14052
      } else if (size > MAX_FONT_SIZE) {
14053
        browserFontSize = MAX_FONT_SIZE;
14054
      }
14055

14056
      this.current.fontSizeScale = size / browserFontSize;
14057
      this.ctx.font = "".concat(italic, " ").concat(bold, " ").concat(browserFontSize, "px ").concat(typeface);
14058
    },
14059
    setTextRenderingMode: function CanvasGraphics_setTextRenderingMode(mode) {
14060
      this.current.textRenderingMode = mode;
14061
    },
14062
    setTextRise: function CanvasGraphics_setTextRise(rise) {
14063
      this.current.textRise = rise;
14064
    },
14065
    moveText: function CanvasGraphics_moveText(x, y) {
14066
      this.current.x = this.current.lineX += x;
14067
      this.current.y = this.current.lineY += y;
14068
    },
14069
    setLeadingMoveText: function CanvasGraphics_setLeadingMoveText(x, y) {
14070
      this.setLeading(-y);
14071
      this.moveText(x, y);
14072
    },
14073
    setTextMatrix: function CanvasGraphics_setTextMatrix(a, b, c, d, e, f) {
14074
      this.current.textMatrix = [a, b, c, d, e, f];
14075
      this.current.textMatrixScale = Math.hypot(a, b);
14076
      this.current.x = this.current.lineX = 0;
14077
      this.current.y = this.current.lineY = 0;
14078
    },
14079
    nextLine: function CanvasGraphics_nextLine() {
14080
      this.moveText(0, this.current.leading);
14081
    },
14082
    paintChar: function paintChar(character, x, y, patternTransform, resetLineWidthToOne) {
14083
      var ctx = this.ctx;
14084
      var current = this.current;
14085
      var font = current.font;
14086
      var textRenderingMode = current.textRenderingMode;
14087
      var fontSize = current.fontSize / current.fontSizeScale;
14088
      var fillStrokeMode = textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
14089
      var isAddToPathSet = !!(textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG);
14090
      var patternFill = current.patternFill && !font.missingFile;
14091
      var addToPath;
14092

14093
      if (font.disableFontFace || isAddToPathSet || patternFill) {
14094
        addToPath = font.getPathGenerator(this.commonObjs, character);
14095
      }
14096

14097
      if (font.disableFontFace || patternFill) {
14098
        ctx.save();
14099
        ctx.translate(x, y);
14100
        ctx.beginPath();
14101
        addToPath(ctx, fontSize);
14102

14103
        if (patternTransform) {
14104
          ctx.setTransform.apply(ctx, patternTransform);
14105
        }
14106

14107
        if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
14108
          ctx.fill();
14109
        }
14110

14111
        if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
14112
          if (resetLineWidthToOne) {
14113
            ctx.resetTransform();
14114
            ctx.lineWidth = Math.round(this._combinedScaleFactor);
14115
          }
14116

14117
          ctx.stroke();
14118
        }
14119

14120
        ctx.restore();
14121
      } else {
14122
        if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
14123
          ctx.fillText(character, x, y);
14124
        }
14125

14126
        if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
14127
          if (resetLineWidthToOne) {
14128
            ctx.save();
14129
            ctx.moveTo(x, y);
14130
            ctx.resetTransform();
14131
            ctx.lineWidth = Math.round(this._combinedScaleFactor);
14132
            ctx.strokeText(character, 0, 0);
14133
            ctx.restore();
14134
          } else {
14135
            ctx.strokeText(character, x, y);
14136
          }
14137
        }
14138
      }
14139

14140
      if (isAddToPathSet) {
14141
        var paths = this.pendingTextPaths || (this.pendingTextPaths = []);
14142
        paths.push({
14143
          transform: ctx.mozCurrentTransform,
14144
          x: x,
14145
          y: y,
14146
          fontSize: fontSize,
14147
          addToPath: addToPath
14148
        });
14149
      }
14150
    },
14151

14152
    get isFontSubpixelAAEnabled() {
14153
      var _this$cachedCanvases$ = this.cachedCanvases.getCanvas("isFontSubpixelAAEnabled", 10, 10),
14154
          ctx = _this$cachedCanvases$.context;
14155

14156
      ctx.scale(1.5, 1);
14157
      ctx.fillText("I", 0, 10);
14158
      var data = ctx.getImageData(0, 0, 10, 10).data;
14159
      var enabled = false;
14160

14161
      for (var i = 3; i < data.length; i += 4) {
14162
        if (data[i] > 0 && data[i] < 255) {
14163
          enabled = true;
14164
          break;
14165
        }
14166
      }
14167

14168
      return (0, _util.shadow)(this, "isFontSubpixelAAEnabled", enabled);
14169
    },
14170

14171
    showText: function CanvasGraphics_showText(glyphs) {
14172
      var current = this.current;
14173
      var font = current.font;
14174

14175
      if (font.isType3Font) {
14176
        return this.showType3Text(glyphs);
14177
      }
14178

14179
      var fontSize = current.fontSize;
14180

14181
      if (fontSize === 0) {
14182
        return undefined;
14183
      }
14184

14185
      var ctx = this.ctx;
14186
      var fontSizeScale = current.fontSizeScale;
14187
      var charSpacing = current.charSpacing;
14188
      var wordSpacing = current.wordSpacing;
14189
      var fontDirection = current.fontDirection;
14190
      var textHScale = current.textHScale * fontDirection;
14191
      var glyphsLength = glyphs.length;
14192
      var vertical = font.vertical;
14193
      var spacingDir = vertical ? 1 : -1;
14194
      var defaultVMetrics = font.defaultVMetrics;
14195
      var widthAdvanceScale = fontSize * current.fontMatrix[0];
14196
      var simpleFillText = current.textRenderingMode === _util.TextRenderingMode.FILL && !font.disableFontFace && !current.patternFill;
14197
      ctx.save();
14198
      var patternTransform;
14199

14200
      if (current.patternFill) {
14201
        ctx.save();
14202
        var pattern = current.fillColor.getPattern(ctx, this);
14203
        patternTransform = ctx.mozCurrentTransform;
14204
        ctx.restore();
14205
        ctx.fillStyle = pattern;
14206
      }
14207

14208
      ctx.transform.apply(ctx, current.textMatrix);
14209
      ctx.translate(current.x, current.y + current.textRise);
14210

14211
      if (fontDirection > 0) {
14212
        ctx.scale(textHScale, -1);
14213
      } else {
14214
        ctx.scale(textHScale, 1);
14215
      }
14216

14217
      var lineWidth = current.lineWidth;
14218
      var resetLineWidthToOne = false;
14219
      var scale = current.textMatrixScale;
14220

14221
      if (scale === 0 || lineWidth === 0) {
14222
        var fillStrokeMode = current.textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
14223

14224
        if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
14225
          this._cachedGetSinglePixelWidth = null;
14226
          lineWidth = this.getSinglePixelWidth();
14227
          resetLineWidthToOne = lineWidth < 0;
14228
        }
14229
      } else {
14230
        lineWidth /= scale;
14231
      }
14232

14233
      if (fontSizeScale !== 1.0) {
14234
        ctx.scale(fontSizeScale, fontSizeScale);
14235
        lineWidth /= fontSizeScale;
14236
      }
14237

14238
      ctx.lineWidth = lineWidth;
14239
      var x = 0,
14240
          i;
14241

14242
      for (i = 0; i < glyphsLength; ++i) {
14243
        var glyph = glyphs[i];
14244

14245
        if ((0, _util.isNum)(glyph)) {
14246
          x += spacingDir * glyph * fontSize / 1000;
14247
          continue;
14248
        }
14249

14250
        var restoreNeeded = false;
14251
        var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
14252
        var character = glyph.fontChar;
14253
        var accent = glyph.accent;
14254
        var scaledX = void 0,
14255
            scaledY = void 0;
14256
        var width = glyph.width;
14257

14258
        if (vertical) {
14259
          var vmetric = glyph.vmetric || defaultVMetrics;
14260
          var vx = -(glyph.vmetric ? vmetric[1] : width * 0.5) * widthAdvanceScale;
14261
          var vy = vmetric[2] * widthAdvanceScale;
14262
          width = vmetric ? -vmetric[0] : width;
14263
          scaledX = vx / fontSizeScale;
14264
          scaledY = (x + vy) / fontSizeScale;
14265
        } else {
14266
          scaledX = x / fontSizeScale;
14267
          scaledY = 0;
14268
        }
14269

14270
        if (font.remeasure && width > 0) {
14271
          var measuredWidth = ctx.measureText(character).width * 1000 / fontSize * fontSizeScale;
14272

14273
          if (width < measuredWidth && this.isFontSubpixelAAEnabled) {
14274
            var characterScaleX = width / measuredWidth;
14275
            restoreNeeded = true;
14276
            ctx.save();
14277
            ctx.scale(characterScaleX, 1);
14278
            scaledX /= characterScaleX;
14279
          } else if (width !== measuredWidth) {
14280
            scaledX += (width - measuredWidth) / 2000 * fontSize / fontSizeScale;
14281
          }
14282
        }
14283

14284
        if (this.contentVisible && (glyph.isInFont || font.missingFile)) {
14285
          if (simpleFillText && !accent) {
14286
            ctx.fillText(character, scaledX, scaledY);
14287
          } else {
14288
            this.paintChar(character, scaledX, scaledY, patternTransform, resetLineWidthToOne);
14289

14290
            if (accent) {
14291
              var scaledAccentX = scaledX + fontSize * accent.offset.x / fontSizeScale;
14292
              var scaledAccentY = scaledY - fontSize * accent.offset.y / fontSizeScale;
14293
              this.paintChar(accent.fontChar, scaledAccentX, scaledAccentY, patternTransform, resetLineWidthToOne);
14294
            }
14295
          }
14296
        }
14297

14298
        var charWidth = void 0;
14299

14300
        if (vertical) {
14301
          charWidth = width * widthAdvanceScale - spacing * fontDirection;
14302
        } else {
14303
          charWidth = width * widthAdvanceScale + spacing * fontDirection;
14304
        }
14305

14306
        x += charWidth;
14307

14308
        if (restoreNeeded) {
14309
          ctx.restore();
14310
        }
14311
      }
14312

14313
      if (vertical) {
14314
        current.y -= x;
14315
      } else {
14316
        current.x += x * textHScale;
14317
      }
14318

14319
      ctx.restore();
14320
    },
14321
    showType3Text: function CanvasGraphics_showType3Text(glyphs) {
14322
      var ctx = this.ctx;
14323
      var current = this.current;
14324
      var font = current.font;
14325
      var fontSize = current.fontSize;
14326
      var fontDirection = current.fontDirection;
14327
      var spacingDir = font.vertical ? 1 : -1;
14328
      var charSpacing = current.charSpacing;
14329
      var wordSpacing = current.wordSpacing;
14330
      var textHScale = current.textHScale * fontDirection;
14331
      var fontMatrix = current.fontMatrix || _util.FONT_IDENTITY_MATRIX;
14332
      var glyphsLength = glyphs.length;
14333
      var isTextInvisible = current.textRenderingMode === _util.TextRenderingMode.INVISIBLE;
14334
      var i, glyph, width, spacingLength;
14335

14336
      if (isTextInvisible || fontSize === 0) {
14337
        return;
14338
      }
14339

14340
      this._cachedGetSinglePixelWidth = null;
14341
      ctx.save();
14342
      ctx.transform.apply(ctx, current.textMatrix);
14343
      ctx.translate(current.x, current.y);
14344
      ctx.scale(textHScale, fontDirection);
14345

14346
      for (i = 0; i < glyphsLength; ++i) {
14347
        glyph = glyphs[i];
14348

14349
        if ((0, _util.isNum)(glyph)) {
14350
          spacingLength = spacingDir * glyph * fontSize / 1000;
14351
          this.ctx.translate(spacingLength, 0);
14352
          current.x += spacingLength * textHScale;
14353
          continue;
14354
        }
14355

14356
        var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
14357
        var operatorList = font.charProcOperatorList[glyph.operatorListId];
14358

14359
        if (!operatorList) {
14360
          (0, _util.warn)("Type3 character \"".concat(glyph.operatorListId, "\" is not available."));
14361
          continue;
14362
        }
14363

14364
        if (this.contentVisible) {
14365
          this.processingType3 = glyph;
14366
          this.save();
14367
          ctx.scale(fontSize, fontSize);
14368
          ctx.transform.apply(ctx, fontMatrix);
14369
          this.executeOperatorList(operatorList);
14370
          this.restore();
14371
        }
14372

14373
        var transformed = _util.Util.applyTransform([glyph.width, 0], fontMatrix);
14374

14375
        width = transformed[0] * fontSize + spacing;
14376
        ctx.translate(width, 0);
14377
        current.x += width * textHScale;
14378
      }
14379

14380
      ctx.restore();
14381
      this.processingType3 = null;
14382
    },
14383
    setCharWidth: function CanvasGraphics_setCharWidth(xWidth, yWidth) {},
14384
    setCharWidthAndBounds: function CanvasGraphics_setCharWidthAndBounds(xWidth, yWidth, llx, lly, urx, ury) {
14385
      this.ctx.rect(llx, lly, urx - llx, ury - lly);
14386
      this.clip();
14387
      this.endPath();
14388
    },
14389
    getColorN_Pattern: function CanvasGraphics_getColorN_Pattern(IR) {
14390
      var _this = this;
14391

14392
      var pattern;
14393

14394
      if (IR[0] === "TilingPattern") {
14395
        var color = IR[1];
14396
        var baseTransform = this.baseTransform || this.ctx.mozCurrentTransform.slice();
14397
        var canvasGraphicsFactory = {
14398
          createCanvasGraphics: function createCanvasGraphics(ctx) {
14399
            return new CanvasGraphics(ctx, _this.commonObjs, _this.objs, _this.canvasFactory, _this.webGLContext);
14400
          }
14401
        };
14402
        pattern = new _pattern_helper.TilingPattern(IR, color, this.ctx, canvasGraphicsFactory, baseTransform);
14403
      } else {
14404
        pattern = (0, _pattern_helper.getShadingPatternFromIR)(IR);
14405
      }
14406

14407
      return pattern;
14408
    },
14409
    setStrokeColorN: function CanvasGraphics_setStrokeColorN() {
14410
      this.current.strokeColor = this.getColorN_Pattern(arguments);
14411
    },
14412
    setFillColorN: function CanvasGraphics_setFillColorN() {
14413
      this.current.fillColor = this.getColorN_Pattern(arguments);
14414
      this.current.patternFill = true;
14415
    },
14416
    setStrokeRGBColor: function CanvasGraphics_setStrokeRGBColor(r, g, b) {
14417
      var color = _util.Util.makeHexColor(r, g, b);
14418

14419
      this.ctx.strokeStyle = color;
14420
      this.current.strokeColor = color;
14421
    },
14422
    setFillRGBColor: function CanvasGraphics_setFillRGBColor(r, g, b) {
14423
      var color = _util.Util.makeHexColor(r, g, b);
14424

14425
      this.ctx.fillStyle = color;
14426
      this.current.fillColor = color;
14427
      this.current.patternFill = false;
14428
    },
14429
    shadingFill: function CanvasGraphics_shadingFill(patternIR) {
14430
      if (!this.contentVisible) {
14431
        return;
14432
      }
14433

14434
      var ctx = this.ctx;
14435
      this.save();
14436
      var pattern = (0, _pattern_helper.getShadingPatternFromIR)(patternIR);
14437
      ctx.fillStyle = pattern.getPattern(ctx, this, true);
14438
      var inv = ctx.mozCurrentTransformInverse;
14439

14440
      if (inv) {
14441
        var canvas = ctx.canvas;
14442
        var width = canvas.width;
14443
        var height = canvas.height;
14444

14445
        var bl = _util.Util.applyTransform([0, 0], inv);
14446

14447
        var br = _util.Util.applyTransform([0, height], inv);
14448

14449
        var ul = _util.Util.applyTransform([width, 0], inv);
14450

14451
        var ur = _util.Util.applyTransform([width, height], inv);
14452

14453
        var x0 = Math.min(bl[0], br[0], ul[0], ur[0]);
14454
        var y0 = Math.min(bl[1], br[1], ul[1], ur[1]);
14455
        var x1 = Math.max(bl[0], br[0], ul[0], ur[0]);
14456
        var y1 = Math.max(bl[1], br[1], ul[1], ur[1]);
14457
        this.ctx.fillRect(x0, y0, x1 - x0, y1 - y0);
14458
      } else {
14459
        this.ctx.fillRect(-1e10, -1e10, 2e10, 2e10);
14460
      }
14461

14462
      this.restore();
14463
    },
14464
    beginInlineImage: function CanvasGraphics_beginInlineImage() {
14465
      (0, _util.unreachable)("Should not call beginInlineImage");
14466
    },
14467
    beginImageData: function CanvasGraphics_beginImageData() {
14468
      (0, _util.unreachable)("Should not call beginImageData");
14469
    },
14470
    paintFormXObjectBegin: function CanvasGraphics_paintFormXObjectBegin(matrix, bbox) {
14471
      if (!this.contentVisible) {
14472
        return;
14473
      }
14474

14475
      this.save();
14476
      this.baseTransformStack.push(this.baseTransform);
14477

14478
      if (Array.isArray(matrix) && matrix.length === 6) {
14479
        this.transform.apply(this, matrix);
14480
      }
14481

14482
      this.baseTransform = this.ctx.mozCurrentTransform;
14483

14484
      if (bbox) {
14485
        var width = bbox[2] - bbox[0];
14486
        var height = bbox[3] - bbox[1];
14487
        this.ctx.rect(bbox[0], bbox[1], width, height);
14488
        this.clip();
14489
        this.endPath();
14490
      }
14491
    },
14492
    paintFormXObjectEnd: function CanvasGraphics_paintFormXObjectEnd() {
14493
      if (!this.contentVisible) {
14494
        return;
14495
      }
14496

14497
      this.restore();
14498
      this.baseTransform = this.baseTransformStack.pop();
14499
    },
14500
    beginGroup: function CanvasGraphics_beginGroup(group) {
14501
      if (!this.contentVisible) {
14502
        return;
14503
      }
14504

14505
      this.save();
14506
      var currentCtx = this.ctx;
14507

14508
      if (!group.isolated) {
14509
        (0, _util.info)("TODO: Support non-isolated groups.");
14510
      }
14511

14512
      if (group.knockout) {
14513
        (0, _util.warn)("Knockout groups not supported.");
14514
      }
14515

14516
      var currentTransform = currentCtx.mozCurrentTransform;
14517

14518
      if (group.matrix) {
14519
        currentCtx.transform.apply(currentCtx, group.matrix);
14520
      }
14521

14522
      if (!group.bbox) {
14523
        throw new Error("Bounding box is required.");
14524
      }
14525

14526
      var bounds = _util.Util.getAxialAlignedBoundingBox(group.bbox, currentCtx.mozCurrentTransform);
14527

14528
      var canvasBounds = [0, 0, currentCtx.canvas.width, currentCtx.canvas.height];
14529
      bounds = _util.Util.intersect(bounds, canvasBounds) || [0, 0, 0, 0];
14530
      var offsetX = Math.floor(bounds[0]);
14531
      var offsetY = Math.floor(bounds[1]);
14532
      var drawnWidth = Math.max(Math.ceil(bounds[2]) - offsetX, 1);
14533
      var drawnHeight = Math.max(Math.ceil(bounds[3]) - offsetY, 1);
14534
      var scaleX = 1,
14535
          scaleY = 1;
14536

14537
      if (drawnWidth > MAX_GROUP_SIZE) {
14538
        scaleX = drawnWidth / MAX_GROUP_SIZE;
14539
        drawnWidth = MAX_GROUP_SIZE;
14540
      }
14541

14542
      if (drawnHeight > MAX_GROUP_SIZE) {
14543
        scaleY = drawnHeight / MAX_GROUP_SIZE;
14544
        drawnHeight = MAX_GROUP_SIZE;
14545
      }
14546

14547
      var cacheId = "groupAt" + this.groupLevel;
14548

14549
      if (group.smask) {
14550
        cacheId += "_smask_" + this.smaskCounter++ % 2;
14551
      }
14552

14553
      var scratchCanvas = this.cachedCanvases.getCanvas(cacheId, drawnWidth, drawnHeight, true);
14554
      var groupCtx = scratchCanvas.context;
14555
      groupCtx.scale(1 / scaleX, 1 / scaleY);
14556
      groupCtx.translate(-offsetX, -offsetY);
14557
      groupCtx.transform.apply(groupCtx, currentTransform);
14558

14559
      if (group.smask) {
14560
        this.smaskStack.push({
14561
          canvas: scratchCanvas.canvas,
14562
          context: groupCtx,
14563
          offsetX: offsetX,
14564
          offsetY: offsetY,
14565
          scaleX: scaleX,
14566
          scaleY: scaleY,
14567
          subtype: group.smask.subtype,
14568
          backdrop: group.smask.backdrop,
14569
          transferMap: group.smask.transferMap || null,
14570
          startTransformInverse: null
14571
        });
14572
      } else {
14573
        currentCtx.setTransform(1, 0, 0, 1, 0, 0);
14574
        currentCtx.translate(offsetX, offsetY);
14575
        currentCtx.scale(scaleX, scaleY);
14576
      }
14577

14578
      copyCtxState(currentCtx, groupCtx);
14579
      this.ctx = groupCtx;
14580
      this.setGState([["BM", "source-over"], ["ca", 1], ["CA", 1]]);
14581
      this.groupStack.push(currentCtx);
14582
      this.groupLevel++;
14583
      this.current.activeSMask = null;
14584
    },
14585
    endGroup: function CanvasGraphics_endGroup(group) {
14586
      if (!this.contentVisible) {
14587
        return;
14588
      }
14589

14590
      this.groupLevel--;
14591
      var groupCtx = this.ctx;
14592
      this.ctx = this.groupStack.pop();
14593

14594
      if (this.ctx.imageSmoothingEnabled !== undefined) {
14595
        this.ctx.imageSmoothingEnabled = false;
14596
      } else {
14597
        this.ctx.mozImageSmoothingEnabled = false;
14598
      }
14599

14600
      if (group.smask) {
14601
        this.tempSMask = this.smaskStack.pop();
14602
      } else {
14603
        this.ctx.drawImage(groupCtx.canvas, 0, 0);
14604
      }
14605

14606
      this.restore();
14607
    },
14608
    beginAnnotations: function CanvasGraphics_beginAnnotations() {
14609
      this.save();
14610

14611
      if (this.baseTransform) {
14612
        this.ctx.setTransform.apply(this.ctx, this.baseTransform);
14613
      }
14614
    },
14615
    endAnnotations: function CanvasGraphics_endAnnotations() {
14616
      this.restore();
14617
    },
14618
    beginAnnotation: function CanvasGraphics_beginAnnotation(rect, transform, matrix) {
14619
      this.save();
14620
      resetCtxToDefault(this.ctx);
14621
      this.current = new CanvasExtraState();
14622

14623
      if (Array.isArray(rect) && rect.length === 4) {
14624
        var width = rect[2] - rect[0];
14625
        var height = rect[3] - rect[1];
14626
        this.ctx.rect(rect[0], rect[1], width, height);
14627
        this.clip();
14628
        this.endPath();
14629
      }
14630

14631
      this.transform.apply(this, transform);
14632
      this.transform.apply(this, matrix);
14633
    },
14634
    endAnnotation: function CanvasGraphics_endAnnotation() {
14635
      this.restore();
14636
    },
14637
    paintImageMaskXObject: function CanvasGraphics_paintImageMaskXObject(img) {
14638
      if (!this.contentVisible) {
14639
        return;
14640
      }
14641

14642
      var ctx = this.ctx;
14643
      var width = img.width,
14644
          height = img.height;
14645
      var fillColor = this.current.fillColor;
14646
      var isPatternFill = this.current.patternFill;
14647
      var glyph = this.processingType3;
14648

14649
      if (COMPILE_TYPE3_GLYPHS && glyph && glyph.compiled === undefined) {
14650
        if (width <= MAX_SIZE_TO_COMPILE && height <= MAX_SIZE_TO_COMPILE) {
14651
          glyph.compiled = compileType3Glyph({
14652
            data: img.data,
14653
            width: width,
14654
            height: height
14655
          });
14656
        } else {
14657
          glyph.compiled = null;
14658
        }
14659
      }
14660

14661
      if (glyph !== null && glyph !== void 0 && glyph.compiled) {
14662
        glyph.compiled(ctx);
14663
        return;
14664
      }
14665

14666
      var maskCanvas = this.cachedCanvases.getCanvas("maskCanvas", width, height);
14667
      var maskCtx = maskCanvas.context;
14668
      maskCtx.save();
14669
      putBinaryImageMask(maskCtx, img);
14670
      maskCtx.globalCompositeOperation = "source-in";
14671
      maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
14672
      maskCtx.fillRect(0, 0, width, height);
14673
      maskCtx.restore();
14674
      this.paintInlineImageXObject(maskCanvas.canvas);
14675
    },
14676
    paintImageMaskXObjectRepeat: function paintImageMaskXObjectRepeat(imgData, scaleX) {
14677
      var skewX = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
14678
      var skewY = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
14679
      var scaleY = arguments.length > 4 ? arguments[4] : undefined;
14680
      var positions = arguments.length > 5 ? arguments[5] : undefined;
14681

14682
      if (!this.contentVisible) {
14683
        return;
14684
      }
14685

14686
      var width = imgData.width;
14687
      var height = imgData.height;
14688
      var fillColor = this.current.fillColor;
14689
      var isPatternFill = this.current.patternFill;
14690
      var maskCanvas = this.cachedCanvases.getCanvas("maskCanvas", width, height);
14691
      var maskCtx = maskCanvas.context;
14692
      maskCtx.save();
14693
      putBinaryImageMask(maskCtx, imgData);
14694
      maskCtx.globalCompositeOperation = "source-in";
14695
      maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
14696
      maskCtx.fillRect(0, 0, width, height);
14697
      maskCtx.restore();
14698
      var ctx = this.ctx;
14699

14700
      for (var i = 0, ii = positions.length; i < ii; i += 2) {
14701
        ctx.save();
14702
        ctx.transform(scaleX, skewX, skewY, scaleY, positions[i], positions[i + 1]);
14703
        ctx.scale(1, -1);
14704
        ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
14705
        ctx.restore();
14706
      }
14707
    },
14708
    paintImageMaskXObjectGroup: function CanvasGraphics_paintImageMaskXObjectGroup(images) {
14709
      if (!this.contentVisible) {
14710
        return;
14711
      }
14712

14713
      var ctx = this.ctx;
14714
      var fillColor = this.current.fillColor;
14715
      var isPatternFill = this.current.patternFill;
14716

14717
      for (var i = 0, ii = images.length; i < ii; i++) {
14718
        var image = images[i];
14719
        var width = image.width,
14720
            height = image.height;
14721
        var maskCanvas = this.cachedCanvases.getCanvas("maskCanvas", width, height);
14722
        var maskCtx = maskCanvas.context;
14723
        maskCtx.save();
14724
        putBinaryImageMask(maskCtx, image);
14725
        maskCtx.globalCompositeOperation = "source-in";
14726
        maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
14727
        maskCtx.fillRect(0, 0, width, height);
14728
        maskCtx.restore();
14729
        ctx.save();
14730
        ctx.transform.apply(ctx, image.transform);
14731
        ctx.scale(1, -1);
14732
        ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
14733
        ctx.restore();
14734
      }
14735
    },
14736
    paintImageXObject: function CanvasGraphics_paintImageXObject(objId) {
14737
      if (!this.contentVisible) {
14738
        return;
14739
      }
14740

14741
      var imgData = objId.startsWith("g_") ? this.commonObjs.get(objId) : this.objs.get(objId);
14742

14743
      if (!imgData) {
14744
        (0, _util.warn)("Dependent image isn't ready yet");
14745
        return;
14746
      }
14747

14748
      this.paintInlineImageXObject(imgData);
14749
    },
14750
    paintImageXObjectRepeat: function CanvasGraphics_paintImageXObjectRepeat(objId, scaleX, scaleY, positions) {
14751
      if (!this.contentVisible) {
14752
        return;
14753
      }
14754

14755
      var imgData = objId.startsWith("g_") ? this.commonObjs.get(objId) : this.objs.get(objId);
14756

14757
      if (!imgData) {
14758
        (0, _util.warn)("Dependent image isn't ready yet");
14759
        return;
14760
      }
14761

14762
      var width = imgData.width;
14763
      var height = imgData.height;
14764
      var map = [];
14765

14766
      for (var i = 0, ii = positions.length; i < ii; i += 2) {
14767
        map.push({
14768
          transform: [scaleX, 0, 0, scaleY, positions[i], positions[i + 1]],
14769
          x: 0,
14770
          y: 0,
14771
          w: width,
14772
          h: height
14773
        });
14774
      }
14775

14776
      this.paintInlineImageXObjectGroup(imgData, map);
14777
    },
14778
    paintInlineImageXObject: function CanvasGraphics_paintInlineImageXObject(imgData) {
14779
      if (!this.contentVisible) {
14780
        return;
14781
      }
14782

14783
      var width = imgData.width;
14784
      var height = imgData.height;
14785
      var ctx = this.ctx;
14786
      this.save();
14787
      ctx.scale(1 / width, -1 / height);
14788
      var currentTransform = ctx.mozCurrentTransformInverse;
14789
      var widthScale = Math.max(Math.hypot(currentTransform[0], currentTransform[1]), 1);
14790
      var heightScale = Math.max(Math.hypot(currentTransform[2], currentTransform[3]), 1);
14791
      var imgToPaint, tmpCanvas, tmpCtx;
14792

14793
      if (typeof HTMLElement === "function" && imgData instanceof HTMLElement || !imgData.data) {
14794
        imgToPaint = imgData;
14795
      } else {
14796
        tmpCanvas = this.cachedCanvases.getCanvas("inlineImage", width, height);
14797
        tmpCtx = tmpCanvas.context;
14798
        putBinaryImageData(tmpCtx, imgData, this.current.transferMaps);
14799
        imgToPaint = tmpCanvas.canvas;
14800
      }
14801

14802
      var paintWidth = width,
14803
          paintHeight = height;
14804
      var tmpCanvasId = "prescale1";
14805

14806
      while (widthScale > 2 && paintWidth > 1 || heightScale > 2 && paintHeight > 1) {
14807
        var newWidth = paintWidth,
14808
            newHeight = paintHeight;
14809

14810
        if (widthScale > 2 && paintWidth > 1) {
14811
          newWidth = Math.ceil(paintWidth / 2);
14812
          widthScale /= paintWidth / newWidth;
14813
        }
14814

14815
        if (heightScale > 2 && paintHeight > 1) {
14816
          newHeight = Math.ceil(paintHeight / 2);
14817
          heightScale /= paintHeight / newHeight;
14818
        }
14819

14820
        tmpCanvas = this.cachedCanvases.getCanvas(tmpCanvasId, newWidth, newHeight);
14821
        tmpCtx = tmpCanvas.context;
14822
        tmpCtx.clearRect(0, 0, newWidth, newHeight);
14823
        tmpCtx.drawImage(imgToPaint, 0, 0, paintWidth, paintHeight, 0, 0, newWidth, newHeight);
14824
        imgToPaint = tmpCanvas.canvas;
14825
        paintWidth = newWidth;
14826
        paintHeight = newHeight;
14827
        tmpCanvasId = tmpCanvasId === "prescale1" ? "prescale2" : "prescale1";
14828
      }
14829

14830
      ctx.drawImage(imgToPaint, 0, 0, paintWidth, paintHeight, 0, -height, width, height);
14831

14832
      if (this.imageLayer) {
14833
        var position = this.getCanvasPosition(0, -height);
14834
        this.imageLayer.appendImage({
14835
          imgData: imgData,
14836
          left: position[0],
14837
          top: position[1],
14838
          width: width / currentTransform[0],
14839
          height: height / currentTransform[3]
14840
        });
14841
      }
14842

14843
      this.restore();
14844
    },
14845
    paintInlineImageXObjectGroup: function CanvasGraphics_paintInlineImageXObjectGroup(imgData, map) {
14846
      if (!this.contentVisible) {
14847
        return;
14848
      }
14849

14850
      var ctx = this.ctx;
14851
      var w = imgData.width;
14852
      var h = imgData.height;
14853
      var tmpCanvas = this.cachedCanvases.getCanvas("inlineImage", w, h);
14854
      var tmpCtx = tmpCanvas.context;
14855
      putBinaryImageData(tmpCtx, imgData, this.current.transferMaps);
14856

14857
      for (var i = 0, ii = map.length; i < ii; i++) {
14858
        var entry = map[i];
14859
        ctx.save();
14860
        ctx.transform.apply(ctx, entry.transform);
14861
        ctx.scale(1, -1);
14862
        ctx.drawImage(tmpCanvas.canvas, entry.x, entry.y, entry.w, entry.h, 0, -1, 1, 1);
14863

14864
        if (this.imageLayer) {
14865
          var position = this.getCanvasPosition(entry.x, entry.y);
14866
          this.imageLayer.appendImage({
14867
            imgData: imgData,
14868
            left: position[0],
14869
            top: position[1],
14870
            width: w,
14871
            height: h
14872
          });
14873
        }
14874

14875
        ctx.restore();
14876
      }
14877
    },
14878
    paintSolidColorImageMask: function CanvasGraphics_paintSolidColorImageMask() {
14879
      if (!this.contentVisible) {
14880
        return;
14881
      }
14882

14883
      this.ctx.fillRect(0, 0, 1, 1);
14884
    },
14885
    markPoint: function CanvasGraphics_markPoint(tag) {},
14886
    markPointProps: function CanvasGraphics_markPointProps(tag, properties) {},
14887
    beginMarkedContent: function CanvasGraphics_beginMarkedContent(tag) {
14888
      this.markedContentStack.push({
14889
        visible: true
14890
      });
14891
    },
14892
    beginMarkedContentProps: function CanvasGraphics_beginMarkedContentProps(tag, properties) {
14893
      if (tag === "OC") {
14894
        this.markedContentStack.push({
14895
          visible: this.optionalContentConfig.isVisible(properties)
14896
        });
14897
      } else {
14898
        this.markedContentStack.push({
14899
          visible: true
14900
        });
14901
      }
14902

14903
      this.contentVisible = this.isContentVisible();
14904
    },
14905
    endMarkedContent: function CanvasGraphics_endMarkedContent() {
14906
      this.markedContentStack.pop();
14907
      this.contentVisible = this.isContentVisible();
14908
    },
14909
    beginCompat: function CanvasGraphics_beginCompat() {},
14910
    endCompat: function CanvasGraphics_endCompat() {},
14911
    consumePath: function CanvasGraphics_consumePath() {
14912
      var ctx = this.ctx;
14913

14914
      if (this.pendingClip) {
14915
        if (this.pendingClip === EO_CLIP) {
14916
          ctx.clip("evenodd");
14917
        } else {
14918
          ctx.clip();
14919
        }
14920

14921
        this.pendingClip = null;
14922
      }
14923

14924
      ctx.beginPath();
14925
    },
14926
    getSinglePixelWidth: function getSinglePixelWidth() {
14927
      if (this._cachedGetSinglePixelWidth === null) {
14928
        var m = this.ctx.mozCurrentTransform;
14929
        var absDet = Math.abs(m[0] * m[3] - m[2] * m[1]);
14930
        var sqNorm1 = Math.pow(m[0], 2) + Math.pow(m[2], 2);
14931
        var sqNorm2 = Math.pow(m[1], 2) + Math.pow(m[3], 2);
14932
        var pixelHeight = Math.sqrt(Math.max(sqNorm1, sqNorm2)) / absDet;
14933

14934
        if (sqNorm1 !== sqNorm2 && this._combinedScaleFactor * pixelHeight > 1) {
14935
          this._cachedGetSinglePixelWidth = -(this._combinedScaleFactor * pixelHeight);
14936
        } else if (absDet > Number.EPSILON) {
14937
          this._cachedGetSinglePixelWidth = pixelHeight;
14938
        } else {
14939
          this._cachedGetSinglePixelWidth = 1;
14940
        }
14941
      }
14942

14943
      return this._cachedGetSinglePixelWidth;
14944
    },
14945
    getCanvasPosition: function CanvasGraphics_getCanvasPosition(x, y) {
14946
      var transform = this.ctx.mozCurrentTransform;
14947
      return [transform[0] * x + transform[2] * y + transform[4], transform[1] * x + transform[3] * y + transform[5]];
14948
    },
14949
    isContentVisible: function CanvasGraphics_isContentVisible() {
14950
      for (var i = this.markedContentStack.length - 1; i >= 0; i--) {
14951
        if (!this.markedContentStack[i].visible) {
14952
          return false;
14953
        }
14954
      }
14955

14956
      return true;
14957
    }
14958
  };
14959

14960
  for (var op in _util.OPS) {
14961
    CanvasGraphics.prototype[_util.OPS[op]] = CanvasGraphics.prototype[op];
14962
  }
14963

14964
  return CanvasGraphics;
14965
}();
14966

14967
exports.CanvasGraphics = CanvasGraphics;
14968

14969
/***/ }),
14970
/* 131 */
14971
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
14972

14973
"use strict";
14974

14975

14976
Object.defineProperty(exports, "__esModule", ({
14977
  value: true
14978
}));
14979
exports.getShadingPatternFromIR = getShadingPatternFromIR;
14980
exports.TilingPattern = void 0;
14981

14982
var _util = __w_pdfjs_require__(4);
14983

14984
var ShadingIRs = {};
14985

14986
function applyBoundingBox(ctx, bbox) {
14987
  if (!bbox || typeof Path2D === "undefined") {
14988
    return;
14989
  }
14990

14991
  var width = bbox[2] - bbox[0];
14992
  var height = bbox[3] - bbox[1];
14993
  var region = new Path2D();
14994
  region.rect(bbox[0], bbox[1], width, height);
14995
  ctx.clip(region);
14996
}
14997

14998
ShadingIRs.RadialAxial = {
14999
  fromIR: function RadialAxial_fromIR(raw) {
15000
    var type = raw[1];
15001
    var bbox = raw[2];
15002
    var colorStops = raw[3];
15003
    var p0 = raw[4];
15004
    var p1 = raw[5];
15005
    var r0 = raw[6];
15006
    var r1 = raw[7];
15007
    return {
15008
      getPattern: function RadialAxial_getPattern(ctx) {
15009
        applyBoundingBox(ctx, bbox);
15010
        var grad;
15011

15012
        if (type === "axial") {
15013
          grad = ctx.createLinearGradient(p0[0], p0[1], p1[0], p1[1]);
15014
        } else if (type === "radial") {
15015
          grad = ctx.createRadialGradient(p0[0], p0[1], r0, p1[0], p1[1], r1);
15016
        }
15017

15018
        for (var i = 0, ii = colorStops.length; i < ii; ++i) {
15019
          var c = colorStops[i];
15020
          grad.addColorStop(c[0], c[1]);
15021
        }
15022

15023
        return grad;
15024
      }
15025
    };
15026
  }
15027
};
15028

15029
var createMeshCanvas = function createMeshCanvasClosure() {
15030
  function drawTriangle(data, context, p1, p2, p3, c1, c2, c3) {
15031
    var coords = context.coords,
15032
        colors = context.colors;
15033
    var bytes = data.data,
15034
        rowSize = data.width * 4;
15035
    var tmp;
15036

15037
    if (coords[p1 + 1] > coords[p2 + 1]) {
15038
      tmp = p1;
15039
      p1 = p2;
15040
      p2 = tmp;
15041
      tmp = c1;
15042
      c1 = c2;
15043
      c2 = tmp;
15044
    }
15045

15046
    if (coords[p2 + 1] > coords[p3 + 1]) {
15047
      tmp = p2;
15048
      p2 = p3;
15049
      p3 = tmp;
15050
      tmp = c2;
15051
      c2 = c3;
15052
      c3 = tmp;
15053
    }
15054

15055
    if (coords[p1 + 1] > coords[p2 + 1]) {
15056
      tmp = p1;
15057
      p1 = p2;
15058
      p2 = tmp;
15059
      tmp = c1;
15060
      c1 = c2;
15061
      c2 = tmp;
15062
    }
15063

15064
    var x1 = (coords[p1] + context.offsetX) * context.scaleX;
15065
    var y1 = (coords[p1 + 1] + context.offsetY) * context.scaleY;
15066
    var x2 = (coords[p2] + context.offsetX) * context.scaleX;
15067
    var y2 = (coords[p2 + 1] + context.offsetY) * context.scaleY;
15068
    var x3 = (coords[p3] + context.offsetX) * context.scaleX;
15069
    var y3 = (coords[p3 + 1] + context.offsetY) * context.scaleY;
15070

15071
    if (y1 >= y3) {
15072
      return;
15073
    }
15074

15075
    var c1r = colors[c1],
15076
        c1g = colors[c1 + 1],
15077
        c1b = colors[c1 + 2];
15078
    var c2r = colors[c2],
15079
        c2g = colors[c2 + 1],
15080
        c2b = colors[c2 + 2];
15081
    var c3r = colors[c3],
15082
        c3g = colors[c3 + 1],
15083
        c3b = colors[c3 + 2];
15084
    var minY = Math.round(y1),
15085
        maxY = Math.round(y3);
15086
    var xa, car, cag, cab;
15087
    var xb, cbr, cbg, cbb;
15088

15089
    for (var y = minY; y <= maxY; y++) {
15090
      if (y < y2) {
15091
        var _k = void 0;
15092

15093
        if (y < y1) {
15094
          _k = 0;
15095
        } else if (y1 === y2) {
15096
          _k = 1;
15097
        } else {
15098
          _k = (y1 - y) / (y1 - y2);
15099
        }
15100

15101
        xa = x1 - (x1 - x2) * _k;
15102
        car = c1r - (c1r - c2r) * _k;
15103
        cag = c1g - (c1g - c2g) * _k;
15104
        cab = c1b - (c1b - c2b) * _k;
15105
      } else {
15106
        var _k2 = void 0;
15107

15108
        if (y > y3) {
15109
          _k2 = 1;
15110
        } else if (y2 === y3) {
15111
          _k2 = 0;
15112
        } else {
15113
          _k2 = (y2 - y) / (y2 - y3);
15114
        }
15115

15116
        xa = x2 - (x2 - x3) * _k2;
15117
        car = c2r - (c2r - c3r) * _k2;
15118
        cag = c2g - (c2g - c3g) * _k2;
15119
        cab = c2b - (c2b - c3b) * _k2;
15120
      }
15121

15122
      var k = void 0;
15123

15124
      if (y < y1) {
15125
        k = 0;
15126
      } else if (y > y3) {
15127
        k = 1;
15128
      } else {
15129
        k = (y1 - y) / (y1 - y3);
15130
      }
15131

15132
      xb = x1 - (x1 - x3) * k;
15133
      cbr = c1r - (c1r - c3r) * k;
15134
      cbg = c1g - (c1g - c3g) * k;
15135
      cbb = c1b - (c1b - c3b) * k;
15136
      var x1_ = Math.round(Math.min(xa, xb));
15137
      var x2_ = Math.round(Math.max(xa, xb));
15138
      var j = rowSize * y + x1_ * 4;
15139

15140
      for (var x = x1_; x <= x2_; x++) {
15141
        k = (xa - x) / (xa - xb);
15142

15143
        if (k < 0) {
15144
          k = 0;
15145
        } else if (k > 1) {
15146
          k = 1;
15147
        }
15148

15149
        bytes[j++] = car - (car - cbr) * k | 0;
15150
        bytes[j++] = cag - (cag - cbg) * k | 0;
15151
        bytes[j++] = cab - (cab - cbb) * k | 0;
15152
        bytes[j++] = 255;
15153
      }
15154
    }
15155
  }
15156

15157
  function drawFigure(data, figure, context) {
15158
    var ps = figure.coords;
15159
    var cs = figure.colors;
15160
    var i, ii;
15161

15162
    switch (figure.type) {
15163
      case "lattice":
15164
        var verticesPerRow = figure.verticesPerRow;
15165
        var rows = Math.floor(ps.length / verticesPerRow) - 1;
15166
        var cols = verticesPerRow - 1;
15167

15168
        for (i = 0; i < rows; i++) {
15169
          var q = i * verticesPerRow;
15170

15171
          for (var j = 0; j < cols; j++, q++) {
15172
            drawTriangle(data, context, ps[q], ps[q + 1], ps[q + verticesPerRow], cs[q], cs[q + 1], cs[q + verticesPerRow]);
15173
            drawTriangle(data, context, ps[q + verticesPerRow + 1], ps[q + 1], ps[q + verticesPerRow], cs[q + verticesPerRow + 1], cs[q + 1], cs[q + verticesPerRow]);
15174
          }
15175
        }
15176

15177
        break;
15178

15179
      case "triangles":
15180
        for (i = 0, ii = ps.length; i < ii; i += 3) {
15181
          drawTriangle(data, context, ps[i], ps[i + 1], ps[i + 2], cs[i], cs[i + 1], cs[i + 2]);
15182
        }
15183

15184
        break;
15185

15186
      default:
15187
        throw new Error("illegal figure");
15188
    }
15189
  }
15190

15191
  function createMeshCanvas(bounds, combinesScale, coords, colors, figures, backgroundColor, cachedCanvases, webGLContext) {
15192
    var EXPECTED_SCALE = 1.1;
15193
    var MAX_PATTERN_SIZE = 3000;
15194
    var BORDER_SIZE = 2;
15195
    var offsetX = Math.floor(bounds[0]);
15196
    var offsetY = Math.floor(bounds[1]);
15197
    var boundsWidth = Math.ceil(bounds[2]) - offsetX;
15198
    var boundsHeight = Math.ceil(bounds[3]) - offsetY;
15199
    var width = Math.min(Math.ceil(Math.abs(boundsWidth * combinesScale[0] * EXPECTED_SCALE)), MAX_PATTERN_SIZE);
15200
    var height = Math.min(Math.ceil(Math.abs(boundsHeight * combinesScale[1] * EXPECTED_SCALE)), MAX_PATTERN_SIZE);
15201
    var scaleX = boundsWidth / width;
15202
    var scaleY = boundsHeight / height;
15203
    var context = {
15204
      coords: coords,
15205
      colors: colors,
15206
      offsetX: -offsetX,
15207
      offsetY: -offsetY,
15208
      scaleX: 1 / scaleX,
15209
      scaleY: 1 / scaleY
15210
    };
15211
    var paddedWidth = width + BORDER_SIZE * 2;
15212
    var paddedHeight = height + BORDER_SIZE * 2;
15213
    var canvas, tmpCanvas, i, ii;
15214

15215
    if (webGLContext.isEnabled) {
15216
      canvas = webGLContext.drawFigures({
15217
        width: width,
15218
        height: height,
15219
        backgroundColor: backgroundColor,
15220
        figures: figures,
15221
        context: context
15222
      });
15223
      tmpCanvas = cachedCanvases.getCanvas("mesh", paddedWidth, paddedHeight, false);
15224
      tmpCanvas.context.drawImage(canvas, BORDER_SIZE, BORDER_SIZE);
15225
      canvas = tmpCanvas.canvas;
15226
    } else {
15227
      tmpCanvas = cachedCanvases.getCanvas("mesh", paddedWidth, paddedHeight, false);
15228
      var tmpCtx = tmpCanvas.context;
15229
      var data = tmpCtx.createImageData(width, height);
15230

15231
      if (backgroundColor) {
15232
        var bytes = data.data;
15233

15234
        for (i = 0, ii = bytes.length; i < ii; i += 4) {
15235
          bytes[i] = backgroundColor[0];
15236
          bytes[i + 1] = backgroundColor[1];
15237
          bytes[i + 2] = backgroundColor[2];
15238
          bytes[i + 3] = 255;
15239
        }
15240
      }
15241

15242
      for (i = 0; i < figures.length; i++) {
15243
        drawFigure(data, figures[i], context);
15244
      }
15245

15246
      tmpCtx.putImageData(data, BORDER_SIZE, BORDER_SIZE);
15247
      canvas = tmpCanvas.canvas;
15248
    }
15249

15250
    return {
15251
      canvas: canvas,
15252
      offsetX: offsetX - BORDER_SIZE * scaleX,
15253
      offsetY: offsetY - BORDER_SIZE * scaleY,
15254
      scaleX: scaleX,
15255
      scaleY: scaleY
15256
    };
15257
  }
15258

15259
  return createMeshCanvas;
15260
}();
15261

15262
ShadingIRs.Mesh = {
15263
  fromIR: function Mesh_fromIR(raw) {
15264
    var coords = raw[2];
15265
    var colors = raw[3];
15266
    var figures = raw[4];
15267
    var bounds = raw[5];
15268
    var matrix = raw[6];
15269
    var bbox = raw[7];
15270
    var background = raw[8];
15271
    return {
15272
      getPattern: function Mesh_getPattern(ctx, owner, shadingFill) {
15273
        applyBoundingBox(ctx, bbox);
15274
        var scale;
15275

15276
        if (shadingFill) {
15277
          scale = _util.Util.singularValueDecompose2dScale(ctx.mozCurrentTransform);
15278
        } else {
15279
          scale = _util.Util.singularValueDecompose2dScale(owner.baseTransform);
15280

15281
          if (matrix) {
15282
            var matrixScale = _util.Util.singularValueDecompose2dScale(matrix);
15283

15284
            scale = [scale[0] * matrixScale[0], scale[1] * matrixScale[1]];
15285
          }
15286
        }
15287

15288
        var temporaryPatternCanvas = createMeshCanvas(bounds, scale, coords, colors, figures, shadingFill ? null : background, owner.cachedCanvases, owner.webGLContext);
15289

15290
        if (!shadingFill) {
15291
          ctx.setTransform.apply(ctx, owner.baseTransform);
15292

15293
          if (matrix) {
15294
            ctx.transform.apply(ctx, matrix);
15295
          }
15296
        }
15297

15298
        ctx.translate(temporaryPatternCanvas.offsetX, temporaryPatternCanvas.offsetY);
15299
        ctx.scale(temporaryPatternCanvas.scaleX, temporaryPatternCanvas.scaleY);
15300
        return ctx.createPattern(temporaryPatternCanvas.canvas, "no-repeat");
15301
      }
15302
    };
15303
  }
15304
};
15305
ShadingIRs.Dummy = {
15306
  fromIR: function Dummy_fromIR() {
15307
    return {
15308
      getPattern: function Dummy_fromIR_getPattern() {
15309
        return "hotpink";
15310
      }
15311
    };
15312
  }
15313
};
15314

15315
function getShadingPatternFromIR(raw) {
15316
  var shadingIR = ShadingIRs[raw[0]];
15317

15318
  if (!shadingIR) {
15319
    throw new Error("Unknown IR type: ".concat(raw[0]));
15320
  }
15321

15322
  return shadingIR.fromIR(raw);
15323
}
15324

15325
var TilingPattern = function TilingPatternClosure() {
15326
  var PaintType = {
15327
    COLORED: 1,
15328
    UNCOLORED: 2
15329
  };
15330
  var MAX_PATTERN_SIZE = 3000;
15331

15332
  function TilingPattern(IR, color, ctx, canvasGraphicsFactory, baseTransform) {
15333
    this.operatorList = IR[2];
15334
    this.matrix = IR[3] || [1, 0, 0, 1, 0, 0];
15335
    this.bbox = IR[4];
15336
    this.xstep = IR[5];
15337
    this.ystep = IR[6];
15338
    this.paintType = IR[7];
15339
    this.tilingType = IR[8];
15340
    this.color = color;
15341
    this.canvasGraphicsFactory = canvasGraphicsFactory;
15342
    this.baseTransform = baseTransform;
15343
    this.ctx = ctx;
15344
  }
15345

15346
  TilingPattern.prototype = {
15347
    createPatternCanvas: function TilinPattern_createPatternCanvas(owner) {
15348
      var operatorList = this.operatorList;
15349
      var bbox = this.bbox;
15350
      var xstep = this.xstep;
15351
      var ystep = this.ystep;
15352
      var paintType = this.paintType;
15353
      var tilingType = this.tilingType;
15354
      var color = this.color;
15355
      var canvasGraphicsFactory = this.canvasGraphicsFactory;
15356
      (0, _util.info)("TilingType: " + tilingType);
15357
      var x0 = bbox[0],
15358
          y0 = bbox[1],
15359
          x1 = bbox[2],
15360
          y1 = bbox[3];
15361

15362
      var matrixScale = _util.Util.singularValueDecompose2dScale(this.matrix);
15363

15364
      var curMatrixScale = _util.Util.singularValueDecompose2dScale(this.baseTransform);
15365

15366
      var combinedScale = [matrixScale[0] * curMatrixScale[0], matrixScale[1] * curMatrixScale[1]];
15367
      var dimx = this.getSizeAndScale(xstep, this.ctx.canvas.width, combinedScale[0]);
15368
      var dimy = this.getSizeAndScale(ystep, this.ctx.canvas.height, combinedScale[1]);
15369
      var tmpCanvas = owner.cachedCanvases.getCanvas("pattern", dimx.size, dimy.size, true);
15370
      var tmpCtx = tmpCanvas.context;
15371
      var graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx);
15372
      graphics.groupLevel = owner.groupLevel;
15373
      this.setFillAndStrokeStyleToContext(graphics, paintType, color);
15374
      graphics.transform(dimx.scale, 0, 0, dimy.scale, 0, 0);
15375
      graphics.transform(1, 0, 0, 1, -x0, -y0);
15376
      this.clipBbox(graphics, bbox, x0, y0, x1, y1);
15377
      graphics.executeOperatorList(operatorList);
15378
      this.ctx.transform(1, 0, 0, 1, x0, y0);
15379
      this.ctx.scale(1 / dimx.scale, 1 / dimy.scale);
15380
      return tmpCanvas.canvas;
15381
    },
15382
    getSizeAndScale: function TilingPattern_getSizeAndScale(step, realOutputSize, scale) {
15383
      step = Math.abs(step);
15384
      var maxSize = Math.max(MAX_PATTERN_SIZE, realOutputSize);
15385
      var size = Math.ceil(step * scale);
15386

15387
      if (size >= maxSize) {
15388
        size = maxSize;
15389
      } else {
15390
        scale = size / step;
15391
      }
15392

15393
      return {
15394
        scale: scale,
15395
        size: size
15396
      };
15397
    },
15398
    clipBbox: function clipBbox(graphics, bbox, x0, y0, x1, y1) {
15399
      if (Array.isArray(bbox) && bbox.length === 4) {
15400
        var bboxWidth = x1 - x0;
15401
        var bboxHeight = y1 - y0;
15402
        graphics.ctx.rect(x0, y0, bboxWidth, bboxHeight);
15403
        graphics.clip();
15404
        graphics.endPath();
15405
      }
15406
    },
15407
    setFillAndStrokeStyleToContext: function setFillAndStrokeStyleToContext(graphics, paintType, color) {
15408
      var context = graphics.ctx,
15409
          current = graphics.current;
15410

15411
      switch (paintType) {
15412
        case PaintType.COLORED:
15413
          var ctx = this.ctx;
15414
          context.fillStyle = ctx.fillStyle;
15415
          context.strokeStyle = ctx.strokeStyle;
15416
          current.fillColor = ctx.fillStyle;
15417
          current.strokeColor = ctx.strokeStyle;
15418
          break;
15419

15420
        case PaintType.UNCOLORED:
15421
          var cssColor = _util.Util.makeHexColor(color[0], color[1], color[2]);
15422

15423
          context.fillStyle = cssColor;
15424
          context.strokeStyle = cssColor;
15425
          current.fillColor = cssColor;
15426
          current.strokeColor = cssColor;
15427
          break;
15428

15429
        default:
15430
          throw new _util.FormatError("Unsupported paint type: ".concat(paintType));
15431
      }
15432
    },
15433
    getPattern: function TilingPattern_getPattern(ctx, owner) {
15434
      ctx = this.ctx;
15435
      ctx.setTransform.apply(ctx, this.baseTransform);
15436
      ctx.transform.apply(ctx, this.matrix);
15437
      var temporaryPatternCanvas = this.createPatternCanvas(owner);
15438
      return ctx.createPattern(temporaryPatternCanvas, "repeat");
15439
    }
15440
  };
15441
  return TilingPattern;
15442
}();
15443

15444
exports.TilingPattern = TilingPattern;
15445

15446
/***/ }),
15447
/* 132 */
15448
/***/ ((__unused_webpack_module, exports) => {
15449

15450
"use strict";
15451

15452

15453
Object.defineProperty(exports, "__esModule", ({
15454
  value: true
15455
}));
15456
exports.GlobalWorkerOptions = void 0;
15457
var GlobalWorkerOptions = Object.create(null);
15458
exports.GlobalWorkerOptions = GlobalWorkerOptions;
15459
GlobalWorkerOptions.workerPort = GlobalWorkerOptions.workerPort === undefined ? null : GlobalWorkerOptions.workerPort;
15460
GlobalWorkerOptions.workerSrc = GlobalWorkerOptions.workerSrc === undefined ? "" : GlobalWorkerOptions.workerSrc;
15461

15462
/***/ }),
15463
/* 133 */
15464
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
15465

15466
"use strict";
15467

15468

15469
Object.defineProperty(exports, "__esModule", ({
15470
  value: true
15471
}));
15472
exports.MessageHandler = void 0;
15473

15474
var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
15475

15476
var _util = __w_pdfjs_require__(4);
15477

15478
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
15479

15480
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
15481

15482
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
15483

15484
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
15485

15486
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
15487

15488
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
15489

15490
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
15491

15492
var CallbackKind = {
15493
  UNKNOWN: 0,
15494
  DATA: 1,
15495
  ERROR: 2
15496
};
15497
var StreamKind = {
15498
  UNKNOWN: 0,
15499
  CANCEL: 1,
15500
  CANCEL_COMPLETE: 2,
15501
  CLOSE: 3,
15502
  ENQUEUE: 4,
15503
  ERROR: 5,
15504
  PULL: 6,
15505
  PULL_COMPLETE: 7,
15506
  START_COMPLETE: 8
15507
};
15508

15509
function wrapReason(reason) {
15510
  if (_typeof(reason) !== "object" || reason === null) {
15511
    return reason;
15512
  }
15513

15514
  switch (reason.name) {
15515
    case "AbortException":
15516
      return new _util.AbortException(reason.message);
15517

15518
    case "MissingPDFException":
15519
      return new _util.MissingPDFException(reason.message);
15520

15521
    case "UnexpectedResponseException":
15522
      return new _util.UnexpectedResponseException(reason.message, reason.status);
15523

15524
    case "UnknownErrorException":
15525
      return new _util.UnknownErrorException(reason.message, reason.details);
15526

15527
    default:
15528
      return new _util.UnknownErrorException(reason.message, reason.toString());
15529
  }
15530
}
15531

15532
var MessageHandler = /*#__PURE__*/function () {
15533
  function MessageHandler(sourceName, targetName, comObj) {
15534
    var _this = this;
15535

15536
    _classCallCheck(this, MessageHandler);
15537

15538
    this.sourceName = sourceName;
15539
    this.targetName = targetName;
15540
    this.comObj = comObj;
15541
    this.callbackId = 1;
15542
    this.streamId = 1;
15543
    this.postMessageTransfers = true;
15544
    this.streamSinks = Object.create(null);
15545
    this.streamControllers = Object.create(null);
15546
    this.callbackCapabilities = Object.create(null);
15547
    this.actionHandler = Object.create(null);
15548

15549
    this._onComObjOnMessage = function (event) {
15550
      var data = event.data;
15551

15552
      if (data.targetName !== _this.sourceName) {
15553
        return;
15554
      }
15555

15556
      if (data.stream) {
15557
        _this._processStreamMessage(data);
15558

15559
        return;
15560
      }
15561

15562
      if (data.callback) {
15563
        var callbackId = data.callbackId;
15564
        var capability = _this.callbackCapabilities[callbackId];
15565

15566
        if (!capability) {
15567
          throw new Error("Cannot resolve callback ".concat(callbackId));
15568
        }
15569

15570
        delete _this.callbackCapabilities[callbackId];
15571

15572
        if (data.callback === CallbackKind.DATA) {
15573
          capability.resolve(data.data);
15574
        } else if (data.callback === CallbackKind.ERROR) {
15575
          capability.reject(wrapReason(data.reason));
15576
        } else {
15577
          throw new Error("Unexpected callback case");
15578
        }
15579

15580
        return;
15581
      }
15582

15583
      var action = _this.actionHandler[data.action];
15584

15585
      if (!action) {
15586
        throw new Error("Unknown action from worker: ".concat(data.action));
15587
      }
15588

15589
      if (data.callbackId) {
15590
        var cbSourceName = _this.sourceName;
15591
        var cbTargetName = data.sourceName;
15592
        new Promise(function (resolve) {
15593
          resolve(action(data.data));
15594
        }).then(function (result) {
15595
          comObj.postMessage({
15596
            sourceName: cbSourceName,
15597
            targetName: cbTargetName,
15598
            callback: CallbackKind.DATA,
15599
            callbackId: data.callbackId,
15600
            data: result
15601
          });
15602
        }, function (reason) {
15603
          comObj.postMessage({
15604
            sourceName: cbSourceName,
15605
            targetName: cbTargetName,
15606
            callback: CallbackKind.ERROR,
15607
            callbackId: data.callbackId,
15608
            reason: wrapReason(reason)
15609
          });
15610
        });
15611
        return;
15612
      }
15613

15614
      if (data.streamId) {
15615
        _this._createStreamSink(data);
15616

15617
        return;
15618
      }
15619

15620
      action(data.data);
15621
    };
15622

15623
    comObj.addEventListener("message", this._onComObjOnMessage);
15624
  }
15625

15626
  _createClass(MessageHandler, [{
15627
    key: "on",
15628
    value: function on(actionName, handler) {
15629
      var ah = this.actionHandler;
15630

15631
      if (ah[actionName]) {
15632
        throw new Error("There is already an actionName called \"".concat(actionName, "\""));
15633
      }
15634

15635
      ah[actionName] = handler;
15636
    }
15637
  }, {
15638
    key: "send",
15639
    value: function send(actionName, data, transfers) {
15640
      this._postMessage({
15641
        sourceName: this.sourceName,
15642
        targetName: this.targetName,
15643
        action: actionName,
15644
        data: data
15645
      }, transfers);
15646
    }
15647
  }, {
15648
    key: "sendWithPromise",
15649
    value: function sendWithPromise(actionName, data, transfers) {
15650
      var callbackId = this.callbackId++;
15651
      var capability = (0, _util.createPromiseCapability)();
15652
      this.callbackCapabilities[callbackId] = capability;
15653

15654
      try {
15655
        this._postMessage({
15656
          sourceName: this.sourceName,
15657
          targetName: this.targetName,
15658
          action: actionName,
15659
          callbackId: callbackId,
15660
          data: data
15661
        }, transfers);
15662
      } catch (ex) {
15663
        capability.reject(ex);
15664
      }
15665

15666
      return capability.promise;
15667
    }
15668
  }, {
15669
    key: "sendWithStream",
15670
    value: function sendWithStream(actionName, data, queueingStrategy, transfers) {
15671
      var _this2 = this;
15672

15673
      var streamId = this.streamId++;
15674
      var sourceName = this.sourceName;
15675
      var targetName = this.targetName;
15676
      var comObj = this.comObj;
15677
      return new ReadableStream({
15678
        start: function start(controller) {
15679
          var startCapability = (0, _util.createPromiseCapability)();
15680
          _this2.streamControllers[streamId] = {
15681
            controller: controller,
15682
            startCall: startCapability,
15683
            pullCall: null,
15684
            cancelCall: null,
15685
            isClosed: false
15686
          };
15687

15688
          _this2._postMessage({
15689
            sourceName: sourceName,
15690
            targetName: targetName,
15691
            action: actionName,
15692
            streamId: streamId,
15693
            data: data,
15694
            desiredSize: controller.desiredSize
15695
          }, transfers);
15696

15697
          return startCapability.promise;
15698
        },
15699
        pull: function pull(controller) {
15700
          var pullCapability = (0, _util.createPromiseCapability)();
15701
          _this2.streamControllers[streamId].pullCall = pullCapability;
15702
          comObj.postMessage({
15703
            sourceName: sourceName,
15704
            targetName: targetName,
15705
            stream: StreamKind.PULL,
15706
            streamId: streamId,
15707
            desiredSize: controller.desiredSize
15708
          });
15709
          return pullCapability.promise;
15710
        },
15711
        cancel: function cancel(reason) {
15712
          (0, _util.assert)(reason instanceof Error, "cancel must have a valid reason");
15713
          var cancelCapability = (0, _util.createPromiseCapability)();
15714
          _this2.streamControllers[streamId].cancelCall = cancelCapability;
15715
          _this2.streamControllers[streamId].isClosed = true;
15716
          comObj.postMessage({
15717
            sourceName: sourceName,
15718
            targetName: targetName,
15719
            stream: StreamKind.CANCEL,
15720
            streamId: streamId,
15721
            reason: wrapReason(reason)
15722
          });
15723
          return cancelCapability.promise;
15724
        }
15725
      }, queueingStrategy);
15726
    }
15727
  }, {
15728
    key: "_createStreamSink",
15729
    value: function _createStreamSink(data) {
15730
      var self = this;
15731
      var action = this.actionHandler[data.action];
15732
      var streamId = data.streamId;
15733
      var sourceName = this.sourceName;
15734
      var targetName = data.sourceName;
15735
      var comObj = this.comObj;
15736
      var streamSink = {
15737
        enqueue: function enqueue(chunk) {
15738
          var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
15739
          var transfers = arguments.length > 2 ? arguments[2] : undefined;
15740

15741
          if (this.isCancelled) {
15742
            return;
15743
          }
15744

15745
          var lastDesiredSize = this.desiredSize;
15746
          this.desiredSize -= size;
15747

15748
          if (lastDesiredSize > 0 && this.desiredSize <= 0) {
15749
            this.sinkCapability = (0, _util.createPromiseCapability)();
15750
            this.ready = this.sinkCapability.promise;
15751
          }
15752

15753
          self._postMessage({
15754
            sourceName: sourceName,
15755
            targetName: targetName,
15756
            stream: StreamKind.ENQUEUE,
15757
            streamId: streamId,
15758
            chunk: chunk
15759
          }, transfers);
15760
        },
15761
        close: function close() {
15762
          if (this.isCancelled) {
15763
            return;
15764
          }
15765

15766
          this.isCancelled = true;
15767
          comObj.postMessage({
15768
            sourceName: sourceName,
15769
            targetName: targetName,
15770
            stream: StreamKind.CLOSE,
15771
            streamId: streamId
15772
          });
15773
          delete self.streamSinks[streamId];
15774
        },
15775
        error: function error(reason) {
15776
          (0, _util.assert)(reason instanceof Error, "error must have a valid reason");
15777

15778
          if (this.isCancelled) {
15779
            return;
15780
          }
15781

15782
          this.isCancelled = true;
15783
          comObj.postMessage({
15784
            sourceName: sourceName,
15785
            targetName: targetName,
15786
            stream: StreamKind.ERROR,
15787
            streamId: streamId,
15788
            reason: wrapReason(reason)
15789
          });
15790
        },
15791
        sinkCapability: (0, _util.createPromiseCapability)(),
15792
        onPull: null,
15793
        onCancel: null,
15794
        isCancelled: false,
15795
        desiredSize: data.desiredSize,
15796
        ready: null
15797
      };
15798
      streamSink.sinkCapability.resolve();
15799
      streamSink.ready = streamSink.sinkCapability.promise;
15800
      this.streamSinks[streamId] = streamSink;
15801
      new Promise(function (resolve) {
15802
        resolve(action(data.data, streamSink));
15803
      }).then(function () {
15804
        comObj.postMessage({
15805
          sourceName: sourceName,
15806
          targetName: targetName,
15807
          stream: StreamKind.START_COMPLETE,
15808
          streamId: streamId,
15809
          success: true
15810
        });
15811
      }, function (reason) {
15812
        comObj.postMessage({
15813
          sourceName: sourceName,
15814
          targetName: targetName,
15815
          stream: StreamKind.START_COMPLETE,
15816
          streamId: streamId,
15817
          reason: wrapReason(reason)
15818
        });
15819
      });
15820
    }
15821
  }, {
15822
    key: "_processStreamMessage",
15823
    value: function _processStreamMessage(data) {
15824
      var streamId = data.streamId;
15825
      var sourceName = this.sourceName;
15826
      var targetName = data.sourceName;
15827
      var comObj = this.comObj;
15828

15829
      switch (data.stream) {
15830
        case StreamKind.START_COMPLETE:
15831
          if (data.success) {
15832
            this.streamControllers[streamId].startCall.resolve();
15833
          } else {
15834
            this.streamControllers[streamId].startCall.reject(wrapReason(data.reason));
15835
          }
15836

15837
          break;
15838

15839
        case StreamKind.PULL_COMPLETE:
15840
          if (data.success) {
15841
            this.streamControllers[streamId].pullCall.resolve();
15842
          } else {
15843
            this.streamControllers[streamId].pullCall.reject(wrapReason(data.reason));
15844
          }
15845

15846
          break;
15847

15848
        case StreamKind.PULL:
15849
          if (!this.streamSinks[streamId]) {
15850
            comObj.postMessage({
15851
              sourceName: sourceName,
15852
              targetName: targetName,
15853
              stream: StreamKind.PULL_COMPLETE,
15854
              streamId: streamId,
15855
              success: true
15856
            });
15857
            break;
15858
          }
15859

15860
          if (this.streamSinks[streamId].desiredSize <= 0 && data.desiredSize > 0) {
15861
            this.streamSinks[streamId].sinkCapability.resolve();
15862
          }
15863

15864
          this.streamSinks[streamId].desiredSize = data.desiredSize;
15865
          var onPull = this.streamSinks[data.streamId].onPull;
15866
          new Promise(function (resolve) {
15867
            resolve(onPull && onPull());
15868
          }).then(function () {
15869
            comObj.postMessage({
15870
              sourceName: sourceName,
15871
              targetName: targetName,
15872
              stream: StreamKind.PULL_COMPLETE,
15873
              streamId: streamId,
15874
              success: true
15875
            });
15876
          }, function (reason) {
15877
            comObj.postMessage({
15878
              sourceName: sourceName,
15879
              targetName: targetName,
15880
              stream: StreamKind.PULL_COMPLETE,
15881
              streamId: streamId,
15882
              reason: wrapReason(reason)
15883
            });
15884
          });
15885
          break;
15886

15887
        case StreamKind.ENQUEUE:
15888
          (0, _util.assert)(this.streamControllers[streamId], "enqueue should have stream controller");
15889

15890
          if (this.streamControllers[streamId].isClosed) {
15891
            break;
15892
          }
15893

15894
          this.streamControllers[streamId].controller.enqueue(data.chunk);
15895
          break;
15896

15897
        case StreamKind.CLOSE:
15898
          (0, _util.assert)(this.streamControllers[streamId], "close should have stream controller");
15899

15900
          if (this.streamControllers[streamId].isClosed) {
15901
            break;
15902
          }
15903

15904
          this.streamControllers[streamId].isClosed = true;
15905
          this.streamControllers[streamId].controller.close();
15906

15907
          this._deleteStreamController(streamId);
15908

15909
          break;
15910

15911
        case StreamKind.ERROR:
15912
          (0, _util.assert)(this.streamControllers[streamId], "error should have stream controller");
15913
          this.streamControllers[streamId].controller.error(wrapReason(data.reason));
15914

15915
          this._deleteStreamController(streamId);
15916

15917
          break;
15918

15919
        case StreamKind.CANCEL_COMPLETE:
15920
          if (data.success) {
15921
            this.streamControllers[streamId].cancelCall.resolve();
15922
          } else {
15923
            this.streamControllers[streamId].cancelCall.reject(wrapReason(data.reason));
15924
          }
15925

15926
          this._deleteStreamController(streamId);
15927

15928
          break;
15929

15930
        case StreamKind.CANCEL:
15931
          if (!this.streamSinks[streamId]) {
15932
            break;
15933
          }
15934

15935
          var onCancel = this.streamSinks[data.streamId].onCancel;
15936
          new Promise(function (resolve) {
15937
            resolve(onCancel && onCancel(wrapReason(data.reason)));
15938
          }).then(function () {
15939
            comObj.postMessage({
15940
              sourceName: sourceName,
15941
              targetName: targetName,
15942
              stream: StreamKind.CANCEL_COMPLETE,
15943
              streamId: streamId,
15944
              success: true
15945
            });
15946
          }, function (reason) {
15947
            comObj.postMessage({
15948
              sourceName: sourceName,
15949
              targetName: targetName,
15950
              stream: StreamKind.CANCEL_COMPLETE,
15951
              streamId: streamId,
15952
              reason: wrapReason(reason)
15953
            });
15954
          });
15955
          this.streamSinks[streamId].sinkCapability.reject(wrapReason(data.reason));
15956
          this.streamSinks[streamId].isCancelled = true;
15957
          delete this.streamSinks[streamId];
15958
          break;
15959

15960
        default:
15961
          throw new Error("Unexpected stream case");
15962
      }
15963
    }
15964
  }, {
15965
    key: "_deleteStreamController",
15966
    value: function () {
15967
      var _deleteStreamController2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee(streamId) {
15968
        return _regenerator["default"].wrap(function _callee$(_context) {
15969
          while (1) {
15970
            switch (_context.prev = _context.next) {
15971
              case 0:
15972
                _context.next = 2;
15973
                return Promise.allSettled([this.streamControllers[streamId].startCall, this.streamControllers[streamId].pullCall, this.streamControllers[streamId].cancelCall].map(function (capability) {
15974
                  return capability && capability.promise;
15975
                }));
15976

15977
              case 2:
15978
                delete this.streamControllers[streamId];
15979

15980
              case 3:
15981
              case "end":
15982
                return _context.stop();
15983
            }
15984
          }
15985
        }, _callee, this);
15986
      }));
15987

15988
      function _deleteStreamController(_x) {
15989
        return _deleteStreamController2.apply(this, arguments);
15990
      }
15991

15992
      return _deleteStreamController;
15993
    }()
15994
  }, {
15995
    key: "_postMessage",
15996
    value: function _postMessage(message, transfers) {
15997
      if (transfers && this.postMessageTransfers) {
15998
        this.comObj.postMessage(message, transfers);
15999
      } else {
16000
        this.comObj.postMessage(message);
16001
      }
16002
    }
16003
  }, {
16004
    key: "destroy",
16005
    value: function destroy() {
16006
      this.comObj.removeEventListener("message", this._onComObjOnMessage);
16007
    }
16008
  }]);
16009

16010
  return MessageHandler;
16011
}();
16012

16013
exports.MessageHandler = MessageHandler;
16014

16015
/***/ }),
16016
/* 134 */
16017
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
16018

16019
"use strict";
16020

16021

16022
Object.defineProperty(exports, "__esModule", ({
16023
  value: true
16024
}));
16025
exports.Metadata = void 0;
16026

16027
var _util = __w_pdfjs_require__(4);
16028

16029
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
16030

16031
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
16032

16033
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
16034

16035
var Metadata = /*#__PURE__*/function () {
16036
  function Metadata(_ref) {
16037
    var parsedData = _ref.parsedData,
16038
        rawData = _ref.rawData;
16039

16040
    _classCallCheck(this, Metadata);
16041

16042
    this._metadataMap = parsedData;
16043
    this._data = rawData;
16044
  }
16045

16046
  _createClass(Metadata, [{
16047
    key: "getRaw",
16048
    value: function getRaw() {
16049
      return this._data;
16050
    }
16051
  }, {
16052
    key: "get",
16053
    value: function get(name) {
16054
      var _this$_metadataMap$ge;
16055

16056
      return (_this$_metadataMap$ge = this._metadataMap.get(name)) !== null && _this$_metadataMap$ge !== void 0 ? _this$_metadataMap$ge : null;
16057
    }
16058
  }, {
16059
    key: "getAll",
16060
    value: function getAll() {
16061
      return (0, _util.objectFromMap)(this._metadataMap);
16062
    }
16063
  }, {
16064
    key: "has",
16065
    value: function has(name) {
16066
      return this._metadataMap.has(name);
16067
    }
16068
  }]);
16069

16070
  return Metadata;
16071
}();
16072

16073
exports.Metadata = Metadata;
16074

16075
/***/ }),
16076
/* 135 */
16077
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
16078

16079
"use strict";
16080

16081

16082
Object.defineProperty(exports, "__esModule", ({
16083
  value: true
16084
}));
16085
exports.OptionalContentConfig = void 0;
16086

16087
var _util = __w_pdfjs_require__(4);
16088

16089
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
16090

16091
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
16092

16093
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
16094

16095
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
16096

16097
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
16098

16099
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
16100

16101
var OptionalContentGroup = function OptionalContentGroup(name, intent) {
16102
  _classCallCheck(this, OptionalContentGroup);
16103

16104
  this.visible = true;
16105
  this.name = name;
16106
  this.intent = intent;
16107
};
16108

16109
var OptionalContentConfig = /*#__PURE__*/function () {
16110
  function OptionalContentConfig(data) {
16111
    _classCallCheck(this, OptionalContentConfig);
16112

16113
    this.name = null;
16114
    this.creator = null;
16115
    this._order = null;
16116
    this._groups = new Map();
16117

16118
    if (data === null) {
16119
      return;
16120
    }
16121

16122
    this.name = data.name;
16123
    this.creator = data.creator;
16124
    this._order = data.order;
16125

16126
    var _iterator = _createForOfIteratorHelper(data.groups),
16127
        _step;
16128

16129
    try {
16130
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
16131
        var _group = _step.value;
16132

16133
        this._groups.set(_group.id, new OptionalContentGroup(_group.name, _group.intent));
16134
      }
16135
    } catch (err) {
16136
      _iterator.e(err);
16137
    } finally {
16138
      _iterator.f();
16139
    }
16140

16141
    if (data.baseState === "OFF") {
16142
      var _iterator2 = _createForOfIteratorHelper(this._groups),
16143
          _step2;
16144

16145
      try {
16146
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
16147
          var group = _step2.value;
16148
          group.visible = false;
16149
        }
16150
      } catch (err) {
16151
        _iterator2.e(err);
16152
      } finally {
16153
        _iterator2.f();
16154
      }
16155
    }
16156

16157
    var _iterator3 = _createForOfIteratorHelper(data.on),
16158
        _step3;
16159

16160
    try {
16161
      for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
16162
        var on = _step3.value;
16163
        this._groups.get(on).visible = true;
16164
      }
16165
    } catch (err) {
16166
      _iterator3.e(err);
16167
    } finally {
16168
      _iterator3.f();
16169
    }
16170

16171
    var _iterator4 = _createForOfIteratorHelper(data.off),
16172
        _step4;
16173

16174
    try {
16175
      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
16176
        var off = _step4.value;
16177
        this._groups.get(off).visible = false;
16178
      }
16179
    } catch (err) {
16180
      _iterator4.e(err);
16181
    } finally {
16182
      _iterator4.f();
16183
    }
16184
  }
16185

16186
  _createClass(OptionalContentConfig, [{
16187
    key: "isVisible",
16188
    value: function isVisible(group) {
16189
      if (group.type === "OCG") {
16190
        if (!this._groups.has(group.id)) {
16191
          (0, _util.warn)("Optional content group not found: ".concat(group.id));
16192
          return true;
16193
        }
16194

16195
        return this._groups.get(group.id).visible;
16196
      } else if (group.type === "OCMD") {
16197
        if (group.expression) {
16198
          (0, _util.warn)("Visibility expression not supported yet.");
16199
        }
16200

16201
        if (!group.policy || group.policy === "AnyOn") {
16202
          var _iterator5 = _createForOfIteratorHelper(group.ids),
16203
              _step5;
16204

16205
          try {
16206
            for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
16207
              var id = _step5.value;
16208

16209
              if (!this._groups.has(id)) {
16210
                (0, _util.warn)("Optional content group not found: ".concat(id));
16211
                return true;
16212
              }
16213

16214
              if (this._groups.get(id).visible) {
16215
                return true;
16216
              }
16217
            }
16218
          } catch (err) {
16219
            _iterator5.e(err);
16220
          } finally {
16221
            _iterator5.f();
16222
          }
16223

16224
          return false;
16225
        } else if (group.policy === "AllOn") {
16226
          var _iterator6 = _createForOfIteratorHelper(group.ids),
16227
              _step6;
16228

16229
          try {
16230
            for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
16231
              var _id = _step6.value;
16232

16233
              if (!this._groups.has(_id)) {
16234
                (0, _util.warn)("Optional content group not found: ".concat(_id));
16235
                return true;
16236
              }
16237

16238
              if (!this._groups.get(_id).visible) {
16239
                return false;
16240
              }
16241
            }
16242
          } catch (err) {
16243
            _iterator6.e(err);
16244
          } finally {
16245
            _iterator6.f();
16246
          }
16247

16248
          return true;
16249
        } else if (group.policy === "AnyOff") {
16250
          var _iterator7 = _createForOfIteratorHelper(group.ids),
16251
              _step7;
16252

16253
          try {
16254
            for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
16255
              var _id2 = _step7.value;
16256

16257
              if (!this._groups.has(_id2)) {
16258
                (0, _util.warn)("Optional content group not found: ".concat(_id2));
16259
                return true;
16260
              }
16261

16262
              if (!this._groups.get(_id2).visible) {
16263
                return true;
16264
              }
16265
            }
16266
          } catch (err) {
16267
            _iterator7.e(err);
16268
          } finally {
16269
            _iterator7.f();
16270
          }
16271

16272
          return false;
16273
        } else if (group.policy === "AllOff") {
16274
          var _iterator8 = _createForOfIteratorHelper(group.ids),
16275
              _step8;
16276

16277
          try {
16278
            for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
16279
              var _id3 = _step8.value;
16280

16281
              if (!this._groups.has(_id3)) {
16282
                (0, _util.warn)("Optional content group not found: ".concat(_id3));
16283
                return true;
16284
              }
16285

16286
              if (this._groups.get(_id3).visible) {
16287
                return false;
16288
              }
16289
            }
16290
          } catch (err) {
16291
            _iterator8.e(err);
16292
          } finally {
16293
            _iterator8.f();
16294
          }
16295

16296
          return true;
16297
        }
16298

16299
        (0, _util.warn)("Unknown optional content policy ".concat(group.policy, "."));
16300
        return true;
16301
      }
16302

16303
      (0, _util.warn)("Unknown group type ".concat(group.type, "."));
16304
      return true;
16305
    }
16306
  }, {
16307
    key: "setVisibility",
16308
    value: function setVisibility(id) {
16309
      var visible = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
16310

16311
      if (!this._groups.has(id)) {
16312
        (0, _util.warn)("Optional content group not found: ".concat(id));
16313
        return;
16314
      }
16315

16316
      this._groups.get(id).visible = !!visible;
16317
    }
16318
  }, {
16319
    key: "getOrder",
16320
    value: function getOrder() {
16321
      if (!this._groups.size) {
16322
        return null;
16323
      }
16324

16325
      if (this._order) {
16326
        return this._order.slice();
16327
      }
16328

16329
      return Array.from(this._groups.keys());
16330
    }
16331
  }, {
16332
    key: "getGroups",
16333
    value: function getGroups() {
16334
      return this._groups.size > 0 ? (0, _util.objectFromMap)(this._groups) : null;
16335
    }
16336
  }, {
16337
    key: "getGroup",
16338
    value: function getGroup(id) {
16339
      return this._groups.get(id) || null;
16340
    }
16341
  }]);
16342

16343
  return OptionalContentConfig;
16344
}();
16345

16346
exports.OptionalContentConfig = OptionalContentConfig;
16347

16348
/***/ }),
16349
/* 136 */
16350
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
16351

16352
"use strict";
16353

16354

16355
Object.defineProperty(exports, "__esModule", ({
16356
  value: true
16357
}));
16358
exports.PDFDataTransportStream = void 0;
16359

16360
var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
16361

16362
var _util = __w_pdfjs_require__(4);
16363

16364
var _display_utils = __w_pdfjs_require__(1);
16365

16366
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
16367

16368
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
16369

16370
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
16371

16372
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
16373

16374
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
16375

16376
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
16377

16378
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
16379

16380
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
16381

16382
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
16383

16384
var PDFDataTransportStream = /*#__PURE__*/function () {
16385
  function PDFDataTransportStream(params, pdfDataRangeTransport) {
16386
    var _this = this;
16387

16388
    _classCallCheck(this, PDFDataTransportStream);
16389

16390
    (0, _util.assert)(pdfDataRangeTransport, 'PDFDataTransportStream - missing required "pdfDataRangeTransport" argument.');
16391
    this._queuedChunks = [];
16392
    this._progressiveDone = params.progressiveDone || false;
16393
    this._contentDispositionFilename = params.contentDispositionFilename || null;
16394
    var initialData = params.initialData;
16395

16396
    if ((initialData === null || initialData === void 0 ? void 0 : initialData.length) > 0) {
16397
      var buffer = new Uint8Array(initialData).buffer;
16398

16399
      this._queuedChunks.push(buffer);
16400
    }
16401

16402
    this._pdfDataRangeTransport = pdfDataRangeTransport;
16403
    this._isStreamingSupported = !params.disableStream;
16404
    this._isRangeSupported = !params.disableRange;
16405
    this._contentLength = params.length;
16406
    this._fullRequestReader = null;
16407
    this._rangeReaders = [];
16408

16409
    this._pdfDataRangeTransport.addRangeListener(function (begin, chunk) {
16410
      _this._onReceiveData({
16411
        begin: begin,
16412
        chunk: chunk
16413
      });
16414
    });
16415

16416
    this._pdfDataRangeTransport.addProgressListener(function (loaded, total) {
16417
      _this._onProgress({
16418
        loaded: loaded,
16419
        total: total
16420
      });
16421
    });
16422

16423
    this._pdfDataRangeTransport.addProgressiveReadListener(function (chunk) {
16424
      _this._onReceiveData({
16425
        chunk: chunk
16426
      });
16427
    });
16428

16429
    this._pdfDataRangeTransport.addProgressiveDoneListener(function () {
16430
      _this._onProgressiveDone();
16431
    });
16432

16433
    this._pdfDataRangeTransport.transportReady();
16434
  }
16435

16436
  _createClass(PDFDataTransportStream, [{
16437
    key: "_onReceiveData",
16438
    value: function _onReceiveData(args) {
16439
      var buffer = new Uint8Array(args.chunk).buffer;
16440

16441
      if (args.begin === undefined) {
16442
        if (this._fullRequestReader) {
16443
          this._fullRequestReader._enqueue(buffer);
16444
        } else {
16445
          this._queuedChunks.push(buffer);
16446
        }
16447
      } else {
16448
        var found = this._rangeReaders.some(function (rangeReader) {
16449
          if (rangeReader._begin !== args.begin) {
16450
            return false;
16451
          }
16452

16453
          rangeReader._enqueue(buffer);
16454

16455
          return true;
16456
        });
16457

16458
        (0, _util.assert)(found, "_onReceiveData - no `PDFDataTransportStreamRangeReader` instance found.");
16459
      }
16460
    }
16461
  }, {
16462
    key: "_progressiveDataLength",
16463
    get: function get() {
16464
      var _this$_fullRequestRea, _this$_fullRequestRea2;
16465

16466
      return (_this$_fullRequestRea = (_this$_fullRequestRea2 = this._fullRequestReader) === null || _this$_fullRequestRea2 === void 0 ? void 0 : _this$_fullRequestRea2._loaded) !== null && _this$_fullRequestRea !== void 0 ? _this$_fullRequestRea : 0;
16467
    }
16468
  }, {
16469
    key: "_onProgress",
16470
    value: function _onProgress(evt) {
16471
      if (evt.total === undefined) {
16472
        var firstReader = this._rangeReaders[0];
16473

16474
        if (firstReader !== null && firstReader !== void 0 && firstReader.onProgress) {
16475
          firstReader.onProgress({
16476
            loaded: evt.loaded
16477
          });
16478
        }
16479
      } else {
16480
        var fullReader = this._fullRequestReader;
16481

16482
        if (fullReader !== null && fullReader !== void 0 && fullReader.onProgress) {
16483
          fullReader.onProgress({
16484
            loaded: evt.loaded,
16485
            total: evt.total
16486
          });
16487
        }
16488
      }
16489
    }
16490
  }, {
16491
    key: "_onProgressiveDone",
16492
    value: function _onProgressiveDone() {
16493
      if (this._fullRequestReader) {
16494
        this._fullRequestReader.progressiveDone();
16495
      }
16496

16497
      this._progressiveDone = true;
16498
    }
16499
  }, {
16500
    key: "_removeRangeReader",
16501
    value: function _removeRangeReader(reader) {
16502
      var i = this._rangeReaders.indexOf(reader);
16503

16504
      if (i >= 0) {
16505
        this._rangeReaders.splice(i, 1);
16506
      }
16507
    }
16508
  }, {
16509
    key: "getFullReader",
16510
    value: function getFullReader() {
16511
      (0, _util.assert)(!this._fullRequestReader, "PDFDataTransportStream.getFullReader can only be called once.");
16512
      var queuedChunks = this._queuedChunks;
16513
      this._queuedChunks = null;
16514
      return new PDFDataTransportStreamReader(this, queuedChunks, this._progressiveDone, this._contentDispositionFilename);
16515
    }
16516
  }, {
16517
    key: "getRangeReader",
16518
    value: function getRangeReader(begin, end) {
16519
      if (end <= this._progressiveDataLength) {
16520
        return null;
16521
      }
16522

16523
      var reader = new PDFDataTransportStreamRangeReader(this, begin, end);
16524

16525
      this._pdfDataRangeTransport.requestDataRange(begin, end);
16526

16527
      this._rangeReaders.push(reader);
16528

16529
      return reader;
16530
    }
16531
  }, {
16532
    key: "cancelAllRequests",
16533
    value: function cancelAllRequests(reason) {
16534
      if (this._fullRequestReader) {
16535
        this._fullRequestReader.cancel(reason);
16536
      }
16537

16538
      var readers = this._rangeReaders.slice(0);
16539

16540
      readers.forEach(function (rangeReader) {
16541
        rangeReader.cancel(reason);
16542
      });
16543

16544
      this._pdfDataRangeTransport.abort();
16545
    }
16546
  }]);
16547

16548
  return PDFDataTransportStream;
16549
}();
16550

16551
exports.PDFDataTransportStream = PDFDataTransportStream;
16552

16553
var PDFDataTransportStreamReader = /*#__PURE__*/function () {
16554
  function PDFDataTransportStreamReader(stream, queuedChunks) {
16555
    var progressiveDone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
16556
    var contentDispositionFilename = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
16557

16558
    _classCallCheck(this, PDFDataTransportStreamReader);
16559

16560
    this._stream = stream;
16561
    this._done = progressiveDone || false;
16562
    this._filename = (0, _display_utils.isPdfFile)(contentDispositionFilename) ? contentDispositionFilename : null;
16563
    this._queuedChunks = queuedChunks || [];
16564
    this._loaded = 0;
16565

16566
    var _iterator = _createForOfIteratorHelper(this._queuedChunks),
16567
        _step;
16568

16569
    try {
16570
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
16571
        var chunk = _step.value;
16572
        this._loaded += chunk.byteLength;
16573
      }
16574
    } catch (err) {
16575
      _iterator.e(err);
16576
    } finally {
16577
      _iterator.f();
16578
    }
16579

16580
    this._requests = [];
16581
    this._headersReady = Promise.resolve();
16582
    stream._fullRequestReader = this;
16583
    this.onProgress = null;
16584
  }
16585

16586
  _createClass(PDFDataTransportStreamReader, [{
16587
    key: "_enqueue",
16588
    value: function _enqueue(chunk) {
16589
      if (this._done) {
16590
        return;
16591
      }
16592

16593
      if (this._requests.length > 0) {
16594
        var requestCapability = this._requests.shift();
16595

16596
        requestCapability.resolve({
16597
          value: chunk,
16598
          done: false
16599
        });
16600
      } else {
16601
        this._queuedChunks.push(chunk);
16602
      }
16603

16604
      this._loaded += chunk.byteLength;
16605
    }
16606
  }, {
16607
    key: "headersReady",
16608
    get: function get() {
16609
      return this._headersReady;
16610
    }
16611
  }, {
16612
    key: "filename",
16613
    get: function get() {
16614
      return this._filename;
16615
    }
16616
  }, {
16617
    key: "isRangeSupported",
16618
    get: function get() {
16619
      return this._stream._isRangeSupported;
16620
    }
16621
  }, {
16622
    key: "isStreamingSupported",
16623
    get: function get() {
16624
      return this._stream._isStreamingSupported;
16625
    }
16626
  }, {
16627
    key: "contentLength",
16628
    get: function get() {
16629
      return this._stream._contentLength;
16630
    }
16631
  }, {
16632
    key: "read",
16633
    value: function () {
16634
      var _read = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
16635
        var chunk, requestCapability;
16636
        return _regenerator["default"].wrap(function _callee$(_context) {
16637
          while (1) {
16638
            switch (_context.prev = _context.next) {
16639
              case 0:
16640
                if (!(this._queuedChunks.length > 0)) {
16641
                  _context.next = 3;
16642
                  break;
16643
                }
16644

16645
                chunk = this._queuedChunks.shift();
16646
                return _context.abrupt("return", {
16647
                  value: chunk,
16648
                  done: false
16649
                });
16650

16651
              case 3:
16652
                if (!this._done) {
16653
                  _context.next = 5;
16654
                  break;
16655
                }
16656

16657
                return _context.abrupt("return", {
16658
                  value: undefined,
16659
                  done: true
16660
                });
16661

16662
              case 5:
16663
                requestCapability = (0, _util.createPromiseCapability)();
16664

16665
                this._requests.push(requestCapability);
16666

16667
                return _context.abrupt("return", requestCapability.promise);
16668

16669
              case 8:
16670
              case "end":
16671
                return _context.stop();
16672
            }
16673
          }
16674
        }, _callee, this);
16675
      }));
16676

16677
      function read() {
16678
        return _read.apply(this, arguments);
16679
      }
16680

16681
      return read;
16682
    }()
16683
  }, {
16684
    key: "cancel",
16685
    value: function cancel(reason) {
16686
      this._done = true;
16687

16688
      this._requests.forEach(function (requestCapability) {
16689
        requestCapability.resolve({
16690
          value: undefined,
16691
          done: true
16692
        });
16693
      });
16694

16695
      this._requests = [];
16696
    }
16697
  }, {
16698
    key: "progressiveDone",
16699
    value: function progressiveDone() {
16700
      if (this._done) {
16701
        return;
16702
      }
16703

16704
      this._done = true;
16705
    }
16706
  }]);
16707

16708
  return PDFDataTransportStreamReader;
16709
}();
16710

16711
var PDFDataTransportStreamRangeReader = /*#__PURE__*/function () {
16712
  function PDFDataTransportStreamRangeReader(stream, begin, end) {
16713
    _classCallCheck(this, PDFDataTransportStreamRangeReader);
16714

16715
    this._stream = stream;
16716
    this._begin = begin;
16717
    this._end = end;
16718
    this._queuedChunk = null;
16719
    this._requests = [];
16720
    this._done = false;
16721
    this.onProgress = null;
16722
  }
16723

16724
  _createClass(PDFDataTransportStreamRangeReader, [{
16725
    key: "_enqueue",
16726
    value: function _enqueue(chunk) {
16727
      if (this._done) {
16728
        return;
16729
      }
16730

16731
      if (this._requests.length === 0) {
16732
        this._queuedChunk = chunk;
16733
      } else {
16734
        var requestsCapability = this._requests.shift();
16735

16736
        requestsCapability.resolve({
16737
          value: chunk,
16738
          done: false
16739
        });
16740

16741
        this._requests.forEach(function (requestCapability) {
16742
          requestCapability.resolve({
16743
            value: undefined,
16744
            done: true
16745
          });
16746
        });
16747

16748
        this._requests = [];
16749
      }
16750

16751
      this._done = true;
16752

16753
      this._stream._removeRangeReader(this);
16754
    }
16755
  }, {
16756
    key: "isStreamingSupported",
16757
    get: function get() {
16758
      return false;
16759
    }
16760
  }, {
16761
    key: "read",
16762
    value: function () {
16763
      var _read2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
16764
        var chunk, requestCapability;
16765
        return _regenerator["default"].wrap(function _callee2$(_context2) {
16766
          while (1) {
16767
            switch (_context2.prev = _context2.next) {
16768
              case 0:
16769
                if (!this._queuedChunk) {
16770
                  _context2.next = 4;
16771
                  break;
16772
                }
16773

16774
                chunk = this._queuedChunk;
16775
                this._queuedChunk = null;
16776
                return _context2.abrupt("return", {
16777
                  value: chunk,
16778
                  done: false
16779
                });
16780

16781
              case 4:
16782
                if (!this._done) {
16783
                  _context2.next = 6;
16784
                  break;
16785
                }
16786

16787
                return _context2.abrupt("return", {
16788
                  value: undefined,
16789
                  done: true
16790
                });
16791

16792
              case 6:
16793
                requestCapability = (0, _util.createPromiseCapability)();
16794

16795
                this._requests.push(requestCapability);
16796

16797
                return _context2.abrupt("return", requestCapability.promise);
16798

16799
              case 9:
16800
              case "end":
16801
                return _context2.stop();
16802
            }
16803
          }
16804
        }, _callee2, this);
16805
      }));
16806

16807
      function read() {
16808
        return _read2.apply(this, arguments);
16809
      }
16810

16811
      return read;
16812
    }()
16813
  }, {
16814
    key: "cancel",
16815
    value: function cancel(reason) {
16816
      this._done = true;
16817

16818
      this._requests.forEach(function (requestCapability) {
16819
        requestCapability.resolve({
16820
          value: undefined,
16821
          done: true
16822
        });
16823
      });
16824

16825
      this._requests = [];
16826

16827
      this._stream._removeRangeReader(this);
16828
    }
16829
  }]);
16830

16831
  return PDFDataTransportStreamRangeReader;
16832
}();
16833

16834
/***/ }),
16835
/* 137 */
16836
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
16837

16838
"use strict";
16839

16840

16841
Object.defineProperty(exports, "__esModule", ({
16842
  value: true
16843
}));
16844
exports.WebGLContext = void 0;
16845

16846
var _util = __w_pdfjs_require__(4);
16847

16848
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
16849

16850
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
16851

16852
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
16853

16854
var WebGLContext = /*#__PURE__*/function () {
16855
  function WebGLContext(_ref) {
16856
    var _ref$enable = _ref.enable,
16857
        enable = _ref$enable === void 0 ? false : _ref$enable;
16858

16859
    _classCallCheck(this, WebGLContext);
16860

16861
    this._enabled = enable === true;
16862
  }
16863

16864
  _createClass(WebGLContext, [{
16865
    key: "isEnabled",
16866
    get: function get() {
16867
      var enabled = this._enabled;
16868

16869
      if (enabled) {
16870
        enabled = WebGLUtils.tryInitGL();
16871
      }
16872

16873
      return (0, _util.shadow)(this, "isEnabled", enabled);
16874
    }
16875
  }, {
16876
    key: "composeSMask",
16877
    value: function composeSMask(_ref2) {
16878
      var layer = _ref2.layer,
16879
          mask = _ref2.mask,
16880
          properties = _ref2.properties;
16881
      return WebGLUtils.composeSMask(layer, mask, properties);
16882
    }
16883
  }, {
16884
    key: "drawFigures",
16885
    value: function drawFigures(_ref3) {
16886
      var width = _ref3.width,
16887
          height = _ref3.height,
16888
          backgroundColor = _ref3.backgroundColor,
16889
          figures = _ref3.figures,
16890
          context = _ref3.context;
16891
      return WebGLUtils.drawFigures(width, height, backgroundColor, figures, context);
16892
    }
16893
  }, {
16894
    key: "clear",
16895
    value: function clear() {
16896
      WebGLUtils.cleanup();
16897
    }
16898
  }]);
16899

16900
  return WebGLContext;
16901
}();
16902

16903
exports.WebGLContext = WebGLContext;
16904

16905
var WebGLUtils = function WebGLUtilsClosure() {
16906
  function loadShader(gl, code, shaderType) {
16907
    var shader = gl.createShader(shaderType);
16908
    gl.shaderSource(shader, code);
16909
    gl.compileShader(shader);
16910
    var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
16911

16912
    if (!compiled) {
16913
      var errorMsg = gl.getShaderInfoLog(shader);
16914
      throw new Error("Error during shader compilation: " + errorMsg);
16915
    }
16916

16917
    return shader;
16918
  }
16919

16920
  function createVertexShader(gl, code) {
16921
    return loadShader(gl, code, gl.VERTEX_SHADER);
16922
  }
16923

16924
  function createFragmentShader(gl, code) {
16925
    return loadShader(gl, code, gl.FRAGMENT_SHADER);
16926
  }
16927

16928
  function createProgram(gl, shaders) {
16929
    var program = gl.createProgram();
16930

16931
    for (var i = 0, ii = shaders.length; i < ii; ++i) {
16932
      gl.attachShader(program, shaders[i]);
16933
    }
16934

16935
    gl.linkProgram(program);
16936
    var linked = gl.getProgramParameter(program, gl.LINK_STATUS);
16937

16938
    if (!linked) {
16939
      var errorMsg = gl.getProgramInfoLog(program);
16940
      throw new Error("Error during program linking: " + errorMsg);
16941
    }
16942

16943
    return program;
16944
  }
16945

16946
  function createTexture(gl, image, textureId) {
16947
    gl.activeTexture(textureId);
16948
    var texture = gl.createTexture();
16949
    gl.bindTexture(gl.TEXTURE_2D, texture);
16950
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
16951
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
16952
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
16953
    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
16954
    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
16955
    return texture;
16956
  }
16957

16958
  var currentGL, currentCanvas;
16959

16960
  function generateGL() {
16961
    if (currentGL) {
16962
      return;
16963
    }
16964

16965
    currentCanvas = document.createElement("canvas");
16966
    currentGL = currentCanvas.getContext("webgl", {
16967
      premultipliedalpha: false
16968
    });
16969
  }
16970

16971
  var smaskVertexShaderCode = "\
16972
  attribute vec2 a_position;                                    \
16973
  attribute vec2 a_texCoord;                                    \
16974
                                                                \
16975
  uniform vec2 u_resolution;                                    \
16976
                                                                \
16977
  varying vec2 v_texCoord;                                      \
16978
                                                                \
16979
  void main() {                                                 \
16980
    vec2 clipSpace = (a_position / u_resolution) * 2.0 - 1.0;   \
16981
    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);          \
16982
                                                                \
16983
    v_texCoord = a_texCoord;                                    \
16984
  }                                                             ";
16985
  var smaskFragmentShaderCode = "\
16986
  precision mediump float;                                      \
16987
                                                                \
16988
  uniform vec4 u_backdrop;                                      \
16989
  uniform int u_subtype;                                        \
16990
  uniform sampler2D u_image;                                    \
16991
  uniform sampler2D u_mask;                                     \
16992
                                                                \
16993
  varying vec2 v_texCoord;                                      \
16994
                                                                \
16995
  void main() {                                                 \
16996
    vec4 imageColor = texture2D(u_image, v_texCoord);           \
16997
    vec4 maskColor = texture2D(u_mask, v_texCoord);             \
16998
    if (u_backdrop.a > 0.0) {                                   \
16999
      maskColor.rgb = maskColor.rgb * maskColor.a +             \
17000
                      u_backdrop.rgb * (1.0 - maskColor.a);     \
17001
    }                                                           \
17002
    float lum;                                                  \
17003
    if (u_subtype == 0) {                                       \
17004
      lum = maskColor.a;                                        \
17005
    } else {                                                    \
17006
      lum = maskColor.r * 0.3 + maskColor.g * 0.59 +            \
17007
            maskColor.b * 0.11;                                 \
17008
    }                                                           \
17009
    imageColor.a *= lum;                                        \
17010
    imageColor.rgb *= imageColor.a;                             \
17011
    gl_FragColor = imageColor;                                  \
17012
  }                                                             ";
17013
  var smaskCache = null;
17014

17015
  function initSmaskGL() {
17016
    generateGL();
17017
    var canvas = currentCanvas;
17018
    currentCanvas = null;
17019
    var gl = currentGL;
17020
    currentGL = null;
17021
    var vertexShader = createVertexShader(gl, smaskVertexShaderCode);
17022
    var fragmentShader = createFragmentShader(gl, smaskFragmentShaderCode);
17023
    var program = createProgram(gl, [vertexShader, fragmentShader]);
17024
    gl.useProgram(program);
17025
    var cache = {};
17026
    cache.gl = gl;
17027
    cache.canvas = canvas;
17028
    cache.resolutionLocation = gl.getUniformLocation(program, "u_resolution");
17029
    cache.positionLocation = gl.getAttribLocation(program, "a_position");
17030
    cache.backdropLocation = gl.getUniformLocation(program, "u_backdrop");
17031
    cache.subtypeLocation = gl.getUniformLocation(program, "u_subtype");
17032
    var texCoordLocation = gl.getAttribLocation(program, "a_texCoord");
17033
    var texLayerLocation = gl.getUniformLocation(program, "u_image");
17034
    var texMaskLocation = gl.getUniformLocation(program, "u_mask");
17035
    var texCoordBuffer = gl.createBuffer();
17036
    gl.bindBuffer(gl.ARRAY_BUFFER, texCoordBuffer);
17037
    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0]), gl.STATIC_DRAW);
17038
    gl.enableVertexAttribArray(texCoordLocation);
17039
    gl.vertexAttribPointer(texCoordLocation, 2, gl.FLOAT, false, 0, 0);
17040
    gl.uniform1i(texLayerLocation, 0);
17041
    gl.uniform1i(texMaskLocation, 1);
17042
    smaskCache = cache;
17043
  }
17044

17045
  function composeSMask(layer, mask, properties) {
17046
    var width = layer.width,
17047
        height = layer.height;
17048

17049
    if (!smaskCache) {
17050
      initSmaskGL();
17051
    }
17052

17053
    var cache = smaskCache,
17054
        canvas = cache.canvas,
17055
        gl = cache.gl;
17056
    canvas.width = width;
17057
    canvas.height = height;
17058
    gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
17059
    gl.uniform2f(cache.resolutionLocation, width, height);
17060

17061
    if (properties.backdrop) {
17062
      gl.uniform4f(cache.resolutionLocation, properties.backdrop[0], properties.backdrop[1], properties.backdrop[2], 1);
17063
    } else {
17064
      gl.uniform4f(cache.resolutionLocation, 0, 0, 0, 0);
17065
    }
17066

17067
    gl.uniform1i(cache.subtypeLocation, properties.subtype === "Luminosity" ? 1 : 0);
17068
    var texture = createTexture(gl, layer, gl.TEXTURE0);
17069
    var maskTexture = createTexture(gl, mask, gl.TEXTURE1);
17070
    var buffer = gl.createBuffer();
17071
    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
17072
    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, width, 0, 0, height, 0, height, width, 0, width, height]), gl.STATIC_DRAW);
17073
    gl.enableVertexAttribArray(cache.positionLocation);
17074
    gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);
17075
    gl.clearColor(0, 0, 0, 0);
17076
    gl.enable(gl.BLEND);
17077
    gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
17078
    gl.clear(gl.COLOR_BUFFER_BIT);
17079
    gl.drawArrays(gl.TRIANGLES, 0, 6);
17080
    gl.flush();
17081
    gl.deleteTexture(texture);
17082
    gl.deleteTexture(maskTexture);
17083
    gl.deleteBuffer(buffer);
17084
    return canvas;
17085
  }
17086

17087
  var figuresVertexShaderCode = "\
17088
  attribute vec2 a_position;                                    \
17089
  attribute vec3 a_color;                                       \
17090
                                                                \
17091
  uniform vec2 u_resolution;                                    \
17092
  uniform vec2 u_scale;                                         \
17093
  uniform vec2 u_offset;                                        \
17094
                                                                \
17095
  varying vec4 v_color;                                         \
17096
                                                                \
17097
  void main() {                                                 \
17098
    vec2 position = (a_position + u_offset) * u_scale;          \
17099
    vec2 clipSpace = (position / u_resolution) * 2.0 - 1.0;     \
17100
    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);          \
17101
                                                                \
17102
    v_color = vec4(a_color / 255.0, 1.0);                       \
17103
  }                                                             ";
17104
  var figuresFragmentShaderCode = "\
17105
  precision mediump float;                                      \
17106
                                                                \
17107
  varying vec4 v_color;                                         \
17108
                                                                \
17109
  void main() {                                                 \
17110
    gl_FragColor = v_color;                                     \
17111
  }                                                             ";
17112
  var figuresCache = null;
17113

17114
  function initFiguresGL() {
17115
    generateGL();
17116
    var canvas = currentCanvas;
17117
    currentCanvas = null;
17118
    var gl = currentGL;
17119
    currentGL = null;
17120
    var vertexShader = createVertexShader(gl, figuresVertexShaderCode);
17121
    var fragmentShader = createFragmentShader(gl, figuresFragmentShaderCode);
17122
    var program = createProgram(gl, [vertexShader, fragmentShader]);
17123
    gl.useProgram(program);
17124
    var cache = {};
17125
    cache.gl = gl;
17126
    cache.canvas = canvas;
17127
    cache.resolutionLocation = gl.getUniformLocation(program, "u_resolution");
17128
    cache.scaleLocation = gl.getUniformLocation(program, "u_scale");
17129
    cache.offsetLocation = gl.getUniformLocation(program, "u_offset");
17130
    cache.positionLocation = gl.getAttribLocation(program, "a_position");
17131
    cache.colorLocation = gl.getAttribLocation(program, "a_color");
17132
    figuresCache = cache;
17133
  }
17134

17135
  function drawFigures(width, height, backgroundColor, figures, context) {
17136
    if (!figuresCache) {
17137
      initFiguresGL();
17138
    }
17139

17140
    var cache = figuresCache,
17141
        canvas = cache.canvas,
17142
        gl = cache.gl;
17143
    canvas.width = width;
17144
    canvas.height = height;
17145
    gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
17146
    gl.uniform2f(cache.resolutionLocation, width, height);
17147
    var count = 0;
17148

17149
    for (var i = 0, ii = figures.length; i < ii; i++) {
17150
      switch (figures[i].type) {
17151
        case "lattice":
17152
          var rows = figures[i].coords.length / figures[i].verticesPerRow | 0;
17153
          count += (rows - 1) * (figures[i].verticesPerRow - 1) * 6;
17154
          break;
17155

17156
        case "triangles":
17157
          count += figures[i].coords.length;
17158
          break;
17159
      }
17160
    }
17161

17162
    var coords = new Float32Array(count * 2);
17163
    var colors = new Uint8Array(count * 3);
17164
    var coordsMap = context.coords,
17165
        colorsMap = context.colors;
17166
    var pIndex = 0,
17167
        cIndex = 0;
17168

17169
    for (var _i = 0, _ii = figures.length; _i < _ii; _i++) {
17170
      var figure = figures[_i],
17171
          ps = figure.coords,
17172
          cs = figure.colors;
17173

17174
      switch (figure.type) {
17175
        case "lattice":
17176
          var cols = figure.verticesPerRow;
17177

17178
          var _rows = ps.length / cols | 0;
17179

17180
          for (var row = 1; row < _rows; row++) {
17181
            var offset = row * cols + 1;
17182

17183
            for (var col = 1; col < cols; col++, offset++) {
17184
              coords[pIndex] = coordsMap[ps[offset - cols - 1]];
17185
              coords[pIndex + 1] = coordsMap[ps[offset - cols - 1] + 1];
17186
              coords[pIndex + 2] = coordsMap[ps[offset - cols]];
17187
              coords[pIndex + 3] = coordsMap[ps[offset - cols] + 1];
17188
              coords[pIndex + 4] = coordsMap[ps[offset - 1]];
17189
              coords[pIndex + 5] = coordsMap[ps[offset - 1] + 1];
17190
              colors[cIndex] = colorsMap[cs[offset - cols - 1]];
17191
              colors[cIndex + 1] = colorsMap[cs[offset - cols - 1] + 1];
17192
              colors[cIndex + 2] = colorsMap[cs[offset - cols - 1] + 2];
17193
              colors[cIndex + 3] = colorsMap[cs[offset - cols]];
17194
              colors[cIndex + 4] = colorsMap[cs[offset - cols] + 1];
17195
              colors[cIndex + 5] = colorsMap[cs[offset - cols] + 2];
17196
              colors[cIndex + 6] = colorsMap[cs[offset - 1]];
17197
              colors[cIndex + 7] = colorsMap[cs[offset - 1] + 1];
17198
              colors[cIndex + 8] = colorsMap[cs[offset - 1] + 2];
17199
              coords[pIndex + 6] = coords[pIndex + 2];
17200
              coords[pIndex + 7] = coords[pIndex + 3];
17201
              coords[pIndex + 8] = coords[pIndex + 4];
17202
              coords[pIndex + 9] = coords[pIndex + 5];
17203
              coords[pIndex + 10] = coordsMap[ps[offset]];
17204
              coords[pIndex + 11] = coordsMap[ps[offset] + 1];
17205
              colors[cIndex + 9] = colors[cIndex + 3];
17206
              colors[cIndex + 10] = colors[cIndex + 4];
17207
              colors[cIndex + 11] = colors[cIndex + 5];
17208
              colors[cIndex + 12] = colors[cIndex + 6];
17209
              colors[cIndex + 13] = colors[cIndex + 7];
17210
              colors[cIndex + 14] = colors[cIndex + 8];
17211
              colors[cIndex + 15] = colorsMap[cs[offset]];
17212
              colors[cIndex + 16] = colorsMap[cs[offset] + 1];
17213
              colors[cIndex + 17] = colorsMap[cs[offset] + 2];
17214
              pIndex += 12;
17215
              cIndex += 18;
17216
            }
17217
          }
17218

17219
          break;
17220

17221
        case "triangles":
17222
          for (var j = 0, jj = ps.length; j < jj; j++) {
17223
            coords[pIndex] = coordsMap[ps[j]];
17224
            coords[pIndex + 1] = coordsMap[ps[j] + 1];
17225
            colors[cIndex] = colorsMap[cs[j]];
17226
            colors[cIndex + 1] = colorsMap[cs[j] + 1];
17227
            colors[cIndex + 2] = colorsMap[cs[j] + 2];
17228
            pIndex += 2;
17229
            cIndex += 3;
17230
          }
17231

17232
          break;
17233
      }
17234
    }
17235

17236
    if (backgroundColor) {
17237
      gl.clearColor(backgroundColor[0] / 255, backgroundColor[1] / 255, backgroundColor[2] / 255, 1.0);
17238
    } else {
17239
      gl.clearColor(0, 0, 0, 0);
17240
    }
17241

17242
    gl.clear(gl.COLOR_BUFFER_BIT);
17243
    var coordsBuffer = gl.createBuffer();
17244
    gl.bindBuffer(gl.ARRAY_BUFFER, coordsBuffer);
17245
    gl.bufferData(gl.ARRAY_BUFFER, coords, gl.STATIC_DRAW);
17246
    gl.enableVertexAttribArray(cache.positionLocation);
17247
    gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);
17248
    var colorsBuffer = gl.createBuffer();
17249
    gl.bindBuffer(gl.ARRAY_BUFFER, colorsBuffer);
17250
    gl.bufferData(gl.ARRAY_BUFFER, colors, gl.STATIC_DRAW);
17251
    gl.enableVertexAttribArray(cache.colorLocation);
17252
    gl.vertexAttribPointer(cache.colorLocation, 3, gl.UNSIGNED_BYTE, false, 0, 0);
17253
    gl.uniform2f(cache.scaleLocation, context.scaleX, context.scaleY);
17254
    gl.uniform2f(cache.offsetLocation, context.offsetX, context.offsetY);
17255
    gl.drawArrays(gl.TRIANGLES, 0, count);
17256
    gl.flush();
17257
    gl.deleteBuffer(coordsBuffer);
17258
    gl.deleteBuffer(colorsBuffer);
17259
    return canvas;
17260
  }
17261

17262
  return {
17263
    tryInitGL: function tryInitGL() {
17264
      try {
17265
        generateGL();
17266
        return !!currentGL;
17267
      } catch (ex) {}
17268

17269
      return false;
17270
    },
17271
    composeSMask: composeSMask,
17272
    drawFigures: drawFigures,
17273
    cleanup: function cleanup() {
17274
      var _smaskCache, _figuresCache;
17275

17276
      if ((_smaskCache = smaskCache) !== null && _smaskCache !== void 0 && _smaskCache.canvas) {
17277
        smaskCache.canvas.width = 0;
17278
        smaskCache.canvas.height = 0;
17279
      }
17280

17281
      if ((_figuresCache = figuresCache) !== null && _figuresCache !== void 0 && _figuresCache.canvas) {
17282
        figuresCache.canvas.width = 0;
17283
        figuresCache.canvas.height = 0;
17284
      }
17285

17286
      smaskCache = null;
17287
      figuresCache = null;
17288
    }
17289
  };
17290
}();
17291

17292
/***/ }),
17293
/* 138 */
17294
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
17295

17296
"use strict";
17297

17298

17299
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
17300

17301
Object.defineProperty(exports, "__esModule", ({
17302
  value: true
17303
}));
17304
exports.AnnotationLayer = void 0;
17305

17306
var _display_utils = __w_pdfjs_require__(1);
17307

17308
var _util = __w_pdfjs_require__(4);
17309

17310
var _annotation_storage = __w_pdfjs_require__(128);
17311

17312
var _scripting_utils = __w_pdfjs_require__(139);
17313

17314
function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
17315

17316
function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
17317

17318
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
17319

17320
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
17321

17322
function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
17323

17324
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
17325

17326
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
17327

17328
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
17329

17330
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
17331

17332
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
17333

17334
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
17335

17336
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
17337

17338
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
17339

17340
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
17341

17342
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
17343

17344
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
17345

17346
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
17347

17348
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
17349

17350
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
17351

17352
var AnnotationElementFactory = /*#__PURE__*/function () {
17353
  function AnnotationElementFactory() {
17354
    _classCallCheck(this, AnnotationElementFactory);
17355
  }
17356

17357
  _createClass(AnnotationElementFactory, null, [{
17358
    key: "create",
17359
    value: function create(parameters) {
17360
      var subtype = parameters.data.annotationType;
17361

17362
      switch (subtype) {
17363
        case _util.AnnotationType.LINK:
17364
          return new LinkAnnotationElement(parameters);
17365

17366
        case _util.AnnotationType.TEXT:
17367
          return new TextAnnotationElement(parameters);
17368

17369
        case _util.AnnotationType.WIDGET:
17370
          var fieldType = parameters.data.fieldType;
17371

17372
          switch (fieldType) {
17373
            case "Tx":
17374
              return new TextWidgetAnnotationElement(parameters);
17375

17376
            case "Btn":
17377
              if (parameters.data.radioButton) {
17378
                return new RadioButtonWidgetAnnotationElement(parameters);
17379
              } else if (parameters.data.checkBox) {
17380
                return new CheckboxWidgetAnnotationElement(parameters);
17381
              }
17382

17383
              return new PushButtonWidgetAnnotationElement(parameters);
17384

17385
            case "Ch":
17386
              return new ChoiceWidgetAnnotationElement(parameters);
17387
          }
17388

17389
          return new WidgetAnnotationElement(parameters);
17390

17391
        case _util.AnnotationType.POPUP:
17392
          return new PopupAnnotationElement(parameters);
17393

17394
        case _util.AnnotationType.FREETEXT:
17395
          return new FreeTextAnnotationElement(parameters);
17396

17397
        case _util.AnnotationType.LINE:
17398
          return new LineAnnotationElement(parameters);
17399

17400
        case _util.AnnotationType.SQUARE:
17401
          return new SquareAnnotationElement(parameters);
17402

17403
        case _util.AnnotationType.CIRCLE:
17404
          return new CircleAnnotationElement(parameters);
17405

17406
        case _util.AnnotationType.POLYLINE:
17407
          return new PolylineAnnotationElement(parameters);
17408

17409
        case _util.AnnotationType.CARET:
17410
          return new CaretAnnotationElement(parameters);
17411

17412
        case _util.AnnotationType.INK:
17413
          return new InkAnnotationElement(parameters);
17414

17415
        case _util.AnnotationType.POLYGON:
17416
          return new PolygonAnnotationElement(parameters);
17417

17418
        case _util.AnnotationType.HIGHLIGHT:
17419
          return new HighlightAnnotationElement(parameters);
17420

17421
        case _util.AnnotationType.UNDERLINE:
17422
          return new UnderlineAnnotationElement(parameters);
17423

17424
        case _util.AnnotationType.SQUIGGLY:
17425
          return new SquigglyAnnotationElement(parameters);
17426

17427
        case _util.AnnotationType.STRIKEOUT:
17428
          return new StrikeOutAnnotationElement(parameters);
17429

17430
        case _util.AnnotationType.STAMP:
17431
          return new StampAnnotationElement(parameters);
17432

17433
        case _util.AnnotationType.FILEATTACHMENT:
17434
          return new FileAttachmentAnnotationElement(parameters);
17435

17436
        default:
17437
          return new AnnotationElement(parameters);
17438
      }
17439
    }
17440
  }]);
17441

17442
  return AnnotationElementFactory;
17443
}();
17444

17445
var AnnotationElement = /*#__PURE__*/function () {
17446
  function AnnotationElement(parameters) {
17447
    var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
17448
        _ref$isRenderable = _ref.isRenderable,
17449
        isRenderable = _ref$isRenderable === void 0 ? false : _ref$isRenderable,
17450
        _ref$ignoreBorder = _ref.ignoreBorder,
17451
        ignoreBorder = _ref$ignoreBorder === void 0 ? false : _ref$ignoreBorder,
17452
        _ref$createQuadrilate = _ref.createQuadrilaterals,
17453
        createQuadrilaterals = _ref$createQuadrilate === void 0 ? false : _ref$createQuadrilate;
17454

17455
    _classCallCheck(this, AnnotationElement);
17456

17457
    this.isRenderable = isRenderable;
17458
    this.data = parameters.data;
17459
    this.layer = parameters.layer;
17460
    this.page = parameters.page;
17461
    this.viewport = parameters.viewport;
17462
    this.linkService = parameters.linkService;
17463
    this.downloadManager = parameters.downloadManager;
17464
    this.imageResourcesPath = parameters.imageResourcesPath;
17465
    this.renderInteractiveForms = parameters.renderInteractiveForms;
17466
    this.svgFactory = parameters.svgFactory;
17467
    this.annotationStorage = parameters.annotationStorage;
17468
    this.enableScripting = parameters.enableScripting;
17469
    this.hasJSActions = parameters.hasJSActions;
17470
    this._mouseState = parameters.mouseState;
17471

17472
    if (isRenderable) {
17473
      this.container = this._createContainer(ignoreBorder);
17474
    }
17475

17476
    if (createQuadrilaterals) {
17477
      this.quadrilaterals = this._createQuadrilaterals(ignoreBorder);
17478
    }
17479
  }
17480

17481
  _createClass(AnnotationElement, [{
17482
    key: "_createContainer",
17483
    value: function _createContainer() {
17484
      var ignoreBorder = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
17485
      var data = this.data,
17486
          page = this.page,
17487
          viewport = this.viewport;
17488
      var container = document.createElement("section");
17489
      var width = data.rect[2] - data.rect[0];
17490
      var height = data.rect[3] - data.rect[1];
17491
      container.setAttribute("data-annotation-id", data.id);
17492

17493
      var rect = _util.Util.normalizeRect([data.rect[0], page.view[3] - data.rect[1] + page.view[1], data.rect[2], page.view[3] - data.rect[3] + page.view[1]]);
17494

17495
      container.style.transform = "matrix(".concat(viewport.transform.join(","), ")");
17496
      container.style.transformOrigin = "".concat(-rect[0], "px ").concat(-rect[1], "px");
17497

17498
      if (!ignoreBorder && data.borderStyle.width > 0) {
17499
        container.style.borderWidth = "".concat(data.borderStyle.width, "px");
17500

17501
        if (data.borderStyle.style !== _util.AnnotationBorderStyleType.UNDERLINE) {
17502
          width = width - 2 * data.borderStyle.width;
17503
          height = height - 2 * data.borderStyle.width;
17504
        }
17505

17506
        var horizontalRadius = data.borderStyle.horizontalCornerRadius;
17507
        var verticalRadius = data.borderStyle.verticalCornerRadius;
17508

17509
        if (horizontalRadius > 0 || verticalRadius > 0) {
17510
          var radius = "".concat(horizontalRadius, "px / ").concat(verticalRadius, "px");
17511
          container.style.borderRadius = radius;
17512
        }
17513

17514
        switch (data.borderStyle.style) {
17515
          case _util.AnnotationBorderStyleType.SOLID:
17516
            container.style.borderStyle = "solid";
17517
            break;
17518

17519
          case _util.AnnotationBorderStyleType.DASHED:
17520
            container.style.borderStyle = "dashed";
17521
            break;
17522

17523
          case _util.AnnotationBorderStyleType.BEVELED:
17524
            (0, _util.warn)("Unimplemented border style: beveled");
17525
            break;
17526

17527
          case _util.AnnotationBorderStyleType.INSET:
17528
            (0, _util.warn)("Unimplemented border style: inset");
17529
            break;
17530

17531
          case _util.AnnotationBorderStyleType.UNDERLINE:
17532
            container.style.borderBottomStyle = "solid";
17533
            break;
17534

17535
          default:
17536
            break;
17537
        }
17538

17539
        if (data.color) {
17540
          container.style.borderColor = _util.Util.makeHexColor(data.color[0] | 0, data.color[1] | 0, data.color[2] | 0);
17541
        } else {
17542
          container.style.borderWidth = 0;
17543
        }
17544
      }
17545

17546
      container.style.left = "".concat(rect[0], "px");
17547
      container.style.top = "".concat(rect[1], "px");
17548
      container.style.width = "".concat(width, "px");
17549
      container.style.height = "".concat(height, "px");
17550
      return container;
17551
    }
17552
  }, {
17553
    key: "_createQuadrilaterals",
17554
    value: function _createQuadrilaterals() {
17555
      var ignoreBorder = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
17556

17557
      if (!this.data.quadPoints) {
17558
        return null;
17559
      }
17560

17561
      var quadrilaterals = [];
17562
      var savedRect = this.data.rect;
17563

17564
      var _iterator = _createForOfIteratorHelper(this.data.quadPoints),
17565
          _step;
17566

17567
      try {
17568
        for (_iterator.s(); !(_step = _iterator.n()).done;) {
17569
          var quadPoint = _step.value;
17570
          this.data.rect = [quadPoint[2].x, quadPoint[2].y, quadPoint[1].x, quadPoint[1].y];
17571
          quadrilaterals.push(this._createContainer(ignoreBorder));
17572
        }
17573
      } catch (err) {
17574
        _iterator.e(err);
17575
      } finally {
17576
        _iterator.f();
17577
      }
17578

17579
      this.data.rect = savedRect;
17580
      return quadrilaterals;
17581
    }
17582
  }, {
17583
    key: "_createPopup",
17584
    value: function _createPopup(trigger, data) {
17585
      var container = this.container;
17586

17587
      if (this.quadrilaterals) {
17588
        trigger = trigger || this.quadrilaterals;
17589
        container = this.quadrilaterals[0];
17590
      }
17591

17592
      if (!trigger) {
17593
        trigger = document.createElement("div");
17594
        trigger.style.height = container.style.height;
17595
        trigger.style.width = container.style.width;
17596
        container.appendChild(trigger);
17597
      }
17598

17599
      var popupElement = new PopupElement({
17600
        container: container,
17601
        trigger: trigger,
17602
        color: data.color,
17603
        title: data.title,
17604
        modificationDate: data.modificationDate,
17605
        contents: data.contents,
17606
        hideWrapper: true
17607
      });
17608
      var popup = popupElement.render();
17609
      popup.style.left = container.style.width;
17610
      container.appendChild(popup);
17611
    }
17612
  }, {
17613
    key: "_renderQuadrilaterals",
17614
    value: function _renderQuadrilaterals(className) {
17615
      this.quadrilaterals.forEach(function (quadrilateral) {
17616
        quadrilateral.className = className;
17617
      });
17618
      return this.quadrilaterals;
17619
    }
17620
  }, {
17621
    key: "render",
17622
    value: function render() {
17623
      (0, _util.unreachable)("Abstract method `AnnotationElement.render` called");
17624
    }
17625
  }]);
17626

17627
  return AnnotationElement;
17628
}();
17629

17630
var LinkAnnotationElement = /*#__PURE__*/function (_AnnotationElement) {
17631
  _inherits(LinkAnnotationElement, _AnnotationElement);
17632

17633
  var _super = _createSuper(LinkAnnotationElement);
17634

17635
  function LinkAnnotationElement(parameters) {
17636
    _classCallCheck(this, LinkAnnotationElement);
17637

17638
    var isRenderable = !!(parameters.data.url || parameters.data.dest || parameters.data.action || parameters.data.isTooltipOnly || parameters.data.actions && (parameters.data.actions.Action || parameters.data.actions["Mouse Up"] || parameters.data.actions["Mouse Down"]));
17639
    return _super.call(this, parameters, {
17640
      isRenderable: isRenderable,
17641
      createQuadrilaterals: true
17642
    });
17643
  }
17644

17645
  _createClass(LinkAnnotationElement, [{
17646
    key: "render",
17647
    value: function render() {
17648
      var data = this.data,
17649
          linkService = this.linkService;
17650
      var link = document.createElement("a");
17651

17652
      if (data.url) {
17653
        (0, _display_utils.addLinkAttributes)(link, {
17654
          url: data.url,
17655
          target: data.newWindow ? _display_utils.LinkTarget.BLANK : linkService.externalLinkTarget,
17656
          rel: linkService.externalLinkRel,
17657
          enabled: linkService.externalLinkEnabled
17658
        });
17659
      } else if (data.action) {
17660
        this._bindNamedAction(link, data.action);
17661
      } else if (data.dest) {
17662
        this._bindLink(link, data.dest);
17663
      } else if (data.actions && (data.actions.Action || data.actions["Mouse Up"] || data.actions["Mouse Down"]) && this.enableScripting && this.hasJSActions) {
17664
        this._bindJSAction(link, data);
17665
      } else {
17666
        this._bindLink(link, "");
17667
      }
17668

17669
      if (this.quadrilaterals) {
17670
        return this._renderQuadrilaterals("linkAnnotation").map(function (quadrilateral, index) {
17671
          var linkElement = index === 0 ? link : link.cloneNode();
17672
          quadrilateral.appendChild(linkElement);
17673
          return quadrilateral;
17674
        });
17675
      }
17676

17677
      this.container.className = "linkAnnotation";
17678
      this.container.appendChild(link);
17679
      return this.container;
17680
    }
17681
  }, {
17682
    key: "_bindLink",
17683
    value: function _bindLink(link, destination) {
17684
      var _this = this;
17685

17686
      link.href = this.linkService.getDestinationHash(destination);
17687

17688
      link.onclick = function () {
17689
        if (destination) {
17690
          _this.linkService.goToDestination(destination);
17691
        }
17692

17693
        return false;
17694
      };
17695

17696
      if (destination || destination === "") {
17697
        link.className = "internalLink";
17698
      }
17699
    }
17700
  }, {
17701
    key: "_bindNamedAction",
17702
    value: function _bindNamedAction(link, action) {
17703
      var _this2 = this;
17704

17705
      link.href = this.linkService.getAnchorUrl("");
17706

17707
      link.onclick = function () {
17708
        _this2.linkService.executeNamedAction(action);
17709

17710
        return false;
17711
      };
17712

17713
      link.className = "internalLink";
17714
    }
17715
  }, {
17716
    key: "_bindJSAction",
17717
    value: function _bindJSAction(link, data) {
17718
      var _this3 = this;
17719

17720
      link.href = this.linkService.getAnchorUrl("");
17721
      var map = new Map([["Action", "onclick"], ["Mouse Up", "onmouseup"], ["Mouse Down", "onmousedown"]]);
17722

17723
      var _loop = function _loop() {
17724
        var name = _Object$keys[_i];
17725
        var jsName = map.get(name);
17726

17727
        if (!jsName) {
17728
          return "continue";
17729
        }
17730

17731
        link[jsName] = function () {
17732
          var _this3$linkService$ev;
17733

17734
          (_this3$linkService$ev = _this3.linkService.eventBus) === null || _this3$linkService$ev === void 0 ? void 0 : _this3$linkService$ev.dispatch("dispatcheventinsandbox", {
17735
            source: _this3,
17736
            detail: {
17737
              id: data.id,
17738
              name: name
17739
            }
17740
          });
17741
          return false;
17742
        };
17743
      };
17744

17745
      for (var _i = 0, _Object$keys = Object.keys(data.actions); _i < _Object$keys.length; _i++) {
17746
        var _ret = _loop();
17747

17748
        if (_ret === "continue") continue;
17749
      }
17750

17751
      link.className = "internalLink";
17752
    }
17753
  }]);
17754

17755
  return LinkAnnotationElement;
17756
}(AnnotationElement);
17757

17758
var TextAnnotationElement = /*#__PURE__*/function (_AnnotationElement2) {
17759
  _inherits(TextAnnotationElement, _AnnotationElement2);
17760

17761
  var _super2 = _createSuper(TextAnnotationElement);
17762

17763
  function TextAnnotationElement(parameters) {
17764
    _classCallCheck(this, TextAnnotationElement);
17765

17766
    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
17767
    return _super2.call(this, parameters, {
17768
      isRenderable: isRenderable
17769
    });
17770
  }
17771

17772
  _createClass(TextAnnotationElement, [{
17773
    key: "render",
17774
    value: function render() {
17775
      this.container.className = "textAnnotation";
17776
      var image = document.createElement("img");
17777
      image.style.height = this.container.style.height;
17778
      image.style.width = this.container.style.width;
17779
      image.src = this.imageResourcesPath + "annotation-" + this.data.name.toLowerCase() + ".svg";
17780
      image.alt = "[{{type}} Annotation]";
17781
      image.dataset.l10nId = "text_annotation_type";
17782
      image.dataset.l10nArgs = JSON.stringify({
17783
        type: this.data.name
17784
      });
17785

17786
      if (!this.data.hasPopup) {
17787
        this._createPopup(image, this.data);
17788
      }
17789

17790
      this.container.appendChild(image);
17791
      return this.container;
17792
    }
17793
  }]);
17794

17795
  return TextAnnotationElement;
17796
}(AnnotationElement);
17797

17798
var WidgetAnnotationElement = /*#__PURE__*/function (_AnnotationElement3) {
17799
  _inherits(WidgetAnnotationElement, _AnnotationElement3);
17800

17801
  var _super3 = _createSuper(WidgetAnnotationElement);
17802

17803
  function WidgetAnnotationElement() {
17804
    _classCallCheck(this, WidgetAnnotationElement);
17805

17806
    return _super3.apply(this, arguments);
17807
  }
17808

17809
  _createClass(WidgetAnnotationElement, [{
17810
    key: "render",
17811
    value: function render() {
17812
      if (this.data.alternativeText) {
17813
        this.container.title = this.data.alternativeText;
17814
      }
17815

17816
      return this.container;
17817
    }
17818
  }, {
17819
    key: "_getKeyModifier",
17820
    value: function _getKeyModifier(event) {
17821
      return navigator.platform.includes("Win") && event.ctrlKey || navigator.platform.includes("Mac") && event.metaKey;
17822
    }
17823
  }, {
17824
    key: "_setEventListener",
17825
    value: function _setEventListener(element, baseName, eventName, valueGetter) {
17826
      var _this4 = this;
17827

17828
      if (baseName.includes("mouse")) {
17829
        element.addEventListener(baseName, function (event) {
17830
          var _this4$linkService$ev;
17831

17832
          (_this4$linkService$ev = _this4.linkService.eventBus) === null || _this4$linkService$ev === void 0 ? void 0 : _this4$linkService$ev.dispatch("dispatcheventinsandbox", {
17833
            source: _this4,
17834
            detail: {
17835
              id: _this4.data.id,
17836
              name: eventName,
17837
              value: valueGetter(event),
17838
              shift: event.shiftKey,
17839
              modifier: _this4._getKeyModifier(event)
17840
            }
17841
          });
17842
        });
17843
      } else {
17844
        element.addEventListener(baseName, function (event) {
17845
          var _this4$linkService$ev2;
17846

17847
          (_this4$linkService$ev2 = _this4.linkService.eventBus) === null || _this4$linkService$ev2 === void 0 ? void 0 : _this4$linkService$ev2.dispatch("dispatcheventinsandbox", {
17848
            source: _this4,
17849
            detail: {
17850
              id: _this4.data.id,
17851
              name: eventName,
17852
              value: event.target.checked
17853
            }
17854
          });
17855
        });
17856
      }
17857
    }
17858
  }, {
17859
    key: "_setEventListeners",
17860
    value: function _setEventListeners(element, names, getter) {
17861
      var _iterator2 = _createForOfIteratorHelper(names),
17862
          _step2;
17863

17864
      try {
17865
        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
17866
          var _this$data$actions;
17867

17868
          var _step2$value = _slicedToArray(_step2.value, 2),
17869
              baseName = _step2$value[0],
17870
              eventName = _step2$value[1];
17871

17872
          if (eventName === "Action" || (_this$data$actions = this.data.actions) !== null && _this$data$actions !== void 0 && _this$data$actions[eventName]) {
17873
            this._setEventListener(element, baseName, eventName, getter);
17874
          }
17875
        }
17876
      } catch (err) {
17877
        _iterator2.e(err);
17878
      } finally {
17879
        _iterator2.f();
17880
      }
17881
    }
17882
  }, {
17883
    key: "_setColor",
17884
    value: function _setColor(event) {
17885
      var detail = event.detail,
17886
          target = event.target;
17887
      var style = target.style;
17888

17889
      for (var _i2 = 0, _arr2 = ["bgColor", "fillColor", "fgColor", "textColor", "borderColor", "strokeColor"]; _i2 < _arr2.length; _i2++) {
17890
        var name = _arr2[_i2];
17891
        var color = detail[name];
17892

17893
        if (!color) {
17894
          continue;
17895
        }
17896

17897
        color = _scripting_utils.ColorConverters["".concat(color[0], "_HTML")](color.slice(1));
17898

17899
        switch (name) {
17900
          case "bgColor":
17901
          case "fillColor":
17902
            style.backgroundColor = color;
17903
            break;
17904

17905
          case "fgColor":
17906
          case "textColor":
17907
            style.color = color;
17908
            break;
17909

17910
          case "borderColor":
17911
          case "strokeColor":
17912
            style.borderColor = color;
17913
            break;
17914
        }
17915
      }
17916
    }
17917
  }]);
17918

17919
  return WidgetAnnotationElement;
17920
}(AnnotationElement);
17921

17922
var TextWidgetAnnotationElement = /*#__PURE__*/function (_WidgetAnnotationElem) {
17923
  _inherits(TextWidgetAnnotationElement, _WidgetAnnotationElem);
17924

17925
  var _super4 = _createSuper(TextWidgetAnnotationElement);
17926

17927
  function TextWidgetAnnotationElement(parameters) {
17928
    _classCallCheck(this, TextWidgetAnnotationElement);
17929

17930
    var isRenderable = parameters.renderInteractiveForms || !parameters.data.hasAppearance && !!parameters.data.fieldValue;
17931
    return _super4.call(this, parameters, {
17932
      isRenderable: isRenderable
17933
    });
17934
  }
17935

17936
  _createClass(TextWidgetAnnotationElement, [{
17937
    key: "render",
17938
    value: function render() {
17939
      var _this5 = this;
17940

17941
      var storage = this.annotationStorage;
17942
      var id = this.data.id;
17943
      this.container.className = "textWidgetAnnotation";
17944
      var element = null;
17945

17946
      if (this.renderInteractiveForms) {
17947
        var storedData = storage.getValue(id, {
17948
          value: this.data.fieldValue,
17949
          valueAsString: this.data.fieldValue
17950
        });
17951
        var textContent = storedData.valueAsString || storedData.value || "";
17952
        var elementData = {
17953
          userValue: null,
17954
          formattedValue: null,
17955
          beforeInputSelectionRange: null,
17956
          beforeInputValue: null
17957
        };
17958

17959
        if (this.data.multiLine) {
17960
          element = document.createElement("textarea");
17961
          element.textContent = textContent;
17962
        } else {
17963
          element = document.createElement("input");
17964
          element.type = "text";
17965
          element.setAttribute("value", textContent);
17966
        }
17967

17968
        elementData.userValue = textContent;
17969
        element.setAttribute("id", id);
17970
        element.addEventListener("input", function (event) {
17971
          storage.setValue(id, {
17972
            value: event.target.value
17973
          });
17974
        });
17975

17976
        var blurListener = function blurListener(event) {
17977
          if (elementData.formattedValue) {
17978
            event.target.value = elementData.formattedValue;
17979
          }
17980

17981
          event.target.setSelectionRange(0, 0);
17982
          elementData.beforeInputSelectionRange = null;
17983
        };
17984

17985
        if (this.enableScripting && this.hasJSActions) {
17986
          var _this$data$actions2;
17987

17988
          element.addEventListener("focus", function (event) {
17989
            if (elementData.userValue) {
17990
              event.target.value = elementData.userValue;
17991
            }
17992
          });
17993
          element.addEventListener("updatefromsandbox", function (event) {
17994
            var detail = event.detail;
17995
            var actions = {
17996
              value: function value() {
17997
                elementData.userValue = detail.value || "";
17998
                storage.setValue(id, {
17999
                  value: elementData.userValue.toString()
18000
                });
18001

18002
                if (!elementData.formattedValue) {
18003
                  event.target.value = elementData.userValue;
18004
                }
18005
              },
18006
              valueAsString: function valueAsString() {
18007
                elementData.formattedValue = detail.valueAsString || "";
18008

18009
                if (event.target !== document.activeElement) {
18010
                  event.target.value = elementData.formattedValue;
18011
                }
18012

18013
                storage.setValue(id, {
18014
                  formattedValue: elementData.formattedValue
18015
                });
18016
              },
18017
              focus: function focus() {
18018
                setTimeout(function () {
18019
                  return event.target.focus({
18020
                    preventScroll: false
18021
                  });
18022
                }, 0);
18023
              },
18024
              userName: function userName() {
18025
                event.target.title = detail.userName;
18026
              },
18027
              hidden: function hidden() {
18028
                event.target.style.visibility = detail.hidden ? "hidden" : "visible";
18029
                storage.setValue(id, {
18030
                  hidden: detail.hidden
18031
                });
18032
              },
18033
              editable: function editable() {
18034
                event.target.disabled = !detail.editable;
18035
              },
18036
              selRange: function selRange() {
18037
                var _detail$selRange = _slicedToArray(detail.selRange, 2),
18038
                    selStart = _detail$selRange[0],
18039
                    selEnd = _detail$selRange[1];
18040

18041
                if (selStart >= 0 && selEnd < event.target.value.length) {
18042
                  event.target.setSelectionRange(selStart, selEnd);
18043
                }
18044
              }
18045
            };
18046
            Object.keys(detail).filter(function (name) {
18047
              return name in actions;
18048
            }).forEach(function (name) {
18049
              return actions[name]();
18050
            });
18051

18052
            _this5._setColor(event);
18053
          });
18054
          element.addEventListener("keydown", function (event) {
18055
            var _this5$linkService$ev;
18056

18057
            elementData.beforeInputValue = event.target.value;
18058
            var commitKey = -1;
18059

18060
            if (event.key === "Escape") {
18061
              commitKey = 0;
18062
            } else if (event.key === "Enter") {
18063
              commitKey = 2;
18064
            } else if (event.key === "Tab") {
18065
              commitKey = 3;
18066
            }
18067

18068
            if (commitKey === -1) {
18069
              return;
18070
            }
18071

18072
            elementData.userValue = event.target.value;
18073
            (_this5$linkService$ev = _this5.linkService.eventBus) === null || _this5$linkService$ev === void 0 ? void 0 : _this5$linkService$ev.dispatch("dispatcheventinsandbox", {
18074
              source: _this5,
18075
              detail: {
18076
                id: id,
18077
                name: "Keystroke",
18078
                value: event.target.value,
18079
                willCommit: true,
18080
                commitKey: commitKey,
18081
                selStart: event.target.selectionStart,
18082
                selEnd: event.target.selectionEnd
18083
              }
18084
            });
18085
          });
18086
          var _blurListener = blurListener;
18087
          blurListener = null;
18088
          element.addEventListener("blur", function (event) {
18089
            if (_this5._mouseState.isDown) {
18090
              var _this5$linkService$ev2;
18091

18092
              elementData.userValue = event.target.value;
18093
              (_this5$linkService$ev2 = _this5.linkService.eventBus) === null || _this5$linkService$ev2 === void 0 ? void 0 : _this5$linkService$ev2.dispatch("dispatcheventinsandbox", {
18094
                source: _this5,
18095
                detail: {
18096
                  id: id,
18097
                  name: "Keystroke",
18098
                  value: event.target.value,
18099
                  willCommit: true,
18100
                  commitKey: 1,
18101
                  selStart: event.target.selectionStart,
18102
                  selEnd: event.target.selectionEnd
18103
                }
18104
              });
18105
            }
18106

18107
            _blurListener(event);
18108
          });
18109
          element.addEventListener("mousedown", function (event) {
18110
            elementData.beforeInputValue = event.target.value;
18111
            elementData.beforeInputSelectionRange = null;
18112
          });
18113
          element.addEventListener("keyup", function (event) {
18114
            if (event.target.selectionStart === event.target.selectionEnd) {
18115
              elementData.beforeInputSelectionRange = null;
18116
            }
18117
          });
18118
          element.addEventListener("select", function (event) {
18119
            elementData.beforeInputSelectionRange = [event.target.selectionStart, event.target.selectionEnd];
18120
          });
18121

18122
          if ((_this$data$actions2 = this.data.actions) !== null && _this$data$actions2 !== void 0 && _this$data$actions2.Keystroke) {
18123
            element.addEventListener("input", function (event) {
18124
              var _this5$linkService$ev3;
18125

18126
              var selStart = -1;
18127
              var selEnd = -1;
18128

18129
              if (elementData.beforeInputSelectionRange) {
18130
                var _elementData$beforeIn = _slicedToArray(elementData.beforeInputSelectionRange, 2);
18131

18132
                selStart = _elementData$beforeIn[0];
18133
                selEnd = _elementData$beforeIn[1];
18134
              }
18135

18136
              (_this5$linkService$ev3 = _this5.linkService.eventBus) === null || _this5$linkService$ev3 === void 0 ? void 0 : _this5$linkService$ev3.dispatch("dispatcheventinsandbox", {
18137
                source: _this5,
18138
                detail: {
18139
                  id: id,
18140
                  name: "Keystroke",
18141
                  value: elementData.beforeInputValue,
18142
                  change: event.data,
18143
                  willCommit: false,
18144
                  selStart: selStart,
18145
                  selEnd: selEnd
18146
                }
18147
              });
18148
            });
18149
          }
18150

18151
          this._setEventListeners(element, [["focus", "Focus"], ["blur", "Blur"], ["mousedown", "Mouse Down"], ["mouseenter", "Mouse Enter"], ["mouseleave", "Mouse Exit"], ["mouseup", "Mouse Up"]], function (event) {
18152
            return event.target.value;
18153
          });
18154
        }
18155

18156
        if (blurListener) {
18157
          element.addEventListener("blur", blurListener);
18158
        }
18159

18160
        element.disabled = this.data.readOnly;
18161
        element.name = this.data.fieldName;
18162

18163
        if (this.data.maxLen !== null) {
18164
          element.maxLength = this.data.maxLen;
18165
        }
18166

18167
        if (this.data.comb) {
18168
          var fieldWidth = this.data.rect[2] - this.data.rect[0];
18169
          var combWidth = fieldWidth / this.data.maxLen;
18170
          element.classList.add("comb");
18171
          element.style.letterSpacing = "calc(".concat(combWidth, "px - 1ch)");
18172
        }
18173
      } else {
18174
        element = document.createElement("div");
18175
        element.textContent = this.data.fieldValue;
18176
        element.style.verticalAlign = "middle";
18177
        element.style.display = "table-cell";
18178
      }
18179

18180
      this._setTextStyle(element);
18181

18182
      this.container.appendChild(element);
18183
      return this.container;
18184
    }
18185
  }, {
18186
    key: "_setTextStyle",
18187
    value: function _setTextStyle(element) {
18188
      var TEXT_ALIGNMENT = ["left", "center", "right"];
18189
      var _this$data$defaultApp = this.data.defaultAppearanceData,
18190
          fontSize = _this$data$defaultApp.fontSize,
18191
          fontColor = _this$data$defaultApp.fontColor;
18192
      var style = element.style;
18193

18194
      if (fontSize) {
18195
        style.fontSize = "".concat(fontSize, "px");
18196
      }
18197

18198
      style.color = _util.Util.makeHexColor(fontColor[0], fontColor[1], fontColor[2]);
18199

18200
      if (this.data.textAlignment !== null) {
18201
        style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment];
18202
      }
18203
    }
18204
  }]);
18205

18206
  return TextWidgetAnnotationElement;
18207
}(WidgetAnnotationElement);
18208

18209
var CheckboxWidgetAnnotationElement = /*#__PURE__*/function (_WidgetAnnotationElem2) {
18210
  _inherits(CheckboxWidgetAnnotationElement, _WidgetAnnotationElem2);
18211

18212
  var _super5 = _createSuper(CheckboxWidgetAnnotationElement);
18213

18214
  function CheckboxWidgetAnnotationElement(parameters) {
18215
    _classCallCheck(this, CheckboxWidgetAnnotationElement);
18216

18217
    return _super5.call(this, parameters, {
18218
      isRenderable: parameters.renderInteractiveForms
18219
    });
18220
  }
18221

18222
  _createClass(CheckboxWidgetAnnotationElement, [{
18223
    key: "render",
18224
    value: function render() {
18225
      var _this6 = this;
18226

18227
      var storage = this.annotationStorage;
18228
      var data = this.data;
18229
      var id = data.id;
18230
      var value = storage.getValue(id, {
18231
        value: data.fieldValue && (data.exportValue && data.exportValue === data.fieldValue || !data.exportValue && data.fieldValue !== "Off")
18232
      }).value;
18233
      this.container.className = "buttonWidgetAnnotation checkBox";
18234
      var element = document.createElement("input");
18235
      element.disabled = data.readOnly;
18236
      element.type = "checkbox";
18237
      element.name = this.data.fieldName;
18238

18239
      if (value) {
18240
        element.setAttribute("checked", true);
18241
      }
18242

18243
      element.setAttribute("id", id);
18244
      element.addEventListener("change", function (event) {
18245
        var name = event.target.name;
18246

18247
        var _iterator3 = _createForOfIteratorHelper(document.getElementsByName(name)),
18248
            _step3;
18249

18250
        try {
18251
          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
18252
            var checkbox = _step3.value;
18253

18254
            if (checkbox !== event.target) {
18255
              checkbox.checked = false;
18256
              storage.setValue(checkbox.parentNode.getAttribute("data-annotation-id"), {
18257
                value: false
18258
              });
18259
            }
18260
          }
18261
        } catch (err) {
18262
          _iterator3.e(err);
18263
        } finally {
18264
          _iterator3.f();
18265
        }
18266

18267
        storage.setValue(id, {
18268
          value: event.target.checked
18269
        });
18270
      });
18271

18272
      if (this.enableScripting && this.hasJSActions) {
18273
        element.addEventListener("updatefromsandbox", function (event) {
18274
          var detail = event.detail;
18275
          var actions = {
18276
            value: function value() {
18277
              event.target.checked = detail.value !== "Off";
18278
              storage.setValue(id, {
18279
                value: event.target.checked
18280
              });
18281
            },
18282
            focus: function focus() {
18283
              setTimeout(function () {
18284
                return event.target.focus({
18285
                  preventScroll: false
18286
                });
18287
              }, 0);
18288
            },
18289
            hidden: function hidden() {
18290
              event.target.style.visibility = detail.hidden ? "hidden" : "visible";
18291
              storage.setValue(id, {
18292
                hidden: detail.hidden
18293
              });
18294
            },
18295
            editable: function editable() {
18296
              event.target.disabled = !detail.editable;
18297
            }
18298
          };
18299
          Object.keys(detail).filter(function (name) {
18300
            return name in actions;
18301
          }).forEach(function (name) {
18302
            return actions[name]();
18303
          });
18304

18305
          _this6._setColor(event);
18306
        });
18307

18308
        this._setEventListeners(element, [["change", "Validate"], ["change", "Action"], ["focus", "Focus"], ["blur", "Blur"], ["mousedown", "Mouse Down"], ["mouseenter", "Mouse Enter"], ["mouseleave", "Mouse Exit"], ["mouseup", "Mouse Up"]], function (event) {
18309
          return event.target.checked;
18310
        });
18311
      }
18312

18313
      this.container.appendChild(element);
18314
      return this.container;
18315
    }
18316
  }]);
18317

18318
  return CheckboxWidgetAnnotationElement;
18319
}(WidgetAnnotationElement);
18320

18321
var RadioButtonWidgetAnnotationElement = /*#__PURE__*/function (_WidgetAnnotationElem3) {
18322
  _inherits(RadioButtonWidgetAnnotationElement, _WidgetAnnotationElem3);
18323

18324
  var _super6 = _createSuper(RadioButtonWidgetAnnotationElement);
18325

18326
  function RadioButtonWidgetAnnotationElement(parameters) {
18327
    _classCallCheck(this, RadioButtonWidgetAnnotationElement);
18328

18329
    return _super6.call(this, parameters, {
18330
      isRenderable: parameters.renderInteractiveForms
18331
    });
18332
  }
18333

18334
  _createClass(RadioButtonWidgetAnnotationElement, [{
18335
    key: "render",
18336
    value: function render() {
18337
      var _this7 = this;
18338

18339
      this.container.className = "buttonWidgetAnnotation radioButton";
18340
      var storage = this.annotationStorage;
18341
      var data = this.data;
18342
      var id = data.id;
18343
      var value = storage.getValue(id, {
18344
        value: data.fieldValue === data.buttonValue
18345
      }).value;
18346
      var element = document.createElement("input");
18347
      element.disabled = data.readOnly;
18348
      element.type = "radio";
18349
      element.name = data.fieldName;
18350

18351
      if (value) {
18352
        element.setAttribute("checked", true);
18353
      }
18354

18355
      element.setAttribute("id", id);
18356
      element.addEventListener("change", function (event) {
18357
        var target = event.target;
18358

18359
        var _iterator4 = _createForOfIteratorHelper(document.getElementsByName(target.name)),
18360
            _step4;
18361

18362
        try {
18363
          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
18364
            var radio = _step4.value;
18365

18366
            if (radio !== target) {
18367
              storage.setValue(radio.getAttribute("id"), {
18368
                value: false
18369
              });
18370
            }
18371
          }
18372
        } catch (err) {
18373
          _iterator4.e(err);
18374
        } finally {
18375
          _iterator4.f();
18376
        }
18377

18378
        storage.setValue(id, {
18379
          value: target.checked
18380
        });
18381
      });
18382

18383
      if (this.enableScripting && this.hasJSActions) {
18384
        var pdfButtonValue = data.buttonValue;
18385
        element.addEventListener("updatefromsandbox", function (event) {
18386
          var detail = event.detail;
18387
          var actions = {
18388
            value: function value() {
18389
              var checked = pdfButtonValue === detail.value;
18390

18391
              var _iterator5 = _createForOfIteratorHelper(document.getElementsByName(event.target.name)),
18392
                  _step5;
18393

18394
              try {
18395
                for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
18396
                  var radio = _step5.value;
18397
                  var radioId = radio.getAttribute("id");
18398
                  radio.checked = radioId === id && checked;
18399
                  storage.setValue(radioId, {
18400
                    value: radio.checked
18401
                  });
18402
                }
18403
              } catch (err) {
18404
                _iterator5.e(err);
18405
              } finally {
18406
                _iterator5.f();
18407
              }
18408
            },
18409
            focus: function focus() {
18410
              setTimeout(function () {
18411
                return event.target.focus({
18412
                  preventScroll: false
18413
                });
18414
              }, 0);
18415
            },
18416
            hidden: function hidden() {
18417
              event.target.style.visibility = detail.hidden ? "hidden" : "visible";
18418
              storage.setValue(id, {
18419
                hidden: detail.hidden
18420
              });
18421
            },
18422
            editable: function editable() {
18423
              event.target.disabled = !detail.editable;
18424
            }
18425
          };
18426
          Object.keys(detail).filter(function (name) {
18427
            return name in actions;
18428
          }).forEach(function (name) {
18429
            return actions[name]();
18430
          });
18431

18432
          _this7._setColor(event);
18433
        });
18434

18435
        this._setEventListeners(element, [["change", "Validate"], ["change", "Action"], ["focus", "Focus"], ["blur", "Blur"], ["mousedown", "Mouse Down"], ["mouseenter", "Mouse Enter"], ["mouseleave", "Mouse Exit"], ["mouseup", "Mouse Up"]], function (event) {
18436
          return event.target.checked;
18437
        });
18438
      }
18439

18440
      this.container.appendChild(element);
18441
      return this.container;
18442
    }
18443
  }]);
18444

18445
  return RadioButtonWidgetAnnotationElement;
18446
}(WidgetAnnotationElement);
18447

18448
var PushButtonWidgetAnnotationElement = /*#__PURE__*/function (_LinkAnnotationElemen) {
18449
  _inherits(PushButtonWidgetAnnotationElement, _LinkAnnotationElemen);
18450

18451
  var _super7 = _createSuper(PushButtonWidgetAnnotationElement);
18452

18453
  function PushButtonWidgetAnnotationElement() {
18454
    _classCallCheck(this, PushButtonWidgetAnnotationElement);
18455

18456
    return _super7.apply(this, arguments);
18457
  }
18458

18459
  _createClass(PushButtonWidgetAnnotationElement, [{
18460
    key: "render",
18461
    value: function render() {
18462
      var container = _get(_getPrototypeOf(PushButtonWidgetAnnotationElement.prototype), "render", this).call(this);
18463

18464
      container.className = "buttonWidgetAnnotation pushButton";
18465

18466
      if (this.data.alternativeText) {
18467
        container.title = this.data.alternativeText;
18468
      }
18469

18470
      return container;
18471
    }
18472
  }]);
18473

18474
  return PushButtonWidgetAnnotationElement;
18475
}(LinkAnnotationElement);
18476

18477
var ChoiceWidgetAnnotationElement = /*#__PURE__*/function (_WidgetAnnotationElem4) {
18478
  _inherits(ChoiceWidgetAnnotationElement, _WidgetAnnotationElem4);
18479

18480
  var _super8 = _createSuper(ChoiceWidgetAnnotationElement);
18481

18482
  function ChoiceWidgetAnnotationElement(parameters) {
18483
    _classCallCheck(this, ChoiceWidgetAnnotationElement);
18484

18485
    return _super8.call(this, parameters, {
18486
      isRenderable: parameters.renderInteractiveForms
18487
    });
18488
  }
18489

18490
  _createClass(ChoiceWidgetAnnotationElement, [{
18491
    key: "render",
18492
    value: function render() {
18493
      var _this8 = this;
18494

18495
      this.container.className = "choiceWidgetAnnotation";
18496
      var storage = this.annotationStorage;
18497
      var id = this.data.id;
18498
      storage.getValue(id, {
18499
        value: this.data.fieldValue.length > 0 ? this.data.fieldValue[0] : undefined
18500
      });
18501
      var selectElement = document.createElement("select");
18502
      selectElement.disabled = this.data.readOnly;
18503
      selectElement.name = this.data.fieldName;
18504
      selectElement.setAttribute("id", id);
18505

18506
      if (!this.data.combo) {
18507
        selectElement.size = this.data.options.length;
18508

18509
        if (this.data.multiSelect) {
18510
          selectElement.multiple = true;
18511
        }
18512
      }
18513

18514
      var _iterator6 = _createForOfIteratorHelper(this.data.options),
18515
          _step6;
18516

18517
      try {
18518
        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
18519
          var option = _step6.value;
18520
          var optionElement = document.createElement("option");
18521
          optionElement.textContent = option.displayValue;
18522
          optionElement.value = option.exportValue;
18523

18524
          if (this.data.fieldValue.includes(option.exportValue)) {
18525
            optionElement.setAttribute("selected", true);
18526
          }
18527

18528
          selectElement.appendChild(optionElement);
18529
        }
18530
      } catch (err) {
18531
        _iterator6.e(err);
18532
      } finally {
18533
        _iterator6.f();
18534
      }
18535

18536
      var getValue = function getValue(event, isExport) {
18537
        var name = isExport ? "value" : "textContent";
18538
        var options = event.target.options;
18539

18540
        if (!event.target.multiple) {
18541
          return options.selectedIndex === -1 ? null : options[options.selectedIndex][name];
18542
        }
18543

18544
        return Array.prototype.filter.call(options, function (option) {
18545
          return option.selected;
18546
        }).map(function (option) {
18547
          return option[name];
18548
        });
18549
      };
18550

18551
      var getItems = function getItems(event) {
18552
        var options = event.target.options;
18553
        return Array.prototype.map.call(options, function (option) {
18554
          return {
18555
            displayValue: option.textContent,
18556
            exportValue: option.value
18557
          };
18558
        });
18559
      };
18560

18561
      if (this.enableScripting && this.hasJSActions) {
18562
        selectElement.addEventListener("updatefromsandbox", function (event) {
18563
          var detail = event.detail;
18564
          var actions = {
18565
            value: function value() {
18566
              var options = selectElement.options;
18567
              var value = detail.value;
18568
              var values = new Set(Array.isArray(value) ? value : [value]);
18569
              Array.prototype.forEach.call(options, function (option) {
18570
                option.selected = values.has(option.value);
18571
              });
18572
              storage.setValue(id, {
18573
                value: getValue(event, true)
18574
              });
18575
            },
18576
            multipleSelection: function multipleSelection() {
18577
              selectElement.multiple = true;
18578
            },
18579
            remove: function remove() {
18580
              var options = selectElement.options;
18581
              var index = detail.remove;
18582
              options[index].selected = false;
18583
              selectElement.remove(index);
18584

18585
              if (options.length > 0) {
18586
                var i = Array.prototype.findIndex.call(options, function (option) {
18587
                  return option.selected;
18588
                });
18589

18590
                if (i === -1) {
18591
                  options[0].selected = true;
18592
                }
18593
              }
18594

18595
              storage.setValue(id, {
18596
                value: getValue(event, true),
18597
                items: getItems(event)
18598
              });
18599
            },
18600
            clear: function clear() {
18601
              while (selectElement.length !== 0) {
18602
                selectElement.remove(0);
18603
              }
18604

18605
              storage.setValue(id, {
18606
                value: null,
18607
                items: []
18608
              });
18609
            },
18610
            insert: function insert() {
18611
              var _detail$insert = detail.insert,
18612
                  index = _detail$insert.index,
18613
                  displayValue = _detail$insert.displayValue,
18614
                  exportValue = _detail$insert.exportValue;
18615
              var optionElement = document.createElement("option");
18616
              optionElement.textContent = displayValue;
18617
              optionElement.value = exportValue;
18618
              selectElement.insertBefore(optionElement, selectElement.children[index]);
18619
              storage.setValue(id, {
18620
                value: getValue(event, true),
18621
                items: getItems(event)
18622
              });
18623
            },
18624
            items: function items() {
18625
              var items = detail.items;
18626

18627
              while (selectElement.length !== 0) {
18628
                selectElement.remove(0);
18629
              }
18630

18631
              var _iterator7 = _createForOfIteratorHelper(items),
18632
                  _step7;
18633

18634
              try {
18635
                for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
18636
                  var item = _step7.value;
18637
                  var displayValue = item.displayValue,
18638
                      exportValue = item.exportValue;
18639
                  var optionElement = document.createElement("option");
18640
                  optionElement.textContent = displayValue;
18641
                  optionElement.value = exportValue;
18642
                  selectElement.appendChild(optionElement);
18643
                }
18644
              } catch (err) {
18645
                _iterator7.e(err);
18646
              } finally {
18647
                _iterator7.f();
18648
              }
18649

18650
              if (selectElement.options.length > 0) {
18651
                selectElement.options[0].selected = true;
18652
              }
18653

18654
              storage.setValue(id, {
18655
                value: getValue(event, true),
18656
                items: getItems(event)
18657
              });
18658
            },
18659
            indices: function indices() {
18660
              var indices = new Set(detail.indices);
18661
              var options = event.target.options;
18662
              Array.prototype.forEach.call(options, function (option, i) {
18663
                option.selected = indices.has(i);
18664
              });
18665
              storage.setValue(id, {
18666
                value: getValue(event, true)
18667
              });
18668
            },
18669
            focus: function focus() {
18670
              setTimeout(function () {
18671
                return event.target.focus({
18672
                  preventScroll: false
18673
                });
18674
              }, 0);
18675
            },
18676
            hidden: function hidden() {
18677
              event.target.style.visibility = detail.hidden ? "hidden" : "visible";
18678
              storage.setValue(id, {
18679
                hidden: detail.hidden
18680
              });
18681
            },
18682
            editable: function editable() {
18683
              event.target.disabled = !detail.editable;
18684
            }
18685
          };
18686
          Object.keys(detail).filter(function (name) {
18687
            return name in actions;
18688
          }).forEach(function (name) {
18689
            return actions[name]();
18690
          });
18691

18692
          _this8._setColor(event);
18693
        });
18694
        selectElement.addEventListener("input", function (event) {
18695
          var _this8$linkService$ev;
18696

18697
          var exportValue = getValue(event, true);
18698
          var value = getValue(event, false);
18699
          storage.setValue(id, {
18700
            value: exportValue
18701
          });
18702
          (_this8$linkService$ev = _this8.linkService.eventBus) === null || _this8$linkService$ev === void 0 ? void 0 : _this8$linkService$ev.dispatch("dispatcheventinsandbox", {
18703
            source: _this8,
18704
            detail: {
18705
              id: id,
18706
              name: "Keystroke",
18707
              value: value,
18708
              changeEx: exportValue,
18709
              willCommit: true,
18710
              commitKey: 1,
18711
              keyDown: false
18712
            }
18713
          });
18714
        });
18715

18716
        this._setEventListeners(selectElement, [["focus", "Focus"], ["blur", "Blur"], ["mousedown", "Mouse Down"], ["mouseenter", "Mouse Enter"], ["mouseleave", "Mouse Exit"], ["mouseup", "Mouse Up"], ["input", "Action"]], function (event) {
18717
          return event.target.checked;
18718
        });
18719
      } else {
18720
        selectElement.addEventListener("input", function (event) {
18721
          storage.setValue(id, {
18722
            value: getValue(event)
18723
          });
18724
        });
18725
      }
18726

18727
      this.container.appendChild(selectElement);
18728
      return this.container;
18729
    }
18730
  }]);
18731

18732
  return ChoiceWidgetAnnotationElement;
18733
}(WidgetAnnotationElement);
18734

18735
var PopupAnnotationElement = /*#__PURE__*/function (_AnnotationElement4) {
18736
  _inherits(PopupAnnotationElement, _AnnotationElement4);
18737

18738
  var _super9 = _createSuper(PopupAnnotationElement);
18739

18740
  function PopupAnnotationElement(parameters) {
18741
    _classCallCheck(this, PopupAnnotationElement);
18742

18743
    var isRenderable = !!(parameters.data.title || parameters.data.contents);
18744
    return _super9.call(this, parameters, {
18745
      isRenderable: isRenderable
18746
    });
18747
  }
18748

18749
  _createClass(PopupAnnotationElement, [{
18750
    key: "render",
18751
    value: function render() {
18752
      var IGNORE_TYPES = ["Line", "Square", "Circle", "PolyLine", "Polygon", "Ink"];
18753
      this.container.className = "popupAnnotation";
18754

18755
      if (IGNORE_TYPES.includes(this.data.parentType)) {
18756
        return this.container;
18757
      }
18758

18759
      var selector = "[data-annotation-id=\"".concat(this.data.parentId, "\"]");
18760
      var parentElements = this.layer.querySelectorAll(selector);
18761

18762
      if (parentElements.length === 0) {
18763
        return this.container;
18764
      }
18765

18766
      var popup = new PopupElement({
18767
        container: this.container,
18768
        trigger: Array.from(parentElements),
18769
        color: this.data.color,
18770
        title: this.data.title,
18771
        modificationDate: this.data.modificationDate,
18772
        contents: this.data.contents
18773
      });
18774
      var page = this.page;
18775

18776
      var rect = _util.Util.normalizeRect([this.data.parentRect[0], page.view[3] - this.data.parentRect[1] + page.view[1], this.data.parentRect[2], page.view[3] - this.data.parentRect[3] + page.view[1]]);
18777

18778
      var popupLeft = rect[0] + this.data.parentRect[2] - this.data.parentRect[0];
18779
      var popupTop = rect[1];
18780
      this.container.style.transformOrigin = "".concat(-popupLeft, "px ").concat(-popupTop, "px");
18781
      this.container.style.left = "".concat(popupLeft, "px");
18782
      this.container.style.top = "".concat(popupTop, "px");
18783
      this.container.appendChild(popup.render());
18784
      return this.container;
18785
    }
18786
  }]);
18787

18788
  return PopupAnnotationElement;
18789
}(AnnotationElement);
18790

18791
var PopupElement = /*#__PURE__*/function () {
18792
  function PopupElement(parameters) {
18793
    _classCallCheck(this, PopupElement);
18794

18795
    this.container = parameters.container;
18796
    this.trigger = parameters.trigger;
18797
    this.color = parameters.color;
18798
    this.title = parameters.title;
18799
    this.modificationDate = parameters.modificationDate;
18800
    this.contents = parameters.contents;
18801
    this.hideWrapper = parameters.hideWrapper || false;
18802
    this.pinned = false;
18803
  }
18804

18805
  _createClass(PopupElement, [{
18806
    key: "render",
18807
    value: function render() {
18808
      var _this9 = this;
18809

18810
      var BACKGROUND_ENLIGHT = 0.7;
18811
      var wrapper = document.createElement("div");
18812
      wrapper.className = "popupWrapper";
18813
      this.hideElement = this.hideWrapper ? wrapper : this.container;
18814
      this.hideElement.hidden = true;
18815
      var popup = document.createElement("div");
18816
      popup.className = "popup";
18817
      var color = this.color;
18818

18819
      if (color) {
18820
        var r = BACKGROUND_ENLIGHT * (255 - color[0]) + color[0];
18821
        var g = BACKGROUND_ENLIGHT * (255 - color[1]) + color[1];
18822
        var b = BACKGROUND_ENLIGHT * (255 - color[2]) + color[2];
18823
        popup.style.backgroundColor = _util.Util.makeHexColor(r | 0, g | 0, b | 0);
18824
      }
18825

18826
      var title = document.createElement("h1");
18827
      title.textContent = this.title;
18828
      popup.appendChild(title);
18829

18830
      var dateObject = _display_utils.PDFDateString.toDateObject(this.modificationDate);
18831

18832
      if (dateObject) {
18833
        var modificationDate = document.createElement("span");
18834
        modificationDate.textContent = "{{date}}, {{time}}";
18835
        modificationDate.dataset.l10nId = "annotation_date_string";
18836
        modificationDate.dataset.l10nArgs = JSON.stringify({
18837
          date: dateObject.toLocaleDateString(),
18838
          time: dateObject.toLocaleTimeString()
18839
        });
18840
        popup.appendChild(modificationDate);
18841
      }
18842

18843
      var contents = this._formatContents(this.contents);
18844

18845
      popup.appendChild(contents);
18846

18847
      if (!Array.isArray(this.trigger)) {
18848
        this.trigger = [this.trigger];
18849
      }
18850

18851
      this.trigger.forEach(function (element) {
18852
        element.addEventListener("click", _this9._toggle.bind(_this9));
18853
        element.addEventListener("mouseover", _this9._show.bind(_this9, false));
18854
        element.addEventListener("mouseout", _this9._hide.bind(_this9, false));
18855
      });
18856
      popup.addEventListener("click", this._hide.bind(this, true));
18857
      wrapper.appendChild(popup);
18858
      return wrapper;
18859
    }
18860
  }, {
18861
    key: "_formatContents",
18862
    value: function _formatContents(contents) {
18863
      var p = document.createElement("p");
18864
      var lines = contents.split(/(?:\r\n?|\n)/);
18865

18866
      for (var i = 0, ii = lines.length; i < ii; ++i) {
18867
        var line = lines[i];
18868
        p.appendChild(document.createTextNode(line));
18869

18870
        if (i < ii - 1) {
18871
          p.appendChild(document.createElement("br"));
18872
        }
18873
      }
18874

18875
      return p;
18876
    }
18877
  }, {
18878
    key: "_toggle",
18879
    value: function _toggle() {
18880
      if (this.pinned) {
18881
        this._hide(true);
18882
      } else {
18883
        this._show(true);
18884
      }
18885
    }
18886
  }, {
18887
    key: "_show",
18888
    value: function _show() {
18889
      var pin = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
18890

18891
      if (pin) {
18892
        this.pinned = true;
18893
      }
18894

18895
      if (this.hideElement.hidden) {
18896
        this.hideElement.hidden = false;
18897
        this.container.style.zIndex += 1;
18898
      }
18899
    }
18900
  }, {
18901
    key: "_hide",
18902
    value: function _hide() {
18903
      var unpin = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
18904

18905
      if (unpin) {
18906
        this.pinned = false;
18907
      }
18908

18909
      if (!this.hideElement.hidden && !this.pinned) {
18910
        this.hideElement.hidden = true;
18911
        this.container.style.zIndex -= 1;
18912
      }
18913
    }
18914
  }]);
18915

18916
  return PopupElement;
18917
}();
18918

18919
var FreeTextAnnotationElement = /*#__PURE__*/function (_AnnotationElement5) {
18920
  _inherits(FreeTextAnnotationElement, _AnnotationElement5);
18921

18922
  var _super10 = _createSuper(FreeTextAnnotationElement);
18923

18924
  function FreeTextAnnotationElement(parameters) {
18925
    _classCallCheck(this, FreeTextAnnotationElement);
18926

18927
    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
18928
    return _super10.call(this, parameters, {
18929
      isRenderable: isRenderable,
18930
      ignoreBorder: true
18931
    });
18932
  }
18933

18934
  _createClass(FreeTextAnnotationElement, [{
18935
    key: "render",
18936
    value: function render() {
18937
      this.container.className = "freeTextAnnotation";
18938

18939
      if (!this.data.hasPopup) {
18940
        this._createPopup(null, this.data);
18941
      }
18942

18943
      return this.container;
18944
    }
18945
  }]);
18946

18947
  return FreeTextAnnotationElement;
18948
}(AnnotationElement);
18949

18950
var LineAnnotationElement = /*#__PURE__*/function (_AnnotationElement6) {
18951
  _inherits(LineAnnotationElement, _AnnotationElement6);
18952

18953
  var _super11 = _createSuper(LineAnnotationElement);
18954

18955
  function LineAnnotationElement(parameters) {
18956
    _classCallCheck(this, LineAnnotationElement);
18957

18958
    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
18959
    return _super11.call(this, parameters, {
18960
      isRenderable: isRenderable,
18961
      ignoreBorder: true
18962
    });
18963
  }
18964

18965
  _createClass(LineAnnotationElement, [{
18966
    key: "render",
18967
    value: function render() {
18968
      this.container.className = "lineAnnotation";
18969
      var data = this.data;
18970
      var width = data.rect[2] - data.rect[0];
18971
      var height = data.rect[3] - data.rect[1];
18972
      var svg = this.svgFactory.create(width, height);
18973
      var line = this.svgFactory.createElement("svg:line");
18974
      line.setAttribute("x1", data.rect[2] - data.lineCoordinates[0]);
18975
      line.setAttribute("y1", data.rect[3] - data.lineCoordinates[1]);
18976
      line.setAttribute("x2", data.rect[2] - data.lineCoordinates[2]);
18977
      line.setAttribute("y2", data.rect[3] - data.lineCoordinates[3]);
18978
      line.setAttribute("stroke-width", data.borderStyle.width || 1);
18979
      line.setAttribute("stroke", "transparent");
18980
      svg.appendChild(line);
18981
      this.container.append(svg);
18982

18983
      this._createPopup(line, data);
18984

18985
      return this.container;
18986
    }
18987
  }]);
18988

18989
  return LineAnnotationElement;
18990
}(AnnotationElement);
18991

18992
var SquareAnnotationElement = /*#__PURE__*/function (_AnnotationElement7) {
18993
  _inherits(SquareAnnotationElement, _AnnotationElement7);
18994

18995
  var _super12 = _createSuper(SquareAnnotationElement);
18996

18997
  function SquareAnnotationElement(parameters) {
18998
    _classCallCheck(this, SquareAnnotationElement);
18999

19000
    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
19001
    return _super12.call(this, parameters, {
19002
      isRenderable: isRenderable,
19003
      ignoreBorder: true
19004
    });
19005
  }
19006

19007
  _createClass(SquareAnnotationElement, [{
19008
    key: "render",
19009
    value: function render() {
19010
      this.container.className = "squareAnnotation";
19011
      var data = this.data;
19012
      var width = data.rect[2] - data.rect[0];
19013
      var height = data.rect[3] - data.rect[1];
19014
      var svg = this.svgFactory.create(width, height);
19015
      var borderWidth = data.borderStyle.width;
19016
      var square = this.svgFactory.createElement("svg:rect");
19017
      square.setAttribute("x", borderWidth / 2);
19018
      square.setAttribute("y", borderWidth / 2);
19019
      square.setAttribute("width", width - borderWidth);
19020
      square.setAttribute("height", height - borderWidth);
19021
      square.setAttribute("stroke-width", borderWidth || 1);
19022
      square.setAttribute("stroke", "transparent");
19023
      square.setAttribute("fill", "none");
19024
      svg.appendChild(square);
19025
      this.container.append(svg);
19026

19027
      this._createPopup(square, data);
19028

19029
      return this.container;
19030
    }
19031
  }]);
19032

19033
  return SquareAnnotationElement;
19034
}(AnnotationElement);
19035

19036
var CircleAnnotationElement = /*#__PURE__*/function (_AnnotationElement8) {
19037
  _inherits(CircleAnnotationElement, _AnnotationElement8);
19038

19039
  var _super13 = _createSuper(CircleAnnotationElement);
19040

19041
  function CircleAnnotationElement(parameters) {
19042
    _classCallCheck(this, CircleAnnotationElement);
19043

19044
    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
19045
    return _super13.call(this, parameters, {
19046
      isRenderable: isRenderable,
19047
      ignoreBorder: true
19048
    });
19049
  }
19050

19051
  _createClass(CircleAnnotationElement, [{
19052
    key: "render",
19053
    value: function render() {
19054
      this.container.className = "circleAnnotation";
19055
      var data = this.data;
19056
      var width = data.rect[2] - data.rect[0];
19057
      var height = data.rect[3] - data.rect[1];
19058
      var svg = this.svgFactory.create(width, height);
19059
      var borderWidth = data.borderStyle.width;
19060
      var circle = this.svgFactory.createElement("svg:ellipse");
19061
      circle.setAttribute("cx", width / 2);
19062
      circle.setAttribute("cy", height / 2);
19063
      circle.setAttribute("rx", width / 2 - borderWidth / 2);
19064
      circle.setAttribute("ry", height / 2 - borderWidth / 2);
19065
      circle.setAttribute("stroke-width", borderWidth || 1);
19066
      circle.setAttribute("stroke", "transparent");
19067
      circle.setAttribute("fill", "none");
19068
      svg.appendChild(circle);
19069
      this.container.append(svg);
19070

19071
      this._createPopup(circle, data);
19072

19073
      return this.container;
19074
    }
19075
  }]);
19076

19077
  return CircleAnnotationElement;
19078
}(AnnotationElement);
19079

19080
var PolylineAnnotationElement = /*#__PURE__*/function (_AnnotationElement9) {
19081
  _inherits(PolylineAnnotationElement, _AnnotationElement9);
19082

19083
  var _super14 = _createSuper(PolylineAnnotationElement);
19084

19085
  function PolylineAnnotationElement(parameters) {
19086
    var _this10;
19087

19088
    _classCallCheck(this, PolylineAnnotationElement);
19089

19090
    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
19091
    _this10 = _super14.call(this, parameters, {
19092
      isRenderable: isRenderable,
19093
      ignoreBorder: true
19094
    });
19095
    _this10.containerClassName = "polylineAnnotation";
19096
    _this10.svgElementName = "svg:polyline";
19097
    return _this10;
19098
  }
19099

19100
  _createClass(PolylineAnnotationElement, [{
19101
    key: "render",
19102
    value: function render() {
19103
      this.container.className = this.containerClassName;
19104
      var data = this.data;
19105
      var width = data.rect[2] - data.rect[0];
19106
      var height = data.rect[3] - data.rect[1];
19107
      var svg = this.svgFactory.create(width, height);
19108
      var points = [];
19109

19110
      var _iterator8 = _createForOfIteratorHelper(data.vertices),
19111
          _step8;
19112

19113
      try {
19114
        for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {
19115
          var coordinate = _step8.value;
19116
          var x = coordinate.x - data.rect[0];
19117
          var y = data.rect[3] - coordinate.y;
19118
          points.push(x + "," + y);
19119
        }
19120
      } catch (err) {
19121
        _iterator8.e(err);
19122
      } finally {
19123
        _iterator8.f();
19124
      }
19125

19126
      points = points.join(" ");
19127
      var polyline = this.svgFactory.createElement(this.svgElementName);
19128
      polyline.setAttribute("points", points);
19129
      polyline.setAttribute("stroke-width", data.borderStyle.width || 1);
19130
      polyline.setAttribute("stroke", "transparent");
19131
      polyline.setAttribute("fill", "none");
19132
      svg.appendChild(polyline);
19133
      this.container.append(svg);
19134

19135
      this._createPopup(polyline, data);
19136

19137
      return this.container;
19138
    }
19139
  }]);
19140

19141
  return PolylineAnnotationElement;
19142
}(AnnotationElement);
19143

19144
var PolygonAnnotationElement = /*#__PURE__*/function (_PolylineAnnotationEl) {
19145
  _inherits(PolygonAnnotationElement, _PolylineAnnotationEl);
19146

19147
  var _super15 = _createSuper(PolygonAnnotationElement);
19148

19149
  function PolygonAnnotationElement(parameters) {
19150
    var _this11;
19151

19152
    _classCallCheck(this, PolygonAnnotationElement);
19153

19154
    _this11 = _super15.call(this, parameters);
19155
    _this11.containerClassName = "polygonAnnotation";
19156
    _this11.svgElementName = "svg:polygon";
19157
    return _this11;
19158
  }
19159

19160
  return PolygonAnnotationElement;
19161
}(PolylineAnnotationElement);
19162

19163
var CaretAnnotationElement = /*#__PURE__*/function (_AnnotationElement10) {
19164
  _inherits(CaretAnnotationElement, _AnnotationElement10);
19165

19166
  var _super16 = _createSuper(CaretAnnotationElement);
19167

19168
  function CaretAnnotationElement(parameters) {
19169
    _classCallCheck(this, CaretAnnotationElement);
19170

19171
    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
19172
    return _super16.call(this, parameters, {
19173
      isRenderable: isRenderable,
19174
      ignoreBorder: true
19175
    });
19176
  }
19177

19178
  _createClass(CaretAnnotationElement, [{
19179
    key: "render",
19180
    value: function render() {
19181
      this.container.className = "caretAnnotation";
19182

19183
      if (!this.data.hasPopup) {
19184
        this._createPopup(null, this.data);
19185
      }
19186

19187
      return this.container;
19188
    }
19189
  }]);
19190

19191
  return CaretAnnotationElement;
19192
}(AnnotationElement);
19193

19194
var InkAnnotationElement = /*#__PURE__*/function (_AnnotationElement11) {
19195
  _inherits(InkAnnotationElement, _AnnotationElement11);
19196

19197
  var _super17 = _createSuper(InkAnnotationElement);
19198

19199
  function InkAnnotationElement(parameters) {
19200
    var _this12;
19201

19202
    _classCallCheck(this, InkAnnotationElement);
19203

19204
    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
19205
    _this12 = _super17.call(this, parameters, {
19206
      isRenderable: isRenderable,
19207
      ignoreBorder: true
19208
    });
19209
    _this12.containerClassName = "inkAnnotation";
19210
    _this12.svgElementName = "svg:polyline";
19211
    return _this12;
19212
  }
19213

19214
  _createClass(InkAnnotationElement, [{
19215
    key: "render",
19216
    value: function render() {
19217
      this.container.className = this.containerClassName;
19218
      var data = this.data;
19219
      var width = data.rect[2] - data.rect[0];
19220
      var height = data.rect[3] - data.rect[1];
19221
      var svg = this.svgFactory.create(width, height);
19222

19223
      var _iterator9 = _createForOfIteratorHelper(data.inkLists),
19224
          _step9;
19225

19226
      try {
19227
        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
19228
          var inkList = _step9.value;
19229
          var points = [];
19230

19231
          var _iterator10 = _createForOfIteratorHelper(inkList),
19232
              _step10;
19233

19234
          try {
19235
            for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
19236
              var coordinate = _step10.value;
19237
              var x = coordinate.x - data.rect[0];
19238
              var y = data.rect[3] - coordinate.y;
19239
              points.push("".concat(x, ",").concat(y));
19240
            }
19241
          } catch (err) {
19242
            _iterator10.e(err);
19243
          } finally {
19244
            _iterator10.f();
19245
          }
19246

19247
          points = points.join(" ");
19248
          var polyline = this.svgFactory.createElement(this.svgElementName);
19249
          polyline.setAttribute("points", points);
19250
          polyline.setAttribute("stroke-width", data.borderStyle.width || 1);
19251
          polyline.setAttribute("stroke", "transparent");
19252
          polyline.setAttribute("fill", "none");
19253

19254
          this._createPopup(polyline, data);
19255

19256
          svg.appendChild(polyline);
19257
        }
19258
      } catch (err) {
19259
        _iterator9.e(err);
19260
      } finally {
19261
        _iterator9.f();
19262
      }
19263

19264
      this.container.append(svg);
19265
      return this.container;
19266
    }
19267
  }]);
19268

19269
  return InkAnnotationElement;
19270
}(AnnotationElement);
19271

19272
var HighlightAnnotationElement = /*#__PURE__*/function (_AnnotationElement12) {
19273
  _inherits(HighlightAnnotationElement, _AnnotationElement12);
19274

19275
  var _super18 = _createSuper(HighlightAnnotationElement);
19276

19277
  function HighlightAnnotationElement(parameters) {
19278
    _classCallCheck(this, HighlightAnnotationElement);
19279

19280
    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
19281
    return _super18.call(this, parameters, {
19282
      isRenderable: isRenderable,
19283
      ignoreBorder: true,
19284
      createQuadrilaterals: true
19285
    });
19286
  }
19287

19288
  _createClass(HighlightAnnotationElement, [{
19289
    key: "render",
19290
    value: function render() {
19291
      if (!this.data.hasPopup) {
19292
        this._createPopup(null, this.data);
19293
      }
19294

19295
      if (this.quadrilaterals) {
19296
        return this._renderQuadrilaterals("highlightAnnotation");
19297
      }
19298

19299
      this.container.className = "highlightAnnotation";
19300
      return this.container;
19301
    }
19302
  }]);
19303

19304
  return HighlightAnnotationElement;
19305
}(AnnotationElement);
19306

19307
var UnderlineAnnotationElement = /*#__PURE__*/function (_AnnotationElement13) {
19308
  _inherits(UnderlineAnnotationElement, _AnnotationElement13);
19309

19310
  var _super19 = _createSuper(UnderlineAnnotationElement);
19311

19312
  function UnderlineAnnotationElement(parameters) {
19313
    _classCallCheck(this, UnderlineAnnotationElement);
19314

19315
    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
19316
    return _super19.call(this, parameters, {
19317
      isRenderable: isRenderable,
19318
      ignoreBorder: true,
19319
      createQuadrilaterals: true
19320
    });
19321
  }
19322

19323
  _createClass(UnderlineAnnotationElement, [{
19324
    key: "render",
19325
    value: function render() {
19326
      if (!this.data.hasPopup) {
19327
        this._createPopup(null, this.data);
19328
      }
19329

19330
      if (this.quadrilaterals) {
19331
        return this._renderQuadrilaterals("underlineAnnotation");
19332
      }
19333

19334
      this.container.className = "underlineAnnotation";
19335
      return this.container;
19336
    }
19337
  }]);
19338

19339
  return UnderlineAnnotationElement;
19340
}(AnnotationElement);
19341

19342
var SquigglyAnnotationElement = /*#__PURE__*/function (_AnnotationElement14) {
19343
  _inherits(SquigglyAnnotationElement, _AnnotationElement14);
19344

19345
  var _super20 = _createSuper(SquigglyAnnotationElement);
19346

19347
  function SquigglyAnnotationElement(parameters) {
19348
    _classCallCheck(this, SquigglyAnnotationElement);
19349

19350
    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
19351
    return _super20.call(this, parameters, {
19352
      isRenderable: isRenderable,
19353
      ignoreBorder: true,
19354
      createQuadrilaterals: true
19355
    });
19356
  }
19357

19358
  _createClass(SquigglyAnnotationElement, [{
19359
    key: "render",
19360
    value: function render() {
19361
      if (!this.data.hasPopup) {
19362
        this._createPopup(null, this.data);
19363
      }
19364

19365
      if (this.quadrilaterals) {
19366
        return this._renderQuadrilaterals("squigglyAnnotation");
19367
      }
19368

19369
      this.container.className = "squigglyAnnotation";
19370
      return this.container;
19371
    }
19372
  }]);
19373

19374
  return SquigglyAnnotationElement;
19375
}(AnnotationElement);
19376

19377
var StrikeOutAnnotationElement = /*#__PURE__*/function (_AnnotationElement15) {
19378
  _inherits(StrikeOutAnnotationElement, _AnnotationElement15);
19379

19380
  var _super21 = _createSuper(StrikeOutAnnotationElement);
19381

19382
  function StrikeOutAnnotationElement(parameters) {
19383
    _classCallCheck(this, StrikeOutAnnotationElement);
19384

19385
    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
19386
    return _super21.call(this, parameters, {
19387
      isRenderable: isRenderable,
19388
      ignoreBorder: true,
19389
      createQuadrilaterals: true
19390
    });
19391
  }
19392

19393
  _createClass(StrikeOutAnnotationElement, [{
19394
    key: "render",
19395
    value: function render() {
19396
      if (!this.data.hasPopup) {
19397
        this._createPopup(null, this.data);
19398
      }
19399

19400
      if (this.quadrilaterals) {
19401
        return this._renderQuadrilaterals("strikeoutAnnotation");
19402
      }
19403

19404
      this.container.className = "strikeoutAnnotation";
19405
      return this.container;
19406
    }
19407
  }]);
19408

19409
  return StrikeOutAnnotationElement;
19410
}(AnnotationElement);
19411

19412
var StampAnnotationElement = /*#__PURE__*/function (_AnnotationElement16) {
19413
  _inherits(StampAnnotationElement, _AnnotationElement16);
19414

19415
  var _super22 = _createSuper(StampAnnotationElement);
19416

19417
  function StampAnnotationElement(parameters) {
19418
    _classCallCheck(this, StampAnnotationElement);
19419

19420
    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
19421
    return _super22.call(this, parameters, {
19422
      isRenderable: isRenderable,
19423
      ignoreBorder: true
19424
    });
19425
  }
19426

19427
  _createClass(StampAnnotationElement, [{
19428
    key: "render",
19429
    value: function render() {
19430
      this.container.className = "stampAnnotation";
19431

19432
      if (!this.data.hasPopup) {
19433
        this._createPopup(null, this.data);
19434
      }
19435

19436
      return this.container;
19437
    }
19438
  }]);
19439

19440
  return StampAnnotationElement;
19441
}(AnnotationElement);
19442

19443
var FileAttachmentAnnotationElement = /*#__PURE__*/function (_AnnotationElement17) {
19444
  _inherits(FileAttachmentAnnotationElement, _AnnotationElement17);
19445

19446
  var _super23 = _createSuper(FileAttachmentAnnotationElement);
19447

19448
  function FileAttachmentAnnotationElement(parameters) {
19449
    var _this13$linkService$e;
19450

19451
    var _this13;
19452

19453
    _classCallCheck(this, FileAttachmentAnnotationElement);
19454

19455
    _this13 = _super23.call(this, parameters, {
19456
      isRenderable: true
19457
    });
19458
    var _this13$data$file = _this13.data.file,
19459
        filename = _this13$data$file.filename,
19460
        content = _this13$data$file.content;
19461
    _this13.filename = (0, _display_utils.getFilenameFromUrl)(filename);
19462
    _this13.content = content;
19463
    (_this13$linkService$e = _this13.linkService.eventBus) === null || _this13$linkService$e === void 0 ? void 0 : _this13$linkService$e.dispatch("fileattachmentannotation", {
19464
      source: _assertThisInitialized(_this13),
19465
      id: (0, _util.stringToPDFString)(filename),
19466
      filename: filename,
19467
      content: content
19468
    });
19469
    return _this13;
19470
  }
19471

19472
  _createClass(FileAttachmentAnnotationElement, [{
19473
    key: "render",
19474
    value: function render() {
19475
      this.container.className = "fileAttachmentAnnotation";
19476
      var trigger = document.createElement("div");
19477
      trigger.style.height = this.container.style.height;
19478
      trigger.style.width = this.container.style.width;
19479
      trigger.addEventListener("dblclick", this._download.bind(this));
19480

19481
      if (!this.data.hasPopup && (this.data.title || this.data.contents)) {
19482
        this._createPopup(trigger, this.data);
19483
      }
19484

19485
      this.container.appendChild(trigger);
19486
      return this.container;
19487
    }
19488
  }, {
19489
    key: "_download",
19490
    value: function _download() {
19491
      var _this$downloadManager;
19492

19493
      (_this$downloadManager = this.downloadManager) === null || _this$downloadManager === void 0 ? void 0 : _this$downloadManager.openOrDownloadData(this.container, this.content, this.filename);
19494
    }
19495
  }]);
19496

19497
  return FileAttachmentAnnotationElement;
19498
}(AnnotationElement);
19499

19500
var AnnotationLayer = /*#__PURE__*/function () {
19501
  function AnnotationLayer() {
19502
    _classCallCheck(this, AnnotationLayer);
19503
  }
19504

19505
  _createClass(AnnotationLayer, null, [{
19506
    key: "render",
19507
    value: function render(parameters) {
19508
      var sortedAnnotations = [],
19509
          popupAnnotations = [];
19510

19511
      var _iterator11 = _createForOfIteratorHelper(parameters.annotations),
19512
          _step11;
19513

19514
      try {
19515
        for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
19516
          var _data = _step11.value;
19517

19518
          if (!_data) {
19519
            continue;
19520
          }
19521

19522
          if (_data.annotationType === _util.AnnotationType.POPUP) {
19523
            popupAnnotations.push(_data);
19524
            continue;
19525
          }
19526

19527
          sortedAnnotations.push(_data);
19528
        }
19529
      } catch (err) {
19530
        _iterator11.e(err);
19531
      } finally {
19532
        _iterator11.f();
19533
      }
19534

19535
      if (popupAnnotations.length) {
19536
        sortedAnnotations.push.apply(sortedAnnotations, popupAnnotations);
19537
      }
19538

19539
      for (var _i3 = 0, _sortedAnnotations = sortedAnnotations; _i3 < _sortedAnnotations.length; _i3++) {
19540
        var data = _sortedAnnotations[_i3];
19541
        var element = AnnotationElementFactory.create({
19542
          data: data,
19543
          layer: parameters.div,
19544
          page: parameters.page,
19545
          viewport: parameters.viewport,
19546
          linkService: parameters.linkService,
19547
          downloadManager: parameters.downloadManager,
19548
          imageResourcesPath: parameters.imageResourcesPath || "",
19549
          renderInteractiveForms: parameters.renderInteractiveForms !== false,
19550
          svgFactory: new _display_utils.DOMSVGFactory(),
19551
          annotationStorage: parameters.annotationStorage || new _annotation_storage.AnnotationStorage(),
19552
          enableScripting: parameters.enableScripting,
19553
          hasJSActions: parameters.hasJSActions,
19554
          mouseState: parameters.mouseState || {
19555
            isDown: false
19556
          }
19557
        });
19558

19559
        if (element.isRenderable) {
19560
          var rendered = element.render();
19561

19562
          if (data.hidden) {
19563
            rendered.style.visibility = "hidden";
19564
          }
19565

19566
          if (Array.isArray(rendered)) {
19567
            var _iterator12 = _createForOfIteratorHelper(rendered),
19568
                _step12;
19569

19570
            try {
19571
              for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {
19572
                var renderedElement = _step12.value;
19573
                parameters.div.appendChild(renderedElement);
19574
              }
19575
            } catch (err) {
19576
              _iterator12.e(err);
19577
            } finally {
19578
              _iterator12.f();
19579
            }
19580
          } else {
19581
            if (element instanceof PopupAnnotationElement) {
19582
              parameters.div.prepend(rendered);
19583
            } else {
19584
              parameters.div.appendChild(rendered);
19585
            }
19586
          }
19587
        }
19588
      }
19589
    }
19590
  }, {
19591
    key: "update",
19592
    value: function update(parameters) {
19593
      var transform = "matrix(".concat(parameters.viewport.transform.join(","), ")");
19594

19595
      var _iterator13 = _createForOfIteratorHelper(parameters.annotations),
19596
          _step13;
19597

19598
      try {
19599
        for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {
19600
          var data = _step13.value;
19601
          var elements = parameters.div.querySelectorAll("[data-annotation-id=\"".concat(data.id, "\"]"));
19602

19603
          if (elements) {
19604
            elements.forEach(function (element) {
19605
              element.style.transform = transform;
19606
            });
19607
          }
19608
        }
19609
      } catch (err) {
19610
        _iterator13.e(err);
19611
      } finally {
19612
        _iterator13.f();
19613
      }
19614

19615
      parameters.div.hidden = false;
19616
    }
19617
  }]);
19618

19619
  return AnnotationLayer;
19620
}();
19621

19622
exports.AnnotationLayer = AnnotationLayer;
19623

19624
/***/ }),
19625
/* 139 */
19626
/***/ ((__unused_webpack_module, exports) => {
19627

19628
"use strict";
19629

19630

19631
Object.defineProperty(exports, "__esModule", ({
19632
  value: true
19633
}));
19634
exports.ColorConverters = void 0;
19635

19636
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
19637

19638
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
19639

19640
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
19641

19642
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
19643

19644
function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
19645

19646
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
19647

19648
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
19649

19650
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
19651

19652
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
19653

19654
function makeColorComp(n) {
19655
  return Math.floor(Math.max(0, Math.min(1, n)) * 255).toString(16).padStart(2, "0");
19656
}
19657

19658
var ColorConverters = /*#__PURE__*/function () {
19659
  function ColorConverters() {
19660
    _classCallCheck(this, ColorConverters);
19661
  }
19662

19663
  _createClass(ColorConverters, null, [{
19664
    key: "CMYK_G",
19665
    value: function CMYK_G(_ref) {
19666
      var _ref2 = _slicedToArray(_ref, 4),
19667
          c = _ref2[0],
19668
          y = _ref2[1],
19669
          m = _ref2[2],
19670
          k = _ref2[3];
19671

19672
      return ["G", 1 - Math.min(1, 0.3 * c + 0.59 * m + 0.11 * y + k)];
19673
    }
19674
  }, {
19675
    key: "G_CMYK",
19676
    value: function G_CMYK(_ref3) {
19677
      var _ref4 = _slicedToArray(_ref3, 1),
19678
          g = _ref4[0];
19679

19680
      return ["CMYK", 0, 0, 0, 1 - g];
19681
    }
19682
  }, {
19683
    key: "G_RGB",
19684
    value: function G_RGB(_ref5) {
19685
      var _ref6 = _slicedToArray(_ref5, 1),
19686
          g = _ref6[0];
19687

19688
      return ["RGB", g, g, g];
19689
    }
19690
  }, {
19691
    key: "G_HTML",
19692
    value: function G_HTML(_ref7) {
19693
      var _ref8 = _slicedToArray(_ref7, 1),
19694
          g = _ref8[0];
19695

19696
      var G = makeColorComp(g);
19697
      return "#".concat(G).concat(G).concat(G);
19698
    }
19699
  }, {
19700
    key: "RGB_G",
19701
    value: function RGB_G(_ref9) {
19702
      var _ref10 = _slicedToArray(_ref9, 3),
19703
          r = _ref10[0],
19704
          g = _ref10[1],
19705
          b = _ref10[2];
19706

19707
      return ["G", 0.3 * r + 0.59 * g + 0.11 * b];
19708
    }
19709
  }, {
19710
    key: "RGB_HTML",
19711
    value: function RGB_HTML(_ref11) {
19712
      var _ref12 = _slicedToArray(_ref11, 3),
19713
          r = _ref12[0],
19714
          g = _ref12[1],
19715
          b = _ref12[2];
19716

19717
      var R = makeColorComp(r);
19718
      var G = makeColorComp(g);
19719
      var B = makeColorComp(b);
19720
      return "#".concat(R).concat(G).concat(B);
19721
    }
19722
  }, {
19723
    key: "T_HTML",
19724
    value: function T_HTML() {
19725
      return "#00000000";
19726
    }
19727
  }, {
19728
    key: "CMYK_RGB",
19729
    value: function CMYK_RGB(_ref13) {
19730
      var _ref14 = _slicedToArray(_ref13, 4),
19731
          c = _ref14[0],
19732
          y = _ref14[1],
19733
          m = _ref14[2],
19734
          k = _ref14[3];
19735

19736
      return ["RGB", 1 - Math.min(1, c + k), 1 - Math.min(1, m + k), 1 - Math.min(1, y + k)];
19737
    }
19738
  }, {
19739
    key: "CMYK_HTML",
19740
    value: function CMYK_HTML(components) {
19741
      return this.RGB_HTML(this.CMYK_RGB(components));
19742
    }
19743
  }, {
19744
    key: "RGB_CMYK",
19745
    value: function RGB_CMYK(_ref15) {
19746
      var _ref16 = _slicedToArray(_ref15, 3),
19747
          r = _ref16[0],
19748
          g = _ref16[1],
19749
          b = _ref16[2];
19750

19751
      var c = 1 - r;
19752
      var m = 1 - g;
19753
      var y = 1 - b;
19754
      var k = Math.min(c, m, y);
19755
      return ["CMYK", c, m, y, k];
19756
    }
19757
  }]);
19758

19759
  return ColorConverters;
19760
}();
19761

19762
exports.ColorConverters = ColorConverters;
19763

19764
/***/ }),
19765
/* 140 */
19766
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
19767

19768
"use strict";
19769

19770

19771
Object.defineProperty(exports, "__esModule", ({
19772
  value: true
19773
}));
19774
exports.renderTextLayer = void 0;
19775

19776
var _util = __w_pdfjs_require__(4);
19777

19778
var renderTextLayer = function renderTextLayerClosure() {
19779
  var MAX_TEXT_DIVS_TO_RENDER = 100000;
19780
  var DEFAULT_FONT_SIZE = 30;
19781
  var DEFAULT_FONT_ASCENT = 0.8;
19782
  var ascentCache = new Map();
19783
  var NonWhitespaceRegexp = /\S/;
19784

19785
  function isAllWhitespace(str) {
19786
    return !NonWhitespaceRegexp.test(str);
19787
  }
19788

19789
  function getAscent(fontFamily, ctx) {
19790
    var cachedAscent = ascentCache.get(fontFamily);
19791

19792
    if (cachedAscent) {
19793
      return cachedAscent;
19794
    }
19795

19796
    ctx.save();
19797
    ctx.font = "".concat(DEFAULT_FONT_SIZE, "px ").concat(fontFamily);
19798
    var metrics = ctx.measureText("");
19799
    var ascent = metrics.fontBoundingBoxAscent;
19800
    var descent = Math.abs(metrics.fontBoundingBoxDescent);
19801

19802
    if (ascent) {
19803
      ctx.restore();
19804
      var ratio = ascent / (ascent + descent);
19805
      ascentCache.set(fontFamily, ratio);
19806
      return ratio;
19807
    }
19808

19809
    ctx.strokeStyle = "red";
19810
    ctx.clearRect(0, 0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE);
19811
    ctx.strokeText("g", 0, 0);
19812
    var pixels = ctx.getImageData(0, 0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE).data;
19813
    descent = 0;
19814

19815
    for (var i = pixels.length - 1 - 3; i >= 0; i -= 4) {
19816
      if (pixels[i] > 0) {
19817
        descent = Math.ceil(i / 4 / DEFAULT_FONT_SIZE);
19818
        break;
19819
      }
19820
    }
19821

19822
    ctx.clearRect(0, 0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE);
19823
    ctx.strokeText("A", 0, DEFAULT_FONT_SIZE);
19824
    pixels = ctx.getImageData(0, 0, DEFAULT_FONT_SIZE, DEFAULT_FONT_SIZE).data;
19825
    ascent = 0;
19826

19827
    for (var _i = 0, ii = pixels.length; _i < ii; _i += 4) {
19828
      if (pixels[_i] > 0) {
19829
        ascent = DEFAULT_FONT_SIZE - Math.floor(_i / 4 / DEFAULT_FONT_SIZE);
19830
        break;
19831
      }
19832
    }
19833

19834
    ctx.restore();
19835

19836
    if (ascent) {
19837
      var _ratio = ascent / (ascent + descent);
19838

19839
      ascentCache.set(fontFamily, _ratio);
19840
      return _ratio;
19841
    }
19842

19843
    ascentCache.set(fontFamily, DEFAULT_FONT_ASCENT);
19844
    return DEFAULT_FONT_ASCENT;
19845
  }
19846

19847
  function appendText(task, geom, styles, ctx) {
19848
    var textDiv = document.createElement("span");
19849
    var textDivProperties = {
19850
      angle: 0,
19851
      canvasWidth: 0,
19852
      isWhitespace: false,
19853
      originalTransform: null,
19854
      paddingBottom: 0,
19855
      paddingLeft: 0,
19856
      paddingRight: 0,
19857
      paddingTop: 0,
19858
      scale: 1
19859
    };
19860

19861
    task._textDivs.push(textDiv);
19862

19863
    if (isAllWhitespace(geom.str)) {
19864
      textDivProperties.isWhitespace = true;
19865

19866
      task._textDivProperties.set(textDiv, textDivProperties);
19867

19868
      return;
19869
    }
19870

19871
    var tx = _util.Util.transform(task._viewport.transform, geom.transform);
19872

19873
    var angle = Math.atan2(tx[1], tx[0]);
19874
    var style = styles[geom.fontName];
19875

19876
    if (style.vertical) {
19877
      angle += Math.PI / 2;
19878
    }
19879

19880
    var fontHeight = Math.hypot(tx[2], tx[3]);
19881
    var fontAscent = fontHeight * getAscent(style.fontFamily, ctx);
19882
    var left, top;
19883

19884
    if (angle === 0) {
19885
      left = tx[4];
19886
      top = tx[5] - fontAscent;
19887
    } else {
19888
      left = tx[4] + fontAscent * Math.sin(angle);
19889
      top = tx[5] - fontAscent * Math.cos(angle);
19890
    }
19891

19892
    textDiv.style.left = "".concat(left, "px");
19893
    textDiv.style.top = "".concat(top, "px");
19894
    textDiv.style.fontSize = "".concat(fontHeight, "px");
19895
    textDiv.style.fontFamily = style.fontFamily;
19896
    textDiv.textContent = geom.str;
19897
    textDiv.dir = geom.dir;
19898

19899
    if (task._fontInspectorEnabled) {
19900
      textDiv.dataset.fontName = geom.fontName;
19901
    }
19902

19903
    if (angle !== 0) {
19904
      textDivProperties.angle = angle * (180 / Math.PI);
19905
    }
19906

19907
    var shouldScaleText = false;
19908

19909
    if (geom.str.length > 1) {
19910
      shouldScaleText = true;
19911
    } else if (geom.transform[0] !== geom.transform[3]) {
19912
      var absScaleX = Math.abs(geom.transform[0]),
19913
          absScaleY = Math.abs(geom.transform[3]);
19914

19915
      if (absScaleX !== absScaleY && Math.max(absScaleX, absScaleY) / Math.min(absScaleX, absScaleY) > 1.5) {
19916
        shouldScaleText = true;
19917
      }
19918
    }
19919

19920
    if (shouldScaleText) {
19921
      if (style.vertical) {
19922
        textDivProperties.canvasWidth = geom.height * task._viewport.scale;
19923
      } else {
19924
        textDivProperties.canvasWidth = geom.width * task._viewport.scale;
19925
      }
19926
    }
19927

19928
    task._textDivProperties.set(textDiv, textDivProperties);
19929

19930
    if (task._textContentStream) {
19931
      task._layoutText(textDiv);
19932
    }
19933

19934
    if (task._enhanceTextSelection) {
19935
      var angleCos = 1,
19936
          angleSin = 0;
19937

19938
      if (angle !== 0) {
19939
        angleCos = Math.cos(angle);
19940
        angleSin = Math.sin(angle);
19941
      }
19942

19943
      var divWidth = (style.vertical ? geom.height : geom.width) * task._viewport.scale;
19944
      var divHeight = fontHeight;
19945
      var m, b;
19946

19947
      if (angle !== 0) {
19948
        m = [angleCos, angleSin, -angleSin, angleCos, left, top];
19949
        b = _util.Util.getAxialAlignedBoundingBox([0, 0, divWidth, divHeight], m);
19950
      } else {
19951
        b = [left, top, left + divWidth, top + divHeight];
19952
      }
19953

19954
      task._bounds.push({
19955
        left: b[0],
19956
        top: b[1],
19957
        right: b[2],
19958
        bottom: b[3],
19959
        div: textDiv,
19960
        size: [divWidth, divHeight],
19961
        m: m
19962
      });
19963
    }
19964
  }
19965

19966
  function render(task) {
19967
    if (task._canceled) {
19968
      return;
19969
    }
19970

19971
    var textDivs = task._textDivs;
19972
    var capability = task._capability;
19973
    var textDivsLength = textDivs.length;
19974

19975
    if (textDivsLength > MAX_TEXT_DIVS_TO_RENDER) {
19976
      task._renderingDone = true;
19977
      capability.resolve();
19978
      return;
19979
    }
19980

19981
    if (!task._textContentStream) {
19982
      for (var i = 0; i < textDivsLength; i++) {
19983
        task._layoutText(textDivs[i]);
19984
      }
19985
    }
19986

19987
    task._renderingDone = true;
19988
    capability.resolve();
19989
  }
19990

19991
  function findPositiveMin(ts, offset, count) {
19992
    var result = 0;
19993

19994
    for (var i = 0; i < count; i++) {
19995
      var t = ts[offset++];
19996

19997
      if (t > 0) {
19998
        result = result ? Math.min(t, result) : t;
19999
      }
20000
    }
20001

20002
    return result;
20003
  }
20004

20005
  function expand(task) {
20006
    var bounds = task._bounds;
20007
    var viewport = task._viewport;
20008
    var expanded = expandBounds(viewport.width, viewport.height, bounds);
20009

20010
    var _loop = function _loop(i) {
20011
      var div = bounds[i].div;
20012

20013
      var divProperties = task._textDivProperties.get(div);
20014

20015
      if (divProperties.angle === 0) {
20016
        divProperties.paddingLeft = bounds[i].left - expanded[i].left;
20017
        divProperties.paddingTop = bounds[i].top - expanded[i].top;
20018
        divProperties.paddingRight = expanded[i].right - bounds[i].right;
20019
        divProperties.paddingBottom = expanded[i].bottom - bounds[i].bottom;
20020

20021
        task._textDivProperties.set(div, divProperties);
20022

20023
        return "continue";
20024
      }
20025

20026
      var e = expanded[i],
20027
          b = bounds[i];
20028
      var m = b.m,
20029
          c = m[0],
20030
          s = m[1];
20031
      var points = [[0, 0], [0, b.size[1]], [b.size[0], 0], b.size];
20032
      var ts = new Float64Array(64);
20033
      points.forEach(function (p, j) {
20034
        var t = _util.Util.applyTransform(p, m);
20035

20036
        ts[j + 0] = c && (e.left - t[0]) / c;
20037
        ts[j + 4] = s && (e.top - t[1]) / s;
20038
        ts[j + 8] = c && (e.right - t[0]) / c;
20039
        ts[j + 12] = s && (e.bottom - t[1]) / s;
20040
        ts[j + 16] = s && (e.left - t[0]) / -s;
20041
        ts[j + 20] = c && (e.top - t[1]) / c;
20042
        ts[j + 24] = s && (e.right - t[0]) / -s;
20043
        ts[j + 28] = c && (e.bottom - t[1]) / c;
20044
        ts[j + 32] = c && (e.left - t[0]) / -c;
20045
        ts[j + 36] = s && (e.top - t[1]) / -s;
20046
        ts[j + 40] = c && (e.right - t[0]) / -c;
20047
        ts[j + 44] = s && (e.bottom - t[1]) / -s;
20048
        ts[j + 48] = s && (e.left - t[0]) / s;
20049
        ts[j + 52] = c && (e.top - t[1]) / -c;
20050
        ts[j + 56] = s && (e.right - t[0]) / s;
20051
        ts[j + 60] = c && (e.bottom - t[1]) / -c;
20052
      });
20053
      var boxScale = 1 + Math.min(Math.abs(c), Math.abs(s));
20054
      divProperties.paddingLeft = findPositiveMin(ts, 32, 16) / boxScale;
20055
      divProperties.paddingTop = findPositiveMin(ts, 48, 16) / boxScale;
20056
      divProperties.paddingRight = findPositiveMin(ts, 0, 16) / boxScale;
20057
      divProperties.paddingBottom = findPositiveMin(ts, 16, 16) / boxScale;
20058

20059
      task._textDivProperties.set(div, divProperties);
20060
    };
20061

20062
    for (var i = 0; i < expanded.length; i++) {
20063
      var _ret = _loop(i);
20064

20065
      if (_ret === "continue") continue;
20066
    }
20067
  }
20068

20069
  function expandBounds(width, height, boxes) {
20070
    var bounds = boxes.map(function (box, i) {
20071
      return {
20072
        x1: box.left,
20073
        y1: box.top,
20074
        x2: box.right,
20075
        y2: box.bottom,
20076
        index: i,
20077
        x1New: undefined,
20078
        x2New: undefined
20079
      };
20080
    });
20081
    expandBoundsLTR(width, bounds);
20082
    var expanded = new Array(boxes.length);
20083
    bounds.forEach(function (b) {
20084
      var i = b.index;
20085
      expanded[i] = {
20086
        left: b.x1New,
20087
        top: 0,
20088
        right: b.x2New,
20089
        bottom: 0
20090
      };
20091
    });
20092
    boxes.map(function (box, i) {
20093
      var e = expanded[i],
20094
          b = bounds[i];
20095
      b.x1 = box.top;
20096
      b.y1 = width - e.right;
20097
      b.x2 = box.bottom;
20098
      b.y2 = width - e.left;
20099
      b.index = i;
20100
      b.x1New = undefined;
20101
      b.x2New = undefined;
20102
    });
20103
    expandBoundsLTR(height, bounds);
20104
    bounds.forEach(function (b) {
20105
      var i = b.index;
20106
      expanded[i].top = b.x1New;
20107
      expanded[i].bottom = b.x2New;
20108
    });
20109
    return expanded;
20110
  }
20111

20112
  function expandBoundsLTR(width, bounds) {
20113
    bounds.sort(function (a, b) {
20114
      return a.x1 - b.x1 || a.index - b.index;
20115
    });
20116
    var fakeBoundary = {
20117
      x1: -Infinity,
20118
      y1: -Infinity,
20119
      x2: 0,
20120
      y2: Infinity,
20121
      index: -1,
20122
      x1New: 0,
20123
      x2New: 0
20124
    };
20125
    var horizon = [{
20126
      start: -Infinity,
20127
      end: Infinity,
20128
      boundary: fakeBoundary
20129
    }];
20130
    bounds.forEach(function (boundary) {
20131
      var i = 0;
20132

20133
      while (i < horizon.length && horizon[i].end <= boundary.y1) {
20134
        i++;
20135
      }
20136

20137
      var j = horizon.length - 1;
20138

20139
      while (j >= 0 && horizon[j].start >= boundary.y2) {
20140
        j--;
20141
      }
20142

20143
      var horizonPart, affectedBoundary;
20144
      var q,
20145
          k,
20146
          maxXNew = -Infinity;
20147

20148
      for (q = i; q <= j; q++) {
20149
        horizonPart = horizon[q];
20150
        affectedBoundary = horizonPart.boundary;
20151
        var xNew = void 0;
20152

20153
        if (affectedBoundary.x2 > boundary.x1) {
20154
          xNew = affectedBoundary.index > boundary.index ? affectedBoundary.x1New : boundary.x1;
20155
        } else if (affectedBoundary.x2New === undefined) {
20156
          xNew = (affectedBoundary.x2 + boundary.x1) / 2;
20157
        } else {
20158
          xNew = affectedBoundary.x2New;
20159
        }
20160

20161
        if (xNew > maxXNew) {
20162
          maxXNew = xNew;
20163
        }
20164
      }
20165

20166
      boundary.x1New = maxXNew;
20167

20168
      for (q = i; q <= j; q++) {
20169
        horizonPart = horizon[q];
20170
        affectedBoundary = horizonPart.boundary;
20171

20172
        if (affectedBoundary.x2New === undefined) {
20173
          if (affectedBoundary.x2 > boundary.x1) {
20174
            if (affectedBoundary.index > boundary.index) {
20175
              affectedBoundary.x2New = affectedBoundary.x2;
20176
            }
20177
          } else {
20178
            affectedBoundary.x2New = maxXNew;
20179
          }
20180
        } else if (affectedBoundary.x2New > maxXNew) {
20181
          affectedBoundary.x2New = Math.max(maxXNew, affectedBoundary.x2);
20182
        }
20183
      }
20184

20185
      var changedHorizon = [];
20186
      var lastBoundary = null;
20187

20188
      for (q = i; q <= j; q++) {
20189
        horizonPart = horizon[q];
20190
        affectedBoundary = horizonPart.boundary;
20191
        var useBoundary = affectedBoundary.x2 > boundary.x2 ? affectedBoundary : boundary;
20192

20193
        if (lastBoundary === useBoundary) {
20194
          changedHorizon[changedHorizon.length - 1].end = horizonPart.end;
20195
        } else {
20196
          changedHorizon.push({
20197
            start: horizonPart.start,
20198
            end: horizonPart.end,
20199
            boundary: useBoundary
20200
          });
20201
          lastBoundary = useBoundary;
20202
        }
20203
      }
20204

20205
      if (horizon[i].start < boundary.y1) {
20206
        changedHorizon[0].start = boundary.y1;
20207
        changedHorizon.unshift({
20208
          start: horizon[i].start,
20209
          end: boundary.y1,
20210
          boundary: horizon[i].boundary
20211
        });
20212
      }
20213

20214
      if (boundary.y2 < horizon[j].end) {
20215
        changedHorizon[changedHorizon.length - 1].end = boundary.y2;
20216
        changedHorizon.push({
20217
          start: boundary.y2,
20218
          end: horizon[j].end,
20219
          boundary: horizon[j].boundary
20220
        });
20221
      }
20222

20223
      for (q = i; q <= j; q++) {
20224
        horizonPart = horizon[q];
20225
        affectedBoundary = horizonPart.boundary;
20226

20227
        if (affectedBoundary.x2New !== undefined) {
20228
          continue;
20229
        }
20230

20231
        var used = false;
20232

20233
        for (k = i - 1; !used && k >= 0 && horizon[k].start >= affectedBoundary.y1; k--) {
20234
          used = horizon[k].boundary === affectedBoundary;
20235
        }
20236

20237
        for (k = j + 1; !used && k < horizon.length && horizon[k].end <= affectedBoundary.y2; k++) {
20238
          used = horizon[k].boundary === affectedBoundary;
20239
        }
20240

20241
        for (k = 0; !used && k < changedHorizon.length; k++) {
20242
          used = changedHorizon[k].boundary === affectedBoundary;
20243
        }
20244

20245
        if (!used) {
20246
          affectedBoundary.x2New = maxXNew;
20247
        }
20248
      }
20249

20250
      Array.prototype.splice.apply(horizon, [i, j - i + 1].concat(changedHorizon));
20251
    });
20252
    horizon.forEach(function (horizonPart) {
20253
      var affectedBoundary = horizonPart.boundary;
20254

20255
      if (affectedBoundary.x2New === undefined) {
20256
        affectedBoundary.x2New = Math.max(width, affectedBoundary.x2);
20257
      }
20258
    });
20259
  }
20260

20261
  function TextLayerRenderTask(_ref) {
20262
    var _globalThis$FontInspe,
20263
        _this = this;
20264

20265
    var textContent = _ref.textContent,
20266
        textContentStream = _ref.textContentStream,
20267
        container = _ref.container,
20268
        viewport = _ref.viewport,
20269
        textDivs = _ref.textDivs,
20270
        textContentItemsStr = _ref.textContentItemsStr,
20271
        enhanceTextSelection = _ref.enhanceTextSelection;
20272
    this._textContent = textContent;
20273
    this._textContentStream = textContentStream;
20274
    this._container = container;
20275
    this._document = container.ownerDocument;
20276
    this._viewport = viewport;
20277
    this._textDivs = textDivs || [];
20278
    this._textContentItemsStr = textContentItemsStr || [];
20279
    this._enhanceTextSelection = !!enhanceTextSelection;
20280
    this._fontInspectorEnabled = !!((_globalThis$FontInspe = globalThis.FontInspector) !== null && _globalThis$FontInspe !== void 0 && _globalThis$FontInspe.enabled);
20281
    this._reader = null;
20282
    this._layoutTextLastFontSize = null;
20283
    this._layoutTextLastFontFamily = null;
20284
    this._layoutTextCtx = null;
20285
    this._textDivProperties = new WeakMap();
20286
    this._renderingDone = false;
20287
    this._canceled = false;
20288
    this._capability = (0, _util.createPromiseCapability)();
20289
    this._renderTimer = null;
20290
    this._bounds = [];
20291

20292
    this._capability.promise["finally"](function () {
20293
      if (_this._layoutTextCtx) {
20294
        _this._layoutTextCtx.canvas.width = 0;
20295
        _this._layoutTextCtx.canvas.height = 0;
20296
        _this._layoutTextCtx = null;
20297
      }
20298
    })["catch"](function () {});
20299
  }
20300

20301
  TextLayerRenderTask.prototype = {
20302
    get promise() {
20303
      return this._capability.promise;
20304
    },
20305

20306
    cancel: function TextLayer_cancel() {
20307
      this._canceled = true;
20308

20309
      if (this._reader) {
20310
        this._reader.cancel(new _util.AbortException("TextLayer task cancelled."));
20311

20312
        this._reader = null;
20313
      }
20314

20315
      if (this._renderTimer !== null) {
20316
        clearTimeout(this._renderTimer);
20317
        this._renderTimer = null;
20318
      }
20319

20320
      this._capability.reject(new Error("TextLayer task cancelled."));
20321
    },
20322
    _processItems: function _processItems(items, styleCache) {
20323
      for (var i = 0, len = items.length; i < len; i++) {
20324
        this._textContentItemsStr.push(items[i].str);
20325

20326
        appendText(this, items[i], styleCache, this._layoutTextCtx);
20327
      }
20328
    },
20329
    _layoutText: function _layoutText(textDiv) {
20330
      var textDivProperties = this._textDivProperties.get(textDiv);
20331

20332
      if (textDivProperties.isWhitespace) {
20333
        return;
20334
      }
20335

20336
      var transform = "";
20337

20338
      if (textDivProperties.canvasWidth !== 0) {
20339
        var _textDiv$style = textDiv.style,
20340
            fontSize = _textDiv$style.fontSize,
20341
            fontFamily = _textDiv$style.fontFamily;
20342

20343
        if (fontSize !== this._layoutTextLastFontSize || fontFamily !== this._layoutTextLastFontFamily) {
20344
          this._layoutTextCtx.font = "".concat(fontSize, " ").concat(fontFamily);
20345
          this._layoutTextLastFontSize = fontSize;
20346
          this._layoutTextLastFontFamily = fontFamily;
20347
        }
20348

20349
        var _this$_layoutTextCtx$ = this._layoutTextCtx.measureText(textDiv.textContent),
20350
            width = _this$_layoutTextCtx$.width;
20351

20352
        if (width > 0) {
20353
          textDivProperties.scale = textDivProperties.canvasWidth / width;
20354
          transform = "scaleX(".concat(textDivProperties.scale, ")");
20355
        }
20356
      }
20357

20358
      if (textDivProperties.angle !== 0) {
20359
        transform = "rotate(".concat(textDivProperties.angle, "deg) ").concat(transform);
20360
      }
20361

20362
      if (transform.length > 0) {
20363
        if (this._enhanceTextSelection) {
20364
          textDivProperties.originalTransform = transform;
20365
        }
20366

20367
        textDiv.style.transform = transform;
20368
      }
20369

20370
      this._textDivProperties.set(textDiv, textDivProperties);
20371

20372
      this._container.appendChild(textDiv);
20373
    },
20374
    _render: function TextLayer_render(timeout) {
20375
      var _this2 = this;
20376

20377
      var capability = (0, _util.createPromiseCapability)();
20378
      var styleCache = Object.create(null);
20379

20380
      var canvas = this._document.createElement("canvas");
20381

20382
      canvas.height = canvas.width = DEFAULT_FONT_SIZE;
20383
      canvas.mozOpaque = true;
20384
      this._layoutTextCtx = canvas.getContext("2d", {
20385
        alpha: false
20386
      });
20387

20388
      if (this._textContent) {
20389
        var textItems = this._textContent.items;
20390
        var textStyles = this._textContent.styles;
20391

20392
        this._processItems(textItems, textStyles);
20393

20394
        capability.resolve();
20395
      } else if (this._textContentStream) {
20396
        var pump = function pump() {
20397
          _this2._reader.read().then(function (_ref2) {
20398
            var value = _ref2.value,
20399
                done = _ref2.done;
20400

20401
            if (done) {
20402
              capability.resolve();
20403
              return;
20404
            }
20405

20406
            Object.assign(styleCache, value.styles);
20407

20408
            _this2._processItems(value.items, styleCache);
20409

20410
            pump();
20411
          }, capability.reject);
20412
        };
20413

20414
        this._reader = this._textContentStream.getReader();
20415
        pump();
20416
      } else {
20417
        throw new Error('Neither "textContent" nor "textContentStream"' + " parameters specified.");
20418
      }
20419

20420
      capability.promise.then(function () {
20421
        styleCache = null;
20422

20423
        if (!timeout) {
20424
          render(_this2);
20425
        } else {
20426
          _this2._renderTimer = setTimeout(function () {
20427
            render(_this2);
20428
            _this2._renderTimer = null;
20429
          }, timeout);
20430
        }
20431
      }, this._capability.reject);
20432
    },
20433
    expandTextDivs: function TextLayer_expandTextDivs(expandDivs) {
20434
      if (!this._enhanceTextSelection || !this._renderingDone) {
20435
        return;
20436
      }
20437

20438
      if (this._bounds !== null) {
20439
        expand(this);
20440
        this._bounds = null;
20441
      }
20442

20443
      var transformBuf = [],
20444
          paddingBuf = [];
20445

20446
      for (var i = 0, ii = this._textDivs.length; i < ii; i++) {
20447
        var div = this._textDivs[i];
20448

20449
        var divProps = this._textDivProperties.get(div);
20450

20451
        if (divProps.isWhitespace) {
20452
          continue;
20453
        }
20454

20455
        if (expandDivs) {
20456
          transformBuf.length = 0;
20457
          paddingBuf.length = 0;
20458

20459
          if (divProps.originalTransform) {
20460
            transformBuf.push(divProps.originalTransform);
20461
          }
20462

20463
          if (divProps.paddingTop > 0) {
20464
            paddingBuf.push("".concat(divProps.paddingTop, "px"));
20465
            transformBuf.push("translateY(".concat(-divProps.paddingTop, "px)"));
20466
          } else {
20467
            paddingBuf.push(0);
20468
          }
20469

20470
          if (divProps.paddingRight > 0) {
20471
            paddingBuf.push("".concat(divProps.paddingRight / divProps.scale, "px"));
20472
          } else {
20473
            paddingBuf.push(0);
20474
          }
20475

20476
          if (divProps.paddingBottom > 0) {
20477
            paddingBuf.push("".concat(divProps.paddingBottom, "px"));
20478
          } else {
20479
            paddingBuf.push(0);
20480
          }
20481

20482
          if (divProps.paddingLeft > 0) {
20483
            paddingBuf.push("".concat(divProps.paddingLeft / divProps.scale, "px"));
20484
            transformBuf.push("translateX(".concat(-divProps.paddingLeft / divProps.scale, "px)"));
20485
          } else {
20486
            paddingBuf.push(0);
20487
          }
20488

20489
          div.style.padding = paddingBuf.join(" ");
20490

20491
          if (transformBuf.length) {
20492
            div.style.transform = transformBuf.join(" ");
20493
          }
20494
        } else {
20495
          div.style.padding = null;
20496
          div.style.transform = divProps.originalTransform;
20497
        }
20498
      }
20499
    }
20500
  };
20501

20502
  function renderTextLayer(renderParameters) {
20503
    var task = new TextLayerRenderTask({
20504
      textContent: renderParameters.textContent,
20505
      textContentStream: renderParameters.textContentStream,
20506
      container: renderParameters.container,
20507
      viewport: renderParameters.viewport,
20508
      textDivs: renderParameters.textDivs,
20509
      textContentItemsStr: renderParameters.textContentItemsStr,
20510
      enhanceTextSelection: renderParameters.enhanceTextSelection
20511
    });
20512

20513
    task._render(renderParameters.timeout);
20514

20515
    return task;
20516
  }
20517

20518
  return renderTextLayer;
20519
}();
20520

20521
exports.renderTextLayer = renderTextLayer;
20522

20523
/***/ }),
20524
/* 141 */
20525
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
20526

20527
"use strict";
20528

20529

20530
Object.defineProperty(exports, "__esModule", ({
20531
  value: true
20532
}));
20533
exports.SVGGraphics = void 0;
20534

20535
var _util = __w_pdfjs_require__(4);
20536

20537
var _display_utils = __w_pdfjs_require__(1);
20538

20539
var _is_node = __w_pdfjs_require__(6);
20540

20541
function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); }
20542

20543
function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
20544

20545
function _iterableToArray(iter) { if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); }
20546

20547
function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) return _arrayLikeToArray(arr); }
20548

20549
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
20550

20551
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
20552

20553
function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
20554

20555
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
20556

20557
function _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e2) { throw _e2; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e3) { didErr = true; err = _e3; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
20558

20559
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
20560

20561
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
20562

20563
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
20564

20565
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
20566

20567
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
20568

20569
var SVGGraphics = function SVGGraphics() {
20570
  throw new Error("Not implemented: SVGGraphics");
20571
};
20572

20573
exports.SVGGraphics = SVGGraphics;
20574
{
20575
  var opListToTree = function opListToTree(opList) {
20576
    var opTree = [];
20577
    var tmp = [];
20578

20579
    var _iterator = _createForOfIteratorHelper(opList),
20580
        _step;
20581

20582
    try {
20583
      for (_iterator.s(); !(_step = _iterator.n()).done;) {
20584
        var opListElement = _step.value;
20585

20586
        if (opListElement.fn === "save") {
20587
          opTree.push({
20588
            fnId: 92,
20589
            fn: "group",
20590
            items: []
20591
          });
20592
          tmp.push(opTree);
20593
          opTree = opTree[opTree.length - 1].items;
20594
          continue;
20595
        }
20596

20597
        if (opListElement.fn === "restore") {
20598
          opTree = tmp.pop();
20599
        } else {
20600
          opTree.push(opListElement);
20601
        }
20602
      }
20603
    } catch (err) {
20604
      _iterator.e(err);
20605
    } finally {
20606
      _iterator.f();
20607
    }
20608

20609
    return opTree;
20610
  };
20611

20612
  var pf = function pf(value) {
20613
    if (Number.isInteger(value)) {
20614
      return value.toString();
20615
    }
20616

20617
    var s = value.toFixed(10);
20618
    var i = s.length - 1;
20619

20620
    if (s[i] !== "0") {
20621
      return s;
20622
    }
20623

20624
    do {
20625
      i--;
20626
    } while (s[i] === "0");
20627

20628
    return s.substring(0, s[i] === "." ? i : i + 1);
20629
  };
20630

20631
  var pm = function pm(m) {
20632
    if (m[4] === 0 && m[5] === 0) {
20633
      if (m[1] === 0 && m[2] === 0) {
20634
        if (m[0] === 1 && m[3] === 1) {
20635
          return "";
20636
        }
20637

20638
        return "scale(".concat(pf(m[0]), " ").concat(pf(m[3]), ")");
20639
      }
20640

20641
      if (m[0] === m[3] && m[1] === -m[2]) {
20642
        var a = Math.acos(m[0]) * 180 / Math.PI;
20643
        return "rotate(".concat(pf(a), ")");
20644
      }
20645
    } else {
20646
      if (m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1) {
20647
        return "translate(".concat(pf(m[4]), " ").concat(pf(m[5]), ")");
20648
      }
20649
    }
20650

20651
    return "matrix(".concat(pf(m[0]), " ").concat(pf(m[1]), " ").concat(pf(m[2]), " ").concat(pf(m[3]), " ").concat(pf(m[4]), " ") + "".concat(pf(m[5]), ")");
20652
  };
20653

20654
  var SVG_DEFAULTS = {
20655
    fontStyle: "normal",
20656
    fontWeight: "normal",
20657
    fillColor: "#000000"
20658
  };
20659
  var XML_NS = "http://www.w3.org/XML/1998/namespace";
20660
  var XLINK_NS = "http://www.w3.org/1999/xlink";
20661
  var LINE_CAP_STYLES = ["butt", "round", "square"];
20662
  var LINE_JOIN_STYLES = ["miter", "round", "bevel"];
20663

20664
  var convertImgDataToPng = function () {
20665
    var PNG_HEADER = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
20666
    var CHUNK_WRAPPER_SIZE = 12;
20667
    var crcTable = new Int32Array(256);
20668

20669
    for (var i = 0; i < 256; i++) {
20670
      var c = i;
20671

20672
      for (var h = 0; h < 8; h++) {
20673
        if (c & 1) {
20674
          c = 0xedb88320 ^ c >> 1 & 0x7fffffff;
20675
        } else {
20676
          c = c >> 1 & 0x7fffffff;
20677
        }
20678
      }
20679

20680
      crcTable[i] = c;
20681
    }
20682

20683
    function crc32(data, start, end) {
20684
      var crc = -1;
20685

20686
      for (var _i = start; _i < end; _i++) {
20687
        var a = (crc ^ data[_i]) & 0xff;
20688
        var b = crcTable[a];
20689
        crc = crc >>> 8 ^ b;
20690
      }
20691

20692
      return crc ^ -1;
20693
    }
20694

20695
    function writePngChunk(type, body, data, offset) {
20696
      var p = offset;
20697
      var len = body.length;
20698
      data[p] = len >> 24 & 0xff;
20699
      data[p + 1] = len >> 16 & 0xff;
20700
      data[p + 2] = len >> 8 & 0xff;
20701
      data[p + 3] = len & 0xff;
20702
      p += 4;
20703
      data[p] = type.charCodeAt(0) & 0xff;
20704
      data[p + 1] = type.charCodeAt(1) & 0xff;
20705
      data[p + 2] = type.charCodeAt(2) & 0xff;
20706
      data[p + 3] = type.charCodeAt(3) & 0xff;
20707
      p += 4;
20708
      data.set(body, p);
20709
      p += body.length;
20710
      var crc = crc32(data, offset + 4, p);
20711
      data[p] = crc >> 24 & 0xff;
20712
      data[p + 1] = crc >> 16 & 0xff;
20713
      data[p + 2] = crc >> 8 & 0xff;
20714
      data[p + 3] = crc & 0xff;
20715
    }
20716

20717
    function adler32(data, start, end) {
20718
      var a = 1;
20719
      var b = 0;
20720

20721
      for (var _i2 = start; _i2 < end; ++_i2) {
20722
        a = (a + (data[_i2] & 0xff)) % 65521;
20723
        b = (b + a) % 65521;
20724
      }
20725

20726
      return b << 16 | a;
20727
    }
20728

20729
    function deflateSync(literals) {
20730
      if (!_is_node.isNodeJS) {
20731
        return deflateSyncUncompressed(literals);
20732
      }
20733

20734
      try {
20735
        var input;
20736

20737
        if (parseInt(process.versions.node) >= 8) {
20738
          input = literals;
20739
        } else {
20740
          input = Buffer.from(literals);
20741
        }
20742

20743
        var output = require("zlib").deflateSync(input, {
20744
          level: 9
20745
        });
20746

20747
        return output instanceof Uint8Array ? output : new Uint8Array(output);
20748
      } catch (e) {
20749
        (0, _util.warn)("Not compressing PNG because zlib.deflateSync is unavailable: " + e);
20750
      }
20751

20752
      return deflateSyncUncompressed(literals);
20753
    }
20754

20755
    function deflateSyncUncompressed(literals) {
20756
      var len = literals.length;
20757
      var maxBlockLength = 0xffff;
20758
      var deflateBlocks = Math.ceil(len / maxBlockLength);
20759
      var idat = new Uint8Array(2 + len + deflateBlocks * 5 + 4);
20760
      var pi = 0;
20761
      idat[pi++] = 0x78;
20762
      idat[pi++] = 0x9c;
20763
      var pos = 0;
20764

20765
      while (len > maxBlockLength) {
20766
        idat[pi++] = 0x00;
20767
        idat[pi++] = 0xff;
20768
        idat[pi++] = 0xff;
20769
        idat[pi++] = 0x00;
20770
        idat[pi++] = 0x00;
20771
        idat.set(literals.subarray(pos, pos + maxBlockLength), pi);
20772
        pi += maxBlockLength;
20773
        pos += maxBlockLength;
20774
        len -= maxBlockLength;
20775
      }
20776

20777
      idat[pi++] = 0x01;
20778
      idat[pi++] = len & 0xff;
20779
      idat[pi++] = len >> 8 & 0xff;
20780
      idat[pi++] = ~len & 0xffff & 0xff;
20781
      idat[pi++] = (~len & 0xffff) >> 8 & 0xff;
20782
      idat.set(literals.subarray(pos), pi);
20783
      pi += literals.length - pos;
20784
      var adler = adler32(literals, 0, literals.length);
20785
      idat[pi++] = adler >> 24 & 0xff;
20786
      idat[pi++] = adler >> 16 & 0xff;
20787
      idat[pi++] = adler >> 8 & 0xff;
20788
      idat[pi++] = adler & 0xff;
20789
      return idat;
20790
    }
20791

20792
    function encode(imgData, kind, forceDataSchema, isMask) {
20793
      var width = imgData.width;
20794
      var height = imgData.height;
20795
      var bitDepth, colorType, lineSize;
20796
      var bytes = imgData.data;
20797

20798
      switch (kind) {
20799
        case _util.ImageKind.GRAYSCALE_1BPP:
20800
          colorType = 0;
20801
          bitDepth = 1;
20802
          lineSize = width + 7 >> 3;
20803
          break;
20804

20805
        case _util.ImageKind.RGB_24BPP:
20806
          colorType = 2;
20807
          bitDepth = 8;
20808
          lineSize = width * 3;
20809
          break;
20810

20811
        case _util.ImageKind.RGBA_32BPP:
20812
          colorType = 6;
20813
          bitDepth = 8;
20814
          lineSize = width * 4;
20815
          break;
20816

20817
        default:
20818
          throw new Error("invalid format");
20819
      }
20820

20821
      var literals = new Uint8Array((1 + lineSize) * height);
20822
      var offsetLiterals = 0,
20823
          offsetBytes = 0;
20824

20825
      for (var y = 0; y < height; ++y) {
20826
        literals[offsetLiterals++] = 0;
20827
        literals.set(bytes.subarray(offsetBytes, offsetBytes + lineSize), offsetLiterals);
20828
        offsetBytes += lineSize;
20829
        offsetLiterals += lineSize;
20830
      }
20831

20832
      if (kind === _util.ImageKind.GRAYSCALE_1BPP && isMask) {
20833
        offsetLiterals = 0;
20834

20835
        for (var _y = 0; _y < height; _y++) {
20836
          offsetLiterals++;
20837

20838
          for (var _i3 = 0; _i3 < lineSize; _i3++) {
20839
            literals[offsetLiterals++] ^= 0xff;
20840
          }
20841
        }
20842
      }
20843

20844
      var ihdr = new Uint8Array([width >> 24 & 0xff, width >> 16 & 0xff, width >> 8 & 0xff, width & 0xff, height >> 24 & 0xff, height >> 16 & 0xff, height >> 8 & 0xff, height & 0xff, bitDepth, colorType, 0x00, 0x00, 0x00]);
20845
      var idat = deflateSync(literals);
20846
      var pngLength = PNG_HEADER.length + CHUNK_WRAPPER_SIZE * 3 + ihdr.length + idat.length;
20847
      var data = new Uint8Array(pngLength);
20848
      var offset = 0;
20849
      data.set(PNG_HEADER, offset);
20850
      offset += PNG_HEADER.length;
20851
      writePngChunk("IHDR", ihdr, data, offset);
20852
      offset += CHUNK_WRAPPER_SIZE + ihdr.length;
20853
      writePngChunk("IDATA", idat, data, offset);
20854
      offset += CHUNK_WRAPPER_SIZE + idat.length;
20855
      writePngChunk("IEND", new Uint8Array(0), data, offset);
20856
      return (0, _util.createObjectURL)(data, "image/png", forceDataSchema);
20857
    }
20858

20859
    return function convertImgDataToPng(imgData, forceDataSchema, isMask) {
20860
      var kind = imgData.kind === undefined ? _util.ImageKind.GRAYSCALE_1BPP : imgData.kind;
20861
      return encode(imgData, kind, forceDataSchema, isMask);
20862
    };
20863
  }();
20864

20865
  var SVGExtraState = /*#__PURE__*/function () {
20866
    function SVGExtraState() {
20867
      _classCallCheck(this, SVGExtraState);
20868

20869
      this.fontSizeScale = 1;
20870
      this.fontWeight = SVG_DEFAULTS.fontWeight;
20871
      this.fontSize = 0;
20872
      this.textMatrix = _util.IDENTITY_MATRIX;
20873
      this.fontMatrix = _util.FONT_IDENTITY_MATRIX;
20874
      this.leading = 0;
20875
      this.textRenderingMode = _util.TextRenderingMode.FILL;
20876
      this.textMatrixScale = 1;
20877
      this.x = 0;
20878
      this.y = 0;
20879
      this.lineX = 0;
20880
      this.lineY = 0;
20881
      this.charSpacing = 0;
20882
      this.wordSpacing = 0;
20883
      this.textHScale = 1;
20884
      this.textRise = 0;
20885
      this.fillColor = SVG_DEFAULTS.fillColor;
20886
      this.strokeColor = "#000000";
20887
      this.fillAlpha = 1;
20888
      this.strokeAlpha = 1;
20889
      this.lineWidth = 1;
20890
      this.lineJoin = "";
20891
      this.lineCap = "";
20892
      this.miterLimit = 0;
20893
      this.dashArray = [];
20894
      this.dashPhase = 0;
20895
      this.dependencies = [];
20896
      this.activeClipUrl = null;
20897
      this.clipGroup = null;
20898
      this.maskId = "";
20899
    }
20900

20901
    _createClass(SVGExtraState, [{
20902
      key: "clone",
20903
      value: function clone() {
20904
        return Object.create(this);
20905
      }
20906
    }, {
20907
      key: "setCurrentPoint",
20908
      value: function setCurrentPoint(x, y) {
20909
        this.x = x;
20910
        this.y = y;
20911
      }
20912
    }]);
20913

20914
    return SVGExtraState;
20915
  }();
20916

20917
  var clipCount = 0;
20918
  var maskCount = 0;
20919
  var shadingCount = 0;
20920

20921
  exports.SVGGraphics = SVGGraphics = /*#__PURE__*/function () {
20922
    function SVGGraphics(commonObjs, objs) {
20923
      var forceDataSchema = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
20924

20925
      _classCallCheck(this, SVGGraphics);
20926

20927
      this.svgFactory = new _display_utils.DOMSVGFactory();
20928
      this.current = new SVGExtraState();
20929
      this.transformMatrix = _util.IDENTITY_MATRIX;
20930
      this.transformStack = [];
20931
      this.extraStack = [];
20932
      this.commonObjs = commonObjs;
20933
      this.objs = objs;
20934
      this.pendingClip = null;
20935
      this.pendingEOFill = false;
20936
      this.embedFonts = false;
20937
      this.embeddedFonts = Object.create(null);
20938
      this.cssStyle = null;
20939
      this.forceDataSchema = !!forceDataSchema;
20940
      this._operatorIdMapping = [];
20941

20942
      for (var op in _util.OPS) {
20943
        this._operatorIdMapping[_util.OPS[op]] = op;
20944
      }
20945
    }
20946

20947
    _createClass(SVGGraphics, [{
20948
      key: "save",
20949
      value: function save() {
20950
        this.transformStack.push(this.transformMatrix);
20951
        var old = this.current;
20952
        this.extraStack.push(old);
20953
        this.current = old.clone();
20954
      }
20955
    }, {
20956
      key: "restore",
20957
      value: function restore() {
20958
        this.transformMatrix = this.transformStack.pop();
20959
        this.current = this.extraStack.pop();
20960
        this.pendingClip = null;
20961
        this.tgrp = null;
20962
      }
20963
    }, {
20964
      key: "group",
20965
      value: function group(items) {
20966
        this.save();
20967
        this.executeOpTree(items);
20968
        this.restore();
20969
      }
20970
    }, {
20971
      key: "loadDependencies",
20972
      value: function loadDependencies(operatorList) {
20973
        var _this = this;
20974

20975
        var fnArray = operatorList.fnArray;
20976
        var argsArray = operatorList.argsArray;
20977

20978
        for (var i = 0, ii = fnArray.length; i < ii; i++) {
20979
          if (fnArray[i] !== _util.OPS.dependency) {
20980
            continue;
20981
          }
20982

20983
          var _iterator2 = _createForOfIteratorHelper(argsArray[i]),
20984
              _step2;
20985

20986
          try {
20987
            var _loop = function _loop() {
20988
              var obj = _step2.value;
20989
              var objsPool = obj.startsWith("g_") ? _this.commonObjs : _this.objs;
20990
              var promise = new Promise(function (resolve) {
20991
                objsPool.get(obj, resolve);
20992
              });
20993

20994
              _this.current.dependencies.push(promise);
20995
            };
20996

20997
            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
20998
              _loop();
20999
            }
21000
          } catch (err) {
21001
            _iterator2.e(err);
21002
          } finally {
21003
            _iterator2.f();
21004
          }
21005
        }
21006

21007
        return Promise.all(this.current.dependencies);
21008
      }
21009
    }, {
21010
      key: "transform",
21011
      value: function transform(a, b, c, d, e, f) {
21012
        var transformMatrix = [a, b, c, d, e, f];
21013
        this.transformMatrix = _util.Util.transform(this.transformMatrix, transformMatrix);
21014
        this.tgrp = null;
21015
      }
21016
    }, {
21017
      key: "getSVG",
21018
      value: function getSVG(operatorList, viewport) {
21019
        var _this2 = this;
21020

21021
        this.viewport = viewport;
21022

21023
        var svgElement = this._initialize(viewport);
21024

21025
        return this.loadDependencies(operatorList).then(function () {
21026
          _this2.transformMatrix = _util.IDENTITY_MATRIX;
21027

21028
          _this2.executeOpTree(_this2.convertOpList(operatorList));
21029

21030
          return svgElement;
21031
        });
21032
      }
21033
    }, {
21034
      key: "convertOpList",
21035
      value: function convertOpList(operatorList) {
21036
        var operatorIdMapping = this._operatorIdMapping;
21037
        var argsArray = operatorList.argsArray;
21038
        var fnArray = operatorList.fnArray;
21039
        var opList = [];
21040

21041
        for (var i = 0, ii = fnArray.length; i < ii; i++) {
21042
          var fnId = fnArray[i];
21043
          opList.push({
21044
            fnId: fnId,
21045
            fn: operatorIdMapping[fnId],
21046
            args: argsArray[i]
21047
          });
21048
        }
21049

21050
        return opListToTree(opList);
21051
      }
21052
    }, {
21053
      key: "executeOpTree",
21054
      value: function executeOpTree(opTree) {
21055
        var _iterator3 = _createForOfIteratorHelper(opTree),
21056
            _step3;
21057

21058
        try {
21059
          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
21060
            var opTreeElement = _step3.value;
21061
            var fn = opTreeElement.fn;
21062
            var fnId = opTreeElement.fnId;
21063
            var args = opTreeElement.args;
21064

21065
            switch (fnId | 0) {
21066
              case _util.OPS.beginText:
21067
                this.beginText();
21068
                break;
21069

21070
              case _util.OPS.dependency:
21071
                break;
21072

21073
              case _util.OPS.setLeading:
21074
                this.setLeading(args);
21075
                break;
21076

21077
              case _util.OPS.setLeadingMoveText:
21078
                this.setLeadingMoveText(args[0], args[1]);
21079
                break;
21080

21081
              case _util.OPS.setFont:
21082
                this.setFont(args);
21083
                break;
21084

21085
              case _util.OPS.showText:
21086
                this.showText(args[0]);
21087
                break;
21088

21089
              case _util.OPS.showSpacedText:
21090
                this.showText(args[0]);
21091
                break;
21092

21093
              case _util.OPS.endText:
21094
                this.endText();
21095
                break;
21096

21097
              case _util.OPS.moveText:
21098
                this.moveText(args[0], args[1]);
21099
                break;
21100

21101
              case _util.OPS.setCharSpacing:
21102
                this.setCharSpacing(args[0]);
21103
                break;
21104

21105
              case _util.OPS.setWordSpacing:
21106
                this.setWordSpacing(args[0]);
21107
                break;
21108

21109
              case _util.OPS.setHScale:
21110
                this.setHScale(args[0]);
21111
                break;
21112

21113
              case _util.OPS.setTextMatrix:
21114
                this.setTextMatrix(args[0], args[1], args[2], args[3], args[4], args[5]);
21115
                break;
21116

21117
              case _util.OPS.setTextRise:
21118
                this.setTextRise(args[0]);
21119
                break;
21120

21121
              case _util.OPS.setTextRenderingMode:
21122
                this.setTextRenderingMode(args[0]);
21123
                break;
21124

21125
              case _util.OPS.setLineWidth:
21126
                this.setLineWidth(args[0]);
21127
                break;
21128

21129
              case _util.OPS.setLineJoin:
21130
                this.setLineJoin(args[0]);
21131
                break;
21132

21133
              case _util.OPS.setLineCap:
21134
                this.setLineCap(args[0]);
21135
                break;
21136

21137
              case _util.OPS.setMiterLimit:
21138
                this.setMiterLimit(args[0]);
21139
                break;
21140

21141
              case _util.OPS.setFillRGBColor:
21142
                this.setFillRGBColor(args[0], args[1], args[2]);
21143
                break;
21144

21145
              case _util.OPS.setStrokeRGBColor:
21146
                this.setStrokeRGBColor(args[0], args[1], args[2]);
21147
                break;
21148

21149
              case _util.OPS.setStrokeColorN:
21150
                this.setStrokeColorN(args);
21151
                break;
21152

21153
              case _util.OPS.setFillColorN:
21154
                this.setFillColorN(args);
21155
                break;
21156

21157
              case _util.OPS.shadingFill:
21158
                this.shadingFill(args[0]);
21159
                break;
21160

21161
              case _util.OPS.setDash:
21162
                this.setDash(args[0], args[1]);
21163
                break;
21164

21165
              case _util.OPS.setRenderingIntent:
21166
                this.setRenderingIntent(args[0]);
21167
                break;
21168

21169
              case _util.OPS.setFlatness:
21170
                this.setFlatness(args[0]);
21171
                break;
21172

21173
              case _util.OPS.setGState:
21174
                this.setGState(args[0]);
21175
                break;
21176

21177
              case _util.OPS.fill:
21178
                this.fill();
21179
                break;
21180

21181
              case _util.OPS.eoFill:
21182
                this.eoFill();
21183
                break;
21184

21185
              case _util.OPS.stroke:
21186
                this.stroke();
21187
                break;
21188

21189
              case _util.OPS.fillStroke:
21190
                this.fillStroke();
21191
                break;
21192

21193
              case _util.OPS.eoFillStroke:
21194
                this.eoFillStroke();
21195
                break;
21196

21197
              case _util.OPS.clip:
21198
                this.clip("nonzero");
21199
                break;
21200

21201
              case _util.OPS.eoClip:
21202
                this.clip("evenodd");
21203
                break;
21204

21205
              case _util.OPS.paintSolidColorImageMask:
21206
                this.paintSolidColorImageMask();
21207
                break;
21208

21209
              case _util.OPS.paintImageXObject:
21210
                this.paintImageXObject(args[0]);
21211
                break;
21212

21213
              case _util.OPS.paintInlineImageXObject:
21214
                this.paintInlineImageXObject(args[0]);
21215
                break;
21216

21217
              case _util.OPS.paintImageMaskXObject:
21218
                this.paintImageMaskXObject(args[0]);
21219
                break;
21220

21221
              case _util.OPS.paintFormXObjectBegin:
21222
                this.paintFormXObjectBegin(args[0], args[1]);
21223
                break;
21224

21225
              case _util.OPS.paintFormXObjectEnd:
21226
                this.paintFormXObjectEnd();
21227
                break;
21228

21229
              case _util.OPS.closePath:
21230
                this.closePath();
21231
                break;
21232

21233
              case _util.OPS.closeStroke:
21234
                this.closeStroke();
21235
                break;
21236

21237
              case _util.OPS.closeFillStroke:
21238
                this.closeFillStroke();
21239
                break;
21240

21241
              case _util.OPS.closeEOFillStroke:
21242
                this.closeEOFillStroke();
21243
                break;
21244

21245
              case _util.OPS.nextLine:
21246
                this.nextLine();
21247
                break;
21248

21249
              case _util.OPS.transform:
21250
                this.transform(args[0], args[1], args[2], args[3], args[4], args[5]);
21251
                break;
21252

21253
              case _util.OPS.constructPath:
21254
                this.constructPath(args[0], args[1]);
21255
                break;
21256

21257
              case _util.OPS.endPath:
21258
                this.endPath();
21259
                break;
21260

21261
              case 92:
21262
                this.group(opTreeElement.items);
21263
                break;
21264

21265
              default:
21266
                (0, _util.warn)("Unimplemented operator ".concat(fn));
21267
                break;
21268
            }
21269
          }
21270
        } catch (err) {
21271
          _iterator3.e(err);
21272
        } finally {
21273
          _iterator3.f();
21274
        }
21275
      }
21276
    }, {
21277
      key: "setWordSpacing",
21278
      value: function setWordSpacing(wordSpacing) {
21279
        this.current.wordSpacing = wordSpacing;
21280
      }
21281
    }, {
21282
      key: "setCharSpacing",
21283
      value: function setCharSpacing(charSpacing) {
21284
        this.current.charSpacing = charSpacing;
21285
      }
21286
    }, {
21287
      key: "nextLine",
21288
      value: function nextLine() {
21289
        this.moveText(0, this.current.leading);
21290
      }
21291
    }, {
21292
      key: "setTextMatrix",
21293
      value: function setTextMatrix(a, b, c, d, e, f) {
21294
        var current = this.current;
21295
        current.textMatrix = current.lineMatrix = [a, b, c, d, e, f];
21296
        current.textMatrixScale = Math.hypot(a, b);
21297
        current.x = current.lineX = 0;
21298
        current.y = current.lineY = 0;
21299
        current.xcoords = [];
21300
        current.ycoords = [];
21301
        current.tspan = this.svgFactory.createElement("svg:tspan");
21302
        current.tspan.setAttributeNS(null, "font-family", current.fontFamily);
21303
        current.tspan.setAttributeNS(null, "font-size", "".concat(pf(current.fontSize), "px"));
21304
        current.tspan.setAttributeNS(null, "y", pf(-current.y));
21305
        current.txtElement = this.svgFactory.createElement("svg:text");
21306
        current.txtElement.appendChild(current.tspan);
21307
      }
21308
    }, {
21309
      key: "beginText",
21310
      value: function beginText() {
21311
        var current = this.current;
21312
        current.x = current.lineX = 0;
21313
        current.y = current.lineY = 0;
21314
        current.textMatrix = _util.IDENTITY_MATRIX;
21315
        current.lineMatrix = _util.IDENTITY_MATRIX;
21316
        current.textMatrixScale = 1;
21317
        current.tspan = this.svgFactory.createElement("svg:tspan");
21318
        current.txtElement = this.svgFactory.createElement("svg:text");
21319
        current.txtgrp = this.svgFactory.createElement("svg:g");
21320
        current.xcoords = [];
21321
        current.ycoords = [];
21322
      }
21323
    }, {
21324
      key: "moveText",
21325
      value: function moveText(x, y) {
21326
        var current = this.current;
21327
        current.x = current.lineX += x;
21328
        current.y = current.lineY += y;
21329
        current.xcoords = [];
21330
        current.ycoords = [];
21331
        current.tspan = this.svgFactory.createElement("svg:tspan");
21332
        current.tspan.setAttributeNS(null, "font-family", current.fontFamily);
21333
        current.tspan.setAttributeNS(null, "font-size", "".concat(pf(current.fontSize), "px"));
21334
        current.tspan.setAttributeNS(null, "y", pf(-current.y));
21335
      }
21336
    }, {
21337
      key: "showText",
21338
      value: function showText(glyphs) {
21339
        var current = this.current;
21340
        var font = current.font;
21341
        var fontSize = current.fontSize;
21342

21343
        if (fontSize === 0) {
21344
          return;
21345
        }
21346

21347
        var fontSizeScale = current.fontSizeScale;
21348
        var charSpacing = current.charSpacing;
21349
        var wordSpacing = current.wordSpacing;
21350
        var fontDirection = current.fontDirection;
21351
        var textHScale = current.textHScale * fontDirection;
21352
        var vertical = font.vertical;
21353
        var spacingDir = vertical ? 1 : -1;
21354
        var defaultVMetrics = font.defaultVMetrics;
21355
        var widthAdvanceScale = fontSize * current.fontMatrix[0];
21356
        var x = 0;
21357

21358
        var _iterator4 = _createForOfIteratorHelper(glyphs),
21359
            _step4;
21360

21361
        try {
21362
          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
21363
            var glyph = _step4.value;
21364

21365
            if (glyph === null) {
21366
              x += fontDirection * wordSpacing;
21367
              continue;
21368
            } else if ((0, _util.isNum)(glyph)) {
21369
              x += spacingDir * glyph * fontSize / 1000;
21370
              continue;
21371
            }
21372

21373
            var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
21374
            var character = glyph.fontChar;
21375
            var scaledX = void 0,
21376
                scaledY = void 0;
21377
            var width = glyph.width;
21378

21379
            if (vertical) {
21380
              var vx = void 0;
21381
              var vmetric = glyph.vmetric || defaultVMetrics;
21382
              vx = glyph.vmetric ? vmetric[1] : width * 0.5;
21383
              vx = -vx * widthAdvanceScale;
21384
              var vy = vmetric[2] * widthAdvanceScale;
21385
              width = vmetric ? -vmetric[0] : width;
21386
              scaledX = vx / fontSizeScale;
21387
              scaledY = (x + vy) / fontSizeScale;
21388
            } else {
21389
              scaledX = x / fontSizeScale;
21390
              scaledY = 0;
21391
            }
21392

21393
            if (glyph.isInFont || font.missingFile) {
21394
              current.xcoords.push(current.x + scaledX);
21395

21396
              if (vertical) {
21397
                current.ycoords.push(-current.y + scaledY);
21398
              }
21399

21400
              current.tspan.textContent += character;
21401
            } else {}
21402

21403
            var charWidth = void 0;
21404

21405
            if (vertical) {
21406
              charWidth = width * widthAdvanceScale - spacing * fontDirection;
21407
            } else {
21408
              charWidth = width * widthAdvanceScale + spacing * fontDirection;
21409
            }
21410

21411
            x += charWidth;
21412
          }
21413
        } catch (err) {
21414
          _iterator4.e(err);
21415
        } finally {
21416
          _iterator4.f();
21417
        }
21418

21419
        current.tspan.setAttributeNS(null, "x", current.xcoords.map(pf).join(" "));
21420

21421
        if (vertical) {
21422
          current.tspan.setAttributeNS(null, "y", current.ycoords.map(pf).join(" "));
21423
        } else {
21424
          current.tspan.setAttributeNS(null, "y", pf(-current.y));
21425
        }
21426

21427
        if (vertical) {
21428
          current.y -= x;
21429
        } else {
21430
          current.x += x * textHScale;
21431
        }
21432

21433
        current.tspan.setAttributeNS(null, "font-family", current.fontFamily);
21434
        current.tspan.setAttributeNS(null, "font-size", "".concat(pf(current.fontSize), "px"));
21435

21436
        if (current.fontStyle !== SVG_DEFAULTS.fontStyle) {
21437
          current.tspan.setAttributeNS(null, "font-style", current.fontStyle);
21438
        }
21439

21440
        if (current.fontWeight !== SVG_DEFAULTS.fontWeight) {
21441
          current.tspan.setAttributeNS(null, "font-weight", current.fontWeight);
21442
        }
21443

21444
        var fillStrokeMode = current.textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
21445

21446
        if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
21447
          if (current.fillColor !== SVG_DEFAULTS.fillColor) {
21448
            current.tspan.setAttributeNS(null, "fill", current.fillColor);
21449
          }
21450

21451
          if (current.fillAlpha < 1) {
21452
            current.tspan.setAttributeNS(null, "fill-opacity", current.fillAlpha);
21453
          }
21454
        } else if (current.textRenderingMode === _util.TextRenderingMode.ADD_TO_PATH) {
21455
          current.tspan.setAttributeNS(null, "fill", "transparent");
21456
        } else {
21457
          current.tspan.setAttributeNS(null, "fill", "none");
21458
        }
21459

21460
        if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
21461
          var lineWidthScale = 1 / (current.textMatrixScale || 1);
21462

21463
          this._setStrokeAttributes(current.tspan, lineWidthScale);
21464
        }
21465

21466
        var textMatrix = current.textMatrix;
21467

21468
        if (current.textRise !== 0) {
21469
          textMatrix = textMatrix.slice();
21470
          textMatrix[5] += current.textRise;
21471
        }
21472

21473
        current.txtElement.setAttributeNS(null, "transform", "".concat(pm(textMatrix), " scale(").concat(pf(textHScale), ", -1)"));
21474
        current.txtElement.setAttributeNS(XML_NS, "xml:space", "preserve");
21475
        current.txtElement.appendChild(current.tspan);
21476
        current.txtgrp.appendChild(current.txtElement);
21477

21478
        this._ensureTransformGroup().appendChild(current.txtElement);
21479
      }
21480
    }, {
21481
      key: "setLeadingMoveText",
21482
      value: function setLeadingMoveText(x, y) {
21483
        this.setLeading(-y);
21484
        this.moveText(x, y);
21485
      }
21486
    }, {
21487
      key: "addFontStyle",
21488
      value: function addFontStyle(fontObj) {
21489
        if (!fontObj.data) {
21490
          throw new Error("addFontStyle: No font data available, " + 'ensure that the "fontExtraProperties" API parameter is set.');
21491
        }
21492

21493
        if (!this.cssStyle) {
21494
          this.cssStyle = this.svgFactory.createElement("svg:style");
21495
          this.cssStyle.setAttributeNS(null, "type", "text/css");
21496
          this.defs.appendChild(this.cssStyle);
21497
        }
21498

21499
        var url = (0, _util.createObjectURL)(fontObj.data, fontObj.mimetype, this.forceDataSchema);
21500
        this.cssStyle.textContent += "@font-face { font-family: \"".concat(fontObj.loadedName, "\";") + " src: url(".concat(url, "); }\n");
21501
      }
21502
    }, {
21503
      key: "setFont",
21504
      value: function setFont(details) {
21505
        var current = this.current;
21506
        var fontObj = this.commonObjs.get(details[0]);
21507
        var size = details[1];
21508
        current.font = fontObj;
21509

21510
        if (this.embedFonts && !fontObj.missingFile && !this.embeddedFonts[fontObj.loadedName]) {
21511
          this.addFontStyle(fontObj);
21512
          this.embeddedFonts[fontObj.loadedName] = fontObj;
21513
        }
21514

21515
        current.fontMatrix = fontObj.fontMatrix || _util.FONT_IDENTITY_MATRIX;
21516
        var bold = "normal";
21517

21518
        if (fontObj.black) {
21519
          bold = "900";
21520
        } else if (fontObj.bold) {
21521
          bold = "bold";
21522
        }
21523

21524
        var italic = fontObj.italic ? "italic" : "normal";
21525

21526
        if (size < 0) {
21527
          size = -size;
21528
          current.fontDirection = -1;
21529
        } else {
21530
          current.fontDirection = 1;
21531
        }
21532

21533
        current.fontSize = size;
21534
        current.fontFamily = fontObj.loadedName;
21535
        current.fontWeight = bold;
21536
        current.fontStyle = italic;
21537
        current.tspan = this.svgFactory.createElement("svg:tspan");
21538
        current.tspan.setAttributeNS(null, "y", pf(-current.y));
21539
        current.xcoords = [];
21540
        current.ycoords = [];
21541
      }
21542
    }, {
21543
      key: "endText",
21544
      value: function endText() {
21545
        var _current$txtElement;
21546

21547
        var current = this.current;
21548

21549
        if (current.textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG && (_current$txtElement = current.txtElement) !== null && _current$txtElement !== void 0 && _current$txtElement.hasChildNodes()) {
21550
          current.element = current.txtElement;
21551
          this.clip("nonzero");
21552
          this.endPath();
21553
        }
21554
      }
21555
    }, {
21556
      key: "setLineWidth",
21557
      value: function setLineWidth(width) {
21558
        if (width > 0) {
21559
          this.current.lineWidth = width;
21560
        }
21561
      }
21562
    }, {
21563
      key: "setLineCap",
21564
      value: function setLineCap(style) {
21565
        this.current.lineCap = LINE_CAP_STYLES[style];
21566
      }
21567
    }, {
21568
      key: "setLineJoin",
21569
      value: function setLineJoin(style) {
21570
        this.current.lineJoin = LINE_JOIN_STYLES[style];
21571
      }
21572
    }, {
21573
      key: "setMiterLimit",
21574
      value: function setMiterLimit(limit) {
21575
        this.current.miterLimit = limit;
21576
      }
21577
    }, {
21578
      key: "setStrokeAlpha",
21579
      value: function setStrokeAlpha(strokeAlpha) {
21580
        this.current.strokeAlpha = strokeAlpha;
21581
      }
21582
    }, {
21583
      key: "setStrokeRGBColor",
21584
      value: function setStrokeRGBColor(r, g, b) {
21585
        this.current.strokeColor = _util.Util.makeHexColor(r, g, b);
21586
      }
21587
    }, {
21588
      key: "setFillAlpha",
21589
      value: function setFillAlpha(fillAlpha) {
21590
        this.current.fillAlpha = fillAlpha;
21591
      }
21592
    }, {
21593
      key: "setFillRGBColor",
21594
      value: function setFillRGBColor(r, g, b) {
21595
        this.current.fillColor = _util.Util.makeHexColor(r, g, b);
21596
        this.current.tspan = this.svgFactory.createElement("svg:tspan");
21597
        this.current.xcoords = [];
21598
        this.current.ycoords = [];
21599
      }
21600
    }, {
21601
      key: "setStrokeColorN",
21602
      value: function setStrokeColorN(args) {
21603
        this.current.strokeColor = this._makeColorN_Pattern(args);
21604
      }
21605
    }, {
21606
      key: "setFillColorN",
21607
      value: function setFillColorN(args) {
21608
        this.current.fillColor = this._makeColorN_Pattern(args);
21609
      }
21610
    }, {
21611
      key: "shadingFill",
21612
      value: function shadingFill(args) {
21613
        var width = this.viewport.width;
21614
        var height = this.viewport.height;
21615

21616
        var inv = _util.Util.inverseTransform(this.transformMatrix);
21617

21618
        var bl = _util.Util.applyTransform([0, 0], inv);
21619

21620
        var br = _util.Util.applyTransform([0, height], inv);
21621

21622
        var ul = _util.Util.applyTransform([width, 0], inv);
21623

21624
        var ur = _util.Util.applyTransform([width, height], inv);
21625

21626
        var x0 = Math.min(bl[0], br[0], ul[0], ur[0]);
21627
        var y0 = Math.min(bl[1], br[1], ul[1], ur[1]);
21628
        var x1 = Math.max(bl[0], br[0], ul[0], ur[0]);
21629
        var y1 = Math.max(bl[1], br[1], ul[1], ur[1]);
21630
        var rect = this.svgFactory.createElement("svg:rect");
21631
        rect.setAttributeNS(null, "x", x0);
21632
        rect.setAttributeNS(null, "y", y0);
21633
        rect.setAttributeNS(null, "width", x1 - x0);
21634
        rect.setAttributeNS(null, "height", y1 - y0);
21635
        rect.setAttributeNS(null, "fill", this._makeShadingPattern(args));
21636

21637
        if (this.current.fillAlpha < 1) {
21638
          rect.setAttributeNS(null, "fill-opacity", this.current.fillAlpha);
21639
        }
21640

21641
        this._ensureTransformGroup().appendChild(rect);
21642
      }
21643
    }, {
21644
      key: "_makeColorN_Pattern",
21645
      value: function _makeColorN_Pattern(args) {
21646
        if (args[0] === "TilingPattern") {
21647
          return this._makeTilingPattern(args);
21648
        }
21649

21650
        return this._makeShadingPattern(args);
21651
      }
21652
    }, {
21653
      key: "_makeTilingPattern",
21654
      value: function _makeTilingPattern(args) {
21655
        var color = args[1];
21656
        var operatorList = args[2];
21657
        var matrix = args[3] || _util.IDENTITY_MATRIX;
21658

21659
        var _args$ = _slicedToArray(args[4], 4),
21660
            x0 = _args$[0],
21661
            y0 = _args$[1],
21662
            x1 = _args$[2],
21663
            y1 = _args$[3];
21664

21665
        var xstep = args[5];
21666
        var ystep = args[6];
21667
        var paintType = args[7];
21668
        var tilingId = "shading".concat(shadingCount++);
21669

21670
        var _Util$applyTransform = _util.Util.applyTransform([x0, y0], matrix),
21671
            _Util$applyTransform2 = _slicedToArray(_Util$applyTransform, 2),
21672
            tx0 = _Util$applyTransform2[0],
21673
            ty0 = _Util$applyTransform2[1];
21674

21675
        var _Util$applyTransform3 = _util.Util.applyTransform([x1, y1], matrix),
21676
            _Util$applyTransform4 = _slicedToArray(_Util$applyTransform3, 2),
21677
            tx1 = _Util$applyTransform4[0],
21678
            ty1 = _Util$applyTransform4[1];
21679

21680
        var _Util$singularValueDe = _util.Util.singularValueDecompose2dScale(matrix),
21681
            _Util$singularValueDe2 = _slicedToArray(_Util$singularValueDe, 2),
21682
            xscale = _Util$singularValueDe2[0],
21683
            yscale = _Util$singularValueDe2[1];
21684

21685
        var txstep = xstep * xscale;
21686
        var tystep = ystep * yscale;
21687
        var tiling = this.svgFactory.createElement("svg:pattern");
21688
        tiling.setAttributeNS(null, "id", tilingId);
21689
        tiling.setAttributeNS(null, "patternUnits", "userSpaceOnUse");
21690
        tiling.setAttributeNS(null, "width", txstep);
21691
        tiling.setAttributeNS(null, "height", tystep);
21692
        tiling.setAttributeNS(null, "x", "".concat(tx0));
21693
        tiling.setAttributeNS(null, "y", "".concat(ty0));
21694
        var svg = this.svg;
21695
        var transformMatrix = this.transformMatrix;
21696
        var fillColor = this.current.fillColor;
21697
        var strokeColor = this.current.strokeColor;
21698
        var bbox = this.svgFactory.create(tx1 - tx0, ty1 - ty0);
21699
        this.svg = bbox;
21700
        this.transformMatrix = matrix;
21701

21702
        if (paintType === 2) {
21703
          var cssColor = _util.Util.makeHexColor.apply(_util.Util, _toConsumableArray(color));
21704

21705
          this.current.fillColor = cssColor;
21706
          this.current.strokeColor = cssColor;
21707
        }
21708

21709
        this.executeOpTree(this.convertOpList(operatorList));
21710
        this.svg = svg;
21711
        this.transformMatrix = transformMatrix;
21712
        this.current.fillColor = fillColor;
21713
        this.current.strokeColor = strokeColor;
21714
        tiling.appendChild(bbox.childNodes[0]);
21715
        this.defs.appendChild(tiling);
21716
        return "url(#".concat(tilingId, ")");
21717
      }
21718
    }, {
21719
      key: "_makeShadingPattern",
21720
      value: function _makeShadingPattern(args) {
21721
        switch (args[0]) {
21722
          case "RadialAxial":
21723
            var shadingId = "shading".concat(shadingCount++);
21724
            var colorStops = args[3];
21725
            var gradient;
21726

21727
            switch (args[1]) {
21728
              case "axial":
21729
                var point0 = args[4];
21730
                var point1 = args[5];
21731
                gradient = this.svgFactory.createElement("svg:linearGradient");
21732
                gradient.setAttributeNS(null, "id", shadingId);
21733
                gradient.setAttributeNS(null, "gradientUnits", "userSpaceOnUse");
21734
                gradient.setAttributeNS(null, "x1", point0[0]);
21735
                gradient.setAttributeNS(null, "y1", point0[1]);
21736
                gradient.setAttributeNS(null, "x2", point1[0]);
21737
                gradient.setAttributeNS(null, "y2", point1[1]);
21738
                break;
21739

21740
              case "radial":
21741
                var focalPoint = args[4];
21742
                var circlePoint = args[5];
21743
                var focalRadius = args[6];
21744
                var circleRadius = args[7];
21745
                gradient = this.svgFactory.createElement("svg:radialGradient");
21746
                gradient.setAttributeNS(null, "id", shadingId);
21747
                gradient.setAttributeNS(null, "gradientUnits", "userSpaceOnUse");
21748
                gradient.setAttributeNS(null, "cx", circlePoint[0]);
21749
                gradient.setAttributeNS(null, "cy", circlePoint[1]);
21750
                gradient.setAttributeNS(null, "r", circleRadius);
21751
                gradient.setAttributeNS(null, "fx", focalPoint[0]);
21752
                gradient.setAttributeNS(null, "fy", focalPoint[1]);
21753
                gradient.setAttributeNS(null, "fr", focalRadius);
21754
                break;
21755

21756
              default:
21757
                throw new Error("Unknown RadialAxial type: ".concat(args[1]));
21758
            }
21759

21760
            var _iterator5 = _createForOfIteratorHelper(colorStops),
21761
                _step5;
21762

21763
            try {
21764
              for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
21765
                var colorStop = _step5.value;
21766
                var stop = this.svgFactory.createElement("svg:stop");
21767
                stop.setAttributeNS(null, "offset", colorStop[0]);
21768
                stop.setAttributeNS(null, "stop-color", colorStop[1]);
21769
                gradient.appendChild(stop);
21770
              }
21771
            } catch (err) {
21772
              _iterator5.e(err);
21773
            } finally {
21774
              _iterator5.f();
21775
            }
21776

21777
            this.defs.appendChild(gradient);
21778
            return "url(#".concat(shadingId, ")");
21779

21780
          case "Mesh":
21781
            (0, _util.warn)("Unimplemented pattern Mesh");
21782
            return null;
21783

21784
          case "Dummy":
21785
            return "hotpink";
21786

21787
          default:
21788
            throw new Error("Unknown IR type: ".concat(args[0]));
21789
        }
21790
      }
21791
    }, {
21792
      key: "setDash",
21793
      value: function setDash(dashArray, dashPhase) {
21794
        this.current.dashArray = dashArray;
21795
        this.current.dashPhase = dashPhase;
21796
      }
21797
    }, {
21798
      key: "constructPath",
21799
      value: function constructPath(ops, args) {
21800
        var current = this.current;
21801
        var x = current.x,
21802
            y = current.y;
21803
        var d = [];
21804
        var j = 0;
21805

21806
        var _iterator6 = _createForOfIteratorHelper(ops),
21807
            _step6;
21808

21809
        try {
21810
          for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
21811
            var op = _step6.value;
21812

21813
            switch (op | 0) {
21814
              case _util.OPS.rectangle:
21815
                x = args[j++];
21816
                y = args[j++];
21817
                var width = args[j++];
21818
                var height = args[j++];
21819
                var xw = x + width;
21820
                var yh = y + height;
21821
                d.push("M", pf(x), pf(y), "L", pf(xw), pf(y), "L", pf(xw), pf(yh), "L", pf(x), pf(yh), "Z");
21822
                break;
21823

21824
              case _util.OPS.moveTo:
21825
                x = args[j++];
21826
                y = args[j++];
21827
                d.push("M", pf(x), pf(y));
21828
                break;
21829

21830
              case _util.OPS.lineTo:
21831
                x = args[j++];
21832
                y = args[j++];
21833
                d.push("L", pf(x), pf(y));
21834
                break;
21835

21836
              case _util.OPS.curveTo:
21837
                x = args[j + 4];
21838
                y = args[j + 5];
21839
                d.push("C", pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3]), pf(x), pf(y));
21840
                j += 6;
21841
                break;
21842

21843
              case _util.OPS.curveTo2:
21844
                d.push("C", pf(x), pf(y), pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3]));
21845
                x = args[j + 2];
21846
                y = args[j + 3];
21847
                j += 4;
21848
                break;
21849

21850
              case _util.OPS.curveTo3:
21851
                x = args[j + 2];
21852
                y = args[j + 3];
21853
                d.push("C", pf(args[j]), pf(args[j + 1]), pf(x), pf(y), pf(x), pf(y));
21854
                j += 4;
21855
                break;
21856

21857
              case _util.OPS.closePath:
21858
                d.push("Z");
21859
                break;
21860
            }
21861
          }
21862
        } catch (err) {
21863
          _iterator6.e(err);
21864
        } finally {
21865
          _iterator6.f();
21866
        }
21867

21868
        d = d.join(" ");
21869

21870
        if (current.path && ops.length > 0 && ops[0] !== _util.OPS.rectangle && ops[0] !== _util.OPS.moveTo) {
21871
          d = current.path.getAttributeNS(null, "d") + d;
21872
        } else {
21873
          current.path = this.svgFactory.createElement("svg:path");
21874

21875
          this._ensureTransformGroup().appendChild(current.path);
21876
        }
21877

21878
        current.path.setAttributeNS(null, "d", d);
21879
        current.path.setAttributeNS(null, "fill", "none");
21880
        current.element = current.path;
21881
        current.setCurrentPoint(x, y);
21882
      }
21883
    }, {
21884
      key: "endPath",
21885
      value: function endPath() {
21886
        var current = this.current;
21887
        current.path = null;
21888

21889
        if (!this.pendingClip) {
21890
          return;
21891
        }
21892

21893
        if (!current.element) {
21894
          this.pendingClip = null;
21895
          return;
21896
        }
21897

21898
        var clipId = "clippath".concat(clipCount++);
21899
        var clipPath = this.svgFactory.createElement("svg:clipPath");
21900
        clipPath.setAttributeNS(null, "id", clipId);
21901
        clipPath.setAttributeNS(null, "transform", pm(this.transformMatrix));
21902
        var clipElement = current.element.cloneNode(true);
21903

21904
        if (this.pendingClip === "evenodd") {
21905
          clipElement.setAttributeNS(null, "clip-rule", "evenodd");
21906
        } else {
21907
          clipElement.setAttributeNS(null, "clip-rule", "nonzero");
21908
        }
21909

21910
        this.pendingClip = null;
21911
        clipPath.appendChild(clipElement);
21912
        this.defs.appendChild(clipPath);
21913

21914
        if (current.activeClipUrl) {
21915
          current.clipGroup = null;
21916
          this.extraStack.forEach(function (prev) {
21917
            prev.clipGroup = null;
21918
          });
21919
          clipPath.setAttributeNS(null, "clip-path", current.activeClipUrl);
21920
        }
21921

21922
        current.activeClipUrl = "url(#".concat(clipId, ")");
21923
        this.tgrp = null;
21924
      }
21925
    }, {
21926
      key: "clip",
21927
      value: function clip(type) {
21928
        this.pendingClip = type;
21929
      }
21930
    }, {
21931
      key: "closePath",
21932
      value: function closePath() {
21933
        var current = this.current;
21934

21935
        if (current.path) {
21936
          var d = "".concat(current.path.getAttributeNS(null, "d"), "Z");
21937
          current.path.setAttributeNS(null, "d", d);
21938
        }
21939
      }
21940
    }, {
21941
      key: "setLeading",
21942
      value: function setLeading(leading) {
21943
        this.current.leading = -leading;
21944
      }
21945
    }, {
21946
      key: "setTextRise",
21947
      value: function setTextRise(textRise) {
21948
        this.current.textRise = textRise;
21949
      }
21950
    }, {
21951
      key: "setTextRenderingMode",
21952
      value: function setTextRenderingMode(textRenderingMode) {
21953
        this.current.textRenderingMode = textRenderingMode;
21954
      }
21955
    }, {
21956
      key: "setHScale",
21957
      value: function setHScale(scale) {
21958
        this.current.textHScale = scale / 100;
21959
      }
21960
    }, {
21961
      key: "setRenderingIntent",
21962
      value: function setRenderingIntent(intent) {}
21963
    }, {
21964
      key: "setFlatness",
21965
      value: function setFlatness(flatness) {}
21966
    }, {
21967
      key: "setGState",
21968
      value: function setGState(states) {
21969
        var _iterator7 = _createForOfIteratorHelper(states),
21970
            _step7;
21971

21972
        try {
21973
          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
21974
            var _step7$value = _slicedToArray(_step7.value, 2),
21975
                key = _step7$value[0],
21976
                value = _step7$value[1];
21977

21978
            switch (key) {
21979
              case "LW":
21980
                this.setLineWidth(value);
21981
                break;
21982

21983
              case "LC":
21984
                this.setLineCap(value);
21985
                break;
21986

21987
              case "LJ":
21988
                this.setLineJoin(value);
21989
                break;
21990

21991
              case "ML":
21992
                this.setMiterLimit(value);
21993
                break;
21994

21995
              case "D":
21996
                this.setDash(value[0], value[1]);
21997
                break;
21998

21999
              case "RI":
22000
                this.setRenderingIntent(value);
22001
                break;
22002

22003
              case "FL":
22004
                this.setFlatness(value);
22005
                break;
22006

22007
              case "Font":
22008
                this.setFont(value);
22009
                break;
22010

22011
              case "CA":
22012
                this.setStrokeAlpha(value);
22013
                break;
22014

22015
              case "ca":
22016
                this.setFillAlpha(value);
22017
                break;
22018

22019
              default:
22020
                (0, _util.warn)("Unimplemented graphic state operator ".concat(key));
22021
                break;
22022
            }
22023
          }
22024
        } catch (err) {
22025
          _iterator7.e(err);
22026
        } finally {
22027
          _iterator7.f();
22028
        }
22029
      }
22030
    }, {
22031
      key: "fill",
22032
      value: function fill() {
22033
        var current = this.current;
22034

22035
        if (current.element) {
22036
          current.element.setAttributeNS(null, "fill", current.fillColor);
22037
          current.element.setAttributeNS(null, "fill-opacity", current.fillAlpha);
22038
          this.endPath();
22039
        }
22040
      }
22041
    }, {
22042
      key: "stroke",
22043
      value: function stroke() {
22044
        var current = this.current;
22045

22046
        if (current.element) {
22047
          this._setStrokeAttributes(current.element);
22048

22049
          current.element.setAttributeNS(null, "fill", "none");
22050
          this.endPath();
22051
        }
22052
      }
22053
    }, {
22054
      key: "_setStrokeAttributes",
22055
      value: function _setStrokeAttributes(element) {
22056
        var lineWidthScale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
22057
        var current = this.current;
22058
        var dashArray = current.dashArray;
22059

22060
        if (lineWidthScale !== 1 && dashArray.length > 0) {
22061
          dashArray = dashArray.map(function (value) {
22062
            return lineWidthScale * value;
22063
          });
22064
        }
22065

22066
        element.setAttributeNS(null, "stroke", current.strokeColor);
22067
        element.setAttributeNS(null, "stroke-opacity", current.strokeAlpha);
22068
        element.setAttributeNS(null, "stroke-miterlimit", pf(current.miterLimit));
22069
        element.setAttributeNS(null, "stroke-linecap", current.lineCap);
22070
        element.setAttributeNS(null, "stroke-linejoin", current.lineJoin);
22071
        element.setAttributeNS(null, "stroke-width", pf(lineWidthScale * current.lineWidth) + "px");
22072
        element.setAttributeNS(null, "stroke-dasharray", dashArray.map(pf).join(" "));
22073
        element.setAttributeNS(null, "stroke-dashoffset", pf(lineWidthScale * current.dashPhase) + "px");
22074
      }
22075
    }, {
22076
      key: "eoFill",
22077
      value: function eoFill() {
22078
        if (this.current.element) {
22079
          this.current.element.setAttributeNS(null, "fill-rule", "evenodd");
22080
        }
22081

22082
        this.fill();
22083
      }
22084
    }, {
22085
      key: "fillStroke",
22086
      value: function fillStroke() {
22087
        this.stroke();
22088
        this.fill();
22089
      }
22090
    }, {
22091
      key: "eoFillStroke",
22092
      value: function eoFillStroke() {
22093
        if (this.current.element) {
22094
          this.current.element.setAttributeNS(null, "fill-rule", "evenodd");
22095
        }
22096

22097
        this.fillStroke();
22098
      }
22099
    }, {
22100
      key: "closeStroke",
22101
      value: function closeStroke() {
22102
        this.closePath();
22103
        this.stroke();
22104
      }
22105
    }, {
22106
      key: "closeFillStroke",
22107
      value: function closeFillStroke() {
22108
        this.closePath();
22109
        this.fillStroke();
22110
      }
22111
    }, {
22112
      key: "closeEOFillStroke",
22113
      value: function closeEOFillStroke() {
22114
        this.closePath();
22115
        this.eoFillStroke();
22116
      }
22117
    }, {
22118
      key: "paintSolidColorImageMask",
22119
      value: function paintSolidColorImageMask() {
22120
        var rect = this.svgFactory.createElement("svg:rect");
22121
        rect.setAttributeNS(null, "x", "0");
22122
        rect.setAttributeNS(null, "y", "0");
22123
        rect.setAttributeNS(null, "width", "1px");
22124
        rect.setAttributeNS(null, "height", "1px");
22125
        rect.setAttributeNS(null, "fill", this.current.fillColor);
22126

22127
        this._ensureTransformGroup().appendChild(rect);
22128
      }
22129
    }, {
22130
      key: "paintImageXObject",
22131
      value: function paintImageXObject(objId) {
22132
        var imgData = objId.startsWith("g_") ? this.commonObjs.get(objId) : this.objs.get(objId);
22133

22134
        if (!imgData) {
22135
          (0, _util.warn)("Dependent image with object ID ".concat(objId, " is not ready yet"));
22136
          return;
22137
        }
22138

22139
        this.paintInlineImageXObject(imgData);
22140
      }
22141
    }, {
22142
      key: "paintInlineImageXObject",
22143
      value: function paintInlineImageXObject(imgData, mask) {
22144
        var width = imgData.width;
22145
        var height = imgData.height;
22146
        var imgSrc = convertImgDataToPng(imgData, this.forceDataSchema, !!mask);
22147
        var cliprect = this.svgFactory.createElement("svg:rect");
22148
        cliprect.setAttributeNS(null, "x", "0");
22149
        cliprect.setAttributeNS(null, "y", "0");
22150
        cliprect.setAttributeNS(null, "width", pf(width));
22151
        cliprect.setAttributeNS(null, "height", pf(height));
22152
        this.current.element = cliprect;
22153
        this.clip("nonzero");
22154
        var imgEl = this.svgFactory.createElement("svg:image");
22155
        imgEl.setAttributeNS(XLINK_NS, "xlink:href", imgSrc);
22156
        imgEl.setAttributeNS(null, "x", "0");
22157
        imgEl.setAttributeNS(null, "y", pf(-height));
22158
        imgEl.setAttributeNS(null, "width", pf(width) + "px");
22159
        imgEl.setAttributeNS(null, "height", pf(height) + "px");
22160
        imgEl.setAttributeNS(null, "transform", "scale(".concat(pf(1 / width), " ").concat(pf(-1 / height), ")"));
22161

22162
        if (mask) {
22163
          mask.appendChild(imgEl);
22164
        } else {
22165
          this._ensureTransformGroup().appendChild(imgEl);
22166
        }
22167
      }
22168
    }, {
22169
      key: "paintImageMaskXObject",
22170
      value: function paintImageMaskXObject(imgData) {
22171
        var current = this.current;
22172
        var width = imgData.width;
22173
        var height = imgData.height;
22174
        var fillColor = current.fillColor;
22175
        current.maskId = "mask".concat(maskCount++);
22176
        var mask = this.svgFactory.createElement("svg:mask");
22177
        mask.setAttributeNS(null, "id", current.maskId);
22178
        var rect = this.svgFactory.createElement("svg:rect");
22179
        rect.setAttributeNS(null, "x", "0");
22180
        rect.setAttributeNS(null, "y", "0");
22181
        rect.setAttributeNS(null, "width", pf(width));
22182
        rect.setAttributeNS(null, "height", pf(height));
22183
        rect.setAttributeNS(null, "fill", fillColor);
22184
        rect.setAttributeNS(null, "mask", "url(#".concat(current.maskId, ")"));
22185
        this.defs.appendChild(mask);
22186

22187
        this._ensureTransformGroup().appendChild(rect);
22188

22189
        this.paintInlineImageXObject(imgData, mask);
22190
      }
22191
    }, {
22192
      key: "paintFormXObjectBegin",
22193
      value: function paintFormXObjectBegin(matrix, bbox) {
22194
        if (Array.isArray(matrix) && matrix.length === 6) {
22195
          this.transform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
22196
        }
22197

22198
        if (bbox) {
22199
          var width = bbox[2] - bbox[0];
22200
          var height = bbox[3] - bbox[1];
22201
          var cliprect = this.svgFactory.createElement("svg:rect");
22202
          cliprect.setAttributeNS(null, "x", bbox[0]);
22203
          cliprect.setAttributeNS(null, "y", bbox[1]);
22204
          cliprect.setAttributeNS(null, "width", pf(width));
22205
          cliprect.setAttributeNS(null, "height", pf(height));
22206
          this.current.element = cliprect;
22207
          this.clip("nonzero");
22208
          this.endPath();
22209
        }
22210
      }
22211
    }, {
22212
      key: "paintFormXObjectEnd",
22213
      value: function paintFormXObjectEnd() {}
22214
    }, {
22215
      key: "_initialize",
22216
      value: function _initialize(viewport) {
22217
        var svg = this.svgFactory.create(viewport.width, viewport.height);
22218
        var definitions = this.svgFactory.createElement("svg:defs");
22219
        svg.appendChild(definitions);
22220
        this.defs = definitions;
22221
        var rootGroup = this.svgFactory.createElement("svg:g");
22222
        rootGroup.setAttributeNS(null, "transform", pm(viewport.transform));
22223
        svg.appendChild(rootGroup);
22224
        this.svg = rootGroup;
22225
        return svg;
22226
      }
22227
    }, {
22228
      key: "_ensureClipGroup",
22229
      value: function _ensureClipGroup() {
22230
        if (!this.current.clipGroup) {
22231
          var clipGroup = this.svgFactory.createElement("svg:g");
22232
          clipGroup.setAttributeNS(null, "clip-path", this.current.activeClipUrl);
22233
          this.svg.appendChild(clipGroup);
22234
          this.current.clipGroup = clipGroup;
22235
        }
22236

22237
        return this.current.clipGroup;
22238
      }
22239
    }, {
22240
      key: "_ensureTransformGroup",
22241
      value: function _ensureTransformGroup() {
22242
        if (!this.tgrp) {
22243
          this.tgrp = this.svgFactory.createElement("svg:g");
22244
          this.tgrp.setAttributeNS(null, "transform", pm(this.transformMatrix));
22245

22246
          if (this.current.activeClipUrl) {
22247
            this._ensureClipGroup().appendChild(this.tgrp);
22248
          } else {
22249
            this.svg.appendChild(this.tgrp);
22250
          }
22251
        }
22252

22253
        return this.tgrp;
22254
      }
22255
    }]);
22256

22257
    return SVGGraphics;
22258
  }();
22259
}
22260

22261
/***/ }),
22262
/* 142 */
22263
/***/ ((__unused_webpack_module, exports) => {
22264

22265
"use strict";
22266

22267

22268
Object.defineProperty(exports, "__esModule", ({
22269
  value: true
22270
}));
22271
exports.XfaLayer = void 0;
22272

22273
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
22274

22275
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
22276

22277
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
22278

22279
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
22280

22281
function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
22282

22283
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
22284

22285
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
22286

22287
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
22288

22289
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
22290

22291
var XfaLayer = /*#__PURE__*/function () {
22292
  function XfaLayer() {
22293
    _classCallCheck(this, XfaLayer);
22294
  }
22295

22296
  _createClass(XfaLayer, null, [{
22297
    key: "setAttributes",
22298
    value: function setAttributes(html, attrs) {
22299
      for (var _i = 0, _Object$entries = Object.entries(attrs); _i < _Object$entries.length; _i++) {
22300
        var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2),
22301
            key = _Object$entries$_i[0],
22302
            value = _Object$entries$_i[1];
22303

22304
        if (value === null || value === undefined) {
22305
          continue;
22306
        }
22307

22308
        if (key !== "style") {
22309
          html.setAttribute(key, value);
22310
        } else {
22311
          Object.assign(html.style, value);
22312
        }
22313
      }
22314
    }
22315
  }, {
22316
    key: "render",
22317
    value: function render(parameters) {
22318
      var root = parameters.xfa;
22319
      var rootHtml = document.createElement(root.name);
22320

22321
      if (root.attributes) {
22322
        XfaLayer.setAttributes(rootHtml, root.attributes);
22323
      }
22324

22325
      var stack = [[root, -1, rootHtml]];
22326
      var rootDiv = parameters.div;
22327
      rootDiv.appendChild(rootHtml);
22328
      var coeffs = parameters.viewport.transform.join(",");
22329
      rootDiv.style.transform = "matrix(".concat(coeffs, ")");
22330
      rootDiv.setAttribute("class", "xfaLayer xfaFont");
22331

22332
      while (stack.length > 0) {
22333
        var _stack = _slicedToArray(stack[stack.length - 1], 3),
22334
            parent = _stack[0],
22335
            i = _stack[1],
22336
            html = _stack[2];
22337

22338
        if (i + 1 === parent.children.length) {
22339
          stack.pop();
22340
          continue;
22341
        }
22342

22343
        var child = parent.children[++stack[stack.length - 1][1]];
22344

22345
        if (child === null) {
22346
          continue;
22347
        }
22348

22349
        var name = child.name;
22350

22351
        if (name === "#text") {
22352
          html.appendChild(document.createTextNode(child.value));
22353
          continue;
22354
        }
22355

22356
        var childHtml = document.createElement(name);
22357
        html.appendChild(childHtml);
22358

22359
        if (child.attributes) {
22360
          XfaLayer.setAttributes(childHtml, child.attributes);
22361
        }
22362

22363
        if (child.children && child.children.length > 0) {
22364
          stack.push([child, -1, childHtml]);
22365
        } else if (child.value) {
22366
          childHtml.appendChild(document.createTextNode(child.value));
22367
        }
22368
      }
22369
    }
22370
  }, {
22371
    key: "update",
22372
    value: function update(parameters) {
22373
      var transform = "matrix(".concat(parameters.viewport.transform.join(","), ")");
22374
      parameters.div.style.transform = transform;
22375
      parameters.div.hidden = false;
22376
    }
22377
  }]);
22378

22379
  return XfaLayer;
22380
}();
22381

22382
exports.XfaLayer = XfaLayer;
22383

22384
/***/ }),
22385
/* 143 */
22386
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
22387

22388
"use strict";
22389

22390

22391
function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
22392

22393
Object.defineProperty(exports, "__esModule", ({
22394
  value: true
22395
}));
22396
exports.PDFNodeStream = void 0;
22397

22398
var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
22399

22400
var _util = __w_pdfjs_require__(4);
22401

22402
var _network_utils = __w_pdfjs_require__(144);
22403

22404
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
22405

22406
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
22407

22408
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
22409

22410
function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }
22411

22412
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
22413

22414
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
22415

22416
function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
22417

22418
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
22419

22420
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
22421

22422
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
22423

22424
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
22425

22426
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
22427

22428
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
22429

22430
;
22431

22432
var fs = require("fs");
22433

22434
var http = require("http");
22435

22436
var https = require("https");
22437

22438
var url = require("url");
22439

22440
var fileUriRegex = /^file:\/\/\/[a-zA-Z]:\//;
22441

22442
function parseUrl(sourceUrl) {
22443
  var parsedUrl = url.parse(sourceUrl);
22444

22445
  if (parsedUrl.protocol === "file:" || parsedUrl.host) {
22446
    return parsedUrl;
22447
  }
22448

22449
  if (/^[a-z]:[/\\]/i.test(sourceUrl)) {
22450
    return url.parse("file:///".concat(sourceUrl));
22451
  }
22452

22453
  if (!parsedUrl.host) {
22454
    parsedUrl.protocol = "file:";
22455
  }
22456

22457
  return parsedUrl;
22458
}
22459

22460
var PDFNodeStream = /*#__PURE__*/function () {
22461
  function PDFNodeStream(source) {
22462
    _classCallCheck(this, PDFNodeStream);
22463

22464
    this.source = source;
22465
    this.url = parseUrl(source.url);
22466
    this.isHttp = this.url.protocol === "http:" || this.url.protocol === "https:";
22467
    this.isFsUrl = this.url.protocol === "file:";
22468
    this.httpHeaders = this.isHttp && source.httpHeaders || {};
22469
    this._fullRequestReader = null;
22470
    this._rangeRequestReaders = [];
22471
  }
22472

22473
  _createClass(PDFNodeStream, [{
22474
    key: "_progressiveDataLength",
22475
    get: function get() {
22476
      var _this$_fullRequestRea, _this$_fullRequestRea2;
22477

22478
      return (_this$_fullRequestRea = (_this$_fullRequestRea2 = this._fullRequestReader) === null || _this$_fullRequestRea2 === void 0 ? void 0 : _this$_fullRequestRea2._loaded) !== null && _this$_fullRequestRea !== void 0 ? _this$_fullRequestRea : 0;
22479
    }
22480
  }, {
22481
    key: "getFullReader",
22482
    value: function getFullReader() {
22483
      (0, _util.assert)(!this._fullRequestReader, "PDFNodeStream.getFullReader can only be called once.");
22484
      this._fullRequestReader = this.isFsUrl ? new PDFNodeStreamFsFullReader(this) : new PDFNodeStreamFullReader(this);
22485
      return this._fullRequestReader;
22486
    }
22487
  }, {
22488
    key: "getRangeReader",
22489
    value: function getRangeReader(start, end) {
22490
      if (end <= this._progressiveDataLength) {
22491
        return null;
22492
      }
22493

22494
      var rangeReader = this.isFsUrl ? new PDFNodeStreamFsRangeReader(this, start, end) : new PDFNodeStreamRangeReader(this, start, end);
22495

22496
      this._rangeRequestReaders.push(rangeReader);
22497

22498
      return rangeReader;
22499
    }
22500
  }, {
22501
    key: "cancelAllRequests",
22502
    value: function cancelAllRequests(reason) {
22503
      if (this._fullRequestReader) {
22504
        this._fullRequestReader.cancel(reason);
22505
      }
22506

22507
      var readers = this._rangeRequestReaders.slice(0);
22508

22509
      readers.forEach(function (reader) {
22510
        reader.cancel(reason);
22511
      });
22512
    }
22513
  }]);
22514

22515
  return PDFNodeStream;
22516
}();
22517

22518
exports.PDFNodeStream = PDFNodeStream;
22519

22520
var BaseFullReader = /*#__PURE__*/function () {
22521
  function BaseFullReader(stream) {
22522
    _classCallCheck(this, BaseFullReader);
22523

22524
    this._url = stream.url;
22525
    this._done = false;
22526
    this._storedError = null;
22527
    this.onProgress = null;
22528
    var source = stream.source;
22529
    this._contentLength = source.length;
22530
    this._loaded = 0;
22531
    this._filename = null;
22532
    this._disableRange = source.disableRange || false;
22533
    this._rangeChunkSize = source.rangeChunkSize;
22534

22535
    if (!this._rangeChunkSize && !this._disableRange) {
22536
      this._disableRange = true;
22537
    }
22538

22539
    this._isStreamingSupported = !source.disableStream;
22540
    this._isRangeSupported = !source.disableRange;
22541
    this._readableStream = null;
22542
    this._readCapability = (0, _util.createPromiseCapability)();
22543
    this._headersCapability = (0, _util.createPromiseCapability)();
22544
  }
22545

22546
  _createClass(BaseFullReader, [{
22547
    key: "headersReady",
22548
    get: function get() {
22549
      return this._headersCapability.promise;
22550
    }
22551
  }, {
22552
    key: "filename",
22553
    get: function get() {
22554
      return this._filename;
22555
    }
22556
  }, {
22557
    key: "contentLength",
22558
    get: function get() {
22559
      return this._contentLength;
22560
    }
22561
  }, {
22562
    key: "isRangeSupported",
22563
    get: function get() {
22564
      return this._isRangeSupported;
22565
    }
22566
  }, {
22567
    key: "isStreamingSupported",
22568
    get: function get() {
22569
      return this._isStreamingSupported;
22570
    }
22571
  }, {
22572
    key: "read",
22573
    value: function () {
22574
      var _read = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
22575
        var chunk, buffer;
22576
        return _regenerator["default"].wrap(function _callee$(_context) {
22577
          while (1) {
22578
            switch (_context.prev = _context.next) {
22579
              case 0:
22580
                _context.next = 2;
22581
                return this._readCapability.promise;
22582

22583
              case 2:
22584
                if (!this._done) {
22585
                  _context.next = 4;
22586
                  break;
22587
                }
22588

22589
                return _context.abrupt("return", {
22590
                  value: undefined,
22591
                  done: true
22592
                });
22593

22594
              case 4:
22595
                if (!this._storedError) {
22596
                  _context.next = 6;
22597
                  break;
22598
                }
22599

22600
                throw this._storedError;
22601

22602
              case 6:
22603
                chunk = this._readableStream.read();
22604

22605
                if (!(chunk === null)) {
22606
                  _context.next = 10;
22607
                  break;
22608
                }
22609

22610
                this._readCapability = (0, _util.createPromiseCapability)();
22611
                return _context.abrupt("return", this.read());
22612

22613
              case 10:
22614
                this._loaded += chunk.length;
22615

22616
                if (this.onProgress) {
22617
                  this.onProgress({
22618
                    loaded: this._loaded,
22619
                    total: this._contentLength
22620
                  });
22621
                }
22622

22623
                buffer = new Uint8Array(chunk).buffer;
22624
                return _context.abrupt("return", {
22625
                  value: buffer,
22626
                  done: false
22627
                });
22628

22629
              case 14:
22630
              case "end":
22631
                return _context.stop();
22632
            }
22633
          }
22634
        }, _callee, this);
22635
      }));
22636

22637
      function read() {
22638
        return _read.apply(this, arguments);
22639
      }
22640

22641
      return read;
22642
    }()
22643
  }, {
22644
    key: "cancel",
22645
    value: function cancel(reason) {
22646
      if (!this._readableStream) {
22647
        this._error(reason);
22648

22649
        return;
22650
      }
22651

22652
      this._readableStream.destroy(reason);
22653
    }
22654
  }, {
22655
    key: "_error",
22656
    value: function _error(reason) {
22657
      this._storedError = reason;
22658

22659
      this._readCapability.resolve();
22660
    }
22661
  }, {
22662
    key: "_setReadableStream",
22663
    value: function _setReadableStream(readableStream) {
22664
      var _this = this;
22665

22666
      this._readableStream = readableStream;
22667
      readableStream.on("readable", function () {
22668
        _this._readCapability.resolve();
22669
      });
22670
      readableStream.on("end", function () {
22671
        readableStream.destroy();
22672
        _this._done = true;
22673

22674
        _this._readCapability.resolve();
22675
      });
22676
      readableStream.on("error", function (reason) {
22677
        _this._error(reason);
22678
      });
22679

22680
      if (!this._isStreamingSupported && this._isRangeSupported) {
22681
        this._error(new _util.AbortException("streaming is disabled"));
22682
      }
22683

22684
      if (this._storedError) {
22685
        this._readableStream.destroy(this._storedError);
22686
      }
22687
    }
22688
  }]);
22689

22690
  return BaseFullReader;
22691
}();
22692

22693
var BaseRangeReader = /*#__PURE__*/function () {
22694
  function BaseRangeReader(stream) {
22695
    _classCallCheck(this, BaseRangeReader);
22696

22697
    this._url = stream.url;
22698
    this._done = false;
22699
    this._storedError = null;
22700
    this.onProgress = null;
22701
    this._loaded = 0;
22702
    this._readableStream = null;
22703
    this._readCapability = (0, _util.createPromiseCapability)();
22704
    var source = stream.source;
22705
    this._isStreamingSupported = !source.disableStream;
22706
  }
22707

22708
  _createClass(BaseRangeReader, [{
22709
    key: "isStreamingSupported",
22710
    get: function get() {
22711
      return this._isStreamingSupported;
22712
    }
22713
  }, {
22714
    key: "read",
22715
    value: function () {
22716
      var _read2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
22717
        var chunk, buffer;
22718
        return _regenerator["default"].wrap(function _callee2$(_context2) {
22719
          while (1) {
22720
            switch (_context2.prev = _context2.next) {
22721
              case 0:
22722
                _context2.next = 2;
22723
                return this._readCapability.promise;
22724

22725
              case 2:
22726
                if (!this._done) {
22727
                  _context2.next = 4;
22728
                  break;
22729
                }
22730

22731
                return _context2.abrupt("return", {
22732
                  value: undefined,
22733
                  done: true
22734
                });
22735

22736
              case 4:
22737
                if (!this._storedError) {
22738
                  _context2.next = 6;
22739
                  break;
22740
                }
22741

22742
                throw this._storedError;
22743

22744
              case 6:
22745
                chunk = this._readableStream.read();
22746

22747
                if (!(chunk === null)) {
22748
                  _context2.next = 10;
22749
                  break;
22750
                }
22751

22752
                this._readCapability = (0, _util.createPromiseCapability)();
22753
                return _context2.abrupt("return", this.read());
22754

22755
              case 10:
22756
                this._loaded += chunk.length;
22757

22758
                if (this.onProgress) {
22759
                  this.onProgress({
22760
                    loaded: this._loaded
22761
                  });
22762
                }
22763

22764
                buffer = new Uint8Array(chunk).buffer;
22765
                return _context2.abrupt("return", {
22766
                  value: buffer,
22767
                  done: false
22768
                });
22769

22770
              case 14:
22771
              case "end":
22772
                return _context2.stop();
22773
            }
22774
          }
22775
        }, _callee2, this);
22776
      }));
22777

22778
      function read() {
22779
        return _read2.apply(this, arguments);
22780
      }
22781

22782
      return read;
22783
    }()
22784
  }, {
22785
    key: "cancel",
22786
    value: function cancel(reason) {
22787
      if (!this._readableStream) {
22788
        this._error(reason);
22789

22790
        return;
22791
      }
22792

22793
      this._readableStream.destroy(reason);
22794
    }
22795
  }, {
22796
    key: "_error",
22797
    value: function _error(reason) {
22798
      this._storedError = reason;
22799

22800
      this._readCapability.resolve();
22801
    }
22802
  }, {
22803
    key: "_setReadableStream",
22804
    value: function _setReadableStream(readableStream) {
22805
      var _this2 = this;
22806

22807
      this._readableStream = readableStream;
22808
      readableStream.on("readable", function () {
22809
        _this2._readCapability.resolve();
22810
      });
22811
      readableStream.on("end", function () {
22812
        readableStream.destroy();
22813
        _this2._done = true;
22814

22815
        _this2._readCapability.resolve();
22816
      });
22817
      readableStream.on("error", function (reason) {
22818
        _this2._error(reason);
22819
      });
22820

22821
      if (this._storedError) {
22822
        this._readableStream.destroy(this._storedError);
22823
      }
22824
    }
22825
  }]);
22826

22827
  return BaseRangeReader;
22828
}();
22829

22830
function createRequestOptions(parsedUrl, headers) {
22831
  return {
22832
    protocol: parsedUrl.protocol,
22833
    auth: parsedUrl.auth,
22834
    host: parsedUrl.hostname,
22835
    port: parsedUrl.port,
22836
    path: parsedUrl.path,
22837
    method: "GET",
22838
    headers: headers
22839
  };
22840
}
22841

22842
var PDFNodeStreamFullReader = /*#__PURE__*/function (_BaseFullReader) {
22843
  _inherits(PDFNodeStreamFullReader, _BaseFullReader);
22844

22845
  var _super = _createSuper(PDFNodeStreamFullReader);
22846

22847
  function PDFNodeStreamFullReader(stream) {
22848
    var _this3;
22849

22850
    _classCallCheck(this, PDFNodeStreamFullReader);
22851

22852
    _this3 = _super.call(this, stream);
22853

22854
    var handleResponse = function handleResponse(response) {
22855
      if (response.statusCode === 404) {
22856
        var error = new _util.MissingPDFException("Missing PDF \"".concat(_this3._url, "\"."));
22857
        _this3._storedError = error;
22858

22859
        _this3._headersCapability.reject(error);
22860

22861
        return;
22862
      }
22863

22864
      _this3._headersCapability.resolve();
22865

22866
      _this3._setReadableStream(response);
22867

22868
      var getResponseHeader = function getResponseHeader(name) {
22869
        return _this3._readableStream.headers[name.toLowerCase()];
22870
      };
22871

22872
      var _validateRangeRequest = (0, _network_utils.validateRangeRequestCapabilities)({
22873
        getResponseHeader: getResponseHeader,
22874
        isHttp: stream.isHttp,
22875
        rangeChunkSize: _this3._rangeChunkSize,
22876
        disableRange: _this3._disableRange
22877
      }),
22878
          allowRangeRequests = _validateRangeRequest.allowRangeRequests,
22879
          suggestedLength = _validateRangeRequest.suggestedLength;
22880

22881
      _this3._isRangeSupported = allowRangeRequests;
22882
      _this3._contentLength = suggestedLength || _this3._contentLength;
22883
      _this3._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader);
22884
    };
22885

22886
    _this3._request = null;
22887

22888
    if (_this3._url.protocol === "http:") {
22889
      _this3._request = http.request(createRequestOptions(_this3._url, stream.httpHeaders), handleResponse);
22890
    } else {
22891
      _this3._request = https.request(createRequestOptions(_this3._url, stream.httpHeaders), handleResponse);
22892
    }
22893

22894
    _this3._request.on("error", function (reason) {
22895
      _this3._storedError = reason;
22896

22897
      _this3._headersCapability.reject(reason);
22898
    });
22899

22900
    _this3._request.end();
22901

22902
    return _this3;
22903
  }
22904

22905
  return PDFNodeStreamFullReader;
22906
}(BaseFullReader);
22907

22908
var PDFNodeStreamRangeReader = /*#__PURE__*/function (_BaseRangeReader) {
22909
  _inherits(PDFNodeStreamRangeReader, _BaseRangeReader);
22910

22911
  var _super2 = _createSuper(PDFNodeStreamRangeReader);
22912

22913
  function PDFNodeStreamRangeReader(stream, start, end) {
22914
    var _this4;
22915

22916
    _classCallCheck(this, PDFNodeStreamRangeReader);
22917

22918
    _this4 = _super2.call(this, stream);
22919
    _this4._httpHeaders = {};
22920

22921
    for (var property in stream.httpHeaders) {
22922
      var value = stream.httpHeaders[property];
22923

22924
      if (typeof value === "undefined") {
22925
        continue;
22926
      }
22927

22928
      _this4._httpHeaders[property] = value;
22929
    }
22930

22931
    _this4._httpHeaders.Range = "bytes=".concat(start, "-").concat(end - 1);
22932

22933
    var handleResponse = function handleResponse(response) {
22934
      if (response.statusCode === 404) {
22935
        var error = new _util.MissingPDFException("Missing PDF \"".concat(_this4._url, "\"."));
22936
        _this4._storedError = error;
22937
        return;
22938
      }
22939

22940
      _this4._setReadableStream(response);
22941
    };
22942

22943
    _this4._request = null;
22944

22945
    if (_this4._url.protocol === "http:") {
22946
      _this4._request = http.request(createRequestOptions(_this4._url, _this4._httpHeaders), handleResponse);
22947
    } else {
22948
      _this4._request = https.request(createRequestOptions(_this4._url, _this4._httpHeaders), handleResponse);
22949
    }
22950

22951
    _this4._request.on("error", function (reason) {
22952
      _this4._storedError = reason;
22953
    });
22954

22955
    _this4._request.end();
22956

22957
    return _this4;
22958
  }
22959

22960
  return PDFNodeStreamRangeReader;
22961
}(BaseRangeReader);
22962

22963
var PDFNodeStreamFsFullReader = /*#__PURE__*/function (_BaseFullReader2) {
22964
  _inherits(PDFNodeStreamFsFullReader, _BaseFullReader2);
22965

22966
  var _super3 = _createSuper(PDFNodeStreamFsFullReader);
22967

22968
  function PDFNodeStreamFsFullReader(stream) {
22969
    var _this5;
22970

22971
    _classCallCheck(this, PDFNodeStreamFsFullReader);
22972

22973
    _this5 = _super3.call(this, stream);
22974
    var path = decodeURIComponent(_this5._url.path);
22975

22976
    if (fileUriRegex.test(_this5._url.href)) {
22977
      path = path.replace(/^\//, "");
22978
    }
22979

22980
    fs.lstat(path, function (error, stat) {
22981
      if (error) {
22982
        if (error.code === "ENOENT") {
22983
          error = new _util.MissingPDFException("Missing PDF \"".concat(path, "\"."));
22984
        }
22985

22986
        _this5._storedError = error;
22987

22988
        _this5._headersCapability.reject(error);
22989

22990
        return;
22991
      }
22992

22993
      _this5._contentLength = stat.size;
22994

22995
      _this5._setReadableStream(fs.createReadStream(path));
22996

22997
      _this5._headersCapability.resolve();
22998
    });
22999
    return _this5;
23000
  }
23001

23002
  return PDFNodeStreamFsFullReader;
23003
}(BaseFullReader);
23004

23005
var PDFNodeStreamFsRangeReader = /*#__PURE__*/function (_BaseRangeReader2) {
23006
  _inherits(PDFNodeStreamFsRangeReader, _BaseRangeReader2);
23007

23008
  var _super4 = _createSuper(PDFNodeStreamFsRangeReader);
23009

23010
  function PDFNodeStreamFsRangeReader(stream, start, end) {
23011
    var _this6;
23012

23013
    _classCallCheck(this, PDFNodeStreamFsRangeReader);
23014

23015
    _this6 = _super4.call(this, stream);
23016
    var path = decodeURIComponent(_this6._url.path);
23017

23018
    if (fileUriRegex.test(_this6._url.href)) {
23019
      path = path.replace(/^\//, "");
23020
    }
23021

23022
    _this6._setReadableStream(fs.createReadStream(path, {
23023
      start: start,
23024
      end: end - 1
23025
    }));
23026

23027
    return _this6;
23028
  }
23029

23030
  return PDFNodeStreamFsRangeReader;
23031
}(BaseRangeReader);
23032

23033
/***/ }),
23034
/* 144 */
23035
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
23036

23037
"use strict";
23038

23039

23040
Object.defineProperty(exports, "__esModule", ({
23041
  value: true
23042
}));
23043
exports.createResponseStatusError = createResponseStatusError;
23044
exports.extractFilenameFromHeader = extractFilenameFromHeader;
23045
exports.validateRangeRequestCapabilities = validateRangeRequestCapabilities;
23046
exports.validateResponseStatus = validateResponseStatus;
23047

23048
var _util = __w_pdfjs_require__(4);
23049

23050
var _content_disposition = __w_pdfjs_require__(145);
23051

23052
var _display_utils = __w_pdfjs_require__(1);
23053

23054
function validateRangeRequestCapabilities(_ref) {
23055
  var getResponseHeader = _ref.getResponseHeader,
23056
      isHttp = _ref.isHttp,
23057
      rangeChunkSize = _ref.rangeChunkSize,
23058
      disableRange = _ref.disableRange;
23059
  (0, _util.assert)(rangeChunkSize > 0, "Range chunk size must be larger than zero");
23060
  var returnValues = {
23061
    allowRangeRequests: false,
23062
    suggestedLength: undefined
23063
  };
23064
  var length = parseInt(getResponseHeader("Content-Length"), 10);
23065

23066
  if (!Number.isInteger(length)) {
23067
    return returnValues;
23068
  }
23069

23070
  returnValues.suggestedLength = length;
23071

23072
  if (length <= 2 * rangeChunkSize) {
23073
    return returnValues;
23074
  }
23075

23076
  if (disableRange || !isHttp) {
23077
    return returnValues;
23078
  }
23079

23080
  if (getResponseHeader("Accept-Ranges") !== "bytes") {
23081
    return returnValues;
23082
  }
23083

23084
  var contentEncoding = getResponseHeader("Content-Encoding") || "identity";
23085

23086
  if (contentEncoding !== "identity") {
23087
    return returnValues;
23088
  }
23089

23090
  returnValues.allowRangeRequests = true;
23091
  return returnValues;
23092
}
23093

23094
function extractFilenameFromHeader(getResponseHeader) {
23095
  var contentDisposition = getResponseHeader("Content-Disposition");
23096

23097
  if (contentDisposition) {
23098
    var filename = (0, _content_disposition.getFilenameFromContentDispositionHeader)(contentDisposition);
23099

23100
    if (filename.includes("%")) {
23101
      try {
23102
        filename = decodeURIComponent(filename);
23103
      } catch (ex) {}
23104
    }
23105

23106
    if ((0, _display_utils.isPdfFile)(filename)) {
23107
      return filename;
23108
    }
23109
  }
23110

23111
  return null;
23112
}
23113

23114
function createResponseStatusError(status, url) {
23115
  if (status === 404 || status === 0 && url.startsWith("file:")) {
23116
    return new _util.MissingPDFException('Missing PDF "' + url + '".');
23117
  }
23118

23119
  return new _util.UnexpectedResponseException("Unexpected server response (".concat(status, ") while retrieving PDF \"").concat(url, "\"."), status);
23120
}
23121

23122
function validateResponseStatus(status) {
23123
  return status === 200 || status === 206;
23124
}
23125

23126
/***/ }),
23127
/* 145 */
23128
/***/ ((__unused_webpack_module, exports) => {
23129

23130
"use strict";
23131

23132

23133
Object.defineProperty(exports, "__esModule", ({
23134
  value: true
23135
}));
23136
exports.getFilenameFromContentDispositionHeader = getFilenameFromContentDispositionHeader;
23137

23138
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); }
23139

23140
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); }
23141

23142
function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
23143

23144
function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
23145

23146
function _iterableToArrayLimit(arr, i) { if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
23147

23148
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
23149

23150
function getFilenameFromContentDispositionHeader(contentDisposition) {
23151
  var needsEncodingFixup = true;
23152
  var tmp = toParamRegExp("filename\\*", "i").exec(contentDisposition);
23153

23154
  if (tmp) {
23155
    tmp = tmp[1];
23156
    var filename = rfc2616unquote(tmp);
23157
    filename = unescape(filename);
23158
    filename = rfc5987decode(filename);
23159
    filename = rfc2047decode(filename);
23160
    return fixupEncoding(filename);
23161
  }
23162

23163
  tmp = rfc2231getparam(contentDisposition);
23164

23165
  if (tmp) {
23166
    var _filename = rfc2047decode(tmp);
23167

23168
    return fixupEncoding(_filename);
23169
  }
23170

23171
  tmp = toParamRegExp("filename", "i").exec(contentDisposition);
23172

23173
  if (tmp) {
23174
    tmp = tmp[1];
23175

23176
    var _filename2 = rfc2616unquote(tmp);
23177

23178
    _filename2 = rfc2047decode(_filename2);
23179
    return fixupEncoding(_filename2);
23180
  }
23181

23182
  function toParamRegExp(attributePattern, flags) {
23183
    return new RegExp("(?:^|;)\\s*" + attributePattern + "\\s*=\\s*" + "(" + '[^";\\s][^;\\s]*' + "|" + '"(?:[^"\\\\]|\\\\"?)+"?' + ")", flags);
23184
  }
23185

23186
  function textdecode(encoding, value) {
23187
    if (encoding) {
23188
      if (!/^[\x00-\xFF]+$/.test(value)) {
23189
        return value;
23190
      }
23191

23192
      try {
23193
        var decoder = new TextDecoder(encoding, {
23194
          fatal: true
23195
        });
23196
        var bytes = Array.from(value, function (ch) {
23197
          return ch.charCodeAt(0) & 0xff;
23198
        });
23199
        value = decoder.decode(new Uint8Array(bytes));
23200
        needsEncodingFixup = false;
23201
      } catch (e) {
23202
        if (/^utf-?8$/i.test(encoding)) {
23203
          try {
23204
            value = decodeURIComponent(escape(value));
23205
            needsEncodingFixup = false;
23206
          } catch (err) {}
23207
        }
23208
      }
23209
    }
23210

23211
    return value;
23212
  }
23213

23214
  function fixupEncoding(value) {
23215
    if (needsEncodingFixup && /[\x80-\xff]/.test(value)) {
23216
      value = textdecode("utf-8", value);
23217

23218
      if (needsEncodingFixup) {
23219
        value = textdecode("iso-8859-1", value);
23220
      }
23221
    }
23222

23223
    return value;
23224
  }
23225

23226
  function rfc2231getparam(contentDispositionStr) {
23227
    var matches = [];
23228
    var match;
23229
    var iter = toParamRegExp("filename\\*((?!0\\d)\\d+)(\\*?)", "ig");
23230

23231
    while ((match = iter.exec(contentDispositionStr)) !== null) {
23232
      var _match = match,
23233
          _match2 = _slicedToArray(_match, 4),
23234
          n = _match2[1],
23235
          quot = _match2[2],
23236
          part = _match2[3];
23237

23238
      n = parseInt(n, 10);
23239

23240
      if (n in matches) {
23241
        if (n === 0) {
23242
          break;
23243
        }
23244

23245
        continue;
23246
      }
23247

23248
      matches[n] = [quot, part];
23249
    }
23250

23251
    var parts = [];
23252

23253
    for (var _n2 = 0; _n2 < matches.length; ++_n2) {
23254
      if (!(_n2 in matches)) {
23255
        break;
23256
      }
23257

23258
      var _matches$_n = _slicedToArray(matches[_n2], 2),
23259
          _quot = _matches$_n[0],
23260
          _part = _matches$_n[1];
23261

23262
      _part = rfc2616unquote(_part);
23263

23264
      if (_quot) {
23265
        _part = unescape(_part);
23266

23267
        if (_n2 === 0) {
23268
          _part = rfc5987decode(_part);
23269
        }
23270
      }
23271

23272
      parts.push(_part);
23273
    }
23274

23275
    return parts.join("");
23276
  }
23277

23278
  function rfc2616unquote(value) {
23279
    if (value.startsWith('"')) {
23280
      var parts = value.slice(1).split('\\"');
23281

23282
      for (var i = 0; i < parts.length; ++i) {
23283
        var quotindex = parts[i].indexOf('"');
23284

23285
        if (quotindex !== -1) {
23286
          parts[i] = parts[i].slice(0, quotindex);
23287
          parts.length = i + 1;
23288
        }
23289

23290
        parts[i] = parts[i].replace(/\\(.)/g, "$1");
23291
      }
23292

23293
      value = parts.join('"');
23294
    }
23295

23296
    return value;
23297
  }
23298

23299
  function rfc5987decode(extvalue) {
23300
    var encodingend = extvalue.indexOf("'");
23301

23302
    if (encodingend === -1) {
23303
      return extvalue;
23304
    }
23305

23306
    var encoding = extvalue.slice(0, encodingend);
23307
    var langvalue = extvalue.slice(encodingend + 1);
23308
    var value = langvalue.replace(/^[^']*'/, "");
23309
    return textdecode(encoding, value);
23310
  }
23311

23312
  function rfc2047decode(value) {
23313
    if (!value.startsWith("=?") || /[\x00-\x19\x80-\xff]/.test(value)) {
23314
      return value;
23315
    }
23316

23317
    return value.replace(/=\?([\w-]*)\?([QqBb])\?((?:[^?]|\?(?!=))*)\?=/g, function (matches, charset, encoding, text) {
23318
      if (encoding === "q" || encoding === "Q") {
23319
        text = text.replace(/_/g, " ");
23320
        text = text.replace(/=([0-9a-fA-F]{2})/g, function (match, hex) {
23321
          return String.fromCharCode(parseInt(hex, 16));
23322
        });
23323
        return textdecode(charset, text);
23324
      }
23325

23326
      try {
23327
        text = atob(text);
23328
      } catch (e) {}
23329

23330
      return textdecode(charset, text);
23331
    });
23332
  }
23333

23334
  return "";
23335
}
23336

23337
/***/ }),
23338
/* 146 */
23339
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
23340

23341
"use strict";
23342

23343

23344
Object.defineProperty(exports, "__esModule", ({
23345
  value: true
23346
}));
23347
exports.PDFNetworkStream = void 0;
23348

23349
var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
23350

23351
var _util = __w_pdfjs_require__(4);
23352

23353
var _network_utils = __w_pdfjs_require__(144);
23354

23355
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
23356

23357
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
23358

23359
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
23360

23361
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
23362

23363
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
23364

23365
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
23366

23367
;
23368
var OK_RESPONSE = 200;
23369
var PARTIAL_CONTENT_RESPONSE = 206;
23370

23371
function getArrayBuffer(xhr) {
23372
  var data = xhr.response;
23373

23374
  if (typeof data !== "string") {
23375
    return data;
23376
  }
23377

23378
  var array = (0, _util.stringToBytes)(data);
23379
  return array.buffer;
23380
}
23381

23382
var NetworkManager = /*#__PURE__*/function () {
23383
  function NetworkManager(url, args) {
23384
    _classCallCheck(this, NetworkManager);
23385

23386
    this.url = url;
23387
    args = args || {};
23388
    this.isHttp = /^https?:/i.test(url);
23389
    this.httpHeaders = this.isHttp && args.httpHeaders || {};
23390
    this.withCredentials = args.withCredentials || false;
23391

23392
    this.getXhr = args.getXhr || function NetworkManager_getXhr() {
23393
      return new XMLHttpRequest();
23394
    };
23395

23396
    this.currXhrId = 0;
23397
    this.pendingRequests = Object.create(null);
23398
  }
23399

23400
  _createClass(NetworkManager, [{
23401
    key: "requestRange",
23402
    value: function requestRange(begin, end, listeners) {
23403
      var args = {
23404
        begin: begin,
23405
        end: end
23406
      };
23407

23408
      for (var prop in listeners) {
23409
        args[prop] = listeners[prop];
23410
      }
23411

23412
      return this.request(args);
23413
    }
23414
  }, {
23415
    key: "requestFull",
23416
    value: function requestFull(listeners) {
23417
      return this.request(listeners);
23418
    }
23419
  }, {
23420
    key: "request",
23421
    value: function request(args) {
23422
      var xhr = this.getXhr();
23423
      var xhrId = this.currXhrId++;
23424
      var pendingRequest = this.pendingRequests[xhrId] = {
23425
        xhr: xhr
23426
      };
23427
      xhr.open("GET", this.url);
23428
      xhr.withCredentials = this.withCredentials;
23429

23430
      for (var property in this.httpHeaders) {
23431
        var value = this.httpHeaders[property];
23432

23433
        if (typeof value === "undefined") {
23434
          continue;
23435
        }
23436

23437
        xhr.setRequestHeader(property, value);
23438
      }
23439

23440
      if (this.isHttp && "begin" in args && "end" in args) {
23441
        xhr.setRequestHeader("Range", "bytes=".concat(args.begin, "-").concat(args.end - 1));
23442
        pendingRequest.expectedStatus = PARTIAL_CONTENT_RESPONSE;
23443
      } else {
23444
        pendingRequest.expectedStatus = OK_RESPONSE;
23445
      }
23446

23447
      xhr.responseType = "arraybuffer";
23448

23449
      if (args.onError) {
23450
        xhr.onerror = function (evt) {
23451
          args.onError(xhr.status);
23452
        };
23453
      }
23454

23455
      xhr.onreadystatechange = this.onStateChange.bind(this, xhrId);
23456
      xhr.onprogress = this.onProgress.bind(this, xhrId);
23457
      pendingRequest.onHeadersReceived = args.onHeadersReceived;
23458
      pendingRequest.onDone = args.onDone;
23459
      pendingRequest.onError = args.onError;
23460
      pendingRequest.onProgress = args.onProgress;
23461
      xhr.send(null);
23462
      return xhrId;
23463
    }
23464
  }, {
23465
    key: "onProgress",
23466
    value: function onProgress(xhrId, evt) {
23467
      var pendingRequest = this.pendingRequests[xhrId];
23468

23469
      if (!pendingRequest) {
23470
        return;
23471
      }
23472

23473
      if (pendingRequest.onProgress) {
23474
        pendingRequest.onProgress(evt);
23475
      }
23476
    }
23477
  }, {
23478
    key: "onStateChange",
23479
    value: function onStateChange(xhrId, evt) {
23480
      var pendingRequest = this.pendingRequests[xhrId];
23481

23482
      if (!pendingRequest) {
23483
        return;
23484
      }
23485

23486
      var xhr = pendingRequest.xhr;
23487

23488
      if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) {
23489
        pendingRequest.onHeadersReceived();
23490
        delete pendingRequest.onHeadersReceived;
23491
      }
23492

23493
      if (xhr.readyState !== 4) {
23494
        return;
23495
      }
23496

23497
      if (!(xhrId in this.pendingRequests)) {
23498
        return;
23499
      }
23500

23501
      delete this.pendingRequests[xhrId];
23502

23503
      if (xhr.status === 0 && this.isHttp) {
23504
        if (pendingRequest.onError) {
23505
          pendingRequest.onError(xhr.status);
23506
        }
23507

23508
        return;
23509
      }
23510

23511
      var xhrStatus = xhr.status || OK_RESPONSE;
23512
      var ok_response_on_range_request = xhrStatus === OK_RESPONSE && pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE;
23513

23514
      if (!ok_response_on_range_request && xhrStatus !== pendingRequest.expectedStatus) {
23515
        if (pendingRequest.onError) {
23516
          pendingRequest.onError(xhr.status);
23517
        }
23518

23519
        return;
23520
      }
23521

23522
      var chunk = getArrayBuffer(xhr);
23523

23524
      if (xhrStatus === PARTIAL_CONTENT_RESPONSE) {
23525
        var rangeHeader = xhr.getResponseHeader("Content-Range");
23526
        var matches = /bytes (\d+)-(\d+)\/(\d+)/.exec(rangeHeader);
23527
        pendingRequest.onDone({
23528
          begin: parseInt(matches[1], 10),
23529
          chunk: chunk
23530
        });
23531
      } else if (chunk) {
23532
        pendingRequest.onDone({
23533
          begin: 0,
23534
          chunk: chunk
23535
        });
23536
      } else if (pendingRequest.onError) {
23537
        pendingRequest.onError(xhr.status);
23538
      }
23539
    }
23540
  }, {
23541
    key: "getRequestXhr",
23542
    value: function getRequestXhr(xhrId) {
23543
      return this.pendingRequests[xhrId].xhr;
23544
    }
23545
  }, {
23546
    key: "isPendingRequest",
23547
    value: function isPendingRequest(xhrId) {
23548
      return xhrId in this.pendingRequests;
23549
    }
23550
  }, {
23551
    key: "abortRequest",
23552
    value: function abortRequest(xhrId) {
23553
      var xhr = this.pendingRequests[xhrId].xhr;
23554
      delete this.pendingRequests[xhrId];
23555
      xhr.abort();
23556
    }
23557
  }]);
23558

23559
  return NetworkManager;
23560
}();
23561

23562
var PDFNetworkStream = /*#__PURE__*/function () {
23563
  function PDFNetworkStream(source) {
23564
    _classCallCheck(this, PDFNetworkStream);
23565

23566
    this._source = source;
23567
    this._manager = new NetworkManager(source.url, {
23568
      httpHeaders: source.httpHeaders,
23569
      withCredentials: source.withCredentials
23570
    });
23571
    this._rangeChunkSize = source.rangeChunkSize;
23572
    this._fullRequestReader = null;
23573
    this._rangeRequestReaders = [];
23574
  }
23575

23576
  _createClass(PDFNetworkStream, [{
23577
    key: "_onRangeRequestReaderClosed",
23578
    value: function _onRangeRequestReaderClosed(reader) {
23579
      var i = this._rangeRequestReaders.indexOf(reader);
23580

23581
      if (i >= 0) {
23582
        this._rangeRequestReaders.splice(i, 1);
23583
      }
23584
    }
23585
  }, {
23586
    key: "getFullReader",
23587
    value: function getFullReader() {
23588
      (0, _util.assert)(!this._fullRequestReader, "PDFNetworkStream.getFullReader can only be called once.");
23589
      this._fullRequestReader = new PDFNetworkStreamFullRequestReader(this._manager, this._source);
23590
      return this._fullRequestReader;
23591
    }
23592
  }, {
23593
    key: "getRangeReader",
23594
    value: function getRangeReader(begin, end) {
23595
      var reader = new PDFNetworkStreamRangeRequestReader(this._manager, begin, end);
23596
      reader.onClosed = this._onRangeRequestReaderClosed.bind(this);
23597

23598
      this._rangeRequestReaders.push(reader);
23599

23600
      return reader;
23601
    }
23602
  }, {
23603
    key: "cancelAllRequests",
23604
    value: function cancelAllRequests(reason) {
23605
      if (this._fullRequestReader) {
23606
        this._fullRequestReader.cancel(reason);
23607
      }
23608

23609
      var readers = this._rangeRequestReaders.slice(0);
23610

23611
      readers.forEach(function (reader) {
23612
        reader.cancel(reason);
23613
      });
23614
    }
23615
  }]);
23616

23617
  return PDFNetworkStream;
23618
}();
23619

23620
exports.PDFNetworkStream = PDFNetworkStream;
23621

23622
var PDFNetworkStreamFullRequestReader = /*#__PURE__*/function () {
23623
  function PDFNetworkStreamFullRequestReader(manager, source) {
23624
    _classCallCheck(this, PDFNetworkStreamFullRequestReader);
23625

23626
    this._manager = manager;
23627
    var args = {
23628
      onHeadersReceived: this._onHeadersReceived.bind(this),
23629
      onDone: this._onDone.bind(this),
23630
      onError: this._onError.bind(this),
23631
      onProgress: this._onProgress.bind(this)
23632
    };
23633
    this._url = source.url;
23634
    this._fullRequestId = manager.requestFull(args);
23635
    this._headersReceivedCapability = (0, _util.createPromiseCapability)();
23636
    this._disableRange = source.disableRange || false;
23637
    this._contentLength = source.length;
23638
    this._rangeChunkSize = source.rangeChunkSize;
23639

23640
    if (!this._rangeChunkSize && !this._disableRange) {
23641
      this._disableRange = true;
23642
    }
23643

23644
    this._isStreamingSupported = false;
23645
    this._isRangeSupported = false;
23646
    this._cachedChunks = [];
23647
    this._requests = [];
23648
    this._done = false;
23649
    this._storedError = undefined;
23650
    this._filename = null;
23651
    this.onProgress = null;
23652
  }
23653

23654
  _createClass(PDFNetworkStreamFullRequestReader, [{
23655
    key: "_onHeadersReceived",
23656
    value: function _onHeadersReceived() {
23657
      var fullRequestXhrId = this._fullRequestId;
23658

23659
      var fullRequestXhr = this._manager.getRequestXhr(fullRequestXhrId);
23660

23661
      var getResponseHeader = function getResponseHeader(name) {
23662
        return fullRequestXhr.getResponseHeader(name);
23663
      };
23664

23665
      var _validateRangeRequest = (0, _network_utils.validateRangeRequestCapabilities)({
23666
        getResponseHeader: getResponseHeader,
23667
        isHttp: this._manager.isHttp,
23668
        rangeChunkSize: this._rangeChunkSize,
23669
        disableRange: this._disableRange
23670
      }),
23671
          allowRangeRequests = _validateRangeRequest.allowRangeRequests,
23672
          suggestedLength = _validateRangeRequest.suggestedLength;
23673

23674
      if (allowRangeRequests) {
23675
        this._isRangeSupported = true;
23676
      }
23677

23678
      this._contentLength = suggestedLength || this._contentLength;
23679
      this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader);
23680

23681
      if (this._isRangeSupported) {
23682
        this._manager.abortRequest(fullRequestXhrId);
23683
      }
23684

23685
      this._headersReceivedCapability.resolve();
23686
    }
23687
  }, {
23688
    key: "_onDone",
23689
    value: function _onDone(args) {
23690
      if (args) {
23691
        if (this._requests.length > 0) {
23692
          var requestCapability = this._requests.shift();
23693

23694
          requestCapability.resolve({
23695
            value: args.chunk,
23696
            done: false
23697
          });
23698
        } else {
23699
          this._cachedChunks.push(args.chunk);
23700
        }
23701
      }
23702

23703
      this._done = true;
23704

23705
      if (this._cachedChunks.length > 0) {
23706
        return;
23707
      }
23708

23709
      this._requests.forEach(function (requestCapability) {
23710
        requestCapability.resolve({
23711
          value: undefined,
23712
          done: true
23713
        });
23714
      });
23715

23716
      this._requests = [];
23717
    }
23718
  }, {
23719
    key: "_onError",
23720
    value: function _onError(status) {
23721
      var url = this._url;
23722
      var exception = (0, _network_utils.createResponseStatusError)(status, url);
23723
      this._storedError = exception;
23724

23725
      this._headersReceivedCapability.reject(exception);
23726

23727
      this._requests.forEach(function (requestCapability) {
23728
        requestCapability.reject(exception);
23729
      });
23730

23731
      this._requests = [];
23732
      this._cachedChunks = [];
23733
    }
23734
  }, {
23735
    key: "_onProgress",
23736
    value: function _onProgress(data) {
23737
      if (this.onProgress) {
23738
        this.onProgress({
23739
          loaded: data.loaded,
23740
          total: data.lengthComputable ? data.total : this._contentLength
23741
        });
23742
      }
23743
    }
23744
  }, {
23745
    key: "filename",
23746
    get: function get() {
23747
      return this._filename;
23748
    }
23749
  }, {
23750
    key: "isRangeSupported",
23751
    get: function get() {
23752
      return this._isRangeSupported;
23753
    }
23754
  }, {
23755
    key: "isStreamingSupported",
23756
    get: function get() {
23757
      return this._isStreamingSupported;
23758
    }
23759
  }, {
23760
    key: "contentLength",
23761
    get: function get() {
23762
      return this._contentLength;
23763
    }
23764
  }, {
23765
    key: "headersReady",
23766
    get: function get() {
23767
      return this._headersReceivedCapability.promise;
23768
    }
23769
  }, {
23770
    key: "read",
23771
    value: function () {
23772
      var _read = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
23773
        var chunk, requestCapability;
23774
        return _regenerator["default"].wrap(function _callee$(_context) {
23775
          while (1) {
23776
            switch (_context.prev = _context.next) {
23777
              case 0:
23778
                if (!this._storedError) {
23779
                  _context.next = 2;
23780
                  break;
23781
                }
23782

23783
                throw this._storedError;
23784

23785
              case 2:
23786
                if (!(this._cachedChunks.length > 0)) {
23787
                  _context.next = 5;
23788
                  break;
23789
                }
23790

23791
                chunk = this._cachedChunks.shift();
23792
                return _context.abrupt("return", {
23793
                  value: chunk,
23794
                  done: false
23795
                });
23796

23797
              case 5:
23798
                if (!this._done) {
23799
                  _context.next = 7;
23800
                  break;
23801
                }
23802

23803
                return _context.abrupt("return", {
23804
                  value: undefined,
23805
                  done: true
23806
                });
23807

23808
              case 7:
23809
                requestCapability = (0, _util.createPromiseCapability)();
23810

23811
                this._requests.push(requestCapability);
23812

23813
                return _context.abrupt("return", requestCapability.promise);
23814

23815
              case 10:
23816
              case "end":
23817
                return _context.stop();
23818
            }
23819
          }
23820
        }, _callee, this);
23821
      }));
23822

23823
      function read() {
23824
        return _read.apply(this, arguments);
23825
      }
23826

23827
      return read;
23828
    }()
23829
  }, {
23830
    key: "cancel",
23831
    value: function cancel(reason) {
23832
      this._done = true;
23833

23834
      this._headersReceivedCapability.reject(reason);
23835

23836
      this._requests.forEach(function (requestCapability) {
23837
        requestCapability.resolve({
23838
          value: undefined,
23839
          done: true
23840
        });
23841
      });
23842

23843
      this._requests = [];
23844

23845
      if (this._manager.isPendingRequest(this._fullRequestId)) {
23846
        this._manager.abortRequest(this._fullRequestId);
23847
      }
23848

23849
      this._fullRequestReader = null;
23850
    }
23851
  }]);
23852

23853
  return PDFNetworkStreamFullRequestReader;
23854
}();
23855

23856
var PDFNetworkStreamRangeRequestReader = /*#__PURE__*/function () {
23857
  function PDFNetworkStreamRangeRequestReader(manager, begin, end) {
23858
    _classCallCheck(this, PDFNetworkStreamRangeRequestReader);
23859

23860
    this._manager = manager;
23861
    var args = {
23862
      onDone: this._onDone.bind(this),
23863
      onProgress: this._onProgress.bind(this)
23864
    };
23865
    this._requestId = manager.requestRange(begin, end, args);
23866
    this._requests = [];
23867
    this._queuedChunk = null;
23868
    this._done = false;
23869
    this.onProgress = null;
23870
    this.onClosed = null;
23871
  }
23872

23873
  _createClass(PDFNetworkStreamRangeRequestReader, [{
23874
    key: "_close",
23875
    value: function _close() {
23876
      if (this.onClosed) {
23877
        this.onClosed(this);
23878
      }
23879
    }
23880
  }, {
23881
    key: "_onDone",
23882
    value: function _onDone(data) {
23883
      var chunk = data.chunk;
23884

23885
      if (this._requests.length > 0) {
23886
        var requestCapability = this._requests.shift();
23887

23888
        requestCapability.resolve({
23889
          value: chunk,
23890
          done: false
23891
        });
23892
      } else {
23893
        this._queuedChunk = chunk;
23894
      }
23895

23896
      this._done = true;
23897

23898
      this._requests.forEach(function (requestCapability) {
23899
        requestCapability.resolve({
23900
          value: undefined,
23901
          done: true
23902
        });
23903
      });
23904

23905
      this._requests = [];
23906

23907
      this._close();
23908
    }
23909
  }, {
23910
    key: "_onProgress",
23911
    value: function _onProgress(evt) {
23912
      if (!this.isStreamingSupported && this.onProgress) {
23913
        this.onProgress({
23914
          loaded: evt.loaded
23915
        });
23916
      }
23917
    }
23918
  }, {
23919
    key: "isStreamingSupported",
23920
    get: function get() {
23921
      return false;
23922
    }
23923
  }, {
23924
    key: "read",
23925
    value: function () {
23926
      var _read2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
23927
        var chunk, requestCapability;
23928
        return _regenerator["default"].wrap(function _callee2$(_context2) {
23929
          while (1) {
23930
            switch (_context2.prev = _context2.next) {
23931
              case 0:
23932
                if (!(this._queuedChunk !== null)) {
23933
                  _context2.next = 4;
23934
                  break;
23935
                }
23936

23937
                chunk = this._queuedChunk;
23938
                this._queuedChunk = null;
23939
                return _context2.abrupt("return", {
23940
                  value: chunk,
23941
                  done: false
23942
                });
23943

23944
              case 4:
23945
                if (!this._done) {
23946
                  _context2.next = 6;
23947
                  break;
23948
                }
23949

23950
                return _context2.abrupt("return", {
23951
                  value: undefined,
23952
                  done: true
23953
                });
23954

23955
              case 6:
23956
                requestCapability = (0, _util.createPromiseCapability)();
23957

23958
                this._requests.push(requestCapability);
23959

23960
                return _context2.abrupt("return", requestCapability.promise);
23961

23962
              case 9:
23963
              case "end":
23964
                return _context2.stop();
23965
            }
23966
          }
23967
        }, _callee2, this);
23968
      }));
23969

23970
      function read() {
23971
        return _read2.apply(this, arguments);
23972
      }
23973

23974
      return read;
23975
    }()
23976
  }, {
23977
    key: "cancel",
23978
    value: function cancel(reason) {
23979
      this._done = true;
23980

23981
      this._requests.forEach(function (requestCapability) {
23982
        requestCapability.resolve({
23983
          value: undefined,
23984
          done: true
23985
        });
23986
      });
23987

23988
      this._requests = [];
23989

23990
      if (this._manager.isPendingRequest(this._requestId)) {
23991
        this._manager.abortRequest(this._requestId);
23992
      }
23993

23994
      this._close();
23995
    }
23996
  }]);
23997

23998
  return PDFNetworkStreamRangeRequestReader;
23999
}();
24000

24001
/***/ }),
24002
/* 147 */
24003
/***/ ((__unused_webpack_module, exports, __w_pdfjs_require__) => {
24004

24005
"use strict";
24006

24007

24008
Object.defineProperty(exports, "__esModule", ({
24009
  value: true
24010
}));
24011
exports.PDFFetchStream = void 0;
24012

24013
var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
24014

24015
var _util = __w_pdfjs_require__(4);
24016

24017
var _network_utils = __w_pdfjs_require__(144);
24018

24019
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
24020

24021
function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
24022

24023
function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
24024

24025
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
24026

24027
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
24028

24029
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
24030

24031
;
24032

24033
function createFetchOptions(headers, withCredentials, abortController) {
24034
  return {
24035
    method: "GET",
24036
    headers: headers,
24037
    signal: abortController === null || abortController === void 0 ? void 0 : abortController.signal,
24038
    mode: "cors",
24039
    credentials: withCredentials ? "include" : "same-origin",
24040
    redirect: "follow"
24041
  };
24042
}
24043

24044
function createHeaders(httpHeaders) {
24045
  var headers = new Headers();
24046

24047
  for (var property in httpHeaders) {
24048
    var value = httpHeaders[property];
24049

24050
    if (typeof value === "undefined") {
24051
      continue;
24052
    }
24053

24054
    headers.append(property, value);
24055
  }
24056

24057
  return headers;
24058
}
24059

24060
var PDFFetchStream = /*#__PURE__*/function () {
24061
  function PDFFetchStream(source) {
24062
    _classCallCheck(this, PDFFetchStream);
24063

24064
    this.source = source;
24065
    this.isHttp = /^https?:/i.test(source.url);
24066
    this.httpHeaders = this.isHttp && source.httpHeaders || {};
24067
    this._fullRequestReader = null;
24068
    this._rangeRequestReaders = [];
24069
  }
24070

24071
  _createClass(PDFFetchStream, [{
24072
    key: "_progressiveDataLength",
24073
    get: function get() {
24074
      var _this$_fullRequestRea, _this$_fullRequestRea2;
24075

24076
      return (_this$_fullRequestRea = (_this$_fullRequestRea2 = this._fullRequestReader) === null || _this$_fullRequestRea2 === void 0 ? void 0 : _this$_fullRequestRea2._loaded) !== null && _this$_fullRequestRea !== void 0 ? _this$_fullRequestRea : 0;
24077
    }
24078
  }, {
24079
    key: "getFullReader",
24080
    value: function getFullReader() {
24081
      (0, _util.assert)(!this._fullRequestReader, "PDFFetchStream.getFullReader can only be called once.");
24082
      this._fullRequestReader = new PDFFetchStreamReader(this);
24083
      return this._fullRequestReader;
24084
    }
24085
  }, {
24086
    key: "getRangeReader",
24087
    value: function getRangeReader(begin, end) {
24088
      if (end <= this._progressiveDataLength) {
24089
        return null;
24090
      }
24091

24092
      var reader = new PDFFetchStreamRangeReader(this, begin, end);
24093

24094
      this._rangeRequestReaders.push(reader);
24095

24096
      return reader;
24097
    }
24098
  }, {
24099
    key: "cancelAllRequests",
24100
    value: function cancelAllRequests(reason) {
24101
      if (this._fullRequestReader) {
24102
        this._fullRequestReader.cancel(reason);
24103
      }
24104

24105
      var readers = this._rangeRequestReaders.slice(0);
24106

24107
      readers.forEach(function (reader) {
24108
        reader.cancel(reason);
24109
      });
24110
    }
24111
  }]);
24112

24113
  return PDFFetchStream;
24114
}();
24115

24116
exports.PDFFetchStream = PDFFetchStream;
24117

24118
var PDFFetchStreamReader = /*#__PURE__*/function () {
24119
  function PDFFetchStreamReader(stream) {
24120
    var _this = this;
24121

24122
    _classCallCheck(this, PDFFetchStreamReader);
24123

24124
    this._stream = stream;
24125
    this._reader = null;
24126
    this._loaded = 0;
24127
    this._filename = null;
24128
    var source = stream.source;
24129
    this._withCredentials = source.withCredentials || false;
24130
    this._contentLength = source.length;
24131
    this._headersCapability = (0, _util.createPromiseCapability)();
24132
    this._disableRange = source.disableRange || false;
24133
    this._rangeChunkSize = source.rangeChunkSize;
24134

24135
    if (!this._rangeChunkSize && !this._disableRange) {
24136
      this._disableRange = true;
24137
    }
24138

24139
    if (typeof AbortController !== "undefined") {
24140
      this._abortController = new AbortController();
24141
    }
24142

24143
    this._isStreamingSupported = !source.disableStream;
24144
    this._isRangeSupported = !source.disableRange;
24145
    this._headers = createHeaders(this._stream.httpHeaders);
24146
    var url = source.url;
24147
    fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(function (response) {
24148
      if (!(0, _network_utils.validateResponseStatus)(response.status)) {
24149
        throw (0, _network_utils.createResponseStatusError)(response.status, url);
24150
      }
24151

24152
      _this._reader = response.body.getReader();
24153

24154
      _this._headersCapability.resolve();
24155

24156
      var getResponseHeader = function getResponseHeader(name) {
24157
        return response.headers.get(name);
24158
      };
24159

24160
      var _validateRangeRequest = (0, _network_utils.validateRangeRequestCapabilities)({
24161
        getResponseHeader: getResponseHeader,
24162
        isHttp: _this._stream.isHttp,
24163
        rangeChunkSize: _this._rangeChunkSize,
24164
        disableRange: _this._disableRange
24165
      }),
24166
          allowRangeRequests = _validateRangeRequest.allowRangeRequests,
24167
          suggestedLength = _validateRangeRequest.suggestedLength;
24168

24169
      _this._isRangeSupported = allowRangeRequests;
24170
      _this._contentLength = suggestedLength || _this._contentLength;
24171
      _this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader);
24172

24173
      if (!_this._isStreamingSupported && _this._isRangeSupported) {
24174
        _this.cancel(new _util.AbortException("Streaming is disabled."));
24175
      }
24176
    })["catch"](this._headersCapability.reject);
24177
    this.onProgress = null;
24178
  }
24179

24180
  _createClass(PDFFetchStreamReader, [{
24181
    key: "headersReady",
24182
    get: function get() {
24183
      return this._headersCapability.promise;
24184
    }
24185
  }, {
24186
    key: "filename",
24187
    get: function get() {
24188
      return this._filename;
24189
    }
24190
  }, {
24191
    key: "contentLength",
24192
    get: function get() {
24193
      return this._contentLength;
24194
    }
24195
  }, {
24196
    key: "isRangeSupported",
24197
    get: function get() {
24198
      return this._isRangeSupported;
24199
    }
24200
  }, {
24201
    key: "isStreamingSupported",
24202
    get: function get() {
24203
      return this._isStreamingSupported;
24204
    }
24205
  }, {
24206
    key: "read",
24207
    value: function () {
24208
      var _read = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee() {
24209
        var _yield$this$_reader$r, value, done, buffer;
24210

24211
        return _regenerator["default"].wrap(function _callee$(_context) {
24212
          while (1) {
24213
            switch (_context.prev = _context.next) {
24214
              case 0:
24215
                _context.next = 2;
24216
                return this._headersCapability.promise;
24217

24218
              case 2:
24219
                _context.next = 4;
24220
                return this._reader.read();
24221

24222
              case 4:
24223
                _yield$this$_reader$r = _context.sent;
24224
                value = _yield$this$_reader$r.value;
24225
                done = _yield$this$_reader$r.done;
24226

24227
                if (!done) {
24228
                  _context.next = 9;
24229
                  break;
24230
                }
24231

24232
                return _context.abrupt("return", {
24233
                  value: value,
24234
                  done: done
24235
                });
24236

24237
              case 9:
24238
                this._loaded += value.byteLength;
24239

24240
                if (this.onProgress) {
24241
                  this.onProgress({
24242
                    loaded: this._loaded,
24243
                    total: this._contentLength
24244
                  });
24245
                }
24246

24247
                buffer = new Uint8Array(value).buffer;
24248
                return _context.abrupt("return", {
24249
                  value: buffer,
24250
                  done: false
24251
                });
24252

24253
              case 13:
24254
              case "end":
24255
                return _context.stop();
24256
            }
24257
          }
24258
        }, _callee, this);
24259
      }));
24260

24261
      function read() {
24262
        return _read.apply(this, arguments);
24263
      }
24264

24265
      return read;
24266
    }()
24267
  }, {
24268
    key: "cancel",
24269
    value: function cancel(reason) {
24270
      if (this._reader) {
24271
        this._reader.cancel(reason);
24272
      }
24273

24274
      if (this._abortController) {
24275
        this._abortController.abort();
24276
      }
24277
    }
24278
  }]);
24279

24280
  return PDFFetchStreamReader;
24281
}();
24282

24283
var PDFFetchStreamRangeReader = /*#__PURE__*/function () {
24284
  function PDFFetchStreamRangeReader(stream, begin, end) {
24285
    var _this2 = this;
24286

24287
    _classCallCheck(this, PDFFetchStreamRangeReader);
24288

24289
    this._stream = stream;
24290
    this._reader = null;
24291
    this._loaded = 0;
24292
    var source = stream.source;
24293
    this._withCredentials = source.withCredentials || false;
24294
    this._readCapability = (0, _util.createPromiseCapability)();
24295
    this._isStreamingSupported = !source.disableStream;
24296

24297
    if (typeof AbortController !== "undefined") {
24298
      this._abortController = new AbortController();
24299
    }
24300

24301
    this._headers = createHeaders(this._stream.httpHeaders);
24302

24303
    this._headers.append("Range", "bytes=".concat(begin, "-").concat(end - 1));
24304

24305
    var url = source.url;
24306
    fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(function (response) {
24307
      if (!(0, _network_utils.validateResponseStatus)(response.status)) {
24308
        throw (0, _network_utils.createResponseStatusError)(response.status, url);
24309
      }
24310

24311
      _this2._readCapability.resolve();
24312

24313
      _this2._reader = response.body.getReader();
24314
    })["catch"](function (reason) {
24315
      if ((reason === null || reason === void 0 ? void 0 : reason.name) === "AbortError") {
24316
        return;
24317
      }
24318

24319
      throw reason;
24320
    });
24321
    this.onProgress = null;
24322
  }
24323

24324
  _createClass(PDFFetchStreamRangeReader, [{
24325
    key: "isStreamingSupported",
24326
    get: function get() {
24327
      return this._isStreamingSupported;
24328
    }
24329
  }, {
24330
    key: "read",
24331
    value: function () {
24332
      var _read2 = _asyncToGenerator( /*#__PURE__*/_regenerator["default"].mark(function _callee2() {
24333
        var _yield$this$_reader$r2, value, done, buffer;
24334

24335
        return _regenerator["default"].wrap(function _callee2$(_context2) {
24336
          while (1) {
24337
            switch (_context2.prev = _context2.next) {
24338
              case 0:
24339
                _context2.next = 2;
24340
                return this._readCapability.promise;
24341

24342
              case 2:
24343
                _context2.next = 4;
24344
                return this._reader.read();
24345

24346
              case 4:
24347
                _yield$this$_reader$r2 = _context2.sent;
24348
                value = _yield$this$_reader$r2.value;
24349
                done = _yield$this$_reader$r2.done;
24350

24351
                if (!done) {
24352
                  _context2.next = 9;
24353
                  break;
24354
                }
24355

24356
                return _context2.abrupt("return", {
24357
                  value: value,
24358
                  done: done
24359
                });
24360

24361
              case 9:
24362
                this._loaded += value.byteLength;
24363

24364
                if (this.onProgress) {
24365
                  this.onProgress({
24366
                    loaded: this._loaded
24367
                  });
24368
                }
24369

24370
                buffer = new Uint8Array(value).buffer;
24371
                return _context2.abrupt("return", {
24372
                  value: buffer,
24373
                  done: false
24374
                });
24375

24376
              case 13:
24377
              case "end":
24378
                return _context2.stop();
24379
            }
24380
          }
24381
        }, _callee2, this);
24382
      }));
24383

24384
      function read() {
24385
        return _read2.apply(this, arguments);
24386
      }
24387

24388
      return read;
24389
    }()
24390
  }, {
24391
    key: "cancel",
24392
    value: function cancel(reason) {
24393
      if (this._reader) {
24394
        this._reader.cancel(reason);
24395
      }
24396

24397
      if (this._abortController) {
24398
        this._abortController.abort();
24399
      }
24400
    }
24401
  }]);
24402

24403
  return PDFFetchStreamRangeReader;
24404
}();
24405

24406
/***/ })
24407
/******/ 	]);
24408
/************************************************************************/
24409
/******/ 	// The module cache
24410
/******/ 	var __webpack_module_cache__ = {};
24411
/******/ 	
24412
/******/ 	// The require function
24413
/******/ 	function __w_pdfjs_require__(moduleId) {
24414
/******/ 		// Check if module is in cache
24415
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
24416
/******/ 		if (cachedModule !== undefined) {
24417
/******/ 			return cachedModule.exports;
24418
/******/ 		}
24419
/******/ 		// Create a new module (and put it into the cache)
24420
/******/ 		var module = __webpack_module_cache__[moduleId] = {
24421
/******/ 			id: moduleId,
24422
/******/ 			loaded: false,
24423
/******/ 			exports: {}
24424
/******/ 		};
24425
/******/ 	
24426
/******/ 		// Execute the module function
24427
/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __w_pdfjs_require__);
24428
/******/ 	
24429
/******/ 		// Flag the module as loaded
24430
/******/ 		module.loaded = true;
24431
/******/ 	
24432
/******/ 		// Return the exports of the module
24433
/******/ 		return module.exports;
24434
/******/ 	}
24435
/******/ 	
24436
/************************************************************************/
24437
/******/ 	/* webpack/runtime/node module decorator */
24438
/******/ 	(() => {
24439
/******/ 		__w_pdfjs_require__.nmd = (module) => {
24440
/******/ 			module.paths = [];
24441
/******/ 			if (!module.children) module.children = [];
24442
/******/ 			return module;
24443
/******/ 		};
24444
/******/ 	})();
24445
/******/ 	
24446
/************************************************************************/
24447
var __webpack_exports__ = {};
24448
// This entry need to be wrapped in an IIFE because it need to be in strict mode.
24449
(() => {
24450
"use strict";
24451
var exports = __webpack_exports__;
24452

24453

24454
Object.defineProperty(exports, "__esModule", ({
24455
  value: true
24456
}));
24457
Object.defineProperty(exports, "addLinkAttributes", ({
24458
  enumerable: true,
24459
  get: function get() {
24460
    return _display_utils.addLinkAttributes;
24461
  }
24462
}));
24463
Object.defineProperty(exports, "getFilenameFromUrl", ({
24464
  enumerable: true,
24465
  get: function get() {
24466
    return _display_utils.getFilenameFromUrl;
24467
  }
24468
}));
24469
Object.defineProperty(exports, "getPdfFilenameFromUrl", ({
24470
  enumerable: true,
24471
  get: function get() {
24472
    return _display_utils.getPdfFilenameFromUrl;
24473
  }
24474
}));
24475
Object.defineProperty(exports, "isPdfFile", ({
24476
  enumerable: true,
24477
  get: function get() {
24478
    return _display_utils.isPdfFile;
24479
  }
24480
}));
24481
Object.defineProperty(exports, "LinkTarget", ({
24482
  enumerable: true,
24483
  get: function get() {
24484
    return _display_utils.LinkTarget;
24485
  }
24486
}));
24487
Object.defineProperty(exports, "loadScript", ({
24488
  enumerable: true,
24489
  get: function get() {
24490
    return _display_utils.loadScript;
24491
  }
24492
}));
24493
Object.defineProperty(exports, "PDFDateString", ({
24494
  enumerable: true,
24495
  get: function get() {
24496
    return _display_utils.PDFDateString;
24497
  }
24498
}));
24499
Object.defineProperty(exports, "RenderingCancelledException", ({
24500
  enumerable: true,
24501
  get: function get() {
24502
    return _display_utils.RenderingCancelledException;
24503
  }
24504
}));
24505
Object.defineProperty(exports, "build", ({
24506
  enumerable: true,
24507
  get: function get() {
24508
    return _api.build;
24509
  }
24510
}));
24511
Object.defineProperty(exports, "getDocument", ({
24512
  enumerable: true,
24513
  get: function get() {
24514
    return _api.getDocument;
24515
  }
24516
}));
24517
Object.defineProperty(exports, "LoopbackPort", ({
24518
  enumerable: true,
24519
  get: function get() {
24520
    return _api.LoopbackPort;
24521
  }
24522
}));
24523
Object.defineProperty(exports, "PDFDataRangeTransport", ({
24524
  enumerable: true,
24525
  get: function get() {
24526
    return _api.PDFDataRangeTransport;
24527
  }
24528
}));
24529
Object.defineProperty(exports, "PDFWorker", ({
24530
  enumerable: true,
24531
  get: function get() {
24532
    return _api.PDFWorker;
24533
  }
24534
}));
24535
Object.defineProperty(exports, "version", ({
24536
  enumerable: true,
24537
  get: function get() {
24538
    return _api.version;
24539
  }
24540
}));
24541
Object.defineProperty(exports, "CMapCompressionType", ({
24542
  enumerable: true,
24543
  get: function get() {
24544
    return _util.CMapCompressionType;
24545
  }
24546
}));
24547
Object.defineProperty(exports, "createObjectURL", ({
24548
  enumerable: true,
24549
  get: function get() {
24550
    return _util.createObjectURL;
24551
  }
24552
}));
24553
Object.defineProperty(exports, "createPromiseCapability", ({
24554
  enumerable: true,
24555
  get: function get() {
24556
    return _util.createPromiseCapability;
24557
  }
24558
}));
24559
Object.defineProperty(exports, "createValidAbsoluteUrl", ({
24560
  enumerable: true,
24561
  get: function get() {
24562
    return _util.createValidAbsoluteUrl;
24563
  }
24564
}));
24565
Object.defineProperty(exports, "InvalidPDFException", ({
24566
  enumerable: true,
24567
  get: function get() {
24568
    return _util.InvalidPDFException;
24569
  }
24570
}));
24571
Object.defineProperty(exports, "MissingPDFException", ({
24572
  enumerable: true,
24573
  get: function get() {
24574
    return _util.MissingPDFException;
24575
  }
24576
}));
24577
Object.defineProperty(exports, "OPS", ({
24578
  enumerable: true,
24579
  get: function get() {
24580
    return _util.OPS;
24581
  }
24582
}));
24583
Object.defineProperty(exports, "PasswordResponses", ({
24584
  enumerable: true,
24585
  get: function get() {
24586
    return _util.PasswordResponses;
24587
  }
24588
}));
24589
Object.defineProperty(exports, "PermissionFlag", ({
24590
  enumerable: true,
24591
  get: function get() {
24592
    return _util.PermissionFlag;
24593
  }
24594
}));
24595
Object.defineProperty(exports, "removeNullCharacters", ({
24596
  enumerable: true,
24597
  get: function get() {
24598
    return _util.removeNullCharacters;
24599
  }
24600
}));
24601
Object.defineProperty(exports, "shadow", ({
24602
  enumerable: true,
24603
  get: function get() {
24604
    return _util.shadow;
24605
  }
24606
}));
24607
Object.defineProperty(exports, "UnexpectedResponseException", ({
24608
  enumerable: true,
24609
  get: function get() {
24610
    return _util.UnexpectedResponseException;
24611
  }
24612
}));
24613
Object.defineProperty(exports, "UNSUPPORTED_FEATURES", ({
24614
  enumerable: true,
24615
  get: function get() {
24616
    return _util.UNSUPPORTED_FEATURES;
24617
  }
24618
}));
24619
Object.defineProperty(exports, "Util", ({
24620
  enumerable: true,
24621
  get: function get() {
24622
    return _util.Util;
24623
  }
24624
}));
24625
Object.defineProperty(exports, "VerbosityLevel", ({
24626
  enumerable: true,
24627
  get: function get() {
24628
    return _util.VerbosityLevel;
24629
  }
24630
}));
24631
Object.defineProperty(exports, "AnnotationLayer", ({
24632
  enumerable: true,
24633
  get: function get() {
24634
    return _annotation_layer.AnnotationLayer;
24635
  }
24636
}));
24637
Object.defineProperty(exports, "apiCompatibilityParams", ({
24638
  enumerable: true,
24639
  get: function get() {
24640
    return _api_compatibility.apiCompatibilityParams;
24641
  }
24642
}));
24643
Object.defineProperty(exports, "GlobalWorkerOptions", ({
24644
  enumerable: true,
24645
  get: function get() {
24646
    return _worker_options.GlobalWorkerOptions;
24647
  }
24648
}));
24649
Object.defineProperty(exports, "renderTextLayer", ({
24650
  enumerable: true,
24651
  get: function get() {
24652
    return _text_layer.renderTextLayer;
24653
  }
24654
}));
24655
Object.defineProperty(exports, "SVGGraphics", ({
24656
  enumerable: true,
24657
  get: function get() {
24658
    return _svg.SVGGraphics;
24659
  }
24660
}));
24661
Object.defineProperty(exports, "XfaLayer", ({
24662
  enumerable: true,
24663
  get: function get() {
24664
    return _xfa_layer.XfaLayer;
24665
  }
24666
}));
24667

24668
var _display_utils = __w_pdfjs_require__(1);
24669

24670
var _api = __w_pdfjs_require__(125);
24671

24672
var _util = __w_pdfjs_require__(4);
24673

24674
var _annotation_layer = __w_pdfjs_require__(138);
24675

24676
var _api_compatibility = __w_pdfjs_require__(129);
24677

24678
var _worker_options = __w_pdfjs_require__(132);
24679

24680
var _text_layer = __w_pdfjs_require__(140);
24681

24682
var _svg = __w_pdfjs_require__(141);
24683

24684
var _xfa_layer = __w_pdfjs_require__(142);
24685

24686
var pdfjsVersion = '2.8.335';
24687
var pdfjsBuild = '228adbf67';
24688
{
24689
  var _require = __w_pdfjs_require__(6),
24690
      isNodeJS = _require.isNodeJS;
24691

24692
  if (isNodeJS) {
24693
    var PDFNodeStream = __w_pdfjs_require__(143).PDFNodeStream;
24694

24695
    (0, _api.setPDFNetworkStreamFactory)(function (params) {
24696
      return new PDFNodeStream(params);
24697
    });
24698
  } else {
24699
    var PDFNetworkStream = __w_pdfjs_require__(146).PDFNetworkStream;
24700

24701
    var PDFFetchStream;
24702

24703
    if ((0, _display_utils.isFetchSupported)()) {
24704
      PDFFetchStream = __w_pdfjs_require__(147).PDFFetchStream;
24705
    }
24706

24707
    (0, _api.setPDFNetworkStreamFactory)(function (params) {
24708
      if (PDFFetchStream && (0, _display_utils.isValidFetchUrl)(params.url)) {
24709
        return new PDFFetchStream(params);
24710
      }
24711

24712
      return new PDFNetworkStream(params);
24713
    });
24714
  }
24715
}
24716
})();
24717

24718
/******/ 	return __webpack_exports__;
24719
/******/ })()
24720
;
24721
});
24722
//# sourceMappingURL=pdf.js.map
24723