https://elsiglo.cl/wp-content/plugins/pdf-embedder/assets/js/pdfjs/pdf.worker.js

1/**
2 * @licstart The following is the entire license notice for the
3 * Javascript code in this page
4 *
5 * Copyright 2019 Mozilla Foundation
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 *     http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 * @licend The above is the entire license notice for the
20 * Javascript code in this page
21 */
22
23(function webpackUniversalModuleDefinition(root, factory) {
24  if(typeof exports === 'object' && typeof module === 'object')
25    module.exports = factory();
26  else if(typeof define === 'function' && define.amd)
27    define("pdfjs-dist/build/pdf.worker", [], factory);
28  else if(typeof exports === 'object')
29    exports["pdfjs-dist/build/pdf.worker"] = factory();
30  else
31    root["pdfjs-dist/build/pdf.worker"] = root.pdfjsWorker = factory();
32})(this, function() {
33return /******/ (function(modules) { // webpackBootstrap
34/******/  // The module cache
35/******/  var installedModules = {};
36/******/
37/******/  // The require function
38/******/  function __w_pdfjs_require__(moduleId) {
39/******/
40/******/    // Check if module is in cache
41/******/    if(installedModules[moduleId]) {
42/******/      return installedModules[moduleId].exports;
43/******/    }
44/******/    // Create a new module (and put it into the cache)
45/******/    var module = installedModules[moduleId] = {
46/******/      i: moduleId,
47/******/      l: false,
48/******/      exports: {}
49/******/    };
50/******/
51/******/    // Execute the module function
52/******/    modules[moduleId].call(module.exports, module, module.exports, __w_pdfjs_require__);
53/******/
54/******/    // Flag the module as loaded
55/******/    module.l = true;
56/******/
57/******/    // Return the exports of the module
58/******/    return module.exports;
59/******/  }
60/******/
61/******/
62/******/  // expose the modules object (__webpack_modules__)
63/******/  __w_pdfjs_require__.m = modules;
64/******/
65/******/  // expose the module cache
66/******/  __w_pdfjs_require__.c = installedModules;
67/******/
68/******/  // define getter function for harmony exports
69/******/  __w_pdfjs_require__.d = function(exports, name, getter) {
70/******/    if(!__w_pdfjs_require__.o(exports, name)) {
71/******/      Object.defineProperty(exports, name, { enumerable: true, get: getter });
72/******/    }
73/******/  };
74/******/
75/******/  // define __esModule on exports
76/******/  __w_pdfjs_require__.r = function(exports) {
77/******/    if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
78/******/      Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
79/******/    }
80/******/    Object.defineProperty(exports, '__esModule', { value: true });
81/******/  };
82/******/
83/******/  // create a fake namespace object
84/******/  // mode & 1: value is a module id, require it
85/******/  // mode & 2: merge all properties of value into the ns
86/******/  // mode & 4: return value when already ns object
87/******/  // mode & 8|1: behave like require
88/******/  __w_pdfjs_require__.t = function(value, mode) {
89/******/    if(mode & 1) value = __w_pdfjs_require__(value);
90/******/    if(mode & 8) return value;
91/******/    if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
92/******/    var ns = Object.create(null);
93/******/    __w_pdfjs_require__.r(ns);
94/******/    Object.defineProperty(ns, 'default', { enumerable: true, value: value });
95/******/    if(mode & 2 && typeof value != 'string') for(var key in value) __w_pdfjs_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
96/******/    return ns;
97/******/  };
98/******/
99/******/  // getDefaultExport function for compatibility with non-harmony modules
100/******/  __w_pdfjs_require__.n = function(module) {

101/******/    var getter = module && module.__esModule ?
102/******/      function getDefault() { return module['default']; } :
103/******/      function getModuleExports() { return module; };
104/******/    __w_pdfjs_require__.d(getter, 'a', getter);
105/******/    return getter;
106/******/  };
107/******/
108/******/  // Object.prototype.hasOwnProperty.call
109/******/  __w_pdfjs_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
110/******/
111/******/  // __webpack_public_path__
112/******/  __w_pdfjs_require__.p = "";
113/******/
114/******/
115/******/  // Load entry module and return exports
116/******/  return __w_pdfjs_require__(__w_pdfjs_require__.s = 0);
117/******/ })
118/************************************************************************/
119/******/ ([
120/* 0 */
121/***/ (function(module, exports, __w_pdfjs_require__) {
122
123"use strict";
124
125
126var pdfjsVersion = '2.2.228';
127var pdfjsBuild = 'd7afb74a';
128
129var pdfjsCoreWorker = __w_pdfjs_require__(1);
130
131exports.WorkerMessageHandler = pdfjsCoreWorker.WorkerMessageHandler;
132
133/***/ }),
134/* 1 */
135/***/ (function(module, exports, __w_pdfjs_require__) {
136
137"use strict";
138
139
140Object.defineProperty(exports, "__esModule", {
141  value: true
142});
143exports.WorkerMessageHandler = exports.WorkerTask = void 0;
144
145var _regenerator = _interopRequireDefault(__w_pdfjs_require__(2));
146
147var _util = __w_pdfjs_require__(5);
148
149var _primitives = __w_pdfjs_require__(151);
150
151var _pdf_manager = __w_pdfjs_require__(152);
152
153var _is_node = _interopRequireDefault(__w_pdfjs_require__(8));
154
155var _message_handler = __w_pdfjs_require__(191);
156
157var _worker_stream = __w_pdfjs_require__(192);
158
159var _core_utils = __w_pdfjs_require__(154);
160
161function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
162
163function _typeof(obj) { 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); }
164
165function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
166
167function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
168
169function _iterableToArrayLimit(arr, i) { 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; }
170
171function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
172
173function 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); } }
174
175function _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); }); }; }
176
177var WorkerTask = function WorkerTaskClosure() {
178  function WorkerTask(name) {
179    this.name = name;
180    this.terminated = false;
181    this._capability = (0, _util.createPromiseCapability)();
182  }
183
184  WorkerTask.prototype = {
185    get finished() {
186      return this._capability.promise;
187    },
188
189    finish: function finish() {
190      this._capability.resolve();
191    },
192    terminate: function terminate() {
193      this.terminated = true;
194    },
195    ensureNotTerminated: function ensureNotTerminated() {
196      if (this.terminated) {
197        throw new Error('Worker task was terminated');
198      }
199    }
200  };
201  return WorkerTask;
202}();
203
204exports.WorkerTask = WorkerTask;
205var WorkerMessageHandler = {
206  setup: function setup(handler, port) {
207    var testMessageProcessed = false;

208    handler.on('test', function wphSetupTest(data) {
209      if (testMessageProcessed) {
210        return;
211      }
212
213      testMessageProcessed = true;
214
215      if (!(data instanceof Uint8Array)) {
216        handler.send('test', false);
217        return;
218      }
219
220      var supportTransfers = data[0] === 255;
221      handler.postMessageTransfers = supportTransfers;
222      var xhr = new XMLHttpRequest();
223      var responseExists = 'response' in xhr;
224
225      try {
226        xhr.responseType;
227      } catch (e) {
228        responseExists = false;
229      }
230
231      if (!responseExists) {
232        handler.send('test', false);
233        return;
234      }
235
236      handler.send('test', {
237        supportTypedArray: true,
238        supportTransfers: supportTransfers
239      });
240    });
241    handler.on('configure', function wphConfigure(data) {
242      (0, _util.setVerbosityLevel)(data.verbosity);
243    });
244    handler.on('GetDocRequest', function wphSetupDoc(data) {
245      return WorkerMessageHandler.createDocumentHandler(data, port);
246    });
247  },
248  createDocumentHandler: function createDocumentHandler(docParams, port) {
249    var pdfManager;
250    var terminated = false;
251    var cancelXHRs = null;
252    var WorkerTasks = [];
253    var verbosity = (0, _util.getVerbosityLevel)();
254    var apiVersion = docParams.apiVersion;
255    var workerVersion = '2.2.228';
256
257    if (apiVersion !== workerVersion) {
258      throw new Error("The API version \"".concat(apiVersion, "\" does not match ") + "the Worker version \"".concat(workerVersion, "\"."));
259    }
260
261    var docId = docParams.docId;
262    var docBaseUrl = docParams.docBaseUrl;
263    var workerHandlerName = docParams.docId + '_worker';
264    var handler = new _message_handler.MessageHandler(workerHandlerName, docId, port);
265    handler.postMessageTransfers = docParams.postMessageTransfers;
266
267    function ensureNotTerminated() {
268      if (terminated) {
269        throw new Error('Worker was terminated');
270      }
271    }
272
273    function startWorkerTask(task) {
274      WorkerTasks.push(task);
275    }
276
277    function finishWorkerTask(task) {
278      task.finish();
279      var i = WorkerTasks.indexOf(task);
280      WorkerTasks.splice(i, 1);
281    }
282
283    function loadDocument(_x) {
284      return _loadDocument.apply(this, arguments);
285    }
286
287    function _loadDocument() {
288      _loadDocument = _asyncToGenerator(
289      /*#__PURE__*/
290      _regenerator["default"].mark(function _callee(recoveryMode) {
291        var _ref4, _ref5, numPages, fingerprint;
292
293        return _regenerator["default"].wrap(function _callee$(_context) {
294          while (1) {
295            switch (_context.prev = _context.next) {
296              case 0:
297                _context.next = 2;
298                return pdfManager.ensureDoc('checkHeader');
299
300              case 2:
301                _context.next = 4;
302                return pdfManager.ensureDoc('parseStartXRef');
303
304              case 4:
305                _context.next = 6;
306                return pdfManager.ensureDoc('parse', [recoveryMode]);
307
308              case 6:
309                if (recoveryMode) {
310                  _context.next = 9;
311                  break;
312                }
313
314                _context.next = 9;
315                return pdfManager.ensureDoc('checkFirstPage');
316
317              case 9:
318                _context.next = 11;
319                return Promise.all([pdfManager.ensureDoc('numPages'), pdfManager.ensureDoc('fingerprint')]);
320
321              case 11:
322                _ref4 = _context.sent;
323                _ref5 = _slicedToArray(_ref4, 2);
324                numPages = _ref5[0];
325                fingerprint = _ref5[1];
326                return _context.abrupt("return", {
327                  numPages: numPages,
328                  fingerprint: fingerprint
329                });
330
331              case 16:
332              case "end":
333                return _context.stop();
334            }
335          }
336        }, _callee);
337      }));
338      return _loadDocument.apply(this, arguments);
339    }
340
341    function getPdfManager(data, evaluatorOptions) {
342      var pdfManagerCapability = (0, _util.createPromiseCapability)();
343      var pdfManager;
344      var source = data.source;
345
346      if (source.data) {
347        try {
348          pdfManager = new _pdf_manager.LocalPdfManager(docId, source.data, source.password, evaluatorOptions, docBaseUrl);
349          pdfManagerCapability.resolve(pdfManager);
350        } catch (ex) {
351          pdfManagerCapability.reject(ex);
352        }
353
354        return pdfManagerCapability.promise;
355      }
356
357      var pdfStream,
358          cachedChunks = [];
359

360      try {
361        pdfStream = new _worker_stream.PDFWorkerStream(handler);
362      } catch (ex) {
363        pdfManagerCapability.reject(ex);
364        return pdfManagerCapability.promise;
365      }
366
367      var fullRequest = pdfStream.getFullReader();
368      fullRequest.headersReady.then(function () {
369        if (!fullRequest.isRangeSupported) {
370          return;
371        }
372
373        var disableAutoFetch = source.disableAutoFetch || fullRequest.isStreamingSupported;
374        pdfManager = new _pdf_manager.NetworkPdfManager(docId, pdfStream, {
375          msgHandler: handler,
376          password: source.password,
377          length: fullRequest.contentLength,
378          disableAutoFetch: disableAutoFetch,
379          rangeChunkSize: source.rangeChunkSize
380        }, evaluatorOptions, docBaseUrl);
381
382        for (var i = 0; i < cachedChunks.length; i++) {
383          pdfManager.sendProgressiveData(cachedChunks[i]);
384        }
385
386        cachedChunks = [];
387        pdfManagerCapability.resolve(pdfManager);
388        cancelXHRs = null;
389      })["catch"](function (reason) {
390        pdfManagerCapability.reject(reason);
391        cancelXHRs = null;
392      });
393      var loaded = 0;
394
395      var flushChunks = function flushChunks() {
396        var pdfFile = (0, _util.arraysToBytes)(cachedChunks);
397
398        if (source.length && pdfFile.length !== source.length) {
399          (0, _util.warn)('reported HTTP length is different from actual');
400        }
401
402        try {
403          pdfManager = new _pdf_manager.LocalPdfManager(docId, pdfFile, source.password, evaluatorOptions, docBaseUrl);
404          pdfManagerCapability.resolve(pdfManager);
405        } catch (ex) {
406          pdfManagerCapability.reject(ex);
407        }
408
409        cachedChunks = [];
410      };
411
412      var readPromise = new Promise(function (resolve, reject) {
413        var readChunk = function readChunk(chunk) {
414          try {
415            ensureNotTerminated();
416
417            if (chunk.done) {
418              if (!pdfManager) {
419                flushChunks();
420              }
421
422              cancelXHRs = null;
423              return;
424            }
425
426            var data = chunk.value;
427            loaded += (0, _util.arrayByteLength)(data);
428
429            if (!fullRequest.isStreamingSupported) {
430              handler.send('DocProgress', {
431                loaded: loaded,
432                total: Math.max(loaded, fullRequest.contentLength || 0)
433              });
434            }
435
436            if (pdfManager) {
437              pdfManager.sendProgressiveData(data);
438            } else {
439              cachedChunks.push(data);
440            }
441
442            fullRequest.read().then(readChunk, reject);
443          } catch (e) {
444            reject(e);
445          }
446        };
447
448        fullRequest.read().then(readChunk, reject);
449      });
450      readPromise["catch"](function (e) {
451        pdfManagerCapability.reject(e);
452        cancelXHRs = null;
453      });
454
455      cancelXHRs = function cancelXHRs() {
456        pdfStream.cancelAllRequests('abort');
457      };
458
459      return pdfManagerCapability.promise;
460    }
461
462    function setupDoc(data) {
463      function onSuccess(doc) {
464        ensureNotTerminated();
465        handler.send('GetDoc', {
466          pdfInfo: doc
467        });
468      }
469
470      function onFailure(e) {
471        ensureNotTerminated();
472
473        if (e instanceof _util.PasswordException) {
474          var task = new WorkerTask('PasswordException: response ' + e.code);
475          startWorkerTask(task);
476          handler.sendWithPromise('PasswordRequest', e).then(function (data) {
477            finishWorkerTask(task);
478            pdfManager.updatePassword(data.password);
479            pdfManagerReady();
480          })["catch"](function (boundException) {
481            finishWorkerTask(task);
482            handler.send('PasswordException', boundException);
483          }.bind(null, e));
484        } else if (e instanceof _util.InvalidPDFException) {
485          handler.send('InvalidPDF', e);
486        } else if (e instanceof _util.MissingPDFException) {
487          handler.send('MissingPDF', e);
488        } else if (e instanceof _util.UnexpectedResponseException) {
489          handler.send('UnexpectedResponse', e);
490        } else {
491          handler.send('UnknownError', new _util.UnknownErrorException(e.message, e.toString()));
492        }
493      }
494
495      function pdfManagerReady() {
496        ensureNotTerminated();
497        loadDocument(false).then(onSuccess, function loadFailure(ex) {
498          ensureNotTerminated();
499
500          if (!(ex instanceof _core_utils.XRefParseException)) {
501            onFailure(ex);
502            return;
503          }
504
505          pdfManager.requestLoadedStream();
506          pdfManager.onLoadedStream().then(function () {
507            ensureNotTerminated();

508            loadDocument(true).then(onSuccess, onFailure);
509          });
510        }, onFailure);
511      }
512
513      ensureNotTerminated();
514      var evaluatorOptions = {
515        forceDataSchema: data.disableCreateObjectURL,
516        maxImageSize: data.maxImageSize,
517        disableFontFace: data.disableFontFace,
518        nativeImageDecoderSupport: data.nativeImageDecoderSupport,
519        ignoreErrors: data.ignoreErrors,
520        isEvalSupported: data.isEvalSupported
521      };
522      getPdfManager(data, evaluatorOptions).then(function (newPdfManager) {
523        if (terminated) {
524          newPdfManager.terminate();
525          throw new Error('Worker was terminated');
526        }
527
528        pdfManager = newPdfManager;
529        pdfManager.onLoadedStream().then(function (stream) {
530          handler.send('DataLoaded', {
531            length: stream.bytes.byteLength
532          });
533        });
534      }).then(pdfManagerReady, onFailure);
535    }
536
537    handler.on('GetPage', function wphSetupGetPage(data) {
538      return pdfManager.getPage(data.pageIndex).then(function (page) {
539        return Promise.all([pdfManager.ensure(page, 'rotate'), pdfManager.ensure(page, 'ref'), pdfManager.ensure(page, 'userUnit'), pdfManager.ensure(page, 'view')]).then(function (_ref) {
540          var _ref2 = _slicedToArray(_ref, 4),
541              rotate = _ref2[0],
542              ref = _ref2[1],
543              userUnit = _ref2[2],
544              view = _ref2[3];
545
546          return {
547            rotate: rotate,
548            ref: ref,
549            userUnit: userUnit,
550            view: view
551          };
552        });
553      });
554    });
555    handler.on('GetPageIndex', function wphSetupGetPageIndex(data) {
556      var ref = _primitives.Ref.get(data.ref.num, data.ref.gen);
557
558      var catalog = pdfManager.pdfDocument.catalog;
559      return catalog.getPageIndex(ref);
560    });
561    handler.on('GetDestinations', function wphSetupGetDestinations(data) {
562      return pdfManager.ensureCatalog('destinations');
563    });
564    handler.on('GetDestination', function wphSetupGetDestination(data) {
565      return pdfManager.ensureCatalog('getDestination', [data.id]);
566    });
567    handler.on('GetPageLabels', function wphSetupGetPageLabels(data) {
568      return pdfManager.ensureCatalog('pageLabels');
569    });
570    handler.on('GetPageLayout', function wphSetupGetPageLayout(data) {
571      return pdfManager.ensureCatalog('pageLayout');
572    });
573    handler.on('GetPageMode', function wphSetupGetPageMode(data) {
574      return pdfManager.ensureCatalog('pageMode');
575    });
576    handler.on('GetViewerPreferences', function (data) {
577      return pdfManager.ensureCatalog('viewerPreferences');
578    });
579    handler.on('GetOpenActionDestination', function (data) {
580      return pdfManager.ensureCatalog('openActionDestination');
581    });
582    handler.on('GetAttachments', function wphSetupGetAttachments(data) {
583      return pdfManager.ensureCatalog('attachments');
584    });
585    handler.on('GetJavaScript', function wphSetupGetJavaScript(data) {
586      return pdfManager.ensureCatalog('javaScript');
587    });
588    handler.on('GetOutline', function wphSetupGetOutline(data) {
589      return pdfManager.ensureCatalog('documentOutline');
590    });
591    handler.on('GetPermissions', function (data) {
592      return pdfManager.ensureCatalog('permissions');
593    });
594    handler.on('GetMetadata', function wphSetupGetMetadata(data) {
595      return Promise.all([pdfManager.ensureDoc('documentInfo'), pdfManager.ensureCatalog('metadata')]);
596    });
597    handler.on('GetData', function wphSetupGetData(data) {
598      pdfManager.requestLoadedStream();
599      return pdfManager.onLoadedStream().then(function (stream) {
600        return stream.bytes;
601      });
602    });
603    handler.on('GetStats', function wphSetupGetStats(data) {
604      return pdfManager.pdfDocument.xref.stats;
605    });
606    handler.on('GetAnnotations', function (_ref3) {
607      var pageIndex = _ref3.pageIndex,
608          intent = _ref3.intent;
609      return pdfManager.getPage(pageIndex).then(function (page) {
610        return page.getAnnotationsData(intent);
611      });
612    });
613    handler.on('RenderPageRequest', function wphSetupRenderPage(data) {
614      var pageIndex = data.pageIndex;
615      pdfManager.getPage(pageIndex).then(function (page) {
616        var task = new WorkerTask('RenderPageRequest: page ' + pageIndex);
617        startWorkerTask(task);
618        var start = verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
619        page.getOperatorList({
620          handler: handler,
621          task: task,
622          intent: data.intent,
623          renderInteractiveForms: data.renderInteractiveForms
624        }).then(function (operatorList) {
625          finishWorkerTask(task);
626
627          if (start) {
628            (0, _util.info)("page=".concat(pageIndex + 1, " - getOperatorList: time=") + "".concat(Date.now() - start, "ms, len=").concat(operatorList.totalLength));
629          }
630        }, function (e) {
631          finishWorkerTask(task);
632
633          if (task.terminated) {
634            return;
635          }
636
637          handler.send('UnsupportedFeature', {
638            featureId: _util.UNSUPPORTED_FEATURES.unknown
639          });
640          var minimumStackMessage = 'worker.js: while trying to getPage() and getOperatorList()';
641          var wrappedException;
642
643          if (typeof e === 'string') {
644            wrappedException = {
645              message: e,
646              stack: minimumStackMessage
647            };
648          } else if (_typeof(e) === 'object') {
649            wrappedException = {
650              message: e.message || e.toString(),
651              stack: e.stack || minimumStackMessage
652            };
653          } else {
654            wrappedException = {
655              message: 'Unknown exception type: ' + _typeof(e),
656              stack: minimumStackMessage
657            };
658          }
659
660          handler.send('PageError', {
661            pageIndex: pageIndex,
662            error: wrappedException,
663            intent: data.intent
664          });
665        });
666      });
667    }, this);
668    handler.on('GetTextContent', function wphExtractText(data, sink) {
669      var pageIndex = data.pageIndex;
670
671      sink.onPull = function (desiredSize) {};
672
673      sink.onCancel = function (reason) {};
674
675      pdfManager.getPage(pageIndex).then(function (page) {
676        var task = new WorkerTask('GetTextContent: page ' + pageIndex);
677        startWorkerTask(task);
678        var start = verbosity >= _util.VerbosityLevel.INFOS ? Date.now() : 0;
679        page.extractTextContent({
680          handler: handler,
681          task: task,
682          sink: sink,
683          normalizeWhitespace: data.normalizeWhitespace,
684          combineTextItems: data.combineTextItems
685        }).then(function () {
686          finishWorkerTask(task);
687
688          if (start) {
689            (0, _util.info)("page=".concat(pageIndex + 1, " - getTextContent: time=") + "".concat(Date.now() - start, "ms"));
690          }
691
692          sink.close();
693        }, function (reason) {
694          finishWorkerTask(task);
695
696          if (task.terminated) {
697            return;
698          }
699
700          sink.error(reason);
701          throw reason;
702        });
703      });
704    });
705    handler.on('FontFallback', function (data) {
706      return pdfManager.fontFallback(data.id, handler);
707    });
708    handler.on('Cleanup', function wphCleanup(data) {
709      return pdfManager.cleanup();
710    });
711    handler.on('Terminate', function wphTerminate(data) {
712      terminated = true;
713
714      if (pdfManager) {
715        pdfManager.terminate();
716        pdfManager = null;
717      }
718
719      if (cancelXHRs) {
720        cancelXHRs();
721      }
722
723      (0, _primitives.clearPrimitiveCaches)();
724      var waitOn = [];
725      WorkerTasks.forEach(function (task) {
726        waitOn.push(task.finished);
727        task.terminate();
728      });
729      return Promise.all(waitOn).then(function () {
730        handler.destroy();
731        handler = null;
732      });
733    });
734    handler.on('Ready', function wphReady(data) {
735      setupDoc(docParams);
736      docParams = null;
737    });
738    return workerHandlerName;
739  },
740  initializeFromPort: function initializeFromPort(port) {
741    var handler = new _message_handler.MessageHandler('worker', 'main', port);
742    WorkerMessageHandler.setup(handler, port);
743    handler.send('ready', null);
744  }
745};
746exports.WorkerMessageHandler = WorkerMessageHandler;
747
748function isMessagePort(maybePort) {
749  return typeof maybePort.postMessage === 'function' && 'onmessage' in maybePort;
750}
751
752if (typeof window === 'undefined' && !(0, _is_node["default"])() && typeof self !== 'undefined' && isMessagePort(self)) {
753  WorkerMessageHandler.initializeFromPort(self);
754}
755
756/***/ }),
757/* 2 */
758/***/ (function(module, exports, __w_pdfjs_require__) {
759
760"use strict";
761
762
763module.exports = __w_pdfjs_require__(3);
764
765/***/ }),
766/* 3 */
767/***/ (function(module, exports, __w_pdfjs_require__) {
768
769"use strict";
770/* WEBPACK VAR INJECTION */(function(module) {
771
772function _typeof(obj) { 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); }
773
774var runtime = function (exports) {
775  "use strict";
776
777  var Op = Object.prototype;
778  var hasOwn = Op.hasOwnProperty;
779  var undefined;
780  var $Symbol = typeof Symbol === "function" ? Symbol : {};
781  var iteratorSymbol = $Symbol.iterator || "@@iterator";
782  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
783  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
784
785  function wrap(innerFn, outerFn, self, tryLocsList) {
786    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
787    var generator = Object.create(protoGenerator.prototype);
788    var context = new Context(tryLocsList || []);
789    generator._invoke = makeInvokeMethod(innerFn, self, context);
790    return generator;
791  }
792
793  exports.wrap = wrap;
794
795  function tryCatch(fn, obj, arg) {
796    try {
797      return {
798        type: "normal",
799        arg: fn.call(obj, arg)
800      };
801    } catch (err) {
802      return {
803        type: "throw",
804        arg: err
805      };
806    }
807  }
808
809  var GenStateSuspendedStart = "suspendedStart";
810  var GenStateSuspendedYield = "suspendedYield";
811  var GenStateExecuting = "executing";
812  var GenStateCompleted = "completed";
813  var ContinueSentinel = {};
814
815  function Generator() {}
816
817  function GeneratorFunction() {}
818
819  function GeneratorFunctionPrototype() {}
820
821  var IteratorPrototype = {};
822
823  IteratorPrototype[iteratorSymbol] = function () {
824    return this;
825  };
826
827  var getProto = Object.getPrototypeOf;
828  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
829
830  if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
831    IteratorPrototype = NativeIteratorPrototype;
832  }
833
834  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
835  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
836  GeneratorFunctionPrototype.constructor = GeneratorFunction;
837  GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = "GeneratorFunction";
838
839  function defineIteratorMethods(prototype) {
840    ["next", "throw", "return"].forEach(function (method) {
841      prototype[method] = function (arg) {
842        return this._invoke(method, arg);
843      };
844    });
845  }
846
847  exports.isGeneratorFunction = function (genFun) {
848    var ctor = typeof genFun === "function" && genFun.constructor;
849    return ctor ? ctor === GeneratorFunction || (ctor.displayName || ctor.name) === "GeneratorFunction" : false;

850  };
851
852  exports.mark = function (genFun) {
853    if (Object.setPrototypeOf) {
854      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
855    } else {
856      genFun.__proto__ = GeneratorFunctionPrototype;
857
858      if (!(toStringTagSymbol in genFun)) {
859        genFun[toStringTagSymbol] = "GeneratorFunction";
860      }
861    }
862
863    genFun.prototype = Object.create(Gp);
864    return genFun;
865  };
866
867  exports.awrap = function (arg) {
868    return {
869      __await: arg
870    };
871  };
872
873  function AsyncIterator(generator) {
874    function invoke(method, arg, resolve, reject) {
875      var record = tryCatch(generator[method], generator, arg);
876
877      if (record.type === "throw") {
878        reject(record.arg);
879      } else {
880        var result = record.arg;
881        var value = result.value;
882
883        if (value && _typeof(value) === "object" && hasOwn.call(value, "__await")) {
884          return Promise.resolve(value.__await).then(function (value) {
885            invoke("next", value, resolve, reject);
886          }, function (err) {
887            invoke("throw", err, resolve, reject);
888          });
889        }
890
891        return Promise.resolve(value).then(function (unwrapped) {
892          result.value = unwrapped;
893          resolve(result);
894        }, function (error) {
895          return invoke("throw", error, resolve, reject);
896        });
897      }
898    }
899
900    var previousPromise;
901
902    function enqueue(method, arg) {
903      function callInvokeWithMethodAndArg() {
904        return new Promise(function (resolve, reject) {
905          invoke(method, arg, resolve, reject);
906        });
907      }
908
909      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
910    }
911
912    this._invoke = enqueue;
913  }
914
915  defineIteratorMethods(AsyncIterator.prototype);
916
917  AsyncIterator.prototype[asyncIteratorSymbol] = function () {
918    return this;
919  };
920
921  exports.AsyncIterator = AsyncIterator;
922
923  exports.async = function (innerFn, outerFn, self, tryLocsList) {
924    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList));
925    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
926      return result.done ? result.value : iter.next();
927    });
928  };
929
930  function makeInvokeMethod(innerFn, self, context) {
931    var state = GenStateSuspendedStart;
932    return function invoke(method, arg) {
933      if (state === GenStateExecuting) {
934        throw new Error("Generator is already running");
935      }
936
937      if (state === GenStateCompleted) {
938        if (method === "throw") {
939          throw arg;
940        }
941
942        return doneResult();
943      }
944
945      context.method = method;
946      context.arg = arg;
947
948      while (true) {
949        var delegate = context.delegate;
950
951        if (delegate) {
952          var delegateResult = maybeInvokeDelegate(delegate, context);
953
954          if (delegateResult) {
955            if (delegateResult === ContinueSentinel) continue;
956            return delegateResult;
957          }
958        }
959
960        if (context.method === "next") {
961          context.sent = context._sent = context.arg;
962        } else if (context.method === "throw") {
963          if (state === GenStateSuspendedStart) {
964            state = GenStateCompleted;
965            throw context.arg;
966          }
967
968          context.dispatchException(context.arg);
969        } else if (context.method === "return") {
970          context.abrupt("return", context.arg);
971        }
972
973        state = GenStateExecuting;
974        var record = tryCatch(innerFn, self, context);
975
976        if (record.type === "normal") {
977          state = context.done ? GenStateCompleted : GenStateSuspendedYield;
978
979          if (record.arg === ContinueSentinel) {
980            continue;
981          }
982
983          return {
984            value: record.arg,
985            done: context.done
986          };
987        } else if (record.type === "throw") {
988          state = GenStateCompleted;
989          context.method = "throw";
990          context.arg = record.arg;
991        }
992      }
993    };
994  }
995
996  function maybeInvokeDelegate(delegate, context) {
997    var method = delegate.iterator[context.method];
998
999    if (method === undefined) {
1000      context.delegate = null;
1001
1002      if (context.method === "throw") {
1003        if (delegate.iterator["return"]) {
1004          context.method = "return";
1005          context.arg = undefined;
1006          maybeInvokeDelegate(delegate, context);
1007
1008          if (context.method === "throw") {
1009            return ContinueSentinel;
1010          }
1011        }
1012
1013        context.method = "throw";
1014        context.arg = new TypeError("The iterator does not provide a 'throw' method");
1015      }
1016
1017      return ContinueSentinel;
1018    }
1019
1020    var record = tryCatch(method, delegate.iterator, context.arg);
1021
1022    if (record.type === "throw") {
1023      context.method = "throw";
1024      context.arg = record.arg;
1025      context.delegate = null;
1026      return ContinueSentinel;
1027    }
1028
1029    var info = record.arg;
1030
1031    if (!info) {
1032      context.method = "throw";
1033      context.arg = new TypeError("iterator result is not an object");
1034      context.delegate = null;
1035      return ContinueSentinel;
1036    }
1037
1038    if (info.done) {
1039      context[delegate.resultName] = info.value;
1040      context.next = delegate.nextLoc;
1041
1042      if (context.method !== "return") {
1043        context.method = "next";
1044        context.arg = undefined;
1045      }
1046    } else {
1047      return info;
1048    }
1049
1050    context.delegate = null;
1051    return ContinueSentinel;
1052  }
1053
1054  defineIteratorMethods(Gp);
1055  Gp[toStringTagSymbol] = "Generator";
1056
1057  Gp[iteratorSymbol] = function () {
1058    return this;
1059  };
1060
1061  Gp.toString = function () {
1062    return "[object Generator]";
1063  };
1064
1065  function pushTryEntry(locs) {
1066    var entry = {

1067      tryLoc: locs[0]
1068    };
1069
1070    if (1 in locs) {
1071      entry.catchLoc = locs[1];
1072    }
1073
1074    if (2 in locs) {
1075      entry.finallyLoc = locs[2];
1076      entry.afterLoc = locs[3];
1077    }
1078
1079    this.tryEntries.push(entry);
1080  }
1081
1082  function resetTryEntry(entry) {
1083    var record = entry.completion || {};
1084    record.type = "normal";
1085    delete record.arg;
1086    entry.completion = record;
1087  }
1088
1089  function Context(tryLocsList) {
1090    this.tryEntries = [{
1091      tryLoc: "root"
1092    }];
1093    tryLocsList.forEach(pushTryEntry, this);
1094    this.reset(true);
1095  }
1096
1097  exports.keys = function (object) {
1098    var keys = [];
1099
1100    for (var key in object) {
1101      keys.push(key);
1102    }
1103
1104    keys.reverse();
1105    return function next() {
1106      while (keys.length) {
1107        var key = keys.pop();
1108
1109        if (key in object) {
1110          next.value = key;
1111          next.done = false;
1112          return next;
1113        }
1114      }
1115
1116      next.done = true;
1117      return next;
1118    };
1119  };
1120
1121  function values(iterable) {
1122    if (iterable) {
1123      var iteratorMethod = iterable[iteratorSymbol];
1124
1125      if (iteratorMethod) {
1126        return iteratorMethod.call(iterable);
1127      }
1128
1129      if (typeof iterable.next === "function") {
1130        return iterable;
1131      }
1132
1133      if (!isNaN(iterable.length)) {
1134        var i = -1,
1135            next = function next() {
1136          while (++i < iterable.length) {
1137            if (hasOwn.call(iterable, i)) {
1138              next.value = iterable[i];
1139              next.done = false;
1140              return next;
1141            }
1142          }
1143
1144          next.value = undefined;
1145          next.done = true;
1146          return next;
1147        };
1148
1149        return next.next = next;
1150      }
1151    }
1152
1153    return {
1154      next: doneResult
1155    };
1156  }
1157
1158  exports.values = values;
1159
1160  function doneResult() {
1161    return {
1162      value: undefined,
1163      done: true
1164    };
1165  }
1166
1167  Context.prototype = {
1168    constructor: Context,
1169    reset: function reset(skipTempReset) {
1170      this.prev = 0;
1171      this.next = 0;
1172      this.sent = this._sent = undefined;
1173      this.done = false;
1174      this.delegate = null;
1175      this.method = "next";
1176      this.arg = undefined;
1177      this.tryEntries.forEach(resetTryEntry);
1178
1179      if (!skipTempReset) {
1180        for (var name in this) {
1181          if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
1182            this[name] = undefined;
1183          }
1184        }
1185      }
1186    },
1187    stop: function stop() {
1188      this.done = true;
1189      var rootEntry = this.tryEntries[0];
1190      var rootRecord = rootEntry.completion;
1191
1192      if (rootRecord.type === "throw") {
1193        throw rootRecord.arg;
1194      }
1195
1196      return this.rval;
1197    },
1198    dispatchException: function dispatchException(exception) {
1199      if (this.done) {
1200        throw exception;
1201      }
1202
1203      var context = this;
1204
1205      function handle(loc, caught) {
1206        record.type = "throw";
1207        record.arg = exception;
1208        context.next = loc;
1209
1210        if (caught) {
1211          context.method = "next";
1212          context.arg = undefined;
1213        }
1214
1215        return !!caught;
1216      }
1217
1218      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1219        var entry = this.tryEntries[i];
1220        var record = entry.completion;
1221
1222        if (entry.tryLoc === "root") {
1223          return handle("end");
1224        }
1225
1226        if (entry.tryLoc <= this.prev) {
1227          var hasCatch = hasOwn.call(entry, "catchLoc");
1228          var hasFinally = hasOwn.call(entry, "finallyLoc");
1229
1230          if (hasCatch && hasFinally) {
1231            if (this.prev < entry.catchLoc) {
1232              return handle(entry.catchLoc, true);
1233            } else if (this.prev < entry.finallyLoc) {
1234              return handle(entry.finallyLoc);
1235            }
1236          } else if (hasCatch) {
1237            if (this.prev < entry.catchLoc) {
1238              return handle(entry.catchLoc, true);
1239            }
1240          } else if (hasFinally) {
1241            if (this.prev < entry.finallyLoc) {
1242              return handle(entry.finallyLoc);
1243            }
1244          } else {
1245            throw new Error("try statement without catch or finally");
1246          }
1247        }
1248      }
1249    },
1250    abrupt: function abrupt(type, arg) {
1251      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1252        var entry = this.tryEntries[i];
1253
1254        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
1255          var finallyEntry = entry;
1256          break;
1257        }
1258      }
1259
1260      if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
1261        finallyEntry = null;
1262      }
1263
1264      var record = finallyEntry ? finallyEntry.completion : {};
1265      record.type = type;
1266      record.arg = arg;
1267
1268      if (finallyEntry) {
1269        this.method = "next";
1270        this.next = finallyEntry.finallyLoc;
1271        return ContinueSentinel;
1272      }
1273
1274      return this.complete(record);
1275    },
1276    complete: function complete(record, afterLoc) {
1277      if (record.type === "throw") {

1278        throw record.arg;
1279      }
1280
1281      if (record.type === "break" || record.type === "continue") {
1282        this.next = record.arg;
1283      } else if (record.type === "return") {
1284        this.rval = this.arg = record.arg;
1285        this.method = "return";
1286        this.next = "end";
1287      } else if (record.type === "normal" && afterLoc) {
1288        this.next = afterLoc;
1289      }
1290
1291      return ContinueSentinel;
1292    },
1293    finish: function finish(finallyLoc) {
1294      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1295        var entry = this.tryEntries[i];
1296
1297        if (entry.finallyLoc === finallyLoc) {
1298          this.complete(entry.completion, entry.afterLoc);
1299          resetTryEntry(entry);
1300          return ContinueSentinel;
1301        }
1302      }
1303    },
1304    "catch": function _catch(tryLoc) {
1305      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
1306        var entry = this.tryEntries[i];
1307
1308        if (entry.tryLoc === tryLoc) {
1309          var record = entry.completion;
1310
1311          if (record.type === "throw") {
1312            var thrown = record.arg;
1313            resetTryEntry(entry);
1314          }
1315
1316          return thrown;
1317        }
1318      }
1319
1320      throw new Error("illegal catch attempt");
1321    },
1322    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
1323      this.delegate = {
1324        iterator: values(iterable),
1325        resultName: resultName,
1326        nextLoc: nextLoc
1327      };
1328
1329      if (this.method === "next") {
1330        this.arg = undefined;
1331      }
1332
1333      return ContinueSentinel;
1334    }
1335  };
1336  return exports;
1337}(( false ? undefined : _typeof(module)) === "object" ? module.exports : {});
1338
1339try {
1340  regeneratorRuntime = runtime;
1341} catch (accidentalStrictMode) {
1342  Function("r", "regeneratorRuntime = r")(runtime);
1343}
1344/* WEBPACK VAR INJECTION */}.call(this, __w_pdfjs_require__(4)(module)))
1345
1346/***/ }),
1347/* 4 */
1348/***/ (function(module, exports, __w_pdfjs_require__) {
1349
1350"use strict";
1351
1352
1353module.exports = function (module) {
1354  if (!module.webpackPolyfill) {
1355    module.deprecate = function () {};
1356
1357    module.paths = [];
1358    if (!module.children) module.children = [];
1359    Object.defineProperty(module, "loaded", {
1360      enumerable: true,
1361      get: function get() {
1362        return module.l;
1363      }
1364    });
1365    Object.defineProperty(module, "id", {
1366      enumerable: true,
1367      get: function get() {
1368        return module.i;
1369      }
1370    });
1371    module.webpackPolyfill = 1;
1372  }
1373
1374  return module;
1375};
1376
1377/***/ }),
1378/* 5 */
1379/***/ (function(module, exports, __w_pdfjs_require__) {
1380
1381"use strict";
1382
1383
1384Object.defineProperty(exports, "__esModule", {
1385  value: true
1386});
1387exports.arrayByteLength = arrayByteLength;
1388exports.arraysToBytes = arraysToBytes;
1389exports.assert = assert;
1390exports.bytesToString = bytesToString;
1391exports.createPromiseCapability = createPromiseCapability;
1392exports.getVerbosityLevel = getVerbosityLevel;
1393exports.info = info;
1394exports.isArrayBuffer = isArrayBuffer;
1395exports.isArrayEqual = isArrayEqual;
1396exports.isBool = isBool;
1397exports.isEmptyObj = isEmptyObj;
1398exports.isNum = isNum;
1399exports.isString = isString;
1400exports.isSpace = isSpace;
1401exports.isSameOrigin = isSameOrigin;
1402exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
1403exports.isLittleEndian = isLittleEndian;
1404exports.isEvalSupported = isEvalSupported;
1405exports.log2 = log2;
1406exports.readInt8 = readInt8;
1407exports.readUint16 = readUint16;
1408exports.readUint32 = readUint32;
1409exports.removeNullCharacters = removeNullCharacters;
1410exports.setVerbosityLevel = setVerbosityLevel;
1411exports.shadow = shadow;
1412exports.string32 = string32;
1413exports.stringToBytes = stringToBytes;
1414exports.stringToPDFString = stringToPDFString;
1415exports.stringToUTF8String = stringToUTF8String;
1416exports.utf8StringToString = utf8StringToString;
1417exports.warn = warn;
1418exports.unreachable = unreachable;
1419Object.defineProperty(exports, "ReadableStream", {
1420  enumerable: true,
1421  get: function get() {
1422    return _streams_polyfill.ReadableStream;
1423  }
1424});
1425Object.defineProperty(exports, "URL", {
1426  enumerable: true,
1427  get: function get() {
1428    return _url_polyfill.URL;
1429  }
1430});
1431exports.createObjectURL = exports.FormatError = exports.Util = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.TextRenderingMode = exports.StreamType = exports.PermissionFlag = exports.PasswordResponses = exports.PasswordException = exports.NativeImageDecoding = exports.MissingPDFException = exports.InvalidPDFException = exports.AbortException = exports.CMapCompressionType = exports.ImageKind = exp

1431orts.FontType = exports.AnnotationType = exports.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationBorderStyleType = exports.UNSUPPORTED_FEATURES = exports.VerbosityLevel = exports.OPS = exports.IDENTITY_MATRIX = exports.FONT_IDENTITY_MATRIX = void 0;
1432
1433__w_pdfjs_require__(6);
1434
1435var _streams_polyfill = __w_pdfjs_require__(147);
1436
1437var _url_polyfill = __w_pdfjs_require__(149);
1438
1439function _typeof(obj) { 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); }
1440
1441var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
1442exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
1443var FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
1444exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
1445var NativeImageDecoding = {
1446  NONE: 'none',
1447  DECODE: 'decode',
1448  DISPLAY: 'display'
1449};
1450exports.NativeImageDecoding = NativeImageDecoding;
1451var PermissionFlag = {
1452  PRINT: 0x04,
1453  MODIFY_CONTENTS: 0x08,
1454  COPY: 0x10,
1455  MODIFY_ANNOTATIONS: 0x20,
1456  FILL_INTERACTIVE_FORMS: 0x100,
1457  COPY_FOR_ACCESSIBILITY: 0x200,
1458  ASSEMBLE: 0x400,
1459  PRINT_HIGH_QUALITY: 0x800
1460};
1461exports.PermissionFlag = PermissionFlag;
1462var TextRenderingMode = {
1463  FILL: 0,
1464  STROKE: 1,
1465  FILL_STROKE: 2,
1466  INVISIBLE: 3,
1467  FILL_ADD_TO_PATH: 4,
1468  STROKE_ADD_TO_PATH: 5,
1469  FILL_STROKE_ADD_TO_PATH: 6,
1470  ADD_TO_PATH: 7,
1471  FILL_STROKE_MASK: 3,
1472  ADD_TO_PATH_FLAG: 4
1473};
1474exports.TextRenderingMode = TextRenderingMode;
1475var ImageKind = {
1476  GRAYSCALE_1BPP: 1,
1477  RGB_24BPP: 2,
1478  RGBA_32BPP: 3
1479};
1480exports.ImageKind = ImageKind;
1481var AnnotationType = {
1482  TEXT: 1,
1483  LINK: 2,
1484  FREETEXT: 3,
1485  LINE: 4,
1486  SQUARE: 5,
1487  CIRCLE: 6,
1488  POLYGON: 7,
1489  POLYLINE: 8,
1490  HIGHLIGHT: 9,
1491  UNDERLINE: 10,
1492  SQUIGGLY: 11,
1493  STRIKEOUT: 12,
1494  STAMP: 13,
1495  CARET: 14,
1496  INK: 15,
1497  POPUP: 16,
1498  FILEATTACHMENT: 17,
1499  SOUND: 18,
1500  MOVIE: 19,
1501  WIDGET: 20,
1502  SCREEN: 21,
1503  PRINTERMARK: 22,
1504  TRAPNET: 23,
1505  WATERMARK: 24,
1506  THREED: 25,
1507  REDACT: 26
1508};
1509exports.AnnotationType = AnnotationType;
1510var AnnotationFlag = {
1511  INVISIBLE: 0x01,
1512  HIDDEN: 0x02,
1513  PRINT: 0x04,
1514  NOZOOM: 0x08,
1515  NOROTATE: 0x10,
1516  NOVIEW: 0x20,
1517  READONLY: 0x40,
1518  LOCKED: 0x80,
1519  TOGGLENOVIEW: 0x100,
1520  LOCKEDCONTENTS: 0x200
1521};
1522exports.AnnotationFlag = AnnotationFlag;
1523var AnnotationFieldFlag = {
1524  READONLY: 0x0000001,
1525  REQUIRED: 0x0000002,
1526  NOEXPORT: 0x0000004,
1527  MULTILINE: 0x0001000,
1528  PASSWORD: 0x0002000,
1529  NOTOGGLETOOFF: 0x0004000,
1530  RADIO: 0x0008000,
1531  PUSHBUTTON: 0x0010000,
1532  COMBO: 0x0020000,
1533  EDIT: 0x0040000,
1534  SORT: 0x0080000,
1535  FILESELECT: 0x0100000,
1536  MULTISELECT: 0x0200000,
1537  DONOTSPELLCHECK: 0x0400000,
1538  DONOTSCROLL: 0x0800000,
1539  COMB: 0x1000000,
1540  RICHTEXT: 0x2000000,
1541  RADIOSINUNISON: 0x2000000,
1542  COMMITONSELCHANGE: 0x4000000
1543};
1544exports.AnnotationFieldFlag = AnnotationFieldFlag;
1545var AnnotationBorderStyleType = {
1546  SOLID: 1,
1547  DASHED: 2,
1548  BEVELED: 3,
1549  INSET: 4,
1550  UNDERLINE: 5
1551};
1552exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
1553var StreamType = {
1554  UNKNOWN: 0,
1555  FLATE: 1,
1556  LZW: 2,
1557  DCT: 3,
1558  JPX: 4,
1559  JBIG: 5,
1560  A85: 6,
1561  AHX: 7,
1562  CCF: 8,
1563  RL: 9
1564};
1565exports.StreamType = StreamType;
1566var FontType = {
1567  UNKNOWN: 0,
1568  TYPE1: 1,
1569  TYPE1C: 2,
1570  CIDFONTTYPE0: 3,
1571  CIDFONTTYPE0C: 4,
1572  TRUETYPE: 5,
1573  CIDFONTTYPE2: 6,
1574  TYPE3: 7,
1575  OPENTYPE: 8,
1576  TYPE0: 9,
1577  MMTYPE1: 10
1578};
1579exports.FontType = FontType;
1580var VerbosityLevel = {
1581  ERRORS: 0,
1582  WARNINGS: 1,
1583  INFOS: 5
1584};
1585exports.VerbosityLevel = VerbosityLevel;
1586var CMapCompressionType = {
1587  NONE: 0,
1588  BINARY: 1,
1589  STREAM: 2
1590};
1591exports.CMapCompressionType = CMapCompressionType;
1592var OPS = {
1593  dependency: 1,
1594  setLineWidth: 2,
1595  setLineCap: 3,
1596  setLineJoin: 4,
1597  setMiterLimit: 5,
1598  setDash: 6,
1599  setRenderingIntent: 7,
1600  setFlatness: 8,
1601  setGState: 9,
1602  save: 10,
1603  restore: 11,
1604  transform: 12,
1605  moveTo: 13,
1606  lineTo: 14,
1607  curveTo: 15,
1608  curveTo2: 16,

1609  curveTo3: 17,
1610  closePath: 18,
1611  rectangle: 19,
1612  stroke: 20,
1613  closeStroke: 21,
1614  fill: 22,
1615  eoFill: 23,
1616  fillStroke: 24,
1617  eoFillStroke: 25,
1618  closeFillStroke: 26,
1619  closeEOFillStroke: 27,
1620  endPath: 28,
1621  clip: 29,
1622  eoClip: 30,
1623  beginText: 31,
1624  endText: 32,
1625  setCharSpacing: 33,
1626  setWordSpacing: 34,
1627  setHScale: 35,
1628  setLeading: 36,
1629  setFont: 37,
1630  setTextRenderingMode: 38,
1631  setTextRise: 39,
1632  moveText: 40,
1633  setLeadingMoveText: 41,
1634  setTextMatrix: 42,
1635  nextLine: 43,
1636  showText: 44,
1637  showSpacedText: 45,
1638  nextLineShowText: 46,
1639  nextLineSetSpacingShowText: 47,
1640  setCharWidth: 48,
1641  setCharWidthAndBounds: 49,
1642  setStrokeColorSpace: 50,
1643  setFillColorSpace: 51,
1644  setStrokeColor: 52,
1645  setStrokeColorN: 53,
1646  setFillColor: 54,
1647  setFillColorN: 55,
1648  setStrokeGray: 56,
1649  setFillGray: 57,
1650  setStrokeRGBColor: 58,
1651  setFillRGBColor: 59,
1652  setStrokeCMYKColor: 60,
1653  setFillCMYKColor: 61,
1654  shadingFill: 62,
1655  beginInlineImage: 63,
1656  beginImageData: 64,
1657  endInlineImage: 65,
1658  paintXObject: 66,
1659  markPoint: 67,
1660  markPointProps: 68,
1661  beginMarkedContent: 69,
1662  beginMarkedContentProps: 70,
1663  endMarkedContent: 71,
1664  beginCompat: 72,
1665  endCompat: 73,
1666  paintFormXObjectBegin: 74,
1667  paintFormXObjectEnd: 75,
1668  beginGroup: 76,
1669  endGroup: 77,
1670  beginAnnotations: 78,
1671  endAnnotations: 79,
1672  beginAnnotation: 80,
1673  endAnnotation: 81,
1674  paintJpegXObject: 82,
1675  paintImageMaskXObject: 83,
1676  paintImageMaskXObjectGroup: 84,
1677  paintImageXObject: 85,
1678  paintInlineImageXObject: 86,
1679  paintInlineImageXObjectGroup: 87,
1680  paintImageXObjectRepeat: 88,
1681  paintImageMaskXObjectRepeat: 89,
1682  paintSolidColorImageMask: 90,
1683  constructPath: 91
1684};
1685exports.OPS = OPS;
1686var UNSUPPORTED_FEATURES = {
1687  unknown: 'unknown',
1688  forms: 'forms',
1689  javaScript: 'javaScript',
1690  smask: 'smask',
1691  shadingPattern: 'shadingPattern',
1692  font: 'font'
1693};
1694exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
1695var PasswordResponses = {
1696  NEED_PASSWORD: 1,
1697  INCORRECT_PASSWORD: 2
1698};
1699exports.PasswordResponses = PasswordResponses;
1700var verbosity = VerbosityLevel.WARNINGS;
1701
1702function setVerbosityLevel(level) {
1703  if (Number.isInteger(level)) {
1704    verbosity = level;
1705  }
1706}
1707
1708function getVerbosityLevel() {
1709  return verbosity;
1710}
1711
1712function info(msg) {
1713  if (verbosity >= VerbosityLevel.INFOS) {
1714    console.log('Info: ' + msg);
1715  }
1716}
1717
1718function warn(msg) {
1719  if (verbosity >= VerbosityLevel.WARNINGS) {
1720    console.log('Warning: ' + msg);
1721  }
1722}
1723
1724function unreachable(msg) {
1725  throw new Error(msg);
1726}
1727
1728function assert(cond, msg) {
1729  if (!cond) {
1730    unreachable(msg);
1731  }
1732}
1733
1734function isSameOrigin(baseUrl, otherUrl) {
1735  try {
1736    var base = new _url_polyfill.URL(baseUrl);
1737
1738    if (!base.origin || base.origin === 'null') {
1739      return false;
1740    }
1741  } catch (e) {
1742    return false;
1743  }
1744
1745  var other = new _url_polyfill.URL(otherUrl, base);
1746  return base.origin === other.origin;
1747}
1748
1749function _isValidProtocol(url) {
1750  if (!url) {
1751    return false;
1752  }
1753
1754  switch (url.protocol) {
1755    case 'http:':
1756    case 'https:':
1757    case 'ftp:':
1758    case 'mailto:':
1759    case 'tel:':
1760      return true;
1761
1762    default:
1763      return false;
1764  }
1765}
1766
1767function createValidAbsoluteUrl(url, baseUrl) {
1768  if (!url) {
1769    return null;
1770  }
1771
1772  try {
1773    var absoluteUrl = baseUrl ? new _url_polyfill.URL(url, baseUrl) : new _url_polyfill.URL(url);
1774
1775    if (_isValidProtocol(absoluteUrl)) {
1776      return absoluteUrl;
1777    }
1778  } catch (ex) {}
1779
1780  return null;
1781}
1782
1783function shadow(obj, prop, value) {
1784  Object.defineProperty(obj, prop, {
1785    value: value,
1786    enumerable: true,
1787    configurable: true,
1788    writable: false
1789  });
1790  return value;
1791}
1792
1793var PasswordException = function PasswordExceptionClosure() {
1794  function PasswordException(msg, code) {
1795    this.name = 'PasswordException';
1796    this.message = msg;
1797    this.code = code;
1798  }
1799
1800  PasswordException.prototype = new Error();
1801  PasswordException.constructor = PasswordException;
1802  return PasswordException;
1803}();
1804
1805exports.PasswordException = PasswordException;
1806
1807var UnknownErrorException = function UnknownErrorExceptionClosure() {
1808  function UnknownErrorException(msg, details) {
1809    this.name = 'UnknownErrorException';
1810    this.message = msg;
1811    this.details = details;
1812  }
1813
1814  UnknownErrorException.prototype = new Error();
1815  UnknownErrorException.constructor = UnknownErrorException;
1816  return UnknownErrorException;
1817}();
1818
1819exports.UnknownErrorException = UnknownErrorException;
1820
1821var InvalidPDFException = function InvalidPDFExceptionClosure() {
1822  function InvalidPDFException(msg) {
1823    this.name = 'InvalidPDFException';
1824    this.message = msg;
1825  }
1826
1827  InvalidPDFException.prototype = new Error();
1828  InvalidPDFException.constructor = InvalidPDFException;
1829  return InvalidPDFException;
1830}();
1831
1832exports.InvalidPDFException = InvalidPDFException;
1833
1834var MissingPDFException = function MissingPDFExceptionClosure() {
1835  function MissingPDFException(msg) {
1836    this.name = 'MissingPDFException';
1837    this.message = msg;
1838  }
1839
1840  MissingPDFException.prototype = new Error();
1841  MissingPDFException.constructor = MissingPDFException;
1842  return MissingPDFException;
1843}();
1844
1845exports.MissingPDFException = MissingPDFException;
1846
1847var UnexpectedResponseException = function UnexpectedResponseExceptionClosure() {
1848  function UnexpectedResponseException(msg, status) {
1849    this.name = 'UnexpectedResponseException';
1850    this.message = msg;
1851    this.status = status;
1852  }
1853
1854  UnexpectedResponseException.prototype = new Error();
1855  UnexpectedResponseException.constructor = UnexpectedResponseException;
1856  return UnexpectedResponseException;
1857}();
1858
1859exports.UnexpectedResponseException = UnexpectedResponseException;
1860
1861var FormatError = function FormatErrorClosure() {
1862  function FormatError(msg) {
1863    this.message = msg;
1864  }
1865
1866  FormatError.prototype = new Error();
1867  FormatError.prototype.name = 'FormatError';
1868  FormatError.constructor = FormatError;
1869  return FormatError;
1870}();
1871
1872exports.FormatError = FormatError;
1873
1874var AbortException = function AbortExceptionClosure() {
1875  function AbortException(msg) {
1876    this.name = 'AbortException';
1877    this.message = msg;
1878  }
1879
1880  AbortException.prototype = new Error();
1881  AbortException.constructor = AbortException;
1882  return AbortException;
1883}();
1884
1885exports.AbortException = AbortException;
1886var NullCharactersRegExp = /\x00/g;
1887
1888function removeNullCharacters(str) {
1889  if (typeof str !== 'string') {
1890    warn('The argument for removeNullCharacters must be a string.');
1891    return str;
1892  }
1893
1894  return str.replace(NullCharactersRegExp, '');
1895}
1896
1897function bytesToString(bytes) {
1898  assert(bytes !== null && _typeof(bytes) === 'object' && bytes.length !== undefined, 'Invalid argument for bytesToString');
1899  var length = bytes.length;
1900  var MAX_ARGUMENT_COUNT = 8192;
1901
1902  if (length < MAX_ARGUMENT_COUNT) {
1903    return String.fromCharCode.apply(null, bytes);
1904  }
1905
1906  var strBuf = [];
1907
1908  for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
1909    var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
1910    var chunk = bytes.subarray(i, chunkEnd);
1911    strBuf.push(String.fromCharCode.apply(null, chunk));
1912  }
1913
1914  return strBuf.join('');
1915}
1916
1917function stringToBytes(str) {
1918  assert(typeof str === 'string', 'Invalid argument for stringToBytes');
1919  var length = str.length;
1920  var bytes = new Uint8Array(length);
1921
1922  for (var i = 0; i < length; ++i) {
1923    bytes[i] = str.charCodeAt(i) & 0xFF;
1924  }
1925
1926  return bytes;
1927}
1928
1929function arrayByteLength(arr) {
1930  if (arr.length !== undefined) {
1931    return arr.length;
1932  }
1933
1934  assert(arr.byteLength !== undefined);
1935  return arr.byteLength;
1936}
1937
1938function arraysToBytes(arr) {
1939  if (arr.length === 1 && arr[0] instanceof Uint8Array) {
1940    return arr[0];
1941  }
1942
1943  var resultLength = 0;
1944  var i,
1945      ii = arr.length;
1946  var item, itemLength;
1947
1948  for (i = 0; i < ii; i++) {
1949    item = arr[i];
1950    itemLength = arrayByteLength(item);
1951    resultLength += itemLength;
1952  }
1953
1954  var pos = 0;
1955  var data = new Uint8Array(resultLength);
1956
1957  for (i = 0; i < ii; i++) {
1958    item = arr[i];
1959
1960    if (!(item instanceof Uint8Array)) {
1961      if (typeof item === 'string') {
1962        item = stringToBytes(item);
1963      } else {
1964        item = new Uint8Array(item);
1965      }
1966    }
1967
1968    itemLength = item.byteLength;
1969    data.set(item, pos);
1970    pos += itemLength;
1971  }
1972
1973  return data;
1974}
1975
1976function string32(value) {
1977  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
1978}
1979
1980function log2(x) {
1981  if (x <= 0) {
1982    return 0;
1983  }
1984
1985  return Math.ceil(Math.log2(x));
1986}
1987
1988function readInt8(data, start) {
1989  return data[start] << 24 >> 24;
1990}
1991
1992function readUint16(data, offset) {
1993  return data[offset] << 8 | data[offset + 1];
1994}
1995
1996function readUint32(data, offset) {
1997  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
1998}
1999
2000function isLittleEndian() {
2001  var buffer8 = new Uint8Array(4);
2002  buffer8[0] = 1;
2003  var view32 = new Uint32Array(buffer8.buffer, 0, 1);
2004  return view32[0] === 1;
2005}
2006
2007function isEvalSupported() {
2008  try {
2009    new Function('');
2010    return true;
2011  } catch (e) {
2012    return false;

2013  }
2014}
2015
2016var Util = function UtilClosure() {
2017  function Util() {}
2018
2019  var rgbBuf = ['rgb(', 0, ',', 0, ',', 0, ')'];
2020
2021  Util.makeCssRgb = function Util_makeCssRgb(r, g, b) {
2022    rgbBuf[1] = r;
2023    rgbBuf[3] = g;
2024    rgbBuf[5] = b;
2025    return rgbBuf.join('');
2026  };
2027
2028  Util.transform = function Util_transform(m1, m2) {
2029    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]];
2030  };
2031
2032  Util.applyTransform = function Util_applyTransform(p, m) {
2033    var xt = p[0] * m[0] + p[1] * m[2] + m[4];
2034    var yt = p[0] * m[1] + p[1] * m[3] + m[5];
2035    return [xt, yt];
2036  };
2037
2038  Util.applyInverseTransform = function Util_applyInverseTransform(p, m) {
2039    var d = m[0] * m[3] - m[1] * m[2];
2040    var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
2041    var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
2042    return [xt, yt];
2043  };
2044
2045  Util.getAxialAlignedBoundingBox = function Util_getAxialAlignedBoundingBox(r, m) {
2046    var p1 = Util.applyTransform(r, m);
2047    var p2 = Util.applyTransform(r.slice(2, 4), m);
2048    var p3 = Util.applyTransform([r[0], r[3]], m);
2049    var p4 = Util.applyTransform([r[2], r[1]], m);
2050    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])];
2051  };
2052
2053  Util.inverseTransform = function Util_inverseTransform(m) {
2054    var d = m[0] * m[3] - m[1] * m[2];
2055    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];
2056  };
2057
2058  Util.apply3dTransform = function Util_apply3dTransform(m, v) {
2059    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]];
2060  };
2061
2062  Util.singularValueDecompose2dScale = function Util_singularValueDecompose2dScale(m) {
2063    var transpose = [m[0], m[2], m[1], m[3]];
2064    var a = m[0] * transpose[0] + m[1] * transpose[2];
2065    var b = m[0] * transpose[1] + m[1] * transpose[3];
2066    var c = m[2] * transpose[0] + m[3] * transpose[2];
2067    var d = m[2] * transpose[1] + m[3] * transpose[3];
2068    var first = (a + d) / 2;
2069    var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;
2070    var sx = first + second || 1;
2071    var sy = first - second || 1;
2072    return [Math.sqrt(sx), Math.sqrt(sy)];
2073  };
2074
2075  Util.normalizeRect = function Util_normalizeRect(rect) {
2076    var r = rect.slice(0);
2077
2078    if (rect[0] > rect[2]) {
2079      r[0] = rect[2];
2080      r[2] = rect[0];
2081    }
2082
2083    if (rect[1] > rect[3]) {
2084      r[1] = rect[3];
2085      r[3] = rect[1];
2086    }
2087
2088    return r;
2089  };
2090
2091  Util.intersect = function Util_intersect(rect1, rect2) {
2092    function compare(a, b) {
2093      return a - b;
2094    }
2095
2096    var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare),

