app-api-merge/public/gzh/static/pdf/html/web/viewer.js

/**
 * @licstart The following is the entire license notice for the
 * Javascript code in this page
 *
 * Copyright 2022 Mozilla Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * @licend The above is the entire license notice for the
 * Javascript code in this page
 */

/******/
(() => { // webpackBootstrap
	/******/
	"use strict";
	/******/
	var __webpack_modules__ = ([
		/* 0 */
		,
		/* 1 */
		/***/
		((__unused_webpack_module, exports) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.compatibilityParams = exports.OptionKind = exports.AppOptions = void 0;

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

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var compatibilityParams = Object.create(null);
			exports.compatibilityParams = compatibilityParams; {
				var userAgent = navigator.userAgent || "";
				var platform = navigator.platform || "";
				var maxTouchPoints = navigator.maxTouchPoints || 1;
				var isAndroid = /Android/.test(userAgent);
				var isIOS = /\b(iPad|iPhone|iPod)(?=;)/.test(userAgent) || platform === "MacIntel" &&
					maxTouchPoints > 1;

				(function checkCanvasSizeLimitation() {
					if (isIOS || isAndroid) {
						compatibilityParams.maxCanvasPixels = 5242880;
					}
				})();
			}
			var OptionKind = {
				VIEWER: 0x02,
				API: 0x04,
				WORKER: 0x08,
				PREFERENCE: 0x80
			};
			exports.OptionKind = OptionKind;
			var defaultOptions = {
				annotationMode: {
					value: 2,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				cursorToolOnLoad: {
					value: 0,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				defaultUrl: {
					value: "compressed.tracemonkey-pldi-09.pdf",
					kind: OptionKind.VIEWER
				},
				defaultZoomValue: {
					value: "",
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				disableHistory: {
					value: false,
					kind: OptionKind.VIEWER
				},
				disablePageLabels: {
					value: false,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				enablePermissions: {
					value: false,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				enablePrintAutoRotate: {
					value: true,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				enableScripting: {
					value: true,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				externalLinkRel: {
					value: "noopener noreferrer nofollow",
					kind: OptionKind.VIEWER
				},
				externalLinkTarget: {
					value: 0,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				historyUpdateUrl: {
					value: false,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				ignoreDestinationZoom: {
					value: false,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				imageResourcesPath: {
					value: "./images/",
					kind: OptionKind.VIEWER
				},
				maxCanvasPixels: {
					value: 16777216,
					compatibility: compatibilityParams.maxCanvasPixels,
					kind: OptionKind.VIEWER
				},
				pdfBugEnabled: {
					value: false,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				printResolution: {
					value: 150,
					kind: OptionKind.VIEWER
				},
				renderer: {
					value: "canvas",
					kind: OptionKind.VIEWER
				},
				sidebarViewOnLoad: {
					value: -1,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				scrollModeOnLoad: {
					value: -1,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				spreadModeOnLoad: {
					value: -1,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				textLayerMode: {
					value: 1,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				useOnlyCssZoom: {
					value: false,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				viewerCssTheme: {
					value: 0,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				viewOnLoad: {
					value: 0,
					kind: OptionKind.VIEWER + OptionKind.PREFERENCE
				},
				cMapPacked: {
					value: true,
					kind: OptionKind.API
				},
				cMapUrl: {
					value: "../web/cmaps/",
					kind: OptionKind.API
				},
				disableAutoFetch: {
					value: false,
					kind: OptionKind.API + OptionKind.PREFERENCE
				},
				disableFontFace: {
					value: false,
					kind: OptionKind.API + OptionKind.PREFERENCE
				},
				disableRange: {
					value: false,
					kind: OptionKind.API + OptionKind.PREFERENCE
				},
				disableStream: {
					value: false,
					kind: OptionKind.API + OptionKind.PREFERENCE
				},
				docBaseUrl: {
					value: "",
					kind: OptionKind.API
				},
				enableXfa: {
					value: true,
					kind: OptionKind.API + OptionKind.PREFERENCE
				},
				fontExtraProperties: {
					value: false,
					kind: OptionKind.API
				},
				isEvalSupported: {
					value: true,
					kind: OptionKind.API
				},
				maxImageSize: {
					value: -1,
					kind: OptionKind.API
				},
				pdfBug: {
					value: false,
					kind: OptionKind.API
				},
				standardFontDataUrl: {
					value: "../web/standard_fonts/",
					kind: OptionKind.API
				},
				verbosity: {
					value: 1,
					kind: OptionKind.API
				},
				workerPort: {
					value: null,
					kind: OptionKind.WORKER
				},
				workerSrc: {
					value: "../build/pdf.worker.js",
					kind: OptionKind.WORKER
				}
			}; {
				defaultOptions.disablePreferences = {
					value: false,
					kind: OptionKind.VIEWER
				};
				defaultOptions.locale = {
					value: navigator.language || "en-US",
					kind: OptionKind.VIEWER
				};
				defaultOptions.sandboxBundleSrc = {
					value: "../build/pdf.sandbox.js",
					kind: OptionKind.VIEWER
				};
				defaultOptions.renderer.kind += OptionKind.PREFERENCE;
			}
			var userOptions = Object.create(null);

			var AppOptions = /*#__PURE__*/ function() {
				function AppOptions() {
					_classCallCheck(this, AppOptions);

					throw new Error("Cannot initialize AppOptions.");
				}

				_createClass(AppOptions, null, [{
					key: "get",
					value: function get(name) {
						var userOption = userOptions[name];

						if (userOption !== undefined) {
							return userOption;
						}

						var defaultOption = defaultOptions[name];

						if (defaultOption !== undefined) {
							var _defaultOption$compat;

							return (_defaultOption$compat = defaultOption
									.compatibility) !== null &&
								_defaultOption$compat !== void 0 ?
								_defaultOption$compat : defaultOption.value;
						}

						return undefined;
					}
				}, {
					key: "getAll",
					value: function getAll() {
						var kind = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : null;
						var options = Object.create(null);

						for (var name in defaultOptions) {
							var _defaultOption$compat2;

							var defaultOption = defaultOptions[name];

							if (kind) {
								if ((kind & defaultOption.kind) === 0) {
									continue;
								}

								if (kind === OptionKind.PREFERENCE) {
									var value = defaultOption.value,
										valueType = _typeof(value);

									if (valueType === "boolean" || valueType ===
										"string" || valueType === "number" && Number
										.isInteger(value)) {
										options[name] = value;
										continue;
									}

									throw new Error("Invalid type for preference: "
										.concat(name));
								}
							}

							var userOption = userOptions[name];
							options[name] = userOption !== undefined ? userOption :
								(_defaultOption$compat2 = defaultOption
									.compatibility) !== null &&
								_defaultOption$compat2 !== void 0 ?
								_defaultOption$compat2 : defaultOption.value;
						}

						return options;
					}
				}, {
					key: "set",
					value: function set(name, value) {
						userOptions[name] = value;
					}
				}, {
					key: "setAll",
					value: function setAll(options) {
						for (var name in options) {
							userOptions[name] = options[name];
						}
					}
				}, {
					key: "remove",
					value: function remove(name) {
						delete userOptions[name];
					}
				}, {
					key: "_hasUserOptions",
					value: function _hasUserOptions() {
						return Object.keys(userOptions).length > 0;
					}
				}]);

				return AppOptions;
			}();

			exports.AppOptions = AppOptions;

			/***/
		}),
		/* 2 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFViewerApplication = exports.PDFPrintServiceFactory = exports
				.DefaultExternalServices = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _ui_utils = __webpack_require__(5);

			var _app_options = __webpack_require__(1);

			var _event_utils = __webpack_require__(6);

			var _pdfjsLib = __webpack_require__(7);

			var _pdf_cursor_tools = __webpack_require__(8);

			var _pdf_link_service = __webpack_require__(10);

			var _overlay_manager = __webpack_require__(11);

			var _password_prompt = __webpack_require__(12);

			var _pdf_attachment_viewer = __webpack_require__(13);

			var _pdf_document_properties = __webpack_require__(15);

			var _pdf_find_bar = __webpack_require__(16);

			var _pdf_find_controller = __webpack_require__(17);

			var _pdf_history = __webpack_require__(19);

			var _pdf_layer_viewer = __webpack_require__(20);

			var _pdf_outline_viewer = __webpack_require__(21);

			var _pdf_presentation_mode = __webpack_require__(22);

			var _pdf_rendering_queue = __webpack_require__(23);

			var _pdf_scripting_manager = __webpack_require__(24);

			var _pdf_sidebar = __webpack_require__(25);

			var _pdf_sidebar_resizer = __webpack_require__(26);

			var _pdf_thumbnail_viewer = __webpack_require__(27);

			var _pdf_viewer = __webpack_require__(29);

			var _secondary_toolbar = __webpack_require__(38);

			var _toolbar = __webpack_require__(39);

			var _view_history = __webpack_require__(40);

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

			function ownKeys(object, enumerableOnly) {
				var keys = Object.keys(object);
				if (Object.getOwnPropertySymbols) {
					var symbols = Object.getOwnPropertySymbols(object);
					enumerableOnly && (symbols = symbols.filter(function(sym) {
						return Object.getOwnPropertyDescriptor(object, sym).enumerable;
					})), keys.push.apply(keys, symbols);
				}
				return keys;
			}

			function _objectSpread(target) {
				for (var i = 1; i < arguments.length; i++) {
					var source = null != arguments[i] ? arguments[i] : {};
					i % 2 ? ownKeys(Object(source), !0).forEach(function(key) {
						_defineProperty(target, key, source[key]);
					}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object
						.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(
						function(key) {
							Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(
								source, key));
						});
				}
				return target;
			}

			function _defineProperty(obj, key, value) {
				if (key in obj) {
					Object.defineProperty(obj, key, {
						value: value,
						enumerable: true,
						configurable: true,
						writable: true
					});
				} else {
					obj[key] = value;
				}
				return obj;
			}

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

			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."
					);
			}

			function _iterableToArrayLimit(arr, i) {
				var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] ||
					arr["@@iterator"];
				if (_i == null) return;
				var _arr = [];
				var _n = true;
				var _d = false;
				var _s, _e;
				try {
					for (_i = _i.call(arr); !(_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;
			}

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

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

			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);
			}

			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;
			}

			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);
				}
			}

			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);
					});
				};
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT = 5000;
			var FORCE_PAGES_LOADED_TIMEOUT = 10000;
			var WHEEL_ZOOM_DISABLED_TIMEOUT = 1000;
			var ViewOnLoad = {
				UNKNOWN: -1,
				PREVIOUS: 0,
				INITIAL: 1
			};
			var ViewerCssTheme = {
				AUTOMATIC: 0,
				LIGHT: 1,
				DARK: 2
			};
			var KNOWN_VERSIONS = ["1.0", "1.1", "1.2", "1.3", "1.4", "1.5", "1.6", "1.7", "1.8", "1.9",
				"2.0", "2.1", "2.2", "2.3"
			];
			var KNOWN_GENERATORS = ["acrobat distiller", "acrobat pdfwriter", "adobe livecycle",
				"adobe pdf library", "adobe photoshop", "ghostscript", "tcpdf", "cairo", "dvipdfm",
				"dvips", "pdftex", "pdfkit", "itext", "prince", "quarkxpress", "mac os x",
				"microsoft", "openoffice", "oracle", "luradocument", "pdf-xchange", "antenna house",
				"aspose.cells", "fpdf"
			];

			var DefaultExternalServices = /*#__PURE__*/ function() {
				function DefaultExternalServices() {
					_classCallCheck(this, DefaultExternalServices);

					throw new Error("Cannot initialize DefaultExternalServices.");
				}

				_createClass(DefaultExternalServices, null, [{
					key: "updateFindControlState",
					value: function updateFindControlState(data) {}
				}, {
					key: "updateFindMatchesCount",
					value: function updateFindMatchesCount(data) {}
				}, {
					key: "initPassiveLoading",
					value: function initPassiveLoading(callbacks) {}
				}, {
					key: "fallback",
					value: function() {
						var _fallback = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee(
							data) {
								return _regenerator["default"].wrap(
									function _callee$(_context) {
										while (1) {
											switch (_context.prev =
												_context.next) {
												case 0:
												case "end":
													return _context
														.stop();
											}
										}
									}, _callee);
							}));

						function fallback(_x) {
							return _fallback.apply(this, arguments);
						}

						return fallback;
					}()
				}, {
					key: "reportTelemetry",
					value: function reportTelemetry(data) {}
				}, {
					key: "createDownloadManager",
					value: function createDownloadManager(options) {
						throw new Error("Not implemented: createDownloadManager");
					}
				}, {
					key: "createPreferences",
					value: function createPreferences() {
						throw new Error("Not implemented: createPreferences");
					}
				}, {
					key: "createL10n",
					value: function createL10n(options) {
						throw new Error("Not implemented: createL10n");
					}
				}, {
					key: "createScripting",
					value: function createScripting(options) {
						throw new Error("Not implemented: createScripting");
					}
				}, {
					key: "supportsIntegratedFind",
					get: function get() {
						return (0, _pdfjsLib.shadow)(this, "supportsIntegratedFind",
							false);
					}
				}, {
					key: "supportsDocumentFonts",
					get: function get() {
						return (0, _pdfjsLib.shadow)(this, "supportsDocumentFonts",
							true);
					}
				}, {
					key: "supportedMouseWheelZoomModifierKeys",
					get: function get() {
						return (0, _pdfjsLib.shadow)(this,
							"supportedMouseWheelZoomModifierKeys", {
								ctrlKey: true,
								metaKey: true
							});
					}
				}, {
					key: "isInAutomation",
					get: function get() {
						return (0, _pdfjsLib.shadow)(this, "isInAutomation", false);
					}
				}]);

				return DefaultExternalServices;
			}();

			exports.DefaultExternalServices = DefaultExternalServices;
			var PDFViewerApplication = {
				initialBookmark: document.location.hash.substring(1),
				_initializedCapability: (0, _pdfjsLib.createPromiseCapability)(),
				_fellback: false,
				appConfig: null,
				pdfDocument: null,
				pdfLoadingTask: null,
				printService: null,
				pdfViewer: null,
				pdfThumbnailViewer: null,
				pdfRenderingQueue: null,
				pdfPresentationMode: null,
				pdfDocumentProperties: null,
				pdfLinkService: null,
				pdfHistory: null,
				pdfSidebar: null,
				pdfSidebarResizer: null,
				pdfOutlineViewer: null,
				pdfAttachmentViewer: null,
				pdfLayerViewer: null,
				pdfCursorTools: null,
				pdfScriptingManager: null,
				store: null,
				downloadManager: null,
				overlayManager: null,
				preferences: null,
				toolbar: null,
				secondaryToolbar: null,
				eventBus: null,
				l10n: null,
				isInitialViewSet: false,
				downloadComplete: false,
				isViewerEmbedded: window.parent !== window,
				url: "",
				baseUrl: "",
				_downloadUrl: "",
				externalServices: DefaultExternalServices,
				_boundEvents: Object.create(null),
				documentInfo: null,
				metadata: null,
				_contentDispositionFilename: null,
				_contentLength: null,
				_saveInProgress: false,
				_docStats: null,
				_wheelUnusedTicks: 0,
				_idleCallbacks: new Set(),
				initialize: function initialize(appConfig) {
					var _this = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee2() {
							var appContainer;
							return _regenerator["default"].wrap(function _callee2$(
								_context2) {
								while (1) {
									switch (_context2.prev = _context2.next) {
										case 0:
											_this.preferences = _this
												.externalServices
												.createPreferences();
											_this.appConfig = appConfig;
											_context2.next = 4;
											return _this._readPreferences();

										case 4:
											_context2.next = 6;
											return _this._parseHashParameters();

										case 6:
											_this._forceCssTheme();

											_context2.next = 9;
											return _this._initializeL10n();

										case 9:
											if (_this.isViewerEmbedded &&
												_app_options.AppOptions.get(
													"externalLinkTarget") ===
												_pdf_link_service.LinkTarget
												.NONE) {
												_app_options.AppOptions.set(
													"externalLinkTarget",
													_pdf_link_service
													.LinkTarget.TOP);
											}

											_context2.next = 12;
											return _this
												._initializeViewerComponents();

										case 12:
											_this.bindEvents();

											_this.bindWindowEvents();

											appContainer = appConfig
												.appContainer || document
												.documentElement;

											_this.l10n.translate(appContainer)
												.then(function() {
													_this.eventBus.dispatch(
														"localized", {
															source: _this
														});
												});

											_this._initializedCapability
												.resolve();

										case 17:
										case "end":
											return _context2.stop();
									}
								}
							}, _callee2);
						}))();
				},
				_readPreferences: function _readPreferences() {
					var _this2 = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee3() {
							return _regenerator["default"].wrap(function _callee3$(
								_context3) {
								while (1) {
									switch (_context3.prev = _context3.next) {
										case 0:
											if (!_app_options.AppOptions.get(
													"disablePreferences")) {
												_context3.next = 2;
												break;
											}

											return _context3.abrupt("return");

										case 2:
											if (_app_options.AppOptions
												._hasUserOptions()) {
												console.warn(
													"_readPreferences: The Preferences may override manually set AppOptions; " +
													'please use the "disablePreferences"-option in order to prevent that.'
													);
											}

											_context3.prev = 3;
											_context3.t0 = _app_options
												.AppOptions;
											_context3.next = 7;
											return _this2.preferences.getAll();

										case 7:
											_context3.t1 = _context3.sent;

											_context3.t0.setAll.call(_context3
												.t0, _context3.t1);

											_context3.next = 14;
											break;

										case 11:
											_context3.prev = 11;
											_context3.t2 = _context3["catch"](
											3);
											console.error("_readPreferences: \""
												.concat(_context3.t2 ===
													null || _context3.t2 ===
													void 0 ? void 0 :
													_context3.t2.message,
													"\"."));

										case 14:
										case "end":
											return _context3.stop();
									}
								}
							}, _callee3, null, [
								[3, 11]
							]);
						}))();
				},
				_parseHashParameters: function _parseHashParameters() {
					var _this3 = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee4() {
							var hash, params, waitOn, viewer, enabled;
							return _regenerator["default"].wrap(function _callee4$(
								_context4) {
								while (1) {
									switch (_context4.prev = _context4.next) {
										case 0:
											if (_app_options.AppOptions.get(
													"pdfBugEnabled")) {
												_context4.next = 2;
												break;
											}

											return _context4.abrupt("return");

										case 2:
											hash = document.location.hash
												.substring(1);

											if (hash) {
												_context4.next = 5;
												break;
											}

											return _context4.abrupt("return");

										case 5:
											params = (0, _ui_utils
													.parseQueryString)(hash),
												waitOn = [];

											if (params.get("disableworker") ===
												"true") {
												waitOn.push(loadFakeWorker());
											}

											if (params.has("disablerange")) {
												_app_options.AppOptions.set(
													"disableRange", params
													.get("disablerange") ===
													"true");
											}

											if (params.has("disablestream")) {
												_app_options.AppOptions.set(
													"disableStream", params
													.get(
													"disablestream") ===
													"true");
											}

											if (params.has(
												"disableautofetch")) {
												_app_options.AppOptions.set(
													"disableAutoFetch",
													params.get(
														"disableautofetch"
														) === "true");
											}

											if (params.has("disablefontface")) {
												_app_options.AppOptions.set(
													"disableFontFace",
													params.get(
														"disablefontface"
														) === "true");
											}

											if (params.has("disablehistory")) {
												_app_options.AppOptions.set(
													"disableHistory", params
													.get(
													"disablehistory") ===
													"true");
											}

											if (params.has("verbosity")) {
												_app_options.AppOptions.set(
													"verbosity", params.get(
														"verbosity") | 0);
											}

											if (!params.has("textlayer")) {
												_context4.next = 22;
												break;
											}

											_context4.t0 = params.get(
												"textlayer");
											_context4.next = _context4.t0 ===
												"off" ? 17 : _context4.t0 ===
												"visible" ? 19 : _context4
												.t0 === "shadow" ? 19 :
												_context4.t0 === "hover" ? 19 :
												22;
											break;

										case 17:
											_app_options.AppOptions.set(
												"textLayerMode", _ui_utils
												.TextLayerMode.DISABLE);

											return _context4.abrupt("break",
											22);

										case 19:
											viewer = _this3.appConfig
												.viewerContainer;
											viewer.classList.add("textLayer-"
												.concat(params.get(
													"textlayer")));
											return _context4.abrupt("break",
											22);

										case 22:
											if (params.has("pdfbug")) {
												_app_options.AppOptions.set(
													"pdfBug", true);

												_app_options.AppOptions.set(
													"fontExtraProperties",
													true);

												enabled = params.get("pdfbug")
													.split(",");
												waitOn.push(initPDFBug(
												enabled));
											}

											if (params.has("locale")) {
												_app_options.AppOptions.set(
													"locale", params.get(
														"locale"));
											}

											if (!(waitOn.length === 0)) {
												_context4.next = 26;
												break;
											}

											return _context4.abrupt("return");

										case 26:
											_context4.prev = 26;
											_context4.next = 29;
											return Promise.all(waitOn);

										case 29:
											_context4.next = 34;
											break;

										case 31:
											_context4.prev = 31;
											_context4.t1 = _context4["catch"](
												26);
											console.error(
												"_parseHashParameters: \""
												.concat(_context4.t1
													.message, "\"."));

										case 34:
										case "end":
											return _context4.stop();
									}
								}
							}, _callee4, null, [
								[26, 31]
							]);
						}))();
				},
				_initializeL10n: function _initializeL10n() {
					var _this4 = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee5() {
							var dir;
							return _regenerator["default"].wrap(function _callee5$(
								_context5) {
								while (1) {
									switch (_context5.prev = _context5.next) {
										case 0:
											_this4.l10n = _this4
												.externalServices.createL10n({
													locale: _app_options
														.AppOptions.get(
															"locale")
												});
											_context5.next = 3;
											return _this4.l10n.getDirection();

										case 3:
											dir = _context5.sent;
											document.getElementsByTagName(
												"html")[0].dir = dir;

										case 5:
										case "end":
											return _context5.stop();
									}
								}
							}, _callee5);
						}))();
				},
				_forceCssTheme: function _forceCssTheme() {
					var cssTheme = _app_options.AppOptions.get("viewerCssTheme");

					if (cssTheme === ViewerCssTheme.AUTOMATIC || !Object.values(ViewerCssTheme)
						.includes(cssTheme)) {
						return;
					}

					try {
						var styleSheet = document.styleSheets[0];
						var cssRules = (styleSheet === null || styleSheet === void 0 ? void 0 :
							styleSheet.cssRules) || [];

						for (var i = 0, ii = cssRules.length; i < ii; i++) {
							var _rule$media;

							var rule = cssRules[i];

							if (rule instanceof CSSMediaRule && ((_rule$media = rule.media) ===
									null || _rule$media === void 0 ? void 0 : _rule$media[0]
									) === "(prefers-color-scheme: dark)") {
								if (cssTheme === ViewerCssTheme.LIGHT) {
									styleSheet.deleteRule(i);
									return;
								}

								var darkRules =
									/^@media \(prefers-color-scheme: dark\) {\n\s*([\w\s-.,:;/\\{}()]+)\n}$/
									.exec(rule.cssText);

								if (darkRules !== null && darkRules !== void 0 && darkRules[
									1]) {
									styleSheet.deleteRule(i);
									styleSheet.insertRule(darkRules[1], i);
								}

								return;
							}
						}
					} catch (reason) {
						console.error("_forceCssTheme: \"".concat(reason === null || reason ===
							void 0 ? void 0 : reason.message, "\"."));
					}
				},
				_initializeViewerComponents: function _initializeViewerComponents() {
					var _this5 = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee6() {
							var appConfig, externalServices, eventBus,
								pdfRenderingQueue, pdfLinkService, downloadManager,
								findController, pdfScriptingManager, container, viewer;
							return _regenerator["default"].wrap(function _callee6$(
								_context6) {
								while (1) {
									switch (_context6.prev = _context6.next) {
										case 0:
											appConfig = _this5.appConfig,
												externalServices = _this5
												.externalServices;
											eventBus = externalServices
												.isInAutomation ?
												new _event_utils
												.AutomationEventBus() :
												new _event_utils.EventBus();
											_this5.eventBus = eventBus;
											_this5.overlayManager =
												new _overlay_manager
												.OverlayManager();
											pdfRenderingQueue =
												new _pdf_rendering_queue
												.PDFRenderingQueue();
											pdfRenderingQueue.onIdle = _this5
												._cleanup.bind(_this5);
											_this5.pdfRenderingQueue =
												pdfRenderingQueue;
											pdfLinkService =
												new _pdf_link_service
												.PDFLinkService({
													eventBus: eventBus,
													externalLinkTarget: _app_options
														.AppOptions.get(
															"externalLinkTarget"
															),
													externalLinkRel: _app_options
														.AppOptions.get(
															"externalLinkRel"
															),
													ignoreDestinationZoom: _app_options
														.AppOptions.get(
															"ignoreDestinationZoom"
															)
												});
											_this5.pdfLinkService =
												pdfLinkService;
											downloadManager = externalServices
												.createDownloadManager();
											_this5.downloadManager =
												downloadManager;
											findController =
												new _pdf_find_controller
												.PDFFindController({
													linkService: pdfLinkService,
													eventBus: eventBus
												});
											_this5.findController =
												findController;
											pdfScriptingManager =
												new _pdf_scripting_manager
												.PDFScriptingManager({
													eventBus: eventBus,
													sandboxBundleSrc: _app_options
														.AppOptions.get(
															"sandboxBundleSrc"
															),
													scriptingFactory: externalServices,
													docPropertiesLookup: _this5
														._scriptingDocProperties
														.bind(_this5)
												});
											_this5.pdfScriptingManager =
												pdfScriptingManager;
											container = appConfig.mainContainer;
											viewer = appConfig.viewerContainer;
											_this5.pdfViewer = new _pdf_viewer
												.PDFViewer({
													container: container,
													viewer: viewer,
													eventBus: eventBus,
													renderingQueue: pdfRenderingQueue,
													linkService: pdfLinkService,
													downloadManager: downloadManager,
													findController: findController,
													scriptingManager: _app_options
														.AppOptions.get(
															"enableScripting"
															) &&
														pdfScriptingManager,
													renderer: _app_options
														.AppOptions.get(
															"renderer"),
													l10n: _this5.l10n,
													textLayerMode: _app_options
														.AppOptions.get(
															"textLayerMode"
															),
													annotationMode: _app_options
														.AppOptions.get(
															"annotationMode"
															),
													imageResourcesPath: _app_options
														.AppOptions.get(
															"imageResourcesPath"
															),
													enablePrintAutoRotate: _app_options
														.AppOptions.get(
															"enablePrintAutoRotate"
															),
													useOnlyCssZoom: _app_options
														.AppOptions.get(
															"useOnlyCssZoom"
															),
													maxCanvasPixels: _app_options
														.AppOptions.get(
															"maxCanvasPixels"
															),
													enablePermissions: _app_options
														.AppOptions.get(
															"enablePermissions"
															)
												});
											pdfRenderingQueue.setViewer(_this5
												.pdfViewer);
											pdfLinkService.setViewer(_this5
												.pdfViewer);
											pdfScriptingManager.setViewer(_this5
												.pdfViewer);
											_this5.pdfThumbnailViewer =
												new _pdf_thumbnail_viewer
												.PDFThumbnailViewer({
													container: appConfig
														.sidebar
														.thumbnailView,
													eventBus: eventBus,
													renderingQueue: pdfRenderingQueue,
													linkService: pdfLinkService,
													l10n: _this5.l10n
												});
											pdfRenderingQueue
												.setThumbnailViewer(_this5
													.pdfThumbnailViewer);

											if (!_this5.isViewerEmbedded && !
												_app_options.AppOptions.get(
													"disableHistory")) {
												_this5.pdfHistory =
													new _pdf_history
												.PDFHistory({
														linkService: pdfLinkService,
														eventBus: eventBus
													});
												pdfLinkService.setHistory(_this5
													.pdfHistory);
											}

											if (!_this5
												.supportsIntegratedFind) {
												_this5.findBar =
													new _pdf_find_bar
													.PDFFindBar(appConfig
														.findBar, eventBus,
														_this5.l10n);
											}

											_this5.pdfDocumentProperties =
												new _pdf_document_properties
												.PDFDocumentProperties(appConfig
													.documentProperties, _this5
													.overlayManager, eventBus,
													_this5.l10n);
											_this5.pdfCursorTools =
												new _pdf_cursor_tools
												.PDFCursorTools({
													container: container,
													eventBus: eventBus,
													cursorToolOnLoad: _app_options
														.AppOptions.get(
															"cursorToolOnLoad"
															)
												});
											_this5.toolbar = new _toolbar
												.Toolbar(appConfig.toolbar,
													eventBus, _this5.l10n);
											_this5.secondaryToolbar =
												new _secondary_toolbar
												.SecondaryToolbar(appConfig
													.secondaryToolbar,
													container, eventBus);

											if (_this5.supportsFullscreen) {
												_this5.pdfPresentationMode =
													new _pdf_presentation_mode
													.PDFPresentationMode({
														container: container,
														pdfViewer: _this5
															.pdfViewer,
														eventBus: eventBus
													});
											}

											_this5.passwordPrompt =
												new _password_prompt
												.PasswordPrompt(appConfig
													.passwordOverlay, _this5
													.overlayManager, _this5
													.l10n, _this5
													.isViewerEmbedded);
											_this5.pdfOutlineViewer =
												new _pdf_outline_viewer
												.PDFOutlineViewer({
													container: appConfig
														.sidebar
														.outlineView,
													eventBus: eventBus,
													linkService: pdfLinkService
												});
											_this5.pdfAttachmentViewer =
												new _pdf_attachment_viewer
												.PDFAttachmentViewer({
													container: appConfig
														.sidebar
														.attachmentsView,
													eventBus: eventBus,
													downloadManager: downloadManager
												});
											_this5.pdfLayerViewer =
												new _pdf_layer_viewer
												.PDFLayerViewer({
													container: appConfig
														.sidebar.layersView,
													eventBus: eventBus,
													l10n: _this5.l10n
												});
											_this5.pdfSidebar = new _pdf_sidebar
												.PDFSidebar({
													elements: appConfig
														.sidebar,
													pdfViewer: _this5
														.pdfViewer,
													pdfThumbnailViewer: _this5
														.pdfThumbnailViewer,
													eventBus: eventBus,
													l10n: _this5.l10n
												});
											_this5.pdfSidebar.onToggled = _this5
												.forceRendering.bind(_this5);
											_this5.pdfSidebarResizer =
												new _pdf_sidebar_resizer
												.PDFSidebarResizer(appConfig
													.sidebarResizer, eventBus,
													_this5.l10n);

										case 37:
										case "end":
											return _context6.stop();
									}
								}
							}, _callee6);
						}))();
				},
				run: function run(config) {
					this.initialize(config).then(webViewerInitialized);
				},

				get initialized() {
					return this._initializedCapability.settled;
				},

				get initializedPromise() {
					return this._initializedCapability.promise;
				},

				zoomIn: function zoomIn(steps) {
					if (this.pdfViewer.isInPresentationMode) {
						return;
					}

					this.pdfViewer.increaseScale(steps);
				},
				zoomOut: function zoomOut(steps) {
					if (this.pdfViewer.isInPresentationMode) {
						return;
					}

					this.pdfViewer.decreaseScale(steps);
				},
				zoomReset: function zoomReset() {
					if (this.pdfViewer.isInPresentationMode) {
						return;
					}

					this.pdfViewer.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
				},

				get pagesCount() {
					return this.pdfDocument ? this.pdfDocument.numPages : 0;
				},

				get page() {
					return this.pdfViewer.currentPageNumber;
				},

				set page(val) {
					this.pdfViewer.currentPageNumber = val;
				},

				get supportsPrinting() {
					return PDFPrintServiceFactory.instance.supportsPrinting;
				},

				get supportsFullscreen() {
					return (0, _pdfjsLib.shadow)(this, "supportsFullscreen", document
						.fullscreenEnabled);
				},

				get supportsIntegratedFind() {
					return this.externalServices.supportsIntegratedFind;
				},

				get supportsDocumentFonts() {
					return this.externalServices.supportsDocumentFonts;
				},

				get loadingBar() {
					var bar = new _ui_utils.ProgressBar("#loadingBar");
					return (0, _pdfjsLib.shadow)(this, "loadingBar", bar);
				},

				get supportedMouseWheelZoomModifierKeys() {
					return this.externalServices.supportedMouseWheelZoomModifierKeys;
				},

				initPassiveLoading: function initPassiveLoading() {
					throw new Error("Not implemented: initPassiveLoading");
				},
				setTitleUsingUrl: function setTitleUsingUrl() {
					var url = arguments.length > 0 && arguments[0] !== undefined ? arguments[
						0] : "";
					var downloadUrl = arguments.length > 1 && arguments[1] !== undefined ?
						arguments[1] : null;
					this.url = url;
					this.baseUrl = url.split("#")[0];

					if (downloadUrl) {
						this._downloadUrl = downloadUrl === url ? this.baseUrl : downloadUrl
							.split("#")[0];
					}

					var title = (0, _pdfjsLib.getPdfFilenameFromUrl)(url, "");

					if (!title) {
						try {
							title = decodeURIComponent((0, _pdfjsLib.getFilenameFromUrl)(
								url)) || url;
						} catch (ex) {
							title = url;
						}
					}

					this.setTitle(title);
				},
				setTitle: function setTitle(title) {
					if (this.isViewerEmbedded) {
						return;
					}

					document.title = title;
				},

				get _docFilename() {
					return this._contentDispositionFilename || (0, _pdfjsLib
						.getPdfFilenameFromUrl)(this.url);
				},

				_hideViewBookmark: function _hideViewBookmark() {
					var _this$appConfig = this.appConfig,
						toolbar = _this$appConfig.toolbar,
						secondaryToolbar = _this$appConfig.secondaryToolbar;
					toolbar.viewBookmark.hidden = true;
					secondaryToolbar.viewBookmarkButton.hidden = true;
				},
				_cancelIdleCallbacks: function _cancelIdleCallbacks() {
					if (!this._idleCallbacks.size) {
						return;
					}

					var _iterator = _createForOfIteratorHelper(this._idleCallbacks),
						_step;

					try {
						for (_iterator.s(); !(_step = _iterator.n()).done;) {
							var callback = _step.value;
							window.cancelIdleCallback(callback);
						}
					} catch (err) {
						_iterator.e(err);
					} finally {
						_iterator.f();
					}

					this._idleCallbacks.clear();
				},
				close: function close() {
					var _this6 = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee7() {
							var _this6$pdfDocument, _this6$pdfHistory, _this6$findBar;

							var container, promises;
							return _regenerator["default"].wrap(function _callee7$(
								_context7) {
								while (1) {
									switch (_context7.prev = _context7.next) {
										case 0:
											_this6._unblockDocumentLoadEvent();

											_this6._hideViewBookmark();

											container = _this6.appConfig
												.errorWrapper.container;
											container.hidden = true;

											if (_this6.pdfLoadingTask) {
												_context7.next = 6;
												break;
											}

											return _context7.abrupt("return");

										case 6:
											if (!(((_this6$pdfDocument = _this6
															.pdfDocument) ===
														null ||
														_this6$pdfDocument ===
														void 0 ? void 0 :
														_this6$pdfDocument
														.annotationStorage.size
														) > 0 && _this6
													._annotationStorageModified
													)) {
												_context7.next = 14;
												break;
											}

											_context7.prev = 7;
											_context7.next = 10;
											return _this6.save({
												sourceEventType: "save"
											});

										case 10:
											_context7.next = 14;
											break;

										case 12:
											_context7.prev = 12;
											_context7.t0 = _context7["catch"](
											7);

										case 14:
											promises = [];
											promises.push(_this6.pdfLoadingTask
												.destroy());
											_this6.pdfLoadingTask = null;

											if (_this6.pdfDocument) {
												_this6.pdfDocument = null;

												_this6.pdfThumbnailViewer
													.setDocument(null);

												_this6.pdfViewer.setDocument(
													null);

												_this6.pdfLinkService
													.setDocument(null);

												_this6.pdfDocumentProperties
													.setDocument(null);
											}

											_this6.pdfLinkService
												.externalLinkEnabled = true;
											_this6._fellback = false;
											_this6.store = null;
											_this6.isInitialViewSet = false;
											_this6.downloadComplete = false;
											_this6.url = "";
											_this6.baseUrl = "";
											_this6._downloadUrl = "";
											_this6.documentInfo = null;
											_this6.metadata = null;
											_this6._contentDispositionFilename =
												null;
											_this6._contentLength = null;
											_this6._saveInProgress = false;
											_this6._docStats = null;

											_this6._cancelIdleCallbacks();

											promises.push(_this6
												.pdfScriptingManager
												.destroyPromise);

											_this6.pdfSidebar.reset();

											_this6.pdfOutlineViewer.reset();

											_this6.pdfAttachmentViewer.reset();

											_this6.pdfLayerViewer.reset();

											(_this6$pdfHistory = _this6
												.pdfHistory) === null ||
												_this6$pdfHistory === void 0 ?
												void 0 : _this6$pdfHistory
												.reset();
											(_this6$findBar = _this6
											.findBar) === null ||
												_this6$findBar === void 0 ?
												void 0 : _this6$findBar.reset();

											_this6.toolbar.reset();

											_this6.secondaryToolbar.reset();

											if (typeof PDFBug !== "undefined") {
												PDFBug.cleanup();
											}

											_context7.next = 45;
											return Promise.all(promises);

										case 45:
										case "end":
											return _context7.stop();
									}
								}
							}, _callee7, null, [
								[7, 12]
							]);
						}))();
				},
				open: function open(file, args) {
					var _this7 = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee8() {
							var workerParameters, key, parameters, apiParameters, _key,
								value, _key2, loadingTask;

							return _regenerator["default"].wrap(function _callee8$(
								_context8) {
								while (1) {
									switch (_context8.prev = _context8.next) {
										case 0:
											if (!_this7.pdfLoadingTask) {
												_context8.next = 3;
												break;
											}

											_context8.next = 3;
											return _this7.close();

										case 3:
											workerParameters = _app_options
												.AppOptions.getAll(_app_options
													.OptionKind.WORKER);

											for (key in workerParameters) {
												_pdfjsLib.GlobalWorkerOptions[
													key] = workerParameters[
													key];
											}

											parameters = Object.create(null);

											if (typeof file === "string") {
												_this7.setTitleUsingUrl(file,
													file);

												parameters.url = file;
											} else if (file && "byteLength" in
												file) {
												parameters.data = file;
											} else if (file.url && file
												.originalUrl) {
												_this7.setTitleUsingUrl(file
													.originalUrl, file.url);

												parameters.url = file.url;
											}

											apiParameters = _app_options
												.AppOptions.getAll(_app_options
													.OptionKind.API);

											for (_key in apiParameters) {
												value = apiParameters[_key];

												if (_key === "docBaseUrl" && !
													value) {}

												parameters[_key] = value;
											}

											if (args) {
												for (_key2 in args) {
													parameters[_key2] = args[
														_key2];
												}
											}

											loadingTask = (0, _pdfjsLib
												.getDocument)(parameters);
											_this7.pdfLoadingTask = loadingTask;

											loadingTask.onPassword = function(
												updateCallback, reason) {
												_this7.pdfLinkService
													.externalLinkEnabled =
													false;

												_this7.passwordPrompt
													.setUpdateCallback(
														updateCallback,
														reason);

												_this7.passwordPrompt
											.open();
											};

											loadingTask.onProgress = function(
												_ref) {
												var loaded = _ref.loaded,
													total = _ref.total;

												_this7.progress(loaded /
													total);
											};

											loadingTask.onUnsupportedFeature =
												_this7.fallback.bind(_this7);
											return _context8.abrupt("return",
												loadingTask.promise.then(
													function(pdfDocument) {
														_this7.load(
															pdfDocument);
													},
													function(reason) {
														if (loadingTask !==
															_this7
															.pdfLoadingTask
															) {
															return undefined;
														}

														var key =
															"loading_error";

														if (reason instanceof _pdfjsLib
															.InvalidPDFException
															) {
															key =
																"invalid_file_error";
														} else if (
															reason instanceof _pdfjsLib
															.MissingPDFException
															) {
															key =
																"missing_file_error";
														} else if (
															reason instanceof _pdfjsLib
															.UnexpectedResponseException
															) {
															key =
																"unexpected_response_error";
														}

														return _this7.l10n
															.get(key).then(
																function(
																	msg) {
																	_this7
																		._documentError(
																			msg, {
																				message: reason ===
																					null ||
																					reason ===
																					void 0 ?
																					void 0 :
																					reason
																					.message
																			}
																			);

																	throw reason;
																});
													}));

										case 16:
										case "end":
											return _context8.stop();
									}
								}
							}, _callee8);
						}))();
				},
				_ensureDownloadComplete: function _ensureDownloadComplete() {
					if (this.pdfDocument && this.downloadComplete) {
						return;
					}

					throw new Error("PDF document not downloaded.");
				},
				download: function download() {
					var _arguments = arguments,
						_this8 = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee9() {
							var _ref2, _ref2$sourceEventType, sourceEventType, url,
								filename, data, blob;

							return _regenerator["default"].wrap(function _callee9$(
								_context9) {
								while (1) {
									switch (_context9.prev = _context9.next) {
										case 0:
											_ref2 = _arguments.length > 0 &&
												_arguments[0] !== undefined ?
												_arguments[0] : {},
												_ref2$sourceEventType = _ref2
												.sourceEventType,
												sourceEventType =
												_ref2$sourceEventType ===
												void 0 ? "download" :
												_ref2$sourceEventType;
											url = _this8._downloadUrl,
												filename = _this8._docFilename;
											_context9.prev = 2;

											_this8._ensureDownloadComplete();

											_context9.next = 6;
											return _this8.pdfDocument.getData();

										case 6:
											data = _context9.sent;
											blob = new Blob([data], {
												type: "application/pdf"
											});
											_context9.next = 10;
											return _this8.downloadManager
												.download(blob, url, filename,
													sourceEventType);

										case 10:
											_context9.next = 16;
											break;

										case 12:
											_context9.prev = 12;
											_context9.t0 = _context9["catch"](
											2);
											_context9.next = 16;
											return _this8.downloadManager
												.downloadUrl(url, filename);

										case 16:
										case "end":
											return _context9.stop();
									}
								}
							}, _callee9, null, [
								[2, 12]
							]);
						}))();
				},
				save: function save() {
					var _arguments2 = arguments,
						_this9 = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee10() {
							var _ref3, _ref3$sourceEventType, sourceEventType, url,
								filename, data, blob;

							return _regenerator["default"].wrap(function _callee10$(
								_context10) {
								while (1) {
									switch (_context10.prev = _context10.next) {
										case 0:
											_ref3 = _arguments2.length > 0 &&
												_arguments2[0] !== undefined ?
												_arguments2[0] : {},
												_ref3$sourceEventType = _ref3
												.sourceEventType,
												sourceEventType =
												_ref3$sourceEventType ===
												void 0 ? "download" :
												_ref3$sourceEventType;

											if (!_this9._saveInProgress) {
												_context10.next = 3;
												break;
											}

											return _context10.abrupt("return");

										case 3:
											_this9._saveInProgress = true;
											_context10.next = 6;
											return _this9.pdfScriptingManager
												.dispatchWillSave();

										case 6:
											url = _this9._downloadUrl,
												filename = _this9._docFilename;
											_context10.prev = 7;

											_this9._ensureDownloadComplete();

											_context10.next = 11;
											return _this9.pdfDocument
												.saveDocument();

										case 11:
											data = _context10.sent;
											blob = new Blob([data], {
												type: "application/pdf"
											});
											_context10.next = 15;
											return _this9.downloadManager
												.download(blob, url, filename,
													sourceEventType);

										case 15:
											_context10.next = 22;
											break;

										case 17:
											_context10.prev = 17;
											_context10.t0 = _context10["catch"](
												7);
											console.error(
												"Error when saving the document: "
												.concat(_context10.t0
													.message));
											_context10.next = 22;
											return _this9.download({
												sourceEventType: sourceEventType
											});

										case 22:
											_context10.prev = 22;
											_context10.next = 25;
											return _this9.pdfScriptingManager
												.dispatchDidSave();

										case 25:
											_this9._saveInProgress = false;
											return _context10.finish(22);

										case 27:
										case "end":
											return _context10.stop();
									}
								}
							}, _callee10, null, [
								[7, 17, 22, 27]
							]);
						}))();
				},
				downloadOrSave: function downloadOrSave(options) {
					var _this$pdfDocument;

					if (((_this$pdfDocument = this.pdfDocument) === null ||
							_this$pdfDocument === void 0 ? void 0 : _this$pdfDocument
							.annotationStorage.size) > 0) {
						this.save(options);
					} else {
						this.download(options);
					}
				},
				fallback: function fallback(featureId) {
					var _this10 = this;

					this.externalServices.reportTelemetry({
						type: "unsupportedFeature",
						featureId: featureId
					});

					if (this._fellback) {
						return;
					}

					this._fellback = true;
					this.externalServices.fallback({
						featureId: featureId,
						url: this.baseUrl
					}).then(function(download) {
						if (!download) {
							return;
						}

						_this10.download({
							sourceEventType: "download"
						});
					});
				},
				_documentError: function _documentError(message) {
					var _moreInfo$message;

					var moreInfo = arguments.length > 1 && arguments[1] !== undefined ?
						arguments[1] : null;

					this._unblockDocumentLoadEvent();

					this._otherError(message, moreInfo);

					this.eventBus.dispatch("documenterror", {
						source: this,
						message: message,
						reason: (_moreInfo$message = moreInfo === null || moreInfo ===
								void 0 ? void 0 : moreInfo.message) !== null &&
							_moreInfo$message !== void 0 ? _moreInfo$message : null
					});
				},
				_otherError: function _otherError(message) {
					var moreInfo = arguments.length > 1 && arguments[1] !== undefined ?
						arguments[1] : null;
					var moreInfoText = [this.l10n.get("error_version_info", {
						version: _pdfjsLib.version || "?",
						build: _pdfjsLib.build || "?"
					})];

					if (moreInfo) {
						moreInfoText.push(this.l10n.get("error_message", {
							message: moreInfo.message
						}));

						if (moreInfo.stack) {
							moreInfoText.push(this.l10n.get("error_stack", {
								stack: moreInfo.stack
							}));
						} else {
							if (moreInfo.filename) {
								moreInfoText.push(this.l10n.get("error_file", {
									file: moreInfo.filename
								}));
							}

							if (moreInfo.lineNumber) {
								moreInfoText.push(this.l10n.get("error_line", {
									line: moreInfo.lineNumber
								}));
							}
						}
					}

					var errorWrapperConfig = this.appConfig.errorWrapper;
					var errorWrapper = errorWrapperConfig.container;
					errorWrapper.hidden = false;
					var errorMessage = errorWrapperConfig.errorMessage;
					errorMessage.textContent = message;
					var closeButton = errorWrapperConfig.closeButton;

					closeButton.onclick = function() {
						errorWrapper.hidden = true;
					};

					var errorMoreInfo = errorWrapperConfig.errorMoreInfo;
					var moreInfoButton = errorWrapperConfig.moreInfoButton;
					var lessInfoButton = errorWrapperConfig.lessInfoButton;

					moreInfoButton.onclick = function() {
						errorMoreInfo.hidden = false;
						moreInfoButton.hidden = true;
						lessInfoButton.hidden = false;
						errorMoreInfo.style.height = errorMoreInfo.scrollHeight + "px";
					};

					lessInfoButton.onclick = function() {
						errorMoreInfo.hidden = true;
						moreInfoButton.hidden = false;
						lessInfoButton.hidden = true;
					};

					moreInfoButton.oncontextmenu = _ui_utils.noContextMenuHandler;
					lessInfoButton.oncontextmenu = _ui_utils.noContextMenuHandler;
					closeButton.oncontextmenu = _ui_utils.noContextMenuHandler;
					moreInfoButton.hidden = false;
					lessInfoButton.hidden = true;
					Promise.all(moreInfoText).then(function(parts) {
						errorMoreInfo.value = parts.join("\n");
					});
				},
				progress: function progress(level) {
					var _this11 = this;

					if (this.downloadComplete) {
						return;
					}

					var percent = Math.round(level * 100);

					if (percent > this.loadingBar.percent || isNaN(percent)) {
						this.loadingBar.percent = percent;
						var disableAutoFetch = this.pdfDocument ? this.pdfDocument.loadingParams
							.disableAutoFetch : _app_options.AppOptions.get("disableAutoFetch");

						if (disableAutoFetch && percent) {
							if (this.disableAutoFetchLoadingBarTimeout) {
								clearTimeout(this.disableAutoFetchLoadingBarTimeout);
								this.disableAutoFetchLoadingBarTimeout = null;
							}

							this.loadingBar.show();
							this.disableAutoFetchLoadingBarTimeout = setTimeout(function() {
								_this11.loadingBar.hide();

								_this11.disableAutoFetchLoadingBarTimeout = null;
							}, DISABLE_AUTO_FETCH_LOADING_BAR_TIMEOUT);
						}
					}
				},
				load: function load(pdfDocument) {
					var _this12 = this;

					this.pdfDocument = pdfDocument;
					pdfDocument.getDownloadInfo().then(function(_ref4) {
						var length = _ref4.length;
						_this12._contentLength = length;
						_this12.downloadComplete = true;

						_this12.loadingBar.hide();

						firstPagePromise.then(function() {
							_this12.eventBus.dispatch("documentloaded", {
								source: _this12
							});
						});
					});
					var pageLayoutPromise = pdfDocument.getPageLayout()["catch"](function() {});
					var pageModePromise = pdfDocument.getPageMode()["catch"](function() {});
					var openActionPromise = pdfDocument.getOpenAction()["catch"](function() {});
					this.toolbar.setPagesCount(pdfDocument.numPages, false);
					this.secondaryToolbar.setPagesCount(pdfDocument.numPages);
					var baseDocumentUrl;
					baseDocumentUrl = null;
					this.pdfLinkService.setDocument(pdfDocument, baseDocumentUrl);
					this.pdfDocumentProperties.setDocument(pdfDocument, this.url);
					var pdfViewer = this.pdfViewer;
					pdfViewer.setDocument(pdfDocument);
					var firstPagePromise = pdfViewer.firstPagePromise,
						onePageRendered = pdfViewer.onePageRendered,
						pagesPromise = pdfViewer.pagesPromise;
					var pdfThumbnailViewer = this.pdfThumbnailViewer;
					pdfThumbnailViewer.setDocument(pdfDocument);
					var storedPromise = (this.store = new _view_history.ViewHistory(pdfDocument
						.fingerprints[0])).getMultiple({
						page: null,
						zoom: _ui_utils.DEFAULT_SCALE_VALUE,
						scrollLeft: "0",
						scrollTop: "0",
						rotation: null,
						sidebarView: _ui_utils.SidebarView.UNKNOWN,
						scrollMode: _ui_utils.ScrollMode.UNKNOWN,
						spreadMode: _ui_utils.SpreadMode.UNKNOWN
					})["catch"](function() {
						return Object.create(null);
					});
					firstPagePromise.then(function(pdfPage) {
						_this12.loadingBar.setWidth(_this12.appConfig.viewerContainer);

						_this12._initializeAnnotationStorageCallbacks(pdfDocument);

						Promise.all([_ui_utils.animationStarted, storedPromise,
							pageLayoutPromise, pageModePromise,
							openActionPromise
						]).then( /*#__PURE__*/ function() {
							var _ref6 = _asyncToGenerator( /*#__PURE__*/
								_regenerator["default"].mark(
									function _callee11(_ref5) {
										var _ref7, timeStamp, stored,
											pageLayout, pageMode,
											openAction, viewOnLoad,
											initialBookmark, zoom, hash,
											rotation, sidebarView,
											scrollMode, spreadMode, modes;

										return _regenerator["default"].wrap(
											function _callee11$(
												_context11) {
												while (1) {
													switch (_context11
														.prev =
														_context11.next
														) {
														case 0:
															_ref7 =
																_slicedToArray(
																	_ref5,
																	5),
																timeStamp =
																_ref7[
																0],
																stored =
																_ref7[
																1],
																pageLayout =
																_ref7[
																2],
																pageMode =
																_ref7[
																3],
																openAction =
																_ref7[
																4];
															viewOnLoad =
																_app_options
																.AppOptions
																.get(
																	"viewOnLoad"
																	);

															_this12
																._initializePdfHistory({
																	fingerprint: pdfDocument
																		.fingerprints[
																			0
																			],
																	viewOnLoad: viewOnLoad,
																	initialDest: openAction ===
																		null ||
																		openAction ===
																		void 0 ?
																		void 0 :
																		openAction
																		.dest
																});

															initialBookmark
																=
																_this12
																.initialBookmark;
															zoom =
																_app_options
																.AppOptions
																.get(
																	"defaultZoomValue"
																	);
															hash =
																zoom ?
																"zoom="
																.concat(
																	zoom
																	) :
																null;
															rotation =
																null;
															sidebarView
																=
																_app_options
																.AppOptions
																.get(
																	"sidebarViewOnLoad"
																	);
															scrollMode =
																_app_options
																.AppOptions
																.get(
																	"scrollModeOnLoad"
																	);
															spreadMode =
																_app_options
																.AppOptions
																.get(
																	"spreadModeOnLoad"
																	);

															if (stored
																.page &&
																viewOnLoad !==
																ViewOnLoad
																.INITIAL
																) {
																hash =
																	"page="
																	.concat(
																		stored
																		.page,
																		"&zoom="
																		)
																	.concat(
																		zoom ||
																		stored
																		.zoom,
																		","
																		) +
																	""
																	.concat(
																		stored
																		.scrollLeft,
																		","
																		)
																	.concat(
																		stored
																		.scrollTop
																		);
																rotation
																	=
																	parseInt(
																		stored
																		.rotation,
																		10
																		);

																if (sidebarView ===
																	_ui_utils
																	.SidebarView
																	.UNKNOWN
																	) {
																	sidebarView
																		=
																		stored
																		.sidebarView |
																		0;
																}

																if (scrollMode ===
																	_ui_utils
																	.ScrollMode
																	.UNKNOWN
																	) {
																	scrollMode
																		=
																		stored
																		.scrollMode |
																		0;
																}

																if (spreadMode ===
																	_ui_utils
																	.SpreadMode
																	.UNKNOWN
																	) {
																	spreadMode
																		=
																		stored
																		.spreadMode |
																		0;
																}
															}

															if (pageMode &&
																sidebarView ===
																_ui_utils
																.SidebarView
																.UNKNOWN
																) {
																sidebarView
																	= (0,
																		_ui_utils
																		.apiPageModeToSidebarView
																		)
																	(
																		pageMode);
															}

															if (pageLayout &&
																scrollMode ===
																_ui_utils
																.ScrollMode
																.UNKNOWN &&
																spreadMode ===
																_ui_utils
																.SpreadMode
																.UNKNOWN
																) {
																modes =
																	(0, _ui_utils
																		.apiPageLayoutToViewerModes
																		)
																	(
																		pageLayout);
																spreadMode
																	=
																	modes
																	.spreadMode;
															}

															_this12
																.setInitialView(
																	hash, {
																		rotation: rotation,
																		sidebarView: sidebarView,
																		scrollMode: scrollMode,
																		spreadMode: spreadMode
																	});

															_this12
																.eventBus
																.dispatch(
																	"documentinit", {
																		source: _this12
																	});

															if (!_this12
																.isViewerEmbedded
																) {
																pdfViewer
																	.focus();
															}

															_context11
																.next =
																18;
															return Promise
																.race([pagesPromise,
																	new Promise(
																		function(
																			resolve
																			) {
																			setTimeout
																				(resolve,
																					FORCE_PAGES_LOADED_TIMEOUT
																					);
																		}
																		)
																]);

														case 18:
															if (!(!initialBookmark &&
																	!
																	hash
																	)) {
																_context11
																	.next =
																	20;
																break;
															}

															return _context11
																.abrupt(
																	"return"
																	);

														case 20:
															if (!
																pdfViewer
																.hasEqualPageSizes
																) {
																_context11
																	.next =
																	22;
																break;
															}

															return _context11
																.abrupt(
																	"return"
																	);

														case 22:
															_this12
																.initialBookmark =
																initialBookmark;
															pdfViewer
																.currentScaleValue =
																pdfViewer
																.currentScaleValue;

															_this12
																.setInitialView(
																	hash
																	);

														case 25:
														case "end":
															return _context11
																.stop();
													}
												}
											}, _callee11);
									}));

							return function(_x2) {
								return _ref6.apply(this, arguments);
							};
						}())["catch"](function() {
							_this12.setInitialView();
						}).then(function() {
							pdfViewer.update();
						});
					});
					pagesPromise.then(function() {
						_this12._unblockDocumentLoadEvent();

						_this12._initializeAutoPrint(pdfDocument, openActionPromise);
					}, function(reason) {
						_this12.l10n.get("loading_error").then(function(msg) {
							_this12._documentError(msg, {
								message: reason === null || reason ===
									void 0 ? void 0 : reason.message
							});
						});
					});
					onePageRendered.then(function(data) {
						_this12.externalServices.reportTelemetry({
							type: "pageInfo",
							timestamp: data.timestamp
						});

						pdfDocument.getOutline().then(function(outline) {
							if (pdfDocument !== _this12.pdfDocument) {
								return;
							}

							_this12.pdfOutlineViewer.render({
								outline: outline,
								pdfDocument: pdfDocument
							});
						});
						pdfDocument.getAttachments().then(function(attachments) {
							if (pdfDocument !== _this12.pdfDocument) {
								return;
							}

							_this12.pdfAttachmentViewer.render({
								attachments: attachments
							});
						});
						pdfViewer.optionalContentConfigPromise.then(function(
							optionalContentConfig) {
							if (pdfDocument !== _this12.pdfDocument) {
								return;
							}

							_this12.pdfLayerViewer.render({
								optionalContentConfig: optionalContentConfig,
								pdfDocument: pdfDocument
							});
						});

						if ("requestIdleCallback" in window) {
							var callback = window.requestIdleCallback(function() {
								_this12._collectTelemetry(pdfDocument);

								_this12._idleCallbacks["delete"](callback);
							}, {
								timeout: 1000
							});

							_this12._idleCallbacks.add(callback);
						}
					});

					this._initializePageLabels(pdfDocument);

					this._initializeMetadata(pdfDocument);
				},
				_scriptingDocProperties: function _scriptingDocProperties(pdfDocument) {
					var _this13 = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee12() {
							var _this13$metadata, _this13$metadata2;

							return _regenerator["default"].wrap(function _callee12$(
								_context12) {
								while (1) {
									switch (_context12.prev = _context12.next) {
										case 0:
											if (_this13.documentInfo) {
												_context12.next = 5;
												break;
											}

											_context12.next = 3;
											return new Promise(function(
											resolve) {
												_this13.eventBus._on(
													"metadataloaded",
													resolve, {
														once: true
													});
											});

										case 3:
											if (!(pdfDocument !== _this13
													.pdfDocument)) {
												_context12.next = 5;
												break;
											}

											return _context12.abrupt("return",
												null);

										case 5:
											if (_this13._contentLength) {
												_context12.next = 10;
												break;
											}

											_context12.next = 8;
											return new Promise(function(
											resolve) {
												_this13.eventBus._on(
													"documentloaded",
													resolve, {
														once: true
													});
											});

										case 8:
											if (!(pdfDocument !== _this13
													.pdfDocument)) {
												_context12.next = 10;
												break;
											}

											return _context12.abrupt("return",
												null);

										case 10:
											return _context12.abrupt("return",
												_objectSpread(
												_objectSpread({},
													_this13.documentInfo
													), {}, {
													baseURL: _this13
														.baseUrl,
													filesize: _this13
														._contentLength,
													filename: _this13
														._docFilename,
													metadata: (
															_this13$metadata =
															_this13
															.metadata
															) ===
														null ||
														_this13$metadata ===
														void 0 ?
														void 0 :
														_this13$metadata
														.getRaw(),
													authors: (
															_this13$metadata2 =
															_this13
															.metadata
															) ===
														null ||
														_this13$metadata2 ===
														void 0 ?
														void 0 :
														_this13$metadata2
														.get(
															"dc:creator"
															),
													numPages: _this13
														.pagesCount,
													URL: _this13.url
												}));

										case 11:
										case "end":
											return _context12.stop();
									}
								}
							}, _callee12);
						}))();
				},
				_collectTelemetry: function _collectTelemetry(pdfDocument) {
					var _this14 = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee13() {
							var markInfo, tagged;
							return _regenerator["default"].wrap(function _callee13$(
								_context13) {
								while (1) {
									switch (_context13.prev = _context13.next) {
										case 0:
											_context13.next = 2;
											return _this14.pdfDocument
												.getMarkInfo();

										case 2:
											markInfo = _context13.sent;

											if (!(pdfDocument !== _this14
													.pdfDocument)) {
												_context13.next = 5;
												break;
											}

											return _context13.abrupt("return");

										case 5:
											tagged = (markInfo === null ||
													markInfo === void 0 ?
													void 0 : markInfo.Marked) ||
												false;

											_this14.externalServices
												.reportTelemetry({
													type: "tagged",
													tagged: tagged
												});

										case 7:
										case "end":
											return _context13.stop();
									}
								}
							}, _callee13);
						}))();
				},
				_initializeAutoPrint: function _initializeAutoPrint(pdfDocument,
				openActionPromise) {
					var _this15 = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee14() {
							var _yield$Promise$all, _yield$Promise$all2, openAction,
								javaScript, triggerAutoPrint, _iterator2, _step2, js;

							return _regenerator["default"].wrap(function _callee14$(
								_context14) {
								while (1) {
									switch (_context14.prev = _context14.next) {
										case 0:
											_context14.next = 2;
											return Promise.all([
												openActionPromise, !
												_this15.pdfViewer
												.enableScripting ?
												pdfDocument
												.getJavaScript() : null
											]);

										case 2:
											_yield$Promise$all = _context14
											.sent;
											_yield$Promise$all2 =
												_slicedToArray(
													_yield$Promise$all, 2);
											openAction = _yield$Promise$all2[0];
											javaScript = _yield$Promise$all2[1];

											if (!(pdfDocument !== _this15
													.pdfDocument)) {
												_context14.next = 8;
												break;
											}

											return _context14.abrupt("return");

										case 8:
											triggerAutoPrint = false;

											if ((openAction === null ||
													openAction === void 0 ?
													void 0 : openAction.action
													) === "Print") {
												triggerAutoPrint = true;
											}

											if (!javaScript) {
												_context14.next = 31;
												break;
											}

											javaScript.some(function(js) {
												if (!js) {
													return false;
												}

												console.warn(
													"Warning: JavaScript support is not enabled"
													);

												_this15.fallback(
													_pdfjsLib
													.UNSUPPORTED_FEATURES
													.javaScript);

												return true;
											});

											if (triggerAutoPrint) {
												_context14.next = 31;
												break;
											}

											_iterator2 =
												_createForOfIteratorHelper(
													javaScript);
											_context14.prev = 14;

											_iterator2.s();

										case 16:
											if ((_step2 = _iterator2.n())
												.done) {
												_context14.next = 23;
												break;
											}

											js = _step2.value;

											if (!(js && _ui_utils
													.AutoPrintRegExp.test(js)
													)) {
												_context14.next = 21;
												break;
											}

											triggerAutoPrint = true;
											return _context14.abrupt("break",
												23);

										case 21:
											_context14.next = 16;
											break;

										case 23:
											_context14.next = 28;
											break;

										case 25:
											_context14.prev = 25;
											_context14.t0 = _context14["catch"](
												14);

											_iterator2.e(_context14.t0);

										case 28:
											_context14.prev = 28;

											_iterator2.f();

											return _context14.finish(28);

										case 31:
											if (triggerAutoPrint) {
												_this15.triggerPrinting();
											}

											case 32:
											case "end":
												return _context14.stop();
									}
								}
							}, _callee14, null, [
								[14, 25, 28, 31]
							]);
						}))();
				},
				_initializeMetadata: function _initializeMetadata(pdfDocument) {
					var _this16 = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee15() {
							var _this16$_contentDispo, _this16$_contentLengt;

							var _yield$pdfDocument$ge, info, metadata,
								contentDispositionFilename, contentLength, pdfTitle,
								metadataTitle, versionId, generatorId, producer,
								formType;

							return _regenerator["default"].wrap(function _callee15$(
								_context15) {
								while (1) {
									switch (_context15.prev = _context15.next) {
										case 0:
											_context15.next = 2;
											return pdfDocument.getMetadata();

										case 2:
											_yield$pdfDocument$ge = _context15
												.sent;
											info = _yield$pdfDocument$ge.info;
											metadata = _yield$pdfDocument$ge
												.metadata;
											contentDispositionFilename =
												_yield$pdfDocument$ge
												.contentDispositionFilename;
											contentLength =
												_yield$pdfDocument$ge
												.contentLength;

											if (!(pdfDocument !== _this16
													.pdfDocument)) {
												_context15.next = 9;
												break;
											}

											return _context15.abrupt("return");

										case 9:
											_this16.documentInfo = info;
											_this16.metadata = metadata;
											(_this16$_contentDispo = _this16
												._contentDispositionFilename
												) !== null &&
												_this16$_contentDispo !==
												void 0 ? _this16$_contentDispo :
												_this16
												._contentDispositionFilename =
												contentDispositionFilename;
											(_this16$_contentLengt = _this16
												._contentLength) !== null &&
												_this16$_contentLengt !==
												void 0 ? _this16$_contentLengt :
												_this16._contentLength =
												contentLength;
											console.log("PDF ".concat(
													pdfDocument
													.fingerprints[0], " [")
												.concat(info
													.PDFFormatVersion, " "
													) + "".concat((info
														.Producer || "-")
													.trim(), " / ").concat((
														info.Creator || "-")
													.trim(), "] ") +
												"(PDF.js: ".concat(_pdfjsLib
													.version || "-", ")"));
											pdfTitle = info === null || info ===
												void 0 ? void 0 : info.Title;
											metadataTitle = metadata === null ||
												metadata === void 0 ? void 0 :
												metadata.get("dc:title");

											if (metadataTitle) {
												if (metadataTitle !==
													"Untitled" && !
													/[\uFFF0-\uFFFF]/g.test(
														metadataTitle)) {
													pdfTitle = metadataTitle;
												}
											}

											if (pdfTitle) {
												_this16.setTitle("".concat(
														pdfTitle, " - ")
													.concat(
														contentDispositionFilename ||
														document.title));
											} else if (
												contentDispositionFilename) {
												_this16.setTitle(
													contentDispositionFilename
													);
											}

											if (info.IsXFAPresent && !info
												.IsAcroFormPresent && !
												pdfDocument.isPureXfa) {
												if (pdfDocument.loadingParams
													.enableXfa) {
													console.warn(
														"Warning: XFA Foreground documents are not supported"
														);
												} else {
													console.warn(
														"Warning: XFA support is not enabled"
														);
												}

												_this16.fallback(_pdfjsLib
													.UNSUPPORTED_FEATURES
													.forms);
											} else if ((info
													.IsAcroFormPresent || info
													.IsXFAPresent) && !_this16
												.pdfViewer.renderForms) {
												console.warn(
													"Warning: Interactive form support is not enabled"
													);

												_this16.fallback(_pdfjsLib
													.UNSUPPORTED_FEATURES
													.forms);
											}

											if (info.IsSignaturesPresent) {
												console.warn(
													"Warning: Digital signatures validation is not supported"
													);

												_this16.fallback(_pdfjsLib
													.UNSUPPORTED_FEATURES
													.signatures);
											}

											versionId = "other";

											if (KNOWN_VERSIONS.includes(info
													.PDFFormatVersion)) {
												versionId = "v".concat(info
													.PDFFormatVersion
													.replace(".", "_"));
											}

											generatorId = "other";

											if (info.Producer) {
												producer = info.Producer
													.toLowerCase();
												KNOWN_GENERATORS.some(function(
													generator) {
													if (!producer
														.includes(
															generator)
														) {
														return false;
													}

													generatorId =
														generator
														.replace(
															/[ .-]/g,
															"_");
													return true;
												});
											}

											formType = null;

											if (info.IsXFAPresent) {
												formType = "xfa";
											} else if (info.IsAcroFormPresent) {
												formType = "acroform";
											}

											_this16.externalServices
												.reportTelemetry({
													type: "documentInfo",
													version: versionId,
													generator: generatorId,
													formType: formType
												});

											_this16.eventBus.dispatch(
												"metadataloaded", {
													source: _this16
												});

										case 28:
										case "end":
											return _context15.stop();
									}
								}
							}, _callee15);
						}))();
				},
				_initializePageLabels: function _initializePageLabels(pdfDocument) {
					var _this17 = this;

					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee16() {
							var labels, numLabels, standardLabels, emptyLabels, i,
								label, pdfViewer, pdfThumbnailViewer, toolbar;
							return _regenerator["default"].wrap(function _callee16$(
								_context16) {
								while (1) {
									switch (_context16.prev = _context16.next) {
										case 0:
											_context16.next = 2;
											return pdfDocument.getPageLabels();

										case 2:
											labels = _context16.sent;

											if (!(pdfDocument !== _this17
													.pdfDocument)) {
												_context16.next = 5;
												break;
											}

											return _context16.abrupt("return");

										case 5:
											if (!(!labels || _app_options
													.AppOptions.get(
														"disablePageLabels"))) {
												_context16.next = 7;
												break;
											}

											return _context16.abrupt("return");

										case 7:
											numLabels = labels.length;
											standardLabels = 0, emptyLabels = 0;
											i = 0;

										case 10:
											if (!(i < numLabels)) {
												_context16.next = 24;
												break;
											}

											label = labels[i];

											if (!(label === (i + 1)
											.toString())) {
												_context16.next = 16;
												break;
											}

											standardLabels++;
											_context16.next = 21;
											break;

										case 16:
											if (!(label === "")) {
												_context16.next = 20;
												break;
											}

											emptyLabels++;
											_context16.next = 21;
											break;

										case 20:
											return _context16.abrupt("break",
												24);

										case 21:
											i++;
											_context16.next = 10;
											break;

										case 24:
											if (!(standardLabels >= numLabels ||
													emptyLabels >= numLabels)) {
												_context16.next = 26;
												break;
											}

											return _context16.abrupt("return");

										case 26:
											pdfViewer = _this17.pdfViewer,
												pdfThumbnailViewer = _this17
												.pdfThumbnailViewer, toolbar =
												_this17.toolbar;
											pdfViewer.setPageLabels(labels);
											pdfThumbnailViewer.setPageLabels(
												labels);
											toolbar.setPagesCount(numLabels,
												true);
											toolbar.setPageNumber(pdfViewer
												.currentPageNumber,
												pdfViewer.currentPageLabel);

										case 31:
										case "end":
											return _context16.stop();
									}
								}
							}, _callee16);
						}))();
				},
				_initializePdfHistory: function _initializePdfHistory(_ref8) {
					var fingerprint = _ref8.fingerprint,
						viewOnLoad = _ref8.viewOnLoad,
						_ref8$initialDest = _ref8.initialDest,
						initialDest = _ref8$initialDest === void 0 ? null : _ref8$initialDest;

					if (!this.pdfHistory) {
						return;
					}

					this.pdfHistory.initialize({
						fingerprint: fingerprint,
						resetHistory: viewOnLoad === ViewOnLoad.INITIAL,
						updateUrl: _app_options.AppOptions.get("historyUpdateUrl")
					});

					if (this.pdfHistory.initialBookmark) {
						this.initialBookmark = this.pdfHistory.initialBookmark;
						this.initialRotation = this.pdfHistory.initialRotation;
					}

					if (initialDest && !this.initialBookmark && viewOnLoad === ViewOnLoad
						.UNKNOWN) {
						this.initialBookmark = JSON.stringify(initialDest);
						this.pdfHistory.push({
							explicitDest: initialDest,
							pageNumber: null
						});
					}
				},
				_initializeAnnotationStorageCallbacks: function _initializeAnnotationStorageCallbacks(
					pdfDocument) {
					var _this18 = this;

					if (pdfDocument !== this.pdfDocument) {
						return;
					}

					var annotationStorage = pdfDocument.annotationStorage;

					annotationStorage.onSetModified = function() {
						window.addEventListener("beforeunload", beforeUnload);
						_this18._annotationStorageModified = true;
					};

					annotationStorage.onResetModified = function() {
						window.removeEventListener("beforeunload", beforeUnload);
						delete _this18._annotationStorageModified;
					};
				},
				setInitialView: function setInitialView(storedHash) {
					var _this19 = this;

					var _ref9 = arguments.length > 1 && arguments[1] !== undefined ? arguments[
							1] : {},
						rotation = _ref9.rotation,
						sidebarView = _ref9.sidebarView,
						scrollMode = _ref9.scrollMode,
						spreadMode = _ref9.spreadMode;

					var setRotation = function setRotation(angle) {
						if ((0, _ui_utils.isValidRotation)(angle)) {
							_this19.pdfViewer.pagesRotation = angle;
						}
					};

					var setViewerModes = function setViewerModes(scroll, spread) {
						if ((0, _ui_utils.isValidScrollMode)(scroll)) {
							_this19.pdfViewer.scrollMode = scroll;
						}

						if ((0, _ui_utils.isValidSpreadMode)(spread)) {
							_this19.pdfViewer.spreadMode = spread;
						}
					};

					this.isInitialViewSet = true;
					this.pdfSidebar.setInitialView(sidebarView);
					setViewerModes(scrollMode, spreadMode);

					if (this.initialBookmark) {
						setRotation(this.initialRotation);
						delete this.initialRotation;
						this.pdfLinkService.setHash(this.initialBookmark);
						this.initialBookmark = null;
					} else if (storedHash) {
						setRotation(rotation);
						this.pdfLinkService.setHash(storedHash);
					}

					this.toolbar.setPageNumber(this.pdfViewer.currentPageNumber, this.pdfViewer
						.currentPageLabel);
					this.secondaryToolbar.setPageNumber(this.pdfViewer.currentPageNumber);

					if (!this.pdfViewer.currentScaleValue) {
						this.pdfViewer.currentScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
					}
				},
				_cleanup: function _cleanup() {
					if (!this.pdfDocument) {
						return;
					}

					this.pdfViewer.cleanup();
					this.pdfThumbnailViewer.cleanup();
					this.pdfDocument.cleanup(this.pdfViewer.renderer === _ui_utils.RendererType
						.SVG);
				},
				forceRendering: function forceRendering() {
					this.pdfRenderingQueue.printing = !!this.printService;
					this.pdfRenderingQueue.isThumbnailViewEnabled = this.pdfSidebar
						.isThumbnailViewVisible;
					this.pdfRenderingQueue.renderHighestPriority();
				},
				beforePrint: function beforePrint() {
					var _this20 = this;

					this.pdfScriptingManager.dispatchWillPrint();

					if (this.printService) {
						return;
					}

					if (!this.supportsPrinting) {
						this.l10n.get("printing_not_supported").then(function(msg) {
							_this20._otherError(msg);
						});
						return;
					}

					if (!this.pdfViewer.pageViewsReady) {
						this.l10n.get("printing_not_ready").then(function(msg) {
							window.alert(msg);
						});
						return;
					}

					var pagesOverview = this.pdfViewer.getPagesOverview();
					var printContainer = this.appConfig.printContainer;

					var printResolution = _app_options.AppOptions.get("printResolution");

					var optionalContentConfigPromise = this.pdfViewer
						.optionalContentConfigPromise;
					var printService = PDFPrintServiceFactory.instance.createPrintService(this
						.pdfDocument, pagesOverview, printContainer, printResolution,
						optionalContentConfigPromise, this.l10n);
					this.printService = printService;
					this.forceRendering();
					printService.layout();
					this.externalServices.reportTelemetry({
						type: "print"
					});
				},
				afterPrint: function afterPrint() {
					this.pdfScriptingManager.dispatchDidPrint();

					if (this.printService) {
						var _this$pdfDocument2;

						this.printService.destroy();
						this.printService = null;
						(_this$pdfDocument2 = this.pdfDocument) === null ||
							_this$pdfDocument2 === void 0 ? void 0 : _this$pdfDocument2
							.annotationStorage.resetModified();
					}

					this.forceRendering();
				},
				rotatePages: function rotatePages(delta) {
					this.pdfViewer.pagesRotation += delta;
				},
				requestPresentationMode: function requestPresentationMode() {
					var _this$pdfPresentation;

					(_this$pdfPresentation = this.pdfPresentationMode) === null ||
						_this$pdfPresentation === void 0 ? void 0 : _this$pdfPresentation
						.request();
				},
				triggerPrinting: function triggerPrinting() {
					if (!this.supportsPrinting) {
						return;
					}

					window.print();
				},
				bindEvents: function bindEvents() {
					var eventBus = this.eventBus,
						_boundEvents = this._boundEvents;
					_boundEvents.beforePrint = this.beforePrint.bind(this);
					_boundEvents.afterPrint = this.afterPrint.bind(this);

					eventBus._on("resize", webViewerResize);

					eventBus._on("hashchange", webViewerHashchange);

					eventBus._on("beforeprint", _boundEvents.beforePrint);

					eventBus._on("afterprint", _boundEvents.afterPrint);

					eventBus._on("pagerendered", webViewerPageRendered);

					eventBus._on("updateviewarea", webViewerUpdateViewarea);

					eventBus._on("pagechanging", webViewerPageChanging);

					eventBus._on("scalechanging", webViewerScaleChanging);

					eventBus._on("rotationchanging", webViewerRotationChanging);

					eventBus._on("sidebarviewchanged", webViewerSidebarViewChanged);

					eventBus._on("pagemode", webViewerPageMode);

					eventBus._on("namedaction", webViewerNamedAction);

					eventBus._on("presentationmodechanged", webViewerPresentationModeChanged);

					eventBus._on("presentationmode", webViewerPresentationMode);

					eventBus._on("print", webViewerPrint);

					eventBus._on("download", webViewerDownload);

					eventBus._on("save", webViewerSave);

					eventBus._on("firstpage", webViewerFirstPage);

					eventBus._on("lastpage", webViewerLastPage);

					eventBus._on("nextpage", webViewerNextPage);

					eventBus._on("previouspage", webViewerPreviousPage);

					eventBus._on("zoomin", webViewerZoomIn);

					eventBus._on("zoomout", webViewerZoomOut);

					eventBus._on("zoomreset", webViewerZoomReset);

					eventBus._on("pagenumberchanged", webViewerPageNumberChanged);

					eventBus._on("scalechanged", webViewerScaleChanged);

					eventBus._on("rotatecw", webViewerRotateCw);

					eventBus._on("rotateccw", webViewerRotateCcw);

					eventBus._on("optionalcontentconfig", webViewerOptionalContentConfig);

					eventBus._on("switchscrollmode", webViewerSwitchScrollMode);

					eventBus._on("scrollmodechanged", webViewerScrollModeChanged);

					eventBus._on("switchspreadmode", webViewerSwitchSpreadMode);

					eventBus._on("spreadmodechanged", webViewerSpreadModeChanged);

					eventBus._on("documentproperties", webViewerDocumentProperties);

					eventBus._on("findfromurlhash", webViewerFindFromUrlHash);

					eventBus._on("updatefindmatchescount", webViewerUpdateFindMatchesCount);

					eventBus._on("updatefindcontrolstate", webViewerUpdateFindControlState);

					if (_app_options.AppOptions.get("pdfBug")) {
						_boundEvents.reportPageStatsPDFBug = reportPageStatsPDFBug;

						eventBus._on("pagerendered", _boundEvents.reportPageStatsPDFBug);

						eventBus._on("pagechanging", _boundEvents.reportPageStatsPDFBug);
					}

					eventBus._on("fileinputchange", webViewerFileInputChange);

					eventBus._on("openfile", webViewerOpenFile);
				},
				bindWindowEvents: function bindWindowEvents() {
					var eventBus = this.eventBus,
						_boundEvents = this._boundEvents;

					_boundEvents.windowResize = function() {
						eventBus.dispatch("resize", {
							source: window
						});
					};

					_boundEvents.windowHashChange = function() {
						eventBus.dispatch("hashchange", {
							source: window,
							hash: document.location.hash.substring(1)
						});
					};

					_boundEvents.windowBeforePrint = function() {
						eventBus.dispatch("beforeprint", {
							source: window
						});
					};

					_boundEvents.windowAfterPrint = function() {
						eventBus.dispatch("afterprint", {
							source: window
						});
					};

					_boundEvents.windowUpdateFromSandbox = function(event) {
						eventBus.dispatch("updatefromsandbox", {
							source: window,
							detail: event.detail
						});
					};

					window.addEventListener("visibilitychange", webViewerVisibilityChange);
					window.addEventListener("wheel", webViewerWheel, {
						passive: false
					});
					window.addEventListener("touchstart", webViewerTouchStart, {
						passive: false
					});
					window.addEventListener("click", webViewerClick);
					window.addEventListener("keydown", webViewerKeyDown);
					window.addEventListener("resize", _boundEvents.windowResize);
					window.addEventListener("hashchange", _boundEvents.windowHashChange);
					window.addEventListener("beforeprint", _boundEvents.windowBeforePrint);
					window.addEventListener("afterprint", _boundEvents.windowAfterPrint);
					window.addEventListener("updatefromsandbox", _boundEvents
						.windowUpdateFromSandbox);
				},
				unbindEvents: function unbindEvents() {
					var eventBus = this.eventBus,
						_boundEvents = this._boundEvents;

					eventBus._off("resize", webViewerResize);

					eventBus._off("hashchange", webViewerHashchange);

					eventBus._off("beforeprint", _boundEvents.beforePrint);

					eventBus._off("afterprint", _boundEvents.afterPrint);

					eventBus._off("pagerendered", webViewerPageRendered);

					eventBus._off("updateviewarea", webViewerUpdateViewarea);

					eventBus._off("pagechanging", webViewerPageChanging);

					eventBus._off("scalechanging", webViewerScaleChanging);

					eventBus._off("rotationchanging", webViewerRotationChanging);

					eventBus._off("sidebarviewchanged", webViewerSidebarViewChanged);

					eventBus._off("pagemode", webViewerPageMode);

					eventBus._off("namedaction", webViewerNamedAction);

					eventBus._off("presentationmodechanged", webViewerPresentationModeChanged);

					eventBus._off("presentationmode", webViewerPresentationMode);

					eventBus._off("print", webViewerPrint);

					eventBus._off("download", webViewerDownload);

					eventBus._off("save", webViewerSave);

					eventBus._off("firstpage", webViewerFirstPage);

					eventBus._off("lastpage", webViewerLastPage);

					eventBus._off("nextpage", webViewerNextPage);

					eventBus._off("previouspage", webViewerPreviousPage);

					eventBus._off("zoomin", webViewerZoomIn);

					eventBus._off("zoomout", webViewerZoomOut);

					eventBus._off("zoomreset", webViewerZoomReset);

					eventBus._off("pagenumberchanged", webViewerPageNumberChanged);

					eventBus._off("scalechanged", webViewerScaleChanged);

					eventBus._off("rotatecw", webViewerRotateCw);

					eventBus._off("rotateccw", webViewerRotateCcw);

					eventBus._off("optionalcontentconfig", webViewerOptionalContentConfig);

					eventBus._off("switchscrollmode", webViewerSwitchScrollMode);

					eventBus._off("scrollmodechanged", webViewerScrollModeChanged);

					eventBus._off("switchspreadmode", webViewerSwitchSpreadMode);

					eventBus._off("spreadmodechanged", webViewerSpreadModeChanged);

					eventBus._off("documentproperties", webViewerDocumentProperties);

					eventBus._off("findfromurlhash", webViewerFindFromUrlHash);

					eventBus._off("updatefindmatchescount", webViewerUpdateFindMatchesCount);

					eventBus._off("updatefindcontrolstate", webViewerUpdateFindControlState);

					if (_boundEvents.reportPageStatsPDFBug) {
						eventBus._off("pagerendered", _boundEvents.reportPageStatsPDFBug);

						eventBus._off("pagechanging", _boundEvents.reportPageStatsPDFBug);

						_boundEvents.reportPageStatsPDFBug = null;
					}

					eventBus._off("fileinputchange", webViewerFileInputChange);

					eventBus._off("openfile", webViewerOpenFile);

					_boundEvents.beforePrint = null;
					_boundEvents.afterPrint = null;
				},
				unbindWindowEvents: function unbindWindowEvents() {
					var _boundEvents = this._boundEvents;
					window.removeEventListener("visibilitychange", webViewerVisibilityChange);
					window.removeEventListener("wheel", webViewerWheel, {
						passive: false
					});
					window.removeEventListener("touchstart", webViewerTouchStart, {
						passive: false
					});
					window.removeEventListener("click", webViewerClick);
					window.removeEventListener("keydown", webViewerKeyDown);
					window.removeEventListener("resize", _boundEvents.windowResize);
					window.removeEventListener("hashchange", _boundEvents.windowHashChange);
					window.removeEventListener("beforeprint", _boundEvents.windowBeforePrint);
					window.removeEventListener("afterprint", _boundEvents.windowAfterPrint);
					window.removeEventListener("updatefromsandbox", _boundEvents
						.windowUpdateFromSandbox);
					_boundEvents.windowResize = null;
					_boundEvents.windowHashChange = null;
					_boundEvents.windowBeforePrint = null;
					_boundEvents.windowAfterPrint = null;
					_boundEvents.windowUpdateFromSandbox = null;
				},
				accumulateWheelTicks: function accumulateWheelTicks(ticks) {
					if (this._wheelUnusedTicks > 0 && ticks < 0 || this._wheelUnusedTicks < 0 &&
						ticks > 0) {
						this._wheelUnusedTicks = 0;
					}

					this._wheelUnusedTicks += ticks;
					var wholeTicks = Math.sign(this._wheelUnusedTicks) * Math.floor(Math.abs(
						this._wheelUnusedTicks));
					this._wheelUnusedTicks -= wholeTicks;
					return wholeTicks;
				},
				_unblockDocumentLoadEvent: function _unblockDocumentLoadEvent() {
					if (document.blockUnblockOnload) {
						document.blockUnblockOnload(false);
					}

					this._unblockDocumentLoadEvent = function() {};
				},
				_reportDocumentStatsTelemetry: function _reportDocumentStatsTelemetry() {
					var stats = this.pdfDocument.stats;

					if (stats !== this._docStats) {
						this._docStats = stats;
						this.externalServices.reportTelemetry({
							type: "documentStats",
							stats: stats
						});
					}
				},

				get scriptingReady() {
					return this.pdfScriptingManager.ready;
				}

			};
			exports.PDFViewerApplication = PDFViewerApplication;
			var validateFileURL; {
				var HOSTED_VIEWER_ORIGINS = ["null", "http://mozilla.github.io",
					"https://mozilla.github.io"
				];

				validateFileURL = function validateFileURL(file) {
					if (file === undefined) {
						return;
					}

					try {
						var viewerOrigin = new URL(window.location.href).origin || "null";

						if (HOSTED_VIEWER_ORIGINS.includes(viewerOrigin)) {
							return;
						}

						var fileOrigin = new URL(file, window.location.href).origin;

						if (fileOrigin !== viewerOrigin) {
							throw new Error("file origin does not match viewer's");
						}
					} catch (ex) {
						PDFViewerApplication.l10n.get("loading_error").then(function(msg) {
							PDFViewerApplication._documentError(msg, {
								message: ex === null || ex === void 0 ? void 0 : ex
									.message
							});
						});
						throw ex;
					}
				};
			}

			function loadFakeWorker() {
				return _loadFakeWorker.apply(this, arguments);
			}

			function _loadFakeWorker() {
				_loadFakeWorker = _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
					function _callee17() {
						return _regenerator["default"].wrap(function _callee17$(_context17) {
							while (1) {
								switch (_context17.prev = _context17.next) {
									case 0:
										if (!_pdfjsLib.GlobalWorkerOptions.workerSrc) {
											_pdfjsLib.GlobalWorkerOptions.workerSrc =
												_app_options.AppOptions.get(
												"workerSrc");
										}

										_context17.next = 3;
										return (0, _pdfjsLib.loadScript)(_pdfjsLib
											.PDFWorker.workerSrc);

									case 3:
									case "end":
										return _context17.stop();
								}
							}
						}, _callee17);
					}));
				return _loadFakeWorker.apply(this, arguments);
			}

			function initPDFBug(_x3) {
				return _initPDFBug.apply(this, arguments);
			}

			function _initPDFBug() {
				_initPDFBug = _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
					function _callee18(enabledTabs) {
						var _PDFViewerApplication7, debuggerScriptPath, mainContainer;

						return _regenerator["default"].wrap(function _callee18$(_context18) {
							while (1) {
								switch (_context18.prev = _context18.next) {
									case 0:
										_PDFViewerApplication7 = PDFViewerApplication
											.appConfig, debuggerScriptPath =
											_PDFViewerApplication7.debuggerScriptPath,
											mainContainer = _PDFViewerApplication7
											.mainContainer;
										_context18.next = 3;
										return (0, _pdfjsLib.loadScript)(
											debuggerScriptPath);

									case 3:
										PDFBug.init({
											OPS: _pdfjsLib.OPS
										}, mainContainer, enabledTabs);

									case 4:
									case "end":
										return _context18.stop();
								}
							}
						}, _callee18);
					}));
				return _initPDFBug.apply(this, arguments);
			}

			function reportPageStatsPDFBug(_ref10) {
				var _pageView$pdfPage;

				var pageNumber = _ref10.pageNumber;

				if (typeof Stats === "undefined" || !Stats.enabled) {
					return;
				}

				var pageView = PDFViewerApplication.pdfViewer.getPageView(pageNumber - 1);
				var pageStats = pageView === null || pageView === void 0 ? void 0 : (_pageView$pdfPage =
						pageView.pdfPage) === null || _pageView$pdfPage === void 0 ? void 0 :
					_pageView$pdfPage.stats;

				if (!pageStats) {
					return;
				}

				Stats.add(pageNumber, pageStats);
			}

			function webViewerInitialized() {
				var _params$get;

				var appConfig = PDFViewerApplication.appConfig;
				var file;
				var queryString = document.location.search.substring(1);
				var params = (0, _ui_utils.parseQueryString)(queryString);
				file = (_params$get = params.get("file")) !== null && _params$get !== void 0 ?
					_params$get : _app_options.AppOptions.get("defaultUrl");
				validateFileURL(file);
				var fileInput = document.createElement("input");
				fileInput.id = appConfig.openFileInputName;
				fileInput.className = "fileInput";
				fileInput.setAttribute("type", "file");
				fileInput.oncontextmenu = _ui_utils.noContextMenuHandler;
				document.body.appendChild(fileInput);

				if (!window.File || !window.FileReader || !window.FileList || !window.Blob) {
					appConfig.toolbar.openFile.hidden = true;
					appConfig.secondaryToolbar.openFileButton.hidden = true;
				} else {
					fileInput.value = null;
				}

				fileInput.addEventListener("change", function(evt) {
					var files = evt.target.files;

					if (!files || files.length === 0) {
						return;
					}

					PDFViewerApplication.eventBus.dispatch("fileinputchange", {
						source: this,
						fileInput: evt.target
					});
				});
				appConfig.mainContainer.addEventListener("dragover", function(evt) {
					evt.preventDefault();
					evt.dataTransfer.dropEffect = "move";
				});
				appConfig.mainContainer.addEventListener("drop", function(evt) {
					evt.preventDefault();
					var files = evt.dataTransfer.files;

					if (!files || files.length === 0) {
						return;
					}

					PDFViewerApplication.eventBus.dispatch("fileinputchange", {
						source: this,
						fileInput: evt.dataTransfer
					});
				});

				if (!PDFViewerApplication.supportsDocumentFonts) {
					_app_options.AppOptions.set("disableFontFace", true);

					PDFViewerApplication.l10n.get("web_fonts_disabled").then(function(msg) {
						console.warn(msg);
					});
				}

				if (!PDFViewerApplication.supportsPrinting) {
					appConfig.toolbar.print.classList.add("hidden");
					appConfig.secondaryToolbar.printButton.classList.add("hidden");
				}

				if (!PDFViewerApplication.supportsFullscreen) {
					appConfig.toolbar.presentationModeButton.classList.add("hidden");
					appConfig.secondaryToolbar.presentationModeButton.classList.add("hidden");
				}

				if (PDFViewerApplication.supportsIntegratedFind) {
					appConfig.toolbar.viewFind.classList.add("hidden");
				}

				appConfig.mainContainer.addEventListener("transitionend", function(evt) {
					if (evt.target === this) {
						PDFViewerApplication.eventBus.dispatch("resize", {
							source: this
						});
					}
				}, true);

				try {
					webViewerOpenFileViaURL(file);
				} catch (reason) {
					PDFViewerApplication.l10n.get("loading_error").then(function(msg) {
						PDFViewerApplication._documentError(msg, reason);
					});
				}
			}

			function webViewerOpenFileViaURL(file) {
				if (file) {
					PDFViewerApplication.open(file);
				} else {
					PDFViewerApplication._hideViewBookmark();
				}
			}

			function webViewerPageRendered(_ref11) {
				var pageNumber = _ref11.pageNumber,
					error = _ref11.error;

				if (pageNumber === PDFViewerApplication.page) {
					PDFViewerApplication.toolbar.updateLoadingIndicatorState(false);
				}

				if (PDFViewerApplication.pdfSidebar.isThumbnailViewVisible) {
					var pageView = PDFViewerApplication.pdfViewer.getPageView(pageNumber - 1);
					var thumbnailView = PDFViewerApplication.pdfThumbnailViewer.getThumbnail(
						pageNumber - 1);

					if (pageView && thumbnailView) {
						thumbnailView.setImage(pageView);
					}
				}

				if (error) {
					PDFViewerApplication.l10n.get("rendering_error").then(function(msg) {
						PDFViewerApplication._otherError(msg, error);
					});
				}

				PDFViewerApplication._reportDocumentStatsTelemetry();
			}

			function webViewerPageMode(_ref12) {
				var mode = _ref12.mode;
				var view;

				switch (mode) {
					case "thumbs":
						view = _ui_utils.SidebarView.THUMBS;
						break;

					case "bookmarks":
					case "outline":
						view = _ui_utils.SidebarView.OUTLINE;
						break;

					case "attachments":
						view = _ui_utils.SidebarView.ATTACHMENTS;
						break;

					case "layers":
						view = _ui_utils.SidebarView.LAYERS;
						break;

					case "none":
						view = _ui_utils.SidebarView.NONE;
						break;

					default:
						console.error('Invalid "pagemode" hash parameter: ' + mode);
						return;
				}

				PDFViewerApplication.pdfSidebar.switchView(view, true);
			}

			function webViewerNamedAction(evt) {
				switch (evt.action) {
					case "GoToPage":
						PDFViewerApplication.appConfig.toolbar.pageNumber.select();
						break;

					case "Find":
						if (!PDFViewerApplication.supportsIntegratedFind) {
							PDFViewerApplication.findBar.toggle();
						}

						break;

					case "Print":
						PDFViewerApplication.triggerPrinting();
						break;

					case "SaveAs":
						webViewerSave();
						break;
				}
			}

			function webViewerPresentationModeChanged(evt) {
				PDFViewerApplication.pdfViewer.presentationModeState = evt.state;
			}

			function webViewerSidebarViewChanged(evt) {
				PDFViewerApplication.pdfRenderingQueue.isThumbnailViewEnabled = PDFViewerApplication
					.pdfSidebar.isThumbnailViewVisible;

				if (PDFViewerApplication.isInitialViewSet) {
					var _PDFViewerApplication;

					(_PDFViewerApplication = PDFViewerApplication.store) === null ||
						_PDFViewerApplication === void 0 ? void 0 : _PDFViewerApplication.set(
							"sidebarView", evt.view)["catch"](function() {});
				}
			}

			function webViewerUpdateViewarea(evt) {
				var location = evt.location;

				if (PDFViewerApplication.isInitialViewSet) {
					var _PDFViewerApplication2;

					(_PDFViewerApplication2 = PDFViewerApplication.store) === null ||
						_PDFViewerApplication2 === void 0 ? void 0 : _PDFViewerApplication2
					.setMultiple({
							page: location.pageNumber,
							zoom: location.scale,
							scrollLeft: location.left,
							scrollTop: location.top,
							rotation: location.rotation
						})["catch"](function() {});
				}

				var href = PDFViewerApplication.pdfLinkService.getAnchorUrl(location.pdfOpenParams);
				PDFViewerApplication.appConfig.toolbar.viewBookmark.href = href;
				PDFViewerApplication.appConfig.secondaryToolbar.viewBookmarkButton.href = href;
				var currentPage = PDFViewerApplication.pdfViewer.getPageView(PDFViewerApplication.page -
					1);
				var loading = (currentPage === null || currentPage === void 0 ? void 0 : currentPage
					.renderingState) !== _ui_utils.RenderingStates.FINISHED;
				PDFViewerApplication.toolbar.updateLoadingIndicatorState(loading);
			}

			function webViewerScrollModeChanged(evt) {
				if (PDFViewerApplication.isInitialViewSet) {
					var _PDFViewerApplication3;

					(_PDFViewerApplication3 = PDFViewerApplication.store) === null ||
						_PDFViewerApplication3 === void 0 ? void 0 : _PDFViewerApplication3.set(
							"scrollMode", evt.mode)["catch"](function() {});
				}
			}

			function webViewerSpreadModeChanged(evt) {
				if (PDFViewerApplication.isInitialViewSet) {
					var _PDFViewerApplication4;

					(_PDFViewerApplication4 = PDFViewerApplication.store) === null ||
						_PDFViewerApplication4 === void 0 ? void 0 : _PDFViewerApplication4.set(
							"spreadMode", evt.mode)["catch"](function() {});
				}
			}

			function webViewerResize() {
				var pdfDocument = PDFViewerApplication.pdfDocument,
					pdfViewer = PDFViewerApplication.pdfViewer;

				if (!pdfDocument) {
					return;
				}

				var currentScaleValue = pdfViewer.currentScaleValue;

				if (currentScaleValue === "auto" || currentScaleValue === "page-fit" ||
					currentScaleValue === "page-width") {
					pdfViewer.currentScaleValue = currentScaleValue;
				}

				pdfViewer.update();
			}

			function webViewerHashchange(evt) {
				var _PDFViewerApplication5;

				var hash = evt.hash;

				if (!hash) {
					return;
				}

				if (!PDFViewerApplication.isInitialViewSet) {
					PDFViewerApplication.initialBookmark = hash;
				} else if (!((_PDFViewerApplication5 = PDFViewerApplication.pdfHistory) !== null &&
						_PDFViewerApplication5 !== void 0 && _PDFViewerApplication5.popStateInProgress
						)) {
					PDFViewerApplication.pdfLinkService.setHash(hash);
				}
			}

			var webViewerFileInputChange, webViewerOpenFile; {
				webViewerFileInputChange = function webViewerFileInputChange(evt) {
					var _PDFViewerApplication6;

					if ((_PDFViewerApplication6 = PDFViewerApplication.pdfViewer) !== null &&
						_PDFViewerApplication6 !== void 0 && _PDFViewerApplication6
						.isInPresentationMode) {
						return;
					}

					var file = evt.fileInput.files[0];
					var url = URL.createObjectURL(file);

					if (file.name) {
						url = {
							url: url,
							originalUrl: file.name
						};
					}

					PDFViewerApplication.open(url);
				};

				webViewerOpenFile = function webViewerOpenFile(evt) {
					var openFileInputName = PDFViewerApplication.appConfig.openFileInputName;
					document.getElementById(openFileInputName).click();
				};
			}

			function webViewerPresentationMode() {
				PDFViewerApplication.requestPresentationMode();
			}

			function webViewerPrint() {
				PDFViewerApplication.triggerPrinting();
			}

			function webViewerDownload() {
				PDFViewerApplication.downloadOrSave({
					sourceEventType: "download"
				});
			}

			function webViewerSave() {
				PDFViewerApplication.downloadOrSave({
					sourceEventType: "save"
				});
			}

			function webViewerFirstPage() {
				if (PDFViewerApplication.pdfDocument) {
					PDFViewerApplication.page = 1;
				}
			}

			function webViewerLastPage() {
				if (PDFViewerApplication.pdfDocument) {
					PDFViewerApplication.page = PDFViewerApplication.pagesCount;
				}
			}

			function webViewerNextPage() {
				PDFViewerApplication.pdfViewer.nextPage();
			}

			function webViewerPreviousPage() {
				PDFViewerApplication.pdfViewer.previousPage();
			}

			function webViewerZoomIn() {
				PDFViewerApplication.zoomIn();
			}

			function webViewerZoomOut() {
				PDFViewerApplication.zoomOut();
			}

			function webViewerZoomReset() {
				PDFViewerApplication.zoomReset();
			}

			function webViewerPageNumberChanged(evt) {
				var pdfViewer = PDFViewerApplication.pdfViewer;

				if (evt.value !== "") {
					PDFViewerApplication.pdfLinkService.goToPage(evt.value);
				}

				if (evt.value !== pdfViewer.currentPageNumber.toString() && evt.value !== pdfViewer
					.currentPageLabel) {
					PDFViewerApplication.toolbar.setPageNumber(pdfViewer.currentPageNumber, pdfViewer
						.currentPageLabel);
				}
			}

			function webViewerScaleChanged(evt) {
				PDFViewerApplication.pdfViewer.currentScaleValue = evt.value;
			}

			function webViewerRotateCw() {
				PDFViewerApplication.rotatePages(90);
			}

			function webViewerRotateCcw() {
				PDFViewerApplication.rotatePages(-90);
			}

			function webViewerOptionalContentConfig(evt) {
				PDFViewerApplication.pdfViewer.optionalContentConfigPromise = evt.promise;
			}

			function webViewerSwitchScrollMode(evt) {
				PDFViewerApplication.pdfViewer.scrollMode = evt.mode;
			}

			function webViewerSwitchSpreadMode(evt) {
				PDFViewerApplication.pdfViewer.spreadMode = evt.mode;
			}

			function webViewerDocumentProperties() {
				PDFViewerApplication.pdfDocumentProperties.open();
			}

			function webViewerFindFromUrlHash(evt) {
				PDFViewerApplication.eventBus.dispatch("find", {
					source: evt.source,
					type: "",
					query: evt.query,
					phraseSearch: evt.phraseSearch,
					caseSensitive: false,
					entireWord: false,
					highlightAll: true,
					findPrevious: false,
					matchDiacritics: true
				});
			}

			function webViewerUpdateFindMatchesCount(_ref13) {
				var matchesCount = _ref13.matchesCount;

				if (PDFViewerApplication.supportsIntegratedFind) {
					PDFViewerApplication.externalServices.updateFindMatchesCount(matchesCount);
				} else {
					PDFViewerApplication.findBar.updateResultsCount(matchesCount);
				}
			}

			function webViewerUpdateFindControlState(_ref14) {
				var state = _ref14.state,
					previous = _ref14.previous,
					matchesCount = _ref14.matchesCount,
					rawQuery = _ref14.rawQuery;

				if (PDFViewerApplication.supportsIntegratedFind) {
					PDFViewerApplication.externalServices.updateFindControlState({
						result: state,
						findPrevious: previous,
						matchesCount: matchesCount,
						rawQuery: rawQuery
					});
				} else {
					PDFViewerApplication.findBar.updateUIState(state, previous, matchesCount);
				}
			}

			function webViewerScaleChanging(evt) {
				PDFViewerApplication.toolbar.setPageScale(evt.presetValue, evt.scale);
				PDFViewerApplication.pdfViewer.update();
			}

			function webViewerRotationChanging(evt) {
				PDFViewerApplication.pdfThumbnailViewer.pagesRotation = evt.pagesRotation;
				PDFViewerApplication.forceRendering();
				PDFViewerApplication.pdfViewer.currentPageNumber = evt.pageNumber;
			}

			function webViewerPageChanging(_ref15) {
				var pageNumber = _ref15.pageNumber,
					pageLabel = _ref15.pageLabel;
				PDFViewerApplication.toolbar.setPageNumber(pageNumber, pageLabel);
				PDFViewerApplication.secondaryToolbar.setPageNumber(pageNumber);

				if (PDFViewerApplication.pdfSidebar.isThumbnailViewVisible) {
					PDFViewerApplication.pdfThumbnailViewer.scrollThumbnailIntoView(pageNumber);
				}
			}

			function webViewerVisibilityChange(evt) {
				if (document.visibilityState === "visible") {
					setZoomDisabledTimeout();
				}
			}

			var zoomDisabledTimeout = null;

			function setZoomDisabledTimeout() {
				if (zoomDisabledTimeout) {
					clearTimeout(zoomDisabledTimeout);
				}

				zoomDisabledTimeout = setTimeout(function() {
					zoomDisabledTimeout = null;
				}, WHEEL_ZOOM_DISABLED_TIMEOUT);
			}

			function webViewerWheel(evt) {
				var pdfViewer = PDFViewerApplication.pdfViewer,
					supportedMouseWheelZoomModifierKeys = PDFViewerApplication
					.supportedMouseWheelZoomModifierKeys;

				if (pdfViewer.isInPresentationMode) {
					return;
				}

				if (evt.ctrlKey && supportedMouseWheelZoomModifierKeys.ctrlKey || evt.metaKey &&
					supportedMouseWheelZoomModifierKeys.metaKey) {
					evt.preventDefault();

					if (zoomDisabledTimeout || document.visibilityState === "hidden") {
						return;
					}

					var deltaMode = evt.deltaMode;
					var delta = (0, _ui_utils.normalizeWheelEventDirection)(evt);
					var previousScale = pdfViewer.currentScale;
					var ticks = 0;

					if (deltaMode === WheelEvent.DOM_DELTA_LINE || deltaMode === WheelEvent
						.DOM_DELTA_PAGE) {
						if (Math.abs(delta) >= 1) {
							ticks = Math.sign(delta);
						} else {
							ticks = PDFViewerApplication.accumulateWheelTicks(delta);
						}
					} else {
						var PIXELS_PER_LINE_SCALE = 30;
						ticks = PDFViewerApplication.accumulateWheelTicks(delta /
						PIXELS_PER_LINE_SCALE);
					}

					if (ticks < 0) {
						PDFViewerApplication.zoomOut(-ticks);
					} else if (ticks > 0) {
						PDFViewerApplication.zoomIn(ticks);
					}

					var currentScale = pdfViewer.currentScale;

					if (previousScale !== currentScale) {
						var scaleCorrectionFactor = currentScale / previousScale - 1;
						var rect = pdfViewer.container.getBoundingClientRect();
						var dx = evt.clientX - rect.left;
						var dy = evt.clientY - rect.top;
						pdfViewer.container.scrollLeft += dx * scaleCorrectionFactor;
						pdfViewer.container.scrollTop += dy * scaleCorrectionFactor;
					}
				} else {
					setZoomDisabledTimeout();
				}
			}

			function webViewerTouchStart(evt) {
				if (evt.touches.length > 1) {
					evt.preventDefault();
				}
			}

			function webViewerClick(evt) {
				if (!PDFViewerApplication.secondaryToolbar.isOpen) {
					return;
				}

				var appConfig = PDFViewerApplication.appConfig;

				if (PDFViewerApplication.pdfViewer.containsElement(evt.target) || appConfig.toolbar
					.container.contains(evt.target) && evt.target !== appConfig.secondaryToolbar
					.toggleButton) {
					PDFViewerApplication.secondaryToolbar.close();
				}
			}

			function webViewerKeyDown(evt) {
				if (PDFViewerApplication.overlayManager.active) {
					return;
				}

				var eventBus = PDFViewerApplication.eventBus,
					pdfViewer = PDFViewerApplication.pdfViewer;
				var isViewerInPresentationMode = pdfViewer.isInPresentationMode;
				var handled = false,
					ensureViewerFocused = false;
				var cmd = (evt.ctrlKey ? 1 : 0) | (evt.altKey ? 2 : 0) | (evt.shiftKey ? 4 : 0) | (evt
					.metaKey ? 8 : 0);

				if (cmd === 1 || cmd === 8 || cmd === 5 || cmd === 12) {
					switch (evt.keyCode) {
						case 70:
							if (!PDFViewerApplication.supportsIntegratedFind && !evt.shiftKey) {
								PDFViewerApplication.findBar.open();
								handled = true;
							}

							break;

						case 71:
							if (!PDFViewerApplication.supportsIntegratedFind) {
								var state = PDFViewerApplication.findController.state;

								if (state) {
									var eventState = Object.assign(Object.create(null), state, {
										source: window,
										type: "again",
										findPrevious: cmd === 5 || cmd === 12
									});
									eventBus.dispatch("find", eventState);
								}

								handled = true;
							}

							break;

						case 61:
						case 107:
						case 187:
						case 171:
							if (!isViewerInPresentationMode) {
								PDFViewerApplication.zoomIn();
							}

							handled = true;
							break;

						case 173:
						case 109:
						case 189:
							if (!isViewerInPresentationMode) {
								PDFViewerApplication.zoomOut();
							}

							handled = true;
							break;

						case 48:
						case 96:
							if (!isViewerInPresentationMode) {
								setTimeout(function() {
									PDFViewerApplication.zoomReset();
								});
								handled = false;
							}

							break;

						case 38:
							if (isViewerInPresentationMode || PDFViewerApplication.page > 1) {
								PDFViewerApplication.page = 1;
								handled = true;
								ensureViewerFocused = true;
							}

							break;

						case 40:
							if (isViewerInPresentationMode || PDFViewerApplication.page <
								PDFViewerApplication.pagesCount) {
								PDFViewerApplication.page = PDFViewerApplication.pagesCount;
								handled = true;
								ensureViewerFocused = true;
							}

							break;
					}
				}

				if (cmd === 1 || cmd === 8) {
					switch (evt.keyCode) {
						case 83:
							eventBus.dispatch("download", {
								source: window
							});
							handled = true;
							break;

						case 79: {
							eventBus.dispatch("openfile", {
								source: window
							});
							handled = true;
						}
						break;
					}
				}

				if (cmd === 3 || cmd === 10) {
					switch (evt.keyCode) {
						case 80:
							PDFViewerApplication.requestPresentationMode();
							handled = true;
							break;

						case 71:
							PDFViewerApplication.appConfig.toolbar.pageNumber.select();
							handled = true;
							break;
					}
				}

				if (handled) {
					if (ensureViewerFocused && !isViewerInPresentationMode) {
						pdfViewer.focus();
					}

					evt.preventDefault();
					return;
				}

				var curElement = (0, _ui_utils.getActiveOrFocusedElement)();
				var curElementTagName = curElement === null || curElement === void 0 ? void 0 :
					curElement.tagName.toUpperCase();

				if (curElementTagName === "INPUT" || curElementTagName === "TEXTAREA" ||
					curElementTagName === "SELECT" || curElement !== null && curElement !== void 0 &&
					curElement.isContentEditable) {
					if (evt.keyCode !== 27) {
						return;
					}
				}

				if (cmd === 0) {
					var turnPage = 0,
						turnOnlyIfPageFit = false;

					switch (evt.keyCode) {
						case 38:
						case 33:
							if (pdfViewer.isVerticalScrollbarEnabled) {
								turnOnlyIfPageFit = true;
							}

							turnPage = -1;
							break;

						case 8:
							if (!isViewerInPresentationMode) {
								turnOnlyIfPageFit = true;
							}

							turnPage = -1;
							break;

						case 37:
							if (pdfViewer.isHorizontalScrollbarEnabled) {
								turnOnlyIfPageFit = true;
							}

							case 75:
							case 80:
								turnPage = -1;
								break;

							case 27:
								if (PDFViewerApplication.secondaryToolbar.isOpen) {
									PDFViewerApplication.secondaryToolbar.close();
									handled = true;
								}

								if (!PDFViewerApplication.supportsIntegratedFind && PDFViewerApplication
									.findBar.opened) {
									PDFViewerApplication.findBar.close();
									handled = true;
								}

								break;

							case 40:
							case 34:
								if (pdfViewer.isVerticalScrollbarEnabled) {
									turnOnlyIfPageFit = true;
								}

								turnPage = 1;
								break;

							case 13:
							case 32:
								if (!isViewerInPresentationMode) {
									turnOnlyIfPageFit = true;
								}

								turnPage = 1;
								break;

							case 39:
								if (pdfViewer.isHorizontalScrollbarEnabled) {
									turnOnlyIfPageFit = true;
								}

								case 74:
								case 78:
									turnPage = 1;
									break;

								case 36:
									if (isViewerInPresentationMode || PDFViewerApplication.page > 1) {
										PDFViewerApplication.page = 1;
										handled = true;
										ensureViewerFocused = true;
									}

									break;

								case 35:
									if (isViewerInPresentationMode || PDFViewerApplication.page <
										PDFViewerApplication.pagesCount) {
										PDFViewerApplication.page = PDFViewerApplication.pagesCount;
										handled = true;
										ensureViewerFocused = true;
									}

									break;

								case 83:
									PDFViewerApplication.pdfCursorTools.switchTool(_pdf_cursor_tools
										.CursorTool.SELECT);
									break;

								case 72:
									PDFViewerApplication.pdfCursorTools.switchTool(_pdf_cursor_tools
										.CursorTool.HAND);
									break;

								case 82:
									PDFViewerApplication.rotatePages(90);
									break;

								case 115:
									PDFViewerApplication.pdfSidebar.toggle();
									break;
					}

					if (turnPage !== 0 && (!turnOnlyIfPageFit || pdfViewer.currentScaleValue ===
							"page-fit")) {
						if (turnPage > 0) {
							pdfViewer.nextPage();
						} else {
							pdfViewer.previousPage();
						}

						handled = true;
					}
				}

				if (cmd === 4) {
					switch (evt.keyCode) {
						case 13:
						case 32:
							if (!isViewerInPresentationMode && pdfViewer.currentScaleValue !==
								"page-fit") {
								break;
							}

							pdfViewer.previousPage();
							handled = true;
							break;

						case 82:
							PDFViewerApplication.rotatePages(-90);
							break;
					}
				}

				if (!handled && !isViewerInPresentationMode) {
					if (evt.keyCode >= 33 && evt.keyCode <= 40 || evt.keyCode === 32 &&
						curElementTagName !== "BUTTON") {
						ensureViewerFocused = true;
					}
				}

				if (ensureViewerFocused && !pdfViewer.containsElement(curElement)) {
					pdfViewer.focus();
				}

				if (handled) {
					evt.preventDefault();
				}
			}

			function beforeUnload(evt) {
				evt.preventDefault();
				evt.returnValue = "";
				return false;
			}

			var PDFPrintServiceFactory = {
				instance: {
					supportsPrinting: false,
					createPrintService: function createPrintService() {
						throw new Error("Not implemented: createPrintService");
					}
				}
			};
			exports.PDFPrintServiceFactory = PDFPrintServiceFactory;

			/***/
		}),
		/* 3 */
		/***/
		((module, __unused_webpack_exports, __webpack_require__) => {



			module.exports = __webpack_require__(4);

			/***/
		}),
		/* 4 */
		/***/
		((module, __unused_webpack_exports, __webpack_require__) => {

			/* module decorator */
			module = __webpack_require__.nmd(module);


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

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

				var Op = Object.prototype;
				var hasOwn = Op.hasOwnProperty;
				var undefined;
				var $Symbol = typeof Symbol === "function" ? Symbol : {};
				var iteratorSymbol = $Symbol.iterator || "@@iterator";
				var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
				var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";

				function define(obj, key, value) {
					Object.defineProperty(obj, key, {
						value: value,
						enumerable: true,
						configurable: true,
						writable: true
					});
					return obj[key];
				}

				try {
					define({}, "");
				} catch (err) {
					define = function define(obj, key, value) {
						return obj[key] = value;
					};
				}

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

				exports.wrap = wrap;

				function tryCatch(fn, obj, arg) {
					try {
						return {
							type: "normal",
							arg: fn.call(obj, arg)
						};
					} catch (err) {
						return {
							type: "throw",
							arg: err
						};
					}
				}

				var GenStateSuspendedStart = "suspendedStart";
				var GenStateSuspendedYield = "suspendedYield";
				var GenStateExecuting = "executing";
				var GenStateCompleted = "completed";
				var ContinueSentinel = {};

				function Generator() {}

				function GeneratorFunction() {}

				function GeneratorFunctionPrototype() {}

				var IteratorPrototype = {};
				define(IteratorPrototype, iteratorSymbol, function() {
					return this;
				});
				var getProto = Object.getPrototypeOf;
				var NativeIteratorPrototype = getProto && getProto(getProto(values([])));

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

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

				function defineIteratorMethods(prototype) {
					["next", "throw", "return"].forEach(function(method) {
						define(prototype, method, function(arg) {
							return this._invoke(method, arg);
						});
					});
				}

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

				exports.mark = function(genFun) {
					if (Object.setPrototypeOf) {
						Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
					} else {
						genFun.__proto__ = GeneratorFunctionPrototype;
						define(genFun, toStringTagSymbol, "GeneratorFunction");
					}

					genFun.prototype = Object.create(Gp);
					return genFun;
				};

				exports.awrap = function(arg) {
					return {
						__await: arg
					};
				};

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

						if (record.type === "throw") {
							reject(record.arg);
						} else {
							var result = record.arg;
							var value = result.value;

							if (value && _typeof(value) === "object" && hasOwn.call(value,
									"__await")) {
								return PromiseImpl.resolve(value.__await).then(function(value) {
									invoke("next", value, resolve, reject);
								}, function(err) {
									invoke("throw", err, resolve, reject);
								});
							}

							return PromiseImpl.resolve(value).then(function(unwrapped) {
								result.value = unwrapped;
								resolve(result);
							}, function(error) {
								return invoke("throw", error, resolve, reject);
							});
						}
					}

					var previousPromise;

					function enqueue(method, arg) {
						function callInvokeWithMethodAndArg() {
							return new PromiseImpl(function(resolve, reject) {
								invoke(method, arg, resolve, reject);
							});
						}

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

					this._invoke = enqueue;
				}

				defineIteratorMethods(AsyncIterator.prototype);
				define(AsyncIterator.prototype, asyncIteratorSymbol, function() {
					return this;
				});
				exports.AsyncIterator = AsyncIterator;

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

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

						if (state === GenStateCompleted) {
							if (method === "throw") {
								throw arg;
							}

							return doneResult();
						}

						context.method = method;
						context.arg = arg;

						while (true) {
							var delegate = context.delegate;

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

								if (delegateResult) {
									if (delegateResult === ContinueSentinel) continue;
									return delegateResult;
								}
							}

							if (context.method === "next") {
								context.sent = context._sent = context.arg;
							} else if (context.method === "throw") {
								if (state === GenStateSuspendedStart) {
									state = GenStateCompleted;
									throw context.arg;
								}

								context.dispatchException(context.arg);
							} else if (context.method === "return") {
								context.abrupt("return", context.arg);
							}

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

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

								if (record.arg === ContinueSentinel) {
									continue;
								}

								return {
									value: record.arg,
									done: context.done
								};
							} else if (record.type === "throw") {
								state = GenStateCompleted;
								context.method = "throw";
								context.arg = record.arg;
							}
						}
					};
				}

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

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

						if (context.method === "throw") {
							if (delegate.iterator["return"]) {
								context.method = "return";
								context.arg = undefined;
								maybeInvokeDelegate(delegate, context);

								if (context.method === "throw") {
									return ContinueSentinel;
								}
							}

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

						return ContinueSentinel;
					}

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

					if (record.type === "throw") {
						context.method = "throw";
						context.arg = record.arg;
						context.delegate = null;
						return ContinueSentinel;
					}

					var info = record.arg;

					if (!info) {
						context.method = "throw";
						context.arg = new TypeError("iterator result is not an object");
						context.delegate = null;
						return ContinueSentinel;
					}

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

						if (context.method !== "return") {
							context.method = "next";
							context.arg = undefined;
						}
					} else {
						return info;
					}

					context.delegate = null;
					return ContinueSentinel;
				}

				defineIteratorMethods(Gp);
				define(Gp, toStringTagSymbol, "Generator");
				define(Gp, iteratorSymbol, function() {
					return this;
				});
				define(Gp, "toString", function() {
					return "[object Generator]";
				});

				function pushTryEntry(locs) {
					var entry = {
						tryLoc: locs[0]
					};

					if (1 in locs) {
						entry.catchLoc = locs[1];
					}

					if (2 in locs) {
						entry.finallyLoc = locs[2];
						entry.afterLoc = locs[3];
					}

					this.tryEntries.push(entry);
				}

				function resetTryEntry(entry) {
					var record = entry.completion || {};
					record.type = "normal";
					delete record.arg;
					entry.completion = record;
				}

				function Context(tryLocsList) {
					this.tryEntries = [{
						tryLoc: "root"
					}];
					tryLocsList.forEach(pushTryEntry, this);
					this.reset(true);
				}

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

					for (var key in object) {
						keys.push(key);
					}

					keys.reverse();
					return function next() {
						while (keys.length) {
							var key = keys.pop();

							if (key in object) {
								next.value = key;
								next.done = false;
								return next;
							}
						}

						next.done = true;
						return next;
					};
				};

				function values(iterable) {
					if (iterable) {
						var iteratorMethod = iterable[iteratorSymbol];

						if (iteratorMethod) {
							return iteratorMethod.call(iterable);
						}

						if (typeof iterable.next === "function") {
							return iterable;
						}

						if (!isNaN(iterable.length)) {
							var i = -1,
								next = function next() {
									while (++i < iterable.length) {
										if (hasOwn.call(iterable, i)) {
											next.value = iterable[i];
											next.done = false;
											return next;
										}
									}

									next.value = undefined;
									next.done = true;
									return next;
								};

							return next.next = next;
						}
					}

					return {
						next: doneResult
					};
				}

				exports.values = values;

				function doneResult() {
					return {
						value: undefined,
						done: true
					};
				}

				Context.prototype = {
					constructor: Context,
					reset: function reset(skipTempReset) {
						this.prev = 0;
						this.next = 0;
						this.sent = this._sent = undefined;
						this.done = false;
						this.delegate = null;
						this.method = "next";
						this.arg = undefined;
						this.tryEntries.forEach(resetTryEntry);

						if (!skipTempReset) {
							for (var name in this) {
								if (name.charAt(0) === "t" && hasOwn.call(this, name) && !
									isNaN(+name.slice(1))) {
									this[name] = undefined;
								}
							}
						}
					},
					stop: function stop() {
						this.done = true;
						var rootEntry = this.tryEntries[0];
						var rootRecord = rootEntry.completion;

						if (rootRecord.type === "throw") {
							throw rootRecord.arg;
						}

						return this.rval;
					},
					dispatchException: function dispatchException(exception) {
						if (this.done) {
							throw exception;
						}

						var context = this;

						function handle(loc, caught) {
							record.type = "throw";
							record.arg = exception;
							context.next = loc;

							if (caught) {
								context.method = "next";
								context.arg = undefined;
							}

							return !!caught;
						}

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

							if (entry.tryLoc === "root") {
								return handle("end");
							}

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

								if (hasCatch && hasFinally) {
									if (this.prev < entry.catchLoc) {
										return handle(entry.catchLoc, true);
									} else if (this.prev < entry.finallyLoc) {
										return handle(entry.finallyLoc);
									}
								} else if (hasCatch) {
									if (this.prev < entry.catchLoc) {
										return handle(entry.catchLoc, true);
									}
								} else if (hasFinally) {
									if (this.prev < entry.finallyLoc) {
										return handle(entry.finallyLoc);
									}
								} else {
									throw new Error(
										"try statement without catch or finally");
								}
							}
						}
					},
					abrupt: function abrupt(type, arg) {
						for (var i = this.tryEntries.length - 1; i >= 0; --i) {
							var entry = this.tryEntries[i];

							if (entry.tryLoc <= this.prev && hasOwn.call(entry,
									"finallyLoc") && this.prev < entry.finallyLoc) {
								var finallyEntry = entry;
								break;
							}
						}

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

						var record = finallyEntry ? finallyEntry.completion : {};
						record.type = type;
						record.arg = arg;

						if (finallyEntry) {
							this.method = "next";
							this.next = finallyEntry.finallyLoc;
							return ContinueSentinel;
						}

						return this.complete(record);
					},
					complete: function complete(record, afterLoc) {
						if (record.type === "throw") {
							throw record.arg;
						}

						if (record.type === "break" || record.type === "continue") {
							this.next = record.arg;
						} else if (record.type === "return") {
							this.rval = this.arg = record.arg;
							this.method = "return";
							this.next = "end";
						} else if (record.type === "normal" && afterLoc) {
							this.next = afterLoc;
						}

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

							if (entry.finallyLoc === finallyLoc) {
								this.complete(entry.completion, entry.afterLoc);
								resetTryEntry(entry);
								return ContinueSentinel;
							}
						}
					},
					"catch": function _catch(tryLoc) {
						for (var i = this.tryEntries.length - 1; i >= 0; --i) {
							var entry = this.tryEntries[i];

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

								if (record.type === "throw") {
									var thrown = record.arg;
									resetTryEntry(entry);
								}

								return thrown;
							}
						}

						throw new Error("illegal catch attempt");
					},
					delegateYield: function delegateYield(iterable, resultName, nextLoc) {
						this.delegate = {
							iterator: values(iterable),
							resultName: resultName,
							nextLoc: nextLoc
						};

						if (this.method === "next") {
							this.arg = undefined;
						}

						return ContinueSentinel;
					}
				};
				return exports;
			}((false ? 0 : _typeof(module)) === "object" ? module.exports : {});

			try {
				regeneratorRuntime = runtime;
			} catch (accidentalStrictMode) {
				if ((typeof globalThis === "undefined" ? "undefined" : _typeof(globalThis)) ===
					"object") {
					globalThis.regeneratorRuntime = runtime;
				} else {
					Function("r", "regeneratorRuntime = r")(runtime);
				}
			}

			/***/
		}),
		/* 5 */
		/***/
		((__unused_webpack_module, exports) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.animationStarted = exports.VERTICAL_PADDING = exports.UNKNOWN_SCALE = exports
				.TextLayerMode = exports.SpreadMode = exports.SidebarView = exports.ScrollMode = exports
				.SCROLLBAR_PADDING = exports.RenderingStates = exports.RendererType = exports
				.ProgressBar = exports.PresentationModeState = exports.OutputScale = exports.MIN_SCALE =
				exports.MAX_SCALE = exports.MAX_AUTO_SCALE = exports.DEFAULT_SCALE_VALUE = exports
				.DEFAULT_SCALE_DELTA = exports.DEFAULT_SCALE = exports.AutoPrintRegExp = void 0;
			exports.apiPageLayoutToViewerModes = apiPageLayoutToViewerModes;
			exports.apiPageModeToSidebarView = apiPageModeToSidebarView;
			exports.approximateFraction = approximateFraction;
			exports.backtrackBeforeAllVisibleElements = backtrackBeforeAllVisibleElements;
			exports.binarySearchFirstItem = binarySearchFirstItem;
			exports.getActiveOrFocusedElement = getActiveOrFocusedElement;
			exports.getPageSizeInches = getPageSizeInches;
			exports.getVisibleElements = getVisibleElements;
			exports.isPortraitOrientation = isPortraitOrientation;
			exports.isValidRotation = isValidRotation;
			exports.isValidScrollMode = isValidScrollMode;
			exports.isValidSpreadMode = isValidSpreadMode;
			exports.noContextMenuHandler = noContextMenuHandler;
			exports.normalizeWheelEventDelta = normalizeWheelEventDelta;
			exports.normalizeWheelEventDirection = normalizeWheelEventDirection;
			exports.parseQueryString = parseQueryString;
			exports.removeNullCharacters = removeNullCharacters;
			exports.roundToDivide = roundToDivide;
			exports.scrollIntoView = scrollIntoView;
			exports.watchScroll = watchScroll;

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

			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."
					);
			}

			function _iterableToArrayLimit(arr, i) {
				var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] ||
					arr["@@iterator"];
				if (_i == null) return;
				var _arr = [];
				var _n = true;
				var _d = false;
				var _s, _e;
				try {
					for (_i = _i.call(arr); !(_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;
			}

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

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

			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);
			}

			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;
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var DEFAULT_SCALE_VALUE = "auto";
			exports.DEFAULT_SCALE_VALUE = DEFAULT_SCALE_VALUE;
			var DEFAULT_SCALE = 1.0;
			exports.DEFAULT_SCALE = DEFAULT_SCALE;
			var DEFAULT_SCALE_DELTA = 1.1;
			exports.DEFAULT_SCALE_DELTA = DEFAULT_SCALE_DELTA;
			var MIN_SCALE = 0.1;
			exports.MIN_SCALE = MIN_SCALE;
			var MAX_SCALE = 10.0;
			exports.MAX_SCALE = MAX_SCALE;
			var UNKNOWN_SCALE = 0;
			exports.UNKNOWN_SCALE = UNKNOWN_SCALE;
			var MAX_AUTO_SCALE = 1.25;
			exports.MAX_AUTO_SCALE = MAX_AUTO_SCALE;
			var SCROLLBAR_PADDING = 40;
			exports.SCROLLBAR_PADDING = SCROLLBAR_PADDING;
			var VERTICAL_PADDING = 5;
			exports.VERTICAL_PADDING = VERTICAL_PADDING;
			var LOADINGBAR_END_OFFSET_VAR = "--loadingBar-end-offset";
			var RenderingStates = {
				INITIAL: 0,
				RUNNING: 1,
				PAUSED: 2,
				FINISHED: 3
			};
			exports.RenderingStates = RenderingStates;
			var PresentationModeState = {
				UNKNOWN: 0,
				NORMAL: 1,
				CHANGING: 2,
				FULLSCREEN: 3
			};
			exports.PresentationModeState = PresentationModeState;
			var SidebarView = {
				UNKNOWN: -1,
				NONE: 0,
				THUMBS: 1,
				OUTLINE: 2,
				ATTACHMENTS: 3,
				LAYERS: 4
			};
			exports.SidebarView = SidebarView;
			var RendererType = {
				CANVAS: "canvas",
				SVG: "svg"
			};
			exports.RendererType = RendererType;
			var TextLayerMode = {
				DISABLE: 0,
				ENABLE: 1,
				ENABLE_ENHANCE: 2
			};
			exports.TextLayerMode = TextLayerMode;
			var ScrollMode = {
				UNKNOWN: -1,
				VERTICAL: 0,
				HORIZONTAL: 1,
				WRAPPED: 2,
				PAGE: 3
			};
			exports.ScrollMode = ScrollMode;
			var SpreadMode = {
				UNKNOWN: -1,
				NONE: 0,
				ODD: 1,
				EVEN: 2
			};
			exports.SpreadMode = SpreadMode;
			var AutoPrintRegExp = /\bprint\s*\(/;
			exports.AutoPrintRegExp = AutoPrintRegExp;

			var OutputScale = /*#__PURE__*/ function() {
				function OutputScale() {
					_classCallCheck(this, OutputScale);

					var pixelRatio = window.devicePixelRatio || 1;
					this.sx = pixelRatio;
					this.sy = pixelRatio;
				}

				_createClass(OutputScale, [{
					key: "scaled",
					get: function get() {
						return this.sx !== 1 || this.sy !== 1;
					}
				}]);

				return OutputScale;
			}();

			exports.OutputScale = OutputScale;

			function scrollIntoView(element, spot) {
				var scrollMatches = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] :
					false;
				var parent = element.offsetParent;

				if (!parent) {
					console.error("offsetParent is not set -- cannot scroll");
					return;
				}

				var offsetY = element.offsetTop + element.clientTop;
				var offsetX = element.offsetLeft + element.clientLeft;

				while (parent.clientHeight === parent.scrollHeight && parent.clientWidth === parent
					.scrollWidth || scrollMatches && (parent.classList.contains("markedContent") ||
						getComputedStyle(parent).overflow === "hidden")) {
					offsetY += parent.offsetTop;
					offsetX += parent.offsetLeft;
					parent = parent.offsetParent;

					if (!parent) {
						return;
					}
				}

				if (spot) {
					if (spot.top !== undefined) {
						offsetY += spot.top;
					}

					if (spot.left !== undefined) {
						offsetX += spot.left;
						parent.scrollLeft = offsetX;
					}
				}

				parent.scrollTop = offsetY;
			}

			function watchScroll(viewAreaElement, callback) {
				var debounceScroll = function debounceScroll(evt) {
					if (rAF) {
						return;
					}

					rAF = window.requestAnimationFrame(function viewAreaElementScrolled() {
						rAF = null;
						var currentX = viewAreaElement.scrollLeft;
						var lastX = state.lastX;

						if (currentX !== lastX) {
							state.right = currentX > lastX;
						}

						state.lastX = currentX;
						var currentY = viewAreaElement.scrollTop;
						var lastY = state.lastY;

						if (currentY !== lastY) {
							state.down = currentY > lastY;
						}

						state.lastY = currentY;
						callback(state);
					});
				};

				var state = {
					right: true,
					down: true,
					lastX: viewAreaElement.scrollLeft,
					lastY: viewAreaElement.scrollTop,
					_eventHandler: debounceScroll
				};
				var rAF = null;
				viewAreaElement.addEventListener("scroll", debounceScroll, true);
				return state;
			}

			function parseQueryString(query) {
				var params = new Map();

				var _iterator = _createForOfIteratorHelper(new URLSearchParams(query)),
					_step;

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

						params.set(key.toLowerCase(), value);
					}
				} catch (err) {
					_iterator.e(err);
				} finally {
					_iterator.f();
				}

				return params;
			}

			var NullCharactersRegExp = /\x00/g;
			var InvisibleCharactersRegExp = /[\x01-\x1F]/g;

			function removeNullCharacters(str) {
				var replaceInvisible = arguments.length > 1 && arguments[1] !== undefined ? arguments[
					1] : false;

				if (typeof str !== "string") {
					console.error("The argument must be a string.");
					return str;
				}

				if (replaceInvisible) {
					str = str.replace(InvisibleCharactersRegExp, " ");
				}

				return str.replace(NullCharactersRegExp, "");
			}

			function binarySearchFirstItem(items, condition) {
				var start = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
				var minIndex = start;
				var maxIndex = items.length - 1;

				if (maxIndex < 0 || !condition(items[maxIndex])) {
					return items.length;
				}

				if (condition(items[minIndex])) {
					return minIndex;
				}

				while (minIndex < maxIndex) {
					var currentIndex = minIndex + maxIndex >> 1;
					var currentItem = items[currentIndex];

					if (condition(currentItem)) {
						maxIndex = currentIndex;
					} else {
						minIndex = currentIndex + 1;
					}
				}

				return minIndex;
			}

			function approximateFraction(x) {
				if (Math.floor(x) === x) {
					return [x, 1];
				}

				var xinv = 1 / x;
				var limit = 8;

				if (xinv > limit) {
					return [1, limit];
				} else if (Math.floor(xinv) === xinv) {
					return [1, xinv];
				}

				var x_ = x > 1 ? xinv : x;
				var a = 0,
					b = 1,
					c = 1,
					d = 1;

				while (true) {
					var p = a + c,
						q = b + d;

					if (q > limit) {
						break;
					}

					if (x_ <= p / q) {
						c = p;
						d = q;
					} else {
						a = p;
						b = q;
					}
				}

				var result;

				if (x_ - a / b < c / d - x_) {
					result = x_ === x ? [a, b] : [b, a];
				} else {
					result = x_ === x ? [c, d] : [d, c];
				}

				return result;
			}

			function roundToDivide(x, div) {
				var r = x % div;
				return r === 0 ? x : Math.round(x - r + div);
			}

			function getPageSizeInches(_ref) {
				var view = _ref.view,
					userUnit = _ref.userUnit,
					rotate = _ref.rotate;

				var _view = _slicedToArray(view, 4),
					x1 = _view[0],
					y1 = _view[1],
					x2 = _view[2],
					y2 = _view[3];

				var changeOrientation = rotate % 180 !== 0;
				var width = (x2 - x1) / 72 * userUnit;
				var height = (y2 - y1) / 72 * userUnit;
				return {
					width: changeOrientation ? height : width,
					height: changeOrientation ? width : height
				};
			}

			function backtrackBeforeAllVisibleElements(index, views, top) {
				if (index < 2) {
					return index;
				}

				var elt = views[index].div;
				var pageTop = elt.offsetTop + elt.clientTop;

				if (pageTop >= top) {
					elt = views[index - 1].div;
					pageTop = elt.offsetTop + elt.clientTop;
				}

				for (var i = index - 2; i >= 0; --i) {
					elt = views[i].div;

					if (elt.offsetTop + elt.clientTop + elt.clientHeight <= pageTop) {
						break;
					}

					index = i;
				}

				return index;
			}

			function getVisibleElements(_ref2) {
				var scrollEl = _ref2.scrollEl,
					views = _ref2.views,
					_ref2$sortByVisibilit = _ref2.sortByVisibility,
					sortByVisibility = _ref2$sortByVisibilit === void 0 ? false : _ref2$sortByVisibilit,
					_ref2$horizontal = _ref2.horizontal,
					horizontal = _ref2$horizontal === void 0 ? false : _ref2$horizontal,
					_ref2$rtl = _ref2.rtl,
					rtl = _ref2$rtl === void 0 ? false : _ref2$rtl;
				var top = scrollEl.scrollTop,
					bottom = top + scrollEl.clientHeight;
				var left = scrollEl.scrollLeft,
					right = left + scrollEl.clientWidth;

				function isElementBottomAfterViewTop(view) {
					var element = view.div;
					var elementBottom = element.offsetTop + element.clientTop + element.clientHeight;
					return elementBottom > top;
				}

				function isElementNextAfterViewHorizontally(view) {
					var element = view.div;
					var elementLeft = element.offsetLeft + element.clientLeft;
					var elementRight = elementLeft + element.clientWidth;
					return rtl ? elementLeft < right : elementRight > left;
				}

				var visible = [],
					ids = new Set(),
					numViews = views.length;
				var firstVisibleElementInd = binarySearchFirstItem(views, horizontal ?
					isElementNextAfterViewHorizontally : isElementBottomAfterViewTop);

				if (firstVisibleElementInd > 0 && firstVisibleElementInd < numViews && !horizontal) {
					firstVisibleElementInd = backtrackBeforeAllVisibleElements(firstVisibleElementInd,
						views, top);
				}

				var lastEdge = horizontal ? right : -1;

				for (var i = firstVisibleElementInd; i < numViews; i++) {
					var view = views[i],
						element = view.div;
					var currentWidth = element.offsetLeft + element.clientLeft;
					var currentHeight = element.offsetTop + element.clientTop;
					var viewWidth = element.clientWidth,
						viewHeight = element.clientHeight;
					var viewRight = currentWidth + viewWidth;
					var viewBottom = currentHeight + viewHeight;

					if (lastEdge === -1) {
						if (viewBottom >= bottom) {
							lastEdge = viewBottom;
						}
					} else if ((horizontal ? currentWidth : currentHeight) > lastEdge) {
						break;
					}

					if (viewBottom <= top || currentHeight >= bottom || viewRight <= left ||
						currentWidth >= right) {
						continue;
					}

					var hiddenHeight = Math.max(0, top - currentHeight) + Math.max(0, viewBottom -
						bottom);
					var hiddenWidth = Math.max(0, left - currentWidth) + Math.max(0, viewRight - right);
					var fractionHeight = (viewHeight - hiddenHeight) / viewHeight,
						fractionWidth = (viewWidth - hiddenWidth) / viewWidth;
					var percent = fractionHeight * fractionWidth * 100 | 0;
					visible.push({
						id: view.id,
						x: currentWidth,
						y: currentHeight,
						view: view,
						percent: percent,
						widthPercent: fractionWidth * 100 | 0
					});
					ids.add(view.id);
				}

				var first = visible[0],
					last = visible[visible.length - 1];

				if (sortByVisibility) {
					visible.sort(function(a, b) {
						var pc = a.percent - b.percent;

						if (Math.abs(pc) > 0.001) {
							return -pc;
						}

						return a.id - b.id;
					});
				}

				return {
					first: first,
					last: last,
					views: visible,
					ids: ids
				};
			}

			function noContextMenuHandler(evt) {
				evt.preventDefault();
			}

			function normalizeWheelEventDirection(evt) {
				var delta = Math.hypot(evt.deltaX, evt.deltaY);
				var angle = Math.atan2(evt.deltaY, evt.deltaX);

				if (-0.25 * Math.PI < angle && angle < 0.75 * Math.PI) {
					delta = -delta;
				}

				return delta;
			}

			function normalizeWheelEventDelta(evt) {
				var delta = normalizeWheelEventDirection(evt);
				var MOUSE_DOM_DELTA_PIXEL_MODE = 0;
				var MOUSE_DOM_DELTA_LINE_MODE = 1;
				var MOUSE_PIXELS_PER_LINE = 30;
				var MOUSE_LINES_PER_PAGE = 30;

				if (evt.deltaMode === MOUSE_DOM_DELTA_PIXEL_MODE) {
					delta /= MOUSE_PIXELS_PER_LINE * MOUSE_LINES_PER_PAGE;
				} else if (evt.deltaMode === MOUSE_DOM_DELTA_LINE_MODE) {
					delta /= MOUSE_LINES_PER_PAGE;
				}

				return delta;
			}

			function isValidRotation(angle) {
				return Number.isInteger(angle) && angle % 90 === 0;
			}

			function isValidScrollMode(mode) {
				return Number.isInteger(mode) && Object.values(ScrollMode).includes(mode) && mode !==
					ScrollMode.UNKNOWN;
			}

			function isValidSpreadMode(mode) {
				return Number.isInteger(mode) && Object.values(SpreadMode).includes(mode) && mode !==
					SpreadMode.UNKNOWN;
			}

			function isPortraitOrientation(size) {
				return size.width <= size.height;
			}

			var animationStarted = new Promise(function(resolve) {
				window.requestAnimationFrame(resolve);
			});
			exports.animationStarted = animationStarted;

			function clamp(v, min, max) {
				return Math.min(Math.max(v, min), max);
			}

			var ProgressBar = /*#__PURE__*/ function() {
				function ProgressBar(id) {
					var _ref3 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] :
						{},
						height = _ref3.height,
						width = _ref3.width,
						units = _ref3.units;

					_classCallCheck(this, ProgressBar);

					this.visible = true;
					this.div = document.querySelector(id + " .progress");
					this.bar = this.div.parentNode;
					this.height = height || 100;
					this.width = width || 100;
					this.units = units || "%";
					this.div.style.height = this.height + this.units;
					this.percent = 0;
				}

				_createClass(ProgressBar, [{
					key: "_updateBar",
					value: function _updateBar() {
						if (this._indeterminate) {
							this.div.classList.add("indeterminate");
							this.div.style.width = this.width + this.units;
							return;
						}

						this.div.classList.remove("indeterminate");
						var progressSize = this.width * this._percent / 100;
						this.div.style.width = progressSize + this.units;
					}
				}, {
					key: "percent",
					get: function get() {
						return this._percent;
					},
					set: function set(val) {
						this._indeterminate = isNaN(val);
						this._percent = clamp(val, 0, 100);

						this._updateBar();
					}
				}, {
					key: "setWidth",
					value: function setWidth(viewer) {
						if (!viewer) {
							return;
						}

						var container = viewer.parentNode;
						var scrollbarWidth = container.offsetWidth - viewer
							.offsetWidth;

						if (scrollbarWidth > 0) {
							var doc = document.documentElement;
							doc.style.setProperty(LOADINGBAR_END_OFFSET_VAR, ""
								.concat(scrollbarWidth, "px"));
						}
					}
				}, {
					key: "hide",
					value: function hide() {
						if (!this.visible) {
							return;
						}

						this.visible = false;
						this.bar.classList.add("hidden");
					}
				}, {
					key: "show",
					value: function show() {
						if (this.visible) {
							return;
						}

						this.visible = true;
						this.bar.classList.remove("hidden");
					}
				}]);

				return ProgressBar;
			}();

			exports.ProgressBar = ProgressBar;

			function getActiveOrFocusedElement() {
				var curRoot = document;
				var curActiveOrFocused = curRoot.activeElement || curRoot.querySelector(":focus");

				while ((_curActiveOrFocused = curActiveOrFocused) !== null && _curActiveOrFocused !==
					void 0 && _curActiveOrFocused.shadowRoot) {
					var _curActiveOrFocused;

					curRoot = curActiveOrFocused.shadowRoot;
					curActiveOrFocused = curRoot.activeElement || curRoot.querySelector(":focus");
				}

				return curActiveOrFocused;
			}

			function apiPageLayoutToViewerModes(layout) {
				var scrollMode = ScrollMode.VERTICAL,
					spreadMode = SpreadMode.NONE;

				switch (layout) {
					case "SinglePage":
						scrollMode = ScrollMode.PAGE;
						break;

					case "OneColumn":
						break;

					case "TwoPageLeft":
						scrollMode = ScrollMode.PAGE;

					case "TwoColumnLeft":
						spreadMode = SpreadMode.ODD;
						break;

					case "TwoPageRight":
						scrollMode = ScrollMode.PAGE;

					case "TwoColumnRight":
						spreadMode = SpreadMode.EVEN;
						break;
				}

				return {
					scrollMode: scrollMode,
					spreadMode: spreadMode
				};
			}

			function apiPageModeToSidebarView(mode) {
				switch (mode) {
					case "UseNone":
						return SidebarView.NONE;

					case "UseThumbs":
						return SidebarView.THUMBS;

					case "UseOutlines":
						return SidebarView.OUTLINE;

					case "UseAttachments":
						return SidebarView.ATTACHMENTS;

					case "UseOC":
						return SidebarView.LAYERS;
				}

				return SidebarView.NONE;
			}

			/***/
		}),
		/* 6 */
		/***/
		((__unused_webpack_module, exports) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.WaitOnType = exports.EventBus = exports.AutomationEventBus = void 0;
			exports.waitOnEventOrTimeout = waitOnEventOrTimeout;

			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
					}
				});
				Object.defineProperty(subClass, "prototype", {
					writable: false
				});
				if (superClass) _setPrototypeOf(subClass, superClass);
			}

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

			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);
				};
			}

			function _possibleConstructorReturn(self, call) {
				if (call && (_typeof(call) === "object" || typeof call === "function")) {
					return call;
				} else if (call !== void 0) {
					throw new TypeError("Derived constructors may only return object or undefined");
				}
				return _assertThisInitialized(self);
			}

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

			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;
				}
			}

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

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

			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);
			}

			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;
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

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

			var WaitOnType = {
				EVENT: "event",
				TIMEOUT: "timeout"
			};
			exports.WaitOnType = WaitOnType;

			function waitOnEventOrTimeout(_ref) {
				var target = _ref.target,
					name = _ref.name,
					_ref$delay = _ref.delay,
					delay = _ref$delay === void 0 ? 0 : _ref$delay;
				return new Promise(function(resolve, reject) {
					if (_typeof(target) !== "object" || !(name && typeof name === "string") || !
						(Number.isInteger(delay) && delay >= 0)) {
						throw new Error("waitOnEventOrTimeout - invalid parameters.");
					}

					function handler(type) {
						if (target instanceof EventBus) {
							target._off(name, eventHandler);
						} else {
							target.removeEventListener(name, eventHandler);
						}

						if (timeout) {
							clearTimeout(timeout);
						}

						resolve(type);
					}

					var eventHandler = handler.bind(null, WaitOnType.EVENT);

					if (target instanceof EventBus) {
						target._on(name, eventHandler);
					} else {
						target.addEventListener(name, eventHandler);
					}

					var timeoutHandler = handler.bind(null, WaitOnType.TIMEOUT);
					var timeout = setTimeout(timeoutHandler, delay);
				});
			}

			var EventBus = /*#__PURE__*/ function() {
				function EventBus() {
					_classCallCheck(this, EventBus);

					this._listeners = Object.create(null);
				}

				_createClass(EventBus, [{
					key: "on",
					value: function on(eventName, listener) {
						var options = arguments.length > 2 && arguments[2] !==
							undefined ? arguments[2] : null;

						this._on(eventName, listener, {
							external: true,
							once: options === null || options === void 0 ?
								void 0 : options.once
						});
					}
				}, {
					key: "off",
					value: function off(eventName, listener) {
						var options = arguments.length > 2 && arguments[2] !==
							undefined ? arguments[2] : null;

						this._off(eventName, listener, {
							external: true,
							once: options === null || options === void 0 ?
								void 0 : options.once
						});
					}
				}, {
					key: "dispatch",
					value: function dispatch(eventName, data) {
						var eventListeners = this._listeners[eventName];

						if (!eventListeners || eventListeners.length === 0) {
							return;
						}

						var externalListeners;

						var _iterator = _createForOfIteratorHelper(eventListeners
								.slice(0)),
							_step;

						try {
							for (_iterator.s(); !(_step = _iterator.n()).done;) {
								var _step$value = _step.value,
									_listener = _step$value.listener,
									external = _step$value.external,
									once = _step$value.once;

								if (once) {
									this._off(eventName, _listener);
								}

								if (external) {
									(externalListeners || (externalListeners = []))
									.push(_listener);
									continue;
								}

								_listener(data);
							}
						} catch (err) {
							_iterator.e(err);
						} finally {
							_iterator.f();
						}

						if (externalListeners) {
							var _iterator2 = _createForOfIteratorHelper(
									externalListeners),
								_step2;

							try {
								for (_iterator2.s(); !(_step2 = _iterator2.n())
									.done;) {
									var listener = _step2.value;
									listener(data);
								}
							} catch (err) {
								_iterator2.e(err);
							} finally {
								_iterator2.f();
							}

							externalListeners = null;
						}
					}
				}, {
					key: "_on",
					value: function _on(eventName, listener) {
						var _this$_listeners;

						var options = arguments.length > 2 && arguments[2] !==
							undefined ? arguments[2] : null;
						var eventListeners = (_this$_listeners = this._listeners)[
							eventName] || (_this$_listeners[eventName] = []);
						eventListeners.push({
							listener: listener,
							external: (options === null || options ===
									void 0 ? void 0 : options.external) ===
								true,
							once: (options === null || options === void 0 ?
								void 0 : options.once) === true
						});
					}
				}, {
					key: "_off",
					value: function _off(eventName, listener) {
						var options = arguments.length > 2 && arguments[2] !==
							undefined ? arguments[2] : null;
						var eventListeners = this._listeners[eventName];

						if (!eventListeners) {
							return;
						}

						for (var i = 0, ii = eventListeners.length; i < ii; i++) {
							if (eventListeners[i].listener === listener) {
								eventListeners.splice(i, 1);
								return;
							}
						}
					}
				}]);

				return EventBus;
			}();

			exports.EventBus = EventBus;

			var AutomationEventBus = /*#__PURE__*/ function(_EventBus) {
				_inherits(AutomationEventBus, _EventBus);

				var _super = _createSuper(AutomationEventBus);

				function AutomationEventBus() {
					_classCallCheck(this, AutomationEventBus);

					return _super.apply(this, arguments);
				}

				_createClass(AutomationEventBus, [{
					key: "dispatch",
					value: function dispatch(eventName, data) {
						throw new Error(
							"Not implemented: AutomationEventBus.dispatch");
					}
				}]);

				return AutomationEventBus;
			}(EventBus);

			exports.AutomationEventBus = AutomationEventBus;

			/***/
		}),
		/* 7 */
		/***/
		((module) => {



			var pdfjsLib;

			if (typeof window !== "undefined" && window["pdfjs-dist/build/pdf"]) {
				pdfjsLib = window["pdfjs-dist/build/pdf"];
			} else {
				pdfjsLib = require("../build/pdf.js");
			}

			module.exports = pdfjsLib;

			/***/
		}),
		/* 8 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFCursorTools = exports.CursorTool = void 0;

			var _grab_to_pan = __webpack_require__(9);

			var _ui_utils = __webpack_require__(5);

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var CursorTool = {
				SELECT: 0,
				HAND: 1,
				ZOOM: 2
			};
			exports.CursorTool = CursorTool;

			var PDFCursorTools = /*#__PURE__*/ function() {
				function PDFCursorTools(_ref) {
					var _this = this;

					var container = _ref.container,
						eventBus = _ref.eventBus,
						_ref$cursorToolOnLoad = _ref.cursorToolOnLoad,
						cursorToolOnLoad = _ref$cursorToolOnLoad === void 0 ? CursorTool.SELECT :
						_ref$cursorToolOnLoad;

					_classCallCheck(this, PDFCursorTools);

					this.container = container;
					this.eventBus = eventBus;
					this.active = CursorTool.SELECT;
					this.activeBeforePresentationMode = null;
					this.handTool = new _grab_to_pan.GrabToPan({
						element: this.container
					});

					this._addEventListeners();

					Promise.resolve().then(function() {
						_this.switchTool(cursorToolOnLoad);
					});
				}

				_createClass(PDFCursorTools, [{
					key: "activeTool",
					get: function get() {
						return this.active;
					}
				}, {
					key: "switchTool",
					value: function switchTool(tool) {
						var _this2 = this;

						if (this.activeBeforePresentationMode !== null) {
							return;
						}

						if (tool === this.active) {
							return;
						}

						var disableActiveTool = function disableActiveTool() {
							switch (_this2.active) {
								case CursorTool.SELECT:
									break;

								case CursorTool.HAND:
									_this2.handTool.deactivate();

									break;

								case CursorTool.ZOOM:
							}
						};

						switch (tool) {
							case CursorTool.SELECT:
								disableActiveTool();
								break;

							case CursorTool.HAND:
								disableActiveTool();
								this.handTool.activate();
								break;

							case CursorTool.ZOOM:
							default:
								console.error("switchTool: \"".concat(tool,
									"\" is an unsupported value."));
								return;
						}

						this.active = tool;

						this._dispatchEvent();
					}
				}, {
					key: "_dispatchEvent",
					value: function _dispatchEvent() {
						this.eventBus.dispatch("cursortoolchanged", {
							source: this,
							tool: this.active
						});
					}
				}, {
					key: "_addEventListeners",
					value: function _addEventListeners() {
						var _this3 = this;

						this.eventBus._on("switchcursortool", function(evt) {
							_this3.switchTool(evt.tool);
						});

						this.eventBus._on("presentationmodechanged", function(evt) {
							switch (evt.state) {
								case _ui_utils.PresentationModeState
								.FULLSCREEN: {
									var previouslyActive = _this3.active;

									_this3.switchTool(CursorTool.SELECT);

									_this3.activeBeforePresentationMode =
										previouslyActive;
									break;
								}

								case _ui_utils.PresentationModeState
								.NORMAL: {
									var _previouslyActive = _this3
										.activeBeforePresentationMode;
									_this3.activeBeforePresentationMode =
										null;

									_this3.switchTool(_previouslyActive);

									break;
								}
							}
						});
					}
				}]);

				return PDFCursorTools;
			}();

			exports.PDFCursorTools = PDFCursorTools;

			/***/
		}),
		/* 9 */
		/***/
		((__unused_webpack_module, exports) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.GrabToPan = void 0;

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			function _classPrivateMethodInitSpec(obj, privateSet) {
				_checkPrivateRedeclaration(obj, privateSet);
				privateSet.add(obj);
			}

			function _checkPrivateRedeclaration(obj, privateCollection) {
				if (privateCollection.has(obj)) {
					throw new TypeError(
						"Cannot initialize the same private elements twice on an object");
				}
			}

			function _classPrivateMethodGet(receiver, privateSet, fn) {
				if (!privateSet.has(receiver)) {
					throw new TypeError("attempted to get private field on non-instance");
				}
				return fn;
			}

			var CSS_CLASS_GRAB = "grab-to-pan-grab";

			var _onMouseDown = /*#__PURE__*/ new WeakSet();

			var _onMouseMove = /*#__PURE__*/ new WeakSet();

			var _endPan = /*#__PURE__*/ new WeakSet();

			var GrabToPan = /*#__PURE__*/ function() {
				function GrabToPan(options) {
					_classCallCheck(this, GrabToPan);

					_classPrivateMethodInitSpec(this, _endPan);

					_classPrivateMethodInitSpec(this, _onMouseMove);

					_classPrivateMethodInitSpec(this, _onMouseDown);

					this.element = options.element;
					this.document = options.element.ownerDocument;

					if (typeof options.ignoreTarget === "function") {
						this.ignoreTarget = options.ignoreTarget;
					}

					this.onActiveChanged = options.onActiveChanged;
					this.activate = this.activate.bind(this);
					this.deactivate = this.deactivate.bind(this);
					this.toggle = this.toggle.bind(this);
					this._onMouseDown = _classPrivateMethodGet(this, _onMouseDown, _onMouseDown2)
						.bind(this);
					this._onMouseMove = _classPrivateMethodGet(this, _onMouseMove, _onMouseMove2)
						.bind(this);
					this._endPan = _classPrivateMethodGet(this, _endPan, _endPan2).bind(this);
					var overlay = this.overlay = document.createElement("div");
					overlay.className = "grab-to-pan-grabbing";
				}

				_createClass(GrabToPan, [{
					key: "activate",
					value: function activate() {
						if (!this.active) {
							var _this$onActiveChanged;

							this.active = true;
							this.element.addEventListener("mousedown", this
								._onMouseDown, true);
							this.element.classList.add(CSS_CLASS_GRAB);
							(_this$onActiveChanged = this.onActiveChanged) === null
								|| _this$onActiveChanged === void 0 ? void 0 :
								_this$onActiveChanged.call(this, true);
						}
					}
				}, {
					key: "deactivate",
					value: function deactivate() {
						if (this.active) {
							var _this$onActiveChanged2;

							this.active = false;
							this.element.removeEventListener("mousedown", this
								._onMouseDown, true);

							this._endPan();

							this.element.classList.remove(CSS_CLASS_GRAB);
							(_this$onActiveChanged2 = this.onActiveChanged) === null
								|| _this$onActiveChanged2 === void 0 ? void 0 :
								_this$onActiveChanged2.call(this, false);
						}
					}
				}, {
					key: "toggle",
					value: function toggle() {
						if (this.active) {
							this.deactivate();
						} else {
							this.activate();
						}
					}
				}, {
					key: "ignoreTarget",
					value: function ignoreTarget(node) {
						return node.matches(
							"a[href], a[href] *, input, textarea, button, button *, select, option"
							);
					}
				}]);

				return GrabToPan;
			}();

			exports.GrabToPan = GrabToPan;

			function _onMouseDown2(event) {
				if (event.button !== 0 || this.ignoreTarget(event.target)) {
					return;
				}

				if (event.originalTarget) {
					try {
						event.originalTarget.tagName;
					} catch (e) {
						return;
					}
				}

				this.scrollLeftStart = this.element.scrollLeft;
				this.scrollTopStart = this.element.scrollTop;
				this.clientXStart = event.clientX;
				this.clientYStart = event.clientY;
				this.document.addEventListener("mousemove", this._onMouseMove, true);
				this.document.addEventListener("mouseup", this._endPan, true);
				this.element.addEventListener("scroll", this._endPan, true);
				event.preventDefault();
				event.stopPropagation();
				var focusedElement = document.activeElement;

				if (focusedElement && !focusedElement.contains(event.target)) {
					focusedElement.blur();
				}
			}

			function _onMouseMove2(event) {
				this.element.removeEventListener("scroll", this._endPan, true);

				if (!(event.buttons & 1)) {
					this._endPan();

					return;
				}

				var xDiff = event.clientX - this.clientXStart;
				var yDiff = event.clientY - this.clientYStart;
				var scrollTop = this.scrollTopStart - yDiff;
				var scrollLeft = this.scrollLeftStart - xDiff;

				if (this.element.scrollTo) {
					this.element.scrollTo({
						top: scrollTop,
						left: scrollLeft,
						behavior: "instant"
					});
				} else {
					this.element.scrollTop = scrollTop;
					this.element.scrollLeft = scrollLeft;
				}

				if (!this.overlay.parentNode) {
					document.body.appendChild(this.overlay);
				}
			}

			function _endPan2() {
				this.element.removeEventListener("scroll", this._endPan, true);
				this.document.removeEventListener("mousemove", this._onMouseMove, true);
				this.document.removeEventListener("mouseup", this._endPan, true);
				this.overlay.remove();
			}

			/***/
		}),
		/* 10 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.SimpleLinkService = exports.PDFLinkService = exports.LinkTarget = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _ui_utils = __webpack_require__(5);

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

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

			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);
				}
			}

			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);
					});
				};
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			function _classPrivateMethodInitSpec(obj, privateSet) {
				_checkPrivateRedeclaration(obj, privateSet);
				privateSet.add(obj);
			}

			function _classPrivateFieldInitSpec(obj, privateMap, value) {
				_checkPrivateRedeclaration(obj, privateMap);
				privateMap.set(obj, value);
			}

			function _checkPrivateRedeclaration(obj, privateCollection) {
				if (privateCollection.has(obj)) {
					throw new TypeError(
						"Cannot initialize the same private elements twice on an object");
				}
			}

			function _classStaticPrivateMethodGet(receiver, classConstructor, method) {
				_classCheckPrivateStaticAccess(receiver, classConstructor);
				return method;
			}

			function _classCheckPrivateStaticAccess(receiver, classConstructor) {
				if (receiver !== classConstructor) {
					throw new TypeError("Private static access of wrong provenance");
				}
			}

			function _classPrivateMethodGet(receiver, privateSet, fn) {
				if (!privateSet.has(receiver)) {
					throw new TypeError("attempted to get private field on non-instance");
				}
				return fn;
			}

			function _classPrivateFieldGet(receiver, privateMap) {
				var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get");
				return _classApplyDescriptorGet(receiver, descriptor);
			}

			function _classExtractFieldDescriptor(receiver, privateMap, action) {
				if (!privateMap.has(receiver)) {
					throw new TypeError("attempted to " + action + " private field on non-instance");
				}
				return privateMap.get(receiver);
			}

			function _classApplyDescriptorGet(receiver, descriptor) {
				if (descriptor.get) {
					return descriptor.get.call(receiver);
				}
				return descriptor.value;
			}

			var DEFAULT_LINK_REL = "noopener noreferrer nofollow";
			var LinkTarget = {
				NONE: 0,
				SELF: 1,
				BLANK: 2,
				PARENT: 3,
				TOP: 4
			};
			exports.LinkTarget = LinkTarget;

			function _addLinkAttributes(link) {
				var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
					url = _ref.url,
					target = _ref.target,
					rel = _ref.rel,
					_ref$enabled = _ref.enabled,
					enabled = _ref$enabled === void 0 ? true : _ref$enabled;

				if (!url || typeof url !== "string") {
					throw new Error('A valid "url" parameter must provided.');
				}

				var urlNullRemoved = (0, _ui_utils.removeNullCharacters)(url);

				if (enabled) {
					link.href = link.title = urlNullRemoved;
				} else {
					link.href = "";
					link.title = "Disabled: ".concat(urlNullRemoved);

					link.onclick = function() {
						return false;
					};
				}

				var targetStr = "";

				switch (target) {
					case LinkTarget.NONE:
						break;

					case LinkTarget.SELF:
						targetStr = "_self";
						break;

					case LinkTarget.BLANK:
						targetStr = "_blank";
						break;

					case LinkTarget.PARENT:
						targetStr = "_parent";
						break;

					case LinkTarget.TOP:
						targetStr = "_top";
						break;
				}

				link.target = targetStr;
				link.rel = typeof rel === "string" ? rel : DEFAULT_LINK_REL;
			}

			var _pagesRefCache = /*#__PURE__*/ new WeakMap();

			var _goToDestinationHelper = /*#__PURE__*/ new WeakSet();

			var PDFLinkService = /*#__PURE__*/ function() {
				function PDFLinkService() {
					var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] :
						{},
						eventBus = _ref2.eventBus,
						_ref2$externalLinkTar = _ref2.externalLinkTarget,
						externalLinkTarget = _ref2$externalLinkTar === void 0 ? null :
						_ref2$externalLinkTar,
						_ref2$externalLinkRel = _ref2.externalLinkRel,
						externalLinkRel = _ref2$externalLinkRel === void 0 ? null :
						_ref2$externalLinkRel,
						_ref2$ignoreDestinati = _ref2.ignoreDestinationZoom,
						ignoreDestinationZoom = _ref2$ignoreDestinati === void 0 ? false :
						_ref2$ignoreDestinati;

					_classCallCheck(this, PDFLinkService);

					_classPrivateMethodInitSpec(this, _goToDestinationHelper);

					_classPrivateFieldInitSpec(this, _pagesRefCache, {
						writable: true,
						value: new Map()
					});

					this.eventBus = eventBus;
					this.externalLinkTarget = externalLinkTarget;
					this.externalLinkRel = externalLinkRel;
					this.externalLinkEnabled = true;
					this._ignoreDestinationZoom = ignoreDestinationZoom;
					this.baseUrl = null;
					this.pdfDocument = null;
					this.pdfViewer = null;
					this.pdfHistory = null;
				}

				_createClass(PDFLinkService, [{
					key: "setDocument",
					value: function setDocument(pdfDocument) {
						var baseUrl = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : null;
						this.baseUrl = baseUrl;
						this.pdfDocument = pdfDocument;

						_classPrivateFieldGet(this, _pagesRefCache).clear();
					}
				}, {
					key: "setViewer",
					value: function setViewer(pdfViewer) {
						this.pdfViewer = pdfViewer;
					}
				}, {
					key: "setHistory",
					value: function setHistory(pdfHistory) {
						this.pdfHistory = pdfHistory;
					}
				}, {
					key: "pagesCount",
					get: function get() {
						return this.pdfDocument ? this.pdfDocument.numPages : 0;
					}
				}, {
					key: "page",
					get: function get() {
						return this.pdfViewer.currentPageNumber;
					},
					set: function set(value) {
						this.pdfViewer.currentPageNumber = value;
					}
				}, {
					key: "rotation",
					get: function get() {
						return this.pdfViewer.pagesRotation;
					},
					set: function set(value) {
						this.pdfViewer.pagesRotation = value;
					}
				}, {
					key: "goToDestination",
					value: function() {
						var _goToDestination = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee(
							dest) {
								var namedDest, explicitDest;
								return _regenerator["default"].wrap(
									function _callee$(_context) {
										while (1) {
											switch (_context.prev =
												_context.next) {
												case 0:
													if (this
														.pdfDocument) {
														_context.next =
															2;
														break;
													}

													return _context
														.abrupt(
															"return");

												case 2:
													if (!(typeof dest ===
															"string")) {
														_context.next =
															9;
														break;
													}

													namedDest = dest;
													_context.next = 6;
													return this
														.pdfDocument
														.getDestination(
															dest);

												case 6:
													explicitDest =
														_context.sent;
													_context.next = 13;
													break;

												case 9:
													namedDest = null;
													_context.next = 12;
													return dest;

												case 12:
													explicitDest =
														_context.sent;

												case 13:
													if (Array.isArray(
															explicitDest
															)) {
														_context.next =
															16;
														break;
													}

													console.error(
														"PDFLinkService.goToDestination: \""
														.concat(
															explicitDest,
															"\" is not "
															) +
														"a valid destination array, for dest=\""
														.concat(
															dest,
															"\"."));
													return _context
														.abrupt(
															"return");

												case 16:
													_classPrivateMethodGet
														(this,
															_goToDestinationHelper,
															_goToDestinationHelper2
															).call(this,
															dest,
															namedDest,
															explicitDest
															);

												case 17:
												case "end":
													return _context
														.stop();
											}
										}
									}, _callee, this);
							}));

						function goToDestination(_x) {
							return _goToDestination.apply(this, arguments);
						}

						return goToDestination;
					}()
				}, {
					key: "goToPage",
					value: function goToPage(val) {
						if (!this.pdfDocument) {
							return;
						}

						var pageNumber = typeof val === "string" && this.pdfViewer
							.pageLabelToPageNumber(val) || val | 0;

						if (!(Number.isInteger(pageNumber) && pageNumber > 0 &&
								pageNumber <= this.pagesCount)) {
							console.error("PDFLinkService.goToPage: \"".concat(val,
								"\" is not a valid page."));
							return;
						}

						if (this.pdfHistory) {
							this.pdfHistory.pushCurrentPosition();
							this.pdfHistory.pushPage(pageNumber);
						}

						this.pdfViewer.scrollPageIntoView({
							pageNumber: pageNumber
						});
					}
				}, {
					key: "addLinkAttributes",
					value: function addLinkAttributes(link, url) {
						var newWindow = arguments.length > 2 && arguments[2] !==
							undefined ? arguments[2] : false;

						_addLinkAttributes(link, {
							url: url,
							target: newWindow ? LinkTarget.BLANK : this
								.externalLinkTarget,
							rel: this.externalLinkRel,
							enabled: this.externalLinkEnabled
						});
					}
				}, {
					key: "getDestinationHash",
					value: function getDestinationHash(dest) {
						if (typeof dest === "string") {
							if (dest.length > 0) {
								return this.getAnchorUrl("#" + escape(dest));
							}
						} else if (Array.isArray(dest)) {
							var str = JSON.stringify(dest);

							if (str.length > 0) {
								return this.getAnchorUrl("#" + escape(str));
							}
						}

						return this.getAnchorUrl("");
					}
				}, {
					key: "getAnchorUrl",
					value: function getAnchorUrl(anchor) {
						return (this.baseUrl || "") + anchor;
					}
				}, {
					key: "setHash",
					value: function setHash(hash) {
						if (!this.pdfDocument) {
							return;
						}

						var pageNumber, dest;

						if (hash.includes("=")) {
							var params = (0, _ui_utils.parseQueryString)(hash);

							if (params.has("search")) {
								this.eventBus.dispatch("findfromurlhash", {
									source: this,
									query: params.get("search").replace(
										/"/g, ""),
									phraseSearch: params.get("phrase") ===
										"true"
								});
							}

							if (params.has("page")) {
								pageNumber = params.get("page") | 0 || 1;
							}

							if (params.has("zoom")) {
								var zoomArgs = params.get("zoom").split(",");
								var zoomArg = zoomArgs[0];
								var zoomArgNumber = parseFloat(zoomArg);

								if (!zoomArg.includes("Fit")) {
									dest = [null, {
											name: "XYZ"
										}, zoomArgs.length > 1 ? zoomArgs[1] |
										0 : null, zoomArgs.length > 2 ?
										zoomArgs[2] | 0 : null, zoomArgNumber ?
										zoomArgNumber / 100 : zoomArg
									];
								} else {
									if (zoomArg === "Fit" || zoomArg === "FitB") {
										dest = [null, {
											name: zoomArg
										}];
									} else if (zoomArg === "FitH" || zoomArg ===
										"FitBH" || zoomArg === "FitV" || zoomArg ===
										"FitBV") {
										dest = [null, {
												name: zoomArg
											}, zoomArgs.length > 1 ? zoomArgs[
											1] | 0 : null
										];
									} else if (zoomArg === "FitR") {
										if (zoomArgs.length !== 5) {
											console.error(
												'PDFLinkService.setHash: Not enough parameters for "FitR".'
												);
										} else {
											dest = [null, {
													name: zoomArg
												}, zoomArgs[1] | 0, zoomArgs[
												2] | 0, zoomArgs[3] | 0,
												zoomArgs[4] | 0
											];
										}
									} else {
										console.error("PDFLinkService.setHash: \""
											.concat(zoomArg,
												"\" is not a valid zoom value.")
											);
									}
								}
							}

							if (dest) {
								this.pdfViewer.scrollPageIntoView({
									pageNumber: pageNumber || this.page,
									destArray: dest,
									allowNegativeOffset: true
								});
							} else if (pageNumber) {
								this.page = pageNumber;
							}

							if (params.has("pagemode")) {
								this.eventBus.dispatch("pagemode", {
									source: this,
									mode: params.get("pagemode")
								});
							}

							if (params.has("nameddest")) {
								this.goToDestination(params.get("nameddest"));
							}
						} else {
							dest = unescape(hash);

							try {
								dest = JSON.parse(dest);

								if (!Array.isArray(dest)) {
									dest = dest.toString();
								}
							} catch (ex) {}

							if (typeof dest === "string" ||
								_classStaticPrivateMethodGet(PDFLinkService,
									PDFLinkService, _isValidExplicitDestination)
								.call(PDFLinkService, dest)) {
								this.goToDestination(dest);
								return;
							}

							console.error("PDFLinkService.setHash: \"".concat(
								unescape(hash),
								"\" is not a valid destination."));
						}
					}
				}, {
					key: "executeNamedAction",
					value: function executeNamedAction(action) {
						var _this$pdfHistory, _this$pdfHistory2;

						switch (action) {
							case "GoBack":
								(_this$pdfHistory = this.pdfHistory) === null ||
									_this$pdfHistory === void 0 ? void 0 :
									_this$pdfHistory.back();
								break;

							case "GoForward":
								(_this$pdfHistory2 = this.pdfHistory) === null ||
									_this$pdfHistory2 === void 0 ? void 0 :
									_this$pdfHistory2.forward();
								break;

							case "NextPage":
								this.pdfViewer.nextPage();
								break;

							case "PrevPage":
								this.pdfViewer.previousPage();
								break;

							case "LastPage":
								this.page = this.pagesCount;
								break;

							case "FirstPage":
								this.page = 1;
								break;

							default:
								break;
						}

						this.eventBus.dispatch("namedaction", {
							source: this,
							action: action
						});
					}
				}, {
					key: "cachePageRef",
					value: function cachePageRef(pageNum, pageRef) {
						if (!pageRef) {
							return;
						}

						var refStr = pageRef.gen === 0 ? "".concat(pageRef.num,
							"R") : "".concat(pageRef.num, "R").concat(pageRef.gen);

						_classPrivateFieldGet(this, _pagesRefCache).set(refStr,
							pageNum);
					}
				}, {
					key: "_cachedPageNumber",
					value: function _cachedPageNumber(pageRef) {
						if (!pageRef) {
							return null;
						}

						var refStr = pageRef.gen === 0 ? "".concat(pageRef.num,
							"R") : "".concat(pageRef.num, "R").concat(pageRef.gen);
						return _classPrivateFieldGet(this, _pagesRefCache).get(
							refStr) || null;
					}
				}, {
					key: "isPageVisible",
					value: function isPageVisible(pageNumber) {
						return this.pdfViewer.isPageVisible(pageNumber);
					}
				}, {
					key: "isPageCached",
					value: function isPageCached(pageNumber) {
						return this.pdfViewer.isPageCached(pageNumber);
					}
				}]);

				return PDFLinkService;
			}();

			exports.PDFLinkService = PDFLinkService;

			function _goToDestinationHelper2(rawDest) {
				var _this = this;

				var namedDest = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] :
				null;
				var explicitDest = arguments.length > 2 ? arguments[2] : undefined;
				var destRef = explicitDest[0];
				var pageNumber;

				if (_typeof(destRef) === "object" && destRef !== null) {
					pageNumber = this._cachedPageNumber(destRef);

					if (!pageNumber) {
						this.pdfDocument.getPageIndex(destRef).then(function(pageIndex) {
							_this.cachePageRef(pageIndex + 1, destRef);

							_classPrivateMethodGet(_this, _goToDestinationHelper,
								_goToDestinationHelper2).call(_this, rawDest, namedDest,
								explicitDest);
						})["catch"](function() {
							console.error("PDFLinkService.#goToDestinationHelper: \"".concat(
									destRef, "\" is not ") +
								"a valid page reference, for dest=\"".concat(rawDest, "\".")
								);
						});
						return;
					}
				} else if (Number.isInteger(destRef)) {
					pageNumber = destRef + 1;
				} else {
					console.error("PDFLinkService.#goToDestinationHelper: \"".concat(destRef,
						"\" is not ") + "a valid destination reference, for dest=\"".concat(
						rawDest, "\"."));
					return;
				}

				if (!pageNumber || pageNumber < 1 || pageNumber > this.pagesCount) {
					console.error("PDFLinkService.#goToDestinationHelper: \"".concat(pageNumber,
						"\" is not ") + "a valid page number, for dest=\"".concat(rawDest,
						"\"."));
					return;
				}

				if (this.pdfHistory) {
					this.pdfHistory.pushCurrentPosition();
					this.pdfHistory.push({
						namedDest: namedDest,
						explicitDest: explicitDest,
						pageNumber: pageNumber
					});
				}

				this.pdfViewer.scrollPageIntoView({
					pageNumber: pageNumber,
					destArray: explicitDest,
					ignoreDestinationZoom: this._ignoreDestinationZoom
				});
			}

			function _isValidExplicitDestination(dest) {
				if (!Array.isArray(dest)) {
					return false;
				}

				var destLength = dest.length;

				if (destLength < 2) {
					return false;
				}

				var page = dest[0];

				if (!(_typeof(page) === "object" && Number.isInteger(page.num) && Number.isInteger(page
						.gen)) && !(Number.isInteger(page) && page >= 0)) {
					return false;
				}

				var zoom = dest[1];

				if (!(_typeof(zoom) === "object" && typeof zoom.name === "string")) {
					return false;
				}

				var allowNull = true;

				switch (zoom.name) {
					case "XYZ":
						if (destLength !== 5) {
							return false;
						}

						break;

					case "Fit":
					case "FitB":
						return destLength === 2;

					case "FitH":
					case "FitBH":
					case "FitV":
					case "FitBV":
						if (destLength !== 3) {
							return false;
						}

						break;

					case "FitR":
						if (destLength !== 6) {
							return false;
						}

						allowNull = false;
						break;

					default:
						return false;
				}

				for (var i = 2; i < destLength; i++) {
					var param = dest[i];

					if (!(typeof param === "number" || allowNull && param === null)) {
						return false;
					}
				}

				return true;
			}

			var SimpleLinkService = /*#__PURE__*/ function() {
				function SimpleLinkService() {
					_classCallCheck(this, SimpleLinkService);

					this.externalLinkEnabled = true;
				}

				_createClass(SimpleLinkService, [{
					key: "pagesCount",
					get: function get() {
						return 0;
					}
				}, {
					key: "page",
					get: function get() {
						return 0;
					},
					set: function set(value) {}
				}, {
					key: "rotation",
					get: function get() {
						return 0;
					},
					set: function set(value) {}
				}, {
					key: "goToDestination",
					value: function() {
						var _goToDestination2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee2(
							dest) {
								return _regenerator["default"].wrap(
									function _callee2$(_context2) {
										while (1) {
											switch (_context2.prev =
												_context2.next) {
												case 0:
												case "end":
													return _context2
														.stop();
											}
										}
									}, _callee2);
							}));

						function goToDestination(_x2) {
							return _goToDestination2.apply(this, arguments);
						}

						return goToDestination;
					}()
				}, {
					key: "goToPage",
					value: function goToPage(val) {}
				}, {
					key: "addLinkAttributes",
					value: function addLinkAttributes(link, url) {
						var newWindow = arguments.length > 2 && arguments[2] !==
							undefined ? arguments[2] : false;

						_addLinkAttributes(link, {
							url: url,
							enabled: this.externalLinkEnabled
						});
					}
				}, {
					key: "getDestinationHash",
					value: function getDestinationHash(dest) {
						return "#";
					}
				}, {
					key: "getAnchorUrl",
					value: function getAnchorUrl(hash) {
						return "#";
					}
				}, {
					key: "setHash",
					value: function setHash(hash) {}
				}, {
					key: "executeNamedAction",
					value: function executeNamedAction(action) {}
				}, {
					key: "cachePageRef",
					value: function cachePageRef(pageNum, pageRef) {}
				}, {
					key: "isPageVisible",
					value: function isPageVisible(pageNumber) {
						return true;
					}
				}, {
					key: "isPageCached",
					value: function isPageCached(pageNumber) {
						return true;
					}
				}]);

				return SimpleLinkService;
			}();

			exports.SimpleLinkService = SimpleLinkService;

			/***/
		}),
		/* 11 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.OverlayManager = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

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

			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);
				}
			}

			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);
					});
				};
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var OverlayManager = /*#__PURE__*/ function() {
				function OverlayManager() {
					_classCallCheck(this, OverlayManager);

					this._overlays = {};
					this._active = null;
					this._keyDownBound = this._keyDown.bind(this);
				}

				_createClass(OverlayManager, [{
					key: "active",
					get: function get() {
						return this._active;
					}
				}, {
					key: "register",
					value: function() {
						var _register = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee(name,
								element) {
								var callerCloseMethod,
									canForceClose,
									container,
									_args = arguments;
								return _regenerator["default"].wrap(
									function _callee$(_context) {
										while (1) {
											switch (_context.prev =
												_context.next) {
												case 0:
													callerCloseMethod =
														_args.length >
														2 && _args[
														2] !==
														undefined ?
														_args[2] : null;
													canForceClose =
														_args.length >
														3 && _args[
														3] !==
														undefined ?
														_args[3] :
														false;

													if (!(!name || !
															element || !
															(container =
																element
																.parentNode
																))) {
														_context.next =
															6;
														break;
													}

													throw new Error(
														"Not enough parameters."
														);

												case 6:
													if (!this._overlays[
															name]) {
														_context.next =
															8;
														break;
													}

													throw new Error(
														"The overlay is already registered."
														);

												case 8:
													this._overlays[
														name] = {
															element: element,
															container: container,
															callerCloseMethod: callerCloseMethod,
															canForceClose: canForceClose
														};

												case 9:
												case "end":
													return _context
														.stop();
											}
										}
									}, _callee, this);
							}));

						function register(_x, _x2) {
							return _register.apply(this, arguments);
						}

						return register;
					}()
				}, {
					key: "unregister",
					value: function() {
						var _unregister = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee2(
							name) {
								return _regenerator["default"].wrap(
									function _callee2$(_context2) {
										while (1) {
											switch (_context2.prev =
												_context2.next) {
												case 0:
													if (this._overlays[
															name]) {
														_context2.next =
															4;
														break;
													}

													throw new Error(
														"The overlay does not exist."
														);

												case 4:
													if (!(this
															._active ===
															name)) {
														_context2.next =
															6;
														break;
													}

													throw new Error(
														"The overlay cannot be removed while it is active."
														);

												case 6:
													delete this
														._overlays[
														name];

												case 7:
												case "end":
													return _context2
														.stop();
											}
										}
									}, _callee2, this);
							}));

						function unregister(_x3) {
							return _unregister.apply(this, arguments);
						}

						return unregister;
					}()
				}, {
					key: "open",
					value: function() {
						var _open = _asyncToGenerator( /*#__PURE__*/ _regenerator[
							"default"].mark(function _callee3(name) {
							return _regenerator["default"].wrap(
								function _callee3$(_context3) {
									while (1) {
										switch (_context3.prev =
											_context3.next) {
											case 0:
												if (this._overlays[
														name]) {
													_context3.next =
														4;
													break;
												}

												throw new Error(
													"The overlay does not exist."
													);

											case 4:
												if (!this._active) {
													_context3.next =
														14;
													break;
												}

												if (!this._overlays[
														name]
													.canForceClose
													) {
													_context3.next =
														9;
													break;
												}

												this
											._closeThroughCaller();

												_context3.next = 14;
												break;

											case 9:
												if (!(this
														._active ===
														name)) {
													_context3.next =
														13;
													break;
												}

												throw new Error(
													"The overlay is already active."
													);

											case 13:
												throw new Error(
													"Another overlay is currently active."
													);

											case 14:
												this._active = name;

												this._overlays[this
														._active]
													.element
													.classList
													.remove(
														"hidden");

												this._overlays[this
														._active]
													.container
													.classList
													.remove(
														"hidden");

												window
													.addEventListener(
														"keydown",
														this
														._keyDownBound
														);

											case 18:
											case "end":
												return _context3
													.stop();
										}
									}
								}, _callee3, this);
						}));

						function open(_x4) {
							return _open.apply(this, arguments);
						}

						return open;
					}()
				}, {
					key: "close",
					value: function() {
						var _close = _asyncToGenerator( /*#__PURE__*/ _regenerator[
							"default"].mark(function _callee4(name) {
							return _regenerator["default"].wrap(
								function _callee4$(_context4) {
									while (1) {
										switch (_context4.prev =
											_context4.next) {
											case 0:
												if (this._overlays[
														name]) {
													_context4.next =
														4;
													break;
												}

												throw new Error(
													"The overlay does not exist."
													);

											case 4:
												if (this._active) {
													_context4.next =
														8;
													break;
												}

												throw new Error(
													"The overlay is currently not active."
													);

											case 8:
												if (!(this
														._active !==
														name)) {
													_context4.next =
														10;
													break;
												}

												throw new Error(
													"Another overlay is currently active."
													);

											case 10:
												this._overlays[this
														._active]
													.container
													.classList.add(
														"hidden");

												this._overlays[this
														._active]
													.element
													.classList.add(
														"hidden");

												this._active = null;
												window
													.removeEventListener(
														"keydown",
														this
														._keyDownBound
														);

											case 14:
											case "end":
												return _context4
													.stop();
										}
									}
								}, _callee4, this);
						}));

						function close(_x5) {
							return _close.apply(this, arguments);
						}

						return close;
					}()
				}, {
					key: "_keyDown",
					value: function _keyDown(evt) {
						if (this._active && evt.keyCode === 27) {
							this._closeThroughCaller();

							evt.preventDefault();
						}
					}
				}, {
					key: "_closeThroughCaller",
					value: function _closeThroughCaller() {
						if (this._overlays[this._active].callerCloseMethod) {
							this._overlays[this._active].callerCloseMethod();
						}

						if (this._active) {
							this.close(this._active);
						}
					}
				}]);

				return OverlayManager;
			}();

			exports.OverlayManager = OverlayManager;

			/***/
		}),
		/* 12 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PasswordPrompt = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _pdfjsLib = __webpack_require__(7);

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

			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);
				}
			}

			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);
					});
				};
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			function _classPrivateMethodInitSpec(obj, privateSet) {
				_checkPrivateRedeclaration(obj, privateSet);
				privateSet.add(obj);
			}

			function _checkPrivateRedeclaration(obj, privateCollection) {
				if (privateCollection.has(obj)) {
					throw new TypeError(
						"Cannot initialize the same private elements twice on an object");
				}
			}

			function _classPrivateMethodGet(receiver, privateSet, fn) {
				if (!privateSet.has(receiver)) {
					throw new TypeError("attempted to get private field on non-instance");
				}
				return fn;
			}

			var _verify = /*#__PURE__*/ new WeakSet();

			var _cancel = /*#__PURE__*/ new WeakSet();

			var PasswordPrompt = /*#__PURE__*/ function() {
				function PasswordPrompt(options, overlayManager, l10n) {
					var _this = this;

					var isViewerEmbedded = arguments.length > 3 && arguments[3] !== undefined ?
						arguments[3] : false;

					_classCallCheck(this, PasswordPrompt);

					_classPrivateMethodInitSpec(this, _cancel);

					_classPrivateMethodInitSpec(this, _verify);

					this.overlayName = options.overlayName;
					this.container = options.container;
					this.label = options.label;
					this.input = options.input;
					this.submitButton = options.submitButton;
					this.cancelButton = options.cancelButton;
					this.overlayManager = overlayManager;
					this.l10n = l10n;
					this._isViewerEmbedded = isViewerEmbedded;
					this.updateCallback = null;
					this.reason = null;
					this.submitButton.addEventListener("click", _classPrivateMethodGet(this,
						_verify, _verify2).bind(this));
					this.cancelButton.addEventListener("click", _classPrivateMethodGet(this,
						_cancel, _cancel2).bind(this));
					this.input.addEventListener("keydown", function(e) {
						if (e.keyCode === 13) {
							_classPrivateMethodGet(_this, _verify, _verify2).call(_this);
						}
					});
					this.overlayManager.register(this.overlayName, this.container,
						_classPrivateMethodGet(this, _cancel, _cancel2).bind(this), true);
				}

				_createClass(PasswordPrompt, [{
					key: "open",
					value: function() {
						var _open = _asyncToGenerator( /*#__PURE__*/ _regenerator[
							"default"].mark(function _callee() {
							var passwordIncorrect;
							return _regenerator["default"].wrap(
								function _callee$(_context) {
									while (1) {
										switch (_context.prev =
											_context.next) {
											case 0:
												_context.next = 2;
												return this
													.overlayManager
													.open(this
														.overlayName
														);

											case 2:
												passwordIncorrect =
													this.reason ===
													_pdfjsLib
													.PasswordResponses
													.INCORRECT_PASSWORD;

												if (!this
													._isViewerEmbedded ||
													passwordIncorrect
													) {
													this.input
														.focus();
												}

												_context.next = 6;
												return this.l10n
													.get("password_"
														.concat(
															passwordIncorrect ?
															"invalid" :
															"label")
														);

											case 6:
												this.label
													.textContent =
													_context.sent;

											case 7:
											case "end":
												return _context
													.stop();
										}
									}
								}, _callee, this);
						}));

						function open() {
							return _open.apply(this, arguments);
						}

						return open;
					}()
				}, {
					key: "close",
					value: function() {
						var _close = _asyncToGenerator( /*#__PURE__*/ _regenerator[
							"default"].mark(function _callee2() {
							return _regenerator["default"].wrap(
								function _callee2$(_context2) {
									while (1) {
										switch (_context2.prev =
											_context2.next) {
											case 0:
												_context2.next = 2;
												return this
													.overlayManager
													.close(this
														.overlayName
														);

											case 2:
												this.input.value =
													"";

											case 3:
											case "end":
												return _context2
													.stop();
										}
									}
								}, _callee2, this);
						}));

						function close() {
							return _close.apply(this, arguments);
						}

						return close;
					}()
				}, {
					key: "setUpdateCallback",
					value: function setUpdateCallback(updateCallback, reason) {
						this.updateCallback = updateCallback;
						this.reason = reason;
					}
				}]);

				return PasswordPrompt;
			}();

			exports.PasswordPrompt = PasswordPrompt;

			function _verify2() {
				var password = this.input.value;

				if ((password === null || password === void 0 ? void 0 : password.length) > 0) {
					this.close();
					this.updateCallback(password);
				}
			}

			function _cancel2() {
				this.close();
				this.updateCallback(new Error("PasswordPrompt cancelled."));
			}

			/***/
		}),
		/* 13 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



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

			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFAttachmentViewer = void 0;

			var _pdfjsLib = __webpack_require__(7);

			var _base_tree_viewer = __webpack_require__(14);

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

			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);
			}

			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;
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			function _get() {
				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(arguments.length < 3 ? target : receiver);
						}
						return desc.value;
					};
				}
				return _get.apply(this, arguments);
			}

			function _superPropBase(object, property) {
				while (!Object.prototype.hasOwnProperty.call(object, property)) {
					object = _getPrototypeOf(object);
					if (object === null) break;
				}
				return object;
			}

			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
					}
				});
				Object.defineProperty(subClass, "prototype", {
					writable: false
				});
				if (superClass) _setPrototypeOf(subClass, superClass);
			}

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

			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);
				};
			}

			function _possibleConstructorReturn(self, call) {
				if (call && (_typeof(call) === "object" || typeof call === "function")) {
					return call;
				} else if (call !== void 0) {
					throw new TypeError("Derived constructors may only return object or undefined");
				}
				return _assertThisInitialized(self);
			}

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

			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;
				}
			}

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

			var PDFAttachmentViewer = /*#__PURE__*/ function(_BaseTreeViewer) {
				_inherits(PDFAttachmentViewer, _BaseTreeViewer);

				var _super = _createSuper(PDFAttachmentViewer);

				function PDFAttachmentViewer(options) {
					var _this;

					_classCallCheck(this, PDFAttachmentViewer);

					_this = _super.call(this, options);
					_this.downloadManager = options.downloadManager;

					_this.eventBus._on("fileattachmentannotation", _this._appendAttachment.bind(
						_assertThisInitialized(_this)));

					return _this;
				}

				_createClass(PDFAttachmentViewer, [{
					key: "reset",
					value: function reset() {
						var keepRenderedCapability = arguments.length > 0 &&
							arguments[0] !== undefined ? arguments[0] : false;

						_get(_getPrototypeOf(PDFAttachmentViewer.prototype),
							"reset", this).call(this);

						this._attachments = null;

						if (!keepRenderedCapability) {
							this._renderedCapability = (0, _pdfjsLib
								.createPromiseCapability)();
						}

						if (this._pendingDispatchEvent) {
							clearTimeout(this._pendingDispatchEvent);
						}

						this._pendingDispatchEvent = null;
					}
				}, {
					key: "_dispatchEvent",
					value: function _dispatchEvent(attachmentsCount) {
						var _this2 = this;

						this._renderedCapability.resolve();

						if (this._pendingDispatchEvent) {
							clearTimeout(this._pendingDispatchEvent);
							this._pendingDispatchEvent = null;
						}

						if (attachmentsCount === 0) {
							this._pendingDispatchEvent = setTimeout(function() {
								_this2.eventBus.dispatch(
									"attachmentsloaded", {
										source: _this2,
										attachmentsCount: 0
									});

								_this2._pendingDispatchEvent = null;
							});
							return;
						}

						this.eventBus.dispatch("attachmentsloaded", {
							source: this,
							attachmentsCount: attachmentsCount
						});
					}
				}, {
					key: "_bindLink",
					value: function _bindLink(element, _ref) {
						var _this3 = this;

						var content = _ref.content,
							filename = _ref.filename;

						element.onclick = function() {
							_this3.downloadManager.openOrDownloadData(element,
								content, filename);

							return false;
						};
					}
				}, {
					key: "render",
					value: function render(_ref2) {
						var attachments = _ref2.attachments,
							_ref2$keepRenderedCap = _ref2.keepRenderedCapability,
							keepRenderedCapability = _ref2$keepRenderedCap ===
							void 0 ? false : _ref2$keepRenderedCap;

						if (this._attachments) {
							this.reset(keepRenderedCapability);
						}

						this._attachments = attachments || null;

						if (!attachments) {
							this._dispatchEvent(0);

							return;
						}

						var names = Object.keys(attachments).sort(function(a, b) {
							return a.toLowerCase().localeCompare(b
								.toLowerCase());
						});
						var fragment = document.createDocumentFragment();
						var attachmentsCount = 0;

						var _iterator = _createForOfIteratorHelper(names),
							_step;

						try {
							for (_iterator.s(); !(_step = _iterator.n()).done;) {
								var name = _step.value;
								var item = attachments[name];
								var content = item.content,
									filename = (0, _pdfjsLib.getFilenameFromUrl)(
										item.filename);
								var div = document.createElement("div");
								div.className = "treeItem";
								var element = document.createElement("a");

								this._bindLink(element, {
									content: content,
									filename: filename
								});

								element.textContent = this._normalizeTextContent(
									filename);
								div.appendChild(element);
								fragment.appendChild(div);
								attachmentsCount++;
							}
						} catch (err) {
							_iterator.e(err);
						} finally {
							_iterator.f();
						}

						this._finishRendering(fragment, attachmentsCount);
					}
				}, {
					key: "_appendAttachment",
					value: function _appendAttachment(_ref3) {
						var _this4 = this;

						var id = _ref3.id,
							filename = _ref3.filename,
							content = _ref3.content;
						var renderedPromise = this._renderedCapability.promise;
						renderedPromise.then(function() {
							if (renderedPromise !== _this4
								._renderedCapability.promise) {
								return;
							}

							var attachments = _this4._attachments;

							if (!attachments) {
								attachments = Object.create(null);
							} else {
								for (var name in attachments) {
									if (id === name) {
										return;
									}
								}
							}

							attachments[id] = {
								filename: filename,
								content: content
							};

							_this4.render({
								attachments: attachments,
								keepRenderedCapability: true
							});
						});
					}
				}]);

				return PDFAttachmentViewer;
			}(_base_tree_viewer.BaseTreeViewer);

			exports.PDFAttachmentViewer = PDFAttachmentViewer;

			/***/
		}),
		/* 14 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.BaseTreeViewer = void 0;

			var _ui_utils = __webpack_require__(5);

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

			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);
			}

			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;
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var TREEITEM_OFFSET_TOP = -100;
			var TREEITEM_SELECTED_CLASS = "selected";

			var BaseTreeViewer = /*#__PURE__*/ function() {
				function BaseTreeViewer(options) {
					_classCallCheck(this, BaseTreeViewer);

					if (this.constructor === BaseTreeViewer) {
						throw new Error("Cannot initialize BaseTreeViewer.");
					}

					this.container = options.container;
					this.eventBus = options.eventBus;
					this.reset();
				}

				_createClass(BaseTreeViewer, [{
					key: "reset",
					value: function reset() {
						this._pdfDocument = null;
						this._lastToggleIsShow = true;
						this._currentTreeItem = null;
						this.container.textContent = "";
						this.container.classList.remove("treeWithDeepNesting");
					}
				}, {
					key: "_dispatchEvent",
					value: function _dispatchEvent(count) {
						throw new Error("Not implemented: _dispatchEvent");
					}
				}, {
					key: "_bindLink",
					value: function _bindLink(element, params) {
						throw new Error("Not implemented: _bindLink");
					}
				}, {
					key: "_normalizeTextContent",
					value: function _normalizeTextContent(str) {
						return (0, _ui_utils.removeNullCharacters)(str, true) ||
							"\u2013";
					}
				}, {
					key: "_addToggleButton",
					value: function _addToggleButton(div) {
						var _this = this;

						var hidden = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : false;
						var toggler = document.createElement("div");
						toggler.className = "treeItemToggler";

						if (hidden) {
							toggler.classList.add("treeItemsHidden");
						}

						toggler.onclick = function(evt) {
							evt.stopPropagation();
							toggler.classList.toggle("treeItemsHidden");

							if (evt.shiftKey) {
								var shouldShowAll = !toggler.classList.contains(
									"treeItemsHidden");

								_this._toggleTreeItem(div, shouldShowAll);
							}
						};

						div.insertBefore(toggler, div.firstChild);
					}
				}, {
					key: "_toggleTreeItem",
					value: function _toggleTreeItem(root) {
						var show = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : false;
						this._lastToggleIsShow = show;

						var _iterator = _createForOfIteratorHelper(root
								.querySelectorAll(".treeItemToggler")),
							_step;

						try {
							for (_iterator.s(); !(_step = _iterator.n()).done;) {
								var toggler = _step.value;
								toggler.classList.toggle("treeItemsHidden", !show);
							}
						} catch (err) {
							_iterator.e(err);
						} finally {
							_iterator.f();
						}
					}
				}, {
					key: "_toggleAllTreeItems",
					value: function _toggleAllTreeItems() {
						this._toggleTreeItem(this.container, !this
							._lastToggleIsShow);
					}
				}, {
					key: "_finishRendering",
					value: function _finishRendering(fragment, count) {
						var hasAnyNesting = arguments.length > 2 && arguments[2] !==
							undefined ? arguments[2] : false;

						if (hasAnyNesting) {
							this.container.classList.add("treeWithDeepNesting");
							this._lastToggleIsShow = !fragment.querySelector(
								".treeItemsHidden");
						}

						this.container.appendChild(fragment);

						this._dispatchEvent(count);
					}
				}, {
					key: "render",
					value: function render(params) {
						throw new Error("Not implemented: render");
					}
				}, {
					key: "_updateCurrentTreeItem",
					value: function _updateCurrentTreeItem() {
						var treeItem = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : null;

						if (this._currentTreeItem) {
							this._currentTreeItem.classList.remove(
								TREEITEM_SELECTED_CLASS);

							this._currentTreeItem = null;
						}

						if (treeItem) {
							treeItem.classList.add(TREEITEM_SELECTED_CLASS);
							this._currentTreeItem = treeItem;
						}
					}
				}, {
					key: "_scrollToCurrentTreeItem",
					value: function _scrollToCurrentTreeItem(treeItem) {
						if (!treeItem) {
							return;
						}

						var currentNode = treeItem.parentNode;

						while (currentNode && currentNode !== this.container) {
							if (currentNode.classList.contains("treeItem")) {
								var toggler = currentNode.firstElementChild;
								toggler === null || toggler === void 0 ? void 0 :
									toggler.classList.remove("treeItemsHidden");
							}

							currentNode = currentNode.parentNode;
						}

						this._updateCurrentTreeItem(treeItem);

						this.container.scrollTo(treeItem.offsetLeft, treeItem
							.offsetTop + TREEITEM_OFFSET_TOP);
					}
				}]);

				return BaseTreeViewer;
			}();

			exports.BaseTreeViewer = BaseTreeViewer;

			/***/
		}),
		/* 15 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFDocumentProperties = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _pdfjsLib = __webpack_require__(7);

			var _ui_utils = __webpack_require__(5);

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

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

			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."
					);
			}

			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);
			}

			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;
			}

			function _iterableToArrayLimit(arr, i) {
				var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] ||
					arr["@@iterator"];
				if (_i == null) return;
				var _arr = [];
				var _n = true;
				var _d = false;
				var _s, _e;
				try {
					for (_i = _i.call(arr); !(_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;
			}

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

			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);
				}
			}

			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);
					});
				};
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var DEFAULT_FIELD_CONTENT = "-";
			var NON_METRIC_LOCALES = ["en-us", "en-lr", "my"];
			var US_PAGE_NAMES = {
				"8.5x11": "Letter",
				"8.5x14": "Legal"
			};
			var METRIC_PAGE_NAMES = {
				"297x420": "A3",
				"210x297": "A4"
			};

			function getPageName(size, isPortrait, pageNames) {
				var width = isPortrait ? size.width : size.height;
				var height = isPortrait ? size.height : size.width;
				return pageNames["".concat(width, "x").concat(height)];
			}

			var PDFDocumentProperties = /*#__PURE__*/ function() {
				function PDFDocumentProperties(_ref, overlayManager, eventBus, l10n) {
					var _this = this;

					var overlayName = _ref.overlayName,
						fields = _ref.fields,
						container = _ref.container,
						closeButton = _ref.closeButton;

					_classCallCheck(this, PDFDocumentProperties);

					this.overlayName = overlayName;
					this.fields = fields;
					this.container = container;
					this.overlayManager = overlayManager;
					this.l10n = l10n;

					this._reset();

					closeButton.addEventListener("click", this.close.bind(this));
					this.overlayManager.register(this.overlayName, this.container, this.close.bind(
						this));

					eventBus._on("pagechanging", function(evt) {
						_this._currentPageNumber = evt.pageNumber;
					});

					eventBus._on("rotationchanging", function(evt) {
						_this._pagesRotation = evt.pagesRotation;
					});

					this._isNonMetricLocale = true;
					l10n.getLanguage().then(function(locale) {
						_this._isNonMetricLocale = NON_METRIC_LOCALES.includes(locale);
					});
				}

				_createClass(PDFDocumentProperties, [{
					key: "open",
					value: function() {
						var _open = _asyncToGenerator( /*#__PURE__*/ _regenerator[
							"default"].mark(function _callee() {
							var _this2 = this;

							var freezeFieldData, currentPageNumber,
								pagesRotation, _yield$this$pdfDocume,
								info, contentDispositionFilename,
								contentLength, _yield$Promise$all,
								_yield$Promise$all2, fileName, fileSize,
								creationDate, modificationDate,
								pageSize, isLinearized,
								_yield$this$pdfDocume2, length, data;

							return _regenerator["default"].wrap(
								function _callee$(_context) {
									while (1) {
										switch (_context.prev =
											_context.next) {
											case 0:
												freezeFieldData =
													function freezeFieldData(
														data) {
														Object
															.defineProperty(
																_this2,
																"fieldData", {
																	value: Object
																		.freeze(
																			data
																			),
																	writable: false,
																	enumerable: true,
																	configurable: true
																});
													};

												_context.next = 3;
												return Promise.all([
													this
													.overlayManager
													.open(
														this
														.overlayName
														),
													this
													._dataAvailableCapability
													.promise
												]);

											case 3:
												currentPageNumber =
													this
													._currentPageNumber;
												pagesRotation = this
													._pagesRotation;

												if (!(this
														.fieldData &&
														currentPageNumber ===
														this
														.fieldData
														._currentPageNumber &&
														pagesRotation ===
														this
														.fieldData
														._pagesRotation
														)) {
													_context.next =
														8;
													break;
												}

												this._updateUI();

												return _context
													.abrupt(
														"return");

											case 8:
												_context.next = 10;
												return this
													.pdfDocument
													.getMetadata();

											case 10:
												_yield$this$pdfDocume
													= _context.sent;
												info =
													_yield$this$pdfDocume
													.info;
												contentDispositionFilename
													=
													_yield$this$pdfDocume
													.contentDispositionFilename;
												contentLength =
													_yield$this$pdfDocume
													.contentLength;
												_context.next = 16;
												return Promise.all([
													contentDispositionFilename ||
													(0, _pdfjsLib
														.getPdfFilenameFromUrl
														)(
														this
														.url
														),
													this
													._parseFileSize(
														contentLength
														),
													this
													._parseDate(
														info
														.CreationDate
														),
													this
													._parseDate(
														info
														.ModDate
														),
													this
													.pdfDocument
													.getPage(
														currentPageNumber
														)
													.then(
														function(
															pdfPage
															) {
															return _this2
																._parsePageSize(
																	(0, _ui_utils
																		.getPageSizeInches
																		)
																	(
																		pdfPage),
																	pagesRotation
																	);
														}),
													this
													._parseLinearization(
														info
														.IsLinearized
														)
												]);

											case 16:
												_yield$Promise$all =
													_context.sent;
												_yield$Promise$all2
													=
													_slicedToArray(
														_yield$Promise$all,
														6);
												fileName =
													_yield$Promise$all2[
														0];
												fileSize =
													_yield$Promise$all2[
														1];
												creationDate =
													_yield$Promise$all2[
														2];
												modificationDate =
													_yield$Promise$all2[
														3];
												pageSize =
													_yield$Promise$all2[
														4];
												isLinearized =
													_yield$Promise$all2[
														5];
												freezeFieldData({
													fileName: fileName,
													fileSize: fileSize,
													title: info
														.Title,
													author: info
														.Author,
													subject: info
														.Subject,
													keywords: info
														.Keywords,
													creationDate: creationDate,
													modificationDate: modificationDate,
													creator: info
														.Creator,
													producer: info
														.Producer,
													version: info
														.PDFFormatVersion,
													pageCount: this
														.pdfDocument
														.numPages,
													pageSize: pageSize,
													linearized: isLinearized,
													_currentPageNumber: currentPageNumber,
													_pagesRotation: pagesRotation
												});

												this._updateUI();

												_context.next = 28;
												return this
													.pdfDocument
													.getDownloadInfo();

											case 28:
												_yield$this$pdfDocume2
													= _context.sent;
												length =
													_yield$this$pdfDocume2
													.length;

												if (!(contentLength ===
														length)) {
													_context.next =
														32;
													break;
												}

												return _context
													.abrupt(
														"return");

											case 32:
												data = Object
													.assign(Object
														.create(
															null),
														this
														.fieldData);
												_context.next = 35;
												return this
													._parseFileSize(
														length);

											case 35:
												data.fileSize =
													_context.sent;
												freezeFieldData(
													data);

												this._updateUI();

											case 38:
											case "end":
												return _context
													.stop();
										}
									}
								}, _callee, this);
						}));

						function open() {
							return _open.apply(this, arguments);
						}

						return open;
					}()
				}, {
					key: "close",
					value: function close() {
						this.overlayManager.close(this.overlayName);
					}
				}, {
					key: "setDocument",
					value: function setDocument(pdfDocument) {
						var url = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : null;

						if (this.pdfDocument) {
							this._reset();

							this._updateUI(true);
						}

						if (!pdfDocument) {
							return;
						}

						this.pdfDocument = pdfDocument;
						this.url = url;

						this._dataAvailableCapability.resolve();
					}
				}, {
					key: "_reset",
					value: function _reset() {
						this.pdfDocument = null;
						this.url = null;
						delete this.fieldData;
						this._dataAvailableCapability = (0, _pdfjsLib
							.createPromiseCapability)();
						this._currentPageNumber = 1;
						this._pagesRotation = 0;
					}
				}, {
					key: "_updateUI",
					value: function _updateUI() {
						var reset = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : false;

						if (reset || !this.fieldData) {
							for (var id in this.fields) {
								this.fields[id].textContent = DEFAULT_FIELD_CONTENT;
							}

							return;
						}

						if (this.overlayManager.active !== this.overlayName) {
							return;
						}

						for (var _id in this.fields) {
							var content = this.fieldData[_id];
							this.fields[_id].textContent = content || content ===
								0 ? content : DEFAULT_FIELD_CONTENT;
						}
					}
				}, {
					key: "_parseFileSize",
					value: function() {
						var _parseFileSize2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee2() {
								var fileSize,
									kb,
									mb,
									_args2 = arguments;
								return _regenerator["default"].wrap(
									function _callee2$(_context2) {
										while (1) {
											switch (_context2.prev =
												_context2.next) {
												case 0:
													fileSize = _args2
														.length > 0 &&
														_args2[0] !==
														undefined ?
														_args2[0] : 0;
													kb = fileSize /
														1024, mb = kb /
														1024;

													if (kb) {
														_context2.next =
															4;
														break;
													}

													return _context2
														.abrupt(
															"return",
															undefined);

												case 4:
													return _context2
														.abrupt(
															"return",
															this.l10n
															.get(
																"document_properties_"
																.concat(
																	mb >=
																	1 ?
																	"mb" :
																	"kb"
																	), {
																	size_mb: mb >=
																		1 &&
																		(+mb.toPrecision(
																			3
																			))
																		.toLocaleString(),
																	size_kb: mb <
																		1 &&
																		(+kb.toPrecision(
																			3
																			))
																		.toLocaleString(),
																	size_b: fileSize
																		.toLocaleString()
																}));

												case 5:
												case "end":
													return _context2
														.stop();
											}
										}
									}, _callee2, this);
							}));

						function _parseFileSize() {
							return _parseFileSize2.apply(this, arguments);
						}

						return _parseFileSize;
					}()
				}, {
					key: "_parsePageSize",
					value: function() {
						var _parsePageSize2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee3(
								pageSizeInches, pagesRotation) {
								var isPortrait, sizeInches, sizeMillimeters,
									rawName, exactMillimeters,
									intMillimeters, _yield$Promise$all3,
									_yield$Promise$all4,
									_yield$Promise$all4$, width, height,
									unit, name, orientation;

								return _regenerator["default"].wrap(
									function _callee3$(_context3) {
										while (1) {
											switch (_context3.prev =
												_context3.next) {
												case 0:
													if (
														pageSizeInches) {
														_context3.next =
															2;
														break;
													}

													return _context3
														.abrupt(
															"return",
															undefined);

												case 2:
													if (pagesRotation %
														180 !== 0) {
														pageSizeInches
														= {
															width: pageSizeInches
																.height,
															height: pageSizeInches
																.width
														};
													}

													isPortrait = (0,
														_ui_utils
														.isPortraitOrientation
														)(
														pageSizeInches
														);
													sizeInches = {
														width: Math
															.round(
																pageSizeInches
																.width *
																100
																) /
															100,
														height: Math
															.round(
																pageSizeInches
																.height *
																100
																) /
															100
													};
													sizeMillimeters = {
														width: Math
															.round(
																pageSizeInches
																.width *
																25.4 *
																10
																) /
															10,
														height: Math
															.round(
																pageSizeInches
																.height *
																25.4 *
																10
																) /
															10
													};
													rawName =
														getPageName(
															sizeInches,
															isPortrait,
															US_PAGE_NAMES
															) ||
														getPageName(
															sizeMillimeters,
															isPortrait,
															METRIC_PAGE_NAMES
															);

													if (!rawName && !(
															Number
															.isInteger(
																sizeMillimeters
																.width
																) &&
															Number
															.isInteger(
																sizeMillimeters
																.height)
															)) {
														exactMillimeters
															= {
																width: pageSizeInches
																	.width *
																	25.4,
																height: pageSizeInches
																	.height *
																	25.4
															};
														intMillimeters
														= {
															width: Math
																.round(
																	sizeMillimeters
																	.width
																	),
															height: Math
																.round(
																	sizeMillimeters
																	.height
																	)
														};

														if (Math.abs(
																exactMillimeters
																.width -
																intMillimeters
																.width
																) <
															0.1 && Math
															.abs(
																exactMillimeters
																.height -
																intMillimeters
																.height
																) < 0.1
															) {
															rawName =
																getPageName(
																	intMillimeters,
																	isPortrait,
																	METRIC_PAGE_NAMES
																	);

															if (
																rawName) {
																sizeInches
																	= {
																		width: Math
																			.round(
																				intMillimeters
																				.width /
																				25.4 *
																				100
																				) /
																			100,
																		height: Math
																			.round(
																				intMillimeters
																				.height /
																				25.4 *
																				100
																				) /
																			100
																	};
																sizeMillimeters
																	=
																	intMillimeters;
															}
														}
													}

													_context3.next = 10;
													return Promise.all([
														this
														._isNonMetricLocale ?
														sizeInches :
														sizeMillimeters,
														this
														.l10n
														.get(
															"document_properties_page_size_unit_"
															.concat(
																this
																._isNonMetricLocale ?
																"inches" :
																"millimeters"
																)
															),
														rawName &&
														this
														.l10n
														.get(
															"document_properties_page_size_name_"
															.concat(
																rawName
																.toLowerCase()
																)
															),
														this
														.l10n
														.get(
															"document_properties_page_size_orientation_"
															.concat(
																isPortrait ?
																"portrait" :
																"landscape"
																)
															)
													]);

												case 10:
													_yield$Promise$all3
														= _context3
														.sent;
													_yield$Promise$all4
														=
														_slicedToArray(
															_yield$Promise$all3,
															4);
													_yield$Promise$all4$
														=
														_yield$Promise$all4[
															0];
													width =
														_yield$Promise$all4$
														.width;
													height =
														_yield$Promise$all4$
														.height;
													unit =
														_yield$Promise$all4[
															1];
													name =
														_yield$Promise$all4[
															2];
													orientation =
														_yield$Promise$all4[
															3];
													return _context3
														.abrupt(
															"return",
															this.l10n
															.get(
																"document_properties_page_size_dimension_"
																.concat(
																	name ?
																	"name_" :
																	"",
																	"string"
																	), {
																	width: width
																		.toLocaleString(),
																	height: height
																		.toLocaleString(),
																	unit: unit,
																	name: name,
																	orientation: orientation
																}));

												case 19:
												case "end":
													return _context3
														.stop();
											}
										}
									}, _callee3, this);
							}));

						function _parsePageSize(_x, _x2) {
							return _parsePageSize2.apply(this, arguments);
						}

						return _parsePageSize;
					}()
				}, {
					key: "_parseDate",
					value: function() {
						var _parseDate2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee4(
								inputDate) {
								var dateObject;
								return _regenerator["default"].wrap(
									function _callee4$(_context4) {
										while (1) {
											switch (_context4.prev =
												_context4.next) {
												case 0:
													dateObject =
														_pdfjsLib
														.PDFDateString
														.toDateObject(
															inputDate);

													if (dateObject) {
														_context4.next =
															3;
														break;
													}

													return _context4
														.abrupt(
															"return",
															undefined);

												case 3:
													return _context4
														.abrupt(
															"return",
															this.l10n
															.get(
																"document_properties_date_string", {
																	date: dateObject
																		.toLocaleDateString(),
																	time: dateObject
																		.toLocaleTimeString()
																}));

												case 4:
												case "end":
													return _context4
														.stop();
											}
										}
									}, _callee4, this);
							}));

						function _parseDate(_x3) {
							return _parseDate2.apply(this, arguments);
						}

						return _parseDate;
					}()
				}, {
					key: "_parseLinearization",
					value: function _parseLinearization(isLinearized) {
						return this.l10n.get("document_properties_linearized_"
							.concat(isLinearized ? "yes" : "no"));
					}
				}]);

				return PDFDocumentProperties;
			}();

			exports.PDFDocumentProperties = PDFDocumentProperties;

			/***/
		}),
		/* 16 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFFindBar = void 0;

			var _pdf_find_controller = __webpack_require__(17);

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var MATCHES_COUNT_LIMIT = 1000;

			var PDFFindBar = /*#__PURE__*/ function() {
				function PDFFindBar(options, eventBus, l10n) {
					var _this = this;

					_classCallCheck(this, PDFFindBar);

					this.opened = false;
					this.bar = options.bar;
					this.toggleButton = options.toggleButton;
					this.findField = options.findField;
					this.highlightAll = options.highlightAllCheckbox;
					this.caseSensitive = options.caseSensitiveCheckbox;
					this.matchDiacritics = options.matchDiacriticsCheckbox;
					this.entireWord = options.entireWordCheckbox;
					this.findMsg = options.findMsg;
					this.findResultsCount = options.findResultsCount;
					this.findPreviousButton = options.findPreviousButton;
					this.findNextButton = options.findNextButton;
					this.eventBus = eventBus;
					this.l10n = l10n;
					this.toggleButton.addEventListener("click", function() {
						_this.toggle();
					});
					this.findField.addEventListener("input", function() {
						_this.dispatchEvent("");
					});
					this.bar.addEventListener("keydown", function(e) {
						switch (e.keyCode) {
							case 13:
								if (e.target === _this.findField) {
									_this.dispatchEvent("again", e.shiftKey);
								}

								break;

							case 27:
								_this.close();

								break;
						}
					});
					this.findPreviousButton.addEventListener("click", function() {
						_this.dispatchEvent("again", true);
					});
					this.findNextButton.addEventListener("click", function() {
						_this.dispatchEvent("again", false);
					});
					this.highlightAll.addEventListener("click", function() {
						_this.dispatchEvent("highlightallchange");
					});
					this.caseSensitive.addEventListener("click", function() {
						_this.dispatchEvent("casesensitivitychange");
					});
					this.entireWord.addEventListener("click", function() {
						_this.dispatchEvent("entirewordchange");
					});
					this.matchDiacritics.addEventListener("click", function() {
						_this.dispatchEvent("diacriticmatchingchange");
					});

					this.eventBus._on("resize", this._adjustWidth.bind(this));
				}

				_createClass(PDFFindBar, [{
					key: "reset",
					value: function reset() {
						this.updateUIState();
					}
				}, {
					key: "dispatchEvent",
					value: function dispatchEvent(type) {
						var findPrev = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : false;
						this.eventBus.dispatch("find", {
							source: this,
							type: type,
							query: this.findField.value,
							phraseSearch: true,
							caseSensitive: this.caseSensitive.checked,
							entireWord: this.entireWord.checked,
							highlightAll: this.highlightAll.checked,
							findPrevious: findPrev,
							matchDiacritics: this.matchDiacritics.checked
						});
					}
				}, {
					key: "updateUIState",
					value: function updateUIState(state, previous, matchesCount) {
						var _this2 = this;

						var findMsg = Promise.resolve("");
						var status = "";

						switch (state) {
							case _pdf_find_controller.FindState.FOUND:
								break;

							case _pdf_find_controller.FindState.PENDING:
								status = "pending";
								break;

							case _pdf_find_controller.FindState.NOT_FOUND:
								findMsg = this.l10n.get("find_not_found");
								status = "notFound";
								break;

							case _pdf_find_controller.FindState.WRAPPED:
								findMsg = this.l10n.get("find_reached_".concat(
									previous ? "top" : "bottom"));
								break;
						}

						this.findField.setAttribute("data-status", status);
						findMsg.then(function(msg) {
							_this2.findMsg.textContent = msg;

							_this2._adjustWidth();
						});
						this.updateResultsCount(matchesCount);
					}
				}, {
					key: "updateResultsCount",
					value: function updateResultsCount() {
						var _this3 = this;

						var _ref = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : {},
							_ref$current = _ref.current,
							current = _ref$current === void 0 ? 0 : _ref$current,
							_ref$total = _ref.total,
							total = _ref$total === void 0 ? 0 : _ref$total;

						var limit = MATCHES_COUNT_LIMIT;
						var matchCountMsg = Promise.resolve("");

						if (total > 0) {
							if (total > limit) {
								var key = "find_match_count_limit";
								matchCountMsg = this.l10n.get(key, {
									limit: limit
								});
							} else {
								var _key = "find_match_count";
								matchCountMsg = this.l10n.get(_key, {
									current: current,
									total: total
								});
							}
						}

						matchCountMsg.then(function(msg) {
							_this3.findResultsCount.textContent = msg;

							_this3._adjustWidth();
						});
					}
				}, {
					key: "open",
					value: function open() {
						if (!this.opened) {
							this.opened = true;
							this.toggleButton.classList.add("toggled");
							this.toggleButton.setAttribute("aria-expanded", "true");
							this.bar.classList.remove("hidden");
						}

						this.findField.select();
						this.findField.focus();

						this._adjustWidth();
					}
				}, {
					key: "close",
					value: function close() {
						if (!this.opened) {
							return;
						}

						this.opened = false;
						this.toggleButton.classList.remove("toggled");
						this.toggleButton.setAttribute("aria-expanded", "false");
						this.bar.classList.add("hidden");
						this.eventBus.dispatch("findbarclose", {
							source: this
						});
					}
				}, {
					key: "toggle",
					value: function toggle() {
						if (this.opened) {
							this.close();
						} else {
							this.open();
						}
					}
				}, {
					key: "_adjustWidth",
					value: function _adjustWidth() {
						if (!this.opened) {
							return;
						}

						this.bar.classList.remove("wrapContainers");
						var findbarHeight = this.bar.clientHeight;
						var inputContainerHeight = this.bar.firstElementChild
							.clientHeight;

						if (findbarHeight > inputContainerHeight) {
							this.bar.classList.add("wrapContainers");
						}
					}
				}]);

				return PDFFindBar;
			}();

			exports.PDFFindBar = PDFFindBar;

			/***/
		}),
		/* 17 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFFindController = exports.FindState = void 0;

			var _ui_utils = __webpack_require__(5);

			var _pdfjsLib = __webpack_require__(7);

			var _pdf_find_utils = __webpack_require__(18);

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

			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."
					);
			}

			function _iterableToArrayLimit(arr, i) {
				var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] ||
					arr["@@iterator"];
				if (_i == null) return;
				var _arr = [];
				var _n = true;
				var _d = false;
				var _s, _e;
				try {
					for (_i = _i.call(arr); !(_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;
			}

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

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

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

			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."
					);
			}

			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);
			}

			function _iterableToArray(iter) {
				if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter[
					"@@iterator"] != null) return Array.from(iter);
			}

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

			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;
			}

			var FindState = {
				FOUND: 0,
				NOT_FOUND: 1,
				WRAPPED: 2,
				PENDING: 3
			};
			exports.FindState = FindState;
			var FIND_TIMEOUT = 250;
			var MATCH_SCROLL_OFFSET_TOP = -50;
			var MATCH_SCROLL_OFFSET_LEFT = -400;
			var CHARACTERS_TO_NORMALIZE = {
				"\u2010": "-",
				"\u2018": "'",
				"\u2019": "'",
				"\u201A": "'",
				"\u201B": "'",
				"\u201C": '"',
				"\u201D": '"',
				"\u201E": '"',
				"\u201F": '"',
				"\xBC": "1/4",
				"\xBD": "1/2",
				"\xBE": "3/4"
			};
			var DIACRITICS_EXCEPTION = new Set([0x3099, 0x309a, 0x094d, 0x09cd, 0x0a4d, 0x0acd, 0x0b4d,
				0x0bcd, 0x0c4d, 0x0ccd, 0x0d3b, 0x0d3c, 0x0d4d, 0x0dca, 0x0e3a, 0x0eba, 0x0f84,
				0x1039, 0x103a, 0x1714, 0x1734, 0x17d2, 0x1a60, 0x1b44, 0x1baa, 0x1bab, 0x1bf2,
				0x1bf3, 0x2d7f, 0xa806, 0xa82c, 0xa8c4, 0xa953, 0xa9c0, 0xaaf6, 0xabed, 0x0c56,
				0x0f71, 0x0f72, 0x0f7a, 0x0f7b, 0x0f7c, 0x0f7d, 0x0f80, 0x0f74
			]);

			var DIACRITICS_EXCEPTION_STR = _toConsumableArray(DIACRITICS_EXCEPTION.values()).map(
				function(x) {
					return String.fromCharCode(x);
				}).join("");

			var DIACRITICS_REG_EXP =
				/(?:[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0898-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u180F\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD803[\uDD24-\uDD27\uDEAB\uDEAC\uDF46-\uDF50\uDF82-\uDF85]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC70\uDC73\uDC74\uDC7F-\uDC82\uDCB0-\uDCBA\uDCC2\uDD00-\uDD02\uDD27-\uDD34\uDD45\uDD46\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDDC9-\uDDCC\uDDCE\uDDCF\uDE2C-\uDE37\uDE3E\uDEDF-\uDEEA\uDF00-\uDF03\uDF3B\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC35-\uDC46\uDC5E\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDDDC\uDDDD\uDE30-\uDE40\uDEAB-\uDEB7\uDF1D-\uDF2B]|\uD806[\uDC2C-\uDC3A\uDD30-\uDD35\uDD37\uDD38\uDD3B-\uDD3E\uDD40\uDD42\uDD43\uDDD1-\uDDD7\uDDDA-\uDDE0\uDDE4\uDE01-\uDE0A\uDE33-\uDE39\uDE3B-\uDE3E\uDE47\uDE51-\uDE5B\uDE8A-\uDE99]|\uD807[\uDC2F-\uDC36\uDC38-\uDC3F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD31-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD45\uDD47\uDD8A-\uDD8E\uDD90\uDD91\uDD93-\uDD97\uDEF3-\uDEF6]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF4F\uDF51-\uDF87\uDF8F-\uDF92\uDFE4\uDFF0\uDFF1]|\uD82F[\uDC9D\uDC9E]|\uD833[\uDF00-\uDF2D\uDF30-\uDF46]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD30-\uDD36\uDEAE\uDEEC-\uDEEF]|\uD83A[\uDCD0-\uDCD6\uDD44-\uDD4A]|\uDB40[\uDD00-\uDDEF])+/g;
			var SPECIAL_CHARS_REG_EXP =
				/([\$\(-\+\.\?\[-\^\{-\}])|((?:[!-#%-\*,-\/:;\?@\[-\]_\{\}\xA1\xA7\xAB\xB6\xB7\xBB\xBF\u037E\u0387\u055A-\u055F\u0589\u058A\u05BE\u05C0\u05C3\u05C6\u05F3\u05F4\u0609\u060A\u060C\u060D\u061B\u061D-\u061F\u066A-\u066D\u06D4\u0700-\u070D\u07F7-\u07F9\u0830-\u083E\u085E\u0964\u0965\u0970\u09FD\u0A76\u0AF0\u0C77\u0C84\u0DF4\u0E4F\u0E5A\u0E5B\u0F04-\u0F12\u0F14\u0F3A-\u0F3D\u0F85\u0FD0-\u0FD4\u0FD9\u0FDA\u104A-\u104F\u10FB\u1360-\u1368\u1400\u166E\u169B\u169C\u16EB-\u16ED\u1735\u1736\u17D4-\u17D6\u17D8-\u17DA\u1800-\u180A\u1944\u1945\u1A1E\u1A1F\u1AA0-\u1AA6\u1AA8-\u1AAD\u1B5A-\u1B60\u1B7D\u1B7E\u1BFC-\u1BFF\u1C3B-\u1C3F\u1C7E\u1C7F\u1CC0-\u1CC7\u1CD3\u2010-\u2027\u2030-\u2043\u2045-\u2051\u2053-\u205E\u207D\u207E\u208D\u208E\u2308-\u230B\u2329\u232A\u2768-\u2775\u27C5\u27C6\u27E6-\u27EF\u2983-\u2998\u29D8-\u29DB\u29FC\u29FD\u2CF9-\u2CFC\u2CFE\u2CFF\u2D70\u2E00-\u2E2E\u2E30-\u2E4F\u2E52-\u2E5D\u3001-\u3003\u3008-\u3011\u3014-\u301F\u3030\u303D\u30A0\u30FB\uA4FE\uA4FF\uA60D-\uA60F\uA673\uA67E\uA6F2-\uA6F7\uA874-\uA877\uA8CE\uA8CF\uA8F8-\uA8FA\uA8FC\uA92E\uA92F\uA95F\uA9C1-\uA9CD\uA9DE\uA9DF\uAA5C-\uAA5F\uAADE\uAADF\uAAF0\uAAF1\uABEB\uFD3E\uFD3F\uFE10-\uFE19\uFE30-\uFE52\uFE54-\uFE61\uFE63\uFE68\uFE6A\uFE6B\uFF01-\uFF03\uFF05-\uFF0A\uFF0C-\uFF0F\uFF1A\uFF1B\uFF1F\uFF20\uFF3B-\uFF3D\uFF3F\uFF5B\uFF5D\uFF5F-\uFF65]|\uD800[\uDD00-\uDD02\uDF9F\uDFD0]|\uD801\uDD6F|\uD802[\uDC57\uDD1F\uDD3F\uDE50-\uDE58\uDE7F\uDEF0-\uDEF6\uDF39-\uDF3F\uDF99-\uDF9C]|\uD803[\uDEAD\uDF55-\uDF59\uDF86-\uDF89]|\uD804[\uDC47-\uDC4D\uDCBB\uDCBC\uDCBE-\uDCC1\uDD40-\uDD43\uDD74\uDD75\uDDC5-\uDDC8\uDDCD\uDDDB\uDDDD-\uDDDF\uDE38-\uDE3D\uDEA9]|\uD805[\uDC4B-\uDC4F\uDC5A\uDC5B\uDC5D\uDCC6\uDDC1-\uDDD7\uDE41-\uDE43\uDE60-\uDE6C\uDEB9\uDF3C-\uDF3E]|\uD806[\uDC3B\uDD44-\uDD46\uDDE2\uDE3F-\uDE46\uDE9A-\uDE9C\uDE9E-\uDEA2]|\uD807[\uDC41-\uDC45\uDC70\uDC71\uDEF7\uDEF8\uDFFF]|\uD809[\uDC70-\uDC74]|\uD80B[\uDFF1\uDFF2]|\uD81A[\uDE6E\uDE6F\uDEF5\uDF37-\uDF3B\uDF44]|\uD81B[\uDE97-\uDE9A\uDFE2]|\uD82F\uDC9F|\uD836[\uDE87-\uDE8B]|\uD83A[\uDD5E\uDD5F]))|([\t-\r \xA0\u1680\u2000-\u200A\u2028\u2029\u202F\u205F\u3000\uFEFF]+)|((?:[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0898-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u180F\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD803[\uDD24-\uDD27\uDEAB\uDEAC\uDF46-\uDF50\uDF82-\uDF85]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC70\uDC73\uDC74\uDC7F-\uDC82\uDCB0-\uDCBA\uDCC2\uDD00-\uDD02\uDD27-\uDD34\uDD45\uDD46\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDDC9-\uDDCC\uDDCE\uDDCF\uDE2C-\uDE37\uDE3E\uDEDF-\uDEEA\uDF00-\uDF03\uDF3B\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC35-\uDC46\uDC5E\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDDDC\uDDDD\uDE30-\uDE40\uDEAB-\uDEB7\uDF1D-\uDF2B]|\uD806[\uDC2C-\uDC3A\uDD30-\uDD35\uDD37\uDD38\uDD3B-\uDD3E\uDD40\uDD42\uDD43\uDDD1-\uDDD7\uDDDA-\uDDE0\uDDE4\uDE01-\uDE0A\uDE33-\uDE39\uDE3B-\uDE3E\uDE47\uDE51-\uDE5B\uDE8A-\uDE99]|\uD807[\uDC2F-\uDC36\uDC38-\uDC3F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD31-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD45\uDD47\uDD8A-\uDD8E\uDD90\uDD91\uDD93-\uDD97\uDEF3-\uDEF6]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF4F\uDF51-\uDF87\uDF8F-\uDF92\uDFE4\uDFF0\uDFF1]|\uD82F[\uDC9D\uDC9E]|\uD833[\uDF00-\uDF2D\uDF30-\uDF46]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD30-\uDD36\uDEAE\uDEEC-\uDEEF]|\uD83A[\uDCD0-\uDCD6\uDD44-\uDD4A]|\uDB40[\uDD00-\uDDEF]))|((?:[A-Za-z\xAA\xB5\xBA\xC0-\xD6\xD8-\xF6\xF8-\u02C1\u02C6-\u02D1\u02E0-\u02E4\u02EC\u02EE\u0370-\u0374\u0376\u0377\u037A-\u037D\u037F\u0386\u0388-\u038A\u038C\u038E-\u03A1\u03A3-\u03F5\u03F7-\u0481\u048A-\u052F\u0531-\u0556\u0559\u0560-\u0588\u05D0-\u05EA\u05EF-\u05F2\u0620-\u064A\u066E\u066F\u0671-\u06D3\u06D5\u06E5\u06E6\u06EE\u06EF\u06FA-\u06FC\u06FF\u0710\u0712-\u072F\u074D-\u07A5\u07B1\u07CA-\u07EA\u07F4\u07F5\u07FA\u0800-\u0815\u081A\u0824\u0828\u0840-\u0858\u0860-\u086A\u0870-\u0887\u0889-\u088E\u08A0-\u08C9\u0904-\u0939\u093D\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098C\u098F\u0990\u0993-\u09A8\u09AA-\u09B0\u09B2\u09B6-\u09B9\u09BD\u09CE\u09DC\u09DD\u09DF-\u09E1\u09F0\u09F1\u09FC\u0A05-\u0A0A\u0A0F\u0A10\u0A13-\u0A28\u0A2A-\u0A30\u0A32\u0A33\u0A35\u0A36\u0A38\u0A39\u0A59-\u0A5C\u0A5E\u0A72-\u0A74\u0A85-\u0A8D\u0A8F-\u0A91\u0A93-\u0AA8\u0AAA-\u0AB0\u0AB2\u0AB3\u0AB5-\u0AB9\u0ABD\u0AD0\u0AE0\u0AE1\u0AF9\u0B05-\u0B0C\u0B0F\u0B10\u0B13-\u0B28\u0B2A-\u0B30\u0B32\u0B33\u0B35-\u0B39\u0B3D\u0B5C\u0B5D\u0B5F-\u0B61\u0B71\u0B83\u0B85-\u0B8A\u0B8E-\u0B90\u0B92-\u0B95\u0B99\u0B9A\u0B9C\u0B9E\u0B9F\u0BA3\u0BA4\u0BA8-\u0BAA\u0BAE-\u0BB9\u0BD0\u0C05-\u0C0C\u0C0E-\u0C10\u0C12-\u0C28\u0C2A-\u0C39\u0C3D\u0C58-\u0C5A\u0C5D\u0C60\u0C61\u0C80\u0C85-\u0C8C\u0C8E-\u0C90\u0C92-\u0CA8\u0CAA-\u0CB3\u0CB5-\u0CB9\u0CBD\u0CDD\u0CDE\u0CE0\u0CE1\u0CF1\u0CF2\u0D04-\u0D0C\u0D0E-\u0D10\u0D12-\u0D3A\u0D3D\u0D4E\u0D54-\u0D56\u0D5F-\u0D61\u0D7A-\u0D7F\u0D85-\u0D96\u0D9A-\u0DB1\u0DB3-\u0DBB\u0DBD\u0DC0-\u0DC6\u0E01-\u0E30\u0E32\u0E33\u0E40-\u0E46\u0E81\u0E82\u0E84\u0E86-\u0E8A\u0E8C-\u0EA3\u0EA5\u0EA7-\u0EB0\u0EB2\u0EB3\u0EBD\u0EC0-\u0EC4\u0EC6\u0EDC-\u0EDF\u0F00\u0F40-\u0F47\u0F49-\u0F6C\u0F88-\u0F8C\u1000-\u102A\u103F\u1050-\u1055\u105A-\u105D\u1061\u1065\u1066\u106E-\u1070\u1075-\u1081\u108E\u10A0-\u10C5\u10C7\u10CD\u10D0-\u10FA\u10FC-\u1248\u124A-\u124D\u1250-\u1256\u1258\u125A-\u125D\u1260-\u1288\u128A-\u128D\u1290-\u12B0\u12B2-\u12B5\u12B8-\u12BE\u12C0\u12C2-\u12C5\u12C8-\u12D6\u12D8-\u1310\u1312-\u1315\u1318-\u135A\u1380-\u138F\u13A0-\u13F5\u13F8-\u13FD\u1401-\u166C\u166F-\u167F\u1681-\u169A\u16A0-\u16EA\u16F1-\u16F8\u1700-\u1711\u171F-\u1731\u1740-\u1751\u1760-\u176C\u176E-\u1770\u1780-\u17B3\u17D7\u17DC\u1820-\u1878\u1880-\u1884\u1887-\u18A8\u18AA\u18B0-\u18F5\u1900-\u191E\u1950-\u196D\u1970-\u1974\u1980-\u19AB\u19B0-\u19C9\u1A00-\u1A16\u1A20-\u1A54\u1AA7\u1B05-\u1B33\u1B45-\u1B4C\u1B83-\u1BA0\u1BAE\u1BAF\u1BBA-\u1BE5\u1C00-\u1C23\u1C4D-\u1C4F\u1C5A-\u1C7D\u1C80-\u1C88\u1C90-\u1CBA\u1CBD-\u1CBF\u1CE9-\u1CEC\u1CEE-\u1CF3\u1CF5\u1CF6\u1CFA\u1D00-\u1DBF\u1E00-\u1F15\u1F18-\u1F1D\u1F20-\u1F45\u1F48-\u1F4D\u1F50-\u1F57\u1F59\u1F5B\u1F5D\u1F5F-\u1F7D\u1F80-\u1FB4\u1FB6-\u1FBC\u1FBE\u1FC2-\u1FC4\u1FC6-\u1FCC\u1FD0-\u1FD3\u1FD6-\u1FDB\u1FE0-\u1FEC\u1FF2-\u1FF4\u1FF6-\u1FFC\u2071\u207F\u2090-\u209C\u2102\u2107\u210A-\u2113\u2115\u2119-\u211D\u2124\u2126\u2128\u212A-\u212D\u212F-\u2139\u213C-\u213F\u2145-\u2149\u214E\u2183\u2184\u2C00-\u2CE4\u2CEB-\u2CEE\u2CF2\u2CF3\u2D00-\u2D25\u2D27\u2D2D\u2D30-\u2D67\u2D6F\u2D80-\u2D96\u2DA0-\u2DA6\u2DA8-\u2DAE\u2DB0-\u2DB6\u2DB8-\u2DBE\u2DC0-\u2DC6\u2DC8-\u2DCE\u2DD0-\u2DD6\u2DD8-\u2DDE\u2E2F\u3005\u3006\u3031-\u3035\u303B\u303C\u3041-\u3096\u309D-\u309F\u30A1-\u30FA\u30FC-\u30FF\u3105-\u312F\u3131-\u318E\u31A0-\u31BF\u31F0-\u31FF\u3400-\u4DBF\u4E00-\uA48C\uA4D0-\uA4FD\uA500-\uA60C\uA610-\uA61F\uA62A\uA62B\uA640-\uA66E\uA67F-\uA69D\uA6A0-\uA6E5\uA717-\uA71F\uA722-\uA788\uA78B-\uA7CA\uA7D0\uA7D1\uA7D3\uA7D5-\uA7D9\uA7F2-\uA801\uA803-\uA805\uA807-\uA80A\uA80C-\uA822\uA840-\uA873\uA882-\uA8B3\uA8F2-\uA8F7\uA8FB\uA8FD\uA8FE\uA90A-\uA925\uA930-\uA946\uA960-\uA97C\uA984-\uA9B2\uA9CF\uA9E0-\uA9E4\uA9E6-\uA9EF\uA9FA-\uA9FE\uAA00-\uAA28\uAA40-\uAA42\uAA44-\uAA4B\uAA60-\uAA76\uAA7A\uAA7E-\uAAAF\uAAB1\uAAB5\uAAB6\uAAB9-\uAABD\uAAC0\uAAC2\uAADB-\uAADD\uAAE0-\uAAEA\uAAF2-\uAAF4\uAB01-\uAB06\uAB09-\uAB0E\uAB11-\uAB16\uAB20-\uAB26\uAB28-\uAB2E\uAB30-\uAB5A\uAB5C-\uAB69\uAB70-\uABE2\uAC00-\uD7A3\uD7B0-\uD7C6\uD7CB-\uD7FB\uF900-\uFA6D\uFA70-\uFAD9\uFB00-\uFB06\uFB13-\uFB17\uFB1D\uFB1F-\uFB28\uFB2A-\uFB36\uFB38-\uFB3C\uFB3E\uFB40\uFB41\uFB43\uFB44\uFB46-\uFBB1\uFBD3-\uFD3D\uFD50-\uFD8F\uFD92-\uFDC7\uFDF0-\uFDFB\uFE70-\uFE74\uFE76-\uFEFC\uFF21-\uFF3A\uFF41-\uFF5A\uFF66-\uFFBE\uFFC2-\uFFC7\uFFCA-\uFFCF\uFFD2-\uFFD7\uFFDA-\uFFDC]|\uD800[\uDC00-\uDC0B\uDC0D-\uDC26\uDC28-\uDC3A\uDC3C\uDC3D\uDC3F-\uDC4D\uDC50-\uDC5D\uDC80-\uDCFA\uDE80-\uDE9C\uDEA0-\uDED0\uDF00-\uDF1F\uDF2D-\uDF40\uDF42-\uDF49\uDF50-\uDF75\uDF80-\uDF9D\uDFA0-\uDFC3\uDFC8-\uDFCF]|\uD801[\uDC00-\uDC9D\uDCB0-\uDCD3\uDCD8-\uDCFB\uDD00-\uDD27\uDD30-\uDD63\uDD70-\uDD7A\uDD7C-\uDD8A\uDD8C-\uDD92\uDD94\uDD95\uDD97-\uDDA1\uDDA3-\uDDB1\uDDB3-\uDDB9\uDDBB\uDDBC\uDE00-\uDF36\uDF40-\uDF55\uDF60-\uDF67\uDF80-\uDF85\uDF87-\uDFB0\uDFB2-\uDFBA]|\uD802[\uDC00-\uDC05\uDC08\uDC0A-\uDC35\uDC37\uDC38\uDC3C\uDC3F-\uDC55\uDC60-\uDC76\uDC80-\uDC9E\uDCE0-\uDCF2\uDCF4\uDCF5\uDD00-\uDD15\uDD20-\uDD39\uDD80-\uDDB7\uDDBE\uDDBF\uDE00\uDE10-\uDE13\uDE15-\uDE17\uDE19-\uDE35\uDE60-\uDE7C\uDE80-\uDE9C\uDEC0-\uDEC7\uDEC9-\uDEE4\uDF00-\uDF35\uDF40-\uDF55\uDF60-\uDF72\uDF80-\uDF91]|\uD803[\uDC00-\uDC48\uDC80-\uDCB2\uDCC0-\uDCF2\uDD00-\uDD23\uDE80-\uDEA9\uDEB0\uDEB1\uDF00-\uDF1C\uDF27\uDF30-\uDF45\uDF70-\uDF81\uDFB0-\uDFC4\uDFE0-\uDFF6]|\uD804[\uDC03-\uDC37\uDC71\uDC72\uDC75\uDC83-\uDCAF\uDCD0-\uDCE8\uDD03-\uDD26\uDD44\uDD47\uDD50-\uDD72\uDD76\uDD83-\uDDB2\uDDC1-\uDDC4\uDDDA\uDDDC\uDE00-\uDE11\uDE13-\uDE2B\uDE80-\uDE86\uDE88\uDE8A-\uDE8D\uDE8F-\uDE9D\uDE9F-\uDEA8\uDEB0-\uDEDE\uDF05-\uDF0C\uDF0F\uDF10\uDF13-\uDF28\uDF2A-\uDF30\uDF32\uDF33\uDF35-\uDF39\uDF3D\uDF50\uDF5D-\uDF61]|\uD805[\uDC00-\uDC34\uDC47-\uDC4A\uDC5F-\uDC61\uDC80-\uDCAF\uDCC4\uDCC5\uDCC7\uDD80-\uDDAE\uDDD8-\uDDDB\uDE00-\uDE2F\uDE44\uDE80-\uDEAA\uDEB8\uDF00-\uDF1A\uDF40-\uDF46]|\uD806[\uDC00-\uDC2B\uDCA0-\uDCDF\uDCFF-\uDD06\uDD09\uDD0C-\uDD13\uDD15\uDD16\uDD18-\uDD2F\uDD3F\uDD41\uDDA0-\uDDA7\uDDAA-\uDDD0\uDDE1\uDDE3\uDE00\uDE0B-\uDE32\uDE3A\uDE50\uDE5C-\uDE89\uDE9D\uDEB0-\uDEF8]|\uD807[\uDC00-\uDC08\uDC0A-\uDC2E\uDC40\uDC72-\uDC8F\uDD00-\uDD06\uDD08\uDD09\uDD0B-\uDD30\uDD46\uDD60-\uDD65\uDD67\uDD68\uDD6A-\uDD89\uDD98\uDEE0-\uDEF2\uDFB0]|\uD808[\uDC00-\uDF99]|\uD809[\uDC80-\uDD43]|\uD80B[\uDF90-\uDFF0]|[\uD80C\uD81C-\uD820\uD822\uD840-\uD868\uD86A-\uD86C\uD86F-\uD872\uD874-\uD879\uD880-\uD883][\uDC00-\uDFFF]|\uD80D[\uDC00-\uDC2E]|\uD811[\uDC00-\uDE46]|\uD81A[\uDC00-\uDE38\uDE40-\uDE5E\uDE70-\uDEBE\uDED0-\uDEED\uDF00-\uDF2F\uDF40-\uDF43\uDF63-\uDF77\uDF7D-\uDF8F]|\uD81B[\uDE40-\uDE7F\uDF00-\uDF4A\uDF50\uDF93-\uDF9F\uDFE0\uDFE1\uDFE3]|\uD821[\uDC00-\uDFF7]|\uD823[\uDC00-\uDCD5\uDD00-\uDD08]|\uD82B[\uDFF0-\uDFF3\uDFF5-\uDFFB\uDFFD\uDFFE]|\uD82C[\uDC00-\uDD22\uDD50-\uDD52\uDD64-\uDD67\uDD70-\uDEFB]|\uD82F[\uDC00-\uDC6A\uDC70-\uDC7C\uDC80-\uDC88\uDC90-\uDC99]|\uD835[\uDC00-\uDC54\uDC56-\uDC9C\uDC9E\uDC9F\uDCA2\uDCA5\uDCA6\uDCA9-\uDCAC\uDCAE-\uDCB9\uDCBB\uDCBD-\uDCC3\uDCC5-\uDD05\uDD07-\uDD0A\uDD0D-\uDD14\uDD16-\uDD1C\uDD1E-\uDD39\uDD3B-\uDD3E\uDD40-\uDD44\uDD46\uDD4A-\uDD50\uDD52-\uDEA5\uDEA8-\uDEC0\uDEC2-\uDEDA\uDEDC-\uDEFA\uDEFC-\uDF14\uDF16-\uDF34\uDF36-\uDF4E\uDF50-\uDF6E\uDF70-\uDF88\uDF8A-\uDFA8\uDFAA-\uDFC2\uDFC4-\uDFCB]|\uD837[\uDF00-\uDF1E]|\uD838[\uDD00-\uDD2C\uDD37-\uDD3D\uDD4E\uDE90-\uDEAD\uDEC0-\uDEEB]|\uD839[\uDFE0-\uDFE6\uDFE8-\uDFEB\uDFED\uDFEE\uDFF0-\uDFFE]|\uD83A[\uDC00-\uDCC4\uDD00-\uDD43\uDD4B]|\uD83B[\uDE00-\uDE03\uDE05-\uDE1F\uDE21\uDE22\uDE24\uDE27\uDE29-\uDE32\uDE34-\uDE37\uDE39\uDE3B\uDE42\uDE47\uDE49\uDE4B\uDE4D-\uDE4F\uDE51\uDE52\uDE54\uDE57\uDE59\uDE5B\uDE5D\uDE5F\uDE61\uDE62\uDE64\uDE67-\uDE6A\uDE6C-\uDE72\uDE74-\uDE77\uDE79-\uDE7C\uDE7E\uDE80-\uDE89\uDE8B-\uDE9B\uDEA1-\uDEA3\uDEA5-\uDEA9\uDEAB-\uDEBB]|\uD869[\uDC00-\uDEDF\uDF00-\uDFFF]|\uD86D[\uDC00-\uDF38\uDF40-\uDFFF]|\uD86E[\uDC00-\uDC1D\uDC20-\uDFFF]|\uD873[\uDC00-\uDEA1\uDEB0-\uDFFF]|\uD87A[\uDC00-\uDFE0]|\uD87E[\uDC00-\uDE1D]|\uD884[\uDC00-\uDF4A]))/g;
			var NOT_DIACRITIC_FROM_END_REG_EXP =
				/((?:(?![\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0898-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u180F\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD803[\uDD24-\uDD27\uDEAB\uDEAC\uDF46-\uDF50\uDF82-\uDF85]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC70\uDC73\uDC74\uDC7F-\uDC82\uDCB0-\uDCBA\uDCC2\uDD00-\uDD02\uDD27-\uDD34\uDD45\uDD46\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDDC9-\uDDCC\uDDCE\uDDCF\uDE2C-\uDE37\uDE3E\uDEDF-\uDEEA\uDF00-\uDF03\uDF3B\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC35-\uDC46\uDC5E\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDDDC\uDDDD\uDE30-\uDE40\uDEAB-\uDEB7\uDF1D-\uDF2B]|\uD806[\uDC2C-\uDC3A\uDD30-\uDD35\uDD37\uDD38\uDD3B-\uDD3E\uDD40\uDD42\uDD43\uDDD1-\uDDD7\uDDDA-\uDDE0\uDDE4\uDE01-\uDE0A\uDE33-\uDE39\uDE3B-\uDE3E\uDE47\uDE51-\uDE5B\uDE8A-\uDE99]|\uD807[\uDC2F-\uDC36\uDC38-\uDC3F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD31-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD45\uDD47\uDD8A-\uDD8E\uDD90\uDD91\uDD93-\uDD97\uDEF3-\uDEF6]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF4F\uDF51-\uDF87\uDF8F-\uDF92\uDFE4\uDFF0\uDFF1]|\uD82F[\uDC9D\uDC9E]|\uD833[\uDF00-\uDF2D\uDF30-\uDF46]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD30-\uDD36\uDEAE\uDEEC-\uDEEF]|\uD83A[\uDCD0-\uDCD6\uDD44-\uDD4A]|\uDB40[\uDD00-\uDDEF])[\s\S]))(?:[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0898-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u180F\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD803[\uDD24-\uDD27\uDEAB\uDEAC\uDF46-\uDF50\uDF82-\uDF85]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC70\uDC73\uDC74\uDC7F-\uDC82\uDCB0-\uDCBA\uDCC2\uDD00-\uDD02\uDD27-\uDD34\uDD45\uDD46\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDDC9-\uDDCC\uDDCE\uDDCF\uDE2C-\uDE37\uDE3E\uDEDF-\uDEEA\uDF00-\uDF03\uDF3B\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC35-\uDC46\uDC5E\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDDDC\uDDDD\uDE30-\uDE40\uDEAB-\uDEB7\uDF1D-\uDF2B]|\uD806[\uDC2C-\uDC3A\uDD30-\uDD35\uDD37\uDD38\uDD3B-\uDD3E\uDD40\uDD42\uDD43\uDDD1-\uDDD7\uDDDA-\uDDE0\uDDE4\uDE01-\uDE0A\uDE33-\uDE39\uDE3B-\uDE3E\uDE47\uDE51-\uDE5B\uDE8A-\uDE99]|\uD807[\uDC2F-\uDC36\uDC38-\uDC3F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD31-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD45\uDD47\uDD8A-\uDD8E\uDD90\uDD91\uDD93-\uDD97\uDEF3-\uDEF6]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF4F\uDF51-\uDF87\uDF8F-\uDF92\uDFE4\uDFF0\uDFF1]|\uD82F[\uDC9D\uDC9E]|\uD833[\uDF00-\uDF2D\uDF30-\uDF46]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD30-\uDD36\uDEAE\uDEEC-\uDEEF]|\uD83A[\uDCD0-\uDCD6\uDD44-\uDD4A]|\uDB40[\uDD00-\uDDEF])*$/;
			var NOT_DIACRITIC_FROM_START_REG_EXP =
				/^(?:[\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0898-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u180F\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD803[\uDD24-\uDD27\uDEAB\uDEAC\uDF46-\uDF50\uDF82-\uDF85]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC70\uDC73\uDC74\uDC7F-\uDC82\uDCB0-\uDCBA\uDCC2\uDD00-\uDD02\uDD27-\uDD34\uDD45\uDD46\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDDC9-\uDDCC\uDDCE\uDDCF\uDE2C-\uDE37\uDE3E\uDEDF-\uDEEA\uDF00-\uDF03\uDF3B\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC35-\uDC46\uDC5E\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDDDC\uDDDD\uDE30-\uDE40\uDEAB-\uDEB7\uDF1D-\uDF2B]|\uD806[\uDC2C-\uDC3A\uDD30-\uDD35\uDD37\uDD38\uDD3B-\uDD3E\uDD40\uDD42\uDD43\uDDD1-\uDDD7\uDDDA-\uDDE0\uDDE4\uDE01-\uDE0A\uDE33-\uDE39\uDE3B-\uDE3E\uDE47\uDE51-\uDE5B\uDE8A-\uDE99]|\uD807[\uDC2F-\uDC36\uDC38-\uDC3F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD31-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD45\uDD47\uDD8A-\uDD8E\uDD90\uDD91\uDD93-\uDD97\uDEF3-\uDEF6]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF4F\uDF51-\uDF87\uDF8F-\uDF92\uDFE4\uDFF0\uDFF1]|\uD82F[\uDC9D\uDC9E]|\uD833[\uDF00-\uDF2D\uDF30-\uDF46]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD30-\uDD36\uDEAE\uDEEC-\uDEEF]|\uD83A[\uDCD0-\uDCD6\uDD44-\uDD4A]|\uDB40[\uDD00-\uDDEF])*((?:(?![\u0300-\u036F\u0483-\u0489\u0591-\u05BD\u05BF\u05C1\u05C2\u05C4\u05C5\u05C7\u0610-\u061A\u064B-\u065F\u0670\u06D6-\u06DC\u06DF-\u06E4\u06E7\u06E8\u06EA-\u06ED\u0711\u0730-\u074A\u07A6-\u07B0\u07EB-\u07F3\u07FD\u0816-\u0819\u081B-\u0823\u0825-\u0827\u0829-\u082D\u0859-\u085B\u0898-\u089F\u08CA-\u08E1\u08E3-\u0903\u093A-\u093C\u093E-\u094F\u0951-\u0957\u0962\u0963\u0981-\u0983\u09BC\u09BE-\u09C4\u09C7\u09C8\u09CB-\u09CD\u09D7\u09E2\u09E3\u09FE\u0A01-\u0A03\u0A3C\u0A3E-\u0A42\u0A47\u0A48\u0A4B-\u0A4D\u0A51\u0A70\u0A71\u0A75\u0A81-\u0A83\u0ABC\u0ABE-\u0AC5\u0AC7-\u0AC9\u0ACB-\u0ACD\u0AE2\u0AE3\u0AFA-\u0AFF\u0B01-\u0B03\u0B3C\u0B3E-\u0B44\u0B47\u0B48\u0B4B-\u0B4D\u0B55-\u0B57\u0B62\u0B63\u0B82\u0BBE-\u0BC2\u0BC6-\u0BC8\u0BCA-\u0BCD\u0BD7\u0C00-\u0C04\u0C3C\u0C3E-\u0C44\u0C46-\u0C48\u0C4A-\u0C4D\u0C55\u0C56\u0C62\u0C63\u0C81-\u0C83\u0CBC\u0CBE-\u0CC4\u0CC6-\u0CC8\u0CCA-\u0CCD\u0CD5\u0CD6\u0CE2\u0CE3\u0D00-\u0D03\u0D3B\u0D3C\u0D3E-\u0D44\u0D46-\u0D48\u0D4A-\u0D4D\u0D57\u0D62\u0D63\u0D81-\u0D83\u0DCA\u0DCF-\u0DD4\u0DD6\u0DD8-\u0DDF\u0DF2\u0DF3\u0E31\u0E34-\u0E3A\u0E47-\u0E4E\u0EB1\u0EB4-\u0EBC\u0EC8-\u0ECD\u0F18\u0F19\u0F35\u0F37\u0F39\u0F3E\u0F3F\u0F71-\u0F84\u0F86\u0F87\u0F8D-\u0F97\u0F99-\u0FBC\u0FC6\u102B-\u103E\u1056-\u1059\u105E-\u1060\u1062-\u1064\u1067-\u106D\u1071-\u1074\u1082-\u108D\u108F\u109A-\u109D\u135D-\u135F\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17B4-\u17D3\u17DD\u180B-\u180D\u180F\u1885\u1886\u18A9\u1920-\u192B\u1930-\u193B\u1A17-\u1A1B\u1A55-\u1A5E\u1A60-\u1A7C\u1A7F\u1AB0-\u1ACE\u1B00-\u1B04\u1B34-\u1B44\u1B6B-\u1B73\u1B80-\u1B82\u1BA1-\u1BAD\u1BE6-\u1BF3\u1C24-\u1C37\u1CD0-\u1CD2\u1CD4-\u1CE8\u1CED\u1CF4\u1CF7-\u1CF9\u1DC0-\u1DFF\u20D0-\u20F0\u2CEF-\u2CF1\u2D7F\u2DE0-\u2DFF\u302A-\u302F\u3099\u309A\uA66F-\uA672\uA674-\uA67D\uA69E\uA69F\uA6F0\uA6F1\uA802\uA806\uA80B\uA823-\uA827\uA82C\uA880\uA881\uA8B4-\uA8C5\uA8E0-\uA8F1\uA8FF\uA926-\uA92D\uA947-\uA953\uA980-\uA983\uA9B3-\uA9C0\uA9E5\uAA29-\uAA36\uAA43\uAA4C\uAA4D\uAA7B-\uAA7D\uAAB0\uAAB2-\uAAB4\uAAB7\uAAB8\uAABE\uAABF\uAAC1\uAAEB-\uAAEF\uAAF5\uAAF6\uABE3-\uABEA\uABEC\uABED\uFB1E\uFE00-\uFE0F\uFE20-\uFE2F]|\uD800[\uDDFD\uDEE0\uDF76-\uDF7A]|\uD802[\uDE01-\uDE03\uDE05\uDE06\uDE0C-\uDE0F\uDE38-\uDE3A\uDE3F\uDEE5\uDEE6]|\uD803[\uDD24-\uDD27\uDEAB\uDEAC\uDF46-\uDF50\uDF82-\uDF85]|\uD804[\uDC00-\uDC02\uDC38-\uDC46\uDC70\uDC73\uDC74\uDC7F-\uDC82\uDCB0-\uDCBA\uDCC2\uDD00-\uDD02\uDD27-\uDD34\uDD45\uDD46\uDD73\uDD80-\uDD82\uDDB3-\uDDC0\uDDC9-\uDDCC\uDDCE\uDDCF\uDE2C-\uDE37\uDE3E\uDEDF-\uDEEA\uDF00-\uDF03\uDF3B\uDF3C\uDF3E-\uDF44\uDF47\uDF48\uDF4B-\uDF4D\uDF57\uDF62\uDF63\uDF66-\uDF6C\uDF70-\uDF74]|\uD805[\uDC35-\uDC46\uDC5E\uDCB0-\uDCC3\uDDAF-\uDDB5\uDDB8-\uDDC0\uDDDC\uDDDD\uDE30-\uDE40\uDEAB-\uDEB7\uDF1D-\uDF2B]|\uD806[\uDC2C-\uDC3A\uDD30-\uDD35\uDD37\uDD38\uDD3B-\uDD3E\uDD40\uDD42\uDD43\uDDD1-\uDDD7\uDDDA-\uDDE0\uDDE4\uDE01-\uDE0A\uDE33-\uDE39\uDE3B-\uDE3E\uDE47\uDE51-\uDE5B\uDE8A-\uDE99]|\uD807[\uDC2F-\uDC36\uDC38-\uDC3F\uDC92-\uDCA7\uDCA9-\uDCB6\uDD31-\uDD36\uDD3A\uDD3C\uDD3D\uDD3F-\uDD45\uDD47\uDD8A-\uDD8E\uDD90\uDD91\uDD93-\uDD97\uDEF3-\uDEF6]|\uD81A[\uDEF0-\uDEF4\uDF30-\uDF36]|\uD81B[\uDF4F\uDF51-\uDF87\uDF8F-\uDF92\uDFE4\uDFF0\uDFF1]|\uD82F[\uDC9D\uDC9E]|\uD833[\uDF00-\uDF2D\uDF30-\uDF46]|\uD834[\uDD65-\uDD69\uDD6D-\uDD72\uDD7B-\uDD82\uDD85-\uDD8B\uDDAA-\uDDAD\uDE42-\uDE44]|\uD836[\uDE00-\uDE36\uDE3B-\uDE6C\uDE75\uDE84\uDE9B-\uDE9F\uDEA1-\uDEAF]|\uD838[\uDC00-\uDC06\uDC08-\uDC18\uDC1B-\uDC21\uDC23\uDC24\uDC26-\uDC2A\uDD30-\uDD36\uDEAE\uDEEC-\uDEEF]|\uD83A[\uDCD0-\uDCD6\uDD44-\uDD4A]|\uDB40[\uDD00-\uDDEF])[\s\S]))/;
			var normalizationRegex = null;

			function normalize(text) {
				if (!normalizationRegex) {
					var replace = Object.keys(CHARACTERS_TO_NORMALIZE).join("");
					normalizationRegex = new RegExp("([".concat(replace,
						"])|(\\p{M}+(?:-\\n)?)|(\\S-\\n)|(\\n)"), "gum");
				}

				var rawDiacriticsPositions = [];
				var m;

				while ((m = DIACRITICS_REG_EXP.exec(text)) !== null) {
					rawDiacriticsPositions.push([m[0].length, m.index]);
				}

				var normalized = text.normalize("NFD");
				var positions = [
					[0, 0]
				];
				var k = 0;
				var shift = 0;
				var shiftOrigin = 0;
				var eol = 0;
				var hasDiacritics = false;
				normalized = normalized.replace(normalizationRegex, function(match, p1, p2, p3, p4, i) {
					i -= shiftOrigin;

					if (p1) {
						var replacement = CHARACTERS_TO_NORMALIZE[match];
						var jj = replacement.length;

						for (var j = 1; j < jj; j++) {
							positions.push([i - shift + j, shift - j]);
						}

						shift -= jj - 1;
						return replacement;
					}

					if (p2) {
						var _rawDiacriticsPositio;

						var hasTrailingDashEOL = p2.endsWith("\n");
						var len = hasTrailingDashEOL ? p2.length - 2 : p2.length;
						hasDiacritics = true;
						var _jj = len;

						if (i + eol === ((_rawDiacriticsPositio = rawDiacriticsPositions[k]) ===
								null || _rawDiacriticsPositio === void 0 ? void 0 :
								_rawDiacriticsPositio[1])) {
							_jj -= rawDiacriticsPositions[k][0];
							++k;
						}

						for (var _j = 1; _j < _jj + 1; _j++) {
							positions.push([i - 1 - shift + _j, shift - _j]);
						}

						shift -= _jj;
						shiftOrigin += _jj;

						if (hasTrailingDashEOL) {
							i += len - 1;
							positions.push([i - shift + 1, 1 + shift]);
							shift += 1;
							shiftOrigin += 1;
							eol += 1;
							return p2.slice(0, len);
						}

						return p2;
					}

					if (p3) {
						positions.push([i - shift + 1, 1 + shift]);
						shift += 1;
						shiftOrigin += 1;
						eol += 1;
						return p3.charAt(0);
					}

					positions.push([i - shift + 1, shift - 1]);
					shift -= 1;
					shiftOrigin += 1;
					eol += 1;
					return " ";
				});
				positions.push([normalized.length, shift]);
				return [normalized, positions, hasDiacritics];
			}

			function getOriginalIndex(diffs, pos, len) {
				if (!diffs) {
					return [pos, len];
				}

				var start = pos;
				var end = pos + len;
				var i = (0, _ui_utils.binarySearchFirstItem)(diffs, function(x) {
					return x[0] >= start;
				});

				if (diffs[i][0] > start) {
					--i;
				}

				var j = (0, _ui_utils.binarySearchFirstItem)(diffs, function(x) {
					return x[0] >= end;
				}, i);

				if (diffs[j][0] > end) {
					--j;
				}

				return [start + diffs[i][1], len + diffs[j][1] - diffs[i][1]];
			}

			var PDFFindController = /*#__PURE__*/ function() {
				function PDFFindController(_ref) {
					var _this = this;

					var linkService = _ref.linkService,
						eventBus = _ref.eventBus;

					_classCallCheck(this, PDFFindController);

					this._linkService = linkService;
					this._eventBus = eventBus;

					this._reset();

					eventBus._on("find", this._onFind.bind(this));

					eventBus._on("findbarclose", this._onFindBarClose.bind(this));

					this.executeCommand = function(cmd, state) {
						console.error(
							"Deprecated method `PDFFindController.executeCommand` called, " +
							'please dispatch a "find"-event using the EventBus instead.');
						var eventState = Object.assign(Object.create(null), state, {
							type: cmd.substring("find".length)
						});

						_this._onFind(eventState);
					};
				}

				_createClass(PDFFindController, [{
					key: "highlightMatches",
					get: function get() {
						return this._highlightMatches;
					}
				}, {
					key: "pageMatches",
					get: function get() {
						return this._pageMatches;
					}
				}, {
					key: "pageMatchesLength",
					get: function get() {
						return this._pageMatchesLength;
					}
				}, {
					key: "selected",
					get: function get() {
						return this._selected;
					}
				}, {
					key: "state",
					get: function get() {
						return this._state;
					}
				}, {
					key: "setDocument",
					value: function setDocument(pdfDocument) {
						if (this._pdfDocument) {
							this._reset();
						}

						if (!pdfDocument) {
							return;
						}

						this._pdfDocument = pdfDocument;

						this._firstPageCapability.resolve();
					}
				}, {
					key: "_onFind",
					value: function _onFind(state) {
						var _this2 = this;

						if (!state) {
							return;
						}

						var pdfDocument = this._pdfDocument;
						var type = state.type;

						if (this._state === null || this._shouldDirtyMatch(state)) {
							this._dirtyMatch = true;
						}

						this._state = state;

						if (type !== "highlightallchange") {
							this._updateUIState(FindState.PENDING);
						}

						this._firstPageCapability.promise.then(function() {
							if (!_this2._pdfDocument || pdfDocument &&
								_this2._pdfDocument !== pdfDocument) {
								return;
							}

							_this2._extractText();

							var findbarClosed = !_this2._highlightMatches;
							var pendingTimeout = !!_this2._findTimeout;

							if (_this2._findTimeout) {
								clearTimeout(_this2._findTimeout);
								_this2._findTimeout = null;
							}

							if (!type) {
								_this2._findTimeout = setTimeout(
							function() {
									_this2._nextMatch();

									_this2._findTimeout = null;
								}, FIND_TIMEOUT);
							} else if (_this2._dirtyMatch) {
								_this2._nextMatch();
							} else if (type === "again") {
								_this2._nextMatch();

								if (findbarClosed && _this2._state
									.highlightAll) {
									_this2._updateAllPages();
								}
							} else if (type === "highlightallchange") {
								if (pendingTimeout) {
									_this2._nextMatch();
								} else {
									_this2._highlightMatches = true;
								}

								_this2._updateAllPages();
							} else {
								_this2._nextMatch();
							}
						});
					}
				}, {
					key: "scrollMatchIntoView",
					value: function scrollMatchIntoView(_ref2) {
						var _ref2$element = _ref2.element,
							element = _ref2$element === void 0 ? null :
							_ref2$element,
							_ref2$selectedLeft = _ref2.selectedLeft,
							selectedLeft = _ref2$selectedLeft === void 0 ? 0 :
							_ref2$selectedLeft,
							_ref2$pageIndex = _ref2.pageIndex,
							pageIndex = _ref2$pageIndex === void 0 ? -1 :
							_ref2$pageIndex,
							_ref2$matchIndex = _ref2.matchIndex,
							matchIndex = _ref2$matchIndex === void 0 ? -1 :
							_ref2$matchIndex;

						if (!this._scrollMatches || !element) {
							return;
						} else if (matchIndex === -1 || matchIndex !== this
							._selected.matchIdx) {
							return;
						} else if (pageIndex === -1 || pageIndex !== this._selected
							.pageIdx) {
							return;
						}

						this._scrollMatches = false;
						var spot = {
							top: MATCH_SCROLL_OFFSET_TOP,
							left: selectedLeft + MATCH_SCROLL_OFFSET_LEFT
						};
						(0, _ui_utils.scrollIntoView)(element, spot, true);
					}
				}, {
					key: "_reset",
					value: function _reset() {
						this._highlightMatches = false;
						this._scrollMatches = false;
						this._pdfDocument = null;
						this._pageMatches = [];
						this._pageMatchesLength = [];
						this._state = null;
						this._selected = {
							pageIdx: -1,
							matchIdx: -1
						};
						this._offset = {
							pageIdx: null,
							matchIdx: null,
							wrapped: false
						};
						this._extractTextPromises = [];
						this._pageContents = [];
						this._pageDiffs = [];
						this._hasDiacritics = [];
						this._matchesCountTotal = 0;
						this._pagesToSearch = null;
						this._pendingFindMatches = new Set();
						this._resumePageIdx = null;
						this._dirtyMatch = false;
						clearTimeout(this._findTimeout);
						this._findTimeout = null;
						this._firstPageCapability = (0, _pdfjsLib
							.createPromiseCapability)();
					}
				}, {
					key: "_query",
					get: function get() {
						if (this._state.query !== this._rawQuery) {
							this._rawQuery = this._state.query;

							var _normalize = normalize(this._state.query);

							var _normalize2 = _slicedToArray(_normalize, 1);

							this._normalizedQuery = _normalize2[0];
						}

						return this._normalizedQuery;
					}
				}, {
					key: "_shouldDirtyMatch",
					value: function _shouldDirtyMatch(state) {
						if (state.query !== this._state.query) {
							return true;
						}

						switch (state.type) {
							case "again":
								var pageNumber = this._selected.pageIdx + 1;
								var linkService = this._linkService;

								if (pageNumber >= 1 && pageNumber <= linkService
									.pagesCount && pageNumber !== linkService
									.page && !linkService.isPageVisible(pageNumber)
									) {
									return true;
								}

								return false;

							case "highlightallchange":
								return false;
						}

						return true;
					}
				}, {
					key: "_isEntireWord",
					value: function _isEntireWord(content, startIdx, length) {
						var match = content.slice(0, startIdx).match(
							NOT_DIACRITIC_FROM_END_REG_EXP);

						if (match) {
							var first = content.charCodeAt(startIdx);
							var limit = match[1].charCodeAt(0);

							if ((0, _pdf_find_utils.getCharacterType)(first) === (0,
									_pdf_find_utils.getCharacterType)(limit)) {
								return false;
							}
						}

						match = content.slice(startIdx + length).match(
							NOT_DIACRITIC_FROM_START_REG_EXP);

						if (match) {
							var last = content.charCodeAt(startIdx + length - 1);

							var _limit = match[1].charCodeAt(0);

							if ((0, _pdf_find_utils.getCharacterType)(last) === (0,
									_pdf_find_utils.getCharacterType)(_limit)) {
								return false;
							}
						}

						return true;
					}
				}, {
					key: "_calculateRegExpMatch",
					value: function _calculateRegExpMatch(query, entireWord, pageIndex,
						pageContent) {
						var matches = [],
							matchesLength = [];
						var diffs = this._pageDiffs[pageIndex];
						var match;

						while ((match = query.exec(pageContent)) !== null) {
							if (entireWord && !this._isEntireWord(pageContent, match
									.index, match[0].length)) {
								continue;
							}

							var _getOriginalIndex = getOriginalIndex(diffs, match
									.index, match[0].length),
								_getOriginalIndex2 = _slicedToArray(
									_getOriginalIndex, 2),
								matchPos = _getOriginalIndex2[0],
								matchLen = _getOriginalIndex2[1];

							if (matchLen) {
								matches.push(matchPos);
								matchesLength.push(matchLen);
							}
						}

						this._pageMatches[pageIndex] = matches;
						this._pageMatchesLength[pageIndex] = matchesLength;
					}
				}, {
					key: "_convertToRegExpString",
					value: function _convertToRegExpString(query, hasDiacritics) {
						var matchDiacritics = this._state.matchDiacritics;
						var isUnicode = false;
						query = query.replace(SPECIAL_CHARS_REG_EXP, function(match,
							p1, p2, p3, p4, p5) {
							if (p1) {
								return "[ ]*\\".concat(p1, "[ ]*");
							}

							if (p2) {
								return "[ ]*".concat(p2, "[ ]*");
							}

							if (p3) {
								return "[ ]+";
							}

							if (matchDiacritics) {
								return p4 || p5;
							}

							if (p4) {
								return DIACRITICS_EXCEPTION.has(p4
									.charCodeAt(0)) ? p4 : "";
							}

							if (hasDiacritics) {
								isUnicode = true;
								return "".concat(p5, "\\p{M}*");
							}

							return p5;
						});
						var trailingSpaces = "[ ]*";

						if (query.endsWith(trailingSpaces)) {
							query = query.slice(0, query.length - trailingSpaces
								.length);
						}

						if (matchDiacritics) {
							if (hasDiacritics) {
								isUnicode = true;
								query = "".concat(query, "(?=[").concat(
									DIACRITICS_EXCEPTION_STR, "]|[^\\p{M}]|$)");
							}
						}

						return [isUnicode, query];
					}
				}, {
					key: "_calculateMatch",
					value: function _calculateMatch(pageIndex) {
						var _this3 = this;

						var query = this._query;

						if (query.length === 0) {
							return;
						}

						var _this$_state = this._state,
							caseSensitive = _this$_state.caseSensitive,
							entireWord = _this$_state.entireWord,
							phraseSearch = _this$_state.phraseSearch;
						var pageContent = this._pageContents[pageIndex];
						var hasDiacritics = this._hasDiacritics[pageIndex];
						var isUnicode = false;

						if (phraseSearch) {
							var _this$_convertToRegEx = this._convertToRegExpString(
								query, hasDiacritics);

							var _this$_convertToRegEx2 = _slicedToArray(
								_this$_convertToRegEx, 2);

							isUnicode = _this$_convertToRegEx2[0];
							query = _this$_convertToRegEx2[1];
						} else {
							var match = query.match(/\S+/g);

							if (match) {
								query = match.sort().reverse().map(function(q) {
									var _this3$_convertToRegE = _this3
										._convertToRegExpString(q,
											hasDiacritics),
										_this3$_convertToRegE2 =
										_slicedToArray(
											_this3$_convertToRegE, 2),
										isUnicodePart =
										_this3$_convertToRegE2[0],
										queryPart = _this3$_convertToRegE2[
											1];

									isUnicode || (isUnicode =
									isUnicodePart);
									return "(".concat(queryPart, ")");
								}).join("|");
							}
						}

						var flags = "g".concat(isUnicode ? "u" : "").concat(
							caseSensitive ? "" : "i");
						query = new RegExp(query, flags);

						this._calculateRegExpMatch(query, entireWord, pageIndex,
							pageContent);

						if (this._state.highlightAll) {
							this._updatePage(pageIndex);
						}

						if (this._resumePageIdx === pageIndex) {
							this._resumePageIdx = null;

							this._nextPageMatch();
						}

						var pageMatchesCount = this._pageMatches[pageIndex].length;

						if (pageMatchesCount > 0) {
							this._matchesCountTotal += pageMatchesCount;

							this._updateUIResultsCount();
						}
					}
				}, {
					key: "_extractText",
					value: function _extractText() {
						var _this4 = this;

						if (this._extractTextPromises.length > 0) {
							return;
						}

						var promise = Promise.resolve();

						var _loop = function _loop(i, ii) {
							var extractTextCapability = (0, _pdfjsLib
								.createPromiseCapability)();
							_this4._extractTextPromises[i] =
								extractTextCapability.promise;
							promise = promise.then(function() {
								return _this4._pdfDocument.getPage(i +
									1).then(function(pdfPage) {
									return pdfPage
										.getTextContent();
								}).then(function(textContent) {
									var textItems = textContent
										.items;
									var strBuf = [];

									for (var j = 0, jj =
											textItems
											.length; j < jj; j++
										) {
										strBuf.push(textItems[j]
											.str);

										if (textItems[j]
											.hasEOL) {
											strBuf.push("\n");
										}
									}

									var _normalize3 = normalize(
										strBuf.join(""));

									var _normalize4 =
										_slicedToArray(
											_normalize3, 3);

									_this4._pageContents[i] =
										_normalize4[0];
									_this4._pageDiffs[i] =
										_normalize4[1];
									_this4._hasDiacritics[i] =
										_normalize4[2];
									extractTextCapability
										.resolve(i);
								}, function(reason) {
									console.error(
										"Unable to get text content for page "
										.concat(i + 1),
										reason);
									_this4._pageContents[i] =
									"";
									_this4._pageDiffs[i] = null;
									_this4._hasDiacritics[i] =
										false;
									extractTextCapability
										.resolve(i);
								});
							});
						};

						for (var i = 0, ii = this._linkService.pagesCount; i <
							ii; i++) {
							_loop(i, ii);
						}
					}
				}, {
					key: "_updatePage",
					value: function _updatePage(index) {
						if (this._scrollMatches && this._selected.pageIdx ===
							index) {
							this._linkService.page = index + 1;
						}

						this._eventBus.dispatch("updatetextlayermatches", {
							source: this,
							pageIndex: index
						});
					}
				}, {
					key: "_updateAllPages",
					value: function _updateAllPages() {
						this._eventBus.dispatch("updatetextlayermatches", {
							source: this,
							pageIndex: -1
						});
					}
				}, {
					key: "_nextMatch",
					value: function _nextMatch() {
						var _this5 = this;

						var previous = this._state.findPrevious;
						var currentPageIndex = this._linkService.page - 1;
						var numPages = this._linkService.pagesCount;
						this._highlightMatches = true;

						if (this._dirtyMatch) {
							this._dirtyMatch = false;
							this._selected.pageIdx = this._selected.matchIdx = -1;
							this._offset.pageIdx = currentPageIndex;
							this._offset.matchIdx = null;
							this._offset.wrapped = false;
							this._resumePageIdx = null;
							this._pageMatches.length = 0;
							this._pageMatchesLength.length = 0;
							this._matchesCountTotal = 0;

							this._updateAllPages();

							for (var i = 0; i < numPages; i++) {
								if (this._pendingFindMatches.has(i)) {
									continue;
								}

								this._pendingFindMatches.add(i);

								this._extractTextPromises[i].then(function(
								pageIdx) {
									_this5._pendingFindMatches["delete"](
										pageIdx);

									_this5._calculateMatch(pageIdx);
								});
							}
						}

						if (this._query === "") {
							this._updateUIState(FindState.FOUND);

							return;
						}

						if (this._resumePageIdx) {
							return;
						}

						var offset = this._offset;
						this._pagesToSearch = numPages;

						if (offset.matchIdx !== null) {
							var numPageMatches = this._pageMatches[offset.pageIdx]
								.length;

							if (!previous && offset.matchIdx + 1 < numPageMatches ||
								previous && offset.matchIdx > 0) {
								offset.matchIdx = previous ? offset.matchIdx - 1 :
									offset.matchIdx + 1;

								this._updateMatch(true);

								return;
							}

							this._advanceOffsetPage(previous);
						}

						this._nextPageMatch();
					}
				}, {
					key: "_matchesReady",
					value: function _matchesReady(matches) {
						var offset = this._offset;
						var numMatches = matches.length;
						var previous = this._state.findPrevious;

						if (numMatches) {
							offset.matchIdx = previous ? numMatches - 1 : 0;

							this._updateMatch(true);

							return true;
						}

						this._advanceOffsetPage(previous);

						if (offset.wrapped) {
							offset.matchIdx = null;

							if (this._pagesToSearch < 0) {
								this._updateMatch(false);

								return true;
							}
						}

						return false;
					}
				}, {
					key: "_nextPageMatch",
					value: function _nextPageMatch() {
						if (this._resumePageIdx !== null) {
							console.error("There can only be one pending page.");
						}

						var matches = null;

						do {
							var pageIdx = this._offset.pageIdx;
							matches = this._pageMatches[pageIdx];

							if (!matches) {
								this._resumePageIdx = pageIdx;
								break;
							}
						} while (!this._matchesReady(matches));
					}
				}, {
					key: "_advanceOffsetPage",
					value: function _advanceOffsetPage(previous) {
						var offset = this._offset;
						var numPages = this._linkService.pagesCount;
						offset.pageIdx = previous ? offset.pageIdx - 1 : offset
							.pageIdx + 1;
						offset.matchIdx = null;
						this._pagesToSearch--;

						if (offset.pageIdx >= numPages || offset.pageIdx < 0) {
							offset.pageIdx = previous ? numPages - 1 : 0;
							offset.wrapped = true;
						}
					}
				}, {
					key: "_updateMatch",
					value: function _updateMatch() {
						var found = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : false;
						var state = FindState.NOT_FOUND;
						var wrapped = this._offset.wrapped;
						this._offset.wrapped = false;

						if (found) {
							var previousPage = this._selected.pageIdx;
							this._selected.pageIdx = this._offset.pageIdx;
							this._selected.matchIdx = this._offset.matchIdx;
							state = wrapped ? FindState.WRAPPED : FindState.FOUND;

							if (previousPage !== -1 && previousPage !== this
								._selected.pageIdx) {
								this._updatePage(previousPage);
							}
						}

						this._updateUIState(state, this._state.findPrevious);

						if (this._selected.pageIdx !== -1) {
							this._scrollMatches = true;

							this._updatePage(this._selected.pageIdx);
						}
					}
				}, {
					key: "_onFindBarClose",
					value: function _onFindBarClose(evt) {
						var _this6 = this;

						var pdfDocument = this._pdfDocument;

						this._firstPageCapability.promise.then(function() {
							if (!_this6._pdfDocument || pdfDocument &&
								_this6._pdfDocument !== pdfDocument) {
								return;
							}

							if (_this6._findTimeout) {
								clearTimeout(_this6._findTimeout);
								_this6._findTimeout = null;
							}

							if (_this6._resumePageIdx) {
								_this6._resumePageIdx = null;
								_this6._dirtyMatch = true;
							}

							_this6._updateUIState(FindState.FOUND);

							_this6._highlightMatches = false;

							_this6._updateAllPages();
						});
					}
				}, {
					key: "_requestMatchesCount",
					value: function _requestMatchesCount() {
						var _this$_selected = this._selected,
							pageIdx = _this$_selected.pageIdx,
							matchIdx = _this$_selected.matchIdx;
						var current = 0,
							total = this._matchesCountTotal;

						if (matchIdx !== -1) {
							for (var i = 0; i < pageIdx; i++) {
								var _this$_pageMatches$i;

								current += ((_this$_pageMatches$i = this
										._pageMatches[i]) === null ||
									_this$_pageMatches$i === void 0 ? void 0 :
									_this$_pageMatches$i.length) || 0;
							}

							current += matchIdx + 1;
						}

						if (current < 1 || current > total) {
							current = total = 0;
						}

						return {
							current: current,
							total: total
						};
					}
				}, {
					key: "_updateUIResultsCount",
					value: function _updateUIResultsCount() {
						this._eventBus.dispatch("updatefindmatchescount", {
							source: this,
							matchesCount: this._requestMatchesCount()
						});
					}
				}, {
					key: "_updateUIState",
					value: function _updateUIState(state) {
						var _this$_state$query, _this$_state2;

						var previous = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : false;

						this._eventBus.dispatch("updatefindcontrolstate", {
							source: this,
							state: state,
							previous: previous,
							matchesCount: this._requestMatchesCount(),
							rawQuery: (_this$_state$query = (_this$_state2 =
										this._state) === null ||
									_this$_state2 === void 0 ? void 0 :
									_this$_state2.query) !== null &&
								_this$_state$query !== void 0 ?
								_this$_state$query : null
						});
					}
				}]);

				return PDFFindController;
			}();

			exports.PDFFindController = PDFFindController;

			/***/
		}),
		/* 18 */
		/***/
		((__unused_webpack_module, exports) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.CharacterType = void 0;
			exports.getCharacterType = getCharacterType;
			var CharacterType = {
				SPACE: 0,
				ALPHA_LETTER: 1,
				PUNCT: 2,
				HAN_LETTER: 3,
				KATAKANA_LETTER: 4,
				HIRAGANA_LETTER: 5,
				HALFWIDTH_KATAKANA_LETTER: 6,
				THAI_LETTER: 7
			};
			exports.CharacterType = CharacterType;

			function isAlphabeticalScript(charCode) {
				return charCode < 0x2e80;
			}

			function isAscii(charCode) {
				return (charCode & 0xff80) === 0;
			}

			function isAsciiAlpha(charCode) {
				return charCode >= 0x61 && charCode <= 0x7a || charCode >= 0x41 && charCode <= 0x5a;
			}

			function isAsciiDigit(charCode) {
				return charCode >= 0x30 && charCode <= 0x39;
			}

			function isAsciiSpace(charCode) {
				return charCode === 0x20 || charCode === 0x09 || charCode === 0x0d || charCode === 0x0a;
			}

			function isHan(charCode) {
				return charCode >= 0x3400 && charCode <= 0x9fff || charCode >= 0xf900 && charCode <=
					0xfaff;
			}

			function isKatakana(charCode) {
				return charCode >= 0x30a0 && charCode <= 0x30ff;
			}

			function isHiragana(charCode) {
				return charCode >= 0x3040 && charCode <= 0x309f;
			}

			function isHalfwidthKatakana(charCode) {
				return charCode >= 0xff60 && charCode <= 0xff9f;
			}

			function isThai(charCode) {
				return (charCode & 0xff80) === 0x0e00;
			}

			function getCharacterType(charCode) {
				if (isAlphabeticalScript(charCode)) {
					if (isAscii(charCode)) {
						if (isAsciiSpace(charCode)) {
							return CharacterType.SPACE;
						} else if (isAsciiAlpha(charCode) || isAsciiDigit(charCode) || charCode ===
							0x5f) {
							return CharacterType.ALPHA_LETTER;
						}

						return CharacterType.PUNCT;
					} else if (isThai(charCode)) {
						return CharacterType.THAI_LETTER;
					} else if (charCode === 0xa0) {
						return CharacterType.SPACE;
					}

					return CharacterType.ALPHA_LETTER;
				}

				if (isHan(charCode)) {
					return CharacterType.HAN_LETTER;
				} else if (isKatakana(charCode)) {
					return CharacterType.KATAKANA_LETTER;
				} else if (isHiragana(charCode)) {
					return CharacterType.HIRAGANA_LETTER;
				} else if (isHalfwidthKatakana(charCode)) {
					return CharacterType.HALFWIDTH_KATAKANA_LETTER;
				}

				return CharacterType.ALPHA_LETTER;
			}

			/***/
		}),
		/* 19 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFHistory = void 0;
			exports.isDestArraysEqual = isDestArraysEqual;
			exports.isDestHashesEqual = isDestHashesEqual;

			var _ui_utils = __webpack_require__(5);

			var _event_utils = __webpack_require__(6);

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

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

			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."
					);
			}

			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);
			}

			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;
			}

			function _iterableToArrayLimit(arr, i) {
				var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] ||
					arr["@@iterator"];
				if (_i == null) return;
				var _arr = [];
				var _n = true;
				var _d = false;
				var _s, _e;
				try {
					for (_i = _i.call(arr); !(_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;
			}

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

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var HASH_CHANGE_TIMEOUT = 1000;
			var POSITION_UPDATED_THRESHOLD = 50;
			var UPDATE_VIEWAREA_TIMEOUT = 1000;

			function getCurrentHash() {
				return document.location.hash;
			}

			var PDFHistory = /*#__PURE__*/ function() {
				function PDFHistory(_ref) {
					var _this = this;

					var linkService = _ref.linkService,
						eventBus = _ref.eventBus;

					_classCallCheck(this, PDFHistory);

					this.linkService = linkService;
					this.eventBus = eventBus;
					this._initialized = false;
					this._fingerprint = "";
					this.reset();
					this._boundEvents = null;
					this._isViewerInPresentationMode = false;

					this.eventBus._on("presentationmodechanged", function(evt) {
						_this._isViewerInPresentationMode = evt.state !== _ui_utils
							.PresentationModeState.NORMAL;
					});

					this.eventBus._on("pagesinit", function() {
						_this._isPagesLoaded = false;

						_this.eventBus._on("pagesloaded", function(evt) {
							_this._isPagesLoaded = !!evt.pagesCount;
						}, {
							once: true
						});
					});
				}

				_createClass(PDFHistory, [{
					key: "initialize",
					value: function initialize(_ref2) {
						var fingerprint = _ref2.fingerprint,
							_ref2$resetHistory = _ref2.resetHistory,
							resetHistory = _ref2$resetHistory === void 0 ? false :
							_ref2$resetHistory,
							_ref2$updateUrl = _ref2.updateUrl,
							updateUrl = _ref2$updateUrl === void 0 ? false :
							_ref2$updateUrl;

						if (!fingerprint || typeof fingerprint !== "string") {
							console.error(
								'PDFHistory.initialize: The "fingerprint" must be a non-empty string.'
								);
							return;
						}

						if (this._initialized) {
							this.reset();
						}

						var reInitialized = this._fingerprint !== "" && this
							._fingerprint !== fingerprint;
						this._fingerprint = fingerprint;
						this._updateUrl = updateUrl === true;
						this._initialized = true;

						this._bindEvents();

						var state = window.history.state;
						this._popStateInProgress = false;
						this._blockHashChange = 0;
						this._currentHash = getCurrentHash();
						this._numPositionUpdates = 0;
						this._uid = this._maxUid = 0;
						this._destination = null;
						this._position = null;

						if (!this._isValidState(state, true) || resetHistory) {
							var _this$_parseCurrentHa = this._parseCurrentHash(
								true),
								hash = _this$_parseCurrentHa.hash,
								page = _this$_parseCurrentHa.page,
								rotation = _this$_parseCurrentHa.rotation;

							if (!hash || reInitialized || resetHistory) {
								this._pushOrReplaceState(null, true);

								return;
							}

							this._pushOrReplaceState({
								hash: hash,
								page: page,
								rotation: rotation
							}, true);

							return;
						}

						var destination = state.destination;

						this._updateInternalState(destination, state.uid, true);

						if (destination.rotation !== undefined) {
							this._initialRotation = destination.rotation;
						}

						if (destination.dest) {
							this._initialBookmark = JSON.stringify(destination
							.dest);
							this._destination.page = null;
						} else if (destination.hash) {
							this._initialBookmark = destination.hash;
						} else if (destination.page) {
							this._initialBookmark = "page=".concat(destination
							.page);
						}
					}
				}, {
					key: "reset",
					value: function reset() {
						if (this._initialized) {
							this._pageHide();

							this._initialized = false;

							this._unbindEvents();
						}

						if (this._updateViewareaTimeout) {
							clearTimeout(this._updateViewareaTimeout);
							this._updateViewareaTimeout = null;
						}

						this._initialBookmark = null;
						this._initialRotation = null;
					}
				}, {
					key: "push",
					value: function push(_ref3) {
						var _this2 = this;

						var _ref3$namedDest = _ref3.namedDest,
							namedDest = _ref3$namedDest === void 0 ? null :
							_ref3$namedDest,
							explicitDest = _ref3.explicitDest,
							pageNumber = _ref3.pageNumber;

						if (!this._initialized) {
							return;
						}

						if (namedDest && typeof namedDest !== "string") {
							console.error("PDFHistory.push: " + "\"".concat(
								namedDest,
								"\" is not a valid namedDest parameter."));
							return;
						} else if (!Array.isArray(explicitDest)) {
							console.error("PDFHistory.push: " + "\"".concat(
									explicitDest,
									"\" is not a valid explicitDest parameter."
									));
							return;
						} else if (!this._isValidPage(pageNumber)) {
							if (pageNumber !== null || this._destination) {
								console.error("PDFHistory.push: " + "\"".concat(
									pageNumber,
									"\" is not a valid pageNumber parameter."
									));
								return;
							}
						}

						var hash = namedDest || JSON.stringify(explicitDest);

						if (!hash) {
							return;
						}

						var forceReplace = false;

						if (this._destination && (isDestHashesEqual(this
								._destination.hash, hash) || isDestArraysEqual(
								this._destination.dest, explicitDest))) {
							if (this._destination.page) {
								return;
							}

							forceReplace = true;
						}

						if (this._popStateInProgress && !forceReplace) {
							return;
						}

						this._pushOrReplaceState({
							dest: explicitDest,
							hash: hash,
							page: pageNumber,
							rotation: this.linkService.rotation
						}, forceReplace);

						if (!this._popStateInProgress) {
							this._popStateInProgress = true;
							Promise.resolve().then(function() {
								_this2._popStateInProgress = false;
							});
						}
					}
				}, {
					key: "pushPage",
					value: function pushPage(pageNumber) {
						var _this$_destination,
							_this3 = this;

						if (!this._initialized) {
							return;
						}

						if (!this._isValidPage(pageNumber)) {
							console.error("PDFHistory.pushPage: \"".concat(
								pageNumber, "\" is not a valid page number."
								));
							return;
						}

						if (((_this$_destination = this._destination) === null ||
								_this$_destination === void 0 ? void 0 :
								_this$_destination.page) === pageNumber) {
							return;
						}

						if (this._popStateInProgress) {
							return;
						}

						this._pushOrReplaceState({
							dest: null,
							hash: "page=".concat(pageNumber),
							page: pageNumber,
							rotation: this.linkService.rotation
						});

						if (!this._popStateInProgress) {
							this._popStateInProgress = true;
							Promise.resolve().then(function() {
								_this3._popStateInProgress = false;
							});
						}
					}
				}, {
					key: "pushCurrentPosition",
					value: function pushCurrentPosition() {
						if (!this._initialized || this._popStateInProgress) {
							return;
						}

						this._tryPushCurrentPosition();
					}
				}, {
					key: "back",
					value: function back() {
						if (!this._initialized || this._popStateInProgress) {
							return;
						}

						var state = window.history.state;

						if (this._isValidState(state) && state.uid > 0) {
							window.history.back();
						}
					}
				}, {
					key: "forward",
					value: function forward() {
						if (!this._initialized || this._popStateInProgress) {
							return;
						}

						var state = window.history.state;

						if (this._isValidState(state) && state.uid < this._maxUid) {
							window.history.forward();
						}
					}
				}, {
					key: "popStateInProgress",
					get: function get() {
						return this._initialized && (this._popStateInProgress ||
							this._blockHashChange > 0);
					}
				}, {
					key: "initialBookmark",
					get: function get() {
						return this._initialized ? this._initialBookmark : null;
					}
				}, {
					key: "initialRotation",
					get: function get() {
						return this._initialized ? this._initialRotation : null;
					}
				}, {
					key: "_pushOrReplaceState",
					value: function _pushOrReplaceState(destination) {
						var forceReplace = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : false;
						var shouldReplace = forceReplace || !this._destination;
						var newState = {
							fingerprint: this._fingerprint,
							uid: shouldReplace ? this._uid : this._uid + 1,
							destination: destination
						};

						this._updateInternalState(destination, newState.uid);

						var newUrl;

						if (this._updateUrl && destination !== null &&
							destination !== void 0 && destination.hash) {
							var baseUrl = document.location.href.split("#")[0];

							if (!baseUrl.startsWith("file://")) {
								newUrl = "".concat(baseUrl, "#").concat(destination
									.hash);
							}
						}

						if (shouldReplace) {
							window.history.replaceState(newState, "", newUrl);
						} else {
							window.history.pushState(newState, "", newUrl);
						}
					}
				}, {
					key: "_tryPushCurrentPosition",
					value: function _tryPushCurrentPosition() {
						var temporary = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : false;

						if (!this._position) {
							return;
						}

						var position = this._position;

						if (temporary) {
							position = Object.assign(Object.create(null), this
								._position);
							position.temporary = true;
						}

						if (!this._destination) {
							this._pushOrReplaceState(position);

							return;
						}

						if (this._destination.temporary) {
							this._pushOrReplaceState(position, true);

							return;
						}

						if (this._destination.hash === position.hash) {
							return;
						}

						if (!this._destination.page && (
								POSITION_UPDATED_THRESHOLD <= 0 || this
								._numPositionUpdates <= POSITION_UPDATED_THRESHOLD
								)) {
							return;
						}

						var forceReplace = false;

						if (this._destination.page >= position.first && this
							._destination.page <= position.page) {
							if (this._destination.dest !== undefined || !this
								._destination.first) {
								return;
							}

							forceReplace = true;
						}

						this._pushOrReplaceState(position, forceReplace);
					}
				}, {
					key: "_isValidPage",
					value: function _isValidPage(val) {
						return Number.isInteger(val) && val > 0 && val <= this
							.linkService.pagesCount;
					}
				}, {
					key: "_isValidState",
					value: function _isValidState(state) {
						var checkReload = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : false;

						if (!state) {
							return false;
						}

						if (state.fingerprint !== this._fingerprint) {
							if (checkReload) {
								if (typeof state.fingerprint !== "string" || state
									.fingerprint.length !== this._fingerprint.length
									) {
									return false;
								}

								var _performance$getEntri = performance
									.getEntriesByType("navigation"),
									_performance$getEntri2 = _slicedToArray(
										_performance$getEntri, 1),
									perfEntry = _performance$getEntri2[0];

								if ((perfEntry === null || perfEntry === void 0 ?
										void 0 : perfEntry.type) !== "reload") {
									return false;
								}
							} else {
								return false;
							}
						}

						if (!Number.isInteger(state.uid) || state.uid < 0) {
							return false;
						}

						if (state.destination === null || _typeof(state
							.destination) !== "object") {
							return false;
						}

						return true;
					}
				}, {
					key: "_updateInternalState",
					value: function _updateInternalState(destination, uid) {
						var removeTemporary = arguments.length > 2 && arguments[
							2] !== undefined ? arguments[2] : false;

						if (this._updateViewareaTimeout) {
							clearTimeout(this._updateViewareaTimeout);
							this._updateViewareaTimeout = null;
						}

						if (removeTemporary && destination !== null &&
							destination !== void 0 && destination.temporary) {
							delete destination.temporary;
						}

						this._destination = destination;
						this._uid = uid;
						this._maxUid = Math.max(this._maxUid, uid);
						this._numPositionUpdates = 0;
					}
				}, {
					key: "_parseCurrentHash",
					value: function _parseCurrentHash() {
						var checkNameddest = arguments.length > 0 && arguments[
							0] !== undefined ? arguments[0] : false;
						var hash = unescape(getCurrentHash()).substring(1);
						var params = (0, _ui_utils.parseQueryString)(hash);
						var nameddest = params.get("nameddest") || "";
						var page = params.get("page") | 0;

						if (!this._isValidPage(page) || checkNameddest && nameddest
							.length > 0) {
							page = null;
						}

						return {
							hash: hash,
							page: page,
							rotation: this.linkService.rotation
						};
					}
				}, {
					key: "_updateViewarea",
					value: function _updateViewarea(_ref4) {
						var _this4 = this;

						var location = _ref4.location;

						if (this._updateViewareaTimeout) {
							clearTimeout(this._updateViewareaTimeout);
							this._updateViewareaTimeout = null;
						}

						this._position = {
							hash: this._isViewerInPresentationMode ? "page="
								.concat(location.pageNumber) : location
								.pdfOpenParams.substring(1),
							page: this.linkService.page,
							first: location.pageNumber,
							rotation: location.rotation
						};

						if (this._popStateInProgress) {
							return;
						}

						if (POSITION_UPDATED_THRESHOLD > 0 && this._isPagesLoaded &&
							this._destination && !this._destination.page) {
							this._numPositionUpdates++;
						}

						if (UPDATE_VIEWAREA_TIMEOUT > 0) {
							this._updateViewareaTimeout = setTimeout(function() {
								if (!_this4._popStateInProgress) {
									_this4._tryPushCurrentPosition(true);
								}

								_this4._updateViewareaTimeout = null;
							}, UPDATE_VIEWAREA_TIMEOUT);
						}
					}
				}, {
					key: "_popState",
					value: function _popState(_ref5) {
						var _this5 = this;

						var state = _ref5.state;
						var newHash = getCurrentHash(),
							hashChanged = this._currentHash !== newHash;
						this._currentHash = newHash;

						if (!state) {
							this._uid++;

							var _this$_parseCurrentHa2 = this._parseCurrentHash(),
								hash = _this$_parseCurrentHa2.hash,
								page = _this$_parseCurrentHa2.page,
								rotation = _this$_parseCurrentHa2.rotation;

							this._pushOrReplaceState({
								hash: hash,
								page: page,
								rotation: rotation
							}, true);

							return;
						}

						if (!this._isValidState(state)) {
							return;
						}

						this._popStateInProgress = true;

						if (hashChanged) {
							this._blockHashChange++;
							(0, _event_utils.waitOnEventOrTimeout)({
								target: window,
								name: "hashchange",
								delay: HASH_CHANGE_TIMEOUT
							}).then(function() {
								_this5._blockHashChange--;
							});
						}

						var destination = state.destination;

						this._updateInternalState(destination, state.uid, true);

						if ((0, _ui_utils.isValidRotation)(destination.rotation)) {
							this.linkService.rotation = destination.rotation;
						}

						if (destination.dest) {
							this.linkService.goToDestination(destination.dest);
						} else if (destination.hash) {
							this.linkService.setHash(destination.hash);
						} else if (destination.page) {
							this.linkService.page = destination.page;
						}

						Promise.resolve().then(function() {
							_this5._popStateInProgress = false;
						});
					}
				}, {
					key: "_pageHide",
					value: function _pageHide() {
						if (!this._destination || this._destination.temporary) {
							this._tryPushCurrentPosition();
						}
					}
				}, {
					key: "_bindEvents",
					value: function _bindEvents() {
						if (this._boundEvents) {
							return;
						}

						this._boundEvents = {
							updateViewarea: this._updateViewarea.bind(this),
							popState: this._popState.bind(this),
							pageHide: this._pageHide.bind(this)
						};

						this.eventBus._on("updateviewarea", this._boundEvents
							.updateViewarea);

						window.addEventListener("popstate", this._boundEvents
							.popState);
						window.addEventListener("pagehide", this._boundEvents
							.pageHide);
					}
				}, {
					key: "_unbindEvents",
					value: function _unbindEvents() {
						if (!this._boundEvents) {
							return;
						}

						this.eventBus._off("updateviewarea", this._boundEvents
							.updateViewarea);

						window.removeEventListener("popstate", this._boundEvents
							.popState);
						window.removeEventListener("pagehide", this._boundEvents
							.pageHide);
						this._boundEvents = null;
					}
				}]);

				return PDFHistory;
			}();

			exports.PDFHistory = PDFHistory;

			function isDestHashesEqual(destHash, pushHash) {
				if (typeof destHash !== "string" || typeof pushHash !== "string") {
					return false;
				}

				if (destHash === pushHash) {
					return true;
				}

				var nameddest = (0, _ui_utils.parseQueryString)(destHash).get("nameddest");

				if (nameddest === pushHash) {
					return true;
				}

				return false;
			}

			function isDestArraysEqual(firstDest, secondDest) {
				function isEntryEqual(first, second) {
					if (_typeof(first) !== _typeof(second)) {
						return false;
					}

					if (Array.isArray(first) || Array.isArray(second)) {
						return false;
					}

					if (first !== null && _typeof(first) === "object" && second !== null) {
						if (Object.keys(first).length !== Object.keys(second).length) {
							return false;
						}

						for (var key in first) {
							if (!isEntryEqual(first[key], second[key])) {
								return false;
							}
						}

						return true;
					}

					return first === second || Number.isNaN(first) && Number.isNaN(second);
				}

				if (!(Array.isArray(firstDest) && Array.isArray(secondDest))) {
					return false;
				}

				if (firstDest.length !== secondDest.length) {
					return false;
				}

				for (var i = 0, ii = firstDest.length; i < ii; i++) {
					if (!isEntryEqual(firstDest[i], secondDest[i])) {
						return false;
					}
				}

				return true;
			}

			/***/
		}),
		/* 20 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFLayerViewer = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _base_tree_viewer = __webpack_require__(14);

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

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

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

			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);
			}

			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;
			}

			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);
				}
			}

			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);
					});
				};
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			function _get() {
				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(arguments.length < 3 ? target : receiver);
						}
						return desc.value;
					};
				}
				return _get.apply(this, arguments);
			}

			function _superPropBase(object, property) {
				while (!Object.prototype.hasOwnProperty.call(object, property)) {
					object = _getPrototypeOf(object);
					if (object === null) break;
				}
				return object;
			}

			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
					}
				});
				Object.defineProperty(subClass, "prototype", {
					writable: false
				});
				if (superClass) _setPrototypeOf(subClass, superClass);
			}

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

			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);
				};
			}

			function _possibleConstructorReturn(self, call) {
				if (call && (_typeof(call) === "object" || typeof call === "function")) {
					return call;
				} else if (call !== void 0) {
					throw new TypeError("Derived constructors may only return object or undefined");
				}
				return _assertThisInitialized(self);
			}

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

			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;
				}
			}

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

			var PDFLayerViewer = /*#__PURE__*/ function(_BaseTreeViewer) {
				_inherits(PDFLayerViewer, _BaseTreeViewer);

				var _super = _createSuper(PDFLayerViewer);

				function PDFLayerViewer(options) {
					var _this;

					_classCallCheck(this, PDFLayerViewer);

					_this = _super.call(this, options);
					_this.l10n = options.l10n;

					_this.eventBus._on("resetlayers", _this._resetLayers.bind(
						_assertThisInitialized(_this)));

					_this.eventBus._on("togglelayerstree", _this._toggleAllTreeItems.bind(
						_assertThisInitialized(_this)));

					return _this;
				}

				_createClass(PDFLayerViewer, [{
					key: "reset",
					value: function reset() {
						_get(_getPrototypeOf(PDFLayerViewer.prototype), "reset",
							this).call(this);

						this._optionalContentConfig = null;
					}
				}, {
					key: "_dispatchEvent",
					value: function _dispatchEvent(layersCount) {
						this.eventBus.dispatch("layersloaded", {
							source: this,
							layersCount: layersCount
						});
					}
				}, {
					key: "_bindLink",
					value: function _bindLink(element, _ref) {
						var _this2 = this;

						var groupId = _ref.groupId,
							input = _ref.input;

						var setVisibility = function setVisibility() {
							_this2._optionalContentConfig.setVisibility(groupId,
								input.checked);

							_this2.eventBus.dispatch("optionalcontentconfig", {
								source: _this2,
								promise: Promise.resolve(_this2
									._optionalContentConfig)
							});
						};

						element.onclick = function(evt) {
							if (evt.target === input) {
								setVisibility();
								return true;
							} else if (evt.target !== element) {
								return true;
							}

							input.checked = !input.checked;
							setVisibility();
							return false;
						};
					}
				}, {
					key: "_setNestedName",
					value: function() {
						var _setNestedName2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee(
								element, _ref2) {
								var _ref2$name, name;

								return _regenerator["default"].wrap(
									function _callee$(_context) {
										while (1) {
											switch (_context.prev =
												_context.next) {
												case 0:
													_ref2$name = _ref2
														.name, name =
														_ref2$name ===
														void 0 ? null :
														_ref2$name;

													if (!(typeof name ===
															"string")) {
														_context.next =
															4;
														break;
													}

													element
														.textContent =
														this
														._normalizeTextContent(
															name);
													return _context
														.abrupt(
															"return");

												case 4:
													_context.next = 6;
													return this.l10n
														.get(
															"additional_layers"
															);

												case 6:
													element
														.textContent =
														_context.sent;
													element.style
														.fontStyle =
														"italic";

												case 8:
												case "end":
													return _context
														.stop();
											}
										}
									}, _callee, this);
							}));

						function _setNestedName(_x, _x2) {
							return _setNestedName2.apply(this, arguments);
						}

						return _setNestedName;
					}()
				}, {
					key: "_addToggleButton",
					value: function _addToggleButton(div, _ref3) {
						var _ref3$name = _ref3.name,
							name = _ref3$name === void 0 ? null : _ref3$name;

						_get(_getPrototypeOf(PDFLayerViewer.prototype),
							"_addToggleButton", this).call(this, div, name ===
							null);
					}
				}, {
					key: "_toggleAllTreeItems",
					value: function _toggleAllTreeItems() {
						if (!this._optionalContentConfig) {
							return;
						}

						_get(_getPrototypeOf(PDFLayerViewer.prototype),
							"_toggleAllTreeItems", this).call(this);
					}
				}, {
					key: "render",
					value: function render(_ref4) {
						var optionalContentConfig = _ref4.optionalContentConfig,
							pdfDocument = _ref4.pdfDocument;

						if (this._optionalContentConfig) {
							this.reset();
						}

						this._optionalContentConfig = optionalContentConfig || null;
						this._pdfDocument = pdfDocument || null;
						var groups = optionalContentConfig === null ||
							optionalContentConfig === void 0 ? void 0 :
							optionalContentConfig.getOrder();

						if (!groups) {
							this._dispatchEvent(0);

							return;
						}

						var fragment = document.createDocumentFragment(),
							queue = [{
								parent: fragment,
								groups: groups
							}];
						var layersCount = 0,
							hasAnyNesting = false;

						while (queue.length > 0) {
							var levelData = queue.shift();

							var _iterator = _createForOfIteratorHelper(levelData
									.groups),
								_step;

							try {
								for (_iterator.s(); !(_step = _iterator.n())
									.done;) {
									var groupId = _step.value;
									var div = document.createElement("div");
									div.className = "treeItem";
									var element = document.createElement("a");
									div.appendChild(element);

									if (_typeof(groupId) === "object") {
										hasAnyNesting = true;

										this._addToggleButton(div, groupId);

										this._setNestedName(element, groupId);

										var itemsDiv = document.createElement(
										"div");
										itemsDiv.className = "treeItems";
										div.appendChild(itemsDiv);
										queue.push({
											parent: itemsDiv,
											groups: groupId.order
										});
									} else {
										var group = optionalContentConfig.getGroup(
											groupId);
										var input = document.createElement("input");

										this._bindLink(element, {
											groupId: groupId,
											input: input
										});

										input.type = "checkbox";
										input.id = groupId;
										input.checked = group.visible;
										var label = document.createElement("label");
										label.setAttribute("for", groupId);
										label.textContent = this
											._normalizeTextContent(group.name);
										element.appendChild(input);
										element.appendChild(label);
										layersCount++;
									}

									levelData.parent.appendChild(div);
								}
							} catch (err) {
								_iterator.e(err);
							} finally {
								_iterator.f();
							}
						}

						this._finishRendering(fragment, layersCount, hasAnyNesting);
					}
				}, {
					key: "_resetLayers",
					value: function() {
						var _resetLayers2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee2() {
								var optionalContentConfig;
								return _regenerator["default"].wrap(
									function _callee2$(_context2) {
										while (1) {
											switch (_context2.prev =
												_context2.next) {
												case 0:
													if (this
														._optionalContentConfig
														) {
														_context2.next =
															2;
														break;
													}

													return _context2
														.abrupt(
															"return");

												case 2:
													_context2.next = 4;
													return this
														._pdfDocument
														.getOptionalContentConfig();

												case 4:
													optionalContentConfig
														= _context2
														.sent;
													this.eventBus
														.dispatch(
															"optionalcontentconfig", {
																source: this,
																promise: Promise
																	.resolve(
																		optionalContentConfig
																		)
															});
													this.render({
														optionalContentConfig: optionalContentConfig,
														pdfDocument: this
															._pdfDocument
													});

												case 7:
												case "end":
													return _context2
														.stop();
											}
										}
									}, _callee2, this);
							}));

						function _resetLayers() {
							return _resetLayers2.apply(this, arguments);
						}

						return _resetLayers;
					}()
				}]);

				return PDFLayerViewer;
			}(_base_tree_viewer.BaseTreeViewer);

			exports.PDFLayerViewer = PDFLayerViewer;

			/***/
		}),
		/* 21 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFOutlineViewer = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _base_tree_viewer = __webpack_require__(14);

			var _pdfjsLib = __webpack_require__(7);

			var _ui_utils = __webpack_require__(5);

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

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

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

			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."
					);
			}

			function _iterableToArrayLimit(arr, i) {
				var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] ||
					arr["@@iterator"];
				if (_i == null) return;
				var _arr = [];
				var _n = true;
				var _d = false;
				var _s, _e;
				try {
					for (_i = _i.call(arr); !(_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;
			}

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

			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);
				}
			}

			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);
					});
				};
			}

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

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

			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."
					);
			}

			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);
			}

			function _iterableToArray(iter) {
				if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter[
					"@@iterator"] != null) return Array.from(iter);
			}

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

			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;
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			function _get() {
				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(arguments.length < 3 ? target : receiver);
						}
						return desc.value;
					};
				}
				return _get.apply(this, arguments);
			}

			function _superPropBase(object, property) {
				while (!Object.prototype.hasOwnProperty.call(object, property)) {
					object = _getPrototypeOf(object);
					if (object === null) break;
				}
				return object;
			}

			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
					}
				});
				Object.defineProperty(subClass, "prototype", {
					writable: false
				});
				if (superClass) _setPrototypeOf(subClass, superClass);
			}

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

			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);
				};
			}

			function _possibleConstructorReturn(self, call) {
				if (call && (_typeof(call) === "object" || typeof call === "function")) {
					return call;
				} else if (call !== void 0) {
					throw new TypeError("Derived constructors may only return object or undefined");
				}
				return _assertThisInitialized(self);
			}

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

			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;
				}
			}

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

			var PDFOutlineViewer = /*#__PURE__*/ function(_BaseTreeViewer) {
				_inherits(PDFOutlineViewer, _BaseTreeViewer);

				var _super = _createSuper(PDFOutlineViewer);

				function PDFOutlineViewer(options) {
					var _this;

					_classCallCheck(this, PDFOutlineViewer);

					_this = _super.call(this, options);
					_this.linkService = options.linkService;

					_this.eventBus._on("toggleoutlinetree", _this._toggleAllTreeItems.bind(
						_assertThisInitialized(_this)));

					_this.eventBus._on("currentoutlineitem", _this._currentOutlineItem.bind(
						_assertThisInitialized(_this)));

					_this.eventBus._on("pagechanging", function(evt) {
						_this._currentPageNumber = evt.pageNumber;
					});

					_this.eventBus._on("pagesloaded", function(evt) {
						_this._isPagesLoaded = !!evt.pagesCount;

						if (_this._currentOutlineItemCapability && !_this
							._currentOutlineItemCapability.settled) {
							_this._currentOutlineItemCapability.resolve(_this
								._isPagesLoaded);
						}
					});

					_this.eventBus._on("sidebarviewchanged", function(evt) {
						_this._sidebarView = evt.view;
					});

					return _this;
				}

				_createClass(PDFOutlineViewer, [{
					key: "reset",
					value: function reset() {
						_get(_getPrototypeOf(PDFOutlineViewer.prototype), "reset",
							this).call(this);

						this._outline = null;
						this._pageNumberToDestHashCapability = null;
						this._currentPageNumber = 1;
						this._isPagesLoaded = null;

						if (this._currentOutlineItemCapability && !this
							._currentOutlineItemCapability.settled) {
							this._currentOutlineItemCapability.resolve(false);
						}

						this._currentOutlineItemCapability = null;
					}
				}, {
					key: "_dispatchEvent",
					value: function _dispatchEvent(outlineCount) {
						var _this$_pdfDocument;

						this._currentOutlineItemCapability = (0, _pdfjsLib
							.createPromiseCapability)();

						if (outlineCount === 0 || (_this$_pdfDocument = this
								._pdfDocument) !== null && _this$_pdfDocument !==
							void 0 && _this$_pdfDocument.loadingParams
							.disableAutoFetch) {
							this._currentOutlineItemCapability.resolve(false);
						} else if (this._isPagesLoaded !== null) {
							this._currentOutlineItemCapability.resolve(this
								._isPagesLoaded);
						}

						this.eventBus.dispatch("outlineloaded", {
							source: this,
							outlineCount: outlineCount,
							currentOutlineItemPromise: this
								._currentOutlineItemCapability.promise
						});
					}
				}, {
					key: "_bindLink",
					value: function _bindLink(element, _ref) {
						var _this2 = this;

						var url = _ref.url,
							newWindow = _ref.newWindow,
							dest = _ref.dest;
						var linkService = this.linkService;

						if (url) {
							linkService.addLinkAttributes(element, url, newWindow);
							return;
						}

						element.href = linkService.getDestinationHash(dest);

						element.onclick = function(evt) {
							_this2._updateCurrentTreeItem(evt.target
							.parentNode);

							if (dest) {
								linkService.goToDestination(dest);
							}

							return false;
						};
					}
				}, {
					key: "_setStyles",
					value: function _setStyles(element, _ref2) {
						var bold = _ref2.bold,
							italic = _ref2.italic;

						if (bold) {
							element.style.fontWeight = "bold";
						}

						if (italic) {
							element.style.fontStyle = "italic";
						}
					}
				}, {
					key: "_addToggleButton",
					value: function _addToggleButton(div, _ref3) {
						var count = _ref3.count,
							items = _ref3.items;
						var hidden = false;

						if (count < 0) {
							var totalCount = items.length;

							if (totalCount > 0) {
								var queue = _toConsumableArray(items);

								while (queue.length > 0) {
									var _queue$shift = queue.shift(),
										nestedCount = _queue$shift.count,
										nestedItems = _queue$shift.items;

									if (nestedCount > 0 && nestedItems.length > 0) {
										totalCount += nestedItems.length;
										queue.push.apply(queue, _toConsumableArray(
											nestedItems));
									}
								}
							}

							if (Math.abs(count) === totalCount) {
								hidden = true;
							}
						}

						_get(_getPrototypeOf(PDFOutlineViewer.prototype),
							"_addToggleButton", this).call(this, div, hidden);
					}
				}, {
					key: "_toggleAllTreeItems",
					value: function _toggleAllTreeItems() {
						if (!this._outline) {
							return;
						}

						_get(_getPrototypeOf(PDFOutlineViewer.prototype),
							"_toggleAllTreeItems", this).call(this);
					}
				}, {
					key: "render",
					value: function render(_ref4) {
						var outline = _ref4.outline,
							pdfDocument = _ref4.pdfDocument;

						if (this._outline) {
							this.reset();
						}

						this._outline = outline || null;
						this._pdfDocument = pdfDocument || null;

						if (!outline) {
							this._dispatchEvent(0);

							return;
						}

						var fragment = document.createDocumentFragment();
						var queue = [{
							parent: fragment,
							items: outline
						}];
						var outlineCount = 0,
							hasAnyNesting = false;

						while (queue.length > 0) {
							var levelData = queue.shift();

							var _iterator = _createForOfIteratorHelper(levelData
									.items),
								_step;

							try {
								for (_iterator.s(); !(_step = _iterator.n())
									.done;) {
									var item = _step.value;
									var div = document.createElement("div");
									div.className = "treeItem";
									var element = document.createElement("a");

									this._bindLink(element, item);

									this._setStyles(element, item);

									element.textContent = this
										._normalizeTextContent(item.title);
									div.appendChild(element);

									if (item.items.length > 0) {
										hasAnyNesting = true;

										this._addToggleButton(div, item);

										var itemsDiv = document.createElement(
										"div");
										itemsDiv.className = "treeItems";
										div.appendChild(itemsDiv);
										queue.push({
											parent: itemsDiv,
											items: item.items
										});
									}

									levelData.parent.appendChild(div);
									outlineCount++;
								}
							} catch (err) {
								_iterator.e(err);
							} finally {
								_iterator.f();
							}
						}

						this._finishRendering(fragment, outlineCount,
						hasAnyNesting);
					}
				}, {
					key: "_currentOutlineItem",
					value: function() {
						var _currentOutlineItem2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee() {
								var pageNumberToDestHash, i, destHash,
									linkElement;
								return _regenerator["default"].wrap(
									function _callee$(_context) {
										while (1) {
											switch (_context.prev =
												_context.next) {
												case 0:
													if (this
														._isPagesLoaded
														) {
														_context.next =
															2;
														break;
													}

													throw new Error(
														"_currentOutlineItem: All pages have not been loaded."
														);

												case 2:
													if (!(!this
															._outline ||
															!this
															._pdfDocument
															)) {
														_context.next =
															4;
														break;
													}

													return _context
														.abrupt(
															"return");

												case 4:
													_context.next = 6;
													return this
														._getPageNumberToDestHash(
															this
															._pdfDocument
															);

												case 6:
													pageNumberToDestHash
														= _context.sent;

													if (
														pageNumberToDestHash) {
														_context.next =
															9;
														break;
													}

													return _context
														.abrupt(
															"return");

												case 9:
													this._updateCurrentTreeItem(
														null);

													if (!(this
															._sidebarView !==
															_ui_utils
															.SidebarView
															.OUTLINE)) {
														_context.next =
															12;
														break;
													}

													return _context
														.abrupt(
															"return");

												case 12:
													i = this
														._currentPageNumber;

												case 13:
													if (!(i > 0)) {
														_context.next =
															25;
														break;
													}

													destHash =
														pageNumberToDestHash
														.get(i);

													if (destHash) {
														_context.next =
															17;
														break;
													}

													return _context
														.abrupt(
															"continue",
															22);

												case 17:
													linkElement = this
														.container
														.querySelector(
															"a[href=\""
															.concat(
																destHash,
																"\"]"));

													if (linkElement) {
														_context.next =
															20;
														break;
													}

													return _context
														.abrupt(
															"continue",
															22);

												case 20:
													this._scrollToCurrentTreeItem(
														linkElement
														.parentNode);

													return _context
														.abrupt("break",
															25);

												case 22:
													i--;
													_context.next = 13;
													break;

												case 25:
												case "end":
													return _context
														.stop();
											}
										}
									}, _callee, this);
							}));

						function _currentOutlineItem() {
							return _currentOutlineItem2.apply(this, arguments);
						}

						return _currentOutlineItem;
					}()
				}, {
					key: "_getPageNumberToDestHash",
					value: function() {
						var _getPageNumberToDestHash2 =
						_asyncToGenerator( /*#__PURE__*/ _regenerator["default"]
							.mark(function _callee2(pdfDocument) {
								var pageNumberToDestHash, pageNumberNesting,
									queue, levelData, currentNesting,
									_iterator2, _step2, _step2$value, dest,
									items, explicitDest, pageNumber,
									_explicitDest, _explicitDest2, destRef,
									destHash;

								return _regenerator["default"].wrap(
									function _callee2$(_context2) {
										while (1) {
											switch (_context2.prev =
												_context2.next) {
												case 0:
													if (!this
														._pageNumberToDestHashCapability
														) {
														_context2.next =
															2;
														break;
													}

													return _context2
														.abrupt(
															"return",
															this
															._pageNumberToDestHashCapability
															.promise);

												case 2:
													this._pageNumberToDestHashCapability =
														(0, _pdfjsLib
															.createPromiseCapability
															)();
													pageNumberToDestHash
														= new Map(),
														pageNumberNesting =
														new Map();
													queue = [{
														nesting: 0,
														items: this
															._outline
													}];

												case 5:
													if (!(queue.length >
															0)) {
														_context2.next =
															56;
														break;
													}

													levelData = queue
														.shift(),
														currentNesting =
														levelData
														.nesting;
													_iterator2 =
														_createForOfIteratorHelper(
															levelData
															.items);
													_context2.prev = 8;

													_iterator2.s();

												case 10:
													if ((_step2 =
															_iterator2
															.n())
														.done) {
														_context2.next =
															46;
														break;
													}

													_step2$value =
														_step2.value,
														dest =
														_step2$value
														.dest, items =
														_step2$value
														.items;
													explicitDest =
														void 0,
														pageNumber =
														void 0;

													if (!(typeof dest ===
															"string")) {
														_context2.next =
															21;
														break;
													}

													_context2.next = 16;
													return pdfDocument
														.getDestination(
															dest);

												case 16:
													explicitDest =
														_context2.sent;

													if (!(pdfDocument !==
															this
															._pdfDocument
															)) {
														_context2.next =
															19;
														break;
													}

													return _context2
														.abrupt(
															"return",
															null);

												case 19:
													_context2.next = 22;
													break;

												case 21:
													explicitDest = dest;

												case 22:
													if (!Array.isArray(
															explicitDest
															)) {
														_context2.next =
															43;
														break;
													}

													_explicitDest =
														explicitDest,
														_explicitDest2 =
														_slicedToArray(
															_explicitDest,
															1),
														destRef =
														_explicitDest2[
															0];

													if (!(_typeof(
																destRef
																) ===
															"object" &&
															destRef !==
															null)) {
														_context2.next =
															41;
														break;
													}

													pageNumber = this
														.linkService
														._cachedPageNumber(
															destRef);

													if (pageNumber) {
														_context2.next =
															39;
														break;
													}

													_context2.prev = 27;
													_context2.next = 30;
													return pdfDocument
														.getPageIndex(
															destRef);

												case 30:
													_context2.t0 =
														_context2.sent;
													pageNumber =
														_context2.t0 +
														1;

													if (!(pdfDocument !==
															this
															._pdfDocument
															)) {
														_context2.next =
															34;
														break;
													}

													return _context2
														.abrupt(
															"return",
															null);

												case 34:
													this.linkService
														.cachePageRef(
															pageNumber,
															destRef);
													_context2.next = 39;
													break;

												case 37:
													_context2.prev = 37;
													_context2.t1 =
														_context2[
															"catch"](
														27);

												case 39:
													_context2.next = 42;
													break;

												case 41:
													if (Number
														.isInteger(
															destRef)) {
														pageNumber =
															destRef + 1;
													}

													case 42:
														if (Number
															.isInteger(
																pageNumber
																) && (!
																pageNumberToDestHash
																.has(
																	pageNumber
																	) ||
																currentNesting >
																pageNumberNesting
																.get(
																	pageNumber
																	))
															) {
															destHash =
																this
																.linkService
																.getDestinationHash(
																	dest
																	);
															pageNumberToDestHash
																.set(
																	pageNumber,
																	destHash
																	);
															pageNumberNesting
																.set(
																	pageNumber,
																	currentNesting
																	);
														}

														case 43:
															if (items
																.length >
																0) {
																queue
																	.push({
																		nesting: currentNesting +
																			1,
																		items: items
																	});
															}

															case 44:
																_context2
																	.next =
																	10;
																break;

															case 46:
																_context2
																	.next =
																	51;
																break;

															case 48:
																_context2
																	.prev =
																	48;
																_context2
																	.t2 =
																	_context2[
																		"catch"
																		]
																	(8);

																_iterator2
																	.e(_context2
																		.t2
																		);

															case 51:
																_context2
																	.prev =
																	51;

																_iterator2
																	.f();

																return _context2
																	.finish(
																		51
																		);

															case 54:
																_context2
																	.next =
																	5;
																break;

															case 56:
																this._pageNumberToDestHashCapability
																	.resolve(
																		pageNumberToDestHash
																		.size >
																		0 ?
																		pageNumberToDestHash :
																		null
																		);

																return _context2
																	.abrupt(
																		"return",
																		this
																		._pageNumberToDestHashCapability
																		.promise
																		);

															case 58:
															case "end":
																return _context2
																	.stop();
											}
										}
									}, _callee2, this, [
										[8, 48, 51, 54],
										[27, 37]
									]);
							}));

						function _getPageNumberToDestHash(_x) {
							return _getPageNumberToDestHash2.apply(this, arguments);
						}

						return _getPageNumberToDestHash;
					}()
				}]);

				return PDFOutlineViewer;
			}(_base_tree_viewer.BaseTreeViewer);

			exports.PDFOutlineViewer = PDFOutlineViewer;

			/***/
		}),
		/* 22 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFPresentationMode = void 0;

			var _ui_utils = __webpack_require__(5);

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			function _classPrivateMethodInitSpec(obj, privateSet) {
				_checkPrivateRedeclaration(obj, privateSet);
				privateSet.add(obj);
			}

			function _checkPrivateRedeclaration(obj, privateCollection) {
				if (privateCollection.has(obj)) {
					throw new TypeError(
						"Cannot initialize the same private elements twice on an object");
				}
			}

			function _classPrivateMethodGet(receiver, privateSet, fn) {
				if (!privateSet.has(receiver)) {
					throw new TypeError("attempted to get private field on non-instance");
				}
				return fn;
			}

			var DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS = 1500;
			var DELAY_BEFORE_HIDING_CONTROLS = 3000;
			var ACTIVE_SELECTOR = "pdfPresentationMode";
			var CONTROLS_SELECTOR = "pdfPresentationModeControls";
			var MOUSE_SCROLL_COOLDOWN_TIME = 50;
			var PAGE_SWITCH_THRESHOLD = 0.1;
			var SWIPE_MIN_DISTANCE_THRESHOLD = 50;
			var SWIPE_ANGLE_THRESHOLD = Math.PI / 6;

			var _mouseWheel = /*#__PURE__*/ new WeakSet();

			var _notifyStateChange = /*#__PURE__*/ new WeakSet();

			var _setSwitchInProgress = /*#__PURE__*/ new WeakSet();

			var _resetSwitchInProgress = /*#__PURE__*/ new WeakSet();

			var _enter = /*#__PURE__*/ new WeakSet();

			var _exit = /*#__PURE__*/ new WeakSet();

			var _mouseDown = /*#__PURE__*/ new WeakSet();

			var _contextMenu = /*#__PURE__*/ new WeakSet();

			var _showControls = /*#__PURE__*/ new WeakSet();

			var _hideControls = /*#__PURE__*/ new WeakSet();

			var _resetMouseScrollState = /*#__PURE__*/ new WeakSet();

			var _touchSwipe = /*#__PURE__*/ new WeakSet();

			var _addWindowListeners = /*#__PURE__*/ new WeakSet();

			var _removeWindowListeners = /*#__PURE__*/ new WeakSet();

			var _fullscreenChange = /*#__PURE__*/ new WeakSet();

			var _addFullscreenChangeListeners = /*#__PURE__*/ new WeakSet();

			var _removeFullscreenChangeListeners = /*#__PURE__*/ new WeakSet();

			var PDFPresentationMode = /*#__PURE__*/ function() {
				function PDFPresentationMode(_ref) {
					var container = _ref.container,
						pdfViewer = _ref.pdfViewer,
						eventBus = _ref.eventBus;

					_classCallCheck(this, PDFPresentationMode);

					_classPrivateMethodInitSpec(this, _removeFullscreenChangeListeners);

					_classPrivateMethodInitSpec(this, _addFullscreenChangeListeners);

					_classPrivateMethodInitSpec(this, _fullscreenChange);

					_classPrivateMethodInitSpec(this, _removeWindowListeners);

					_classPrivateMethodInitSpec(this, _addWindowListeners);

					_classPrivateMethodInitSpec(this, _touchSwipe);

					_classPrivateMethodInitSpec(this, _resetMouseScrollState);

					_classPrivateMethodInitSpec(this, _hideControls);

					_classPrivateMethodInitSpec(this, _showControls);

					_classPrivateMethodInitSpec(this, _contextMenu);

					_classPrivateMethodInitSpec(this, _mouseDown);

					_classPrivateMethodInitSpec(this, _exit);

					_classPrivateMethodInitSpec(this, _enter);

					_classPrivateMethodInitSpec(this, _resetSwitchInProgress);

					_classPrivateMethodInitSpec(this, _setSwitchInProgress);

					_classPrivateMethodInitSpec(this, _notifyStateChange);

					_classPrivateMethodInitSpec(this, _mouseWheel);

					this.container = container;
					this.pdfViewer = pdfViewer;
					this.eventBus = eventBus;
					this.active = false;
					this.args = null;
					this.contextMenuOpen = false;
					this.mouseScrollTimeStamp = 0;
					this.mouseScrollDelta = 0;
					this.touchSwipeState = null;
				}

				_createClass(PDFPresentationMode, [{
					key: "request",
					value: function request() {
						if (this.switchInProgress || this.active || !this.pdfViewer
							.pagesCount || !this.container.requestFullscreen) {
							return false;
						}

						_classPrivateMethodGet(this, _addFullscreenChangeListeners,
							_addFullscreenChangeListeners2).call(this);

						_classPrivateMethodGet(this, _setSwitchInProgress,
							_setSwitchInProgress2).call(this);

						_classPrivateMethodGet(this, _notifyStateChange,
							_notifyStateChange2).call(this);

						this.container.requestFullscreen();
						this.args = {
							pageNumber: this.pdfViewer.currentPageNumber,
							scaleValue: this.pdfViewer.currentScaleValue,
							scrollMode: this.pdfViewer.scrollMode,
							spreadMode: this.pdfViewer.spreadMode
						};
						return true;
					}
				}]);

				return PDFPresentationMode;
			}();

			exports.PDFPresentationMode = PDFPresentationMode;

			function _mouseWheel2(evt) {
				if (!this.active) {
					return;
				}

				evt.preventDefault();
				var delta = (0, _ui_utils.normalizeWheelEventDelta)(evt);
				var currentTime = Date.now();
				var storedTime = this.mouseScrollTimeStamp;

				if (currentTime > storedTime && currentTime - storedTime < MOUSE_SCROLL_COOLDOWN_TIME) {
					return;
				}

				if (this.mouseScrollDelta > 0 && delta < 0 || this.mouseScrollDelta < 0 && delta > 0) {
					_classPrivateMethodGet(this, _resetMouseScrollState, _resetMouseScrollState2).call(
						this);
				}

				this.mouseScrollDelta += delta;

				if (Math.abs(this.mouseScrollDelta) >= PAGE_SWITCH_THRESHOLD) {
					var totalDelta = this.mouseScrollDelta;

					_classPrivateMethodGet(this, _resetMouseScrollState, _resetMouseScrollState2).call(
						this);

					var success = totalDelta > 0 ? this.pdfViewer.previousPage() : this.pdfViewer
						.nextPage();

					if (success) {
						this.mouseScrollTimeStamp = currentTime;
					}
				}
			}

			function _notifyStateChange2() {
				var state = _ui_utils.PresentationModeState.NORMAL;

				if (this.switchInProgress) {
					state = _ui_utils.PresentationModeState.CHANGING;
				} else if (this.active) {
					state = _ui_utils.PresentationModeState.FULLSCREEN;
				}

				this.eventBus.dispatch("presentationmodechanged", {
					source: this,
					state: state
				});
			}

			function _setSwitchInProgress2() {
				var _this = this;

				if (this.switchInProgress) {
					clearTimeout(this.switchInProgress);
				}

				this.switchInProgress = setTimeout(function() {
					_classPrivateMethodGet(_this, _removeFullscreenChangeListeners,
						_removeFullscreenChangeListeners2).call(_this);

					delete _this.switchInProgress;

					_classPrivateMethodGet(_this, _notifyStateChange, _notifyStateChange2).call(
						_this);
				}, DELAY_BEFORE_RESETTING_SWITCH_IN_PROGRESS);
			}

			function _resetSwitchInProgress2() {
				if (this.switchInProgress) {
					clearTimeout(this.switchInProgress);
					delete this.switchInProgress;
				}
			}

			function _enter2() {
				var _this2 = this;

				this.active = true;

				_classPrivateMethodGet(this, _resetSwitchInProgress, _resetSwitchInProgress2).call(
				this);

				_classPrivateMethodGet(this, _notifyStateChange, _notifyStateChange2).call(this);

				this.container.classList.add(ACTIVE_SELECTOR);
				setTimeout(function() {
					_this2.pdfViewer.scrollMode = _ui_utils.ScrollMode.PAGE;
					_this2.pdfViewer.spreadMode = _ui_utils.SpreadMode.NONE;
					_this2.pdfViewer.currentPageNumber = _this2.args.pageNumber;
					_this2.pdfViewer.currentScaleValue = "page-fit";
				}, 0);

				_classPrivateMethodGet(this, _addWindowListeners, _addWindowListeners2).call(this);

				_classPrivateMethodGet(this, _showControls, _showControls2).call(this);

				this.contextMenuOpen = false;
				window.getSelection().removeAllRanges();
			}

			function _exit2() {
				var _this3 = this;

				var pageNumber = this.pdfViewer.currentPageNumber;
				this.container.classList.remove(ACTIVE_SELECTOR);
				setTimeout(function() {
					_this3.active = false;

					_classPrivateMethodGet(_this3, _removeFullscreenChangeListeners,
						_removeFullscreenChangeListeners2).call(_this3);

					_classPrivateMethodGet(_this3, _notifyStateChange, _notifyStateChange2)
						.call(_this3);

					_this3.pdfViewer.scrollMode = _this3.args.scrollMode;
					_this3.pdfViewer.spreadMode = _this3.args.spreadMode;
					_this3.pdfViewer.currentScaleValue = _this3.args.scaleValue;
					_this3.pdfViewer.currentPageNumber = pageNumber;
					_this3.args = null;
				}, 0);

				_classPrivateMethodGet(this, _removeWindowListeners, _removeWindowListeners2).call(
				this);

				_classPrivateMethodGet(this, _hideControls, _hideControls2).call(this);

				_classPrivateMethodGet(this, _resetMouseScrollState, _resetMouseScrollState2).call(
				this);

				this.contextMenuOpen = false;
			}

			function _mouseDown2(evt) {
				if (this.contextMenuOpen) {
					this.contextMenuOpen = false;
					evt.preventDefault();
					return;
				}

				if (evt.button === 0) {
					var isInternalLink = evt.target.href && evt.target.classList.contains(
						"internalLink");

					if (!isInternalLink) {
						evt.preventDefault();

						if (evt.shiftKey) {
							this.pdfViewer.previousPage();
						} else {
							this.pdfViewer.nextPage();
						}
					}
				}
			}

			function _contextMenu2() {
				this.contextMenuOpen = true;
			}

			function _showControls2() {
				var _this4 = this;

				if (this.controlsTimeout) {
					clearTimeout(this.controlsTimeout);
				} else {
					this.container.classList.add(CONTROLS_SELECTOR);
				}

				this.controlsTimeout = setTimeout(function() {
					_this4.container.classList.remove(CONTROLS_SELECTOR);

					delete _this4.controlsTimeout;
				}, DELAY_BEFORE_HIDING_CONTROLS);
			}

			function _hideControls2() {
				if (!this.controlsTimeout) {
					return;
				}

				clearTimeout(this.controlsTimeout);
				this.container.classList.remove(CONTROLS_SELECTOR);
				delete this.controlsTimeout;
			}

			function _resetMouseScrollState2() {
				this.mouseScrollTimeStamp = 0;
				this.mouseScrollDelta = 0;
			}

			function _touchSwipe2(evt) {
				if (!this.active) {
					return;
				}

				if (evt.touches.length > 1) {
					this.touchSwipeState = null;
					return;
				}

				switch (evt.type) {
					case "touchstart":
						this.touchSwipeState = {
							startX: evt.touches[0].pageX,
							startY: evt.touches[0].pageY,
							endX: evt.touches[0].pageX,
							endY: evt.touches[0].pageY
						};
						break;

					case "touchmove":
						if (this.touchSwipeState === null) {
							return;
						}

						this.touchSwipeState.endX = evt.touches[0].pageX;
						this.touchSwipeState.endY = evt.touches[0].pageY;
						evt.preventDefault();
						break;

					case "touchend":
						if (this.touchSwipeState === null) {
							return;
						}

						var delta = 0;
						var dx = this.touchSwipeState.endX - this.touchSwipeState.startX;
						var dy = this.touchSwipeState.endY - this.touchSwipeState.startY;
						var absAngle = Math.abs(Math.atan2(dy, dx));

						if (Math.abs(dx) > SWIPE_MIN_DISTANCE_THRESHOLD && (absAngle <=
								SWIPE_ANGLE_THRESHOLD || absAngle >= Math.PI - SWIPE_ANGLE_THRESHOLD)) {
							delta = dx;
						} else if (Math.abs(dy) > SWIPE_MIN_DISTANCE_THRESHOLD && Math.abs(absAngle -
								Math.PI / 2) <= SWIPE_ANGLE_THRESHOLD) {
							delta = dy;
						}

						if (delta > 0) {
							this.pdfViewer.previousPage();
						} else if (delta < 0) {
							this.pdfViewer.nextPage();
						}

						break;
				}
			}

			function _addWindowListeners2() {
				this.showControlsBind = _classPrivateMethodGet(this, _showControls, _showControls2)
					.bind(this);
				this.mouseDownBind = _classPrivateMethodGet(this, _mouseDown, _mouseDown2).bind(this);
				this.mouseWheelBind = _classPrivateMethodGet(this, _mouseWheel, _mouseWheel2).bind(
				this);
				this.resetMouseScrollStateBind = _classPrivateMethodGet(this, _resetMouseScrollState,
					_resetMouseScrollState2).bind(this);
				this.contextMenuBind = _classPrivateMethodGet(this, _contextMenu, _contextMenu2).bind(
					this);
				this.touchSwipeBind = _classPrivateMethodGet(this, _touchSwipe, _touchSwipe2).bind(
				this);
				window.addEventListener("mousemove", this.showControlsBind);
				window.addEventListener("mousedown", this.mouseDownBind);
				window.addEventListener("wheel", this.mouseWheelBind, {
					passive: false
				});
				window.addEventListener("keydown", this.resetMouseScrollStateBind);
				window.addEventListener("contextmenu", this.contextMenuBind);
				window.addEventListener("touchstart", this.touchSwipeBind);
				window.addEventListener("touchmove", this.touchSwipeBind);
				window.addEventListener("touchend", this.touchSwipeBind);
			}

			function _removeWindowListeners2() {
				window.removeEventListener("mousemove", this.showControlsBind);
				window.removeEventListener("mousedown", this.mouseDownBind);
				window.removeEventListener("wheel", this.mouseWheelBind, {
					passive: false
				});
				window.removeEventListener("keydown", this.resetMouseScrollStateBind);
				window.removeEventListener("contextmenu", this.contextMenuBind);
				window.removeEventListener("touchstart", this.touchSwipeBind);
				window.removeEventListener("touchmove", this.touchSwipeBind);
				window.removeEventListener("touchend", this.touchSwipeBind);
				delete this.showControlsBind;
				delete this.mouseDownBind;
				delete this.mouseWheelBind;
				delete this.resetMouseScrollStateBind;
				delete this.contextMenuBind;
				delete this.touchSwipeBind;
			}

			function _fullscreenChange2() {
				if (document.fullscreenElement) {
					_classPrivateMethodGet(this, _enter, _enter2).call(this);
				} else {
					_classPrivateMethodGet(this, _exit, _exit2).call(this);
				}
			}

			function _addFullscreenChangeListeners2() {
				this.fullscreenChangeBind = _classPrivateMethodGet(this, _fullscreenChange,
					_fullscreenChange2).bind(this);
				window.addEventListener("fullscreenchange", this.fullscreenChangeBind);
			}

			function _removeFullscreenChangeListeners2() {
				window.removeEventListener("fullscreenchange", this.fullscreenChangeBind);
				delete this.fullscreenChangeBind;
			}

			/***/
		}),
		/* 23 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFRenderingQueue = void 0;

			var _pdfjsLib = __webpack_require__(7);

			var _ui_utils = __webpack_require__(5);

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var CLEANUP_TIMEOUT = 30000;

			var PDFRenderingQueue = /*#__PURE__*/ function() {
				function PDFRenderingQueue() {
					_classCallCheck(this, PDFRenderingQueue);

					this.pdfViewer = null;
					this.pdfThumbnailViewer = null;
					this.onIdle = null;
					this.highestPriorityPage = null;
					this.idleTimeout = null;
					this.printing = false;
					this.isThumbnailViewEnabled = false;
				}

				_createClass(PDFRenderingQueue, [{
					key: "setViewer",
					value: function setViewer(pdfViewer) {
						this.pdfViewer = pdfViewer;
					}
				}, {
					key: "setThumbnailViewer",
					value: function setThumbnailViewer(pdfThumbnailViewer) {
						this.pdfThumbnailViewer = pdfThumbnailViewer;
					}
				}, {
					key: "isHighestPriority",
					value: function isHighestPriority(view) {
						return this.highestPriorityPage === view.renderingId;
					}
				}, {
					key: "hasViewer",
					value: function hasViewer() {
						return !!this.pdfViewer;
					}
				}, {
					key: "renderHighestPriority",
					value: function renderHighestPriority(currentlyVisiblePages) {
						var _this$pdfThumbnailVie;

						if (this.idleTimeout) {
							clearTimeout(this.idleTimeout);
							this.idleTimeout = null;
						}

						if (this.pdfViewer.forceRendering(currentlyVisiblePages)) {
							return;
						}

						if (this.isThumbnailViewEnabled && (_this$pdfThumbnailVie =
								this.pdfThumbnailViewer) !== null &&
							_this$pdfThumbnailVie !== void 0 &&
							_this$pdfThumbnailVie.forceRendering()) {
							return;
						}

						if (this.printing) {
							return;
						}

						if (this.onIdle) {
							this.idleTimeout = setTimeout(this.onIdle.bind(this),
								CLEANUP_TIMEOUT);
						}
					}
				}, {
					key: "getHighestPriority",
					value: function getHighestPriority(visible, views, scrolledDown) {
						var preRenderExtra = arguments.length > 3 && arguments[
							3] !== undefined ? arguments[3] : false;
						var visibleViews = visible.views,
							numVisible = visibleViews.length;

						if (numVisible === 0) {
							return null;
						}

						for (var i = 0; i < numVisible; i++) {
							var view = visibleViews[i].view;

							if (!this.isViewFinished(view)) {
								return view;
							}
						}

						var firstId = visible.first.id,
							lastId = visible.last.id;

						if (lastId - firstId + 1 > numVisible) {
							var visibleIds = visible.ids;

							for (var _i = 1, ii = lastId - firstId; _i < ii; _i++) {
								var holeId = scrolledDown ? firstId + _i : lastId -
									_i;

								if (visibleIds.has(holeId)) {
									continue;
								}

								var holeView = views[holeId - 1];

								if (!this.isViewFinished(holeView)) {
									return holeView;
								}
							}
						}

						var preRenderIndex = scrolledDown ? lastId : firstId - 2;
						var preRenderView = views[preRenderIndex];

						if (preRenderView && !this.isViewFinished(preRenderView)) {
							return preRenderView;
						}

						if (preRenderExtra) {
							preRenderIndex += scrolledDown ? 1 : -1;
							preRenderView = views[preRenderIndex];

							if (preRenderView && !this.isViewFinished(
								preRenderView)) {
								return preRenderView;
							}
						}

						return null;
					}
				}, {
					key: "isViewFinished",
					value: function isViewFinished(view) {
						return view.renderingState === _ui_utils.RenderingStates
							.FINISHED;
					}
				}, {
					key: "renderView",
					value: function renderView(view) {
						var _this = this;

						switch (view.renderingState) {
							case _ui_utils.RenderingStates.FINISHED:
								return false;

							case _ui_utils.RenderingStates.PAUSED:
								this.highestPriorityPage = view.renderingId;
								view.resume();
								break;

							case _ui_utils.RenderingStates.RUNNING:
								this.highestPriorityPage = view.renderingId;
								break;

							case _ui_utils.RenderingStates.INITIAL:
								this.highestPriorityPage = view.renderingId;
								view.draw()["finally"](function() {
									_this.renderHighestPriority();
								})["catch"](function(reason) {
									if (reason instanceof _pdfjsLib
										.RenderingCancelledException) {
										return;
									}

									console.error("renderView: \"".concat(
										reason, "\""));
								});
								break;
						}

						return true;
					}
				}]);

				return PDFRenderingQueue;
			}();

			exports.PDFRenderingQueue = PDFRenderingQueue;

			/***/
		}),
		/* 24 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFScriptingManager = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _ui_utils = __webpack_require__(5);

			var _pdfjsLib = __webpack_require__(7);

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

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

			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."
					);
			}

			function _iterableToArray(iter) {
				if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter[
					"@@iterator"] != null) return Array.from(iter);
			}

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

			function ownKeys(object, enumerableOnly) {
				var keys = Object.keys(object);
				if (Object.getOwnPropertySymbols) {
					var symbols = Object.getOwnPropertySymbols(object);
					enumerableOnly && (symbols = symbols.filter(function(sym) {
						return Object.getOwnPropertyDescriptor(object, sym).enumerable;
					})), keys.push.apply(keys, symbols);
				}
				return keys;
			}

			function _objectSpread(target) {
				for (var i = 1; i < arguments.length; i++) {
					var source = null != arguments[i] ? arguments[i] : {};
					i % 2 ? ownKeys(Object(source), !0).forEach(function(key) {
						_defineProperty(target, key, source[key]);
					}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object
						.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(
						function(key) {
							Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(
								source, key));
						});
				}
				return target;
			}

			function _defineProperty(obj, key, value) {
				if (key in obj) {
					Object.defineProperty(obj, key, {
						value: value,
						enumerable: true,
						configurable: true,
						writable: true
					});
				} else {
					obj[key] = value;
				}
				return obj;
			}

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

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

			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."
					);
			}

			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);
			}

			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;
			}

			function _iterableToArrayLimit(arr, i) {
				var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] ||
					arr["@@iterator"];
				if (_i == null) return;
				var _arr = [];
				var _n = true;
				var _d = false;
				var _s, _e;
				try {
					for (_i = _i.call(arr); !(_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;
			}

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

			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);
				}
			}

			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);
					});
				};
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var PDFScriptingManager = /*#__PURE__*/ function() {
				function PDFScriptingManager(_ref) {
					var eventBus = _ref.eventBus,
						_ref$sandboxBundleSrc = _ref.sandboxBundleSrc,
						sandboxBundleSrc = _ref$sandboxBundleSrc === void 0 ? null :
						_ref$sandboxBundleSrc,
						_ref$scriptingFactory = _ref.scriptingFactory,
						scriptingFactory = _ref$scriptingFactory === void 0 ? null :
						_ref$scriptingFactory,
						_ref$docPropertiesLoo = _ref.docPropertiesLookup,
						docPropertiesLookup = _ref$docPropertiesLoo === void 0 ? null :
						_ref$docPropertiesLoo;

					_classCallCheck(this, PDFScriptingManager);

					this._pdfDocument = null;
					this._pdfViewer = null;
					this._closeCapability = null;
					this._destroyCapability = null;
					this._scripting = null;
					this._mouseState = Object.create(null);
					this._ready = false;
					this._eventBus = eventBus;
					this._sandboxBundleSrc = sandboxBundleSrc;
					this._scriptingFactory = scriptingFactory;
					this._docPropertiesLookup = docPropertiesLookup;
				}

				_createClass(PDFScriptingManager, [{
					key: "setViewer",
					value: function setViewer(pdfViewer) {
						this._pdfViewer = pdfViewer;
					}
				}, {
					key: "setDocument",
					value: function() {
						var _setDocument = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee2(
								pdfDocument) {
								var _this = this,
									_this$_scripting3;

								var _yield$Promise$all, _yield$Promise$all2,
									objects, calculationOrder, docActions,
									_iterator, _step, _step$value, name,
									listener, _iterator2, _step2,
									_step2$value, _name, _listener,
									docProperties;

								return _regenerator["default"].wrap(
									function _callee2$(_context2) {
										while (1) {
											switch (_context2.prev =
												_context2.next) {
												case 0:
													if (!this
														._pdfDocument) {
														_context2.next =
															3;
														break;
													}

													_context2.next = 3;
													return this
														._destroyScripting();

												case 3:
													this._pdfDocument =
														pdfDocument;

													if (pdfDocument) {
														_context2.next =
															6;
														break;
													}

													return _context2
														.abrupt(
															"return");

												case 6:
													_context2.next = 8;
													return Promise.all([
														pdfDocument
														.getFieldObjects(),
														pdfDocument
														.getCalculationOrderIds(),
														pdfDocument
														.getJSActions()
													]);

												case 8:
													_yield$Promise$all =
														_context2.sent;
													_yield$Promise$all2
														=
														_slicedToArray(
															_yield$Promise$all,
															3);
													objects =
														_yield$Promise$all2[
															0];
													calculationOrder =
														_yield$Promise$all2[
															1];
													docActions =
														_yield$Promise$all2[
															2];

													if (!(!objects && !
															docActions
															)) {
														_context2.next =
															17;
														break;
													}

													_context2.next = 16;
													return this
														._destroyScripting();

												case 16:
													return _context2
														.abrupt(
															"return");

												case 17:
													if (!(pdfDocument !==
															this
															._pdfDocument
															)) {
														_context2.next =
															19;
														break;
													}

													return _context2
														.abrupt(
															"return");

												case 19:
													_context2.prev = 19;
													this._scripting =
														this
														._createScripting();
													_context2.next = 29;
													break;

												case 23:
													_context2.prev = 23;
													_context2.t0 =
														_context2[
															"catch"](
														19);
													console.error(
														"PDFScriptingManager.setDocument: \""
														.concat(
															_context2
															.t0 ===
															null ||
															_context2
															.t0 ===
															void 0 ?
															void 0 :
															_context2
															.t0
															.message,
															"\"."));
													_context2.next = 28;
													return this
														._destroyScripting();

												case 28:
													return _context2
														.abrupt(
															"return");

												case 29:
													this._internalEvents
														.set(
															"updatefromsandbox",
															function(
																event) {
																if ((event ===
																		null ||
																		event ===
																		void 0 ?
																		void 0 :
																		event
																		.source
																		) !==
																	window
																	) {
																	return;
																}

																_this
																	._updateFromSandbox(
																		event
																		.detail
																		);
															});

													this._internalEvents
														.set(
															"dispatcheventinsandbox",
															function(
																event) {
																var
																_this$_scripting;

																(_this$_scripting =
																	_this
																	._scripting
																	) ===
																null ||
																	_this$_scripting ===
																	void 0 ?
																	void 0 :
																	_this$_scripting
																	.dispatchEventInSandbox(
																		event
																		.detail
																		);
															});

													this._internalEvents
														.set(
															"pagechanging",
															function(
																_ref2) {
																var pageNumber =
																	_ref2
																	.pageNumber,
																	previous =
																	_ref2
																	.previous;

																if (pageNumber ===
																	previous
																	) {
																	return;
																}

																_this
																	._dispatchPageClose(
																		previous
																		);

																_this
																	._dispatchPageOpen(
																		pageNumber
																		);
															});

													this._internalEvents
														.set(
															"pagerendered",
															function(
																_ref3) {
																var pageNumber =
																	_ref3
																	.pageNumber;

																if (!
																	_this
																	._pageOpenPending
																	.has(
																		pageNumber
																		)
																	) {
																	return;
																}

																if (pageNumber !==
																	_this
																	._pdfViewer
																	.currentPageNumber
																	) {
																	return;
																}

																_this
																	._dispatchPageOpen(
																		pageNumber
																		);
															});

													this._internalEvents
														.set(
															"pagesdestroy", /*#__PURE__*/
															function() {
																var _ref4 =
																	_asyncToGenerator( /*#__PURE__*/
																		_regenerator[
																			"default"
																			]
																		.mark(
																			function _callee(
																				event
																				) {
																				var _this$_scripting2,
																					_this$_closeCapabilit;

																				return _regenerator[
																						"default"
																						]
																					.wrap(
																						function _callee$(
																							_context
																							) {
																							while (
																								1
																								) {
																								switch (
																									_context
																									.prev =
																									_context
																									.next
																									) {
																									case 0:
																										_context
																											.next =
																											2;
																										return _this
																											._dispatchPageClose(
																												_this
																												._pdfViewer
																												.currentPageNumber
																												);

																									case 2:
																										_context
																											.next =
																											4;
																										return (_this$_scripting2 =
																												_this
																												._scripting
																												) ===
																											null ||
																											_this$_scripting2 ===
																											void 0 ?
																											void 0 :
																											_this$_scripting2
																											.dispatchEventInSandbox({
																												id: "doc",
																												name: "WillClose"
																											});

																									case 4:
																										(_this$_closeCapabilit =
																											_this
																											._closeCapability
																											) ===
																										null ||
																											_this$_closeCapabilit ===
																											void 0 ?
																											void 0 :
																											_this$_closeCapabilit
																											.resolve();

																									case 5:
																									case "end":
																										return _context
																											.stop();
																								}
																							}
																						},
																						_callee
																						);
																			}
																			)
																		);

																return function(
																	_x2
																	) {
																	return _ref4
																		.apply(
																			this,
																			arguments
																			);
																};
															}());

													this._domEvents.set(
														"mousedown",
														function(
															event) {
															_this
																._mouseState
																.isDown =
																true;
														});

													this._domEvents.set(
														"mouseup",
														function(
															event) {
															_this
																._mouseState
																.isDown =
																false;
														});

													_iterator =
														_createForOfIteratorHelper(
															this
															._internalEvents
															);

													try {
														for (_iterator
															.s(); !(
																_step =
																_iterator
																.n())
															.done;) {
															_step$value
																=
																_slicedToArray(
																	_step
																	.value,
																	2),
																name =
																_step$value[
																	0],
																listener =
																_step$value[
																	1];

															this._eventBus
																._on(
																	name,
																	listener
																	);
														}
													} catch (err) {
														_iterator.e(
														err);
													} finally {
														_iterator.f();
													}

													_iterator2 =
														_createForOfIteratorHelper(
															this
															._domEvents
															);

													try {
														for (_iterator2
															.s(); !(
																_step2 =
																_iterator2
																.n())
															.done;) {
															_step2$value
																=
																_slicedToArray(
																	_step2
																	.value,
																	2),
																_name =
																_step2$value[
																	0],
																_listener =
																_step2$value[
																	1];
															window
																.addEventListener(
																	_name,
																	_listener
																	);
														}
													} catch (err) {
														_iterator2.e(
															err);
													} finally {
														_iterator2.f();
													}

													_context2.prev = 40;
													_context2.next = 43;
													return this
														._getDocProperties();

												case 43:
													docProperties =
														_context2.sent;

													if (!(pdfDocument !==
															this
															._pdfDocument
															)) {
														_context2.next =
															46;
														break;
													}

													return _context2
														.abrupt(
															"return");

												case 46:
													_context2.next = 48;
													return this
														._scripting
														.createSandbox({
															objects: objects,
															calculationOrder: calculationOrder,
															appInfo: {
																platform: navigator
																	.platform,
																language: navigator
																	.language
															},
															docInfo: _objectSpread(
																_objectSpread({},
																	docProperties
																	), {}, {
																	actions: docActions
																}
																)
														});

												case 48:
													this._eventBus
														.dispatch(
															"sandboxcreated", {
																source: this
															});

													_context2.next = 57;
													break;

												case 51:
													_context2.prev = 51;
													_context2.t1 =
														_context2[
															"catch"](
														40);
													console.error(
														"PDFScriptingManager.setDocument: \""
														.concat(
															_context2
															.t1 ===
															null ||
															_context2
															.t1 ===
															void 0 ?
															void 0 :
															_context2
															.t1
															.message,
															"\"."));
													_context2.next = 56;
													return this
														._destroyScripting();

												case 56:
													return _context2
														.abrupt(
															"return");

												case 57:
													_context2.next = 59;
													return (_this$_scripting3 =
															this
															._scripting
															) ===
														null ||
														_this$_scripting3 ===
														void 0 ?
														void 0 :
														_this$_scripting3
														.dispatchEventInSandbox({
															id: "doc",
															name: "Open"
														});

												case 59:
													_context2.next = 61;
													return this
														._dispatchPageOpen(
															this
															._pdfViewer
															.currentPageNumber,
															true);

												case 61:
													Promise.resolve()
														.then(
													function() {
															if (pdfDocument ===
																_this
																._pdfDocument
																) {
																_this
																	._ready =
																	true;
															}
														});

												case 62:
												case "end":
													return _context2
														.stop();
											}
										}
									}, _callee2, this, [
										[19, 23],
										[40, 51]
									]);
							}));

						function setDocument(_x) {
							return _setDocument.apply(this, arguments);
						}

						return setDocument;
					}()
				}, {
					key: "dispatchWillSave",
					value: function() {
						var _dispatchWillSave = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee3(
								detail) {
								var _this$_scripting4;

								return _regenerator["default"].wrap(
									function _callee3$(_context3) {
										while (1) {
											switch (_context3.prev =
												_context3.next) {
												case 0:
													return _context3
														.abrupt(
															"return", (
																_this$_scripting4 =
																this
																._scripting
																) ===
															null ||
															_this$_scripting4 ===
															void 0 ?
															void 0 :
															_this$_scripting4
															.dispatchEventInSandbox({
																id: "doc",
																name: "WillSave"
															}));

												case 1:
												case "end":
													return _context3
														.stop();
											}
										}
									}, _callee3, this);
							}));

						function dispatchWillSave(_x3) {
							return _dispatchWillSave.apply(this, arguments);
						}

						return dispatchWillSave;
					}()
				}, {
					key: "dispatchDidSave",
					value: function() {
						var _dispatchDidSave = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee4(
								detail) {
								var _this$_scripting5;

								return _regenerator["default"].wrap(
									function _callee4$(_context4) {
										while (1) {
											switch (_context4.prev =
												_context4.next) {
												case 0:
													return _context4
														.abrupt(
															"return", (
																_this$_scripting5 =
																this
																._scripting
																) ===
															null ||
															_this$_scripting5 ===
															void 0 ?
															void 0 :
															_this$_scripting5
															.dispatchEventInSandbox({
																id: "doc",
																name: "DidSave"
															}));

												case 1:
												case "end":
													return _context4
														.stop();
											}
										}
									}, _callee4, this);
							}));

						function dispatchDidSave(_x4) {
							return _dispatchDidSave.apply(this, arguments);
						}

						return dispatchDidSave;
					}()
				}, {
					key: "dispatchWillPrint",
					value: function() {
						var _dispatchWillPrint = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee5(
								detail) {
								var _this$_scripting6;

								return _regenerator["default"].wrap(
									function _callee5$(_context5) {
										while (1) {
											switch (_context5.prev =
												_context5.next) {
												case 0:
													return _context5
														.abrupt(
															"return", (
																_this$_scripting6 =
																this
																._scripting
																) ===
															null ||
															_this$_scripting6 ===
															void 0 ?
															void 0 :
															_this$_scripting6
															.dispatchEventInSandbox({
																id: "doc",
																name: "WillPrint"
															}));

												case 1:
												case "end":
													return _context5
														.stop();
											}
										}
									}, _callee5, this);
							}));

						function dispatchWillPrint(_x5) {
							return _dispatchWillPrint.apply(this, arguments);
						}

						return dispatchWillPrint;
					}()
				}, {
					key: "dispatchDidPrint",
					value: function() {
						var _dispatchDidPrint = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee6(
								detail) {
								var _this$_scripting7;

								return _regenerator["default"].wrap(
									function _callee6$(_context6) {
										while (1) {
											switch (_context6.prev =
												_context6.next) {
												case 0:
													return _context6
														.abrupt(
															"return", (
																_this$_scripting7 =
																this
																._scripting
																) ===
															null ||
															_this$_scripting7 ===
															void 0 ?
															void 0 :
															_this$_scripting7
															.dispatchEventInSandbox({
																id: "doc",
																name: "DidPrint"
															}));

												case 1:
												case "end":
													return _context6
														.stop();
											}
										}
									}, _callee6, this);
							}));

						function dispatchDidPrint(_x6) {
							return _dispatchDidPrint.apply(this, arguments);
						}

						return dispatchDidPrint;
					}()
				}, {
					key: "mouseState",
					get: function get() {
						return this._mouseState;
					}
				}, {
					key: "destroyPromise",
					get: function get() {
						var _this$_destroyCapabil;

						return ((_this$_destroyCapabil = this
							._destroyCapability) === null ||
							_this$_destroyCapabil === void 0 ? void 0 :
							_this$_destroyCapabil.promise) || null;
					}
				}, {
					key: "ready",
					get: function get() {
						return this._ready;
					}
				}, {
					key: "_internalEvents",
					get: function get() {
						return (0, _pdfjsLib.shadow)(this, "_internalEvents",
							new Map());
					}
				}, {
					key: "_domEvents",
					get: function get() {
						return (0, _pdfjsLib.shadow)(this, "_domEvents", new Map());
					}
				}, {
					key: "_pageOpenPending",
					get: function get() {
						return (0, _pdfjsLib.shadow)(this, "_pageOpenPending",
							new Set());
					}
				}, {
					key: "_visitedPages",
					get: function get() {
						return (0, _pdfjsLib.shadow)(this, "_visitedPages",
						new Map());
					}
				}, {
					key: "_updateFromSandbox",
					value: function() {
						var _updateFromSandbox2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee7(
								detail) {
								var isInPresentationMode, id, siblings,
									command, value, modes, ids, _iterator3,
									_step3, elementId, element,
									_this$_pdfDocument;

								return _regenerator["default"].wrap(
									function _callee7$(_context7) {
										while (1) {
											switch (_context7.prev =
												_context7.next) {
												case 0:
													isInPresentationMode
														= this
														._pdfViewer
														.isInPresentationMode ||
														this._pdfViewer
														.isChangingPresentationMode;
													id = detail.id,
														siblings =
														detail.siblings,
														command = detail
														.command,
														value = detail
														.value;

													if (id) {
														_context7.next =
															46;
														break;
													}

													_context7.t0 =
														command;
													_context7.next =
														_context7.t0 ===
														"clear" ? 6 :
														_context7.t0 ===
														"error" ? 8 :
														_context7.t0 ===
														"layout" ? 10 :
														_context7.t0 ===
														"page-num" ?
														15 : _context7
														.t0 ===
														"print" ? 17 :
														_context7.t0 ===
														"println" ? 21 :
														_context7.t0 ===
														"zoom" ? 23 :
														_context7.t0 ===
														"SaveAs" ? 27 :
														_context7.t0 ===
														"FirstPage" ?
														29 : _context7
														.t0 ===
														"LastPage" ?
														31 : _context7
														.t0 ===
														"NextPage" ?
														33 : _context7
														.t0 ===
														"PrevPage" ?
														35 : _context7
														.t0 ===
														"ZoomViewIn" ?
														37 : _context7
														.t0 ===
														"ZoomViewOut" ?
														41 : 45;
													break;

												case 6:
													console.clear();
													return _context7
														.abrupt("break",
															45);

												case 8:
													console.error(
													value);
													return _context7
														.abrupt("break",
															45);

												case 10:
													if (!
														isInPresentationMode
														) {
														_context7.next =
															12;
														break;
													}

													return _context7
														.abrupt(
															"return");

												case 12:
													modes = (0,
														_ui_utils
														.apiPageLayoutToViewerModes
														)(value);
													this._pdfViewer
														.spreadMode =
														modes
														.spreadMode;
													return _context7
														.abrupt("break",
															45);

												case 15:
													this._pdfViewer
														.currentPageNumber =
														value + 1;
													return _context7
														.abrupt("break",
															45);

												case 17:
													_context7.next = 19;
													return this
														._pdfViewer
														.pagesPromise;

												case 19:
													this._eventBus
														.dispatch(
															"print", {
																source: this
															});

													return _context7
														.abrupt("break",
															45);

												case 21:
													console.log(value);
													return _context7
														.abrupt("break",
															45);

												case 23:
													if (!
														isInPresentationMode
														) {
														_context7.next =
															25;
														break;
													}

													return _context7
														.abrupt(
															"return");

												case 25:
													this._pdfViewer
														.currentScaleValue =
														value;
													return _context7
														.abrupt("break",
															45);

												case 27:
													this._eventBus
														.dispatch(
															"save", {
																source: this
															});

													return _context7
														.abrupt("break",
															45);

												case 29:
													this._pdfViewer
														.currentPageNumber =
														1;
													return _context7
														.abrupt("break",
															45);

												case 31:
													this._pdfViewer
														.currentPageNumber =
														this._pdfViewer
														.pagesCount;
													return _context7
														.abrupt("break",
															45);

												case 33:
													this._pdfViewer
														.nextPage();

													return _context7
														.abrupt("break",
															45);

												case 35:
													this._pdfViewer
														.previousPage();

													return _context7
														.abrupt("break",
															45);

												case 37:
													if (!
														isInPresentationMode
														) {
														_context7.next =
															39;
														break;
													}

													return _context7
														.abrupt(
															"return");

												case 39:
													this._pdfViewer
														.increaseScale();

													return _context7
														.abrupt("break",
															45);

												case 41:
													if (!
														isInPresentationMode
														) {
														_context7.next =
															43;
														break;
													}

													return _context7
														.abrupt(
															"return");

												case 43:
													this._pdfViewer
														.decreaseScale();

													return _context7
														.abrupt("break",
															45);

												case 45:
													return _context7
														.abrupt(
															"return");

												case 46:
													if (!
														isInPresentationMode
														) {
														_context7.next =
															49;
														break;
													}

													if (!detail.focus) {
														_context7.next =
															49;
														break;
													}

													return _context7
														.abrupt(
															"return");

												case 49:
													delete detail.id;
													delete detail
														.siblings;
													ids = siblings ? [
														id].concat(
														_toConsumableArray(
															siblings
															)) : [
														id];
													_iterator3 =
														_createForOfIteratorHelper(
															ids);

													try {
														for (_iterator3
															.s(); !(
																_step3 =
																_iterator3
																.n())
															.done;) {
															elementId =
																_step3
																.value;
															element =
																document
																.getElementById(
																	elementId
																	);

															if (
																element) {
																element
																	.dispatchEvent(
																		new CustomEvent(
																			"updatefromsandbox", {
																				detail: detail
																			}
																			)
																		);
															} else {
																(_this$_pdfDocument =
																	this
																	._pdfDocument
																	) ===
																null ||
																	_this$_pdfDocument ===
																	void 0 ?
																	void 0 :
																	_this$_pdfDocument
																	.annotationStorage
																	.setValue(
																		elementId,
																		detail
																		);
															}
														}
													} catch (err) {
														_iterator3.e(
															err);
													} finally {
														_iterator3.f();
													}

													case 54:
													case "end":
														return _context7
															.stop();
											}
										}
									}, _callee7, this);
							}));

						function _updateFromSandbox(_x7) {
							return _updateFromSandbox2.apply(this, arguments);
						}

						return _updateFromSandbox;
					}()
				}, {
					key: "_dispatchPageOpen",
					value: function() {
						var _dispatchPageOpen2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee9(
								pageNumber) {
								var _this2 = this;

								var initialize,
									pdfDocument,
									visitedPages,
									pageView,
									actionsPromise,
									_args9 = arguments;
								return _regenerator["default"].wrap(
									function _callee9$(_context9) {
										while (1) {
											switch (_context9.prev =
												_context9.next) {
												case 0:
													initialize = _args9
														.length > 1 &&
														_args9[1] !==
														undefined ?
														_args9[1] :
														false;
													pdfDocument = this
														._pdfDocument,
														visitedPages =
														this
														._visitedPages;

													if (initialize) {
														this._closeCapability =
															(0, _pdfjsLib
																.createPromiseCapability
																)();
													}

													if (this
														._closeCapability
														) {
														_context9.next =
															5;
														break;
													}

													return _context9
														.abrupt(
															"return");

												case 5:
													pageView = this
														._pdfViewer
														.getPageView(
															pageNumber -
															1);

													if (!((pageView ===
																null ||
																pageView ===
																void 0 ?
																void 0 :
																pageView
																.renderingState
																) !==
															_ui_utils
															.RenderingStates
															.FINISHED
															)) {
														_context9.next =
															9;
														break;
													}

													this._pageOpenPending
														.add(
														pageNumber);

													return _context9
														.abrupt(
															"return");

												case 9:
													this._pageOpenPending[
														"delete"](
														pageNumber);

													actionsPromise =
														_asyncToGenerator( /*#__PURE__*/
															_regenerator[
																"default"
																].mark(
																function _callee8() {
																	var _pageView$pdfPage,
																		_this2$_scripting;

																	var
																	actions;
																	return _regenerator[
																			"default"
																			]
																		.wrap(
																			function _callee8$(
																				_context8
																				) {
																				while (
																					1
																					) {
																					switch (
																						_context8
																						.prev =
																						_context8
																						.next
																						) {
																						case 0:
																							_context8
																								.next =
																								2;
																							return !
																								visitedPages
																								.has(
																									pageNumber
																									) ?
																								(_pageView$pdfPage =
																									pageView
																									.pdfPage
																									) ===
																								null ||
																								_pageView$pdfPage ===
																								void 0 ?
																								void 0 :
																								_pageView$pdfPage
																								.getJSActions() :
																								null;

																						case 2:
																							actions
																								=
																								_context8
																								.sent;

																							if (!
																								(pdfDocument !==
																									_this2
																									._pdfDocument
																									)
																								) {
																								_context8
																									.next =
																									5;
																								break;
																							}

																							return _context8
																								.abrupt(
																									"return"
																									);

																						case 5:
																							_context8
																								.next =
																								7;
																							return (_this2$_scripting =
																									_this2
																									._scripting
																									) ===
																								null ||
																								_this2$_scripting ===
																								void 0 ?
																								void 0 :
																								_this2$_scripting
																								.dispatchEventInSandbox({
																									id: "page",
																									name: "PageOpen",
																									pageNumber: pageNumber,
																									actions: actions
																								});

																						case 7:
																						case "end":
																							return _context8
																								.stop();
																					}
																				}
																			},
																			_callee8
																			);
																}))();
													visitedPages.set(
														pageNumber,
														actionsPromise
														);

												case 12:
												case "end":
													return _context9
														.stop();
											}
										}
									}, _callee9, this);
							}));

						function _dispatchPageOpen(_x8) {
							return _dispatchPageOpen2.apply(this, arguments);
						}

						return _dispatchPageOpen;
					}()
				}, {
					key: "_dispatchPageClose",
					value: function() {
						var _dispatchPageClose2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee10(
								pageNumber) {
								var _this$_scripting8;

								var pdfDocument, visitedPages,
									actionsPromise;
								return _regenerator["default"].wrap(
									function _callee10$(_context10) {
										while (1) {
											switch (_context10.prev =
												_context10.next) {
												case 0:
													pdfDocument = this
														._pdfDocument,
														visitedPages =
														this
														._visitedPages;

													if (this
														._closeCapability
														) {
														_context10
															.next = 3;
														break;
													}

													return _context10
														.abrupt(
															"return");

												case 3:
													if (!this
														._pageOpenPending
														.has(pageNumber)
														) {
														_context10
															.next = 5;
														break;
													}

													return _context10
														.abrupt(
															"return");

												case 5:
													actionsPromise =
														visitedPages
														.get(
														pageNumber);

													if (
														actionsPromise) {
														_context10
															.next = 8;
														break;
													}

													return _context10
														.abrupt(
															"return");

												case 8:
													visitedPages.set(
														pageNumber,
														null);
													_context10.next =
													11;
													return actionsPromise;

												case 11:
													if (!(pdfDocument !==
															this
															._pdfDocument
															)) {
														_context10
															.next = 13;
														break;
													}

													return _context10
														.abrupt(
															"return");

												case 13:
													_context10.next =
													15;
													return (_this$_scripting8 =
															this
															._scripting
															) ===
														null ||
														_this$_scripting8 ===
														void 0 ?
														void 0 :
														_this$_scripting8
														.dispatchEventInSandbox({
															id: "page",
															name: "PageClose",
															pageNumber: pageNumber
														});

												case 15:
												case "end":
													return _context10
														.stop();
											}
										}
									}, _callee10, this);
							}));

						function _dispatchPageClose(_x9) {
							return _dispatchPageClose2.apply(this, arguments);
						}

						return _dispatchPageClose;
					}()
				}, {
					key: "_getDocProperties",
					value: function() {
						var _getDocProperties2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee11() {
								return _regenerator["default"].wrap(
									function _callee11$(_context11) {
										while (1) {
											switch (_context11.prev =
												_context11.next) {
												case 0:
													if (!this
														._docPropertiesLookup
														) {
														_context11
															.next = 2;
														break;
													}

													return _context11
														.abrupt(
															"return",
															this
															._docPropertiesLookup(
																this
																._pdfDocument
																));

												case 2:
													throw new Error(
														"_getDocProperties: Unable to lookup properties."
														);

												case 3:
												case "end":
													return _context11
														.stop();
											}
										}
									}, _callee11, this);
							}));

						function _getDocProperties() {
							return _getDocProperties2.apply(this, arguments);
						}

						return _getDocProperties;
					}()
				}, {
					key: "_createScripting",
					value: function _createScripting() {
						this._destroyCapability = (0, _pdfjsLib
							.createPromiseCapability)();

						if (this._scripting) {
							throw new Error(
								"_createScripting: Scripting already exists.");
						}

						if (this._scriptingFactory) {
							return this._scriptingFactory.createScripting({
								sandboxBundleSrc: this._sandboxBundleSrc
							});
						}

						throw new Error(
							"_createScripting: Cannot create scripting.");
					}
				}, {
					key: "_destroyScripting",
					value: function() {
						var _destroyScripting2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee12() {
								var _this$_destroyCapabil3;

								var _this$_destroyCapabil2, _iterator4,
									_step4, _step4$value, name, listener,
									_iterator5, _step5, _step5$value,
									_name2, _listener2;

								return _regenerator["default"].wrap(
									function _callee12$(_context12) {
										while (1) {
											switch (_context12.prev =
												_context12.next) {
												case 0:
													if (this
														._scripting) {
														_context12
															.next = 4;
														break;
													}

													this._pdfDocument =
														null;
													(_this$_destroyCapabil2 =
														this
														._destroyCapability
														) === null ||
														_this$_destroyCapabil2 ===
														void 0 ?
														void 0 :
														_this$_destroyCapabil2
														.resolve();
													return _context12
														.abrupt(
															"return");

												case 4:
													if (!this
														._closeCapability
														) {
														_context12
															.next = 8;
														break;
													}

													_context12.next = 7;
													return Promise.race(
														[this
															._closeCapability
															.promise,
															new Promise(
																function(
																	resolve
																	) {
																	setTimeout
																		(resolve,
																			1000
																			);
																})
														])["catch"](
														function(
															reason
															) {});

												case 7:
													this._closeCapability =
														null;

												case 8:
													this._pdfDocument =
														null;
													_context12.prev = 9;
													_context12.next =
													12;
													return this
														._scripting
														.destroySandbox();

												case 12:
													_context12.next =
													16;
													break;

												case 14:
													_context12.prev =
													14;
													_context12.t0 =
														_context12[
															"catch"](9);

												case 16:
													_iterator4 =
														_createForOfIteratorHelper(
															this
															._internalEvents
															);

													try {
														for (_iterator4
															.s(); !(
																_step4 =
																_iterator4
																.n())
															.done;) {
															_step4$value
																=
																_slicedToArray(
																	_step4
																	.value,
																	2),
																name =
																_step4$value[
																	0],
																listener =
																_step4$value[
																	1];

															this._eventBus
																._off(
																	name,
																	listener
																	);
														}
													} catch (err) {
														_iterator4.e(
															err);
													} finally {
														_iterator4.f();
													}

													this._internalEvents
														.clear();

													_iterator5 =
														_createForOfIteratorHelper(
															this
															._domEvents
															);

													try {
														for (_iterator5
															.s(); !(
																_step5 =
																_iterator5
																.n())
															.done;) {
															_step5$value
																=
																_slicedToArray(
																	_step5
																	.value,
																	2),
																_name2 =
																_step5$value[
																	0],
																_listener2 =
																_step5$value[
																	1];
															window
																.removeEventListener(
																	_name2,
																	_listener2
																	);
														}
													} catch (err) {
														_iterator5.e(
															err);
													} finally {
														_iterator5.f();
													}

													this._domEvents
														.clear();

													this._pageOpenPending
														.clear();

													this._visitedPages
														.clear();

													this._scripting =
														null;
													delete this
														._mouseState
														.isDown;
													this._ready = false;
													(_this$_destroyCapabil3 =
														this
														._destroyCapability
														) === null ||
														_this$_destroyCapabil3 ===
														void 0 ?
														void 0 :
														_this$_destroyCapabil3
														.resolve();

												case 28:
												case "end":
													return _context12
														.stop();
											}
										}
									}, _callee12, this, [
										[9, 14]
									]);
							}));

						function _destroyScripting() {
							return _destroyScripting2.apply(this, arguments);
						}

						return _destroyScripting;
					}()
				}]);

				return PDFScriptingManager;
			}();

			exports.PDFScriptingManager = PDFScriptingManager;

			/***/
		}),
		/* 25 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFSidebar = void 0;

			var _ui_utils = __webpack_require__(5);

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var UI_NOTIFICATION_CLASS = "pdfSidebarNotification";

			var PDFSidebar = /*#__PURE__*/ function() {
				function PDFSidebar(_ref) {
					var elements = _ref.elements,
						pdfViewer = _ref.pdfViewer,
						pdfThumbnailViewer = _ref.pdfThumbnailViewer,
						eventBus = _ref.eventBus,
						l10n = _ref.l10n;

					_classCallCheck(this, PDFSidebar);

					this.isOpen = false;
					this.active = _ui_utils.SidebarView.THUMBS;
					this.isInitialViewSet = false;
					this.onToggled = null;
					this.pdfViewer = pdfViewer;
					this.pdfThumbnailViewer = pdfThumbnailViewer;
					this.outerContainer = elements.outerContainer;
					this.viewerContainer = elements.viewerContainer;
					this.toggleButton = elements.toggleButton;
					this.thumbnailButton = elements.thumbnailButton;
					this.outlineButton = elements.outlineButton;
					this.attachmentsButton = elements.attachmentsButton;
					this.layersButton = elements.layersButton;
					this.thumbnailView = elements.thumbnailView;
					this.outlineView = elements.outlineView;
					this.attachmentsView = elements.attachmentsView;
					this.layersView = elements.layersView;
					this._outlineOptionsContainer = elements.outlineOptionsContainer;
					this._currentOutlineItemButton = elements.currentOutlineItemButton;
					this.eventBus = eventBus;
					this.l10n = l10n;

					this._addEventListeners();
				}

				_createClass(PDFSidebar, [{
					key: "reset",
					value: function reset() {
						this.isInitialViewSet = false;

						this._hideUINotification(true);

						this.switchView(_ui_utils.SidebarView.THUMBS);
						this.outlineButton.disabled = false;
						this.attachmentsButton.disabled = false;
						this.layersButton.disabled = false;
						this._currentOutlineItemButton.disabled = true;
					}
				}, {
					key: "visibleView",
					get: function get() {
						return this.isOpen ? this.active : _ui_utils.SidebarView
							.NONE;
					}
				}, {
					key: "isThumbnailViewVisible",
					get: function get() {
						return this.isOpen && this.active === _ui_utils.SidebarView
							.THUMBS;
					}
				}, {
					key: "isOutlineViewVisible",
					get: function get() {
						return this.isOpen && this.active === _ui_utils.SidebarView
							.OUTLINE;
					}
				}, {
					key: "isAttachmentsViewVisible",
					get: function get() {
						return this.isOpen && this.active === _ui_utils.SidebarView
							.ATTACHMENTS;
					}
				}, {
					key: "isLayersViewVisible",
					get: function get() {
						return this.isOpen && this.active === _ui_utils.SidebarView
							.LAYERS;
					}
				}, {
					key: "setInitialView",
					value: function setInitialView() {
						var view = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : _ui_utils.SidebarView.NONE;

						if (this.isInitialViewSet) {
							return;
						}

						this.isInitialViewSet = true;

						if (view === _ui_utils.SidebarView.NONE || view ===
							_ui_utils.SidebarView.UNKNOWN) {
							this._dispatchEvent();

							return;
						}

						if (!this._switchView(view, true)) {
							this._dispatchEvent();
						}
					}
				}, {
					key: "switchView",
					value: function switchView(view) {
						var forceOpen = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : false;

						this._switchView(view, forceOpen);
					}
				}, {
					key: "_switchView",
					value: function _switchView(view) {
						var forceOpen = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : false;
						var isViewChanged = view !== this.active;
						var shouldForceRendering = false;

						switch (view) {
							case _ui_utils.SidebarView.NONE:
								if (this.isOpen) {
									this.close();
									return true;
								}

								return false;

							case _ui_utils.SidebarView.THUMBS:
								if (this.isOpen && isViewChanged) {
									shouldForceRendering = true;
								}

								break;

							case _ui_utils.SidebarView.OUTLINE:
								if (this.outlineButton.disabled) {
									return false;
								}

								break;

							case _ui_utils.SidebarView.ATTACHMENTS:
								if (this.attachmentsButton.disabled) {
									return false;
								}

								break;

							case _ui_utils.SidebarView.LAYERS:
								if (this.layersButton.disabled) {
									return false;
								}

								break;

							default:
								console.error("PDFSidebar._switchView: \"".concat(
									view, "\" is not a valid view."));
								return false;
						}

						this.active = view;
						this.thumbnailButton.classList.toggle("toggled", view ===
							_ui_utils.SidebarView.THUMBS);
						this.outlineButton.classList.toggle("toggled", view ===
							_ui_utils.SidebarView.OUTLINE);
						this.attachmentsButton.classList.toggle("toggled", view ===
							_ui_utils.SidebarView.ATTACHMENTS);
						this.layersButton.classList.toggle("toggled", view ===
							_ui_utils.SidebarView.LAYERS);
						this.thumbnailView.classList.toggle("hidden", view !==
							_ui_utils.SidebarView.THUMBS);
						this.outlineView.classList.toggle("hidden", view !==
							_ui_utils.SidebarView.OUTLINE);
						this.attachmentsView.classList.toggle("hidden", view !==
							_ui_utils.SidebarView.ATTACHMENTS);
						this.layersView.classList.toggle("hidden", view !==
							_ui_utils.SidebarView.LAYERS);

						this._outlineOptionsContainer.classList.toggle("hidden",
							view !== _ui_utils.SidebarView.OUTLINE);

						if (forceOpen && !this.isOpen) {
							this.open();
							return true;
						}

						if (shouldForceRendering) {
							this._updateThumbnailViewer();

							this._forceRendering();
						}

						if (isViewChanged) {
							this._dispatchEvent();
						}

						return isViewChanged;
					}
				}, {
					key: "open",
					value: function open() {
						if (this.isOpen) {
							return;
						}

						this.isOpen = true;
						this.toggleButton.classList.add("toggled");
						this.toggleButton.setAttribute("aria-expanded", "true");
						this.outerContainer.classList.add("sidebarMoving",
							"sidebarOpen");

						if (this.active === _ui_utils.SidebarView.THUMBS) {
							this._updateThumbnailViewer();
						}

						this._forceRendering();

						this._dispatchEvent();

						this._hideUINotification();
					}
				}, {
					key: "close",
					value: function close() {
						if (!this.isOpen) {
							return;
						}

						this.isOpen = false;
						this.toggleButton.classList.remove("toggled");
						this.toggleButton.setAttribute("aria-expanded", "false");
						this.outerContainer.classList.add("sidebarMoving");
						this.outerContainer.classList.remove("sidebarOpen");

						this._forceRendering();

						this._dispatchEvent();
					}
				}, {
					key: "toggle",
					value: function toggle() {
						if (this.isOpen) {
							this.close();
						} else {
							this.open();
						}
					}
				}, {
					key: "_dispatchEvent",
					value: function _dispatchEvent() {
						this.eventBus.dispatch("sidebarviewchanged", {
							source: this,
							view: this.visibleView
						});
					}
				}, {
					key: "_forceRendering",
					value: function _forceRendering() {
						if (this.onToggled) {
							this.onToggled();
						} else {
							this.pdfViewer.forceRendering();
							this.pdfThumbnailViewer.forceRendering();
						}
					}
				}, {
					key: "_updateThumbnailViewer",
					value: function _updateThumbnailViewer() {
						var pdfViewer = this.pdfViewer,
							pdfThumbnailViewer = this.pdfThumbnailViewer;
						var pagesCount = pdfViewer.pagesCount;

						for (var pageIndex = 0; pageIndex <
							pagesCount; pageIndex++) {
							var pageView = pdfViewer.getPageView(pageIndex);

							if ((pageView === null || pageView === void 0 ? void 0 :
									pageView.renderingState) === _ui_utils
								.RenderingStates.FINISHED) {
								var thumbnailView = pdfThumbnailViewer.getThumbnail(
									pageIndex);
								thumbnailView.setImage(pageView);
							}
						}

						pdfThumbnailViewer.scrollThumbnailIntoView(pdfViewer
							.currentPageNumber);
					}
				}, {
					key: "_showUINotification",
					value: function _showUINotification() {
						var _this = this;

						this.l10n.get("toggle_sidebar_notification2.title").then(
							function(msg) {
								_this.toggleButton.title = msg;
							});

						if (!this.isOpen) {
							this.toggleButton.classList.add(UI_NOTIFICATION_CLASS);
						}
					}
				}, {
					key: "_hideUINotification",
					value: function _hideUINotification() {
						var _this2 = this;

						var reset = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : false;

						if (this.isOpen || reset) {
							this.toggleButton.classList.remove(
								UI_NOTIFICATION_CLASS);
						}

						if (reset) {
							this.l10n.get("toggle_sidebar.title").then(function(
							msg) {
								_this2.toggleButton.title = msg;
							});
						}
					}
				}, {
					key: "_addEventListeners",
					value: function _addEventListeners() {
						var _this3 = this;

						this.viewerContainer.addEventListener("transitionend",
							function(evt) {
								if (evt.target === _this3.viewerContainer) {
									_this3.outerContainer.classList.remove(
										"sidebarMoving");
								}
							});
						this.toggleButton.addEventListener("click", function() {
							_this3.toggle();
						});
						this.thumbnailButton.addEventListener("click", function() {
							_this3.switchView(_ui_utils.SidebarView.THUMBS);
						});
						this.outlineButton.addEventListener("click", function() {
							_this3.switchView(_ui_utils.SidebarView
							.OUTLINE);
						});
						this.outlineButton.addEventListener("dblclick", function() {
							_this3.eventBus.dispatch("toggleoutlinetree", {
								source: _this3
							});
						});
						this.attachmentsButton.addEventListener("click",
					function() {
							_this3.switchView(_ui_utils.SidebarView
								.ATTACHMENTS);
						});
						this.layersButton.addEventListener("click", function() {
							_this3.switchView(_ui_utils.SidebarView.LAYERS);
						});
						this.layersButton.addEventListener("dblclick", function() {
							_this3.eventBus.dispatch("resetlayers", {
								source: _this3
							});
						});

						this._currentOutlineItemButton.addEventListener("click",
							function() {
								_this3.eventBus.dispatch("currentoutlineitem", {
									source: _this3
								});
							});

						var onTreeLoaded = function onTreeLoaded(count, button,
							view) {
							button.disabled = !count;

							if (count) {
								_this3._showUINotification();
							} else if (_this3.active === view) {
								_this3.switchView(_ui_utils.SidebarView.THUMBS);
							}
						};

						this.eventBus._on("outlineloaded", function(evt) {
							onTreeLoaded(evt.outlineCount, _this3
								.outlineButton, _ui_utils.SidebarView
								.OUTLINE);
							evt.currentOutlineItemPromise.then(function(
								enabled) {
								if (!_this3.isInitialViewSet) {
									return;
								}

								_this3._currentOutlineItemButton
									.disabled = !enabled;
							});
						});

						this.eventBus._on("attachmentsloaded", function(evt) {
							onTreeLoaded(evt.attachmentsCount, _this3
								.attachmentsButton, _ui_utils
								.SidebarView.ATTACHMENTS);
						});

						this.eventBus._on("layersloaded", function(evt) {
							onTreeLoaded(evt.layersCount, _this3
								.layersButton, _ui_utils.SidebarView
								.LAYERS);
						});

						this.eventBus._on("presentationmodechanged", function(evt) {
							if (evt.state === _ui_utils
								.PresentationModeState.NORMAL && _this3
								.isThumbnailViewVisible) {
								_this3._updateThumbnailViewer();
							}
						});
					}
				}]);

				return PDFSidebar;
			}();

			exports.PDFSidebar = PDFSidebar;

			/***/
		}),
		/* 26 */
		/***/
		((__unused_webpack_module, exports) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFSidebarResizer = void 0;

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var SIDEBAR_WIDTH_VAR = "--sidebar-width";
			var SIDEBAR_MIN_WIDTH = 200;
			var SIDEBAR_RESIZING_CLASS = "sidebarResizing";

			var PDFSidebarResizer = /*#__PURE__*/ function() {
				function PDFSidebarResizer(options, eventBus, l10n) {
					var _this = this;

					_classCallCheck(this, PDFSidebarResizer);

					this.isRTL = false;
					this.sidebarOpen = false;
					this.doc = document.documentElement;
					this._width = null;
					this._outerContainerWidth = null;
					this._boundEvents = Object.create(null);
					this.outerContainer = options.outerContainer;
					this.resizer = options.resizer;
					this.eventBus = eventBus;
					l10n.getDirection().then(function(dir) {
						_this.isRTL = dir === "rtl";
					});

					this._addEventListeners();
				}

				_createClass(PDFSidebarResizer, [{
					key: "outerContainerWidth",
					get: function get() {
						return this._outerContainerWidth || (this
							._outerContainerWidth = this.outerContainer
							.clientWidth);
					}
				}, {
					key: "_updateWidth",
					value: function _updateWidth() {
						var width = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : 0;
						var maxWidth = Math.floor(this.outerContainerWidth / 2);

						if (width > maxWidth) {
							width = maxWidth;
						}

						if (width < SIDEBAR_MIN_WIDTH) {
							width = SIDEBAR_MIN_WIDTH;
						}

						if (width === this._width) {
							return false;
						}

						this._width = width;
						this.doc.style.setProperty(SIDEBAR_WIDTH_VAR, "".concat(
							width, "px"));
						return true;
					}
				}, {
					key: "_mouseMove",
					value: function _mouseMove(evt) {
						var width = evt.clientX;

						if (this.isRTL) {
							width = this.outerContainerWidth - width;
						}

						this._updateWidth(width);
					}
				}, {
					key: "_mouseUp",
					value: function _mouseUp(evt) {
						this.outerContainer.classList.remove(
						SIDEBAR_RESIZING_CLASS);
						this.eventBus.dispatch("resize", {
							source: this
						});
						var _boundEvents = this._boundEvents;
						window.removeEventListener("mousemove", _boundEvents
							.mouseMove);
						window.removeEventListener("mouseup", _boundEvents.mouseUp);
					}
				}, {
					key: "_addEventListeners",
					value: function _addEventListeners() {
						var _this2 = this;

						var _boundEvents = this._boundEvents;
						_boundEvents.mouseMove = this._mouseMove.bind(this);
						_boundEvents.mouseUp = this._mouseUp.bind(this);
						this.resizer.addEventListener("mousedown", function(evt) {
							if (evt.button !== 0) {
								return;
							}

							_this2.outerContainer.classList.add(
								SIDEBAR_RESIZING_CLASS);

							window.addEventListener("mousemove",
								_boundEvents.mouseMove);
							window.addEventListener("mouseup", _boundEvents
								.mouseUp);
						});

						this.eventBus._on("sidebarviewchanged", function(evt) {
							_this2.sidebarOpen = !!(evt !== null && evt !==
								void 0 && evt.view);
						});

						this.eventBus._on("resize", function(evt) {
							if ((evt === null || evt === void 0 ? void 0 :
									evt.source) !== window) {
								return;
							}

							_this2._outerContainerWidth = null;

							if (!_this2._width) {
								return;
							}

							if (!_this2.sidebarOpen) {
								_this2._updateWidth(_this2._width);

								return;
							}

							_this2.outerContainer.classList.add(
								SIDEBAR_RESIZING_CLASS);

							var updated = _this2._updateWidth(_this2
							._width);

							Promise.resolve().then(function() {
								_this2.outerContainer.classList
									.remove(SIDEBAR_RESIZING_CLASS);

								if (updated) {
									_this2.eventBus.dispatch(
										"resize", {
											source: _this2
										});
								}
							});
						});
					}
				}]);

				return PDFSidebarResizer;
			}();

			exports.PDFSidebarResizer = PDFSidebarResizer;

			/***/
		}),
		/* 27 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFThumbnailViewer = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _ui_utils = __webpack_require__(5);

			var _pdf_thumbnail_view = __webpack_require__(28);

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

			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);
				}
			}

			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);
					});
				};
			}

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

			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);
			}

			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;
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			function _classPrivateMethodInitSpec(obj, privateSet) {
				_checkPrivateRedeclaration(obj, privateSet);
				privateSet.add(obj);
			}

			function _checkPrivateRedeclaration(obj, privateCollection) {
				if (privateCollection.has(obj)) {
					throw new TypeError(
						"Cannot initialize the same private elements twice on an object");
				}
			}

			function _classPrivateMethodGet(receiver, privateSet, fn) {
				if (!privateSet.has(receiver)) {
					throw new TypeError("attempted to get private field on non-instance");
				}
				return fn;
			}

			var THUMBNAIL_SCROLL_MARGIN = -19;
			var THUMBNAIL_SELECTED_CLASS = "selected";

			var _ensurePdfPageLoaded = /*#__PURE__*/ new WeakSet();

			var _getScrollAhead = /*#__PURE__*/ new WeakSet();

			var PDFThumbnailViewer = /*#__PURE__*/ function() {
				function PDFThumbnailViewer(_ref) {
					var _this = this;

					var container = _ref.container,
						eventBus = _ref.eventBus,
						linkService = _ref.linkService,
						renderingQueue = _ref.renderingQueue,
						l10n = _ref.l10n;

					_classCallCheck(this, PDFThumbnailViewer);

					_classPrivateMethodInitSpec(this, _getScrollAhead);

					_classPrivateMethodInitSpec(this, _ensurePdfPageLoaded);

					this.container = container;
					this.linkService = linkService;
					this.renderingQueue = renderingQueue;
					this.l10n = l10n;
					this.scroll = (0, _ui_utils.watchScroll)(this.container, this._scrollUpdated
						.bind(this));

					this._resetView();

					eventBus._on("optionalcontentconfigchanged", function() {
						_this._setImageDisabled = true;
					});
				}

				_createClass(PDFThumbnailViewer, [{
					key: "_scrollUpdated",
					value: function _scrollUpdated() {
						this.renderingQueue.renderHighestPriority();
					}
				}, {
					key: "getThumbnail",
					value: function getThumbnail(index) {
						return this._thumbnails[index];
					}
				}, {
					key: "_getVisibleThumbs",
					value: function _getVisibleThumbs() {
						return (0, _ui_utils.getVisibleElements)({
							scrollEl: this.container,
							views: this._thumbnails
						});
					}
				}, {
					key: "scrollThumbnailIntoView",
					value: function scrollThumbnailIntoView(pageNumber) {
						if (!this.pdfDocument) {
							return;
						}

						var thumbnailView = this._thumbnails[pageNumber - 1];

						if (!thumbnailView) {
							console.error(
								'scrollThumbnailIntoView: Invalid "pageNumber" parameter.'
								);
							return;
						}

						if (pageNumber !== this._currentPageNumber) {
							var prevThumbnailView = this._thumbnails[this
								._currentPageNumber - 1];
							prevThumbnailView.div.classList.remove(
								THUMBNAIL_SELECTED_CLASS);
							thumbnailView.div.classList.add(
								THUMBNAIL_SELECTED_CLASS);
						}

						var _this$_getVisibleThum = this._getVisibleThumbs(),
							first = _this$_getVisibleThum.first,
							last = _this$_getVisibleThum.last,
							views = _this$_getVisibleThum.views;

						if (views.length > 0) {
							var shouldScroll = false;

							if (pageNumber <= first.id || pageNumber >= last.id) {
								shouldScroll = true;
							} else {
								var _iterator = _createForOfIteratorHelper(views),
									_step;

								try {
									for (_iterator.s(); !(_step = _iterator.n())
										.done;) {
										var _step$value = _step.value,
											id = _step$value.id,
											percent = _step$value.percent;

										if (id !== pageNumber) {
											continue;
										}

										shouldScroll = percent < 100;
										break;
									}
								} catch (err) {
									_iterator.e(err);
								} finally {
									_iterator.f();
								}
							}

							if (shouldScroll) {
								(0, _ui_utils.scrollIntoView)(thumbnailView.div, {
									top: THUMBNAIL_SCROLL_MARGIN
								});
							}
						}

						this._currentPageNumber = pageNumber;
					}
				}, {
					key: "pagesRotation",
					get: function get() {
						return this._pagesRotation;
					},
					set: function set(rotation) {
						if (!(0, _ui_utils.isValidRotation)(rotation)) {
							throw new Error("Invalid thumbnails rotation angle.");
						}

						if (!this.pdfDocument) {
							return;
						}

						if (this._pagesRotation === rotation) {
							return;
						}

						this._pagesRotation = rotation;
						var updateArgs = {
							rotation: rotation
						};

						var _iterator2 = _createForOfIteratorHelper(this
								._thumbnails),
							_step2;

						try {
							for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
								var thumbnail = _step2.value;
								thumbnail.update(updateArgs);
							}
						} catch (err) {
							_iterator2.e(err);
						} finally {
							_iterator2.f();
						}
					}
				}, {
					key: "cleanup",
					value: function cleanup() {
						for (var i = 0, ii = this._thumbnails.length; i < ii; i++) {
							if (this._thumbnails[i] && this._thumbnails[i]
								.renderingState !== _ui_utils.RenderingStates
								.FINISHED) {
								this._thumbnails[i].reset();
							}
						}

						_pdf_thumbnail_view.TempImageFactory.destroyCanvas();
					}
				}, {
					key: "_resetView",
					value: function _resetView() {
						this._thumbnails = [];
						this._currentPageNumber = 1;
						this._pageLabels = null;
						this._pagesRotation = 0;
						this._optionalContentConfigPromise = null;
						this._setImageDisabled = false;
						this.container.textContent = "";
					}
				}, {
					key: "setDocument",
					value: function setDocument(pdfDocument) {
						var _this2 = this;

						if (this.pdfDocument) {
							this._cancelRendering();

							this._resetView();
						}

						this.pdfDocument = pdfDocument;

						if (!pdfDocument) {
							return;
						}

						var firstPagePromise = pdfDocument.getPage(1);
						var optionalContentConfigPromise = pdfDocument
							.getOptionalContentConfig();
						firstPagePromise.then(function(firstPdfPage) {
							_this2._optionalContentConfigPromise =
								optionalContentConfigPromise;
							var pagesCount = pdfDocument.numPages;
							var viewport = firstPdfPage.getViewport({
								scale: 1
							});

							var checkSetImageDisabled =
								function checkSetImageDisabled() {
									return _this2._setImageDisabled;
								};

							for (var pageNum = 1; pageNum <= pagesCount; ++
								pageNum) {
								var thumbnail = new _pdf_thumbnail_view
									.PDFThumbnailView({
										container: _this2.container,
										id: pageNum,
										defaultViewport: viewport
										.clone(),
										optionalContentConfigPromise: optionalContentConfigPromise,
										linkService: _this2.linkService,
										renderingQueue: _this2
											.renderingQueue,
										checkSetImageDisabled: checkSetImageDisabled,
										l10n: _this2.l10n
									});

								_this2._thumbnails.push(thumbnail);
							}

							var firstThumbnailView = _this2._thumbnails[0];

							if (firstThumbnailView) {
								firstThumbnailView.setPdfPage(firstPdfPage);
							}

							var thumbnailView = _this2._thumbnails[_this2
								._currentPageNumber - 1];
							thumbnailView.div.classList.add(
								THUMBNAIL_SELECTED_CLASS);
						})["catch"](function(reason) {
							console.error(
								"Unable to initialize thumbnail viewer",
								reason);
						});
					}
				}, {
					key: "_cancelRendering",
					value: function _cancelRendering() {
						for (var i = 0, ii = this._thumbnails.length; i < ii; i++) {
							if (this._thumbnails[i]) {
								this._thumbnails[i].cancelRendering();
							}
						}
					}
				}, {
					key: "setPageLabels",
					value: function setPageLabels(labels) {
						if (!this.pdfDocument) {
							return;
						}

						if (!labels) {
							this._pageLabels = null;
						} else if (!(Array.isArray(labels) && this.pdfDocument
								.numPages === labels.length)) {
							this._pageLabels = null;
							console.error(
								"PDFThumbnailViewer_setPageLabels: Invalid page labels."
								);
						} else {
							this._pageLabels = labels;
						}

						for (var i = 0, ii = this._thumbnails.length; i < ii; i++) {
							var _this$_pageLabels$i, _this$_pageLabels;

							this._thumbnails[i].setPageLabel((_this$_pageLabels$i =
									(_this$_pageLabels = this._pageLabels) ===
									null || _this$_pageLabels === void 0 ?
									void 0 : _this$_pageLabels[i]) !== null &&
								_this$_pageLabels$i !== void 0 ?
								_this$_pageLabels$i : null);
						}
					}
				}, {
					key: "forceRendering",
					value: function forceRendering() {
						var _this3 = this;

						var visibleThumbs = this._getVisibleThumbs();

						var scrollAhead = _classPrivateMethodGet(this,
							_getScrollAhead, _getScrollAhead2).call(this,
							visibleThumbs);

						var thumbView = this.renderingQueue.getHighestPriority(
							visibleThumbs, this._thumbnails, scrollAhead);

						if (thumbView) {
							_classPrivateMethodGet(this, _ensurePdfPageLoaded,
									_ensurePdfPageLoaded2).call(this, thumbView)
								.then(function() {
									_this3.renderingQueue.renderView(thumbView);
								});

							return true;
						}

						return false;
					}
				}]);

				return PDFThumbnailViewer;
			}();

			exports.PDFThumbnailViewer = PDFThumbnailViewer;

			function _ensurePdfPageLoaded2(_x) {
				return _ensurePdfPageLoaded3.apply(this, arguments);
			}

			function _ensurePdfPageLoaded3() {
				_ensurePdfPageLoaded3 = _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
					function _callee(thumbView) {
						var pdfPage;
						return _regenerator["default"].wrap(function _callee$(_context) {
							while (1) {
								switch (_context.prev = _context.next) {
									case 0:
										if (!thumbView.pdfPage) {
											_context.next = 2;
											break;
										}

										return _context.abrupt("return", thumbView
											.pdfPage);

									case 2:
										_context.prev = 2;
										_context.next = 5;
										return this.pdfDocument.getPage(thumbView.id);

									case 5:
										pdfPage = _context.sent;

										if (!thumbView.pdfPage) {
											thumbView.setPdfPage(pdfPage);
										}

										return _context.abrupt("return", pdfPage);

									case 10:
										_context.prev = 10;
										_context.t0 = _context["catch"](2);
										console.error(
											"Unable to get page for thumb view",
											_context.t0);
										return _context.abrupt("return", null);

									case 14:
									case "end":
										return _context.stop();
								}
							}
						}, _callee, this, [
							[2, 10]
						]);
					}));
				return _ensurePdfPageLoaded3.apply(this, arguments);
			}

			function _getScrollAhead2(visible) {
				var _visible$first, _visible$last;

				if (((_visible$first = visible.first) === null || _visible$first === void 0 ? void 0 :
						_visible$first.id) === 1) {
					return true;
				} else if (((_visible$last = visible.last) === null || _visible$last === void 0 ?
						void 0 : _visible$last.id) === this._thumbnails.length) {
					return false;
				}

				return this.scroll.down;
			}

			/***/
		}),
		/* 28 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.TempImageFactory = exports.PDFThumbnailView = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _ui_utils = __webpack_require__(5);

			var _pdfjsLib = __webpack_require__(7);

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

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

			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."
					);
			}

			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);
			}

			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;
			}

			function _iterableToArrayLimit(arr, i) {
				var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] ||
					arr["@@iterator"];
				if (_i == null) return;
				var _arr = [];
				var _n = true;
				var _d = false;
				var _s, _e;
				try {
					for (_i = _i.call(arr); !(_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;
			}

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

			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);
				}
			}

			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);
					});
				};
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) {
				_classCheckPrivateStaticAccess(receiver, classConstructor);
				_classCheckPrivateStaticFieldDescriptor(descriptor, "set");
				_classApplyDescriptorSet(receiver, descriptor, value);
				return value;
			}

			function _classApplyDescriptorSet(receiver, descriptor, value) {
				if (descriptor.set) {
					descriptor.set.call(receiver, value);
				} else {
					if (!descriptor.writable) {
						throw new TypeError("attempted to set read only private field");
					}
					descriptor.value = value;
				}
			}

			function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) {
				_classCheckPrivateStaticAccess(receiver, classConstructor);
				_classCheckPrivateStaticFieldDescriptor(descriptor, "get");
				return _classApplyDescriptorGet(receiver, descriptor);
			}

			function _classCheckPrivateStaticFieldDescriptor(descriptor, action) {
				if (descriptor === undefined) {
					throw new TypeError("attempted to " + action +
						" private static field before its declaration");
				}
			}

			function _classCheckPrivateStaticAccess(receiver, classConstructor) {
				if (receiver !== classConstructor) {
					throw new TypeError("Private static access of wrong provenance");
				}
			}

			function _classApplyDescriptorGet(receiver, descriptor) {
				if (descriptor.get) {
					return descriptor.get.call(receiver);
				}
				return descriptor.value;
			}

			var DRAW_UPSCALE_FACTOR = 2;
			var MAX_NUM_SCALING_STEPS = 3;
			var THUMBNAIL_CANVAS_BORDER_WIDTH = 1;
			var THUMBNAIL_WIDTH = 98;

			var TempImageFactory = /*#__PURE__*/ function() {
				function TempImageFactory() {
					_classCallCheck(this, TempImageFactory);
				}

				_createClass(TempImageFactory, null, [{
					key: "getCanvas",
					value: function getCanvas(width, height) {
						var tempCanvas = _classStaticPrivateFieldSpecGet(this,
								TempImageFactory, _tempCanvas) ||
							_classStaticPrivateFieldSpecSet(this, TempImageFactory,
								_tempCanvas, document.createElement("canvas"));

						tempCanvas.width = width;
						tempCanvas.height = height;
						tempCanvas.mozOpaque = true;
						var ctx = tempCanvas.getContext("2d", {
							alpha: false
						});
						ctx.save();
						ctx.fillStyle = "rgb(255, 255, 255)";
						ctx.fillRect(0, 0, width, height);
						ctx.restore();
						return [tempCanvas, tempCanvas.getContext("2d")];
					}
				}, {
					key: "destroyCanvas",
					value: function destroyCanvas() {
						var tempCanvas = _classStaticPrivateFieldSpecGet(this,
							TempImageFactory, _tempCanvas);

						if (tempCanvas) {
							tempCanvas.width = 0;
							tempCanvas.height = 0;
						}

						_classStaticPrivateFieldSpecSet(this, TempImageFactory,
							_tempCanvas, null);
					}
				}]);

				return TempImageFactory;
			}();

			exports.TempImageFactory = TempImageFactory;
			var _tempCanvas = {
				writable: true,
				value: null
			};

			var PDFThumbnailView = /*#__PURE__*/ function() {
				function PDFThumbnailView(_ref) {
					var container = _ref.container,
						id = _ref.id,
						defaultViewport = _ref.defaultViewport,
						optionalContentConfigPromise = _ref.optionalContentConfigPromise,
						linkService = _ref.linkService,
						renderingQueue = _ref.renderingQueue,
						checkSetImageDisabled = _ref.checkSetImageDisabled,
						l10n = _ref.l10n;

					_classCallCheck(this, PDFThumbnailView);

					this.id = id;
					this.renderingId = "thumbnail" + id;
					this.pageLabel = null;
					this.pdfPage = null;
					this.rotation = 0;
					this.viewport = defaultViewport;
					this.pdfPageRotate = defaultViewport.rotation;
					this._optionalContentConfigPromise = optionalContentConfigPromise || null;
					this.linkService = linkService;
					this.renderingQueue = renderingQueue;
					this.renderTask = null;
					this.renderingState = _ui_utils.RenderingStates.INITIAL;
					this.resume = null;

					this._checkSetImageDisabled = checkSetImageDisabled || function() {
						return false;
					};

					var pageWidth = this.viewport.width,
						pageHeight = this.viewport.height,
						pageRatio = pageWidth / pageHeight;
					this.canvasWidth = THUMBNAIL_WIDTH;
					this.canvasHeight = this.canvasWidth / pageRatio | 0;
					this.scale = this.canvasWidth / pageWidth;
					this.l10n = l10n;
					var anchor = document.createElement("a");
					anchor.href = linkService.getAnchorUrl("#page=" + id);

					this._thumbPageTitle.then(function(msg) {
						anchor.title = msg;
					});

					anchor.onclick = function() {
						linkService.goToPage(id);
						return false;
					};

					this.anchor = anchor;
					var div = document.createElement("div");
					div.className = "thumbnail";
					div.setAttribute("data-page-number", this.id);
					this.div = div;
					var ring = document.createElement("div");
					ring.className = "thumbnailSelectionRing";
					var borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
					ring.style.width = this.canvasWidth + borderAdjustment + "px";
					ring.style.height = this.canvasHeight + borderAdjustment + "px";
					this.ring = ring;
					div.appendChild(ring);
					anchor.appendChild(div);
					container.appendChild(anchor);
				}

				_createClass(PDFThumbnailView, [{
					key: "setPdfPage",
					value: function setPdfPage(pdfPage) {
						this.pdfPage = pdfPage;
						this.pdfPageRotate = pdfPage.rotate;
						var totalRotation = (this.rotation + this.pdfPageRotate) %
							360;
						this.viewport = pdfPage.getViewport({
							scale: 1,
							rotation: totalRotation
						});
						this.reset();
					}
				}, {
					key: "reset",
					value: function reset() {
						this.cancelRendering();
						this.renderingState = _ui_utils.RenderingStates.INITIAL;
						var pageWidth = this.viewport.width,
							pageHeight = this.viewport.height,
							pageRatio = pageWidth / pageHeight;
						this.canvasHeight = this.canvasWidth / pageRatio | 0;
						this.scale = this.canvasWidth / pageWidth;
						this.div.removeAttribute("data-loaded");
						var ring = this.ring;
						ring.textContent = "";
						var borderAdjustment = 2 * THUMBNAIL_CANVAS_BORDER_WIDTH;
						ring.style.width = this.canvasWidth + borderAdjustment +
							"px";
						ring.style.height = this.canvasHeight + borderAdjustment +
							"px";

						if (this.canvas) {
							this.canvas.width = 0;
							this.canvas.height = 0;
							delete this.canvas;
						}

						if (this.image) {
							this.image.removeAttribute("src");
							delete this.image;
						}
					}
				}, {
					key: "update",
					value: function update(_ref2) {
						var _ref2$rotation = _ref2.rotation,
							rotation = _ref2$rotation === void 0 ? null :
							_ref2$rotation;

						if (typeof rotation === "number") {
							this.rotation = rotation;
						}

						var totalRotation = (this.rotation + this.pdfPageRotate) %
							360;
						this.viewport = this.viewport.clone({
							scale: 1,
							rotation: totalRotation
						});
						this.reset();
					}
				}, {
					key: "cancelRendering",
					value: function cancelRendering() {
						if (this.renderTask) {
							this.renderTask.cancel();
							this.renderTask = null;
						}

						this.resume = null;
					}
				}, {
					key: "_getPageDrawContext",
					value: function _getPageDrawContext() {
						var upscaleFactor = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : 1;
						var canvas = document.createElement("canvas");
						canvas.mozOpaque = true;
						var ctx = canvas.getContext("2d", {
							alpha: false
						});
						var outputScale = new _ui_utils.OutputScale();
						canvas.width = upscaleFactor * this.canvasWidth *
							outputScale.sx | 0;
						canvas.height = upscaleFactor * this.canvasHeight *
							outputScale.sy | 0;
						var transform = outputScale.scaled ? [outputScale.sx, 0, 0,
							outputScale.sy, 0, 0
						] : null;
						return {
							ctx: ctx,
							canvas: canvas,
							transform: transform
						};
					}
				}, {
					key: "_convertCanvasToImage",
					value: function _convertCanvasToImage(canvas) {
						if (this.renderingState !== _ui_utils.RenderingStates
							.FINISHED) {
							throw new Error(
								"_convertCanvasToImage: Rendering has not finished."
								);
						}

						var reducedCanvas = this._reduceImage(canvas);

						var image = document.createElement("img");
						image.className = "thumbnailImage";

						this._thumbPageCanvas.then(function(msg) {
							image.setAttribute("aria-label", msg);
						});

						image.style.width = this.canvasWidth + "px";
						image.style.height = this.canvasHeight + "px";
						image.src = reducedCanvas.toDataURL();
						this.image = image;
						this.div.setAttribute("data-loaded", true);
						this.ring.appendChild(image);
						reducedCanvas.width = 0;
						reducedCanvas.height = 0;
					}
				}, {
					key: "draw",
					value: function draw() {
						var _this = this;

						if (this.renderingState !== _ui_utils.RenderingStates
							.INITIAL) {
							console.error("Must be in new state before drawing");
							return Promise.resolve();
						}

						var pdfPage = this.pdfPage;

						if (!pdfPage) {
							this.renderingState = _ui_utils.RenderingStates
							.FINISHED;
							return Promise.reject(new Error(
								"pdfPage is not loaded"));
						}

						this.renderingState = _ui_utils.RenderingStates.RUNNING;

						var finishRenderTask = /*#__PURE__*/ function() {
							var _ref3 = _asyncToGenerator( /*#__PURE__*/
								_regenerator["default"].mark(
									function _callee() {
										var error,
											_args = arguments;
										return _regenerator["default"].wrap(
											function _callee$(
											_context) {
												while (1) {
													switch (_context
														.prev = _context
														.next) {
														case 0:
															error =
																_args
																.length >
																0 &&
																_args[
																0] !==
																undefined ?
																_args[
																0] :
																null;

															if (renderTask ===
																_this
																.renderTask
																) {
																_this
																	.renderTask =
																	null;
															}

															if (!(error instanceof _pdfjsLib
																	.RenderingCancelledException
																	)) {
																_context
																	.next =
																	4;
																break;
															}

															return _context
																.abrupt(
																	"return"
																	);

														case 4:
															_this
																.renderingState =
																_ui_utils
																.RenderingStates
																.FINISHED;

															_this
																._convertCanvasToImage(
																	canvas
																	);

															if (!
																error) {
																_context
																	.next =
																	8;
																break;
															}

															throw error;

														case 8:
														case "end":
															return _context
																.stop();
													}
												}
											}, _callee);
									}));

							return function finishRenderTask() {
								return _ref3.apply(this, arguments);
							};
						}();

						var _this$_getPageDrawCon = this._getPageDrawContext(
								DRAW_UPSCALE_FACTOR),
							ctx = _this$_getPageDrawCon.ctx,
							canvas = _this$_getPageDrawCon.canvas,
							transform = _this$_getPageDrawCon.transform;

						var drawViewport = this.viewport.clone({
							scale: DRAW_UPSCALE_FACTOR * this.scale
						});

						var renderContinueCallback =
							function renderContinueCallback(cont) {
								if (!_this.renderingQueue.isHighestPriority(
									_this)) {
									_this.renderingState = _ui_utils.RenderingStates
										.PAUSED;

									_this.resume = function() {
										_this.renderingState = _ui_utils
											.RenderingStates.RUNNING;
										cont();
									};

									return;
								}

								cont();
							};

						var renderContext = {
							canvasContext: ctx,
							transform: transform,
							viewport: drawViewport,
							optionalContentConfigPromise: this
								._optionalContentConfigPromise
						};
						var renderTask = this.renderTask = pdfPage.render(
							renderContext);
						renderTask.onContinue = renderContinueCallback;
						var resultPromise = renderTask.promise.then(function() {
							return finishRenderTask(null);
						}, function(error) {
							return finishRenderTask(error);
						});
						resultPromise["finally"](function() {
							canvas.width = 0;
							canvas.height = 0;

							var pageCached = _this.linkService.isPageCached(
								_this.id);

							if (!pageCached) {
								var _this$pdfPage;

								(_this$pdfPage = _this.pdfPage) === null ||
									_this$pdfPage === void 0 ? void 0 :
									_this$pdfPage.cleanup();
							}
						});
						return resultPromise;
					}
				}, {
					key: "setImage",
					value: function setImage(pageView) {
						if (this._checkSetImageDisabled()) {
							return;
						}

						if (this.renderingState !== _ui_utils.RenderingStates
							.INITIAL) {
							return;
						}

						var canvas = pageView.canvas,
							pdfPage = pageView.pdfPage;

						if (!canvas) {
							return;
						}

						if (!this.pdfPage) {
							this.setPdfPage(pdfPage);
						}

						this.renderingState = _ui_utils.RenderingStates.FINISHED;

						this._convertCanvasToImage(canvas);
					}
				}, {
					key: "_reduceImage",
					value: function _reduceImage(img) {
						var _this$_getPageDrawCon2 = this._getPageDrawContext(),
							ctx = _this$_getPageDrawCon2.ctx,
							canvas = _this$_getPageDrawCon2.canvas;

						if (img.width <= 2 * canvas.width) {
							ctx.drawImage(img, 0, 0, img.width, img.height, 0, 0,
								canvas.width, canvas.height);
							return canvas;
						}

						var reducedWidth = canvas.width << MAX_NUM_SCALING_STEPS;
						var reducedHeight = canvas.height << MAX_NUM_SCALING_STEPS;

						var _TempImageFactory$get = TempImageFactory.getCanvas(
								reducedWidth, reducedHeight),
							_TempImageFactory$get2 = _slicedToArray(
								_TempImageFactory$get, 2),
							reducedImage = _TempImageFactory$get2[0],
							reducedImageCtx = _TempImageFactory$get2[1];

						while (reducedWidth > img.width || reducedHeight > img
							.height) {
							reducedWidth >>= 1;
							reducedHeight >>= 1;
						}

						reducedImageCtx.drawImage(img, 0, 0, img.width, img.height,
							0, 0, reducedWidth, reducedHeight);

						while (reducedWidth > 2 * canvas.width) {
							reducedImageCtx.drawImage(reducedImage, 0, 0,
								reducedWidth, reducedHeight, 0, 0,
								reducedWidth >> 1, reducedHeight >> 1);
							reducedWidth >>= 1;
							reducedHeight >>= 1;
						}

						ctx.drawImage(reducedImage, 0, 0, reducedWidth,
							reducedHeight, 0, 0, canvas.width, canvas.height);
						return canvas;
					}
				}, {
					key: "_thumbPageTitle",
					get: function get() {
						var _this$pageLabel;

						return this.l10n.get("thumb_page_title", {
							page: (_this$pageLabel = this.pageLabel) !==
								null && _this$pageLabel !== void 0 ?
								_this$pageLabel : this.id
						});
					}
				}, {
					key: "_thumbPageCanvas",
					get: function get() {
						var _this$pageLabel2;

						return this.l10n.get("thumb_page_canvas", {
							page: (_this$pageLabel2 = this.pageLabel) !==
								null && _this$pageLabel2 !== void 0 ?
								_this$pageLabel2 : this.id
						});
					}
				}, {
					key: "setPageLabel",
					value: function setPageLabel(label) {
						var _this2 = this;

						this.pageLabel = typeof label === "string" ? label : null;

						this._thumbPageTitle.then(function(msg) {
							_this2.anchor.title = msg;
						});

						if (this.renderingState !== _ui_utils.RenderingStates
							.FINISHED) {
							return;
						}

						this._thumbPageCanvas.then(function(msg) {
							var _this2$image;

							(_this2$image = _this2.image) === null ||
								_this2$image === void 0 ? void 0 :
								_this2$image.setAttribute("aria-label",
								msg);
						});
					}
				}]);

				return PDFThumbnailView;
			}();

			exports.PDFThumbnailView = PDFThumbnailView;

			/***/
		}),
		/* 29 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



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

			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFViewer = exports.PDFSinglePageViewer = void 0;

			var _ui_utils = __webpack_require__(5);

			var _base_viewer = __webpack_require__(30);

			function _get() {
				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(arguments.length < 3 ? target : receiver);
						}
						return desc.value;
					};
				}
				return _get.apply(this, arguments);
			}

			function _superPropBase(object, property) {
				while (!Object.prototype.hasOwnProperty.call(object, property)) {
					object = _getPrototypeOf(object);
					if (object === null) break;
				}
				return object;
			}

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

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

			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
					}
				});
				Object.defineProperty(subClass, "prototype", {
					writable: false
				});
				if (superClass) _setPrototypeOf(subClass, superClass);
			}

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

			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);
				};
			}

			function _possibleConstructorReturn(self, call) {
				if (call && (_typeof(call) === "object" || typeof call === "function")) {
					return call;
				} else if (call !== void 0) {
					throw new TypeError("Derived constructors may only return object or undefined");
				}
				return _assertThisInitialized(self);
			}

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

			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;
				}
			}

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

			var PDFViewer = /*#__PURE__*/ function(_BaseViewer) {
				_inherits(PDFViewer, _BaseViewer);

				var _super = _createSuper(PDFViewer);

				function PDFViewer() {
					_classCallCheck(this, PDFViewer);

					return _super.apply(this, arguments);
				}

				return _createClass(PDFViewer);
			}(_base_viewer.BaseViewer);

			exports.PDFViewer = PDFViewer;

			var PDFSinglePageViewer = /*#__PURE__*/ function(_BaseViewer2) {
				_inherits(PDFSinglePageViewer, _BaseViewer2);

				var _super2 = _createSuper(PDFSinglePageViewer);

				function PDFSinglePageViewer() {
					_classCallCheck(this, PDFSinglePageViewer);

					return _super2.apply(this, arguments);
				}

				_createClass(PDFSinglePageViewer, [{
					key: "_resetView",
					value: function _resetView() {
						_get(_getPrototypeOf(PDFSinglePageViewer.prototype),
							"_resetView", this).call(this);

						this._scrollMode = _ui_utils.ScrollMode.PAGE;
						this._spreadMode = _ui_utils.SpreadMode.NONE;
					}
				}, {
					key: "scrollMode",
					set: function set(mode) {}
				}, {
					key: "_updateScrollMode",
					value: function _updateScrollMode() {}
				}, {
					key: "spreadMode",
					set: function set(mode) {}
				}, {
					key: "_updateSpreadMode",
					value: function _updateSpreadMode() {}
				}]);

				return PDFSinglePageViewer;
			}(_base_viewer.BaseViewer);

			exports.PDFSinglePageViewer = PDFSinglePageViewer;

			/***/
		}),
		/* 30 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PagesCountLimit = exports.PDFPageViewBuffer = exports.BaseViewer = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _pdfjsLib = __webpack_require__(7);

			var _ui_utils = __webpack_require__(5);

			var _annotation_layer_builder = __webpack_require__(31);

			var _l10n_utils = __webpack_require__(32);

			var _pdf_page_view = __webpack_require__(33);

			var _pdf_rendering_queue = __webpack_require__(23);

			var _pdf_link_service = __webpack_require__(10);

			var _struct_tree_layer_builder = __webpack_require__(34);

			var _text_highlighter = __webpack_require__(35);

			var _text_layer_builder = __webpack_require__(36);

			var _xfa_layer_builder = __webpack_require__(37);

			var _Symbol$iterator;

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

			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);
				}
			}

			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);
					});
				};
			}

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

			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."
					);
			}

			function _iterableToArrayLimit(arr, i) {
				var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] ||
					arr["@@iterator"];
				if (_i == null) return;
				var _arr = [];
				var _n = true;
				var _d = false;
				var _s, _e;
				try {
					for (_i = _i.call(arr); !(_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;
			}

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

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

			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);
			}

			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;
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			function _classPrivateMethodInitSpec(obj, privateSet) {
				_checkPrivateRedeclaration(obj, privateSet);
				privateSet.add(obj);
			}

			function _classPrivateFieldInitSpec(obj, privateMap, value) {
				_checkPrivateRedeclaration(obj, privateMap);
				privateMap.set(obj, value);
			}

			function _checkPrivateRedeclaration(obj, privateCollection) {
				if (privateCollection.has(obj)) {
					throw new TypeError(
						"Cannot initialize the same private elements twice on an object");
				}
			}

			function _classPrivateMethodGet(receiver, privateSet, fn) {
				if (!privateSet.has(receiver)) {
					throw new TypeError("attempted to get private field on non-instance");
				}
				return fn;
			}

			function _classPrivateFieldGet(receiver, privateMap) {
				var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get");
				return _classApplyDescriptorGet(receiver, descriptor);
			}

			function _classApplyDescriptorGet(receiver, descriptor) {
				if (descriptor.get) {
					return descriptor.get.call(receiver);
				}
				return descriptor.value;
			}

			function _classPrivateFieldSet(receiver, privateMap, value) {
				var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set");
				_classApplyDescriptorSet(receiver, descriptor, value);
				return value;
			}

			function _classExtractFieldDescriptor(receiver, privateMap, action) {
				if (!privateMap.has(receiver)) {
					throw new TypeError("attempted to " + action + " private field on non-instance");
				}
				return privateMap.get(receiver);
			}

			function _classApplyDescriptorSet(receiver, descriptor, value) {
				if (descriptor.set) {
					descriptor.set.call(receiver, value);
				} else {
					if (!descriptor.writable) {
						throw new TypeError("attempted to set read only private field");
					}
					descriptor.value = value;
				}
			}

			var DEFAULT_CACHE_SIZE = 10;
			var ENABLE_PERMISSIONS_CLASS = "enablePermissions";
			var PagesCountLimit = {
				FORCE_SCROLL_MODE_PAGE: 15000,
				FORCE_LAZY_PAGE_INIT: 7500,
				PAUSE_EAGER_PAGE_INIT: 250
			};
			exports.PagesCountLimit = PagesCountLimit;

			var _buf = /*#__PURE__*/ new WeakMap();

			var _size = /*#__PURE__*/ new WeakMap();

			var _destroyFirstView = /*#__PURE__*/ new WeakSet();

			_Symbol$iterator = Symbol.iterator;

			var PDFPageViewBuffer = /*#__PURE__*/ function() {
				function PDFPageViewBuffer(size) {
					_classCallCheck(this, PDFPageViewBuffer);

					_classPrivateMethodInitSpec(this, _destroyFirstView);

					_classPrivateFieldInitSpec(this, _buf, {
						writable: true,
						value: new Set()
					});

					_classPrivateFieldInitSpec(this, _size, {
						writable: true,
						value: 0
					});

					_classPrivateFieldSet(this, _size, size);
				}

				_createClass(PDFPageViewBuffer, [{
					key: "push",
					value: function push(view) {
						var buf = _classPrivateFieldGet(this, _buf);

						if (buf.has(view)) {
							buf["delete"](view);
						}

						buf.add(view);

						if (buf.size > _classPrivateFieldGet(this, _size)) {
							_classPrivateMethodGet(this, _destroyFirstView,
								_destroyFirstView2).call(this);
						}
					}
				}, {
					key: "resize",
					value: function resize(newSize) {
						var idsToKeep = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : null;

						_classPrivateFieldSet(this, _size, newSize);

						var buf = _classPrivateFieldGet(this, _buf);

						if (idsToKeep) {
							var ii = buf.size;
							var i = 1;

							var _iterator = _createForOfIteratorHelper(buf),
								_step;

							try {
								for (_iterator.s(); !(_step = _iterator.n())
									.done;) {
									var view = _step.value;

									if (idsToKeep.has(view.id)) {
										buf["delete"](view);
										buf.add(view);
									}

									if (++i > ii) {
										break;
									}
								}
							} catch (err) {
								_iterator.e(err);
							} finally {
								_iterator.f();
							}
						}

						while (buf.size > _classPrivateFieldGet(this, _size)) {
							_classPrivateMethodGet(this, _destroyFirstView,
								_destroyFirstView2).call(this);
						}
					}
				}, {
					key: "has",
					value: function has(view) {
						return _classPrivateFieldGet(this, _buf).has(view);
					}
				}, {
					key: _Symbol$iterator,
					value: function value() {
						return _classPrivateFieldGet(this, _buf).keys();
					}
				}]);

				return PDFPageViewBuffer;
			}();

			exports.PDFPageViewBuffer = PDFPageViewBuffer;

			function _destroyFirstView2() {
				var firstView = _classPrivateFieldGet(this, _buf).keys().next().value;

				firstView === null || firstView === void 0 ? void 0 : firstView.destroy();

				_classPrivateFieldGet(this, _buf)["delete"](firstView);
			}

			var _buffer = /*#__PURE__*/ new WeakMap();

			var _annotationMode = /*#__PURE__*/ new WeakMap();

			var _previousAnnotationMode = /*#__PURE__*/ new WeakMap();

			var _enablePermissions = /*#__PURE__*/ new WeakMap();

			var _previousContainerHeight = /*#__PURE__*/ new WeakMap();

			var _scrollModePageState = /*#__PURE__*/ new WeakMap();

			var _onVisibilityChange = /*#__PURE__*/ new WeakMap();

			var _initializePermissions = /*#__PURE__*/ new WeakSet();

			var _onePageRenderedOrForceFetch = /*#__PURE__*/ new WeakSet();

			var _ensurePageViewVisible = /*#__PURE__*/ new WeakSet();

			var _isSameScale = /*#__PURE__*/ new WeakSet();

			var _ensurePdfPageLoaded = /*#__PURE__*/ new WeakSet();

			var _getScrollAhead = /*#__PURE__*/ new WeakSet();

			var _toggleLoadingIconSpinner = /*#__PURE__*/ new WeakSet();

			var BaseViewer = /*#__PURE__*/ function() {
				function BaseViewer(options) {
					var _this$container,
						_this$viewer,
						_options$textLayerMod,
						_options$annotationMo,
						_this = this;

					_classCallCheck(this, BaseViewer);

					_classPrivateMethodInitSpec(this, _toggleLoadingIconSpinner);

					_classPrivateMethodInitSpec(this, _getScrollAhead);

					_classPrivateMethodInitSpec(this, _ensurePdfPageLoaded);

					_classPrivateMethodInitSpec(this, _isSameScale);

					_classPrivateMethodInitSpec(this, _ensurePageViewVisible);

					_classPrivateMethodInitSpec(this, _onePageRenderedOrForceFetch);

					_classPrivateMethodInitSpec(this, _initializePermissions);

					_classPrivateFieldInitSpec(this, _buffer, {
						writable: true,
						value: null
					});

					_classPrivateFieldInitSpec(this, _annotationMode, {
						writable: true,
						value: _pdfjsLib.AnnotationMode.ENABLE_FORMS
					});

					_classPrivateFieldInitSpec(this, _previousAnnotationMode, {
						writable: true,
						value: null
					});

					_classPrivateFieldInitSpec(this, _enablePermissions, {
						writable: true,
						value: false
					});

					_classPrivateFieldInitSpec(this, _previousContainerHeight, {
						writable: true,
						value: 0
					});

					_classPrivateFieldInitSpec(this, _scrollModePageState, {
						writable: true,
						value: null
					});

					_classPrivateFieldInitSpec(this, _onVisibilityChange, {
						writable: true,
						value: null
					});

					if (this.constructor === BaseViewer) {
						throw new Error("Cannot initialize BaseViewer.");
					}

					var viewerVersion = '2.13.216';

					if (_pdfjsLib.version !== viewerVersion) {
						throw new Error("The API version \"".concat(_pdfjsLib.version,
							"\" does not match the Viewer version \"").concat(viewerVersion,
							"\"."));
					}

					this.container = options.container;
					this.viewer = options.viewer || options.container.firstElementChild;

					if (!(((_this$container = this.container) === null || _this$container ===
								void 0 ? void 0 : _this$container.tagName.toUpperCase()) ===
							"DIV" && ((_this$viewer = this.viewer) === null || _this$viewer ===
								void 0 ? void 0 : _this$viewer.tagName.toUpperCase()) === "DIV")) {
						throw new Error("Invalid `container` and/or `viewer` option.");
					}

					if (this.container.offsetParent && getComputedStyle(this.container).position !==
						"absolute") {
						throw new Error("The `container` must be absolutely positioned.");
					}

					this.eventBus = options.eventBus;
					this.linkService = options.linkService || new _pdf_link_service
						.SimpleLinkService();
					this.downloadManager = options.downloadManager || null;
					this.findController = options.findController || null;
					this._scriptingManager = options.scriptingManager || null;
					this.removePageBorders = options.removePageBorders || false;
					this.textLayerMode = (_options$textLayerMod = options.textLayerMode) !== null &&
						_options$textLayerMod !== void 0 ? _options$textLayerMod : _ui_utils
						.TextLayerMode.ENABLE;

					_classPrivateFieldSet(this, _annotationMode, (_options$annotationMo = options
							.annotationMode) !== null && _options$annotationMo !== void 0 ?
						_options$annotationMo : _pdfjsLib.AnnotationMode.ENABLE_FORMS);

					this.imageResourcesPath = options.imageResourcesPath || "";
					this.enablePrintAutoRotate = options.enablePrintAutoRotate || false;
					this.renderer = options.renderer || _ui_utils.RendererType.CANVAS;
					this.useOnlyCssZoom = options.useOnlyCssZoom || false;
					this.maxCanvasPixels = options.maxCanvasPixels;
					this.l10n = options.l10n || _l10n_utils.NullL10n;

					_classPrivateFieldSet(this, _enablePermissions, options.enablePermissions ||
						false);

					this.defaultRenderingQueue = !options.renderingQueue;

					if (this.defaultRenderingQueue) {
						this.renderingQueue = new _pdf_rendering_queue.PDFRenderingQueue();
						this.renderingQueue.setViewer(this);
					} else {
						this.renderingQueue = options.renderingQueue;
					}

					this._doc = document.documentElement;
					this.scroll = (0, _ui_utils.watchScroll)(this.container, this._scrollUpdate
						.bind(this));
					this.presentationModeState = _ui_utils.PresentationModeState.UNKNOWN;
					this._onBeforeDraw = this._onAfterDraw = null;

					this._resetView();

					if (this.removePageBorders) {
						this.viewer.classList.add("removePageBorders");
					}

					Promise.resolve().then(function() {
						_this.eventBus.dispatch("baseviewerinit", {
							source: _this
						});
					});
				}

				_createClass(BaseViewer, [{
					key: "pagesCount",
					get: function get() {
						return this._pages.length;
					}
				}, {
					key: "getPageView",
					value: function getPageView(index) {
						return this._pages[index];
					}
				}, {
					key: "pageViewsReady",
					get: function get() {
						if (!this._pagesCapability.settled) {
							return false;
						}

						return this._pages.every(function(pageView) {
							return pageView === null || pageView ===
								void 0 ? void 0 : pageView.pdfPage;
						});
					}
				}, {
					key: "renderForms",
					get: function get() {
						return _classPrivateFieldGet(this, _annotationMode) ===
							_pdfjsLib.AnnotationMode.ENABLE_FORMS;
					}
				}, {
					key: "enableScripting",
					get: function get() {
						return !!this._scriptingManager;
					}
				}, {
					key: "currentPageNumber",
					get: function get() {
						return this._currentPageNumber;
					},
					set: function set(val) {
						if (!Number.isInteger(val)) {
							throw new Error("Invalid page number.");
						}

						if (!this.pdfDocument) {
							return;
						}

						if (!this._setCurrentPageNumber(val, true)) {
							console.error("currentPageNumber: \"".concat(val,
								"\" is not a valid page."));
						}
					}
				}, {
					key: "_setCurrentPageNumber",
					value: function _setCurrentPageNumber(val) {
						var _this$_pageLabels, _this$_pageLabels2;

						var resetCurrentPageView = arguments.length > 1 &&
							arguments[1] !== undefined ? arguments[1] : false;

						if (this._currentPageNumber === val) {
							if (resetCurrentPageView) {
								this._resetCurrentPageView();
							}

							return true;
						}

						if (!(0 < val && val <= this.pagesCount)) {
							return false;
						}

						var previous = this._currentPageNumber;
						this._currentPageNumber = val;
						this.eventBus.dispatch("pagechanging", {
							source: this,
							pageNumber: val,
							pageLabel: (_this$_pageLabels = (
										_this$_pageLabels2 = this
										._pageLabels) === null ||
									_this$_pageLabels2 === void 0 ? void 0 :
									_this$_pageLabels2[val - 1]) !== null &&
								_this$_pageLabels !== void 0 ?
								_this$_pageLabels : null,
							previous: previous
						});

						if (resetCurrentPageView) {
							this._resetCurrentPageView();
						}

						return true;
					}
				}, {
					key: "currentPageLabel",
					get: function get() {
						var _this$_pageLabels3, _this$_pageLabels4;

						return (_this$_pageLabels3 = (_this$_pageLabels4 = this
									._pageLabels) === null || _this$_pageLabels4 ===
								void 0 ? void 0 : _this$_pageLabels4[this
									._currentPageNumber - 1]) !== null &&
							_this$_pageLabels3 !== void 0 ? _this$_pageLabels3 :
							null;
					},
					set: function set(val) {
						if (!this.pdfDocument) {
							return;
						}

						var page = val | 0;

						if (this._pageLabels) {
							var i = this._pageLabels.indexOf(val);

							if (i >= 0) {
								page = i + 1;
							}
						}

						if (!this._setCurrentPageNumber(page, true)) {
							console.error("currentPageLabel: \"".concat(val,
								"\" is not a valid page."));
						}
					}
				}, {
					key: "currentScale",
					get: function get() {
						return this._currentScale !== _ui_utils.UNKNOWN_SCALE ? this
							._currentScale : _ui_utils.DEFAULT_SCALE;
					},
					set: function set(val) {
						if (isNaN(val)) {
							throw new Error("Invalid numeric scale.");
						}

						if (!this.pdfDocument) {
							return;
						}

						this._setScale(val, false);
					}
				}, {
					key: "currentScaleValue",
					get: function get() {
						return this._currentScaleValue;
					},
					set: function set(val) {
						if (!this.pdfDocument) {
							return;
						}

						this._setScale(val, false);
					}
				}, {
					key: "pagesRotation",
					get: function get() {
						return this._pagesRotation;
					},
					set: function set(rotation) {
						if (!(0, _ui_utils.isValidRotation)(rotation)) {
							throw new Error("Invalid pages rotation angle.");
						}

						if (!this.pdfDocument) {
							return;
						}

						rotation %= 360;

						if (rotation < 0) {
							rotation += 360;
						}

						if (this._pagesRotation === rotation) {
							return;
						}

						this._pagesRotation = rotation;
						var pageNumber = this._currentPageNumber;
						var updateArgs = {
							rotation: rotation
						};

						var _iterator2 = _createForOfIteratorHelper(this._pages),
							_step2;

						try {
							for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
								var pageView = _step2.value;
								pageView.update(updateArgs);
							}
						} catch (err) {
							_iterator2.e(err);
						} finally {
							_iterator2.f();
						}

						if (this._currentScaleValue) {
							this._setScale(this._currentScaleValue, true);
						}

						this.eventBus.dispatch("rotationchanging", {
							source: this,
							pagesRotation: rotation,
							pageNumber: pageNumber
						});

						if (this.defaultRenderingQueue) {
							this.update();
						}
					}
				}, {
					key: "firstPagePromise",
					get: function get() {
						return this.pdfDocument ? this._firstPageCapability
							.promise : null;
					}
				}, {
					key: "onePageRendered",
					get: function get() {
						return this.pdfDocument ? this._onePageRenderedCapability
							.promise : null;
					}
				}, {
					key: "pagesPromise",
					get: function get() {
						return this.pdfDocument ? this._pagesCapability.promise :
							null;
					}
				}, {
					key: "setDocument",
					value: function setDocument(pdfDocument) {
						var _this2 = this;

						if (this.pdfDocument) {
							this.eventBus.dispatch("pagesdestroy", {
								source: this
							});

							this._cancelRendering();

							this._resetView();

							if (this.findController) {
								this.findController.setDocument(null);
							}

							if (this._scriptingManager) {
								this._scriptingManager.setDocument(null);
							}
						}

						this.pdfDocument = pdfDocument;

						if (!pdfDocument) {
							return;
						}

						var isPureXfa = pdfDocument.isPureXfa;
						var pagesCount = pdfDocument.numPages;
						var firstPagePromise = pdfDocument.getPage(1);
						var optionalContentConfigPromise = pdfDocument
							.getOptionalContentConfig();
						var permissionsPromise = _classPrivateFieldGet(this,
								_enablePermissions) ? pdfDocument.getPermissions() :
							Promise.resolve();

						if (pagesCount > PagesCountLimit.FORCE_SCROLL_MODE_PAGE) {
							console.warn(
								"Forcing PAGE-scrolling for performance reasons, given the length of the document."
								);
							var mode = this._scrollMode = _ui_utils.ScrollMode.PAGE;
							this.eventBus.dispatch("scrollmodechanged", {
								source: this,
								mode: mode
							});
						}

						this._pagesCapability.promise.then(function() {
							_this2.eventBus.dispatch("pagesloaded", {
								source: _this2,
								pagesCount: pagesCount
							});
						}, function() {});

						this._onBeforeDraw = function(evt) {
							var pageView = _this2._pages[evt.pageNumber - 1];

							if (!pageView) {
								return;
							}

							_classPrivateFieldGet(_this2, _buffer).push(
								pageView);
						};

						this.eventBus._on("pagerender", this._onBeforeDraw);

						this._onAfterDraw = function(evt) {
							if (evt.cssTransform || _this2
								._onePageRenderedCapability.settled) {
								return;
							}

							_this2._onePageRenderedCapability.resolve({
								timestamp: evt.timestamp
							});

							_this2.eventBus._off("pagerendered", _this2
								._onAfterDraw);

							_this2._onAfterDraw = null;

							if (_classPrivateFieldGet(_this2,
									_onVisibilityChange)) {
								document.removeEventListener("visibilitychange",
									_classPrivateFieldGet(_this2,
										_onVisibilityChange));

								_classPrivateFieldSet(_this2,
									_onVisibilityChange, null);
							}
						};

						this.eventBus._on("pagerendered", this._onAfterDraw);

						Promise.all([firstPagePromise, permissionsPromise]).then(
							function(_ref) {
								var _ref2 = _slicedToArray(_ref, 2),
									firstPdfPage = _ref2[0],
									permissions = _ref2[1];

								if (pdfDocument !== _this2.pdfDocument) {
									return;
								}

								_this2._firstPageCapability.resolve(
									firstPdfPage);

								_this2._optionalContentConfigPromise =
									optionalContentConfigPromise;

								_classPrivateMethodGet(_this2,
									_initializePermissions,
									_initializePermissions2).call(_this2,
									permissions);

								var viewerElement = _this2._scrollMode ===
									_ui_utils.ScrollMode.PAGE ? null : _this2
									.viewer;
								var scale = _this2.currentScale;
								var viewport = firstPdfPage.getViewport({
									scale: scale * _pdfjsLib
										.PixelsPerInch.PDF_TO_CSS_UNITS
								});
								var textLayerFactory = _this2.textLayerMode !==
									_ui_utils.TextLayerMode.DISABLE && !
									isPureXfa ? _this2 : null;
								var annotationLayerFactory =
									_classPrivateFieldGet(_this2,
										_annotationMode) !== _pdfjsLib
									.AnnotationMode.DISABLE ? _this2 : null;
								var xfaLayerFactory = isPureXfa ? _this2 : null;

								for (var pageNum = 1; pageNum <= pagesCount; ++
									pageNum) {
									var pageView = new _pdf_page_view
										.PDFPageView({
											container: viewerElement,
											eventBus: _this2.eventBus,
											id: pageNum,
											scale: scale,
											defaultViewport: viewport
											.clone(),
											optionalContentConfigPromise: optionalContentConfigPromise,
											renderingQueue: _this2
												.renderingQueue,
											textLayerFactory: textLayerFactory,
											textLayerMode: _this2
												.textLayerMode,
											annotationLayerFactory: annotationLayerFactory,
											annotationMode: _classPrivateFieldGet(
													_this2, _annotationMode
													),
											xfaLayerFactory: xfaLayerFactory,
											textHighlighterFactory: _this2,
											structTreeLayerFactory: _this2,
											imageResourcesPath: _this2
												.imageResourcesPath,
											renderer: _this2.renderer,
											useOnlyCssZoom: _this2
												.useOnlyCssZoom,
											maxCanvasPixels: _this2
												.maxCanvasPixels,
											l10n: _this2.l10n
										});

									_this2._pages.push(pageView);
								}

								var firstPageView = _this2._pages[0];

								if (firstPageView) {
									firstPageView.setPdfPage(firstPdfPage);

									_this2.linkService.cachePageRef(1,
										firstPdfPage.ref);
								}

								if (_this2._scrollMode === _ui_utils.ScrollMode
									.PAGE) {
									_classPrivateMethodGet(_this2,
										_ensurePageViewVisible,
										_ensurePageViewVisible2).call(
										_this2);
								} else if (_this2._spreadMode !== _ui_utils
									.SpreadMode.NONE) {
									_this2._updateSpreadMode();
								}

								_classPrivateMethodGet(_this2,
									_onePageRenderedOrForceFetch,
									_onePageRenderedOrForceFetch2).call(
									_this2).then( /*#__PURE__*/
									_asyncToGenerator( /*#__PURE__*/
										_regenerator["default"].mark(
											function _callee() {
												var getPagesLeft, _loop,
													_pageNum;

												return _regenerator[
													"default"].wrap(
													function _callee$(
														_context2) {
														while (1) {
															switch (
																_context2
																.prev =
																_context2
																.next) {
																case 0:
																	if (_this2
																		.findController
																		) {
																		_this2
																			.findController
																			.setDocument(
																				pdfDocument
																				);
																	}

																	if (_this2
																		._scriptingManager
																		) {
																		_this2
																			._scriptingManager
																			.setDocument(
																				pdfDocument
																				);
																	}

																	if (!
																		(pdfDocument
																			.loadingParams
																			.disableAutoFetch ||
																			pagesCount >
																			PagesCountLimit
																			.FORCE_LAZY_PAGE_INIT
																			)
																		) {
																		_context2
																			.next =
																			5;
																		break;
																	}

																	_this2
																		._pagesCapability
																		.resolve();

																	return _context2
																		.abrupt(
																			"return"
																			);

																case 5:
																	getPagesLeft
																		=
																		pagesCount -
																		1;

																	if (!
																		(getPagesLeft <=
																			0
																			)
																		) {
																		_context2
																			.next =
																			9;
																		break;
																	}

																	_this2
																		._pagesCapability
																		.resolve();

																	return _context2
																		.abrupt(
																			"return"
																			);

																case 9:
																	_loop
																		= /*#__PURE__*/
																		_regenerator[
																			"default"
																			]
																		.mark(
																			function _loop(
																				_pageNum
																				) {
																				var
																				promise;
																				return _regenerator[
																						"default"
																						]
																					.wrap(
																						function _loop$(
																							_context
																							) {
																							while (
																								1
																								) {
																								switch (
																									_context
																									.prev =
																									_context
																									.next
																									) {
																									case 0:
																										promise
																											=
																											pdfDocument
																											.getPage(
																												_pageNum
																												)
																											.then(
																												function(
																													pdfPage
																													) {
																													var pageView =
																														_this2
																														._pages[
																															_pageNum -
																															1
																															];

																													if (!
																														pageView
																														.pdfPage
																														) {
																														pageView
																															.setPdfPage(
																																pdfPage
																																);
																													}

																													_this2
																														.linkService
																														.cachePageRef(
																															_pageNum,
																															pdfPage
																															.ref
																															);

																													if (--
																														getPagesLeft ===
																														0
																														) {
																														_this2
																															._pagesCapability
																															.resolve();
																													}
																												},
																												function(
																													reason
																													) {
																													console
																														.error(
																															"Unable to get page "
																															.concat(
																																_pageNum,
																																" to initialize viewer"
																																),
																															reason
																															);

																													if (--
																														getPagesLeft ===
																														0
																														) {
																														_this2
																															._pagesCapability
																															.resolve();
																													}
																												}
																												);

																										if (!
																											(_pageNum %
																												PagesCountLimit
																												.PAUSE_EAGER_PAGE_INIT ===
																												0
																												)
																											) {
																											_context
																												.next =
																												4;
																											break;
																										}

																										_context
																											.next =
																											4;
																										return promise;

																									case 4:
																									case "end":
																										return _context
																											.stop();
																								}
																							}
																						},
																						_loop
																						);
																			}
																			);
																	_pageNum
																		=
																		2;

																case 11:
																	if (!
																		(_pageNum <=
																			pagesCount
																			)
																		) {
																		_context2
																			.next =
																			16;
																		break;
																	}

																	return _context2
																		.delegateYield(
																			_loop(
																				_pageNum
																				),
																			"t0",
																			13
																			);

																case 13:
																	++
																	_pageNum
																	;
																	_context2
																		.next =
																		11;
																	break;

																case 16:
																case "end":
																	return _context2
																		.stop();
															}
														}
													}, _callee);
											})));

								_this2.eventBus.dispatch("pagesinit", {
									source: _this2
								});

								pdfDocument.getMetadata().then(function(_ref4) {
									var info = _ref4.info;

									if (pdfDocument !== _this2
										.pdfDocument) {
										return;
									}

									if (info.Language) {
										_this2.viewer.lang = info
											.Language;
									}
								});

								if (_this2.defaultRenderingQueue) {
									_this2.update();
								}
							})["catch"](function(reason) {
							console.error("Unable to initialize viewer",
								reason);

							_this2._pagesCapability.reject(reason);
						});
					}
				}, {
					key: "setPageLabels",
					value: function setPageLabels(labels) {
						if (!this.pdfDocument) {
							return;
						}

						if (!labels) {
							this._pageLabels = null;
						} else if (!(Array.isArray(labels) && this.pdfDocument
								.numPages === labels.length)) {
							this._pageLabels = null;
							console.error("setPageLabels: Invalid page labels.");
						} else {
							this._pageLabels = labels;
						}

						for (var i = 0, ii = this._pages.length; i < ii; i++) {
							var _this$_pageLabels$i, _this$_pageLabels5;

							this._pages[i].setPageLabel((_this$_pageLabels$i = (
										_this$_pageLabels5 = this._pageLabels
										) === null || _this$_pageLabels5 ===
									void 0 ? void 0 : _this$_pageLabels5[i]) !==
								null && _this$_pageLabels$i !== void 0 ?
								_this$_pageLabels$i : null);
						}
					}
				}, {
					key: "_resetView",
					value: function _resetView() {
						this._pages = [];
						this._currentPageNumber = 1;
						this._currentScale = _ui_utils.UNKNOWN_SCALE;
						this._currentScaleValue = null;
						this._pageLabels = null;

						_classPrivateFieldSet(this, _buffer, new PDFPageViewBuffer(
							DEFAULT_CACHE_SIZE));

						this._location = null;
						this._pagesRotation = 0;
						this._optionalContentConfigPromise = null;
						this._firstPageCapability = (0, _pdfjsLib
							.createPromiseCapability)();
						this._onePageRenderedCapability = (0, _pdfjsLib
							.createPromiseCapability)();
						this._pagesCapability = (0, _pdfjsLib
							.createPromiseCapability)();
						this._scrollMode = _ui_utils.ScrollMode.VERTICAL;
						this._previousScrollMode = _ui_utils.ScrollMode.UNKNOWN;
						this._spreadMode = _ui_utils.SpreadMode.NONE;

						_classPrivateFieldSet(this, _scrollModePageState, {
							previousPageNumber: 1,
							scrollDown: true,
							pages: []
						});

						if (this._onBeforeDraw) {
							this.eventBus._off("pagerender", this._onBeforeDraw);

							this._onBeforeDraw = null;
						}

						if (this._onAfterDraw) {
							this.eventBus._off("pagerendered", this._onAfterDraw);

							this._onAfterDraw = null;
						}

						if (_classPrivateFieldGet(this, _onVisibilityChange)) {
							document.removeEventListener("visibilitychange",
								_classPrivateFieldGet(this, _onVisibilityChange)
								);

							_classPrivateFieldSet(this, _onVisibilityChange, null);
						}

						this.viewer.textContent = "";

						this._updateScrollMode();

						this.viewer.removeAttribute("lang");
						this.viewer.classList.remove(ENABLE_PERMISSIONS_CLASS);

						if (_classPrivateFieldGet(this, _previousAnnotationMode) !==
							null) {
							_classPrivateFieldSet(this, _annotationMode,
								_classPrivateFieldGet(this,
									_previousAnnotationMode));

							_classPrivateFieldSet(this, _previousAnnotationMode,
								null);
						}
					}
				}, {
					key: "_scrollUpdate",
					value: function _scrollUpdate() {
						if (this.pagesCount === 0) {
							return;
						}

						this.update();
					}
				}, {
					key: "_scrollIntoView",
					value: function _scrollIntoView(_ref5) {
						var pageDiv = _ref5.pageDiv,
							_ref5$pageSpot = _ref5.pageSpot,
							pageSpot = _ref5$pageSpot === void 0 ? null :
							_ref5$pageSpot,
							_ref5$pageNumber = _ref5.pageNumber,
							pageNumber = _ref5$pageNumber === void 0 ? null :
							_ref5$pageNumber;

						if (this._scrollMode === _ui_utils.ScrollMode.PAGE) {
							if (pageNumber) {
								this._setCurrentPageNumber(pageNumber);
							}

							_classPrivateMethodGet(this, _ensurePageViewVisible,
								_ensurePageViewVisible2).call(this);

							this.update();
						}

						if (!pageSpot && !this.isInPresentationMode) {
							var left = pageDiv.offsetLeft + pageDiv.clientLeft;
							var right = left + pageDiv.clientWidth;
							var _this$container2 = this.container,
								scrollLeft = _this$container2.scrollLeft,
								clientWidth = _this$container2.clientWidth;

							if (this._scrollMode === _ui_utils.ScrollMode
								.HORIZONTAL || left < scrollLeft || right >
								scrollLeft + clientWidth) {
								pageSpot = {
									left: 0,
									top: 0
								};
							}
						}

						(0, _ui_utils.scrollIntoView)(pageDiv, pageSpot);
					}
				}, {
					key: "_setScaleUpdatePages",
					value: function _setScaleUpdatePages(newScale, newValue) {
						var noScroll = arguments.length > 2 && arguments[2] !==
							undefined ? arguments[2] : false;
						var preset = arguments.length > 3 && arguments[3] !==
							undefined ? arguments[3] : false;
						this._currentScaleValue = newValue.toString();

						if (_classPrivateMethodGet(this, _isSameScale,
								_isSameScale2).call(this, newScale)) {
							if (preset) {
								this.eventBus.dispatch("scalechanging", {
									source: this,
									scale: newScale,
									presetValue: newValue
								});
							}

							return;
						}

						this._doc.style.setProperty("--zoom-factor", newScale);

						this._doc.style.setProperty("--viewport-scale-factor",
							newScale * _pdfjsLib.PixelsPerInch.PDF_TO_CSS_UNITS);

						var updateArgs = {
							scale: newScale
						};

						var _iterator3 = _createForOfIteratorHelper(this._pages),
							_step3;

						try {
							for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
								var pageView = _step3.value;
								pageView.update(updateArgs);
							}
						} catch (err) {
							_iterator3.e(err);
						} finally {
							_iterator3.f();
						}

						this._currentScale = newScale;

						if (!noScroll) {
							var page = this._currentPageNumber,
								dest;

							if (this._location && !(this.isInPresentationMode ||
									this.isChangingPresentationMode)) {
								page = this._location.pageNumber;
								dest = [null, {
										name: "XYZ"
									}, this._location.left, this._location.top,
									null
								];
							}

							this.scrollPageIntoView({
								pageNumber: page,
								destArray: dest,
								allowNegativeOffset: true
							});
						}

						this.eventBus.dispatch("scalechanging", {
							source: this,
							scale: newScale,
							presetValue: preset ? newValue : undefined
						});

						if (this.defaultRenderingQueue) {
							this.update();
						}

						_classPrivateFieldSet(this, _previousContainerHeight, this
							.container.clientHeight);
					}
				}, {
					key: "_pageWidthScaleFactor",
					get: function get() {
						if (this._spreadMode !== _ui_utils.SpreadMode.NONE && this
							._scrollMode !== _ui_utils.ScrollMode.HORIZONTAL) {
							return 2;
						}

						return 1;
					}
				}, {
					key: "_setScale",
					value: function _setScale(value) {
						var noScroll = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : false;
						var scale = parseFloat(value);

						if (scale > 0) {
							this._setScaleUpdatePages(scale, value, noScroll,
							false);
						} else {
							var currentPage = this._pages[this._currentPageNumber -
								1];

							if (!currentPage) {
								return;
							}

							var hPadding = _ui_utils.SCROLLBAR_PADDING,
								vPadding = _ui_utils.VERTICAL_PADDING;

							if (this.isInPresentationMode) {
								hPadding = vPadding = 4;
							} else if (this.removePageBorders) {
								hPadding = vPadding = 0;
							}

							if (this._scrollMode === _ui_utils.ScrollMode
								.HORIZONTAL) {
								var _ref6 = [vPadding, hPadding];
								hPadding = _ref6[0];
								vPadding = _ref6[1];
							}

							var pageWidthScale = (this.container.clientWidth -
									hPadding) / currentPage.width * currentPage
								.scale / this._pageWidthScaleFactor;
							var pageHeightScale = (this.container.clientHeight -
									vPadding) / currentPage.height * currentPage
								.scale;

							switch (value) {
								case "page-actual":
									scale = 1;
									break;

								case "page-width":
									scale = pageWidthScale;
									break;

								case "page-height":
									scale = pageHeightScale;
									break;

								case "page-fit":
									scale = Math.min(pageWidthScale,
										pageHeightScale);
									break;

								case "auto":
									var horizontalScale = (0, _ui_utils
											.isPortraitOrientation)(currentPage) ?
										pageWidthScale : Math.min(pageHeightScale,
											pageWidthScale);
									scale = Math.min(_ui_utils.MAX_AUTO_SCALE,
										horizontalScale);
									break;

								default:
									console.error("_setScale: \"".concat(value,
										"\" is an unknown zoom value."));
									return;
							}

							this._setScaleUpdatePages(scale, value, noScroll, true);
						}
					}
				}, {
					key: "_resetCurrentPageView",
					value: function _resetCurrentPageView() {
						if (this.isInPresentationMode) {
							this._setScale(this._currentScaleValue, true);
						}

						var pageView = this._pages[this._currentPageNumber - 1];

						this._scrollIntoView({
							pageDiv: pageView.div
						});
					}
				}, {
					key: "pageLabelToPageNumber",
					value: function pageLabelToPageNumber(label) {
						if (!this._pageLabels) {
							return null;
						}

						var i = this._pageLabels.indexOf(label);

						if (i < 0) {
							return null;
						}

						return i + 1;
					}
				}, {
					key: "scrollPageIntoView",
					value: function scrollPageIntoView(_ref7) {
						var pageNumber = _ref7.pageNumber,
							_ref7$destArray = _ref7.destArray,
							destArray = _ref7$destArray === void 0 ? null :
							_ref7$destArray,
							_ref7$allowNegativeOf = _ref7.allowNegativeOffset,
							allowNegativeOffset = _ref7$allowNegativeOf === void 0 ?
							false : _ref7$allowNegativeOf,
							_ref7$ignoreDestinati = _ref7.ignoreDestinationZoom,
							ignoreDestinationZoom = _ref7$ignoreDestinati ===
							void 0 ? false : _ref7$ignoreDestinati;

						if (!this.pdfDocument) {
							return;
						}

						var pageView = Number.isInteger(pageNumber) && this._pages[
							pageNumber - 1];

						if (!pageView) {
							console.error("scrollPageIntoView: \"".concat(
								pageNumber,
								"\" is not a valid pageNumber parameter."));
							return;
						}

						if (this.isInPresentationMode || !destArray) {
							this._setCurrentPageNumber(pageNumber, true);

							return;
						}

						var x = 0,
							y = 0;
						var width = 0,
							height = 0,
							widthScale,
							heightScale;
						var changeOrientation = pageView.rotation % 180 !== 0;
						var pageWidth = (changeOrientation ? pageView.height :
								pageView.width) / pageView.scale / _pdfjsLib
							.PixelsPerInch.PDF_TO_CSS_UNITS;
						var pageHeight = (changeOrientation ? pageView.width :
								pageView.height) / pageView.scale / _pdfjsLib
							.PixelsPerInch.PDF_TO_CSS_UNITS;
						var scale = 0;

						switch (destArray[1].name) {
							case "XYZ":
								x = destArray[2];
								y = destArray[3];
								scale = destArray[4];
								x = x !== null ? x : 0;
								y = y !== null ? y : pageHeight;
								break;

							case "Fit":
							case "FitB":
								scale = "page-fit";
								break;

							case "FitH":
							case "FitBH":
								y = destArray[2];
								scale = "page-width";

								if (y === null && this._location) {
									x = this._location.left;
									y = this._location.top;
								} else if (typeof y !== "number" || y < 0) {
									y = pageHeight;
								}

								break;

							case "FitV":
							case "FitBV":
								x = destArray[2];
								width = pageWidth;
								height = pageHeight;
								scale = "page-height";
								break;

							case "FitR":
								x = destArray[2];
								y = destArray[3];
								width = destArray[4] - x;
								height = destArray[5] - y;
								var hPadding = this.removePageBorders ? 0 :
									_ui_utils.SCROLLBAR_PADDING;
								var vPadding = this.removePageBorders ? 0 :
									_ui_utils.VERTICAL_PADDING;
								widthScale = (this.container.clientWidth -
									hPadding) / width / _pdfjsLib.PixelsPerInch
									.PDF_TO_CSS_UNITS;
								heightScale = (this.container.clientHeight -
										vPadding) / height / _pdfjsLib.PixelsPerInch
									.PDF_TO_CSS_UNITS;
								scale = Math.min(Math.abs(widthScale), Math.abs(
									heightScale));
								break;

							default:
								console.error("scrollPageIntoView: \"".concat(
									destArray[1].name,
									"\" is not a valid destination type."));
								return;
						}

						if (!ignoreDestinationZoom) {
							if (scale && scale !== this._currentScale) {
								this.currentScaleValue = scale;
							} else if (this._currentScale === _ui_utils
								.UNKNOWN_SCALE) {
								this.currentScaleValue = _ui_utils
									.DEFAULT_SCALE_VALUE;
							}
						}

						if (scale === "page-fit" && !destArray[4]) {
							this._scrollIntoView({
								pageDiv: pageView.div,
								pageNumber: pageNumber
							});

							return;
						}

						var boundingRect = [pageView.viewport
							.convertToViewportPoint(x, y), pageView.viewport
							.convertToViewportPoint(x + width, y + height)
						];
						var left = Math.min(boundingRect[0][0], boundingRect[1][0]);
						var top = Math.min(boundingRect[0][1], boundingRect[1][1]);

						if (!allowNegativeOffset) {
							left = Math.max(left, 0);
							top = Math.max(top, 0);
						}

						this._scrollIntoView({
							pageDiv: pageView.div,
							pageSpot: {
								left: left,
								top: top
							},
							pageNumber: pageNumber
						});
					}
				}, {
					key: "_updateLocation",
					value: function _updateLocation(firstPage) {
						var currentScale = this._currentScale;
						var currentScaleValue = this._currentScaleValue;
						var normalizedScaleValue = parseFloat(currentScaleValue) ===
							currentScale ? Math.round(currentScale * 10000) / 100 :
							currentScaleValue;
						var pageNumber = firstPage.id;
						var pdfOpenParams = "#page=" + pageNumber;
						pdfOpenParams += "&zoom=" + normalizedScaleValue;
						var currentPageView = this._pages[pageNumber - 1];
						var container = this.container;
						var topLeft = currentPageView.getPagePoint(container
							.scrollLeft - firstPage.x, container.scrollTop -
							firstPage.y);
						var intLeft = Math.round(topLeft[0]);
						var intTop = Math.round(topLeft[1]);
						pdfOpenParams += "," + intLeft + "," + intTop;
						this._location = {
							pageNumber: pageNumber,
							scale: normalizedScaleValue,
							top: intTop,
							left: intLeft,
							rotation: this._pagesRotation,
							pdfOpenParams: pdfOpenParams
						};
					}
				}, {
					key: "update",
					value: function update() {
						var visible = this._getVisiblePages();

						var visiblePages = visible.views,
							numVisiblePages = visiblePages.length;

						if (numVisiblePages === 0) {
							return;
						}

						var newCacheSize = Math.max(DEFAULT_CACHE_SIZE, 2 *
							numVisiblePages + 1);

						_classPrivateFieldGet(this, _buffer).resize(newCacheSize,
							visible.ids);

						this.renderingQueue.renderHighestPriority(visible);

						if (!this.isInPresentationMode) {
							var isSimpleLayout = this._spreadMode === _ui_utils
								.SpreadMode.NONE && (this._scrollMode === _ui_utils
									.ScrollMode.PAGE || this._scrollMode ===
									_ui_utils.ScrollMode.VERTICAL);
							var currentId = this._currentPageNumber;
							var stillFullyVisible = false;

							var _iterator4 = _createForOfIteratorHelper(
									visiblePages),
								_step4;

							try {
								for (_iterator4.s(); !(_step4 = _iterator4.n())
									.done;) {
									var page = _step4.value;

									if (page.percent < 100) {
										break;
									}

									if (page.id === currentId && isSimpleLayout) {
										stillFullyVisible = true;
										break;
									}
								}
							} catch (err) {
								_iterator4.e(err);
							} finally {
								_iterator4.f();
							}

							if (!stillFullyVisible) {
								currentId = visiblePages[0].id;
							}

							this._setCurrentPageNumber(currentId);
						}

						this._updateLocation(visible.first);

						this.eventBus.dispatch("updateviewarea", {
							source: this,
							location: this._location
						});
					}
				}, {
					key: "containsElement",
					value: function containsElement(element) {
						return this.container.contains(element);
					}
				}, {
					key: "focus",
					value: function focus() {
						this.container.focus();
					}
				}, {
					key: "_isContainerRtl",
					get: function get() {
						return getComputedStyle(this.container).direction === "rtl";
					}
				}, {
					key: "isInPresentationMode",
					get: function get() {
						return this.presentationModeState === _ui_utils
							.PresentationModeState.FULLSCREEN;
					}
				}, {
					key: "isChangingPresentationMode",
					get: function get() {
						return this.presentationModeState === _ui_utils
							.PresentationModeState.CHANGING;
					}
				}, {
					key: "isHorizontalScrollbarEnabled",
					get: function get() {
						return this.isInPresentationMode ? false : this.container
							.scrollWidth > this.container.clientWidth;
					}
				}, {
					key: "isVerticalScrollbarEnabled",
					get: function get() {
						return this.isInPresentationMode ? false : this.container
							.scrollHeight > this.container.clientHeight;
					}
				}, {
					key: "_getCurrentVisiblePage",
					value: function _getCurrentVisiblePage() {
						if (!this.pagesCount) {
							return {
								views: []
							};
						}

						var pageView = this._pages[this._currentPageNumber - 1];
						var element = pageView.div;
						var view = {
							id: pageView.id,
							x: element.offsetLeft + element.clientLeft,
							y: element.offsetTop + element.clientTop,
							view: pageView
						};
						var ids = new Set([pageView.id]);
						return {
							first: view,
							last: view,
							views: [view],
							ids: ids
						};
					}
				}, {
					key: "_getVisiblePages",
					value: function _getVisiblePages() {
						if (this.isInPresentationMode) {
							return this._getCurrentVisiblePage();
						}

						var views = this._scrollMode === _ui_utils.ScrollMode.PAGE ?
							_classPrivateFieldGet(this, _scrollModePageState)
							.pages : this._pages,
							horizontal = this._scrollMode === _ui_utils.ScrollMode
							.HORIZONTAL,
							rtl = horizontal && this._isContainerRtl;
						return (0, _ui_utils.getVisibleElements)({
							scrollEl: this.container,
							views: views,
							sortByVisibility: true,
							horizontal: horizontal,
							rtl: rtl
						});
					}
				}, {
					key: "isPageVisible",
					value: function isPageVisible(pageNumber) {
						if (!this.pdfDocument) {
							return false;
						}

						if (!(Number.isInteger(pageNumber) && pageNumber > 0 &&
								pageNumber <= this.pagesCount)) {
							console.error("isPageVisible: \"".concat(pageNumber,
								"\" is not a valid page."));
							return false;
						}

						return this._getVisiblePages().ids.has(pageNumber);
					}
				}, {
					key: "isPageCached",
					value: function isPageCached(pageNumber) {
						if (!this.pdfDocument) {
							return false;
						}

						if (!(Number.isInteger(pageNumber) && pageNumber > 0 &&
								pageNumber <= this.pagesCount)) {
							console.error("isPageCached: \"".concat(pageNumber,
								"\" is not a valid page."));
							return false;
						}

						var pageView = this._pages[pageNumber - 1];
						return _classPrivateFieldGet(this, _buffer).has(pageView);
					}
				}, {
					key: "cleanup",
					value: function cleanup() {
						for (var i = 0, ii = this._pages.length; i < ii; i++) {
							if (this._pages[i] && this._pages[i].renderingState !==
								_ui_utils.RenderingStates.FINISHED) {
								this._pages[i].reset();
							}
						}
					}
				}, {
					key: "_cancelRendering",
					value: function _cancelRendering() {
						for (var i = 0, ii = this._pages.length; i < ii; i++) {
							if (this._pages[i]) {
								this._pages[i].cancelRendering();
							}
						}
					}
				}, {
					key: "forceRendering",
					value: function forceRendering(currentlyVisiblePages) {
						var _this3 = this;

						var visiblePages = currentlyVisiblePages || this
							._getVisiblePages();

						var scrollAhead = _classPrivateMethodGet(this,
							_getScrollAhead, _getScrollAhead2).call(this,
							visiblePages);

						var preRenderExtra = this._spreadMode !== _ui_utils
							.SpreadMode.NONE && this._scrollMode !== _ui_utils
							.ScrollMode.HORIZONTAL;
						var pageView = this.renderingQueue.getHighestPriority(
							visiblePages, this._pages, scrollAhead,
							preRenderExtra);

						_classPrivateMethodGet(this, _toggleLoadingIconSpinner,
							_toggleLoadingIconSpinner2).call(this, visiblePages
							.ids);

						if (pageView) {
							_classPrivateMethodGet(this, _ensurePdfPageLoaded,
									_ensurePdfPageLoaded2).call(this, pageView)
								.then(function() {
									_this3.renderingQueue.renderView(pageView);
								});

							return true;
						}

						return false;
					}
				}, {
					key: "createTextLayerBuilder",
					value: function createTextLayerBuilder(textLayerDiv, pageIndex,
						viewport) {
						var enhanceTextSelection = arguments.length > 3 &&
							arguments[3] !== undefined ? arguments[3] : false;
						var eventBus = arguments.length > 4 ? arguments[4] :
							undefined;
						var highlighter = arguments.length > 5 ? arguments[5] :
							undefined;
						return new _text_layer_builder.TextLayerBuilder({
							textLayerDiv: textLayerDiv,
							eventBus: eventBus,
							pageIndex: pageIndex,
							viewport: viewport,
							enhanceTextSelection: this
								.isInPresentationMode ? false :
								enhanceTextSelection,
							highlighter: highlighter
						});
					}
				}, {
					key: "createTextHighlighter",
					value: function createTextHighlighter(pageIndex, eventBus) {
						return new _text_highlighter.TextHighlighter({
							eventBus: eventBus,
							pageIndex: pageIndex,
							findController: this.isInPresentationMode ?
								null : this.findController
						});
					}
				}, {
					key: "createAnnotationLayerBuilder",
					value: function createAnnotationLayerBuilder(pageDiv, pdfPage) {
						var _this$pdfDocument, _this$pdfDocument2,
							_this$pdfDocument3, _this$_scriptingManag;

						var annotationStorage = arguments.length > 2 && arguments[
							2] !== undefined ? arguments[2] : null;
						var imageResourcesPath = arguments.length > 3 && arguments[
							3] !== undefined ? arguments[3] : "";
						var renderForms = arguments.length > 4 && arguments[4] !==
							undefined ? arguments[4] : true;
						var l10n = arguments.length > 5 && arguments[5] !==
							undefined ? arguments[5] : _l10n_utils.NullL10n;
						var enableScripting = arguments.length > 6 && arguments[
							6] !== undefined ? arguments[6] : null;
						var hasJSActionsPromise = arguments.length > 7 && arguments[
							7] !== undefined ? arguments[7] : null;
						var mouseState = arguments.length > 8 && arguments[8] !==
							undefined ? arguments[8] : null;
						var fieldObjectsPromise = arguments.length > 9 && arguments[
							9] !== undefined ? arguments[9] : null;
						var annotationCanvasMap = arguments.length > 10 &&
							arguments[10] !== undefined ? arguments[10] : null;
						return new _annotation_layer_builder
					.AnnotationLayerBuilder({
							pageDiv: pageDiv,
							pdfPage: pdfPage,
							annotationStorage: annotationStorage || ((
									_this$pdfDocument = this.pdfDocument
									) === null || _this$pdfDocument ===
								void 0 ? void 0 : _this$pdfDocument
								.annotationStorage),
							imageResourcesPath: imageResourcesPath,
							renderForms: renderForms,
							linkService: this.linkService,
							downloadManager: this.downloadManager,
							l10n: l10n,
							enableScripting: enableScripting !== null &&
								enableScripting !== void 0 ?
								enableScripting : this.enableScripting,
							hasJSActionsPromise: hasJSActionsPromise || ((
									_this$pdfDocument2 = this
									.pdfDocument) === null ||
								_this$pdfDocument2 === void 0 ? void 0 :
								_this$pdfDocument2.hasJSActions()),
							fieldObjectsPromise: fieldObjectsPromise || ((
									_this$pdfDocument3 = this
									.pdfDocument) === null ||
								_this$pdfDocument3 === void 0 ? void 0 :
								_this$pdfDocument3.getFieldObjects()),
							mouseState: mouseState || ((
									_this$_scriptingManag = this
									._scriptingManager) === null ||
								_this$_scriptingManag === void 0 ?
								void 0 : _this$_scriptingManag
								.mouseState),
							annotationCanvasMap: annotationCanvasMap
						});
					}
				}, {
					key: "createXfaLayerBuilder",
					value: function createXfaLayerBuilder(pageDiv, pdfPage) {
						var _this$pdfDocument4;

						var annotationStorage = arguments.length > 2 && arguments[
							2] !== undefined ? arguments[2] : null;
						return new _xfa_layer_builder.XfaLayerBuilder({
							pageDiv: pageDiv,
							pdfPage: pdfPage,
							annotationStorage: annotationStorage || ((
									_this$pdfDocument4 = this
									.pdfDocument) === null ||
								_this$pdfDocument4 === void 0 ? void 0 :
								_this$pdfDocument4.annotationStorage),
							linkService: this.linkService
						});
					}
				}, {
					key: "createStructTreeLayerBuilder",
					value: function createStructTreeLayerBuilder(pdfPage) {
						return new _struct_tree_layer_builder
							.StructTreeLayerBuilder({
								pdfPage: pdfPage
							});
					}
				}, {
					key: "hasEqualPageSizes",
					get: function get() {
						var firstPageView = this._pages[0];

						for (var i = 1, ii = this._pages.length; i < ii; ++i) {
							var pageView = this._pages[i];

							if (pageView.width !== firstPageView.width || pageView
								.height !== firstPageView.height) {
								return false;
							}
						}

						return true;
					}
				}, {
					key: "getPagesOverview",
					value: function getPagesOverview() {
						var _this4 = this;

						return this._pages.map(function(pageView) {
							var viewport = pageView.pdfPage.getViewport({
								scale: 1
							});

							if (!_this4.enablePrintAutoRotate || (0,
									_ui_utils.isPortraitOrientation)(
									viewport)) {
								return {
									width: viewport.width,
									height: viewport.height,
									rotation: viewport.rotation
								};
							}

							return {
								width: viewport.height,
								height: viewport.width,
								rotation: (viewport.rotation - 90) % 360
							};
						});
					}
				}, {
					key: "optionalContentConfigPromise",
					get: function get() {
						if (!this.pdfDocument) {
							return Promise.resolve(null);
						}

						if (!this._optionalContentConfigPromise) {
							return this.pdfDocument.getOptionalContentConfig();
						}

						return this._optionalContentConfigPromise;
					},
					set: function set(promise) {
						if (!(promise instanceof Promise)) {
							throw new Error("Invalid optionalContentConfigPromise: "
								.concat(promise));
						}

						if (!this.pdfDocument) {
							return;
						}

						if (!this._optionalContentConfigPromise) {
							return;
						}

						this._optionalContentConfigPromise = promise;
						var updateArgs = {
							optionalContentConfigPromise: promise
						};

						var _iterator5 = _createForOfIteratorHelper(this._pages),
							_step5;

						try {
							for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
								var pageView = _step5.value;
								pageView.update(updateArgs);
							}
						} catch (err) {
							_iterator5.e(err);
						} finally {
							_iterator5.f();
						}

						this.update();
						this.eventBus.dispatch("optionalcontentconfigchanged", {
							source: this,
							promise: promise
						});
					}
				}, {
					key: "scrollMode",
					get: function get() {
						return this._scrollMode;
					},
					set: function set(mode) {
						if (this._scrollMode === mode) {
							return;
						}

						if (!(0, _ui_utils.isValidScrollMode)(mode)) {
							throw new Error("Invalid scroll mode: ".concat(mode));
						}

						if (this.pagesCount > PagesCountLimit
							.FORCE_SCROLL_MODE_PAGE) {
							return;
						}

						this._previousScrollMode = this._scrollMode;
						this._scrollMode = mode;
						this.eventBus.dispatch("scrollmodechanged", {
							source: this,
							mode: mode
						});

						this._updateScrollMode(this._currentPageNumber);
					}
				}, {
					key: "_updateScrollMode",
					value: function _updateScrollMode() {
						var pageNumber = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : null;
						var scrollMode = this._scrollMode,
							viewer = this.viewer;
						viewer.classList.toggle("scrollHorizontal", scrollMode ===
							_ui_utils.ScrollMode.HORIZONTAL);
						viewer.classList.toggle("scrollWrapped", scrollMode ===
							_ui_utils.ScrollMode.WRAPPED);

						if (!this.pdfDocument || !pageNumber) {
							return;
						}

						if (scrollMode === _ui_utils.ScrollMode.PAGE) {
							_classPrivateMethodGet(this, _ensurePageViewVisible,
								_ensurePageViewVisible2).call(this);
						} else if (this._previousScrollMode === _ui_utils.ScrollMode
							.PAGE) {
							this._updateSpreadMode();
						}

						if (this._currentScaleValue && isNaN(this
								._currentScaleValue)) {
							this._setScale(this._currentScaleValue, true);
						}

						this._setCurrentPageNumber(pageNumber, true);

						this.update();
					}
				}, {
					key: "spreadMode",
					get: function get() {
						return this._spreadMode;
					},
					set: function set(mode) {
						if (this._spreadMode === mode) {
							return;
						}

						if (!(0, _ui_utils.isValidSpreadMode)(mode)) {
							throw new Error("Invalid spread mode: ".concat(mode));
						}

						this._spreadMode = mode;
						this.eventBus.dispatch("spreadmodechanged", {
							source: this,
							mode: mode
						});

						this._updateSpreadMode(this._currentPageNumber);
					}
				}, {
					key: "_updateSpreadMode",
					value: function _updateSpreadMode() {
						var pageNumber = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : null;

						if (!this.pdfDocument) {
							return;
						}

						var viewer = this.viewer,
							pages = this._pages;

						if (this._scrollMode === _ui_utils.ScrollMode.PAGE) {
							_classPrivateMethodGet(this, _ensurePageViewVisible,
								_ensurePageViewVisible2).call(this);
						} else {
							viewer.textContent = "";

							if (this._spreadMode === _ui_utils.SpreadMode.NONE) {
								for (var i = 0, ii = pages.length; i < ii; ++i) {
									viewer.appendChild(pages[i].div);
								}
							} else {
								var parity = this._spreadMode - 1;
								var spread = null;

								for (var _i2 = 0, _ii = pages.length; _i2 < _ii; ++
									_i2) {
									if (spread === null) {
										spread = document.createElement("div");
										spread.className = "spread";
										viewer.appendChild(spread);
									} else if (_i2 % 2 === parity) {
										spread = spread.cloneNode(false);
										viewer.appendChild(spread);
									}

									spread.appendChild(pages[_i2].div);
								}
							}
						}

						if (!pageNumber) {
							return;
						}

						if (this._currentScaleValue && isNaN(this
								._currentScaleValue)) {
							this._setScale(this._currentScaleValue, true);
						}

						this._setCurrentPageNumber(pageNumber, true);

						this.update();
					}
				}, {
					key: "_getPageAdvance",
					value: function _getPageAdvance(currentPageNumber) {
						var previous = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : false;

						switch (this._scrollMode) {
							case _ui_utils.ScrollMode.WRAPPED: {
								var _this$_getVisiblePage = this._getVisiblePages(),
									views = _this$_getVisiblePage.views,
									pageLayout = new Map();

								var _iterator6 = _createForOfIteratorHelper(views),
									_step6;

								try {
									for (_iterator6.s(); !(_step6 = _iterator6.n())
										.done;) {
										var _step6$value = _step6.value,
											id = _step6$value.id,
											y = _step6$value.y,
											percent = _step6$value.percent,
											widthPercent = _step6$value
											.widthPercent;

										if (percent === 0 || widthPercent < 100) {
											continue;
										}

										var yArray = pageLayout.get(y);

										if (!yArray) {
											pageLayout.set(y, yArray || (
											yArray = []));
										}

										yArray.push(id);
									}
								} catch (err) {
									_iterator6.e(err);
								} finally {
									_iterator6.f();
								}

								var _iterator7 = _createForOfIteratorHelper(
										pageLayout.values()),
									_step7;

								try {
									for (_iterator7.s(); !(_step7 = _iterator7.n())
										.done;) {
										var _yArray = _step7.value;

										var currentIndex = _yArray.indexOf(
											currentPageNumber);

										if (currentIndex === -1) {
											continue;
										}

										var numPages = _yArray.length;

										if (numPages === 1) {
											break;
										}

										if (previous) {
											for (var i = currentIndex - 1, ii =
												0; i >= ii; i--) {
												var currentId = _yArray[i],
													expectedId = _yArray[i + 1] - 1;

												if (currentId < expectedId) {
													return currentPageNumber -
														expectedId;
												}
											}
										} else {
											for (var _i3 = currentIndex + 1, _ii2 =
													numPages; _i3 < _ii2; _i3++) {
												var _currentId = _yArray[_i3],
													_expectedId = _yArray[_i3 - 1] +
													1;

												if (_currentId > _expectedId) {
													return _expectedId -
														currentPageNumber;
												}
											}
										}

										if (previous) {
											var firstId = _yArray[0];

											if (firstId < currentPageNumber) {
												return currentPageNumber - firstId +
													1;
											}
										} else {
											var lastId = _yArray[numPages - 1];

											if (lastId > currentPageNumber) {
												return lastId - currentPageNumber +
													1;
											}
										}

										break;
									}
								} catch (err) {
									_iterator7.e(err);
								} finally {
									_iterator7.f();
								}

								break;
							}

							case _ui_utils.ScrollMode.HORIZONTAL: {
								break;
							}

							case _ui_utils.ScrollMode.PAGE:
							case _ui_utils.ScrollMode.VERTICAL: {
								if (this._spreadMode === _ui_utils.SpreadMode
									.NONE) {
									break;
								}

								var parity = this._spreadMode - 1;

								if (previous && currentPageNumber % 2 !== parity) {
									break;
								} else if (!previous && currentPageNumber % 2 ===
									parity) {
									break;
								}

								var _this$_getVisiblePage2 = this
								._getVisiblePages(),
									_views = _this$_getVisiblePage2.views,
									_expectedId2 = previous ? currentPageNumber -
									1 : currentPageNumber + 1;

								var _iterator8 = _createForOfIteratorHelper(_views),
									_step8;

								try {
									for (_iterator8.s(); !(_step8 = _iterator8.n())
										.done;) {
										var _step8$value = _step8.value,
											_id = _step8$value.id,
											_percent = _step8$value.percent,
											_widthPercent = _step8$value
											.widthPercent;

										if (_id !== _expectedId2) {
											continue;
										}

										if (_percent > 0 && _widthPercent === 100) {
											return 2;
										}

										break;
									}
								} catch (err) {
									_iterator8.e(err);
								} finally {
									_iterator8.f();
								}

								break;
							}
						}

						return 1;
					}
				}, {
					key: "nextPage",
					value: function nextPage() {
						var currentPageNumber = this._currentPageNumber,
							pagesCount = this.pagesCount;

						if (currentPageNumber >= pagesCount) {
							return false;
						}

						var advance = this._getPageAdvance(currentPageNumber,
							false) || 1;
						this.currentPageNumber = Math.min(currentPageNumber +
							advance, pagesCount);
						return true;
					}
				}, {
					key: "previousPage",
					value: function previousPage() {
						var currentPageNumber = this._currentPageNumber;

						if (currentPageNumber <= 1) {
							return false;
						}

						var advance = this._getPageAdvance(currentPageNumber,
							true) || 1;
						this.currentPageNumber = Math.max(currentPageNumber -
							advance, 1);
						return true;
					}
				}, {
					key: "increaseScale",
					value: function increaseScale() {
						var steps = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : 1;
						var newScale = this._currentScale;

						do {
							newScale = (newScale * _ui_utils.DEFAULT_SCALE_DELTA)
								.toFixed(2);
							newScale = Math.ceil(newScale * 10) / 10;
							newScale = Math.min(_ui_utils.MAX_SCALE, newScale);
						} while (--steps > 0 && newScale < _ui_utils.MAX_SCALE);

						this.currentScaleValue = newScale;
					}
				}, {
					key: "decreaseScale",
					value: function decreaseScale() {
						var steps = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : 1;
						var newScale = this._currentScale;

						do {
							newScale = (newScale / _ui_utils.DEFAULT_SCALE_DELTA)
								.toFixed(2);
							newScale = Math.floor(newScale * 10) / 10;
							newScale = Math.max(_ui_utils.MIN_SCALE, newScale);
						} while (--steps > 0 && newScale > _ui_utils.MIN_SCALE);

						this.currentScaleValue = newScale;
					}
				}]);

				return BaseViewer;
			}();

			exports.BaseViewer = BaseViewer;

			function _initializePermissions2(permissions) {
				if (!permissions) {
					return;
				}

				if (!permissions.includes(_pdfjsLib.PermissionFlag.COPY)) {
					this.viewer.classList.add(ENABLE_PERMISSIONS_CLASS);
				}

				if (!permissions.includes(_pdfjsLib.PermissionFlag.MODIFY_ANNOTATIONS) && !permissions
					.includes(_pdfjsLib.PermissionFlag.FILL_INTERACTIVE_FORMS)) {
					if (_classPrivateFieldGet(this, _annotationMode) === _pdfjsLib.AnnotationMode
						.ENABLE_FORMS) {
						_classPrivateFieldSet(this, _previousAnnotationMode, _classPrivateFieldGet(this,
							_annotationMode));

						_classPrivateFieldSet(this, _annotationMode, _pdfjsLib.AnnotationMode.ENABLE);
					}
				}
			}

			function _onePageRenderedOrForceFetch2() {
				var _this5 = this;

				if (document.visibilityState === "hidden" || !this.container.offsetParent || this
					._getVisiblePages().views.length === 0) {
					return Promise.resolve();
				}

				var visibilityChangePromise = new Promise(function(resolve) {
					_classPrivateFieldSet(_this5, _onVisibilityChange, function() {
						if (document.visibilityState !== "hidden") {
							return;
						}

						resolve();
						document.removeEventListener("visibilitychange",
							_classPrivateFieldGet(_this5, _onVisibilityChange));

						_classPrivateFieldSet(_this5, _onVisibilityChange, null);
					});

					document.addEventListener("visibilitychange", _classPrivateFieldGet(_this5,
						_onVisibilityChange));
				});
				return Promise.race([this._onePageRenderedCapability.promise, visibilityChangePromise]);
			}

			function _ensurePageViewVisible2() {
				if (this._scrollMode !== _ui_utils.ScrollMode.PAGE) {
					throw new Error("#ensurePageViewVisible: Invalid scrollMode value.");
				}

				var pageNumber = this._currentPageNumber,
					state = _classPrivateFieldGet(this, _scrollModePageState),
					viewer = this.viewer;

				viewer.textContent = "";
				state.pages.length = 0;

				if (this._spreadMode === _ui_utils.SpreadMode.NONE) {
					var pageView = this._pages[pageNumber - 1];

					if (this.isInPresentationMode) {
						var spread = document.createElement("div");
						spread.className = "spread";
						var dummyPage = document.createElement("div");
						dummyPage.className = "dummyPage";
						dummyPage.style.height = "".concat(this.container.clientHeight, "px");
						spread.appendChild(dummyPage);
						spread.appendChild(pageView.div);
						viewer.appendChild(spread);
					} else {
						viewer.appendChild(pageView.div);
					}

					state.pages.push(pageView);
				} else {
					var pageIndexSet = new Set(),
						parity = this._spreadMode - 1;

					if (pageNumber % 2 !== parity) {
						pageIndexSet.add(pageNumber - 1);
						pageIndexSet.add(pageNumber);
					} else {
						pageIndexSet.add(pageNumber - 2);
						pageIndexSet.add(pageNumber - 1);
					}

					var _spread = null;

					var _iterator9 = _createForOfIteratorHelper(pageIndexSet),
						_step9;

					try {
						for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {
							var i = _step9.value;
							var _pageView = this._pages[i];

							if (!_pageView) {
								continue;
							}

							if (_spread === null) {
								_spread = document.createElement("div");
								_spread.className = "spread";
								viewer.appendChild(_spread);
							} else if (i % 2 === parity) {
								_spread = _spread.cloneNode(false);
								viewer.appendChild(_spread);
							}

							_spread.appendChild(_pageView.div);

							state.pages.push(_pageView);
						}
					} catch (err) {
						_iterator9.e(err);
					} finally {
						_iterator9.f();
					}
				}

				state.scrollDown = pageNumber >= state.previousPageNumber;
				state.previousPageNumber = pageNumber;
			}

			function _isSameScale2(newScale) {
				if (this.isInPresentationMode && this.container.clientHeight !== _classPrivateFieldGet(
						this, _previousContainerHeight)) {
					return false;
				}

				return newScale === this._currentScale || Math.abs(newScale - this._currentScale) <
					1e-15;
			}

			function _ensurePdfPageLoaded2(_x) {
				return _ensurePdfPageLoaded3.apply(this, arguments);
			}

			function _ensurePdfPageLoaded3() {
				_ensurePdfPageLoaded3 = _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
					function _callee2(pageView) {
						var _this$linkService$_ca, _this$linkService, pdfPage;

						return _regenerator["default"].wrap(function _callee2$(_context3) {
							while (1) {
								switch (_context3.prev = _context3.next) {
									case 0:
										if (!pageView.pdfPage) {
											_context3.next = 2;
											break;
										}

										return _context3.abrupt("return", pageView
											.pdfPage);

									case 2:
										_context3.prev = 2;
										_context3.next = 5;
										return this.pdfDocument.getPage(pageView.id);

									case 5:
										pdfPage = _context3.sent;

										if (!pageView.pdfPage) {
											pageView.setPdfPage(pdfPage);
										}

										if (!((_this$linkService$_ca = (
													_this$linkService = this
													.linkService)._cachedPageNumber) !==
												null && _this$linkService$_ca !==
												void 0 && _this$linkService$_ca.call(
													_this$linkService, pdfPage.ref))) {
											this.linkService.cachePageRef(pageView.id,
												pdfPage.ref);
										}

										return _context3.abrupt("return", pdfPage);

									case 11:
										_context3.prev = 11;
										_context3.t0 = _context3["catch"](2);
										console.error(
											"Unable to get page for page view",
											_context3.t0);
										return _context3.abrupt("return", null);

									case 15:
									case "end":
										return _context3.stop();
								}
							}
						}, _callee2, this, [
							[2, 11]
						]);
					}));
				return _ensurePdfPageLoaded3.apply(this, arguments);
			}

			function _getScrollAhead2(visible) {
				var _visible$first, _visible$last;

				if (((_visible$first = visible.first) === null || _visible$first === void 0 ? void 0 :
						_visible$first.id) === 1) {
					return true;
				} else if (((_visible$last = visible.last) === null || _visible$last === void 0 ?
						void 0 : _visible$last.id) === this.pagesCount) {
					return false;
				}

				switch (this._scrollMode) {
					case _ui_utils.ScrollMode.PAGE:
						return _classPrivateFieldGet(this, _scrollModePageState).scrollDown;

					case _ui_utils.ScrollMode.HORIZONTAL:
						return this.scroll.right;
				}

				return this.scroll.down;
			}

			function _toggleLoadingIconSpinner2(visibleIds) {
				var _iterator10 = _createForOfIteratorHelper(visibleIds),
					_step10;

				try {
					for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {
						var id = _step10.value;
						var pageView = this._pages[id - 1];
						pageView === null || pageView === void 0 ? void 0 : pageView
							.toggleLoadingIconSpinner(true);
					}
				} catch (err) {
					_iterator10.e(err);
				} finally {
					_iterator10.f();
				}

				var _iterator11 = _createForOfIteratorHelper(_classPrivateFieldGet(this, _buffer)),
					_step11;

				try {
					for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {
						var _pageView2 = _step11.value;

						if (visibleIds.has(_pageView2.id)) {
							continue;
						}

						_pageView2.toggleLoadingIconSpinner(false);
					}
				} catch (err) {
					_iterator11.e(err);
				} finally {
					_iterator11.f();
				}
			}

			/***/
		}),
		/* 31 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.AnnotationLayerBuilder = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _pdfjsLib = __webpack_require__(7);

			var _l10n_utils = __webpack_require__(32);

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

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

			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."
					);
			}

			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);
			}

			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;
			}

			function _iterableToArrayLimit(arr, i) {
				var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] ||
					arr["@@iterator"];
				if (_i == null) return;
				var _arr = [];
				var _n = true;
				var _d = false;
				var _s, _e;
				try {
					for (_i = _i.call(arr); !(_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;
			}

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

			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);
				}
			}

			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);
					});
				};
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var AnnotationLayerBuilder = /*#__PURE__*/ function() {
				function AnnotationLayerBuilder(_ref) {
					var pageDiv = _ref.pageDiv,
						pdfPage = _ref.pdfPage,
						linkService = _ref.linkService,
						downloadManager = _ref.downloadManager,
						_ref$annotationStorag = _ref.annotationStorage,
						annotationStorage = _ref$annotationStorag === void 0 ? null :
						_ref$annotationStorag,
						_ref$imageResourcesPa = _ref.imageResourcesPath,
						imageResourcesPath = _ref$imageResourcesPa === void 0 ? "" :
						_ref$imageResourcesPa,
						_ref$renderForms = _ref.renderForms,
						renderForms = _ref$renderForms === void 0 ? true : _ref$renderForms,
						_ref$l10n = _ref.l10n,
						l10n = _ref$l10n === void 0 ? _l10n_utils.NullL10n : _ref$l10n,
						_ref$enableScripting = _ref.enableScripting,
						enableScripting = _ref$enableScripting === void 0 ? false :
						_ref$enableScripting,
						_ref$hasJSActionsProm = _ref.hasJSActionsPromise,
						hasJSActionsPromise = _ref$hasJSActionsProm === void 0 ? null :
						_ref$hasJSActionsProm,
						_ref$fieldObjectsProm = _ref.fieldObjectsPromise,
						fieldObjectsPromise = _ref$fieldObjectsProm === void 0 ? null :
						_ref$fieldObjectsProm,
						_ref$mouseState = _ref.mouseState,
						mouseState = _ref$mouseState === void 0 ? null : _ref$mouseState,
						_ref$annotationCanvas = _ref.annotationCanvasMap,
						annotationCanvasMap = _ref$annotationCanvas === void 0 ? null :
						_ref$annotationCanvas;

					_classCallCheck(this, AnnotationLayerBuilder);

					this.pageDiv = pageDiv;
					this.pdfPage = pdfPage;
					this.linkService = linkService;
					this.downloadManager = downloadManager;
					this.imageResourcesPath = imageResourcesPath;
					this.renderForms = renderForms;
					this.l10n = l10n;
					this.annotationStorage = annotationStorage;
					this.enableScripting = enableScripting;
					this._hasJSActionsPromise = hasJSActionsPromise;
					this._fieldObjectsPromise = fieldObjectsPromise;
					this._mouseState = mouseState;
					this._annotationCanvasMap = annotationCanvasMap;
					this.div = null;
					this._cancelled = false;
				}

				_createClass(AnnotationLayerBuilder, [{
					key: "render",
					value: function() {
						var _render = _asyncToGenerator( /*#__PURE__*/ _regenerator[
							"default"].mark(function _callee(viewport) {
							var intent,
								_yield$Promise$all,
								_yield$Promise$all2,
								annotations,
								_yield$Promise$all2$,
								hasJSActions,
								_yield$Promise$all2$2,
								fieldObjects,
								parameters,
								_args = arguments;

							return _regenerator["default"].wrap(
								function _callee$(_context) {
									while (1) {
										switch (_context.prev =
											_context.next) {
											case 0:
												intent = _args
													.length > 1 &&
													_args[1] !==
													undefined ?
													_args[1] :
													"display";
												_context.next = 3;
												return Promise.all([
													this
													.pdfPage
													.getAnnotations({
														intent: intent
													}), this
													._hasJSActionsPromise,
													this
													._fieldObjectsPromise
												]);

											case 3:
												_yield$Promise$all =
													_context.sent;
												_yield$Promise$all2
													=
													_slicedToArray(
														_yield$Promise$all,
														3);
												annotations =
													_yield$Promise$all2[
														0];
												_yield$Promise$all2$
													=
													_yield$Promise$all2[
														1];
												hasJSActions =
													_yield$Promise$all2$ ===
													void 0 ? false :
													_yield$Promise$all2$;
												_yield$Promise$all2$2
													=
													_yield$Promise$all2[
														2];
												fieldObjects =
													_yield$Promise$all2$2 ===
													void 0 ? null :
													_yield$Promise$all2$2;

												if (!(this
														._cancelled ||
														annotations
														.length ===
														0)) {
													_context.next =
														12;
													break;
												}

												return _context
													.abrupt(
														"return");

											case 12:
												parameters = {
													viewport: viewport
														.clone({
															dontFlip: true
														}),
													div: this
														.div,
													annotations: annotations,
													page: this
														.pdfPage,
													imageResourcesPath: this
														.imageResourcesPath,
													renderForms: this
														.renderForms,
													linkService: this
														.linkService,
													downloadManager: this
														.downloadManager,
													annotationStorage: this
														.annotationStorage,
													enableScripting: this
														.enableScripting,
													hasJSActions: hasJSActions,
													fieldObjects: fieldObjects,
													mouseState: this
														._mouseState,
													annotationCanvasMap: this
														._annotationCanvasMap
												};

												if (this.div) {
													_pdfjsLib
														.AnnotationLayer
														.update(
															parameters
															);
												} else {
													this.div =
														document
														.createElement(
															"div");
													this.div
														.className =
														"annotationLayer";
													this.pageDiv
														.appendChild(
															this.div
															);
													parameters.div =
														this.div;

													_pdfjsLib
														.AnnotationLayer
														.render(
															parameters
															);

													this.l10n
														.translate(
															this.div
															);
												}

												case 14:
												case "end":
													return _context
														.stop();
										}
									}
								}, _callee, this);
						}));

						function render(_x) {
							return _render.apply(this, arguments);
						}

						return render;
					}()
				}, {
					key: "cancel",
					value: function cancel() {
						this._cancelled = true;
					}
				}, {
					key: "hide",
					value: function hide() {
						if (!this.div) {
							return;
						}

						this.div.hidden = true;
					}
				}]);

				return AnnotationLayerBuilder;
			}();

			exports.AnnotationLayerBuilder = AnnotationLayerBuilder;

			/***/
		}),
		/* 32 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.NullL10n = void 0;
			exports.fixupLangCode = fixupLangCode;
			exports.getL10nFallback = getL10nFallback;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

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

			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);
				}
			}

			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);
					});
				};
			}

			var DEFAULT_L10N_STRINGS = {
				of_pages: "of {{pagesCount}}",
				page_of_pages: "({{pageNumber}} of {{pagesCount}})",
				document_properties_kb: "{{size_kb}} KB ({{size_b}} bytes)",
				document_properties_mb: "{{size_mb}} MB ({{size_b}} bytes)",
				document_properties_date_string: "{{date}}, {{time}}",
				document_properties_page_size_unit_inches: "in",
				document_properties_page_size_unit_millimeters: "mm",
				document_properties_page_size_orientation_portrait: "portrait",
				document_properties_page_size_orientation_landscape: "landscape",
				document_properties_page_size_name_a3: "A3",
				document_properties_page_size_name_a4: "A4",
				document_properties_page_size_name_letter: "Letter",
				document_properties_page_size_name_legal: "Legal",
				document_properties_page_size_dimension_string: "{{width}} × {{height}} {{unit}} ({{orientation}})",
				document_properties_page_size_dimension_name_string: "{{width}} × {{height}} {{unit}} ({{name}}, {{orientation}})",
				document_properties_linearized_yes: "Yes",
				document_properties_linearized_no: "No",
				print_progress_percent: "{{progress}}%",
				"toggle_sidebar.title": "Toggle Sidebar",
				"toggle_sidebar_notification2.title": "Toggle Sidebar (document contains outline/attachments/layers)",
				additional_layers: "Additional Layers",
				page_landmark: "Page {{page}}",
				thumb_page_title: "Page {{page}}",
				thumb_page_canvas: "Thumbnail of Page {{page}}",
				find_reached_top: "Reached top of document, continued from bottom",
				find_reached_bottom: "Reached end of document, continued from top",
				"find_match_count[one]": "{{current}} of {{total}} match",
				"find_match_count[other]": "{{current}} of {{total}} matches",
				"find_match_count_limit[one]": "More than {{limit}} match",
				"find_match_count_limit[other]": "More than {{limit}} matches",
				find_not_found: "Phrase not found",
				error_version_info: "PDF.js v{{version}} (build: {{build}})",
				error_message: "Message: {{message}}",
				error_stack: "Stack: {{stack}}",
				error_file: "File: {{file}}",
				error_line: "Line: {{line}}",
				rendering_error: "An error occurred while rendering the page.",
				page_scale_width: "Page Width",
				page_scale_fit: "Page Fit",
				page_scale_auto: "Automatic Zoom",
				page_scale_actual: "Actual Size",
				page_scale_percent: "{{scale}}%",
				loading: "Loading…",
				loading_error: "An error occurred while loading the PDF.",
				invalid_file_error: "Invalid or corrupted PDF file.",
				missing_file_error: "Missing PDF file.",
				unexpected_response_error: "Unexpected server response.",
				printing_not_supported: "Warning: Printing is not fully supported by this browser.",
				printing_not_ready: "Warning: The PDF is not fully loaded for printing.",
				web_fonts_disabled: "Web fonts are disabled: unable to use embedded PDF fonts."
			};

			function getL10nFallback(key, args) {
				switch (key) {
					case "find_match_count":
						key = "find_match_count[".concat(args.total === 1 ? "one" : "other", "]");
						break;

					case "find_match_count_limit":
						key = "find_match_count_limit[".concat(args.limit === 1 ? "one" : "other", "]");
						break;
				}

				return DEFAULT_L10N_STRINGS[key] || "";
			}

			var PARTIAL_LANG_CODES = {
				en: "en-US",
				es: "es-ES",
				fy: "fy-NL",
				ga: "ga-IE",
				gu: "gu-IN",
				hi: "hi-IN",
				hy: "hy-AM",
				nb: "nb-NO",
				ne: "ne-NP",
				nn: "nn-NO",
				pa: "pa-IN",
				pt: "pt-PT",
				sv: "sv-SE",
				zh: "zh-CN"
			};

			function fixupLangCode(langCode) {
				return PARTIAL_LANG_CODES[langCode === null || langCode === void 0 ? void 0 : langCode
					.toLowerCase()] || langCode;
			}

			function formatL10nValue(text, args) {
				if (!args) {
					return text;
				}

				return text.replace(/\{\{\s*(\w+)\s*\}\}/g, function(all, name) {
					return name in args ? args[name] : "{{" + name + "}}";
				});
			}

			var NullL10n = {
				getLanguage: function getLanguage() {
					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee() {
							return _regenerator["default"].wrap(function _callee$(
								_context) {
								while (1) {
									switch (_context.prev = _context.next) {
										case 0:
											return _context.abrupt("return",
												"en-us");

										case 1:
										case "end":
											return _context.stop();
									}
								}
							}, _callee);
						}))();
				},
				getDirection: function getDirection() {
					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee2() {
							return _regenerator["default"].wrap(function _callee2$(
								_context2) {
								while (1) {
									switch (_context2.prev = _context2.next) {
										case 0:
											return _context2.abrupt("return",
												"ltr");

										case 1:
										case "end":
											return _context2.stop();
									}
								}
							}, _callee2);
						}))();
				},
				get: function get(key) {
					var _arguments = arguments;
					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee3() {
							var args, fallback;
							return _regenerator["default"].wrap(function _callee3$(
								_context3) {
								while (1) {
									switch (_context3.prev = _context3.next) {
										case 0:
											args = _arguments.length > 1 &&
												_arguments[1] !== undefined ?
												_arguments[1] : null;
											fallback = _arguments.length > 2 &&
												_arguments[2] !== undefined ?
												_arguments[2] : getL10nFallback(
													key, args);
											return _context3.abrupt("return",
												formatL10nValue(fallback,
													args));

										case 3:
										case "end":
											return _context3.stop();
									}
								}
							}, _callee3);
						}))();
				},
				translate: function translate(element) {
					return _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
						function _callee4() {
							return _regenerator["default"].wrap(function _callee4$(
								_context4) {
								while (1) {
									switch (_context4.prev = _context4.next) {
										case 0:
										case "end":
											return _context4.stop();
									}
								}
							}, _callee4);
						}))();
				}
			};
			exports.NullL10n = NullL10n;

			/***/
		}),
		/* 33 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFPageView = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _pdfjsLib = __webpack_require__(7);

			var _ui_utils = __webpack_require__(5);

			var _app_options = __webpack_require__(1);

			var _l10n_utils = __webpack_require__(32);

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

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

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

			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);
			}

			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;
			}

			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);
				}
			}

			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);
					});
				};
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			function _classPrivateFieldInitSpec(obj, privateMap, value) {
				_checkPrivateRedeclaration(obj, privateMap);
				privateMap.set(obj, value);
			}

			function _checkPrivateRedeclaration(obj, privateCollection) {
				if (privateCollection.has(obj)) {
					throw new TypeError(
						"Cannot initialize the same private elements twice on an object");
				}
			}

			function _classPrivateFieldGet(receiver, privateMap) {
				var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "get");
				return _classApplyDescriptorGet(receiver, descriptor);
			}

			function _classApplyDescriptorGet(receiver, descriptor) {
				if (descriptor.get) {
					return descriptor.get.call(receiver);
				}
				return descriptor.value;
			}

			function _classPrivateFieldSet(receiver, privateMap, value) {
				var descriptor = _classExtractFieldDescriptor(receiver, privateMap, "set");
				_classApplyDescriptorSet(receiver, descriptor, value);
				return value;
			}

			function _classExtractFieldDescriptor(receiver, privateMap, action) {
				if (!privateMap.has(receiver)) {
					throw new TypeError("attempted to " + action + " private field on non-instance");
				}
				return privateMap.get(receiver);
			}

			function _classApplyDescriptorSet(receiver, descriptor, value) {
				if (descriptor.set) {
					descriptor.set.call(receiver, value);
				} else {
					if (!descriptor.writable) {
						throw new TypeError("attempted to set read only private field");
					}
					descriptor.value = value;
				}
			}

			var MAX_CANVAS_PIXELS = _app_options.compatibilityParams.maxCanvasPixels || 16777216;

			var _annotationMode = /*#__PURE__*/ new WeakMap();

			var PDFPageView = /*#__PURE__*/ function() {
				function PDFPageView(options) {
					var _options$textLayerMod, _options$annotationMo, _options$textHighligh,
						_this$renderingQueue;

					_classCallCheck(this, PDFPageView);

					_classPrivateFieldInitSpec(this, _annotationMode, {
						writable: true,
						value: _pdfjsLib.AnnotationMode.ENABLE_FORMS
					});

					var container = options.container;
					var defaultViewport = options.defaultViewport;
					this.id = options.id;
					this.renderingId = "page" + this.id;
					this.pdfPage = null;
					this.pageLabel = null;
					this.rotation = 0;
					this.scale = options.scale || _ui_utils.DEFAULT_SCALE;
					this.viewport = defaultViewport;
					this.pdfPageRotate = defaultViewport.rotation;
					this._optionalContentConfigPromise = options.optionalContentConfigPromise ||
						null;
					this.hasRestrictedScaling = false;
					this.textLayerMode = (_options$textLayerMod = options.textLayerMode) !== null &&
						_options$textLayerMod !== void 0 ? _options$textLayerMod : _ui_utils
						.TextLayerMode.ENABLE;

					_classPrivateFieldSet(this, _annotationMode, (_options$annotationMo = options
							.annotationMode) !== null && _options$annotationMo !== void 0 ?
						_options$annotationMo : _pdfjsLib.AnnotationMode.ENABLE_FORMS);

					this.imageResourcesPath = options.imageResourcesPath || "";
					this.useOnlyCssZoom = options.useOnlyCssZoom || false;
					this.maxCanvasPixels = options.maxCanvasPixels || MAX_CANVAS_PIXELS;
					this.eventBus = options.eventBus;
					this.renderingQueue = options.renderingQueue;
					this.textLayerFactory = options.textLayerFactory;
					this.annotationLayerFactory = options.annotationLayerFactory;
					this.xfaLayerFactory = options.xfaLayerFactory;
					this.textHighlighter = (_options$textHighligh = options
						.textHighlighterFactory) === null || _options$textHighligh === void 0 ?
						void 0 : _options$textHighligh.createTextHighlighter(this.id - 1, this
							.eventBus);
					this.structTreeLayerFactory = options.structTreeLayerFactory;
					this.renderer = options.renderer || _ui_utils.RendererType.CANVAS;
					this.l10n = options.l10n || _l10n_utils.NullL10n;
					this.paintTask = null;
					this.paintedViewportMap = new WeakMap();
					this.renderingState = _ui_utils.RenderingStates.INITIAL;
					this.resume = null;
					this._renderError = null;
					this._isStandalone = !((_this$renderingQueue = this.renderingQueue) !== null &&
						_this$renderingQueue !== void 0 && _this$renderingQueue.hasViewer());
					this._annotationCanvasMap = null;
					this.annotationLayer = null;
					this.textLayer = null;
					this.zoomLayer = null;
					this.xfaLayer = null;
					this.structTreeLayer = null;
					var div = document.createElement("div");
					div.className = "page";
					div.style.width = Math.floor(this.viewport.width) + "px";
					div.style.height = Math.floor(this.viewport.height) + "px";
					div.setAttribute("data-page-number", this.id);
					div.setAttribute("role", "region");
					this.l10n.get("page_landmark", {
						page: this.id
					}).then(function(msg) {
						div.setAttribute("aria-label", msg);
					});
					this.div = div;
					container === null || container === void 0 ? void 0 : container.appendChild(
					div);
				}

				_createClass(PDFPageView, [{
					key: "setPdfPage",
					value: function setPdfPage(pdfPage) {
						this.pdfPage = pdfPage;
						this.pdfPageRotate = pdfPage.rotate;
						var totalRotation = (this.rotation + this.pdfPageRotate) %
							360;
						this.viewport = pdfPage.getViewport({
							scale: this.scale * _pdfjsLib.PixelsPerInch
								.PDF_TO_CSS_UNITS,
							rotation: totalRotation
						});
						this.reset();
					}
				}, {
					key: "destroy",
					value: function destroy() {
						this.reset();

						if (this.pdfPage) {
							this.pdfPage.cleanup();
						}
					}
				}, {
					key: "_renderAnnotationLayer",
					value: function() {
						var _renderAnnotationLayer2 =
						_asyncToGenerator( /*#__PURE__*/ _regenerator["default"]
							.mark(function _callee() {
								var error;
								return _regenerator["default"].wrap(
									function _callee$(_context) {
										while (1) {
											switch (_context.prev =
												_context.next) {
												case 0:
													error = null;
													_context.prev = 1;
													_context.next = 4;
													return this
														.annotationLayer
														.render(this
															.viewport,
															"display");

												case 4:
													_context.next = 9;
													break;

												case 6:
													_context.prev = 6;
													_context.t0 =
														_context[
															"catch"](1);
													error = _context.t0;

												case 9:
													_context.prev = 9;
													this.eventBus
														.dispatch(
															"annotationlayerrendered", {
																source: this,
																pageNumber: this
																	.id,
																error: error
															});
													return _context
														.finish(9);

												case 12:
												case "end":
													return _context
														.stop();
											}
										}
									}, _callee, this, [
										[1, 6, 9, 12]
									]);
							}));

						function _renderAnnotationLayer() {
							return _renderAnnotationLayer2.apply(this, arguments);
						}

						return _renderAnnotationLayer;
					}()
				}, {
					key: "_renderXfaLayer",
					value: function() {
						var _renderXfaLayer2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee2() {
								var error, result;
								return _regenerator["default"].wrap(
									function _callee2$(_context2) {
										while (1) {
											switch (_context2.prev =
												_context2.next) {
												case 0:
													error = null;
													_context2.prev = 1;
													_context2.next = 4;
													return this.xfaLayer
														.render(this
															.viewport,
															"display");

												case 4:
													result = _context2
														.sent;

													if (this
														.textHighlighter
														) {
														this._buildXfaTextContentItems(
															result
															.textDivs
															);
													}

													_context2.next = 11;
													break;

												case 8:
													_context2.prev = 8;
													_context2.t0 =
														_context2[
															"catch"](1);
													error = _context2
													.t0;

												case 11:
													_context2.prev = 11;
													this.eventBus
														.dispatch(
															"xfalayerrendered", {
																source: this,
																pageNumber: this
																	.id,
																error: error
															});
													return _context2
														.finish(11);

												case 14:
												case "end":
													return _context2
														.stop();
											}
										}
									}, _callee2, this, [
										[1, 8, 11, 14]
									]);
							}));

						function _renderXfaLayer() {
							return _renderXfaLayer2.apply(this, arguments);
						}

						return _renderXfaLayer;
					}()
				}, {
					key: "_buildXfaTextContentItems",
					value: function() {
						var _buildXfaTextContentItems2 =
						_asyncToGenerator( /*#__PURE__*/ _regenerator["default"]
							.mark(function _callee3(textDivs) {
								var text, items, _iterator, _step, item;

								return _regenerator["default"].wrap(
									function _callee3$(_context3) {
										while (1) {
											switch (_context3.prev =
												_context3.next) {
												case 0:
													_context3.next = 2;
													return this.pdfPage
														.getTextContent();

												case 2:
													text = _context3
														.sent;
													items = [];
													_iterator =
														_createForOfIteratorHelper(
															text.items);

													try {
														for (_iterator
															.s(); !(
																_step =
																_iterator
																.n())
															.done;) {
															item = _step
																.value;
															items.push(
																item
																.str
																);
														}
													} catch (err) {
														_iterator.e(
														err);
													} finally {
														_iterator.f();
													}

													this.textHighlighter
														.setTextMapping(
															textDivs,
															items);
													this.textHighlighter
														.enable();

												case 8:
												case "end":
													return _context3
														.stop();
											}
										}
									}, _callee3, this);
							}));

						function _buildXfaTextContentItems(_x) {
							return _buildXfaTextContentItems2.apply(this,
							arguments);
						}

						return _buildXfaTextContentItems;
					}()
				}, {
					key: "_resetZoomLayer",
					value: function _resetZoomLayer() {
						var removeFromDOM = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : false;

						if (!this.zoomLayer) {
							return;
						}

						var zoomLayerCanvas = this.zoomLayer.firstChild;
						this.paintedViewportMap["delete"](zoomLayerCanvas);
						zoomLayerCanvas.width = 0;
						zoomLayerCanvas.height = 0;

						if (removeFromDOM) {
							this.zoomLayer.remove();
						}

						this.zoomLayer = null;
					}
				}, {
					key: "reset",
					value: function reset() {
						var _this$annotationLayer,
							_this$xfaLayer,
							_this = this;

						var _ref = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : {},
							_ref$keepZoomLayer = _ref.keepZoomLayer,
							keepZoomLayer = _ref$keepZoomLayer === void 0 ? false :
							_ref$keepZoomLayer,
							_ref$keepAnnotationLa = _ref.keepAnnotationLayer,
							keepAnnotationLayer = _ref$keepAnnotationLa === void 0 ?
							false : _ref$keepAnnotationLa,
							_ref$keepXfaLayer = _ref.keepXfaLayer,
							keepXfaLayer = _ref$keepXfaLayer === void 0 ? false :
							_ref$keepXfaLayer;

						this.cancelRendering({
							keepAnnotationLayer: keepAnnotationLayer,
							keepXfaLayer: keepXfaLayer
						});
						this.renderingState = _ui_utils.RenderingStates.INITIAL;
						var div = this.div;
						div.style.width = Math.floor(this.viewport.width) + "px";
						div.style.height = Math.floor(this.viewport.height) + "px";
						var childNodes = div.childNodes,
							zoomLayerNode = keepZoomLayer && this.zoomLayer || null,
							annotationLayerNode = keepAnnotationLayer && ((
									_this$annotationLayer = this.annotationLayer
									) === null || _this$annotationLayer === void 0 ?
								void 0 : _this$annotationLayer.div) || null,
							xfaLayerNode = keepXfaLayer && ((_this$xfaLayer = this
									.xfaLayer) === null || _this$xfaLayer ===
								void 0 ? void 0 : _this$xfaLayer.div) || null;

						for (var i = childNodes.length - 1; i >= 0; i--) {
							var node = childNodes[i];

							switch (node) {
								case zoomLayerNode:
								case annotationLayerNode:
								case xfaLayerNode:
									continue;
							}

							node.remove();
						}

						div.removeAttribute("data-loaded");

						if (annotationLayerNode) {
							this.annotationLayer.hide();
						}

						if (xfaLayerNode) {
							this.xfaLayer.hide();
						}

						if (!zoomLayerNode) {
							if (this.canvas) {
								this.paintedViewportMap["delete"](this.canvas);
								this.canvas.width = 0;
								this.canvas.height = 0;
								delete this.canvas;
							}

							this._resetZoomLayer();
						}

						if (this.svg) {
							this.paintedViewportMap["delete"](this.svg);
							delete this.svg;
						}

						this.loadingIconDiv = document.createElement("div");
						this.loadingIconDiv.className = "loadingIcon notVisible";

						if (this._isStandalone) {
							this.toggleLoadingIconSpinner(true);
						}

						this.loadingIconDiv.setAttribute("role", "img");
						this.l10n.get("loading").then(function(msg) {
							var _this$loadingIconDiv;

							(_this$loadingIconDiv = _this
							.loadingIconDiv) === null ||
								_this$loadingIconDiv === void 0 ? void 0 :
								_this$loadingIconDiv.setAttribute(
									"aria-label", msg);
						});
						div.appendChild(this.loadingIconDiv);
					}
				}, {
					key: "update",
					value: function update(_ref2) {
						var _ref2$scale = _ref2.scale,
							scale = _ref2$scale === void 0 ? 0 : _ref2$scale,
							_ref2$rotation = _ref2.rotation,
							rotation = _ref2$rotation === void 0 ? null :
							_ref2$rotation,
							_ref2$optionalContent = _ref2
							.optionalContentConfigPromise,
							optionalContentConfigPromise = _ref2$optionalContent ===
							void 0 ? null : _ref2$optionalContent;

						if (_typeof(arguments[0]) !== "object") {
							console.error(
								"PDFPageView.update called with separate parameters, please use an object instead."
								);
							this.update({
								scale: arguments[0],
								rotation: arguments[1],
								optionalContentConfigPromise: arguments[2]
							});
							return;
						}

						this.scale = scale || this.scale;

						if (typeof rotation === "number") {
							this.rotation = rotation;
						}

						if (optionalContentConfigPromise instanceof Promise) {
							this._optionalContentConfigPromise =
								optionalContentConfigPromise;
						}

						var totalRotation = (this.rotation + this.pdfPageRotate) %
							360;
						var viewportScale = this.scale * _pdfjsLib.PixelsPerInch
							.PDF_TO_CSS_UNITS;
						this.viewport = this.viewport.clone({
							scale: viewportScale,
							rotation: totalRotation
						});

						if (this._isStandalone) {
							var style = document.documentElement.style;
							style.setProperty("--zoom-factor", this.scale);
							style.setProperty("--viewport-scale-factor",
								viewportScale);
						}

						if (this.svg) {
							this.cssTransform({
								target: this.svg,
								redrawAnnotationLayer: true,
								redrawXfaLayer: true
							});
							this.eventBus.dispatch("pagerendered", {
								source: this,
								pageNumber: this.id,
								cssTransform: true,
								timestamp: performance.now(),
								error: this._renderError
							});
							return;
						}

						var isScalingRestricted = false;

						if (this.canvas && this.maxCanvasPixels > 0) {
							var outputScale = this.outputScale;

							if ((Math.floor(this.viewport.width) * outputScale.sx |
									0) * (Math.floor(this.viewport.height) *
									outputScale.sy | 0) > this.maxCanvasPixels) {
								isScalingRestricted = true;
							}
						}

						if (this.canvas) {
							if (this.useOnlyCssZoom || this.hasRestrictedScaling &&
								isScalingRestricted) {
								this.cssTransform({
									target: this.canvas,
									redrawAnnotationLayer: true,
									redrawXfaLayer: true
								});
								this.eventBus.dispatch("pagerendered", {
									source: this,
									pageNumber: this.id,
									cssTransform: true,
									timestamp: performance.now(),
									error: this._renderError
								});
								return;
							}

							if (!this.zoomLayer && !this.canvas.hidden) {
								this.zoomLayer = this.canvas.parentNode;
								this.zoomLayer.style.position = "absolute";
							}
						}

						if (this.zoomLayer) {
							this.cssTransform({
								target: this.zoomLayer.firstChild
							});
						}

						this.reset({
							keepZoomLayer: true,
							keepAnnotationLayer: true,
							keepXfaLayer: true
						});
					}
				}, {
					key: "cancelRendering",
					value: function cancelRendering() {
						var _ref3 = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : {},
							_ref3$keepAnnotationL = _ref3.keepAnnotationLayer,
							keepAnnotationLayer = _ref3$keepAnnotationL === void 0 ?
							false : _ref3$keepAnnotationL,
							_ref3$keepXfaLayer = _ref3.keepXfaLayer,
							keepXfaLayer = _ref3$keepXfaLayer === void 0 ? false :
							_ref3$keepXfaLayer;

						if (this.paintTask) {
							this.paintTask.cancel();
							this.paintTask = null;
						}

						this.resume = null;

						if (this.textLayer) {
							this.textLayer.cancel();
							this.textLayer = null;
						}

						if (this.annotationLayer && (!keepAnnotationLayer || !this
								.annotationLayer.div)) {
							this.annotationLayer.cancel();
							this.annotationLayer = null;
							this._annotationCanvasMap = null;
						}

						if (this.xfaLayer && (!keepXfaLayer || !this.xfaLayer
							.div)) {
							var _this$textHighlighter;

							this.xfaLayer.cancel();
							this.xfaLayer = null;
							(_this$textHighlighter = this.textHighlighter) === null
								|| _this$textHighlighter === void 0 ? void 0 :
								_this$textHighlighter.disable();
						}

						if (this._onTextLayerRendered) {
							this.eventBus._off("textlayerrendered", this
								._onTextLayerRendered);

							this._onTextLayerRendered = null;
						}
					}
				}, {
					key: "cssTransform",
					value: function cssTransform(_ref4) {
						var target = _ref4.target,
							_ref4$redrawAnnotatio = _ref4.redrawAnnotationLayer,
							redrawAnnotationLayer = _ref4$redrawAnnotatio ===
							void 0 ? false : _ref4$redrawAnnotatio,
							_ref4$redrawXfaLayer = _ref4.redrawXfaLayer,
							redrawXfaLayer = _ref4$redrawXfaLayer === void 0 ?
							false : _ref4$redrawXfaLayer;
						var width = this.viewport.width;
						var height = this.viewport.height;
						var div = this.div;
						target.style.width = target.parentNode.style.width = div
							.style.width = Math.floor(width) + "px";
						target.style.height = target.parentNode.style.height = div
							.style.height = Math.floor(height) + "px";
						var relativeRotation = this.viewport.rotation - this
							.paintedViewportMap.get(target).rotation;
						var absRotation = Math.abs(relativeRotation);
						var scaleX = 1,
							scaleY = 1;

						if (absRotation === 90 || absRotation === 270) {
							scaleX = height / width;
							scaleY = width / height;
						}

						target.style.transform = "rotate(".concat(relativeRotation,
							"deg) scale(").concat(scaleX, ", ").concat(scaleY,
							")");

						if (this.textLayer) {
							var textLayerViewport = this.textLayer.viewport;
							var textRelativeRotation = this.viewport.rotation -
								textLayerViewport.rotation;
							var textAbsRotation = Math.abs(textRelativeRotation);
							var scale = width / textLayerViewport.width;

							if (textAbsRotation === 90 || textAbsRotation === 270) {
								scale = width / textLayerViewport.height;
							}

							var textLayerDiv = this.textLayer.textLayerDiv;
							var transX, transY;

							switch (textAbsRotation) {
								case 0:
									transX = transY = 0;
									break;

								case 90:
									transX = 0;
									transY = "-" + textLayerDiv.style.height;
									break;

								case 180:
									transX = "-" + textLayerDiv.style.width;
									transY = "-" + textLayerDiv.style.height;
									break;

								case 270:
									transX = "-" + textLayerDiv.style.width;
									transY = 0;
									break;

								default:
									console.error("Bad rotation value.");
									break;
							}

							textLayerDiv.style.transform = "rotate(".concat(
									textAbsRotation, "deg) ") + "scale(".concat(
									scale, ") ") + "translate(".concat(transX, ", ")
								.concat(transY, ")");
							textLayerDiv.style.transformOrigin = "0% 0%";
						}

						if (redrawAnnotationLayer && this.annotationLayer) {
							this._renderAnnotationLayer();
						}

						if (redrawXfaLayer && this.xfaLayer) {
							this._renderXfaLayer();
						}
					}
				}, {
					key: "width",
					get: function get() {
						return this.viewport.width;
					}
				}, {
					key: "height",
					get: function get() {
						return this.viewport.height;
					}
				}, {
					key: "getPagePoint",
					value: function getPagePoint(x, y) {
						return this.viewport.convertToPdfPoint(x, y);
					}
				}, {
					key: "toggleLoadingIconSpinner",
					value: function toggleLoadingIconSpinner() {
						var _this$loadingIconDiv2;

						var viewVisible = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : false;
						(_this$loadingIconDiv2 = this.loadingIconDiv) === null ||
							_this$loadingIconDiv2 === void 0 ? void 0 :
							_this$loadingIconDiv2.classList.toggle("notVisible", !
								viewVisible);
					}
				}, {
					key: "draw",
					value: function draw() {
						var _this$annotationLayer2,
							_this$xfaLayer2,
							_this2 = this;

						if (this.renderingState !== _ui_utils.RenderingStates
							.INITIAL) {
							console.error("Must be in new state before drawing");
							this.reset();
						}

						var div = this.div,
							pdfPage = this.pdfPage;

						if (!pdfPage) {
							this.renderingState = _ui_utils.RenderingStates
							.FINISHED;

							if (this.loadingIconDiv) {
								this.loadingIconDiv.remove();
								delete this.loadingIconDiv;
							}

							return Promise.reject(new Error(
								"pdfPage is not loaded"));
						}

						this.renderingState = _ui_utils.RenderingStates.RUNNING;
						var canvasWrapper = document.createElement("div");
						canvasWrapper.style.width = div.style.width;
						canvasWrapper.style.height = div.style.height;
						canvasWrapper.classList.add("canvasWrapper");

						if ((_this$annotationLayer2 = this.annotationLayer) !==
							null && _this$annotationLayer2 !== void 0 &&
							_this$annotationLayer2.div) {
							div.insertBefore(canvasWrapper, this.annotationLayer
								.div);
						} else {
							div.appendChild(canvasWrapper);
						}

						var textLayer = null;

						if (this.textLayerMode !== _ui_utils.TextLayerMode
							.DISABLE && this.textLayerFactory) {
							var _this$annotationLayer3;

							var textLayerDiv = document.createElement("div");
							textLayerDiv.className = "textLayer";
							textLayerDiv.style.width = canvasWrapper.style.width;
							textLayerDiv.style.height = canvasWrapper.style.height;

							if ((_this$annotationLayer3 = this.annotationLayer) !==
								null && _this$annotationLayer3 !== void 0 &&
								_this$annotationLayer3.div) {
								div.insertBefore(textLayerDiv, this.annotationLayer
									.div);
							} else {
								div.appendChild(textLayerDiv);
							}

							textLayer = this.textLayerFactory
								.createTextLayerBuilder(textLayerDiv, this.id - 1,
									this.viewport, this.textLayerMode === _ui_utils
									.TextLayerMode.ENABLE_ENHANCE, this.eventBus,
									this.textHighlighter);
						}

						this.textLayer = textLayer;

						if (_classPrivateFieldGet(this, _annotationMode) !==
							_pdfjsLib.AnnotationMode.DISABLE && this
							.annotationLayerFactory) {
							this._annotationCanvasMap || (this
								._annotationCanvasMap = new Map());
							this.annotationLayer || (this.annotationLayer = this
								.annotationLayerFactory
								.createAnnotationLayerBuilder(div, pdfPage,
									null, this.imageResourcesPath,
									_classPrivateFieldGet(this,
									_annotationMode) === _pdfjsLib
									.AnnotationMode.ENABLE_FORMS, this.l10n,
									null, null, null, null, this
									._annotationCanvasMap));
						}

						if ((_this$xfaLayer2 = this.xfaLayer) !== null &&
							_this$xfaLayer2 !== void 0 && _this$xfaLayer2.div) {
							div.appendChild(this.xfaLayer.div);
						}

						var renderContinueCallback = null;

						if (this.renderingQueue) {
							renderContinueCallback =
								function renderContinueCallback(cont) {
									if (!_this2.renderingQueue.isHighestPriority(
											_this2)) {
										_this2.renderingState = _ui_utils
											.RenderingStates.PAUSED;

										_this2.resume = function() {
											_this2.renderingState = _ui_utils
												.RenderingStates.RUNNING;
											cont();
										};

										return;
									}

									cont();
								};
						}

						var finishPaintTask = /*#__PURE__*/ function() {
							var _ref5 = _asyncToGenerator( /*#__PURE__*/
								_regenerator["default"].mark(
									function _callee4() {
										var error,
											_args4 = arguments;
										return _regenerator["default"].wrap(
											function _callee4$(
												_context4) {
												while (1) {
													switch (_context4
														.prev =
														_context4.next
														) {
														case 0:
															error =
																_args4
																.length >
																0 &&
																_args4[
																	0] !==
																undefined ?
																_args4[
																	0] :
																null;

															if (paintTask ===
																_this2
																.paintTask
																) {
																_this2
																	.paintTask =
																	null;
															}

															if (!(error instanceof _pdfjsLib
																	.RenderingCancelledException
																	)) {
																_context4
																	.next =
																	5;
																break;
															}

															_this2
																._renderError =
																null;
															return _context4
																.abrupt(
																	"return"
																	);

														case 5:
															_this2
																._renderError =
																error;
															_this2
																.renderingState =
																_ui_utils
																.RenderingStates
																.FINISHED;

															if (_this2
																.loadingIconDiv
																) {
																_this2
																	.loadingIconDiv
																	.remove();

																delete _this2
																	.loadingIconDiv;
															}

															_this2
																._resetZoomLayer(
																	true
																	);

															_this2
																.eventBus
																.dispatch(
																	"pagerendered", {
																		source: _this2,
																		pageNumber: _this2
																			.id,
																		cssTransform: false,
																		timestamp: performance
																			.now(),
																		error: _this2
																			._renderError
																	});

															if (!
																error) {
																_context4
																	.next =
																	12;
																break;
															}

															throw error;

														case 12:
														case "end":
															return _context4
																.stop();
													}
												}
											}, _callee4);
									}));

							return function finishPaintTask() {
								return _ref5.apply(this, arguments);
							};
						}();

						var paintTask = this.renderer === _ui_utils.RendererType
							.SVG ? this.paintOnSvg(canvasWrapper) : this
							.paintOnCanvas(canvasWrapper);
						paintTask.onRenderContinue = renderContinueCallback;
						this.paintTask = paintTask;
						var resultPromise = paintTask.promise.then(function() {
							return finishPaintTask(null).then(function() {
								if (textLayer) {
									var readableStream = pdfPage
										.streamTextContent({
											includeMarkedContent: true
										});
									textLayer.setTextContentStream(
										readableStream);
									textLayer.render();
								}

								if (_this2.annotationLayer) {
									_this2._renderAnnotationLayer();
								}
							});
						}, function(reason) {
							return finishPaintTask(reason);
						});

						if (this.xfaLayerFactory) {
							if (!this.xfaLayer) {
								this.xfaLayer = this.xfaLayerFactory
									.createXfaLayerBuilder(div, pdfPage, null);
							}

							this._renderXfaLayer();
						}

						if (this.structTreeLayerFactory && this.textLayer && this
							.canvas) {
							this._onTextLayerRendered = function(event) {
								if (event.pageNumber !== _this2.id) {
									return;
								}

								_this2.eventBus._off("textlayerrendered", _this2
									._onTextLayerRendered);

								_this2._onTextLayerRendered = null;

								if (!_this2.canvas) {
									return;
								}

								_this2.pdfPage.getStructTree().then(function(
									tree) {
									if (!tree) {
										return;
									}

									if (!_this2.canvas) {
										return;
									}

									var treeDom = _this2.structTreeLayer
										.render(tree);

									treeDom.classList.add("structTree");

									_this2.canvas.appendChild(treeDom);
								});
							};

							this.eventBus._on("textlayerrendered", this
								._onTextLayerRendered);

							this.structTreeLayer = this.structTreeLayerFactory
								.createStructTreeLayerBuilder(pdfPage);
						}

						div.setAttribute("data-loaded", true);
						this.eventBus.dispatch("pagerender", {
							source: this,
							pageNumber: this.id
						});
						return resultPromise;
					}
				}, {
					key: "paintOnCanvas",
					value: function paintOnCanvas(canvasWrapper) {
						var renderCapability = (0, _pdfjsLib
							.createPromiseCapability)();
						var result = {
							promise: renderCapability.promise,
							onRenderContinue: function onRenderContinue(cont) {
								cont();
							},
							cancel: function cancel() {
								renderTask.cancel();
							}
						};
						var viewport = this.viewport;
						var canvas = document.createElement("canvas");
						canvas.hidden = true;
						var isCanvasHidden = true;

						var showCanvas = function showCanvas() {
							if (isCanvasHidden) {
								canvas.hidden = false;
								isCanvasHidden = false;
							}
						};

						canvasWrapper.appendChild(canvas);
						this.canvas = canvas;
						canvas.mozOpaque = true;
						var ctx = canvas.getContext("2d", {
							alpha: false
						});
						var outputScale = this.outputScale = new _ui_utils
							.OutputScale();

						if (this.useOnlyCssZoom) {
							var actualSizeViewport = viewport.clone({
								scale: _pdfjsLib.PixelsPerInch
									.PDF_TO_CSS_UNITS
							});
							outputScale.sx *= actualSizeViewport.width / viewport
								.width;
							outputScale.sy *= actualSizeViewport.height / viewport
								.height;
						}

						if (this.maxCanvasPixels > 0) {
							var pixelsInViewport = viewport.width * viewport.height;
							var maxScale = Math.sqrt(this.maxCanvasPixels /
								pixelsInViewport);

							if (outputScale.sx > maxScale || outputScale.sy >
								maxScale) {
								outputScale.sx = maxScale;
								outputScale.sy = maxScale;
								this.hasRestrictedScaling = true;
							} else {
								this.hasRestrictedScaling = false;
							}
						}

						var sfx = (0, _ui_utils.approximateFraction)(outputScale
						.sx);
						var sfy = (0, _ui_utils.approximateFraction)(outputScale
						.sy);
						canvas.width = (0, _ui_utils.roundToDivide)(viewport.width *
							outputScale.sx, sfx[0]);
						canvas.height = (0, _ui_utils.roundToDivide)(viewport
							.height * outputScale.sy, sfy[0]);
						canvas.style.width = (0, _ui_utils.roundToDivide)(viewport
							.width, sfx[1]) + "px";
						canvas.style.height = (0, _ui_utils.roundToDivide)(viewport
							.height, sfy[1]) + "px";
						this.paintedViewportMap.set(canvas, viewport);
						var transform = outputScale.scaled ? [outputScale.sx, 0, 0,
							outputScale.sy, 0, 0
						] : null;
						var renderContext = {
							canvasContext: ctx,
							transform: transform,
							viewport: this.viewport,
							annotationMode: _classPrivateFieldGet(this,
								_annotationMode),
							optionalContentConfigPromise: this
								._optionalContentConfigPromise,
							annotationCanvasMap: this._annotationCanvasMap
						};
						var renderTask = this.pdfPage.render(renderContext);

						renderTask.onContinue = function(cont) {
							showCanvas();

							if (result.onRenderContinue) {
								result.onRenderContinue(cont);
							} else {
								cont();
							}
						};

						renderTask.promise.then(function() {
							showCanvas();
							renderCapability.resolve();
						}, function(error) {
							showCanvas();
							renderCapability.reject(error);
						});
						return result;
					}
				}, {
					key: "paintOnSvg",
					value: function paintOnSvg(wrapper) {
						var _this3 = this;

						var cancelled = false;

						var ensureNotCancelled = function ensureNotCancelled() {
							if (cancelled) {
								throw new _pdfjsLib.RenderingCancelledException(
									"Rendering cancelled, page ".concat(
										_this3.id), "svg");
							}
						};

						var pdfPage = this.pdfPage;
						var actualSizeViewport = this.viewport.clone({
							scale: _pdfjsLib.PixelsPerInch.PDF_TO_CSS_UNITS
						});
						var promise = pdfPage.getOperatorList({
							annotationMode: _classPrivateFieldGet(this,
								_annotationMode)
						}).then(function(opList) {
							ensureNotCancelled();
							var svgGfx = new _pdfjsLib.SVGGraphics(pdfPage
								.commonObjs, pdfPage.objs);
							return svgGfx.getSVG(opList, actualSizeViewport)
								.then(function(svg) {
									ensureNotCancelled();
									_this3.svg = svg;

									_this3.paintedViewportMap.set(svg,
										actualSizeViewport);

									svg.style.width = wrapper.style
										.width;
									svg.style.height = wrapper.style
										.height;
									_this3.renderingState = _ui_utils
										.RenderingStates.FINISHED;
									wrapper.appendChild(svg);
								});
						});
						return {
							promise: promise,
							onRenderContinue: function onRenderContinue(cont) {
								cont();
							},
							cancel: function cancel() {
								cancelled = true;
							}
						};
					}
				}, {
					key: "setPageLabel",
					value: function setPageLabel(label) {
						this.pageLabel = typeof label === "string" ? label : null;

						if (this.pageLabel !== null) {
							this.div.setAttribute("data-page-label", this
							.pageLabel);
						} else {
							this.div.removeAttribute("data-page-label");
						}
					}
				}]);

				return PDFPageView;
			}();

			exports.PDFPageView = PDFPageView;

			/***/
		}),
		/* 34 */
		/***/
		((__unused_webpack_module, exports) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.StructTreeLayerBuilder = void 0;

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

			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);
			}

			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;
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var PDF_ROLE_TO_HTML_ROLE = {
				Document: null,
				DocumentFragment: null,
				Part: "group",
				Sect: "group",
				Div: "group",
				Aside: "note",
				NonStruct: "none",
				P: null,
				H: "heading",
				Title: null,
				FENote: "note",
				Sub: "group",
				Lbl: null,
				Span: null,
				Em: null,
				Strong: null,
				Link: "link",
				Annot: "note",
				Form: "form",
				Ruby: null,
				RB: null,
				RT: null,
				RP: null,
				Warichu: null,
				WT: null,
				WP: null,
				L: "list",
				LI: "listitem",
				LBody: null,
				Table: "table",
				TR: "row",
				TH: "columnheader",
				TD: "cell",
				THead: "columnheader",
				TBody: null,
				TFoot: null,
				Caption: null,
				Figure: "figure",
				Formula: null,
				Artifact: null
			};
			var HEADING_PATTERN = /^H(\d+)$/;

			var StructTreeLayerBuilder = /*#__PURE__*/ function() {
				function StructTreeLayerBuilder(_ref) {
					var pdfPage = _ref.pdfPage;

					_classCallCheck(this, StructTreeLayerBuilder);

					this.pdfPage = pdfPage;
				}

				_createClass(StructTreeLayerBuilder, [{
					key: "render",
					value: function render(structTree) {
						return this._walk(structTree);
					}
				}, {
					key: "_setAttributes",
					value: function _setAttributes(structElement, htmlElement) {
						if (structElement.alt !== undefined) {
							htmlElement.setAttribute("aria-label", structElement
								.alt);
						}

						if (structElement.id !== undefined) {
							htmlElement.setAttribute("aria-owns", structElement.id);
						}

						if (structElement.lang !== undefined) {
							htmlElement.setAttribute("lang", structElement.lang);
						}
					}
				}, {
					key: "_walk",
					value: function _walk(node) {
						if (!node) {
							return null;
						}

						var element = document.createElement("span");

						if ("role" in node) {
							var role = node.role;
							var match = role.match(HEADING_PATTERN);

							if (match) {
								element.setAttribute("role", "heading");
								element.setAttribute("aria-level", match[1]);
							} else if (PDF_ROLE_TO_HTML_ROLE[role]) {
								element.setAttribute("role", PDF_ROLE_TO_HTML_ROLE[
									role]);
							}
						}

						this._setAttributes(node, element);

						if (node.children) {
							if (node.children.length === 1 && "id" in node.children[
									0]) {
								this._setAttributes(node.children[0], element);
							} else {
								var _iterator = _createForOfIteratorHelper(node
										.children),
									_step;

								try {
									for (_iterator.s(); !(_step = _iterator.n())
										.done;) {
										var kid = _step.value;
										element.appendChild(this._walk(kid));
									}
								} catch (err) {
									_iterator.e(err);
								} finally {
									_iterator.f();
								}
							}
						}

						return element;
					}
				}]);

				return StructTreeLayerBuilder;
			}();

			exports.StructTreeLayerBuilder = StructTreeLayerBuilder;

			/***/
		}),
		/* 35 */
		/***/
		((__unused_webpack_module, exports) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.TextHighlighter = void 0;

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var TextHighlighter = /*#__PURE__*/ function() {
				function TextHighlighter(_ref) {
					var findController = _ref.findController,
						eventBus = _ref.eventBus,
						pageIndex = _ref.pageIndex;

					_classCallCheck(this, TextHighlighter);

					this.findController = findController;
					this.matches = [];
					this.eventBus = eventBus;
					this.pageIdx = pageIndex;
					this._onUpdateTextLayerMatches = null;
					this.textDivs = null;
					this.textContentItemsStr = null;
					this.enabled = false;
				}

				_createClass(TextHighlighter, [{
					key: "setTextMapping",
					value: function setTextMapping(divs, texts) {
						this.textDivs = divs;
						this.textContentItemsStr = texts;
					}
				}, {
					key: "enable",
					value: function enable() {
						var _this = this;

						if (!this.textDivs || !this.textContentItemsStr) {
							throw new Error(
								"Text divs and strings have not been set.");
						}

						if (this.enabled) {
							throw new Error("TextHighlighter is already enabled.");
						}

						this.enabled = true;

						if (!this._onUpdateTextLayerMatches) {
							this._onUpdateTextLayerMatches = function(evt) {
								if (evt.pageIndex === _this.pageIdx || evt
									.pageIndex === -1) {
									_this._updateMatches();
								}
							};

							this.eventBus._on("updatetextlayermatches", this
								._onUpdateTextLayerMatches);
						}

						this._updateMatches();
					}
				}, {
					key: "disable",
					value: function disable() {
						if (!this.enabled) {
							return;
						}

						this.enabled = false;

						if (this._onUpdateTextLayerMatches) {
							this.eventBus._off("updatetextlayermatches", this
								._onUpdateTextLayerMatches);

							this._onUpdateTextLayerMatches = null;
						}
					}
				}, {
					key: "_convertMatches",
					value: function _convertMatches(matches, matchesLength) {
						if (!matches) {
							return [];
						}

						var textContentItemsStr = this.textContentItemsStr;
						var i = 0,
							iIndex = 0;
						var end = textContentItemsStr.length - 1;
						var result = [];

						for (var m = 0, mm = matches.length; m < mm; m++) {
							var matchIdx = matches[m];

							while (i !== end && matchIdx >= iIndex +
								textContentItemsStr[i].length) {
								iIndex += textContentItemsStr[i].length;
								i++;
							}

							if (i === textContentItemsStr.length) {
								console.error("Could not find a matching mapping");
							}

							var match = {
								begin: {
									divIdx: i,
									offset: matchIdx - iIndex
								}
							};
							matchIdx += matchesLength[m];

							while (i !== end && matchIdx > iIndex +
								textContentItemsStr[i].length) {
								iIndex += textContentItemsStr[i].length;
								i++;
							}

							match.end = {
								divIdx: i,
								offset: matchIdx - iIndex
							};
							result.push(match);
						}

						return result;
					}
				}, {
					key: "_renderMatches",
					value: function _renderMatches(matches) {
						if (matches.length === 0) {
							return;
						}

						var findController = this.findController,
							pageIdx = this.pageIdx;
						var textContentItemsStr = this.textContentItemsStr,
							textDivs = this.textDivs;
						var isSelectedPage = pageIdx === findController.selected
							.pageIdx;
						var selectedMatchIdx = findController.selected.matchIdx;
						var highlightAll = findController.state.highlightAll;
						var prevEnd = null;
						var infinity = {
							divIdx: -1,
							offset: undefined
						};

						function beginText(begin, className) {
							var divIdx = begin.divIdx;
							textDivs[divIdx].textContent = "";
							return appendTextToDiv(divIdx, 0, begin.offset,
								className);
						}

						function appendTextToDiv(divIdx, fromOffset, toOffset,
							className) {
							var div = textDivs[divIdx];

							if (div.nodeType === Node.TEXT_NODE) {
								var span = document.createElement("span");
								div.parentNode.insertBefore(span, div);
								span.appendChild(div);
								textDivs[divIdx] = span;
								div = span;
							}

							var content = textContentItemsStr[divIdx].substring(
								fromOffset, toOffset);
							var node = document.createTextNode(content);

							if (className) {
								var _span = document.createElement("span");

								_span.className = "".concat(className, " appended");

								_span.appendChild(node);

								div.appendChild(_span);
								return className.includes("selected") ? _span
									.offsetLeft : 0;
							}

							div.appendChild(node);
							return 0;
						}

						var i0 = selectedMatchIdx,
							i1 = i0 + 1;

						if (highlightAll) {
							i0 = 0;
							i1 = matches.length;
						} else if (!isSelectedPage) {
							return;
						}

						for (var i = i0; i < i1; i++) {
							var match = matches[i];
							var begin = match.begin;
							var end = match.end;
							var isSelected = isSelectedPage && i ===
								selectedMatchIdx;
							var highlightSuffix = isSelected ? " selected" : "";
							var selectedLeft = 0;

							if (!prevEnd || begin.divIdx !== prevEnd.divIdx) {
								if (prevEnd !== null) {
									appendTextToDiv(prevEnd.divIdx, prevEnd.offset,
										infinity.offset);
								}

								beginText(begin);
							} else {
								appendTextToDiv(prevEnd.divIdx, prevEnd.offset,
									begin.offset);
							}

							if (begin.divIdx === end.divIdx) {
								selectedLeft = appendTextToDiv(begin.divIdx, begin
									.offset, end.offset, "highlight" +
									highlightSuffix);
							} else {
								selectedLeft = appendTextToDiv(begin.divIdx, begin
									.offset, infinity.offset,
									"highlight begin" + highlightSuffix);

								for (var n0 = begin.divIdx + 1, n1 = end
									.divIdx; n0 < n1; n0++) {
									textDivs[n0].className = "highlight middle" +
										highlightSuffix;
								}

								beginText(end, "highlight end" + highlightSuffix);
							}

							prevEnd = end;

							if (isSelected) {
								findController.scrollMatchIntoView({
									element: textDivs[begin.divIdx],
									selectedLeft: selectedLeft,
									pageIndex: pageIdx,
									matchIndex: selectedMatchIdx
								});
							}
						}

						if (prevEnd) {
							appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity
								.offset);
						}
					}
				}, {
					key: "_updateMatches",
					value: function _updateMatches() {
						if (!this.enabled) {
							return;
						}

						var findController = this.findController,
							matches = this.matches,
							pageIdx = this.pageIdx;
						var textContentItemsStr = this.textContentItemsStr,
							textDivs = this.textDivs;
						var clearedUntilDivIdx = -1;

						for (var i = 0, ii = matches.length; i < ii; i++) {
							var match = matches[i];
							var begin = Math.max(clearedUntilDivIdx, match.begin
								.divIdx);

							for (var n = begin, end = match.end.divIdx; n <=
								end; n++) {
								var div = textDivs[n];
								div.textContent = textContentItemsStr[n];
								div.className = "";
							}

							clearedUntilDivIdx = match.end.divIdx + 1;
						}

						if (!(findController !== null && findController !==
								void 0 && findController.highlightMatches)) {
							return;
						}

						var pageMatches = findController.pageMatches[pageIdx] ||
							null;
						var pageMatchesLength = findController.pageMatchesLength[
							pageIdx] || null;
						this.matches = this._convertMatches(pageMatches,
							pageMatchesLength);

						this._renderMatches(this.matches);
					}
				}]);

				return TextHighlighter;
			}();

			exports.TextHighlighter = TextHighlighter;

			/***/
		}),
		/* 36 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.TextLayerBuilder = void 0;

			var _pdfjsLib = __webpack_require__(7);

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var EXPAND_DIVS_TIMEOUT = 300;

			var TextLayerBuilder = /*#__PURE__*/ function() {
				function TextLayerBuilder(_ref) {
					var textLayerDiv = _ref.textLayerDiv,
						eventBus = _ref.eventBus,
						pageIndex = _ref.pageIndex,
						viewport = _ref.viewport,
						_ref$highlighter = _ref.highlighter,
						highlighter = _ref$highlighter === void 0 ? null : _ref$highlighter,
						_ref$enhanceTextSelec = _ref.enhanceTextSelection,
						enhanceTextSelection = _ref$enhanceTextSelec === void 0 ? false :
						_ref$enhanceTextSelec;

					_classCallCheck(this, TextLayerBuilder);

					this.textLayerDiv = textLayerDiv;
					this.eventBus = eventBus;
					this.textContent = null;
					this.textContentItemsStr = [];
					this.textContentStream = null;
					this.renderingDone = false;
					this.pageNumber = pageIndex + 1;
					this.viewport = viewport;
					this.textDivs = [];
					this.textLayerRenderTask = null;
					this.highlighter = highlighter;
					this.enhanceTextSelection = enhanceTextSelection;

					this._bindMouse();
				}

				_createClass(TextLayerBuilder, [{
					key: "_finishRendering",
					value: function _finishRendering() {
						this.renderingDone = true;

						if (!this.enhanceTextSelection) {
							var endOfContent = document.createElement("div");
							endOfContent.className = "endOfContent";
							this.textLayerDiv.appendChild(endOfContent);
						}

						this.eventBus.dispatch("textlayerrendered", {
							source: this,
							pageNumber: this.pageNumber,
							numTextDivs: this.textDivs.length
						});
					}
				}, {
					key: "render",
					value: function render() {
						var _this$highlighter,
							_this = this;

						var timeout = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : 0;

						if (!(this.textContent || this.textContentStream) || this
							.renderingDone) {
							return;
						}

						this.cancel();
						this.textDivs.length = 0;
						(_this$highlighter = this.highlighter) === null ||
							_this$highlighter === void 0 ? void 0 :
							_this$highlighter.setTextMapping(this.textDivs, this
								.textContentItemsStr);
						var textLayerFrag = document.createDocumentFragment();
						this.textLayerRenderTask = (0, _pdfjsLib.renderTextLayer)({
							textContent: this.textContent,
							textContentStream: this.textContentStream,
							container: textLayerFrag,
							viewport: this.viewport,
							textDivs: this.textDivs,
							textContentItemsStr: this.textContentItemsStr,
							timeout: timeout,
							enhanceTextSelection: this.enhanceTextSelection
						});
						this.textLayerRenderTask.promise.then(function() {
							var _this$highlighter2;

							_this.textLayerDiv.appendChild(textLayerFrag);

							_this._finishRendering();

							(_this$highlighter2 = _this.highlighter) ===
							null || _this$highlighter2 === void 0 ? void 0 :
								_this$highlighter2.enable();
						}, function(reason) {});
					}
				}, {
					key: "cancel",
					value: function cancel() {
						var _this$highlighter3;

						if (this.textLayerRenderTask) {
							this.textLayerRenderTask.cancel();
							this.textLayerRenderTask = null;
						}

						(_this$highlighter3 = this.highlighter) === null ||
							_this$highlighter3 === void 0 ? void 0 :
							_this$highlighter3.disable();
					}
				}, {
					key: "setTextContentStream",
					value: function setTextContentStream(readableStream) {
						this.cancel();
						this.textContentStream = readableStream;
					}
				}, {
					key: "setTextContent",
					value: function setTextContent(textContent) {
						this.cancel();
						this.textContent = textContent;
					}
				}, {
					key: "_bindMouse",
					value: function _bindMouse() {
						var _this2 = this;

						var div = this.textLayerDiv;
						var expandDivsTimer = null;
						div.addEventListener("mousedown", function(evt) {
							if (_this2.enhanceTextSelection && _this2
								.textLayerRenderTask) {
								_this2.textLayerRenderTask.expandTextDivs(
									true);

								if (expandDivsTimer) {
									clearTimeout(expandDivsTimer);
									expandDivsTimer = null;
								}

								return;
							}

							var end = div.querySelector(".endOfContent");

							if (!end) {
								return;
							}

							var adjustTop = evt.target !== div;
							adjustTop = adjustTop && window
								.getComputedStyle(end).getPropertyValue(
									"-moz-user-select") !== "none";

							if (adjustTop) {
								var divBounds = div.getBoundingClientRect();
								var r = Math.max(0, (evt.pageY - divBounds
									.top) / divBounds.height);
								end.style.top = (r * 100).toFixed(2) + "%";
							}

							end.classList.add("active");
						});
						div.addEventListener("mouseup", function() {
							if (_this2.enhanceTextSelection && _this2
								.textLayerRenderTask) {
								expandDivsTimer = setTimeout(function() {
									if (_this2
										.textLayerRenderTask) {
										_this2.textLayerRenderTask
											.expandTextDivs(false);
									}

									expandDivsTimer = null;
								}, EXPAND_DIVS_TIMEOUT);
								return;
							}

							var end = div.querySelector(".endOfContent");

							if (!end) {
								return;
							}

							end.style.top = "";
							end.classList.remove("active");
						});
					}
				}]);

				return TextLayerBuilder;
			}();

			exports.TextLayerBuilder = TextLayerBuilder;

			/***/
		}),
		/* 37 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.XfaLayerBuilder = void 0;

			var _pdfjsLib = __webpack_require__(7);

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var XfaLayerBuilder = /*#__PURE__*/ function() {
				function XfaLayerBuilder(_ref) {
					var pageDiv = _ref.pageDiv,
						pdfPage = _ref.pdfPage,
						_ref$annotationStorag = _ref.annotationStorage,
						annotationStorage = _ref$annotationStorag === void 0 ? null :
						_ref$annotationStorag,
						linkService = _ref.linkService,
						_ref$xfaHtml = _ref.xfaHtml,
						xfaHtml = _ref$xfaHtml === void 0 ? null : _ref$xfaHtml;

					_classCallCheck(this, XfaLayerBuilder);

					this.pageDiv = pageDiv;
					this.pdfPage = pdfPage;
					this.annotationStorage = annotationStorage;
					this.linkService = linkService;
					this.xfaHtml = xfaHtml;
					this.div = null;
					this._cancelled = false;
				}

				_createClass(XfaLayerBuilder, [{
					key: "render",
					value: function render(viewport) {
						var _this = this;

						var intent = arguments.length > 1 && arguments[1] !==
							undefined ? arguments[1] : "display";

						if (intent === "print") {
							var parameters = {
								viewport: viewport.clone({
									dontFlip: true
								}),
								div: this.div,
								xfaHtml: this.xfaHtml,
								annotationStorage: this.annotationStorage,
								linkService: this.linkService,
								intent: intent
							};
							var div = document.createElement("div");
							this.pageDiv.appendChild(div);
							parameters.div = div;

							var result = _pdfjsLib.XfaLayer.render(parameters);

							return Promise.resolve(result);
						}

						return this.pdfPage.getXfa().then(function(xfaHtml) {
							if (_this._cancelled || !xfaHtml) {
								return {
									textDivs: []
								};
							}

							var parameters = {
								viewport: viewport.clone({
									dontFlip: true
								}),
								div: _this.div,
								xfaHtml: xfaHtml,
								annotationStorage: _this
									.annotationStorage,
								linkService: _this.linkService,
								intent: intent
							};

							if (_this.div) {
								return _pdfjsLib.XfaLayer.update(
								parameters);
							}

							_this.div = document.createElement("div");

							_this.pageDiv.appendChild(_this.div);

							parameters.div = _this.div;
							return _pdfjsLib.XfaLayer.render(parameters);
						})["catch"](function(error) {
							console.error(error);
						});
					}
				}, {
					key: "cancel",
					value: function cancel() {
						this._cancelled = true;
					}
				}, {
					key: "hide",
					value: function hide() {
						if (!this.div) {
							return;
						}

						this.div.hidden = true;
					}
				}]);

				return XfaLayerBuilder;
			}();

			exports.XfaLayerBuilder = XfaLayerBuilder;

			/***/
		}),
		/* 38 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.SecondaryToolbar = void 0;

			var _ui_utils = __webpack_require__(5);

			var _pdf_cursor_tools = __webpack_require__(8);

			var _base_viewer = __webpack_require__(30);

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

			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);
			}

			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;
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var SecondaryToolbar = /*#__PURE__*/ function() {
				function SecondaryToolbar(options, mainContainer, eventBus) {
					_classCallCheck(this, SecondaryToolbar);

					this.toolbar = options.toolbar;
					this.toggleButton = options.toggleButton;
					this.toolbarButtonContainer = options.toolbarButtonContainer;
					this.buttons = [{
						element: options.presentationModeButton,
						eventName: "presentationmode",
						close: true
					}, {
						element: options.openFileButton,
						eventName: "openfile",
						close: true
					}, {
						element: options.printButton,
						eventName: "print",
						close: true
					}, {
						element: options.downloadButton,
						eventName: "download",
						close: true
					}, {
						element: options.viewBookmarkButton,
						eventName: null,
						close: true
					}, {
						element: options.firstPageButton,
						eventName: "firstpage",
						close: true
					}, {
						element: options.lastPageButton,
						eventName: "lastpage",
						close: true
					}, {
						element: options.pageRotateCwButton,
						eventName: "rotatecw",
						close: false
					}, {
						element: options.pageRotateCcwButton,
						eventName: "rotateccw",
						close: false
					}, {
						element: options.cursorSelectToolButton,
						eventName: "switchcursortool",
						eventDetails: {
							tool: _pdf_cursor_tools.CursorTool.SELECT
						},
						close: true
					}, {
						element: options.cursorHandToolButton,
						eventName: "switchcursortool",
						eventDetails: {
							tool: _pdf_cursor_tools.CursorTool.HAND
						},
						close: true
					}, {
						element: options.scrollPageButton,
						eventName: "switchscrollmode",
						eventDetails: {
							mode: _ui_utils.ScrollMode.PAGE
						},
						close: true
					}, {
						element: options.scrollVerticalButton,
						eventName: "switchscrollmode",
						eventDetails: {
							mode: _ui_utils.ScrollMode.VERTICAL
						},
						close: true
					}, {
						element: options.scrollHorizontalButton,
						eventName: "switchscrollmode",
						eventDetails: {
							mode: _ui_utils.ScrollMode.HORIZONTAL
						},
						close: true
					}, {
						element: options.scrollWrappedButton,
						eventName: "switchscrollmode",
						eventDetails: {
							mode: _ui_utils.ScrollMode.WRAPPED
						},
						close: true
					}, {
						element: options.spreadNoneButton,
						eventName: "switchspreadmode",
						eventDetails: {
							mode: _ui_utils.SpreadMode.NONE
						},
						close: true
					}, {
						element: options.spreadOddButton,
						eventName: "switchspreadmode",
						eventDetails: {
							mode: _ui_utils.SpreadMode.ODD
						},
						close: true
					}, {
						element: options.spreadEvenButton,
						eventName: "switchspreadmode",
						eventDetails: {
							mode: _ui_utils.SpreadMode.EVEN
						},
						close: true
					}, {
						element: options.documentPropertiesButton,
						eventName: "documentproperties",
						close: true
					}];
					this.items = {
						firstPage: options.firstPageButton,
						lastPage: options.lastPageButton,
						pageRotateCw: options.pageRotateCwButton,
						pageRotateCcw: options.pageRotateCcwButton
					};
					this.mainContainer = mainContainer;
					this.eventBus = eventBus;
					this.opened = false;
					this.containerHeight = null;
					this.previousContainerHeight = null;
					this.reset();

					this._bindClickListeners();

					this._bindCursorToolsListener(options);

					this._bindScrollModeListener(options);

					this._bindSpreadModeListener(options);

					this.eventBus._on("resize", this._setMaxHeight.bind(this));
				}

				_createClass(SecondaryToolbar, [{
					key: "isOpen",
					get: function get() {
						return this.opened;
					}
				}, {
					key: "setPageNumber",
					value: function setPageNumber(pageNumber) {
						this.pageNumber = pageNumber;

						this._updateUIState();
					}
				}, {
					key: "setPagesCount",
					value: function setPagesCount(pagesCount) {
						this.pagesCount = pagesCount;

						this._updateUIState();
					}
				}, {
					key: "reset",
					value: function reset() {
						this.pageNumber = 0;
						this.pagesCount = 0;

						this._updateUIState();

						this.eventBus.dispatch("secondarytoolbarreset", {
							source: this
						});
					}
				}, {
					key: "_updateUIState",
					value: function _updateUIState() {
						this.items.firstPage.disabled = this.pageNumber <= 1;
						this.items.lastPage.disabled = this.pageNumber >= this
							.pagesCount;
						this.items.pageRotateCw.disabled = this.pagesCount === 0;
						this.items.pageRotateCcw.disabled = this.pagesCount === 0;
					}
				}, {
					key: "_bindClickListeners",
					value: function _bindClickListeners() {
						var _this = this;

						this.toggleButton.addEventListener("click", this.toggle
							.bind(this));

						var _iterator = _createForOfIteratorHelper(this.buttons),
							_step;

						try {
							var _loop = function _loop() {
								var _step$value = _step.value,
									element = _step$value.element,
									eventName = _step$value.eventName,
									close = _step$value.close,
									eventDetails = _step$value.eventDetails;
								element.addEventListener("click", function(
								evt) {
									if (eventName !== null) {
										var details = {
											source: _this
										};

										for (var property in
												eventDetails) {
											details[property] =
												eventDetails[property];
										}

										_this.eventBus.dispatch(
											eventName, details);
									}

									if (close) {
										_this.close();
									}
								});
							};

							for (_iterator.s(); !(_step = _iterator.n()).done;) {
								_loop();
							}
						} catch (err) {
							_iterator.e(err);
						} finally {
							_iterator.f();
						}
					}
				}, {
					key: "_bindCursorToolsListener",
					value: function _bindCursorToolsListener(buttons) {
						this.eventBus._on("cursortoolchanged", function(_ref) {
							var tool = _ref.tool;
							buttons.cursorSelectToolButton.classList.toggle(
								"toggled", tool === _pdf_cursor_tools
								.CursorTool.SELECT);
							buttons.cursorHandToolButton.classList.toggle(
								"toggled", tool === _pdf_cursor_tools
								.CursorTool.HAND);
						});
					}
				}, {
					key: "_bindScrollModeListener",
					value: function _bindScrollModeListener(buttons) {
						var _this2 = this;

						var scrollModeChanged = function scrollModeChanged(_ref2) {
							var mode = _ref2.mode;
							buttons.scrollPageButton.classList.toggle("toggled",
								mode === _ui_utils.ScrollMode.PAGE);
							buttons.scrollVerticalButton.classList.toggle(
								"toggled", mode === _ui_utils.ScrollMode
								.VERTICAL);
							buttons.scrollHorizontalButton.classList.toggle(
								"toggled", mode === _ui_utils.ScrollMode
								.HORIZONTAL);
							buttons.scrollWrappedButton.classList.toggle(
								"toggled", mode === _ui_utils.ScrollMode
								.WRAPPED);
							var forceScrollModePage = _this2.pagesCount >
								_base_viewer.PagesCountLimit
								.FORCE_SCROLL_MODE_PAGE;
							buttons.scrollPageButton.disabled =
								forceScrollModePage;
							buttons.scrollVerticalButton.disabled =
								forceScrollModePage;
							buttons.scrollHorizontalButton.disabled =
								forceScrollModePage;
							buttons.scrollWrappedButton.disabled =
								forceScrollModePage;
							var isScrollModeHorizontal = mode === _ui_utils
								.ScrollMode.HORIZONTAL;
							buttons.spreadNoneButton.disabled =
								isScrollModeHorizontal;
							buttons.spreadOddButton.disabled =
								isScrollModeHorizontal;
							buttons.spreadEvenButton.disabled =
								isScrollModeHorizontal;
						};

						this.eventBus._on("scrollmodechanged", scrollModeChanged);

						this.eventBus._on("secondarytoolbarreset", function(evt) {
							if (evt.source === _this2) {
								scrollModeChanged({
									mode: _ui_utils.ScrollMode
										.VERTICAL
								});
							}
						});
					}
				}, {
					key: "_bindSpreadModeListener",
					value: function _bindSpreadModeListener(buttons) {
						var _this3 = this;

						function spreadModeChanged(_ref3) {
							var mode = _ref3.mode;
							buttons.spreadNoneButton.classList.toggle("toggled",
								mode === _ui_utils.SpreadMode.NONE);
							buttons.spreadOddButton.classList.toggle("toggled",
								mode === _ui_utils.SpreadMode.ODD);
							buttons.spreadEvenButton.classList.toggle("toggled",
								mode === _ui_utils.SpreadMode.EVEN);
						}

						this.eventBus._on("spreadmodechanged", spreadModeChanged);

						this.eventBus._on("secondarytoolbarreset", function(evt) {
							if (evt.source === _this3) {
								spreadModeChanged({
									mode: _ui_utils.SpreadMode.NONE
								});
							}
						});
					}
				}, {
					key: "open",
					value: function open() {
						if (this.opened) {
							return;
						}

						this.opened = true;

						this._setMaxHeight();

						this.toggleButton.classList.add("toggled");
						this.toggleButton.setAttribute("aria-expanded", "true");
						this.toolbar.classList.remove("hidden");
					}
				}, {
					key: "close",
					value: function close() {
						if (!this.opened) {
							return;
						}

						this.opened = false;
						this.toolbar.classList.add("hidden");
						this.toggleButton.classList.remove("toggled");
						this.toggleButton.setAttribute("aria-expanded", "false");
					}
				}, {
					key: "toggle",
					value: function toggle() {
						if (this.opened) {
							this.close();
						} else {
							this.open();
						}
					}
				}, {
					key: "_setMaxHeight",
					value: function _setMaxHeight() {
						if (!this.opened) {
							return;
						}

						this.containerHeight = this.mainContainer.clientHeight;

						if (this.containerHeight === this.previousContainerHeight) {
							return;
						}

						this.toolbarButtonContainer.style.maxHeight = "".concat(this
							.containerHeight - _ui_utils.SCROLLBAR_PADDING, "px"
							);
						this.previousContainerHeight = this.containerHeight;
					}
				}]);

				return SecondaryToolbar;
			}();

			exports.SecondaryToolbar = SecondaryToolbar;

			/***/
		}),
		/* 39 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.Toolbar = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _ui_utils = __webpack_require__(5);

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

			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);
				}
			}

			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);
					});
				};
			}

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

			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);
			}

			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;
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var PAGE_NUMBER_LOADING_INDICATOR = "visiblePageIsLoading";

			var Toolbar = /*#__PURE__*/ function() {
				function Toolbar(options, eventBus, l10n) {
					_classCallCheck(this, Toolbar);

					this.toolbar = options.container;
					this.eventBus = eventBus;
					this.l10n = l10n;
					this.buttons = [{
						element: options.previous,
						eventName: "previouspage"
					}, {
						element: options.next,
						eventName: "nextpage"
					}, {
						element: options.zoomIn,
						eventName: "zoomin"
					}, {
						element: options.zoomOut,
						eventName: "zoomout"
					}, {
						element: options.openFile,
						eventName: "openfile"
					}, {
						element: options.print,
						eventName: "print"
					}, {
						element: options.presentationModeButton,
						eventName: "presentationmode"
					}, {
						element: options.download,
						eventName: "download"
					}, {
						element: options.viewBookmark,
						eventName: null
					}];
					this.items = {
						numPages: options.numPages,
						pageNumber: options.pageNumber,
						scaleSelect: options.scaleSelect,
						customScaleOption: options.customScaleOption,
						previous: options.previous,
						next: options.next,
						zoomIn: options.zoomIn,
						zoomOut: options.zoomOut
					};
					this._wasLocalized = false;
					this.reset();

					this._bindListeners();
				}

				_createClass(Toolbar, [{
					key: "setPageNumber",
					value: function setPageNumber(pageNumber, pageLabel) {
						this.pageNumber = pageNumber;
						this.pageLabel = pageLabel;

						this._updateUIState(false);
					}
				}, {
					key: "setPagesCount",
					value: function setPagesCount(pagesCount, hasPageLabels) {
						this.pagesCount = pagesCount;
						this.hasPageLabels = hasPageLabels;

						this._updateUIState(true);
					}
				}, {
					key: "setPageScale",
					value: function setPageScale(pageScaleValue, pageScale) {
						this.pageScaleValue = (pageScaleValue || pageScale)
							.toString();
						this.pageScale = pageScale;

						this._updateUIState(false);
					}
				}, {
					key: "reset",
					value: function reset() {
						this.pageNumber = 0;
						this.pageLabel = null;
						this.hasPageLabels = false;
						this.pagesCount = 0;
						this.pageScaleValue = _ui_utils.DEFAULT_SCALE_VALUE;
						this.pageScale = _ui_utils.DEFAULT_SCALE;

						this._updateUIState(true);

						this.updateLoadingIndicatorState();
					}
				}, {
					key: "_bindListeners",
					value: function _bindListeners() {
						var _this = this;

						var _this$items = this.items,
							pageNumber = _this$items.pageNumber,
							scaleSelect = _this$items.scaleSelect;
						var self = this;

						var _iterator = _createForOfIteratorHelper(this.buttons),
							_step;

						try {
							var _loop = function _loop() {
								var _step$value = _step.value,
									element = _step$value.element,
									eventName = _step$value.eventName;
								element.addEventListener("click", function(
								evt) {
									if (eventName !== null) {
										_this.eventBus.dispatch(
											eventName, {
												source: _this
											});
									}
								});
							};

							for (_iterator.s(); !(_step = _iterator.n()).done;) {
								_loop();
							}
						} catch (err) {
							_iterator.e(err);
						} finally {
							_iterator.f();
						}

						pageNumber.addEventListener("click", function() {
							this.select();
						});
						pageNumber.addEventListener("change", function() {
							self.eventBus.dispatch("pagenumberchanged", {
								source: self,
								value: this.value
							});
						});
						scaleSelect.addEventListener("change", function() {
							if (this.value === "custom") {
								return;
							}

							self.eventBus.dispatch("scalechanged", {
								source: self,
								value: this.value
							});
						});
						scaleSelect.addEventListener("click", function(evt) {
							var target = evt.target;

							if (this.value === self.pageScaleValue && target
								.tagName.toUpperCase() === "OPTION") {
								this.blur();
							}
						});
						scaleSelect.oncontextmenu = _ui_utils.noContextMenuHandler;

						this.eventBus._on("localized", function() {
							_this._wasLocalized = true;

							_this._adjustScaleWidth();

							_this._updateUIState(true);
						});
					}
				}, {
					key: "_updateUIState",
					value: function _updateUIState() {
						var resetNumPages = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : false;

						if (!this._wasLocalized) {
							return;
						}

						var pageNumber = this.pageNumber,
							pagesCount = this.pagesCount,
							pageScaleValue = this.pageScaleValue,
							pageScale = this.pageScale,
							items = this.items;

						if (resetNumPages) {
							if (this.hasPageLabels) {
								items.pageNumber.type = "text";
							} else {
								items.pageNumber.type = "number";
								this.l10n.get("of_pages", {
									pagesCount: pagesCount
								}).then(function(msg) {
									items.numPages.textContent = msg;
								});
							}

							items.pageNumber.max = pagesCount;
						}

						if (this.hasPageLabels) {
							items.pageNumber.value = this.pageLabel;
							this.l10n.get("page_of_pages", {
								pageNumber: pageNumber,
								pagesCount: pagesCount
							}).then(function(msg) {
								items.numPages.textContent = msg;
							});
						} else {
							items.pageNumber.value = pageNumber;
						}

						items.previous.disabled = pageNumber <= 1;
						items.next.disabled = pageNumber >= pagesCount;
						items.zoomOut.disabled = pageScale <= _ui_utils.MIN_SCALE;
						items.zoomIn.disabled = pageScale >= _ui_utils.MAX_SCALE;
						this.l10n.get("page_scale_percent", {
							scale: Math.round(pageScale * 10000) / 100
						}).then(function(msg) {
							var predefinedValueFound = false;

							var _iterator2 = _createForOfIteratorHelper(
									items.scaleSelect.options),
								_step2;

							try {
								for (_iterator2.s(); !(_step2 = _iterator2
										.n()).done;) {
									var option = _step2.value;

									if (option.value !== pageScaleValue) {
										option.selected = false;
										continue;
									}

									option.selected = true;
									predefinedValueFound = true;
								}
							} catch (err) {
								_iterator2.e(err);
							} finally {
								_iterator2.f();
							}

							if (!predefinedValueFound) {
								items.customScaleOption.textContent = msg;
								items.customScaleOption.selected = true;
							}
						});
					}
				}, {
					key: "updateLoadingIndicatorState",
					value: function updateLoadingIndicatorState() {
						var loading = arguments.length > 0 && arguments[0] !==
							undefined ? arguments[0] : false;
						var pageNumberInput = this.items.pageNumber;
						pageNumberInput.classList.toggle(
							PAGE_NUMBER_LOADING_INDICATOR, loading);
					}
				}, {
					key: "_adjustScaleWidth",
					value: function() {
						var _adjustScaleWidth2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee() {
								var items, l10n, predefinedValuesPromise,
									style, scaleSelectContainerWidth,
									scaleSelectOverflow, canvas, ctx,
									maxWidth, _iterator3, _step3,
									predefinedValue, _ctx$measureText,
									width, doc;

								return _regenerator["default"].wrap(
									function _callee$(_context) {
										while (1) {
											switch (_context.prev =
												_context.next) {
												case 0:
													items = this.items,
														l10n = this
														.l10n;
													predefinedValuesPromise
														= Promise.all([
															l10n
															.get(
																"page_scale_auto"
																),
															l10n
															.get(
																"page_scale_actual"
																),
															l10n
															.get(
																"page_scale_fit"
																),
															l10n
															.get(
																"page_scale_width"
																)
														]);
													style =
														getComputedStyle(
															items
															.scaleSelect
															),
														scaleSelectContainerWidth =
														parseInt(style
															.getPropertyValue(
																"--scale-select-container-width"
																), 10),
														scaleSelectOverflow =
														parseInt(style
															.getPropertyValue(
																"--scale-select-overflow"
																), 10);
													canvas = document
														.createElement(
															"canvas");
													canvas.mozOpaque =
														true;
													ctx = canvas
														.getContext(
															"2d", {
																alpha: false
															});
													_context.next = 8;
													return _ui_utils
														.animationStarted;

												case 8:
													ctx.font = ""
														.concat(style
															.fontSize,
															" ").concat(
															style
															.fontFamily
															);
													maxWidth = 0;
													_context.t0 =
														_createForOfIteratorHelper;
													_context.next = 13;
													return predefinedValuesPromise;

												case 13:
													_context.t1 =
														_context.sent;
													_iterator3 = (0,
															_context.t0)
														(_context.t1);

													try {
														for (_iterator3
															.s(); !(
																_step3 =
																_iterator3
																.n())
															.done;) {
															predefinedValue
																= _step3
																.value;
															_ctx$measureText
																= ctx
																.measureText(
																	predefinedValue
																	),
																width =
																_ctx$measureText
																.width;

															if (width >
																maxWidth
																) {
																maxWidth
																	=
																	width;
															}
														}
													} catch (err) {
														_iterator3.e(
															err);
													} finally {
														_iterator3.f();
													}

													maxWidth += 2 *
														scaleSelectOverflow;

													if (maxWidth >
														scaleSelectContainerWidth
														) {
														doc = document
															.documentElement;
														doc.style
															.setProperty(
																"--scale-select-container-width",
																""
																.concat(
																	maxWidth,
																	"px"
																	));
													}

													canvas.width = 0;
													canvas.height = 0;
													canvas = ctx = null;

												case 21:
												case "end":
													return _context
														.stop();
											}
										}
									}, _callee, this);
							}));

						function _adjustScaleWidth() {
							return _adjustScaleWidth2.apply(this, arguments);
						}

						return _adjustScaleWidth;
					}()
				}]);

				return Toolbar;
			}();

			exports.Toolbar = Toolbar;

			/***/
		}),
		/* 40 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.ViewHistory = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

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

			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);
				}
			}

			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);
					});
				};
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var DEFAULT_VIEW_HISTORY_CACHE_SIZE = 20;

			var ViewHistory = /*#__PURE__*/ function() {
				function ViewHistory(fingerprint) {
					var _this = this;

					var cacheSize = arguments.length > 1 && arguments[1] !== undefined ? arguments[
						1] : DEFAULT_VIEW_HISTORY_CACHE_SIZE;

					_classCallCheck(this, ViewHistory);

					this.fingerprint = fingerprint;
					this.cacheSize = cacheSize;
					this._initializedPromise = this._readFromStorage().then(function(databaseStr) {
						var database = JSON.parse(databaseStr || "{}");
						var index = -1;

						if (!Array.isArray(database.files)) {
							database.files = [];
						} else {
							while (database.files.length >= _this.cacheSize) {
								database.files.shift();
							}

							for (var i = 0, ii = database.files.length; i < ii; i++) {
								var branch = database.files[i];

								if (branch.fingerprint === _this.fingerprint) {
									index = i;
									break;
								}
							}
						}

						if (index === -1) {
							index = database.files.push({
								fingerprint: _this.fingerprint
							}) - 1;
						}

						_this.file = database.files[index];
						_this.database = database;
					});
				}

				_createClass(ViewHistory, [{
					key: "_writeToStorage",
					value: function() {
						var _writeToStorage2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee() {
								var databaseStr;
								return _regenerator["default"].wrap(
									function _callee$(_context) {
										while (1) {
											switch (_context.prev =
												_context.next) {
												case 0:
													databaseStr = JSON
														.stringify(this
															.database);
													localStorage
														.setItem(
															"pdfjs.history",
															databaseStr
															);

												case 2:
												case "end":
													return _context
														.stop();
											}
										}
									}, _callee, this);
							}));

						function _writeToStorage() {
							return _writeToStorage2.apply(this, arguments);
						}

						return _writeToStorage;
					}()
				}, {
					key: "_readFromStorage",
					value: function() {
						var _readFromStorage2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee2() {
								return _regenerator["default"].wrap(
									function _callee2$(_context2) {
										while (1) {
											switch (_context2.prev =
												_context2.next) {
												case 0:
													return _context2
														.abrupt(
															"return",
															localStorage
															.getItem(
																"pdfjs.history"
																));

												case 1:
												case "end":
													return _context2
														.stop();
											}
										}
									}, _callee2);
							}));

						function _readFromStorage() {
							return _readFromStorage2.apply(this, arguments);
						}

						return _readFromStorage;
					}()
				}, {
					key: "set",
					value: function() {
						var _set = _asyncToGenerator( /*#__PURE__*/ _regenerator[
							"default"].mark(function _callee3(name, val) {
							return _regenerator["default"].wrap(
								function _callee3$(_context3) {
									while (1) {
										switch (_context3.prev =
											_context3.next) {
											case 0:
												_context3.next = 2;
												return this
													._initializedPromise;

											case 2:
												this.file[name] =
													val;
												return _context3
													.abrupt(
														"return",
														this
														._writeToStorage()
														);

											case 4:
											case "end":
												return _context3
													.stop();
										}
									}
								}, _callee3, this);
						}));

						function set(_x, _x2) {
							return _set.apply(this, arguments);
						}

						return set;
					}()
				}, {
					key: "setMultiple",
					value: function() {
						var _setMultiple = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee4(
								properties) {
								var name;
								return _regenerator["default"].wrap(
									function _callee4$(_context4) {
										while (1) {
											switch (_context4.prev =
												_context4.next) {
												case 0:
													_context4.next = 2;
													return this
														._initializedPromise;

												case 2:
													for (name in
														properties) {
														this.file[
															name] =
															properties[
																name];
													}

													return _context4
														.abrupt(
															"return",
															this
															._writeToStorage()
															);

												case 4:
												case "end":
													return _context4
														.stop();
											}
										}
									}, _callee4, this);
							}));

						function setMultiple(_x3) {
							return _setMultiple.apply(this, arguments);
						}

						return setMultiple;
					}()
				}, {
					key: "get",
					value: function() {
						var _get = _asyncToGenerator( /*#__PURE__*/ _regenerator[
							"default"].mark(function _callee5(name,
							defaultValue) {
							var val;
							return _regenerator["default"].wrap(
								function _callee5$(_context5) {
									while (1) {
										switch (_context5.prev =
											_context5.next) {
											case 0:
												_context5.next = 2;
												return this
													._initializedPromise;

											case 2:
												val = this.file[
													name];
												return _context5
													.abrupt(
														"return",
														val !==
														undefined ?
														val :
														defaultValue
														);

											case 4:
											case "end":
												return _context5
													.stop();
										}
									}
								}, _callee5, this);
						}));

						function get(_x4, _x5) {
							return _get.apply(this, arguments);
						}

						return get;
					}()
				}, {
					key: "getMultiple",
					value: function() {
						var _getMultiple = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee6(
								properties) {
								var values, name, val;
								return _regenerator["default"].wrap(
									function _callee6$(_context6) {
										while (1) {
											switch (_context6.prev =
												_context6.next) {
												case 0:
													_context6.next = 2;
													return this
														._initializedPromise;

												case 2:
													values = Object
														.create(null);

													for (name in
														properties) {
														val = this.file[
															name];
														values[name] =
															val !==
															undefined ?
															val :
															properties[
																name];
													}

													return _context6
														.abrupt(
															"return",
															values);

												case 5:
												case "end":
													return _context6
														.stop();
											}
										}
									}, _callee6, this);
							}));

						function getMultiple(_x6) {
							return _getMultiple.apply(this, arguments);
						}

						return getMultiple;
					}()
				}]);

				return ViewHistory;
			}();

			exports.ViewHistory = ViewHistory;

			/***/
		}),
		/* 41 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



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

			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.GenericCom = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _app = __webpack_require__(2);

			var _preferences = __webpack_require__(42);

			var _download_manager = __webpack_require__(43);

			var _genericl10n = __webpack_require__(44);

			var _generic_scripting = __webpack_require__(46);

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

			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);
				}
			}

			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);
					});
				};
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			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
					}
				});
				Object.defineProperty(subClass, "prototype", {
					writable: false
				});
				if (superClass) _setPrototypeOf(subClass, superClass);
			}

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

			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);
				};
			}

			function _possibleConstructorReturn(self, call) {
				if (call && (_typeof(call) === "object" || typeof call === "function")) {
					return call;
				} else if (call !== void 0) {
					throw new TypeError("Derived constructors may only return object or undefined");
				}
				return _assertThisInitialized(self);
			}

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

			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;
				}
			}

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

			;
			var GenericCom = {};
			exports.GenericCom = GenericCom;

			var GenericPreferences = /*#__PURE__*/ function(_BasePreferences) {
				_inherits(GenericPreferences, _BasePreferences);

				var _super = _createSuper(GenericPreferences);

				function GenericPreferences() {
					_classCallCheck(this, GenericPreferences);

					return _super.apply(this, arguments);
				}

				_createClass(GenericPreferences, [{
					key: "_writeToStorage",
					value: function() {
						var _writeToStorage2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee(
								prefObj) {
								return _regenerator["default"].wrap(
									function _callee$(_context) {
										while (1) {
											switch (_context.prev =
												_context.next) {
												case 0:
													localStorage
														.setItem(
															"pdfjs.preferences",
															JSON
															.stringify(
																prefObj)
															);

												case 1:
												case "end":
													return _context
														.stop();
											}
										}
									}, _callee);
							}));

						function _writeToStorage(_x) {
							return _writeToStorage2.apply(this, arguments);
						}

						return _writeToStorage;
					}()
				}, {
					key: "_readFromStorage",
					value: function() {
						var _readFromStorage2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee2(
								prefObj) {
								return _regenerator["default"].wrap(
									function _callee2$(_context2) {
										while (1) {
											switch (_context2.prev =
												_context2.next) {
												case 0:
													return _context2
														.abrupt(
															"return",
															JSON.parse(
																localStorage
																.getItem(
																	"pdfjs.preferences"
																	)));

												case 1:
												case "end":
													return _context2
														.stop();
											}
										}
									}, _callee2);
							}));

						function _readFromStorage(_x2) {
							return _readFromStorage2.apply(this, arguments);
						}

						return _readFromStorage;
					}()
				}]);

				return GenericPreferences;
			}(_preferences.BasePreferences);

			var GenericExternalServices = /*#__PURE__*/ function(_DefaultExternalServi) {
				_inherits(GenericExternalServices, _DefaultExternalServi);

				var _super2 = _createSuper(GenericExternalServices);

				function GenericExternalServices() {
					_classCallCheck(this, GenericExternalServices);

					return _super2.apply(this, arguments);
				}

				_createClass(GenericExternalServices, null, [{
					key: "createDownloadManager",
					value: function createDownloadManager(options) {
						return new _download_manager.DownloadManager();
					}
				}, {
					key: "createPreferences",
					value: function createPreferences() {
						return new GenericPreferences();
					}
				}, {
					key: "createL10n",
					value: function createL10n(_ref) {
						var _ref$locale = _ref.locale,
							locale = _ref$locale === void 0 ? "en-US" : _ref$locale;
						return new _genericl10n.GenericL10n(locale);
					}
				}, {
					key: "createScripting",
					value: function createScripting(_ref2) {
						var sandboxBundleSrc = _ref2.sandboxBundleSrc;
						return new _generic_scripting.GenericScripting(
							sandboxBundleSrc);
					}
				}]);

				return GenericExternalServices;
			}(_app.DefaultExternalServices);

			_app.PDFViewerApplication.externalServices = GenericExternalServices;

			/***/
		}),
		/* 42 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.BasePreferences = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _app_options = __webpack_require__(1);

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

			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);
				}
			}

			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);
					});
				};
			}

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

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var BasePreferences = /*#__PURE__*/ function() {
				function BasePreferences() {
					var _this = this;

					_classCallCheck(this, BasePreferences);

					if (this.constructor === BasePreferences) {
						throw new Error("Cannot initialize BasePreferences.");
					}

					Object.defineProperty(this, "defaults", {
						value: Object.freeze({
							"annotationMode": 2,
							"cursorToolOnLoad": 0,
							"defaultZoomValue": "",
							"disablePageLabels": false,
							"enablePermissions": false,
							"enablePrintAutoRotate": true,
							"enableScripting": true,
							"externalLinkTarget": 0,
							"historyUpdateUrl": false,
							"ignoreDestinationZoom": false,
							"pdfBugEnabled": false,
							"renderer": "canvas",
							"sidebarViewOnLoad": -1,
							"scrollModeOnLoad": -1,
							"spreadModeOnLoad": -1,
							"textLayerMode": 1,
							"useOnlyCssZoom": false,
							"viewerCssTheme": 0,
							"viewOnLoad": 0,
							"disableAutoFetch": false,
							"disableFontFace": false,
							"disableRange": false,
							"disableStream": false,
							"enableXfa": true
						}),
						writable: false,
						enumerable: true,
						configurable: false
					});
					this.prefs = Object.create(null);
					this._initializedPromise = this._readFromStorage(this.defaults).then(function(
						prefs) {
						for (var name in _this.defaults) {
							var prefValue = prefs === null || prefs === void 0 ? void 0 :
								prefs[name];

							if (_typeof(prefValue) === _typeof(_this.defaults[name])) {
								_this.prefs[name] = prefValue;
							}
						}
					});
				}

				_createClass(BasePreferences, [{
					key: "_writeToStorage",
					value: function() {
						var _writeToStorage2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee(
								prefObj) {
								return _regenerator["default"].wrap(
									function _callee$(_context) {
										while (1) {
											switch (_context.prev =
												_context.next) {
												case 0:
													throw new Error(
														"Not implemented: _writeToStorage"
														);

												case 1:
												case "end":
													return _context
														.stop();
											}
										}
									}, _callee);
							}));

						function _writeToStorage(_x) {
							return _writeToStorage2.apply(this, arguments);
						}

						return _writeToStorage;
					}()
				}, {
					key: "_readFromStorage",
					value: function() {
						var _readFromStorage2 = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee2(
								prefObj) {
								return _regenerator["default"].wrap(
									function _callee2$(_context2) {
										while (1) {
											switch (_context2.prev =
												_context2.next) {
												case 0:
													throw new Error(
														"Not implemented: _readFromStorage"
														);

												case 1:
												case "end":
													return _context2
														.stop();
											}
										}
									}, _callee2);
							}));

						function _readFromStorage(_x2) {
							return _readFromStorage2.apply(this, arguments);
						}

						return _readFromStorage;
					}()
				}, {
					key: "reset",
					value: function() {
						var _reset = _asyncToGenerator( /*#__PURE__*/ _regenerator[
							"default"].mark(function _callee3() {
							return _regenerator["default"].wrap(
								function _callee3$(_context3) {
									while (1) {
										switch (_context3.prev =
											_context3.next) {
											case 0:
												_context3.next = 2;
												return this
													._initializedPromise;

											case 2:
												this.prefs = Object
													.create(null);
												return _context3
													.abrupt(
														"return",
														this
														._writeToStorage(
															this
															.defaults
															));

											case 4:
											case "end":
												return _context3
													.stop();
										}
									}
								}, _callee3, this);
						}));

						function reset() {
							return _reset.apply(this, arguments);
						}

						return reset;
					}()
				}, {
					key: "set",
					value: function() {
						var _set = _asyncToGenerator( /*#__PURE__*/ _regenerator[
							"default"].mark(function _callee4(name, value) {
							var defaultValue, valueType, defaultType;
							return _regenerator["default"].wrap(
								function _callee4$(_context4) {
									while (1) {
										switch (_context4.prev =
											_context4.next) {
											case 0:
												_context4.next = 2;
												return this
													._initializedPromise;

											case 2:
												defaultValue = this
													.defaults[name];

												if (!(defaultValue ===
														undefined
														)) {
													_context4.next =
														7;
													break;
												}

												throw new Error(
													"Set preference: \""
													.concat(
														name,
														"\" is undefined."
														));

											case 7:
												if (!(value ===
														undefined
														)) {
													_context4.next =
														9;
													break;
												}

												throw new Error(
													"Set preference: no value is specified."
													);

											case 9:
												valueType = _typeof(
													value);
												defaultType =
													_typeof(
														defaultValue
														);

												if (!(valueType !==
														defaultType
														)) {
													_context4.next =
														19;
													break;
												}

												if (!(valueType ===
														"number" &&
														defaultType ===
														"string")) {
													_context4.next =
														16;
													break;
												}

												value = value
													.toString();
												_context4.next = 17;
												break;

											case 16:
												throw new Error(
													"Set preference: \""
													.concat(
														value,
														"\" is a "
														)
													.concat(
														valueType,
														", expected a "
														)
													.concat(
														defaultType,
														"."));

											case 17:
												_context4.next = 21;
												break;

											case 19:
												if (!(valueType ===
														"number" &&
														!Number
														.isInteger(
															value)
														)) {
													_context4.next =
														21;
													break;
												}

												throw new Error(
													"Set preference: \""
													.concat(
														value,
														"\" must be an integer."
														));

											case 21:
												this.prefs[name] =
													value;
												return _context4
													.abrupt(
														"return",
														this
														._writeToStorage(
															this
															.prefs)
														);

											case 23:
											case "end":
												return _context4
													.stop();
										}
									}
								}, _callee4, this);
						}));

						function set(_x3, _x4) {
							return _set.apply(this, arguments);
						}

						return set;
					}()
				}, {
					key: "get",
					value: function() {
						var _get = _asyncToGenerator( /*#__PURE__*/ _regenerator[
							"default"].mark(function _callee5(name) {
							var defaultValue, prefValue;
							return _regenerator["default"].wrap(
								function _callee5$(_context5) {
									while (1) {
										switch (_context5.prev =
											_context5.next) {
											case 0:
												_context5.next = 2;
												return this
													._initializedPromise;

											case 2:
												defaultValue = this
													.defaults[name],
													prefValue = this
													.prefs[name];

												if (!(defaultValue ===
														undefined
														)) {
													_context5.next =
														5;
													break;
												}

												throw new Error(
													"Get preference: \""
													.concat(
														name,
														"\" is undefined."
														));

											case 5:
												return _context5
													.abrupt(
														"return",
														prefValue !==
														undefined ?
														prefValue :
														defaultValue
														);

											case 6:
											case "end":
												return _context5
													.stop();
										}
									}
								}, _callee5, this);
						}));

						function get(_x5) {
							return _get.apply(this, arguments);
						}

						return get;
					}()
				}, {
					key: "getAll",
					value: function() {
						var _getAll = _asyncToGenerator( /*#__PURE__*/ _regenerator[
							"default"].mark(function _callee6() {
							var obj, name, prefValue;
							return _regenerator["default"].wrap(
								function _callee6$(_context6) {
									while (1) {
										switch (_context6.prev =
											_context6.next) {
											case 0:
												_context6.next = 2;
												return this
													._initializedPromise;

											case 2:
												obj = Object.create(
													null);

												for (name in this
													.defaults) {
													prefValue = this
														.prefs[
														name];
													obj[name] =
														prefValue !==
														undefined ?
														prefValue :
														this
														.defaults[
															name];
												}

												return _context6
													.abrupt(
														"return",
														obj);

											case 5:
											case "end":
												return _context6
													.stop();
										}
									}
								}, _callee6, this);
						}));

						function getAll() {
							return _getAll.apply(this, arguments);
						}

						return getAll;
					}()
				}]);

				return BasePreferences;
			}();

			exports.BasePreferences = BasePreferences;

			/***/
		}),
		/* 43 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.DownloadManager = void 0;

			var _pdfjsLib = __webpack_require__(7);

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			;

			function _download(blobUrl, filename) {
				var a = document.createElement("a");

				if (!a.click) {
					throw new Error('DownloadManager: "a.click()" is not supported.');
				}

				a.href = blobUrl;
				a.target = "_parent";

				if ("download" in a) {
					a.download = filename;
				}

				(document.body || document.documentElement).appendChild(a);
				a.click();
				a.remove();
			}

			var DownloadManager = /*#__PURE__*/ function() {
				function DownloadManager() {
					_classCallCheck(this, DownloadManager);

					this._openBlobUrls = new WeakMap();
				}

				_createClass(DownloadManager, [{
					key: "downloadUrl",
					value: function downloadUrl(url, filename) {
						if (!(0, _pdfjsLib.createValidAbsoluteUrl)(url,
								"http://example.com")) {
							console.error("downloadUrl - not a valid URL: ".concat(
								url));
							return;
						}

						_download(url + "#pdfjs.action=download", filename);
					}
				}, {
					key: "downloadData",
					value: function downloadData(data, filename, contentType) {
						var blobUrl = URL.createObjectURL(new Blob([data], {
							type: contentType
						}));

						_download(blobUrl, filename);
					}
				}, {
					key: "openOrDownloadData",
					value: function openOrDownloadData(element, data, filename) {
						var isPdfData = (0, _pdfjsLib.isPdfFile)(filename);
						var contentType = isPdfData ? "application/pdf" : "";

						if (isPdfData) {
							var blobUrl = this._openBlobUrls.get(element);

							if (!blobUrl) {
								blobUrl = URL.createObjectURL(new Blob([data], {
									type: contentType
								}));

								this._openBlobUrls.set(element, blobUrl);
							}

							var viewerUrl;
							viewerUrl = "?file=" + encodeURIComponent(blobUrl +
								"#" + filename);

							try {
								window.open(viewerUrl);
								return true;
							} catch (ex) {
								console.error("openOrDownloadData: ".concat(ex));
								URL.revokeObjectURL(blobUrl);

								this._openBlobUrls["delete"](element);
							}
						}

						this.downloadData(data, filename, contentType);
						return false;
					}
				}, {
					key: "download",
					value: function download(blob, url, filename) {
						var sourceEventType = arguments.length > 3 && arguments[
							3] !== undefined ? arguments[3] : "download";
						var blobUrl = URL.createObjectURL(blob);

						_download(blobUrl, filename);
					}
				}]);

				return DownloadManager;
			}();

			exports.DownloadManager = DownloadManager;

			/***/
		}),
		/* 44 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.GenericL10n = void 0;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			__webpack_require__(45);

			var _l10n_utils = __webpack_require__(32);

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

			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);
				}
			}

			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);
					});
				};
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			var webL10n = document.webL10n;

			var GenericL10n = /*#__PURE__*/ function() {
				function GenericL10n(lang) {
					_classCallCheck(this, GenericL10n);

					this._lang = lang;
					this._ready = new Promise(function(resolve, reject) {
						webL10n.setLanguage((0, _l10n_utils.fixupLangCode)(lang),
					function() {
							resolve(webL10n);
						});
					});
				}

				_createClass(GenericL10n, [{
					key: "getLanguage",
					value: function() {
						var _getLanguage = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee() {
								var l10n;
								return _regenerator["default"].wrap(
									function _callee$(_context) {
										while (1) {
											switch (_context.prev =
												_context.next) {
												case 0:
													_context.next = 2;
													return this._ready;

												case 2:
													l10n = _context
													.sent;
													return _context
														.abrupt(
															"return",
															l10n
															.getLanguage()
															);

												case 4:
												case "end":
													return _context
														.stop();
											}
										}
									}, _callee, this);
							}));

						function getLanguage() {
							return _getLanguage.apply(this, arguments);
						}

						return getLanguage;
					}()
				}, {
					key: "getDirection",
					value: function() {
						var _getDirection = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee2() {
								var l10n;
								return _regenerator["default"].wrap(
									function _callee2$(_context2) {
										while (1) {
											switch (_context2.prev =
												_context2.next) {
												case 0:
													_context2.next = 2;
													return this._ready;

												case 2:
													l10n = _context2
														.sent;
													return _context2
														.abrupt(
															"return",
															l10n
															.getDirection()
															);

												case 4:
												case "end":
													return _context2
														.stop();
											}
										}
									}, _callee2, this);
							}));

						function getDirection() {
							return _getDirection.apply(this, arguments);
						}

						return getDirection;
					}()
				}, {
					key: "get",
					value: function() {
						var _get = _asyncToGenerator( /*#__PURE__*/ _regenerator[
							"default"].mark(function _callee3(key) {
							var args,
								fallback,
								l10n,
								_args3 = arguments;
							return _regenerator["default"].wrap(
								function _callee3$(_context3) {
									while (1) {
										switch (_context3.prev =
											_context3.next) {
											case 0:
												args = _args3
													.length > 1 &&
													_args3[1] !==
													undefined ?
													_args3[1] :
													null;
												fallback = _args3
													.length > 2 &&
													_args3[2] !==
													undefined ?
													_args3[2] : (0,
														_l10n_utils
														.getL10nFallback
														)(key,
													args);
												_context3.next = 4;
												return this._ready;

											case 4:
												l10n = _context3
													.sent;
												return _context3
													.abrupt(
														"return",
														l10n.get(
															key,
															args,
															fallback
															));

											case 6:
											case "end":
												return _context3
													.stop();
										}
									}
								}, _callee3, this);
						}));

						function get(_x) {
							return _get.apply(this, arguments);
						}

						return get;
					}()
				}, {
					key: "translate",
					value: function() {
						var _translate = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee4(
								element) {
								var l10n;
								return _regenerator["default"].wrap(
									function _callee4$(_context4) {
										while (1) {
											switch (_context4.prev =
												_context4.next) {
												case 0:
													_context4.next = 2;
													return this._ready;

												case 2:
													l10n = _context4
														.sent;
													return _context4
														.abrupt(
															"return",
															l10n
															.translate(
																element)
															);

												case 4:
												case "end":
													return _context4
														.stop();
											}
										}
									}, _callee4, this);
							}));

						function translate(_x2) {
							return _translate.apply(this, arguments);
						}

						return translate;
					}()
				}]);

				return GenericL10n;
			}();

			exports.GenericL10n = GenericL10n;

			/***/
		}),
		/* 45 */
		/***/
		(() => {



			document.webL10n = function(window, document, undefined) {
				var gL10nData = {};
				var gTextData = '';
				var gTextProp = 'textContent';
				var gLanguage = '';
				var gMacros = {};
				var gReadyState = 'loading';
				var gAsyncResourceLoading = true;

				function getL10nResourceLinks() {
					return document.querySelectorAll('link[type="application/l10n"]');
				}

				function getL10nDictionary() {
					var script = document.querySelector('script[type="application/l10n"]');
					return script ? JSON.parse(script.innerHTML) : null;
				}

				function getTranslatableChildren(element) {
					return element ? element.querySelectorAll('*[data-l10n-id]') : [];
				}

				function getL10nAttributes(element) {
					if (!element) return {};
					var l10nId = element.getAttribute('data-l10n-id');
					var l10nArgs = element.getAttribute('data-l10n-args');
					var args = {};

					if (l10nArgs) {
						try {
							args = JSON.parse(l10nArgs);
						} catch (e) {
							console.warn('could not parse arguments for #' + l10nId);
						}
					}

					return {
						id: l10nId,
						args: args
					};
				}

				function xhrLoadText(url, onSuccess, onFailure) {
					onSuccess = onSuccess || function _onSuccess(data) {};

					onFailure = onFailure || function _onFailure() {};

					var xhr = new XMLHttpRequest();
					xhr.open('GET', url, gAsyncResourceLoading);

					if (xhr.overrideMimeType) {
						xhr.overrideMimeType('text/plain; charset=utf-8');
					}

					xhr.onreadystatechange = function() {
						if (xhr.readyState == 4) {
							if (xhr.status == 200 || xhr.status === 0) {
								onSuccess(xhr.responseText);
							} else {
								onFailure();
							}
						}
					};

					xhr.onerror = onFailure;
					xhr.ontimeout = onFailure;

					try {
						xhr.send(null);
					} catch (e) {
						onFailure();
					}
				}

				function parseResource(href, lang, successCallback, failureCallback) {
					var baseURL = href.replace(/[^\/]*$/, '') || './';

					function evalString(text) {
						if (text.lastIndexOf('\\') < 0) return text;
						return text.replace(/\\\\/g, '\\').replace(/\\n/g, '\n').replace(/\\r/g,
								'\r').replace(/\\t/g, '\t').replace(/\\b/g, '\b').replace(/\\f/g,
								'\f').replace(/\\{/g, '{').replace(/\\}/g, '}').replace(/\\"/g, '"')
							.replace(/\\'/g, "'");
					}

					function parseProperties(text, parsedPropertiesCallback) {
						var dictionary = {};
						var reBlank = /^\s*|\s*$/;
						var reComment = /^\s*#|^\s*$/;
						var reSection = /^\s*\[(.*)\]\s*$/;
						var reImport = /^\s*@import\s+url\((.*)\)\s*$/i;
						var reSplit = /^([^=\s]*)\s*=\s*(.+)$/;

						function parseRawLines(rawText, extendedSyntax, parsedRawLinesCallback) {
							var entries = rawText.replace(reBlank, '').split(/[\r\n]+/);
							var currentLang = '*';
							var genericLang = lang.split('-', 1)[0];
							var skipLang = false;
							var match = '';

							function nextEntry() {
								while (true) {
									if (!entries.length) {
										parsedRawLinesCallback();
										return;
									}

									var line = entries.shift();
									if (reComment.test(line)) continue;

									if (extendedSyntax) {
										match = reSection.exec(line);

										if (match) {
											currentLang = match[1].toLowerCase();
											skipLang = currentLang !== '*' && currentLang !==
												lang && currentLang !== genericLang;
											continue;
										} else if (skipLang) {
											continue;
										}

										match = reImport.exec(line);

										if (match) {
											loadImport(baseURL + match[1], nextEntry);
											return;
										}
									}

									var tmp = line.match(reSplit);

									if (tmp && tmp.length == 3) {
										dictionary[tmp[1]] = evalString(tmp[2]);
									}
								}
							}

							nextEntry();
						}

						function loadImport(url, callback) {
							xhrLoadText(url, function(content) {
								parseRawLines(content, false, callback);
							}, function() {
								console.warn(url + ' not found.');
								callback();
							});
						}

						parseRawLines(text, true, function() {
							parsedPropertiesCallback(dictionary);
						});
					}

					xhrLoadText(href, function(response) {
						gTextData += response;
						parseProperties(response, function(data) {
							for (var key in data) {
								var id,
									prop,
									index = key.lastIndexOf('.');

								if (index > 0) {
									id = key.substring(0, index);
									prop = key.substring(index + 1);
								} else {
									id = key;
									prop = gTextProp;
								}

								if (!gL10nData[id]) {
									gL10nData[id] = {};
								}

								gL10nData[id][prop] = data[key];
							}

							if (successCallback) {
								successCallback();
							}
						});
					}, failureCallback);
				}

				function loadLocale(lang, callback) {
					if (lang) {
						lang = lang.toLowerCase();
					}

					callback = callback || function _callback() {};

					clear();
					gLanguage = lang;
					var langLinks = getL10nResourceLinks();
					var langCount = langLinks.length;

					if (langCount === 0) {
						var dict = getL10nDictionary();

						if (dict && dict.locales && dict.default_locale) {
							console.log('using the embedded JSON directory, early way out');
							gL10nData = dict.locales[lang];

							if (!gL10nData) {
								var defaultLocale = dict.default_locale.toLowerCase();

								for (var anyCaseLang in dict.locales) {
									anyCaseLang = anyCaseLang.toLowerCase();

									if (anyCaseLang === lang) {
										gL10nData = dict.locales[lang];
										break;
									} else if (anyCaseLang === defaultLocale) {
										gL10nData = dict.locales[defaultLocale];
									}
								}
							}

							callback();
						} else {
							console.log('no resource to load, early way out');
						}

						gReadyState = 'complete';
						return;
					}

					var onResourceLoaded = null;
					var gResourceCount = 0;

					onResourceLoaded = function onResourceLoaded() {
						gResourceCount++;

						if (gResourceCount >= langCount) {
							callback();
							gReadyState = 'complete';
						}
					};

					function L10nResourceLink(link) {
						var href = link.href;

						this.load = function(lang, callback) {
							parseResource(href, lang, callback, function() {
								console.warn(href + ' not found.');
								console.warn('"' + lang + '" resource not found');
								gLanguage = '';
								callback();
							});
						};
					}

					for (var i = 0; i < langCount; i++) {
						var resource = new L10nResourceLink(langLinks[i]);
						resource.load(lang, onResourceLoaded);
					}
				}

				function clear() {
					gL10nData = {};
					gTextData = '';
					gLanguage = '';
				}

				function getPluralRules(lang) {
					var locales2rules = {
						'af': 3,
						'ak': 4,
						'am': 4,
						'ar': 1,
						'asa': 3,
						'az': 0,
						'be': 11,
						'bem': 3,
						'bez': 3,
						'bg': 3,
						'bh': 4,
						'bm': 0,
						'bn': 3,
						'bo': 0,
						'br': 20,
						'brx': 3,
						'bs': 11,
						'ca': 3,
						'cgg': 3,
						'chr': 3,
						'cs': 12,
						'cy': 17,
						'da': 3,
						'de': 3,
						'dv': 3,
						'dz': 0,
						'ee': 3,
						'el': 3,
						'en': 3,
						'eo': 3,
						'es': 3,
						'et': 3,
						'eu': 3,
						'fa': 0,
						'ff': 5,
						'fi': 3,
						'fil': 4,
						'fo': 3,
						'fr': 5,
						'fur': 3,
						'fy': 3,
						'ga': 8,
						'gd': 24,
						'gl': 3,
						'gsw': 3,
						'gu': 3,
						'guw': 4,
						'gv': 23,
						'ha': 3,
						'haw': 3,
						'he': 2,
						'hi': 4,
						'hr': 11,
						'hu': 0,
						'id': 0,
						'ig': 0,
						'ii': 0,
						'is': 3,
						'it': 3,
						'iu': 7,
						'ja': 0,
						'jmc': 3,
						'jv': 0,
						'ka': 0,
						'kab': 5,
						'kaj': 3,
						'kcg': 3,
						'kde': 0,
						'kea': 0,
						'kk': 3,
						'kl': 3,
						'km': 0,
						'kn': 0,
						'ko': 0,
						'ksb': 3,
						'ksh': 21,
						'ku': 3,
						'kw': 7,
						'lag': 18,
						'lb': 3,
						'lg': 3,
						'ln': 4,
						'lo': 0,
						'lt': 10,
						'lv': 6,
						'mas': 3,
						'mg': 4,
						'mk': 16,
						'ml': 3,
						'mn': 3,
						'mo': 9,
						'mr': 3,
						'ms': 0,
						'mt': 15,
						'my': 0,
						'nah': 3,
						'naq': 7,
						'nb': 3,
						'nd': 3,
						'ne': 3,
						'nl': 3,
						'nn': 3,
						'no': 3,
						'nr': 3,
						'nso': 4,
						'ny': 3,
						'nyn': 3,
						'om': 3,
						'or': 3,
						'pa': 3,
						'pap': 3,
						'pl': 13,
						'ps': 3,
						'pt': 3,
						'rm': 3,
						'ro': 9,
						'rof': 3,
						'ru': 11,
						'rwk': 3,
						'sah': 0,
						'saq': 3,
						'se': 7,
						'seh': 3,
						'ses': 0,
						'sg': 0,
						'sh': 11,
						'shi': 19,
						'sk': 12,
						'sl': 14,
						'sma': 7,
						'smi': 7,
						'smj': 7,
						'smn': 7,
						'sms': 7,
						'sn': 3,
						'so': 3,
						'sq': 3,
						'sr': 11,
						'ss': 3,
						'ssy': 3,
						'st': 3,
						'sv': 3,
						'sw': 3,
						'syr': 3,
						'ta': 3,
						'te': 3,
						'teo': 3,
						'th': 0,
						'ti': 4,
						'tig': 3,
						'tk': 3,
						'tl': 4,
						'tn': 3,
						'to': 0,
						'tr': 0,
						'ts': 3,
						'tzm': 22,
						'uk': 11,
						'ur': 3,
						've': 3,
						'vi': 0,
						'vun': 3,
						'wa': 4,
						'wae': 3,
						'wo': 0,
						'xh': 3,
						'xog': 3,
						'yo': 0,
						'zh': 0,
						'zu': 3
					};

					function isIn(n, list) {
						return list.indexOf(n) !== -1;
					}

					function isBetween(n, start, end) {
						return start <= n && n <= end;
					}

					var pluralRules = {
						'0': function _(n) {
							return 'other';
						},
						'1': function _(n) {
							if (isBetween(n % 100, 3, 10)) return 'few';
							if (n === 0) return 'zero';
							if (isBetween(n % 100, 11, 99)) return 'many';
							if (n == 2) return 'two';
							if (n == 1) return 'one';
							return 'other';
						},
						'2': function _(n) {
							if (n !== 0 && n % 10 === 0) return 'many';
							if (n == 2) return 'two';
							if (n == 1) return 'one';
							return 'other';
						},
						'3': function _(n) {
							if (n == 1) return 'one';
							return 'other';
						},
						'4': function _(n) {
							if (isBetween(n, 0, 1)) return 'one';
							return 'other';
						},
						'5': function _(n) {
							if (isBetween(n, 0, 2) && n != 2) return 'one';
							return 'other';
						},
						'6': function _(n) {
							if (n === 0) return 'zero';
							if (n % 10 == 1 && n % 100 != 11) return 'one';
							return 'other';
						},
						'7': function _(n) {
							if (n == 2) return 'two';
							if (n == 1) return 'one';
							return 'other';
						},
						'8': function _(n) {
							if (isBetween(n, 3, 6)) return 'few';
							if (isBetween(n, 7, 10)) return 'many';
							if (n == 2) return 'two';
							if (n == 1) return 'one';
							return 'other';
						},
						'9': function _(n) {
							if (n === 0 || n != 1 && isBetween(n % 100, 1, 19))
						return 'few';
							if (n == 1) return 'one';
							return 'other';
						},
						'10': function _(n) {
							if (isBetween(n % 10, 2, 9) && !isBetween(n % 100, 11, 19))
								return 'few';
							if (n % 10 == 1 && !isBetween(n % 100, 11, 19)) return 'one';
							return 'other';
						},
						'11': function _(n) {
							if (isBetween(n % 10, 2, 4) && !isBetween(n % 100, 12, 14))
								return 'few';
							if (n % 10 === 0 || isBetween(n % 10, 5, 9) || isBetween(n %
									100, 11, 14)) return 'many';
							if (n % 10 == 1 && n % 100 != 11) return 'one';
							return 'other';
						},
						'12': function _(n) {
							if (isBetween(n, 2, 4)) return 'few';
							if (n == 1) return 'one';
							return 'other';
						},
						'13': function _(n) {
							if (isBetween(n % 10, 2, 4) && !isBetween(n % 100, 12, 14))
								return 'few';
							if (n != 1 && isBetween(n % 10, 0, 1) || isBetween(n % 10, 5,
								9) || isBetween(n % 100, 12, 14)) return 'many';
							if (n == 1) return 'one';
							return 'other';
						},
						'14': function _(n) {
							if (isBetween(n % 100, 3, 4)) return 'few';
							if (n % 100 == 2) return 'two';
							if (n % 100 == 1) return 'one';
							return 'other';
						},
						'15': function _(n) {
							if (n === 0 || isBetween(n % 100, 2, 10)) return 'few';
							if (isBetween(n % 100, 11, 19)) return 'many';
							if (n == 1) return 'one';
							return 'other';
						},
						'16': function _(n) {
							if (n % 10 == 1 && n != 11) return 'one';
							return 'other';
						},
						'17': function _(n) {
							if (n == 3) return 'few';
							if (n === 0) return 'zero';
							if (n == 6) return 'many';
							if (n == 2) return 'two';
							if (n == 1) return 'one';
							return 'other';
						},
						'18': function _(n) {
							if (n === 0) return 'zero';
							if (isBetween(n, 0, 2) && n !== 0 && n != 2) return 'one';
							return 'other';
						},
						'19': function _(n) {
							if (isBetween(n, 2, 10)) return 'few';
							if (isBetween(n, 0, 1)) return 'one';
							return 'other';
						},
						'20': function _(n) {
							if ((isBetween(n % 10, 3, 4) || n % 10 == 9) && !(isBetween(n %
										100, 10, 19) || isBetween(n % 100, 70, 79) ||
									isBetween(n % 100, 90, 99))) return 'few';
							if (n % 1000000 === 0 && n !== 0) return 'many';
							if (n % 10 == 2 && !isIn(n % 100, [12, 72, 92])) return 'two';
							if (n % 10 == 1 && !isIn(n % 100, [11, 71, 91])) return 'one';
							return 'other';
						},
						'21': function _(n) {
							if (n === 0) return 'zero';
							if (n == 1) return 'one';
							return 'other';
						},
						'22': function _(n) {
							if (isBetween(n, 0, 1) || isBetween(n, 11, 99)) return 'one';
							return 'other';
						},
						'23': function _(n) {
							if (isBetween(n % 10, 1, 2) || n % 20 === 0) return 'one';
							return 'other';
						},
						'24': function _(n) {
							if (isBetween(n, 3, 10) || isBetween(n, 13, 19)) return 'few';
							if (isIn(n, [2, 12])) return 'two';
							if (isIn(n, [1, 11])) return 'one';
							return 'other';
						}
					};
					var index = locales2rules[lang.replace(/-.*$/, '')];

					if (!(index in pluralRules)) {
						console.warn('plural form unknown for [' + lang + ']');
						return function() {
							return 'other';
						};
					}

					return pluralRules[index];
				}

				gMacros.plural = function(str, param, key, prop) {
					var n = parseFloat(param);
					if (isNaN(n)) return str;
					if (prop != gTextProp) return str;

					if (!gMacros._pluralRules) {
						gMacros._pluralRules = getPluralRules(gLanguage);
					}

					var index = '[' + gMacros._pluralRules(n) + ']';

					if (n === 0 && key + '[zero]' in gL10nData) {
						str = gL10nData[key + '[zero]'][prop];
					} else if (n == 1 && key + '[one]' in gL10nData) {
						str = gL10nData[key + '[one]'][prop];
					} else if (n == 2 && key + '[two]' in gL10nData) {
						str = gL10nData[key + '[two]'][prop];
					} else if (key + index in gL10nData) {
						str = gL10nData[key + index][prop];
					} else if (key + '[other]' in gL10nData) {
						str = gL10nData[key + '[other]'][prop];
					}

					return str;
				};

				function getL10nData(key, args, fallback) {
					var data = gL10nData[key];

					if (!data) {
						console.warn('#' + key + ' is undefined.');

						if (!fallback) {
							return null;
						}

						data = fallback;
					}

					var rv = {};

					for (var prop in data) {
						var str = data[prop];
						str = substIndexes(str, args, key, prop);
						str = substArguments(str, args, key);
						rv[prop] = str;
					}

					return rv;
				}

				function substIndexes(str, args, key, prop) {
					var reIndex = /\{\[\s*([a-zA-Z]+)\(([a-zA-Z]+)\)\s*\]\}/;
					var reMatch = reIndex.exec(str);
					if (!reMatch || !reMatch.length) return str;
					var macroName = reMatch[1];
					var paramName = reMatch[2];
					var param;

					if (args && paramName in args) {
						param = args[paramName];
					} else if (paramName in gL10nData) {
						param = gL10nData[paramName];
					}

					if (macroName in gMacros) {
						var macro = gMacros[macroName];
						str = macro(str, param, key, prop);
					}

					return str;
				}

				function substArguments(str, args, key) {
					var reArgs = /\{\{\s*(.+?)\s*\}\}/g;
					return str.replace(reArgs, function(matched_text, arg) {
						if (args && arg in args) {
							return args[arg];
						}

						if (arg in gL10nData) {
							return gL10nData[arg];
						}

						console.log('argument {{' + arg + '}} for #' + key +
							' is undefined.');
						return matched_text;
					});
				}

				function translateElement(element) {
					var l10n = getL10nAttributes(element);
					if (!l10n.id) return;
					var data = getL10nData(l10n.id, l10n.args);

					if (!data) {
						console.warn('#' + l10n.id + ' is undefined.');
						return;
					}

					if (data[gTextProp]) {
						if (getChildElementCount(element) === 0) {
							element[gTextProp] = data[gTextProp];
						} else {
							var children = element.childNodes;
							var found = false;

							for (var i = 0, l = children.length; i < l; i++) {
								if (children[i].nodeType === 3 && /\S/.test(children[i]
									.nodeValue)) {
									if (found) {
										children[i].nodeValue = '';
									} else {
										children[i].nodeValue = data[gTextProp];
										found = true;
									}
								}
							}

							if (!found) {
								var textNode = document.createTextNode(data[gTextProp]);
								element.insertBefore(textNode, element.firstChild);
							}
						}

						delete data[gTextProp];
					}

					for (var k in data) {
						element[k] = data[k];
					}
				}

				function getChildElementCount(element) {
					if (element.children) {
						return element.children.length;
					}

					if (typeof element.childElementCount !== 'undefined') {
						return element.childElementCount;
					}

					var count = 0;

					for (var i = 0; i < element.childNodes.length; i++) {
						count += element.nodeType === 1 ? 1 : 0;
					}

					return count;
				}

				function translateFragment(element) {
					element = element || document.documentElement;
					var children = getTranslatableChildren(element);
					var elementCount = children.length;

					for (var i = 0; i < elementCount; i++) {
						translateElement(children[i]);
					}

					translateElement(element);
				}

				return {
					get: function get(key, args, fallbackString) {
						var index = key.lastIndexOf('.');
						var prop = gTextProp;

						if (index > 0) {
							prop = key.substring(index + 1);
							key = key.substring(0, index);
						}

						var fallback;

						if (fallbackString) {
							fallback = {};
							fallback[prop] = fallbackString;
						}

						var data = getL10nData(key, args, fallback);

						if (data && prop in data) {
							return data[prop];
						}

						return '{{' + key + '}}';
					},
					getData: function getData() {
						return gL10nData;
					},
					getText: function getText() {
						return gTextData;
					},
					getLanguage: function getLanguage() {
						return gLanguage;
					},
					setLanguage: function setLanguage(lang, callback) {
						loadLocale(lang, function() {
							if (callback) callback();
						});
					},
					getDirection: function getDirection() {
						var rtlList = ['ar', 'he', 'fa', 'ps', 'ur'];
						var shortCode = gLanguage.split('-', 1)[0];
						return rtlList.indexOf(shortCode) >= 0 ? 'rtl' : 'ltr';
					},
					translate: translateFragment,
					getReadyState: function getReadyState() {
						return gReadyState;
					},
					ready: function ready(callback) {
						if (!callback) {
							return;
						} else if (gReadyState == 'complete' || gReadyState == 'interactive') {
							window.setTimeout(function() {
								callback();
							});
						} else if (document.addEventListener) {
							document.addEventListener('localized', function once() {
								document.removeEventListener('localized', once);
								callback();
							});
						}
					}
				};
			}(window, document);

			/***/
		}),
		/* 46 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.GenericScripting = void 0;
			exports.docPropertiesLookup = docPropertiesLookup;

			var _regenerator = _interopRequireDefault(__webpack_require__(3));

			var _pdfjsLib = __webpack_require__(7);

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

			function ownKeys(object, enumerableOnly) {
				var keys = Object.keys(object);
				if (Object.getOwnPropertySymbols) {
					var symbols = Object.getOwnPropertySymbols(object);
					enumerableOnly && (symbols = symbols.filter(function(sym) {
						return Object.getOwnPropertyDescriptor(object, sym).enumerable;
					})), keys.push.apply(keys, symbols);
				}
				return keys;
			}

			function _objectSpread(target) {
				for (var i = 1; i < arguments.length; i++) {
					var source = null != arguments[i] ? arguments[i] : {};
					i % 2 ? ownKeys(Object(source), !0).forEach(function(key) {
						_defineProperty(target, key, source[key]);
					}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object
						.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(
						function(key) {
							Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(
								source, key));
						});
				}
				return target;
			}

			function _defineProperty(obj, key, value) {
				if (key in obj) {
					Object.defineProperty(obj, key, {
						value: value,
						enumerable: true,
						configurable: true,
						writable: true
					});
				} else {
					obj[key] = value;
				}
				return obj;
			}

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

			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);
				}
			}

			function _createClass(Constructor, protoProps, staticProps) {
				if (protoProps) _defineProperties(Constructor.prototype, protoProps);
				if (staticProps) _defineProperties(Constructor, staticProps);
				Object.defineProperty(Constructor, "prototype", {
					writable: false
				});
				return Constructor;
			}

			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);
				}
			}

			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);
					});
				};
			}

			function docPropertiesLookup(_x) {
				return _docPropertiesLookup.apply(this, arguments);
			}

			function _docPropertiesLookup() {
				_docPropertiesLookup = _asyncToGenerator( /*#__PURE__*/ _regenerator["default"].mark(
					function _callee4(pdfDocument) {
						var url, baseUrl, _yield$pdfDocument$ge, info, metadata,
							contentDispositionFilename, contentLength, _yield$pdfDocument$ge2,
							length;

						return _regenerator["default"].wrap(function _callee4$(_context4) {
							while (1) {
								switch (_context4.prev = _context4.next) {
									case 0:
										url = "", baseUrl = url.split("#")[0];
										_context4.next = 3;
										return pdfDocument.getMetadata();

									case 3:
										_yield$pdfDocument$ge = _context4.sent;
										info = _yield$pdfDocument$ge.info;
										metadata = _yield$pdfDocument$ge.metadata;
										contentDispositionFilename =
											_yield$pdfDocument$ge
											.contentDispositionFilename;
										contentLength = _yield$pdfDocument$ge
											.contentLength;

										if (contentLength) {
											_context4.next = 14;
											break;
										}

										_context4.next = 11;
										return pdfDocument.getDownloadInfo();

									case 11:
										_yield$pdfDocument$ge2 = _context4.sent;
										length = _yield$pdfDocument$ge2.length;
										contentLength = length;

									case 14:
										return _context4.abrupt("return", _objectSpread(
											_objectSpread({}, info), {}, {
												baseURL: baseUrl,
												filesize: contentLength,
												filename: contentDispositionFilename ||
													(0, _pdfjsLib
														.getPdfFilenameFromUrl)(
														url),
												metadata: metadata === null ||
													metadata === void 0 ?
													void 0 : metadata.getRaw(),
												authors: metadata === null ||
													metadata === void 0 ?
													void 0 : metadata.get(
														"dc:creator"),
												numPages: pdfDocument.numPages,
												URL: url
											}));

									case 15:
									case "end":
										return _context4.stop();
								}
							}
						}, _callee4);
					}));
				return _docPropertiesLookup.apply(this, arguments);
			}

			var GenericScripting = /*#__PURE__*/ function() {
				function GenericScripting(sandboxBundleSrc) {
					_classCallCheck(this, GenericScripting);

					this._ready = (0, _pdfjsLib.loadScript)(sandboxBundleSrc, true).then(
				function() {
						return window.pdfjsSandbox.QuickJSSandbox();
					});
				}

				_createClass(GenericScripting, [{
					key: "createSandbox",
					value: function() {
						var _createSandbox = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee(
							data) {
								var sandbox;
								return _regenerator["default"].wrap(
									function _callee$(_context) {
										while (1) {
											switch (_context.prev =
												_context.next) {
												case 0:
													_context.next = 2;
													return this._ready;

												case 2:
													sandbox = _context
														.sent;
													sandbox.create(
													data);

												case 4:
												case "end":
													return _context
														.stop();
											}
										}
									}, _callee, this);
							}));

						function createSandbox(_x2) {
							return _createSandbox.apply(this, arguments);
						}

						return createSandbox;
					}()
				}, {
					key: "dispatchEventInSandbox",
					value: function() {
						var _dispatchEventInSandbox =
						_asyncToGenerator( /*#__PURE__*/ _regenerator["default"]
							.mark(function _callee2(event) {
								var sandbox;
								return _regenerator["default"].wrap(
									function _callee2$(_context2) {
										while (1) {
											switch (_context2.prev =
												_context2.next) {
												case 0:
													_context2.next = 2;
													return this._ready;

												case 2:
													sandbox = _context2
														.sent;
													setTimeout(
													function() {
														return sandbox
															.dispatchEvent(
																event
																);
													}, 0);

												case 4:
												case "end":
													return _context2
														.stop();
											}
										}
									}, _callee2, this);
							}));

						function dispatchEventInSandbox(_x3) {
							return _dispatchEventInSandbox.apply(this, arguments);
						}

						return dispatchEventInSandbox;
					}()
				}, {
					key: "destroySandbox",
					value: function() {
						var _destroySandbox = _asyncToGenerator( /*#__PURE__*/
							_regenerator["default"].mark(function _callee3() {
								var sandbox;
								return _regenerator["default"].wrap(
									function _callee3$(_context3) {
										while (1) {
											switch (_context3.prev =
												_context3.next) {
												case 0:
													_context3.next = 2;
													return this._ready;

												case 2:
													sandbox = _context3
														.sent;
													sandbox
													.nukeSandbox();

												case 4:
												case "end":
													return _context3
														.stop();
											}
										}
									}, _callee3, this);
							}));

						function destroySandbox() {
							return _destroySandbox.apply(this, arguments);
						}

						return destroySandbox;
					}()
				}]);

				return GenericScripting;
			}();

			exports.GenericScripting = GenericScripting;

			/***/
		}),
		/* 47 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.PDFPrintService = PDFPrintService;

			var _pdfjsLib = __webpack_require__(7);

			var _app = __webpack_require__(2);

			var _print_utils = __webpack_require__(48);

			var activeService = null;
			var overlayManager = null;

			function renderPage(activeServiceOnEntry, pdfDocument, pageNumber, size, printResolution,
				optionalContentConfigPromise) {
				var scratchCanvas = activeService.scratchCanvas;
				var PRINT_UNITS = printResolution / _pdfjsLib.PixelsPerInch.PDF;
				scratchCanvas.width = Math.floor(size.width * PRINT_UNITS);
				scratchCanvas.height = Math.floor(size.height * PRINT_UNITS);
				var ctx = scratchCanvas.getContext("2d");
				ctx.save();
				ctx.fillStyle = "rgb(255, 255, 255)";
				ctx.fillRect(0, 0, scratchCanvas.width, scratchCanvas.height);
				ctx.restore();
				return pdfDocument.getPage(pageNumber).then(function(pdfPage) {
					var renderContext = {
						canvasContext: ctx,
						transform: [PRINT_UNITS, 0, 0, PRINT_UNITS, 0, 0],
						viewport: pdfPage.getViewport({
							scale: 1,
							rotation: size.rotation
						}),
						intent: "print",
						annotationMode: _pdfjsLib.AnnotationMode.ENABLE_STORAGE,
						optionalContentConfigPromise: optionalContentConfigPromise
					};
					return pdfPage.render(renderContext).promise;
				});
			}

			function PDFPrintService(pdfDocument, pagesOverview, printContainer, printResolution) {
				var optionalContentConfigPromise = arguments.length > 4 && arguments[4] !== undefined ?
					arguments[4] : null;
				var l10n = arguments.length > 5 ? arguments[5] : undefined;
				this.pdfDocument = pdfDocument;
				this.pagesOverview = pagesOverview;
				this.printContainer = printContainer;
				this._printResolution = printResolution || 150;
				this._optionalContentConfigPromise = optionalContentConfigPromise || pdfDocument
					.getOptionalContentConfig();
				this.l10n = l10n;
				this.currentPage = -1;
				this.scratchCanvas = document.createElement("canvas");
			}

			PDFPrintService.prototype = {
				layout: function layout() {
					this.throwIfInactive();
					var body = document.querySelector("body");
					body.setAttribute("data-pdfjsprinting", true);
					var hasEqualPageSizes = this.pagesOverview.every(function(size) {
						return size.width === this.pagesOverview[0].width && size
							.height === this.pagesOverview[0].height;
					}, this);

					if (!hasEqualPageSizes) {
						console.warn("Not all pages have the same size. The printed " +
							"result may be incorrect!");
					}

					this.pageStyleSheet = document.createElement("style");
					var pageSize = this.pagesOverview[0];
					this.pageStyleSheet.textContent = "@page { size: " + pageSize.width +
						"pt " + pageSize.height + "pt;}";
					body.appendChild(this.pageStyleSheet);
				},
				destroy: function destroy() {
					if (activeService !== this) {
						return;
					}

					this.printContainer.textContent = "";
					var body = document.querySelector("body");
					body.removeAttribute("data-pdfjsprinting");

					if (this.pageStyleSheet) {
						this.pageStyleSheet.remove();
						this.pageStyleSheet = null;
					}

					this.scratchCanvas.width = this.scratchCanvas.height = 0;
					this.scratchCanvas = null;
					activeService = null;
					ensureOverlay().then(function() {
						if (overlayManager.active !== "printServiceOverlay") {
							return;
						}

						overlayManager.close("printServiceOverlay");
					});
				},
				renderPages: function renderPages() {
					var _this = this;

					if (this.pdfDocument.isPureXfa) {
						(0, _print_utils.getXfaHtmlForPrinting)(this.printContainer, this
							.pdfDocument);
						return Promise.resolve();
					}

					var pageCount = this.pagesOverview.length;

					var renderNextPage = function renderNextPage(resolve, reject) {
						_this.throwIfInactive();

						if (++_this.currentPage >= pageCount) {
							renderProgress(pageCount, pageCount, _this.l10n);
							resolve();
							return;
						}

						var index = _this.currentPage;
						renderProgress(index, pageCount, _this.l10n);
						renderPage(_this, _this.pdfDocument, index + 1, _this.pagesOverview[
								index], _this._printResolution, _this
							._optionalContentConfigPromise).then(_this.useRenderedPage
							.bind(_this)).then(function() {
							renderNextPage(resolve, reject);
						}, reject);
					};

					return new Promise(renderNextPage);
				},
				useRenderedPage: function useRenderedPage() {
					this.throwIfInactive();
					var img = document.createElement("img");
					var scratchCanvas = this.scratchCanvas;

					if ("toBlob" in scratchCanvas) {
						scratchCanvas.toBlob(function(blob) {
							img.src = URL.createObjectURL(blob);
						});
					} else {
						img.src = scratchCanvas.toDataURL();
					}

					var wrapper = document.createElement("div");
					wrapper.className = "printedPage";
					wrapper.appendChild(img);
					this.printContainer.appendChild(wrapper);
					return new Promise(function(resolve, reject) {
						img.onload = resolve;
						img.onerror = reject;
					});
				},
				performPrint: function performPrint() {
					var _this2 = this;

					this.throwIfInactive();
					return new Promise(function(resolve) {
						setTimeout(function() {
							if (!_this2.active) {
								resolve();
								return;
							}

							print.call(window);
							setTimeout(resolve, 20);
						}, 0);
					});
				},

				get active() {
					return this === activeService;
				},

				throwIfInactive: function throwIfInactive() {
					if (!this.active) {
						throw new Error("This print request was cancelled or completed.");
					}
				}
			};
			var print = window.print;

			window.print = function() {
				if (activeService) {
					console.warn("Ignored window.print() because of a pending print job.");
					return;
				}

				ensureOverlay().then(function() {
					if (activeService) {
						overlayManager.open("printServiceOverlay");
					}
				});

				try {
					dispatchEvent("beforeprint");
				} finally {
					if (!activeService) {
						console.error("Expected print service to be initialized.");
						ensureOverlay().then(function() {
							if (overlayManager.active === "printServiceOverlay") {
								overlayManager.close("printServiceOverlay");
							}
						});
						return;
					}

					var activeServiceOnEntry = activeService;
					activeService.renderPages().then(function() {
						return activeServiceOnEntry.performPrint();
					})["catch"](function() {}).then(function() {
						if (activeServiceOnEntry.active) {
							abort();
						}
					});
				}
			};

			function dispatchEvent(eventType) {
				var event = document.createEvent("CustomEvent");
				event.initCustomEvent(eventType, false, false, "custom");
				window.dispatchEvent(event);
			}

			function abort() {
				if (activeService) {
					activeService.destroy();
					dispatchEvent("afterprint");
				}
			}

			function renderProgress(index, total, l10n) {
				var progressContainer = document.getElementById("printServiceOverlay");
				var progress = Math.round(100 * index / total);
				var progressBar = progressContainer.querySelector("progress");
				var progressPerc = progressContainer.querySelector(".relative-progress");
				progressBar.value = progress;
				l10n.get("print_progress_percent", {
					progress: progress
				}).then(function(msg) {
					progressPerc.textContent = msg;
				});
			}

			window.addEventListener("keydown", function(event) {
				if (event.keyCode === 80 && (event.ctrlKey || event.metaKey) && !event.altKey &&
					(!event.shiftKey || window.chrome || window.opera)) {
					window.print();
					event.preventDefault();

					if (event.stopImmediatePropagation) {
						event.stopImmediatePropagation();
					} else {
						event.stopPropagation();
					}
				}
			}, true);

			if ("onbeforeprint" in window) {
				var stopPropagationIfNeeded = function stopPropagationIfNeeded(event) {
					if (event.detail !== "custom" && event.stopImmediatePropagation) {
						event.stopImmediatePropagation();
					}
				};

				window.addEventListener("beforeprint", stopPropagationIfNeeded);
				window.addEventListener("afterprint", stopPropagationIfNeeded);
			}

			var overlayPromise;

			function ensureOverlay() {
				if (!overlayPromise) {
					overlayManager = _app.PDFViewerApplication.overlayManager;

					if (!overlayManager) {
						throw new Error("The overlay manager has not yet been initialized.");
					}

					overlayPromise = overlayManager.register("printServiceOverlay", document
						.getElementById("printServiceOverlay"), abort, true);
					document.getElementById("printCancel").onclick = abort;
				}

				return overlayPromise;
			}

			_app.PDFPrintServiceFactory.instance = {
				supportsPrinting: true,
				createPrintService: function createPrintService(pdfDocument, pagesOverview,
					printContainer, printResolution, optionalContentConfigPromise, l10n) {
					if (activeService) {
						throw new Error("The print service is created and active.");
					}

					activeService = new PDFPrintService(pdfDocument, pagesOverview,
						printContainer, printResolution, optionalContentConfigPromise, l10n);
					return activeService;
				}
			};

			/***/
		}),
		/* 48 */
		/***/
		((__unused_webpack_module, exports, __webpack_require__) => {



			Object.defineProperty(exports, "__esModule", ({
				value: true
			}));
			exports.getXfaHtmlForPrinting = getXfaHtmlForPrinting;

			var _pdfjsLib = __webpack_require__(7);

			var _pdf_link_service = __webpack_require__(10);

			var _xfa_layer_builder = __webpack_require__(37);

			function _createForOfIteratorHelper(o, allowArrayLike) {
				var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
				if (!it) {
					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 = it.call(o);
					},
					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;
						}
					}
				};
			}

			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);
			}

			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;
			}

			function getXfaHtmlForPrinting(printContainer, pdfDocument) {
				var xfaHtml = pdfDocument.allXfaHtml;
				var linkService = new _pdf_link_service.SimpleLinkService();
				var scale = Math.round(_pdfjsLib.PixelsPerInch.PDF_TO_CSS_UNITS * 100) / 100;

				var _iterator = _createForOfIteratorHelper(xfaHtml.children),
					_step;

				try {
					for (_iterator.s(); !(_step = _iterator.n()).done;) {
						var xfaPage = _step.value;
						var page = document.createElement("div");
						page.className = "xfaPrintedPage";
						printContainer.appendChild(page);
						var builder = new _xfa_layer_builder.XfaLayerBuilder({
							pageDiv: page,
							pdfPage: null,
							annotationStorage: pdfDocument.annotationStorage,
							linkService: linkService,
							xfaHtml: xfaPage
						});
						var viewport = (0, _pdfjsLib.getXfaPageViewport)(xfaPage, {
							scale: scale
						});
						builder.render(viewport, "print");
					}
				} catch (err) {
					_iterator.e(err);
				} finally {
					_iterator.f();
				}
			}

			/***/
		})
		/******/
	]);
	/************************************************************************/
	/******/ // The module cache
	/******/
	var __webpack_module_cache__ = {};
	/******/
	/******/ // The require function
	/******/
	function __webpack_require__(moduleId) {
		/******/ // Check if module is in cache
		/******/
		var cachedModule = __webpack_module_cache__[moduleId];
		/******/
		if (cachedModule !== undefined) {
			/******/
			return cachedModule.exports;
			/******/
		}
		/******/ // Create a new module (and put it into the cache)
		/******/
		var module = __webpack_module_cache__[moduleId] = {
			/******/
			id: moduleId,
			/******/
			loaded: false,
			/******/
			exports: {}
			/******/
		};
		/******/
		/******/ // Execute the module function
		/******/
		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
		/******/
		/******/ // Flag the module as loaded
		/******/
		module.loaded = true;
		/******/
		/******/ // Return the exports of the module
		/******/
		return module.exports;
		/******/
	}
	/******/
	/************************************************************************/
	/******/
	/* webpack/runtime/node module decorator */
	/******/
	(() => {
		/******/
		__webpack_require__.nmd = (module) => {
			/******/
			module.paths = [];
			/******/
			if (!module.children) module.children = [];
			/******/
			return module;
			/******/
		};
		/******/
	})();
	/******/
	/************************************************************************/
	var __webpack_exports__ = {};
	// This entry need to be wrapped in an IIFE because it need to be isolated against other modules in the chunk.
	(() => {
		var exports = __webpack_exports__;


		Object.defineProperty(exports, "__esModule", ({
			value: true
		}));
		Object.defineProperty(exports, "PDFViewerApplication", ({
			enumerable: true,
			get: function get() {
				return _app.PDFViewerApplication;
			}
		}));
		Object.defineProperty(exports, "PDFViewerApplicationOptions", ({
			enumerable: true,
			get: function get() {
				return _app_options.AppOptions;
			}
		}));

		var _app_options = __webpack_require__(1);

		var _app = __webpack_require__(2);

		var pdfjsVersion = '2.13.216';
		var pdfjsBuild = '399a0ec60';
		window.PDFViewerApplication = _app.PDFViewerApplication;
		window.PDFViewerApplicationOptions = _app_options.AppOptions;;; {
			__webpack_require__(41);
		}; {
			__webpack_require__(47);
		}

		function getViewerConfiguration() {
			var errorWrapper = null;
			errorWrapper = {
				container: document.getElementById("errorWrapper"),
				errorMessage: document.getElementById("errorMessage"),
				closeButton: document.getElementById("errorClose"),
				errorMoreInfo: document.getElementById("errorMoreInfo"),
				moreInfoButton: document.getElementById("errorShowMore"),
				lessInfoButton: document.getElementById("errorShowLess")
			};
			return {
				appContainer: document.body,
				mainContainer: document.getElementById("viewerContainer"),
				viewerContainer: document.getElementById("viewer"),
				toolbar: {
					container: document.getElementById("toolbarViewer"),
					numPages: document.getElementById("numPages"),
					pageNumber: document.getElementById("pageNumber"),
					scaleSelect: document.getElementById("scaleSelect"),
					customScaleOption: document.getElementById("customScaleOption"),
					previous: document.getElementById("previous"),
					next: document.getElementById("next"),
					zoomIn: document.getElementById("zoomIn"),
					zoomOut: document.getElementById("zoomOut"),
					viewFind: document.getElementById("viewFind"),
					openFile: document.getElementById("openFile"),
					print: document.getElementById("print"),
					presentationModeButton: document.getElementById("presentationMode"),
					download: document.getElementById("download"),
					viewBookmark: document.getElementById("viewBookmark")
				},
				secondaryToolbar: {
					toolbar: document.getElementById("secondaryToolbar"),
					toggleButton: document.getElementById("secondaryToolbarToggle"),
					toolbarButtonContainer: document.getElementById("secondaryToolbarButtonContainer"),
					presentationModeButton: document.getElementById("secondaryPresentationMode"),
					openFileButton: document.getElementById("secondaryOpenFile"),
					printButton: document.getElementById("secondaryPrint"),
					downloadButton: document.getElementById("secondaryDownload"),
					viewBookmarkButton: document.getElementById("secondaryViewBookmark"),
					firstPageButton: document.getElementById("firstPage"),
					lastPageButton: document.getElementById("lastPage"),
					pageRotateCwButton: document.getElementById("pageRotateCw"),
					pageRotateCcwButton: document.getElementById("pageRotateCcw"),
					cursorSelectToolButton: document.getElementById("cursorSelectTool"),
					cursorHandToolButton: document.getElementById("cursorHandTool"),
					scrollPageButton: document.getElementById("scrollPage"),
					scrollVerticalButton: document.getElementById("scrollVertical"),
					scrollHorizontalButton: document.getElementById("scrollHorizontal"),
					scrollWrappedButton: document.getElementById("scrollWrapped"),
					spreadNoneButton: document.getElementById("spreadNone"),
					spreadOddButton: document.getElementById("spreadOdd"),
					spreadEvenButton: document.getElementById("spreadEven"),
					documentPropertiesButton: document.getElementById("documentProperties")
				},
				sidebar: {
					outerContainer: document.getElementById("outerContainer"),
					viewerContainer: document.getElementById("viewerContainer"),
					toggleButton: document.getElementById("sidebarToggle"),
					thumbnailButton: document.getElementById("viewThumbnail"),
					outlineButton: document.getElementById("viewOutline"),
					attachmentsButton: document.getElementById("viewAttachments"),
					layersButton: document.getElementById("viewLayers"),
					thumbnailView: document.getElementById("thumbnailView"),
					outlineView: document.getElementById("outlineView"),
					attachmentsView: document.getElementById("attachmentsView"),
					layersView: document.getElementById("layersView"),
					outlineOptionsContainer: document.getElementById("outlineOptionsContainer"),
					currentOutlineItemButton: document.getElementById("currentOutlineItem")
				},
				sidebarResizer: {
					outerContainer: document.getElementById("outerContainer"),
					resizer: document.getElementById("sidebarResizer")
				},
				findBar: {
					bar: document.getElementById("findbar"),
					toggleButton: document.getElementById("viewFind"),
					findField: document.getElementById("findInput"),
					highlightAllCheckbox: document.getElementById("findHighlightAll"),
					caseSensitiveCheckbox: document.getElementById("findMatchCase"),
					matchDiacriticsCheckbox: document.getElementById("findMatchDiacritics"),
					entireWordCheckbox: document.getElementById("findEntireWord"),
					findMsg: document.getElementById("findMsg"),
					findResultsCount: document.getElementById("findResultsCount"),
					findPreviousButton: document.getElementById("findPrevious"),
					findNextButton: document.getElementById("findNext")
				},
				passwordOverlay: {
					overlayName: "passwordOverlay",
					container: document.getElementById("passwordOverlay"),
					label: document.getElementById("passwordText"),
					input: document.getElementById("password"),
					submitButton: document.getElementById("passwordSubmit"),
					cancelButton: document.getElementById("passwordCancel")
				},
				documentProperties: {
					overlayName: "documentPropertiesOverlay",
					container: document.getElementById("documentPropertiesOverlay"),
					closeButton: document.getElementById("documentPropertiesClose"),
					fields: {
						fileName: document.getElementById("fileNameField"),
						fileSize: document.getElementById("fileSizeField"),
						title: document.getElementById("titleField"),
						author: document.getElementById("authorField"),
						subject: document.getElementById("subjectField"),
						keywords: document.getElementById("keywordsField"),
						creationDate: document.getElementById("creationDateField"),
						modificationDate: document.getElementById("modificationDateField"),
						creator: document.getElementById("creatorField"),
						producer: document.getElementById("producerField"),
						version: document.getElementById("versionField"),
						pageCount: document.getElementById("pageCountField"),
						pageSize: document.getElementById("pageSizeField"),
						linearized: document.getElementById("linearizedField")
					}
				},
				errorWrapper: errorWrapper,
				printContainer: document.getElementById("printContainer"),
				openFileInputName: "fileInput",
				debuggerScriptPath: "./debugger.js"
			};
		}

		function webViewerLoad() {
			var config = getViewerConfiguration();
			var event = document.createEvent("CustomEvent");
			event.initCustomEvent("webviewerloaded", true, true, {
				source: window
			});

			try {
				parent.document.dispatchEvent(event);
			} catch (ex) {
				console.error("webviewerloaded: ".concat(ex));
				document.dispatchEvent(event);
			}

			_app.PDFViewerApplication.run(config);
		}

		if (document.blockUnblockOnload) {
			document.blockUnblockOnload(true);
		}

		if (document.readyState === "interactive" || document.readyState === "complete") {
			webViewerLoad();
		} else {
			document.addEventListener("DOMContentLoaded", webViewerLoad, true);
		}
	})();

	/******/
})();
//# sourceMappingURL=viewer.js.map