2097        orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare),
2098        result = [];
2099    rect1 = Util.normalizeRect(rect1);
2100    rect2 = Util.normalizeRect(rect2);
2101
2102    if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
2103      result[0] = orderedX[1];
2104      result[2] = orderedX[2];
2105    } else {
2106      return false;
2107    }
2108
2109    if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
2110      result[1] = orderedY[1];
2111      result[3] = orderedY[2];
2112    } else {
2113      return false;
2114    }
2115
2116    return result;
2117  };
2118
2119  return Util;
2120}();
2121
2122exports.Util = Util;
2123var 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];
2124
2125function stringToPDFString(str) {
2126  var i,
2127      n = str.length,
2128      strBuf = [];
2129
2130  if (str[0] === '\xFE' && str[1] === '\xFF') {
2131    for (i = 2; i < n; i += 2) {
2132      strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
2133    }
2134  } else {
2135    for (i = 0; i < n; ++i) {
2136      var code = PDFStringTranslateTable[str.charCodeAt(i)];
2137      strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
2138    }
2139  }
2140
2141  return strBuf.join('');
2142}
2143
2144function stringToUTF8String(str) {
2145  return decodeURIComponent(escape(str));
2146}
2147
2148function utf8StringToString(str) {
2149  return unescape(encodeURIComponent(str));
2150}
2151
2152function isEmptyObj(obj) {
2153  for (var key in obj) {
2154    return false;
2155  }
2156
2157  return true;
2158}
2159
2160function isBool(v) {
2161  return typeof v === 'boolean';
2162}
2163
2164function isNum(v) {
2165  return typeof v === 'number';
2166}
2167
2168function isString(v) {
2169  return typeof v === 'string';
2170}
2171
2172function isArrayBuffer(v) {
2173  return _typeof(v) === 'object' && v !== null && v.byteLength !== undefined;
2174}
2175
2176function isArrayEqual(arr1, arr2) {
2177  if (arr1.length !== arr2.length) {
2178    return false;
2179  }
2180
2181  return arr1.every(function (element, index) {
2182    return element === arr2[index];
2183  });
2184}
2185
2186function isSpace(ch) {
2187  return ch === 0x20 || ch === 0x09 || ch === 0x0D || ch === 0x0A;
2188}
2189
2190function createPromiseCapability() {
2191  var capability = Object.create(null);
2192  var isSettled = false;
2193  Object.defineProperty(capability, 'settled', {
2194    get: function get() {
2195      return isSettled;
2196    }
2197  });
2198  capability.promise = new Promise(function (resolve, reject) {
2199    capability.resolve = function (data) {
2200      isSettled = true;
2201      resolve(data);
2202    };
2203
2204    capability.reject = function (reason) {
2205      isSettled = true;
2206      reject(reason);
2207    };
2208  });
2209  return capability;
2210}
2211
2212var createObjectURL = function createObjectURLClosure() {
2213  var digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
2214  return function createObjectURL(data, contentType) {
2215    var forceDataSchema = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
2216
2217    if (!forceDataSchema && _url_polyfill.URL.createObjectURL) {
2218      var blob = new Blob([data], {
2219        type: contentType
2220      });
2221      return _url_polyfill.URL.createObjectURL(blob);
2222    }
2223
2224    var buffer = 'data:' + contentType + ';base64,';
2225
2226    for (var i = 0, ii = data.length; i < ii; i += 3) {
2227      var b1 = data[i] & 0xFF;
2228      var b2 = data[i + 1] & 0xFF;
2229      var b3 = data[i + 2] & 0xFF;
2230      var d1 = b1 >> 2,
2231          d2 = (b1 & 3) << 4 | b2 >> 4;
2232      var d3 = i + 1 < ii ? (b2 & 0xF) << 2 | b3 >> 6 : 64;
2233      var d4 = i + 2 < ii ? b3 & 0x3F : 64;
2234      buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];
2235    }
2236
2237    return buffer;
2238  };
2239}();
2240
2241exports.createObjectURL = createObjectURL;
2242
2243/***/ }),
2244/* 6 */
2245/***/ (function(module, exports, __w_pdfjs_require__) {
2246
2247"use strict";
2248
2249
2250function _typeof(obj) { 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); }
2251
2252var globalScope = __w_pdfjs_require__(7);
2253
2254if (!globalScope._pdfjsCompatibilityChecked) {
2255  globalScope._pdfjsCompatibilityChecked = true;
2256
2257  var isNodeJS = __w_pdfjs_require__(8);
2258
2259  var hasDOM = (typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object' && (typeof document === "undefined" ? "undefined" : _typeof(document)) === 'object';
2260
2261  (function checkNodeBtoa() {
2262    if (globalScope.btoa || !isNodeJS()) {
2263      return;
2264    }
2265
2266    globalScope.btoa = function (chars) {
2267      return Buffer.from(chars, 'binary').toString('base64');
2268    };
2269  })();
2270
2271  (function checkNodeAtob() {
2272    if (globalScope.atob || !isNodeJS()) {
2273      return;
2274    }
2275
2276    globalScope.atob = function (input) {
2277      return Buffer.from(input, 'base64').toString('binary');
2278    };
2279  })();
2280
2281  (function checkChildNodeRemove() {
2282    if (!hasDOM) {
2283      return;
2284    }
2285
2286    if (typeof Element.prototype.remove !== 'undefined') {
2287      return;
2288    }
2289
2290    Element.prototype.remove = function () {
2291      if (this.parentNode) {
2292        this.parentNode.removeChild(this);
2293      }
2294    };
2295  })();
2296
2297  (function checkDOMTokenListAddRemove() {
2298    if (!hasDOM || isNodeJS()) {
2299      return;
2300    }
2301
2302    var div = document.createElement('div');
2303    div.classList.add('testOne', 'testTwo');
2304
2305    if (div.classList.contains('testOne') === true && div.classList.contains('testTwo') === true) {
2306      return;
2307    }
2308
2309    var OriginalDOMTokenListAdd = DOMTokenList.prototype.add;
2310    var OriginalDOMTokenListRemove = DOMTokenList.prototype.remove;
2311
2312    DOMTokenList.prototype.add = function () {
2313      for (var _len = arguments.length, tokens = new Array(_len), _key = 0; _key < _len; _key++) {
2314        tokens[_key] = arguments[_key];
2315      }
2316
2317      for (var _i = 0, _tokens = tokens; _i < _tokens.length; _i++) {
2318        var token = _tokens[_i];
2319        OriginalDOMTokenListAdd.call(this, token);
2320      }
2321    };
2322
2323    DOMTokenList.prototype.remove = function () {
2324      for (var _len2 = arguments.length, tokens = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
2325        tokens[_key2] = arguments[_key2];
2326      }
2327
2328      for (var _i2 = 0, _tokens2 = tokens; _i2 < _tokens2.length; _i2++) {
2329        var token = _tokens2[_i2];
2330        OriginalDOMTokenListRemove.call(this, token);
2331      }
2332    };
2333  })();
2334
2335  (function checkDOMTokenListToggle() {
2336    if (!hasDOM || isNodeJS()) {
2337      return;
2338    }
2339
2340    var div = document.createElement('div');
2341
2342    if (div.classList.toggle('test', 0) === false) {
2343      return;
2344    }
2345
2346    DOMTokenList.prototype.toggle = function (token) {
2347      var force = arguments.length > 1 ? !!arguments[1] : !this.contains(token);
2348      return this[force ? 'add' : 'remove'](token), force;
2349    };
2350  })();
2351
2352  (function checkStringStartsWith() {
2353    if (String.prototype.startsWith) {
2354      return;
2355    }
2356
2357    __w_pdfjs_require__(9);
2358  })();
2359
2360  (function checkStringEndsWith() {
2361    if (String.prototype.endsWith) {
2362      return;
2363    }
2364
2365    __w_pdfjs_require__(40);
2366  })();
2367
2368  (function checkStringIncludes() {
2369    if (String.prototype.includes) {
2370      return;
2371    }
2372
2373    __w_pdfjs_require__(42);
2374  })();
2375
2376  (function checkArrayIncludes() {
2377    if (Array.prototype.includes) {
2378      return;
2379    }
2380
2381    __w_pdfjs_require__(44);
2382  })();
2383
2384  (function checkArrayFrom() {
2385    if (Array.from) {
2386      return;
2387    }
2388
2389    __w_pdfjs_require__(51);
2390  })();
2391
2392  (function checkObjectAssign() {
2393    if (Object.assign) {
2394      return;
2395    }
2396
2397    __w_pdfjs_require__(74);
2398  })();
2399
2400  (function checkMathLog2() {
2401    if (Math.log2) {
2402      return;
2403    }
2404
2405    Math.log2 = __w_pdfjs_require__(79);
2406  })();
2407
2408  (function checkNumberIsNaN() {
2409    if (Number.isNaN) {
2410      return;
2411    }
2412
2413    Number.isNaN = __w_pdfjs_require__(81);
2414  })();
2415
2416  (function checkNumberIsInteger() {
2417    if (Number.isInteger) {
2418      return;
2419    }
2420
2421    Number.isInteger = __w_pdfjs_require__(83);
2422  })();
2423
2424  (function checkPromise() {
2425    if (globalScope.Promise && globalScope.Promise.prototype && globalScope.Promise.prototype["finally"]) {
2426      return;
2427    }
2428
2429    globalScope.Promise = __w_pdfjs_require__(86);
2430  })();
2431
2432  (function checkWeakMap() {
2433    if (globalScope.WeakMap) {
2434      return;
2435    }
2436
2437    globalScope.WeakMap = __w_pdfjs_require__(106);
2438  })();
2439
2440  (function checkWeakSet() {
2441    if (globalScope.WeakSet) {
2442      return;
2443    }
2444
2445    globalScope.WeakSet = __w_pdfjs_require__(123);
2446  })();
2447
2448  (function checkStringCodePointAt() {
2449    if (String.codePointAt) {
2450      return;
2451    }
2452
2453    String.codePointAt = __w_pdfjs_require__(127);
2454  })();
2455
2456  (function checkStringFromCodePoint() {
2457    if (String.fromCodePoint) {
2458      return;
2459    }
2460
2461    String.fromCodePoint = __w_pdfjs_require__(129);
2462  })();
2463
2464  (function checkSymbol() {
2465    if (globalScope.Symbol) {
2466      return;
2467    }
2468
2469    __w_pdfjs_require__(131);
2470  })();
2471
2472  (function checkStringPadStart() {
2473    if (String.prototype.padStart) {
2474      return;
2475    }
2476
2477    __w_pdfjs_require__(138);
2478  })();
2479
2480  (function checkStringPadEnd() {
2481    if (String.prototype.padEnd) {
2482      return;
2483    }
2484
2485    __w_pdfjs_require__(142);
2486  })();
2487
2488  (function checkObjectValues() {
2489    if (Object.values) {
2490      return;
2491    }
2492
2493    Object.values = __w_pdfjs_require__(144);
2494  })();
2495}
2496
2497/***/ }),
2498/* 7 */
2499/***/ (function(module, exports, __w_pdfjs_require__) {
2500
2501"use strict";
2502
2503
2504module.exports = typeof window !== 'undefined' && window.Math === Math ? window : typeof global !== 'undefined' && global.Math === Math ? global : typeof self !== 'undefined' && self.Math === Math ? self : {};
2505
2506/***/ }),
2507/* 8 */
2508/***/ (function(module, exports, __w_pdfjs_require__) {
2509
2510"use strict";
2511
2512
2513function _typeof(obj) { 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); }
2514
2515module.exports = function isNodeJS() {
2516  return (typeof process === "undefined" ? "undefined" : _typeof(process)) === 'object' && process + '' === '[object process]' && !process.versions['nw'] && !process.versions['electron'];
2517};
2518
2519/***/ }),
2520/* 9 */
2521/***/ (function(module, exports, __w_pdfjs_require__) {
2522
2523"use strict";
2524
2525
2526__w_pdfjs_require__(10);
2527

2528module.exports = __w_pdfjs_require__(13).String.startsWith;
2529
2530/***/ }),
2531/* 10 */
2532/***/ (function(module, exports, __w_pdfjs_require__) {
2533
2534"use strict";
2535
2536
2537var $export = __w_pdfjs_require__(11);
2538
2539var toLength = __w_pdfjs_require__(32);
2540
2541var context = __w_pdfjs_require__(34);
2542
2543var STARTS_WITH = 'startsWith';
2544var $startsWith = ''[STARTS_WITH];
2545$export($export.P + $export.F * __w_pdfjs_require__(39)(STARTS_WITH), 'String', {
2546  startsWith: function startsWith(searchString) {
2547    var that = context(this, searchString, STARTS_WITH);
2548    var index = toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length));
2549    var search = String(searchString);
2550    return $startsWith ? $startsWith.call(that, search, index) : that.slice(index, index + search.length) === search;
2551  }
2552});
2553
2554/***/ }),
2555/* 11 */
2556/***/ (function(module, exports, __w_pdfjs_require__) {
2557
2558"use strict";
2559
2560
2561var global = __w_pdfjs_require__(12);
2562
2563var core = __w_pdfjs_require__(13);
2564
2565var hide = __w_pdfjs_require__(14);
2566
2567var redefine = __w_pdfjs_require__(24);
2568
2569var ctx = __w_pdfjs_require__(30);
2570
2571var PROTOTYPE = 'prototype';
2572
2573var $export = function $export(type, name, source) {
2574  var IS_FORCED = type & $export.F;
2575  var IS_GLOBAL = type & $export.G;
2576  var IS_STATIC = type & $export.S;
2577  var IS_PROTO = type & $export.P;
2578  var IS_BIND = type & $export.B;
2579  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE];
2580  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
2581  var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
2582  var key, own, out, exp;
2583  if (IS_GLOBAL) source = name;
2584
2585  for (key in source) {
2586    own = !IS_FORCED && target && target[key] !== undefined;
2587    out = (own ? target : source)[key];
2588    exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
2589    if (target) redefine(target, key, out, type & $export.U);
2590    if (exports[key] != out) hide(exports, key, exp);
2591    if (IS_PROTO && expProto[key] != out) expProto[key] = out;
2592  }
2593};
2594
2595global.core = core;
2596$export.F = 1;
2597$export.G = 2;
2598$export.S = 4;
2599$export.P = 8;
2600$export.B = 16;
2601$export.W = 32;
2602$export.U = 64;
2603$export.R = 128;
2604module.exports = $export;
2605
2606/***/ }),
2607/* 12 */
2608/***/ (function(module, exports, __w_pdfjs_require__) {
2609
2610"use strict";
2611
2612
2613var global = module.exports = typeof window != 'undefined' && window.Math == Math ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
2614if (typeof __g == 'number') __g = global;
2615
2616/***/ }),
2617/* 13 */
2618/***/ (function(module, exports, __w_pdfjs_require__) {
2619
2620"use strict";
2621
2622
2623var core = module.exports = {
2624  version: '2.6.9'
2625};
2626if (typeof __e == 'number') __e = core;
2627
2628/***/ }),
2629/* 14 */
2630/***/ (function(module, exports, __w_pdfjs_require__) {
2631
2632"use strict";
2633
2634
2635var dP = __w_pdfjs_require__(15);
2636
2637var createDesc = __w_pdfjs_require__(23);
2638
2639module.exports = __w_pdfjs_require__(19) ? function (object, key, value) {
2640  return dP.f(object, key, createDesc(1, value));
2641} : function (object, key, value) {
2642  object[key] = value;
2643  return object;
2644};
2645
2646/***/ }),
2647/* 15 */
2648/***/ (function(module, exports, __w_pdfjs_require__) {
2649
2650"use strict";
2651
2652
2653var anObject = __w_pdfjs_require__(16);
2654
2655var IE8_DOM_DEFINE = __w_pdfjs_require__(18);
2656
2657var toPrimitive = __w_pdfjs_require__(22);
2658
2659var dP = Object.defineProperty;
2660exports.f = __w_pdfjs_require__(19) ? Object.defineProperty : function defineProperty(O, P, Attributes) {
2661  anObject(O);
2662  P = toPrimitive(P, true);
2663  anObject(Attributes);
2664  if (IE8_DOM_DEFINE) try {
2665    return dP(O, P, Attributes);
2666  } catch (e) {}
2667  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
2668  if ('value' in Attributes) O[P] = Attributes.value;
2669  return O;
2670};
2671
2672/***/ }),
2673/* 16 */
2674/***/ (function(module, exports, __w_pdfjs_require__) {
2675
2676"use strict";
2677
2678
2679var isObject = __w_pdfjs_require__(17);
2680
2681module.exports = function (it) {
2682  if (!isObject(it)) throw TypeError(it + ' is not an object!');
2683  return it;
2684};
2685
2686/***/ }),
2687/* 17 */
2688/***/ (function(module, exports, __w_pdfjs_require__) {
2689
2690"use strict";
2691
2692
2693function _typeof(obj) { 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); }
2694
2695module.exports = function (it) {
2696  return _typeof(it) === 'object' ? it !== null : typeof it === 'function';
2697};
2698
2699/***/ }),
2700/* 18 */
2701/***/ (function(module, exports, __w_pdfjs_require__) {
2702
2703"use strict";
2704
2705
2706module.exports = !__w_pdfjs_require__(19) && !__w_pdfjs_require__(20)(function () {
2707  return Object.defineProperty(__w_pdfjs_require__(21)('div'), 'a', {
2708    get: function get() {
2709      return 7;
2710    }
2711  }).a != 7;
2712});
2713
2714/***/ }),
2715/* 19 */
2716/***/ (function(module, exports, __w_pdfjs_require__) {
2717
2718"use strict";
2719
2720
2721module.exports = !__w_pdfjs_require__(20)(function () {
2722  return Object.defineProperty({}, 'a', {
2723    get: function get() {
2724      return 7;
2725    }
2726  }).a != 7;
2727});
2728
2729/***/ }),
2730/* 20 */
2731/***/ (function(module, exports, __w_pdfjs_require__) {
2732
2733"use strict";
2734
2735
2736module.exports = function (exec) {
2737  try {
2738    return !!exec();
2739  } catch (e) {
2740    return true;
2741  }
2742};
2743
2744/***/ }),
2745/* 21 */
2746/***/ (function(module, exports, __w_pdfjs_require__) {
2747
2748"use strict";
2749
2750
2751var isObject = __w_pdfjs_require__(17);
2752
2753var document = __w_pdfjs_require__(12).document;
2754
2755var is = isObject(document) && isObject(document.createElement);
2756
2757module.exports = function (it) {
2758  return is ? document.createElement(it) : {};
2759};
2760
2761/***/ }),
2762/* 22 */
2763/***/ (function(module, exports, __w_pdfjs_require__) {
2764
2765"use strict";
2766
2767
2768var isObject = __w_pdfjs_require__(17);
2769
2770module.exports = function (it, S) {
2771  if (!isObject(it)) return it;
2772  var fn, val;
2773  if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
2774  if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
2775  if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
2776  throw TypeError("Can't convert object to primitive value");
2777};
2778
2779/***/ }),
2780/* 23 */
2781/***/ (function(module, exports, __w_pdfjs_require__) {
2782
2783"use strict";
2784
2785
2786module.exports = function (bitmap, value) {
2787  return {
2788    enumerable: !(bitmap & 1),
2789    configurable: !(bitmap & 2),
2790    writable: !(bitmap & 4),
2791    value: value
2792  };
2793};
2794
2795/***/ }),
2796/* 24 */
2797/***/ (function(module, exports, __w_pdfjs_require__) {
2798
2799"use strict";
2800
2801
2802var global = __w_pdfjs_require__(12);
2803
2804var hide = __w_pdfjs_require__(14);
2805
2806var has = __w_pdfjs_require__(25);
2807
2808var SRC = __w_pdfjs_require__(26)('src');
2809
2810var $toString = __w_pdfjs_require__(27);
2811
2812var TO_STRING = 'toString';
2813var TPL = ('' + $toString).split(TO_STRING);
2814
2815__w_pdfjs_require__(13).inspectSource = function (it) {
2816  return $toString.call(it);
2817};
2818
2819(module.exports = function (O, key, val, safe) {
2820  var isFunction = typeof val == 'function';
2821  if (isFunction) has(val, 'name') || hide(val, 'name', key);
2822  if (O[key] === val) return;
2823  if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
2824
2825  if (O === global) {
2826    O[key] = val;
2827  } else if (!safe) {
2828    delete O[key];
2829    hide(O, key, val);
2830  } else if (O[key]) {
2831    O[key] = val;
2832  } else {
2833    hide(O, key, val);
2834  }
2835})(Function.prototype, TO_STRING, function toString() {
2836  return typeof this == 'function' && this[SRC] || $toString.call(this);
2837});
2838
2839/***/ }),
2840/* 25 */
2841/***/ (function(module, exports, __w_pdfjs_require__) {
2842
2843"use strict";
2844
2845
2846var hasOwnProperty = {}.hasOwnProperty;
2847
2848module.exports = function (it, key) {
2849  return hasOwnProperty.call(it, key);
2850};
2851
2852/***/ }),
2853/* 26 */
2854/***/ (function(module, exports, __w_pdfjs_require__) {
2855
2856"use strict";
2857
2858
2859var id = 0;
2860var px = Math.random();
2861
2862module.exports = function (key) {
2863  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
2864};
2865
2866/***/ }),
2867/* 27 */
2868/***/ (function(module, exports, __w_pdfjs_require__) {
2869
2870"use strict";
2871
2872
2873module.exports = __w_pdfjs_require__(28)('native-function-to-string', Function.toString);
2874
2875/***/ }),
2876/* 28 */
2877/***/ (function(module, exports, __w_pdfjs_require__) {
2878
2879"use strict";
2880
2881
2882var core = __w_pdfjs_require__(13);
2883
2884var global = __w_pdfjs_require__(12);
2885