{"version":3,"file":"js/834.f6671095.js","mappings":"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","sources":["webpack://baozhida-chain-verify-online/node_modules/_vue-resize-sensor@2.0.0@vue-resize-sensor/src/resize-sensor.vue","webpack://baozhida-chain-verify-online/./node_modules/_vue-resize-sensor@2.0.0@vue-resize-sensor/src/resize-sensor.vue","webpack://baozhida-chain-verify-online/./node_modules/_vue-resize-sensor@2.0.0@vue-resize-sensor/src/resize-sensor.vue?5eb6","webpack://baozhida-chain-verify-online/./node_modules/_vue-pdf@4.3.0@vue-pdf/src/componentFactory.js","webpack://baozhida-chain-verify-online/node_modules/_vue-pdf@4.3.0@vue-pdf/src/vuePdfNoSss.vue","webpack://baozhida-chain-verify-online/./node_modules/_vue-pdf@4.3.0@vue-pdf/src/vuePdfNoSss.vue","webpack://baozhida-chain-verify-online/./node_modules/_vue-pdf@4.3.0@vue-pdf/src/vuePdfNoSss.vue?5edd","webpack://baozhida-chain-verify-online/./node_modules/_pdfjs-dist@2.6.347@pdfjs-dist/es5/build/pdf.worker.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/webpack/universalModuleDefinition","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/webpack/bootstrap","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/pdf.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/display_utils.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/@babel/runtime/regenerator/index.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/@babel/runtime/node_modules/regenerator-runtime/runtime.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/webpack/buildin/module.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/shared/util.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/shared/compatibility.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/shared/is_node.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/global-this.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.global-this.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/export.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/global.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-get-own-property-descriptor.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/descriptors.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/fails.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-property-is-enumerable.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/create-property-descriptor.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/to-indexed-object.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/indexed-object.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/classof-raw.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/require-object-coercible.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/to-primitive.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/is-object.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/has.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/ie8-dom-define.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/document-create-element.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/create-non-enumerable-property.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-define-property.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/an-object.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/redefine.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/set-global.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/inspect-source.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/shared-store.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/internal-state.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/native-weak-map.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/shared-key.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/shared.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/is-pure.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/uid.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/hidden-keys.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/copy-constructor-properties.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/own-keys.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/get-built-in.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/path.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-get-own-property-names.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-keys-internal.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/array-includes.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/to-length.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/to-integer.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/to-absolute-index.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/enum-bug-keys.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-get-own-property-symbols.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/is-forced.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/string/starts-with.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.string.starts-with.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/not-a-regexp.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/is-regexp.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/well-known-symbol.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/native-symbol.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/use-symbol-as-uid.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/correct-is-regexp-logic.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/entry-unbind.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/function-bind-context.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/a-function.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/string/ends-with.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.string.ends-with.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/string/includes.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.string.includes.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/array/includes.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.array.includes.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/add-to-unscopables.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-create.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-define-properties.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-keys.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/html.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/array-method-uses-to-length.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/array/from.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.string.iterator.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/string-multibyte.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/define-iterator.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/create-iterator-constructor.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/iterators-core.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-get-prototype-of.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/to-object.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/correct-prototype-getter.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/set-to-string-tag.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/iterators.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-set-prototype-of.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/a-possible-prototype.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.array.from.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/array-from.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/call-with-safe-iteration-closing.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/is-array-iterator-method.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/create-property.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/get-iterator-method.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/classof.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/to-string-tag-support.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/check-correctness-of-iteration.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/object/assign.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.object.assign.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-assign.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/object/from-entries.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.array.iterator.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.object.from-entries.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/iterate.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/math/log2.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.math.log2.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/number/is-nan.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.number.is-nan.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/number/is-integer.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.number.is-integer.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/is-integer.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/typed-array/slice.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.typed-array.slice.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/array-buffer-view-core.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/array-buffer-native.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/species-constructor.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/promise/index.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.object.to-string.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-to-string.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/web.dom-collections.iterator.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/dom-iterables.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.promise.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/native-promise-constructor.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/redefine-all.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/set-species.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/an-instance.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/task.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/engine-is-ios.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/engine-user-agent.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/microtask.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/promise-resolve.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/new-promise-capability.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/host-report-errors.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/perform.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/engine-v8-version.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.promise.all-settled.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.promise.finally.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/web/url.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/web.url.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/native-url.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/string-punycode-to-ascii.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/web.url-search-params.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/get-iterator.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/web.url.to-json.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/web-streams-polyfill/dist/ponyfill.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/map/index.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.map.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/collection.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/internal-metadata.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/freezing.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/inherit-if-required.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/collection-strong.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/set/index.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.set.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/weak-map/index.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.weak-map.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/collection-weak.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/array-iteration.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/array-species-create.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/is-array.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/weak-set/index.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.weak-set.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/string/code-point-at.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.string.code-point-at.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/string/from-code-point.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.string.from-code-point.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/symbol/index.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.array.concat.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/array-method-has-species-support.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-get-own-property-names-external.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/well-known-symbol-wrapped.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/define-well-known-symbol.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.async-iterator.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.description.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.has-instance.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.is-concat-spreadable.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.iterator.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.match.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.match-all.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.replace.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.search.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.species.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.split.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.to-primitive.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.to-string-tag.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.symbol.unscopables.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.math.to-string-tag.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.json.to-string-tag.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/string/pad-start.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.string.pad-start.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/string-pad.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/string-repeat.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/string-pad-webkit-bug.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/string/pad-end.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.string.pad-end.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/object/values.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.object.values.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/internals/object-to-array.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/es/object/entries.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/node_modules/core-js/modules/es.object.entries.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/api.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/font_loader.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/node_utils.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/annotation_storage.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/api_compatibility.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/canvas.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/pattern_helper.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/worker_options.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/shared/message_handler.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/metadata.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/xml_parser.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/optional_content_config.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/transport_stream.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/webgl.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/annotation_layer.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/text_layer.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/svg.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/node_stream.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/network_utils.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/content_disposition.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/network.js","webpack://baozhida-chain-verify-online/pdfjs-dist/build/pdf/src/display/fetch_stream.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/webpack/universalModuleDefinition","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/webpack/bootstrap","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/pdf_viewer.component.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/annotation_layer_builder.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/pdfjs.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/ui_utils.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/node_modules/@babel/runtime/regenerator/index.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/node_modules/@babel/runtime/node_modules/regenerator-runtime/runtime.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/node_modules/webpack/buildin/module.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/pdf_link_service.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/text_layer_builder.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/download_manager.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/viewer_compatibility.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/genericl10n.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/external/webL10n/l10n.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/pdf_find_controller.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/pdf_find_utils.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/pdf_history.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/pdf_page_view.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/pdf_rendering_queue.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/pdf_single_page_viewer.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/base_viewer.js","webpack://baozhida-chain-verify-online/pdfjs-dist/web/pdf_viewer/web/pdf_viewer.js","webpack://baozhida-chain-verify-online/./node_modules/_vue-pdf@4.3.0@vue-pdf/src/pdfjsWrapper.js"],"sourcesContent":["<style>\r\n@keyframes resizeSensorVisibility {\r\n\tfrom { top: 0; }\r\n}\r\n</style>\r\n\r\n<script>\r\n\"use strict\";\r\n\r\nexport default {\r\n\r\n\t// thanks to https://github.com/marcj/css-element-queries\r\n\tprops: {\r\n\t\tinitial: {\r\n\t\t\ttype: Boolean,\r\n\t\t\tdefault: false,\r\n\t\t}\r\n\t},\r\n\tdata: function() {\r\n\t\treturn {\r\n\t\t\tsize: {\r\n\t\t\t\twidth: -1,\r\n\t\t\t\theight: -1\r\n\t\t\t}\r\n\t\t}\r\n\t},\r\n\tmethods: {\r\n\t\treset: function() {\r\n\r\n\t\t\tvar expand = this.$el.firstChild;\r\n\t\t\tvar shrink = this.$el.lastChild;\r\n\t\t\texpand.scrollLeft = 100000;\r\n\t\t\texpand.scrollTop = 100000;\r\n\t\t\tshrink.scrollLeft = 100000;\r\n\t\t\tshrink.scrollTop = 100000;\r\n\t\t},\r\n\t\tupdate: function() {\r\n\t\t\t\r\n\t\t\tthis.size.width = this.$el.offsetWidth;\r\n\t\t\tthis.size.height = this.$el.offsetHeight;\r\n\t\t}\r\n\t},\r\n\twatch: {\r\n\t\tsize: {\r\n\t\t\tdeep: true,\r\n\t\t\thandler: function(size) {\r\n\t\t\t\t\r\n\t\t\t\tthis.reset();\r\n\t\t\t\tthis.$emit('resize', { width: this.size.width, height: this.size.height });\r\n\t\t\t}\r\n\t\t}\r\n\t},\r\n\trender: function(create) {\r\n\t\t\r\n\t\tvar style = 'position: absolute; left: 0; top: 0; right: 0; bottom: 0; overflow: hidden; z-index: -1; visibility: hidden;';\r\n\t\tvar styleChild = 'position: absolute; left: 0; top: 0;';\r\n\r\n\t\treturn create('div', {\r\n\t\t\tstyle: style + 'animation-name: resizeSensorVisibility;',\r\n\t\t\ton: {\r\n\t\t\t\t'~animationstart': this.update\r\n\t\t\t}\r\n\t\t},[\r\n\t\t\tcreate('div', {\r\n\t\t\t\tstyle: style,\r\n\t\t\t\ton: {\r\n\t\t\t\t\tscroll: this.update\r\n\t\t\t\t}\r\n\t\t\t}, [\r\n\t\t\t\tcreate('div', {\r\n\t\t\t\t\tstyle: styleChild + 'width: 100000px; height: 100000px;'\r\n\t\t\t\t})\r\n\t\t\t]),\r\n\t\t\tcreate('div', {\r\n\t\t\t\tstyle: style,\r\n\t\t\t\ton: {\r\n\t\t\t\t\tscroll: this.update\r\n\t\t\t\t}\r\n\t\t\t}, [\r\n\t\t\t\tcreate('div', {\r\n\t\t\t\t\tstyle: styleChild + 'width: 200%; height: 200%;'\r\n\t\t\t\t})\r\n\t\t\t]),\r\n\t\t]);\r\n\t},\r\n\tbeforeDestroy: function() {\r\n\t\t\r\n\t\tthis.$emit('resize', { width: 0, height: 0 });\r\n\t\tthis.$emit('resizeSensorBeforeDestroy');\r\n\t},\r\n\tmounted: function() {\r\n\r\n\t\tif ( this.initial === true )\r\n\t\t\tthis.$nextTick(this.update);\r\n\t\t\r\n\t\tif ( this.$el.offsetParent !== this.$el.parentNode )\r\n\t\t\tthis.$el.parentNode.style.position = 'relative';\r\n\r\n\t\tif ( 'attachEvent' in this.$el && !('AnimationEvent' in window) ) {\r\n\r\n\t\t\tvar onresizeHandler = function() {\r\n\r\n\t\t\t\tthis.update();\r\n\t\t\t\tremoveOnresizeEvent();\r\n\t\t\t}.bind(this);\r\n\t\t\r\n\t\t\tvar removeOnresizeEvent = function() {\r\n\t\t\t\t\r\n\t\t\t\tthis.$el.detachEvent('onresize', onresizeHandler);\r\n\t\t\t\tthis.$off('resizeSensorBeforeDestroy', removeOnresizeEvent);\r\n\t\t\t}.bind(this);\r\n\t\t\t\r\n\t\t\tthis.$el.attachEvent('onresize', onresizeHandler);\r\n\t\t\tthis.$on('resizeSensorBeforeDestroy', removeOnresizeEvent);\r\n\t\t\tthis.reset();\r\n\t\t}\r\n\t}\r\n}\r\n\r\n</script>\r\n","var render, staticRenderFns\nimport script from \"./resize-sensor.vue?vue&type=script&lang=js&\"\nexport * from \"./resize-sensor.vue?vue&type=script&lang=js&\"\nimport style0 from \"./resize-sensor.vue?vue&type=style&index=0&id=806e08f0&prod&lang=css&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../@vue/vue-loader-v15/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","import mod from \"-!../../thread-loader/dist/cjs.js!../../babel-loader/lib/index.js??clonedRuleSet-40.use[1]!../../@vue/vue-loader-v15/lib/index.js??vue-loader-options!./resize-sensor.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../thread-loader/dist/cjs.js!../../babel-loader/lib/index.js??clonedRuleSet-40.use[1]!../../@vue/vue-loader-v15/lib/index.js??vue-loader-options!./resize-sensor.vue?vue&type=script&lang=js&\"","import resizeSensor from 'vue-resize-sensor'\r\n\r\nexport default function(pdfjsWrapper) {\r\n\r\n\tvar createLoadingTask = pdfjsWrapper.createLoadingTask;\r\n\tvar PDFJSWrapper = pdfjsWrapper.PDFJSWrapper;\r\n\r\n\treturn {\r\n\t\tcreateLoadingTask: createLoadingTask,\r\n\t\trender: function(h) {\r\n\t\t\treturn h('span', {\r\n\t\t\t\tattrs: {\r\n\t\t\t\t\tstyle: 'position: relative; display: block'\r\n\t\t\t\t}\r\n\t\t\t}, [\r\n\t\t\t\th('canvas', {\r\n\t\t\t\t\tattrs: {\r\n\t\t\t\t\t\tstyle: 'display: inline-block; width: 100%; height: 100%; vertical-align: top',\r\n\t\t\t\t\t},\r\n\t\t\t\t\tref:'canvas'\r\n\t\t\t\t}),\r\n\t\t\t\th('span', {\r\n\t\t\t\t\tstyle: 'display: inline-block; width: 100%; height: 100%',\r\n\t\t\t\t\tclass: 'annotationLayer',\r\n\t\t\t\t\tref:'annotationLayer'\r\n\t\t\t\t}),\r\n\t\t\t\th(resizeSensor, {\r\n\t\t\t\t\tprops: {\r\n\t\t\t\t\t\tinitial: true\r\n\t\t\t\t\t},\r\n\t\t\t\t\ton: {\r\n\t\t\t\t\t\tresize: this.resize\r\n\t\t\t\t\t},\r\n\t\t\t\t})\r\n\t\t\t])\r\n\t\t},\r\n\t\tprops: {\r\n\t\t\tsrc: {\r\n\t\t\t\ttype: [String, Object, Uint8Array],\r\n\t\t\t\tdefault: '',\r\n\t\t\t},\r\n\t\t\tpage: {\r\n\t\t\t\ttype: Number,\r\n\t\t\t\tdefault: 1,\r\n\t\t\t},\r\n\t\t\trotate: {\r\n\t\t\t\ttype: Number,\r\n\t\t\t},\r\n\t\t},\r\n\t\twatch: {\r\n\t\t\tsrc: function() {\r\n\r\n\t\t\t\tthis.pdf.loadDocument(this.src);\r\n\t\t\t},\r\n\t\t\tpage: function() {\r\n\r\n\t\t\t\tthis.pdf.loadPage(this.page, this.rotate);\r\n\t\t\t},\r\n\t\t\trotate: function() {\r\n\t\t\t\tthis.pdf.renderPage(this.rotate);\r\n\t\t\t},\r\n\t\t},\r\n\t\tmethods: {\r\n\t\t\tresize: function(size) {\r\n\r\n\t\t\t\t// check if the element is attached to the dom tree || resizeSensor being destroyed\r\n\t\t\t\tif ( this.$el.parentNode === null || (size.width === 0 && size.height === 0) )\r\n\t\t\t\t\treturn;\r\n\r\n\t\t\t\t// on IE10- canvas height must be set\r\n\t\t\t\tthis.$refs.canvas.style.height = this.$refs.canvas.offsetWidth * (this.$refs.canvas.height / this.$refs.canvas.width) + 'px';\r\n\t\t\t\t// update the page when the resolution is too poor\r\n\t\t\t\tvar resolutionScale = this.pdf.getResolutionScale();\r\n\r\n\t\t\t\tif ( resolutionScale < 0.85 || resolutionScale > 1.15 )\r\n\t\t\t\t\tthis.pdf.renderPage(this.rotate);\r\n\r\n\t\t\t\t// this.$refs.annotationLayer.style.transform = 'scale('+resolutionScale+')';\r\n\t\t\t},\r\n\t\t\tprint: function(dpi, pageList) {\r\n\r\n\t\t\t\tthis.pdf.printPage(dpi, pageList);\r\n\t\t\t}\r\n\t\t},\r\n\r\n\t\t// doc: mounted hook is not called during server-side rendering.\r\n\t\tmounted: function() {\r\n\r\n\t\t\tthis.pdf = new PDFJSWrapper(this.$refs.canvas, this.$refs.annotationLayer, this.$emit.bind(this));\r\n\r\n\t\t\tthis.$on('loaded', function() {\r\n\r\n\t\t\t\tthis.pdf.loadPage(this.page, this.rotate);\r\n\t\t\t});\r\n\r\n\t\t\tthis.$on('page-size', function(width, height) {\r\n\r\n\t\t\t\tthis.$refs.canvas.style.height = this.$refs.canvas.offsetWidth * (height / width) + 'px';\r\n\t\t\t});\r\n\r\n\t\t\tthis.pdf.loadDocument(this.src);\r\n\t\t},\r\n\r\n\t\t// doc: destroyed hook is not called during server-side rendering.\r\n\t\tdestroyed: function() {\r\n\r\n\t\t\tthis.pdf.destroy();\r\n\t\t}\r\n\t}\r\n\r\n}\r\n","<style src=\"./annotationLayer.css\"></style>\r\n<script>\r\n\r\n\timport componentFactory from './componentFactory.js'\r\n\r\n\tif ( process.env.VUE_ENV !== 'server' ) {\r\n\r\n\t\tvar pdfjsWrapper = require('./pdfjsWrapper.js').default;\r\n\t\tvar PDFJS = require('pdfjs-dist/es5/build/pdf.js');\r\n\r\n\t\tif ( typeof window !== 'undefined' && 'Worker' in window && navigator.appVersion.indexOf('MSIE 10') === -1 ) {\r\n\r\n\t\t\tvar PdfjsWorker = require('worker-loader!pdfjs-dist/es5/build/pdf.worker.js');\r\n\t\t\tPDFJS.GlobalWorkerOptions.workerPort = new PdfjsWorker();\r\n\t\t}\r\n\r\n\t\tvar component = componentFactory(pdfjsWrapper(PDFJS));\r\n\t} else {\r\n\r\n\t\tvar component = componentFactory({});\r\n\t}\r\n\r\n\texport default component;\r\n</script>","var render, staticRenderFns\nimport script from \"./vuePdfNoSss.vue?vue&type=script&lang=js&\"\nexport * from \"./vuePdfNoSss.vue?vue&type=script&lang=js&\"\nimport style0 from \"./annotationLayer.css?vue&type=style&index=0&prod&lang=css&\"\n\n\n/* normalize component */\nimport normalizer from \"!../../@vue/vue-loader-v15/lib/runtime/componentNormalizer.js\"\nvar component = normalizer(\n  script,\n  render,\n  staticRenderFns,\n  false,\n  null,\n  null,\n  null\n  \n)\n\nexport default component.exports","import mod from \"-!../../thread-loader/dist/cjs.js!../../babel-loader/lib/index.js??clonedRuleSet-40.use[1]!../../@vue/vue-loader-v15/lib/index.js??vue-loader-options!./vuePdfNoSss.vue?vue&type=script&lang=js&\"; export default mod; export * from \"-!../../thread-loader/dist/cjs.js!../../babel-loader/lib/index.js??clonedRuleSet-40.use[1]!../../@vue/vue-loader-v15/lib/index.js??vue-loader-options!./vuePdfNoSss.vue?vue&type=script&lang=js&\"","module.exports = function() {\n  return new Worker(__webpack_public_path__ + \"7800e017db2cfb37.worker.js\");\n};","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"pdfjs-dist/build/pdf\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"pdfjs-dist/build/pdf\"] = factory();\n\telse\n\t\troot[\"pdfjs-dist/build/pdf\"] = factory();\n})(this, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __w_pdfjs_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __w_pdfjs_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__w_pdfjs_require__.m = modules;\n\n \t// expose the module cache\n \t__w_pdfjs_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__w_pdfjs_require__.d = function(exports, name, getter) {\n \t\tif(!__w_pdfjs_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__w_pdfjs_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__w_pdfjs_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __w_pdfjs_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__w_pdfjs_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __w_pdfjs_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__w_pdfjs_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__w_pdfjs_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__w_pdfjs_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__w_pdfjs_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __w_pdfjs_require__(__w_pdfjs_require__.s = 0);\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  addLinkAttributes,\n  getFilenameFromUrl,\n  isFetchSupported,\n  isValidFetchUrl,\n  LinkTarget,\n  loadScript,\n  PDFDateString,\n  RenderingCancelledException,\n} from \"./display/display_utils.js\";\nimport {\n  build,\n  getDocument,\n  LoopbackPort,\n  PDFDataRangeTransport,\n  PDFWorker,\n  setPDFNetworkStreamFactory,\n  version,\n} from \"./display/api.js\";\nimport {\n  CMapCompressionType,\n  createObjectURL,\n  createPromiseCapability,\n  createValidAbsoluteUrl,\n  InvalidPDFException,\n  MissingPDFException,\n  OPS,\n  PasswordResponses,\n  PermissionFlag,\n  removeNullCharacters,\n  shadow,\n  UnexpectedResponseException,\n  UNSUPPORTED_FEATURES,\n  Util,\n  VerbosityLevel,\n} from \"./shared/util.js\";\nimport { AnnotationLayer } from \"./display/annotation_layer.js\";\nimport { apiCompatibilityParams } from \"./display/api_compatibility.js\";\nimport { GlobalWorkerOptions } from \"./display/worker_options.js\";\nimport { renderTextLayer } from \"./display/text_layer.js\";\nimport { SVGGraphics } from \"./display/svg.js\";\n\n/* eslint-disable-next-line no-unused-vars */\nconst pdfjsVersion =\n  typeof PDFJSDev !== \"undefined\" ? PDFJSDev.eval(\"BUNDLE_VERSION\") : void 0;\n/* eslint-disable-next-line no-unused-vars */\nconst pdfjsBuild =\n  typeof PDFJSDev !== \"undefined\" ? PDFJSDev.eval(\"BUNDLE_BUILD\") : void 0;\n\nif (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"PRODUCTION\")) {\n  const streamsPromise = Promise.all([\n    import(\"pdfjs/display/network.js\"),\n    import(\"pdfjs/display/fetch_stream.js\"),\n  ]);\n  setPDFNetworkStreamFactory(params => {\n    return streamsPromise.then(streams => {\n      const [{ PDFNetworkStream }, { PDFFetchStream }] = streams;\n      if (isFetchSupported() && isValidFetchUrl(params.url)) {\n        return new PDFFetchStream(params);\n      }\n      return new PDFNetworkStream(params);\n    });\n  });\n} else if (PDFJSDev.test(\"GENERIC\")) {\n  const { isNodeJS } = require(\"./shared/is_node.js\");\n  if (isNodeJS) {\n    const PDFNodeStream = require(\"./display/node_stream.js\").PDFNodeStream;\n    setPDFNetworkStreamFactory(params => {\n      return new PDFNodeStream(params);\n    });\n  } else {\n    const PDFNetworkStream = require(\"./display/network.js\").PDFNetworkStream;\n    let PDFFetchStream;\n    if (isFetchSupported()) {\n      PDFFetchStream = require(\"./display/fetch_stream.js\").PDFFetchStream;\n    }\n    setPDFNetworkStreamFactory(params => {\n      if (PDFFetchStream && isValidFetchUrl(params.url)) {\n        return new PDFFetchStream(params);\n      }\n      return new PDFNetworkStream(params);\n    });\n  }\n} else if (PDFJSDev.test(\"CHROME\")) {\n  const PDFNetworkStream = require(\"./display/network.js\").PDFNetworkStream;\n  let PDFFetchStream;\n  const isChromeWithFetchCredentials = function () {\n    // fetch does not include credentials until Chrome 61.0.3138.0 and later.\n    // https://chromium.googlesource.com/chromium/src/+/2e231cf052ca5e68e22baf0008ac9e5e29121707\n    try {\n      // Indexed properties on window are read-only in Chrome 61.0.3151.0+\n      // https://chromium.googlesource.com/chromium/src.git/+/58ab4a971b06dec13e4edf9de8382ca6847f6190\n      window[999] = 123; // should throw. Note: JS strict mode MUST be enabled.\n      delete window[999];\n      return false;\n    } catch (e) {\n      return true;\n    }\n  };\n  if (isFetchSupported() && isChromeWithFetchCredentials()) {\n    PDFFetchStream = require(\"./display/fetch_stream.js\").PDFFetchStream;\n  }\n  setPDFNetworkStreamFactory(params => {\n    if (PDFFetchStream && isValidFetchUrl(params.url)) {\n      return new PDFFetchStream(params);\n    }\n    return new PDFNetworkStream(params);\n  });\n}\n\nexport {\n  // From \"./display/display_utils.js\":\n  addLinkAttributes,\n  getFilenameFromUrl,\n  LinkTarget,\n  loadScript,\n  PDFDateString,\n  RenderingCancelledException,\n  // From \"./display/api.js\":\n  build,\n  getDocument,\n  LoopbackPort,\n  PDFDataRangeTransport,\n  PDFWorker,\n  version,\n  // From \"./shared/util.js\":\n  CMapCompressionType,\n  createObjectURL,\n  createPromiseCapability,\n  createValidAbsoluteUrl,\n  InvalidPDFException,\n  MissingPDFException,\n  OPS,\n  PasswordResponses,\n  PermissionFlag,\n  removeNullCharacters,\n  shadow,\n  UnexpectedResponseException,\n  UNSUPPORTED_FEATURES,\n  Util,\n  VerbosityLevel,\n  // From \"./display/annotation_layer.js\":\n  AnnotationLayer,\n  // From \"./display/api_compatibility.js\":\n  apiCompatibilityParams,\n  // From \"./display/worker_options.js\":\n  GlobalWorkerOptions,\n  // From \"./display/text_layer.js\":\n  renderTextLayer,\n  // From \"./display/svg.js\":\n  SVGGraphics,\n};\n","/* Copyright 2015 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport {\n  assert,\n  BaseException,\n  CMapCompressionType,\n  isString,\n  removeNullCharacters,\n  stringToBytes,\n  unreachable,\n  Util,\n  warn,\n} from \"../shared/util.js\";\n\nconst DEFAULT_LINK_REL = \"noopener noreferrer nofollow\";\nconst SVG_NS = \"http://www.w3.org/2000/svg\";\n\nclass BaseCanvasFactory {\n  constructor() {\n    if (this.constructor === BaseCanvasFactory) {\n      unreachable(\"Cannot initialize BaseCanvasFactory.\");\n    }\n  }\n\n  create(width, height) {\n    unreachable(\"Abstract method `create` called.\");\n  }\n\n  reset(canvasAndContext, width, height) {\n    if (!canvasAndContext.canvas) {\n      throw new Error(\"Canvas is not specified\");\n    }\n    if (width <= 0 || height <= 0) {\n      throw new Error(\"Invalid canvas size\");\n    }\n    canvasAndContext.canvas.width = width;\n    canvasAndContext.canvas.height = height;\n  }\n\n  destroy(canvasAndContext) {\n    if (!canvasAndContext.canvas) {\n      throw new Error(\"Canvas is not specified\");\n    }\n    // Zeroing the width and height cause Firefox to release graphics\n    // resources immediately, which can greatly reduce memory consumption.\n    canvasAndContext.canvas.width = 0;\n    canvasAndContext.canvas.height = 0;\n    canvasAndContext.canvas = null;\n    canvasAndContext.context = null;\n  }\n}\n\nclass DOMCanvasFactory extends BaseCanvasFactory {\n  constructor({ ownerDocument = globalThis.document } = {}) {\n    super();\n    this._document = ownerDocument;\n  }\n\n  create(width, height) {\n    if (width <= 0 || height <= 0) {\n      throw new Error(\"Invalid canvas size\");\n    }\n    const canvas = this._document.createElement(\"canvas\");\n    const context = canvas.getContext(\"2d\");\n    canvas.width = width;\n    canvas.height = height;\n    return {\n      canvas,\n      context,\n    };\n  }\n}\n\nclass BaseCMapReaderFactory {\n  constructor({ baseUrl = null, isCompressed = false }) {\n    if (this.constructor === BaseCMapReaderFactory) {\n      unreachable(\"Cannot initialize BaseCMapReaderFactory.\");\n    }\n    this.baseUrl = baseUrl;\n    this.isCompressed = isCompressed;\n  }\n\n  async fetch({ name }) {\n    if (!this.baseUrl) {\n      throw new Error(\n        'The CMap \"baseUrl\" parameter must be specified, ensure that ' +\n          'the \"cMapUrl\" and \"cMapPacked\" API parameters are provided.'\n      );\n    }\n    if (!name) {\n      throw new Error(\"CMap name must be specified.\");\n    }\n    const url = this.baseUrl + name + (this.isCompressed ? \".bcmap\" : \"\");\n    const compressionType = this.isCompressed\n      ? CMapCompressionType.BINARY\n      : CMapCompressionType.NONE;\n\n    return this._fetchData(url, compressionType).catch(reason => {\n      throw new Error(\n        `Unable to load ${this.isCompressed ? \"binary \" : \"\"}CMap at: ${url}`\n      );\n    });\n  }\n\n  /**\n   * @private\n   */\n  _fetchData(url, compressionType) {\n    unreachable(\"Abstract method `_fetchData` called.\");\n  }\n}\n\nclass DOMCMapReaderFactory extends BaseCMapReaderFactory {\n  _fetchData(url, compressionType) {\n    if (\n      (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"MOZCENTRAL\")) ||\n      (isFetchSupported() && isValidFetchUrl(url, document.baseURI))\n    ) {\n      return fetch(url).then(async response => {\n        if (!response.ok) {\n          throw new Error(response.statusText);\n        }\n        let cMapData;\n        if (this.isCompressed) {\n          cMapData = new Uint8Array(await response.arrayBuffer());\n        } else {\n          cMapData = stringToBytes(await response.text());\n        }\n        return { cMapData, compressionType };\n      });\n    }\n\n    // The Fetch API is not supported.\n    return new Promise((resolve, reject) => {\n      const request = new XMLHttpRequest();\n      request.open(\"GET\", url, true);\n\n      if (this.isCompressed) {\n        request.responseType = \"arraybuffer\";\n      }\n      request.onreadystatechange = () => {\n        if (request.readyState !== XMLHttpRequest.DONE) {\n          return;\n        }\n        if (request.status === 200 || request.status === 0) {\n          let cMapData;\n          if (this.isCompressed && request.response) {\n            cMapData = new Uint8Array(request.response);\n          } else if (!this.isCompressed && request.responseText) {\n            cMapData = stringToBytes(request.responseText);\n          }\n          if (cMapData) {\n            resolve({ cMapData, compressionType });\n            return;\n          }\n        }\n        reject(new Error(request.statusText));\n      };\n\n      request.send(null);\n    });\n  }\n}\n\nclass DOMSVGFactory {\n  create(width, height) {\n    assert(width > 0 && height > 0, \"Invalid SVG dimensions\");\n\n    const svg = document.createElementNS(SVG_NS, \"svg:svg\");\n    svg.setAttribute(\"version\", \"1.1\");\n    svg.setAttribute(\"width\", width + \"px\");\n    svg.setAttribute(\"height\", height + \"px\");\n    svg.setAttribute(\"preserveAspectRatio\", \"none\");\n    svg.setAttribute(\"viewBox\", \"0 0 \" + width + \" \" + height);\n\n    return svg;\n  }\n\n  createElement(type) {\n    assert(typeof type === \"string\", \"Invalid SVG element type\");\n\n    return document.createElementNS(SVG_NS, type);\n  }\n}\n\n/**\n * @typedef {Object} PageViewportParameters\n * @property {Array<number>} viewBox - The xMin, yMin, xMax and\n *   yMax coordinates.\n * @property {number} scale - The scale of the viewport.\n * @property {number} rotation - The rotation, in degrees, of the viewport.\n * @property {number} [offsetX] - The horizontal, i.e. x-axis, offset. The\n *   default value is `0`.\n * @property {number} [offsetY] - The vertical, i.e. y-axis, offset. The\n *   default value is `0`.\n * @property {boolean} [dontFlip] - If true, the y-axis will not be flipped.\n *   The default value is `false`.\n */\n\n/**\n * @typedef {Object} PageViewportCloneParameters\n * @property {number} [scale] - The scale, overriding the one in the cloned\n *   viewport. The default value is `this.scale`.\n * @property {number} [rotation] - The rotation, in degrees, overriding the one\n *   in the cloned viewport. The default value is `this.rotation`.\n * @property {number} [offsetX] - The horizontal, i.e. x-axis, offset.\n *   The default value is `this.offsetX`.\n * @property {number} [offsetY] - The vertical, i.e. y-axis, offset.\n *   The default value is `this.offsetY`.\n * @property {boolean} [dontFlip] - If true, the x-axis will not be flipped.\n *   The default value is `false`.\n */\n\n/**\n * PDF page viewport created based on scale, rotation and offset.\n */\nclass PageViewport {\n  /**\n   * @param {PageViewportParameters}\n   */\n  constructor({\n    viewBox,\n    scale,\n    rotation,\n    offsetX = 0,\n    offsetY = 0,\n    dontFlip = false,\n  }) {\n    this.viewBox = viewBox;\n    this.scale = scale;\n    this.rotation = rotation;\n    this.offsetX = offsetX;\n    this.offsetY = offsetY;\n\n    // creating transform to convert pdf coordinate system to the normal\n    // canvas like coordinates taking in account scale and rotation\n    const centerX = (viewBox[2] + viewBox[0]) / 2;\n    const centerY = (viewBox[3] + viewBox[1]) / 2;\n    let rotateA, rotateB, rotateC, rotateD;\n    rotation = rotation % 360;\n    rotation = rotation < 0 ? rotation + 360 : rotation;\n    switch (rotation) {\n      case 180:\n        rotateA = -1;\n        rotateB = 0;\n        rotateC = 0;\n        rotateD = 1;\n        break;\n      case 90:\n        rotateA = 0;\n        rotateB = 1;\n        rotateC = 1;\n        rotateD = 0;\n        break;\n      case 270:\n        rotateA = 0;\n        rotateB = -1;\n        rotateC = -1;\n        rotateD = 0;\n        break;\n      case 0:\n        rotateA = 1;\n        rotateB = 0;\n        rotateC = 0;\n        rotateD = -1;\n        break;\n      default:\n        throw new Error(\n          \"PageViewport: Invalid rotation, must be a multiple of 90 degrees.\"\n        );\n    }\n\n    if (dontFlip) {\n      rotateC = -rotateC;\n      rotateD = -rotateD;\n    }\n\n    let offsetCanvasX, offsetCanvasY;\n    let width, height;\n    if (rotateA === 0) {\n      offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;\n      offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;\n      width = Math.abs(viewBox[3] - viewBox[1]) * scale;\n      height = Math.abs(viewBox[2] - viewBox[0]) * scale;\n    } else {\n      offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;\n      offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;\n      width = Math.abs(viewBox[2] - viewBox[0]) * scale;\n      height = Math.abs(viewBox[3] - viewBox[1]) * scale;\n    }\n    // creating transform for the following operations:\n    // translate(-centerX, -centerY), rotate and flip vertically,\n    // scale, and translate(offsetCanvasX, offsetCanvasY)\n    this.transform = [\n      rotateA * scale,\n      rotateB * scale,\n      rotateC * scale,\n      rotateD * scale,\n      offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY,\n      offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY,\n    ];\n\n    this.width = width;\n    this.height = height;\n  }\n\n  /**\n   * Clones viewport, with optional additional properties.\n   * @param {PageViewportCloneParameters} [params]\n   * @returns {PageViewport} Cloned viewport.\n   */\n  clone({\n    scale = this.scale,\n    rotation = this.rotation,\n    offsetX = this.offsetX,\n    offsetY = this.offsetY,\n    dontFlip = false,\n  } = {}) {\n    return new PageViewport({\n      viewBox: this.viewBox.slice(),\n      scale,\n      rotation,\n      offsetX,\n      offsetY,\n      dontFlip,\n    });\n  }\n\n  /**\n   * Converts PDF point to the viewport coordinates. For examples, useful for\n   * converting PDF location into canvas pixel coordinates.\n   * @param {number} x - The x-coordinate.\n   * @param {number} y - The y-coordinate.\n   * @returns {Object} Object containing `x` and `y` properties of the\n   *   point in the viewport coordinate space.\n   * @see {@link convertToPdfPoint}\n   * @see {@link convertToViewportRectangle}\n   */\n  convertToViewportPoint(x, y) {\n    return Util.applyTransform([x, y], this.transform);\n  }\n\n  /**\n   * Converts PDF rectangle to the viewport coordinates.\n   * @param {Array} rect - The xMin, yMin, xMax and yMax coordinates.\n   * @returns {Array} Array containing corresponding coordinates of the\n   *   rectangle in the viewport coordinate space.\n   * @see {@link convertToViewportPoint}\n   */\n  convertToViewportRectangle(rect) {\n    const topLeft = Util.applyTransform([rect[0], rect[1]], this.transform);\n    const bottomRight = Util.applyTransform([rect[2], rect[3]], this.transform);\n    return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]];\n  }\n\n  /**\n   * Converts viewport coordinates to the PDF location. For examples, useful\n   * for converting canvas pixel location into PDF one.\n   * @param {number} x - The x-coordinate.\n   * @param {number} y - The y-coordinate.\n   * @returns {Object} Object containing `x` and `y` properties of the\n   *   point in the PDF coordinate space.\n   * @see {@link convertToViewportPoint}\n   */\n  convertToPdfPoint(x, y) {\n    return Util.applyInverseTransform([x, y], this.transform);\n  }\n}\n\nclass RenderingCancelledException extends BaseException {\n  constructor(msg, type) {\n    super(msg);\n    this.type = type;\n  }\n}\n\nconst LinkTarget = {\n  NONE: 0, // Default value.\n  SELF: 1,\n  BLANK: 2,\n  PARENT: 3,\n  TOP: 4,\n};\n\n/**\n * @typedef ExternalLinkParameters\n * @typedef {Object} ExternalLinkParameters\n * @property {string} url - An absolute URL.\n * @property {LinkTarget} [target] - The link target. The default value is\n *   `LinkTarget.NONE`.\n * @property {string} [rel] - The link relationship. The default value is\n *   `DEFAULT_LINK_REL`.\n * @property {boolean} [enabled] - Whether the link should be enabled. The\n *   default value is true.\n */\n\n/**\n * Adds various attributes (href, title, target, rel) to hyperlinks.\n * @param {HTMLLinkElement} link - The link element.\n * @param {ExternalLinkParameters} params\n */\nfunction addLinkAttributes(link, { url, target, rel, enabled = true } = {}) {\n  assert(\n    url && typeof url === \"string\",\n    'addLinkAttributes: A valid \"url\" parameter must provided.'\n  );\n\n  const urlNullRemoved = removeNullCharacters(url);\n  if (enabled) {\n    link.href = link.title = urlNullRemoved;\n  } else {\n    link.href = \"\";\n    link.title = `Disabled: ${urlNullRemoved}`;\n    link.onclick = () => {\n      return false;\n    };\n  }\n\n  let targetStr = \"\"; // LinkTarget.NONE\n  switch (target) {\n    case LinkTarget.NONE:\n      break;\n    case LinkTarget.SELF:\n      targetStr = \"_self\";\n      break;\n    case LinkTarget.BLANK:\n      targetStr = \"_blank\";\n      break;\n    case LinkTarget.PARENT:\n      targetStr = \"_parent\";\n      break;\n    case LinkTarget.TOP:\n      targetStr = \"_top\";\n      break;\n  }\n  link.target = targetStr;\n\n  link.rel = typeof rel === \"string\" ? rel : DEFAULT_LINK_REL;\n}\n\n/**\n * Gets the file name from a given URL.\n * @param {string} url\n */\nfunction getFilenameFromUrl(url) {\n  const anchor = url.indexOf(\"#\");\n  const query = url.indexOf(\"?\");\n  const end = Math.min(\n    anchor > 0 ? anchor : url.length,\n    query > 0 ? query : url.length\n  );\n  return url.substring(url.lastIndexOf(\"/\", end) + 1, end);\n}\n\nclass StatTimer {\n  constructor() {\n    this.started = Object.create(null);\n    this.times = [];\n  }\n\n  time(name) {\n    if (name in this.started) {\n      warn(`Timer is already running for ${name}`);\n    }\n    this.started[name] = Date.now();\n  }\n\n  timeEnd(name) {\n    if (!(name in this.started)) {\n      warn(`Timer has not been started for ${name}`);\n    }\n    this.times.push({\n      name,\n      start: this.started[name],\n      end: Date.now(),\n    });\n    // Remove timer from started so it can be called again.\n    delete this.started[name];\n  }\n\n  toString() {\n    // Find the longest name for padding purposes.\n    const outBuf = [];\n    let longest = 0;\n    for (const time of this.times) {\n      const name = time.name;\n      if (name.length > longest) {\n        longest = name.length;\n      }\n    }\n    for (const time of this.times) {\n      const duration = time.end - time.start;\n      outBuf.push(`${time.name.padEnd(longest)} ${duration}ms\\n`);\n    }\n    return outBuf.join(\"\");\n  }\n}\n\nfunction isFetchSupported() {\n  return (\n    typeof fetch !== \"undefined\" &&\n    typeof Response !== \"undefined\" &&\n    \"body\" in Response.prototype &&\n    typeof ReadableStream !== \"undefined\"\n  );\n}\n\nfunction isValidFetchUrl(url, baseUrl) {\n  try {\n    const { protocol } = baseUrl ? new URL(url, baseUrl) : new URL(url);\n    // The Fetch API only supports the http/https protocols, and not file/ftp.\n    return protocol === \"http:\" || protocol === \"https:\";\n  } catch (ex) {\n    return false; // `new URL()` will throw on incorrect data.\n  }\n}\n\n/**\n * @param {string} src\n * @returns {Promise<void>}\n */\nfunction loadScript(src) {\n  return new Promise((resolve, reject) => {\n    const script = document.createElement(\"script\");\n    script.src = src;\n\n    script.onload = resolve;\n    script.onerror = function () {\n      reject(new Error(`Cannot load script at: ${script.src}`));\n    };\n    (document.head || document.documentElement).appendChild(script);\n  });\n}\n\n// Deprecated API function -- display regardless of the `verbosity` setting.\nfunction deprecated(details) {\n  console.log(\"Deprecated API usage: \" + details);\n}\n\nlet pdfDateStringRegex;\n\nclass PDFDateString {\n  /**\n   * Convert a PDF date string to a JavaScript `Date` object.\n   *\n   * The PDF date string format is described in section 7.9.4 of the official\n   * PDF 32000-1:2008 specification. However, in the PDF 1.7 reference (sixth\n   * edition) Adobe describes the same format including a trailing apostrophe.\n   * This syntax in incorrect, but Adobe Acrobat creates PDF files that contain\n   * them. We ignore all apostrophes as they are not necessary for date parsing.\n   *\n   * Moreover, Adobe Acrobat doesn't handle changing the date to universal time\n   * and doesn't use the user's time zone (effectively ignoring the HH' and mm'\n   * parts of the date string).\n   *\n   * @param {string} input\n   * @returns {Date|null}\n   */\n  static toDateObject(input) {\n    if (!input || !isString(input)) {\n      return null;\n    }\n\n    // Lazily initialize the regular expression.\n    if (!pdfDateStringRegex) {\n      pdfDateStringRegex = new RegExp(\n        \"^D:\" + // Prefix (required)\n        \"(\\\\d{4})\" + // Year (required)\n        \"(\\\\d{2})?\" + // Month (optional)\n        \"(\\\\d{2})?\" + // Day (optional)\n        \"(\\\\d{2})?\" + // Hour (optional)\n        \"(\\\\d{2})?\" + // Minute (optional)\n        \"(\\\\d{2})?\" + // Second (optional)\n        \"([Z|+|-])?\" + // Universal time relation (optional)\n        \"(\\\\d{2})?\" + // Offset hour (optional)\n        \"'?\" + // Splitting apostrophe (optional)\n        \"(\\\\d{2})?\" + // Offset minute (optional)\n          \"'?\" // Trailing apostrophe (optional)\n      );\n    }\n\n    // Optional fields that don't satisfy the requirements from the regular\n    // expression (such as incorrect digit counts or numbers that are out of\n    // range) will fall back the defaults from the specification.\n    const matches = pdfDateStringRegex.exec(input);\n    if (!matches) {\n      return null;\n    }\n\n    // JavaScript's `Date` object expects the month to be between 0 and 11\n    // instead of 1 and 12, so we have to correct for that.\n    const year = parseInt(matches[1], 10);\n    let month = parseInt(matches[2], 10);\n    month = month >= 1 && month <= 12 ? month - 1 : 0;\n    let day = parseInt(matches[3], 10);\n    day = day >= 1 && day <= 31 ? day : 1;\n    let hour = parseInt(matches[4], 10);\n    hour = hour >= 0 && hour <= 23 ? hour : 0;\n    let minute = parseInt(matches[5], 10);\n    minute = minute >= 0 && minute <= 59 ? minute : 0;\n    let second = parseInt(matches[6], 10);\n    second = second >= 0 && second <= 59 ? second : 0;\n    const universalTimeRelation = matches[7] || \"Z\";\n    let offsetHour = parseInt(matches[8], 10);\n    offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0;\n    let offsetMinute = parseInt(matches[9], 10) || 0;\n    offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0;\n\n    // Universal time relation 'Z' means that the local time is equal to the\n    // universal time, whereas the relations '+'/'-' indicate that the local\n    // time is later respectively earlier than the universal time. Every date\n    // is normalized to universal time.\n    if (universalTimeRelation === \"-\") {\n      hour += offsetHour;\n      minute += offsetMinute;\n    } else if (universalTimeRelation === \"+\") {\n      hour -= offsetHour;\n      minute -= offsetMinute;\n    }\n\n    return new Date(Date.UTC(year, month, day, hour, minute, second));\n  }\n}\n\nexport {\n  PageViewport,\n  RenderingCancelledException,\n  addLinkAttributes,\n  getFilenameFromUrl,\n  LinkTarget,\n  DEFAULT_LINK_REL,\n  BaseCanvasFactory,\n  DOMCanvasFactory,\n  BaseCMapReaderFactory,\n  DOMCMapReaderFactory,\n  DOMSVGFactory,\n  StatTimer,\n  isFetchSupported,\n  isValidFetchUrl,\n  loadScript,\n  deprecated,\n  PDFDateString,\n};\n","module.exports = require(\"regenerator-runtime\");\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","module.exports = function(module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function() {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport \"./compatibility.js\";\n\nconst IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];\nconst FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];\n\n// Permission flags from Table 22, Section 7.6.3.2 of the PDF specification.\nconst PermissionFlag = {\n  PRINT: 0x04,\n  MODIFY_CONTENTS: 0x08,\n  COPY: 0x10,\n  MODIFY_ANNOTATIONS: 0x20,\n  FILL_INTERACTIVE_FORMS: 0x100,\n  COPY_FOR_ACCESSIBILITY: 0x200,\n  ASSEMBLE: 0x400,\n  PRINT_HIGH_QUALITY: 0x800,\n};\n\nconst TextRenderingMode = {\n  FILL: 0,\n  STROKE: 1,\n  FILL_STROKE: 2,\n  INVISIBLE: 3,\n  FILL_ADD_TO_PATH: 4,\n  STROKE_ADD_TO_PATH: 5,\n  FILL_STROKE_ADD_TO_PATH: 6,\n  ADD_TO_PATH: 7,\n  FILL_STROKE_MASK: 3,\n  ADD_TO_PATH_FLAG: 4,\n};\n\nconst ImageKind = {\n  GRAYSCALE_1BPP: 1,\n  RGB_24BPP: 2,\n  RGBA_32BPP: 3,\n};\n\nconst AnnotationType = {\n  TEXT: 1,\n  LINK: 2,\n  FREETEXT: 3,\n  LINE: 4,\n  SQUARE: 5,\n  CIRCLE: 6,\n  POLYGON: 7,\n  POLYLINE: 8,\n  HIGHLIGHT: 9,\n  UNDERLINE: 10,\n  SQUIGGLY: 11,\n  STRIKEOUT: 12,\n  STAMP: 13,\n  CARET: 14,\n  INK: 15,\n  POPUP: 16,\n  FILEATTACHMENT: 17,\n  SOUND: 18,\n  MOVIE: 19,\n  WIDGET: 20,\n  SCREEN: 21,\n  PRINTERMARK: 22,\n  TRAPNET: 23,\n  WATERMARK: 24,\n  THREED: 25,\n  REDACT: 26,\n};\n\nconst AnnotationStateModelType = {\n  MARKED: \"Marked\",\n  REVIEW: \"Review\",\n};\n\nconst AnnotationMarkedState = {\n  MARKED: \"Marked\",\n  UNMARKED: \"Unmarked\",\n};\n\nconst AnnotationReviewState = {\n  ACCEPTED: \"Accepted\",\n  REJECTED: \"Rejected\",\n  CANCELLED: \"Cancelled\",\n  COMPLETED: \"Completed\",\n  NONE: \"None\",\n};\n\nconst AnnotationReplyType = {\n  GROUP: \"Group\",\n  REPLY: \"R\",\n};\n\nconst AnnotationFlag = {\n  INVISIBLE: 0x01,\n  HIDDEN: 0x02,\n  PRINT: 0x04,\n  NOZOOM: 0x08,\n  NOROTATE: 0x10,\n  NOVIEW: 0x20,\n  READONLY: 0x40,\n  LOCKED: 0x80,\n  TOGGLENOVIEW: 0x100,\n  LOCKEDCONTENTS: 0x200,\n};\n\nconst AnnotationFieldFlag = {\n  READONLY: 0x0000001,\n  REQUIRED: 0x0000002,\n  NOEXPORT: 0x0000004,\n  MULTILINE: 0x0001000,\n  PASSWORD: 0x0002000,\n  NOTOGGLETOOFF: 0x0004000,\n  RADIO: 0x0008000,\n  PUSHBUTTON: 0x0010000,\n  COMBO: 0x0020000,\n  EDIT: 0x0040000,\n  SORT: 0x0080000,\n  FILESELECT: 0x0100000,\n  MULTISELECT: 0x0200000,\n  DONOTSPELLCHECK: 0x0400000,\n  DONOTSCROLL: 0x0800000,\n  COMB: 0x1000000,\n  RICHTEXT: 0x2000000,\n  RADIOSINUNISON: 0x2000000,\n  COMMITONSELCHANGE: 0x4000000,\n};\n\nconst AnnotationBorderStyleType = {\n  SOLID: 1,\n  DASHED: 2,\n  BEVELED: 3,\n  INSET: 4,\n  UNDERLINE: 5,\n};\n\nconst StreamType = {\n  UNKNOWN: \"UNKNOWN\",\n  FLATE: \"FLATE\",\n  LZW: \"LZW\",\n  DCT: \"DCT\",\n  JPX: \"JPX\",\n  JBIG: \"JBIG\",\n  A85: \"A85\",\n  AHX: \"AHX\",\n  CCF: \"CCF\",\n  RLX: \"RLX\", // PDF short name is 'RL', but telemetry requires three chars.\n};\n\nconst FontType = {\n  UNKNOWN: \"UNKNOWN\",\n  TYPE1: \"TYPE1\",\n  TYPE1C: \"TYPE1C\",\n  CIDFONTTYPE0: \"CIDFONTTYPE0\",\n  CIDFONTTYPE0C: \"CIDFONTTYPE0C\",\n  TRUETYPE: \"TRUETYPE\",\n  CIDFONTTYPE2: \"CIDFONTTYPE2\",\n  TYPE3: \"TYPE3\",\n  OPENTYPE: \"OPENTYPE\",\n  TYPE0: \"TYPE0\",\n  MMTYPE1: \"MMTYPE1\",\n};\n\nconst VerbosityLevel = {\n  ERRORS: 0,\n  WARNINGS: 1,\n  INFOS: 5,\n};\n\nconst CMapCompressionType = {\n  NONE: 0,\n  BINARY: 1,\n  STREAM: 2,\n};\n\n// All the possible operations for an operator list.\nconst OPS = {\n  // Intentionally start from 1 so it is easy to spot bad operators that will be\n  // 0's.\n  dependency: 1,\n  setLineWidth: 2,\n  setLineCap: 3,\n  setLineJoin: 4,\n  setMiterLimit: 5,\n  setDash: 6,\n  setRenderingIntent: 7,\n  setFlatness: 8,\n  setGState: 9,\n  save: 10,\n  restore: 11,\n  transform: 12,\n  moveTo: 13,\n  lineTo: 14,\n  curveTo: 15,\n  curveTo2: 16,\n  curveTo3: 17,\n  closePath: 18,\n  rectangle: 19,\n  stroke: 20,\n  closeStroke: 21,\n  fill: 22,\n  eoFill: 23,\n  fillStroke: 24,\n  eoFillStroke: 25,\n  closeFillStroke: 26,\n  closeEOFillStroke: 27,\n  endPath: 28,\n  clip: 29,\n  eoClip: 30,\n  beginText: 31,\n  endText: 32,\n  setCharSpacing: 33,\n  setWordSpacing: 34,\n  setHScale: 35,\n  setLeading: 36,\n  setFont: 37,\n  setTextRenderingMode: 38,\n  setTextRise: 39,\n  moveText: 40,\n  setLeadingMoveText: 41,\n  setTextMatrix: 42,\n  nextLine: 43,\n  showText: 44,\n  showSpacedText: 45,\n  nextLineShowText: 46,\n  nextLineSetSpacingShowText: 47,\n  setCharWidth: 48,\n  setCharWidthAndBounds: 49,\n  setStrokeColorSpace: 50,\n  setFillColorSpace: 51,\n  setStrokeColor: 52,\n  setStrokeColorN: 53,\n  setFillColor: 54,\n  setFillColorN: 55,\n  setStrokeGray: 56,\n  setFillGray: 57,\n  setStrokeRGBColor: 58,\n  setFillRGBColor: 59,\n  setStrokeCMYKColor: 60,\n  setFillCMYKColor: 61,\n  shadingFill: 62,\n  beginInlineImage: 63,\n  beginImageData: 64,\n  endInlineImage: 65,\n  paintXObject: 66,\n  markPoint: 67,\n  markPointProps: 68,\n  beginMarkedContent: 69,\n  beginMarkedContentProps: 70,\n  endMarkedContent: 71,\n  beginCompat: 72,\n  endCompat: 73,\n  paintFormXObjectBegin: 74,\n  paintFormXObjectEnd: 75,\n  beginGroup: 76,\n  endGroup: 77,\n  beginAnnotations: 78,\n  endAnnotations: 79,\n  beginAnnotation: 80,\n  endAnnotation: 81,\n  paintJpegXObject: 82,\n  paintImageMaskXObject: 83,\n  paintImageMaskXObjectGroup: 84,\n  paintImageXObject: 85,\n  paintInlineImageXObject: 86,\n  paintInlineImageXObjectGroup: 87,\n  paintImageXObjectRepeat: 88,\n  paintImageMaskXObjectRepeat: 89,\n  paintSolidColorImageMask: 90,\n  constructPath: 91,\n};\n\nconst UNSUPPORTED_FEATURES = {\n  /** @deprecated unused */\n  unknown: \"unknown\",\n  forms: \"forms\",\n  javaScript: \"javaScript\",\n  smask: \"smask\",\n  shadingPattern: \"shadingPattern\",\n  /** @deprecated unused */\n  font: \"font\",\n  errorTilingPattern: \"errorTilingPattern\",\n  errorExtGState: \"errorExtGState\",\n  errorXObject: \"errorXObject\",\n  errorFontLoadType3: \"errorFontLoadType3\",\n  errorFontState: \"errorFontState\",\n  errorFontMissing: \"errorFontMissing\",\n  errorFontTranslate: \"errorFontTranslate\",\n  errorColorSpace: \"errorColorSpace\",\n  errorOperatorList: \"errorOperatorList\",\n  errorFontToUnicode: \"errorFontToUnicode\",\n  errorFontLoadNative: \"errorFontLoadNative\",\n  errorFontGetPath: \"errorFontGetPath\",\n  errorMarkedContent: \"errorMarkedContent\",\n};\n\nconst PasswordResponses = {\n  NEED_PASSWORD: 1,\n  INCORRECT_PASSWORD: 2,\n};\n\nlet verbosity = VerbosityLevel.WARNINGS;\n\nfunction setVerbosityLevel(level) {\n  if (Number.isInteger(level)) {\n    verbosity = level;\n  }\n}\n\nfunction getVerbosityLevel() {\n  return verbosity;\n}\n\n// A notice for devs. These are good for things that are helpful to devs, such\n// as warning that Workers were disabled, which is important to devs but not\n// end users.\nfunction info(msg) {\n  if (verbosity >= VerbosityLevel.INFOS) {\n    console.log(`Info: ${msg}`);\n  }\n}\n\n// Non-fatal warnings.\nfunction warn(msg) {\n  if (verbosity >= VerbosityLevel.WARNINGS) {\n    console.log(`Warning: ${msg}`);\n  }\n}\n\nfunction unreachable(msg) {\n  throw new Error(msg);\n}\n\nfunction assert(cond, msg) {\n  if (!cond) {\n    unreachable(msg);\n  }\n}\n\n// Checks if URLs have the same origin. For non-HTTP based URLs, returns false.\nfunction isSameOrigin(baseUrl, otherUrl) {\n  let base;\n  try {\n    base = new URL(baseUrl);\n    if (!base.origin || base.origin === \"null\") {\n      return false; // non-HTTP url\n    }\n  } catch (e) {\n    return false;\n  }\n\n  const other = new URL(otherUrl, base);\n  return base.origin === other.origin;\n}\n\n// Checks if URLs use one of the allowed protocols, e.g. to avoid XSS.\nfunction _isValidProtocol(url) {\n  if (!url) {\n    return false;\n  }\n  switch (url.protocol) {\n    case \"http:\":\n    case \"https:\":\n    case \"ftp:\":\n    case \"mailto:\":\n    case \"tel:\":\n      return true;\n    default:\n      return false;\n  }\n}\n\n/**\n * Attempts to create a valid absolute URL.\n *\n * @param {URL|string} url - An absolute, or relative, URL.\n * @param {URL|string} baseUrl - An absolute URL.\n * @returns Either a valid {URL}, or `null` otherwise.\n */\nfunction createValidAbsoluteUrl(url, baseUrl) {\n  if (!url) {\n    return null;\n  }\n  try {\n    const absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);\n    if (_isValidProtocol(absoluteUrl)) {\n      return absoluteUrl;\n    }\n  } catch (ex) {\n    /* `new URL()` will throw on incorrect data. */\n  }\n  return null;\n}\n\nfunction shadow(obj, prop, value) {\n  Object.defineProperty(obj, prop, {\n    value,\n    enumerable: true,\n    configurable: true,\n    writable: false,\n  });\n  return value;\n}\n\n/**\n * @type {any}\n */\nconst BaseException = (function BaseExceptionClosure() {\n  // eslint-disable-next-line no-shadow\n  function BaseException(message) {\n    if (this.constructor === BaseException) {\n      unreachable(\"Cannot initialize BaseException.\");\n    }\n    this.message = message;\n    this.name = this.constructor.name;\n  }\n  BaseException.prototype = new Error();\n  BaseException.constructor = BaseException;\n\n  return BaseException;\n})();\n\nclass PasswordException extends BaseException {\n  constructor(msg, code) {\n    super(msg);\n    this.code = code;\n  }\n}\n\nclass UnknownErrorException extends BaseException {\n  constructor(msg, details) {\n    super(msg);\n    this.details = details;\n  }\n}\n\nclass InvalidPDFException extends BaseException {}\n\nclass MissingPDFException extends BaseException {}\n\nclass UnexpectedResponseException extends BaseException {\n  constructor(msg, status) {\n    super(msg);\n    this.status = status;\n  }\n}\n\n/**\n * Error caused during parsing PDF data.\n */\nclass FormatError extends BaseException {}\n\n/**\n * Error used to indicate task cancellation.\n */\nclass AbortException extends BaseException {}\n\nconst NullCharactersRegExp = /\\x00/g;\n\n/**\n * @param {string} str\n */\nfunction removeNullCharacters(str) {\n  if (typeof str !== \"string\") {\n    warn(\"The argument for removeNullCharacters must be a string.\");\n    return str;\n  }\n  return str.replace(NullCharactersRegExp, \"\");\n}\n\nfunction bytesToString(bytes) {\n  assert(\n    bytes !== null && typeof bytes === \"object\" && bytes.length !== undefined,\n    \"Invalid argument for bytesToString\"\n  );\n  const length = bytes.length;\n  const MAX_ARGUMENT_COUNT = 8192;\n  if (length < MAX_ARGUMENT_COUNT) {\n    return String.fromCharCode.apply(null, bytes);\n  }\n  const strBuf = [];\n  for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {\n    const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);\n    const chunk = bytes.subarray(i, chunkEnd);\n    strBuf.push(String.fromCharCode.apply(null, chunk));\n  }\n  return strBuf.join(\"\");\n}\n\nfunction stringToBytes(str) {\n  assert(typeof str === \"string\", \"Invalid argument for stringToBytes\");\n  const length = str.length;\n  const bytes = new Uint8Array(length);\n  for (let i = 0; i < length; ++i) {\n    bytes[i] = str.charCodeAt(i) & 0xff;\n  }\n  return bytes;\n}\n\n/**\n * Gets length of the array (Array, Uint8Array, or string) in bytes.\n * @param {Array<any>|Uint8Array|string} arr\n * @returns {number}\n */\nfunction arrayByteLength(arr) {\n  if (arr.length !== undefined) {\n    return arr.length;\n  }\n  assert(arr.byteLength !== undefined, \"arrayByteLength - invalid argument.\");\n  return arr.byteLength;\n}\n\n/**\n * Combines array items (arrays) into single Uint8Array object.\n * @param {Array<Array<any>|Uint8Array|string>} arr - the array of the arrays\n *   (Array, Uint8Array, or string).\n * @returns {Uint8Array}\n */\nfunction arraysToBytes(arr) {\n  const length = arr.length;\n  // Shortcut: if first and only item is Uint8Array, return it.\n  if (length === 1 && arr[0] instanceof Uint8Array) {\n    return arr[0];\n  }\n  let resultLength = 0;\n  for (let i = 0; i < length; i++) {\n    resultLength += arrayByteLength(arr[i]);\n  }\n  let pos = 0;\n  const data = new Uint8Array(resultLength);\n  for (let i = 0; i < length; i++) {\n    let item = arr[i];\n    if (!(item instanceof Uint8Array)) {\n      if (typeof item === \"string\") {\n        item = stringToBytes(item);\n      } else {\n        item = new Uint8Array(item);\n      }\n    }\n    const itemLength = item.byteLength;\n    data.set(item, pos);\n    pos += itemLength;\n  }\n  return data;\n}\n\nfunction string32(value) {\n  return String.fromCharCode(\n    (value >> 24) & 0xff,\n    (value >> 16) & 0xff,\n    (value >> 8) & 0xff,\n    value & 0xff\n  );\n}\n\n// Checks the endianness of the platform.\nfunction isLittleEndian() {\n  const buffer8 = new Uint8Array(4);\n  buffer8[0] = 1;\n  const view32 = new Uint32Array(buffer8.buffer, 0, 1);\n  return view32[0] === 1;\n}\nconst IsLittleEndianCached = {\n  get value() {\n    return shadow(this, \"value\", isLittleEndian());\n  },\n};\n\n// Checks if it's possible to eval JS expressions.\nfunction isEvalSupported() {\n  try {\n    new Function(\"\"); // eslint-disable-line no-new, no-new-func\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\nconst IsEvalSupportedCached = {\n  get value() {\n    return shadow(this, \"value\", isEvalSupported());\n  },\n};\n\nconst rgbBuf = [\"rgb(\", 0, \",\", 0, \",\", 0, \")\"];\n\nclass Util {\n  // makeCssRgb() can be called thousands of times. Using ´rgbBuf` avoids\n  // creating many intermediate strings.\n  static makeCssRgb(r, g, b) {\n    rgbBuf[1] = r;\n    rgbBuf[3] = g;\n    rgbBuf[5] = b;\n    return rgbBuf.join(\"\");\n  }\n\n  // Concatenates two transformation matrices together and returns the result.\n  static transform(m1, m2) {\n    return [\n      m1[0] * m2[0] + m1[2] * m2[1],\n      m1[1] * m2[0] + m1[3] * m2[1],\n      m1[0] * m2[2] + m1[2] * m2[3],\n      m1[1] * m2[2] + m1[3] * m2[3],\n      m1[0] * m2[4] + m1[2] * m2[5] + m1[4],\n      m1[1] * m2[4] + m1[3] * m2[5] + m1[5],\n    ];\n  }\n\n  // For 2d affine transforms\n  static applyTransform(p, m) {\n    const xt = p[0] * m[0] + p[1] * m[2] + m[4];\n    const yt = p[0] * m[1] + p[1] * m[3] + m[5];\n    return [xt, yt];\n  }\n\n  static applyInverseTransform(p, m) {\n    const d = m[0] * m[3] - m[1] * m[2];\n    const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;\n    const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;\n    return [xt, yt];\n  }\n\n  // Applies the transform to the rectangle and finds the minimum axially\n  // aligned bounding box.\n  static getAxialAlignedBoundingBox(r, m) {\n    const p1 = Util.applyTransform(r, m);\n    const p2 = Util.applyTransform(r.slice(2, 4), m);\n    const p3 = Util.applyTransform([r[0], r[3]], m);\n    const p4 = Util.applyTransform([r[2], r[1]], m);\n    return [\n      Math.min(p1[0], p2[0], p3[0], p4[0]),\n      Math.min(p1[1], p2[1], p3[1], p4[1]),\n      Math.max(p1[0], p2[0], p3[0], p4[0]),\n      Math.max(p1[1], p2[1], p3[1], p4[1]),\n    ];\n  }\n\n  static inverseTransform(m) {\n    const d = m[0] * m[3] - m[1] * m[2];\n    return [\n      m[3] / d,\n      -m[1] / d,\n      -m[2] / d,\n      m[0] / d,\n      (m[2] * m[5] - m[4] * m[3]) / d,\n      (m[4] * m[1] - m[5] * m[0]) / d,\n    ];\n  }\n\n  // Apply a generic 3d matrix M on a 3-vector v:\n  //   | a b c |   | X |\n  //   | d e f | x | Y |\n  //   | g h i |   | Z |\n  // M is assumed to be serialized as [a,b,c,d,e,f,g,h,i],\n  // with v as [X,Y,Z]\n  static apply3dTransform(m, v) {\n    return [\n      m[0] * v[0] + m[1] * v[1] + m[2] * v[2],\n      m[3] * v[0] + m[4] * v[1] + m[5] * v[2],\n      m[6] * v[0] + m[7] * v[1] + m[8] * v[2],\n    ];\n  }\n\n  // This calculation uses Singular Value Decomposition.\n  // The SVD can be represented with formula A = USV. We are interested in the\n  // matrix S here because it represents the scale values.\n  static singularValueDecompose2dScale(m) {\n    const transpose = [m[0], m[2], m[1], m[3]];\n\n    // Multiply matrix m with its transpose.\n    const a = m[0] * transpose[0] + m[1] * transpose[2];\n    const b = m[0] * transpose[1] + m[1] * transpose[3];\n    const c = m[2] * transpose[0] + m[3] * transpose[2];\n    const d = m[2] * transpose[1] + m[3] * transpose[3];\n\n    // Solve the second degree polynomial to get roots.\n    const first = (a + d) / 2;\n    const second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;\n    const sx = first + second || 1;\n    const sy = first - second || 1;\n\n    // Scale values are the square roots of the eigenvalues.\n    return [Math.sqrt(sx), Math.sqrt(sy)];\n  }\n\n  // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)\n  // For coordinate systems whose origin lies in the bottom-left, this\n  // means normalization to (BL,TR) ordering. For systems with origin in the\n  // top-left, this means (TL,BR) ordering.\n  static normalizeRect(rect) {\n    const r = rect.slice(0); // clone rect\n    if (rect[0] > rect[2]) {\n      r[0] = rect[2];\n      r[2] = rect[0];\n    }\n    if (rect[1] > rect[3]) {\n      r[1] = rect[3];\n      r[3] = rect[1];\n    }\n    return r;\n  }\n\n  // Returns a rectangle [x1, y1, x2, y2] corresponding to the\n  // intersection of rect1 and rect2. If no intersection, returns 'false'\n  // The rectangle coordinates of rect1, rect2 should be [x1, y1, x2, y2]\n  static intersect(rect1, rect2) {\n    function compare(a, b) {\n      return a - b;\n    }\n\n    // Order points along the axes\n    const orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare);\n    const orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare);\n    const result = [];\n\n    rect1 = Util.normalizeRect(rect1);\n    rect2 = Util.normalizeRect(rect2);\n\n    // X: first and second points belong to different rectangles?\n    if (\n      (orderedX[0] === rect1[0] && orderedX[1] === rect2[0]) ||\n      (orderedX[0] === rect2[0] && orderedX[1] === rect1[0])\n    ) {\n      // Intersection must be between second and third points\n      result[0] = orderedX[1];\n      result[2] = orderedX[2];\n    } else {\n      return null;\n    }\n\n    // Y: first and second points belong to different rectangles?\n    if (\n      (orderedY[0] === rect1[1] && orderedY[1] === rect2[1]) ||\n      (orderedY[0] === rect2[1] && orderedY[1] === rect1[1])\n    ) {\n      // Intersection must be between second and third points\n      result[1] = orderedY[1];\n      result[3] = orderedY[2];\n    } else {\n      return null;\n    }\n\n    return result;\n  }\n}\n\n// prettier-ignore\nconst PDFStringTranslateTable = [\n  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n  0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0,\n  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014,\n  0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C,\n  0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160,\n  0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC\n];\n\nfunction stringToPDFString(str) {\n  const length = str.length,\n    strBuf = [];\n  if (str[0] === \"\\xFE\" && str[1] === \"\\xFF\") {\n    // UTF16BE BOM\n    for (let i = 2; i < length; i += 2) {\n      strBuf.push(\n        String.fromCharCode((str.charCodeAt(i) << 8) | str.charCodeAt(i + 1))\n      );\n    }\n  } else if (str[0] === \"\\xFF\" && str[1] === \"\\xFE\") {\n    // UTF16LE BOM\n    for (let i = 2; i < length; i += 2) {\n      strBuf.push(\n        String.fromCharCode((str.charCodeAt(i + 1) << 8) | str.charCodeAt(i))\n      );\n    }\n  } else {\n    for (let i = 0; i < length; ++i) {\n      const code = PDFStringTranslateTable[str.charCodeAt(i)];\n      strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));\n    }\n  }\n  return strBuf.join(\"\");\n}\n\nfunction escapeString(str) {\n  // replace \"(\", \")\" and \"\\\" by \"\\(\", \"\\)\" and \"\\\\\"\n  // in order to write it in a PDF file.\n  return str.replace(/([\\(\\)\\\\])/g, \"\\\\$1\");\n}\n\nfunction stringToUTF8String(str) {\n  return decodeURIComponent(escape(str));\n}\n\nfunction utf8StringToString(str) {\n  return unescape(encodeURIComponent(str));\n}\n\nfunction isBool(v) {\n  return typeof v === \"boolean\";\n}\n\nfunction isNum(v) {\n  return typeof v === \"number\";\n}\n\nfunction isString(v) {\n  return typeof v === \"string\";\n}\n\nfunction isArrayBuffer(v) {\n  return typeof v === \"object\" && v !== null && v.byteLength !== undefined;\n}\n\nfunction isArrayEqual(arr1, arr2) {\n  if (arr1.length !== arr2.length) {\n    return false;\n  }\n  return arr1.every(function (element, index) {\n    return element === arr2[index];\n  });\n}\n\nfunction getModificationDate(date = new Date(Date.now())) {\n  const buffer = [\n    date.getUTCFullYear().toString(),\n    (date.getUTCMonth() + 1).toString().padStart(2, \"0\"),\n    (date.getUTCDate() + 1).toString().padStart(2, \"0\"),\n    date.getUTCHours().toString().padStart(2, \"0\"),\n    date.getUTCMinutes().toString().padStart(2, \"0\"),\n    date.getUTCSeconds().toString().padStart(2, \"0\"),\n  ];\n\n  return buffer.join(\"\");\n}\n\n/**\n * Promise Capability object.\n *\n * @typedef {Object} PromiseCapability\n * @property {Promise<any>} promise - A Promise object.\n * @property {boolean} settled - If the Promise has been fulfilled/rejected.\n * @property {function} resolve - Fulfills the Promise.\n * @property {function} reject - Rejects the Promise.\n */\n\n/**\n * Creates a promise capability object.\n * @alias createPromiseCapability\n *\n * @returns {PromiseCapability}\n */\nfunction createPromiseCapability() {\n  const capability = Object.create(null);\n  let isSettled = false;\n\n  Object.defineProperty(capability, \"settled\", {\n    get() {\n      return isSettled;\n    },\n  });\n  capability.promise = new Promise(function (resolve, reject) {\n    capability.resolve = function (data) {\n      isSettled = true;\n      resolve(data);\n    };\n    capability.reject = function (reason) {\n      isSettled = true;\n      reject(reason);\n    };\n  });\n  return capability;\n}\n\nconst createObjectURL = (function createObjectURLClosure() {\n  // Blob/createObjectURL is not available, falling back to data schema.\n  const digits =\n    \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\";\n\n  // eslint-disable-next-line no-shadow\n  return function createObjectURL(data, contentType, forceDataSchema = false) {\n    if (!forceDataSchema && URL.createObjectURL) {\n      const blob = new Blob([data], { type: contentType });\n      return URL.createObjectURL(blob);\n    }\n\n    let buffer = `data:${contentType};base64,`;\n    for (let i = 0, ii = data.length; i < ii; i += 3) {\n      const b1 = data[i] & 0xff;\n      const b2 = data[i + 1] & 0xff;\n      const b3 = data[i + 2] & 0xff;\n      const d1 = b1 >> 2,\n        d2 = ((b1 & 3) << 4) | (b2 >> 4);\n      const d3 = i + 1 < ii ? ((b2 & 0xf) << 2) | (b3 >> 6) : 64;\n      const d4 = i + 2 < ii ? b3 & 0x3f : 64;\n      buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];\n    }\n    return buffer;\n  };\n})();\n\nexport {\n  BaseException,\n  FONT_IDENTITY_MATRIX,\n  IDENTITY_MATRIX,\n  OPS,\n  VerbosityLevel,\n  UNSUPPORTED_FEATURES,\n  AnnotationBorderStyleType,\n  AnnotationFieldFlag,\n  AnnotationFlag,\n  AnnotationMarkedState,\n  AnnotationReplyType,\n  AnnotationReviewState,\n  AnnotationStateModelType,\n  AnnotationType,\n  FontType,\n  ImageKind,\n  CMapCompressionType,\n  AbortException,\n  InvalidPDFException,\n  MissingPDFException,\n  PasswordException,\n  PasswordResponses,\n  PermissionFlag,\n  StreamType,\n  TextRenderingMode,\n  UnexpectedResponseException,\n  UnknownErrorException,\n  Util,\n  FormatError,\n  arrayByteLength,\n  arraysToBytes,\n  assert,\n  bytesToString,\n  createPromiseCapability,\n  createObjectURL,\n  escapeString,\n  getModificationDate,\n  getVerbosityLevel,\n  info,\n  isArrayBuffer,\n  isArrayEqual,\n  isBool,\n  isNum,\n  isString,\n  isSameOrigin,\n  createValidAbsoluteUrl,\n  IsLittleEndianCached,\n  IsEvalSupportedCached,\n  removeNullCharacters,\n  setVerbosityLevel,\n  shadow,\n  string32,\n  stringToBytes,\n  stringToPDFString,\n  stringToUTF8String,\n  utf8StringToString,\n  warn,\n  unreachable,\n};\n","/* Copyright 2017 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport { isNodeJS } from \"./is_node.js\";\n\n// Skip compatibility checks for modern builds and if we already ran the module.\nif (\n  (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"SKIP_BABEL\")) &&\n  (typeof globalThis === \"undefined\" || !globalThis._pdfjsCompatibilityChecked)\n) {\n  // Provides support for globalThis in legacy browsers.\n  // Support: IE11/Edge, Opera\n  if (typeof globalThis === \"undefined\" || globalThis.Math !== Math) {\n    // eslint-disable-next-line no-global-assign\n    globalThis = require(\"core-js/es/global-this\");\n  }\n  globalThis._pdfjsCompatibilityChecked = true;\n\n  const hasDOM = typeof window === \"object\" && typeof document === \"object\";\n  const userAgent =\n    (typeof navigator !== \"undefined\" && navigator.userAgent) || \"\";\n  const isIE = /Trident/.test(userAgent);\n\n  // Support: Node.js\n  (function checkNodeBtoa() {\n    if (globalThis.btoa || !isNodeJS) {\n      return;\n    }\n    globalThis.btoa = function (chars) {\n      // eslint-disable-next-line no-undef\n      return Buffer.from(chars, \"binary\").toString(\"base64\");\n    };\n  })();\n\n  // Support: Node.js\n  (function checkNodeAtob() {\n    if (globalThis.atob || !isNodeJS) {\n      return;\n    }\n    globalThis.atob = function (input) {\n      // eslint-disable-next-line no-undef\n      return Buffer.from(input, \"base64\").toString(\"binary\");\n    };\n  })();\n\n  // Provides support for ChildNode.remove in legacy browsers.\n  // Support: IE.\n  (function checkChildNodeRemove() {\n    if (!hasDOM) {\n      return;\n    }\n    if (typeof Element.prototype.remove !== \"undefined\") {\n      return;\n    }\n    Element.prototype.remove = function () {\n      if (this.parentNode) {\n        // eslint-disable-next-line mozilla/avoid-removeChild\n        this.parentNode.removeChild(this);\n      }\n    };\n  })();\n\n  // Provides support for DOMTokenList.prototype.{add, remove}, with more than\n  // one parameter, in legacy browsers.\n  // Support: IE\n  (function checkDOMTokenListAddRemove() {\n    if (!hasDOM || isNodeJS) {\n      return;\n    }\n    const div = document.createElement(\"div\");\n    div.classList.add(\"testOne\", \"testTwo\");\n\n    if (\n      div.classList.contains(\"testOne\") === true &&\n      div.classList.contains(\"testTwo\") === true\n    ) {\n      return;\n    }\n    const OriginalDOMTokenListAdd = DOMTokenList.prototype.add;\n    const OriginalDOMTokenListRemove = DOMTokenList.prototype.remove;\n\n    DOMTokenList.prototype.add = function (...tokens) {\n      for (const token of tokens) {\n        OriginalDOMTokenListAdd.call(this, token);\n      }\n    };\n    DOMTokenList.prototype.remove = function (...tokens) {\n      for (const token of tokens) {\n        OriginalDOMTokenListRemove.call(this, token);\n      }\n    };\n  })();\n\n  // Provides support for DOMTokenList.prototype.toggle, with the optional\n  // \"force\" parameter, in legacy browsers.\n  // Support: IE\n  (function checkDOMTokenListToggle() {\n    if (!hasDOM || isNodeJS) {\n      return;\n    }\n    const div = document.createElement(\"div\");\n    if (div.classList.toggle(\"test\", 0) === false) {\n      return;\n    }\n\n    DOMTokenList.prototype.toggle = function (token) {\n      const force =\n        arguments.length > 1 ? !!arguments[1] : !this.contains(token);\n      return this[force ? \"add\" : \"remove\"](token), force;\n    };\n  })();\n\n  // Provides support for window.history.{pushState, replaceState}, with the\n  // `url` parameter set to `undefined`, without breaking the document URL.\n  // Support: IE\n  (function checkWindowHistoryPushStateReplaceState() {\n    if (!hasDOM || !isIE) {\n      return;\n    }\n    const OriginalPushState = window.history.pushState;\n    const OriginalReplaceState = window.history.replaceState;\n\n    window.history.pushState = function (state, title, url) {\n      const args = url === undefined ? [state, title] : [state, title, url];\n      OriginalPushState.apply(this, args);\n    };\n    window.history.replaceState = function (state, title, url) {\n      const args = url === undefined ? [state, title] : [state, title, url];\n      OriginalReplaceState.apply(this, args);\n    };\n  })();\n\n  // Provides support for String.prototype.startsWith in legacy browsers.\n  // Support: IE, Chrome<41\n  (function checkStringStartsWith() {\n    if (String.prototype.startsWith) {\n      return;\n    }\n    require(\"core-js/es/string/starts-with.js\");\n  })();\n\n  // Provides support for String.prototype.endsWith in legacy browsers.\n  // Support: IE, Chrome<41\n  (function checkStringEndsWith() {\n    if (String.prototype.endsWith) {\n      return;\n    }\n    require(\"core-js/es/string/ends-with.js\");\n  })();\n\n  // Provides support for String.prototype.includes in legacy browsers.\n  // Support: IE, Chrome<41\n  (function checkStringIncludes() {\n    if (String.prototype.includes) {\n      return;\n    }\n    require(\"core-js/es/string/includes.js\");\n  })();\n\n  // Provides support for Array.prototype.includes in legacy browsers.\n  // Support: IE, Chrome<47\n  (function checkArrayIncludes() {\n    if (Array.prototype.includes) {\n      return;\n    }\n    require(\"core-js/es/array/includes.js\");\n  })();\n\n  // Provides support for Array.from in legacy browsers.\n  // Support: IE\n  (function checkArrayFrom() {\n    if (Array.from) {\n      return;\n    }\n    require(\"core-js/es/array/from.js\");\n  })();\n\n  // Provides support for Object.assign in legacy browsers.\n  // Support: IE\n  (function checkObjectAssign() {\n    if (Object.assign) {\n      return;\n    }\n    require(\"core-js/es/object/assign.js\");\n  })();\n\n  // Provides support for Object.fromEntries in legacy browsers.\n  // Support: IE, Chrome<73\n  (function checkObjectFromEntries() {\n    if (Object.fromEntries) {\n      return;\n    }\n    require(\"core-js/es/object/from-entries.js\");\n  })();\n\n  // Provides support for Math.log2 in legacy browsers.\n  // Support: IE, Chrome<38\n  (function checkMathLog2() {\n    if (Math.log2) {\n      return;\n    }\n    Math.log2 = require(\"core-js/es/math/log2.js\");\n  })();\n\n  // Provides support for Number.isNaN in legacy browsers.\n  // Support: IE.\n  (function checkNumberIsNaN() {\n    if (Number.isNaN) {\n      return;\n    }\n    Number.isNaN = require(\"core-js/es/number/is-nan.js\");\n  })();\n\n  // Provides support for Number.isInteger in legacy browsers.\n  // Support: IE, Chrome<34\n  (function checkNumberIsInteger() {\n    if (Number.isInteger) {\n      return;\n    }\n    Number.isInteger = require(\"core-js/es/number/is-integer.js\");\n  })();\n\n  // Provides support for TypedArray.prototype.slice in legacy browsers.\n  // Support: IE\n  (function checkTypedArraySlice() {\n    if (Uint8Array.prototype.slice) {\n      return;\n    }\n    require(\"core-js/es/typed-array/slice\");\n  })();\n\n  // Support: IE, Safari<11, Chrome<63\n  (function checkPromise() {\n    if (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"IMAGE_DECODERS\")) {\n      // The current image decoders are synchronous, hence `Promise` shouldn't\n      // need to be polyfilled for the IMAGE_DECODERS build target.\n      return;\n    }\n    if (globalThis.Promise && globalThis.Promise.allSettled) {\n      return;\n    }\n    globalThis.Promise = require(\"core-js/es/promise/index.js\");\n  })();\n\n  // Support: IE\n  (function checkURL() {\n    if (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"PRODUCTION\")) {\n      // Prevent \"require is not a function\" errors in development mode,\n      // since the `URL` constructor should be available in modern browers.\n      return;\n    } else if (!PDFJSDev.test(\"GENERIC\")) {\n      // The `URL` constructor is assumed to be available in the extension\n      // builds.\n      return;\n    } else if (PDFJSDev.test(\"IMAGE_DECODERS\")) {\n      // The current image decoders don't use the `URL` constructor, so it\n      // doesn't need to be polyfilled for the IMAGE_DECODERS build target.\n      return;\n    }\n    globalThis.URL = require(\"core-js/web/url.js\");\n  })();\n\n  // Support: IE, Node.js\n  (function checkReadableStream() {\n    if (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"IMAGE_DECODERS\")) {\n      // The current image decoders are synchronous, hence `ReadableStream`\n      // shouldn't need to be polyfilled for the IMAGE_DECODERS build target.\n      return;\n    }\n    let isReadableStreamSupported = false;\n\n    if (typeof ReadableStream !== \"undefined\") {\n      // MS Edge may say it has ReadableStream but they are not up to spec yet.\n      try {\n        // eslint-disable-next-line no-new\n        new ReadableStream({\n          start(controller) {\n            controller.close();\n          },\n        });\n        isReadableStreamSupported = true;\n      } catch (e) {\n        // The ReadableStream constructor cannot be used.\n      }\n    }\n    if (isReadableStreamSupported) {\n      return;\n    }\n    globalThis.ReadableStream = require(\"web-streams-polyfill/dist/ponyfill.js\").ReadableStream;\n  })();\n\n  // We want to support Map iteration, but it doesn't seem possible to easily\n  // test for that specifically; hence using a similarly unsupported property.\n  // Support: IE11\n  (function checkMapEntries() {\n    if (globalThis.Map && globalThis.Map.prototype.entries) {\n      return;\n    }\n    globalThis.Map = require(\"core-js/es/map/index.js\");\n  })();\n\n  // We want to support Set iteration, but it doesn't seem possible to easily\n  // test for that specifically; hence using a similarly unsupported property.\n  // Support: IE11\n  (function checkSetEntries() {\n    if (globalThis.Set && globalThis.Set.prototype.entries) {\n      return;\n    }\n    globalThis.Set = require(\"core-js/es/set/index.js\");\n  })();\n\n  // Support: IE<11, Safari<8, Chrome<36\n  (function checkWeakMap() {\n    if (globalThis.WeakMap) {\n      return;\n    }\n    globalThis.WeakMap = require(\"core-js/es/weak-map/index.js\");\n  })();\n\n  // Support: IE11\n  (function checkWeakSet() {\n    if (globalThis.WeakSet) {\n      return;\n    }\n    globalThis.WeakSet = require(\"core-js/es/weak-set/index.js\");\n  })();\n\n  // Provides support for String.codePointAt in legacy browsers.\n  // Support: IE11.\n  (function checkStringCodePointAt() {\n    if (String.prototype.codePointAt) {\n      return;\n    }\n    require(\"core-js/es/string/code-point-at.js\");\n  })();\n\n  // Provides support for String.fromCodePoint in legacy browsers.\n  // Support: IE11.\n  (function checkStringFromCodePoint() {\n    if (String.fromCodePoint) {\n      return;\n    }\n    String.fromCodePoint = require(\"core-js/es/string/from-code-point.js\");\n  })();\n\n  // Support: IE\n  (function checkSymbol() {\n    if (globalThis.Symbol) {\n      return;\n    }\n    require(\"core-js/es/symbol/index.js\");\n  })();\n\n  // Provides support for String.prototype.padStart in legacy browsers.\n  // Support: IE, Chrome<57\n  (function checkStringPadStart() {\n    if (String.prototype.padStart) {\n      return;\n    }\n    require(\"core-js/es/string/pad-start.js\");\n  })();\n\n  // Provides support for String.prototype.padEnd in legacy browsers.\n  // Support: IE, Chrome<57\n  (function checkStringPadEnd() {\n    if (String.prototype.padEnd) {\n      return;\n    }\n    require(\"core-js/es/string/pad-end.js\");\n  })();\n\n  // Provides support for Object.values in legacy browsers.\n  // Support: IE, Chrome<54\n  (function checkObjectValues() {\n    if (Object.values) {\n      return;\n    }\n    Object.values = require(\"core-js/es/object/values.js\");\n  })();\n\n  // Provides support for Object.entries in legacy browsers.\n  // Support: IE, Chrome<54\n  (function checkObjectEntries() {\n    if (Object.entries) {\n      return;\n    }\n    Object.entries = require(\"core-js/es/object/entries.js\");\n  })();\n}\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* globals process */\n\n// NW.js / Electron is a browser context, but copies some Node.js objects; see\n// http://docs.nwjs.io/en/latest/For%20Users/Advanced/JavaScript%20Contexts%20in%20NW.js/#access-nodejs-and-nwjs-api-in-browser-context\n// https://www.electronjs.org/docs/api/process#processversionselectron-readonly\n// https://www.electronjs.org/docs/api/process#processtype-readonly\nconst isNodeJS =\n  typeof process === \"object\" &&\n  process + \"\" === \"[object process]\" &&\n  !process.versions.nw &&\n  !(process.versions.electron && process.type && process.type !== \"browser\");\n\nexport { isNodeJS };\n","require('../modules/es.global-this');\n\nmodule.exports = require('../internals/global');\n","var $ = require('../internals/export');\nvar global = require('../internals/global');\n\n// `globalThis` object\n// https://github.com/tc39/proposal-global\n$({ global: true }, {\n  globalThis: global\n});\n","var global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar setGlobal = require('../internals/set-global');\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\nvar isForced = require('../internals/is-forced');\n\n/*\n  options.target      - name of the target object\n  options.global      - target is the global object\n  options.stat        - export as static methods of target\n  options.proto       - export as prototype methods of target\n  options.real        - real prototype method for the `pure` version\n  options.forced      - export even if the native feature is available\n  options.bind        - bind methods to the target, required for the `pure` version\n  options.wrap        - wrap constructors to preventing global pollution, required for the `pure` version\n  options.unsafe      - use the simple assignment of property instead of delete + defineProperty\n  options.sham        - add a flag to not completely full polyfills\n  options.enumerable  - export as enumerable property\n  options.noTargetGet - prevent calling a getter on target\n*/\nmodule.exports = function (options, source) {\n  var TARGET = options.target;\n  var GLOBAL = options.global;\n  var STATIC = options.stat;\n  var FORCED, target, key, targetProperty, sourceProperty, descriptor;\n  if (GLOBAL) {\n    target = global;\n  } else if (STATIC) {\n    target = global[TARGET] || setGlobal(TARGET, {});\n  } else {\n    target = (global[TARGET] || {}).prototype;\n  }\n  if (target) for (key in source) {\n    sourceProperty = source[key];\n    if (options.noTargetGet) {\n      descriptor = getOwnPropertyDescriptor(target, key);\n      targetProperty = descriptor && descriptor.value;\n    } else targetProperty = target[key];\n    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);\n    // contained in target\n    if (!FORCED && targetProperty !== undefined) {\n      if (typeof sourceProperty === typeof targetProperty) continue;\n      copyConstructorProperties(sourceProperty, targetProperty);\n    }\n    // add a flag to not completely full polyfills\n    if (options.sham || (targetProperty && targetProperty.sham)) {\n      createNonEnumerableProperty(sourceProperty, 'sham', true);\n    }\n    // extend global\n    redefine(target, key, sourceProperty, options);\n  }\n};\n","var check = function (it) {\n  return it && it.Math == Math && it;\n};\n\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nmodule.exports =\n  // eslint-disable-next-line no-undef\n  check(typeof globalThis == 'object' && globalThis) ||\n  check(typeof window == 'object' && window) ||\n  check(typeof self == 'object' && self) ||\n  check(typeof global == 'object' && global) ||\n  // eslint-disable-next-line no-new-func\n  Function('return this')();\n","var DESCRIPTORS = require('../internals/descriptors');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPrimitive = require('../internals/to-primitive');\nvar has = require('../internals/has');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\n\nvar nativeGetOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// `Object.getOwnPropertyDescriptor` method\n// https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptor\nexports.f = DESCRIPTORS ? nativeGetOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {\n  O = toIndexedObject(O);\n  P = toPrimitive(P, true);\n  if (IE8_DOM_DEFINE) try {\n    return nativeGetOwnPropertyDescriptor(O, P);\n  } catch (error) { /* empty */ }\n  if (has(O, P)) return createPropertyDescriptor(!propertyIsEnumerableModule.f.call(O, P), O[P]);\n};\n","var fails = require('../internals/fails');\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !fails(function () {\n  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] != 7;\n});\n","module.exports = function (exec) {\n  try {\n    return !!exec();\n  } catch (error) {\n    return true;\n  }\n};\n","'use strict';\nvar nativePropertyIsEnumerable = {}.propertyIsEnumerable;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\n\n// Nashorn ~ JDK8 bug\nvar NASHORN_BUG = getOwnPropertyDescriptor && !nativePropertyIsEnumerable.call({ 1: 2 }, 1);\n\n// `Object.prototype.propertyIsEnumerable` method implementation\n// https://tc39.github.io/ecma262/#sec-object.prototype.propertyisenumerable\nexports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {\n  var descriptor = getOwnPropertyDescriptor(this, V);\n  return !!descriptor && descriptor.enumerable;\n} : nativePropertyIsEnumerable;\n","module.exports = function (bitmap, value) {\n  return {\n    enumerable: !(bitmap & 1),\n    configurable: !(bitmap & 2),\n    writable: !(bitmap & 4),\n    value: value\n  };\n};\n","// toObject with fallback for non-array-like ES3 strings\nvar IndexedObject = require('../internals/indexed-object');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nmodule.exports = function (it) {\n  return IndexedObject(requireObjectCoercible(it));\n};\n","var fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\n\nvar split = ''.split;\n\n// fallback for non-array-like ES3 and non-enumerable old V8 strings\nmodule.exports = fails(function () {\n  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346\n  // eslint-disable-next-line no-prototype-builtins\n  return !Object('z').propertyIsEnumerable(0);\n}) ? function (it) {\n  return classof(it) == 'String' ? split.call(it, '') : Object(it);\n} : Object;\n","var toString = {}.toString;\n\nmodule.exports = function (it) {\n  return toString.call(it).slice(8, -1);\n};\n","// `RequireObjectCoercible` abstract operation\n// https://tc39.github.io/ecma262/#sec-requireobjectcoercible\nmodule.exports = function (it) {\n  if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n  return it;\n};\n","var isObject = require('../internals/is-object');\n\n// `ToPrimitive` abstract operation\n// https://tc39.github.io/ecma262/#sec-toprimitive\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nmodule.exports = function (input, PREFERRED_STRING) {\n  if (!isObject(input)) return input;\n  var fn, val;\n  if (PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (typeof (fn = input.valueOf) == 'function' && !isObject(val = fn.call(input))) return val;\n  if (!PREFERRED_STRING && typeof (fn = input.toString) == 'function' && !isObject(val = fn.call(input))) return val;\n  throw TypeError(\"Can't convert object to primitive value\");\n};\n","module.exports = function (it) {\n  return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n","var hasOwnProperty = {}.hasOwnProperty;\n\nmodule.exports = function (it, key) {\n  return hasOwnProperty.call(it, key);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar createElement = require('../internals/document-create-element');\n\n// Thank's IE8 for his funny defineProperty\nmodule.exports = !DESCRIPTORS && !fails(function () {\n  return Object.defineProperty(createElement('div'), 'a', {\n    get: function () { return 7; }\n  }).a != 7;\n});\n","var global = require('../internals/global');\nvar isObject = require('../internals/is-object');\n\nvar document = global.document;\n// typeof document.createElement is 'object' in old IE\nvar EXISTS = isObject(document) && isObject(document.createElement);\n\nmodule.exports = function (it) {\n  return EXISTS ? document.createElement(it) : {};\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = DESCRIPTORS ? function (object, key, value) {\n  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));\n} : function (object, key, value) {\n  object[key] = value;\n  return object;\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar IE8_DOM_DEFINE = require('../internals/ie8-dom-define');\nvar anObject = require('../internals/an-object');\nvar toPrimitive = require('../internals/to-primitive');\n\nvar nativeDefineProperty = Object.defineProperty;\n\n// `Object.defineProperty` method\n// https://tc39.github.io/ecma262/#sec-object.defineproperty\nexports.f = DESCRIPTORS ? nativeDefineProperty : function defineProperty(O, P, Attributes) {\n  anObject(O);\n  P = toPrimitive(P, true);\n  anObject(Attributes);\n  if (IE8_DOM_DEFINE) try {\n    return nativeDefineProperty(O, P, Attributes);\n  } catch (error) { /* empty */ }\n  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported');\n  if ('value' in Attributes) O[P] = Attributes.value;\n  return O;\n};\n","var isObject = require('../internals/is-object');\n\nmodule.exports = function (it) {\n  if (!isObject(it)) {\n    throw TypeError(String(it) + ' is not an object');\n  } return it;\n};\n","var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar has = require('../internals/has');\nvar setGlobal = require('../internals/set-global');\nvar inspectSource = require('../internals/inspect-source');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar getInternalState = InternalStateModule.get;\nvar enforceInternalState = InternalStateModule.enforce;\nvar TEMPLATE = String(String).split('String');\n\n(module.exports = function (O, key, value, options) {\n  var unsafe = options ? !!options.unsafe : false;\n  var simple = options ? !!options.enumerable : false;\n  var noTargetGet = options ? !!options.noTargetGet : false;\n  if (typeof value == 'function') {\n    if (typeof key == 'string' && !has(value, 'name')) createNonEnumerableProperty(value, 'name', key);\n    enforceInternalState(value).source = TEMPLATE.join(typeof key == 'string' ? key : '');\n  }\n  if (O === global) {\n    if (simple) O[key] = value;\n    else setGlobal(key, value);\n    return;\n  } else if (!unsafe) {\n    delete O[key];\n  } else if (!noTargetGet && O[key]) {\n    simple = true;\n  }\n  if (simple) O[key] = value;\n  else createNonEnumerableProperty(O, key, value);\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, 'toString', function toString() {\n  return typeof this == 'function' && getInternalState(this).source || inspectSource(this);\n});\n","var global = require('../internals/global');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\n\nmodule.exports = function (key, value) {\n  try {\n    createNonEnumerableProperty(global, key, value);\n  } catch (error) {\n    global[key] = value;\n  } return value;\n};\n","var store = require('../internals/shared-store');\n\nvar functionToString = Function.toString;\n\n// this helper broken in `3.4.1-3.4.4`, so we can't use `shared` helper\nif (typeof store.inspectSource != 'function') {\n  store.inspectSource = function (it) {\n    return functionToString.call(it);\n  };\n}\n\nmodule.exports = store.inspectSource;\n","var global = require('../internals/global');\nvar setGlobal = require('../internals/set-global');\n\nvar SHARED = '__core-js_shared__';\nvar store = global[SHARED] || setGlobal(SHARED, {});\n\nmodule.exports = store;\n","var NATIVE_WEAK_MAP = require('../internals/native-weak-map');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar objectHas = require('../internals/has');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\n\nvar WeakMap = global.WeakMap;\nvar set, get, has;\n\nvar enforce = function (it) {\n  return has(it) ? get(it) : set(it, {});\n};\n\nvar getterFor = function (TYPE) {\n  return function (it) {\n    var state;\n    if (!isObject(it) || (state = get(it)).type !== TYPE) {\n      throw TypeError('Incompatible receiver, ' + TYPE + ' required');\n    } return state;\n  };\n};\n\nif (NATIVE_WEAK_MAP) {\n  var store = new WeakMap();\n  var wmget = store.get;\n  var wmhas = store.has;\n  var wmset = store.set;\n  set = function (it, metadata) {\n    wmset.call(store, it, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return wmget.call(store, it) || {};\n  };\n  has = function (it) {\n    return wmhas.call(store, it);\n  };\n} else {\n  var STATE = sharedKey('state');\n  hiddenKeys[STATE] = true;\n  set = function (it, metadata) {\n    createNonEnumerableProperty(it, STATE, metadata);\n    return metadata;\n  };\n  get = function (it) {\n    return objectHas(it, STATE) ? it[STATE] : {};\n  };\n  has = function (it) {\n    return objectHas(it, STATE);\n  };\n}\n\nmodule.exports = {\n  set: set,\n  get: get,\n  has: has,\n  enforce: enforce,\n  getterFor: getterFor\n};\n","var global = require('../internals/global');\nvar inspectSource = require('../internals/inspect-source');\n\nvar WeakMap = global.WeakMap;\n\nmodule.exports = typeof WeakMap === 'function' && /native code/.test(inspectSource(WeakMap));\n","var shared = require('../internals/shared');\nvar uid = require('../internals/uid');\n\nvar keys = shared('keys');\n\nmodule.exports = function (key) {\n  return keys[key] || (keys[key] = uid(key));\n};\n","var IS_PURE = require('../internals/is-pure');\nvar store = require('../internals/shared-store');\n\n(module.exports = function (key, value) {\n  return store[key] || (store[key] = value !== undefined ? value : {});\n})('versions', []).push({\n  version: '3.6.5',\n  mode: IS_PURE ? 'pure' : 'global',\n  copyright: '© 2020 Denis Pushkarev (zloirock.ru)'\n});\n","module.exports = false;\n","var id = 0;\nvar postfix = Math.random();\n\nmodule.exports = function (key) {\n  return 'Symbol(' + String(key === undefined ? '' : key) + ')_' + (++id + postfix).toString(36);\n};\n","module.exports = {};\n","var has = require('../internals/has');\nvar ownKeys = require('../internals/own-keys');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\n\nmodule.exports = function (target, source) {\n  var keys = ownKeys(source);\n  var defineProperty = definePropertyModule.f;\n  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\n  for (var i = 0; i < keys.length; i++) {\n    var key = keys[i];\n    if (!has(target, key)) defineProperty(target, key, getOwnPropertyDescriptor(source, key));\n  }\n};\n","var getBuiltIn = require('../internals/get-built-in');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar anObject = require('../internals/an-object');\n\n// all object keys, includes non-enumerable and symbols\nmodule.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {\n  var keys = getOwnPropertyNamesModule.f(anObject(it));\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  return getOwnPropertySymbols ? keys.concat(getOwnPropertySymbols(it)) : keys;\n};\n","var path = require('../internals/path');\nvar global = require('../internals/global');\n\nvar aFunction = function (variable) {\n  return typeof variable == 'function' ? variable : undefined;\n};\n\nmodule.exports = function (namespace, method) {\n  return arguments.length < 2 ? aFunction(path[namespace]) || aFunction(global[namespace])\n    : path[namespace] && path[namespace][method] || global[namespace] && global[namespace][method];\n};\n","var global = require('../internals/global');\n\nmodule.exports = global;\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\nvar hiddenKeys = enumBugKeys.concat('length', 'prototype');\n\n// `Object.getOwnPropertyNames` method\n// https://tc39.github.io/ecma262/#sec-object.getownpropertynames\nexports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {\n  return internalObjectKeys(O, hiddenKeys);\n};\n","var has = require('../internals/has');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar indexOf = require('../internals/array-includes').indexOf;\nvar hiddenKeys = require('../internals/hidden-keys');\n\nmodule.exports = function (object, names) {\n  var O = toIndexedObject(object);\n  var i = 0;\n  var result = [];\n  var key;\n  for (key in O) !has(hiddenKeys, key) && has(O, key) && result.push(key);\n  // Don't enum bug & hidden keys\n  while (names.length > i) if (has(O, key = names[i++])) {\n    ~indexOf(result, key) || result.push(key);\n  }\n  return result;\n};\n","var toIndexedObject = require('../internals/to-indexed-object');\nvar toLength = require('../internals/to-length');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\n\n// `Array.prototype.{ indexOf, includes }` methods implementation\nvar createMethod = function (IS_INCLUDES) {\n  return function ($this, el, fromIndex) {\n    var O = toIndexedObject($this);\n    var length = toLength(O.length);\n    var index = toAbsoluteIndex(fromIndex, length);\n    var value;\n    // Array#includes uses SameValueZero equality algorithm\n    // eslint-disable-next-line no-self-compare\n    if (IS_INCLUDES && el != el) while (length > index) {\n      value = O[index++];\n      // eslint-disable-next-line no-self-compare\n      if (value != value) return true;\n    // Array#indexOf ignores holes, Array#includes - not\n    } else for (;length > index; index++) {\n      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;\n    } return !IS_INCLUDES && -1;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.includes` method\n  // https://tc39.github.io/ecma262/#sec-array.prototype.includes\n  includes: createMethod(true),\n  // `Array.prototype.indexOf` method\n  // https://tc39.github.io/ecma262/#sec-array.prototype.indexof\n  indexOf: createMethod(false)\n};\n","var toInteger = require('../internals/to-integer');\n\nvar min = Math.min;\n\n// `ToLength` abstract operation\n// https://tc39.github.io/ecma262/#sec-tolength\nmodule.exports = function (argument) {\n  return argument > 0 ? min(toInteger(argument), 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991\n};\n","var ceil = Math.ceil;\nvar floor = Math.floor;\n\n// `ToInteger` abstract operation\n// https://tc39.github.io/ecma262/#sec-tointeger\nmodule.exports = function (argument) {\n  return isNaN(argument = +argument) ? 0 : (argument > 0 ? floor : ceil)(argument);\n};\n","var toInteger = require('../internals/to-integer');\n\nvar max = Math.max;\nvar min = Math.min;\n\n// Helper for a popular repeating case of the spec:\n// Let integer be ? ToInteger(index).\n// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).\nmodule.exports = function (index, length) {\n  var integer = toInteger(index);\n  return integer < 0 ? max(integer + length, 0) : min(integer, length);\n};\n","// IE8- don't enum bug keys\nmodule.exports = [\n  'constructor',\n  'hasOwnProperty',\n  'isPrototypeOf',\n  'propertyIsEnumerable',\n  'toLocaleString',\n  'toString',\n  'valueOf'\n];\n","exports.f = Object.getOwnPropertySymbols;\n","var fails = require('../internals/fails');\n\nvar replacement = /#|\\.prototype\\./;\n\nvar isForced = function (feature, detection) {\n  var value = data[normalize(feature)];\n  return value == POLYFILL ? true\n    : value == NATIVE ? false\n    : typeof detection == 'function' ? fails(detection)\n    : !!detection;\n};\n\nvar normalize = isForced.normalize = function (string) {\n  return String(string).replace(replacement, '.').toLowerCase();\n};\n\nvar data = isForced.data = {};\nvar NATIVE = isForced.NATIVE = 'N';\nvar POLYFILL = isForced.POLYFILL = 'P';\n\nmodule.exports = isForced;\n","require('../../modules/es.string.starts-with');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('String', 'startsWith');\n","'use strict';\nvar $ = require('../internals/export');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar toLength = require('../internals/to-length');\nvar notARegExp = require('../internals/not-a-regexp');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');\nvar IS_PURE = require('../internals/is-pure');\n\nvar nativeStartsWith = ''.startsWith;\nvar min = Math.min;\n\nvar CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('startsWith');\n// https://github.com/zloirock/core-js/pull/702\nvar MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () {\n  var descriptor = getOwnPropertyDescriptor(String.prototype, 'startsWith');\n  return descriptor && !descriptor.writable;\n}();\n\n// `String.prototype.startsWith` method\n// https://tc39.github.io/ecma262/#sec-string.prototype.startswith\n$({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {\n  startsWith: function startsWith(searchString /* , position = 0 */) {\n    var that = String(requireObjectCoercible(this));\n    notARegExp(searchString);\n    var index = toLength(min(arguments.length > 1 ? arguments[1] : undefined, that.length));\n    var search = String(searchString);\n    return nativeStartsWith\n      ? nativeStartsWith.call(that, search, index)\n      : that.slice(index, index + search.length) === search;\n  }\n});\n","var isRegExp = require('../internals/is-regexp');\n\nmodule.exports = function (it) {\n  if (isRegExp(it)) {\n    throw TypeError(\"The method doesn't accept regular expressions\");\n  } return it;\n};\n","var isObject = require('../internals/is-object');\nvar classof = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\n\n// `IsRegExp` abstract operation\n// https://tc39.github.io/ecma262/#sec-isregexp\nmodule.exports = function (it) {\n  var isRegExp;\n  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : classof(it) == 'RegExp');\n};\n","var global = require('../internals/global');\nvar shared = require('../internals/shared');\nvar has = require('../internals/has');\nvar uid = require('../internals/uid');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\n\nvar WellKnownSymbolsStore = shared('wks');\nvar Symbol = global.Symbol;\nvar createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol : Symbol && Symbol.withoutSetter || uid;\n\nmodule.exports = function (name) {\n  if (!has(WellKnownSymbolsStore, name)) {\n    if (NATIVE_SYMBOL && has(Symbol, name)) WellKnownSymbolsStore[name] = Symbol[name];\n    else WellKnownSymbolsStore[name] = createWellKnownSymbol('Symbol.' + name);\n  } return WellKnownSymbolsStore[name];\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !!Object.getOwnPropertySymbols && !fails(function () {\n  // Chrome 38 Symbol has incorrect toString conversion\n  // eslint-disable-next-line no-undef\n  return !String(Symbol());\n});\n","var NATIVE_SYMBOL = require('../internals/native-symbol');\n\nmodule.exports = NATIVE_SYMBOL\n  // eslint-disable-next-line no-undef\n  && !Symbol.sham\n  // eslint-disable-next-line no-undef\n  && typeof Symbol.iterator == 'symbol';\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar MATCH = wellKnownSymbol('match');\n\nmodule.exports = function (METHOD_NAME) {\n  var regexp = /./;\n  try {\n    '/./'[METHOD_NAME](regexp);\n  } catch (e) {\n    try {\n      regexp[MATCH] = false;\n      return '/./'[METHOD_NAME](regexp);\n    } catch (f) { /* empty */ }\n  } return false;\n};\n","var global = require('../internals/global');\nvar bind = require('../internals/function-bind-context');\n\nvar call = Function.call;\n\nmodule.exports = function (CONSTRUCTOR, METHOD, length) {\n  return bind(call, global[CONSTRUCTOR].prototype[METHOD], length);\n};\n","var aFunction = require('../internals/a-function');\n\n// optional / simple context binding\nmodule.exports = function (fn, that, length) {\n  aFunction(fn);\n  if (that === undefined) return fn;\n  switch (length) {\n    case 0: return function () {\n      return fn.call(that);\n    };\n    case 1: return function (a) {\n      return fn.call(that, a);\n    };\n    case 2: return function (a, b) {\n      return fn.call(that, a, b);\n    };\n    case 3: return function (a, b, c) {\n      return fn.call(that, a, b, c);\n    };\n  }\n  return function (/* ...args */) {\n    return fn.apply(that, arguments);\n  };\n};\n","module.exports = function (it) {\n  if (typeof it != 'function') {\n    throw TypeError(String(it) + ' is not a function');\n  } return it;\n};\n","require('../../modules/es.string.ends-with');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('String', 'endsWith');\n","'use strict';\nvar $ = require('../internals/export');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar toLength = require('../internals/to-length');\nvar notARegExp = require('../internals/not-a-regexp');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');\nvar IS_PURE = require('../internals/is-pure');\n\nvar nativeEndsWith = ''.endsWith;\nvar min = Math.min;\n\nvar CORRECT_IS_REGEXP_LOGIC = correctIsRegExpLogic('endsWith');\n// https://github.com/zloirock/core-js/pull/702\nvar MDN_POLYFILL_BUG = !IS_PURE && !CORRECT_IS_REGEXP_LOGIC && !!function () {\n  var descriptor = getOwnPropertyDescriptor(String.prototype, 'endsWith');\n  return descriptor && !descriptor.writable;\n}();\n\n// `String.prototype.endsWith` method\n// https://tc39.github.io/ecma262/#sec-string.prototype.endswith\n$({ target: 'String', proto: true, forced: !MDN_POLYFILL_BUG && !CORRECT_IS_REGEXP_LOGIC }, {\n  endsWith: function endsWith(searchString /* , endPosition = @length */) {\n    var that = String(requireObjectCoercible(this));\n    notARegExp(searchString);\n    var endPosition = arguments.length > 1 ? arguments[1] : undefined;\n    var len = toLength(that.length);\n    var end = endPosition === undefined ? len : min(toLength(endPosition), len);\n    var search = String(searchString);\n    return nativeEndsWith\n      ? nativeEndsWith.call(that, search, end)\n      : that.slice(end - search.length, end) === search;\n  }\n});\n","require('../../modules/es.string.includes');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('String', 'includes');\n","'use strict';\nvar $ = require('../internals/export');\nvar notARegExp = require('../internals/not-a-regexp');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\nvar correctIsRegExpLogic = require('../internals/correct-is-regexp-logic');\n\n// `String.prototype.includes` method\n// https://tc39.github.io/ecma262/#sec-string.prototype.includes\n$({ target: 'String', proto: true, forced: !correctIsRegExpLogic('includes') }, {\n  includes: function includes(searchString /* , position = 0 */) {\n    return !!~String(requireObjectCoercible(this))\n      .indexOf(notARegExp(searchString), arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n","require('../../modules/es.array.includes');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('Array', 'includes');\n","'use strict';\nvar $ = require('../internals/export');\nvar $includes = require('../internals/array-includes').includes;\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar arrayMethodUsesToLength = require('../internals/array-method-uses-to-length');\n\nvar USES_TO_LENGTH = arrayMethodUsesToLength('indexOf', { ACCESSORS: true, 1: 0 });\n\n// `Array.prototype.includes` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.includes\n$({ target: 'Array', proto: true, forced: !USES_TO_LENGTH }, {\n  includes: function includes(el /* , fromIndex = 0 */) {\n    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('includes');\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar create = require('../internals/object-create');\nvar definePropertyModule = require('../internals/object-define-property');\n\nvar UNSCOPABLES = wellKnownSymbol('unscopables');\nvar ArrayPrototype = Array.prototype;\n\n// Array.prototype[@@unscopables]\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables\nif (ArrayPrototype[UNSCOPABLES] == undefined) {\n  definePropertyModule.f(ArrayPrototype, UNSCOPABLES, {\n    configurable: true,\n    value: create(null)\n  });\n}\n\n// add a key to Array.prototype[@@unscopables]\nmodule.exports = function (key) {\n  ArrayPrototype[UNSCOPABLES][key] = true;\n};\n","var anObject = require('../internals/an-object');\nvar defineProperties = require('../internals/object-define-properties');\nvar enumBugKeys = require('../internals/enum-bug-keys');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar html = require('../internals/html');\nvar documentCreateElement = require('../internals/document-create-element');\nvar sharedKey = require('../internals/shared-key');\n\nvar GT = '>';\nvar LT = '<';\nvar PROTOTYPE = 'prototype';\nvar SCRIPT = 'script';\nvar IE_PROTO = sharedKey('IE_PROTO');\n\nvar EmptyConstructor = function () { /* empty */ };\n\nvar scriptTag = function (content) {\n  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;\n};\n\n// Create object with fake `null` prototype: use ActiveX Object with cleared prototype\nvar NullProtoObjectViaActiveX = function (activeXDocument) {\n  activeXDocument.write(scriptTag(''));\n  activeXDocument.close();\n  var temp = activeXDocument.parentWindow.Object;\n  activeXDocument = null; // avoid memory leak\n  return temp;\n};\n\n// Create object with fake `null` prototype: use iframe Object with cleared prototype\nvar NullProtoObjectViaIFrame = function () {\n  // Thrash, waste and sodomy: IE GC bug\n  var iframe = documentCreateElement('iframe');\n  var JS = 'java' + SCRIPT + ':';\n  var iframeDocument;\n  iframe.style.display = 'none';\n  html.appendChild(iframe);\n  // https://github.com/zloirock/core-js/issues/475\n  iframe.src = String(JS);\n  iframeDocument = iframe.contentWindow.document;\n  iframeDocument.open();\n  iframeDocument.write(scriptTag('document.F=Object'));\n  iframeDocument.close();\n  return iframeDocument.F;\n};\n\n// Check for document.domain and active x support\n// No need to use active x approach when document.domain is not set\n// see https://github.com/es-shims/es5-shim/issues/150\n// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346\n// avoid IE GC bug\nvar activeXDocument;\nvar NullProtoObject = function () {\n  try {\n    /* global ActiveXObject */\n    activeXDocument = document.domain && new ActiveXObject('htmlfile');\n  } catch (error) { /* ignore */ }\n  NullProtoObject = activeXDocument ? NullProtoObjectViaActiveX(activeXDocument) : NullProtoObjectViaIFrame();\n  var length = enumBugKeys.length;\n  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];\n  return NullProtoObject();\n};\n\nhiddenKeys[IE_PROTO] = true;\n\n// `Object.create` method\n// https://tc39.github.io/ecma262/#sec-object.create\nmodule.exports = Object.create || function create(O, Properties) {\n  var result;\n  if (O !== null) {\n    EmptyConstructor[PROTOTYPE] = anObject(O);\n    result = new EmptyConstructor();\n    EmptyConstructor[PROTOTYPE] = null;\n    // add \"__proto__\" for Object.getPrototypeOf polyfill\n    result[IE_PROTO] = O;\n  } else result = NullProtoObject();\n  return Properties === undefined ? result : defineProperties(result, Properties);\n};\n","var DESCRIPTORS = require('../internals/descriptors');\nvar definePropertyModule = require('../internals/object-define-property');\nvar anObject = require('../internals/an-object');\nvar objectKeys = require('../internals/object-keys');\n\n// `Object.defineProperties` method\n// https://tc39.github.io/ecma262/#sec-object.defineproperties\nmodule.exports = DESCRIPTORS ? Object.defineProperties : function defineProperties(O, Properties) {\n  anObject(O);\n  var keys = objectKeys(Properties);\n  var length = keys.length;\n  var index = 0;\n  var key;\n  while (length > index) definePropertyModule.f(O, key = keys[index++], Properties[key]);\n  return O;\n};\n","var internalObjectKeys = require('../internals/object-keys-internal');\nvar enumBugKeys = require('../internals/enum-bug-keys');\n\n// `Object.keys` method\n// https://tc39.github.io/ecma262/#sec-object.keys\nmodule.exports = Object.keys || function keys(O) {\n  return internalObjectKeys(O, enumBugKeys);\n};\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('document', 'documentElement');\n","var DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar has = require('../internals/has');\n\nvar defineProperty = Object.defineProperty;\nvar cache = {};\n\nvar thrower = function (it) { throw it; };\n\nmodule.exports = function (METHOD_NAME, options) {\n  if (has(cache, METHOD_NAME)) return cache[METHOD_NAME];\n  if (!options) options = {};\n  var method = [][METHOD_NAME];\n  var ACCESSORS = has(options, 'ACCESSORS') ? options.ACCESSORS : false;\n  var argument0 = has(options, 0) ? options[0] : thrower;\n  var argument1 = has(options, 1) ? options[1] : undefined;\n\n  return cache[METHOD_NAME] = !!method && !fails(function () {\n    if (ACCESSORS && !DESCRIPTORS) return true;\n    var O = { length: -1 };\n\n    if (ACCESSORS) defineProperty(O, 1, { enumerable: true, get: thrower });\n    else O[1] = 1;\n\n    method.call(O, argument0, argument1);\n  });\n};\n","require('../../modules/es.string.iterator');\nrequire('../../modules/es.array.from');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Array.from;\n","'use strict';\nvar charAt = require('../internals/string-multibyte').charAt;\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar STRING_ITERATOR = 'String Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(STRING_ITERATOR);\n\n// `String.prototype[@@iterator]` method\n// https://tc39.github.io/ecma262/#sec-string.prototype-@@iterator\ndefineIterator(String, 'String', function (iterated) {\n  setInternalState(this, {\n    type: STRING_ITERATOR,\n    string: String(iterated),\n    index: 0\n  });\n// `%StringIteratorPrototype%.next` method\n// https://tc39.github.io/ecma262/#sec-%stringiteratorprototype%.next\n}, function next() {\n  var state = getInternalState(this);\n  var string = state.string;\n  var index = state.index;\n  var point;\n  if (index >= string.length) return { value: undefined, done: true };\n  point = charAt(string, index);\n  state.index += point.length;\n  return { value: point, done: false };\n});\n","var toInteger = require('../internals/to-integer');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\n// `String.prototype.{ codePointAt, at }` methods implementation\nvar createMethod = function (CONVERT_TO_STRING) {\n  return function ($this, pos) {\n    var S = String(requireObjectCoercible($this));\n    var position = toInteger(pos);\n    var size = S.length;\n    var first, second;\n    if (position < 0 || position >= size) return CONVERT_TO_STRING ? '' : undefined;\n    first = S.charCodeAt(position);\n    return first < 0xD800 || first > 0xDBFF || position + 1 === size\n      || (second = S.charCodeAt(position + 1)) < 0xDC00 || second > 0xDFFF\n        ? CONVERT_TO_STRING ? S.charAt(position) : first\n        : CONVERT_TO_STRING ? S.slice(position, position + 2) : (first - 0xD800 << 10) + (second - 0xDC00) + 0x10000;\n  };\n};\n\nmodule.exports = {\n  // `String.prototype.codePointAt` method\n  // https://tc39.github.io/ecma262/#sec-string.prototype.codepointat\n  codeAt: createMethod(false),\n  // `String.prototype.at` method\n  // https://github.com/mathiasbynens/String.prototype.at\n  charAt: createMethod(true)\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar createIteratorConstructor = require('../internals/create-iterator-constructor');\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\nvar Iterators = require('../internals/iterators');\nvar IteratorsCore = require('../internals/iterators-core');\n\nvar IteratorPrototype = IteratorsCore.IteratorPrototype;\nvar BUGGY_SAFARI_ITERATORS = IteratorsCore.BUGGY_SAFARI_ITERATORS;\nvar ITERATOR = wellKnownSymbol('iterator');\nvar KEYS = 'keys';\nvar VALUES = 'values';\nvar ENTRIES = 'entries';\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (Iterable, NAME, IteratorConstructor, next, DEFAULT, IS_SET, FORCED) {\n  createIteratorConstructor(IteratorConstructor, NAME, next);\n\n  var getIterationMethod = function (KIND) {\n    if (KIND === DEFAULT && defaultIterator) return defaultIterator;\n    if (!BUGGY_SAFARI_ITERATORS && KIND in IterablePrototype) return IterablePrototype[KIND];\n    switch (KIND) {\n      case KEYS: return function keys() { return new IteratorConstructor(this, KIND); };\n      case VALUES: return function values() { return new IteratorConstructor(this, KIND); };\n      case ENTRIES: return function entries() { return new IteratorConstructor(this, KIND); };\n    } return function () { return new IteratorConstructor(this); };\n  };\n\n  var TO_STRING_TAG = NAME + ' Iterator';\n  var INCORRECT_VALUES_NAME = false;\n  var IterablePrototype = Iterable.prototype;\n  var nativeIterator = IterablePrototype[ITERATOR]\n    || IterablePrototype['@@iterator']\n    || DEFAULT && IterablePrototype[DEFAULT];\n  var defaultIterator = !BUGGY_SAFARI_ITERATORS && nativeIterator || getIterationMethod(DEFAULT);\n  var anyNativeIterator = NAME == 'Array' ? IterablePrototype.entries || nativeIterator : nativeIterator;\n  var CurrentIteratorPrototype, methods, KEY;\n\n  // fix native\n  if (anyNativeIterator) {\n    CurrentIteratorPrototype = getPrototypeOf(anyNativeIterator.call(new Iterable()));\n    if (IteratorPrototype !== Object.prototype && CurrentIteratorPrototype.next) {\n      if (!IS_PURE && getPrototypeOf(CurrentIteratorPrototype) !== IteratorPrototype) {\n        if (setPrototypeOf) {\n          setPrototypeOf(CurrentIteratorPrototype, IteratorPrototype);\n        } else if (typeof CurrentIteratorPrototype[ITERATOR] != 'function') {\n          createNonEnumerableProperty(CurrentIteratorPrototype, ITERATOR, returnThis);\n        }\n      }\n      // Set @@toStringTag to native iterators\n      setToStringTag(CurrentIteratorPrototype, TO_STRING_TAG, true, true);\n      if (IS_PURE) Iterators[TO_STRING_TAG] = returnThis;\n    }\n  }\n\n  // fix Array#{values, @@iterator}.name in V8 / FF\n  if (DEFAULT == VALUES && nativeIterator && nativeIterator.name !== VALUES) {\n    INCORRECT_VALUES_NAME = true;\n    defaultIterator = function values() { return nativeIterator.call(this); };\n  }\n\n  // define iterator\n  if ((!IS_PURE || FORCED) && IterablePrototype[ITERATOR] !== defaultIterator) {\n    createNonEnumerableProperty(IterablePrototype, ITERATOR, defaultIterator);\n  }\n  Iterators[NAME] = defaultIterator;\n\n  // export additional methods\n  if (DEFAULT) {\n    methods = {\n      values: getIterationMethod(VALUES),\n      keys: IS_SET ? defaultIterator : getIterationMethod(KEYS),\n      entries: getIterationMethod(ENTRIES)\n    };\n    if (FORCED) for (KEY in methods) {\n      if (BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME || !(KEY in IterablePrototype)) {\n        redefine(IterablePrototype, KEY, methods[KEY]);\n      }\n    } else $({ target: NAME, proto: true, forced: BUGGY_SAFARI_ITERATORS || INCORRECT_VALUES_NAME }, methods);\n  }\n\n  return methods;\n};\n","'use strict';\nvar IteratorPrototype = require('../internals/iterators-core').IteratorPrototype;\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar Iterators = require('../internals/iterators');\n\nvar returnThis = function () { return this; };\n\nmodule.exports = function (IteratorConstructor, NAME, next) {\n  var TO_STRING_TAG = NAME + ' Iterator';\n  IteratorConstructor.prototype = create(IteratorPrototype, { next: createPropertyDescriptor(1, next) });\n  setToStringTag(IteratorConstructor, TO_STRING_TAG, false, true);\n  Iterators[TO_STRING_TAG] = returnThis;\n  return IteratorConstructor;\n};\n","'use strict';\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar has = require('../internals/has');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar BUGGY_SAFARI_ITERATORS = false;\n\nvar returnThis = function () { return this; };\n\n// `%IteratorPrototype%` object\n// https://tc39.github.io/ecma262/#sec-%iteratorprototype%-object\nvar IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;\n\nif ([].keys) {\n  arrayIterator = [].keys();\n  // Safari 8 has buggy iterators w/o `next`\n  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;\n  else {\n    PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));\n    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;\n  }\n}\n\nif (IteratorPrototype == undefined) IteratorPrototype = {};\n\n// 25.1.2.1.1 %IteratorPrototype%[@@iterator]()\nif (!IS_PURE && !has(IteratorPrototype, ITERATOR)) {\n  createNonEnumerableProperty(IteratorPrototype, ITERATOR, returnThis);\n}\n\nmodule.exports = {\n  IteratorPrototype: IteratorPrototype,\n  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS\n};\n","var has = require('../internals/has');\nvar toObject = require('../internals/to-object');\nvar sharedKey = require('../internals/shared-key');\nvar CORRECT_PROTOTYPE_GETTER = require('../internals/correct-prototype-getter');\n\nvar IE_PROTO = sharedKey('IE_PROTO');\nvar ObjectPrototype = Object.prototype;\n\n// `Object.getPrototypeOf` method\n// https://tc39.github.io/ecma262/#sec-object.getprototypeof\nmodule.exports = CORRECT_PROTOTYPE_GETTER ? Object.getPrototypeOf : function (O) {\n  O = toObject(O);\n  if (has(O, IE_PROTO)) return O[IE_PROTO];\n  if (typeof O.constructor == 'function' && O instanceof O.constructor) {\n    return O.constructor.prototype;\n  } return O instanceof Object ? ObjectPrototype : null;\n};\n","var requireObjectCoercible = require('../internals/require-object-coercible');\n\n// `ToObject` abstract operation\n// https://tc39.github.io/ecma262/#sec-toobject\nmodule.exports = function (argument) {\n  return Object(requireObjectCoercible(argument));\n};\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  function F() { /* empty */ }\n  F.prototype.constructor = null;\n  return Object.getPrototypeOf(new F()) !== F.prototype;\n});\n","var defineProperty = require('../internals/object-define-property').f;\nvar has = require('../internals/has');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n\nmodule.exports = function (it, TAG, STATIC) {\n  if (it && !has(it = STATIC ? it : it.prototype, TO_STRING_TAG)) {\n    defineProperty(it, TO_STRING_TAG, { configurable: true, value: TAG });\n  }\n};\n","module.exports = {};\n","var anObject = require('../internals/an-object');\nvar aPossiblePrototype = require('../internals/a-possible-prototype');\n\n// `Object.setPrototypeOf` method\n// https://tc39.github.io/ecma262/#sec-object.setprototypeof\n// Works with __proto__ only. Old v8 can't work with null proto objects.\n/* eslint-disable no-proto */\nmodule.exports = Object.setPrototypeOf || ('__proto__' in {} ? function () {\n  var CORRECT_SETTER = false;\n  var test = {};\n  var setter;\n  try {\n    setter = Object.getOwnPropertyDescriptor(Object.prototype, '__proto__').set;\n    setter.call(test, []);\n    CORRECT_SETTER = test instanceof Array;\n  } catch (error) { /* empty */ }\n  return function setPrototypeOf(O, proto) {\n    anObject(O);\n    aPossiblePrototype(proto);\n    if (CORRECT_SETTER) setter.call(O, proto);\n    else O.__proto__ = proto;\n    return O;\n  };\n}() : undefined);\n","var isObject = require('../internals/is-object');\n\nmodule.exports = function (it) {\n  if (!isObject(it) && it !== null) {\n    throw TypeError(\"Can't set \" + String(it) + ' as a prototype');\n  } return it;\n};\n","var $ = require('../internals/export');\nvar from = require('../internals/array-from');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\n\nvar INCORRECT_ITERATION = !checkCorrectnessOfIteration(function (iterable) {\n  Array.from(iterable);\n});\n\n// `Array.from` method\n// https://tc39.github.io/ecma262/#sec-array.from\n$({ target: 'Array', stat: true, forced: INCORRECT_ITERATION }, {\n  from: from\n});\n","'use strict';\nvar bind = require('../internals/function-bind-context');\nvar toObject = require('../internals/to-object');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar toLength = require('../internals/to-length');\nvar createProperty = require('../internals/create-property');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\n// `Array.from` method implementation\n// https://tc39.github.io/ecma262/#sec-array.from\nmodule.exports = function from(arrayLike /* , mapfn = undefined, thisArg = undefined */) {\n  var O = toObject(arrayLike);\n  var C = typeof this == 'function' ? this : Array;\n  var argumentsLength = arguments.length;\n  var mapfn = argumentsLength > 1 ? arguments[1] : undefined;\n  var mapping = mapfn !== undefined;\n  var iteratorMethod = getIteratorMethod(O);\n  var index = 0;\n  var length, result, step, iterator, next, value;\n  if (mapping) mapfn = bind(mapfn, argumentsLength > 2 ? arguments[2] : undefined, 2);\n  // if the target is not iterable or it's an array with the default iterator - use a simple case\n  if (iteratorMethod != undefined && !(C == Array && isArrayIteratorMethod(iteratorMethod))) {\n    iterator = iteratorMethod.call(O);\n    next = iterator.next;\n    result = new C();\n    for (;!(step = next.call(iterator)).done; index++) {\n      value = mapping ? callWithSafeIterationClosing(iterator, mapfn, [step.value, index], true) : step.value;\n      createProperty(result, index, value);\n    }\n  } else {\n    length = toLength(O.length);\n    result = new C(length);\n    for (;length > index; index++) {\n      value = mapping ? mapfn(O[index], index) : O[index];\n      createProperty(result, index, value);\n    }\n  }\n  result.length = index;\n  return result;\n};\n","var anObject = require('../internals/an-object');\n\n// call something on iterator step with safe closing on error\nmodule.exports = function (iterator, fn, value, ENTRIES) {\n  try {\n    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);\n  // 7.4.6 IteratorClose(iterator, completion)\n  } catch (error) {\n    var returnMethod = iterator['return'];\n    if (returnMethod !== undefined) anObject(returnMethod.call(iterator));\n    throw error;\n  }\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\nvar Iterators = require('../internals/iterators');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar ArrayPrototype = Array.prototype;\n\n// check on default Array iterator\nmodule.exports = function (it) {\n  return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);\n};\n","'use strict';\nvar toPrimitive = require('../internals/to-primitive');\nvar definePropertyModule = require('../internals/object-define-property');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\n\nmodule.exports = function (object, key, value) {\n  var propertyKey = toPrimitive(key);\n  if (propertyKey in object) definePropertyModule.f(object, propertyKey, createPropertyDescriptor(0, value));\n  else object[propertyKey] = value;\n};\n","var classof = require('../internals/classof');\nvar Iterators = require('../internals/iterators');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = function (it) {\n  if (it != undefined) return it[ITERATOR]\n    || it['@@iterator']\n    || Iterators[classof(it)];\n};\n","var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classofRaw = require('../internals/classof-raw');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\n// ES3 wrong here\nvar CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) == 'Arguments';\n\n// fallback for IE11 Script Access Denied error\nvar tryGet = function (it, key) {\n  try {\n    return it[key];\n  } catch (error) { /* empty */ }\n};\n\n// getting tag from ES6+ `Object.prototype.toString`\nmodule.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {\n  var O, tag, result;\n  return it === undefined ? 'Undefined' : it === null ? 'Null'\n    // @@toStringTag case\n    : typeof (tag = tryGet(O = Object(it), TO_STRING_TAG)) == 'string' ? tag\n    // builtinTag case\n    : CORRECT_ARGUMENTS ? classofRaw(O)\n    // ES3 arguments fallback\n    : (result = classofRaw(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : result;\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar test = {};\n\ntest[TO_STRING_TAG] = 'z';\n\nmodule.exports = String(test) === '[object z]';\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar SAFE_CLOSING = false;\n\ntry {\n  var called = 0;\n  var iteratorWithReturn = {\n    next: function () {\n      return { done: !!called++ };\n    },\n    'return': function () {\n      SAFE_CLOSING = true;\n    }\n  };\n  iteratorWithReturn[ITERATOR] = function () {\n    return this;\n  };\n  // eslint-disable-next-line no-throw-literal\n  Array.from(iteratorWithReturn, function () { throw 2; });\n} catch (error) { /* empty */ }\n\nmodule.exports = function (exec, SKIP_CLOSING) {\n  if (!SKIP_CLOSING && !SAFE_CLOSING) return false;\n  var ITERATION_SUPPORT = false;\n  try {\n    var object = {};\n    object[ITERATOR] = function () {\n      return {\n        next: function () {\n          return { done: ITERATION_SUPPORT = true };\n        }\n      };\n    };\n    exec(object);\n  } catch (error) { /* empty */ }\n  return ITERATION_SUPPORT;\n};\n","require('../../modules/es.object.assign');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.assign;\n","var $ = require('../internals/export');\nvar assign = require('../internals/object-assign');\n\n// `Object.assign` method\n// https://tc39.github.io/ecma262/#sec-object.assign\n$({ target: 'Object', stat: true, forced: Object.assign !== assign }, {\n  assign: assign\n});\n","'use strict';\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fails = require('../internals/fails');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar toObject = require('../internals/to-object');\nvar IndexedObject = require('../internals/indexed-object');\n\nvar nativeAssign = Object.assign;\nvar defineProperty = Object.defineProperty;\n\n// `Object.assign` method\n// https://tc39.github.io/ecma262/#sec-object.assign\nmodule.exports = !nativeAssign || fails(function () {\n  // should have correct order of operations (Edge bug)\n  if (DESCRIPTORS && nativeAssign({ b: 1 }, nativeAssign(defineProperty({}, 'a', {\n    enumerable: true,\n    get: function () {\n      defineProperty(this, 'b', {\n        value: 3,\n        enumerable: false\n      });\n    }\n  }), { b: 2 })).b !== 1) return true;\n  // should work with symbols and should have deterministic property order (V8 bug)\n  var A = {};\n  var B = {};\n  // eslint-disable-next-line no-undef\n  var symbol = Symbol();\n  var alphabet = 'abcdefghijklmnopqrst';\n  A[symbol] = 7;\n  alphabet.split('').forEach(function (chr) { B[chr] = chr; });\n  return nativeAssign({}, A)[symbol] != 7 || objectKeys(nativeAssign({}, B)).join('') != alphabet;\n}) ? function assign(target, source) { // eslint-disable-line no-unused-vars\n  var T = toObject(target);\n  var argumentsLength = arguments.length;\n  var index = 1;\n  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;\n  var propertyIsEnumerable = propertyIsEnumerableModule.f;\n  while (argumentsLength > index) {\n    var S = IndexedObject(arguments[index++]);\n    var keys = getOwnPropertySymbols ? objectKeys(S).concat(getOwnPropertySymbols(S)) : objectKeys(S);\n    var length = keys.length;\n    var j = 0;\n    var key;\n    while (length > j) {\n      key = keys[j++];\n      if (!DESCRIPTORS || propertyIsEnumerable.call(S, key)) T[key] = S[key];\n    }\n  } return T;\n} : nativeAssign;\n","require('../../modules/es.array.iterator');\nrequire('../../modules/es.object.from-entries');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.fromEntries;\n","'use strict';\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar addToUnscopables = require('../internals/add-to-unscopables');\nvar Iterators = require('../internals/iterators');\nvar InternalStateModule = require('../internals/internal-state');\nvar defineIterator = require('../internals/define-iterator');\n\nvar ARRAY_ITERATOR = 'Array Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(ARRAY_ITERATOR);\n\n// `Array.prototype.entries` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.entries\n// `Array.prototype.keys` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.keys\n// `Array.prototype.values` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.values\n// `Array.prototype[@@iterator]` method\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@iterator\n// `CreateArrayIterator` internal method\n// https://tc39.github.io/ecma262/#sec-createarrayiterator\nmodule.exports = defineIterator(Array, 'Array', function (iterated, kind) {\n  setInternalState(this, {\n    type: ARRAY_ITERATOR,\n    target: toIndexedObject(iterated), // target\n    index: 0,                          // next index\n    kind: kind                         // kind\n  });\n// `%ArrayIteratorPrototype%.next` method\n// https://tc39.github.io/ecma262/#sec-%arrayiteratorprototype%.next\n}, function () {\n  var state = getInternalState(this);\n  var target = state.target;\n  var kind = state.kind;\n  var index = state.index++;\n  if (!target || index >= target.length) {\n    state.target = undefined;\n    return { value: undefined, done: true };\n  }\n  if (kind == 'keys') return { value: index, done: false };\n  if (kind == 'values') return { value: target[index], done: false };\n  return { value: [index, target[index]], done: false };\n}, 'values');\n\n// argumentsList[@@iterator] is %ArrayProto_values%\n// https://tc39.github.io/ecma262/#sec-createunmappedargumentsobject\n// https://tc39.github.io/ecma262/#sec-createmappedargumentsobject\nIterators.Arguments = Iterators.Array;\n\n// https://tc39.github.io/ecma262/#sec-array.prototype-@@unscopables\naddToUnscopables('keys');\naddToUnscopables('values');\naddToUnscopables('entries');\n","var $ = require('../internals/export');\nvar iterate = require('../internals/iterate');\nvar createProperty = require('../internals/create-property');\n\n// `Object.fromEntries` method\n// https://github.com/tc39/proposal-object-from-entries\n$({ target: 'Object', stat: true }, {\n  fromEntries: function fromEntries(iterable) {\n    var obj = {};\n    iterate(iterable, function (k, v) {\n      createProperty(obj, k, v);\n    }, undefined, true);\n    return obj;\n  }\n});\n","var anObject = require('../internals/an-object');\nvar isArrayIteratorMethod = require('../internals/is-array-iterator-method');\nvar toLength = require('../internals/to-length');\nvar bind = require('../internals/function-bind-context');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar callWithSafeIterationClosing = require('../internals/call-with-safe-iteration-closing');\n\nvar Result = function (stopped, result) {\n  this.stopped = stopped;\n  this.result = result;\n};\n\nvar iterate = module.exports = function (iterable, fn, that, AS_ENTRIES, IS_ITERATOR) {\n  var boundFunction = bind(fn, that, AS_ENTRIES ? 2 : 1);\n  var iterator, iterFn, index, length, result, next, step;\n\n  if (IS_ITERATOR) {\n    iterator = iterable;\n  } else {\n    iterFn = getIteratorMethod(iterable);\n    if (typeof iterFn != 'function') throw TypeError('Target is not iterable');\n    // optimisation for array iterators\n    if (isArrayIteratorMethod(iterFn)) {\n      for (index = 0, length = toLength(iterable.length); length > index; index++) {\n        result = AS_ENTRIES\n          ? boundFunction(anObject(step = iterable[index])[0], step[1])\n          : boundFunction(iterable[index]);\n        if (result && result instanceof Result) return result;\n      } return new Result(false);\n    }\n    iterator = iterFn.call(iterable);\n  }\n\n  next = iterator.next;\n  while (!(step = next.call(iterator)).done) {\n    result = callWithSafeIterationClosing(iterator, boundFunction, step.value, AS_ENTRIES);\n    if (typeof result == 'object' && result && result instanceof Result) return result;\n  } return new Result(false);\n};\n\niterate.stop = function (result) {\n  return new Result(true, result);\n};\n","require('../../modules/es.math.log2');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Math.log2;\n","var $ = require('../internals/export');\n\nvar log = Math.log;\nvar LN2 = Math.LN2;\n\n// `Math.log2` method\n// https://tc39.github.io/ecma262/#sec-math.log2\n$({ target: 'Math', stat: true }, {\n  log2: function log2(x) {\n    return log(x) / LN2;\n  }\n});\n","require('../../modules/es.number.is-nan');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.isNaN;\n","var $ = require('../internals/export');\n\n// `Number.isNaN` method\n// https://tc39.github.io/ecma262/#sec-number.isnan\n$({ target: 'Number', stat: true }, {\n  isNaN: function isNaN(number) {\n    // eslint-disable-next-line no-self-compare\n    return number != number;\n  }\n});\n","require('../../modules/es.number.is-integer');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Number.isInteger;\n","var $ = require('../internals/export');\nvar isInteger = require('../internals/is-integer');\n\n// `Number.isInteger` method\n// https://tc39.github.io/ecma262/#sec-number.isinteger\n$({ target: 'Number', stat: true }, {\n  isInteger: isInteger\n});\n","var isObject = require('../internals/is-object');\n\nvar floor = Math.floor;\n\n// `Number.isInteger` method implementation\n// https://tc39.github.io/ecma262/#sec-number.isinteger\nmodule.exports = function isInteger(it) {\n  return !isObject(it) && isFinite(it) && floor(it) === it;\n};\n","require('../../modules/es.typed-array.slice');\n","'use strict';\nvar ArrayBufferViewCore = require('../internals/array-buffer-view-core');\nvar speciesConstructor = require('../internals/species-constructor');\nvar fails = require('../internals/fails');\n\nvar aTypedArray = ArrayBufferViewCore.aTypedArray;\nvar aTypedArrayConstructor = ArrayBufferViewCore.aTypedArrayConstructor;\nvar exportTypedArrayMethod = ArrayBufferViewCore.exportTypedArrayMethod;\nvar $slice = [].slice;\n\nvar FORCED = fails(function () {\n  // eslint-disable-next-line no-undef\n  new Int8Array(1).slice();\n});\n\n// `%TypedArray%.prototype.slice` method\n// https://tc39.github.io/ecma262/#sec-%typedarray%.prototype.slice\nexportTypedArrayMethod('slice', function slice(start, end) {\n  var list = $slice.call(aTypedArray(this), start, end);\n  var C = speciesConstructor(this, this.constructor);\n  var index = 0;\n  var length = list.length;\n  var result = new (aTypedArrayConstructor(C))(length);\n  while (length > index) result[index] = list[index++];\n  return result;\n}, FORCED);\n","'use strict';\nvar NATIVE_ARRAY_BUFFER = require('../internals/array-buffer-native');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar global = require('../internals/global');\nvar isObject = require('../internals/is-object');\nvar has = require('../internals/has');\nvar classof = require('../internals/classof');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar defineProperty = require('../internals/object-define-property').f;\nvar getPrototypeOf = require('../internals/object-get-prototype-of');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar uid = require('../internals/uid');\n\nvar Int8Array = global.Int8Array;\nvar Int8ArrayPrototype = Int8Array && Int8Array.prototype;\nvar Uint8ClampedArray = global.Uint8ClampedArray;\nvar Uint8ClampedArrayPrototype = Uint8ClampedArray && Uint8ClampedArray.prototype;\nvar TypedArray = Int8Array && getPrototypeOf(Int8Array);\nvar TypedArrayPrototype = Int8ArrayPrototype && getPrototypeOf(Int8ArrayPrototype);\nvar ObjectPrototype = Object.prototype;\nvar isPrototypeOf = ObjectPrototype.isPrototypeOf;\n\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar TYPED_ARRAY_TAG = uid('TYPED_ARRAY_TAG');\n// Fixing native typed arrays in Opera Presto crashes the browser, see #595\nvar NATIVE_ARRAY_BUFFER_VIEWS = NATIVE_ARRAY_BUFFER && !!setPrototypeOf && classof(global.opera) !== 'Opera';\nvar TYPED_ARRAY_TAG_REQIRED = false;\nvar NAME;\n\nvar TypedArrayConstructorsList = {\n  Int8Array: 1,\n  Uint8Array: 1,\n  Uint8ClampedArray: 1,\n  Int16Array: 2,\n  Uint16Array: 2,\n  Int32Array: 4,\n  Uint32Array: 4,\n  Float32Array: 4,\n  Float64Array: 8\n};\n\nvar isView = function isView(it) {\n  var klass = classof(it);\n  return klass === 'DataView' || has(TypedArrayConstructorsList, klass);\n};\n\nvar isTypedArray = function (it) {\n  return isObject(it) && has(TypedArrayConstructorsList, classof(it));\n};\n\nvar aTypedArray = function (it) {\n  if (isTypedArray(it)) return it;\n  throw TypeError('Target is not a typed array');\n};\n\nvar aTypedArrayConstructor = function (C) {\n  if (setPrototypeOf) {\n    if (isPrototypeOf.call(TypedArray, C)) return C;\n  } else for (var ARRAY in TypedArrayConstructorsList) if (has(TypedArrayConstructorsList, NAME)) {\n    var TypedArrayConstructor = global[ARRAY];\n    if (TypedArrayConstructor && (C === TypedArrayConstructor || isPrototypeOf.call(TypedArrayConstructor, C))) {\n      return C;\n    }\n  } throw TypeError('Target is not a typed array constructor');\n};\n\nvar exportTypedArrayMethod = function (KEY, property, forced) {\n  if (!DESCRIPTORS) return;\n  if (forced) for (var ARRAY in TypedArrayConstructorsList) {\n    var TypedArrayConstructor = global[ARRAY];\n    if (TypedArrayConstructor && has(TypedArrayConstructor.prototype, KEY)) {\n      delete TypedArrayConstructor.prototype[KEY];\n    }\n  }\n  if (!TypedArrayPrototype[KEY] || forced) {\n    redefine(TypedArrayPrototype, KEY, forced ? property\n      : NATIVE_ARRAY_BUFFER_VIEWS && Int8ArrayPrototype[KEY] || property);\n  }\n};\n\nvar exportTypedArrayStaticMethod = function (KEY, property, forced) {\n  var ARRAY, TypedArrayConstructor;\n  if (!DESCRIPTORS) return;\n  if (setPrototypeOf) {\n    if (forced) for (ARRAY in TypedArrayConstructorsList) {\n      TypedArrayConstructor = global[ARRAY];\n      if (TypedArrayConstructor && has(TypedArrayConstructor, KEY)) {\n        delete TypedArrayConstructor[KEY];\n      }\n    }\n    if (!TypedArray[KEY] || forced) {\n      // V8 ~ Chrome 49-50 `%TypedArray%` methods are non-writable non-configurable\n      try {\n        return redefine(TypedArray, KEY, forced ? property : NATIVE_ARRAY_BUFFER_VIEWS && Int8Array[KEY] || property);\n      } catch (error) { /* empty */ }\n    } else return;\n  }\n  for (ARRAY in TypedArrayConstructorsList) {\n    TypedArrayConstructor = global[ARRAY];\n    if (TypedArrayConstructor && (!TypedArrayConstructor[KEY] || forced)) {\n      redefine(TypedArrayConstructor, KEY, property);\n    }\n  }\n};\n\nfor (NAME in TypedArrayConstructorsList) {\n  if (!global[NAME]) NATIVE_ARRAY_BUFFER_VIEWS = false;\n}\n\n// WebKit bug - typed arrays constructors prototype is Object.prototype\nif (!NATIVE_ARRAY_BUFFER_VIEWS || typeof TypedArray != 'function' || TypedArray === Function.prototype) {\n  // eslint-disable-next-line no-shadow\n  TypedArray = function TypedArray() {\n    throw TypeError('Incorrect invocation');\n  };\n  if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {\n    if (global[NAME]) setPrototypeOf(global[NAME], TypedArray);\n  }\n}\n\nif (!NATIVE_ARRAY_BUFFER_VIEWS || !TypedArrayPrototype || TypedArrayPrototype === ObjectPrototype) {\n  TypedArrayPrototype = TypedArray.prototype;\n  if (NATIVE_ARRAY_BUFFER_VIEWS) for (NAME in TypedArrayConstructorsList) {\n    if (global[NAME]) setPrototypeOf(global[NAME].prototype, TypedArrayPrototype);\n  }\n}\n\n// WebKit bug - one more object in Uint8ClampedArray prototype chain\nif (NATIVE_ARRAY_BUFFER_VIEWS && getPrototypeOf(Uint8ClampedArrayPrototype) !== TypedArrayPrototype) {\n  setPrototypeOf(Uint8ClampedArrayPrototype, TypedArrayPrototype);\n}\n\nif (DESCRIPTORS && !has(TypedArrayPrototype, TO_STRING_TAG)) {\n  TYPED_ARRAY_TAG_REQIRED = true;\n  defineProperty(TypedArrayPrototype, TO_STRING_TAG, { get: function () {\n    return isObject(this) ? this[TYPED_ARRAY_TAG] : undefined;\n  } });\n  for (NAME in TypedArrayConstructorsList) if (global[NAME]) {\n    createNonEnumerableProperty(global[NAME], TYPED_ARRAY_TAG, NAME);\n  }\n}\n\nmodule.exports = {\n  NATIVE_ARRAY_BUFFER_VIEWS: NATIVE_ARRAY_BUFFER_VIEWS,\n  TYPED_ARRAY_TAG: TYPED_ARRAY_TAG_REQIRED && TYPED_ARRAY_TAG,\n  aTypedArray: aTypedArray,\n  aTypedArrayConstructor: aTypedArrayConstructor,\n  exportTypedArrayMethod: exportTypedArrayMethod,\n  exportTypedArrayStaticMethod: exportTypedArrayStaticMethod,\n  isView: isView,\n  isTypedArray: isTypedArray,\n  TypedArray: TypedArray,\n  TypedArrayPrototype: TypedArrayPrototype\n};\n","module.exports = typeof ArrayBuffer !== 'undefined' && typeof DataView !== 'undefined';\n","var anObject = require('../internals/an-object');\nvar aFunction = require('../internals/a-function');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `SpeciesConstructor` abstract operation\n// https://tc39.github.io/ecma262/#sec-speciesconstructor\nmodule.exports = function (O, defaultConstructor) {\n  var C = anObject(O).constructor;\n  var S;\n  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? defaultConstructor : aFunction(S);\n};\n","require('../../modules/es.object.to-string');\nrequire('../../modules/es.string.iterator');\nrequire('../../modules/web.dom-collections.iterator');\nrequire('../../modules/es.promise');\nrequire('../../modules/es.promise.all-settled');\nrequire('../../modules/es.promise.finally');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Promise;\n","var TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar redefine = require('../internals/redefine');\nvar toString = require('../internals/object-to-string');\n\n// `Object.prototype.toString` method\n// https://tc39.github.io/ecma262/#sec-object.prototype.tostring\nif (!TO_STRING_TAG_SUPPORT) {\n  redefine(Object.prototype, 'toString', toString, { unsafe: true });\n}\n","'use strict';\nvar TO_STRING_TAG_SUPPORT = require('../internals/to-string-tag-support');\nvar classof = require('../internals/classof');\n\n// `Object.prototype.toString` method implementation\n// https://tc39.github.io/ecma262/#sec-object.prototype.tostring\nmodule.exports = TO_STRING_TAG_SUPPORT ? {}.toString : function toString() {\n  return '[object ' + classof(this) + ']';\n};\n","var global = require('../internals/global');\nvar DOMIterables = require('../internals/dom-iterables');\nvar ArrayIteratorMethods = require('../modules/es.array.iterator');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar ITERATOR = wellKnownSymbol('iterator');\nvar TO_STRING_TAG = wellKnownSymbol('toStringTag');\nvar ArrayValues = ArrayIteratorMethods.values;\n\nfor (var COLLECTION_NAME in DOMIterables) {\n  var Collection = global[COLLECTION_NAME];\n  var CollectionPrototype = Collection && Collection.prototype;\n  if (CollectionPrototype) {\n    // some Chrome versions have non-configurable methods on DOMTokenList\n    if (CollectionPrototype[ITERATOR] !== ArrayValues) try {\n      createNonEnumerableProperty(CollectionPrototype, ITERATOR, ArrayValues);\n    } catch (error) {\n      CollectionPrototype[ITERATOR] = ArrayValues;\n    }\n    if (!CollectionPrototype[TO_STRING_TAG]) {\n      createNonEnumerableProperty(CollectionPrototype, TO_STRING_TAG, COLLECTION_NAME);\n    }\n    if (DOMIterables[COLLECTION_NAME]) for (var METHOD_NAME in ArrayIteratorMethods) {\n      // some Chrome versions have non-configurable methods on DOMTokenList\n      if (CollectionPrototype[METHOD_NAME] !== ArrayIteratorMethods[METHOD_NAME]) try {\n        createNonEnumerableProperty(CollectionPrototype, METHOD_NAME, ArrayIteratorMethods[METHOD_NAME]);\n      } catch (error) {\n        CollectionPrototype[METHOD_NAME] = ArrayIteratorMethods[METHOD_NAME];\n      }\n    }\n  }\n}\n","// iterable DOM collections\n// flag - `iterable` interface - 'entries', 'keys', 'values', 'forEach' methods\nmodule.exports = {\n  CSSRuleList: 0,\n  CSSStyleDeclaration: 0,\n  CSSValueList: 0,\n  ClientRectList: 0,\n  DOMRectList: 0,\n  DOMStringList: 0,\n  DOMTokenList: 1,\n  DataTransferItemList: 0,\n  FileList: 0,\n  HTMLAllCollection: 0,\n  HTMLCollection: 0,\n  HTMLFormElement: 0,\n  HTMLSelectElement: 0,\n  MediaList: 0,\n  MimeTypeArray: 0,\n  NamedNodeMap: 0,\n  NodeList: 1,\n  PaintRequestList: 0,\n  Plugin: 0,\n  PluginArray: 0,\n  SVGLengthList: 0,\n  SVGNumberList: 0,\n  SVGPathSegList: 0,\n  SVGPointList: 0,\n  SVGStringList: 0,\n  SVGTransformList: 0,\n  SourceBufferList: 0,\n  StyleSheetList: 0,\n  TextTrackCueList: 0,\n  TextTrackList: 0,\n  TouchList: 0\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar NativePromise = require('../internals/native-promise-constructor');\nvar redefine = require('../internals/redefine');\nvar redefineAll = require('../internals/redefine-all');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar setSpecies = require('../internals/set-species');\nvar isObject = require('../internals/is-object');\nvar aFunction = require('../internals/a-function');\nvar anInstance = require('../internals/an-instance');\nvar classof = require('../internals/classof-raw');\nvar inspectSource = require('../internals/inspect-source');\nvar iterate = require('../internals/iterate');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar speciesConstructor = require('../internals/species-constructor');\nvar task = require('../internals/task').set;\nvar microtask = require('../internals/microtask');\nvar promiseResolve = require('../internals/promise-resolve');\nvar hostReportErrors = require('../internals/host-report-errors');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar InternalStateModule = require('../internals/internal-state');\nvar isForced = require('../internals/is-forced');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\nvar PROMISE = 'Promise';\nvar getInternalState = InternalStateModule.get;\nvar setInternalState = InternalStateModule.set;\nvar getInternalPromiseState = InternalStateModule.getterFor(PROMISE);\nvar PromiseConstructor = NativePromise;\nvar TypeError = global.TypeError;\nvar document = global.document;\nvar process = global.process;\nvar $fetch = getBuiltIn('fetch');\nvar newPromiseCapability = newPromiseCapabilityModule.f;\nvar newGenericPromiseCapability = newPromiseCapability;\nvar IS_NODE = classof(process) == 'process';\nvar DISPATCH_EVENT = !!(document && document.createEvent && global.dispatchEvent);\nvar UNHANDLED_REJECTION = 'unhandledrejection';\nvar REJECTION_HANDLED = 'rejectionhandled';\nvar PENDING = 0;\nvar FULFILLED = 1;\nvar REJECTED = 2;\nvar HANDLED = 1;\nvar UNHANDLED = 2;\nvar Internal, OwnPromiseCapability, PromiseWrapper, nativeThen;\n\nvar FORCED = isForced(PROMISE, function () {\n  var GLOBAL_CORE_JS_PROMISE = inspectSource(PromiseConstructor) !== String(PromiseConstructor);\n  if (!GLOBAL_CORE_JS_PROMISE) {\n    // V8 6.6 (Node 10 and Chrome 66) have a bug with resolving custom thenables\n    // https://bugs.chromium.org/p/chromium/issues/detail?id=830565\n    // We can't detect it synchronously, so just check versions\n    if (V8_VERSION === 66) return true;\n    // Unhandled rejections tracking support, NodeJS Promise without it fails @@species test\n    if (!IS_NODE && typeof PromiseRejectionEvent != 'function') return true;\n  }\n  // We need Promise#finally in the pure version for preventing prototype pollution\n  if (IS_PURE && !PromiseConstructor.prototype['finally']) return true;\n  // We can't use @@species feature detection in V8 since it causes\n  // deoptimization and performance degradation\n  // https://github.com/zloirock/core-js/issues/679\n  if (V8_VERSION >= 51 && /native code/.test(PromiseConstructor)) return false;\n  // Detect correctness of subclassing with @@species support\n  var promise = PromiseConstructor.resolve(1);\n  var FakePromise = function (exec) {\n    exec(function () { /* empty */ }, function () { /* empty */ });\n  };\n  var constructor = promise.constructor = {};\n  constructor[SPECIES] = FakePromise;\n  return !(promise.then(function () { /* empty */ }) instanceof FakePromise);\n});\n\nvar INCORRECT_ITERATION = FORCED || !checkCorrectnessOfIteration(function (iterable) {\n  PromiseConstructor.all(iterable)['catch'](function () { /* empty */ });\n});\n\n// helpers\nvar isThenable = function (it) {\n  var then;\n  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;\n};\n\nvar notify = function (promise, state, isReject) {\n  if (state.notified) return;\n  state.notified = true;\n  var chain = state.reactions;\n  microtask(function () {\n    var value = state.value;\n    var ok = state.state == FULFILLED;\n    var index = 0;\n    // variable length - can't use forEach\n    while (chain.length > index) {\n      var reaction = chain[index++];\n      var handler = ok ? reaction.ok : reaction.fail;\n      var resolve = reaction.resolve;\n      var reject = reaction.reject;\n      var domain = reaction.domain;\n      var result, then, exited;\n      try {\n        if (handler) {\n          if (!ok) {\n            if (state.rejection === UNHANDLED) onHandleUnhandled(promise, state);\n            state.rejection = HANDLED;\n          }\n          if (handler === true) result = value;\n          else {\n            if (domain) domain.enter();\n            result = handler(value); // can throw\n            if (domain) {\n              domain.exit();\n              exited = true;\n            }\n          }\n          if (result === reaction.promise) {\n            reject(TypeError('Promise-chain cycle'));\n          } else if (then = isThenable(result)) {\n            then.call(result, resolve, reject);\n          } else resolve(result);\n        } else reject(value);\n      } catch (error) {\n        if (domain && !exited) domain.exit();\n        reject(error);\n      }\n    }\n    state.reactions = [];\n    state.notified = false;\n    if (isReject && !state.rejection) onUnhandled(promise, state);\n  });\n};\n\nvar dispatchEvent = function (name, promise, reason) {\n  var event, handler;\n  if (DISPATCH_EVENT) {\n    event = document.createEvent('Event');\n    event.promise = promise;\n    event.reason = reason;\n    event.initEvent(name, false, true);\n    global.dispatchEvent(event);\n  } else event = { promise: promise, reason: reason };\n  if (handler = global['on' + name]) handler(event);\n  else if (name === UNHANDLED_REJECTION) hostReportErrors('Unhandled promise rejection', reason);\n};\n\nvar onUnhandled = function (promise, state) {\n  task.call(global, function () {\n    var value = state.value;\n    var IS_UNHANDLED = isUnhandled(state);\n    var result;\n    if (IS_UNHANDLED) {\n      result = perform(function () {\n        if (IS_NODE) {\n          process.emit('unhandledRejection', value, promise);\n        } else dispatchEvent(UNHANDLED_REJECTION, promise, value);\n      });\n      // Browsers should not trigger `rejectionHandled` event if it was handled here, NodeJS - should\n      state.rejection = IS_NODE || isUnhandled(state) ? UNHANDLED : HANDLED;\n      if (result.error) throw result.value;\n    }\n  });\n};\n\nvar isUnhandled = function (state) {\n  return state.rejection !== HANDLED && !state.parent;\n};\n\nvar onHandleUnhandled = function (promise, state) {\n  task.call(global, function () {\n    if (IS_NODE) {\n      process.emit('rejectionHandled', promise);\n    } else dispatchEvent(REJECTION_HANDLED, promise, state.value);\n  });\n};\n\nvar bind = function (fn, promise, state, unwrap) {\n  return function (value) {\n    fn(promise, state, value, unwrap);\n  };\n};\n\nvar internalReject = function (promise, state, value, unwrap) {\n  if (state.done) return;\n  state.done = true;\n  if (unwrap) state = unwrap;\n  state.value = value;\n  state.state = REJECTED;\n  notify(promise, state, true);\n};\n\nvar internalResolve = function (promise, state, value, unwrap) {\n  if (state.done) return;\n  state.done = true;\n  if (unwrap) state = unwrap;\n  try {\n    if (promise === value) throw TypeError(\"Promise can't be resolved itself\");\n    var then = isThenable(value);\n    if (then) {\n      microtask(function () {\n        var wrapper = { done: false };\n        try {\n          then.call(value,\n            bind(internalResolve, promise, wrapper, state),\n            bind(internalReject, promise, wrapper, state)\n          );\n        } catch (error) {\n          internalReject(promise, wrapper, error, state);\n        }\n      });\n    } else {\n      state.value = value;\n      state.state = FULFILLED;\n      notify(promise, state, false);\n    }\n  } catch (error) {\n    internalReject(promise, { done: false }, error, state);\n  }\n};\n\n// constructor polyfill\nif (FORCED) {\n  // 25.4.3.1 Promise(executor)\n  PromiseConstructor = function Promise(executor) {\n    anInstance(this, PromiseConstructor, PROMISE);\n    aFunction(executor);\n    Internal.call(this);\n    var state = getInternalState(this);\n    try {\n      executor(bind(internalResolve, this, state), bind(internalReject, this, state));\n    } catch (error) {\n      internalReject(this, state, error);\n    }\n  };\n  // eslint-disable-next-line no-unused-vars\n  Internal = function Promise(executor) {\n    setInternalState(this, {\n      type: PROMISE,\n      done: false,\n      notified: false,\n      parent: false,\n      reactions: [],\n      rejection: false,\n      state: PENDING,\n      value: undefined\n    });\n  };\n  Internal.prototype = redefineAll(PromiseConstructor.prototype, {\n    // `Promise.prototype.then` method\n    // https://tc39.github.io/ecma262/#sec-promise.prototype.then\n    then: function then(onFulfilled, onRejected) {\n      var state = getInternalPromiseState(this);\n      var reaction = newPromiseCapability(speciesConstructor(this, PromiseConstructor));\n      reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;\n      reaction.fail = typeof onRejected == 'function' && onRejected;\n      reaction.domain = IS_NODE ? process.domain : undefined;\n      state.parent = true;\n      state.reactions.push(reaction);\n      if (state.state != PENDING) notify(this, state, false);\n      return reaction.promise;\n    },\n    // `Promise.prototype.catch` method\n    // https://tc39.github.io/ecma262/#sec-promise.prototype.catch\n    'catch': function (onRejected) {\n      return this.then(undefined, onRejected);\n    }\n  });\n  OwnPromiseCapability = function () {\n    var promise = new Internal();\n    var state = getInternalState(promise);\n    this.promise = promise;\n    this.resolve = bind(internalResolve, promise, state);\n    this.reject = bind(internalReject, promise, state);\n  };\n  newPromiseCapabilityModule.f = newPromiseCapability = function (C) {\n    return C === PromiseConstructor || C === PromiseWrapper\n      ? new OwnPromiseCapability(C)\n      : newGenericPromiseCapability(C);\n  };\n\n  if (!IS_PURE && typeof NativePromise == 'function') {\n    nativeThen = NativePromise.prototype.then;\n\n    // wrap native Promise#then for native async functions\n    redefine(NativePromise.prototype, 'then', function then(onFulfilled, onRejected) {\n      var that = this;\n      return new PromiseConstructor(function (resolve, reject) {\n        nativeThen.call(that, resolve, reject);\n      }).then(onFulfilled, onRejected);\n    // https://github.com/zloirock/core-js/issues/640\n    }, { unsafe: true });\n\n    // wrap fetch result\n    if (typeof $fetch == 'function') $({ global: true, enumerable: true, forced: true }, {\n      // eslint-disable-next-line no-unused-vars\n      fetch: function fetch(input /* , init */) {\n        return promiseResolve(PromiseConstructor, $fetch.apply(global, arguments));\n      }\n    });\n  }\n}\n\n$({ global: true, wrap: true, forced: FORCED }, {\n  Promise: PromiseConstructor\n});\n\nsetToStringTag(PromiseConstructor, PROMISE, false, true);\nsetSpecies(PROMISE);\n\nPromiseWrapper = getBuiltIn(PROMISE);\n\n// statics\n$({ target: PROMISE, stat: true, forced: FORCED }, {\n  // `Promise.reject` method\n  // https://tc39.github.io/ecma262/#sec-promise.reject\n  reject: function reject(r) {\n    var capability = newPromiseCapability(this);\n    capability.reject.call(undefined, r);\n    return capability.promise;\n  }\n});\n\n$({ target: PROMISE, stat: true, forced: IS_PURE || FORCED }, {\n  // `Promise.resolve` method\n  // https://tc39.github.io/ecma262/#sec-promise.resolve\n  resolve: function resolve(x) {\n    return promiseResolve(IS_PURE && this === PromiseWrapper ? PromiseConstructor : this, x);\n  }\n});\n\n$({ target: PROMISE, stat: true, forced: INCORRECT_ITERATION }, {\n  // `Promise.all` method\n  // https://tc39.github.io/ecma262/#sec-promise.all\n  all: function all(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var $promiseResolve = aFunction(C.resolve);\n      var values = [];\n      var counter = 0;\n      var remaining = 1;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyCalled = false;\n        values.push(undefined);\n        remaining++;\n        $promiseResolve.call(C, promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = value;\n          --remaining || resolve(values);\n        }, reject);\n      });\n      --remaining || resolve(values);\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  },\n  // `Promise.race` method\n  // https://tc39.github.io/ecma262/#sec-promise.race\n  race: function race(iterable) {\n    var C = this;\n    var capability = newPromiseCapability(C);\n    var reject = capability.reject;\n    var result = perform(function () {\n      var $promiseResolve = aFunction(C.resolve);\n      iterate(iterable, function (promise) {\n        $promiseResolve.call(C, promise).then(capability.resolve, reject);\n      });\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","var global = require('../internals/global');\n\nmodule.exports = global.Promise;\n","var redefine = require('../internals/redefine');\n\nmodule.exports = function (target, src, options) {\n  for (var key in src) redefine(target, key, src[key], options);\n  return target;\n};\n","'use strict';\nvar getBuiltIn = require('../internals/get-built-in');\nvar definePropertyModule = require('../internals/object-define-property');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar DESCRIPTORS = require('../internals/descriptors');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (CONSTRUCTOR_NAME) {\n  var Constructor = getBuiltIn(CONSTRUCTOR_NAME);\n  var defineProperty = definePropertyModule.f;\n\n  if (DESCRIPTORS && Constructor && !Constructor[SPECIES]) {\n    defineProperty(Constructor, SPECIES, {\n      configurable: true,\n      get: function () { return this; }\n    });\n  }\n};\n","module.exports = function (it, Constructor, name) {\n  if (!(it instanceof Constructor)) {\n    throw TypeError('Incorrect ' + (name ? name + ' ' : '') + 'invocation');\n  } return it;\n};\n","var global = require('../internals/global');\nvar fails = require('../internals/fails');\nvar classof = require('../internals/classof-raw');\nvar bind = require('../internals/function-bind-context');\nvar html = require('../internals/html');\nvar createElement = require('../internals/document-create-element');\nvar IS_IOS = require('../internals/engine-is-ios');\n\nvar location = global.location;\nvar set = global.setImmediate;\nvar clear = global.clearImmediate;\nvar process = global.process;\nvar MessageChannel = global.MessageChannel;\nvar Dispatch = global.Dispatch;\nvar counter = 0;\nvar queue = {};\nvar ONREADYSTATECHANGE = 'onreadystatechange';\nvar defer, channel, port;\n\nvar run = function (id) {\n  // eslint-disable-next-line no-prototype-builtins\n  if (queue.hasOwnProperty(id)) {\n    var fn = queue[id];\n    delete queue[id];\n    fn();\n  }\n};\n\nvar runner = function (id) {\n  return function () {\n    run(id);\n  };\n};\n\nvar listener = function (event) {\n  run(event.data);\n};\n\nvar post = function (id) {\n  // old engines have not location.origin\n  global.postMessage(id + '', location.protocol + '//' + location.host);\n};\n\n// Node.js 0.9+ & IE10+ has setImmediate, otherwise:\nif (!set || !clear) {\n  set = function setImmediate(fn) {\n    var args = [];\n    var i = 1;\n    while (arguments.length > i) args.push(arguments[i++]);\n    queue[++counter] = function () {\n      // eslint-disable-next-line no-new-func\n      (typeof fn == 'function' ? fn : Function(fn)).apply(undefined, args);\n    };\n    defer(counter);\n    return counter;\n  };\n  clear = function clearImmediate(id) {\n    delete queue[id];\n  };\n  // Node.js 0.8-\n  if (classof(process) == 'process') {\n    defer = function (id) {\n      process.nextTick(runner(id));\n    };\n  // Sphere (JS game engine) Dispatch API\n  } else if (Dispatch && Dispatch.now) {\n    defer = function (id) {\n      Dispatch.now(runner(id));\n    };\n  // Browsers with MessageChannel, includes WebWorkers\n  // except iOS - https://github.com/zloirock/core-js/issues/624\n  } else if (MessageChannel && !IS_IOS) {\n    channel = new MessageChannel();\n    port = channel.port2;\n    channel.port1.onmessage = listener;\n    defer = bind(port.postMessage, port, 1);\n  // Browsers with postMessage, skip WebWorkers\n  // IE8 has postMessage, but it's sync & typeof its postMessage is 'object'\n  } else if (\n    global.addEventListener &&\n    typeof postMessage == 'function' &&\n    !global.importScripts &&\n    !fails(post) &&\n    location.protocol !== 'file:'\n  ) {\n    defer = post;\n    global.addEventListener('message', listener, false);\n  // IE8-\n  } else if (ONREADYSTATECHANGE in createElement('script')) {\n    defer = function (id) {\n      html.appendChild(createElement('script'))[ONREADYSTATECHANGE] = function () {\n        html.removeChild(this);\n        run(id);\n      };\n    };\n  // Rest old browsers\n  } else {\n    defer = function (id) {\n      setTimeout(runner(id), 0);\n    };\n  }\n}\n\nmodule.exports = {\n  set: set,\n  clear: clear\n};\n","var userAgent = require('../internals/engine-user-agent');\n\nmodule.exports = /(iphone|ipod|ipad).*applewebkit/i.test(userAgent);\n","var getBuiltIn = require('../internals/get-built-in');\n\nmodule.exports = getBuiltIn('navigator', 'userAgent') || '';\n","var global = require('../internals/global');\nvar getOwnPropertyDescriptor = require('../internals/object-get-own-property-descriptor').f;\nvar classof = require('../internals/classof-raw');\nvar macrotask = require('../internals/task').set;\nvar IS_IOS = require('../internals/engine-is-ios');\n\nvar MutationObserver = global.MutationObserver || global.WebKitMutationObserver;\nvar process = global.process;\nvar Promise = global.Promise;\nvar IS_NODE = classof(process) == 'process';\n// Node.js 11 shows ExperimentalWarning on getting `queueMicrotask`\nvar queueMicrotaskDescriptor = getOwnPropertyDescriptor(global, 'queueMicrotask');\nvar queueMicrotask = queueMicrotaskDescriptor && queueMicrotaskDescriptor.value;\n\nvar flush, head, last, notify, toggle, node, promise, then;\n\n// modern engines have queueMicrotask method\nif (!queueMicrotask) {\n  flush = function () {\n    var parent, fn;\n    if (IS_NODE && (parent = process.domain)) parent.exit();\n    while (head) {\n      fn = head.fn;\n      head = head.next;\n      try {\n        fn();\n      } catch (error) {\n        if (head) notify();\n        else last = undefined;\n        throw error;\n      }\n    } last = undefined;\n    if (parent) parent.enter();\n  };\n\n  // Node.js\n  if (IS_NODE) {\n    notify = function () {\n      process.nextTick(flush);\n    };\n  // browsers with MutationObserver, except iOS - https://github.com/zloirock/core-js/issues/339\n  } else if (MutationObserver && !IS_IOS) {\n    toggle = true;\n    node = document.createTextNode('');\n    new MutationObserver(flush).observe(node, { characterData: true });\n    notify = function () {\n      node.data = toggle = !toggle;\n    };\n  // environments with maybe non-completely correct, but existent Promise\n  } else if (Promise && Promise.resolve) {\n    // Promise.resolve without an argument throws an error in LG WebOS 2\n    promise = Promise.resolve(undefined);\n    then = promise.then;\n    notify = function () {\n      then.call(promise, flush);\n    };\n  // for other environments - macrotask based on:\n  // - setImmediate\n  // - MessageChannel\n  // - window.postMessag\n  // - onreadystatechange\n  // - setTimeout\n  } else {\n    notify = function () {\n      // strange IE + webpack dev server bug - use .call(global)\n      macrotask.call(global, flush);\n    };\n  }\n}\n\nmodule.exports = queueMicrotask || function (fn) {\n  var task = { fn: fn, next: undefined };\n  if (last) last.next = task;\n  if (!head) {\n    head = task;\n    notify();\n  } last = task;\n};\n","var anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar newPromiseCapability = require('../internals/new-promise-capability');\n\nmodule.exports = function (C, x) {\n  anObject(C);\n  if (isObject(x) && x.constructor === C) return x;\n  var promiseCapability = newPromiseCapability.f(C);\n  var resolve = promiseCapability.resolve;\n  resolve(x);\n  return promiseCapability.promise;\n};\n","'use strict';\nvar aFunction = require('../internals/a-function');\n\nvar PromiseCapability = function (C) {\n  var resolve, reject;\n  this.promise = new C(function ($$resolve, $$reject) {\n    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');\n    resolve = $$resolve;\n    reject = $$reject;\n  });\n  this.resolve = aFunction(resolve);\n  this.reject = aFunction(reject);\n};\n\n// 25.4.1.5 NewPromiseCapability(C)\nmodule.exports.f = function (C) {\n  return new PromiseCapability(C);\n};\n","var global = require('../internals/global');\n\nmodule.exports = function (a, b) {\n  var console = global.console;\n  if (console && console.error) {\n    arguments.length === 1 ? console.error(a) : console.error(a, b);\n  }\n};\n","module.exports = function (exec) {\n  try {\n    return { error: false, value: exec() };\n  } catch (error) {\n    return { error: true, value: error };\n  }\n};\n","var global = require('../internals/global');\nvar userAgent = require('../internals/engine-user-agent');\n\nvar process = global.process;\nvar versions = process && process.versions;\nvar v8 = versions && versions.v8;\nvar match, version;\n\nif (v8) {\n  match = v8.split('.');\n  version = match[0] + match[1];\n} else if (userAgent) {\n  match = userAgent.match(/Edge\\/(\\d+)/);\n  if (!match || match[1] >= 74) {\n    match = userAgent.match(/Chrome\\/(\\d+)/);\n    if (match) version = match[1];\n  }\n}\n\nmodule.exports = version && +version;\n","'use strict';\nvar $ = require('../internals/export');\nvar aFunction = require('../internals/a-function');\nvar newPromiseCapabilityModule = require('../internals/new-promise-capability');\nvar perform = require('../internals/perform');\nvar iterate = require('../internals/iterate');\n\n// `Promise.allSettled` method\n// https://github.com/tc39/proposal-promise-allSettled\n$({ target: 'Promise', stat: true }, {\n  allSettled: function allSettled(iterable) {\n    var C = this;\n    var capability = newPromiseCapabilityModule.f(C);\n    var resolve = capability.resolve;\n    var reject = capability.reject;\n    var result = perform(function () {\n      var promiseResolve = aFunction(C.resolve);\n      var values = [];\n      var counter = 0;\n      var remaining = 1;\n      iterate(iterable, function (promise) {\n        var index = counter++;\n        var alreadyCalled = false;\n        values.push(undefined);\n        remaining++;\n        promiseResolve.call(C, promise).then(function (value) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'fulfilled', value: value };\n          --remaining || resolve(values);\n        }, function (e) {\n          if (alreadyCalled) return;\n          alreadyCalled = true;\n          values[index] = { status: 'rejected', reason: e };\n          --remaining || resolve(values);\n        });\n      });\n      --remaining || resolve(values);\n    });\n    if (result.error) reject(result.value);\n    return capability.promise;\n  }\n});\n","'use strict';\nvar $ = require('../internals/export');\nvar IS_PURE = require('../internals/is-pure');\nvar NativePromise = require('../internals/native-promise-constructor');\nvar fails = require('../internals/fails');\nvar getBuiltIn = require('../internals/get-built-in');\nvar speciesConstructor = require('../internals/species-constructor');\nvar promiseResolve = require('../internals/promise-resolve');\nvar redefine = require('../internals/redefine');\n\n// Safari bug https://bugs.webkit.org/show_bug.cgi?id=200829\nvar NON_GENERIC = !!NativePromise && fails(function () {\n  NativePromise.prototype['finally'].call({ then: function () { /* empty */ } }, function () { /* empty */ });\n});\n\n// `Promise.prototype.finally` method\n// https://tc39.github.io/ecma262/#sec-promise.prototype.finally\n$({ target: 'Promise', proto: true, real: true, forced: NON_GENERIC }, {\n  'finally': function (onFinally) {\n    var C = speciesConstructor(this, getBuiltIn('Promise'));\n    var isFunction = typeof onFinally == 'function';\n    return this.then(\n      isFunction ? function (x) {\n        return promiseResolve(C, onFinally()).then(function () { return x; });\n      } : onFinally,\n      isFunction ? function (e) {\n        return promiseResolve(C, onFinally()).then(function () { throw e; });\n      } : onFinally\n    );\n  }\n});\n\n// patch native Promise.prototype for native async functions\nif (!IS_PURE && typeof NativePromise == 'function' && !NativePromise.prototype['finally']) {\n  redefine(NativePromise.prototype, 'finally', getBuiltIn('Promise').prototype['finally']);\n}\n","require('../modules/web.url');\nrequire('../modules/web.url.to-json');\nrequire('../modules/web.url-search-params');\nvar path = require('../internals/path');\n\nmodule.exports = path.URL;\n","'use strict';\n// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`\nrequire('../modules/es.string.iterator');\nvar $ = require('../internals/export');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar USE_NATIVE_URL = require('../internals/native-url');\nvar global = require('../internals/global');\nvar defineProperties = require('../internals/object-define-properties');\nvar redefine = require('../internals/redefine');\nvar anInstance = require('../internals/an-instance');\nvar has = require('../internals/has');\nvar assign = require('../internals/object-assign');\nvar arrayFrom = require('../internals/array-from');\nvar codeAt = require('../internals/string-multibyte').codeAt;\nvar toASCII = require('../internals/string-punycode-to-ascii');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar URLSearchParamsModule = require('../modules/web.url-search-params');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar NativeURL = global.URL;\nvar URLSearchParams = URLSearchParamsModule.URLSearchParams;\nvar getInternalSearchParamsState = URLSearchParamsModule.getState;\nvar setInternalState = InternalStateModule.set;\nvar getInternalURLState = InternalStateModule.getterFor('URL');\nvar floor = Math.floor;\nvar pow = Math.pow;\n\nvar INVALID_AUTHORITY = 'Invalid authority';\nvar INVALID_SCHEME = 'Invalid scheme';\nvar INVALID_HOST = 'Invalid host';\nvar INVALID_PORT = 'Invalid port';\n\nvar ALPHA = /[A-Za-z]/;\nvar ALPHANUMERIC = /[\\d+-.A-Za-z]/;\nvar DIGIT = /\\d/;\nvar HEX_START = /^(0x|0X)/;\nvar OCT = /^[0-7]+$/;\nvar DEC = /^\\d+$/;\nvar HEX = /^[\\dA-Fa-f]+$/;\n// eslint-disable-next-line no-control-regex\nvar FORBIDDEN_HOST_CODE_POINT = /[\\u0000\\u0009\\u000A\\u000D #%/:?@[\\\\]]/;\n// eslint-disable-next-line no-control-regex\nvar FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT = /[\\u0000\\u0009\\u000A\\u000D #/:?@[\\\\]]/;\n// eslint-disable-next-line no-control-regex\nvar LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE = /^[\\u0000-\\u001F ]+|[\\u0000-\\u001F ]+$/g;\n// eslint-disable-next-line no-control-regex\nvar TAB_AND_NEW_LINE = /[\\u0009\\u000A\\u000D]/g;\nvar EOF;\n\nvar parseHost = function (url, input) {\n  var result, codePoints, index;\n  if (input.charAt(0) == '[') {\n    if (input.charAt(input.length - 1) != ']') return INVALID_HOST;\n    result = parseIPv6(input.slice(1, -1));\n    if (!result) return INVALID_HOST;\n    url.host = result;\n  // opaque host\n  } else if (!isSpecial(url)) {\n    if (FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT.test(input)) return INVALID_HOST;\n    result = '';\n    codePoints = arrayFrom(input);\n    for (index = 0; index < codePoints.length; index++) {\n      result += percentEncode(codePoints[index], C0ControlPercentEncodeSet);\n    }\n    url.host = result;\n  } else {\n    input = toASCII(input);\n    if (FORBIDDEN_HOST_CODE_POINT.test(input)) return INVALID_HOST;\n    result = parseIPv4(input);\n    if (result === null) return INVALID_HOST;\n    url.host = result;\n  }\n};\n\nvar parseIPv4 = function (input) {\n  var parts = input.split('.');\n  var partsLength, numbers, index, part, radix, number, ipv4;\n  if (parts.length && parts[parts.length - 1] == '') {\n    parts.pop();\n  }\n  partsLength = parts.length;\n  if (partsLength > 4) return input;\n  numbers = [];\n  for (index = 0; index < partsLength; index++) {\n    part = parts[index];\n    if (part == '') return input;\n    radix = 10;\n    if (part.length > 1 && part.charAt(0) == '0') {\n      radix = HEX_START.test(part) ? 16 : 8;\n      part = part.slice(radix == 8 ? 1 : 2);\n    }\n    if (part === '') {\n      number = 0;\n    } else {\n      if (!(radix == 10 ? DEC : radix == 8 ? OCT : HEX).test(part)) return input;\n      number = parseInt(part, radix);\n    }\n    numbers.push(number);\n  }\n  for (index = 0; index < partsLength; index++) {\n    number = numbers[index];\n    if (index == partsLength - 1) {\n      if (number >= pow(256, 5 - partsLength)) return null;\n    } else if (number > 255) return null;\n  }\n  ipv4 = numbers.pop();\n  for (index = 0; index < numbers.length; index++) {\n    ipv4 += numbers[index] * pow(256, 3 - index);\n  }\n  return ipv4;\n};\n\n// eslint-disable-next-line max-statements\nvar parseIPv6 = function (input) {\n  var address = [0, 0, 0, 0, 0, 0, 0, 0];\n  var pieceIndex = 0;\n  var compress = null;\n  var pointer = 0;\n  var value, length, numbersSeen, ipv4Piece, number, swaps, swap;\n\n  var char = function () {\n    return input.charAt(pointer);\n  };\n\n  if (char() == ':') {\n    if (input.charAt(1) != ':') return;\n    pointer += 2;\n    pieceIndex++;\n    compress = pieceIndex;\n  }\n  while (char()) {\n    if (pieceIndex == 8) return;\n    if (char() == ':') {\n      if (compress !== null) return;\n      pointer++;\n      pieceIndex++;\n      compress = pieceIndex;\n      continue;\n    }\n    value = length = 0;\n    while (length < 4 && HEX.test(char())) {\n      value = value * 16 + parseInt(char(), 16);\n      pointer++;\n      length++;\n    }\n    if (char() == '.') {\n      if (length == 0) return;\n      pointer -= length;\n      if (pieceIndex > 6) return;\n      numbersSeen = 0;\n      while (char()) {\n        ipv4Piece = null;\n        if (numbersSeen > 0) {\n          if (char() == '.' && numbersSeen < 4) pointer++;\n          else return;\n        }\n        if (!DIGIT.test(char())) return;\n        while (DIGIT.test(char())) {\n          number = parseInt(char(), 10);\n          if (ipv4Piece === null) ipv4Piece = number;\n          else if (ipv4Piece == 0) return;\n          else ipv4Piece = ipv4Piece * 10 + number;\n          if (ipv4Piece > 255) return;\n          pointer++;\n        }\n        address[pieceIndex] = address[pieceIndex] * 256 + ipv4Piece;\n        numbersSeen++;\n        if (numbersSeen == 2 || numbersSeen == 4) pieceIndex++;\n      }\n      if (numbersSeen != 4) return;\n      break;\n    } else if (char() == ':') {\n      pointer++;\n      if (!char()) return;\n    } else if (char()) return;\n    address[pieceIndex++] = value;\n  }\n  if (compress !== null) {\n    swaps = pieceIndex - compress;\n    pieceIndex = 7;\n    while (pieceIndex != 0 && swaps > 0) {\n      swap = address[pieceIndex];\n      address[pieceIndex--] = address[compress + swaps - 1];\n      address[compress + --swaps] = swap;\n    }\n  } else if (pieceIndex != 8) return;\n  return address;\n};\n\nvar findLongestZeroSequence = function (ipv6) {\n  var maxIndex = null;\n  var maxLength = 1;\n  var currStart = null;\n  var currLength = 0;\n  var index = 0;\n  for (; index < 8; index++) {\n    if (ipv6[index] !== 0) {\n      if (currLength > maxLength) {\n        maxIndex = currStart;\n        maxLength = currLength;\n      }\n      currStart = null;\n      currLength = 0;\n    } else {\n      if (currStart === null) currStart = index;\n      ++currLength;\n    }\n  }\n  if (currLength > maxLength) {\n    maxIndex = currStart;\n    maxLength = currLength;\n  }\n  return maxIndex;\n};\n\nvar serializeHost = function (host) {\n  var result, index, compress, ignore0;\n  // ipv4\n  if (typeof host == 'number') {\n    result = [];\n    for (index = 0; index < 4; index++) {\n      result.unshift(host % 256);\n      host = floor(host / 256);\n    } return result.join('.');\n  // ipv6\n  } else if (typeof host == 'object') {\n    result = '';\n    compress = findLongestZeroSequence(host);\n    for (index = 0; index < 8; index++) {\n      if (ignore0 && host[index] === 0) continue;\n      if (ignore0) ignore0 = false;\n      if (compress === index) {\n        result += index ? ':' : '::';\n        ignore0 = true;\n      } else {\n        result += host[index].toString(16);\n        if (index < 7) result += ':';\n      }\n    }\n    return '[' + result + ']';\n  } return host;\n};\n\nvar C0ControlPercentEncodeSet = {};\nvar fragmentPercentEncodeSet = assign({}, C0ControlPercentEncodeSet, {\n  ' ': 1, '\"': 1, '<': 1, '>': 1, '`': 1\n});\nvar pathPercentEncodeSet = assign({}, fragmentPercentEncodeSet, {\n  '#': 1, '?': 1, '{': 1, '}': 1\n});\nvar userinfoPercentEncodeSet = assign({}, pathPercentEncodeSet, {\n  '/': 1, ':': 1, ';': 1, '=': 1, '@': 1, '[': 1, '\\\\': 1, ']': 1, '^': 1, '|': 1\n});\n\nvar percentEncode = function (char, set) {\n  var code = codeAt(char, 0);\n  return code > 0x20 && code < 0x7F && !has(set, char) ? char : encodeURIComponent(char);\n};\n\nvar specialSchemes = {\n  ftp: 21,\n  file: null,\n  http: 80,\n  https: 443,\n  ws: 80,\n  wss: 443\n};\n\nvar isSpecial = function (url) {\n  return has(specialSchemes, url.scheme);\n};\n\nvar includesCredentials = function (url) {\n  return url.username != '' || url.password != '';\n};\n\nvar cannotHaveUsernamePasswordPort = function (url) {\n  return !url.host || url.cannotBeABaseURL || url.scheme == 'file';\n};\n\nvar isWindowsDriveLetter = function (string, normalized) {\n  var second;\n  return string.length == 2 && ALPHA.test(string.charAt(0))\n    && ((second = string.charAt(1)) == ':' || (!normalized && second == '|'));\n};\n\nvar startsWithWindowsDriveLetter = function (string) {\n  var third;\n  return string.length > 1 && isWindowsDriveLetter(string.slice(0, 2)) && (\n    string.length == 2 ||\n    ((third = string.charAt(2)) === '/' || third === '\\\\' || third === '?' || third === '#')\n  );\n};\n\nvar shortenURLsPath = function (url) {\n  var path = url.path;\n  var pathSize = path.length;\n  if (pathSize && (url.scheme != 'file' || pathSize != 1 || !isWindowsDriveLetter(path[0], true))) {\n    path.pop();\n  }\n};\n\nvar isSingleDot = function (segment) {\n  return segment === '.' || segment.toLowerCase() === '%2e';\n};\n\nvar isDoubleDot = function (segment) {\n  segment = segment.toLowerCase();\n  return segment === '..' || segment === '%2e.' || segment === '.%2e' || segment === '%2e%2e';\n};\n\n// States:\nvar SCHEME_START = {};\nvar SCHEME = {};\nvar NO_SCHEME = {};\nvar SPECIAL_RELATIVE_OR_AUTHORITY = {};\nvar PATH_OR_AUTHORITY = {};\nvar RELATIVE = {};\nvar RELATIVE_SLASH = {};\nvar SPECIAL_AUTHORITY_SLASHES = {};\nvar SPECIAL_AUTHORITY_IGNORE_SLASHES = {};\nvar AUTHORITY = {};\nvar HOST = {};\nvar HOSTNAME = {};\nvar PORT = {};\nvar FILE = {};\nvar FILE_SLASH = {};\nvar FILE_HOST = {};\nvar PATH_START = {};\nvar PATH = {};\nvar CANNOT_BE_A_BASE_URL_PATH = {};\nvar QUERY = {};\nvar FRAGMENT = {};\n\n// eslint-disable-next-line max-statements\nvar parseURL = function (url, input, stateOverride, base) {\n  var state = stateOverride || SCHEME_START;\n  var pointer = 0;\n  var buffer = '';\n  var seenAt = false;\n  var seenBracket = false;\n  var seenPasswordToken = false;\n  var codePoints, char, bufferCodePoints, failure;\n\n  if (!stateOverride) {\n    url.scheme = '';\n    url.username = '';\n    url.password = '';\n    url.host = null;\n    url.port = null;\n    url.path = [];\n    url.query = null;\n    url.fragment = null;\n    url.cannotBeABaseURL = false;\n    input = input.replace(LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE, '');\n  }\n\n  input = input.replace(TAB_AND_NEW_LINE, '');\n\n  codePoints = arrayFrom(input);\n\n  while (pointer <= codePoints.length) {\n    char = codePoints[pointer];\n    switch (state) {\n      case SCHEME_START:\n        if (char && ALPHA.test(char)) {\n          buffer += char.toLowerCase();\n          state = SCHEME;\n        } else if (!stateOverride) {\n          state = NO_SCHEME;\n          continue;\n        } else return INVALID_SCHEME;\n        break;\n\n      case SCHEME:\n        if (char && (ALPHANUMERIC.test(char) || char == '+' || char == '-' || char == '.')) {\n          buffer += char.toLowerCase();\n        } else if (char == ':') {\n          if (stateOverride && (\n            (isSpecial(url) != has(specialSchemes, buffer)) ||\n            (buffer == 'file' && (includesCredentials(url) || url.port !== null)) ||\n            (url.scheme == 'file' && !url.host)\n          )) return;\n          url.scheme = buffer;\n          if (stateOverride) {\n            if (isSpecial(url) && specialSchemes[url.scheme] == url.port) url.port = null;\n            return;\n          }\n          buffer = '';\n          if (url.scheme == 'file') {\n            state = FILE;\n          } else if (isSpecial(url) && base && base.scheme == url.scheme) {\n            state = SPECIAL_RELATIVE_OR_AUTHORITY;\n          } else if (isSpecial(url)) {\n            state = SPECIAL_AUTHORITY_SLASHES;\n          } else if (codePoints[pointer + 1] == '/') {\n            state = PATH_OR_AUTHORITY;\n            pointer++;\n          } else {\n            url.cannotBeABaseURL = true;\n            url.path.push('');\n            state = CANNOT_BE_A_BASE_URL_PATH;\n          }\n        } else if (!stateOverride) {\n          buffer = '';\n          state = NO_SCHEME;\n          pointer = 0;\n          continue;\n        } else return INVALID_SCHEME;\n        break;\n\n      case NO_SCHEME:\n        if (!base || (base.cannotBeABaseURL && char != '#')) return INVALID_SCHEME;\n        if (base.cannotBeABaseURL && char == '#') {\n          url.scheme = base.scheme;\n          url.path = base.path.slice();\n          url.query = base.query;\n          url.fragment = '';\n          url.cannotBeABaseURL = true;\n          state = FRAGMENT;\n          break;\n        }\n        state = base.scheme == 'file' ? FILE : RELATIVE;\n        continue;\n\n      case SPECIAL_RELATIVE_OR_AUTHORITY:\n        if (char == '/' && codePoints[pointer + 1] == '/') {\n          state = SPECIAL_AUTHORITY_IGNORE_SLASHES;\n          pointer++;\n        } else {\n          state = RELATIVE;\n          continue;\n        } break;\n\n      case PATH_OR_AUTHORITY:\n        if (char == '/') {\n          state = AUTHORITY;\n          break;\n        } else {\n          state = PATH;\n          continue;\n        }\n\n      case RELATIVE:\n        url.scheme = base.scheme;\n        if (char == EOF) {\n          url.username = base.username;\n          url.password = base.password;\n          url.host = base.host;\n          url.port = base.port;\n          url.path = base.path.slice();\n          url.query = base.query;\n        } else if (char == '/' || (char == '\\\\' && isSpecial(url))) {\n          state = RELATIVE_SLASH;\n        } else if (char == '?') {\n          url.username = base.username;\n          url.password = base.password;\n          url.host = base.host;\n          url.port = base.port;\n          url.path = base.path.slice();\n          url.query = '';\n          state = QUERY;\n        } else if (char == '#') {\n          url.username = base.username;\n          url.password = base.password;\n          url.host = base.host;\n          url.port = base.port;\n          url.path = base.path.slice();\n          url.query = base.query;\n          url.fragment = '';\n          state = FRAGMENT;\n        } else {\n          url.username = base.username;\n          url.password = base.password;\n          url.host = base.host;\n          url.port = base.port;\n          url.path = base.path.slice();\n          url.path.pop();\n          state = PATH;\n          continue;\n        } break;\n\n      case RELATIVE_SLASH:\n        if (isSpecial(url) && (char == '/' || char == '\\\\')) {\n          state = SPECIAL_AUTHORITY_IGNORE_SLASHES;\n        } else if (char == '/') {\n          state = AUTHORITY;\n        } else {\n          url.username = base.username;\n          url.password = base.password;\n          url.host = base.host;\n          url.port = base.port;\n          state = PATH;\n          continue;\n        } break;\n\n      case SPECIAL_AUTHORITY_SLASHES:\n        state = SPECIAL_AUTHORITY_IGNORE_SLASHES;\n        if (char != '/' || buffer.charAt(pointer + 1) != '/') continue;\n        pointer++;\n        break;\n\n      case SPECIAL_AUTHORITY_IGNORE_SLASHES:\n        if (char != '/' && char != '\\\\') {\n          state = AUTHORITY;\n          continue;\n        } break;\n\n      case AUTHORITY:\n        if (char == '@') {\n          if (seenAt) buffer = '%40' + buffer;\n          seenAt = true;\n          bufferCodePoints = arrayFrom(buffer);\n          for (var i = 0; i < bufferCodePoints.length; i++) {\n            var codePoint = bufferCodePoints[i];\n            if (codePoint == ':' && !seenPasswordToken) {\n              seenPasswordToken = true;\n              continue;\n            }\n            var encodedCodePoints = percentEncode(codePoint, userinfoPercentEncodeSet);\n            if (seenPasswordToken) url.password += encodedCodePoints;\n            else url.username += encodedCodePoints;\n          }\n          buffer = '';\n        } else if (\n          char == EOF || char == '/' || char == '?' || char == '#' ||\n          (char == '\\\\' && isSpecial(url))\n        ) {\n          if (seenAt && buffer == '') return INVALID_AUTHORITY;\n          pointer -= arrayFrom(buffer).length + 1;\n          buffer = '';\n          state = HOST;\n        } else buffer += char;\n        break;\n\n      case HOST:\n      case HOSTNAME:\n        if (stateOverride && url.scheme == 'file') {\n          state = FILE_HOST;\n          continue;\n        } else if (char == ':' && !seenBracket) {\n          if (buffer == '') return INVALID_HOST;\n          failure = parseHost(url, buffer);\n          if (failure) return failure;\n          buffer = '';\n          state = PORT;\n          if (stateOverride == HOSTNAME) return;\n        } else if (\n          char == EOF || char == '/' || char == '?' || char == '#' ||\n          (char == '\\\\' && isSpecial(url))\n        ) {\n          if (isSpecial(url) && buffer == '') return INVALID_HOST;\n          if (stateOverride && buffer == '' && (includesCredentials(url) || url.port !== null)) return;\n          failure = parseHost(url, buffer);\n          if (failure) return failure;\n          buffer = '';\n          state = PATH_START;\n          if (stateOverride) return;\n          continue;\n        } else {\n          if (char == '[') seenBracket = true;\n          else if (char == ']') seenBracket = false;\n          buffer += char;\n        } break;\n\n      case PORT:\n        if (DIGIT.test(char)) {\n          buffer += char;\n        } else if (\n          char == EOF || char == '/' || char == '?' || char == '#' ||\n          (char == '\\\\' && isSpecial(url)) ||\n          stateOverride\n        ) {\n          if (buffer != '') {\n            var port = parseInt(buffer, 10);\n            if (port > 0xFFFF) return INVALID_PORT;\n            url.port = (isSpecial(url) && port === specialSchemes[url.scheme]) ? null : port;\n            buffer = '';\n          }\n          if (stateOverride) return;\n          state = PATH_START;\n          continue;\n        } else return INVALID_PORT;\n        break;\n\n      case FILE:\n        url.scheme = 'file';\n        if (char == '/' || char == '\\\\') state = FILE_SLASH;\n        else if (base && base.scheme == 'file') {\n          if (char == EOF) {\n            url.host = base.host;\n            url.path = base.path.slice();\n            url.query = base.query;\n          } else if (char == '?') {\n            url.host = base.host;\n            url.path = base.path.slice();\n            url.query = '';\n            state = QUERY;\n          } else if (char == '#') {\n            url.host = base.host;\n            url.path = base.path.slice();\n            url.query = base.query;\n            url.fragment = '';\n            state = FRAGMENT;\n          } else {\n            if (!startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {\n              url.host = base.host;\n              url.path = base.path.slice();\n              shortenURLsPath(url);\n            }\n            state = PATH;\n            continue;\n          }\n        } else {\n          state = PATH;\n          continue;\n        } break;\n\n      case FILE_SLASH:\n        if (char == '/' || char == '\\\\') {\n          state = FILE_HOST;\n          break;\n        }\n        if (base && base.scheme == 'file' && !startsWithWindowsDriveLetter(codePoints.slice(pointer).join(''))) {\n          if (isWindowsDriveLetter(base.path[0], true)) url.path.push(base.path[0]);\n          else url.host = base.host;\n        }\n        state = PATH;\n        continue;\n\n      case FILE_HOST:\n        if (char == EOF || char == '/' || char == '\\\\' || char == '?' || char == '#') {\n          if (!stateOverride && isWindowsDriveLetter(buffer)) {\n            state = PATH;\n          } else if (buffer == '') {\n            url.host = '';\n            if (stateOverride) return;\n            state = PATH_START;\n          } else {\n            failure = parseHost(url, buffer);\n            if (failure) return failure;\n            if (url.host == 'localhost') url.host = '';\n            if (stateOverride) return;\n            buffer = '';\n            state = PATH_START;\n          } continue;\n        } else buffer += char;\n        break;\n\n      case PATH_START:\n        if (isSpecial(url)) {\n          state = PATH;\n          if (char != '/' && char != '\\\\') continue;\n        } else if (!stateOverride && char == '?') {\n          url.query = '';\n          state = QUERY;\n        } else if (!stateOverride && char == '#') {\n          url.fragment = '';\n          state = FRAGMENT;\n        } else if (char != EOF) {\n          state = PATH;\n          if (char != '/') continue;\n        } break;\n\n      case PATH:\n        if (\n          char == EOF || char == '/' ||\n          (char == '\\\\' && isSpecial(url)) ||\n          (!stateOverride && (char == '?' || char == '#'))\n        ) {\n          if (isDoubleDot(buffer)) {\n            shortenURLsPath(url);\n            if (char != '/' && !(char == '\\\\' && isSpecial(url))) {\n              url.path.push('');\n            }\n          } else if (isSingleDot(buffer)) {\n            if (char != '/' && !(char == '\\\\' && isSpecial(url))) {\n              url.path.push('');\n            }\n          } else {\n            if (url.scheme == 'file' && !url.path.length && isWindowsDriveLetter(buffer)) {\n              if (url.host) url.host = '';\n              buffer = buffer.charAt(0) + ':'; // normalize windows drive letter\n            }\n            url.path.push(buffer);\n          }\n          buffer = '';\n          if (url.scheme == 'file' && (char == EOF || char == '?' || char == '#')) {\n            while (url.path.length > 1 && url.path[0] === '') {\n              url.path.shift();\n            }\n          }\n          if (char == '?') {\n            url.query = '';\n            state = QUERY;\n          } else if (char == '#') {\n            url.fragment = '';\n            state = FRAGMENT;\n          }\n        } else {\n          buffer += percentEncode(char, pathPercentEncodeSet);\n        } break;\n\n      case CANNOT_BE_A_BASE_URL_PATH:\n        if (char == '?') {\n          url.query = '';\n          state = QUERY;\n        } else if (char == '#') {\n          url.fragment = '';\n          state = FRAGMENT;\n        } else if (char != EOF) {\n          url.path[0] += percentEncode(char, C0ControlPercentEncodeSet);\n        } break;\n\n      case QUERY:\n        if (!stateOverride && char == '#') {\n          url.fragment = '';\n          state = FRAGMENT;\n        } else if (char != EOF) {\n          if (char == \"'\" && isSpecial(url)) url.query += '%27';\n          else if (char == '#') url.query += '%23';\n          else url.query += percentEncode(char, C0ControlPercentEncodeSet);\n        } break;\n\n      case FRAGMENT:\n        if (char != EOF) url.fragment += percentEncode(char, fragmentPercentEncodeSet);\n        break;\n    }\n\n    pointer++;\n  }\n};\n\n// `URL` constructor\n// https://url.spec.whatwg.org/#url-class\nvar URLConstructor = function URL(url /* , base */) {\n  var that = anInstance(this, URLConstructor, 'URL');\n  var base = arguments.length > 1 ? arguments[1] : undefined;\n  var urlString = String(url);\n  var state = setInternalState(that, { type: 'URL' });\n  var baseState, failure;\n  if (base !== undefined) {\n    if (base instanceof URLConstructor) baseState = getInternalURLState(base);\n    else {\n      failure = parseURL(baseState = {}, String(base));\n      if (failure) throw TypeError(failure);\n    }\n  }\n  failure = parseURL(state, urlString, null, baseState);\n  if (failure) throw TypeError(failure);\n  var searchParams = state.searchParams = new URLSearchParams();\n  var searchParamsState = getInternalSearchParamsState(searchParams);\n  searchParamsState.updateSearchParams(state.query);\n  searchParamsState.updateURL = function () {\n    state.query = String(searchParams) || null;\n  };\n  if (!DESCRIPTORS) {\n    that.href = serializeURL.call(that);\n    that.origin = getOrigin.call(that);\n    that.protocol = getProtocol.call(that);\n    that.username = getUsername.call(that);\n    that.password = getPassword.call(that);\n    that.host = getHost.call(that);\n    that.hostname = getHostname.call(that);\n    that.port = getPort.call(that);\n    that.pathname = getPathname.call(that);\n    that.search = getSearch.call(that);\n    that.searchParams = getSearchParams.call(that);\n    that.hash = getHash.call(that);\n  }\n};\n\nvar URLPrototype = URLConstructor.prototype;\n\nvar serializeURL = function () {\n  var url = getInternalURLState(this);\n  var scheme = url.scheme;\n  var username = url.username;\n  var password = url.password;\n  var host = url.host;\n  var port = url.port;\n  var path = url.path;\n  var query = url.query;\n  var fragment = url.fragment;\n  var output = scheme + ':';\n  if (host !== null) {\n    output += '//';\n    if (includesCredentials(url)) {\n      output += username + (password ? ':' + password : '') + '@';\n    }\n    output += serializeHost(host);\n    if (port !== null) output += ':' + port;\n  } else if (scheme == 'file') output += '//';\n  output += url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';\n  if (query !== null) output += '?' + query;\n  if (fragment !== null) output += '#' + fragment;\n  return output;\n};\n\nvar getOrigin = function () {\n  var url = getInternalURLState(this);\n  var scheme = url.scheme;\n  var port = url.port;\n  if (scheme == 'blob') try {\n    return new URL(scheme.path[0]).origin;\n  } catch (error) {\n    return 'null';\n  }\n  if (scheme == 'file' || !isSpecial(url)) return 'null';\n  return scheme + '://' + serializeHost(url.host) + (port !== null ? ':' + port : '');\n};\n\nvar getProtocol = function () {\n  return getInternalURLState(this).scheme + ':';\n};\n\nvar getUsername = function () {\n  return getInternalURLState(this).username;\n};\n\nvar getPassword = function () {\n  return getInternalURLState(this).password;\n};\n\nvar getHost = function () {\n  var url = getInternalURLState(this);\n  var host = url.host;\n  var port = url.port;\n  return host === null ? ''\n    : port === null ? serializeHost(host)\n    : serializeHost(host) + ':' + port;\n};\n\nvar getHostname = function () {\n  var host = getInternalURLState(this).host;\n  return host === null ? '' : serializeHost(host);\n};\n\nvar getPort = function () {\n  var port = getInternalURLState(this).port;\n  return port === null ? '' : String(port);\n};\n\nvar getPathname = function () {\n  var url = getInternalURLState(this);\n  var path = url.path;\n  return url.cannotBeABaseURL ? path[0] : path.length ? '/' + path.join('/') : '';\n};\n\nvar getSearch = function () {\n  var query = getInternalURLState(this).query;\n  return query ? '?' + query : '';\n};\n\nvar getSearchParams = function () {\n  return getInternalURLState(this).searchParams;\n};\n\nvar getHash = function () {\n  var fragment = getInternalURLState(this).fragment;\n  return fragment ? '#' + fragment : '';\n};\n\nvar accessorDescriptor = function (getter, setter) {\n  return { get: getter, set: setter, configurable: true, enumerable: true };\n};\n\nif (DESCRIPTORS) {\n  defineProperties(URLPrototype, {\n    // `URL.prototype.href` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-href\n    href: accessorDescriptor(serializeURL, function (href) {\n      var url = getInternalURLState(this);\n      var urlString = String(href);\n      var failure = parseURL(url, urlString);\n      if (failure) throw TypeError(failure);\n      getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);\n    }),\n    // `URL.prototype.origin` getter\n    // https://url.spec.whatwg.org/#dom-url-origin\n    origin: accessorDescriptor(getOrigin),\n    // `URL.prototype.protocol` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-protocol\n    protocol: accessorDescriptor(getProtocol, function (protocol) {\n      var url = getInternalURLState(this);\n      parseURL(url, String(protocol) + ':', SCHEME_START);\n    }),\n    // `URL.prototype.username` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-username\n    username: accessorDescriptor(getUsername, function (username) {\n      var url = getInternalURLState(this);\n      var codePoints = arrayFrom(String(username));\n      if (cannotHaveUsernamePasswordPort(url)) return;\n      url.username = '';\n      for (var i = 0; i < codePoints.length; i++) {\n        url.username += percentEncode(codePoints[i], userinfoPercentEncodeSet);\n      }\n    }),\n    // `URL.prototype.password` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-password\n    password: accessorDescriptor(getPassword, function (password) {\n      var url = getInternalURLState(this);\n      var codePoints = arrayFrom(String(password));\n      if (cannotHaveUsernamePasswordPort(url)) return;\n      url.password = '';\n      for (var i = 0; i < codePoints.length; i++) {\n        url.password += percentEncode(codePoints[i], userinfoPercentEncodeSet);\n      }\n    }),\n    // `URL.prototype.host` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-host\n    host: accessorDescriptor(getHost, function (host) {\n      var url = getInternalURLState(this);\n      if (url.cannotBeABaseURL) return;\n      parseURL(url, String(host), HOST);\n    }),\n    // `URL.prototype.hostname` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-hostname\n    hostname: accessorDescriptor(getHostname, function (hostname) {\n      var url = getInternalURLState(this);\n      if (url.cannotBeABaseURL) return;\n      parseURL(url, String(hostname), HOSTNAME);\n    }),\n    // `URL.prototype.port` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-port\n    port: accessorDescriptor(getPort, function (port) {\n      var url = getInternalURLState(this);\n      if (cannotHaveUsernamePasswordPort(url)) return;\n      port = String(port);\n      if (port == '') url.port = null;\n      else parseURL(url, port, PORT);\n    }),\n    // `URL.prototype.pathname` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-pathname\n    pathname: accessorDescriptor(getPathname, function (pathname) {\n      var url = getInternalURLState(this);\n      if (url.cannotBeABaseURL) return;\n      url.path = [];\n      parseURL(url, pathname + '', PATH_START);\n    }),\n    // `URL.prototype.search` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-search\n    search: accessorDescriptor(getSearch, function (search) {\n      var url = getInternalURLState(this);\n      search = String(search);\n      if (search == '') {\n        url.query = null;\n      } else {\n        if ('?' == search.charAt(0)) search = search.slice(1);\n        url.query = '';\n        parseURL(url, search, QUERY);\n      }\n      getInternalSearchParamsState(url.searchParams).updateSearchParams(url.query);\n    }),\n    // `URL.prototype.searchParams` getter\n    // https://url.spec.whatwg.org/#dom-url-searchparams\n    searchParams: accessorDescriptor(getSearchParams),\n    // `URL.prototype.hash` accessors pair\n    // https://url.spec.whatwg.org/#dom-url-hash\n    hash: accessorDescriptor(getHash, function (hash) {\n      var url = getInternalURLState(this);\n      hash = String(hash);\n      if (hash == '') {\n        url.fragment = null;\n        return;\n      }\n      if ('#' == hash.charAt(0)) hash = hash.slice(1);\n      url.fragment = '';\n      parseURL(url, hash, FRAGMENT);\n    })\n  });\n}\n\n// `URL.prototype.toJSON` method\n// https://url.spec.whatwg.org/#dom-url-tojson\nredefine(URLPrototype, 'toJSON', function toJSON() {\n  return serializeURL.call(this);\n}, { enumerable: true });\n\n// `URL.prototype.toString` method\n// https://url.spec.whatwg.org/#URL-stringification-behavior\nredefine(URLPrototype, 'toString', function toString() {\n  return serializeURL.call(this);\n}, { enumerable: true });\n\nif (NativeURL) {\n  var nativeCreateObjectURL = NativeURL.createObjectURL;\n  var nativeRevokeObjectURL = NativeURL.revokeObjectURL;\n  // `URL.createObjectURL` method\n  // https://developer.mozilla.org/en-US/docs/Web/API/URL/createObjectURL\n  // eslint-disable-next-line no-unused-vars\n  if (nativeCreateObjectURL) redefine(URLConstructor, 'createObjectURL', function createObjectURL(blob) {\n    return nativeCreateObjectURL.apply(NativeURL, arguments);\n  });\n  // `URL.revokeObjectURL` method\n  // https://developer.mozilla.org/en-US/docs/Web/API/URL/revokeObjectURL\n  // eslint-disable-next-line no-unused-vars\n  if (nativeRevokeObjectURL) redefine(URLConstructor, 'revokeObjectURL', function revokeObjectURL(url) {\n    return nativeRevokeObjectURL.apply(NativeURL, arguments);\n  });\n}\n\nsetToStringTag(URLConstructor, 'URL');\n\n$({ global: true, forced: !USE_NATIVE_URL, sham: !DESCRIPTORS }, {\n  URL: URLConstructor\n});\n","var fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar IS_PURE = require('../internals/is-pure');\n\nvar ITERATOR = wellKnownSymbol('iterator');\n\nmodule.exports = !fails(function () {\n  var url = new URL('b?a=1&b=2&c=3', 'http://a');\n  var searchParams = url.searchParams;\n  var result = '';\n  url.pathname = 'c%20d';\n  searchParams.forEach(function (value, key) {\n    searchParams['delete']('b');\n    result += key + value;\n  });\n  return (IS_PURE && !url.toJSON)\n    || !searchParams.sort\n    || url.href !== 'http://a/c%20d?a=1&c=3'\n    || searchParams.get('c') !== '3'\n    || String(new URLSearchParams('?a=1')) !== 'a=1'\n    || !searchParams[ITERATOR]\n    // throws in Edge\n    || new URL('https://a@b').username !== 'a'\n    || new URLSearchParams(new URLSearchParams('a=b')).get('a') !== 'b'\n    // not punycoded in Edge\n    || new URL('http://тест').host !== 'xn--e1aybc'\n    // not escaped in Chrome 62-\n    || new URL('http://a#б').hash !== '#%D0%B1'\n    // fails in Chrome 66-\n    || result !== 'a1c3'\n    // throws in Safari\n    || new URL('http://x', undefined).host !== 'x';\n});\n","'use strict';\n// based on https://github.com/bestiejs/punycode.js/blob/master/punycode.js\nvar maxInt = 2147483647; // aka. 0x7FFFFFFF or 2^31-1\nvar base = 36;\nvar tMin = 1;\nvar tMax = 26;\nvar skew = 38;\nvar damp = 700;\nvar initialBias = 72;\nvar initialN = 128; // 0x80\nvar delimiter = '-'; // '\\x2D'\nvar regexNonASCII = /[^\\0-\\u007E]/; // non-ASCII chars\nvar regexSeparators = /[.\\u3002\\uFF0E\\uFF61]/g; // RFC 3490 separators\nvar OVERFLOW_ERROR = 'Overflow: input needs wider integers to process';\nvar baseMinusTMin = base - tMin;\nvar floor = Math.floor;\nvar stringFromCharCode = String.fromCharCode;\n\n/**\n * Creates an array containing the numeric code points of each Unicode\n * character in the string. While JavaScript uses UCS-2 internally,\n * this function will convert a pair of surrogate halves (each of which\n * UCS-2 exposes as separate characters) into a single code point,\n * matching UTF-16.\n */\nvar ucs2decode = function (string) {\n  var output = [];\n  var counter = 0;\n  var length = string.length;\n  while (counter < length) {\n    var value = string.charCodeAt(counter++);\n    if (value >= 0xD800 && value <= 0xDBFF && counter < length) {\n      // It's a high surrogate, and there is a next character.\n      var extra = string.charCodeAt(counter++);\n      if ((extra & 0xFC00) == 0xDC00) { // Low surrogate.\n        output.push(((value & 0x3FF) << 10) + (extra & 0x3FF) + 0x10000);\n      } else {\n        // It's an unmatched surrogate; only append this code unit, in case the\n        // next code unit is the high surrogate of a surrogate pair.\n        output.push(value);\n        counter--;\n      }\n    } else {\n      output.push(value);\n    }\n  }\n  return output;\n};\n\n/**\n * Converts a digit/integer into a basic code point.\n */\nvar digitToBasic = function (digit) {\n  //  0..25 map to ASCII a..z or A..Z\n  // 26..35 map to ASCII 0..9\n  return digit + 22 + 75 * (digit < 26);\n};\n\n/**\n * Bias adaptation function as per section 3.4 of RFC 3492.\n * https://tools.ietf.org/html/rfc3492#section-3.4\n */\nvar adapt = function (delta, numPoints, firstTime) {\n  var k = 0;\n  delta = firstTime ? floor(delta / damp) : delta >> 1;\n  delta += floor(delta / numPoints);\n  for (; delta > baseMinusTMin * tMax >> 1; k += base) {\n    delta = floor(delta / baseMinusTMin);\n  }\n  return floor(k + (baseMinusTMin + 1) * delta / (delta + skew));\n};\n\n/**\n * Converts a string of Unicode symbols (e.g. a domain name label) to a\n * Punycode string of ASCII-only symbols.\n */\n// eslint-disable-next-line  max-statements\nvar encode = function (input) {\n  var output = [];\n\n  // Convert the input in UCS-2 to an array of Unicode code points.\n  input = ucs2decode(input);\n\n  // Cache the length.\n  var inputLength = input.length;\n\n  // Initialize the state.\n  var n = initialN;\n  var delta = 0;\n  var bias = initialBias;\n  var i, currentValue;\n\n  // Handle the basic code points.\n  for (i = 0; i < input.length; i++) {\n    currentValue = input[i];\n    if (currentValue < 0x80) {\n      output.push(stringFromCharCode(currentValue));\n    }\n  }\n\n  var basicLength = output.length; // number of basic code points.\n  var handledCPCount = basicLength; // number of code points that have been handled;\n\n  // Finish the basic string with a delimiter unless it's empty.\n  if (basicLength) {\n    output.push(delimiter);\n  }\n\n  // Main encoding loop:\n  while (handledCPCount < inputLength) {\n    // All non-basic code points < n have been handled already. Find the next larger one:\n    var m = maxInt;\n    for (i = 0; i < input.length; i++) {\n      currentValue = input[i];\n      if (currentValue >= n && currentValue < m) {\n        m = currentValue;\n      }\n    }\n\n    // Increase `delta` enough to advance the decoder's <n,i> state to <m,0>, but guard against overflow.\n    var handledCPCountPlusOne = handledCPCount + 1;\n    if (m - n > floor((maxInt - delta) / handledCPCountPlusOne)) {\n      throw RangeError(OVERFLOW_ERROR);\n    }\n\n    delta += (m - n) * handledCPCountPlusOne;\n    n = m;\n\n    for (i = 0; i < input.length; i++) {\n      currentValue = input[i];\n      if (currentValue < n && ++delta > maxInt) {\n        throw RangeError(OVERFLOW_ERROR);\n      }\n      if (currentValue == n) {\n        // Represent delta as a generalized variable-length integer.\n        var q = delta;\n        for (var k = base; /* no condition */; k += base) {\n          var t = k <= bias ? tMin : (k >= bias + tMax ? tMax : k - bias);\n          if (q < t) break;\n          var qMinusT = q - t;\n          var baseMinusT = base - t;\n          output.push(stringFromCharCode(digitToBasic(t + qMinusT % baseMinusT)));\n          q = floor(qMinusT / baseMinusT);\n        }\n\n        output.push(stringFromCharCode(digitToBasic(q)));\n        bias = adapt(delta, handledCPCountPlusOne, handledCPCount == basicLength);\n        delta = 0;\n        ++handledCPCount;\n      }\n    }\n\n    ++delta;\n    ++n;\n  }\n  return output.join('');\n};\n\nmodule.exports = function (input) {\n  var encoded = [];\n  var labels = input.toLowerCase().replace(regexSeparators, '\\u002E').split('.');\n  var i, label;\n  for (i = 0; i < labels.length; i++) {\n    label = labels[i];\n    encoded.push(regexNonASCII.test(label) ? 'xn--' + encode(label) : label);\n  }\n  return encoded.join('.');\n};\n","'use strict';\n// TODO: in core-js@4, move /modules/ dependencies to public entries for better optimization by tools like `preset-env`\nrequire('../modules/es.array.iterator');\nvar $ = require('../internals/export');\nvar getBuiltIn = require('../internals/get-built-in');\nvar USE_NATIVE_URL = require('../internals/native-url');\nvar redefine = require('../internals/redefine');\nvar redefineAll = require('../internals/redefine-all');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar createIteratorConstructor = require('../internals/create-iterator-constructor');\nvar InternalStateModule = require('../internals/internal-state');\nvar anInstance = require('../internals/an-instance');\nvar hasOwn = require('../internals/has');\nvar bind = require('../internals/function-bind-context');\nvar classof = require('../internals/classof');\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar create = require('../internals/object-create');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar getIterator = require('../internals/get-iterator');\nvar getIteratorMethod = require('../internals/get-iterator-method');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar $fetch = getBuiltIn('fetch');\nvar Headers = getBuiltIn('Headers');\nvar ITERATOR = wellKnownSymbol('iterator');\nvar URL_SEARCH_PARAMS = 'URLSearchParams';\nvar URL_SEARCH_PARAMS_ITERATOR = URL_SEARCH_PARAMS + 'Iterator';\nvar setInternalState = InternalStateModule.set;\nvar getInternalParamsState = InternalStateModule.getterFor(URL_SEARCH_PARAMS);\nvar getInternalIteratorState = InternalStateModule.getterFor(URL_SEARCH_PARAMS_ITERATOR);\n\nvar plus = /\\+/g;\nvar sequences = Array(4);\n\nvar percentSequence = function (bytes) {\n  return sequences[bytes - 1] || (sequences[bytes - 1] = RegExp('((?:%[\\\\da-f]{2}){' + bytes + '})', 'gi'));\n};\n\nvar percentDecode = function (sequence) {\n  try {\n    return decodeURIComponent(sequence);\n  } catch (error) {\n    return sequence;\n  }\n};\n\nvar deserialize = function (it) {\n  var result = it.replace(plus, ' ');\n  var bytes = 4;\n  try {\n    return decodeURIComponent(result);\n  } catch (error) {\n    while (bytes) {\n      result = result.replace(percentSequence(bytes--), percentDecode);\n    }\n    return result;\n  }\n};\n\nvar find = /[!'()~]|%20/g;\n\nvar replace = {\n  '!': '%21',\n  \"'\": '%27',\n  '(': '%28',\n  ')': '%29',\n  '~': '%7E',\n  '%20': '+'\n};\n\nvar replacer = function (match) {\n  return replace[match];\n};\n\nvar serialize = function (it) {\n  return encodeURIComponent(it).replace(find, replacer);\n};\n\nvar parseSearchParams = function (result, query) {\n  if (query) {\n    var attributes = query.split('&');\n    var index = 0;\n    var attribute, entry;\n    while (index < attributes.length) {\n      attribute = attributes[index++];\n      if (attribute.length) {\n        entry = attribute.split('=');\n        result.push({\n          key: deserialize(entry.shift()),\n          value: deserialize(entry.join('='))\n        });\n      }\n    }\n  }\n};\n\nvar updateSearchParams = function (query) {\n  this.entries.length = 0;\n  parseSearchParams(this.entries, query);\n};\n\nvar validateArgumentsLength = function (passed, required) {\n  if (passed < required) throw TypeError('Not enough arguments');\n};\n\nvar URLSearchParamsIterator = createIteratorConstructor(function Iterator(params, kind) {\n  setInternalState(this, {\n    type: URL_SEARCH_PARAMS_ITERATOR,\n    iterator: getIterator(getInternalParamsState(params).entries),\n    kind: kind\n  });\n}, 'Iterator', function next() {\n  var state = getInternalIteratorState(this);\n  var kind = state.kind;\n  var step = state.iterator.next();\n  var entry = step.value;\n  if (!step.done) {\n    step.value = kind === 'keys' ? entry.key : kind === 'values' ? entry.value : [entry.key, entry.value];\n  } return step;\n});\n\n// `URLSearchParams` constructor\n// https://url.spec.whatwg.org/#interface-urlsearchparams\nvar URLSearchParamsConstructor = function URLSearchParams(/* init */) {\n  anInstance(this, URLSearchParamsConstructor, URL_SEARCH_PARAMS);\n  var init = arguments.length > 0 ? arguments[0] : undefined;\n  var that = this;\n  var entries = [];\n  var iteratorMethod, iterator, next, step, entryIterator, entryNext, first, second, key;\n\n  setInternalState(that, {\n    type: URL_SEARCH_PARAMS,\n    entries: entries,\n    updateURL: function () { /* empty */ },\n    updateSearchParams: updateSearchParams\n  });\n\n  if (init !== undefined) {\n    if (isObject(init)) {\n      iteratorMethod = getIteratorMethod(init);\n      if (typeof iteratorMethod === 'function') {\n        iterator = iteratorMethod.call(init);\n        next = iterator.next;\n        while (!(step = next.call(iterator)).done) {\n          entryIterator = getIterator(anObject(step.value));\n          entryNext = entryIterator.next;\n          if (\n            (first = entryNext.call(entryIterator)).done ||\n            (second = entryNext.call(entryIterator)).done ||\n            !entryNext.call(entryIterator).done\n          ) throw TypeError('Expected sequence with length 2');\n          entries.push({ key: first.value + '', value: second.value + '' });\n        }\n      } else for (key in init) if (hasOwn(init, key)) entries.push({ key: key, value: init[key] + '' });\n    } else {\n      parseSearchParams(entries, typeof init === 'string' ? init.charAt(0) === '?' ? init.slice(1) : init : init + '');\n    }\n  }\n};\n\nvar URLSearchParamsPrototype = URLSearchParamsConstructor.prototype;\n\nredefineAll(URLSearchParamsPrototype, {\n  // `URLSearchParams.prototype.appent` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-append\n  append: function append(name, value) {\n    validateArgumentsLength(arguments.length, 2);\n    var state = getInternalParamsState(this);\n    state.entries.push({ key: name + '', value: value + '' });\n    state.updateURL();\n  },\n  // `URLSearchParams.prototype.delete` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-delete\n  'delete': function (name) {\n    validateArgumentsLength(arguments.length, 1);\n    var state = getInternalParamsState(this);\n    var entries = state.entries;\n    var key = name + '';\n    var index = 0;\n    while (index < entries.length) {\n      if (entries[index].key === key) entries.splice(index, 1);\n      else index++;\n    }\n    state.updateURL();\n  },\n  // `URLSearchParams.prototype.get` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-get\n  get: function get(name) {\n    validateArgumentsLength(arguments.length, 1);\n    var entries = getInternalParamsState(this).entries;\n    var key = name + '';\n    var index = 0;\n    for (; index < entries.length; index++) {\n      if (entries[index].key === key) return entries[index].value;\n    }\n    return null;\n  },\n  // `URLSearchParams.prototype.getAll` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-getall\n  getAll: function getAll(name) {\n    validateArgumentsLength(arguments.length, 1);\n    var entries = getInternalParamsState(this).entries;\n    var key = name + '';\n    var result = [];\n    var index = 0;\n    for (; index < entries.length; index++) {\n      if (entries[index].key === key) result.push(entries[index].value);\n    }\n    return result;\n  },\n  // `URLSearchParams.prototype.has` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-has\n  has: function has(name) {\n    validateArgumentsLength(arguments.length, 1);\n    var entries = getInternalParamsState(this).entries;\n    var key = name + '';\n    var index = 0;\n    while (index < entries.length) {\n      if (entries[index++].key === key) return true;\n    }\n    return false;\n  },\n  // `URLSearchParams.prototype.set` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-set\n  set: function set(name, value) {\n    validateArgumentsLength(arguments.length, 1);\n    var state = getInternalParamsState(this);\n    var entries = state.entries;\n    var found = false;\n    var key = name + '';\n    var val = value + '';\n    var index = 0;\n    var entry;\n    for (; index < entries.length; index++) {\n      entry = entries[index];\n      if (entry.key === key) {\n        if (found) entries.splice(index--, 1);\n        else {\n          found = true;\n          entry.value = val;\n        }\n      }\n    }\n    if (!found) entries.push({ key: key, value: val });\n    state.updateURL();\n  },\n  // `URLSearchParams.prototype.sort` method\n  // https://url.spec.whatwg.org/#dom-urlsearchparams-sort\n  sort: function sort() {\n    var state = getInternalParamsState(this);\n    var entries = state.entries;\n    // Array#sort is not stable in some engines\n    var slice = entries.slice();\n    var entry, entriesIndex, sliceIndex;\n    entries.length = 0;\n    for (sliceIndex = 0; sliceIndex < slice.length; sliceIndex++) {\n      entry = slice[sliceIndex];\n      for (entriesIndex = 0; entriesIndex < sliceIndex; entriesIndex++) {\n        if (entries[entriesIndex].key > entry.key) {\n          entries.splice(entriesIndex, 0, entry);\n          break;\n        }\n      }\n      if (entriesIndex === sliceIndex) entries.push(entry);\n    }\n    state.updateURL();\n  },\n  // `URLSearchParams.prototype.forEach` method\n  forEach: function forEach(callback /* , thisArg */) {\n    var entries = getInternalParamsState(this).entries;\n    var boundFunction = bind(callback, arguments.length > 1 ? arguments[1] : undefined, 3);\n    var index = 0;\n    var entry;\n    while (index < entries.length) {\n      entry = entries[index++];\n      boundFunction(entry.value, entry.key, this);\n    }\n  },\n  // `URLSearchParams.prototype.keys` method\n  keys: function keys() {\n    return new URLSearchParamsIterator(this, 'keys');\n  },\n  // `URLSearchParams.prototype.values` method\n  values: function values() {\n    return new URLSearchParamsIterator(this, 'values');\n  },\n  // `URLSearchParams.prototype.entries` method\n  entries: function entries() {\n    return new URLSearchParamsIterator(this, 'entries');\n  }\n}, { enumerable: true });\n\n// `URLSearchParams.prototype[@@iterator]` method\nredefine(URLSearchParamsPrototype, ITERATOR, URLSearchParamsPrototype.entries);\n\n// `URLSearchParams.prototype.toString` method\n// https://url.spec.whatwg.org/#urlsearchparams-stringification-behavior\nredefine(URLSearchParamsPrototype, 'toString', function toString() {\n  var entries = getInternalParamsState(this).entries;\n  var result = [];\n  var index = 0;\n  var entry;\n  while (index < entries.length) {\n    entry = entries[index++];\n    result.push(serialize(entry.key) + '=' + serialize(entry.value));\n  } return result.join('&');\n}, { enumerable: true });\n\nsetToStringTag(URLSearchParamsConstructor, URL_SEARCH_PARAMS);\n\n$({ global: true, forced: !USE_NATIVE_URL }, {\n  URLSearchParams: URLSearchParamsConstructor\n});\n\n// Wrap `fetch` for correct work with polyfilled `URLSearchParams`\n// https://github.com/zloirock/core-js/issues/674\nif (!USE_NATIVE_URL && typeof $fetch == 'function' && typeof Headers == 'function') {\n  $({ global: true, enumerable: true, forced: true }, {\n    fetch: function fetch(input /* , init */) {\n      var args = [input];\n      var init, body, headers;\n      if (arguments.length > 1) {\n        init = arguments[1];\n        if (isObject(init)) {\n          body = init.body;\n          if (classof(body) === URL_SEARCH_PARAMS) {\n            headers = init.headers ? new Headers(init.headers) : new Headers();\n            if (!headers.has('content-type')) {\n              headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');\n            }\n            init = create(init, {\n              body: createPropertyDescriptor(0, String(body)),\n              headers: createPropertyDescriptor(0, headers)\n            });\n          }\n        }\n        args.push(init);\n      } return $fetch.apply(this, args);\n    }\n  });\n}\n\nmodule.exports = {\n  URLSearchParams: URLSearchParamsConstructor,\n  getState: getInternalParamsState\n};\n","var anObject = require('../internals/an-object');\nvar getIteratorMethod = require('../internals/get-iterator-method');\n\nmodule.exports = function (it) {\n  var iteratorMethod = getIteratorMethod(it);\n  if (typeof iteratorMethod != 'function') {\n    throw TypeError(String(it) + ' is not iterable');\n  } return anObject(iteratorMethod.call(it));\n};\n","'use strict';\nvar $ = require('../internals/export');\n\n// `URL.prototype.toJSON` method\n// https://url.spec.whatwg.org/#dom-url-tojson\n$({ target: 'URL', proto: true, enumerable: true }, {\n  toJSON: function toJSON() {\n    return URL.prototype.toString.call(this);\n  }\n});\n","/**\n * web-streams-polyfill v2.1.1\n */\n(function (global, factory) {\n    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :\n    typeof define === 'function' && define.amd ? define(['exports'], factory) :\n    (global = global || self, factory(global.WebStreamsPolyfill = {}));\n}(this, (function (exports) { 'use strict';\n\n    /// <reference lib=\"es2015.symbol\" />\n    var SymbolPolyfill = typeof Symbol === 'function' && typeof Symbol.iterator === 'symbol' ?\n        Symbol :\n        function (description) { return \"Symbol(\" + description + \")\"; };\n\n    /// <reference lib=\"dom\" />\n    function noop() {\n        // do nothing\n    }\n\n    /// <reference lib=\"es2015.core\" />\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isNaN#Polyfill\n    var NumberIsNaN = Number.isNaN || function (x) {\n        // eslint-disable-next-line no-self-compare\n        return x !== x;\n    };\n\n    var rethrowAssertionErrorRejection =  noop;\n\n    function typeIsObject(x) {\n        return (typeof x === 'object' && x !== null) || typeof x === 'function';\n    }\n    function createArrayFromList(elements) {\n        // We use arrays to represent lists, so this is basically a no-op.\n        // Do a slice though just in case we happen to depend on the unique-ness.\n        return elements.slice();\n    }\n    function ArrayBufferCopy(dest, destOffset, src, srcOffset, n) {\n        new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);\n    }\n    function IsFiniteNonNegativeNumber(v) {\n        if (IsNonNegativeNumber(v) === false) {\n            return false;\n        }\n        if (v === Infinity) {\n            return false;\n        }\n        return true;\n    }\n    function IsNonNegativeNumber(v) {\n        if (typeof v !== 'number') {\n            return false;\n        }\n        if (NumberIsNaN(v)) {\n            return false;\n        }\n        if (v < 0) {\n            return false;\n        }\n        return true;\n    }\n    function Call(F, V, args) {\n        if (typeof F !== 'function') {\n            throw new TypeError('Argument is not a function');\n        }\n        return Function.prototype.apply.call(F, V, args);\n    }\n    function CreateAlgorithmFromUnderlyingMethod(underlyingObject, methodName, algoArgCount, extraArgs) {\n        var method = underlyingObject[methodName];\n        if (method !== undefined) {\n            if (typeof method !== 'function') {\n                throw new TypeError(method + \" is not a method\");\n            }\n            switch (algoArgCount) {\n                case 0: {\n                    return function () {\n                        return PromiseCall(method, underlyingObject, extraArgs);\n                    };\n                }\n                case 1: {\n                    return function (arg) {\n                        var fullArgs = [arg].concat(extraArgs);\n                        return PromiseCall(method, underlyingObject, fullArgs);\n                    };\n                }\n            }\n        }\n        return function () { return promiseResolvedWith(undefined); };\n    }\n    function InvokeOrNoop(O, P, args) {\n        var method = O[P];\n        if (method === undefined) {\n            return undefined;\n        }\n        return Call(method, O, args);\n    }\n    function PromiseCall(F, V, args) {\n        try {\n            return promiseResolvedWith(Call(F, V, args));\n        }\n        catch (value) {\n            return promiseRejectedWith(value);\n        }\n    }\n    // Not implemented correctly\n    function TransferArrayBuffer(O) {\n        return O;\n    }\n    // Not implemented correctly\n    function IsDetachedBuffer(O) {\n        return false;\n    }\n    function ValidateAndNormalizeHighWaterMark(highWaterMark) {\n        highWaterMark = Number(highWaterMark);\n        if (NumberIsNaN(highWaterMark) || highWaterMark < 0) {\n            throw new RangeError('highWaterMark property of a queuing strategy must be non-negative and non-NaN');\n        }\n        return highWaterMark;\n    }\n    function MakeSizeAlgorithmFromSizeFunction(size) {\n        if (size === undefined) {\n            return function () { return 1; };\n        }\n        if (typeof size !== 'function') {\n            throw new TypeError('size property of a queuing strategy must be a function');\n        }\n        return function (chunk) { return size(chunk); };\n    }\n    var originalPromise = Promise;\n    var originalPromiseThen = Promise.prototype.then;\n    var originalPromiseResolve = Promise.resolve.bind(originalPromise);\n    var originalPromiseReject = Promise.reject.bind(originalPromise);\n    function newPromise(executor) {\n        return new originalPromise(executor);\n    }\n    function promiseResolvedWith(value) {\n        return originalPromiseResolve(value);\n    }\n    function promiseRejectedWith(reason) {\n        return originalPromiseReject(reason);\n    }\n    function PerformPromiseThen(promise, onFulfilled, onRejected) {\n        // There doesn't appear to be any way to correctly emulate the behaviour from JavaScript, so this is just an\n        // approximation.\n        return originalPromiseThen.call(promise, onFulfilled, onRejected);\n    }\n    function uponPromise(promise, onFulfilled, onRejected) {\n        PerformPromiseThen(PerformPromiseThen(promise, onFulfilled, onRejected), undefined, rethrowAssertionErrorRejection);\n    }\n    function uponFulfillment(promise, onFulfilled) {\n        uponPromise(promise, onFulfilled);\n    }\n    function uponRejection(promise, onRejected) {\n        uponPromise(promise, undefined, onRejected);\n    }\n    function transformPromiseWith(promise, fulfillmentHandler, rejectionHandler) {\n        return PerformPromiseThen(promise, fulfillmentHandler, rejectionHandler);\n    }\n    function setPromiseIsHandledToTrue(promise) {\n        PerformPromiseThen(promise, undefined, rethrowAssertionErrorRejection);\n    }\n\n    // Original from Chromium\n    // https://chromium.googlesource.com/chromium/src/+/0aee4434a4dba42a42abaea9bfbc0cd196a63bc1/third_party/blink/renderer/core/streams/SimpleQueue.js\n    var QUEUE_MAX_ARRAY_SIZE = 16384;\n    /**\n     * Simple queue structure.\n     *\n     * Avoids scalability issues with using a packed array directly by using\n     * multiple arrays in a linked list and keeping the array size bounded.\n     */\n    var SimpleQueue = /** @class */ (function () {\n        function SimpleQueue() {\n            this._cursor = 0;\n            this._size = 0;\n            // _front and _back are always defined.\n            this._front = {\n                _elements: [],\n                _next: undefined\n            };\n            this._back = this._front;\n            // The cursor is used to avoid calling Array.shift().\n            // It contains the index of the front element of the array inside the\n            // front-most node. It is always in the range [0, QUEUE_MAX_ARRAY_SIZE).\n            this._cursor = 0;\n            // When there is only one node, size === elements.length - cursor.\n            this._size = 0;\n        }\n        Object.defineProperty(SimpleQueue.prototype, \"length\", {\n            get: function () {\n                return this._size;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        // For exception safety, this method is structured in order:\n        // 1. Read state\n        // 2. Calculate required state mutations\n        // 3. Perform state mutations\n        SimpleQueue.prototype.push = function (element) {\n            var oldBack = this._back;\n            var newBack = oldBack;\n            if (oldBack._elements.length === QUEUE_MAX_ARRAY_SIZE - 1) {\n                newBack = {\n                    _elements: [],\n                    _next: undefined\n                };\n            }\n            // push() is the mutation most likely to throw an exception, so it\n            // goes first.\n            oldBack._elements.push(element);\n            if (newBack !== oldBack) {\n                this._back = newBack;\n                oldBack._next = newBack;\n            }\n            ++this._size;\n        };\n        // Like push(), shift() follows the read -> calculate -> mutate pattern for\n        // exception safety.\n        SimpleQueue.prototype.shift = function () { // must not be called on an empty queue\n            var oldFront = this._front;\n            var newFront = oldFront;\n            var oldCursor = this._cursor;\n            var newCursor = oldCursor + 1;\n            var elements = oldFront._elements;\n            var element = elements[oldCursor];\n            if (newCursor === QUEUE_MAX_ARRAY_SIZE) {\n                newFront = oldFront._next;\n                newCursor = 0;\n            }\n            // No mutations before this point.\n            --this._size;\n            this._cursor = newCursor;\n            if (oldFront !== newFront) {\n                this._front = newFront;\n            }\n            // Permit shifted element to be garbage collected.\n            elements[oldCursor] = undefined;\n            return element;\n        };\n        // The tricky thing about forEach() is that it can be called\n        // re-entrantly. The queue may be mutated inside the callback. It is easy to\n        // see that push() within the callback has no negative effects since the end\n        // of the queue is checked for on every iteration. If shift() is called\n        // repeatedly within the callback then the next iteration may return an\n        // element that has been removed. In this case the callback will be called\n        // with undefined values until we either \"catch up\" with elements that still\n        // exist or reach the back of the queue.\n        SimpleQueue.prototype.forEach = function (callback) {\n            var i = this._cursor;\n            var node = this._front;\n            var elements = node._elements;\n            while (i !== elements.length || node._next !== undefined) {\n                if (i === elements.length) {\n                    node = node._next;\n                    elements = node._elements;\n                    i = 0;\n                    if (elements.length === 0) {\n                        break;\n                    }\n                }\n                callback(elements[i]);\n                ++i;\n            }\n        };\n        // Return the element that would be returned if shift() was called now,\n        // without modifying the queue.\n        SimpleQueue.prototype.peek = function () { // must not be called on an empty queue\n            var front = this._front;\n            var cursor = this._cursor;\n            return front._elements[cursor];\n        };\n        return SimpleQueue;\n    }());\n\n    function ReadableStreamCreateReadResult(value, done, forAuthorCode) {\n        var prototype = null;\n        if (forAuthorCode === true) {\n            prototype = Object.prototype;\n        }\n        var obj = Object.create(prototype);\n        obj.value = value;\n        obj.done = done;\n        return obj;\n    }\n    function ReadableStreamReaderGenericInitialize(reader, stream) {\n        reader._forAuthorCode = true;\n        reader._ownerReadableStream = stream;\n        stream._reader = reader;\n        if (stream._state === 'readable') {\n            defaultReaderClosedPromiseInitialize(reader);\n        }\n        else if (stream._state === 'closed') {\n            defaultReaderClosedPromiseInitializeAsResolved(reader);\n        }\n        else {\n            defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);\n        }\n    }\n    // A client of ReadableStreamDefaultReader and ReadableStreamBYOBReader may use these functions directly to bypass state\n    // check.\n    function ReadableStreamReaderGenericCancel(reader, reason) {\n        var stream = reader._ownerReadableStream;\n        return ReadableStreamCancel(stream, reason);\n    }\n    function ReadableStreamReaderGenericRelease(reader) {\n        if (reader._ownerReadableStream._state === 'readable') {\n            defaultReaderClosedPromiseReject(reader, new TypeError('Reader was released and can no longer be used to monitor the stream\\'s closedness'));\n        }\n        else {\n            defaultReaderClosedPromiseResetToRejected(reader, new TypeError('Reader was released and can no longer be used to monitor the stream\\'s closedness'));\n        }\n        reader._ownerReadableStream._reader = undefined;\n        reader._ownerReadableStream = undefined;\n    }\n    // Helper functions for the readers.\n    function readerLockException(name) {\n        return new TypeError('Cannot ' + name + ' a stream using a released reader');\n    }\n    // Helper functions for the ReadableStreamDefaultReader.\n    function defaultReaderClosedPromiseInitialize(reader) {\n        reader._closedPromise = newPromise(function (resolve, reject) {\n            reader._closedPromise_resolve = resolve;\n            reader._closedPromise_reject = reject;\n        });\n    }\n    function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {\n        defaultReaderClosedPromiseInitialize(reader);\n        defaultReaderClosedPromiseReject(reader, reason);\n    }\n    function defaultReaderClosedPromiseInitializeAsResolved(reader) {\n        defaultReaderClosedPromiseInitialize(reader);\n        defaultReaderClosedPromiseResolve(reader);\n    }\n    function defaultReaderClosedPromiseReject(reader, reason) {\n        setPromiseIsHandledToTrue(reader._closedPromise);\n        reader._closedPromise_reject(reason);\n        reader._closedPromise_resolve = undefined;\n        reader._closedPromise_reject = undefined;\n    }\n    function defaultReaderClosedPromiseResetToRejected(reader, reason) {\n        defaultReaderClosedPromiseInitializeAsRejected(reader, reason);\n    }\n    function defaultReaderClosedPromiseResolve(reader) {\n        reader._closedPromise_resolve(undefined);\n        reader._closedPromise_resolve = undefined;\n        reader._closedPromise_reject = undefined;\n    }\n\n    var CancelSteps = SymbolPolyfill('[[CancelSteps]]');\n    var PullSteps = SymbolPolyfill('[[PullSteps]]');\n\n    // Abstract operations for the ReadableStream.\n    function AcquireReadableStreamDefaultReader(stream, forAuthorCode) {\n        if (forAuthorCode === void 0) { forAuthorCode = false; }\n        var reader = new ReadableStreamDefaultReader(stream);\n        reader._forAuthorCode = forAuthorCode;\n        return reader;\n    }\n    // ReadableStream API exposed for controllers.\n    function ReadableStreamAddReadRequest(stream) {\n        var promise = newPromise(function (resolve, reject) {\n            var readRequest = {\n                _resolve: resolve,\n                _reject: reject\n            };\n            stream._reader._readRequests.push(readRequest);\n        });\n        return promise;\n    }\n    function ReadableStreamFulfillReadRequest(stream, chunk, done) {\n        var reader = stream._reader;\n        var readRequest = reader._readRequests.shift();\n        readRequest._resolve(ReadableStreamCreateReadResult(chunk, done, reader._forAuthorCode));\n    }\n    function ReadableStreamGetNumReadRequests(stream) {\n        return stream._reader._readRequests.length;\n    }\n    function ReadableStreamHasDefaultReader(stream) {\n        var reader = stream._reader;\n        if (reader === undefined) {\n            return false;\n        }\n        if (!IsReadableStreamDefaultReader(reader)) {\n            return false;\n        }\n        return true;\n    }\n    var ReadableStreamDefaultReader = /** @class */ (function () {\n        function ReadableStreamDefaultReader(stream) {\n            if (IsReadableStream(stream) === false) {\n                throw new TypeError('ReadableStreamDefaultReader can only be constructed with a ReadableStream instance');\n            }\n            if (IsReadableStreamLocked(stream) === true) {\n                throw new TypeError('This stream has already been locked for exclusive reading by another reader');\n            }\n            ReadableStreamReaderGenericInitialize(this, stream);\n            this._readRequests = new SimpleQueue();\n        }\n        Object.defineProperty(ReadableStreamDefaultReader.prototype, \"closed\", {\n            get: function () {\n                if (!IsReadableStreamDefaultReader(this)) {\n                    return promiseRejectedWith(defaultReaderBrandCheckException('closed'));\n                }\n                return this._closedPromise;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        ReadableStreamDefaultReader.prototype.cancel = function (reason) {\n            if (!IsReadableStreamDefaultReader(this)) {\n                return promiseRejectedWith(defaultReaderBrandCheckException('cancel'));\n            }\n            if (this._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('cancel'));\n            }\n            return ReadableStreamReaderGenericCancel(this, reason);\n        };\n        ReadableStreamDefaultReader.prototype.read = function () {\n            if (!IsReadableStreamDefaultReader(this)) {\n                return promiseRejectedWith(defaultReaderBrandCheckException('read'));\n            }\n            if (this._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('read from'));\n            }\n            return ReadableStreamDefaultReaderRead(this);\n        };\n        ReadableStreamDefaultReader.prototype.releaseLock = function () {\n            if (!IsReadableStreamDefaultReader(this)) {\n                throw defaultReaderBrandCheckException('releaseLock');\n            }\n            if (this._ownerReadableStream === undefined) {\n                return;\n            }\n            if (this._readRequests.length > 0) {\n                throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');\n            }\n            ReadableStreamReaderGenericRelease(this);\n        };\n        return ReadableStreamDefaultReader;\n    }());\n    // Abstract operations for the readers.\n    function IsReadableStreamDefaultReader(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {\n            return false;\n        }\n        return true;\n    }\n    function ReadableStreamDefaultReaderRead(reader) {\n        var stream = reader._ownerReadableStream;\n        stream._disturbed = true;\n        if (stream._state === 'closed') {\n            return promiseResolvedWith(ReadableStreamCreateReadResult(undefined, true, reader._forAuthorCode));\n        }\n        if (stream._state === 'errored') {\n            return promiseRejectedWith(stream._storedError);\n        }\n        return stream._readableStreamController[PullSteps]();\n    }\n    // Helper functions for the ReadableStreamDefaultReader.\n    function defaultReaderBrandCheckException(name) {\n        return new TypeError(\"ReadableStreamDefaultReader.prototype.\" + name + \" can only be used on a ReadableStreamDefaultReader\");\n    }\n\n    /// <reference lib=\"es2018.asynciterable\" />\n    var _a;\n    var AsyncIteratorPrototype;\n    if (typeof SymbolPolyfill.asyncIterator === 'symbol') {\n        // We're running inside a ES2018+ environment, but we're compiling to an older syntax.\n        // We cannot access %AsyncIteratorPrototype% without non-ES2018 syntax, but we can re-create it.\n        AsyncIteratorPrototype = (_a = {},\n            // 25.1.3.1 %AsyncIteratorPrototype% [ @@asyncIterator ] ( )\n            // https://tc39.github.io/ecma262/#sec-asynciteratorprototype-asynciterator\n            _a[SymbolPolyfill.asyncIterator] = function () {\n                return this;\n            },\n            _a);\n        Object.defineProperty(AsyncIteratorPrototype, SymbolPolyfill.asyncIterator, { enumerable: false });\n    }\n\n    /// <reference lib=\"es2018.asynciterable\" />\n    var ReadableStreamAsyncIteratorPrototype = {\n        next: function () {\n            if (IsReadableStreamAsyncIterator(this) === false) {\n                return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next'));\n            }\n            var reader = this._asyncIteratorReader;\n            if (reader._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('iterate'));\n            }\n            return transformPromiseWith(ReadableStreamDefaultReaderRead(reader), function (result) {\n                var done = result.done;\n                if (done) {\n                    ReadableStreamReaderGenericRelease(reader);\n                }\n                var value = result.value;\n                return ReadableStreamCreateReadResult(value, done, true);\n            });\n        },\n        return: function (value) {\n            if (IsReadableStreamAsyncIterator(this) === false) {\n                return promiseRejectedWith(streamAsyncIteratorBrandCheckException('next'));\n            }\n            var reader = this._asyncIteratorReader;\n            if (reader._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('finish iterating'));\n            }\n            if (reader._readRequests.length > 0) {\n                return promiseRejectedWith(new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled'));\n            }\n            if (this._preventCancel === false) {\n                var result = ReadableStreamReaderGenericCancel(reader, value);\n                ReadableStreamReaderGenericRelease(reader);\n                return transformPromiseWith(result, function () { return ReadableStreamCreateReadResult(value, true, true); });\n            }\n            ReadableStreamReaderGenericRelease(reader);\n            return promiseResolvedWith(ReadableStreamCreateReadResult(value, true, true));\n        }\n    };\n    if (AsyncIteratorPrototype !== undefined) {\n        Object.setPrototypeOf(ReadableStreamAsyncIteratorPrototype, AsyncIteratorPrototype);\n    }\n    Object.defineProperty(ReadableStreamAsyncIteratorPrototype, 'next', { enumerable: false });\n    Object.defineProperty(ReadableStreamAsyncIteratorPrototype, 'return', { enumerable: false });\n    // Abstract operations for the ReadableStream.\n    function AcquireReadableStreamAsyncIterator(stream, preventCancel) {\n        if (preventCancel === void 0) { preventCancel = false; }\n        var reader = AcquireReadableStreamDefaultReader(stream);\n        var iterator = Object.create(ReadableStreamAsyncIteratorPrototype);\n        iterator._asyncIteratorReader = reader;\n        iterator._preventCancel = Boolean(preventCancel);\n        return iterator;\n    }\n    function IsReadableStreamAsyncIterator(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_asyncIteratorReader')) {\n            return false;\n        }\n        return true;\n    }\n    // Helper functions for the ReadableStream.\n    function streamAsyncIteratorBrandCheckException(name) {\n        return new TypeError(\"ReadableStreamAsyncIterator.\" + name + \" can only be used on a ReadableSteamAsyncIterator\");\n    }\n\n    function DequeueValue(container) {\n        var pair = container._queue.shift();\n        container._queueTotalSize -= pair.size;\n        if (container._queueTotalSize < 0) {\n            container._queueTotalSize = 0;\n        }\n        return pair.value;\n    }\n    function EnqueueValueWithSize(container, value, size) {\n        size = Number(size);\n        if (!IsFiniteNonNegativeNumber(size)) {\n            throw new RangeError('Size must be a finite, non-NaN, non-negative number.');\n        }\n        container._queue.push({ value: value, size: size });\n        container._queueTotalSize += size;\n    }\n    function PeekQueueValue(container) {\n        var pair = container._queue.peek();\n        return pair.value;\n    }\n    function ResetQueue(container) {\n        container._queue = new SimpleQueue();\n        container._queueTotalSize = 0;\n    }\n\n    var AbortSteps = SymbolPolyfill('[[AbortSteps]]');\n    var ErrorSteps = SymbolPolyfill('[[ErrorSteps]]');\n    var WritableStream = /** @class */ (function () {\n        function WritableStream(underlyingSink, strategy) {\n            if (underlyingSink === void 0) { underlyingSink = {}; }\n            if (strategy === void 0) { strategy = {}; }\n            InitializeWritableStream(this);\n            var size = strategy.size;\n            var highWaterMark = strategy.highWaterMark;\n            var type = underlyingSink.type;\n            if (type !== undefined) {\n                throw new RangeError('Invalid type is specified');\n            }\n            var sizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(size);\n            if (highWaterMark === undefined) {\n                highWaterMark = 1;\n            }\n            highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark);\n            SetUpWritableStreamDefaultControllerFromUnderlyingSink(this, underlyingSink, highWaterMark, sizeAlgorithm);\n        }\n        Object.defineProperty(WritableStream.prototype, \"locked\", {\n            get: function () {\n                if (IsWritableStream(this) === false) {\n                    throw streamBrandCheckException('locked');\n                }\n                return IsWritableStreamLocked(this);\n            },\n            enumerable: true,\n            configurable: true\n        });\n        WritableStream.prototype.abort = function (reason) {\n            if (IsWritableStream(this) === false) {\n                return promiseRejectedWith(streamBrandCheckException('abort'));\n            }\n            if (IsWritableStreamLocked(this) === true) {\n                return promiseRejectedWith(new TypeError('Cannot abort a stream that already has a writer'));\n            }\n            return WritableStreamAbort(this, reason);\n        };\n        WritableStream.prototype.close = function () {\n            if (IsWritableStream(this) === false) {\n                return promiseRejectedWith(streamBrandCheckException('close'));\n            }\n            if (IsWritableStreamLocked(this) === true) {\n                return promiseRejectedWith(new TypeError('Cannot close a stream that already has a writer'));\n            }\n            if (WritableStreamCloseQueuedOrInFlight(this) === true) {\n                return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));\n            }\n            return WritableStreamClose(this);\n        };\n        WritableStream.prototype.getWriter = function () {\n            if (IsWritableStream(this) === false) {\n                throw streamBrandCheckException('getWriter');\n            }\n            return AcquireWritableStreamDefaultWriter(this);\n        };\n        return WritableStream;\n    }());\n    // Abstract operations for the WritableStream.\n    function AcquireWritableStreamDefaultWriter(stream) {\n        return new WritableStreamDefaultWriter(stream);\n    }\n    // Throws if and only if startAlgorithm throws.\n    function CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {\n        if (highWaterMark === void 0) { highWaterMark = 1; }\n        if (sizeAlgorithm === void 0) { sizeAlgorithm = function () { return 1; }; }\n        var stream = Object.create(WritableStream.prototype);\n        InitializeWritableStream(stream);\n        var controller = Object.create(WritableStreamDefaultController.prototype);\n        SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);\n        return stream;\n    }\n    function InitializeWritableStream(stream) {\n        stream._state = 'writable';\n        // The error that will be reported by new method calls once the state becomes errored. Only set when [[state]] is\n        // 'erroring' or 'errored'. May be set to an undefined value.\n        stream._storedError = undefined;\n        stream._writer = undefined;\n        // Initialize to undefined first because the constructor of the controller checks this\n        // variable to validate the caller.\n        stream._writableStreamController = undefined;\n        // This queue is placed here instead of the writer class in order to allow for passing a writer to the next data\n        // producer without waiting for the queued writes to finish.\n        stream._writeRequests = new SimpleQueue();\n        // Write requests are removed from _writeRequests when write() is called on the underlying sink. This prevents\n        // them from being erroneously rejected on error. If a write() call is in-flight, the request is stored here.\n        stream._inFlightWriteRequest = undefined;\n        // The promise that was returned from writer.close(). Stored here because it may be fulfilled after the writer\n        // has been detached.\n        stream._closeRequest = undefined;\n        // Close request is removed from _closeRequest when close() is called on the underlying sink. This prevents it\n        // from being erroneously rejected on error. If a close() call is in-flight, the request is stored here.\n        stream._inFlightCloseRequest = undefined;\n        // The promise that was returned from writer.abort(). This may also be fulfilled after the writer has detached.\n        stream._pendingAbortRequest = undefined;\n        // The backpressure signal set by the controller.\n        stream._backpressure = false;\n    }\n    function IsWritableStream(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {\n            return false;\n        }\n        return true;\n    }\n    function IsWritableStreamLocked(stream) {\n        if (stream._writer === undefined) {\n            return false;\n        }\n        return true;\n    }\n    function WritableStreamAbort(stream, reason) {\n        var state = stream._state;\n        if (state === 'closed' || state === 'errored') {\n            return promiseResolvedWith(undefined);\n        }\n        if (stream._pendingAbortRequest !== undefined) {\n            return stream._pendingAbortRequest._promise;\n        }\n        var wasAlreadyErroring = false;\n        if (state === 'erroring') {\n            wasAlreadyErroring = true;\n            // reason will not be used, so don't keep a reference to it.\n            reason = undefined;\n        }\n        var promise = newPromise(function (resolve, reject) {\n            stream._pendingAbortRequest = {\n                _promise: undefined,\n                _resolve: resolve,\n                _reject: reject,\n                _reason: reason,\n                _wasAlreadyErroring: wasAlreadyErroring\n            };\n        });\n        stream._pendingAbortRequest._promise = promise;\n        if (wasAlreadyErroring === false) {\n            WritableStreamStartErroring(stream, reason);\n        }\n        return promise;\n    }\n    function WritableStreamClose(stream) {\n        var state = stream._state;\n        if (state === 'closed' || state === 'errored') {\n            return promiseRejectedWith(new TypeError(\"The stream (in \" + state + \" state) is not in the writable state and cannot be closed\"));\n        }\n        var promise = newPromise(function (resolve, reject) {\n            var closeRequest = {\n                _resolve: resolve,\n                _reject: reject\n            };\n            stream._closeRequest = closeRequest;\n        });\n        var writer = stream._writer;\n        if (writer !== undefined && stream._backpressure === true && state === 'writable') {\n            defaultWriterReadyPromiseResolve(writer);\n        }\n        WritableStreamDefaultControllerClose(stream._writableStreamController);\n        return promise;\n    }\n    // WritableStream API exposed for controllers.\n    function WritableStreamAddWriteRequest(stream) {\n        var promise = newPromise(function (resolve, reject) {\n            var writeRequest = {\n                _resolve: resolve,\n                _reject: reject\n            };\n            stream._writeRequests.push(writeRequest);\n        });\n        return promise;\n    }\n    function WritableStreamDealWithRejection(stream, error) {\n        var state = stream._state;\n        if (state === 'writable') {\n            WritableStreamStartErroring(stream, error);\n            return;\n        }\n        WritableStreamFinishErroring(stream);\n    }\n    function WritableStreamStartErroring(stream, reason) {\n        var controller = stream._writableStreamController;\n        stream._state = 'erroring';\n        stream._storedError = reason;\n        var writer = stream._writer;\n        if (writer !== undefined) {\n            WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);\n        }\n        if (WritableStreamHasOperationMarkedInFlight(stream) === false && controller._started === true) {\n            WritableStreamFinishErroring(stream);\n        }\n    }\n    function WritableStreamFinishErroring(stream) {\n        stream._state = 'errored';\n        stream._writableStreamController[ErrorSteps]();\n        var storedError = stream._storedError;\n        stream._writeRequests.forEach(function (writeRequest) {\n            writeRequest._reject(storedError);\n        });\n        stream._writeRequests = new SimpleQueue();\n        if (stream._pendingAbortRequest === undefined) {\n            WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);\n            return;\n        }\n        var abortRequest = stream._pendingAbortRequest;\n        stream._pendingAbortRequest = undefined;\n        if (abortRequest._wasAlreadyErroring === true) {\n            abortRequest._reject(storedError);\n            WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);\n            return;\n        }\n        var promise = stream._writableStreamController[AbortSteps](abortRequest._reason);\n        uponPromise(promise, function () {\n            abortRequest._resolve();\n            WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);\n        }, function (reason) {\n            abortRequest._reject(reason);\n            WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);\n        });\n    }\n    function WritableStreamFinishInFlightWrite(stream) {\n        stream._inFlightWriteRequest._resolve(undefined);\n        stream._inFlightWriteRequest = undefined;\n    }\n    function WritableStreamFinishInFlightWriteWithError(stream, error) {\n        stream._inFlightWriteRequest._reject(error);\n        stream._inFlightWriteRequest = undefined;\n        WritableStreamDealWithRejection(stream, error);\n    }\n    function WritableStreamFinishInFlightClose(stream) {\n        stream._inFlightCloseRequest._resolve(undefined);\n        stream._inFlightCloseRequest = undefined;\n        var state = stream._state;\n        if (state === 'erroring') {\n            // The error was too late to do anything, so it is ignored.\n            stream._storedError = undefined;\n            if (stream._pendingAbortRequest !== undefined) {\n                stream._pendingAbortRequest._resolve();\n                stream._pendingAbortRequest = undefined;\n            }\n        }\n        stream._state = 'closed';\n        var writer = stream._writer;\n        if (writer !== undefined) {\n            defaultWriterClosedPromiseResolve(writer);\n        }\n    }\n    function WritableStreamFinishInFlightCloseWithError(stream, error) {\n        stream._inFlightCloseRequest._reject(error);\n        stream._inFlightCloseRequest = undefined;\n        // Never execute sink abort() after sink close().\n        if (stream._pendingAbortRequest !== undefined) {\n            stream._pendingAbortRequest._reject(error);\n            stream._pendingAbortRequest = undefined;\n        }\n        WritableStreamDealWithRejection(stream, error);\n    }\n    // TODO(ricea): Fix alphabetical order.\n    function WritableStreamCloseQueuedOrInFlight(stream) {\n        if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) {\n            return false;\n        }\n        return true;\n    }\n    function WritableStreamHasOperationMarkedInFlight(stream) {\n        if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) {\n            return false;\n        }\n        return true;\n    }\n    function WritableStreamMarkCloseRequestInFlight(stream) {\n        stream._inFlightCloseRequest = stream._closeRequest;\n        stream._closeRequest = undefined;\n    }\n    function WritableStreamMarkFirstWriteRequestInFlight(stream) {\n        stream._inFlightWriteRequest = stream._writeRequests.shift();\n    }\n    function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {\n        if (stream._closeRequest !== undefined) {\n            stream._closeRequest._reject(stream._storedError);\n            stream._closeRequest = undefined;\n        }\n        var writer = stream._writer;\n        if (writer !== undefined) {\n            defaultWriterClosedPromiseReject(writer, stream._storedError);\n        }\n    }\n    function WritableStreamUpdateBackpressure(stream, backpressure) {\n        var writer = stream._writer;\n        if (writer !== undefined && backpressure !== stream._backpressure) {\n            if (backpressure === true) {\n                defaultWriterReadyPromiseReset(writer);\n            }\n            else {\n                defaultWriterReadyPromiseResolve(writer);\n            }\n        }\n        stream._backpressure = backpressure;\n    }\n    var WritableStreamDefaultWriter = /** @class */ (function () {\n        function WritableStreamDefaultWriter(stream) {\n            if (IsWritableStream(stream) === false) {\n                throw new TypeError('WritableStreamDefaultWriter can only be constructed with a WritableStream instance');\n            }\n            if (IsWritableStreamLocked(stream) === true) {\n                throw new TypeError('This stream has already been locked for exclusive writing by another writer');\n            }\n            this._ownerWritableStream = stream;\n            stream._writer = this;\n            var state = stream._state;\n            if (state === 'writable') {\n                if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._backpressure === true) {\n                    defaultWriterReadyPromiseInitialize(this);\n                }\n                else {\n                    defaultWriterReadyPromiseInitializeAsResolved(this);\n                }\n                defaultWriterClosedPromiseInitialize(this);\n            }\n            else if (state === 'erroring') {\n                defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);\n                defaultWriterClosedPromiseInitialize(this);\n            }\n            else if (state === 'closed') {\n                defaultWriterReadyPromiseInitializeAsResolved(this);\n                defaultWriterClosedPromiseInitializeAsResolved(this);\n            }\n            else {\n                var storedError = stream._storedError;\n                defaultWriterReadyPromiseInitializeAsRejected(this, storedError);\n                defaultWriterClosedPromiseInitializeAsRejected(this, storedError);\n            }\n        }\n        Object.defineProperty(WritableStreamDefaultWriter.prototype, \"closed\", {\n            get: function () {\n                if (IsWritableStreamDefaultWriter(this) === false) {\n                    return promiseRejectedWith(defaultWriterBrandCheckException('closed'));\n                }\n                return this._closedPromise;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        Object.defineProperty(WritableStreamDefaultWriter.prototype, \"desiredSize\", {\n            get: function () {\n                if (IsWritableStreamDefaultWriter(this) === false) {\n                    throw defaultWriterBrandCheckException('desiredSize');\n                }\n                if (this._ownerWritableStream === undefined) {\n                    throw defaultWriterLockException('desiredSize');\n                }\n                return WritableStreamDefaultWriterGetDesiredSize(this);\n            },\n            enumerable: true,\n            configurable: true\n        });\n        Object.defineProperty(WritableStreamDefaultWriter.prototype, \"ready\", {\n            get: function () {\n                if (IsWritableStreamDefaultWriter(this) === false) {\n                    return promiseRejectedWith(defaultWriterBrandCheckException('ready'));\n                }\n                return this._readyPromise;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        WritableStreamDefaultWriter.prototype.abort = function (reason) {\n            if (IsWritableStreamDefaultWriter(this) === false) {\n                return promiseRejectedWith(defaultWriterBrandCheckException('abort'));\n            }\n            if (this._ownerWritableStream === undefined) {\n                return promiseRejectedWith(defaultWriterLockException('abort'));\n            }\n            return WritableStreamDefaultWriterAbort(this, reason);\n        };\n        WritableStreamDefaultWriter.prototype.close = function () {\n            if (IsWritableStreamDefaultWriter(this) === false) {\n                return promiseRejectedWith(defaultWriterBrandCheckException('close'));\n            }\n            var stream = this._ownerWritableStream;\n            if (stream === undefined) {\n                return promiseRejectedWith(defaultWriterLockException('close'));\n            }\n            if (WritableStreamCloseQueuedOrInFlight(stream) === true) {\n                return promiseRejectedWith(new TypeError('Cannot close an already-closing stream'));\n            }\n            return WritableStreamDefaultWriterClose(this);\n        };\n        WritableStreamDefaultWriter.prototype.releaseLock = function () {\n            if (IsWritableStreamDefaultWriter(this) === false) {\n                throw defaultWriterBrandCheckException('releaseLock');\n            }\n            var stream = this._ownerWritableStream;\n            if (stream === undefined) {\n                return;\n            }\n            WritableStreamDefaultWriterRelease(this);\n        };\n        WritableStreamDefaultWriter.prototype.write = function (chunk) {\n            if (IsWritableStreamDefaultWriter(this) === false) {\n                return promiseRejectedWith(defaultWriterBrandCheckException('write'));\n            }\n            if (this._ownerWritableStream === undefined) {\n                return promiseRejectedWith(defaultWriterLockException('write to'));\n            }\n            return WritableStreamDefaultWriterWrite(this, chunk);\n        };\n        return WritableStreamDefaultWriter;\n    }());\n    // Abstract operations for the WritableStreamDefaultWriter.\n    function IsWritableStreamDefaultWriter(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {\n            return false;\n        }\n        return true;\n    }\n    // A client of WritableStreamDefaultWriter may use these functions directly to bypass state check.\n    function WritableStreamDefaultWriterAbort(writer, reason) {\n        var stream = writer._ownerWritableStream;\n        return WritableStreamAbort(stream, reason);\n    }\n    function WritableStreamDefaultWriterClose(writer) {\n        var stream = writer._ownerWritableStream;\n        return WritableStreamClose(stream);\n    }\n    function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {\n        var stream = writer._ownerWritableStream;\n        var state = stream._state;\n        if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {\n            return promiseResolvedWith(undefined);\n        }\n        if (state === 'errored') {\n            return promiseRejectedWith(stream._storedError);\n        }\n        return WritableStreamDefaultWriterClose(writer);\n    }\n    function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {\n        if (writer._closedPromiseState === 'pending') {\n            defaultWriterClosedPromiseReject(writer, error);\n        }\n        else {\n            defaultWriterClosedPromiseResetToRejected(writer, error);\n        }\n    }\n    function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {\n        if (writer._readyPromiseState === 'pending') {\n            defaultWriterReadyPromiseReject(writer, error);\n        }\n        else {\n            defaultWriterReadyPromiseResetToRejected(writer, error);\n        }\n    }\n    function WritableStreamDefaultWriterGetDesiredSize(writer) {\n        var stream = writer._ownerWritableStream;\n        var state = stream._state;\n        if (state === 'errored' || state === 'erroring') {\n            return null;\n        }\n        if (state === 'closed') {\n            return 0;\n        }\n        return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);\n    }\n    function WritableStreamDefaultWriterRelease(writer) {\n        var stream = writer._ownerWritableStream;\n        var releasedError = new TypeError('Writer was released and can no longer be used to monitor the stream\\'s closedness');\n        WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);\n        // The state transitions to \"errored\" before the sink abort() method runs, but the writer.closed promise is not\n        // rejected until afterwards. This means that simply testing state will not work.\n        WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);\n        stream._writer = undefined;\n        writer._ownerWritableStream = undefined;\n    }\n    function WritableStreamDefaultWriterWrite(writer, chunk) {\n        var stream = writer._ownerWritableStream;\n        var controller = stream._writableStreamController;\n        var chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);\n        if (stream !== writer._ownerWritableStream) {\n            return promiseRejectedWith(defaultWriterLockException('write to'));\n        }\n        var state = stream._state;\n        if (state === 'errored') {\n            return promiseRejectedWith(stream._storedError);\n        }\n        if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {\n            return promiseRejectedWith(new TypeError('The stream is closing or closed and cannot be written to'));\n        }\n        if (state === 'erroring') {\n            return promiseRejectedWith(stream._storedError);\n        }\n        var promise = WritableStreamAddWriteRequest(stream);\n        WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);\n        return promise;\n    }\n    var WritableStreamDefaultController = /** @class */ (function () {\n        /** @internal */\n        function WritableStreamDefaultController() {\n            throw new TypeError('WritableStreamDefaultController cannot be constructed explicitly');\n        }\n        WritableStreamDefaultController.prototype.error = function (e) {\n            if (IsWritableStreamDefaultController(this) === false) {\n                throw new TypeError('WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController');\n            }\n            var state = this._controlledWritableStream._state;\n            if (state !== 'writable') {\n                // The stream is closed, errored or will be soon. The sink can't do anything useful if it gets an error here, so\n                // just treat it as a no-op.\n                return;\n            }\n            WritableStreamDefaultControllerError(this, e);\n        };\n        /** @internal */\n        WritableStreamDefaultController.prototype[AbortSteps] = function (reason) {\n            var result = this._abortAlgorithm(reason);\n            WritableStreamDefaultControllerClearAlgorithms(this);\n            return result;\n        };\n        /** @internal */\n        WritableStreamDefaultController.prototype[ErrorSteps] = function () {\n            ResetQueue(this);\n        };\n        return WritableStreamDefaultController;\n    }());\n    // Abstract operations implementing interface required by the WritableStream.\n    function IsWritableStreamDefaultController(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_controlledWritableStream')) {\n            return false;\n        }\n        return true;\n    }\n    function SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm) {\n        controller._controlledWritableStream = stream;\n        stream._writableStreamController = controller;\n        // Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.\n        controller._queue = undefined;\n        controller._queueTotalSize = undefined;\n        ResetQueue(controller);\n        controller._started = false;\n        controller._strategySizeAlgorithm = sizeAlgorithm;\n        controller._strategyHWM = highWaterMark;\n        controller._writeAlgorithm = writeAlgorithm;\n        controller._closeAlgorithm = closeAlgorithm;\n        controller._abortAlgorithm = abortAlgorithm;\n        var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);\n        WritableStreamUpdateBackpressure(stream, backpressure);\n        var startResult = startAlgorithm();\n        var startPromise = promiseResolvedWith(startResult);\n        uponPromise(startPromise, function () {\n            controller._started = true;\n            WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);\n        }, function (r) {\n            controller._started = true;\n            WritableStreamDealWithRejection(stream, r);\n        });\n    }\n    function SetUpWritableStreamDefaultControllerFromUnderlyingSink(stream, underlyingSink, highWaterMark, sizeAlgorithm) {\n        var controller = Object.create(WritableStreamDefaultController.prototype);\n        function startAlgorithm() {\n            return InvokeOrNoop(underlyingSink, 'start', [controller]);\n        }\n        var writeAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSink, 'write', 1, [controller]);\n        var closeAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSink, 'close', 0, []);\n        var abortAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSink, 'abort', 1, []);\n        SetUpWritableStreamDefaultController(stream, controller, startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, highWaterMark, sizeAlgorithm);\n    }\n    // ClearAlgorithms may be called twice. Erroring the same stream in multiple ways will often result in redundant calls.\n    function WritableStreamDefaultControllerClearAlgorithms(controller) {\n        controller._writeAlgorithm = undefined;\n        controller._closeAlgorithm = undefined;\n        controller._abortAlgorithm = undefined;\n        controller._strategySizeAlgorithm = undefined;\n    }\n    function WritableStreamDefaultControllerClose(controller) {\n        EnqueueValueWithSize(controller, 'close', 0);\n        WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);\n    }\n    function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {\n        try {\n            return controller._strategySizeAlgorithm(chunk);\n        }\n        catch (chunkSizeE) {\n            WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);\n            return 1;\n        }\n    }\n    function WritableStreamDefaultControllerGetDesiredSize(controller) {\n        return controller._strategyHWM - controller._queueTotalSize;\n    }\n    function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {\n        var writeRecord = { chunk: chunk };\n        try {\n            EnqueueValueWithSize(controller, writeRecord, chunkSize);\n        }\n        catch (enqueueE) {\n            WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);\n            return;\n        }\n        var stream = controller._controlledWritableStream;\n        if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._state === 'writable') {\n            var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);\n            WritableStreamUpdateBackpressure(stream, backpressure);\n        }\n        WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);\n    }\n    // Abstract operations for the WritableStreamDefaultController.\n    function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {\n        var stream = controller._controlledWritableStream;\n        if (controller._started === false) {\n            return;\n        }\n        if (stream._inFlightWriteRequest !== undefined) {\n            return;\n        }\n        var state = stream._state;\n        if (state === 'erroring') {\n            WritableStreamFinishErroring(stream);\n            return;\n        }\n        if (controller._queue.length === 0) {\n            return;\n        }\n        var writeRecord = PeekQueueValue(controller);\n        if (writeRecord === 'close') {\n            WritableStreamDefaultControllerProcessClose(controller);\n        }\n        else {\n            WritableStreamDefaultControllerProcessWrite(controller, writeRecord.chunk);\n        }\n    }\n    function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {\n        if (controller._controlledWritableStream._state === 'writable') {\n            WritableStreamDefaultControllerError(controller, error);\n        }\n    }\n    function WritableStreamDefaultControllerProcessClose(controller) {\n        var stream = controller._controlledWritableStream;\n        WritableStreamMarkCloseRequestInFlight(stream);\n        DequeueValue(controller);\n        var sinkClosePromise = controller._closeAlgorithm();\n        WritableStreamDefaultControllerClearAlgorithms(controller);\n        uponPromise(sinkClosePromise, function () {\n            WritableStreamFinishInFlightClose(stream);\n        }, function (reason) {\n            WritableStreamFinishInFlightCloseWithError(stream, reason);\n        });\n    }\n    function WritableStreamDefaultControllerProcessWrite(controller, chunk) {\n        var stream = controller._controlledWritableStream;\n        WritableStreamMarkFirstWriteRequestInFlight(stream);\n        var sinkWritePromise = controller._writeAlgorithm(chunk);\n        uponPromise(sinkWritePromise, function () {\n            WritableStreamFinishInFlightWrite(stream);\n            var state = stream._state;\n            DequeueValue(controller);\n            if (WritableStreamCloseQueuedOrInFlight(stream) === false && state === 'writable') {\n                var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);\n                WritableStreamUpdateBackpressure(stream, backpressure);\n            }\n            WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);\n        }, function (reason) {\n            if (stream._state === 'writable') {\n                WritableStreamDefaultControllerClearAlgorithms(controller);\n            }\n            WritableStreamFinishInFlightWriteWithError(stream, reason);\n        });\n    }\n    function WritableStreamDefaultControllerGetBackpressure(controller) {\n        var desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);\n        return desiredSize <= 0;\n    }\n    // A client of WritableStreamDefaultController may use these functions directly to bypass state check.\n    function WritableStreamDefaultControllerError(controller, error) {\n        var stream = controller._controlledWritableStream;\n        WritableStreamDefaultControllerClearAlgorithms(controller);\n        WritableStreamStartErroring(stream, error);\n    }\n    // Helper functions for the WritableStream.\n    function streamBrandCheckException(name) {\n        return new TypeError(\"WritableStream.prototype.\" + name + \" can only be used on a WritableStream\");\n    }\n    // Helper functions for the WritableStreamDefaultWriter.\n    function defaultWriterBrandCheckException(name) {\n        return new TypeError(\"WritableStreamDefaultWriter.prototype.\" + name + \" can only be used on a WritableStreamDefaultWriter\");\n    }\n    function defaultWriterLockException(name) {\n        return new TypeError('Cannot ' + name + ' a stream using a released writer');\n    }\n    function defaultWriterClosedPromiseInitialize(writer) {\n        writer._closedPromise = newPromise(function (resolve, reject) {\n            writer._closedPromise_resolve = resolve;\n            writer._closedPromise_reject = reject;\n            writer._closedPromiseState = 'pending';\n        });\n    }\n    function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {\n        defaultWriterClosedPromiseInitialize(writer);\n        defaultWriterClosedPromiseReject(writer, reason);\n    }\n    function defaultWriterClosedPromiseInitializeAsResolved(writer) {\n        defaultWriterClosedPromiseInitialize(writer);\n        defaultWriterClosedPromiseResolve(writer);\n    }\n    function defaultWriterClosedPromiseReject(writer, reason) {\n        setPromiseIsHandledToTrue(writer._closedPromise);\n        writer._closedPromise_reject(reason);\n        writer._closedPromise_resolve = undefined;\n        writer._closedPromise_reject = undefined;\n        writer._closedPromiseState = 'rejected';\n    }\n    function defaultWriterClosedPromiseResetToRejected(writer, reason) {\n        defaultWriterClosedPromiseInitializeAsRejected(writer, reason);\n    }\n    function defaultWriterClosedPromiseResolve(writer) {\n        writer._closedPromise_resolve(undefined);\n        writer._closedPromise_resolve = undefined;\n        writer._closedPromise_reject = undefined;\n        writer._closedPromiseState = 'resolved';\n    }\n    function defaultWriterReadyPromiseInitialize(writer) {\n        writer._readyPromise = newPromise(function (resolve, reject) {\n            writer._readyPromise_resolve = resolve;\n            writer._readyPromise_reject = reject;\n        });\n        writer._readyPromiseState = 'pending';\n    }\n    function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) {\n        defaultWriterReadyPromiseInitialize(writer);\n        defaultWriterReadyPromiseReject(writer, reason);\n    }\n    function defaultWriterReadyPromiseInitializeAsResolved(writer) {\n        defaultWriterReadyPromiseInitialize(writer);\n        defaultWriterReadyPromiseResolve(writer);\n    }\n    function defaultWriterReadyPromiseReject(writer, reason) {\n        setPromiseIsHandledToTrue(writer._readyPromise);\n        writer._readyPromise_reject(reason);\n        writer._readyPromise_resolve = undefined;\n        writer._readyPromise_reject = undefined;\n        writer._readyPromiseState = 'rejected';\n    }\n    function defaultWriterReadyPromiseReset(writer) {\n        defaultWriterReadyPromiseInitialize(writer);\n    }\n    function defaultWriterReadyPromiseResetToRejected(writer, reason) {\n        defaultWriterReadyPromiseInitializeAsRejected(writer, reason);\n    }\n    function defaultWriterReadyPromiseResolve(writer) {\n        writer._readyPromise_resolve(undefined);\n        writer._readyPromise_resolve = undefined;\n        writer._readyPromise_reject = undefined;\n        writer._readyPromiseState = 'fulfilled';\n    }\n\n    function isAbortSignal(value) {\n        if (typeof value !== 'object' || value === null) {\n            return false;\n        }\n        try {\n            return typeof value.aborted === 'boolean';\n        }\n        catch (_a) {\n            // AbortSignal.prototype.aborted throws if its brand check fails\n            return false;\n        }\n    }\n\n    /// <reference lib=\"dom\" />\n    var NativeDOMException = typeof DOMException !== 'undefined' ? DOMException : undefined;\n\n    /// <reference types=\"node\" />\n    function isDOMExceptionConstructor(ctor) {\n        if (!(typeof ctor === 'function' || typeof ctor === 'object')) {\n            return false;\n        }\n        try {\n            new ctor();\n            return true;\n        }\n        catch (_a) {\n            return false;\n        }\n    }\n    function createDOMExceptionPolyfill() {\n        var ctor = function DOMException(message, name) {\n            this.message = message || '';\n            this.name = name || 'Error';\n            if (Error.captureStackTrace) {\n                Error.captureStackTrace(this, this.constructor);\n            }\n        };\n        ctor.prototype = Object.create(Error.prototype);\n        Object.defineProperty(ctor.prototype, 'constructor', { value: ctor, writable: true, configurable: true });\n        return ctor;\n    }\n    var DOMException$1 = isDOMExceptionConstructor(NativeDOMException) ? NativeDOMException : createDOMExceptionPolyfill();\n\n    function ReadableStreamPipeTo(source, dest, preventClose, preventAbort, preventCancel, signal) {\n        var reader = AcquireReadableStreamDefaultReader(source);\n        var writer = AcquireWritableStreamDefaultWriter(dest);\n        source._disturbed = true;\n        var shuttingDown = false;\n        // This is used to keep track of the spec's requirement that we wait for ongoing writes during shutdown.\n        var currentWrite = promiseResolvedWith(undefined);\n        return newPromise(function (resolve, reject) {\n            var abortAlgorithm;\n            if (signal !== undefined) {\n                abortAlgorithm = function () {\n                    var error = new DOMException$1('Aborted', 'AbortError');\n                    var actions = [];\n                    if (preventAbort === false) {\n                        actions.push(function () {\n                            if (dest._state === 'writable') {\n                                return WritableStreamAbort(dest, error);\n                            }\n                            return promiseResolvedWith(undefined);\n                        });\n                    }\n                    if (preventCancel === false) {\n                        actions.push(function () {\n                            if (source._state === 'readable') {\n                                return ReadableStreamCancel(source, error);\n                            }\n                            return promiseResolvedWith(undefined);\n                        });\n                    }\n                    shutdownWithAction(function () { return Promise.all(actions.map(function (action) { return action(); })); }, true, error);\n                };\n                if (signal.aborted === true) {\n                    abortAlgorithm();\n                    return;\n                }\n                signal.addEventListener('abort', abortAlgorithm);\n            }\n            // Using reader and writer, read all chunks from this and write them to dest\n            // - Backpressure must be enforced\n            // - Shutdown must stop all activity\n            function pipeLoop() {\n                return newPromise(function (resolveLoop, rejectLoop) {\n                    function next(done) {\n                        if (done) {\n                            resolveLoop();\n                        }\n                        else {\n                            // Use `PerformPromiseThen` instead of `uponPromise` to avoid\n                            // adding unnecessary `.catch(rethrowAssertionErrorRejection)` handlers\n                            PerformPromiseThen(pipeStep(), next, rejectLoop);\n                        }\n                    }\n                    next(false);\n                });\n            }\n            function pipeStep() {\n                if (shuttingDown === true) {\n                    return promiseResolvedWith(true);\n                }\n                return PerformPromiseThen(writer._readyPromise, function () {\n                    return PerformPromiseThen(ReadableStreamDefaultReaderRead(reader), function (result) {\n                        if (result.done === true) {\n                            return true;\n                        }\n                        currentWrite = PerformPromiseThen(WritableStreamDefaultWriterWrite(writer, result.value), undefined, noop);\n                        return false;\n                    });\n                });\n            }\n            // Errors must be propagated forward\n            isOrBecomesErrored(source, reader._closedPromise, function (storedError) {\n                if (preventAbort === false) {\n                    shutdownWithAction(function () { return WritableStreamAbort(dest, storedError); }, true, storedError);\n                }\n                else {\n                    shutdown(true, storedError);\n                }\n            });\n            // Errors must be propagated backward\n            isOrBecomesErrored(dest, writer._closedPromise, function (storedError) {\n                if (preventCancel === false) {\n                    shutdownWithAction(function () { return ReadableStreamCancel(source, storedError); }, true, storedError);\n                }\n                else {\n                    shutdown(true, storedError);\n                }\n            });\n            // Closing must be propagated forward\n            isOrBecomesClosed(source, reader._closedPromise, function () {\n                if (preventClose === false) {\n                    shutdownWithAction(function () { return WritableStreamDefaultWriterCloseWithErrorPropagation(writer); });\n                }\n                else {\n                    shutdown();\n                }\n            });\n            // Closing must be propagated backward\n            if (WritableStreamCloseQueuedOrInFlight(dest) === true || dest._state === 'closed') {\n                var destClosed_1 = new TypeError('the destination writable stream closed before all data could be piped to it');\n                if (preventCancel === false) {\n                    shutdownWithAction(function () { return ReadableStreamCancel(source, destClosed_1); }, true, destClosed_1);\n                }\n                else {\n                    shutdown(true, destClosed_1);\n                }\n            }\n            setPromiseIsHandledToTrue(pipeLoop());\n            function waitForWritesToFinish() {\n                // Another write may have started while we were waiting on this currentWrite, so we have to be sure to wait\n                // for that too.\n                var oldCurrentWrite = currentWrite;\n                return PerformPromiseThen(currentWrite, function () { return oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined; });\n            }\n            function isOrBecomesErrored(stream, promise, action) {\n                if (stream._state === 'errored') {\n                    action(stream._storedError);\n                }\n                else {\n                    uponRejection(promise, action);\n                }\n            }\n            function isOrBecomesClosed(stream, promise, action) {\n                if (stream._state === 'closed') {\n                    action();\n                }\n                else {\n                    uponFulfillment(promise, action);\n                }\n            }\n            function shutdownWithAction(action, originalIsError, originalError) {\n                if (shuttingDown === true) {\n                    return;\n                }\n                shuttingDown = true;\n                if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) {\n                    uponFulfillment(waitForWritesToFinish(), doTheRest);\n                }\n                else {\n                    doTheRest();\n                }\n                function doTheRest() {\n                    uponPromise(action(), function () { return finalize(originalIsError, originalError); }, function (newError) { return finalize(true, newError); });\n                }\n            }\n            function shutdown(isError, error) {\n                if (shuttingDown === true) {\n                    return;\n                }\n                shuttingDown = true;\n                if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) {\n                    uponFulfillment(waitForWritesToFinish(), function () { return finalize(isError, error); });\n                }\n                else {\n                    finalize(isError, error);\n                }\n            }\n            function finalize(isError, error) {\n                WritableStreamDefaultWriterRelease(writer);\n                ReadableStreamReaderGenericRelease(reader);\n                if (signal !== undefined) {\n                    signal.removeEventListener('abort', abortAlgorithm);\n                }\n                if (isError) {\n                    reject(error);\n                }\n                else {\n                    resolve(undefined);\n                }\n            }\n        });\n    }\n\n    var ReadableStreamDefaultController = /** @class */ (function () {\n        /** @internal */\n        function ReadableStreamDefaultController() {\n            throw new TypeError();\n        }\n        Object.defineProperty(ReadableStreamDefaultController.prototype, \"desiredSize\", {\n            get: function () {\n                if (IsReadableStreamDefaultController(this) === false) {\n                    throw defaultControllerBrandCheckException('desiredSize');\n                }\n                return ReadableStreamDefaultControllerGetDesiredSize(this);\n            },\n            enumerable: true,\n            configurable: true\n        });\n        ReadableStreamDefaultController.prototype.close = function () {\n            if (IsReadableStreamDefaultController(this) === false) {\n                throw defaultControllerBrandCheckException('close');\n            }\n            if (ReadableStreamDefaultControllerCanCloseOrEnqueue(this) === false) {\n                throw new TypeError('The stream is not in a state that permits close');\n            }\n            ReadableStreamDefaultControllerClose(this);\n        };\n        ReadableStreamDefaultController.prototype.enqueue = function (chunk) {\n            if (IsReadableStreamDefaultController(this) === false) {\n                throw defaultControllerBrandCheckException('enqueue');\n            }\n            if (ReadableStreamDefaultControllerCanCloseOrEnqueue(this) === false) {\n                throw new TypeError('The stream is not in a state that permits enqueue');\n            }\n            return ReadableStreamDefaultControllerEnqueue(this, chunk);\n        };\n        ReadableStreamDefaultController.prototype.error = function (e) {\n            if (IsReadableStreamDefaultController(this) === false) {\n                throw defaultControllerBrandCheckException('error');\n            }\n            ReadableStreamDefaultControllerError(this, e);\n        };\n        /** @internal */\n        ReadableStreamDefaultController.prototype[CancelSteps] = function (reason) {\n            ResetQueue(this);\n            var result = this._cancelAlgorithm(reason);\n            ReadableStreamDefaultControllerClearAlgorithms(this);\n            return result;\n        };\n        /** @internal */\n        ReadableStreamDefaultController.prototype[PullSteps] = function () {\n            var stream = this._controlledReadableStream;\n            if (this._queue.length > 0) {\n                var chunk = DequeueValue(this);\n                if (this._closeRequested === true && this._queue.length === 0) {\n                    ReadableStreamDefaultControllerClearAlgorithms(this);\n                    ReadableStreamClose(stream);\n                }\n                else {\n                    ReadableStreamDefaultControllerCallPullIfNeeded(this);\n                }\n                return promiseResolvedWith(ReadableStreamCreateReadResult(chunk, false, stream._reader._forAuthorCode));\n            }\n            var pendingPromise = ReadableStreamAddReadRequest(stream);\n            ReadableStreamDefaultControllerCallPullIfNeeded(this);\n            return pendingPromise;\n        };\n        return ReadableStreamDefaultController;\n    }());\n    // Abstract operations for the ReadableStreamDefaultController.\n    function IsReadableStreamDefaultController(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableStream')) {\n            return false;\n        }\n        return true;\n    }\n    function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {\n        var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);\n        if (shouldPull === false) {\n            return;\n        }\n        if (controller._pulling === true) {\n            controller._pullAgain = true;\n            return;\n        }\n        controller._pulling = true;\n        var pullPromise = controller._pullAlgorithm();\n        uponPromise(pullPromise, function () {\n            controller._pulling = false;\n            if (controller._pullAgain === true) {\n                controller._pullAgain = false;\n                ReadableStreamDefaultControllerCallPullIfNeeded(controller);\n            }\n        }, function (e) {\n            ReadableStreamDefaultControllerError(controller, e);\n        });\n    }\n    function ReadableStreamDefaultControllerShouldCallPull(controller) {\n        var stream = controller._controlledReadableStream;\n        if (ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) === false) {\n            return false;\n        }\n        if (controller._started === false) {\n            return false;\n        }\n        if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {\n            return true;\n        }\n        var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);\n        if (desiredSize > 0) {\n            return true;\n        }\n        return false;\n    }\n    function ReadableStreamDefaultControllerClearAlgorithms(controller) {\n        controller._pullAlgorithm = undefined;\n        controller._cancelAlgorithm = undefined;\n        controller._strategySizeAlgorithm = undefined;\n    }\n    // A client of ReadableStreamDefaultController may use these functions directly to bypass state check.\n    function ReadableStreamDefaultControllerClose(controller) {\n        var stream = controller._controlledReadableStream;\n        controller._closeRequested = true;\n        if (controller._queue.length === 0) {\n            ReadableStreamDefaultControllerClearAlgorithms(controller);\n            ReadableStreamClose(stream);\n        }\n    }\n    function ReadableStreamDefaultControllerEnqueue(controller, chunk) {\n        var stream = controller._controlledReadableStream;\n        if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {\n            ReadableStreamFulfillReadRequest(stream, chunk, false);\n        }\n        else {\n            var chunkSize = void 0;\n            try {\n                chunkSize = controller._strategySizeAlgorithm(chunk);\n            }\n            catch (chunkSizeE) {\n                ReadableStreamDefaultControllerError(controller, chunkSizeE);\n                throw chunkSizeE;\n            }\n            try {\n                EnqueueValueWithSize(controller, chunk, chunkSize);\n            }\n            catch (enqueueE) {\n                ReadableStreamDefaultControllerError(controller, enqueueE);\n                throw enqueueE;\n            }\n        }\n        ReadableStreamDefaultControllerCallPullIfNeeded(controller);\n    }\n    function ReadableStreamDefaultControllerError(controller, e) {\n        var stream = controller._controlledReadableStream;\n        if (stream._state !== 'readable') {\n            return;\n        }\n        ResetQueue(controller);\n        ReadableStreamDefaultControllerClearAlgorithms(controller);\n        ReadableStreamError(stream, e);\n    }\n    function ReadableStreamDefaultControllerGetDesiredSize(controller) {\n        var stream = controller._controlledReadableStream;\n        var state = stream._state;\n        if (state === 'errored') {\n            return null;\n        }\n        if (state === 'closed') {\n            return 0;\n        }\n        return controller._strategyHWM - controller._queueTotalSize;\n    }\n    // This is used in the implementation of TransformStream.\n    function ReadableStreamDefaultControllerHasBackpressure(controller) {\n        if (ReadableStreamDefaultControllerShouldCallPull(controller) === true) {\n            return false;\n        }\n        return true;\n    }\n    function ReadableStreamDefaultControllerCanCloseOrEnqueue(controller) {\n        var state = controller._controlledReadableStream._state;\n        if (controller._closeRequested === false && state === 'readable') {\n            return true;\n        }\n        return false;\n    }\n    function SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {\n        controller._controlledReadableStream = stream;\n        controller._queue = undefined;\n        controller._queueTotalSize = undefined;\n        ResetQueue(controller);\n        controller._started = false;\n        controller._closeRequested = false;\n        controller._pullAgain = false;\n        controller._pulling = false;\n        controller._strategySizeAlgorithm = sizeAlgorithm;\n        controller._strategyHWM = highWaterMark;\n        controller._pullAlgorithm = pullAlgorithm;\n        controller._cancelAlgorithm = cancelAlgorithm;\n        stream._readableStreamController = controller;\n        var startResult = startAlgorithm();\n        uponPromise(promiseResolvedWith(startResult), function () {\n            controller._started = true;\n            ReadableStreamDefaultControllerCallPullIfNeeded(controller);\n        }, function (r) {\n            ReadableStreamDefaultControllerError(controller, r);\n        });\n    }\n    function SetUpReadableStreamDefaultControllerFromUnderlyingSource(stream, underlyingSource, highWaterMark, sizeAlgorithm) {\n        var controller = Object.create(ReadableStreamDefaultController.prototype);\n        function startAlgorithm() {\n            return InvokeOrNoop(underlyingSource, 'start', [controller]);\n        }\n        var pullAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSource, 'pull', 0, [controller]);\n        var cancelAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingSource, 'cancel', 1, []);\n        SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);\n    }\n    // Helper functions for the ReadableStreamDefaultController.\n    function defaultControllerBrandCheckException(name) {\n        return new TypeError(\"ReadableStreamDefaultController.prototype.\" + name + \" can only be used on a ReadableStreamDefaultController\");\n    }\n\n    function ReadableStreamTee(stream, cloneForBranch2) {\n        var reader = AcquireReadableStreamDefaultReader(stream);\n        var reading = false;\n        var canceled1 = false;\n        var canceled2 = false;\n        var reason1;\n        var reason2;\n        var branch1;\n        var branch2;\n        var resolveCancelPromise;\n        var cancelPromise = newPromise(function (resolve) {\n            resolveCancelPromise = resolve;\n        });\n        function pullAlgorithm() {\n            if (reading === true) {\n                return promiseResolvedWith(undefined);\n            }\n            reading = true;\n            var readPromise = transformPromiseWith(ReadableStreamDefaultReaderRead(reader), function (result) {\n                reading = false;\n                var done = result.done;\n                if (done === true) {\n                    if (canceled1 === false) {\n                        ReadableStreamDefaultControllerClose(branch1._readableStreamController);\n                    }\n                    if (canceled2 === false) {\n                        ReadableStreamDefaultControllerClose(branch2._readableStreamController);\n                    }\n                    return;\n                }\n                var value = result.value;\n                var value1 = value;\n                var value2 = value;\n                // There is no way to access the cloning code right now in the reference implementation.\n                // If we add one then we'll need an implementation for serializable objects.\n                // if (canceled2 === false && cloneForBranch2 === true) {\n                //   value2 = StructuredDeserialize(StructuredSerialize(value2));\n                // }\n                if (canceled1 === false) {\n                    ReadableStreamDefaultControllerEnqueue(branch1._readableStreamController, value1);\n                }\n                if (canceled2 === false) {\n                    ReadableStreamDefaultControllerEnqueue(branch2._readableStreamController, value2);\n                }\n            });\n            setPromiseIsHandledToTrue(readPromise);\n            return promiseResolvedWith(undefined);\n        }\n        function cancel1Algorithm(reason) {\n            canceled1 = true;\n            reason1 = reason;\n            if (canceled2 === true) {\n                var compositeReason = createArrayFromList([reason1, reason2]);\n                var cancelResult = ReadableStreamCancel(stream, compositeReason);\n                resolveCancelPromise(cancelResult);\n            }\n            return cancelPromise;\n        }\n        function cancel2Algorithm(reason) {\n            canceled2 = true;\n            reason2 = reason;\n            if (canceled1 === true) {\n                var compositeReason = createArrayFromList([reason1, reason2]);\n                var cancelResult = ReadableStreamCancel(stream, compositeReason);\n                resolveCancelPromise(cancelResult);\n            }\n            return cancelPromise;\n        }\n        function startAlgorithm() { }\n        branch1 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel1Algorithm);\n        branch2 = CreateReadableStream(startAlgorithm, pullAlgorithm, cancel2Algorithm);\n        uponRejection(reader._closedPromise, function (r) {\n            ReadableStreamDefaultControllerError(branch1._readableStreamController, r);\n            ReadableStreamDefaultControllerError(branch2._readableStreamController, r);\n        });\n        return [branch1, branch2];\n    }\n\n    /// <reference lib=\"es2015.core\" />\n    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/isInteger#Polyfill\n    var NumberIsInteger = Number.isInteger || function (value) {\n        return typeof value === 'number' &&\n            isFinite(value) &&\n            Math.floor(value) === value;\n    };\n\n    var ReadableStreamBYOBRequest = /** @class */ (function () {\n        /** @internal */\n        function ReadableStreamBYOBRequest() {\n            throw new TypeError('ReadableStreamBYOBRequest cannot be used directly');\n        }\n        Object.defineProperty(ReadableStreamBYOBRequest.prototype, \"view\", {\n            get: function () {\n                if (IsReadableStreamBYOBRequest(this) === false) {\n                    throw byobRequestBrandCheckException('view');\n                }\n                return this._view;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        ReadableStreamBYOBRequest.prototype.respond = function (bytesWritten) {\n            if (IsReadableStreamBYOBRequest(this) === false) {\n                throw byobRequestBrandCheckException('respond');\n            }\n            if (this._associatedReadableByteStreamController === undefined) {\n                throw new TypeError('This BYOB request has been invalidated');\n            }\n            if (IsDetachedBuffer(this._view.buffer) === true) ;\n            ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);\n        };\n        ReadableStreamBYOBRequest.prototype.respondWithNewView = function (view) {\n            if (IsReadableStreamBYOBRequest(this) === false) {\n                throw byobRequestBrandCheckException('respond');\n            }\n            if (this._associatedReadableByteStreamController === undefined) {\n                throw new TypeError('This BYOB request has been invalidated');\n            }\n            if (!ArrayBuffer.isView(view)) {\n                throw new TypeError('You can only respond with array buffer views');\n            }\n            if (IsDetachedBuffer(view.buffer) === true) ;\n            ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);\n        };\n        return ReadableStreamBYOBRequest;\n    }());\n    var ReadableByteStreamController = /** @class */ (function () {\n        /** @internal */\n        function ReadableByteStreamController() {\n            throw new TypeError('ReadableByteStreamController constructor cannot be used directly');\n        }\n        Object.defineProperty(ReadableByteStreamController.prototype, \"byobRequest\", {\n            get: function () {\n                if (IsReadableByteStreamController(this) === false) {\n                    throw byteStreamControllerBrandCheckException('byobRequest');\n                }\n                if (this._byobRequest === undefined && this._pendingPullIntos.length > 0) {\n                    var firstDescriptor = this._pendingPullIntos.peek();\n                    var view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);\n                    var byobRequest = Object.create(ReadableStreamBYOBRequest.prototype);\n                    SetUpReadableStreamBYOBRequest(byobRequest, this, view);\n                    this._byobRequest = byobRequest;\n                }\n                return this._byobRequest;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        Object.defineProperty(ReadableByteStreamController.prototype, \"desiredSize\", {\n            get: function () {\n                if (IsReadableByteStreamController(this) === false) {\n                    throw byteStreamControllerBrandCheckException('desiredSize');\n                }\n                return ReadableByteStreamControllerGetDesiredSize(this);\n            },\n            enumerable: true,\n            configurable: true\n        });\n        ReadableByteStreamController.prototype.close = function () {\n            if (IsReadableByteStreamController(this) === false) {\n                throw byteStreamControllerBrandCheckException('close');\n            }\n            if (this._closeRequested === true) {\n                throw new TypeError('The stream has already been closed; do not close it again!');\n            }\n            var state = this._controlledReadableByteStream._state;\n            if (state !== 'readable') {\n                throw new TypeError(\"The stream (in \" + state + \" state) is not in the readable state and cannot be closed\");\n            }\n            ReadableByteStreamControllerClose(this);\n        };\n        ReadableByteStreamController.prototype.enqueue = function (chunk) {\n            if (IsReadableByteStreamController(this) === false) {\n                throw byteStreamControllerBrandCheckException('enqueue');\n            }\n            if (this._closeRequested === true) {\n                throw new TypeError('stream is closed or draining');\n            }\n            var state = this._controlledReadableByteStream._state;\n            if (state !== 'readable') {\n                throw new TypeError(\"The stream (in \" + state + \" state) is not in the readable state and cannot be enqueued to\");\n            }\n            if (!ArrayBuffer.isView(chunk)) {\n                throw new TypeError('You can only enqueue array buffer views when using a ReadableByteStreamController');\n            }\n            if (IsDetachedBuffer(chunk.buffer) === true) ;\n            ReadableByteStreamControllerEnqueue(this, chunk);\n        };\n        ReadableByteStreamController.prototype.error = function (e) {\n            if (IsReadableByteStreamController(this) === false) {\n                throw byteStreamControllerBrandCheckException('error');\n            }\n            ReadableByteStreamControllerError(this, e);\n        };\n        /** @internal */\n        ReadableByteStreamController.prototype[CancelSteps] = function (reason) {\n            if (this._pendingPullIntos.length > 0) {\n                var firstDescriptor = this._pendingPullIntos.peek();\n                firstDescriptor.bytesFilled = 0;\n            }\n            ResetQueue(this);\n            var result = this._cancelAlgorithm(reason);\n            ReadableByteStreamControllerClearAlgorithms(this);\n            return result;\n        };\n        /** @internal */\n        ReadableByteStreamController.prototype[PullSteps] = function () {\n            var stream = this._controlledReadableByteStream;\n            if (this._queueTotalSize > 0) {\n                var entry = this._queue.shift();\n                this._queueTotalSize -= entry.byteLength;\n                ReadableByteStreamControllerHandleQueueDrain(this);\n                var view = void 0;\n                try {\n                    view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);\n                }\n                catch (viewE) {\n                    return promiseRejectedWith(viewE);\n                }\n                return promiseResolvedWith(ReadableStreamCreateReadResult(view, false, stream._reader._forAuthorCode));\n            }\n            var autoAllocateChunkSize = this._autoAllocateChunkSize;\n            if (autoAllocateChunkSize !== undefined) {\n                var buffer = void 0;\n                try {\n                    buffer = new ArrayBuffer(autoAllocateChunkSize);\n                }\n                catch (bufferE) {\n                    return promiseRejectedWith(bufferE);\n                }\n                var pullIntoDescriptor = {\n                    buffer: buffer,\n                    byteOffset: 0,\n                    byteLength: autoAllocateChunkSize,\n                    bytesFilled: 0,\n                    elementSize: 1,\n                    ctor: Uint8Array,\n                    readerType: 'default'\n                };\n                this._pendingPullIntos.push(pullIntoDescriptor);\n            }\n            var promise = ReadableStreamAddReadRequest(stream);\n            ReadableByteStreamControllerCallPullIfNeeded(this);\n            return promise;\n        };\n        return ReadableByteStreamController;\n    }());\n    // Abstract operations for the ReadableByteStreamController.\n    function IsReadableByteStreamController(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_controlledReadableByteStream')) {\n            return false;\n        }\n        return true;\n    }\n    function IsReadableStreamBYOBRequest(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {\n            return false;\n        }\n        return true;\n    }\n    function ReadableByteStreamControllerCallPullIfNeeded(controller) {\n        var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);\n        if (shouldPull === false) {\n            return;\n        }\n        if (controller._pulling === true) {\n            controller._pullAgain = true;\n            return;\n        }\n        controller._pulling = true;\n        // TODO: Test controller argument\n        var pullPromise = controller._pullAlgorithm();\n        uponPromise(pullPromise, function () {\n            controller._pulling = false;\n            if (controller._pullAgain === true) {\n                controller._pullAgain = false;\n                ReadableByteStreamControllerCallPullIfNeeded(controller);\n            }\n        }, function (e) {\n            ReadableByteStreamControllerError(controller, e);\n        });\n    }\n    function ReadableByteStreamControllerClearPendingPullIntos(controller) {\n        ReadableByteStreamControllerInvalidateBYOBRequest(controller);\n        controller._pendingPullIntos = new SimpleQueue();\n    }\n    function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {\n        var done = false;\n        if (stream._state === 'closed') {\n            done = true;\n        }\n        var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);\n        if (pullIntoDescriptor.readerType === 'default') {\n            ReadableStreamFulfillReadRequest(stream, filledView, done);\n        }\n        else {\n            ReadableStreamFulfillReadIntoRequest(stream, filledView, done);\n        }\n    }\n    function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {\n        var bytesFilled = pullIntoDescriptor.bytesFilled;\n        var elementSize = pullIntoDescriptor.elementSize;\n        return new pullIntoDescriptor.ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);\n    }\n    function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {\n        controller._queue.push({ buffer: buffer, byteOffset: byteOffset, byteLength: byteLength });\n        controller._queueTotalSize += byteLength;\n    }\n    function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {\n        var elementSize = pullIntoDescriptor.elementSize;\n        var currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;\n        var maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);\n        var maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;\n        var maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;\n        var totalBytesToCopyRemaining = maxBytesToCopy;\n        var ready = false;\n        if (maxAlignedBytes > currentAlignedBytes) {\n            totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;\n            ready = true;\n        }\n        var queue = controller._queue;\n        while (totalBytesToCopyRemaining > 0) {\n            var headOfQueue = queue.peek();\n            var bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);\n            var destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;\n            ArrayBufferCopy(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);\n            if (headOfQueue.byteLength === bytesToCopy) {\n                queue.shift();\n            }\n            else {\n                headOfQueue.byteOffset += bytesToCopy;\n                headOfQueue.byteLength -= bytesToCopy;\n            }\n            controller._queueTotalSize -= bytesToCopy;\n            ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);\n            totalBytesToCopyRemaining -= bytesToCopy;\n        }\n        return ready;\n    }\n    function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {\n        ReadableByteStreamControllerInvalidateBYOBRequest(controller);\n        pullIntoDescriptor.bytesFilled += size;\n    }\n    function ReadableByteStreamControllerHandleQueueDrain(controller) {\n        if (controller._queueTotalSize === 0 && controller._closeRequested === true) {\n            ReadableByteStreamControllerClearAlgorithms(controller);\n            ReadableStreamClose(controller._controlledReadableByteStream);\n        }\n        else {\n            ReadableByteStreamControllerCallPullIfNeeded(controller);\n        }\n    }\n    function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {\n        if (controller._byobRequest === undefined) {\n            return;\n        }\n        controller._byobRequest._associatedReadableByteStreamController = undefined;\n        controller._byobRequest._view = undefined;\n        controller._byobRequest = undefined;\n    }\n    function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {\n        while (controller._pendingPullIntos.length > 0) {\n            if (controller._queueTotalSize === 0) {\n                return;\n            }\n            var pullIntoDescriptor = controller._pendingPullIntos.peek();\n            if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {\n                ReadableByteStreamControllerShiftPendingPullInto(controller);\n                ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);\n            }\n        }\n    }\n    function ReadableByteStreamControllerPullInto(controller, view) {\n        var stream = controller._controlledReadableByteStream;\n        var elementSize = 1;\n        if (view.constructor !== DataView) {\n            elementSize = view.constructor.BYTES_PER_ELEMENT;\n        }\n        var ctor = view.constructor;\n        var buffer = TransferArrayBuffer(view.buffer);\n        var pullIntoDescriptor = {\n            buffer: buffer,\n            byteOffset: view.byteOffset,\n            byteLength: view.byteLength,\n            bytesFilled: 0,\n            elementSize: elementSize,\n            ctor: ctor,\n            readerType: 'byob'\n        };\n        if (controller._pendingPullIntos.length > 0) {\n            controller._pendingPullIntos.push(pullIntoDescriptor);\n            // No ReadableByteStreamControllerCallPullIfNeeded() call since:\n            // - No change happens on desiredSize\n            // - The source has already been notified of that there's at least 1 pending read(view)\n            return ReadableStreamAddReadIntoRequest(stream);\n        }\n        if (stream._state === 'closed') {\n            var emptyView = new ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);\n            return promiseResolvedWith(ReadableStreamCreateReadResult(emptyView, true, stream._reader._forAuthorCode));\n        }\n        if (controller._queueTotalSize > 0) {\n            if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {\n                var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);\n                ReadableByteStreamControllerHandleQueueDrain(controller);\n                return promiseResolvedWith(ReadableStreamCreateReadResult(filledView, false, stream._reader._forAuthorCode));\n            }\n            if (controller._closeRequested === true) {\n                var e = new TypeError('Insufficient bytes to fill elements in the given buffer');\n                ReadableByteStreamControllerError(controller, e);\n                return promiseRejectedWith(e);\n            }\n        }\n        controller._pendingPullIntos.push(pullIntoDescriptor);\n        var promise = ReadableStreamAddReadIntoRequest(stream);\n        ReadableByteStreamControllerCallPullIfNeeded(controller);\n        return promise;\n    }\n    function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {\n        firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);\n        var stream = controller._controlledReadableByteStream;\n        if (ReadableStreamHasBYOBReader(stream) === true) {\n            while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {\n                var pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);\n                ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);\n            }\n        }\n    }\n    function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {\n        if (pullIntoDescriptor.bytesFilled + bytesWritten > pullIntoDescriptor.byteLength) {\n            throw new RangeError('bytesWritten out of range');\n        }\n        ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);\n        if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {\n            // TODO: Figure out whether we should detach the buffer or not here.\n            return;\n        }\n        ReadableByteStreamControllerShiftPendingPullInto(controller);\n        var remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;\n        if (remainderSize > 0) {\n            var end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;\n            var remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end);\n            ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);\n        }\n        pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);\n        pullIntoDescriptor.bytesFilled -= remainderSize;\n        ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableByteStream, pullIntoDescriptor);\n        ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);\n    }\n    function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {\n        var firstDescriptor = controller._pendingPullIntos.peek();\n        var stream = controller._controlledReadableByteStream;\n        if (stream._state === 'closed') {\n            if (bytesWritten !== 0) {\n                throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');\n            }\n            ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);\n        }\n        else {\n            ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);\n        }\n        ReadableByteStreamControllerCallPullIfNeeded(controller);\n    }\n    function ReadableByteStreamControllerShiftPendingPullInto(controller) {\n        var descriptor = controller._pendingPullIntos.shift();\n        ReadableByteStreamControllerInvalidateBYOBRequest(controller);\n        return descriptor;\n    }\n    function ReadableByteStreamControllerShouldCallPull(controller) {\n        var stream = controller._controlledReadableByteStream;\n        if (stream._state !== 'readable') {\n            return false;\n        }\n        if (controller._closeRequested === true) {\n            return false;\n        }\n        if (controller._started === false) {\n            return false;\n        }\n        if (ReadableStreamHasDefaultReader(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {\n            return true;\n        }\n        if (ReadableStreamHasBYOBReader(stream) === true && ReadableStreamGetNumReadIntoRequests(stream) > 0) {\n            return true;\n        }\n        var desiredSize = ReadableByteStreamControllerGetDesiredSize(controller);\n        if (desiredSize > 0) {\n            return true;\n        }\n        return false;\n    }\n    function ReadableByteStreamControllerClearAlgorithms(controller) {\n        controller._pullAlgorithm = undefined;\n        controller._cancelAlgorithm = undefined;\n    }\n    // A client of ReadableByteStreamController may use these functions directly to bypass state check.\n    function ReadableByteStreamControllerClose(controller) {\n        var stream = controller._controlledReadableByteStream;\n        if (controller._queueTotalSize > 0) {\n            controller._closeRequested = true;\n            return;\n        }\n        if (controller._pendingPullIntos.length > 0) {\n            var firstPendingPullInto = controller._pendingPullIntos.peek();\n            if (firstPendingPullInto.bytesFilled > 0) {\n                var e = new TypeError('Insufficient bytes to fill elements in the given buffer');\n                ReadableByteStreamControllerError(controller, e);\n                throw e;\n            }\n        }\n        ReadableByteStreamControllerClearAlgorithms(controller);\n        ReadableStreamClose(stream);\n    }\n    function ReadableByteStreamControllerEnqueue(controller, chunk) {\n        var stream = controller._controlledReadableByteStream;\n        var buffer = chunk.buffer;\n        var byteOffset = chunk.byteOffset;\n        var byteLength = chunk.byteLength;\n        var transferredBuffer = TransferArrayBuffer(buffer);\n        if (ReadableStreamHasDefaultReader(stream) === true) {\n            if (ReadableStreamGetNumReadRequests(stream) === 0) {\n                ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);\n            }\n            else {\n                var transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);\n                ReadableStreamFulfillReadRequest(stream, transferredView, false);\n            }\n        }\n        else if (ReadableStreamHasBYOBReader(stream) === true) {\n            // TODO: Ideally in this branch detaching should happen only if the buffer is not consumed fully.\n            ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);\n            ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);\n        }\n        else {\n            ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);\n        }\n        ReadableByteStreamControllerCallPullIfNeeded(controller);\n    }\n    function ReadableByteStreamControllerError(controller, e) {\n        var stream = controller._controlledReadableByteStream;\n        if (stream._state !== 'readable') {\n            return;\n        }\n        ReadableByteStreamControllerClearPendingPullIntos(controller);\n        ResetQueue(controller);\n        ReadableByteStreamControllerClearAlgorithms(controller);\n        ReadableStreamError(stream, e);\n    }\n    function ReadableByteStreamControllerGetDesiredSize(controller) {\n        var stream = controller._controlledReadableByteStream;\n        var state = stream._state;\n        if (state === 'errored') {\n            return null;\n        }\n        if (state === 'closed') {\n            return 0;\n        }\n        return controller._strategyHWM - controller._queueTotalSize;\n    }\n    function ReadableByteStreamControllerRespond(controller, bytesWritten) {\n        bytesWritten = Number(bytesWritten);\n        if (IsFiniteNonNegativeNumber(bytesWritten) === false) {\n            throw new RangeError('bytesWritten must be a finite');\n        }\n        ReadableByteStreamControllerRespondInternal(controller, bytesWritten);\n    }\n    function ReadableByteStreamControllerRespondWithNewView(controller, view) {\n        var firstDescriptor = controller._pendingPullIntos.peek();\n        if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {\n            throw new RangeError('The region specified by view does not match byobRequest');\n        }\n        if (firstDescriptor.byteLength !== view.byteLength) {\n            throw new RangeError('The buffer of view has different capacity than byobRequest');\n        }\n        firstDescriptor.buffer = view.buffer;\n        ReadableByteStreamControllerRespondInternal(controller, view.byteLength);\n    }\n    function SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize) {\n        controller._controlledReadableByteStream = stream;\n        controller._pullAgain = false;\n        controller._pulling = false;\n        controller._byobRequest = undefined;\n        // Need to set the slots so that the assert doesn't fire. In the spec the slots already exist implicitly.\n        controller._queue = controller._queueTotalSize = undefined;\n        ResetQueue(controller);\n        controller._closeRequested = false;\n        controller._started = false;\n        controller._strategyHWM = ValidateAndNormalizeHighWaterMark(highWaterMark);\n        controller._pullAlgorithm = pullAlgorithm;\n        controller._cancelAlgorithm = cancelAlgorithm;\n        controller._autoAllocateChunkSize = autoAllocateChunkSize;\n        controller._pendingPullIntos = new SimpleQueue();\n        stream._readableStreamController = controller;\n        var startResult = startAlgorithm();\n        uponPromise(promiseResolvedWith(startResult), function () {\n            controller._started = true;\n            ReadableByteStreamControllerCallPullIfNeeded(controller);\n        }, function (r) {\n            ReadableByteStreamControllerError(controller, r);\n        });\n    }\n    function SetUpReadableByteStreamControllerFromUnderlyingSource(stream, underlyingByteSource, highWaterMark) {\n        var controller = Object.create(ReadableByteStreamController.prototype);\n        function startAlgorithm() {\n            return InvokeOrNoop(underlyingByteSource, 'start', [controller]);\n        }\n        var pullAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingByteSource, 'pull', 0, [controller]);\n        var cancelAlgorithm = CreateAlgorithmFromUnderlyingMethod(underlyingByteSource, 'cancel', 1, []);\n        var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;\n        if (autoAllocateChunkSize !== undefined) {\n            autoAllocateChunkSize = Number(autoAllocateChunkSize);\n            if (NumberIsInteger(autoAllocateChunkSize) === false || autoAllocateChunkSize <= 0) {\n                throw new RangeError('autoAllocateChunkSize must be a positive integer');\n            }\n        }\n        SetUpReadableByteStreamController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, autoAllocateChunkSize);\n    }\n    function SetUpReadableStreamBYOBRequest(request, controller, view) {\n        request._associatedReadableByteStreamController = controller;\n        request._view = view;\n    }\n    // Helper functions for the ReadableStreamBYOBRequest.\n    function byobRequestBrandCheckException(name) {\n        return new TypeError(\"ReadableStreamBYOBRequest.prototype.\" + name + \" can only be used on a ReadableStreamBYOBRequest\");\n    }\n    // Helper functions for the ReadableByteStreamController.\n    function byteStreamControllerBrandCheckException(name) {\n        return new TypeError(\"ReadableByteStreamController.prototype.\" + name + \" can only be used on a ReadableByteStreamController\");\n    }\n\n    // Abstract operations for the ReadableStream.\n    function AcquireReadableStreamBYOBReader(stream, forAuthorCode) {\n        if (forAuthorCode === void 0) { forAuthorCode = false; }\n        var reader = new ReadableStreamBYOBReader(stream);\n        reader._forAuthorCode = forAuthorCode;\n        return reader;\n    }\n    // ReadableStream API exposed for controllers.\n    function ReadableStreamAddReadIntoRequest(stream) {\n        var promise = newPromise(function (resolve, reject) {\n            var readIntoRequest = {\n                _resolve: resolve,\n                _reject: reject\n            };\n            stream._reader._readIntoRequests.push(readIntoRequest);\n        });\n        return promise;\n    }\n    function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {\n        var reader = stream._reader;\n        var readIntoRequest = reader._readIntoRequests.shift();\n        readIntoRequest._resolve(ReadableStreamCreateReadResult(chunk, done, reader._forAuthorCode));\n    }\n    function ReadableStreamGetNumReadIntoRequests(stream) {\n        return stream._reader._readIntoRequests.length;\n    }\n    function ReadableStreamHasBYOBReader(stream) {\n        var reader = stream._reader;\n        if (reader === undefined) {\n            return false;\n        }\n        if (!IsReadableStreamBYOBReader(reader)) {\n            return false;\n        }\n        return true;\n    }\n    var ReadableStreamBYOBReader = /** @class */ (function () {\n        function ReadableStreamBYOBReader(stream) {\n            if (!IsReadableStream(stream)) {\n                throw new TypeError('ReadableStreamBYOBReader can only be constructed with a ReadableStream instance given a ' +\n                    'byte source');\n            }\n            if (IsReadableByteStreamController(stream._readableStreamController) === false) {\n                throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte ' +\n                    'source');\n            }\n            if (IsReadableStreamLocked(stream)) {\n                throw new TypeError('This stream has already been locked for exclusive reading by another reader');\n            }\n            ReadableStreamReaderGenericInitialize(this, stream);\n            this._readIntoRequests = new SimpleQueue();\n        }\n        Object.defineProperty(ReadableStreamBYOBReader.prototype, \"closed\", {\n            get: function () {\n                if (!IsReadableStreamBYOBReader(this)) {\n                    return promiseRejectedWith(byobReaderBrandCheckException('closed'));\n                }\n                return this._closedPromise;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        ReadableStreamBYOBReader.prototype.cancel = function (reason) {\n            if (!IsReadableStreamBYOBReader(this)) {\n                return promiseRejectedWith(byobReaderBrandCheckException('cancel'));\n            }\n            if (this._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('cancel'));\n            }\n            return ReadableStreamReaderGenericCancel(this, reason);\n        };\n        ReadableStreamBYOBReader.prototype.read = function (view) {\n            if (!IsReadableStreamBYOBReader(this)) {\n                return promiseRejectedWith(byobReaderBrandCheckException('read'));\n            }\n            if (this._ownerReadableStream === undefined) {\n                return promiseRejectedWith(readerLockException('read from'));\n            }\n            if (!ArrayBuffer.isView(view)) {\n                return promiseRejectedWith(new TypeError('view must be an array buffer view'));\n            }\n            if (IsDetachedBuffer(view.buffer) === true) ;\n            if (view.byteLength === 0) {\n                return promiseRejectedWith(new TypeError('view must have non-zero byteLength'));\n            }\n            return ReadableStreamBYOBReaderRead(this, view);\n        };\n        ReadableStreamBYOBReader.prototype.releaseLock = function () {\n            if (!IsReadableStreamBYOBReader(this)) {\n                throw byobReaderBrandCheckException('releaseLock');\n            }\n            if (this._ownerReadableStream === undefined) {\n                return;\n            }\n            if (this._readIntoRequests.length > 0) {\n                throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');\n            }\n            ReadableStreamReaderGenericRelease(this);\n        };\n        return ReadableStreamBYOBReader;\n    }());\n    // Abstract operations for the readers.\n    function IsReadableStreamBYOBReader(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {\n            return false;\n        }\n        return true;\n    }\n    function ReadableStreamBYOBReaderRead(reader, view) {\n        var stream = reader._ownerReadableStream;\n        stream._disturbed = true;\n        if (stream._state === 'errored') {\n            return promiseRejectedWith(stream._storedError);\n        }\n        // Controllers must implement this.\n        return ReadableByteStreamControllerPullInto(stream._readableStreamController, view);\n    }\n    // Helper functions for the ReadableStreamBYOBReader.\n    function byobReaderBrandCheckException(name) {\n        return new TypeError(\"ReadableStreamBYOBReader.prototype.\" + name + \" can only be used on a ReadableStreamBYOBReader\");\n    }\n\n    var ReadableStream = /** @class */ (function () {\n        function ReadableStream(underlyingSource, strategy) {\n            if (underlyingSource === void 0) { underlyingSource = {}; }\n            if (strategy === void 0) { strategy = {}; }\n            InitializeReadableStream(this);\n            var size = strategy.size;\n            var highWaterMark = strategy.highWaterMark;\n            var type = underlyingSource.type;\n            var typeString = String(type);\n            if (typeString === 'bytes') {\n                if (size !== undefined) {\n                    throw new RangeError('The strategy for a byte stream cannot have a size function');\n                }\n                if (highWaterMark === undefined) {\n                    highWaterMark = 0;\n                }\n                highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark);\n                SetUpReadableByteStreamControllerFromUnderlyingSource(this, underlyingSource, highWaterMark);\n            }\n            else if (type === undefined) {\n                var sizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(size);\n                if (highWaterMark === undefined) {\n                    highWaterMark = 1;\n                }\n                highWaterMark = ValidateAndNormalizeHighWaterMark(highWaterMark);\n                SetUpReadableStreamDefaultControllerFromUnderlyingSource(this, underlyingSource, highWaterMark, sizeAlgorithm);\n            }\n            else {\n                throw new RangeError('Invalid type is specified');\n            }\n        }\n        Object.defineProperty(ReadableStream.prototype, \"locked\", {\n            get: function () {\n                if (IsReadableStream(this) === false) {\n                    throw streamBrandCheckException$1('locked');\n                }\n                return IsReadableStreamLocked(this);\n            },\n            enumerable: true,\n            configurable: true\n        });\n        ReadableStream.prototype.cancel = function (reason) {\n            if (IsReadableStream(this) === false) {\n                return promiseRejectedWith(streamBrandCheckException$1('cancel'));\n            }\n            if (IsReadableStreamLocked(this) === true) {\n                return promiseRejectedWith(new TypeError('Cannot cancel a stream that already has a reader'));\n            }\n            return ReadableStreamCancel(this, reason);\n        };\n        ReadableStream.prototype.getReader = function (_a) {\n            var mode = (_a === void 0 ? {} : _a).mode;\n            if (IsReadableStream(this) === false) {\n                throw streamBrandCheckException$1('getReader');\n            }\n            if (mode === undefined) {\n                return AcquireReadableStreamDefaultReader(this, true);\n            }\n            mode = String(mode);\n            if (mode === 'byob') {\n                return AcquireReadableStreamBYOBReader(this, true);\n            }\n            throw new RangeError('Invalid mode is specified');\n        };\n        ReadableStream.prototype.pipeThrough = function (_a, _b) {\n            var writable = _a.writable, readable = _a.readable;\n            var _c = _b === void 0 ? {} : _b, preventClose = _c.preventClose, preventAbort = _c.preventAbort, preventCancel = _c.preventCancel, signal = _c.signal;\n            if (IsReadableStream(this) === false) {\n                throw streamBrandCheckException$1('pipeThrough');\n            }\n            if (IsWritableStream(writable) === false) {\n                throw new TypeError('writable argument to pipeThrough must be a WritableStream');\n            }\n            if (IsReadableStream(readable) === false) {\n                throw new TypeError('readable argument to pipeThrough must be a ReadableStream');\n            }\n            preventClose = Boolean(preventClose);\n            preventAbort = Boolean(preventAbort);\n            preventCancel = Boolean(preventCancel);\n            if (signal !== undefined && !isAbortSignal(signal)) {\n                throw new TypeError('ReadableStream.prototype.pipeThrough\\'s signal option must be an AbortSignal');\n            }\n            if (IsReadableStreamLocked(this) === true) {\n                throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked ReadableStream');\n            }\n            if (IsWritableStreamLocked(writable) === true) {\n                throw new TypeError('ReadableStream.prototype.pipeThrough cannot be used on a locked WritableStream');\n            }\n            var promise = ReadableStreamPipeTo(this, writable, preventClose, preventAbort, preventCancel, signal);\n            setPromiseIsHandledToTrue(promise);\n            return readable;\n        };\n        ReadableStream.prototype.pipeTo = function (dest, _a) {\n            var _b = _a === void 0 ? {} : _a, preventClose = _b.preventClose, preventAbort = _b.preventAbort, preventCancel = _b.preventCancel, signal = _b.signal;\n            if (IsReadableStream(this) === false) {\n                return promiseRejectedWith(streamBrandCheckException$1('pipeTo'));\n            }\n            if (IsWritableStream(dest) === false) {\n                return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo\\'s first argument must be a WritableStream'));\n            }\n            preventClose = Boolean(preventClose);\n            preventAbort = Boolean(preventAbort);\n            preventCancel = Boolean(preventCancel);\n            if (signal !== undefined && !isAbortSignal(signal)) {\n                return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo\\'s signal option must be an AbortSignal'));\n            }\n            if (IsReadableStreamLocked(this) === true) {\n                return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream'));\n            }\n            if (IsWritableStreamLocked(dest) === true) {\n                return promiseRejectedWith(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream'));\n            }\n            return ReadableStreamPipeTo(this, dest, preventClose, preventAbort, preventCancel, signal);\n        };\n        ReadableStream.prototype.tee = function () {\n            if (IsReadableStream(this) === false) {\n                throw streamBrandCheckException$1('tee');\n            }\n            var branches = ReadableStreamTee(this);\n            return createArrayFromList(branches);\n        };\n        ReadableStream.prototype.getIterator = function (_a) {\n            var _b = (_a === void 0 ? {} : _a).preventCancel, preventCancel = _b === void 0 ? false : _b;\n            if (IsReadableStream(this) === false) {\n                throw streamBrandCheckException$1('getIterator');\n            }\n            return AcquireReadableStreamAsyncIterator(this, preventCancel);\n        };\n        return ReadableStream;\n    }());\n    if (typeof SymbolPolyfill.asyncIterator === 'symbol') {\n        Object.defineProperty(ReadableStream.prototype, SymbolPolyfill.asyncIterator, {\n            value: ReadableStream.prototype.getIterator,\n            enumerable: false,\n            writable: true,\n            configurable: true\n        });\n    }\n    // Abstract operations for the ReadableStream.\n    // Throws if and only if startAlgorithm throws.\n    function CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm) {\n        if (highWaterMark === void 0) { highWaterMark = 1; }\n        if (sizeAlgorithm === void 0) { sizeAlgorithm = function () { return 1; }; }\n        var stream = Object.create(ReadableStream.prototype);\n        InitializeReadableStream(stream);\n        var controller = Object.create(ReadableStreamDefaultController.prototype);\n        SetUpReadableStreamDefaultController(stream, controller, startAlgorithm, pullAlgorithm, cancelAlgorithm, highWaterMark, sizeAlgorithm);\n        return stream;\n    }\n    function InitializeReadableStream(stream) {\n        stream._state = 'readable';\n        stream._reader = undefined;\n        stream._storedError = undefined;\n        stream._disturbed = false;\n    }\n    function IsReadableStream(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {\n            return false;\n        }\n        return true;\n    }\n    function IsReadableStreamLocked(stream) {\n        if (stream._reader === undefined) {\n            return false;\n        }\n        return true;\n    }\n    // ReadableStream API exposed for controllers.\n    function ReadableStreamCancel(stream, reason) {\n        stream._disturbed = true;\n        if (stream._state === 'closed') {\n            return promiseResolvedWith(undefined);\n        }\n        if (stream._state === 'errored') {\n            return promiseRejectedWith(stream._storedError);\n        }\n        ReadableStreamClose(stream);\n        var sourceCancelPromise = stream._readableStreamController[CancelSteps](reason);\n        return transformPromiseWith(sourceCancelPromise, noop);\n    }\n    function ReadableStreamClose(stream) {\n        stream._state = 'closed';\n        var reader = stream._reader;\n        if (reader === undefined) {\n            return;\n        }\n        if (IsReadableStreamDefaultReader(reader)) {\n            reader._readRequests.forEach(function (readRequest) {\n                readRequest._resolve(ReadableStreamCreateReadResult(undefined, true, reader._forAuthorCode));\n            });\n            reader._readRequests = new SimpleQueue();\n        }\n        defaultReaderClosedPromiseResolve(reader);\n    }\n    function ReadableStreamError(stream, e) {\n        stream._state = 'errored';\n        stream._storedError = e;\n        var reader = stream._reader;\n        if (reader === undefined) {\n            return;\n        }\n        if (IsReadableStreamDefaultReader(reader)) {\n            reader._readRequests.forEach(function (readRequest) {\n                readRequest._reject(e);\n            });\n            reader._readRequests = new SimpleQueue();\n        }\n        else {\n            reader._readIntoRequests.forEach(function (readIntoRequest) {\n                readIntoRequest._reject(e);\n            });\n            reader._readIntoRequests = new SimpleQueue();\n        }\n        defaultReaderClosedPromiseReject(reader, e);\n    }\n    // Helper functions for the ReadableStream.\n    function streamBrandCheckException$1(name) {\n        return new TypeError(\"ReadableStream.prototype.\" + name + \" can only be used on a ReadableStream\");\n    }\n\n    var ByteLengthQueuingStrategy = /** @class */ (function () {\n        function ByteLengthQueuingStrategy(_a) {\n            var highWaterMark = _a.highWaterMark;\n            this.highWaterMark = highWaterMark;\n        }\n        ByteLengthQueuingStrategy.prototype.size = function (chunk) {\n            return chunk.byteLength;\n        };\n        return ByteLengthQueuingStrategy;\n    }());\n\n    var CountQueuingStrategy = /** @class */ (function () {\n        function CountQueuingStrategy(_a) {\n            var highWaterMark = _a.highWaterMark;\n            this.highWaterMark = highWaterMark;\n        }\n        CountQueuingStrategy.prototype.size = function () {\n            return 1;\n        };\n        return CountQueuingStrategy;\n    }());\n\n    // Class TransformStream\n    var TransformStream = /** @class */ (function () {\n        function TransformStream(transformer, writableStrategy, readableStrategy) {\n            if (transformer === void 0) { transformer = {}; }\n            if (writableStrategy === void 0) { writableStrategy = {}; }\n            if (readableStrategy === void 0) { readableStrategy = {}; }\n            var writableSizeFunction = writableStrategy.size;\n            var writableHighWaterMark = writableStrategy.highWaterMark;\n            var readableSizeFunction = readableStrategy.size;\n            var readableHighWaterMark = readableStrategy.highWaterMark;\n            var writableType = transformer.writableType;\n            if (writableType !== undefined) {\n                throw new RangeError('Invalid writable type specified');\n            }\n            var writableSizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(writableSizeFunction);\n            if (writableHighWaterMark === undefined) {\n                writableHighWaterMark = 1;\n            }\n            writableHighWaterMark = ValidateAndNormalizeHighWaterMark(writableHighWaterMark);\n            var readableType = transformer.readableType;\n            if (readableType !== undefined) {\n                throw new RangeError('Invalid readable type specified');\n            }\n            var readableSizeAlgorithm = MakeSizeAlgorithmFromSizeFunction(readableSizeFunction);\n            if (readableHighWaterMark === undefined) {\n                readableHighWaterMark = 0;\n            }\n            readableHighWaterMark = ValidateAndNormalizeHighWaterMark(readableHighWaterMark);\n            var startPromise_resolve;\n            var startPromise = newPromise(function (resolve) {\n                startPromise_resolve = resolve;\n            });\n            InitializeTransformStream(this, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm);\n            SetUpTransformStreamDefaultControllerFromTransformer(this, transformer);\n            var startResult = InvokeOrNoop(transformer, 'start', [this._transformStreamController]);\n            startPromise_resolve(startResult);\n        }\n        Object.defineProperty(TransformStream.prototype, \"readable\", {\n            get: function () {\n                if (IsTransformStream(this) === false) {\n                    throw streamBrandCheckException$2('readable');\n                }\n                return this._readable;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        Object.defineProperty(TransformStream.prototype, \"writable\", {\n            get: function () {\n                if (IsTransformStream(this) === false) {\n                    throw streamBrandCheckException$2('writable');\n                }\n                return this._writable;\n            },\n            enumerable: true,\n            configurable: true\n        });\n        return TransformStream;\n    }());\n    function InitializeTransformStream(stream, startPromise, writableHighWaterMark, writableSizeAlgorithm, readableHighWaterMark, readableSizeAlgorithm) {\n        function startAlgorithm() {\n            return startPromise;\n        }\n        function writeAlgorithm(chunk) {\n            return TransformStreamDefaultSinkWriteAlgorithm(stream, chunk);\n        }\n        function abortAlgorithm(reason) {\n            return TransformStreamDefaultSinkAbortAlgorithm(stream, reason);\n        }\n        function closeAlgorithm() {\n            return TransformStreamDefaultSinkCloseAlgorithm(stream);\n        }\n        stream._writable = CreateWritableStream(startAlgorithm, writeAlgorithm, closeAlgorithm, abortAlgorithm, writableHighWaterMark, writableSizeAlgorithm);\n        function pullAlgorithm() {\n            return TransformStreamDefaultSourcePullAlgorithm(stream);\n        }\n        function cancelAlgorithm(reason) {\n            TransformStreamErrorWritableAndUnblockWrite(stream, reason);\n            return promiseResolvedWith(undefined);\n        }\n        stream._readable = CreateReadableStream(startAlgorithm, pullAlgorithm, cancelAlgorithm, readableHighWaterMark, readableSizeAlgorithm);\n        // The [[backpressure]] slot is set to undefined so that it can be initialised by TransformStreamSetBackpressure.\n        stream._backpressure = undefined;\n        stream._backpressureChangePromise = undefined;\n        stream._backpressureChangePromise_resolve = undefined;\n        TransformStreamSetBackpressure(stream, true);\n        // Used by IsWritableStream() which is called by SetUpTransformStreamDefaultController().\n        stream._transformStreamController = undefined;\n    }\n    function IsTransformStream(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {\n            return false;\n        }\n        return true;\n    }\n    // This is a no-op if both sides are already errored.\n    function TransformStreamError(stream, e) {\n        ReadableStreamDefaultControllerError(stream._readable._readableStreamController, e);\n        TransformStreamErrorWritableAndUnblockWrite(stream, e);\n    }\n    function TransformStreamErrorWritableAndUnblockWrite(stream, e) {\n        TransformStreamDefaultControllerClearAlgorithms(stream._transformStreamController);\n        WritableStreamDefaultControllerErrorIfNeeded(stream._writable._writableStreamController, e);\n        if (stream._backpressure === true) {\n            // Pretend that pull() was called to permit any pending write() calls to complete. TransformStreamSetBackpressure()\n            // cannot be called from enqueue() or pull() once the ReadableStream is errored, so this will will be the final time\n            // _backpressure is set.\n            TransformStreamSetBackpressure(stream, false);\n        }\n    }\n    function TransformStreamSetBackpressure(stream, backpressure) {\n        // Passes also when called during construction.\n        if (stream._backpressureChangePromise !== undefined) {\n            stream._backpressureChangePromise_resolve();\n        }\n        stream._backpressureChangePromise = newPromise(function (resolve) {\n            stream._backpressureChangePromise_resolve = resolve;\n        });\n        stream._backpressure = backpressure;\n    }\n    var TransformStreamDefaultController = /** @class */ (function () {\n        /** @internal */\n        function TransformStreamDefaultController() {\n            throw new TypeError('TransformStreamDefaultController instances cannot be created directly');\n        }\n        Object.defineProperty(TransformStreamDefaultController.prototype, \"desiredSize\", {\n            get: function () {\n                if (IsTransformStreamDefaultController(this) === false) {\n                    throw defaultControllerBrandCheckException$1('desiredSize');\n                }\n                var readableController = this._controlledTransformStream._readable._readableStreamController;\n                return ReadableStreamDefaultControllerGetDesiredSize(readableController);\n            },\n            enumerable: true,\n            configurable: true\n        });\n        TransformStreamDefaultController.prototype.enqueue = function (chunk) {\n            if (IsTransformStreamDefaultController(this) === false) {\n                throw defaultControllerBrandCheckException$1('enqueue');\n            }\n            TransformStreamDefaultControllerEnqueue(this, chunk);\n        };\n        TransformStreamDefaultController.prototype.error = function (reason) {\n            if (IsTransformStreamDefaultController(this) === false) {\n                throw defaultControllerBrandCheckException$1('error');\n            }\n            TransformStreamDefaultControllerError(this, reason);\n        };\n        TransformStreamDefaultController.prototype.terminate = function () {\n            if (IsTransformStreamDefaultController(this) === false) {\n                throw defaultControllerBrandCheckException$1('terminate');\n            }\n            TransformStreamDefaultControllerTerminate(this);\n        };\n        return TransformStreamDefaultController;\n    }());\n    // Transform Stream Default Controller Abstract Operations\n    function IsTransformStreamDefaultController(x) {\n        if (!typeIsObject(x)) {\n            return false;\n        }\n        if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {\n            return false;\n        }\n        return true;\n    }\n    function SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm) {\n        controller._controlledTransformStream = stream;\n        stream._transformStreamController = controller;\n        controller._transformAlgorithm = transformAlgorithm;\n        controller._flushAlgorithm = flushAlgorithm;\n    }\n    function SetUpTransformStreamDefaultControllerFromTransformer(stream, transformer) {\n        var controller = Object.create(TransformStreamDefaultController.prototype);\n        var transformAlgorithm = function (chunk) {\n            try {\n                TransformStreamDefaultControllerEnqueue(controller, chunk);\n                return promiseResolvedWith(undefined);\n            }\n            catch (transformResultE) {\n                return promiseRejectedWith(transformResultE);\n            }\n        };\n        var transformMethod = transformer.transform;\n        if (transformMethod !== undefined) {\n            if (typeof transformMethod !== 'function') {\n                throw new TypeError('transform is not a method');\n            }\n            transformAlgorithm = function (chunk) { return PromiseCall(transformMethod, transformer, [chunk, controller]); };\n        }\n        var flushAlgorithm = CreateAlgorithmFromUnderlyingMethod(transformer, 'flush', 0, [controller]);\n        SetUpTransformStreamDefaultController(stream, controller, transformAlgorithm, flushAlgorithm);\n    }\n    function TransformStreamDefaultControllerClearAlgorithms(controller) {\n        controller._transformAlgorithm = undefined;\n        controller._flushAlgorithm = undefined;\n    }\n    function TransformStreamDefaultControllerEnqueue(controller, chunk) {\n        var stream = controller._controlledTransformStream;\n        var readableController = stream._readable._readableStreamController;\n        if (ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) === false) {\n            throw new TypeError('Readable side is not in a state that permits enqueue');\n        }\n        // We throttle transform invocations based on the backpressure of the ReadableStream, but we still\n        // accept TransformStreamDefaultControllerEnqueue() calls.\n        try {\n            ReadableStreamDefaultControllerEnqueue(readableController, chunk);\n        }\n        catch (e) {\n            // This happens when readableStrategy.size() throws.\n            TransformStreamErrorWritableAndUnblockWrite(stream, e);\n            throw stream._readable._storedError;\n        }\n        var backpressure = ReadableStreamDefaultControllerHasBackpressure(readableController);\n        if (backpressure !== stream._backpressure) {\n            TransformStreamSetBackpressure(stream, true);\n        }\n    }\n    function TransformStreamDefaultControllerError(controller, e) {\n        TransformStreamError(controller._controlledTransformStream, e);\n    }\n    function TransformStreamDefaultControllerPerformTransform(controller, chunk) {\n        var transformPromise = controller._transformAlgorithm(chunk);\n        return transformPromiseWith(transformPromise, undefined, function (r) {\n            TransformStreamError(controller._controlledTransformStream, r);\n            throw r;\n        });\n    }\n    function TransformStreamDefaultControllerTerminate(controller) {\n        var stream = controller._controlledTransformStream;\n        var readableController = stream._readable._readableStreamController;\n        if (ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) === true) {\n            ReadableStreamDefaultControllerClose(readableController);\n        }\n        var error = new TypeError('TransformStream terminated');\n        TransformStreamErrorWritableAndUnblockWrite(stream, error);\n    }\n    // TransformStreamDefaultSink Algorithms\n    function TransformStreamDefaultSinkWriteAlgorithm(stream, chunk) {\n        var controller = stream._transformStreamController;\n        if (stream._backpressure === true) {\n            var backpressureChangePromise = stream._backpressureChangePromise;\n            return transformPromiseWith(backpressureChangePromise, function () {\n                var writable = stream._writable;\n                var state = writable._state;\n                if (state === 'erroring') {\n                    throw writable._storedError;\n                }\n                return TransformStreamDefaultControllerPerformTransform(controller, chunk);\n            });\n        }\n        return TransformStreamDefaultControllerPerformTransform(controller, chunk);\n    }\n    function TransformStreamDefaultSinkAbortAlgorithm(stream, reason) {\n        // abort() is not called synchronously, so it is possible for abort() to be called when the stream is already\n        // errored.\n        TransformStreamError(stream, reason);\n        return promiseResolvedWith(undefined);\n    }\n    function TransformStreamDefaultSinkCloseAlgorithm(stream) {\n        // stream._readable cannot change after construction, so caching it across a call to user code is safe.\n        var readable = stream._readable;\n        var controller = stream._transformStreamController;\n        var flushPromise = controller._flushAlgorithm();\n        TransformStreamDefaultControllerClearAlgorithms(controller);\n        // Return a promise that is fulfilled with undefined on success.\n        return transformPromiseWith(flushPromise, function () {\n            if (readable._state === 'errored') {\n                throw readable._storedError;\n            }\n            var readableController = readable._readableStreamController;\n            if (ReadableStreamDefaultControllerCanCloseOrEnqueue(readableController) === true) {\n                ReadableStreamDefaultControllerClose(readableController);\n            }\n        }, function (r) {\n            TransformStreamError(stream, r);\n            throw readable._storedError;\n        });\n    }\n    // TransformStreamDefaultSource Algorithms\n    function TransformStreamDefaultSourcePullAlgorithm(stream) {\n        // Invariant. Enforced by the promises returned by start() and pull().\n        TransformStreamSetBackpressure(stream, false);\n        // Prevent the next pull() call until there is backpressure.\n        return stream._backpressureChangePromise;\n    }\n    // Helper functions for the TransformStreamDefaultController.\n    function defaultControllerBrandCheckException$1(name) {\n        return new TypeError(\"TransformStreamDefaultController.prototype.\" + name + \" can only be used on a TransformStreamDefaultController\");\n    }\n    // Helper functions for the TransformStream.\n    function streamBrandCheckException$2(name) {\n        return new TypeError(\"TransformStream.prototype.\" + name + \" can only be used on a TransformStream\");\n    }\n\n    exports.ByteLengthQueuingStrategy = ByteLengthQueuingStrategy;\n    exports.CountQueuingStrategy = CountQueuingStrategy;\n    exports.ReadableStream = ReadableStream;\n    exports.TransformStream = TransformStream;\n    exports.WritableStream = WritableStream;\n\n    Object.defineProperty(exports, '__esModule', { value: true });\n\n})));\n//# sourceMappingURL=ponyfill.js.map\n","require('../../modules/es.map');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.string.iterator');\nrequire('../../modules/web.dom-collections.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Map;\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Map` constructor\n// https://tc39.github.io/ecma262/#sec-map-objects\nmodule.exports = collection('Map', function (init) {\n  return function Map() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar isForced = require('../internals/is-forced');\nvar redefine = require('../internals/redefine');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar iterate = require('../internals/iterate');\nvar anInstance = require('../internals/an-instance');\nvar isObject = require('../internals/is-object');\nvar fails = require('../internals/fails');\nvar checkCorrectnessOfIteration = require('../internals/check-correctness-of-iteration');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar inheritIfRequired = require('../internals/inherit-if-required');\n\nmodule.exports = function (CONSTRUCTOR_NAME, wrapper, common) {\n  var IS_MAP = CONSTRUCTOR_NAME.indexOf('Map') !== -1;\n  var IS_WEAK = CONSTRUCTOR_NAME.indexOf('Weak') !== -1;\n  var ADDER = IS_MAP ? 'set' : 'add';\n  var NativeConstructor = global[CONSTRUCTOR_NAME];\n  var NativePrototype = NativeConstructor && NativeConstructor.prototype;\n  var Constructor = NativeConstructor;\n  var exported = {};\n\n  var fixMethod = function (KEY) {\n    var nativeMethod = NativePrototype[KEY];\n    redefine(NativePrototype, KEY,\n      KEY == 'add' ? function add(value) {\n        nativeMethod.call(this, value === 0 ? 0 : value);\n        return this;\n      } : KEY == 'delete' ? function (key) {\n        return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key);\n      } : KEY == 'get' ? function get(key) {\n        return IS_WEAK && !isObject(key) ? undefined : nativeMethod.call(this, key === 0 ? 0 : key);\n      } : KEY == 'has' ? function has(key) {\n        return IS_WEAK && !isObject(key) ? false : nativeMethod.call(this, key === 0 ? 0 : key);\n      } : function set(key, value) {\n        nativeMethod.call(this, key === 0 ? 0 : key, value);\n        return this;\n      }\n    );\n  };\n\n  // eslint-disable-next-line max-len\n  if (isForced(CONSTRUCTOR_NAME, typeof NativeConstructor != 'function' || !(IS_WEAK || NativePrototype.forEach && !fails(function () {\n    new NativeConstructor().entries().next();\n  })))) {\n    // create collection constructor\n    Constructor = common.getConstructor(wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER);\n    InternalMetadataModule.REQUIRED = true;\n  } else if (isForced(CONSTRUCTOR_NAME, true)) {\n    var instance = new Constructor();\n    // early implementations not supports chaining\n    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;\n    // V8 ~ Chromium 40- weak-collections throws on primitives, but should return false\n    var THROWS_ON_PRIMITIVES = fails(function () { instance.has(1); });\n    // most early implementations doesn't supports iterables, most modern - not close it correctly\n    // eslint-disable-next-line no-new\n    var ACCEPT_ITERABLES = checkCorrectnessOfIteration(function (iterable) { new NativeConstructor(iterable); });\n    // for early implementations -0 and +0 not the same\n    var BUGGY_ZERO = !IS_WEAK && fails(function () {\n      // V8 ~ Chromium 42- fails only with 5+ elements\n      var $instance = new NativeConstructor();\n      var index = 5;\n      while (index--) $instance[ADDER](index, index);\n      return !$instance.has(-0);\n    });\n\n    if (!ACCEPT_ITERABLES) {\n      Constructor = wrapper(function (dummy, iterable) {\n        anInstance(dummy, Constructor, CONSTRUCTOR_NAME);\n        var that = inheritIfRequired(new NativeConstructor(), dummy, Constructor);\n        if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP);\n        return that;\n      });\n      Constructor.prototype = NativePrototype;\n      NativePrototype.constructor = Constructor;\n    }\n\n    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {\n      fixMethod('delete');\n      fixMethod('has');\n      IS_MAP && fixMethod('get');\n    }\n\n    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);\n\n    // weak collections should not contains .clear method\n    if (IS_WEAK && NativePrototype.clear) delete NativePrototype.clear;\n  }\n\n  exported[CONSTRUCTOR_NAME] = Constructor;\n  $({ global: true, forced: Constructor != NativeConstructor }, exported);\n\n  setToStringTag(Constructor, CONSTRUCTOR_NAME);\n\n  if (!IS_WEAK) common.setStrong(Constructor, CONSTRUCTOR_NAME, IS_MAP);\n\n  return Constructor;\n};\n","var hiddenKeys = require('../internals/hidden-keys');\nvar isObject = require('../internals/is-object');\nvar has = require('../internals/has');\nvar defineProperty = require('../internals/object-define-property').f;\nvar uid = require('../internals/uid');\nvar FREEZING = require('../internals/freezing');\n\nvar METADATA = uid('meta');\nvar id = 0;\n\nvar isExtensible = Object.isExtensible || function () {\n  return true;\n};\n\nvar setMetadata = function (it) {\n  defineProperty(it, METADATA, { value: {\n    objectID: 'O' + ++id, // object ID\n    weakData: {}          // weak collections IDs\n  } });\n};\n\nvar fastKey = function (it, create) {\n  // return a primitive with prefix\n  if (!isObject(it)) return typeof it == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;\n  if (!has(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return 'F';\n    // not necessary to add metadata\n    if (!create) return 'E';\n    // add missing metadata\n    setMetadata(it);\n  // return object ID\n  } return it[METADATA].objectID;\n};\n\nvar getWeakData = function (it, create) {\n  if (!has(it, METADATA)) {\n    // can't set metadata to uncaught frozen object\n    if (!isExtensible(it)) return true;\n    // not necessary to add metadata\n    if (!create) return false;\n    // add missing metadata\n    setMetadata(it);\n  // return the store of weak collections IDs\n  } return it[METADATA].weakData;\n};\n\n// add metadata on freeze-family methods calling\nvar onFreeze = function (it) {\n  if (FREEZING && meta.REQUIRED && isExtensible(it) && !has(it, METADATA)) setMetadata(it);\n  return it;\n};\n\nvar meta = module.exports = {\n  REQUIRED: false,\n  fastKey: fastKey,\n  getWeakData: getWeakData,\n  onFreeze: onFreeze\n};\n\nhiddenKeys[METADATA] = true;\n","var fails = require('../internals/fails');\n\nmodule.exports = !fails(function () {\n  return Object.isExtensible(Object.preventExtensions({}));\n});\n","var isObject = require('../internals/is-object');\nvar setPrototypeOf = require('../internals/object-set-prototype-of');\n\n// makes subclassing work correct for wrapped built-ins\nmodule.exports = function ($this, dummy, Wrapper) {\n  var NewTarget, NewTargetPrototype;\n  if (\n    // it can work only with native `setPrototypeOf`\n    setPrototypeOf &&\n    // we haven't completely correct pre-ES6 way for getting `new.target`, so use this\n    typeof (NewTarget = dummy.constructor) == 'function' &&\n    NewTarget !== Wrapper &&\n    isObject(NewTargetPrototype = NewTarget.prototype) &&\n    NewTargetPrototype !== Wrapper.prototype\n  ) setPrototypeOf($this, NewTargetPrototype);\n  return $this;\n};\n","'use strict';\nvar defineProperty = require('../internals/object-define-property').f;\nvar create = require('../internals/object-create');\nvar redefineAll = require('../internals/redefine-all');\nvar bind = require('../internals/function-bind-context');\nvar anInstance = require('../internals/an-instance');\nvar iterate = require('../internals/iterate');\nvar defineIterator = require('../internals/define-iterator');\nvar setSpecies = require('../internals/set-species');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar fastKey = require('../internals/internal-metadata').fastKey;\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\n\nmodule.exports = {\n  getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n    var C = wrapper(function (that, iterable) {\n      anInstance(that, C, CONSTRUCTOR_NAME);\n      setInternalState(that, {\n        type: CONSTRUCTOR_NAME,\n        index: create(null),\n        first: undefined,\n        last: undefined,\n        size: 0\n      });\n      if (!DESCRIPTORS) that.size = 0;\n      if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP);\n    });\n\n    var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n    var define = function (that, key, value) {\n      var state = getInternalState(that);\n      var entry = getEntry(that, key);\n      var previous, index;\n      // change existing entry\n      if (entry) {\n        entry.value = value;\n      // create new entry\n      } else {\n        state.last = entry = {\n          index: index = fastKey(key, true),\n          key: key,\n          value: value,\n          previous: previous = state.last,\n          next: undefined,\n          removed: false\n        };\n        if (!state.first) state.first = entry;\n        if (previous) previous.next = entry;\n        if (DESCRIPTORS) state.size++;\n        else that.size++;\n        // add to index\n        if (index !== 'F') state.index[index] = entry;\n      } return that;\n    };\n\n    var getEntry = function (that, key) {\n      var state = getInternalState(that);\n      // fast case\n      var index = fastKey(key);\n      var entry;\n      if (index !== 'F') return state.index[index];\n      // frozen object case\n      for (entry = state.first; entry; entry = entry.next) {\n        if (entry.key == key) return entry;\n      }\n    };\n\n    redefineAll(C.prototype, {\n      // 23.1.3.1 Map.prototype.clear()\n      // 23.2.3.2 Set.prototype.clear()\n      clear: function clear() {\n        var that = this;\n        var state = getInternalState(that);\n        var data = state.index;\n        var entry = state.first;\n        while (entry) {\n          entry.removed = true;\n          if (entry.previous) entry.previous = entry.previous.next = undefined;\n          delete data[entry.index];\n          entry = entry.next;\n        }\n        state.first = state.last = undefined;\n        if (DESCRIPTORS) state.size = 0;\n        else that.size = 0;\n      },\n      // 23.1.3.3 Map.prototype.delete(key)\n      // 23.2.3.4 Set.prototype.delete(value)\n      'delete': function (key) {\n        var that = this;\n        var state = getInternalState(that);\n        var entry = getEntry(that, key);\n        if (entry) {\n          var next = entry.next;\n          var prev = entry.previous;\n          delete state.index[entry.index];\n          entry.removed = true;\n          if (prev) prev.next = next;\n          if (next) next.previous = prev;\n          if (state.first == entry) state.first = next;\n          if (state.last == entry) state.last = prev;\n          if (DESCRIPTORS) state.size--;\n          else that.size--;\n        } return !!entry;\n      },\n      // 23.2.3.6 Set.prototype.forEach(callbackfn, thisArg = undefined)\n      // 23.1.3.5 Map.prototype.forEach(callbackfn, thisArg = undefined)\n      forEach: function forEach(callbackfn /* , that = undefined */) {\n        var state = getInternalState(this);\n        var boundFunction = bind(callbackfn, arguments.length > 1 ? arguments[1] : undefined, 3);\n        var entry;\n        while (entry = entry ? entry.next : state.first) {\n          boundFunction(entry.value, entry.key, this);\n          // revert to the last existing entry\n          while (entry && entry.removed) entry = entry.previous;\n        }\n      },\n      // 23.1.3.7 Map.prototype.has(key)\n      // 23.2.3.7 Set.prototype.has(value)\n      has: function has(key) {\n        return !!getEntry(this, key);\n      }\n    });\n\n    redefineAll(C.prototype, IS_MAP ? {\n      // 23.1.3.6 Map.prototype.get(key)\n      get: function get(key) {\n        var entry = getEntry(this, key);\n        return entry && entry.value;\n      },\n      // 23.1.3.9 Map.prototype.set(key, value)\n      set: function set(key, value) {\n        return define(this, key === 0 ? 0 : key, value);\n      }\n    } : {\n      // 23.2.3.1 Set.prototype.add(value)\n      add: function add(value) {\n        return define(this, value = value === 0 ? 0 : value, value);\n      }\n    });\n    if (DESCRIPTORS) defineProperty(C.prototype, 'size', {\n      get: function () {\n        return getInternalState(this).size;\n      }\n    });\n    return C;\n  },\n  setStrong: function (C, CONSTRUCTOR_NAME, IS_MAP) {\n    var ITERATOR_NAME = CONSTRUCTOR_NAME + ' Iterator';\n    var getInternalCollectionState = internalStateGetterFor(CONSTRUCTOR_NAME);\n    var getInternalIteratorState = internalStateGetterFor(ITERATOR_NAME);\n    // add .keys, .values, .entries, [@@iterator]\n    // 23.1.3.4, 23.1.3.8, 23.1.3.11, 23.1.3.12, 23.2.3.5, 23.2.3.8, 23.2.3.10, 23.2.3.11\n    defineIterator(C, CONSTRUCTOR_NAME, function (iterated, kind) {\n      setInternalState(this, {\n        type: ITERATOR_NAME,\n        target: iterated,\n        state: getInternalCollectionState(iterated),\n        kind: kind,\n        last: undefined\n      });\n    }, function () {\n      var state = getInternalIteratorState(this);\n      var kind = state.kind;\n      var entry = state.last;\n      // revert to the last existing entry\n      while (entry && entry.removed) entry = entry.previous;\n      // get next entry\n      if (!state.target || !(state.last = entry = entry ? entry.next : state.state.first)) {\n        // or finish the iteration\n        state.target = undefined;\n        return { value: undefined, done: true };\n      }\n      // return step by kind\n      if (kind == 'keys') return { value: entry.key, done: false };\n      if (kind == 'values') return { value: entry.value, done: false };\n      return { value: [entry.key, entry.value], done: false };\n    }, IS_MAP ? 'entries' : 'values', !IS_MAP, true);\n\n    // add [@@species], 23.1.2.2, 23.2.2.2\n    setSpecies(CONSTRUCTOR_NAME);\n  }\n};\n","require('../../modules/es.set');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.string.iterator');\nrequire('../../modules/web.dom-collections.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Set;\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionStrong = require('../internals/collection-strong');\n\n// `Set` constructor\n// https://tc39.github.io/ecma262/#sec-set-objects\nmodule.exports = collection('Set', function (init) {\n  return function Set() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionStrong);\n","require('../../modules/es.object.to-string');\nrequire('../../modules/es.weak-map');\nrequire('../../modules/web.dom-collections.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.WeakMap;\n","'use strict';\nvar global = require('../internals/global');\nvar redefineAll = require('../internals/redefine-all');\nvar InternalMetadataModule = require('../internals/internal-metadata');\nvar collection = require('../internals/collection');\nvar collectionWeak = require('../internals/collection-weak');\nvar isObject = require('../internals/is-object');\nvar enforceIternalState = require('../internals/internal-state').enforce;\nvar NATIVE_WEAK_MAP = require('../internals/native-weak-map');\n\nvar IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global;\nvar isExtensible = Object.isExtensible;\nvar InternalWeakMap;\n\nvar wrapper = function (init) {\n  return function WeakMap() {\n    return init(this, arguments.length ? arguments[0] : undefined);\n  };\n};\n\n// `WeakMap` constructor\n// https://tc39.github.io/ecma262/#sec-weakmap-constructor\nvar $WeakMap = module.exports = collection('WeakMap', wrapper, collectionWeak);\n\n// IE11 WeakMap frozen keys fix\n// We can't use feature detection because it crash some old IE builds\n// https://github.com/zloirock/core-js/issues/485\nif (NATIVE_WEAK_MAP && IS_IE11) {\n  InternalWeakMap = collectionWeak.getConstructor(wrapper, 'WeakMap', true);\n  InternalMetadataModule.REQUIRED = true;\n  var WeakMapPrototype = $WeakMap.prototype;\n  var nativeDelete = WeakMapPrototype['delete'];\n  var nativeHas = WeakMapPrototype.has;\n  var nativeGet = WeakMapPrototype.get;\n  var nativeSet = WeakMapPrototype.set;\n  redefineAll(WeakMapPrototype, {\n    'delete': function (key) {\n      if (isObject(key) && !isExtensible(key)) {\n        var state = enforceIternalState(this);\n        if (!state.frozen) state.frozen = new InternalWeakMap();\n        return nativeDelete.call(this, key) || state.frozen['delete'](key);\n      } return nativeDelete.call(this, key);\n    },\n    has: function has(key) {\n      if (isObject(key) && !isExtensible(key)) {\n        var state = enforceIternalState(this);\n        if (!state.frozen) state.frozen = new InternalWeakMap();\n        return nativeHas.call(this, key) || state.frozen.has(key);\n      } return nativeHas.call(this, key);\n    },\n    get: function get(key) {\n      if (isObject(key) && !isExtensible(key)) {\n        var state = enforceIternalState(this);\n        if (!state.frozen) state.frozen = new InternalWeakMap();\n        return nativeHas.call(this, key) ? nativeGet.call(this, key) : state.frozen.get(key);\n      } return nativeGet.call(this, key);\n    },\n    set: function set(key, value) {\n      if (isObject(key) && !isExtensible(key)) {\n        var state = enforceIternalState(this);\n        if (!state.frozen) state.frozen = new InternalWeakMap();\n        nativeHas.call(this, key) ? nativeSet.call(this, key, value) : state.frozen.set(key, value);\n      } else nativeSet.call(this, key, value);\n      return this;\n    }\n  });\n}\n","'use strict';\nvar redefineAll = require('../internals/redefine-all');\nvar getWeakData = require('../internals/internal-metadata').getWeakData;\nvar anObject = require('../internals/an-object');\nvar isObject = require('../internals/is-object');\nvar anInstance = require('../internals/an-instance');\nvar iterate = require('../internals/iterate');\nvar ArrayIterationModule = require('../internals/array-iteration');\nvar $has = require('../internals/has');\nvar InternalStateModule = require('../internals/internal-state');\n\nvar setInternalState = InternalStateModule.set;\nvar internalStateGetterFor = InternalStateModule.getterFor;\nvar find = ArrayIterationModule.find;\nvar findIndex = ArrayIterationModule.findIndex;\nvar id = 0;\n\n// fallback for uncaught frozen keys\nvar uncaughtFrozenStore = function (store) {\n  return store.frozen || (store.frozen = new UncaughtFrozenStore());\n};\n\nvar UncaughtFrozenStore = function () {\n  this.entries = [];\n};\n\nvar findUncaughtFrozen = function (store, key) {\n  return find(store.entries, function (it) {\n    return it[0] === key;\n  });\n};\n\nUncaughtFrozenStore.prototype = {\n  get: function (key) {\n    var entry = findUncaughtFrozen(this, key);\n    if (entry) return entry[1];\n  },\n  has: function (key) {\n    return !!findUncaughtFrozen(this, key);\n  },\n  set: function (key, value) {\n    var entry = findUncaughtFrozen(this, key);\n    if (entry) entry[1] = value;\n    else this.entries.push([key, value]);\n  },\n  'delete': function (key) {\n    var index = findIndex(this.entries, function (it) {\n      return it[0] === key;\n    });\n    if (~index) this.entries.splice(index, 1);\n    return !!~index;\n  }\n};\n\nmodule.exports = {\n  getConstructor: function (wrapper, CONSTRUCTOR_NAME, IS_MAP, ADDER) {\n    var C = wrapper(function (that, iterable) {\n      anInstance(that, C, CONSTRUCTOR_NAME);\n      setInternalState(that, {\n        type: CONSTRUCTOR_NAME,\n        id: id++,\n        frozen: undefined\n      });\n      if (iterable != undefined) iterate(iterable, that[ADDER], that, IS_MAP);\n    });\n\n    var getInternalState = internalStateGetterFor(CONSTRUCTOR_NAME);\n\n    var define = function (that, key, value) {\n      var state = getInternalState(that);\n      var data = getWeakData(anObject(key), true);\n      if (data === true) uncaughtFrozenStore(state).set(key, value);\n      else data[state.id] = value;\n      return that;\n    };\n\n    redefineAll(C.prototype, {\n      // 23.3.3.2 WeakMap.prototype.delete(key)\n      // 23.4.3.3 WeakSet.prototype.delete(value)\n      'delete': function (key) {\n        var state = getInternalState(this);\n        if (!isObject(key)) return false;\n        var data = getWeakData(key);\n        if (data === true) return uncaughtFrozenStore(state)['delete'](key);\n        return data && $has(data, state.id) && delete data[state.id];\n      },\n      // 23.3.3.4 WeakMap.prototype.has(key)\n      // 23.4.3.4 WeakSet.prototype.has(value)\n      has: function has(key) {\n        var state = getInternalState(this);\n        if (!isObject(key)) return false;\n        var data = getWeakData(key);\n        if (data === true) return uncaughtFrozenStore(state).has(key);\n        return data && $has(data, state.id);\n      }\n    });\n\n    redefineAll(C.prototype, IS_MAP ? {\n      // 23.3.3.3 WeakMap.prototype.get(key)\n      get: function get(key) {\n        var state = getInternalState(this);\n        if (isObject(key)) {\n          var data = getWeakData(key);\n          if (data === true) return uncaughtFrozenStore(state).get(key);\n          return data ? data[state.id] : undefined;\n        }\n      },\n      // 23.3.3.5 WeakMap.prototype.set(key, value)\n      set: function set(key, value) {\n        return define(this, key, value);\n      }\n    } : {\n      // 23.4.3.1 WeakSet.prototype.add(value)\n      add: function add(value) {\n        return define(this, value, true);\n      }\n    });\n\n    return C;\n  }\n};\n","var bind = require('../internals/function-bind-context');\nvar IndexedObject = require('../internals/indexed-object');\nvar toObject = require('../internals/to-object');\nvar toLength = require('../internals/to-length');\nvar arraySpeciesCreate = require('../internals/array-species-create');\n\nvar push = [].push;\n\n// `Array.prototype.{ forEach, map, filter, some, every, find, findIndex }` methods implementation\nvar createMethod = function (TYPE) {\n  var IS_MAP = TYPE == 1;\n  var IS_FILTER = TYPE == 2;\n  var IS_SOME = TYPE == 3;\n  var IS_EVERY = TYPE == 4;\n  var IS_FIND_INDEX = TYPE == 6;\n  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;\n  return function ($this, callbackfn, that, specificCreate) {\n    var O = toObject($this);\n    var self = IndexedObject(O);\n    var boundFunction = bind(callbackfn, that, 3);\n    var length = toLength(self.length);\n    var index = 0;\n    var create = specificCreate || arraySpeciesCreate;\n    var target = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;\n    var value, result;\n    for (;length > index; index++) if (NO_HOLES || index in self) {\n      value = self[index];\n      result = boundFunction(value, index, O);\n      if (TYPE) {\n        if (IS_MAP) target[index] = result; // map\n        else if (result) switch (TYPE) {\n          case 3: return true;              // some\n          case 5: return value;             // find\n          case 6: return index;             // findIndex\n          case 2: push.call(target, value); // filter\n        } else if (IS_EVERY) return false;  // every\n      }\n    }\n    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : target;\n  };\n};\n\nmodule.exports = {\n  // `Array.prototype.forEach` method\n  // https://tc39.github.io/ecma262/#sec-array.prototype.foreach\n  forEach: createMethod(0),\n  // `Array.prototype.map` method\n  // https://tc39.github.io/ecma262/#sec-array.prototype.map\n  map: createMethod(1),\n  // `Array.prototype.filter` method\n  // https://tc39.github.io/ecma262/#sec-array.prototype.filter\n  filter: createMethod(2),\n  // `Array.prototype.some` method\n  // https://tc39.github.io/ecma262/#sec-array.prototype.some\n  some: createMethod(3),\n  // `Array.prototype.every` method\n  // https://tc39.github.io/ecma262/#sec-array.prototype.every\n  every: createMethod(4),\n  // `Array.prototype.find` method\n  // https://tc39.github.io/ecma262/#sec-array.prototype.find\n  find: createMethod(5),\n  // `Array.prototype.findIndex` method\n  // https://tc39.github.io/ecma262/#sec-array.prototype.findIndex\n  findIndex: createMethod(6)\n};\n","var isObject = require('../internals/is-object');\nvar isArray = require('../internals/is-array');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\n\nvar SPECIES = wellKnownSymbol('species');\n\n// `ArraySpeciesCreate` abstract operation\n// https://tc39.github.io/ecma262/#sec-arrayspeciescreate\nmodule.exports = function (originalArray, length) {\n  var C;\n  if (isArray(originalArray)) {\n    C = originalArray.constructor;\n    // cross-realm fallback\n    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;\n    else if (isObject(C)) {\n      C = C[SPECIES];\n      if (C === null) C = undefined;\n    }\n  } return new (C === undefined ? Array : C)(length === 0 ? 0 : length);\n};\n","var classof = require('../internals/classof-raw');\n\n// `IsArray` abstract operation\n// https://tc39.github.io/ecma262/#sec-isarray\nmodule.exports = Array.isArray || function isArray(arg) {\n  return classof(arg) == 'Array';\n};\n","require('../../modules/es.object.to-string');\nrequire('../../modules/es.weak-set');\nrequire('../../modules/web.dom-collections.iterator');\nvar path = require('../../internals/path');\n\nmodule.exports = path.WeakSet;\n","'use strict';\nvar collection = require('../internals/collection');\nvar collectionWeak = require('../internals/collection-weak');\n\n// `WeakSet` constructor\n// https://tc39.github.io/ecma262/#sec-weakset-constructor\ncollection('WeakSet', function (init) {\n  return function WeakSet() { return init(this, arguments.length ? arguments[0] : undefined); };\n}, collectionWeak);\n","require('../../modules/es.string.code-point-at');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('String', 'codePointAt');\n","'use strict';\nvar $ = require('../internals/export');\nvar codeAt = require('../internals/string-multibyte').codeAt;\n\n// `String.prototype.codePointAt` method\n// https://tc39.github.io/ecma262/#sec-string.prototype.codepointat\n$({ target: 'String', proto: true }, {\n  codePointAt: function codePointAt(pos) {\n    return codeAt(this, pos);\n  }\n});\n","require('../../modules/es.string.from-code-point');\nvar path = require('../../internals/path');\n\nmodule.exports = path.String.fromCodePoint;\n","var $ = require('../internals/export');\nvar toAbsoluteIndex = require('../internals/to-absolute-index');\n\nvar fromCharCode = String.fromCharCode;\nvar nativeFromCodePoint = String.fromCodePoint;\n\n// length should be 1, old FF problem\nvar INCORRECT_LENGTH = !!nativeFromCodePoint && nativeFromCodePoint.length != 1;\n\n// `String.fromCodePoint` method\n// https://tc39.github.io/ecma262/#sec-string.fromcodepoint\n$({ target: 'String', stat: true, forced: INCORRECT_LENGTH }, {\n  fromCodePoint: function fromCodePoint(x) { // eslint-disable-line no-unused-vars\n    var elements = [];\n    var length = arguments.length;\n    var i = 0;\n    var code;\n    while (length > i) {\n      code = +arguments[i++];\n      if (toAbsoluteIndex(code, 0x10FFFF) !== code) throw RangeError(code + ' is not a valid code point');\n      elements.push(code < 0x10000\n        ? fromCharCode(code)\n        : fromCharCode(((code -= 0x10000) >> 10) + 0xD800, code % 0x400 + 0xDC00)\n      );\n    } return elements.join('');\n  }\n});\n","require('../../modules/es.array.concat');\nrequire('../../modules/es.object.to-string');\nrequire('../../modules/es.symbol');\nrequire('../../modules/es.symbol.async-iterator');\nrequire('../../modules/es.symbol.description');\nrequire('../../modules/es.symbol.has-instance');\nrequire('../../modules/es.symbol.is-concat-spreadable');\nrequire('../../modules/es.symbol.iterator');\nrequire('../../modules/es.symbol.match');\nrequire('../../modules/es.symbol.match-all');\nrequire('../../modules/es.symbol.replace');\nrequire('../../modules/es.symbol.search');\nrequire('../../modules/es.symbol.species');\nrequire('../../modules/es.symbol.split');\nrequire('../../modules/es.symbol.to-primitive');\nrequire('../../modules/es.symbol.to-string-tag');\nrequire('../../modules/es.symbol.unscopables');\nrequire('../../modules/es.math.to-string-tag');\nrequire('../../modules/es.json.to-string-tag');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Symbol;\n","'use strict';\nvar $ = require('../internals/export');\nvar fails = require('../internals/fails');\nvar isArray = require('../internals/is-array');\nvar isObject = require('../internals/is-object');\nvar toObject = require('../internals/to-object');\nvar toLength = require('../internals/to-length');\nvar createProperty = require('../internals/create-property');\nvar arraySpeciesCreate = require('../internals/array-species-create');\nvar arrayMethodHasSpeciesSupport = require('../internals/array-method-has-species-support');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar IS_CONCAT_SPREADABLE = wellKnownSymbol('isConcatSpreadable');\nvar MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF;\nvar MAXIMUM_ALLOWED_INDEX_EXCEEDED = 'Maximum allowed index exceeded';\n\n// We can't use this feature detection in V8 since it causes\n// deoptimization and serious performance degradation\n// https://github.com/zloirock/core-js/issues/679\nvar IS_CONCAT_SPREADABLE_SUPPORT = V8_VERSION >= 51 || !fails(function () {\n  var array = [];\n  array[IS_CONCAT_SPREADABLE] = false;\n  return array.concat()[0] !== array;\n});\n\nvar SPECIES_SUPPORT = arrayMethodHasSpeciesSupport('concat');\n\nvar isConcatSpreadable = function (O) {\n  if (!isObject(O)) return false;\n  var spreadable = O[IS_CONCAT_SPREADABLE];\n  return spreadable !== undefined ? !!spreadable : isArray(O);\n};\n\nvar FORCED = !IS_CONCAT_SPREADABLE_SUPPORT || !SPECIES_SUPPORT;\n\n// `Array.prototype.concat` method\n// https://tc39.github.io/ecma262/#sec-array.prototype.concat\n// with adding support of @@isConcatSpreadable and @@species\n$({ target: 'Array', proto: true, forced: FORCED }, {\n  concat: function concat(arg) { // eslint-disable-line no-unused-vars\n    var O = toObject(this);\n    var A = arraySpeciesCreate(O, 0);\n    var n = 0;\n    var i, k, length, len, E;\n    for (i = -1, length = arguments.length; i < length; i++) {\n      E = i === -1 ? O : arguments[i];\n      if (isConcatSpreadable(E)) {\n        len = toLength(E.length);\n        if (n + len > MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);\n        for (k = 0; k < len; k++, n++) if (k in E) createProperty(A, n, E[k]);\n      } else {\n        if (n >= MAX_SAFE_INTEGER) throw TypeError(MAXIMUM_ALLOWED_INDEX_EXCEEDED);\n        createProperty(A, n++, E);\n      }\n    }\n    A.length = n;\n    return A;\n  }\n});\n","var fails = require('../internals/fails');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar V8_VERSION = require('../internals/engine-v8-version');\n\nvar SPECIES = wellKnownSymbol('species');\n\nmodule.exports = function (METHOD_NAME) {\n  // We can't use this feature detection in V8 since it causes\n  // deoptimization and serious performance degradation\n  // https://github.com/zloirock/core-js/issues/677\n  return V8_VERSION >= 51 || !fails(function () {\n    var array = [];\n    var constructor = array.constructor = {};\n    constructor[SPECIES] = function () {\n      return { foo: 1 };\n    };\n    return array[METHOD_NAME](Boolean).foo !== 1;\n  });\n};\n","'use strict';\nvar $ = require('../internals/export');\nvar global = require('../internals/global');\nvar getBuiltIn = require('../internals/get-built-in');\nvar IS_PURE = require('../internals/is-pure');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar NATIVE_SYMBOL = require('../internals/native-symbol');\nvar USE_SYMBOL_AS_UID = require('../internals/use-symbol-as-uid');\nvar fails = require('../internals/fails');\nvar has = require('../internals/has');\nvar isArray = require('../internals/is-array');\nvar isObject = require('../internals/is-object');\nvar anObject = require('../internals/an-object');\nvar toObject = require('../internals/to-object');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar toPrimitive = require('../internals/to-primitive');\nvar createPropertyDescriptor = require('../internals/create-property-descriptor');\nvar nativeObjectCreate = require('../internals/object-create');\nvar objectKeys = require('../internals/object-keys');\nvar getOwnPropertyNamesModule = require('../internals/object-get-own-property-names');\nvar getOwnPropertyNamesExternal = require('../internals/object-get-own-property-names-external');\nvar getOwnPropertySymbolsModule = require('../internals/object-get-own-property-symbols');\nvar getOwnPropertyDescriptorModule = require('../internals/object-get-own-property-descriptor');\nvar definePropertyModule = require('../internals/object-define-property');\nvar propertyIsEnumerableModule = require('../internals/object-property-is-enumerable');\nvar createNonEnumerableProperty = require('../internals/create-non-enumerable-property');\nvar redefine = require('../internals/redefine');\nvar shared = require('../internals/shared');\nvar sharedKey = require('../internals/shared-key');\nvar hiddenKeys = require('../internals/hidden-keys');\nvar uid = require('../internals/uid');\nvar wellKnownSymbol = require('../internals/well-known-symbol');\nvar wrappedWellKnownSymbolModule = require('../internals/well-known-symbol-wrapped');\nvar defineWellKnownSymbol = require('../internals/define-well-known-symbol');\nvar setToStringTag = require('../internals/set-to-string-tag');\nvar InternalStateModule = require('../internals/internal-state');\nvar $forEach = require('../internals/array-iteration').forEach;\n\nvar HIDDEN = sharedKey('hidden');\nvar SYMBOL = 'Symbol';\nvar PROTOTYPE = 'prototype';\nvar TO_PRIMITIVE = wellKnownSymbol('toPrimitive');\nvar setInternalState = InternalStateModule.set;\nvar getInternalState = InternalStateModule.getterFor(SYMBOL);\nvar ObjectPrototype = Object[PROTOTYPE];\nvar $Symbol = global.Symbol;\nvar $stringify = getBuiltIn('JSON', 'stringify');\nvar nativeGetOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;\nvar nativeDefineProperty = definePropertyModule.f;\nvar nativeGetOwnPropertyNames = getOwnPropertyNamesExternal.f;\nvar nativePropertyIsEnumerable = propertyIsEnumerableModule.f;\nvar AllSymbols = shared('symbols');\nvar ObjectPrototypeSymbols = shared('op-symbols');\nvar StringToSymbolRegistry = shared('string-to-symbol-registry');\nvar SymbolToStringRegistry = shared('symbol-to-string-registry');\nvar WellKnownSymbolsStore = shared('wks');\nvar QObject = global.QObject;\n// Don't use setters in Qt Script, https://github.com/zloirock/core-js/issues/173\nvar USE_SETTER = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;\n\n// fallback for old Android, https://code.google.com/p/v8/issues/detail?id=687\nvar setSymbolDescriptor = DESCRIPTORS && fails(function () {\n  return nativeObjectCreate(nativeDefineProperty({}, 'a', {\n    get: function () { return nativeDefineProperty(this, 'a', { value: 7 }).a; }\n  })).a != 7;\n}) ? function (O, P, Attributes) {\n  var ObjectPrototypeDescriptor = nativeGetOwnPropertyDescriptor(ObjectPrototype, P);\n  if (ObjectPrototypeDescriptor) delete ObjectPrototype[P];\n  nativeDefineProperty(O, P, Attributes);\n  if (ObjectPrototypeDescriptor && O !== ObjectPrototype) {\n    nativeDefineProperty(ObjectPrototype, P, ObjectPrototypeDescriptor);\n  }\n} : nativeDefineProperty;\n\nvar wrap = function (tag, description) {\n  var symbol = AllSymbols[tag] = nativeObjectCreate($Symbol[PROTOTYPE]);\n  setInternalState(symbol, {\n    type: SYMBOL,\n    tag: tag,\n    description: description\n  });\n  if (!DESCRIPTORS) symbol.description = description;\n  return symbol;\n};\n\nvar isSymbol = USE_SYMBOL_AS_UID ? function (it) {\n  return typeof it == 'symbol';\n} : function (it) {\n  return Object(it) instanceof $Symbol;\n};\n\nvar $defineProperty = function defineProperty(O, P, Attributes) {\n  if (O === ObjectPrototype) $defineProperty(ObjectPrototypeSymbols, P, Attributes);\n  anObject(O);\n  var key = toPrimitive(P, true);\n  anObject(Attributes);\n  if (has(AllSymbols, key)) {\n    if (!Attributes.enumerable) {\n      if (!has(O, HIDDEN)) nativeDefineProperty(O, HIDDEN, createPropertyDescriptor(1, {}));\n      O[HIDDEN][key] = true;\n    } else {\n      if (has(O, HIDDEN) && O[HIDDEN][key]) O[HIDDEN][key] = false;\n      Attributes = nativeObjectCreate(Attributes, { enumerable: createPropertyDescriptor(0, false) });\n    } return setSymbolDescriptor(O, key, Attributes);\n  } return nativeDefineProperty(O, key, Attributes);\n};\n\nvar $defineProperties = function defineProperties(O, Properties) {\n  anObject(O);\n  var properties = toIndexedObject(Properties);\n  var keys = objectKeys(properties).concat($getOwnPropertySymbols(properties));\n  $forEach(keys, function (key) {\n    if (!DESCRIPTORS || $propertyIsEnumerable.call(properties, key)) $defineProperty(O, key, properties[key]);\n  });\n  return O;\n};\n\nvar $create = function create(O, Properties) {\n  return Properties === undefined ? nativeObjectCreate(O) : $defineProperties(nativeObjectCreate(O), Properties);\n};\n\nvar $propertyIsEnumerable = function propertyIsEnumerable(V) {\n  var P = toPrimitive(V, true);\n  var enumerable = nativePropertyIsEnumerable.call(this, P);\n  if (this === ObjectPrototype && has(AllSymbols, P) && !has(ObjectPrototypeSymbols, P)) return false;\n  return enumerable || !has(this, P) || !has(AllSymbols, P) || has(this, HIDDEN) && this[HIDDEN][P] ? enumerable : true;\n};\n\nvar $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(O, P) {\n  var it = toIndexedObject(O);\n  var key = toPrimitive(P, true);\n  if (it === ObjectPrototype && has(AllSymbols, key) && !has(ObjectPrototypeSymbols, key)) return;\n  var descriptor = nativeGetOwnPropertyDescriptor(it, key);\n  if (descriptor && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) {\n    descriptor.enumerable = true;\n  }\n  return descriptor;\n};\n\nvar $getOwnPropertyNames = function getOwnPropertyNames(O) {\n  var names = nativeGetOwnPropertyNames(toIndexedObject(O));\n  var result = [];\n  $forEach(names, function (key) {\n    if (!has(AllSymbols, key) && !has(hiddenKeys, key)) result.push(key);\n  });\n  return result;\n};\n\nvar $getOwnPropertySymbols = function getOwnPropertySymbols(O) {\n  var IS_OBJECT_PROTOTYPE = O === ObjectPrototype;\n  var names = nativeGetOwnPropertyNames(IS_OBJECT_PROTOTYPE ? ObjectPrototypeSymbols : toIndexedObject(O));\n  var result = [];\n  $forEach(names, function (key) {\n    if (has(AllSymbols, key) && (!IS_OBJECT_PROTOTYPE || has(ObjectPrototype, key))) {\n      result.push(AllSymbols[key]);\n    }\n  });\n  return result;\n};\n\n// `Symbol` constructor\n// https://tc39.github.io/ecma262/#sec-symbol-constructor\nif (!NATIVE_SYMBOL) {\n  $Symbol = function Symbol() {\n    if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor');\n    var description = !arguments.length || arguments[0] === undefined ? undefined : String(arguments[0]);\n    var tag = uid(description);\n    var setter = function (value) {\n      if (this === ObjectPrototype) setter.call(ObjectPrototypeSymbols, value);\n      if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;\n      setSymbolDescriptor(this, tag, createPropertyDescriptor(1, value));\n    };\n    if (DESCRIPTORS && USE_SETTER) setSymbolDescriptor(ObjectPrototype, tag, { configurable: true, set: setter });\n    return wrap(tag, description);\n  };\n\n  redefine($Symbol[PROTOTYPE], 'toString', function toString() {\n    return getInternalState(this).tag;\n  });\n\n  redefine($Symbol, 'withoutSetter', function (description) {\n    return wrap(uid(description), description);\n  });\n\n  propertyIsEnumerableModule.f = $propertyIsEnumerable;\n  definePropertyModule.f = $defineProperty;\n  getOwnPropertyDescriptorModule.f = $getOwnPropertyDescriptor;\n  getOwnPropertyNamesModule.f = getOwnPropertyNamesExternal.f = $getOwnPropertyNames;\n  getOwnPropertySymbolsModule.f = $getOwnPropertySymbols;\n\n  wrappedWellKnownSymbolModule.f = function (name) {\n    return wrap(wellKnownSymbol(name), name);\n  };\n\n  if (DESCRIPTORS) {\n    // https://github.com/tc39/proposal-Symbol-description\n    nativeDefineProperty($Symbol[PROTOTYPE], 'description', {\n      configurable: true,\n      get: function description() {\n        return getInternalState(this).description;\n      }\n    });\n    if (!IS_PURE) {\n      redefine(ObjectPrototype, 'propertyIsEnumerable', $propertyIsEnumerable, { unsafe: true });\n    }\n  }\n}\n\n$({ global: true, wrap: true, forced: !NATIVE_SYMBOL, sham: !NATIVE_SYMBOL }, {\n  Symbol: $Symbol\n});\n\n$forEach(objectKeys(WellKnownSymbolsStore), function (name) {\n  defineWellKnownSymbol(name);\n});\n\n$({ target: SYMBOL, stat: true, forced: !NATIVE_SYMBOL }, {\n  // `Symbol.for` method\n  // https://tc39.github.io/ecma262/#sec-symbol.for\n  'for': function (key) {\n    var string = String(key);\n    if (has(StringToSymbolRegistry, string)) return StringToSymbolRegistry[string];\n    var symbol = $Symbol(string);\n    StringToSymbolRegistry[string] = symbol;\n    SymbolToStringRegistry[symbol] = string;\n    return symbol;\n  },\n  // `Symbol.keyFor` method\n  // https://tc39.github.io/ecma262/#sec-symbol.keyfor\n  keyFor: function keyFor(sym) {\n    if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol');\n    if (has(SymbolToStringRegistry, sym)) return SymbolToStringRegistry[sym];\n  },\n  useSetter: function () { USE_SETTER = true; },\n  useSimple: function () { USE_SETTER = false; }\n});\n\n$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL, sham: !DESCRIPTORS }, {\n  // `Object.create` method\n  // https://tc39.github.io/ecma262/#sec-object.create\n  create: $create,\n  // `Object.defineProperty` method\n  // https://tc39.github.io/ecma262/#sec-object.defineproperty\n  defineProperty: $defineProperty,\n  // `Object.defineProperties` method\n  // https://tc39.github.io/ecma262/#sec-object.defineproperties\n  defineProperties: $defineProperties,\n  // `Object.getOwnPropertyDescriptor` method\n  // https://tc39.github.io/ecma262/#sec-object.getownpropertydescriptors\n  getOwnPropertyDescriptor: $getOwnPropertyDescriptor\n});\n\n$({ target: 'Object', stat: true, forced: !NATIVE_SYMBOL }, {\n  // `Object.getOwnPropertyNames` method\n  // https://tc39.github.io/ecma262/#sec-object.getownpropertynames\n  getOwnPropertyNames: $getOwnPropertyNames,\n  // `Object.getOwnPropertySymbols` method\n  // https://tc39.github.io/ecma262/#sec-object.getownpropertysymbols\n  getOwnPropertySymbols: $getOwnPropertySymbols\n});\n\n// Chrome 38 and 39 `Object.getOwnPropertySymbols` fails on primitives\n// https://bugs.chromium.org/p/v8/issues/detail?id=3443\n$({ target: 'Object', stat: true, forced: fails(function () { getOwnPropertySymbolsModule.f(1); }) }, {\n  getOwnPropertySymbols: function getOwnPropertySymbols(it) {\n    return getOwnPropertySymbolsModule.f(toObject(it));\n  }\n});\n\n// `JSON.stringify` method behavior with symbols\n// https://tc39.github.io/ecma262/#sec-json.stringify\nif ($stringify) {\n  var FORCED_JSON_STRINGIFY = !NATIVE_SYMBOL || fails(function () {\n    var symbol = $Symbol();\n    // MS Edge converts symbol values to JSON as {}\n    return $stringify([symbol]) != '[null]'\n      // WebKit converts symbol values to JSON as null\n      || $stringify({ a: symbol }) != '{}'\n      // V8 throws on boxed symbols\n      || $stringify(Object(symbol)) != '{}';\n  });\n\n  $({ target: 'JSON', stat: true, forced: FORCED_JSON_STRINGIFY }, {\n    // eslint-disable-next-line no-unused-vars\n    stringify: function stringify(it, replacer, space) {\n      var args = [it];\n      var index = 1;\n      var $replacer;\n      while (arguments.length > index) args.push(arguments[index++]);\n      $replacer = replacer;\n      if (!isObject(replacer) && it === undefined || isSymbol(it)) return; // IE8 returns string on undefined\n      if (!isArray(replacer)) replacer = function (key, value) {\n        if (typeof $replacer == 'function') value = $replacer.call(this, key, value);\n        if (!isSymbol(value)) return value;\n      };\n      args[1] = replacer;\n      return $stringify.apply(null, args);\n    }\n  });\n}\n\n// `Symbol.prototype[@@toPrimitive]` method\n// https://tc39.github.io/ecma262/#sec-symbol.prototype-@@toprimitive\nif (!$Symbol[PROTOTYPE][TO_PRIMITIVE]) {\n  createNonEnumerableProperty($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);\n}\n// `Symbol.prototype[@@toStringTag]` property\n// https://tc39.github.io/ecma262/#sec-symbol.prototype-@@tostringtag\nsetToStringTag($Symbol, SYMBOL);\n\nhiddenKeys[HIDDEN] = true;\n","var toIndexedObject = require('../internals/to-indexed-object');\nvar nativeGetOwnPropertyNames = require('../internals/object-get-own-property-names').f;\n\nvar toString = {}.toString;\n\nvar windowNames = typeof window == 'object' && window && Object.getOwnPropertyNames\n  ? Object.getOwnPropertyNames(window) : [];\n\nvar getWindowNames = function (it) {\n  try {\n    return nativeGetOwnPropertyNames(it);\n  } catch (error) {\n    return windowNames.slice();\n  }\n};\n\n// fallback for IE11 buggy Object.getOwnPropertyNames with iframe and window\nmodule.exports.f = function getOwnPropertyNames(it) {\n  return windowNames && toString.call(it) == '[object Window]'\n    ? getWindowNames(it)\n    : nativeGetOwnPropertyNames(toIndexedObject(it));\n};\n","var wellKnownSymbol = require('../internals/well-known-symbol');\n\nexports.f = wellKnownSymbol;\n","var path = require('../internals/path');\nvar has = require('../internals/has');\nvar wrappedWellKnownSymbolModule = require('../internals/well-known-symbol-wrapped');\nvar defineProperty = require('../internals/object-define-property').f;\n\nmodule.exports = function (NAME) {\n  var Symbol = path.Symbol || (path.Symbol = {});\n  if (!has(Symbol, NAME)) defineProperty(Symbol, NAME, {\n    value: wrappedWellKnownSymbolModule.f(NAME)\n  });\n};\n","var defineWellKnownSymbol = require('../internals/define-well-known-symbol');\n\n// `Symbol.asyncIterator` well-known symbol\n// https://tc39.github.io/ecma262/#sec-symbol.asynciterator\ndefineWellKnownSymbol('asyncIterator');\n","// `Symbol.prototype.description` getter\n// https://tc39.github.io/ecma262/#sec-symbol.prototype.description\n'use strict';\nvar $ = require('../internals/export');\nvar DESCRIPTORS = require('../internals/descriptors');\nvar global = require('../internals/global');\nvar has = require('../internals/has');\nvar isObject = require('../internals/is-object');\nvar defineProperty = require('../internals/object-define-property').f;\nvar copyConstructorProperties = require('../internals/copy-constructor-properties');\n\nvar NativeSymbol = global.Symbol;\n\nif (DESCRIPTORS && typeof NativeSymbol == 'function' && (!('description' in NativeSymbol.prototype) ||\n  // Safari 12 bug\n  NativeSymbol().description !== undefined\n)) {\n  var EmptyStringDescriptionStore = {};\n  // wrap Symbol constructor for correct work with undefined description\n  var SymbolWrapper = function Symbol() {\n    var description = arguments.length < 1 || arguments[0] === undefined ? undefined : String(arguments[0]);\n    var result = this instanceof SymbolWrapper\n      ? new NativeSymbol(description)\n      // in Edge 13, String(Symbol(undefined)) === 'Symbol(undefined)'\n      : description === undefined ? NativeSymbol() : NativeSymbol(description);\n    if (description === '') EmptyStringDescriptionStore[result] = true;\n    return result;\n  };\n  copyConstructorProperties(SymbolWrapper, NativeSymbol);\n  var symbolPrototype = SymbolWrapper.prototype = NativeSymbol.prototype;\n  symbolPrototype.constructor = SymbolWrapper;\n\n  var symbolToString = symbolPrototype.toString;\n  var native = String(NativeSymbol('test')) == 'Symbol(test)';\n  var regexp = /^Symbol\\((.*)\\)[^)]+$/;\n  defineProperty(symbolPrototype, 'description', {\n    configurable: true,\n    get: function description() {\n      var symbol = isObject(this) ? this.valueOf() : this;\n      var string = symbolToString.call(symbol);\n      if (has(EmptyStringDescriptionStore, symbol)) return '';\n      var desc = native ? string.slice(7, -1) : string.replace(regexp, '$1');\n      return desc === '' ? undefined : desc;\n    }\n  });\n\n  $({ global: true, forced: true }, {\n    Symbol: SymbolWrapper\n  });\n}\n","var defineWellKnownSymbol = require('../internals/define-well-known-symbol');\n\n// `Symbol.hasInstance` well-known symbol\n// https://tc39.github.io/ecma262/#sec-symbol.hasinstance\ndefineWellKnownSymbol('hasInstance');\n","var defineWellKnownSymbol = require('../internals/define-well-known-symbol');\n\n// `Symbol.isConcatSpreadable` well-known symbol\n// https://tc39.github.io/ecma262/#sec-symbol.isconcatspreadable\ndefineWellKnownSymbol('isConcatSpreadable');\n","var defineWellKnownSymbol = require('../internals/define-well-known-symbol');\n\n// `Symbol.iterator` well-known symbol\n// https://tc39.github.io/ecma262/#sec-symbol.iterator\ndefineWellKnownSymbol('iterator');\n","var defineWellKnownSymbol = require('../internals/define-well-known-symbol');\n\n// `Symbol.match` well-known symbol\n// https://tc39.github.io/ecma262/#sec-symbol.match\ndefineWellKnownSymbol('match');\n","var defineWellKnownSymbol = require('../internals/define-well-known-symbol');\n\n// `Symbol.matchAll` well-known symbol\ndefineWellKnownSymbol('matchAll');\n","var defineWellKnownSymbol = require('../internals/define-well-known-symbol');\n\n// `Symbol.replace` well-known symbol\n// https://tc39.github.io/ecma262/#sec-symbol.replace\ndefineWellKnownSymbol('replace');\n","var defineWellKnownSymbol = require('../internals/define-well-known-symbol');\n\n// `Symbol.search` well-known symbol\n// https://tc39.github.io/ecma262/#sec-symbol.search\ndefineWellKnownSymbol('search');\n","var defineWellKnownSymbol = require('../internals/define-well-known-symbol');\n\n// `Symbol.species` well-known symbol\n// https://tc39.github.io/ecma262/#sec-symbol.species\ndefineWellKnownSymbol('species');\n","var defineWellKnownSymbol = require('../internals/define-well-known-symbol');\n\n// `Symbol.split` well-known symbol\n// https://tc39.github.io/ecma262/#sec-symbol.split\ndefineWellKnownSymbol('split');\n","var defineWellKnownSymbol = require('../internals/define-well-known-symbol');\n\n// `Symbol.toPrimitive` well-known symbol\n// https://tc39.github.io/ecma262/#sec-symbol.toprimitive\ndefineWellKnownSymbol('toPrimitive');\n","var defineWellKnownSymbol = require('../internals/define-well-known-symbol');\n\n// `Symbol.toStringTag` well-known symbol\n// https://tc39.github.io/ecma262/#sec-symbol.tostringtag\ndefineWellKnownSymbol('toStringTag');\n","var defineWellKnownSymbol = require('../internals/define-well-known-symbol');\n\n// `Symbol.unscopables` well-known symbol\n// https://tc39.github.io/ecma262/#sec-symbol.unscopables\ndefineWellKnownSymbol('unscopables');\n","var setToStringTag = require('../internals/set-to-string-tag');\n\n// Math[@@toStringTag] property\n// https://tc39.github.io/ecma262/#sec-math-@@tostringtag\nsetToStringTag(Math, 'Math', true);\n","var global = require('../internals/global');\nvar setToStringTag = require('../internals/set-to-string-tag');\n\n// JSON[@@toStringTag] property\n// https://tc39.github.io/ecma262/#sec-json-@@tostringtag\nsetToStringTag(global.JSON, 'JSON', true);\n","require('../../modules/es.string.pad-start');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('String', 'padStart');\n","'use strict';\nvar $ = require('../internals/export');\nvar $padStart = require('../internals/string-pad').start;\nvar WEBKIT_BUG = require('../internals/string-pad-webkit-bug');\n\n// `String.prototype.padStart` method\n// https://tc39.github.io/ecma262/#sec-string.prototype.padstart\n$({ target: 'String', proto: true, forced: WEBKIT_BUG }, {\n  padStart: function padStart(maxLength /* , fillString = ' ' */) {\n    return $padStart(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n","// https://github.com/tc39/proposal-string-pad-start-end\nvar toLength = require('../internals/to-length');\nvar repeat = require('../internals/string-repeat');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\nvar ceil = Math.ceil;\n\n// `String.prototype.{ padStart, padEnd }` methods implementation\nvar createMethod = function (IS_END) {\n  return function ($this, maxLength, fillString) {\n    var S = String(requireObjectCoercible($this));\n    var stringLength = S.length;\n    var fillStr = fillString === undefined ? ' ' : String(fillString);\n    var intMaxLength = toLength(maxLength);\n    var fillLen, stringFiller;\n    if (intMaxLength <= stringLength || fillStr == '') return S;\n    fillLen = intMaxLength - stringLength;\n    stringFiller = repeat.call(fillStr, ceil(fillLen / fillStr.length));\n    if (stringFiller.length > fillLen) stringFiller = stringFiller.slice(0, fillLen);\n    return IS_END ? S + stringFiller : stringFiller + S;\n  };\n};\n\nmodule.exports = {\n  // `String.prototype.padStart` method\n  // https://tc39.github.io/ecma262/#sec-string.prototype.padstart\n  start: createMethod(false),\n  // `String.prototype.padEnd` method\n  // https://tc39.github.io/ecma262/#sec-string.prototype.padend\n  end: createMethod(true)\n};\n","'use strict';\nvar toInteger = require('../internals/to-integer');\nvar requireObjectCoercible = require('../internals/require-object-coercible');\n\n// `String.prototype.repeat` method implementation\n// https://tc39.github.io/ecma262/#sec-string.prototype.repeat\nmodule.exports = ''.repeat || function repeat(count) {\n  var str = String(requireObjectCoercible(this));\n  var result = '';\n  var n = toInteger(count);\n  if (n < 0 || n == Infinity) throw RangeError('Wrong number of repetitions');\n  for (;n > 0; (n >>>= 1) && (str += str)) if (n & 1) result += str;\n  return result;\n};\n","// https://github.com/zloirock/core-js/issues/280\nvar userAgent = require('../internals/engine-user-agent');\n\n// eslint-disable-next-line unicorn/no-unsafe-regex\nmodule.exports = /Version\\/10\\.\\d+(\\.\\d+)?( Mobile\\/\\w+)? Safari\\//.test(userAgent);\n","require('../../modules/es.string.pad-end');\nvar entryUnbind = require('../../internals/entry-unbind');\n\nmodule.exports = entryUnbind('String', 'padEnd');\n","'use strict';\nvar $ = require('../internals/export');\nvar $padEnd = require('../internals/string-pad').end;\nvar WEBKIT_BUG = require('../internals/string-pad-webkit-bug');\n\n// `String.prototype.padEnd` method\n// https://tc39.github.io/ecma262/#sec-string.prototype.padend\n$({ target: 'String', proto: true, forced: WEBKIT_BUG }, {\n  padEnd: function padEnd(maxLength /* , fillString = ' ' */) {\n    return $padEnd(this, maxLength, arguments.length > 1 ? arguments[1] : undefined);\n  }\n});\n","require('../../modules/es.object.values');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.values;\n","var $ = require('../internals/export');\nvar $values = require('../internals/object-to-array').values;\n\n// `Object.values` method\n// https://tc39.github.io/ecma262/#sec-object.values\n$({ target: 'Object', stat: true }, {\n  values: function values(O) {\n    return $values(O);\n  }\n});\n","var DESCRIPTORS = require('../internals/descriptors');\nvar objectKeys = require('../internals/object-keys');\nvar toIndexedObject = require('../internals/to-indexed-object');\nvar propertyIsEnumerable = require('../internals/object-property-is-enumerable').f;\n\n// `Object.{ entries, values }` methods implementation\nvar createMethod = function (TO_ENTRIES) {\n  return function (it) {\n    var O = toIndexedObject(it);\n    var keys = objectKeys(O);\n    var length = keys.length;\n    var i = 0;\n    var result = [];\n    var key;\n    while (length > i) {\n      key = keys[i++];\n      if (!DESCRIPTORS || propertyIsEnumerable.call(O, key)) {\n        result.push(TO_ENTRIES ? [key, O[key]] : O[key]);\n      }\n    }\n    return result;\n  };\n};\n\nmodule.exports = {\n  // `Object.entries` method\n  // https://tc39.github.io/ecma262/#sec-object.entries\n  entries: createMethod(true),\n  // `Object.values` method\n  // https://tc39.github.io/ecma262/#sec-object.values\n  values: createMethod(false)\n};\n","require('../../modules/es.object.entries');\nvar path = require('../../internals/path');\n\nmodule.exports = path.Object.entries;\n","var $ = require('../internals/export');\nvar $entries = require('../internals/object-to-array').entries;\n\n// `Object.entries` method\n// https://tc39.github.io/ecma262/#sec-object.entries\n$({ target: 'Object', stat: true }, {\n  entries: function entries(O) {\n    return $entries(O);\n  }\n});\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\n/**\n * @module pdfjsLib\n */\n\nimport {\n  AbortException,\n  assert,\n  createPromiseCapability,\n  getVerbosityLevel,\n  info,\n  InvalidPDFException,\n  isArrayBuffer,\n  isSameOrigin,\n  MissingPDFException,\n  PasswordException,\n  setVerbosityLevel,\n  shadow,\n  stringToBytes,\n  UnexpectedResponseException,\n  UnknownErrorException,\n  unreachable,\n  warn,\n} from \"../shared/util.js\";\nimport {\n  deprecated,\n  DOMCanvasFactory,\n  DOMCMapReaderFactory,\n  loadScript,\n  PageViewport,\n  RenderingCancelledException,\n  StatTimer,\n} from \"./display_utils.js\";\nimport { FontFaceObject, FontLoader } from \"./font_loader.js\";\nimport { NodeCanvasFactory, NodeCMapReaderFactory } from \"./node_utils.js\";\nimport { AnnotationStorage } from \"./annotation_storage.js\";\nimport { apiCompatibilityParams } from \"./api_compatibility.js\";\nimport { CanvasGraphics } from \"./canvas.js\";\nimport { GlobalWorkerOptions } from \"./worker_options.js\";\nimport { isNodeJS } from \"../shared/is_node.js\";\nimport { MessageHandler } from \"../shared/message_handler.js\";\nimport { Metadata } from \"./metadata.js\";\nimport { OptionalContentConfig } from \"./optional_content_config.js\";\nimport { PDFDataTransportStream } from \"./transport_stream.js\";\nimport { WebGLContext } from \"./webgl.js\";\n\nconst DEFAULT_RANGE_CHUNK_SIZE = 65536; // 2^16 = 65536\nconst RENDERING_CANCELLED_TIMEOUT = 100; // ms\n\nconst DefaultCanvasFactory =\n  (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) && isNodeJS\n    ? NodeCanvasFactory\n    : DOMCanvasFactory;\nconst DefaultCMapReaderFactory =\n  (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) && isNodeJS\n    ? NodeCMapReaderFactory\n    : DOMCMapReaderFactory;\n\n/**\n * @typedef {function} IPDFStreamFactory\n * @param {DocumentInitParameters} params - The document initialization\n *   parameters. The \"url\" key is always present.\n * @returns {Promise} A promise, which is resolved with an instance of\n *   {IPDFStream}.\n * @ignore\n */\n\n/**\n * @type IPDFStreamFactory\n * @private\n */\nlet createPDFNetworkStream;\n\n/**\n * Sets the function that instantiates an {IPDFStream} as an alternative PDF\n * data transport.\n *\n * @param {IPDFStreamFactory} pdfNetworkStreamFactory - The factory function\n *   that takes document initialization parameters (including a \"url\") and\n *   returns a promise which is resolved with an instance of {IPDFStream}.\n * @ignore\n */\nfunction setPDFNetworkStreamFactory(pdfNetworkStreamFactory) {\n  createPDFNetworkStream = pdfNetworkStreamFactory;\n}\n\n/**\n * @typedef { Int8Array | Uint8Array | Uint8ClampedArray |\n *            Int16Array | Uint16Array |\n *            Int32Array | Uint32Array | Float32Array |\n *            Float64Array\n * } TypedArray\n */\n\n/**\n * Document initialization / loading parameters object.\n *\n * @typedef {Object} DocumentInitParameters\n * @property {string} [url] - The URL of the PDF.\n * @property {TypedArray|Array<number>|string} [data] - Binary PDF data. Use\n *    typed arrays (Uint8Array) to improve the memory usage. If PDF data is\n *    BASE64-encoded, use `atob()` to convert it to a binary string first.\n * @property {Object} [httpHeaders] - Basic authentication headers.\n * @property {boolean} [withCredentials] - Indicates whether or not\n *   cross-site Access-Control requests should be made using credentials such\n *   as cookies or authorization headers. The default is `false`.\n * @property {string} [password] - For decrypting password-protected PDFs.\n * @property {TypedArray} [initialData] - A typed array with the first portion\n *   or all of the pdf data. Used by the extension since some data is already\n *   loaded before the switch to range requests.\n * @property {number} [length] - The PDF file length. It's used for progress\n *   reports and range requests operations.\n * @property {PDFDataRangeTransport} [range] - Allows for using a custom range\n *   transport implementation.\n * @property {number} [rangeChunkSize] - Specify maximum number of bytes fetched\n *   per range request. The default value is {@link DEFAULT_RANGE_CHUNK_SIZE}.\n * @property {PDFWorker} [worker] - The worker that will be used for loading and\n *   parsing the PDF data.\n * @property {number} [verbosity] - Controls the logging level; the constants\n *   from {@link VerbosityLevel} should be used.\n * @property {string} [docBaseUrl] - The base URL of the document, used when\n *   attempting to recover valid absolute URLs for annotations, and outline\n *   items, that (incorrectly) only specify relative URLs.\n * @property {string} [cMapUrl] - The URL where the predefined Adobe CMaps are\n *   located. Include the trailing slash.\n * @property {boolean} [cMapPacked] - Specifies if the Adobe CMaps are binary\n *   packed or not.\n * @property {Object} [CMapReaderFactory] - The factory that will be used when\n *   reading built-in CMap files. Providing a custom factory is useful for\n *   environments without Fetch API or `XMLHttpRequest` support, such as\n *   Node.js. The default value is {DOMCMapReaderFactory}.\n * @property {boolean} [stopAtErrors] - Reject certain promises, e.g.\n *   `getOperatorList`, `getTextContent`, and `RenderTask`, when the associated\n *   PDF data cannot be successfully parsed, instead of attempting to recover\n *   whatever possible of the data. The default value is `false`.\n * @property {number} [maxImageSize] - The maximum allowed image size in total\n *   pixels, i.e. width * height. Images above this value will not be rendered.\n *   Use -1 for no limit, which is also the default value.\n * @property {boolean} [isEvalSupported] - Determines if we can evaluate strings\n *   as JavaScript. Primarily used to improve performance of font rendering, and\n *   when parsing PDF functions. The default value is `true`.\n * @property {boolean} [disableFontFace] - By default fonts are converted to\n *   OpenType fonts and loaded via `@font-face` rules. If disabled, fonts will\n *   be rendered using a built-in font renderer that constructs the glyphs with\n *   primitive path commands. The default value is `false`.\n * @property {boolean} [fontExtraProperties] - Include additional properties,\n *   which are unused during rendering of PDF documents, when exporting the\n *   parsed font data from the worker-thread. This may be useful for debugging\n *   purposes (and backwards compatibility), but note that it will lead to\n *   increased memory usage. The default value is `false`.\n * @property {HTMLDocument} [ownerDocument] - Specify an explicit document\n *   context to create elements with and to load resources, such as fonts,\n *   into. Defaults to the current document.\n * @property {boolean} [disableRange] - Disable range request loading of PDF\n *   files. When enabled, and if the server supports partial content requests,\n *   then the PDF will be fetched in chunks. The default value is `false`.\n * @property {boolean} [disableStream] - Disable streaming of PDF file data.\n *   By default PDF.js attempts to load PDF files in chunks. The default value\n *   is `false`.\n * @property {boolean} [disableAutoFetch] - Disable pre-fetching of PDF file\n *   data. When range requests are enabled PDF.js will automatically keep\n *   fetching more data even if it isn't needed to display the current page.\n *   The default value is `false`.\n *\n *   NOTE: It is also necessary to disable streaming, see above, in order for\n *   disabling of pre-fetching to work correctly.\n * @property {boolean} [pdfBug] - Enables special hooks for debugging PDF.js\n *   (see `web/debugger.js`). The default value is `false`.\n */\n\n/**\n * @typedef {Object} PDFDocumentStats\n * @property {Object<string, boolean>} streamTypes - Used stream types in the\n *   document (an item is set to true if specific stream ID was used in the\n *   document).\n * @property {Object<string, boolean>} fontTypes - Used font types in the\n *   document (an item is set to true if specific font ID was used in the\n *   document).\n */\n\n/**\n * This is the main entry point for loading a PDF and interacting with it.\n *\n * NOTE: If a URL is used to fetch the PDF data a standard Fetch API call (or\n * XHR as fallback) is used, which means it must follow same origin rules,\n * e.g. no cross-domain requests without CORS.\n *\n * @param {string|TypedArray|DocumentInitParameters|PDFDataRangeTransport} src -\n *   Can be a URL to where a PDF file is located, a typed array (Uint8Array)\n *   already populated with data or parameter object.\n * @returns {PDFDocumentLoadingTask}\n */\nfunction getDocument(src) {\n  const task = new PDFDocumentLoadingTask();\n\n  let source;\n  if (typeof src === \"string\") {\n    source = { url: src };\n  } else if (isArrayBuffer(src)) {\n    source = { data: src };\n  } else if (src instanceof PDFDataRangeTransport) {\n    source = { range: src };\n  } else {\n    if (typeof src !== \"object\") {\n      throw new Error(\n        \"Invalid parameter in getDocument, \" +\n          \"need either Uint8Array, string or a parameter object\"\n      );\n    }\n    if (!src.url && !src.data && !src.range) {\n      throw new Error(\n        \"Invalid parameter object: need either .data, .range or .url\"\n      );\n    }\n    source = src;\n  }\n  const params = Object.create(null);\n  let rangeTransport = null,\n    worker = null;\n\n  for (const key in source) {\n    if (key === \"url\" && typeof window !== \"undefined\") {\n      // The full path is required in the 'url' field.\n      params[key] = new URL(source[key], window.location).href;\n      continue;\n    } else if (key === \"range\") {\n      rangeTransport = source[key];\n      continue;\n    } else if (key === \"worker\") {\n      worker = source[key];\n      continue;\n    } else if (key === \"data\" && !(source[key] instanceof Uint8Array)) {\n      // Converting string or array-like data to Uint8Array.\n      const pdfBytes = source[key];\n      if (typeof pdfBytes === \"string\") {\n        params[key] = stringToBytes(pdfBytes);\n      } else if (\n        typeof pdfBytes === \"object\" &&\n        pdfBytes !== null &&\n        !isNaN(pdfBytes.length)\n      ) {\n        params[key] = new Uint8Array(pdfBytes);\n      } else if (isArrayBuffer(pdfBytes)) {\n        params[key] = new Uint8Array(pdfBytes);\n      } else {\n        throw new Error(\n          \"Invalid PDF binary data: either typed array, \" +\n            \"string or array-like object is expected in the \" +\n            \"data property.\"\n        );\n      }\n      continue;\n    }\n    params[key] = source[key];\n  }\n\n  params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE;\n  params.CMapReaderFactory =\n    params.CMapReaderFactory || DefaultCMapReaderFactory;\n  params.ignoreErrors = params.stopAtErrors !== true;\n  params.fontExtraProperties = params.fontExtraProperties === true;\n  params.pdfBug = params.pdfBug === true;\n\n  if (!Number.isInteger(params.maxImageSize)) {\n    params.maxImageSize = -1;\n  }\n  if (typeof params.isEvalSupported !== \"boolean\") {\n    params.isEvalSupported = true;\n  }\n  if (typeof params.disableFontFace !== \"boolean\") {\n    params.disableFontFace = apiCompatibilityParams.disableFontFace || false;\n  }\n  if (typeof params.ownerDocument === \"undefined\") {\n    params.ownerDocument = globalThis.document;\n  }\n\n  if (typeof params.disableRange !== \"boolean\") {\n    params.disableRange = false;\n  }\n  if (typeof params.disableStream !== \"boolean\") {\n    params.disableStream = false;\n  }\n  if (typeof params.disableAutoFetch !== \"boolean\") {\n    params.disableAutoFetch = false;\n  }\n\n  // Set the main-thread verbosity level.\n  setVerbosityLevel(params.verbosity);\n\n  if (!worker) {\n    const workerParams = {\n      verbosity: params.verbosity,\n      port: GlobalWorkerOptions.workerPort,\n    };\n    // Worker was not provided -- creating and owning our own. If message port\n    // is specified in global worker options, using it.\n    worker = workerParams.port\n      ? PDFWorker.fromPort(workerParams)\n      : new PDFWorker(workerParams);\n    task._worker = worker;\n  }\n  const docId = task.docId;\n  worker.promise\n    .then(function () {\n      if (task.destroyed) {\n        throw new Error(\"Loading aborted\");\n      }\n\n      const workerIdPromise = _fetchDocument(\n        worker,\n        params,\n        rangeTransport,\n        docId\n      );\n      const networkStreamPromise = new Promise(function (resolve) {\n        let networkStream;\n        if (rangeTransport) {\n          networkStream = new PDFDataTransportStream(\n            {\n              length: params.length,\n              initialData: params.initialData,\n              progressiveDone: params.progressiveDone,\n              disableRange: params.disableRange,\n              disableStream: params.disableStream,\n            },\n            rangeTransport\n          );\n        } else if (!params.data) {\n          networkStream = createPDFNetworkStream({\n            url: params.url,\n            length: params.length,\n            httpHeaders: params.httpHeaders,\n            withCredentials: params.withCredentials,\n            rangeChunkSize: params.rangeChunkSize,\n            disableRange: params.disableRange,\n            disableStream: params.disableStream,\n          });\n        }\n        resolve(networkStream);\n      });\n\n      return Promise.all([workerIdPromise, networkStreamPromise]).then(\n        function ([workerId, networkStream]) {\n          if (task.destroyed) {\n            throw new Error(\"Loading aborted\");\n          }\n\n          const messageHandler = new MessageHandler(\n            docId,\n            workerId,\n            worker.port\n          );\n          messageHandler.postMessageTransfers = worker.postMessageTransfers;\n          const transport = new WorkerTransport(\n            messageHandler,\n            task,\n            networkStream,\n            params\n          );\n          task._transport = transport;\n          messageHandler.send(\"Ready\", null);\n        }\n      );\n    })\n    .catch(task._capability.reject);\n\n  return task;\n}\n\n/**\n * Starts fetching of specified PDF document/data.\n *\n * @param {PDFWorker} worker\n * @param {Object} source\n * @param {PDFDataRangeTransport} pdfDataRangeTransport\n * @param {string} docId - Unique document ID, used in `MessageHandler`.\n * @returns {Promise} A promise that is resolved when the worker ID of the\n *   `MessageHandler` is known.\n * @private\n */\nfunction _fetchDocument(worker, source, pdfDataRangeTransport, docId) {\n  if (worker.destroyed) {\n    return Promise.reject(new Error(\"Worker was destroyed\"));\n  }\n\n  if (pdfDataRangeTransport) {\n    source.length = pdfDataRangeTransport.length;\n    source.initialData = pdfDataRangeTransport.initialData;\n    source.progressiveDone = pdfDataRangeTransport.progressiveDone;\n  }\n  return worker.messageHandler\n    .sendWithPromise(\"GetDocRequest\", {\n      docId,\n      apiVersion:\n        typeof PDFJSDev !== \"undefined\" && !PDFJSDev.test(\"TESTING\")\n          ? PDFJSDev.eval(\"BUNDLE_VERSION\")\n          : null,\n      // Only send the required properties, and *not* the entire object.\n      source: {\n        data: source.data,\n        url: source.url,\n        password: source.password,\n        disableAutoFetch: source.disableAutoFetch,\n        rangeChunkSize: source.rangeChunkSize,\n        length: source.length,\n      },\n      maxImageSize: source.maxImageSize,\n      disableFontFace: source.disableFontFace,\n      postMessageTransfers: worker.postMessageTransfers,\n      docBaseUrl: source.docBaseUrl,\n      ignoreErrors: source.ignoreErrors,\n      isEvalSupported: source.isEvalSupported,\n      fontExtraProperties: source.fontExtraProperties,\n    })\n    .then(function (workerId) {\n      if (worker.destroyed) {\n        throw new Error(\"Worker was destroyed\");\n      }\n      return workerId;\n    });\n}\n\n/**\n * The loading task controls the operations required to load a PDF document\n * (such as network requests) and provides a way to listen for completion,\n * after which individual pages can be rendered.\n *\n * @typedef {Object} PDFDocumentLoadingTask\n * @property {string} docId - Unique identifier for the document loading task.\n * @property {boolean} destroyed - Whether the loading task is destroyed or not.\n * @property {function} [onPassword] - Callback to request a password if a wrong\n *   or no password was provided. The callback receives two parameters: a\n *   function that should be called with the new password, and a reason (see\n *   {@link PasswordResponses}).\n * @property {function} [onProgress] - Callback to be able to monitor the\n *   loading progress of the PDF file (necessary to implement e.g. a loading\n *   bar). The callback receives an {Object} with the properties `loaded`\n *   ({number}) and `total` ({number}) that indicate how many bytes are loaded.\n * @property {function} [onUnsupportedFeature] - Callback for when an\n *   unsupported feature is used in the PDF document. The callback receives an\n *   {@link UNSUPPORTED_FEATURES} argument.\n * @property {Promise<PDFDocumentProxy>} promise - Promise for document loading\n *   task completion.\n * @property {function} destroy - Abort all network requests and destroy\n *   the worker. Returns a promise that is resolved when destruction is\n *   completed.\n */\n\n/**\n * @type {any}\n * @ignore\n */\nconst PDFDocumentLoadingTask = (function PDFDocumentLoadingTaskClosure() {\n  let nextDocumentId = 0;\n\n  /**\n   * The loading task controls the operations required to load a PDF document\n   * (such as network requests) and provides a way to listen for completion,\n   * after which individual pages can be rendered.\n   */\n  // eslint-disable-next-line no-shadow\n  class PDFDocumentLoadingTask {\n    constructor() {\n      this._capability = createPromiseCapability();\n      this._transport = null;\n      this._worker = null;\n\n      /**\n       * Unique identifier for the document loading task.\n       * @type {string}\n       */\n      this.docId = \"d\" + nextDocumentId++;\n\n      /**\n       * Whether the loading task is destroyed or not.\n       * @type {boolean}\n       */\n      this.destroyed = false;\n\n      /**\n       * Callback to request a password if a wrong or no password was provided.\n       * The callback receives two parameters: a function that should be called\n       * with the new password, and a reason (see {@link PasswordResponses}).\n       * @type {function}\n       */\n      this.onPassword = null;\n\n      /**\n       * Callback to be able to monitor the loading progress of the PDF file\n       * (necessary to implement e.g. a loading bar). The callback receives\n       * an {Object} with the properties `loaded` ({number}) and `total`\n       * ({number}) that indicate how many bytes are loaded.\n       * @type {function}\n       */\n      this.onProgress = null;\n\n      /**\n       * Callback for when an unsupported feature is used in the PDF document.\n       * The callback receives an {@link UNSUPPORTED_FEATURES} argument.\n       * @type {function}\n       */\n      this.onUnsupportedFeature = null;\n    }\n\n    /**\n     * Promise for document loading task completion.\n     * @type {Promise<PDFDocumentProxy>}\n     */\n    get promise() {\n      return this._capability.promise;\n    }\n\n    /**\n     * @returns {Promise<void>} A promise that is resolved when destruction is\n     *   completed.\n     */\n    destroy() {\n      this.destroyed = true;\n\n      const transportDestroyed = !this._transport\n        ? Promise.resolve()\n        : this._transport.destroy();\n      return transportDestroyed.then(() => {\n        this._transport = null;\n        if (this._worker) {\n          this._worker.destroy();\n          this._worker = null;\n        }\n      });\n    }\n  }\n  return PDFDocumentLoadingTask;\n})();\n\n/**\n * Abstract class to support range requests file loading.\n */\nclass PDFDataRangeTransport {\n  /**\n   * @param {number} length\n   * @param {Uint8Array} initialData\n   * @param {boolean} [progressiveDone]\n   */\n  constructor(length, initialData, progressiveDone = false) {\n    this.length = length;\n    this.initialData = initialData;\n    this.progressiveDone = progressiveDone;\n\n    this._rangeListeners = [];\n    this._progressListeners = [];\n    this._progressiveReadListeners = [];\n    this._progressiveDoneListeners = [];\n    this._readyCapability = createPromiseCapability();\n  }\n\n  addRangeListener(listener) {\n    this._rangeListeners.push(listener);\n  }\n\n  addProgressListener(listener) {\n    this._progressListeners.push(listener);\n  }\n\n  addProgressiveReadListener(listener) {\n    this._progressiveReadListeners.push(listener);\n  }\n\n  addProgressiveDoneListener(listener) {\n    this._progressiveDoneListeners.push(listener);\n  }\n\n  onDataRange(begin, chunk) {\n    for (const listener of this._rangeListeners) {\n      listener(begin, chunk);\n    }\n  }\n\n  onDataProgress(loaded, total) {\n    this._readyCapability.promise.then(() => {\n      for (const listener of this._progressListeners) {\n        listener(loaded, total);\n      }\n    });\n  }\n\n  onDataProgressiveRead(chunk) {\n    this._readyCapability.promise.then(() => {\n      for (const listener of this._progressiveReadListeners) {\n        listener(chunk);\n      }\n    });\n  }\n\n  onDataProgressiveDone() {\n    this._readyCapability.promise.then(() => {\n      for (const listener of this._progressiveDoneListeners) {\n        listener();\n      }\n    });\n  }\n\n  transportReady() {\n    this._readyCapability.resolve();\n  }\n\n  requestDataRange(begin, end) {\n    unreachable(\"Abstract method PDFDataRangeTransport.requestDataRange\");\n  }\n\n  abort() {}\n}\n\n/**\n * Proxy to a `PDFDocument` in the worker thread.\n */\nclass PDFDocumentProxy {\n  constructor(pdfInfo, transport) {\n    this._pdfInfo = pdfInfo;\n    this._transport = transport;\n  }\n\n  /**\n   * @type {AnnotationStorage} Storage for annotation data in forms.\n   */\n  get annotationStorage() {\n    return shadow(this, \"annotationStorage\", new AnnotationStorage());\n  }\n\n  /**\n   * @type {number} Total number of pages in the PDF file.\n   */\n  get numPages() {\n    return this._pdfInfo.numPages;\n  }\n\n  /**\n   * @type {string} A (not guaranteed to be) unique ID to identify a PDF.\n   */\n  get fingerprint() {\n    return this._pdfInfo.fingerprint;\n  }\n\n  /**\n   * @param {number} pageNumber - The page number to get. The first page is 1.\n   * @returns {Promise<PDFPageProxy>} A promise that is resolved with\n   *   a {@link PDFPageProxy} object.\n   */\n  getPage(pageNumber) {\n    return this._transport.getPage(pageNumber);\n  }\n\n  /**\n   * @param {{num: number, gen: number}} ref - The page reference. Must have\n   *   the `num` and `gen` properties.\n   * @returns {Promise<{num: number, gen: number}>} A promise that is resolved\n   *   with the page index (starting from zero) that is associated with the\n   *   reference.\n   */\n  getPageIndex(ref) {\n    return this._transport.getPageIndex(ref);\n  }\n\n  /**\n   * @returns {Promise<Object<string, Array<any>>>} A promise that is resolved\n   *   with a mapping from named destinations to references.\n   *\n   * This can be slow for large documents. Use `getDestination` instead.\n   */\n  getDestinations() {\n    return this._transport.getDestinations();\n  }\n\n  /**\n   * @param {string} id - The named destination to get.\n   * @returns {Promise<Array<any>>} A promise that is resolved with all\n   *   information of the given named destination.\n   */\n  getDestination(id) {\n    return this._transport.getDestination(id);\n  }\n\n  /**\n   * @returns {Promise<Array<string> | null>} A promise that is resolved with\n   *   an {Array} containing the page labels that correspond to the page\n   *   indexes, or `null` when no page labels are present in the PDF file.\n   */\n  getPageLabels() {\n    return this._transport.getPageLabels();\n  }\n\n  /**\n   * @returns {Promise<string>} A promise that is resolved with a {string}\n   *   containing the page layout name.\n   */\n  getPageLayout() {\n    return this._transport.getPageLayout();\n  }\n\n  /**\n   * @returns {Promise<string>} A promise that is resolved with a {string}\n   *   containing the page mode name.\n   */\n  getPageMode() {\n    return this._transport.getPageMode();\n  }\n\n  /**\n   * @returns {Promise<Object | null>} A promise that is resolved with an\n   *   {Object} containing the viewer preferences, or `null` when no viewer\n   *   preferences are present in the PDF file.\n   */\n  getViewerPreferences() {\n    return this._transport.getViewerPreferences();\n  }\n\n  /**\n   * @returns {Promise<any | null>} A promise that is resolved with an {Array}\n   *   containing the destination, or `null` when no open action is present\n   *   in the PDF.\n   */\n  getOpenAction() {\n    return this._transport.getOpenAction();\n  }\n\n  /**\n   * @returns {Promise<any>} A promise that is resolved with a lookup table\n   *   for mapping named attachments to their content.\n   */\n  getAttachments() {\n    return this._transport.getAttachments();\n  }\n\n  /**\n   * @returns {Promise<Array<string> | null>} A promise that is resolved with\n   *   an {Array} of all the JavaScript strings in the name tree, or `null`\n   *   if no JavaScript exists.\n   */\n  getJavaScript() {\n    return this._transport.getJavaScript();\n  }\n\n  /**\n   * @typedef {Object} OutlineNode\n   * @property {string} title\n   * @property {boolean} bold\n   * @property {boolean} italic\n   * @property {Uint8ClampedArray} color - The color in RGB format to use for\n   *   display purposes.\n   * @property {string | Array<any> | null} dest\n   * @property {string | null} url\n   * @property {string | undefined} unsafeUrl\n   * @property {boolean | undefined} newWindow\n   * @property {number | undefined} count\n   * @property {Array<OutlineNode>} items\n   */\n\n  /**\n   * @returns {Promise<Array<OutlineNode>>} A promise that is resolved with an\n   *   {Array} that is a tree outline (if it has one) of the PDF file.\n   */\n  getOutline() {\n    return this._transport.getOutline();\n  }\n\n  /**\n   * @returns {Promise<OptionalContentConfig>} A promise that is resolved with\n   *   an {@link OptionalContentConfig} that contains all the optional content\n   *   groups (assuming that the document has any).\n   */\n  getOptionalContentConfig() {\n    return this._transport.getOptionalContentConfig();\n  }\n\n  /**\n   * @returns {Promise<Array<number> | null>} A promise that is resolved with\n   *   an {Array} that contains the permission flags for the PDF document, or\n   *   `null` when no permissions are present in the PDF file.\n   */\n  getPermissions() {\n    return this._transport.getPermissions();\n  }\n\n  /**\n   * @returns {Promise<{ info: Object, metadata: Metadata }>} A promise that is\n   *   resolved with an {Object} that has `info` and `metadata` properties.\n   *   `info` is an {Object} filled with anything available in the information\n   *   dictionary and similarly `metadata` is a {Metadata} object with\n   *   information from the metadata section of the PDF.\n   */\n  getMetadata() {\n    return this._transport.getMetadata();\n  }\n\n  /**\n   * @returns {Promise<TypedArray>} A promise that is resolved with a\n   *   {TypedArray} that has the raw data from the PDF.\n   */\n  getData() {\n    return this._transport.getData();\n  }\n\n  /**\n   * @returns {Promise<{ length: number }>} A promise that is resolved when the\n   *   document's data is loaded. It is resolved with an {Object} that contains\n   *   the `length` property that indicates size of the PDF data in bytes.\n   */\n  getDownloadInfo() {\n    return this._transport.downloadInfoCapability.promise;\n  }\n\n  /**\n   * @returns {Promise<PDFDocumentStats>} A promise this is resolved with\n   *   current statistics about document structures (see\n   *   {@link PDFDocumentStats}).\n   */\n  getStats() {\n    return this._transport.getStats();\n  }\n\n  /**\n   * Cleans up resources allocated by the document on both the main and worker\n   * threads.\n   *\n   * NOTE: Do not, under any circumstances, call this method when rendering is\n   * currently ongoing since that may lead to rendering errors.\n   *\n   * @returns {Promise} A promise that is resolved when clean-up has finished.\n   */\n  cleanup() {\n    return this._transport.startCleanup();\n  }\n\n  /**\n   * Destroys the current document instance and terminates the worker.\n   */\n  destroy() {\n    return this.loadingTask.destroy();\n  }\n\n  /**\n   * @type {DocumentInitParameters} A subset of the current\n   *   {DocumentInitParameters}, which are either needed in the viewer and/or\n   *   whose default values may be affected by the `apiCompatibilityParams`.\n   */\n  get loadingParams() {\n    return this._transport.loadingParams;\n  }\n\n  /**\n   * @type {PDFDocumentLoadingTask} The loadingTask for the current document.\n   */\n  get loadingTask() {\n    return this._transport.loadingTask;\n  }\n\n  /**\n   * @param {AnnotationStorage} annotationStorage - Storage for annotation\n   *   data in forms.\n   * @returns {Promise<Uint8Array>} A promise that is resolved with a\n   *   {Uint8Array} containing the full data of the saved document.\n   */\n  saveDocument(annotationStorage) {\n    return this._transport.saveDocument(annotationStorage);\n  }\n}\n\n/**\n * Page getViewport parameters.\n *\n * @typedef {Object} GetViewportParameters\n * @property {number} scale - The desired scale of the viewport.\n * @property {number} [rotation] - The desired rotation, in degrees, of\n *   the viewport. If omitted it defaults to the page rotation.\n * @property {number} [offsetX] - The horizontal, i.e. x-axis, offset.\n *   The default value is `0`.\n * @property {number} [offsetY] - The vertical, i.e. y-axis, offset.\n *   The default value is `0`.\n * @property {boolean} [dontFlip] - If true, the y-axis will not be\n *   flipped. The default value is `false`.\n */\n\n/**\n * Page getTextContent parameters.\n *\n * @typedef {Object} getTextContentParameters\n * @property {boolean} normalizeWhitespace - Replaces all occurrences of\n *   whitespace with standard spaces (0x20). The default value is `false`.\n * @property {boolean} disableCombineTextItems - Do not attempt to combine\n *   same line {@link TextItem}'s. The default value is `false`.\n */\n\n/**\n * Page text content.\n *\n * @typedef {Object} TextContent\n * @property {Array<TextItem>} items - Array of {@link TextItem} objects.\n * @property {Object<string, TextStyle>} styles - {@link TextStyle} objects,\n *   indexed by font name.\n */\n\n/**\n * Page text content part.\n *\n * @typedef {Object} TextItem\n * @property {string} str - Text content.\n * @property {string} dir - Text direction: 'ttb', 'ltr' or 'rtl'.\n * @property {Array<any>} transform - Transformation matrix.\n * @property {number} width - Width in device space.\n * @property {number} height - Height in device space.\n * @property {string} fontName - Font name used by PDF.js for converted font.\n */\n\n/**\n * Text style.\n *\n * @typedef {Object} TextStyle\n * @property {number} ascent - Font ascent.\n * @property {number} descent - Font descent.\n * @property {boolean} vertical - Whether or not the text is in vertical mode.\n * @property {string} fontFamily - The possible font family.\n */\n\n/**\n * Page annotation parameters.\n *\n * @typedef {Object} GetAnnotationsParameters\n * @property {string} intent - Determines the annotations that will be fetched,\n *   can be either 'display' (viewable annotations) or 'print' (printable\n *   annotations). If the parameter is omitted, all annotations are fetched.\n */\n\n/**\n * Page render parameters.\n *\n * @typedef {Object} RenderParameters\n * @property {Object} canvasContext - A 2D context of a DOM Canvas object.\n * @property {PageViewport} viewport - Rendering viewport obtained by calling\n *   the `PDFPageProxy.getViewport` method.\n * @property {string} [intent] - Rendering intent, can be 'display' or 'print'.\n *   The default value is 'display'.\n * @property {boolean} [enableWebGL] - Enables WebGL accelerated rendering for\n *   some operations. The default value is `false`.\n * @property {boolean} [renderInteractiveForms] - Whether or not interactive\n *   form elements are rendered in the display layer. If so, we do not render\n *   them on the canvas as well.\n * @property {Array<any>} [transform] - Additional transform, applied just\n *   before viewport transform.\n * @property {Object} [imageLayer] - An object that has `beginLayout`,\n *   `endLayout` and `appendImage` functions.\n * @property {Object} [canvasFactory] - The factory instance that will be used\n *   when creating canvases. The default value is {new DOMCanvasFactory()}.\n * @property {Object | string} [background] - Background to use for the canvas.\n *   Any valid `canvas.fillStyle` can be used: a `DOMString` parsed as CSS\n *   <color> value, a `CanvasGradient` object (a linear or radial gradient) or\n *   a `CanvasPattern` object (a repetitive image). The default value is\n *   'rgb(255,255,255)'.\n * @property {AnnotationStorage} [annotationStorage] - Storage for annotation\n *   data in forms.\n * @property {Promise<OptionalContentConfig>} [optionalContentConfigPromise] -\n *   A promise that should resolve with an {@link OptionalContentConfig}\n *   created from `PDFDocumentProxy.getOptionalContentConfig`. If `null`,\n *   the configuration will be fetched automatically with the default visibility\n *   states set.\n */\n\n/**\n * PDF page operator list.\n *\n * @typedef {Object} PDFOperatorList\n * @property {Array<number>} fnArray - Array containing the operator functions.\n * @property {Array<any>} argsArray - Array containing the arguments of the\n *   functions.\n */\n\n/**\n * Proxy to a `PDFPage` in the worker thread.\n */\nclass PDFPageProxy {\n  constructor(pageIndex, pageInfo, transport, ownerDocument, pdfBug = false) {\n    this._pageIndex = pageIndex;\n    this._pageInfo = pageInfo;\n    this._ownerDocument = ownerDocument;\n    this._transport = transport;\n    this._stats = pdfBug ? new StatTimer() : null;\n    this._pdfBug = pdfBug;\n    this.commonObjs = transport.commonObjs;\n    this.objs = new PDFObjects();\n\n    this.cleanupAfterRender = false;\n    this.pendingCleanup = false;\n    this._intentStates = new Map();\n    this.destroyed = false;\n  }\n\n  /**\n   * @type {number} Page number of the page. First page is 1.\n   */\n  get pageNumber() {\n    return this._pageIndex + 1;\n  }\n\n  /**\n   * @type {number} The number of degrees the page is rotated clockwise.\n   */\n  get rotate() {\n    return this._pageInfo.rotate;\n  }\n\n  /**\n   * @type {Object} The reference that points to this page. It has `num` and\n   *   `gen` properties.\n   */\n  get ref() {\n    return this._pageInfo.ref;\n  }\n\n  /**\n   * @type {number} The default size of units in 1/72nds of an inch.\n   */\n  get userUnit() {\n    return this._pageInfo.userUnit;\n  }\n\n  /**\n   * @type {Array<number>} An array of the visible portion of the PDF page in\n   *   user space units [x1, y1, x2, y2].\n   */\n  get view() {\n    return this._pageInfo.view;\n  }\n\n  /**\n   * @param {GetViewportParameters} params - Viewport parameters.\n   * @returns {PageViewport} Contains 'width' and 'height' properties\n   *   along with transforms required for rendering.\n   */\n  getViewport({\n    scale,\n    rotation = this.rotate,\n    offsetX = 0,\n    offsetY = 0,\n    dontFlip = false,\n  } = {}) {\n    return new PageViewport({\n      viewBox: this.view,\n      scale,\n      rotation,\n      offsetX,\n      offsetY,\n      dontFlip,\n    });\n  }\n\n  /**\n   * @param {GetAnnotationsParameters} params - Annotation parameters.\n   * @returns {Promise<Array<any>>} A promise that is resolved with an\n   *   {Array} of the annotation objects.\n   */\n  getAnnotations({ intent = null } = {}) {\n    if (!this.annotationsPromise || this.annotationsIntent !== intent) {\n      this.annotationsPromise = this._transport.getAnnotations(\n        this._pageIndex,\n        intent\n      );\n      this.annotationsIntent = intent;\n    }\n    return this.annotationsPromise;\n  }\n\n  /**\n   * Begins the process of rendering a page to the desired context.\n   *\n   * @param {RenderParameters} params Page render parameters.\n   * @returns {RenderTask} An object that contains a promise that is\n   *   resolved when the page finishes rendering.\n   */\n  render({\n    canvasContext,\n    viewport,\n    intent = \"display\",\n    enableWebGL = false,\n    renderInteractiveForms = false,\n    transform = null,\n    imageLayer = null,\n    canvasFactory = null,\n    background = null,\n    annotationStorage = null,\n    optionalContentConfigPromise = null,\n  }) {\n    if (this._stats) {\n      this._stats.time(\"Overall\");\n    }\n\n    const renderingIntent = intent === \"print\" ? \"print\" : \"display\";\n    // If there was a pending destroy, cancel it so no cleanup happens during\n    // this call to render.\n    this.pendingCleanup = false;\n\n    if (!optionalContentConfigPromise) {\n      optionalContentConfigPromise = this._transport.getOptionalContentConfig();\n    }\n\n    let intentState = this._intentStates.get(renderingIntent);\n    if (!intentState) {\n      intentState = Object.create(null);\n      this._intentStates.set(renderingIntent, intentState);\n    }\n\n    // Ensure that a pending `streamReader` cancel timeout is always aborted.\n    if (intentState.streamReaderCancelTimeout) {\n      clearTimeout(intentState.streamReaderCancelTimeout);\n      intentState.streamReaderCancelTimeout = null;\n    }\n\n    const canvasFactoryInstance =\n      canvasFactory ||\n      new DefaultCanvasFactory({ ownerDocument: this._ownerDocument });\n    const webGLContext = new WebGLContext({\n      enable: enableWebGL,\n    });\n\n    // If there's no displayReadyCapability yet, then the operatorList\n    // was never requested before. Make the request and create the promise.\n    if (!intentState.displayReadyCapability) {\n      intentState.displayReadyCapability = createPromiseCapability();\n      intentState.operatorList = {\n        fnArray: [],\n        argsArray: [],\n        lastChunk: false,\n      };\n\n      if (this._stats) {\n        this._stats.time(\"Page Request\");\n      }\n      this._pumpOperatorList({\n        pageIndex: this._pageIndex,\n        intent: renderingIntent,\n        renderInteractiveForms: renderInteractiveForms === true,\n        annotationStorage:\n          (annotationStorage && annotationStorage.getAll()) || null,\n      });\n    }\n\n    const complete = error => {\n      const i = intentState.renderTasks.indexOf(internalRenderTask);\n      if (i >= 0) {\n        intentState.renderTasks.splice(i, 1);\n      }\n\n      // Attempt to reduce memory usage during *printing*, by always running\n      // cleanup once rendering has finished (regardless of cleanupAfterRender).\n      if (this.cleanupAfterRender || renderingIntent === \"print\") {\n        this.pendingCleanup = true;\n      }\n      this._tryCleanup();\n\n      if (error) {\n        internalRenderTask.capability.reject(error);\n\n        this._abortOperatorList({\n          intentState,\n          reason: error,\n        });\n      } else {\n        internalRenderTask.capability.resolve();\n      }\n      if (this._stats) {\n        this._stats.timeEnd(\"Rendering\");\n        this._stats.timeEnd(\"Overall\");\n      }\n    };\n\n    const internalRenderTask = new InternalRenderTask({\n      callback: complete,\n      // Only include the required properties, and *not* the entire object.\n      params: {\n        canvasContext,\n        viewport,\n        transform,\n        imageLayer,\n        background,\n      },\n      objs: this.objs,\n      commonObjs: this.commonObjs,\n      operatorList: intentState.operatorList,\n      pageIndex: this._pageIndex,\n      canvasFactory: canvasFactoryInstance,\n      webGLContext,\n      useRequestAnimationFrame: renderingIntent !== \"print\",\n      pdfBug: this._pdfBug,\n    });\n\n    if (!intentState.renderTasks) {\n      intentState.renderTasks = [];\n    }\n    intentState.renderTasks.push(internalRenderTask);\n    const renderTask = internalRenderTask.task;\n\n    Promise.all([\n      intentState.displayReadyCapability.promise,\n      optionalContentConfigPromise,\n    ])\n      .then(([transparency, optionalContentConfig]) => {\n        if (this.pendingCleanup) {\n          complete();\n          return;\n        }\n        if (this._stats) {\n          this._stats.time(\"Rendering\");\n        }\n        internalRenderTask.initializeGraphics({\n          transparency,\n          optionalContentConfig,\n        });\n        internalRenderTask.operatorListChanged();\n      })\n      .catch(complete);\n\n    return renderTask;\n  }\n\n  /**\n   * @returns {Promise<PDFOperatorList>} A promise resolved with an\n   *   {@link PDFOperatorList} object that represents page's operator list.\n   */\n  getOperatorList() {\n    function operatorListChanged() {\n      if (intentState.operatorList.lastChunk) {\n        intentState.opListReadCapability.resolve(intentState.operatorList);\n\n        const i = intentState.renderTasks.indexOf(opListTask);\n        if (i >= 0) {\n          intentState.renderTasks.splice(i, 1);\n        }\n      }\n    }\n\n    const renderingIntent = \"oplist\";\n    let intentState = this._intentStates.get(renderingIntent);\n    if (!intentState) {\n      intentState = Object.create(null);\n      this._intentStates.set(renderingIntent, intentState);\n    }\n    let opListTask;\n\n    if (!intentState.opListReadCapability) {\n      opListTask = Object.create(null);\n      opListTask.operatorListChanged = operatorListChanged;\n      intentState.opListReadCapability = createPromiseCapability();\n      intentState.renderTasks = [];\n      intentState.renderTasks.push(opListTask);\n      intentState.operatorList = {\n        fnArray: [],\n        argsArray: [],\n        lastChunk: false,\n      };\n\n      if (this._stats) {\n        this._stats.time(\"Page Request\");\n      }\n      this._pumpOperatorList({\n        pageIndex: this._pageIndex,\n        intent: renderingIntent,\n      });\n    }\n    return intentState.opListReadCapability.promise;\n  }\n\n  /**\n   * @param {getTextContentParameters} params - getTextContent parameters.\n   * @returns {ReadableStream} Stream for reading text content chunks.\n   */\n  streamTextContent({\n    normalizeWhitespace = false,\n    disableCombineTextItems = false,\n  } = {}) {\n    const TEXT_CONTENT_CHUNK_SIZE = 100;\n\n    return this._transport.messageHandler.sendWithStream(\n      \"GetTextContent\",\n      {\n        pageIndex: this._pageIndex,\n        normalizeWhitespace: normalizeWhitespace === true,\n        combineTextItems: disableCombineTextItems !== true,\n      },\n      {\n        highWaterMark: TEXT_CONTENT_CHUNK_SIZE,\n        size(textContent) {\n          return textContent.items.length;\n        },\n      }\n    );\n  }\n\n  /**\n   * @param {getTextContentParameters} params - getTextContent parameters.\n   * @returns {Promise<TextContent>} A promise that is resolved with a\n   *   {@link TextContent} object that represents the page's text content.\n   */\n  getTextContent(params = {}) {\n    const readableStream = this.streamTextContent(params);\n\n    return new Promise(function (resolve, reject) {\n      function pump() {\n        reader.read().then(function ({ value, done }) {\n          if (done) {\n            resolve(textContent);\n            return;\n          }\n          Object.assign(textContent.styles, value.styles);\n          textContent.items.push(...value.items);\n          pump();\n        }, reject);\n      }\n\n      const reader = readableStream.getReader();\n      const textContent = {\n        items: [],\n        styles: Object.create(null),\n      };\n      pump();\n    });\n  }\n\n  /**\n   * Destroys the page object.\n   * @private\n   */\n  _destroy() {\n    this.destroyed = true;\n    this._transport.pageCache[this._pageIndex] = null;\n\n    const waitOn = [];\n    for (const [intent, intentState] of this._intentStates) {\n      this._abortOperatorList({\n        intentState,\n        reason: new Error(\"Page was destroyed.\"),\n        force: true,\n      });\n\n      if (intent === \"oplist\") {\n        // Avoid errors below, since the renderTasks are just stubs.\n        continue;\n      }\n      for (const internalRenderTask of intentState.renderTasks) {\n        waitOn.push(internalRenderTask.completed);\n        internalRenderTask.cancel();\n      }\n    }\n    this.objs.clear();\n    this.annotationsPromise = null;\n    this.pendingCleanup = false;\n    return Promise.all(waitOn);\n  }\n\n  /**\n   * Cleans up resources allocated by the page.\n   *\n   * @param {boolean} [resetStats] - Reset page stats, if enabled.\n   *   The default value is `false`.\n   * @returns {boolean} Indicates if clean-up was successfully run.\n   */\n  cleanup(resetStats = false) {\n    this.pendingCleanup = true;\n    return this._tryCleanup(resetStats);\n  }\n\n  /**\n   * Attempts to clean up if rendering is in a state where that's possible.\n   * @private\n   */\n  _tryCleanup(resetStats = false) {\n    if (!this.pendingCleanup) {\n      return false;\n    }\n    for (const { renderTasks, operatorList } of this._intentStates.values()) {\n      if (renderTasks.length !== 0 || !operatorList.lastChunk) {\n        return false;\n      }\n    }\n\n    this._intentStates.clear();\n    this.objs.clear();\n    this.annotationsPromise = null;\n    if (resetStats && this._stats) {\n      this._stats = new StatTimer();\n    }\n    this.pendingCleanup = false;\n    return true;\n  }\n\n  /**\n   * @private\n   */\n  _startRenderPage(transparency, intent) {\n    const intentState = this._intentStates.get(intent);\n    if (!intentState) {\n      return; // Rendering was cancelled.\n    }\n    if (this._stats) {\n      this._stats.timeEnd(\"Page Request\");\n    }\n    // TODO Refactor RenderPageRequest to separate rendering\n    // and operator list logic\n    if (intentState.displayReadyCapability) {\n      intentState.displayReadyCapability.resolve(transparency);\n    }\n  }\n\n  /**\n   * @private\n   */\n  _renderPageChunk(operatorListChunk, intentState) {\n    // Add the new chunk to the current operator list.\n    for (let i = 0, ii = operatorListChunk.length; i < ii; i++) {\n      intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);\n      intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);\n    }\n    intentState.operatorList.lastChunk = operatorListChunk.lastChunk;\n\n    // Notify all the rendering tasks there are more operators to be consumed.\n    for (let i = 0; i < intentState.renderTasks.length; i++) {\n      intentState.renderTasks[i].operatorListChanged();\n    }\n\n    if (operatorListChunk.lastChunk) {\n      this._tryCleanup();\n    }\n  }\n\n  /**\n   * @private\n   */\n  _pumpOperatorList(args) {\n    assert(\n      args.intent,\n      'PDFPageProxy._pumpOperatorList: Expected \"intent\" argument.'\n    );\n\n    const readableStream = this._transport.messageHandler.sendWithStream(\n      \"GetOperatorList\",\n      args\n    );\n    const reader = readableStream.getReader();\n\n    const intentState = this._intentStates.get(args.intent);\n    intentState.streamReader = reader;\n\n    const pump = () => {\n      reader.read().then(\n        ({ value, done }) => {\n          if (done) {\n            intentState.streamReader = null;\n            return;\n          }\n          if (this._transport.destroyed) {\n            return; // Ignore any pending requests if the worker was terminated.\n          }\n          this._renderPageChunk(value, intentState);\n          pump();\n        },\n        reason => {\n          intentState.streamReader = null;\n\n          if (this._transport.destroyed) {\n            return; // Ignore any pending requests if the worker was terminated.\n          }\n          if (intentState.operatorList) {\n            // Mark operator list as complete.\n            intentState.operatorList.lastChunk = true;\n\n            for (let i = 0; i < intentState.renderTasks.length; i++) {\n              intentState.renderTasks[i].operatorListChanged();\n            }\n            this._tryCleanup();\n          }\n\n          if (intentState.displayReadyCapability) {\n            intentState.displayReadyCapability.reject(reason);\n          } else if (intentState.opListReadCapability) {\n            intentState.opListReadCapability.reject(reason);\n          } else {\n            throw reason;\n          }\n        }\n      );\n    };\n    pump();\n  }\n\n  /**\n   * @private\n   */\n  _abortOperatorList({ intentState, reason, force = false }) {\n    assert(\n      reason instanceof Error ||\n        (typeof reason === \"object\" && reason !== null),\n      'PDFPageProxy._abortOperatorList: Expected \"reason\" argument.'\n    );\n\n    if (!intentState.streamReader) {\n      return;\n    }\n    if (!force) {\n      // Ensure that an Error occurring in *only* one `InternalRenderTask`, e.g.\n      // multiple render() calls on the same canvas, won't break all rendering.\n      if (intentState.renderTasks.length !== 0) {\n        return;\n      }\n      // Don't immediately abort parsing on the worker-thread when rendering is\n      // cancelled, since that will unnecessarily delay re-rendering when (for\n      // partially parsed pages) e.g. zooming/rotation occurs in the viewer.\n      if (reason instanceof RenderingCancelledException) {\n        intentState.streamReaderCancelTimeout = setTimeout(() => {\n          this._abortOperatorList({ intentState, reason, force: true });\n          intentState.streamReaderCancelTimeout = null;\n        }, RENDERING_CANCELLED_TIMEOUT);\n        return;\n      }\n    }\n    intentState.streamReader.cancel(\n      new AbortException(reason && reason.message)\n    );\n    intentState.streamReader = null;\n\n    if (this._transport.destroyed) {\n      return; // Ignore any pending requests if the worker was terminated.\n    }\n    // Remove the current `intentState`, since a cancelled `getOperatorList`\n    // call on the worker-thread cannot be re-started...\n    for (const [intent, curIntentState] of this._intentStates) {\n      if (curIntentState === intentState) {\n        this._intentStates.delete(intent);\n        break;\n      }\n    }\n    // ... and force clean-up to ensure that any old state is always removed.\n    this.cleanup();\n  }\n\n  /**\n   * @type {Object} Returns page stats, if enabled; returns `null` otherwise.\n   */\n  get stats() {\n    return this._stats;\n  }\n}\n\nclass LoopbackPort {\n  constructor(defer = true) {\n    this._listeners = [];\n    this._defer = defer;\n    this._deferred = Promise.resolve(undefined);\n  }\n\n  postMessage(obj, transfers) {\n    function cloneValue(value) {\n      // Trying to perform a structured clone close to the spec, including\n      // transfers.\n      if (typeof value !== \"object\" || value === null) {\n        return value;\n      }\n      if (cloned.has(value)) {\n        // already cloned the object\n        return cloned.get(value);\n      }\n      let buffer, result;\n      if ((buffer = value.buffer) && isArrayBuffer(buffer)) {\n        // We found object with ArrayBuffer (typed array).\n        const transferable = transfers && transfers.includes(buffer);\n        if (transferable) {\n          result = new value.constructor(\n            buffer,\n            value.byteOffset,\n            value.byteLength\n          );\n        } else {\n          result = new value.constructor(value);\n        }\n        cloned.set(value, result);\n        return result;\n      }\n      result = Array.isArray(value) ? [] : {};\n      cloned.set(value, result); // adding to cache now for cyclic references\n      // Cloning all value and object properties, however ignoring properties\n      // defined via getter.\n      for (const i in value) {\n        let desc,\n          p = value;\n        while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {\n          p = Object.getPrototypeOf(p);\n        }\n        if (typeof desc.value === \"undefined\") {\n          continue;\n        }\n        if (typeof desc.value === \"function\") {\n          if (value.hasOwnProperty && value.hasOwnProperty(i)) {\n            throw new Error(\n              `LoopbackPort.postMessage - cannot clone: ${value[i]}`\n            );\n          }\n          continue;\n        }\n        result[i] = cloneValue(desc.value);\n      }\n      return result;\n    }\n\n    if (!this._defer) {\n      this._listeners.forEach(listener => {\n        listener.call(this, { data: obj });\n      });\n      return;\n    }\n\n    const cloned = new WeakMap();\n    const e = { data: cloneValue(obj) };\n    this._deferred.then(() => {\n      this._listeners.forEach(listener => {\n        listener.call(this, e);\n      });\n    });\n  }\n\n  addEventListener(name, listener) {\n    this._listeners.push(listener);\n  }\n\n  removeEventListener(name, listener) {\n    const i = this._listeners.indexOf(listener);\n    this._listeners.splice(i, 1);\n  }\n\n  terminate() {\n    this._listeners.length = 0;\n  }\n}\n\n/**\n * @typedef {Object} PDFWorkerParameters\n * @property {string} [name] - The name of the worker.\n * @property {Object} [port] - The `workerPort` object.\n * @property {number} [verbosity] - Controls the logging level; the\n *   constants from {@link VerbosityLevel} should be used.\n */\n\n/** @type {any} */\nconst PDFWorker = (function PDFWorkerClosure() {\n  const pdfWorkerPorts = new WeakMap();\n  let isWorkerDisabled = false;\n  let fallbackWorkerSrc;\n  let nextFakeWorkerId = 0;\n  let fakeWorkerCapability;\n\n  if (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"GENERIC\")) {\n    // eslint-disable-next-line no-undef\n    if (isNodeJS && typeof __non_webpack_require__ === \"function\") {\n      // Workers aren't supported in Node.js, force-disabling them there.\n      isWorkerDisabled = true;\n\n      if (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"LIB\")) {\n        fallbackWorkerSrc = \"../pdf.worker.js\";\n      } else {\n        fallbackWorkerSrc = \"./pdf.worker.js\";\n      }\n    } else if (typeof document === \"object\" && \"currentScript\" in document) {\n      const pdfjsFilePath =\n        document.currentScript && document.currentScript.src;\n      if (pdfjsFilePath) {\n        fallbackWorkerSrc = pdfjsFilePath.replace(\n          /(\\.(?:min\\.)?js)(\\?.*)?$/i,\n          \".worker$1$2\"\n        );\n      }\n    }\n  }\n\n  function getWorkerSrc() {\n    if (GlobalWorkerOptions.workerSrc) {\n      return GlobalWorkerOptions.workerSrc;\n    }\n    if (typeof fallbackWorkerSrc !== \"undefined\") {\n      if (!isNodeJS) {\n        deprecated('No \"GlobalWorkerOptions.workerSrc\" specified.');\n      }\n      return fallbackWorkerSrc;\n    }\n    throw new Error('No \"GlobalWorkerOptions.workerSrc\" specified.');\n  }\n\n  function getMainThreadWorkerMessageHandler() {\n    let mainWorkerMessageHandler;\n    try {\n      mainWorkerMessageHandler =\n        globalThis.pdfjsWorker && globalThis.pdfjsWorker.WorkerMessageHandler;\n    } catch (ex) {\n      /* Ignore errors. */\n    }\n    return mainWorkerMessageHandler || null;\n  }\n\n  // Loads worker code into main thread.\n  function setupFakeWorkerGlobal() {\n    if (fakeWorkerCapability) {\n      return fakeWorkerCapability.promise;\n    }\n    fakeWorkerCapability = createPromiseCapability();\n\n    const loader = async function () {\n      const mainWorkerMessageHandler = getMainThreadWorkerMessageHandler();\n\n      if (mainWorkerMessageHandler) {\n        // The worker was already loaded using e.g. a `<script>` tag.\n        return mainWorkerMessageHandler;\n      }\n      if (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"PRODUCTION\")) {\n        if (typeof SystemJS !== \"object\") {\n          // Manually load SystemJS, since it's only necessary for fake workers.\n          await loadScript(\"../node_modules/systemjs/dist/system.js\");\n          await loadScript(\"../systemjs.config.js\");\n        }\n        const worker = await SystemJS.import(\"pdfjs/core/worker.js\");\n        return worker.WorkerMessageHandler;\n      }\n      if (\n        PDFJSDev.test(\"GENERIC\") &&\n        isNodeJS &&\n        // eslint-disable-next-line no-undef\n        typeof __non_webpack_require__ === \"function\"\n      ) {\n        // Since bundlers, such as Webpack, cannot be told to leave `require`\n        // statements alone we are thus forced to jump through hoops in order\n        // to prevent `Critical dependency: ...` warnings in third-party\n        // deployments of the built `pdf.js`/`pdf.worker.js` files; see\n        // https://github.com/webpack/webpack/issues/8826\n        //\n        // The following hack is based on the assumption that code running in\n        // Node.js won't ever be affected by e.g. Content Security Policies that\n        // prevent the use of `eval`. If that ever occurs, we should revert this\n        // to a normal `__non_webpack_require__` statement and simply document\n        // the Webpack warnings instead (telling users to ignore them).\n        //\n        // eslint-disable-next-line no-eval\n        const worker = eval(\"require\")(getWorkerSrc());\n        return worker.WorkerMessageHandler;\n      }\n      await loadScript(getWorkerSrc());\n      return window.pdfjsWorker.WorkerMessageHandler;\n    };\n    loader().then(fakeWorkerCapability.resolve, fakeWorkerCapability.reject);\n\n    return fakeWorkerCapability.promise;\n  }\n\n  function createCDNWrapper(url) {\n    // We will rely on blob URL's property to specify origin.\n    // We want this function to fail in case if createObjectURL or Blob do not\n    // exist or fail for some reason -- our Worker creation will fail anyway.\n    const wrapper = \"importScripts('\" + url + \"');\";\n    return URL.createObjectURL(new Blob([wrapper]));\n  }\n\n  /**\n   * PDF.js web worker abstraction that controls the instantiation of PDF\n   * documents. Message handlers are used to pass information from the main\n   * thread to the worker thread and vice versa. If the creation of a web\n   * worker is not possible, a \"fake\" worker will be used instead.\n   */\n  // eslint-disable-next-line no-shadow\n  class PDFWorker {\n    /**\n     * @param {PDFWorkerParameters} params - Worker initialization parameters.\n     */\n    constructor({\n      name = null,\n      port = null,\n      verbosity = getVerbosityLevel(),\n    } = {}) {\n      if (port && pdfWorkerPorts.has(port)) {\n        throw new Error(\"Cannot use more than one PDFWorker per port\");\n      }\n\n      this.name = name;\n      this.destroyed = false;\n      this.postMessageTransfers = true;\n      this.verbosity = verbosity;\n\n      this._readyCapability = createPromiseCapability();\n      this._port = null;\n      this._webWorker = null;\n      this._messageHandler = null;\n\n      if (port) {\n        pdfWorkerPorts.set(port, this);\n        this._initializeFromPort(port);\n        return;\n      }\n      this._initialize();\n    }\n\n    get promise() {\n      return this._readyCapability.promise;\n    }\n\n    get port() {\n      return this._port;\n    }\n\n    get messageHandler() {\n      return this._messageHandler;\n    }\n\n    _initializeFromPort(port) {\n      this._port = port;\n      this._messageHandler = new MessageHandler(\"main\", \"worker\", port);\n      this._messageHandler.on(\"ready\", function () {\n        // Ignoring 'ready' event -- MessageHandler shall be already initialized\n        // and ready to accept the messages.\n      });\n      this._readyCapability.resolve();\n    }\n\n    _initialize() {\n      // If worker support isn't disabled explicit and the browser has worker\n      // support, create a new web worker and test if it/the browser fulfills\n      // all requirements to run parts of pdf.js in a web worker.\n      // Right now, the requirement is, that an Uint8Array is still an\n      // Uint8Array as it arrives on the worker. (Chrome added this with v.15.)\n      if (\n        typeof Worker !== \"undefined\" &&\n        !isWorkerDisabled &&\n        !getMainThreadWorkerMessageHandler()\n      ) {\n        let workerSrc = getWorkerSrc();\n\n        try {\n          // Wraps workerSrc path into blob URL, if the former does not belong\n          // to the same origin.\n          if (\n            typeof PDFJSDev !== \"undefined\" &&\n            PDFJSDev.test(\"GENERIC\") &&\n            !isSameOrigin(window.location.href, workerSrc)\n          ) {\n            workerSrc = createCDNWrapper(\n              new URL(workerSrc, window.location).href\n            );\n          }\n\n          // Some versions of FF can't create a worker on localhost, see:\n          // https://bugzilla.mozilla.org/show_bug.cgi?id=683280\n          const worker = new Worker(workerSrc);\n          const messageHandler = new MessageHandler(\"main\", \"worker\", worker);\n          const terminateEarly = () => {\n            worker.removeEventListener(\"error\", onWorkerError);\n            messageHandler.destroy();\n            worker.terminate();\n            if (this.destroyed) {\n              this._readyCapability.reject(new Error(\"Worker was destroyed\"));\n            } else {\n              // Fall back to fake worker if the termination is caused by an\n              // error (e.g. NetworkError / SecurityError).\n              this._setupFakeWorker();\n            }\n          };\n\n          const onWorkerError = () => {\n            if (!this._webWorker) {\n              // Worker failed to initialize due to an error. Clean up and fall\n              // back to the fake worker.\n              terminateEarly();\n            }\n          };\n          worker.addEventListener(\"error\", onWorkerError);\n\n          messageHandler.on(\"test\", data => {\n            worker.removeEventListener(\"error\", onWorkerError);\n            if (this.destroyed) {\n              terminateEarly();\n              return; // worker was destroyed\n            }\n            if (data) {\n              // supportTypedArray\n              this._messageHandler = messageHandler;\n              this._port = worker;\n              this._webWorker = worker;\n              if (!data.supportTransfers) {\n                this.postMessageTransfers = false;\n              }\n              this._readyCapability.resolve();\n              // Send global setting, e.g. verbosity level.\n              messageHandler.send(\"configure\", {\n                verbosity: this.verbosity,\n              });\n            } else {\n              this._setupFakeWorker();\n              messageHandler.destroy();\n              worker.terminate();\n            }\n          });\n\n          messageHandler.on(\"ready\", data => {\n            worker.removeEventListener(\"error\", onWorkerError);\n            if (this.destroyed) {\n              terminateEarly();\n              return; // worker was destroyed\n            }\n            try {\n              sendTest();\n            } catch (e) {\n              // We need fallback to a faked worker.\n              this._setupFakeWorker();\n            }\n          });\n\n          const sendTest = () => {\n            const testObj = new Uint8Array([\n              this.postMessageTransfers ? 255 : 0,\n            ]);\n            // Some versions of Opera throw a DATA_CLONE_ERR on serializing the\n            // typed array. Also, checking if we can use transfers.\n            try {\n              messageHandler.send(\"test\", testObj, [testObj.buffer]);\n            } catch (ex) {\n              warn(\"Cannot use postMessage transfers.\");\n              testObj[0] = 0;\n              messageHandler.send(\"test\", testObj);\n            }\n          };\n\n          // It might take time for worker to initialize (especially when AMD\n          // loader is used). We will try to send test immediately, and then\n          // when 'ready' message will arrive. The worker shall process only\n          // first received 'test'.\n          sendTest();\n          return;\n        } catch (e) {\n          info(\"The worker has been disabled.\");\n        }\n      }\n      // Either workers are disabled, not supported or have thrown an exception.\n      // Thus, we fallback to a faked worker.\n      this._setupFakeWorker();\n    }\n\n    _setupFakeWorker() {\n      if (!isWorkerDisabled) {\n        warn(\"Setting up fake worker.\");\n        isWorkerDisabled = true;\n      }\n\n      setupFakeWorkerGlobal()\n        .then(WorkerMessageHandler => {\n          if (this.destroyed) {\n            this._readyCapability.reject(new Error(\"Worker was destroyed\"));\n            return;\n          }\n          const port = new LoopbackPort();\n          this._port = port;\n\n          // All fake workers use the same port, making id unique.\n          const id = \"fake\" + nextFakeWorkerId++;\n\n          // If the main thread is our worker, setup the handling for the\n          // messages -- the main thread sends to it self.\n          const workerHandler = new MessageHandler(id + \"_worker\", id, port);\n          WorkerMessageHandler.setup(workerHandler, port);\n\n          const messageHandler = new MessageHandler(id, id + \"_worker\", port);\n          this._messageHandler = messageHandler;\n          this._readyCapability.resolve();\n          // Send global setting, e.g. verbosity level.\n          messageHandler.send(\"configure\", {\n            verbosity: this.verbosity,\n          });\n        })\n        .catch(reason => {\n          this._readyCapability.reject(\n            new Error(`Setting up fake worker failed: \"${reason.message}\".`)\n          );\n        });\n    }\n\n    /**\n     * Destroys the worker instance.\n     */\n    destroy() {\n      this.destroyed = true;\n      if (this._webWorker) {\n        // We need to terminate only web worker created resource.\n        this._webWorker.terminate();\n        this._webWorker = null;\n      }\n      pdfWorkerPorts.delete(this._port);\n      this._port = null;\n      if (this._messageHandler) {\n        this._messageHandler.destroy();\n        this._messageHandler = null;\n      }\n    }\n\n    /**\n     * @param {PDFWorkerParameters} params - The worker initialization\n     *   parameters.\n     */\n    static fromPort(params) {\n      if (!params || !params.port) {\n        throw new Error(\"PDFWorker.fromPort - invalid method signature.\");\n      }\n      if (pdfWorkerPorts.has(params.port)) {\n        return pdfWorkerPorts.get(params.port);\n      }\n      return new PDFWorker(params);\n    }\n\n    static getWorkerSrc() {\n      return getWorkerSrc();\n    }\n  }\n  return PDFWorker;\n})();\n\n/**\n * For internal use only.\n * @ignore\n */\nclass WorkerTransport {\n  constructor(messageHandler, loadingTask, networkStream, params) {\n    this.messageHandler = messageHandler;\n    this.loadingTask = loadingTask;\n    this.commonObjs = new PDFObjects();\n    this.fontLoader = new FontLoader({\n      docId: loadingTask.docId,\n      onUnsupportedFeature: this._onUnsupportedFeature.bind(this),\n      ownerDocument: params.ownerDocument,\n    });\n    this._params = params;\n    this.CMapReaderFactory = new params.CMapReaderFactory({\n      baseUrl: params.cMapUrl,\n      isCompressed: params.cMapPacked,\n    });\n\n    this.destroyed = false;\n    this.destroyCapability = null;\n    this._passwordCapability = null;\n\n    this._networkStream = networkStream;\n    this._fullReader = null;\n    this._lastProgress = null;\n\n    this.pageCache = [];\n    this.pagePromises = [];\n    this.downloadInfoCapability = createPromiseCapability();\n\n    this.setupMessageHandler();\n  }\n\n  destroy() {\n    if (this.destroyCapability) {\n      return this.destroyCapability.promise;\n    }\n\n    this.destroyed = true;\n    this.destroyCapability = createPromiseCapability();\n\n    if (this._passwordCapability) {\n      this._passwordCapability.reject(\n        new Error(\"Worker was destroyed during onPassword callback\")\n      );\n    }\n\n    const waitOn = [];\n    // We need to wait for all renderings to be completed, e.g.\n    // timeout/rAF can take a long time.\n    this.pageCache.forEach(function (page) {\n      if (page) {\n        waitOn.push(page._destroy());\n      }\n    });\n    this.pageCache.length = 0;\n    this.pagePromises.length = 0;\n    // We also need to wait for the worker to finish its long running tasks.\n    const terminated = this.messageHandler.sendWithPromise(\"Terminate\", null);\n    waitOn.push(terminated);\n    Promise.all(waitOn).then(() => {\n      this.fontLoader.clear();\n      if (this._networkStream) {\n        this._networkStream.cancelAllRequests(\n          new AbortException(\"Worker was terminated.\")\n        );\n      }\n\n      if (this.messageHandler) {\n        this.messageHandler.destroy();\n        this.messageHandler = null;\n      }\n      this.destroyCapability.resolve();\n    }, this.destroyCapability.reject);\n    return this.destroyCapability.promise;\n  }\n\n  setupMessageHandler() {\n    const { messageHandler, loadingTask } = this;\n\n    messageHandler.on(\"GetReader\", (data, sink) => {\n      assert(\n        this._networkStream,\n        \"GetReader - no `IPDFStream` instance available.\"\n      );\n      this._fullReader = this._networkStream.getFullReader();\n      this._fullReader.onProgress = evt => {\n        this._lastProgress = {\n          loaded: evt.loaded,\n          total: evt.total,\n        };\n      };\n      sink.onPull = () => {\n        this._fullReader\n          .read()\n          .then(function ({ value, done }) {\n            if (done) {\n              sink.close();\n              return;\n            }\n            assert(\n              isArrayBuffer(value),\n              \"GetReader - expected an ArrayBuffer.\"\n            );\n            // Enqueue data chunk into sink, and transfer it\n            // to other side as `Transferable` object.\n            sink.enqueue(new Uint8Array(value), 1, [value]);\n          })\n          .catch(reason => {\n            sink.error(reason);\n          });\n      };\n\n      sink.onCancel = reason => {\n        this._fullReader.cancel(reason);\n\n        sink.ready.catch(readyReason => {\n          if (this.destroyed) {\n            return; // Ignore any pending requests if the worker was terminated.\n          }\n          throw readyReason;\n        });\n      };\n    });\n\n    messageHandler.on(\"ReaderHeadersReady\", data => {\n      const headersCapability = createPromiseCapability();\n      const fullReader = this._fullReader;\n      fullReader.headersReady.then(() => {\n        // If stream or range are disabled, it's our only way to report\n        // loading progress.\n        if (!fullReader.isStreamingSupported || !fullReader.isRangeSupported) {\n          if (this._lastProgress && loadingTask.onProgress) {\n            loadingTask.onProgress(this._lastProgress);\n          }\n          fullReader.onProgress = evt => {\n            if (loadingTask.onProgress) {\n              loadingTask.onProgress({\n                loaded: evt.loaded,\n                total: evt.total,\n              });\n            }\n          };\n        }\n\n        headersCapability.resolve({\n          isStreamingSupported: fullReader.isStreamingSupported,\n          isRangeSupported: fullReader.isRangeSupported,\n          contentLength: fullReader.contentLength,\n        });\n      }, headersCapability.reject);\n\n      return headersCapability.promise;\n    });\n\n    messageHandler.on(\"GetRangeReader\", (data, sink) => {\n      assert(\n        this._networkStream,\n        \"GetRangeReader - no `IPDFStream` instance available.\"\n      );\n      const rangeReader = this._networkStream.getRangeReader(\n        data.begin,\n        data.end\n      );\n\n      // When streaming is enabled, it's possible that the data requested here\n      // has already been fetched via the `_fullRequestReader` implementation.\n      // However, given that the PDF data is loaded asynchronously on the\n      // main-thread and then sent via `postMessage` to the worker-thread,\n      // it may not have been available during parsing (hence the attempt to\n      // use range requests here).\n      //\n      // To avoid wasting time and resources here, we'll thus *not* dispatch\n      // range requests if the data was already loaded but has not been sent to\n      // the worker-thread yet (which will happen via the `_fullRequestReader`).\n      if (!rangeReader) {\n        sink.close();\n        return;\n      }\n\n      sink.onPull = () => {\n        rangeReader\n          .read()\n          .then(function ({ value, done }) {\n            if (done) {\n              sink.close();\n              return;\n            }\n            assert(\n              isArrayBuffer(value),\n              \"GetRangeReader - expected an ArrayBuffer.\"\n            );\n            sink.enqueue(new Uint8Array(value), 1, [value]);\n          })\n          .catch(reason => {\n            sink.error(reason);\n          });\n      };\n\n      sink.onCancel = reason => {\n        rangeReader.cancel(reason);\n\n        sink.ready.catch(readyReason => {\n          if (this.destroyed) {\n            return; // Ignore any pending requests if the worker was terminated.\n          }\n          throw readyReason;\n        });\n      };\n    });\n\n    messageHandler.on(\"GetDoc\", ({ pdfInfo }) => {\n      this._numPages = pdfInfo.numPages;\n      loadingTask._capability.resolve(new PDFDocumentProxy(pdfInfo, this));\n    });\n\n    messageHandler.on(\"DocException\", function (ex) {\n      let reason;\n      switch (ex.name) {\n        case \"PasswordException\":\n          reason = new PasswordException(ex.message, ex.code);\n          break;\n        case \"InvalidPDFException\":\n          reason = new InvalidPDFException(ex.message);\n          break;\n        case \"MissingPDFException\":\n          reason = new MissingPDFException(ex.message);\n          break;\n        case \"UnexpectedResponseException\":\n          reason = new UnexpectedResponseException(ex.message, ex.status);\n          break;\n        case \"UnknownErrorException\":\n          reason = new UnknownErrorException(ex.message, ex.details);\n          break;\n      }\n      if (!(reason instanceof Error)) {\n        const msg = \"DocException - expected a valid Error.\";\n        if (\n          typeof PDFJSDev === \"undefined\" ||\n          PDFJSDev.test(\"!PRODUCTION || TESTING\")\n        ) {\n          unreachable(msg);\n        } else {\n          warn(msg);\n        }\n      }\n      loadingTask._capability.reject(reason);\n    });\n\n    messageHandler.on(\"PasswordRequest\", exception => {\n      this._passwordCapability = createPromiseCapability();\n\n      if (loadingTask.onPassword) {\n        const updatePassword = password => {\n          this._passwordCapability.resolve({\n            password,\n          });\n        };\n        try {\n          loadingTask.onPassword(updatePassword, exception.code);\n        } catch (ex) {\n          this._passwordCapability.reject(ex);\n        }\n      } else {\n        this._passwordCapability.reject(\n          new PasswordException(exception.message, exception.code)\n        );\n      }\n      return this._passwordCapability.promise;\n    });\n\n    messageHandler.on(\"DataLoaded\", data => {\n      // For consistency: Ensure that progress is always reported when the\n      // entire PDF file has been loaded, regardless of how it was fetched.\n      if (loadingTask.onProgress) {\n        loadingTask.onProgress({\n          loaded: data.length,\n          total: data.length,\n        });\n      }\n      this.downloadInfoCapability.resolve(data);\n    });\n\n    messageHandler.on(\"StartRenderPage\", data => {\n      if (this.destroyed) {\n        return; // Ignore any pending requests if the worker was terminated.\n      }\n\n      const page = this.pageCache[data.pageIndex];\n      page._startRenderPage(data.transparency, data.intent);\n    });\n\n    messageHandler.on(\"commonobj\", data => {\n      if (this.destroyed) {\n        return; // Ignore any pending requests if the worker was terminated.\n      }\n\n      const [id, type, exportedData] = data;\n      if (this.commonObjs.has(id)) {\n        return;\n      }\n\n      switch (type) {\n        case \"Font\":\n          const params = this._params;\n\n          if (\"error\" in exportedData) {\n            const exportedError = exportedData.error;\n            warn(`Error during font loading: ${exportedError}`);\n            this.commonObjs.resolve(id, exportedError);\n            break;\n          }\n\n          let fontRegistry = null;\n          if (\n            params.pdfBug &&\n            globalThis.FontInspector &&\n            globalThis.FontInspector.enabled\n          ) {\n            fontRegistry = {\n              registerFont(font, url) {\n                globalThis.FontInspector.fontAdded(font, url);\n              },\n            };\n          }\n          const font = new FontFaceObject(exportedData, {\n            isEvalSupported: params.isEvalSupported,\n            disableFontFace: params.disableFontFace,\n            ignoreErrors: params.ignoreErrors,\n            onUnsupportedFeature: this._onUnsupportedFeature.bind(this),\n            fontRegistry,\n          });\n\n          this.fontLoader\n            .bind(font)\n            .catch(reason => {\n              return messageHandler.sendWithPromise(\"FontFallback\", { id });\n            })\n            .finally(() => {\n              if (!params.fontExtraProperties && font.data) {\n                // Immediately release the `font.data` property once the font\n                // has been attached to the DOM, since it's no longer needed,\n                // rather than waiting for a `PDFDocumentProxy.cleanup` call.\n                // Since `font.data` could be very large, e.g. in some cases\n                // multiple megabytes, this will help reduce memory usage.\n                font.data = null;\n              }\n              this.commonObjs.resolve(id, font);\n            });\n          break;\n        case \"FontPath\":\n        case \"Image\":\n          this.commonObjs.resolve(id, exportedData);\n          break;\n        default:\n          throw new Error(`Got unknown common object type ${type}`);\n      }\n    });\n\n    messageHandler.on(\"obj\", data => {\n      if (this.destroyed) {\n        // Ignore any pending requests if the worker was terminated.\n        return undefined;\n      }\n\n      const [id, pageIndex, type, imageData] = data;\n      const pageProxy = this.pageCache[pageIndex];\n      if (pageProxy.objs.has(id)) {\n        return undefined;\n      }\n\n      switch (type) {\n        case \"Image\":\n          pageProxy.objs.resolve(id, imageData);\n\n          // Heuristic that will allow us not to store large data.\n          const MAX_IMAGE_SIZE_TO_STORE = 8000000;\n          if (\n            imageData &&\n            \"data\" in imageData &&\n            imageData.data.length > MAX_IMAGE_SIZE_TO_STORE\n          ) {\n            pageProxy.cleanupAfterRender = true;\n          }\n          break;\n        default:\n          throw new Error(`Got unknown object type ${type}`);\n      }\n      return undefined;\n    });\n\n    messageHandler.on(\"DocProgress\", data => {\n      if (this.destroyed) {\n        return; // Ignore any pending requests if the worker was terminated.\n      }\n\n      if (loadingTask.onProgress) {\n        loadingTask.onProgress({\n          loaded: data.loaded,\n          total: data.total,\n        });\n      }\n    });\n\n    messageHandler.on(\n      \"UnsupportedFeature\",\n      this._onUnsupportedFeature.bind(this)\n    );\n\n    messageHandler.on(\"FetchBuiltInCMap\", (data, sink) => {\n      if (this.destroyed) {\n        sink.error(new Error(\"Worker was destroyed\"));\n        return;\n      }\n      let fetched = false;\n\n      sink.onPull = () => {\n        if (fetched) {\n          sink.close();\n          return;\n        }\n        fetched = true;\n\n        this.CMapReaderFactory.fetch(data)\n          .then(function (builtInCMap) {\n            sink.enqueue(builtInCMap, 1, [builtInCMap.cMapData.buffer]);\n          })\n          .catch(function (reason) {\n            sink.error(reason);\n          });\n      };\n    });\n  }\n\n  _onUnsupportedFeature({ featureId }) {\n    if (this.destroyed) {\n      return; // Ignore any pending requests if the worker was terminated.\n    }\n    if (this.loadingTask.onUnsupportedFeature) {\n      this.loadingTask.onUnsupportedFeature(featureId);\n    }\n  }\n\n  getData() {\n    return this.messageHandler.sendWithPromise(\"GetData\", null);\n  }\n\n  getPage(pageNumber) {\n    if (\n      !Number.isInteger(pageNumber) ||\n      pageNumber <= 0 ||\n      pageNumber > this._numPages\n    ) {\n      return Promise.reject(new Error(\"Invalid page request\"));\n    }\n\n    const pageIndex = pageNumber - 1;\n    if (pageIndex in this.pagePromises) {\n      return this.pagePromises[pageIndex];\n    }\n    const promise = this.messageHandler\n      .sendWithPromise(\"GetPage\", {\n        pageIndex,\n      })\n      .then(pageInfo => {\n        if (this.destroyed) {\n          throw new Error(\"Transport destroyed\");\n        }\n        const page = new PDFPageProxy(\n          pageIndex,\n          pageInfo,\n          this,\n          this._params.ownerDocument,\n          this._params.pdfBug\n        );\n        this.pageCache[pageIndex] = page;\n        return page;\n      });\n    this.pagePromises[pageIndex] = promise;\n    return promise;\n  }\n\n  getPageIndex(ref) {\n    return this.messageHandler\n      .sendWithPromise(\"GetPageIndex\", {\n        ref,\n      })\n      .catch(function (reason) {\n        return Promise.reject(new Error(reason));\n      });\n  }\n\n  getAnnotations(pageIndex, intent) {\n    return this.messageHandler.sendWithPromise(\"GetAnnotations\", {\n      pageIndex,\n      intent,\n    });\n  }\n\n  saveDocument(annotationStorage) {\n    return this.messageHandler\n      .sendWithPromise(\"SaveDocument\", {\n        numPages: this._numPages,\n        annotationStorage:\n          (annotationStorage && annotationStorage.getAll()) || null,\n        filename: this._fullReader ? this._fullReader.filename : null,\n      })\n      .finally(() => {\n        if (annotationStorage) {\n          annotationStorage.resetModified();\n        }\n      });\n  }\n\n  getDestinations() {\n    return this.messageHandler.sendWithPromise(\"GetDestinations\", null);\n  }\n\n  getDestination(id) {\n    if (typeof id !== \"string\") {\n      return Promise.reject(new Error(\"Invalid destination request.\"));\n    }\n    return this.messageHandler.sendWithPromise(\"GetDestination\", {\n      id,\n    });\n  }\n\n  getPageLabels() {\n    return this.messageHandler.sendWithPromise(\"GetPageLabels\", null);\n  }\n\n  getPageLayout() {\n    return this.messageHandler.sendWithPromise(\"GetPageLayout\", null);\n  }\n\n  getPageMode() {\n    return this.messageHandler.sendWithPromise(\"GetPageMode\", null);\n  }\n\n  getViewerPreferences() {\n    return this.messageHandler.sendWithPromise(\"GetViewerPreferences\", null);\n  }\n\n  getOpenAction() {\n    return this.messageHandler.sendWithPromise(\"GetOpenAction\", null);\n  }\n\n  getAttachments() {\n    return this.messageHandler.sendWithPromise(\"GetAttachments\", null);\n  }\n\n  getJavaScript() {\n    return this.messageHandler.sendWithPromise(\"GetJavaScript\", null);\n  }\n\n  getOutline() {\n    return this.messageHandler.sendWithPromise(\"GetOutline\", null);\n  }\n\n  getOptionalContentConfig() {\n    return this.messageHandler\n      .sendWithPromise(\"GetOptionalContentConfig\", null)\n      .then(results => {\n        return new OptionalContentConfig(results);\n      });\n  }\n\n  getPermissions() {\n    return this.messageHandler.sendWithPromise(\"GetPermissions\", null);\n  }\n\n  getMetadata() {\n    return this.messageHandler\n      .sendWithPromise(\"GetMetadata\", null)\n      .then(results => {\n        return {\n          info: results[0],\n          metadata: results[1] ? new Metadata(results[1]) : null,\n          contentDispositionFilename: this._fullReader\n            ? this._fullReader.filename\n            : null,\n        };\n      });\n  }\n\n  getStats() {\n    return this.messageHandler.sendWithPromise(\"GetStats\", null);\n  }\n\n  startCleanup() {\n    return this.messageHandler.sendWithPromise(\"Cleanup\", null).then(() => {\n      for (let i = 0, ii = this.pageCache.length; i < ii; i++) {\n        const page = this.pageCache[i];\n        if (page) {\n          const cleanupSuccessful = page.cleanup();\n\n          if (!cleanupSuccessful) {\n            throw new Error(\n              `startCleanup: Page ${i + 1} is currently rendering.`\n            );\n          }\n        }\n      }\n      this.commonObjs.clear();\n      this.fontLoader.clear();\n    });\n  }\n\n  get loadingParams() {\n    const params = this._params;\n    return shadow(this, \"loadingParams\", {\n      disableAutoFetch: params.disableAutoFetch,\n      disableFontFace: params.disableFontFace,\n    });\n  }\n}\n\n/**\n * A PDF document and page is built of many objects. E.g. there are objects for\n * fonts, images, rendering code, etc. These objects may get processed inside of\n * a worker. This class implements some basic methods to manage these objects.\n * @ignore\n */\nclass PDFObjects {\n  constructor() {\n    this._objs = Object.create(null);\n  }\n\n  /**\n   * Ensures there is an object defined for `objId`.\n   * @private\n   */\n  _ensureObj(objId) {\n    if (this._objs[objId]) {\n      return this._objs[objId];\n    }\n    return (this._objs[objId] = {\n      capability: createPromiseCapability(),\n      data: null,\n      resolved: false,\n    });\n  }\n\n  /**\n   * If called *without* callback, this returns the data of `objId` but the\n   * object needs to be resolved. If it isn't, this method throws.\n   *\n   * If called *with* a callback, the callback is called with the data of the\n   * object once the object is resolved. That means, if you call this method\n   * and the object is already resolved, the callback gets called right away.\n   */\n  get(objId, callback = null) {\n    // If there is a callback, then the get can be async and the object is\n    // not required to be resolved right now.\n    if (callback) {\n      this._ensureObj(objId).capability.promise.then(callback);\n      return null;\n    }\n    // If there isn't a callback, the user expects to get the resolved data\n    // directly.\n    const obj = this._objs[objId];\n    // If there isn't an object yet or the object isn't resolved, then the\n    // data isn't ready yet!\n    if (!obj || !obj.resolved) {\n      throw new Error(`Requesting object that isn't resolved yet ${objId}.`);\n    }\n    return obj.data;\n  }\n\n  has(objId) {\n    const obj = this._objs[objId];\n    return obj ? obj.resolved : false;\n  }\n\n  /**\n   * Resolves the object `objId` with optional `data`.\n   */\n  resolve(objId, data) {\n    const obj = this._ensureObj(objId);\n\n    obj.resolved = true;\n    obj.data = data;\n    obj.capability.resolve(data);\n  }\n\n  clear() {\n    this._objs = Object.create(null);\n  }\n}\n\n/**\n * Allows controlling of the rendering tasks.\n */\nclass RenderTask {\n  constructor(internalRenderTask) {\n    this._internalRenderTask = internalRenderTask;\n\n    /**\n     * Callback for incremental rendering -- a function that will be called\n     * each time the rendering is paused.  To continue rendering call the\n     * function that is the first argument to the callback.\n     * @type {function}\n     */\n    this.onContinue = null;\n  }\n\n  /**\n   * Promise for rendering task completion.\n   * @type {Promise<void>}\n   */\n  get promise() {\n    return this._internalRenderTask.capability.promise;\n  }\n\n  /**\n   * Cancels the rendering task. If the task is currently rendering it will\n   * not be cancelled until graphics pauses with a timeout. The promise that\n   * this object extends will be rejected when cancelled.\n   */\n  cancel() {\n    this._internalRenderTask.cancel();\n  }\n}\n\n/**\n * For internal use only.\n * @ignore\n */\nconst InternalRenderTask = (function InternalRenderTaskClosure() {\n  const canvasInRendering = new WeakSet();\n\n  // eslint-disable-next-line no-shadow\n  class InternalRenderTask {\n    constructor({\n      callback,\n      params,\n      objs,\n      commonObjs,\n      operatorList,\n      pageIndex,\n      canvasFactory,\n      webGLContext,\n      useRequestAnimationFrame = false,\n      pdfBug = false,\n    }) {\n      this.callback = callback;\n      this.params = params;\n      this.objs = objs;\n      this.commonObjs = commonObjs;\n      this.operatorListIdx = null;\n      this.operatorList = operatorList;\n      this._pageIndex = pageIndex;\n      this.canvasFactory = canvasFactory;\n      this.webGLContext = webGLContext;\n      this._pdfBug = pdfBug;\n\n      this.running = false;\n      this.graphicsReadyCallback = null;\n      this.graphicsReady = false;\n      this._useRequestAnimationFrame =\n        useRequestAnimationFrame === true && typeof window !== \"undefined\";\n      this.cancelled = false;\n      this.capability = createPromiseCapability();\n      this.task = new RenderTask(this);\n      // caching this-bound methods\n      this._continueBound = this._continue.bind(this);\n      this._scheduleNextBound = this._scheduleNext.bind(this);\n      this._nextBound = this._next.bind(this);\n      this._canvas = params.canvasContext.canvas;\n    }\n\n    get completed() {\n      return this.capability.promise.catch(function () {\n        // Ignoring errors, since we only want to know when rendering is\n        // no longer pending.\n      });\n    }\n\n    initializeGraphics({ transparency = false, optionalContentConfig }) {\n      if (this.cancelled) {\n        return;\n      }\n      if (this._canvas) {\n        if (canvasInRendering.has(this._canvas)) {\n          throw new Error(\n            \"Cannot use the same canvas during multiple render() operations. \" +\n              \"Use different canvas or ensure previous operations were \" +\n              \"cancelled or completed.\"\n          );\n        }\n        canvasInRendering.add(this._canvas);\n      }\n\n      if (\n        this._pdfBug &&\n        globalThis.StepperManager &&\n        globalThis.StepperManager.enabled\n      ) {\n        this.stepper = globalThis.StepperManager.create(this._pageIndex);\n        this.stepper.init(this.operatorList);\n        this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();\n      }\n      const {\n        canvasContext,\n        viewport,\n        transform,\n        imageLayer,\n        background,\n      } = this.params;\n\n      this.gfx = new CanvasGraphics(\n        canvasContext,\n        this.commonObjs,\n        this.objs,\n        this.canvasFactory,\n        this.webGLContext,\n        imageLayer,\n        optionalContentConfig\n      );\n      this.gfx.beginDrawing({\n        transform,\n        viewport,\n        transparency,\n        background,\n      });\n      this.operatorListIdx = 0;\n      this.graphicsReady = true;\n      if (this.graphicsReadyCallback) {\n        this.graphicsReadyCallback();\n      }\n    }\n\n    cancel(error = null) {\n      this.running = false;\n      this.cancelled = true;\n      if (this.gfx) {\n        this.gfx.endDrawing();\n      }\n      if (this._canvas) {\n        canvasInRendering.delete(this._canvas);\n      }\n      this.callback(\n        error ||\n          new RenderingCancelledException(\n            `Rendering cancelled, page ${this._pageIndex + 1}`,\n            \"canvas\"\n          )\n      );\n    }\n\n    operatorListChanged() {\n      if (!this.graphicsReady) {\n        if (!this.graphicsReadyCallback) {\n          this.graphicsReadyCallback = this._continueBound;\n        }\n        return;\n      }\n\n      if (this.stepper) {\n        this.stepper.updateOperatorList(this.operatorList);\n      }\n\n      if (this.running) {\n        return;\n      }\n      this._continue();\n    }\n\n    _continue() {\n      this.running = true;\n      if (this.cancelled) {\n        return;\n      }\n      if (this.task.onContinue) {\n        this.task.onContinue(this._scheduleNextBound);\n      } else {\n        this._scheduleNext();\n      }\n    }\n\n    _scheduleNext() {\n      if (this._useRequestAnimationFrame) {\n        window.requestAnimationFrame(() => {\n          this._nextBound().catch(this.cancel.bind(this));\n        });\n      } else {\n        Promise.resolve().then(this._nextBound).catch(this.cancel.bind(this));\n      }\n    }\n\n    async _next() {\n      if (this.cancelled) {\n        return;\n      }\n      this.operatorListIdx = this.gfx.executeOperatorList(\n        this.operatorList,\n        this.operatorListIdx,\n        this._continueBound,\n        this.stepper\n      );\n      if (this.operatorListIdx === this.operatorList.argsArray.length) {\n        this.running = false;\n        if (this.operatorList.lastChunk) {\n          this.gfx.endDrawing();\n          if (this._canvas) {\n            canvasInRendering.delete(this._canvas);\n          }\n          this.callback();\n        }\n      }\n    }\n  }\n  return InternalRenderTask;\n})();\n\n/** @type {string} */\nconst version =\n  typeof PDFJSDev !== \"undefined\" ? PDFJSDev.eval(\"BUNDLE_VERSION\") : null;\n/** @type {string} */\nconst build =\n  typeof PDFJSDev !== \"undefined\" ? PDFJSDev.eval(\"BUNDLE_BUILD\") : null;\n\nexport {\n  getDocument,\n  LoopbackPort,\n  PDFDataRangeTransport,\n  PDFWorker,\n  PDFDocumentProxy,\n  PDFPageProxy,\n  setPDFNetworkStreamFactory,\n  version,\n  build,\n};\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  assert,\n  bytesToString,\n  IsEvalSupportedCached,\n  shadow,\n  string32,\n  unreachable,\n  UNSUPPORTED_FEATURES,\n  warn,\n} from \"../shared/util.js\";\n\nclass BaseFontLoader {\n  constructor({\n    docId,\n    onUnsupportedFeature,\n    ownerDocument = globalThis.document,\n  }) {\n    if (this.constructor === BaseFontLoader) {\n      unreachable(\"Cannot initialize BaseFontLoader.\");\n    }\n    this.docId = docId;\n    this._onUnsupportedFeature = onUnsupportedFeature;\n    this._document = ownerDocument;\n\n    this.nativeFontFaces = [];\n    this.styleElement = null;\n  }\n\n  addNativeFontFace(nativeFontFace) {\n    this.nativeFontFaces.push(nativeFontFace);\n    this._document.fonts.add(nativeFontFace);\n  }\n\n  insertRule(rule) {\n    let styleElement = this.styleElement;\n    if (!styleElement) {\n      styleElement = this.styleElement = this._document.createElement(\"style\");\n      styleElement.id = `PDFJS_FONT_STYLE_TAG_${this.docId}`;\n      this._document.documentElement\n        .getElementsByTagName(\"head\")[0]\n        .appendChild(styleElement);\n    }\n\n    const styleSheet = styleElement.sheet;\n    styleSheet.insertRule(rule, styleSheet.cssRules.length);\n  }\n\n  clear() {\n    this.nativeFontFaces.forEach(nativeFontFace => {\n      this._document.fonts.delete(nativeFontFace);\n    });\n    this.nativeFontFaces.length = 0;\n\n    if (this.styleElement) {\n      // Note: ChildNode.remove doesn't throw if the parentNode is undefined.\n      this.styleElement.remove();\n      this.styleElement = null;\n    }\n  }\n\n  async bind(font) {\n    // Add the font to the DOM only once; skip if the font is already loaded.\n    if (font.attached || font.missingFile) {\n      return;\n    }\n    font.attached = true;\n\n    if (this.isFontLoadingAPISupported) {\n      const nativeFontFace = font.createNativeFontFace();\n      if (nativeFontFace) {\n        this.addNativeFontFace(nativeFontFace);\n        try {\n          await nativeFontFace.loaded;\n        } catch (ex) {\n          this._onUnsupportedFeature({\n            featureId: UNSUPPORTED_FEATURES.errorFontLoadNative,\n          });\n          warn(`Failed to load font '${nativeFontFace.family}': '${ex}'.`);\n\n          // When font loading failed, fall back to the built-in font renderer.\n          font.disableFontFace = true;\n          throw ex;\n        }\n      }\n      return; // The font was, asynchronously, loaded.\n    }\n\n    // !this.isFontLoadingAPISupported\n    const rule = font.createFontFaceRule();\n    if (rule) {\n      this.insertRule(rule);\n\n      if (this.isSyncFontLoadingSupported) {\n        return; // The font was, synchronously, loaded.\n      }\n      await new Promise(resolve => {\n        const request = this._queueLoadingCallback(resolve);\n        this._prepareFontLoadEvent([rule], [font], request);\n      });\n      // The font was, asynchronously, loaded.\n    }\n  }\n\n  _queueLoadingCallback(callback) {\n    unreachable(\"Abstract method `_queueLoadingCallback`.\");\n  }\n\n  get isFontLoadingAPISupported() {\n    const supported =\n      typeof this._document !== \"undefined\" && !!this._document.fonts;\n    return shadow(this, \"isFontLoadingAPISupported\", supported);\n  }\n\n  // eslint-disable-next-line getter-return\n  get isSyncFontLoadingSupported() {\n    unreachable(\"Abstract method `isSyncFontLoadingSupported`.\");\n  }\n\n  // eslint-disable-next-line getter-return\n  get _loadTestFont() {\n    unreachable(\"Abstract method `_loadTestFont`.\");\n  }\n\n  _prepareFontLoadEvent(rules, fontsToLoad, request) {\n    unreachable(\"Abstract method `_prepareFontLoadEvent`.\");\n  }\n}\n\nlet FontLoader;\nif (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"MOZCENTRAL\")) {\n  FontLoader = class MozcentralFontLoader extends BaseFontLoader {\n    get isSyncFontLoadingSupported() {\n      return shadow(this, \"isSyncFontLoadingSupported\", true);\n    }\n  };\n} else {\n  // PDFJSDev.test('CHROME || GENERIC')\n\n  FontLoader = class GenericFontLoader extends BaseFontLoader {\n    constructor(params) {\n      super(params);\n      this.loadingContext = {\n        requests: [],\n        nextRequestId: 0,\n      };\n      this.loadTestFontId = 0;\n    }\n\n    get isSyncFontLoadingSupported() {\n      let supported = false;\n      if (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"CHROME\")) {\n        if (typeof navigator === \"undefined\") {\n          // Node.js - we can pretend that sync font loading is supported.\n          supported = true;\n        } else {\n          // User agent string sniffing is bad, but there is no reliable way to\n          // tell if the font is fully loaded and ready to be used with canvas.\n          const m = /Mozilla\\/5.0.*?rv:(\\d+).*? Gecko/.exec(\n            navigator.userAgent\n          );\n          if (m && m[1] >= 14) {\n            supported = true;\n          }\n          // TODO - other browsers...\n        }\n      }\n      return shadow(this, \"isSyncFontLoadingSupported\", supported);\n    }\n\n    _queueLoadingCallback(callback) {\n      function completeRequest() {\n        assert(!request.done, \"completeRequest() cannot be called twice.\");\n        request.done = true;\n\n        // Sending all completed requests in order of how they were queued.\n        while (context.requests.length > 0 && context.requests[0].done) {\n          const otherRequest = context.requests.shift();\n          setTimeout(otherRequest.callback, 0);\n        }\n      }\n\n      const context = this.loadingContext;\n      const request = {\n        id: `pdfjs-font-loading-${context.nextRequestId++}`,\n        done: false,\n        complete: completeRequest,\n        callback,\n      };\n      context.requests.push(request);\n      return request;\n    }\n\n    get _loadTestFont() {\n      const getLoadTestFont = function () {\n        // This is a CFF font with 1 glyph for '.' that fills its entire width\n        // and height.\n        return atob(\n          \"T1RUTwALAIAAAwAwQ0ZGIDHtZg4AAAOYAAAAgUZGVE1lkzZwAAAEHAAAABxHREVGABQA\" +\n            \"FQAABDgAAAAeT1MvMlYNYwkAAAEgAAAAYGNtYXABDQLUAAACNAAAAUJoZWFk/xVFDQAA\" +\n            \"ALwAAAA2aGhlYQdkA+oAAAD0AAAAJGhtdHgD6AAAAAAEWAAAAAZtYXhwAAJQAAAAARgA\" +\n            \"AAAGbmFtZVjmdH4AAAGAAAAAsXBvc3T/hgAzAAADeAAAACAAAQAAAAEAALZRFsRfDzz1\" +\n            \"AAsD6AAAAADOBOTLAAAAAM4KHDwAAAAAA+gDIQAAAAgAAgAAAAAAAAABAAADIQAAAFoD\" +\n            \"6AAAAAAD6AABAAAAAAAAAAAAAAAAAAAAAQAAUAAAAgAAAAQD6AH0AAUAAAKKArwAAACM\" +\n            \"AooCvAAAAeAAMQECAAACAAYJAAAAAAAAAAAAAQAAAAAAAAAAAAAAAFBmRWQAwAAuAC4D\" +\n            \"IP84AFoDIQAAAAAAAQAAAAAAAAAAACAAIAABAAAADgCuAAEAAAAAAAAAAQAAAAEAAAAA\" +\n            \"AAEAAQAAAAEAAAAAAAIAAQAAAAEAAAAAAAMAAQAAAAEAAAAAAAQAAQAAAAEAAAAAAAUA\" +\n            \"AQAAAAEAAAAAAAYAAQAAAAMAAQQJAAAAAgABAAMAAQQJAAEAAgABAAMAAQQJAAIAAgAB\" +\n            \"AAMAAQQJAAMAAgABAAMAAQQJAAQAAgABAAMAAQQJAAUAAgABAAMAAQQJAAYAAgABWABY\" +\n            \"AAAAAAAAAwAAAAMAAAAcAAEAAAAAADwAAwABAAAAHAAEACAAAAAEAAQAAQAAAC7//wAA\" +\n            \"AC7////TAAEAAAAAAAABBgAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\" +\n            \"AAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\" +\n            \"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\" +\n            \"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\" +\n            \"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\" +\n            \"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAD/gwAyAAAAAQAAAAAAAAAAAAAAAAAA\" +\n            \"AAABAAQEAAEBAQJYAAEBASH4DwD4GwHEAvgcA/gXBIwMAYuL+nz5tQXkD5j3CBLnEQAC\" +\n            \"AQEBIVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYAAABAQAADwACAQEEE/t3\" +\n            \"Dov6fAH6fAT+fPp8+nwHDosMCvm1Cvm1DAz6fBQAAAAAAAABAAAAAMmJbzEAAAAAzgTj\" +\n            \"FQAAAADOBOQpAAEAAAAAAAAADAAUAAQAAAABAAAAAgABAAAAAAAAAAAD6AAAAAAAAA==\"\n        );\n      };\n      return shadow(this, \"_loadTestFont\", getLoadTestFont());\n    }\n\n    _prepareFontLoadEvent(rules, fonts, request) {\n      /** Hack begin */\n      // There's currently no event when a font has finished downloading so the\n      // following code is a dirty hack to 'guess' when a font is ready.\n      // It's assumed fonts are loaded in order, so add a known test font after\n      // the desired fonts and then test for the loading of that test font.\n\n      function int32(data, offset) {\n        return (\n          (data.charCodeAt(offset) << 24) |\n          (data.charCodeAt(offset + 1) << 16) |\n          (data.charCodeAt(offset + 2) << 8) |\n          (data.charCodeAt(offset + 3) & 0xff)\n        );\n      }\n      function spliceString(s, offset, remove, insert) {\n        const chunk1 = s.substring(0, offset);\n        const chunk2 = s.substring(offset + remove);\n        return chunk1 + insert + chunk2;\n      }\n      let i, ii;\n\n      // The temporary canvas is used to determine if fonts are loaded.\n      const canvas = this._document.createElement(\"canvas\");\n      canvas.width = 1;\n      canvas.height = 1;\n      const ctx = canvas.getContext(\"2d\");\n\n      let called = 0;\n      function isFontReady(name, callback) {\n        called++;\n        // With setTimeout clamping this gives the font ~100ms to load.\n        if (called > 30) {\n          warn(\"Load test font never loaded.\");\n          callback();\n          return;\n        }\n        ctx.font = \"30px \" + name;\n        ctx.fillText(\".\", 0, 20);\n        const imageData = ctx.getImageData(0, 0, 1, 1);\n        if (imageData.data[3] > 0) {\n          callback();\n          return;\n        }\n        setTimeout(isFontReady.bind(null, name, callback));\n      }\n\n      const loadTestFontId = `lt${Date.now()}${this.loadTestFontId++}`;\n      // Chromium seems to cache fonts based on a hash of the actual font data,\n      // so the font must be modified for each load test else it will appear to\n      // be loaded already.\n      // TODO: This could maybe be made faster by avoiding the btoa of the full\n      // font by splitting it in chunks before hand and padding the font id.\n      let data = this._loadTestFont;\n      const COMMENT_OFFSET = 976; // has to be on 4 byte boundary (for checksum)\n      data = spliceString(\n        data,\n        COMMENT_OFFSET,\n        loadTestFontId.length,\n        loadTestFontId\n      );\n      // CFF checksum is important for IE, adjusting it\n      const CFF_CHECKSUM_OFFSET = 16;\n      const XXXX_VALUE = 0x58585858; // the \"comment\" filled with 'X'\n      let checksum = int32(data, CFF_CHECKSUM_OFFSET);\n      for (i = 0, ii = loadTestFontId.length - 3; i < ii; i += 4) {\n        checksum = (checksum - XXXX_VALUE + int32(loadTestFontId, i)) | 0;\n      }\n      if (i < loadTestFontId.length) {\n        // align to 4 bytes boundary\n        checksum =\n          (checksum - XXXX_VALUE + int32(loadTestFontId + \"XXX\", i)) | 0;\n      }\n      data = spliceString(data, CFF_CHECKSUM_OFFSET, 4, string32(checksum));\n\n      const url = `url(data:font/opentype;base64,${btoa(data)});`;\n      const rule = `@font-face {font-family:\"${loadTestFontId}\";src:${url}}`;\n      this.insertRule(rule);\n\n      const names = [];\n      for (i = 0, ii = fonts.length; i < ii; i++) {\n        names.push(fonts[i].loadedName);\n      }\n      names.push(loadTestFontId);\n\n      const div = this._document.createElement(\"div\");\n      div.style.visibility = \"hidden\";\n      div.style.width = div.style.height = \"10px\";\n      div.style.position = \"absolute\";\n      div.style.top = div.style.left = \"0px\";\n\n      for (i = 0, ii = names.length; i < ii; ++i) {\n        const span = this._document.createElement(\"span\");\n        span.textContent = \"Hi\";\n        span.style.fontFamily = names[i];\n        div.appendChild(span);\n      }\n      this._document.body.appendChild(div);\n\n      isFontReady(loadTestFontId, () => {\n        this._document.body.removeChild(div);\n        request.complete();\n      });\n      /** Hack end */\n    }\n  };\n} // End of PDFJSDev.test('CHROME || GENERIC')\n\nclass FontFaceObject {\n  constructor(\n    translatedData,\n    {\n      isEvalSupported = true,\n      disableFontFace = false,\n      ignoreErrors = false,\n      onUnsupportedFeature = null,\n      fontRegistry = null,\n    }\n  ) {\n    this.compiledGlyphs = Object.create(null);\n    // importing translated data\n    for (const i in translatedData) {\n      this[i] = translatedData[i];\n    }\n    this.isEvalSupported = isEvalSupported !== false;\n    this.disableFontFace = disableFontFace === true;\n    this.ignoreErrors = ignoreErrors === true;\n    this._onUnsupportedFeature = onUnsupportedFeature;\n    this.fontRegistry = fontRegistry;\n  }\n\n  createNativeFontFace() {\n    if (!this.data || this.disableFontFace) {\n      return null;\n    }\n    const nativeFontFace = new FontFace(this.loadedName, this.data, {});\n\n    if (this.fontRegistry) {\n      this.fontRegistry.registerFont(this);\n    }\n    return nativeFontFace;\n  }\n\n  createFontFaceRule() {\n    if (!this.data || this.disableFontFace) {\n      return null;\n    }\n    const data = bytesToString(new Uint8Array(this.data));\n    // Add the @font-face rule to the document.\n    const url = `url(data:${this.mimetype};base64,${btoa(data)});`;\n    const rule = `@font-face {font-family:\"${this.loadedName}\";src:${url}}`;\n\n    if (this.fontRegistry) {\n      this.fontRegistry.registerFont(this, url);\n    }\n    return rule;\n  }\n\n  getPathGenerator(objs, character) {\n    if (this.compiledGlyphs[character] !== undefined) {\n      return this.compiledGlyphs[character];\n    }\n\n    let cmds, current;\n    try {\n      cmds = objs.get(this.loadedName + \"_path_\" + character);\n    } catch (ex) {\n      if (!this.ignoreErrors) {\n        throw ex;\n      }\n      if (this._onUnsupportedFeature) {\n        this._onUnsupportedFeature({\n          featureId: UNSUPPORTED_FEATURES.errorFontGetPath,\n        });\n      }\n      warn(`getPathGenerator - ignoring character: \"${ex}\".`);\n\n      return (this.compiledGlyphs[character] = function (c, size) {\n        // No-op function, to allow rendering to continue.\n      });\n    }\n\n    // If we can, compile cmds into JS for MAXIMUM SPEED...\n    if (this.isEvalSupported && IsEvalSupportedCached.value) {\n      let args,\n        js = \"\";\n      for (let i = 0, ii = cmds.length; i < ii; i++) {\n        current = cmds[i];\n\n        if (current.args !== undefined) {\n          args = current.args.join(\",\");\n        } else {\n          args = \"\";\n        }\n        js += \"c.\" + current.cmd + \"(\" + args + \");\\n\";\n      }\n      // eslint-disable-next-line no-new-func\n      return (this.compiledGlyphs[character] = new Function(\"c\", \"size\", js));\n    }\n    // ... but fall back on using Function.prototype.apply() if we're\n    // blocked from using eval() for whatever reason (like CSP policies).\n    return (this.compiledGlyphs[character] = function (c, size) {\n      for (let i = 0, ii = cmds.length; i < ii; i++) {\n        current = cmds[i];\n\n        if (current.cmd === \"scale\") {\n          current.args = [size, -size];\n        }\n        c[current.cmd].apply(c, current.args);\n      }\n    });\n  }\n}\n\nexport { FontFaceObject, FontLoader };\n","/* Copyright 2020 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* globals __non_webpack_require__ */\n/* eslint no-var: error */\n\nimport { BaseCanvasFactory, BaseCMapReaderFactory } from \"./display_utils.js\";\nimport { isNodeJS } from \"../shared/is_node.js\";\nimport { unreachable } from \"../shared/util.js\";\n\nlet NodeCanvasFactory = class {\n  constructor() {\n    unreachable(\"Not implemented: NodeCanvasFactory\");\n  }\n};\n\nlet NodeCMapReaderFactory = class {\n  constructor() {\n    unreachable(\"Not implemented: NodeCMapReaderFactory\");\n  }\n};\n\nif ((typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) && isNodeJS) {\n  NodeCanvasFactory = class extends BaseCanvasFactory {\n    create(width, height) {\n      if (width <= 0 || height <= 0) {\n        throw new Error(\"Invalid canvas size\");\n      }\n      const Canvas = __non_webpack_require__(\"canvas\");\n      const canvas = Canvas.createCanvas(width, height);\n      return {\n        canvas,\n        context: canvas.getContext(\"2d\"),\n      };\n    }\n  };\n\n  NodeCMapReaderFactory = class extends BaseCMapReaderFactory {\n    _fetchData(url, compressionType) {\n      return new Promise((resolve, reject) => {\n        const fs = __non_webpack_require__(\"fs\");\n        fs.readFile(url, (error, data) => {\n          if (error || !data) {\n            reject(new Error(error));\n            return;\n          }\n          resolve({ cMapData: new Uint8Array(data), compressionType });\n        });\n      });\n    }\n  };\n}\n\nexport { NodeCanvasFactory, NodeCMapReaderFactory };\n","/* Copyright 2020 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Key/value storage for annotation data in forms.\n */\nclass AnnotationStorage {\n  constructor() {\n    this._storage = new Map();\n    this._modified = false;\n\n    // Callbacks to signal when the modification state is set or reset.\n    // This is used by the viewer to only bind on `beforeunload` if forms\n    // are actually edited to prevent doing so unconditionally since that\n    // can have undesirable efffects.\n    this.onSetModified = null;\n    this.onResetModified = null;\n  }\n\n  /**\n   * Get the value for a given key if it exists\n   * or store and return the default value\n   *\n   * @public\n   * @memberof AnnotationStorage\n   * @param {string} key\n   * @param {Object} defaultValue\n   * @returns {Object}\n   */\n  getOrCreateValue(key, defaultValue) {\n    if (this._storage.has(key)) {\n      return this._storage.get(key);\n    }\n\n    this._storage.set(key, defaultValue);\n    return defaultValue;\n  }\n\n  /**\n   * Set the value for a given key\n   *\n   * @public\n   * @memberof AnnotationStorage\n   * @param {string} key\n   * @param {Object} value\n   */\n  setValue(key, value) {\n    if (this._storage.get(key) !== value) {\n      this._setModified();\n    }\n    this._storage.set(key, value);\n  }\n\n  getAll() {\n    if (this._storage.size === 0) {\n      return null;\n    }\n    return Object.fromEntries(this._storage);\n  }\n\n  get size() {\n    return this._storage.size;\n  }\n\n  /**\n   * @private\n   */\n  _setModified() {\n    if (!this._modified) {\n      this._modified = true;\n      if (typeof this.onSetModified === \"function\") {\n        this.onSetModified();\n      }\n    }\n  }\n\n  resetModified() {\n    if (this._modified) {\n      this._modified = false;\n      if (typeof this.onResetModified === \"function\") {\n        this.onResetModified();\n      }\n    }\n  }\n}\n\nexport { AnnotationStorage };\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isNodeJS } from \"../shared/is_node.js\";\n\nconst compatibilityParams = Object.create(null);\nif (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) {\n  // Support: Node.js\n  (function checkFontFace() {\n    // Node.js is missing native support for `@font-face`.\n    if (isNodeJS) {\n      compatibilityParams.disableFontFace = true;\n    }\n  })();\n}\nconst apiCompatibilityParams = Object.freeze(compatibilityParams);\n\nexport { apiCompatibilityParams };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  FONT_IDENTITY_MATRIX,\n  IDENTITY_MATRIX,\n  ImageKind,\n  info,\n  IsLittleEndianCached,\n  isNum,\n  OPS,\n  shadow,\n  TextRenderingMode,\n  unreachable,\n  Util,\n  warn,\n} from \"../shared/util.js\";\nimport { getShadingPatternFromIR, TilingPattern } from \"./pattern_helper.js\";\n\n// <canvas> contexts store most of the state we need natively.\n// However, PDF needs a bit more state, which we store here.\n\n// Minimal font size that would be used during canvas fillText operations.\nvar MIN_FONT_SIZE = 16;\n// Maximum font size that would be used during canvas fillText operations.\nvar MAX_FONT_SIZE = 100;\nvar MAX_GROUP_SIZE = 4096;\n\n// Heuristic value used when enforcing minimum line widths.\nvar MIN_WIDTH_FACTOR = 0.65;\n\nvar COMPILE_TYPE3_GLYPHS = true;\nvar MAX_SIZE_TO_COMPILE = 1000;\n\nvar FULL_CHUNK_HEIGHT = 16;\n\nfunction addContextCurrentTransform(ctx) {\n  // If the context doesn't expose a `mozCurrentTransform`, add a JS based one.\n  if (!ctx.mozCurrentTransform) {\n    ctx._originalSave = ctx.save;\n    ctx._originalRestore = ctx.restore;\n    ctx._originalRotate = ctx.rotate;\n    ctx._originalScale = ctx.scale;\n    ctx._originalTranslate = ctx.translate;\n    ctx._originalTransform = ctx.transform;\n    ctx._originalSetTransform = ctx.setTransform;\n\n    ctx._transformMatrix = ctx._transformMatrix || [1, 0, 0, 1, 0, 0];\n    ctx._transformStack = [];\n\n    Object.defineProperty(ctx, \"mozCurrentTransform\", {\n      get: function getCurrentTransform() {\n        return this._transformMatrix;\n      },\n    });\n\n    Object.defineProperty(ctx, \"mozCurrentTransformInverse\", {\n      get: function getCurrentTransformInverse() {\n        // Calculation done using WolframAlpha:\n        // http://www.wolframalpha.com/input/?\n        //   i=Inverse+{{a%2C+c%2C+e}%2C+{b%2C+d%2C+f}%2C+{0%2C+0%2C+1}}\n\n        var m = this._transformMatrix;\n        var a = m[0],\n          b = m[1],\n          c = m[2],\n          d = m[3],\n          e = m[4],\n          f = m[5];\n\n        var ad_bc = a * d - b * c;\n        var bc_ad = b * c - a * d;\n\n        return [\n          d / ad_bc,\n          b / bc_ad,\n          c / bc_ad,\n          a / ad_bc,\n          (d * e - c * f) / bc_ad,\n          (b * e - a * f) / ad_bc,\n        ];\n      },\n    });\n\n    ctx.save = function ctxSave() {\n      var old = this._transformMatrix;\n      this._transformStack.push(old);\n      this._transformMatrix = old.slice(0, 6);\n\n      this._originalSave();\n    };\n\n    ctx.restore = function ctxRestore() {\n      var prev = this._transformStack.pop();\n      if (prev) {\n        this._transformMatrix = prev;\n        this._originalRestore();\n      }\n    };\n\n    ctx.translate = function ctxTranslate(x, y) {\n      var m = this._transformMatrix;\n      m[4] = m[0] * x + m[2] * y + m[4];\n      m[5] = m[1] * x + m[3] * y + m[5];\n\n      this._originalTranslate(x, y);\n    };\n\n    ctx.scale = function ctxScale(x, y) {\n      var m = this._transformMatrix;\n      m[0] = m[0] * x;\n      m[1] = m[1] * x;\n      m[2] = m[2] * y;\n      m[3] = m[3] * y;\n\n      this._originalScale(x, y);\n    };\n\n    ctx.transform = function ctxTransform(a, b, c, d, e, f) {\n      var m = this._transformMatrix;\n      this._transformMatrix = [\n        m[0] * a + m[2] * b,\n        m[1] * a + m[3] * b,\n        m[0] * c + m[2] * d,\n        m[1] * c + m[3] * d,\n        m[0] * e + m[2] * f + m[4],\n        m[1] * e + m[3] * f + m[5],\n      ];\n\n      ctx._originalTransform(a, b, c, d, e, f);\n    };\n\n    ctx.setTransform = function ctxSetTransform(a, b, c, d, e, f) {\n      this._transformMatrix = [a, b, c, d, e, f];\n\n      ctx._originalSetTransform(a, b, c, d, e, f);\n    };\n\n    ctx.rotate = function ctxRotate(angle) {\n      var cosValue = Math.cos(angle);\n      var sinValue = Math.sin(angle);\n\n      var m = this._transformMatrix;\n      this._transformMatrix = [\n        m[0] * cosValue + m[2] * sinValue,\n        m[1] * cosValue + m[3] * sinValue,\n        m[0] * -sinValue + m[2] * cosValue,\n        m[1] * -sinValue + m[3] * cosValue,\n        m[4],\n        m[5],\n      ];\n\n      this._originalRotate(angle);\n    };\n  }\n}\n\nvar CachedCanvases = (function CachedCanvasesClosure() {\n  // eslint-disable-next-line no-shadow\n  function CachedCanvases(canvasFactory) {\n    this.canvasFactory = canvasFactory;\n    this.cache = Object.create(null);\n  }\n  CachedCanvases.prototype = {\n    getCanvas: function CachedCanvases_getCanvas(\n      id,\n      width,\n      height,\n      trackTransform\n    ) {\n      var canvasEntry;\n      if (this.cache[id] !== undefined) {\n        canvasEntry = this.cache[id];\n        this.canvasFactory.reset(canvasEntry, width, height);\n        // reset canvas transform for emulated mozCurrentTransform, if needed\n        canvasEntry.context.setTransform(1, 0, 0, 1, 0, 0);\n      } else {\n        canvasEntry = this.canvasFactory.create(width, height);\n        this.cache[id] = canvasEntry;\n      }\n      if (trackTransform) {\n        addContextCurrentTransform(canvasEntry.context);\n      }\n      return canvasEntry;\n    },\n    clear() {\n      for (var id in this.cache) {\n        var canvasEntry = this.cache[id];\n        this.canvasFactory.destroy(canvasEntry);\n        delete this.cache[id];\n      }\n    },\n  };\n  return CachedCanvases;\n})();\n\nfunction compileType3Glyph(imgData) {\n  var POINT_TO_PROCESS_LIMIT = 1000;\n\n  var width = imgData.width,\n    height = imgData.height;\n  var i,\n    j,\n    j0,\n    width1 = width + 1;\n  var points = new Uint8Array(width1 * (height + 1));\n  // prettier-ignore\n  var POINT_TYPES =\n      new Uint8Array([0, 2, 4, 0, 1, 0, 5, 4, 8, 10, 0, 8, 0, 2, 1, 0]);\n\n  // decodes bit-packed mask data\n  var lineSize = (width + 7) & ~7,\n    data0 = imgData.data;\n  var data = new Uint8Array(lineSize * height),\n    pos = 0,\n    ii;\n  for (i = 0, ii = data0.length; i < ii; i++) {\n    var mask = 128,\n      elem = data0[i];\n    while (mask > 0) {\n      data[pos++] = elem & mask ? 0 : 255;\n      mask >>= 1;\n    }\n  }\n\n  // finding interesting points: every point is located between mask pixels,\n  // so there will be points of the (width + 1)x(height + 1) grid. Every point\n  // will have flags assigned based on neighboring mask pixels:\n  //   4 | 8\n  //   --P--\n  //   2 | 1\n  // We are interested only in points with the flags:\n  //   - outside corners: 1, 2, 4, 8;\n  //   - inside corners: 7, 11, 13, 14;\n  //   - and, intersections: 5, 10.\n  var count = 0;\n  pos = 0;\n  if (data[pos] !== 0) {\n    points[0] = 1;\n    ++count;\n  }\n  for (j = 1; j < width; j++) {\n    if (data[pos] !== data[pos + 1]) {\n      points[j] = data[pos] ? 2 : 1;\n      ++count;\n    }\n    pos++;\n  }\n  if (data[pos] !== 0) {\n    points[j] = 2;\n    ++count;\n  }\n  for (i = 1; i < height; i++) {\n    pos = i * lineSize;\n    j0 = i * width1;\n    if (data[pos - lineSize] !== data[pos]) {\n      points[j0] = data[pos] ? 1 : 8;\n      ++count;\n    }\n    // 'sum' is the position of the current pixel configuration in the 'TYPES'\n    // array (in order 8-1-2-4, so we can use '>>2' to shift the column).\n    var sum = (data[pos] ? 4 : 0) + (data[pos - lineSize] ? 8 : 0);\n    for (j = 1; j < width; j++) {\n      sum =\n        (sum >> 2) +\n        (data[pos + 1] ? 4 : 0) +\n        (data[pos - lineSize + 1] ? 8 : 0);\n      if (POINT_TYPES[sum]) {\n        points[j0 + j] = POINT_TYPES[sum];\n        ++count;\n      }\n      pos++;\n    }\n    if (data[pos - lineSize] !== data[pos]) {\n      points[j0 + j] = data[pos] ? 2 : 4;\n      ++count;\n    }\n\n    if (count > POINT_TO_PROCESS_LIMIT) {\n      return null;\n    }\n  }\n\n  pos = lineSize * (height - 1);\n  j0 = i * width1;\n  if (data[pos] !== 0) {\n    points[j0] = 8;\n    ++count;\n  }\n  for (j = 1; j < width; j++) {\n    if (data[pos] !== data[pos + 1]) {\n      points[j0 + j] = data[pos] ? 4 : 8;\n      ++count;\n    }\n    pos++;\n  }\n  if (data[pos] !== 0) {\n    points[j0 + j] = 4;\n    ++count;\n  }\n  if (count > POINT_TO_PROCESS_LIMIT) {\n    return null;\n  }\n\n  // building outlines\n  var steps = new Int32Array([0, width1, -1, 0, -width1, 0, 0, 0, 1]);\n  var outlines = [];\n  for (i = 0; count && i <= height; i++) {\n    var p = i * width1;\n    var end = p + width;\n    while (p < end && !points[p]) {\n      p++;\n    }\n    if (p === end) {\n      continue;\n    }\n    var coords = [p % width1, i];\n\n    var type = points[p],\n      p0 = p,\n      pp;\n    do {\n      var step = steps[type];\n      do {\n        p += step;\n      } while (!points[p]);\n\n      pp = points[p];\n      if (pp !== 5 && pp !== 10) {\n        // set new direction\n        type = pp;\n        // delete mark\n        points[p] = 0;\n      } else {\n        // type is 5 or 10, ie, a crossing\n        // set new direction\n        type = pp & ((0x33 * type) >> 4);\n        // set new type for \"future hit\"\n        points[p] &= (type >> 2) | (type << 2);\n      }\n\n      coords.push(p % width1);\n      coords.push((p / width1) | 0);\n\n      if (!points[p]) {\n        --count;\n      }\n    } while (p0 !== p);\n    outlines.push(coords);\n    --i;\n  }\n\n  var drawOutline = function (c) {\n    c.save();\n    // the path shall be painted in [0..1]x[0..1] space\n    c.scale(1 / width, -1 / height);\n    c.translate(0, -height);\n    c.beginPath();\n    for (let k = 0, kk = outlines.length; k < kk; k++) {\n      var o = outlines[k];\n      c.moveTo(o[0], o[1]);\n      for (let l = 2, ll = o.length; l < ll; l += 2) {\n        c.lineTo(o[l], o[l + 1]);\n      }\n    }\n    c.fill();\n    c.beginPath();\n    c.restore();\n  };\n\n  return drawOutline;\n}\n\nvar CanvasExtraState = (function CanvasExtraStateClosure() {\n  // eslint-disable-next-line no-shadow\n  function CanvasExtraState() {\n    // Are soft masks and alpha values shapes or opacities?\n    this.alphaIsShape = false;\n    this.fontSize = 0;\n    this.fontSizeScale = 1;\n    this.textMatrix = IDENTITY_MATRIX;\n    this.textMatrixScale = 1;\n    this.fontMatrix = FONT_IDENTITY_MATRIX;\n    this.leading = 0;\n    // Current point (in user coordinates)\n    this.x = 0;\n    this.y = 0;\n    // Start of text line (in text coordinates)\n    this.lineX = 0;\n    this.lineY = 0;\n    // Character and word spacing\n    this.charSpacing = 0;\n    this.wordSpacing = 0;\n    this.textHScale = 1;\n    this.textRenderingMode = TextRenderingMode.FILL;\n    this.textRise = 0;\n    // Default fore and background colors\n    this.fillColor = \"#000000\";\n    this.strokeColor = \"#000000\";\n    this.patternFill = false;\n    // Note: fill alpha applies to all non-stroking operations\n    this.fillAlpha = 1;\n    this.strokeAlpha = 1;\n    this.lineWidth = 1;\n    this.activeSMask = null;\n    this.resumeSMaskCtx = null; // nonclonable field (see the save method below)\n    this.transferMaps = null;\n  }\n\n  CanvasExtraState.prototype = {\n    clone: function CanvasExtraState_clone() {\n      return Object.create(this);\n    },\n    setCurrentPoint: function CanvasExtraState_setCurrentPoint(x, y) {\n      this.x = x;\n      this.y = y;\n    },\n  };\n  return CanvasExtraState;\n})();\n\n/**\n * @type {any}\n */\nvar CanvasGraphics = (function CanvasGraphicsClosure() {\n  // Defines the time the executeOperatorList is going to be executing\n  // before it stops and shedules a continue of execution.\n  var EXECUTION_TIME = 15;\n  // Defines the number of steps before checking the execution time\n  var EXECUTION_STEPS = 10;\n\n  // eslint-disable-next-line no-shadow\n  function CanvasGraphics(\n    canvasCtx,\n    commonObjs,\n    objs,\n    canvasFactory,\n    webGLContext,\n    imageLayer,\n    optionalContentConfig\n  ) {\n    this.ctx = canvasCtx;\n    this.current = new CanvasExtraState();\n    this.stateStack = [];\n    this.pendingClip = null;\n    this.pendingEOFill = false;\n    this.res = null;\n    this.xobjs = null;\n    this.commonObjs = commonObjs;\n    this.objs = objs;\n    this.canvasFactory = canvasFactory;\n    this.webGLContext = webGLContext;\n    this.imageLayer = imageLayer;\n    this.groupStack = [];\n    this.processingType3 = null;\n    // Patterns are painted relative to the initial page/form transform, see pdf\n    // spec 8.7.2 NOTE 1.\n    this.baseTransform = null;\n    this.baseTransformStack = [];\n    this.groupLevel = 0;\n    this.smaskStack = [];\n    this.smaskCounter = 0;\n    this.tempSMask = null;\n    this.contentVisible = true;\n    this.markedContentStack = [];\n    this.optionalContentConfig = optionalContentConfig;\n    this.cachedCanvases = new CachedCanvases(this.canvasFactory);\n    if (canvasCtx) {\n      // NOTE: if mozCurrentTransform is polyfilled, then the current state of\n      // the transformation must already be set in canvasCtx._transformMatrix.\n      addContextCurrentTransform(canvasCtx);\n    }\n    this._cachedGetSinglePixelWidth = null;\n  }\n\n  function putBinaryImageData(ctx, imgData, transferMaps = null) {\n    if (typeof ImageData !== \"undefined\" && imgData instanceof ImageData) {\n      ctx.putImageData(imgData, 0, 0);\n      return;\n    }\n\n    // Put the image data to the canvas in chunks, rather than putting the\n    // whole image at once.  This saves JS memory, because the ImageData object\n    // is smaller. It also possibly saves C++ memory within the implementation\n    // of putImageData(). (E.g. in Firefox we make two short-lived copies of\n    // the data passed to putImageData()). |n| shouldn't be too small, however,\n    // because too many putImageData() calls will slow things down.\n    //\n    // Note: as written, if the last chunk is partial, the putImageData() call\n    // will (conceptually) put pixels past the bounds of the canvas.  But\n    // that's ok; any such pixels are ignored.\n\n    var height = imgData.height,\n      width = imgData.width;\n    var partialChunkHeight = height % FULL_CHUNK_HEIGHT;\n    var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;\n    var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;\n\n    var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);\n    var srcPos = 0,\n      destPos;\n    var src = imgData.data;\n    var dest = chunkImgData.data;\n    var i, j, thisChunkHeight, elemsInThisChunk;\n\n    let transferMapRed, transferMapGreen, transferMapBlue, transferMapGray;\n    if (transferMaps) {\n      switch (transferMaps.length) {\n        case 1:\n          transferMapRed = transferMaps[0];\n          transferMapGreen = transferMaps[0];\n          transferMapBlue = transferMaps[0];\n          transferMapGray = transferMaps[0];\n          break;\n        case 4:\n          transferMapRed = transferMaps[0];\n          transferMapGreen = transferMaps[1];\n          transferMapBlue = transferMaps[2];\n          transferMapGray = transferMaps[3];\n          break;\n      }\n    }\n\n    // There are multiple forms in which the pixel data can be passed, and\n    // imgData.kind tells us which one this is.\n    if (imgData.kind === ImageKind.GRAYSCALE_1BPP) {\n      // Grayscale, 1 bit per pixel (i.e. black-and-white).\n      var srcLength = src.byteLength;\n      var dest32 = new Uint32Array(dest.buffer, 0, dest.byteLength >> 2);\n      var dest32DataLength = dest32.length;\n      var fullSrcDiff = (width + 7) >> 3;\n      var white = 0xffffffff;\n      var black = IsLittleEndianCached.value ? 0xff000000 : 0x000000ff;\n\n      if (transferMapGray) {\n        if (transferMapGray[0] === 0xff && transferMapGray[0xff] === 0) {\n          [white, black] = [black, white];\n        }\n      }\n\n      for (i = 0; i < totalChunks; i++) {\n        thisChunkHeight =\n          i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;\n        destPos = 0;\n        for (j = 0; j < thisChunkHeight; j++) {\n          var srcDiff = srcLength - srcPos;\n          let k = 0;\n          var kEnd = srcDiff > fullSrcDiff ? width : srcDiff * 8 - 7;\n          var kEndUnrolled = kEnd & ~7;\n          var mask = 0;\n          var srcByte = 0;\n          for (; k < kEndUnrolled; k += 8) {\n            srcByte = src[srcPos++];\n            dest32[destPos++] = srcByte & 128 ? white : black;\n            dest32[destPos++] = srcByte & 64 ? white : black;\n            dest32[destPos++] = srcByte & 32 ? white : black;\n            dest32[destPos++] = srcByte & 16 ? white : black;\n            dest32[destPos++] = srcByte & 8 ? white : black;\n            dest32[destPos++] = srcByte & 4 ? white : black;\n            dest32[destPos++] = srcByte & 2 ? white : black;\n            dest32[destPos++] = srcByte & 1 ? white : black;\n          }\n          for (; k < kEnd; k++) {\n            if (mask === 0) {\n              srcByte = src[srcPos++];\n              mask = 128;\n            }\n\n            dest32[destPos++] = srcByte & mask ? white : black;\n            mask >>= 1;\n          }\n        }\n        // We ran out of input. Make all remaining pixels transparent.\n        while (destPos < dest32DataLength) {\n          dest32[destPos++] = 0;\n        }\n\n        ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);\n      }\n    } else if (imgData.kind === ImageKind.RGBA_32BPP) {\n      // RGBA, 32-bits per pixel.\n      const hasTransferMaps = !!(\n        transferMapRed ||\n        transferMapGreen ||\n        transferMapBlue\n      );\n\n      j = 0;\n      elemsInThisChunk = width * FULL_CHUNK_HEIGHT * 4;\n      for (i = 0; i < fullChunks; i++) {\n        dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));\n        srcPos += elemsInThisChunk;\n\n        if (hasTransferMaps) {\n          for (let k = 0; k < elemsInThisChunk; k += 4) {\n            if (transferMapRed) {\n              dest[k + 0] = transferMapRed[dest[k + 0]];\n            }\n            if (transferMapGreen) {\n              dest[k + 1] = transferMapGreen[dest[k + 1]];\n            }\n            if (transferMapBlue) {\n              dest[k + 2] = transferMapBlue[dest[k + 2]];\n            }\n          }\n        }\n\n        ctx.putImageData(chunkImgData, 0, j);\n        j += FULL_CHUNK_HEIGHT;\n      }\n      if (i < totalChunks) {\n        elemsInThisChunk = width * partialChunkHeight * 4;\n        dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));\n\n        if (hasTransferMaps) {\n          for (let k = 0; k < elemsInThisChunk; k += 4) {\n            if (transferMapRed) {\n              dest[k + 0] = transferMapRed[dest[k + 0]];\n            }\n            if (transferMapGreen) {\n              dest[k + 1] = transferMapGreen[dest[k + 1]];\n            }\n            if (transferMapBlue) {\n              dest[k + 2] = transferMapBlue[dest[k + 2]];\n            }\n          }\n        }\n\n        ctx.putImageData(chunkImgData, 0, j);\n      }\n    } else if (imgData.kind === ImageKind.RGB_24BPP) {\n      // RGB, 24-bits per pixel.\n      const hasTransferMaps = !!(\n        transferMapRed ||\n        transferMapGreen ||\n        transferMapBlue\n      );\n\n      thisChunkHeight = FULL_CHUNK_HEIGHT;\n      elemsInThisChunk = width * thisChunkHeight;\n      for (i = 0; i < totalChunks; i++) {\n        if (i >= fullChunks) {\n          thisChunkHeight = partialChunkHeight;\n          elemsInThisChunk = width * thisChunkHeight;\n        }\n\n        destPos = 0;\n        for (j = elemsInThisChunk; j--; ) {\n          dest[destPos++] = src[srcPos++];\n          dest[destPos++] = src[srcPos++];\n          dest[destPos++] = src[srcPos++];\n          dest[destPos++] = 255;\n        }\n\n        if (hasTransferMaps) {\n          for (let k = 0; k < destPos; k += 4) {\n            if (transferMapRed) {\n              dest[k + 0] = transferMapRed[dest[k + 0]];\n            }\n            if (transferMapGreen) {\n              dest[k + 1] = transferMapGreen[dest[k + 1]];\n            }\n            if (transferMapBlue) {\n              dest[k + 2] = transferMapBlue[dest[k + 2]];\n            }\n          }\n        }\n\n        ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);\n      }\n    } else {\n      throw new Error(`bad image kind: ${imgData.kind}`);\n    }\n  }\n\n  function putBinaryImageMask(ctx, imgData) {\n    var height = imgData.height,\n      width = imgData.width;\n    var partialChunkHeight = height % FULL_CHUNK_HEIGHT;\n    var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;\n    var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;\n\n    var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);\n    var srcPos = 0;\n    var src = imgData.data;\n    var dest = chunkImgData.data;\n\n    for (var i = 0; i < totalChunks; i++) {\n      var thisChunkHeight =\n        i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;\n\n      // Expand the mask so it can be used by the canvas.  Any required\n      // inversion has already been handled.\n      var destPos = 3; // alpha component offset\n      for (var j = 0; j < thisChunkHeight; j++) {\n        var mask = 0;\n        for (var k = 0; k < width; k++) {\n          if (!mask) {\n            var elem = src[srcPos++];\n            mask = 128;\n          }\n          dest[destPos] = elem & mask ? 0 : 255;\n          destPos += 4;\n          mask >>= 1;\n        }\n      }\n      ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);\n    }\n  }\n\n  function copyCtxState(sourceCtx, destCtx) {\n    var properties = [\n      \"strokeStyle\",\n      \"fillStyle\",\n      \"fillRule\",\n      \"globalAlpha\",\n      \"lineWidth\",\n      \"lineCap\",\n      \"lineJoin\",\n      \"miterLimit\",\n      \"globalCompositeOperation\",\n      \"font\",\n    ];\n    for (var i = 0, ii = properties.length; i < ii; i++) {\n      var property = properties[i];\n      if (sourceCtx[property] !== undefined) {\n        destCtx[property] = sourceCtx[property];\n      }\n    }\n    if (sourceCtx.setLineDash !== undefined) {\n      destCtx.setLineDash(sourceCtx.getLineDash());\n      destCtx.lineDashOffset = sourceCtx.lineDashOffset;\n    }\n  }\n\n  function resetCtxToDefault(ctx) {\n    ctx.strokeStyle = \"#000000\";\n    ctx.fillStyle = \"#000000\";\n    ctx.fillRule = \"nonzero\";\n    ctx.globalAlpha = 1;\n    ctx.lineWidth = 1;\n    ctx.lineCap = \"butt\";\n    ctx.lineJoin = \"miter\";\n    ctx.miterLimit = 10;\n    ctx.globalCompositeOperation = \"source-over\";\n    ctx.font = \"10px sans-serif\";\n    if (ctx.setLineDash !== undefined) {\n      ctx.setLineDash([]);\n      ctx.lineDashOffset = 0;\n    }\n  }\n\n  function composeSMaskBackdrop(bytes, r0, g0, b0) {\n    var length = bytes.length;\n    for (var i = 3; i < length; i += 4) {\n      var alpha = bytes[i];\n      if (alpha === 0) {\n        bytes[i - 3] = r0;\n        bytes[i - 2] = g0;\n        bytes[i - 1] = b0;\n      } else if (alpha < 255) {\n        var alpha_ = 255 - alpha;\n        bytes[i - 3] = (bytes[i - 3] * alpha + r0 * alpha_) >> 8;\n        bytes[i - 2] = (bytes[i - 2] * alpha + g0 * alpha_) >> 8;\n        bytes[i - 1] = (bytes[i - 1] * alpha + b0 * alpha_) >> 8;\n      }\n    }\n  }\n\n  function composeSMaskAlpha(maskData, layerData, transferMap) {\n    var length = maskData.length;\n    var scale = 1 / 255;\n    for (var i = 3; i < length; i += 4) {\n      var alpha = transferMap ? transferMap[maskData[i]] : maskData[i];\n      layerData[i] = (layerData[i] * alpha * scale) | 0;\n    }\n  }\n\n  function composeSMaskLuminosity(maskData, layerData, transferMap) {\n    var length = maskData.length;\n    for (var i = 3; i < length; i += 4) {\n      var y =\n        maskData[i - 3] * 77 + // * 0.3 / 255 * 0x10000\n        maskData[i - 2] * 152 + // * 0.59 ....\n        maskData[i - 1] * 28; // * 0.11 ....\n      layerData[i] = transferMap\n        ? (layerData[i] * transferMap[y >> 8]) >> 8\n        : (layerData[i] * y) >> 16;\n    }\n  }\n\n  function genericComposeSMask(\n    maskCtx,\n    layerCtx,\n    width,\n    height,\n    subtype,\n    backdrop,\n    transferMap\n  ) {\n    var hasBackdrop = !!backdrop;\n    var r0 = hasBackdrop ? backdrop[0] : 0;\n    var g0 = hasBackdrop ? backdrop[1] : 0;\n    var b0 = hasBackdrop ? backdrop[2] : 0;\n\n    var composeFn;\n    if (subtype === \"Luminosity\") {\n      composeFn = composeSMaskLuminosity;\n    } else {\n      composeFn = composeSMaskAlpha;\n    }\n\n    // processing image in chunks to save memory\n    var PIXELS_TO_PROCESS = 1048576;\n    var chunkSize = Math.min(height, Math.ceil(PIXELS_TO_PROCESS / width));\n    for (var row = 0; row < height; row += chunkSize) {\n      var chunkHeight = Math.min(chunkSize, height - row);\n      var maskData = maskCtx.getImageData(0, row, width, chunkHeight);\n      var layerData = layerCtx.getImageData(0, row, width, chunkHeight);\n\n      if (hasBackdrop) {\n        composeSMaskBackdrop(maskData.data, r0, g0, b0);\n      }\n      composeFn(maskData.data, layerData.data, transferMap);\n\n      maskCtx.putImageData(layerData, 0, row);\n    }\n  }\n\n  function composeSMask(ctx, smask, layerCtx, webGLContext) {\n    var mask = smask.canvas;\n    var maskCtx = smask.context;\n\n    ctx.setTransform(\n      smask.scaleX,\n      0,\n      0,\n      smask.scaleY,\n      smask.offsetX,\n      smask.offsetY\n    );\n\n    var backdrop = smask.backdrop || null;\n    if (!smask.transferMap && webGLContext.isEnabled) {\n      const composed = webGLContext.composeSMask({\n        layer: layerCtx.canvas,\n        mask,\n        properties: {\n          subtype: smask.subtype,\n          backdrop,\n        },\n      });\n      ctx.setTransform(1, 0, 0, 1, 0, 0);\n      ctx.drawImage(composed, smask.offsetX, smask.offsetY);\n      return;\n    }\n    genericComposeSMask(\n      maskCtx,\n      layerCtx,\n      mask.width,\n      mask.height,\n      smask.subtype,\n      backdrop,\n      smask.transferMap\n    );\n    ctx.drawImage(mask, 0, 0);\n  }\n\n  var LINE_CAP_STYLES = [\"butt\", \"round\", \"square\"];\n  var LINE_JOIN_STYLES = [\"miter\", \"round\", \"bevel\"];\n  var NORMAL_CLIP = {};\n  var EO_CLIP = {};\n\n  CanvasGraphics.prototype = {\n    beginDrawing({\n      transform,\n      viewport,\n      transparency = false,\n      background = null,\n    }) {\n      // For pdfs that use blend modes we have to clear the canvas else certain\n      // blend modes can look wrong since we'd be blending with a white\n      // backdrop. The problem with a transparent backdrop though is we then\n      // don't get sub pixel anti aliasing on text, creating temporary\n      // transparent canvas when we have blend modes.\n      var width = this.ctx.canvas.width;\n      var height = this.ctx.canvas.height;\n\n      this.ctx.save();\n      this.ctx.fillStyle = background || \"rgb(255, 255, 255)\";\n      this.ctx.fillRect(0, 0, width, height);\n      this.ctx.restore();\n\n      if (transparency) {\n        var transparentCanvas = this.cachedCanvases.getCanvas(\n          \"transparent\",\n          width,\n          height,\n          true\n        );\n        this.compositeCtx = this.ctx;\n        this.transparentCanvas = transparentCanvas.canvas;\n        this.ctx = transparentCanvas.context;\n        this.ctx.save();\n        // The transform can be applied before rendering, transferring it to\n        // the new canvas.\n        this.ctx.transform.apply(\n          this.ctx,\n          this.compositeCtx.mozCurrentTransform\n        );\n      }\n\n      this.ctx.save();\n      resetCtxToDefault(this.ctx);\n      if (transform) {\n        this.ctx.transform.apply(this.ctx, transform);\n      }\n      this.ctx.transform.apply(this.ctx, viewport.transform);\n\n      this.baseTransform = this.ctx.mozCurrentTransform.slice();\n\n      if (this.imageLayer) {\n        this.imageLayer.beginLayout();\n      }\n    },\n\n    executeOperatorList: function CanvasGraphics_executeOperatorList(\n      operatorList,\n      executionStartIdx,\n      continueCallback,\n      stepper\n    ) {\n      var argsArray = operatorList.argsArray;\n      var fnArray = operatorList.fnArray;\n      var i = executionStartIdx || 0;\n      var argsArrayLen = argsArray.length;\n\n      // Sometimes the OperatorList to execute is empty.\n      if (argsArrayLen === i) {\n        return i;\n      }\n\n      var chunkOperations =\n        argsArrayLen - i > EXECUTION_STEPS &&\n        typeof continueCallback === \"function\";\n      var endTime = chunkOperations ? Date.now() + EXECUTION_TIME : 0;\n      var steps = 0;\n\n      var commonObjs = this.commonObjs;\n      var objs = this.objs;\n      var fnId;\n\n      while (true) {\n        if (stepper !== undefined && i === stepper.nextBreakPoint) {\n          stepper.breakIt(i, continueCallback);\n          return i;\n        }\n\n        fnId = fnArray[i];\n\n        if (fnId !== OPS.dependency) {\n          this[fnId].apply(this, argsArray[i]);\n        } else {\n          for (const depObjId of argsArray[i]) {\n            const objsPool = depObjId.startsWith(\"g_\") ? commonObjs : objs;\n\n            // If the promise isn't resolved yet, add the continueCallback\n            // to the promise and bail out.\n            if (!objsPool.has(depObjId)) {\n              objsPool.get(depObjId, continueCallback);\n              return i;\n            }\n          }\n        }\n\n        i++;\n\n        // If the entire operatorList was executed, stop as were done.\n        if (i === argsArrayLen) {\n          return i;\n        }\n\n        // If the execution took longer then a certain amount of time and\n        // `continueCallback` is specified, interrupt the execution.\n        if (chunkOperations && ++steps > EXECUTION_STEPS) {\n          if (Date.now() > endTime) {\n            continueCallback();\n            return i;\n          }\n          steps = 0;\n        }\n\n        // If the operatorList isn't executed completely yet OR the execution\n        // time was short enough, do another execution round.\n      }\n    },\n\n    endDrawing: function CanvasGraphics_endDrawing() {\n      // Finishing all opened operations such as SMask group painting.\n      if (this.current.activeSMask !== null) {\n        this.endSMaskGroup();\n      }\n\n      this.ctx.restore();\n\n      if (this.transparentCanvas) {\n        this.ctx = this.compositeCtx;\n        this.ctx.save();\n        this.ctx.setTransform(1, 0, 0, 1, 0, 0); // Avoid apply transform twice\n        this.ctx.drawImage(this.transparentCanvas, 0, 0);\n        this.ctx.restore();\n        this.transparentCanvas = null;\n      }\n\n      this.cachedCanvases.clear();\n      this.webGLContext.clear();\n\n      if (this.imageLayer) {\n        this.imageLayer.endLayout();\n      }\n    },\n\n    // Graphics state\n    setLineWidth: function CanvasGraphics_setLineWidth(width) {\n      this.current.lineWidth = width;\n      this.ctx.lineWidth = width;\n    },\n    setLineCap: function CanvasGraphics_setLineCap(style) {\n      this.ctx.lineCap = LINE_CAP_STYLES[style];\n    },\n    setLineJoin: function CanvasGraphics_setLineJoin(style) {\n      this.ctx.lineJoin = LINE_JOIN_STYLES[style];\n    },\n    setMiterLimit: function CanvasGraphics_setMiterLimit(limit) {\n      this.ctx.miterLimit = limit;\n    },\n    setDash: function CanvasGraphics_setDash(dashArray, dashPhase) {\n      var ctx = this.ctx;\n      if (ctx.setLineDash !== undefined) {\n        ctx.setLineDash(dashArray);\n        ctx.lineDashOffset = dashPhase;\n      }\n    },\n    setRenderingIntent(intent) {\n      // This operation is ignored since we haven't found a use case for it yet.\n    },\n    setFlatness(flatness) {\n      // This operation is ignored since we haven't found a use case for it yet.\n    },\n    setGState: function CanvasGraphics_setGState(states) {\n      for (var i = 0, ii = states.length; i < ii; i++) {\n        var state = states[i];\n        var key = state[0];\n        var value = state[1];\n\n        switch (key) {\n          case \"LW\":\n            this.setLineWidth(value);\n            break;\n          case \"LC\":\n            this.setLineCap(value);\n            break;\n          case \"LJ\":\n            this.setLineJoin(value);\n            break;\n          case \"ML\":\n            this.setMiterLimit(value);\n            break;\n          case \"D\":\n            this.setDash(value[0], value[1]);\n            break;\n          case \"RI\":\n            this.setRenderingIntent(value);\n            break;\n          case \"FL\":\n            this.setFlatness(value);\n            break;\n          case \"Font\":\n            this.setFont(value[0], value[1]);\n            break;\n          case \"CA\":\n            this.current.strokeAlpha = state[1];\n            break;\n          case \"ca\":\n            this.current.fillAlpha = state[1];\n            this.ctx.globalAlpha = state[1];\n            break;\n          case \"BM\":\n            this.ctx.globalCompositeOperation = value;\n            break;\n          case \"SMask\":\n            if (this.current.activeSMask) {\n              // If SMask is currrenly used, it needs to be suspended or\n              // finished. Suspend only makes sense when at least one save()\n              // was performed and state needs to be reverted on restore().\n              if (\n                this.stateStack.length > 0 &&\n                this.stateStack[this.stateStack.length - 1].activeSMask ===\n                  this.current.activeSMask\n              ) {\n                this.suspendSMaskGroup();\n              } else {\n                this.endSMaskGroup();\n              }\n            }\n            this.current.activeSMask = value ? this.tempSMask : null;\n            if (this.current.activeSMask) {\n              this.beginSMaskGroup();\n            }\n            this.tempSMask = null;\n            break;\n          case \"TR\":\n            this.current.transferMaps = value;\n        }\n      }\n    },\n    beginSMaskGroup: function CanvasGraphics_beginSMaskGroup() {\n      var activeSMask = this.current.activeSMask;\n      var drawnWidth = activeSMask.canvas.width;\n      var drawnHeight = activeSMask.canvas.height;\n      var cacheId = \"smaskGroupAt\" + this.groupLevel;\n      var scratchCanvas = this.cachedCanvases.getCanvas(\n        cacheId,\n        drawnWidth,\n        drawnHeight,\n        true\n      );\n\n      var currentCtx = this.ctx;\n      var currentTransform = currentCtx.mozCurrentTransform;\n      this.ctx.save();\n\n      var groupCtx = scratchCanvas.context;\n      groupCtx.scale(1 / activeSMask.scaleX, 1 / activeSMask.scaleY);\n      groupCtx.translate(-activeSMask.offsetX, -activeSMask.offsetY);\n      groupCtx.transform.apply(groupCtx, currentTransform);\n\n      activeSMask.startTransformInverse = groupCtx.mozCurrentTransformInverse;\n\n      copyCtxState(currentCtx, groupCtx);\n      this.ctx = groupCtx;\n      this.setGState([\n        [\"BM\", \"source-over\"],\n        [\"ca\", 1],\n        [\"CA\", 1],\n      ]);\n      this.groupStack.push(currentCtx);\n      this.groupLevel++;\n    },\n    suspendSMaskGroup: function CanvasGraphics_endSMaskGroup() {\n      // Similar to endSMaskGroup, the intermediate canvas has to be composed\n      // and future ctx state restored.\n      var groupCtx = this.ctx;\n      this.groupLevel--;\n      this.ctx = this.groupStack.pop();\n\n      composeSMask(\n        this.ctx,\n        this.current.activeSMask,\n        groupCtx,\n        this.webGLContext\n      );\n      this.ctx.restore();\n      this.ctx.save(); // save is needed since SMask will be resumed.\n      copyCtxState(groupCtx, this.ctx);\n\n      // Saving state for resuming.\n      this.current.resumeSMaskCtx = groupCtx;\n      // Transform was changed in the SMask canvas, reflecting this change on\n      // this.ctx.\n      var deltaTransform = Util.transform(\n        this.current.activeSMask.startTransformInverse,\n        groupCtx.mozCurrentTransform\n      );\n      this.ctx.transform.apply(this.ctx, deltaTransform);\n\n      // SMask was composed, the results at the groupCtx can be cleared.\n      groupCtx.save();\n      groupCtx.setTransform(1, 0, 0, 1, 0, 0);\n      groupCtx.clearRect(0, 0, groupCtx.canvas.width, groupCtx.canvas.height);\n      groupCtx.restore();\n    },\n    resumeSMaskGroup: function CanvasGraphics_endSMaskGroup() {\n      // Resuming state saved by suspendSMaskGroup. We don't need to restore\n      // any groupCtx state since restore() command (the only caller) will do\n      // that for us. See also beginSMaskGroup.\n      var groupCtx = this.current.resumeSMaskCtx;\n      var currentCtx = this.ctx;\n      this.ctx = groupCtx;\n      this.groupStack.push(currentCtx);\n      this.groupLevel++;\n    },\n    endSMaskGroup: function CanvasGraphics_endSMaskGroup() {\n      var groupCtx = this.ctx;\n      this.groupLevel--;\n      this.ctx = this.groupStack.pop();\n\n      composeSMask(\n        this.ctx,\n        this.current.activeSMask,\n        groupCtx,\n        this.webGLContext\n      );\n      this.ctx.restore();\n      copyCtxState(groupCtx, this.ctx);\n      // Transform was changed in the SMask canvas, reflecting this change on\n      // this.ctx.\n      var deltaTransform = Util.transform(\n        this.current.activeSMask.startTransformInverse,\n        groupCtx.mozCurrentTransform\n      );\n      this.ctx.transform.apply(this.ctx, deltaTransform);\n    },\n    save: function CanvasGraphics_save() {\n      this.ctx.save();\n      var old = this.current;\n      this.stateStack.push(old);\n      this.current = old.clone();\n      this.current.resumeSMaskCtx = null;\n    },\n    restore: function CanvasGraphics_restore() {\n      // SMask was suspended, we just need to resume it.\n      if (this.current.resumeSMaskCtx) {\n        this.resumeSMaskGroup();\n      }\n      // SMask has to be finished once there is no states that are using the\n      // same SMask.\n      if (\n        this.current.activeSMask !== null &&\n        (this.stateStack.length === 0 ||\n          this.stateStack[this.stateStack.length - 1].activeSMask !==\n            this.current.activeSMask)\n      ) {\n        this.endSMaskGroup();\n      }\n\n      if (this.stateStack.length !== 0) {\n        this.current = this.stateStack.pop();\n        this.ctx.restore();\n\n        // Ensure that the clipping path is reset (fixes issue6413.pdf).\n        this.pendingClip = null;\n\n        this._cachedGetSinglePixelWidth = null;\n      }\n    },\n    transform: function CanvasGraphics_transform(a, b, c, d, e, f) {\n      this.ctx.transform(a, b, c, d, e, f);\n\n      this._cachedGetSinglePixelWidth = null;\n    },\n\n    // Path\n    constructPath: function CanvasGraphics_constructPath(ops, args) {\n      var ctx = this.ctx;\n      var current = this.current;\n      var x = current.x,\n        y = current.y;\n      for (var i = 0, j = 0, ii = ops.length; i < ii; i++) {\n        switch (ops[i] | 0) {\n          case OPS.rectangle:\n            x = args[j++];\n            y = args[j++];\n            var width = args[j++];\n            var height = args[j++];\n            if (width === 0 && ctx.lineWidth < this.getSinglePixelWidth()) {\n              width = this.getSinglePixelWidth();\n            }\n            if (height === 0 && ctx.lineWidth < this.getSinglePixelWidth()) {\n              height = this.getSinglePixelWidth();\n            }\n            var xw = x + width;\n            var yh = y + height;\n            ctx.moveTo(x, y);\n            ctx.lineTo(xw, y);\n            ctx.lineTo(xw, yh);\n            ctx.lineTo(x, yh);\n            ctx.lineTo(x, y);\n            ctx.closePath();\n            break;\n          case OPS.moveTo:\n            x = args[j++];\n            y = args[j++];\n            ctx.moveTo(x, y);\n            break;\n          case OPS.lineTo:\n            x = args[j++];\n            y = args[j++];\n            ctx.lineTo(x, y);\n            break;\n          case OPS.curveTo:\n            x = args[j + 4];\n            y = args[j + 5];\n            ctx.bezierCurveTo(\n              args[j],\n              args[j + 1],\n              args[j + 2],\n              args[j + 3],\n              x,\n              y\n            );\n            j += 6;\n            break;\n          case OPS.curveTo2:\n            ctx.bezierCurveTo(\n              x,\n              y,\n              args[j],\n              args[j + 1],\n              args[j + 2],\n              args[j + 3]\n            );\n            x = args[j + 2];\n            y = args[j + 3];\n            j += 4;\n            break;\n          case OPS.curveTo3:\n            x = args[j + 2];\n            y = args[j + 3];\n            ctx.bezierCurveTo(args[j], args[j + 1], x, y, x, y);\n            j += 4;\n            break;\n          case OPS.closePath:\n            ctx.closePath();\n            break;\n        }\n      }\n      current.setCurrentPoint(x, y);\n    },\n    closePath: function CanvasGraphics_closePath() {\n      this.ctx.closePath();\n    },\n    stroke: function CanvasGraphics_stroke(consumePath) {\n      consumePath = typeof consumePath !== \"undefined\" ? consumePath : true;\n      var ctx = this.ctx;\n      var strokeColor = this.current.strokeColor;\n      // For stroke we want to temporarily change the global alpha to the\n      // stroking alpha.\n      ctx.globalAlpha = this.current.strokeAlpha;\n      if (this.contentVisible) {\n        if (\n          strokeColor &&\n          strokeColor.hasOwnProperty(\"type\") &&\n          strokeColor.type === \"Pattern\"\n        ) {\n          // for patterns, we transform to pattern space, calculate\n          // the pattern, call stroke, and restore to user space\n          ctx.save();\n          // The current transform will be replaced while building the pattern,\n          // but the line width needs to be adjusted by the current transform,\n          // so we must scale it. To properly fix this we should be using a\n          // pattern transform instead (see #10955).\n          const transform = ctx.mozCurrentTransform;\n          const scale = Util.singularValueDecompose2dScale(transform)[0];\n          ctx.strokeStyle = strokeColor.getPattern(ctx, this);\n          ctx.lineWidth = Math.max(\n            this.getSinglePixelWidth() * MIN_WIDTH_FACTOR,\n            this.current.lineWidth * scale\n          );\n          ctx.stroke();\n          ctx.restore();\n        } else {\n          // Prevent drawing too thin lines by enforcing a minimum line width.\n          ctx.lineWidth = Math.max(\n            this.getSinglePixelWidth() * MIN_WIDTH_FACTOR,\n            this.current.lineWidth\n          );\n          ctx.stroke();\n        }\n      }\n      if (consumePath) {\n        this.consumePath();\n      }\n      // Restore the global alpha to the fill alpha\n      ctx.globalAlpha = this.current.fillAlpha;\n    },\n    closeStroke: function CanvasGraphics_closeStroke() {\n      this.closePath();\n      this.stroke();\n    },\n    fill: function CanvasGraphics_fill(consumePath) {\n      consumePath = typeof consumePath !== \"undefined\" ? consumePath : true;\n      var ctx = this.ctx;\n      var fillColor = this.current.fillColor;\n      var isPatternFill = this.current.patternFill;\n      var needRestore = false;\n\n      if (isPatternFill) {\n        ctx.save();\n        if (this.baseTransform) {\n          ctx.setTransform.apply(ctx, this.baseTransform);\n        }\n        ctx.fillStyle = fillColor.getPattern(ctx, this);\n        needRestore = true;\n      }\n\n      if (this.contentVisible) {\n        if (this.pendingEOFill) {\n          ctx.fill(\"evenodd\");\n          this.pendingEOFill = false;\n        } else {\n          ctx.fill();\n        }\n      }\n\n      if (needRestore) {\n        ctx.restore();\n      }\n      if (consumePath) {\n        this.consumePath();\n      }\n    },\n    eoFill: function CanvasGraphics_eoFill() {\n      this.pendingEOFill = true;\n      this.fill();\n    },\n    fillStroke: function CanvasGraphics_fillStroke() {\n      this.fill(false);\n      this.stroke(false);\n\n      this.consumePath();\n    },\n    eoFillStroke: function CanvasGraphics_eoFillStroke() {\n      this.pendingEOFill = true;\n      this.fillStroke();\n    },\n    closeFillStroke: function CanvasGraphics_closeFillStroke() {\n      this.closePath();\n      this.fillStroke();\n    },\n    closeEOFillStroke: function CanvasGraphics_closeEOFillStroke() {\n      this.pendingEOFill = true;\n      this.closePath();\n      this.fillStroke();\n    },\n    endPath: function CanvasGraphics_endPath() {\n      this.consumePath();\n    },\n\n    // Clipping\n    clip: function CanvasGraphics_clip() {\n      this.pendingClip = NORMAL_CLIP;\n    },\n    eoClip: function CanvasGraphics_eoClip() {\n      this.pendingClip = EO_CLIP;\n    },\n\n    // Text\n    beginText: function CanvasGraphics_beginText() {\n      this.current.textMatrix = IDENTITY_MATRIX;\n      this.current.textMatrixScale = 1;\n      this.current.x = this.current.lineX = 0;\n      this.current.y = this.current.lineY = 0;\n    },\n    endText: function CanvasGraphics_endText() {\n      var paths = this.pendingTextPaths;\n      var ctx = this.ctx;\n      if (paths === undefined) {\n        ctx.beginPath();\n        return;\n      }\n\n      ctx.save();\n      ctx.beginPath();\n      for (var i = 0; i < paths.length; i++) {\n        var path = paths[i];\n        ctx.setTransform.apply(ctx, path.transform);\n        ctx.translate(path.x, path.y);\n        path.addToPath(ctx, path.fontSize);\n      }\n      ctx.restore();\n      ctx.clip();\n      ctx.beginPath();\n      delete this.pendingTextPaths;\n    },\n    setCharSpacing: function CanvasGraphics_setCharSpacing(spacing) {\n      this.current.charSpacing = spacing;\n    },\n    setWordSpacing: function CanvasGraphics_setWordSpacing(spacing) {\n      this.current.wordSpacing = spacing;\n    },\n    setHScale: function CanvasGraphics_setHScale(scale) {\n      this.current.textHScale = scale / 100;\n    },\n    setLeading: function CanvasGraphics_setLeading(leading) {\n      this.current.leading = -leading;\n    },\n    setFont: function CanvasGraphics_setFont(fontRefName, size) {\n      var fontObj = this.commonObjs.get(fontRefName);\n      var current = this.current;\n\n      if (!fontObj) {\n        throw new Error(`Can't find font for ${fontRefName}`);\n      }\n\n      current.fontMatrix = fontObj.fontMatrix\n        ? fontObj.fontMatrix\n        : FONT_IDENTITY_MATRIX;\n\n      // A valid matrix needs all main diagonal elements to be non-zero\n      // This also ensures we bypass FF bugzilla bug #719844.\n      if (current.fontMatrix[0] === 0 || current.fontMatrix[3] === 0) {\n        warn(\"Invalid font matrix for font \" + fontRefName);\n      }\n\n      // The spec for Tf (setFont) says that 'size' specifies the font 'scale',\n      // and in some docs this can be negative (inverted x-y axes).\n      if (size < 0) {\n        size = -size;\n        current.fontDirection = -1;\n      } else {\n        current.fontDirection = 1;\n      }\n\n      this.current.font = fontObj;\n      this.current.fontSize = size;\n\n      if (fontObj.isType3Font) {\n        return; // we don't need ctx.font for Type3 fonts\n      }\n\n      var name = fontObj.loadedName || \"sans-serif\";\n\n      let bold = \"normal\";\n      if (fontObj.black) {\n        bold = \"900\";\n      } else if (fontObj.bold) {\n        bold = \"bold\";\n      }\n      var italic = fontObj.italic ? \"italic\" : \"normal\";\n      var typeface = `\"${name}\", ${fontObj.fallbackName}`;\n\n      // Some font backends cannot handle fonts below certain size.\n      // Keeping the font at minimal size and using the fontSizeScale to change\n      // the current transformation matrix before the fillText/strokeText.\n      // See https://bugzilla.mozilla.org/show_bug.cgi?id=726227\n      let browserFontSize = size;\n      if (size < MIN_FONT_SIZE) {\n        browserFontSize = MIN_FONT_SIZE;\n      } else if (size > MAX_FONT_SIZE) {\n        browserFontSize = MAX_FONT_SIZE;\n      }\n      this.current.fontSizeScale = size / browserFontSize;\n\n      this.ctx.font = `${italic} ${bold} ${browserFontSize}px ${typeface}`;\n    },\n    setTextRenderingMode: function CanvasGraphics_setTextRenderingMode(mode) {\n      this.current.textRenderingMode = mode;\n    },\n    setTextRise: function CanvasGraphics_setTextRise(rise) {\n      this.current.textRise = rise;\n    },\n    moveText: function CanvasGraphics_moveText(x, y) {\n      this.current.x = this.current.lineX += x;\n      this.current.y = this.current.lineY += y;\n    },\n    setLeadingMoveText: function CanvasGraphics_setLeadingMoveText(x, y) {\n      this.setLeading(-y);\n      this.moveText(x, y);\n    },\n    setTextMatrix: function CanvasGraphics_setTextMatrix(a, b, c, d, e, f) {\n      this.current.textMatrix = [a, b, c, d, e, f];\n      this.current.textMatrixScale = Math.sqrt(a * a + b * b);\n\n      this.current.x = this.current.lineX = 0;\n      this.current.y = this.current.lineY = 0;\n    },\n    nextLine: function CanvasGraphics_nextLine() {\n      this.moveText(0, this.current.leading);\n    },\n\n    paintChar(character, x, y, patternTransform) {\n      var ctx = this.ctx;\n      var current = this.current;\n      var font = current.font;\n      var textRenderingMode = current.textRenderingMode;\n      var fontSize = current.fontSize / current.fontSizeScale;\n      var fillStrokeMode =\n        textRenderingMode & TextRenderingMode.FILL_STROKE_MASK;\n      var isAddToPathSet = !!(\n        textRenderingMode & TextRenderingMode.ADD_TO_PATH_FLAG\n      );\n      const patternFill = current.patternFill && !font.missingFile;\n\n      var addToPath;\n      if (font.disableFontFace || isAddToPathSet || patternFill) {\n        addToPath = font.getPathGenerator(this.commonObjs, character);\n      }\n\n      if (font.disableFontFace || patternFill) {\n        ctx.save();\n        ctx.translate(x, y);\n        ctx.beginPath();\n        addToPath(ctx, fontSize);\n        if (patternTransform) {\n          ctx.setTransform.apply(ctx, patternTransform);\n        }\n        if (\n          fillStrokeMode === TextRenderingMode.FILL ||\n          fillStrokeMode === TextRenderingMode.FILL_STROKE\n        ) {\n          ctx.fill();\n        }\n        if (\n          fillStrokeMode === TextRenderingMode.STROKE ||\n          fillStrokeMode === TextRenderingMode.FILL_STROKE\n        ) {\n          ctx.stroke();\n        }\n        ctx.restore();\n      } else {\n        if (\n          fillStrokeMode === TextRenderingMode.FILL ||\n          fillStrokeMode === TextRenderingMode.FILL_STROKE\n        ) {\n          ctx.fillText(character, x, y);\n        }\n        if (\n          fillStrokeMode === TextRenderingMode.STROKE ||\n          fillStrokeMode === TextRenderingMode.FILL_STROKE\n        ) {\n          ctx.strokeText(character, x, y);\n        }\n      }\n\n      if (isAddToPathSet) {\n        var paths = this.pendingTextPaths || (this.pendingTextPaths = []);\n        paths.push({\n          transform: ctx.mozCurrentTransform,\n          x,\n          y,\n          fontSize,\n          addToPath,\n        });\n      }\n    },\n\n    get isFontSubpixelAAEnabled() {\n      // Checks if anti-aliasing is enabled when scaled text is painted.\n      // On Windows GDI scaled fonts looks bad.\n      const { context: ctx } = this.cachedCanvases.getCanvas(\n        \"isFontSubpixelAAEnabled\",\n        10,\n        10\n      );\n      ctx.scale(1.5, 1);\n      ctx.fillText(\"I\", 0, 10);\n      var data = ctx.getImageData(0, 0, 10, 10).data;\n      var enabled = false;\n      for (var i = 3; i < data.length; i += 4) {\n        if (data[i] > 0 && data[i] < 255) {\n          enabled = true;\n          break;\n        }\n      }\n      return shadow(this, \"isFontSubpixelAAEnabled\", enabled);\n    },\n\n    showText: function CanvasGraphics_showText(glyphs) {\n      var current = this.current;\n      var font = current.font;\n      if (font.isType3Font) {\n        return this.showType3Text(glyphs);\n      }\n\n      var fontSize = current.fontSize;\n      if (fontSize === 0) {\n        return undefined;\n      }\n\n      var ctx = this.ctx;\n      var fontSizeScale = current.fontSizeScale;\n      var charSpacing = current.charSpacing;\n      var wordSpacing = current.wordSpacing;\n      var fontDirection = current.fontDirection;\n      var textHScale = current.textHScale * fontDirection;\n      var glyphsLength = glyphs.length;\n      var vertical = font.vertical;\n      var spacingDir = vertical ? 1 : -1;\n      var defaultVMetrics = font.defaultVMetrics;\n      var widthAdvanceScale = fontSize * current.fontMatrix[0];\n\n      var simpleFillText =\n        current.textRenderingMode === TextRenderingMode.FILL &&\n        !font.disableFontFace &&\n        !current.patternFill;\n\n      ctx.save();\n      let patternTransform;\n      if (current.patternFill) {\n        // TODO: Patterns are not applied correctly to text if a non-embedded\n        // font is used. E.g. issue 8111 and ShowText-ShadingPattern.pdf.\n        ctx.save();\n        const pattern = current.fillColor.getPattern(ctx, this);\n        patternTransform = ctx.mozCurrentTransform;\n        ctx.restore();\n        ctx.fillStyle = pattern;\n      }\n      ctx.transform.apply(ctx, current.textMatrix);\n      ctx.translate(current.x, current.y + current.textRise);\n\n      if (fontDirection > 0) {\n        ctx.scale(textHScale, -1);\n      } else {\n        ctx.scale(textHScale, 1);\n      }\n\n      var lineWidth = current.lineWidth;\n      var scale = current.textMatrixScale;\n      if (scale === 0 || lineWidth === 0) {\n        var fillStrokeMode =\n          current.textRenderingMode & TextRenderingMode.FILL_STROKE_MASK;\n        if (\n          fillStrokeMode === TextRenderingMode.STROKE ||\n          fillStrokeMode === TextRenderingMode.FILL_STROKE\n        ) {\n          this._cachedGetSinglePixelWidth = null;\n          lineWidth = this.getSinglePixelWidth() * MIN_WIDTH_FACTOR;\n        }\n      } else {\n        lineWidth /= scale;\n      }\n\n      if (fontSizeScale !== 1.0) {\n        ctx.scale(fontSizeScale, fontSizeScale);\n        lineWidth /= fontSizeScale;\n      }\n\n      ctx.lineWidth = lineWidth;\n\n      var x = 0,\n        i;\n      for (i = 0; i < glyphsLength; ++i) {\n        var glyph = glyphs[i];\n        if (isNum(glyph)) {\n          x += (spacingDir * glyph * fontSize) / 1000;\n          continue;\n        }\n\n        var restoreNeeded = false;\n        var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;\n        var character = glyph.fontChar;\n        var accent = glyph.accent;\n        var scaledX, scaledY, scaledAccentX, scaledAccentY;\n        var width = glyph.width;\n        if (vertical) {\n          var vmetric, vx, vy;\n          vmetric = glyph.vmetric || defaultVMetrics;\n          vx = glyph.vmetric ? vmetric[1] : width * 0.5;\n          vx = -vx * widthAdvanceScale;\n          vy = vmetric[2] * widthAdvanceScale;\n\n          width = vmetric ? -vmetric[0] : width;\n          scaledX = vx / fontSizeScale;\n          scaledY = (x + vy) / fontSizeScale;\n        } else {\n          scaledX = x / fontSizeScale;\n          scaledY = 0;\n        }\n\n        if (font.remeasure && width > 0) {\n          // Some standard fonts may not have the exact width: rescale per\n          // character if measured width is greater than expected glyph width\n          // and subpixel-aa is enabled, otherwise just center the glyph.\n          var measuredWidth =\n            ((ctx.measureText(character).width * 1000) / fontSize) *\n            fontSizeScale;\n          if (width < measuredWidth && this.isFontSubpixelAAEnabled) {\n            var characterScaleX = width / measuredWidth;\n            restoreNeeded = true;\n            ctx.save();\n            ctx.scale(characterScaleX, 1);\n            scaledX /= characterScaleX;\n          } else if (width !== measuredWidth) {\n            scaledX +=\n              (((width - measuredWidth) / 2000) * fontSize) / fontSizeScale;\n          }\n        }\n\n        // Only attempt to draw the glyph if it is actually in the embedded font\n        // file or if there isn't a font file so the fallback font is shown.\n        if (this.contentVisible && (glyph.isInFont || font.missingFile)) {\n          if (simpleFillText && !accent) {\n            // common case\n            ctx.fillText(character, scaledX, scaledY);\n          } else {\n            this.paintChar(character, scaledX, scaledY, patternTransform);\n            if (accent) {\n              scaledAccentX =\n                scaledX + (fontSize * accent.offset.x) / fontSizeScale;\n              scaledAccentY =\n                scaledY - (fontSize * accent.offset.y) / fontSizeScale;\n              this.paintChar(\n                accent.fontChar,\n                scaledAccentX,\n                scaledAccentY,\n                patternTransform\n              );\n            }\n          }\n        }\n\n        var charWidth;\n        if (vertical) {\n          charWidth = width * widthAdvanceScale - spacing * fontDirection;\n        } else {\n          charWidth = width * widthAdvanceScale + spacing * fontDirection;\n        }\n        x += charWidth;\n\n        if (restoreNeeded) {\n          ctx.restore();\n        }\n      }\n      if (vertical) {\n        current.y -= x;\n      } else {\n        current.x += x * textHScale;\n      }\n      ctx.restore();\n    },\n\n    showType3Text: function CanvasGraphics_showType3Text(glyphs) {\n      // Type3 fonts - each glyph is a \"mini-PDF\"\n      var ctx = this.ctx;\n      var current = this.current;\n      var font = current.font;\n      var fontSize = current.fontSize;\n      var fontDirection = current.fontDirection;\n      var spacingDir = font.vertical ? 1 : -1;\n      var charSpacing = current.charSpacing;\n      var wordSpacing = current.wordSpacing;\n      var textHScale = current.textHScale * fontDirection;\n      var fontMatrix = current.fontMatrix || FONT_IDENTITY_MATRIX;\n      var glyphsLength = glyphs.length;\n      var isTextInvisible =\n        current.textRenderingMode === TextRenderingMode.INVISIBLE;\n      var i, glyph, width, spacingLength;\n\n      if (isTextInvisible || fontSize === 0) {\n        return;\n      }\n      this._cachedGetSinglePixelWidth = null;\n\n      ctx.save();\n      ctx.transform.apply(ctx, current.textMatrix);\n      ctx.translate(current.x, current.y);\n\n      ctx.scale(textHScale, fontDirection);\n\n      for (i = 0; i < glyphsLength; ++i) {\n        glyph = glyphs[i];\n        if (isNum(glyph)) {\n          spacingLength = (spacingDir * glyph * fontSize) / 1000;\n          this.ctx.translate(spacingLength, 0);\n          current.x += spacingLength * textHScale;\n          continue;\n        }\n\n        var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;\n        var operatorList = font.charProcOperatorList[glyph.operatorListId];\n        if (!operatorList) {\n          warn(`Type3 character \"${glyph.operatorListId}\" is not available.`);\n          continue;\n        }\n        if (this.contentVisible) {\n          this.processingType3 = glyph;\n          this.save();\n          ctx.scale(fontSize, fontSize);\n          ctx.transform.apply(ctx, fontMatrix);\n          this.executeOperatorList(operatorList);\n          this.restore();\n        }\n\n        var transformed = Util.applyTransform([glyph.width, 0], fontMatrix);\n        width = transformed[0] * fontSize + spacing;\n\n        ctx.translate(width, 0);\n        current.x += width * textHScale;\n      }\n      ctx.restore();\n      this.processingType3 = null;\n    },\n\n    // Type3 fonts\n    setCharWidth: function CanvasGraphics_setCharWidth(xWidth, yWidth) {\n      // We can safely ignore this since the width should be the same\n      // as the width in the Widths array.\n    },\n    setCharWidthAndBounds: function CanvasGraphics_setCharWidthAndBounds(\n      xWidth,\n      yWidth,\n      llx,\n      lly,\n      urx,\n      ury\n    ) {\n      // TODO According to the spec we're also suppose to ignore any operators\n      // that set color or include images while processing this type3 font.\n      this.ctx.rect(llx, lly, urx - llx, ury - lly);\n      this.clip();\n      this.endPath();\n    },\n\n    // Color\n    getColorN_Pattern: function CanvasGraphics_getColorN_Pattern(IR) {\n      var pattern;\n      if (IR[0] === \"TilingPattern\") {\n        var color = IR[1];\n        var baseTransform =\n          this.baseTransform || this.ctx.mozCurrentTransform.slice();\n        var canvasGraphicsFactory = {\n          createCanvasGraphics: ctx => {\n            return new CanvasGraphics(\n              ctx,\n              this.commonObjs,\n              this.objs,\n              this.canvasFactory,\n              this.webGLContext\n            );\n          },\n        };\n        pattern = new TilingPattern(\n          IR,\n          color,\n          this.ctx,\n          canvasGraphicsFactory,\n          baseTransform\n        );\n      } else {\n        pattern = getShadingPatternFromIR(IR);\n      }\n      return pattern;\n    },\n    setStrokeColorN: function CanvasGraphics_setStrokeColorN() {\n      this.current.strokeColor = this.getColorN_Pattern(arguments);\n    },\n    setFillColorN: function CanvasGraphics_setFillColorN() {\n      this.current.fillColor = this.getColorN_Pattern(arguments);\n      this.current.patternFill = true;\n    },\n    setStrokeRGBColor: function CanvasGraphics_setStrokeRGBColor(r, g, b) {\n      var color = Util.makeCssRgb(r, g, b);\n      this.ctx.strokeStyle = color;\n      this.current.strokeColor = color;\n    },\n    setFillRGBColor: function CanvasGraphics_setFillRGBColor(r, g, b) {\n      var color = Util.makeCssRgb(r, g, b);\n      this.ctx.fillStyle = color;\n      this.current.fillColor = color;\n      this.current.patternFill = false;\n    },\n\n    shadingFill: function CanvasGraphics_shadingFill(patternIR) {\n      if (!this.contentVisible) {\n        return;\n      }\n      var ctx = this.ctx;\n\n      this.save();\n      var pattern = getShadingPatternFromIR(patternIR);\n      ctx.fillStyle = pattern.getPattern(ctx, this, true);\n\n      var inv = ctx.mozCurrentTransformInverse;\n      if (inv) {\n        var canvas = ctx.canvas;\n        var width = canvas.width;\n        var height = canvas.height;\n\n        var bl = Util.applyTransform([0, 0], inv);\n        var br = Util.applyTransform([0, height], inv);\n        var ul = Util.applyTransform([width, 0], inv);\n        var ur = Util.applyTransform([width, height], inv);\n\n        var x0 = Math.min(bl[0], br[0], ul[0], ur[0]);\n        var y0 = Math.min(bl[1], br[1], ul[1], ur[1]);\n        var x1 = Math.max(bl[0], br[0], ul[0], ur[0]);\n        var y1 = Math.max(bl[1], br[1], ul[1], ur[1]);\n\n        this.ctx.fillRect(x0, y0, x1 - x0, y1 - y0);\n      } else {\n        // HACK to draw the gradient onto an infinite rectangle.\n        // PDF gradients are drawn across the entire image while\n        // Canvas only allows gradients to be drawn in a rectangle\n        // The following bug should allow us to remove this.\n        // https://bugzilla.mozilla.org/show_bug.cgi?id=664884\n\n        this.ctx.fillRect(-1e10, -1e10, 2e10, 2e10);\n      }\n\n      this.restore();\n    },\n\n    // Images\n    beginInlineImage: function CanvasGraphics_beginInlineImage() {\n      unreachable(\"Should not call beginInlineImage\");\n    },\n    beginImageData: function CanvasGraphics_beginImageData() {\n      unreachable(\"Should not call beginImageData\");\n    },\n\n    paintFormXObjectBegin: function CanvasGraphics_paintFormXObjectBegin(\n      matrix,\n      bbox\n    ) {\n      if (!this.contentVisible) {\n        return;\n      }\n      this.save();\n      this.baseTransformStack.push(this.baseTransform);\n\n      if (Array.isArray(matrix) && matrix.length === 6) {\n        this.transform.apply(this, matrix);\n      }\n\n      this.baseTransform = this.ctx.mozCurrentTransform;\n\n      if (bbox) {\n        var width = bbox[2] - bbox[0];\n        var height = bbox[3] - bbox[1];\n        this.ctx.rect(bbox[0], bbox[1], width, height);\n        this.clip();\n        this.endPath();\n      }\n    },\n\n    paintFormXObjectEnd: function CanvasGraphics_paintFormXObjectEnd() {\n      if (!this.contentVisible) {\n        return;\n      }\n      this.restore();\n      this.baseTransform = this.baseTransformStack.pop();\n    },\n\n    beginGroup: function CanvasGraphics_beginGroup(group) {\n      if (!this.contentVisible) {\n        return;\n      }\n\n      this.save();\n      var currentCtx = this.ctx;\n      // TODO non-isolated groups - according to Rik at adobe non-isolated\n      // group results aren't usually that different and they even have tools\n      // that ignore this setting. Notes from Rik on implementing:\n      // - When you encounter an transparency group, create a new canvas with\n      // the dimensions of the bbox\n      // - copy the content from the previous canvas to the new canvas\n      // - draw as usual\n      // - remove the backdrop alpha:\n      // alphaNew = 1 - (1 - alpha)/(1 - alphaBackdrop) with 'alpha' the alpha\n      // value of your transparency group and 'alphaBackdrop' the alpha of the\n      // backdrop\n      // - remove background color:\n      // colorNew = color - alphaNew *colorBackdrop /(1 - alphaNew)\n      if (!group.isolated) {\n        info(\"TODO: Support non-isolated groups.\");\n      }\n\n      // TODO knockout - supposedly possible with the clever use of compositing\n      // modes.\n      if (group.knockout) {\n        warn(\"Knockout groups not supported.\");\n      }\n\n      var currentTransform = currentCtx.mozCurrentTransform;\n      if (group.matrix) {\n        currentCtx.transform.apply(currentCtx, group.matrix);\n      }\n      if (!group.bbox) {\n        throw new Error(\"Bounding box is required.\");\n      }\n\n      // Based on the current transform figure out how big the bounding box\n      // will actually be.\n      var bounds = Util.getAxialAlignedBoundingBox(\n        group.bbox,\n        currentCtx.mozCurrentTransform\n      );\n      // Clip the bounding box to the current canvas.\n      var canvasBounds = [\n        0,\n        0,\n        currentCtx.canvas.width,\n        currentCtx.canvas.height,\n      ];\n      bounds = Util.intersect(bounds, canvasBounds) || [0, 0, 0, 0];\n      // Use ceil in case we're between sizes so we don't create canvas that is\n      // too small and make the canvas at least 1x1 pixels.\n      var offsetX = Math.floor(bounds[0]);\n      var offsetY = Math.floor(bounds[1]);\n      var drawnWidth = Math.max(Math.ceil(bounds[2]) - offsetX, 1);\n      var drawnHeight = Math.max(Math.ceil(bounds[3]) - offsetY, 1);\n      var scaleX = 1,\n        scaleY = 1;\n      if (drawnWidth > MAX_GROUP_SIZE) {\n        scaleX = drawnWidth / MAX_GROUP_SIZE;\n        drawnWidth = MAX_GROUP_SIZE;\n      }\n      if (drawnHeight > MAX_GROUP_SIZE) {\n        scaleY = drawnHeight / MAX_GROUP_SIZE;\n        drawnHeight = MAX_GROUP_SIZE;\n      }\n\n      var cacheId = \"groupAt\" + this.groupLevel;\n      if (group.smask) {\n        // Using two cache entries is case if masks are used one after another.\n        cacheId += \"_smask_\" + (this.smaskCounter++ % 2);\n      }\n      var scratchCanvas = this.cachedCanvases.getCanvas(\n        cacheId,\n        drawnWidth,\n        drawnHeight,\n        true\n      );\n      var groupCtx = scratchCanvas.context;\n\n      // Since we created a new canvas that is just the size of the bounding box\n      // we have to translate the group ctx.\n      groupCtx.scale(1 / scaleX, 1 / scaleY);\n      groupCtx.translate(-offsetX, -offsetY);\n      groupCtx.transform.apply(groupCtx, currentTransform);\n\n      if (group.smask) {\n        // Saving state and cached mask to be used in setGState.\n        this.smaskStack.push({\n          canvas: scratchCanvas.canvas,\n          context: groupCtx,\n          offsetX,\n          offsetY,\n          scaleX,\n          scaleY,\n          subtype: group.smask.subtype,\n          backdrop: group.smask.backdrop,\n          transferMap: group.smask.transferMap || null,\n          startTransformInverse: null, // used during suspend operation\n        });\n      } else {\n        // Setup the current ctx so when the group is popped we draw it at the\n        // right location.\n        currentCtx.setTransform(1, 0, 0, 1, 0, 0);\n        currentCtx.translate(offsetX, offsetY);\n        currentCtx.scale(scaleX, scaleY);\n      }\n      // The transparency group inherits all off the current graphics state\n      // except the blend mode, soft mask, and alpha constants.\n      copyCtxState(currentCtx, groupCtx);\n      this.ctx = groupCtx;\n      this.setGState([\n        [\"BM\", \"source-over\"],\n        [\"ca\", 1],\n        [\"CA\", 1],\n      ]);\n      this.groupStack.push(currentCtx);\n      this.groupLevel++;\n\n      // Reseting mask state, masks will be applied on restore of the group.\n      this.current.activeSMask = null;\n    },\n\n    endGroup: function CanvasGraphics_endGroup(group) {\n      if (!this.contentVisible) {\n        return;\n      }\n      this.groupLevel--;\n      var groupCtx = this.ctx;\n      this.ctx = this.groupStack.pop();\n      // Turn off image smoothing to avoid sub pixel interpolation which can\n      // look kind of blurry for some pdfs.\n      if (this.ctx.imageSmoothingEnabled !== undefined) {\n        this.ctx.imageSmoothingEnabled = false;\n      } else {\n        this.ctx.mozImageSmoothingEnabled = false;\n      }\n      if (group.smask) {\n        this.tempSMask = this.smaskStack.pop();\n      } else {\n        this.ctx.drawImage(groupCtx.canvas, 0, 0);\n      }\n      this.restore();\n    },\n\n    beginAnnotations: function CanvasGraphics_beginAnnotations() {\n      this.save();\n      if (this.baseTransform) {\n        this.ctx.setTransform.apply(this.ctx, this.baseTransform);\n      }\n    },\n\n    endAnnotations: function CanvasGraphics_endAnnotations() {\n      this.restore();\n    },\n\n    beginAnnotation: function CanvasGraphics_beginAnnotation(\n      rect,\n      transform,\n      matrix\n    ) {\n      this.save();\n      resetCtxToDefault(this.ctx);\n      this.current = new CanvasExtraState();\n\n      if (Array.isArray(rect) && rect.length === 4) {\n        var width = rect[2] - rect[0];\n        var height = rect[3] - rect[1];\n        this.ctx.rect(rect[0], rect[1], width, height);\n        this.clip();\n        this.endPath();\n      }\n\n      this.transform.apply(this, transform);\n      this.transform.apply(this, matrix);\n    },\n\n    endAnnotation: function CanvasGraphics_endAnnotation() {\n      this.restore();\n    },\n\n    paintImageMaskXObject: function CanvasGraphics_paintImageMaskXObject(img) {\n      if (!this.contentVisible) {\n        return;\n      }\n      var ctx = this.ctx;\n      var width = img.width,\n        height = img.height;\n      var fillColor = this.current.fillColor;\n      var isPatternFill = this.current.patternFill;\n\n      var glyph = this.processingType3;\n\n      if (COMPILE_TYPE3_GLYPHS && glyph && glyph.compiled === undefined) {\n        if (width <= MAX_SIZE_TO_COMPILE && height <= MAX_SIZE_TO_COMPILE) {\n          glyph.compiled = compileType3Glyph({ data: img.data, width, height });\n        } else {\n          glyph.compiled = null;\n        }\n      }\n\n      if (glyph && glyph.compiled) {\n        glyph.compiled(ctx);\n        return;\n      }\n\n      var maskCanvas = this.cachedCanvases.getCanvas(\n        \"maskCanvas\",\n        width,\n        height\n      );\n      var maskCtx = maskCanvas.context;\n      maskCtx.save();\n\n      putBinaryImageMask(maskCtx, img);\n\n      maskCtx.globalCompositeOperation = \"source-in\";\n\n      maskCtx.fillStyle = isPatternFill\n        ? fillColor.getPattern(maskCtx, this)\n        : fillColor;\n      maskCtx.fillRect(0, 0, width, height);\n\n      maskCtx.restore();\n\n      this.paintInlineImageXObject(maskCanvas.canvas);\n    },\n\n    paintImageMaskXObjectRepeat(\n      imgData,\n      scaleX,\n      skewX = 0,\n      skewY = 0,\n      scaleY,\n      positions\n    ) {\n      if (!this.contentVisible) {\n        return;\n      }\n      var width = imgData.width;\n      var height = imgData.height;\n      var fillColor = this.current.fillColor;\n      var isPatternFill = this.current.patternFill;\n\n      var maskCanvas = this.cachedCanvases.getCanvas(\n        \"maskCanvas\",\n        width,\n        height\n      );\n      var maskCtx = maskCanvas.context;\n      maskCtx.save();\n\n      putBinaryImageMask(maskCtx, imgData);\n\n      maskCtx.globalCompositeOperation = \"source-in\";\n\n      maskCtx.fillStyle = isPatternFill\n        ? fillColor.getPattern(maskCtx, this)\n        : fillColor;\n      maskCtx.fillRect(0, 0, width, height);\n\n      maskCtx.restore();\n\n      var ctx = this.ctx;\n      for (var i = 0, ii = positions.length; i < ii; i += 2) {\n        ctx.save();\n        ctx.transform(\n          scaleX,\n          skewX,\n          skewY,\n          scaleY,\n          positions[i],\n          positions[i + 1]\n        );\n        ctx.scale(1, -1);\n        ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);\n        ctx.restore();\n      }\n    },\n\n    paintImageMaskXObjectGroup: function CanvasGraphics_paintImageMaskXObjectGroup(\n      images\n    ) {\n      if (!this.contentVisible) {\n        return;\n      }\n      var ctx = this.ctx;\n\n      var fillColor = this.current.fillColor;\n      var isPatternFill = this.current.patternFill;\n      for (var i = 0, ii = images.length; i < ii; i++) {\n        var image = images[i];\n        var width = image.width,\n          height = image.height;\n\n        var maskCanvas = this.cachedCanvases.getCanvas(\n          \"maskCanvas\",\n          width,\n          height\n        );\n        var maskCtx = maskCanvas.context;\n        maskCtx.save();\n\n        putBinaryImageMask(maskCtx, image);\n\n        maskCtx.globalCompositeOperation = \"source-in\";\n\n        maskCtx.fillStyle = isPatternFill\n          ? fillColor.getPattern(maskCtx, this)\n          : fillColor;\n        maskCtx.fillRect(0, 0, width, height);\n\n        maskCtx.restore();\n\n        ctx.save();\n        ctx.transform.apply(ctx, image.transform);\n        ctx.scale(1, -1);\n        ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);\n        ctx.restore();\n      }\n    },\n\n    paintImageXObject: function CanvasGraphics_paintImageXObject(objId) {\n      if (!this.contentVisible) {\n        return;\n      }\n      const imgData = objId.startsWith(\"g_\")\n        ? this.commonObjs.get(objId)\n        : this.objs.get(objId);\n      if (!imgData) {\n        warn(\"Dependent image isn't ready yet\");\n        return;\n      }\n\n      this.paintInlineImageXObject(imgData);\n    },\n\n    paintImageXObjectRepeat: function CanvasGraphics_paintImageXObjectRepeat(\n      objId,\n      scaleX,\n      scaleY,\n      positions\n    ) {\n      if (!this.contentVisible) {\n        return;\n      }\n      const imgData = objId.startsWith(\"g_\")\n        ? this.commonObjs.get(objId)\n        : this.objs.get(objId);\n      if (!imgData) {\n        warn(\"Dependent image isn't ready yet\");\n        return;\n      }\n\n      var width = imgData.width;\n      var height = imgData.height;\n      var map = [];\n      for (var i = 0, ii = positions.length; i < ii; i += 2) {\n        map.push({\n          transform: [scaleX, 0, 0, scaleY, positions[i], positions[i + 1]],\n          x: 0,\n          y: 0,\n          w: width,\n          h: height,\n        });\n      }\n      this.paintInlineImageXObjectGroup(imgData, map);\n    },\n\n    paintInlineImageXObject: function CanvasGraphics_paintInlineImageXObject(\n      imgData\n    ) {\n      if (!this.contentVisible) {\n        return;\n      }\n      var width = imgData.width;\n      var height = imgData.height;\n      var ctx = this.ctx;\n\n      this.save();\n      // scale the image to the unit square\n      ctx.scale(1 / width, -1 / height);\n\n      var currentTransform = ctx.mozCurrentTransformInverse;\n      var a = currentTransform[0],\n        b = currentTransform[1];\n      var widthScale = Math.max(Math.sqrt(a * a + b * b), 1);\n      var c = currentTransform[2],\n        d = currentTransform[3];\n      var heightScale = Math.max(Math.sqrt(c * c + d * d), 1);\n\n      var imgToPaint, tmpCanvas;\n      // typeof check is needed due to node.js support, see issue #8489\n      if (\n        (typeof HTMLElement === \"function\" && imgData instanceof HTMLElement) ||\n        !imgData.data\n      ) {\n        imgToPaint = imgData;\n      } else {\n        tmpCanvas = this.cachedCanvases.getCanvas(\"inlineImage\", width, height);\n        var tmpCtx = tmpCanvas.context;\n        putBinaryImageData(tmpCtx, imgData, this.current.transferMaps);\n        imgToPaint = tmpCanvas.canvas;\n      }\n\n      var paintWidth = width,\n        paintHeight = height;\n      var tmpCanvasId = \"prescale1\";\n      // Vertical or horizontal scaling shall not be more than 2 to not lose the\n      // pixels during drawImage operation, painting on the temporary canvas(es)\n      // that are twice smaller in size.\n      while (\n        (widthScale > 2 && paintWidth > 1) ||\n        (heightScale > 2 && paintHeight > 1)\n      ) {\n        var newWidth = paintWidth,\n          newHeight = paintHeight;\n        if (widthScale > 2 && paintWidth > 1) {\n          newWidth = Math.ceil(paintWidth / 2);\n          widthScale /= paintWidth / newWidth;\n        }\n        if (heightScale > 2 && paintHeight > 1) {\n          newHeight = Math.ceil(paintHeight / 2);\n          heightScale /= paintHeight / newHeight;\n        }\n        tmpCanvas = this.cachedCanvases.getCanvas(\n          tmpCanvasId,\n          newWidth,\n          newHeight\n        );\n        tmpCtx = tmpCanvas.context;\n        tmpCtx.clearRect(0, 0, newWidth, newHeight);\n        tmpCtx.drawImage(\n          imgToPaint,\n          0,\n          0,\n          paintWidth,\n          paintHeight,\n          0,\n          0,\n          newWidth,\n          newHeight\n        );\n        imgToPaint = tmpCanvas.canvas;\n        paintWidth = newWidth;\n        paintHeight = newHeight;\n        tmpCanvasId = tmpCanvasId === \"prescale1\" ? \"prescale2\" : \"prescale1\";\n      }\n      ctx.drawImage(\n        imgToPaint,\n        0,\n        0,\n        paintWidth,\n        paintHeight,\n        0,\n        -height,\n        width,\n        height\n      );\n\n      if (this.imageLayer) {\n        var position = this.getCanvasPosition(0, -height);\n        this.imageLayer.appendImage({\n          imgData,\n          left: position[0],\n          top: position[1],\n          width: width / currentTransform[0],\n          height: height / currentTransform[3],\n        });\n      }\n      this.restore();\n    },\n\n    paintInlineImageXObjectGroup: function CanvasGraphics_paintInlineImageXObjectGroup(\n      imgData,\n      map\n    ) {\n      if (!this.contentVisible) {\n        return;\n      }\n      var ctx = this.ctx;\n      var w = imgData.width;\n      var h = imgData.height;\n\n      var tmpCanvas = this.cachedCanvases.getCanvas(\"inlineImage\", w, h);\n      var tmpCtx = tmpCanvas.context;\n      putBinaryImageData(tmpCtx, imgData, this.current.transferMaps);\n\n      for (var i = 0, ii = map.length; i < ii; i++) {\n        var entry = map[i];\n        ctx.save();\n        ctx.transform.apply(ctx, entry.transform);\n        ctx.scale(1, -1);\n        ctx.drawImage(\n          tmpCanvas.canvas,\n          entry.x,\n          entry.y,\n          entry.w,\n          entry.h,\n          0,\n          -1,\n          1,\n          1\n        );\n        if (this.imageLayer) {\n          var position = this.getCanvasPosition(entry.x, entry.y);\n          this.imageLayer.appendImage({\n            imgData,\n            left: position[0],\n            top: position[1],\n            width: w,\n            height: h,\n          });\n        }\n        ctx.restore();\n      }\n    },\n\n    paintSolidColorImageMask: function CanvasGraphics_paintSolidColorImageMask() {\n      if (!this.contentVisible) {\n        return;\n      }\n      this.ctx.fillRect(0, 0, 1, 1);\n    },\n\n    // Marked content\n\n    markPoint: function CanvasGraphics_markPoint(tag) {\n      // TODO Marked content.\n    },\n    markPointProps: function CanvasGraphics_markPointProps(tag, properties) {\n      // TODO Marked content.\n    },\n    beginMarkedContent: function CanvasGraphics_beginMarkedContent(tag) {\n      this.markedContentStack.push({\n        visible: true,\n      });\n    },\n    beginMarkedContentProps: function CanvasGraphics_beginMarkedContentProps(\n      tag,\n      properties\n    ) {\n      if (tag === \"OC\") {\n        this.markedContentStack.push({\n          visible: this.optionalContentConfig.isVisible(properties),\n        });\n      } else {\n        this.markedContentStack.push({\n          visible: true,\n        });\n      }\n      this.contentVisible = this.isContentVisible();\n    },\n    endMarkedContent: function CanvasGraphics_endMarkedContent() {\n      this.markedContentStack.pop();\n      this.contentVisible = this.isContentVisible();\n    },\n\n    // Compatibility\n\n    beginCompat: function CanvasGraphics_beginCompat() {\n      // TODO ignore undefined operators (should we do that anyway?)\n    },\n    endCompat: function CanvasGraphics_endCompat() {\n      // TODO stop ignoring undefined operators\n    },\n\n    // Helper functions\n\n    consumePath: function CanvasGraphics_consumePath() {\n      var ctx = this.ctx;\n      if (this.pendingClip) {\n        if (this.pendingClip === EO_CLIP) {\n          ctx.clip(\"evenodd\");\n        } else {\n          ctx.clip();\n        }\n        this.pendingClip = null;\n      }\n      ctx.beginPath();\n    },\n    getSinglePixelWidth(scale) {\n      if (this._cachedGetSinglePixelWidth === null) {\n        const inverse = this.ctx.mozCurrentTransformInverse;\n        // max of the current horizontal and vertical scale\n        this._cachedGetSinglePixelWidth = Math.sqrt(\n          Math.max(\n            inverse[0] * inverse[0] + inverse[1] * inverse[1],\n            inverse[2] * inverse[2] + inverse[3] * inverse[3]\n          )\n        );\n      }\n      return this._cachedGetSinglePixelWidth;\n    },\n    getCanvasPosition: function CanvasGraphics_getCanvasPosition(x, y) {\n      var transform = this.ctx.mozCurrentTransform;\n      return [\n        transform[0] * x + transform[2] * y + transform[4],\n        transform[1] * x + transform[3] * y + transform[5],\n      ];\n    },\n\n    isContentVisible: function CanvasGraphics_isContentVisible() {\n      for (let i = this.markedContentStack.length - 1; i >= 0; i--) {\n        if (!this.markedContentStack[i].visible) {\n          return false;\n        }\n      }\n      return true;\n    },\n  };\n\n  for (var op in OPS) {\n    CanvasGraphics.prototype[OPS[op]] = CanvasGraphics.prototype[op];\n  }\n\n  return CanvasGraphics;\n})();\n\nexport { CanvasGraphics };\n","/* Copyright 2014 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FormatError, info, Util } from \"../shared/util.js\";\n\nvar ShadingIRs = {};\n\nfunction applyBoundingBox(ctx, bbox) {\n  if (!bbox || typeof Path2D === \"undefined\") {\n    return;\n  }\n  const width = bbox[2] - bbox[0];\n  const height = bbox[3] - bbox[1];\n  const region = new Path2D();\n  region.rect(bbox[0], bbox[1], width, height);\n  ctx.clip(region);\n}\n\nShadingIRs.RadialAxial = {\n  fromIR: function RadialAxial_fromIR(raw) {\n    var type = raw[1];\n    var bbox = raw[2];\n    var colorStops = raw[3];\n    var p0 = raw[4];\n    var p1 = raw[5];\n    var r0 = raw[6];\n    var r1 = raw[7];\n    return {\n      type: \"Pattern\",\n      getPattern: function RadialAxial_getPattern(ctx) {\n        applyBoundingBox(ctx, bbox);\n        var grad;\n        if (type === \"axial\") {\n          grad = ctx.createLinearGradient(p0[0], p0[1], p1[0], p1[1]);\n        } else if (type === \"radial\") {\n          grad = ctx.createRadialGradient(p0[0], p0[1], r0, p1[0], p1[1], r1);\n        }\n\n        for (var i = 0, ii = colorStops.length; i < ii; ++i) {\n          var c = colorStops[i];\n          grad.addColorStop(c[0], c[1]);\n        }\n        return grad;\n      },\n    };\n  },\n};\n\nvar createMeshCanvas = (function createMeshCanvasClosure() {\n  function drawTriangle(data, context, p1, p2, p3, c1, c2, c3) {\n    // Very basic Gouraud-shaded triangle rasterization algorithm.\n    var coords = context.coords,\n      colors = context.colors;\n    var bytes = data.data,\n      rowSize = data.width * 4;\n    var tmp;\n    if (coords[p1 + 1] > coords[p2 + 1]) {\n      tmp = p1;\n      p1 = p2;\n      p2 = tmp;\n      tmp = c1;\n      c1 = c2;\n      c2 = tmp;\n    }\n    if (coords[p2 + 1] > coords[p3 + 1]) {\n      tmp = p2;\n      p2 = p3;\n      p3 = tmp;\n      tmp = c2;\n      c2 = c3;\n      c3 = tmp;\n    }\n    if (coords[p1 + 1] > coords[p2 + 1]) {\n      tmp = p1;\n      p1 = p2;\n      p2 = tmp;\n      tmp = c1;\n      c1 = c2;\n      c2 = tmp;\n    }\n    var x1 = (coords[p1] + context.offsetX) * context.scaleX;\n    var y1 = (coords[p1 + 1] + context.offsetY) * context.scaleY;\n    var x2 = (coords[p2] + context.offsetX) * context.scaleX;\n    var y2 = (coords[p2 + 1] + context.offsetY) * context.scaleY;\n    var x3 = (coords[p3] + context.offsetX) * context.scaleX;\n    var y3 = (coords[p3 + 1] + context.offsetY) * context.scaleY;\n    if (y1 >= y3) {\n      return;\n    }\n    var c1r = colors[c1],\n      c1g = colors[c1 + 1],\n      c1b = colors[c1 + 2];\n    var c2r = colors[c2],\n      c2g = colors[c2 + 1],\n      c2b = colors[c2 + 2];\n    var c3r = colors[c3],\n      c3g = colors[c3 + 1],\n      c3b = colors[c3 + 2];\n\n    var minY = Math.round(y1),\n      maxY = Math.round(y3);\n    var xa, car, cag, cab;\n    var xb, cbr, cbg, cbb;\n    for (var y = minY; y <= maxY; y++) {\n      if (y < y2) {\n        let k;\n        if (y < y1) {\n          k = 0;\n        } else if (y1 === y2) {\n          k = 1;\n        } else {\n          k = (y1 - y) / (y1 - y2);\n        }\n        xa = x1 - (x1 - x2) * k;\n        car = c1r - (c1r - c2r) * k;\n        cag = c1g - (c1g - c2g) * k;\n        cab = c1b - (c1b - c2b) * k;\n      } else {\n        let k;\n        if (y > y3) {\n          k = 1;\n        } else if (y2 === y3) {\n          k = 0;\n        } else {\n          k = (y2 - y) / (y2 - y3);\n        }\n        xa = x2 - (x2 - x3) * k;\n        car = c2r - (c2r - c3r) * k;\n        cag = c2g - (c2g - c3g) * k;\n        cab = c2b - (c2b - c3b) * k;\n      }\n\n      let k;\n      if (y < y1) {\n        k = 0;\n      } else if (y > y3) {\n        k = 1;\n      } else {\n        k = (y1 - y) / (y1 - y3);\n      }\n      xb = x1 - (x1 - x3) * k;\n      cbr = c1r - (c1r - c3r) * k;\n      cbg = c1g - (c1g - c3g) * k;\n      cbb = c1b - (c1b - c3b) * k;\n      var x1_ = Math.round(Math.min(xa, xb));\n      var x2_ = Math.round(Math.max(xa, xb));\n      var j = rowSize * y + x1_ * 4;\n      for (var x = x1_; x <= x2_; x++) {\n        k = (xa - x) / (xa - xb);\n        if (k < 0) {\n          k = 0;\n        } else if (k > 1) {\n          k = 1;\n        }\n        bytes[j++] = (car - (car - cbr) * k) | 0;\n        bytes[j++] = (cag - (cag - cbg) * k) | 0;\n        bytes[j++] = (cab - (cab - cbb) * k) | 0;\n        bytes[j++] = 255;\n      }\n    }\n  }\n\n  function drawFigure(data, figure, context) {\n    var ps = figure.coords;\n    var cs = figure.colors;\n    var i, ii;\n    switch (figure.type) {\n      case \"lattice\":\n        var verticesPerRow = figure.verticesPerRow;\n        var rows = Math.floor(ps.length / verticesPerRow) - 1;\n        var cols = verticesPerRow - 1;\n        for (i = 0; i < rows; i++) {\n          var q = i * verticesPerRow;\n          for (var j = 0; j < cols; j++, q++) {\n            drawTriangle(\n              data,\n              context,\n              ps[q],\n              ps[q + 1],\n              ps[q + verticesPerRow],\n              cs[q],\n              cs[q + 1],\n              cs[q + verticesPerRow]\n            );\n            drawTriangle(\n              data,\n              context,\n              ps[q + verticesPerRow + 1],\n              ps[q + 1],\n              ps[q + verticesPerRow],\n              cs[q + verticesPerRow + 1],\n              cs[q + 1],\n              cs[q + verticesPerRow]\n            );\n          }\n        }\n        break;\n      case \"triangles\":\n        for (i = 0, ii = ps.length; i < ii; i += 3) {\n          drawTriangle(\n            data,\n            context,\n            ps[i],\n            ps[i + 1],\n            ps[i + 2],\n            cs[i],\n            cs[i + 1],\n            cs[i + 2]\n          );\n        }\n        break;\n      default:\n        throw new Error(\"illegal figure\");\n    }\n  }\n\n  // eslint-disable-next-line no-shadow\n  function createMeshCanvas(\n    bounds,\n    combinesScale,\n    coords,\n    colors,\n    figures,\n    backgroundColor,\n    cachedCanvases,\n    webGLContext\n  ) {\n    // we will increase scale on some weird factor to let antialiasing take\n    // care of \"rough\" edges\n    var EXPECTED_SCALE = 1.1;\n    // MAX_PATTERN_SIZE is used to avoid OOM situation.\n    var MAX_PATTERN_SIZE = 3000; // 10in @ 300dpi shall be enough\n    // We need to keep transparent border around our pattern for fill():\n    // createPattern with 'no-repeat' will bleed edges across entire area.\n    var BORDER_SIZE = 2;\n\n    var offsetX = Math.floor(bounds[0]);\n    var offsetY = Math.floor(bounds[1]);\n    var boundsWidth = Math.ceil(bounds[2]) - offsetX;\n    var boundsHeight = Math.ceil(bounds[3]) - offsetY;\n\n    var width = Math.min(\n      Math.ceil(Math.abs(boundsWidth * combinesScale[0] * EXPECTED_SCALE)),\n      MAX_PATTERN_SIZE\n    );\n    var height = Math.min(\n      Math.ceil(Math.abs(boundsHeight * combinesScale[1] * EXPECTED_SCALE)),\n      MAX_PATTERN_SIZE\n    );\n    var scaleX = boundsWidth / width;\n    var scaleY = boundsHeight / height;\n\n    var context = {\n      coords,\n      colors,\n      offsetX: -offsetX,\n      offsetY: -offsetY,\n      scaleX: 1 / scaleX,\n      scaleY: 1 / scaleY,\n    };\n\n    var paddedWidth = width + BORDER_SIZE * 2;\n    var paddedHeight = height + BORDER_SIZE * 2;\n\n    var canvas, tmpCanvas, i, ii;\n    if (webGLContext.isEnabled) {\n      canvas = webGLContext.drawFigures({\n        width,\n        height,\n        backgroundColor,\n        figures,\n        context,\n      });\n      // https://bugzilla.mozilla.org/show_bug.cgi?id=972126\n      tmpCanvas = cachedCanvases.getCanvas(\n        \"mesh\",\n        paddedWidth,\n        paddedHeight,\n        false\n      );\n      tmpCanvas.context.drawImage(canvas, BORDER_SIZE, BORDER_SIZE);\n      canvas = tmpCanvas.canvas;\n    } else {\n      tmpCanvas = cachedCanvases.getCanvas(\n        \"mesh\",\n        paddedWidth,\n        paddedHeight,\n        false\n      );\n      var tmpCtx = tmpCanvas.context;\n\n      var data = tmpCtx.createImageData(width, height);\n      if (backgroundColor) {\n        var bytes = data.data;\n        for (i = 0, ii = bytes.length; i < ii; i += 4) {\n          bytes[i] = backgroundColor[0];\n          bytes[i + 1] = backgroundColor[1];\n          bytes[i + 2] = backgroundColor[2];\n          bytes[i + 3] = 255;\n        }\n      }\n      for (i = 0; i < figures.length; i++) {\n        drawFigure(data, figures[i], context);\n      }\n      tmpCtx.putImageData(data, BORDER_SIZE, BORDER_SIZE);\n      canvas = tmpCanvas.canvas;\n    }\n\n    return {\n      canvas,\n      offsetX: offsetX - BORDER_SIZE * scaleX,\n      offsetY: offsetY - BORDER_SIZE * scaleY,\n      scaleX,\n      scaleY,\n    };\n  }\n  return createMeshCanvas;\n})();\n\nShadingIRs.Mesh = {\n  fromIR: function Mesh_fromIR(raw) {\n    // var type = raw[1];\n    var coords = raw[2];\n    var colors = raw[3];\n    var figures = raw[4];\n    var bounds = raw[5];\n    var matrix = raw[6];\n    var bbox = raw[7];\n    var background = raw[8];\n    return {\n      type: \"Pattern\",\n      getPattern: function Mesh_getPattern(ctx, owner, shadingFill) {\n        applyBoundingBox(ctx, bbox);\n        var scale;\n        if (shadingFill) {\n          scale = Util.singularValueDecompose2dScale(ctx.mozCurrentTransform);\n        } else {\n          // Obtain scale from matrix and current transformation matrix.\n          scale = Util.singularValueDecompose2dScale(owner.baseTransform);\n          if (matrix) {\n            var matrixScale = Util.singularValueDecompose2dScale(matrix);\n            scale = [scale[0] * matrixScale[0], scale[1] * matrixScale[1]];\n          }\n        }\n\n        // Rasterizing on the main thread since sending/queue large canvases\n        // might cause OOM.\n        var temporaryPatternCanvas = createMeshCanvas(\n          bounds,\n          scale,\n          coords,\n          colors,\n          figures,\n          shadingFill ? null : background,\n          owner.cachedCanvases,\n          owner.webGLContext\n        );\n\n        if (!shadingFill) {\n          ctx.setTransform.apply(ctx, owner.baseTransform);\n          if (matrix) {\n            ctx.transform.apply(ctx, matrix);\n          }\n        }\n\n        ctx.translate(\n          temporaryPatternCanvas.offsetX,\n          temporaryPatternCanvas.offsetY\n        );\n        ctx.scale(temporaryPatternCanvas.scaleX, temporaryPatternCanvas.scaleY);\n\n        return ctx.createPattern(temporaryPatternCanvas.canvas, \"no-repeat\");\n      },\n    };\n  },\n};\n\nShadingIRs.Dummy = {\n  fromIR: function Dummy_fromIR() {\n    return {\n      type: \"Pattern\",\n      getPattern: function Dummy_fromIR_getPattern() {\n        return \"hotpink\";\n      },\n    };\n  },\n};\n\nfunction getShadingPatternFromIR(raw) {\n  var shadingIR = ShadingIRs[raw[0]];\n  if (!shadingIR) {\n    throw new Error(`Unknown IR type: ${raw[0]}`);\n  }\n  return shadingIR.fromIR(raw);\n}\n\n/**\n * @type {any}\n */\nvar TilingPattern = (function TilingPatternClosure() {\n  var PaintType = {\n    COLORED: 1,\n    UNCOLORED: 2,\n  };\n\n  var MAX_PATTERN_SIZE = 3000; // 10in @ 300dpi shall be enough\n\n  // eslint-disable-next-line no-shadow\n  function TilingPattern(IR, color, ctx, canvasGraphicsFactory, baseTransform) {\n    this.operatorList = IR[2];\n    this.matrix = IR[3] || [1, 0, 0, 1, 0, 0];\n    this.bbox = IR[4];\n    this.xstep = IR[5];\n    this.ystep = IR[6];\n    this.paintType = IR[7];\n    this.tilingType = IR[8];\n    this.color = color;\n    this.canvasGraphicsFactory = canvasGraphicsFactory;\n    this.baseTransform = baseTransform;\n    this.type = \"Pattern\";\n    this.ctx = ctx;\n  }\n\n  TilingPattern.prototype = {\n    createPatternCanvas: function TilinPattern_createPatternCanvas(owner) {\n      var operatorList = this.operatorList;\n      var bbox = this.bbox;\n      var xstep = this.xstep;\n      var ystep = this.ystep;\n      var paintType = this.paintType;\n      var tilingType = this.tilingType;\n      var color = this.color;\n      var canvasGraphicsFactory = this.canvasGraphicsFactory;\n\n      info(\"TilingType: \" + tilingType);\n\n      // A tiling pattern as defined by PDF spec 8.7.2 is a cell whose size is\n      // described by bbox, and may repeat regularly by shifting the cell by\n      // xstep and ystep.\n      // Because the HTML5 canvas API does not support pattern repetition with\n      // gaps in between, we use the xstep/ystep instead of the bbox's size.\n      //\n      // This has the following consequences (similarly for ystep):\n      //\n      // - If xstep is the same as bbox, then there is no observable difference.\n      //\n      // - If xstep is larger than bbox, then the pattern canvas is partially\n      //   empty: the area bounded by bbox is painted, the outside area is void.\n      //\n      // - If xstep is smaller than bbox, then the pixels between xstep and the\n      //   bbox boundary will be missing. This is INCORRECT behavior.\n      //   \"Figures on adjacent tiles should not overlap\" (PDF spec 8.7.3.1),\n      //   but overlapping cells without common pixels are still valid.\n      //   TODO: Fix the implementation, to allow this scenario to be painted\n      //   correctly.\n\n      var x0 = bbox[0],\n        y0 = bbox[1],\n        x1 = bbox[2],\n        y1 = bbox[3];\n\n      // Obtain scale from matrix and current transformation matrix.\n      var matrixScale = Util.singularValueDecompose2dScale(this.matrix);\n      var curMatrixScale = Util.singularValueDecompose2dScale(\n        this.baseTransform\n      );\n      var combinedScale = [\n        matrixScale[0] * curMatrixScale[0],\n        matrixScale[1] * curMatrixScale[1],\n      ];\n\n      // Use width and height values that are as close as possible to the end\n      // result when the pattern is used. Too low value makes the pattern look\n      // blurry. Too large value makes it look too crispy.\n      var dimx = this.getSizeAndScale(\n        xstep,\n        this.ctx.canvas.width,\n        combinedScale[0]\n      );\n      var dimy = this.getSizeAndScale(\n        ystep,\n        this.ctx.canvas.height,\n        combinedScale[1]\n      );\n\n      var tmpCanvas = owner.cachedCanvases.getCanvas(\n        \"pattern\",\n        dimx.size,\n        dimy.size,\n        true\n      );\n      var tmpCtx = tmpCanvas.context;\n      var graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx);\n      graphics.groupLevel = owner.groupLevel;\n\n      this.setFillAndStrokeStyleToContext(graphics, paintType, color);\n\n      graphics.transform(dimx.scale, 0, 0, dimy.scale, 0, 0);\n\n      // transform coordinates to pattern space\n      graphics.transform(1, 0, 0, 1, -x0, -y0);\n\n      this.clipBbox(graphics, bbox, x0, y0, x1, y1);\n\n      graphics.executeOperatorList(operatorList);\n\n      this.ctx.transform(1, 0, 0, 1, x0, y0);\n\n      // Rescale canvas so that the ctx.createPattern call generates a pattern\n      // with the desired size.\n      this.ctx.scale(1 / dimx.scale, 1 / dimy.scale);\n      return tmpCanvas.canvas;\n    },\n\n    getSizeAndScale: function TilingPattern_getSizeAndScale(\n      step,\n      realOutputSize,\n      scale\n    ) {\n      // xstep / ystep may be negative -- normalize.\n      step = Math.abs(step);\n      // MAX_PATTERN_SIZE is used to avoid OOM situation.\n      // Use the destination canvas's size if it is bigger than the hard-coded\n      // limit of MAX_PATTERN_SIZE to avoid clipping patterns that cover the\n      // whole canvas.\n      var maxSize = Math.max(MAX_PATTERN_SIZE, realOutputSize);\n      var size = Math.ceil(step * scale);\n      if (size >= maxSize) {\n        size = maxSize;\n      } else {\n        scale = size / step;\n      }\n      return { scale, size };\n    },\n\n    clipBbox: function clipBbox(graphics, bbox, x0, y0, x1, y1) {\n      if (Array.isArray(bbox) && bbox.length === 4) {\n        var bboxWidth = x1 - x0;\n        var bboxHeight = y1 - y0;\n        graphics.ctx.rect(x0, y0, bboxWidth, bboxHeight);\n        graphics.clip();\n        graphics.endPath();\n      }\n    },\n\n    setFillAndStrokeStyleToContext: function setFillAndStrokeStyleToContext(\n      graphics,\n      paintType,\n      color\n    ) {\n      const context = graphics.ctx,\n        current = graphics.current;\n      switch (paintType) {\n        case PaintType.COLORED:\n          var ctx = this.ctx;\n          context.fillStyle = ctx.fillStyle;\n          context.strokeStyle = ctx.strokeStyle;\n          current.fillColor = ctx.fillStyle;\n          current.strokeColor = ctx.strokeStyle;\n          break;\n        case PaintType.UNCOLORED:\n          var cssColor = Util.makeCssRgb(color[0], color[1], color[2]);\n          context.fillStyle = cssColor;\n          context.strokeStyle = cssColor;\n          // Set color needed by image masks (fixes issues 3226 and 8741).\n          current.fillColor = cssColor;\n          current.strokeColor = cssColor;\n          break;\n        default:\n          throw new FormatError(`Unsupported paint type: ${paintType}`);\n      }\n    },\n\n    getPattern: function TilingPattern_getPattern(ctx, owner) {\n      ctx = this.ctx;\n      // PDF spec 8.7.2 NOTE 1: pattern's matrix is relative to initial matrix.\n      ctx.setTransform.apply(ctx, this.baseTransform);\n      ctx.transform.apply(ctx, this.matrix);\n\n      var temporaryPatternCanvas = this.createPatternCanvas(owner);\n\n      return ctx.createPattern(temporaryPatternCanvas, \"repeat\");\n    },\n  };\n\n  return TilingPattern;\n})();\n\nexport { getShadingPatternFromIR, TilingPattern };\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @typedef {Object} GlobalWorkerOptionsType\n * @property {Worker | null} workerPort - Defines global port for worker\n *   process. Overrides the `workerSrc` option.\n * @property {string} workerSrc - A string containing the path and filename\n *   of the worker file.\n *\n *   NOTE: The `workerSrc` option should always be set, in order to prevent any\n *         issues when using the PDF.js library.\n */\n\n/** @type {GlobalWorkerOptionsType} */\nconst GlobalWorkerOptions = Object.create(null);\n\nGlobalWorkerOptions.workerPort =\n  GlobalWorkerOptions.workerPort === undefined\n    ? null\n    : GlobalWorkerOptions.workerPort;\n\nGlobalWorkerOptions.workerSrc =\n  GlobalWorkerOptions.workerSrc === undefined\n    ? \"\"\n    : GlobalWorkerOptions.workerSrc;\n\nexport { GlobalWorkerOptions };\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error, prefer-const: error */\n\nimport {\n  AbortException,\n  assert,\n  createPromiseCapability,\n  MissingPDFException,\n  UnexpectedResponseException,\n  UnknownErrorException,\n} from \"./util.js\";\n\nconst CallbackKind = {\n  UNKNOWN: 0,\n  DATA: 1,\n  ERROR: 2,\n};\n\nconst StreamKind = {\n  UNKNOWN: 0,\n  CANCEL: 1,\n  CANCEL_COMPLETE: 2,\n  CLOSE: 3,\n  ENQUEUE: 4,\n  ERROR: 5,\n  PULL: 6,\n  PULL_COMPLETE: 7,\n  START_COMPLETE: 8,\n};\n\nfunction wrapReason(reason) {\n  if (\n    typeof PDFJSDev === \"undefined\" ||\n    PDFJSDev.test(\"!PRODUCTION || TESTING\")\n  ) {\n    assert(\n      reason instanceof Error ||\n        (typeof reason === \"object\" && reason !== null),\n      'wrapReason: Expected \"reason\" to be a (possibly cloned) Error.'\n    );\n  } else {\n    if (typeof reason !== \"object\" || reason === null) {\n      return reason;\n    }\n  }\n  switch (reason.name) {\n    case \"AbortException\":\n      return new AbortException(reason.message);\n    case \"MissingPDFException\":\n      return new MissingPDFException(reason.message);\n    case \"UnexpectedResponseException\":\n      return new UnexpectedResponseException(reason.message, reason.status);\n    case \"UnknownErrorException\":\n      return new UnknownErrorException(reason.message, reason.details);\n    default:\n      return new UnknownErrorException(reason.message, reason.toString());\n  }\n}\n\nclass MessageHandler {\n  constructor(sourceName, targetName, comObj) {\n    this.sourceName = sourceName;\n    this.targetName = targetName;\n    this.comObj = comObj;\n    this.callbackId = 1;\n    this.streamId = 1;\n    this.postMessageTransfers = true;\n    this.streamSinks = Object.create(null);\n    this.streamControllers = Object.create(null);\n    this.callbackCapabilities = Object.create(null);\n    this.actionHandler = Object.create(null);\n\n    this._onComObjOnMessage = event => {\n      const data = event.data;\n      if (data.targetName !== this.sourceName) {\n        return;\n      }\n      if (data.stream) {\n        this._processStreamMessage(data);\n        return;\n      }\n      if (data.callback) {\n        const callbackId = data.callbackId;\n        const capability = this.callbackCapabilities[callbackId];\n        if (!capability) {\n          throw new Error(`Cannot resolve callback ${callbackId}`);\n        }\n        delete this.callbackCapabilities[callbackId];\n\n        if (data.callback === CallbackKind.DATA) {\n          capability.resolve(data.data);\n        } else if (data.callback === CallbackKind.ERROR) {\n          capability.reject(wrapReason(data.reason));\n        } else {\n          throw new Error(\"Unexpected callback case\");\n        }\n        return;\n      }\n      const action = this.actionHandler[data.action];\n      if (!action) {\n        throw new Error(`Unknown action from worker: ${data.action}`);\n      }\n      if (data.callbackId) {\n        const cbSourceName = this.sourceName;\n        const cbTargetName = data.sourceName;\n        new Promise(function (resolve) {\n          resolve(action(data.data));\n        }).then(\n          function (result) {\n            comObj.postMessage({\n              sourceName: cbSourceName,\n              targetName: cbTargetName,\n              callback: CallbackKind.DATA,\n              callbackId: data.callbackId,\n              data: result,\n            });\n          },\n          function (reason) {\n            comObj.postMessage({\n              sourceName: cbSourceName,\n              targetName: cbTargetName,\n              callback: CallbackKind.ERROR,\n              callbackId: data.callbackId,\n              reason: wrapReason(reason),\n            });\n          }\n        );\n        return;\n      }\n      if (data.streamId) {\n        this._createStreamSink(data);\n        return;\n      }\n      action(data.data);\n    };\n    comObj.addEventListener(\"message\", this._onComObjOnMessage);\n  }\n\n  on(actionName, handler) {\n    if (\n      typeof PDFJSDev === \"undefined\" ||\n      PDFJSDev.test(\"!PRODUCTION || TESTING\")\n    ) {\n      assert(\n        typeof handler === \"function\",\n        'MessageHandler.on: Expected \"handler\" to be a function.'\n      );\n    }\n    const ah = this.actionHandler;\n    if (ah[actionName]) {\n      throw new Error(`There is already an actionName called \"${actionName}\"`);\n    }\n    ah[actionName] = handler;\n  }\n\n  /**\n   * Sends a message to the comObj to invoke the action with the supplied data.\n   * @param {string} actionName - Action to call.\n   * @param {JSON} data - JSON data to send.\n   * @param {Array} [transfers] - List of transfers/ArrayBuffers.\n   */\n  send(actionName, data, transfers) {\n    this._postMessage(\n      {\n        sourceName: this.sourceName,\n        targetName: this.targetName,\n        action: actionName,\n        data,\n      },\n      transfers\n    );\n  }\n\n  /**\n   * Sends a message to the comObj to invoke the action with the supplied data.\n   * Expects that the other side will callback with the response.\n   * @param {string} actionName - Action to call.\n   * @param {JSON} data - JSON data to send.\n   * @param {Array} [transfers] - List of transfers/ArrayBuffers.\n   * @returns {Promise} Promise to be resolved with response data.\n   */\n  sendWithPromise(actionName, data, transfers) {\n    const callbackId = this.callbackId++;\n    const capability = createPromiseCapability();\n    this.callbackCapabilities[callbackId] = capability;\n    try {\n      this._postMessage(\n        {\n          sourceName: this.sourceName,\n          targetName: this.targetName,\n          action: actionName,\n          callbackId,\n          data,\n        },\n        transfers\n      );\n    } catch (ex) {\n      capability.reject(ex);\n    }\n    return capability.promise;\n  }\n\n  /**\n   * Sends a message to the comObj to invoke the action with the supplied data.\n   * Expect that the other side will callback to signal 'start_complete'.\n   * @param {string} actionName - Action to call.\n   * @param {JSON} data - JSON data to send.\n   * @param {Object} queueingStrategy - Strategy to signal backpressure based on\n   *                 internal queue.\n   * @param {Array} [transfers] - List of transfers/ArrayBuffers.\n   * @returns {ReadableStream} ReadableStream to read data in chunks.\n   */\n  sendWithStream(actionName, data, queueingStrategy, transfers) {\n    const streamId = this.streamId++;\n    const sourceName = this.sourceName;\n    const targetName = this.targetName;\n    const comObj = this.comObj;\n\n    return new ReadableStream(\n      {\n        start: controller => {\n          const startCapability = createPromiseCapability();\n          this.streamControllers[streamId] = {\n            controller,\n            startCall: startCapability,\n            pullCall: null,\n            cancelCall: null,\n            isClosed: false,\n          };\n          this._postMessage(\n            {\n              sourceName,\n              targetName,\n              action: actionName,\n              streamId,\n              data,\n              desiredSize: controller.desiredSize,\n            },\n            transfers\n          );\n          // Return Promise for Async process, to signal success/failure.\n          return startCapability.promise;\n        },\n\n        pull: controller => {\n          const pullCapability = createPromiseCapability();\n          this.streamControllers[streamId].pullCall = pullCapability;\n          comObj.postMessage({\n            sourceName,\n            targetName,\n            stream: StreamKind.PULL,\n            streamId,\n            desiredSize: controller.desiredSize,\n          });\n          // Returning Promise will not call \"pull\"\n          // again until current pull is resolved.\n          return pullCapability.promise;\n        },\n\n        cancel: reason => {\n          assert(reason instanceof Error, \"cancel must have a valid reason\");\n          const cancelCapability = createPromiseCapability();\n          this.streamControllers[streamId].cancelCall = cancelCapability;\n          this.streamControllers[streamId].isClosed = true;\n          comObj.postMessage({\n            sourceName,\n            targetName,\n            stream: StreamKind.CANCEL,\n            streamId,\n            reason: wrapReason(reason),\n          });\n          // Return Promise to signal success or failure.\n          return cancelCapability.promise;\n        },\n      },\n      queueingStrategy\n    );\n  }\n\n  /**\n   * @private\n   */\n  _createStreamSink(data) {\n    const self = this;\n    const action = this.actionHandler[data.action];\n    const streamId = data.streamId;\n    const sourceName = this.sourceName;\n    const targetName = data.sourceName;\n    const comObj = this.comObj;\n\n    const streamSink = {\n      enqueue(chunk, size = 1, transfers) {\n        if (this.isCancelled) {\n          return;\n        }\n        const lastDesiredSize = this.desiredSize;\n        this.desiredSize -= size;\n        // Enqueue decreases the desiredSize property of sink,\n        // so when it changes from positive to negative,\n        // set ready as unresolved promise.\n        if (lastDesiredSize > 0 && this.desiredSize <= 0) {\n          this.sinkCapability = createPromiseCapability();\n          this.ready = this.sinkCapability.promise;\n        }\n        self._postMessage(\n          {\n            sourceName,\n            targetName,\n            stream: StreamKind.ENQUEUE,\n            streamId,\n            chunk,\n          },\n          transfers\n        );\n      },\n\n      close() {\n        if (this.isCancelled) {\n          return;\n        }\n        this.isCancelled = true;\n        comObj.postMessage({\n          sourceName,\n          targetName,\n          stream: StreamKind.CLOSE,\n          streamId,\n        });\n        delete self.streamSinks[streamId];\n      },\n\n      error(reason) {\n        assert(reason instanceof Error, \"error must have a valid reason\");\n        if (this.isCancelled) {\n          return;\n        }\n        this.isCancelled = true;\n        comObj.postMessage({\n          sourceName,\n          targetName,\n          stream: StreamKind.ERROR,\n          streamId,\n          reason: wrapReason(reason),\n        });\n      },\n\n      sinkCapability: createPromiseCapability(),\n      onPull: null,\n      onCancel: null,\n      isCancelled: false,\n      desiredSize: data.desiredSize,\n      ready: null,\n    };\n\n    streamSink.sinkCapability.resolve();\n    streamSink.ready = streamSink.sinkCapability.promise;\n    this.streamSinks[streamId] = streamSink;\n    new Promise(function (resolve) {\n      resolve(action(data.data, streamSink));\n    }).then(\n      function () {\n        comObj.postMessage({\n          sourceName,\n          targetName,\n          stream: StreamKind.START_COMPLETE,\n          streamId,\n          success: true,\n        });\n      },\n      function (reason) {\n        comObj.postMessage({\n          sourceName,\n          targetName,\n          stream: StreamKind.START_COMPLETE,\n          streamId,\n          reason: wrapReason(reason),\n        });\n      }\n    );\n  }\n\n  /**\n   * @private\n   */\n  _processStreamMessage(data) {\n    const streamId = data.streamId;\n    const sourceName = this.sourceName;\n    const targetName = data.sourceName;\n    const comObj = this.comObj;\n\n    switch (data.stream) {\n      case StreamKind.START_COMPLETE:\n        if (data.success) {\n          this.streamControllers[streamId].startCall.resolve();\n        } else {\n          this.streamControllers[streamId].startCall.reject(\n            wrapReason(data.reason)\n          );\n        }\n        break;\n      case StreamKind.PULL_COMPLETE:\n        if (data.success) {\n          this.streamControllers[streamId].pullCall.resolve();\n        } else {\n          this.streamControllers[streamId].pullCall.reject(\n            wrapReason(data.reason)\n          );\n        }\n        break;\n      case StreamKind.PULL:\n        // Ignore any pull after close is called.\n        if (!this.streamSinks[streamId]) {\n          comObj.postMessage({\n            sourceName,\n            targetName,\n            stream: StreamKind.PULL_COMPLETE,\n            streamId,\n            success: true,\n          });\n          break;\n        }\n        // Pull increases the desiredSize property of sink,\n        // so when it changes from negative to positive,\n        // set ready property as resolved promise.\n        if (\n          this.streamSinks[streamId].desiredSize <= 0 &&\n          data.desiredSize > 0\n        ) {\n          this.streamSinks[streamId].sinkCapability.resolve();\n        }\n        // Reset desiredSize property of sink on every pull.\n        this.streamSinks[streamId].desiredSize = data.desiredSize;\n        const { onPull } = this.streamSinks[data.streamId];\n        new Promise(function (resolve) {\n          resolve(onPull && onPull());\n        }).then(\n          function () {\n            comObj.postMessage({\n              sourceName,\n              targetName,\n              stream: StreamKind.PULL_COMPLETE,\n              streamId,\n              success: true,\n            });\n          },\n          function (reason) {\n            comObj.postMessage({\n              sourceName,\n              targetName,\n              stream: StreamKind.PULL_COMPLETE,\n              streamId,\n              reason: wrapReason(reason),\n            });\n          }\n        );\n        break;\n      case StreamKind.ENQUEUE:\n        assert(\n          this.streamControllers[streamId],\n          \"enqueue should have stream controller\"\n        );\n        if (this.streamControllers[streamId].isClosed) {\n          break;\n        }\n        this.streamControllers[streamId].controller.enqueue(data.chunk);\n        break;\n      case StreamKind.CLOSE:\n        assert(\n          this.streamControllers[streamId],\n          \"close should have stream controller\"\n        );\n        if (this.streamControllers[streamId].isClosed) {\n          break;\n        }\n        this.streamControllers[streamId].isClosed = true;\n        this.streamControllers[streamId].controller.close();\n        this._deleteStreamController(streamId);\n        break;\n      case StreamKind.ERROR:\n        assert(\n          this.streamControllers[streamId],\n          \"error should have stream controller\"\n        );\n        this.streamControllers[streamId].controller.error(\n          wrapReason(data.reason)\n        );\n        this._deleteStreamController(streamId);\n        break;\n      case StreamKind.CANCEL_COMPLETE:\n        if (data.success) {\n          this.streamControllers[streamId].cancelCall.resolve();\n        } else {\n          this.streamControllers[streamId].cancelCall.reject(\n            wrapReason(data.reason)\n          );\n        }\n        this._deleteStreamController(streamId);\n        break;\n      case StreamKind.CANCEL:\n        if (!this.streamSinks[streamId]) {\n          break;\n        }\n        const { onCancel } = this.streamSinks[data.streamId];\n        new Promise(function (resolve) {\n          resolve(onCancel && onCancel(wrapReason(data.reason)));\n        }).then(\n          function () {\n            comObj.postMessage({\n              sourceName,\n              targetName,\n              stream: StreamKind.CANCEL_COMPLETE,\n              streamId,\n              success: true,\n            });\n          },\n          function (reason) {\n            comObj.postMessage({\n              sourceName,\n              targetName,\n              stream: StreamKind.CANCEL_COMPLETE,\n              streamId,\n              reason: wrapReason(reason),\n            });\n          }\n        );\n        this.streamSinks[streamId].sinkCapability.reject(\n          wrapReason(data.reason)\n        );\n        this.streamSinks[streamId].isCancelled = true;\n        delete this.streamSinks[streamId];\n        break;\n      default:\n        throw new Error(\"Unexpected stream case\");\n    }\n  }\n\n  /**\n   * @private\n   */\n  async _deleteStreamController(streamId) {\n    // Delete the `streamController` only when the start, pull, and cancel\n    // capabilities have settled, to prevent `TypeError`s.\n    await Promise.allSettled(\n      [\n        this.streamControllers[streamId].startCall,\n        this.streamControllers[streamId].pullCall,\n        this.streamControllers[streamId].cancelCall,\n      ].map(function (capability) {\n        return capability && capability.promise;\n      })\n    );\n    delete this.streamControllers[streamId];\n  }\n\n  /**\n   * Sends raw message to the comObj.\n   * @param {Object} message - Raw message.\n   * @param transfers List of transfers/ArrayBuffers, or undefined.\n   * @private\n   */\n  _postMessage(message, transfers) {\n    if (transfers && this.postMessageTransfers) {\n      this.comObj.postMessage(message, transfers);\n    } else {\n      this.comObj.postMessage(message);\n    }\n  }\n\n  destroy() {\n    this.comObj.removeEventListener(\"message\", this._onComObjOnMessage);\n  }\n}\n\nexport { MessageHandler };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { assert } from \"../shared/util.js\";\nimport { SimpleXMLParser } from \"./xml_parser.js\";\n\nclass Metadata {\n  constructor(data) {\n    assert(typeof data === \"string\", \"Metadata: input is not a string\");\n\n    // Ghostscript may produce invalid metadata, so try to repair that first.\n    data = this._repair(data);\n\n    // Convert the string to an XML document.\n    const parser = new SimpleXMLParser();\n    const xmlDocument = parser.parseFromString(data);\n\n    this._metadataMap = new Map();\n\n    if (xmlDocument) {\n      this._parse(xmlDocument);\n    }\n  }\n\n  _repair(data) {\n    // Start by removing any \"junk\" before the first tag (see issue 10395).\n    return data\n      .replace(/^[^<]+/, \"\")\n      .replace(/>\\\\376\\\\377([^<]+)/g, function (all, codes) {\n        const bytes = codes\n          .replace(/\\\\([0-3])([0-7])([0-7])/g, function (code, d1, d2, d3) {\n            return String.fromCharCode(d1 * 64 + d2 * 8 + d3 * 1);\n          })\n          .replace(/&(amp|apos|gt|lt|quot);/g, function (str, name) {\n            switch (name) {\n              case \"amp\":\n                return \"&\";\n              case \"apos\":\n                return \"'\";\n              case \"gt\":\n                return \">\";\n              case \"lt\":\n                return \"<\";\n              case \"quot\":\n                return '\"';\n            }\n            throw new Error(`_repair: ${name} isn't defined.`);\n          });\n\n        let chars = \"\";\n        for (let i = 0, ii = bytes.length; i < ii; i += 2) {\n          const code = bytes.charCodeAt(i) * 256 + bytes.charCodeAt(i + 1);\n          if (\n            code >= /* Space = */ 32 &&\n            code < /* Delete = */ 127 &&\n            code !== /* '<' = */ 60 &&\n            code !== /* '>' = */ 62 &&\n            code !== /* '&' = */ 38\n          ) {\n            chars += String.fromCharCode(code);\n          } else {\n            chars += \"&#x\" + (0x10000 + code).toString(16).substring(1) + \";\";\n          }\n        }\n\n        return \">\" + chars;\n      });\n  }\n\n  _parse(xmlDocument) {\n    let rdf = xmlDocument.documentElement;\n\n    if (rdf.nodeName.toLowerCase() !== \"rdf:rdf\") {\n      // Wrapped in <xmpmeta>\n      rdf = rdf.firstChild;\n      while (rdf && rdf.nodeName.toLowerCase() !== \"rdf:rdf\") {\n        rdf = rdf.nextSibling;\n      }\n    }\n\n    const nodeName = rdf ? rdf.nodeName.toLowerCase() : null;\n    if (!rdf || nodeName !== \"rdf:rdf\" || !rdf.hasChildNodes()) {\n      return;\n    }\n\n    const children = rdf.childNodes;\n    for (let i = 0, ii = children.length; i < ii; i++) {\n      const desc = children[i];\n      if (desc.nodeName.toLowerCase() !== \"rdf:description\") {\n        continue;\n      }\n\n      for (let j = 0, jj = desc.childNodes.length; j < jj; j++) {\n        if (desc.childNodes[j].nodeName.toLowerCase() !== \"#text\") {\n          const entry = desc.childNodes[j];\n          const name = entry.nodeName.toLowerCase();\n\n          this._metadataMap.set(name, entry.textContent.trim());\n        }\n      }\n    }\n  }\n\n  get(name) {\n    return this._metadataMap.has(name) ? this._metadataMap.get(name) : null;\n  }\n\n  getAll() {\n    return Object.fromEntries(this._metadataMap);\n  }\n\n  has(name) {\n    return this._metadataMap.has(name);\n  }\n}\n\nexport { Metadata };\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// The code for XMLParserBase copied from\n// https://github.com/mozilla/shumway/blob/16451d8836fa85f4b16eeda8b4bda2fa9e2b22b0/src/avm2/natives/xml.ts\n\nconst XMLParserErrorCode = {\n  NoError: 0,\n  EndOfDocument: -1,\n  UnterminatedCdat: -2,\n  UnterminatedXmlDeclaration: -3,\n  UnterminatedDoctypeDeclaration: -4,\n  UnterminatedComment: -5,\n  MalformedElement: -6,\n  OutOfMemory: -7,\n  UnterminatedAttributeValue: -8,\n  UnterminatedElement: -9,\n  ElementNeverBegun: -10,\n};\n\nfunction isWhitespace(s, index) {\n  const ch = s[index];\n  return ch === \" \" || ch === \"\\n\" || ch === \"\\r\" || ch === \"\\t\";\n}\n\nfunction isWhitespaceString(s) {\n  for (let i = 0, ii = s.length; i < ii; i++) {\n    if (!isWhitespace(s, i)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nclass XMLParserBase {\n  _resolveEntities(s) {\n    return s.replace(/&([^;]+);/g, (all, entity) => {\n      if (entity.substring(0, 2) === \"#x\") {\n        return String.fromCharCode(parseInt(entity.substring(2), 16));\n      } else if (entity.substring(0, 1) === \"#\") {\n        return String.fromCharCode(parseInt(entity.substring(1), 10));\n      }\n      switch (entity) {\n        case \"lt\":\n          return \"<\";\n        case \"gt\":\n          return \">\";\n        case \"amp\":\n          return \"&\";\n        case \"quot\":\n          return '\"';\n      }\n      return this.onResolveEntity(entity);\n    });\n  }\n\n  _parseContent(s, start) {\n    const attributes = [];\n    let pos = start;\n\n    function skipWs() {\n      while (pos < s.length && isWhitespace(s, pos)) {\n        ++pos;\n      }\n    }\n\n    while (\n      pos < s.length &&\n      !isWhitespace(s, pos) &&\n      s[pos] !== \">\" &&\n      s[pos] !== \"/\"\n    ) {\n      ++pos;\n    }\n    const name = s.substring(start, pos);\n    skipWs();\n    while (\n      pos < s.length &&\n      s[pos] !== \">\" &&\n      s[pos] !== \"/\" &&\n      s[pos] !== \"?\"\n    ) {\n      skipWs();\n      let attrName = \"\",\n        attrValue = \"\";\n      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== \"=\") {\n        attrName += s[pos];\n        ++pos;\n      }\n      skipWs();\n      if (s[pos] !== \"=\") {\n        return null;\n      }\n      ++pos;\n      skipWs();\n      const attrEndChar = s[pos];\n      if (attrEndChar !== '\"' && attrEndChar !== \"'\") {\n        return null;\n      }\n      const attrEndIndex = s.indexOf(attrEndChar, ++pos);\n      if (attrEndIndex < 0) {\n        return null;\n      }\n      attrValue = s.substring(pos, attrEndIndex);\n      attributes.push({\n        name: attrName,\n        value: this._resolveEntities(attrValue),\n      });\n      pos = attrEndIndex + 1;\n      skipWs();\n    }\n    return {\n      name,\n      attributes,\n      parsed: pos - start,\n    };\n  }\n\n  _parseProcessingInstruction(s, start) {\n    let pos = start;\n\n    function skipWs() {\n      while (pos < s.length && isWhitespace(s, pos)) {\n        ++pos;\n      }\n    }\n\n    while (\n      pos < s.length &&\n      !isWhitespace(s, pos) &&\n      s[pos] !== \">\" &&\n      s[pos] !== \"/\"\n    ) {\n      ++pos;\n    }\n    const name = s.substring(start, pos);\n    skipWs();\n    const attrStart = pos;\n    while (pos < s.length && (s[pos] !== \"?\" || s[pos + 1] !== \">\")) {\n      ++pos;\n    }\n    const value = s.substring(attrStart, pos);\n    return {\n      name,\n      value,\n      parsed: pos - start,\n    };\n  }\n\n  parseXml(s) {\n    let i = 0;\n    while (i < s.length) {\n      const ch = s[i];\n      let j = i;\n      if (ch === \"<\") {\n        ++j;\n        const ch2 = s[j];\n        let q;\n        switch (ch2) {\n          case \"/\":\n            ++j;\n            q = s.indexOf(\">\", j);\n            if (q < 0) {\n              this.onError(XMLParserErrorCode.UnterminatedElement);\n              return;\n            }\n            this.onEndElement(s.substring(j, q));\n            j = q + 1;\n            break;\n          case \"?\":\n            ++j;\n            const pi = this._parseProcessingInstruction(s, j);\n            if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== \"?>\") {\n              this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration);\n              return;\n            }\n            this.onPi(pi.name, pi.value);\n            j += pi.parsed + 2;\n            break;\n          case \"!\":\n            if (s.substring(j + 1, j + 3) === \"--\") {\n              q = s.indexOf(\"-->\", j + 3);\n              if (q < 0) {\n                this.onError(XMLParserErrorCode.UnterminatedComment);\n                return;\n              }\n              this.onComment(s.substring(j + 3, q));\n              j = q + 3;\n            } else if (s.substring(j + 1, j + 8) === \"[CDATA[\") {\n              q = s.indexOf(\"]]>\", j + 8);\n              if (q < 0) {\n                this.onError(XMLParserErrorCode.UnterminatedCdat);\n                return;\n              }\n              this.onCdata(s.substring(j + 8, q));\n              j = q + 3;\n            } else if (s.substring(j + 1, j + 8) === \"DOCTYPE\") {\n              const q2 = s.indexOf(\"[\", j + 8);\n              let complexDoctype = false;\n              q = s.indexOf(\">\", j + 8);\n              if (q < 0) {\n                this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);\n                return;\n              }\n              if (q2 > 0 && q > q2) {\n                q = s.indexOf(\"]>\", j + 8);\n                if (q < 0) {\n                  this.onError(\n                    XMLParserErrorCode.UnterminatedDoctypeDeclaration\n                  );\n                  return;\n                }\n                complexDoctype = true;\n              }\n              const doctypeContent = s.substring(\n                j + 8,\n                q + (complexDoctype ? 1 : 0)\n              );\n              this.onDoctype(doctypeContent);\n              j = q + (complexDoctype ? 2 : 1);\n            } else {\n              this.onError(XMLParserErrorCode.MalformedElement);\n              return;\n            }\n            break;\n          default:\n            const content = this._parseContent(s, j);\n            if (content === null) {\n              this.onError(XMLParserErrorCode.MalformedElement);\n              return;\n            }\n            let isClosed = false;\n            if (\n              s.substring(j + content.parsed, j + content.parsed + 2) === \"/>\"\n            ) {\n              isClosed = true;\n            } else if (\n              s.substring(j + content.parsed, j + content.parsed + 1) !== \">\"\n            ) {\n              this.onError(XMLParserErrorCode.UnterminatedElement);\n              return;\n            }\n            this.onBeginElement(content.name, content.attributes, isClosed);\n            j += content.parsed + (isClosed ? 2 : 1);\n            break;\n        }\n      } else {\n        while (j < s.length && s[j] !== \"<\") {\n          j++;\n        }\n        const text = s.substring(i, j);\n        this.onText(this._resolveEntities(text));\n      }\n      i = j;\n    }\n  }\n\n  onResolveEntity(name) {\n    return `&${name};`;\n  }\n\n  onPi(name, value) {}\n\n  onComment(text) {}\n\n  onCdata(text) {}\n\n  onDoctype(doctypeContent) {}\n\n  onText(text) {}\n\n  onBeginElement(name, attributes, isEmpty) {}\n\n  onEndElement(name) {}\n\n  onError(code) {}\n}\n\nclass SimpleDOMNode {\n  constructor(nodeName, nodeValue) {\n    this.nodeName = nodeName;\n    this.nodeValue = nodeValue;\n\n    Object.defineProperty(this, \"parentNode\", { value: null, writable: true });\n  }\n\n  get firstChild() {\n    return this.childNodes && this.childNodes[0];\n  }\n\n  get nextSibling() {\n    const childNodes = this.parentNode.childNodes;\n    if (!childNodes) {\n      return undefined;\n    }\n    const index = childNodes.indexOf(this);\n    if (index === -1) {\n      return undefined;\n    }\n    return childNodes[index + 1];\n  }\n\n  get textContent() {\n    if (!this.childNodes) {\n      return this.nodeValue || \"\";\n    }\n    return this.childNodes\n      .map(function (child) {\n        return child.textContent;\n      })\n      .join(\"\");\n  }\n\n  hasChildNodes() {\n    return this.childNodes && this.childNodes.length > 0;\n  }\n}\n\nclass SimpleXMLParser extends XMLParserBase {\n  constructor() {\n    super();\n    this._currentFragment = null;\n    this._stack = null;\n    this._errorCode = XMLParserErrorCode.NoError;\n  }\n\n  parseFromString(data) {\n    this._currentFragment = [];\n    this._stack = [];\n    this._errorCode = XMLParserErrorCode.NoError;\n\n    this.parseXml(data);\n\n    if (this._errorCode !== XMLParserErrorCode.NoError) {\n      return undefined; // return undefined on error\n    }\n\n    // We should only have one root.\n    const [documentElement] = this._currentFragment;\n    if (!documentElement) {\n      return undefined; // Return undefined if no root was found.\n    }\n    return { documentElement };\n  }\n\n  onResolveEntity(name) {\n    switch (name) {\n      case \"apos\":\n        return \"'\";\n    }\n    return super.onResolveEntity(name);\n  }\n\n  onText(text) {\n    if (isWhitespaceString(text)) {\n      return;\n    }\n    const node = new SimpleDOMNode(\"#text\", text);\n    this._currentFragment.push(node);\n  }\n\n  onCdata(text) {\n    const node = new SimpleDOMNode(\"#text\", text);\n    this._currentFragment.push(node);\n  }\n\n  onBeginElement(name, attributes, isEmpty) {\n    const node = new SimpleDOMNode(name);\n    node.childNodes = [];\n    this._currentFragment.push(node);\n    if (isEmpty) {\n      return;\n    }\n    this._stack.push(this._currentFragment);\n    this._currentFragment = node.childNodes;\n  }\n\n  onEndElement(name) {\n    this._currentFragment = this._stack.pop() || [];\n    const lastElement = this._currentFragment[this._currentFragment.length - 1];\n    if (!lastElement) {\n      return;\n    }\n    for (let i = 0, ii = lastElement.childNodes.length; i < ii; i++) {\n      lastElement.childNodes[i].parentNode = lastElement;\n    }\n  }\n\n  onError(code) {\n    this._errorCode = code;\n  }\n}\n\nexport { SimpleXMLParser };\n","/* Copyright 2020 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { warn } from \"../shared/util.js\";\n\nclass OptionalContentGroup {\n  constructor(name, intent) {\n    this.visible = true;\n    this.name = name;\n    this.intent = intent;\n  }\n}\n\nclass OptionalContentConfig {\n  constructor(data) {\n    this.name = null;\n    this.creator = null;\n    this._order = null;\n    this._groups = new Map();\n\n    if (data === null) {\n      return;\n    }\n    this.name = data.name;\n    this.creator = data.creator;\n    this._order = data.order;\n    for (const group of data.groups) {\n      this._groups.set(\n        group.id,\n        new OptionalContentGroup(group.name, group.intent)\n      );\n    }\n\n    if (data.baseState === \"OFF\") {\n      for (const group of this._groups) {\n        group.visible = false;\n      }\n    }\n\n    for (const on of data.on) {\n      this._groups.get(on).visible = true;\n    }\n\n    for (const off of data.off) {\n      this._groups.get(off).visible = false;\n    }\n  }\n\n  isVisible(group) {\n    if (group.type === \"OCG\") {\n      if (!this._groups.has(group.id)) {\n        warn(`Optional content group not found: ${group.id}`);\n        return true;\n      }\n      return this._groups.get(group.id).visible;\n    } else if (group.type === \"OCMD\") {\n      // Per the spec, the expression should be preferred if available. Until\n      // we implement this, just fallback to using the group policy for now.\n      if (group.expression) {\n        warn(\"Visibility expression not supported yet.\");\n      }\n      if (!group.policy || group.policy === \"AnyOn\") {\n        // Default\n        for (const id of group.ids) {\n          if (!this._groups.has(id)) {\n            warn(`Optional content group not found: ${id}`);\n            return true;\n          }\n          if (this._groups.get(id).visible) {\n            return true;\n          }\n        }\n        return false;\n      } else if (group.policy === \"AllOn\") {\n        for (const id of group.ids) {\n          if (!this._groups.has(id)) {\n            warn(`Optional content group not found: ${id}`);\n            return true;\n          }\n          if (!this._groups.get(id).visible) {\n            return false;\n          }\n        }\n        return true;\n      } else if (group.policy === \"AnyOff\") {\n        for (const id of group.ids) {\n          if (!this._groups.has(id)) {\n            warn(`Optional content group not found: ${id}`);\n            return true;\n          }\n          if (!this._groups.get(id).visible) {\n            return true;\n          }\n        }\n        return false;\n      } else if (group.policy === \"AllOff\") {\n        for (const id of group.ids) {\n          if (!this._groups.has(id)) {\n            warn(`Optional content group not found: ${id}`);\n            return true;\n          }\n          if (this._groups.get(id).visible) {\n            return false;\n          }\n        }\n        return true;\n      }\n      warn(`Unknown optional content policy ${group.policy}.`);\n      return true;\n    }\n    warn(`Unknown group type ${group.type}.`);\n    return true;\n  }\n\n  setVisibility(id, visible = true) {\n    if (!this._groups.has(id)) {\n      warn(`Optional content group not found: ${id}`);\n      return;\n    }\n    this._groups.get(id).visible = !!visible;\n  }\n\n  getOrder() {\n    if (!this._groups.size) {\n      return null;\n    }\n    if (this._order) {\n      return this._order.slice();\n    }\n    return Array.from(this._groups.keys());\n  }\n\n  getGroups() {\n    if (!this._groups.size) {\n      return null;\n    }\n    return Object.fromEntries(this._groups);\n  }\n\n  getGroup(id) {\n    return this._groups.get(id) || null;\n  }\n}\n\nexport { OptionalContentConfig };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport { assert, createPromiseCapability } from \"../shared/util.js\";\n\n/** @implements {IPDFStream} */\nclass PDFDataTransportStream {\n  constructor(params, pdfDataRangeTransport) {\n    assert(\n      pdfDataRangeTransport,\n      'PDFDataTransportStream - missing required \"pdfDataRangeTransport\" argument.'\n    );\n\n    this._queuedChunks = [];\n    this._progressiveDone = params.progressiveDone || false;\n\n    const initialData = params.initialData;\n    if (initialData && initialData.length > 0) {\n      const buffer = new Uint8Array(initialData).buffer;\n      this._queuedChunks.push(buffer);\n    }\n\n    this._pdfDataRangeTransport = pdfDataRangeTransport;\n    this._isStreamingSupported = !params.disableStream;\n    this._isRangeSupported = !params.disableRange;\n    this._contentLength = params.length;\n\n    this._fullRequestReader = null;\n    this._rangeReaders = [];\n\n    this._pdfDataRangeTransport.addRangeListener((begin, chunk) => {\n      this._onReceiveData({ begin, chunk });\n    });\n\n    this._pdfDataRangeTransport.addProgressListener((loaded, total) => {\n      this._onProgress({ loaded, total });\n    });\n\n    this._pdfDataRangeTransport.addProgressiveReadListener(chunk => {\n      this._onReceiveData({ chunk });\n    });\n\n    this._pdfDataRangeTransport.addProgressiveDoneListener(() => {\n      this._onProgressiveDone();\n    });\n\n    this._pdfDataRangeTransport.transportReady();\n  }\n\n  _onReceiveData(args) {\n    const buffer = new Uint8Array(args.chunk).buffer;\n    if (args.begin === undefined) {\n      if (this._fullRequestReader) {\n        this._fullRequestReader._enqueue(buffer);\n      } else {\n        this._queuedChunks.push(buffer);\n      }\n    } else {\n      const found = this._rangeReaders.some(function (rangeReader) {\n        if (rangeReader._begin !== args.begin) {\n          return false;\n        }\n        rangeReader._enqueue(buffer);\n        return true;\n      });\n      assert(\n        found,\n        \"_onReceiveData - no `PDFDataTransportStreamRangeReader` instance found.\"\n      );\n    }\n  }\n\n  get _progressiveDataLength() {\n    return this._fullRequestReader ? this._fullRequestReader._loaded : 0;\n  }\n\n  _onProgress(evt) {\n    if (evt.total === undefined) {\n      // Reporting to first range reader, if it exists.\n      const firstReader = this._rangeReaders[0];\n      if (firstReader && firstReader.onProgress) {\n        firstReader.onProgress({ loaded: evt.loaded });\n      }\n    } else {\n      const fullReader = this._fullRequestReader;\n      if (fullReader && fullReader.onProgress) {\n        fullReader.onProgress({ loaded: evt.loaded, total: evt.total });\n      }\n    }\n  }\n\n  _onProgressiveDone() {\n    if (this._fullRequestReader) {\n      this._fullRequestReader.progressiveDone();\n    }\n    this._progressiveDone = true;\n  }\n\n  _removeRangeReader(reader) {\n    const i = this._rangeReaders.indexOf(reader);\n    if (i >= 0) {\n      this._rangeReaders.splice(i, 1);\n    }\n  }\n\n  getFullReader() {\n    assert(\n      !this._fullRequestReader,\n      \"PDFDataTransportStream.getFullReader can only be called once.\"\n    );\n    const queuedChunks = this._queuedChunks;\n    this._queuedChunks = null;\n    return new PDFDataTransportStreamReader(\n      this,\n      queuedChunks,\n      this._progressiveDone\n    );\n  }\n\n  getRangeReader(begin, end) {\n    if (end <= this._progressiveDataLength) {\n      return null;\n    }\n    const reader = new PDFDataTransportStreamRangeReader(this, begin, end);\n    this._pdfDataRangeTransport.requestDataRange(begin, end);\n    this._rangeReaders.push(reader);\n    return reader;\n  }\n\n  cancelAllRequests(reason) {\n    if (this._fullRequestReader) {\n      this._fullRequestReader.cancel(reason);\n    }\n    const readers = this._rangeReaders.slice(0);\n    readers.forEach(function (rangeReader) {\n      rangeReader.cancel(reason);\n    });\n    this._pdfDataRangeTransport.abort();\n  }\n}\n\n/** @implements {IPDFStreamReader} */\nclass PDFDataTransportStreamReader {\n  constructor(stream, queuedChunks, progressiveDone = false) {\n    this._stream = stream;\n    this._done = progressiveDone || false;\n    this._filename = null;\n    this._queuedChunks = queuedChunks || [];\n    this._loaded = 0;\n    for (const chunk of this._queuedChunks) {\n      this._loaded += chunk.byteLength;\n    }\n    this._requests = [];\n    this._headersReady = Promise.resolve();\n    stream._fullRequestReader = this;\n\n    this.onProgress = null;\n  }\n\n  _enqueue(chunk) {\n    if (this._done) {\n      return; // Ignore new data.\n    }\n    if (this._requests.length > 0) {\n      const requestCapability = this._requests.shift();\n      requestCapability.resolve({ value: chunk, done: false });\n    } else {\n      this._queuedChunks.push(chunk);\n    }\n    this._loaded += chunk.byteLength;\n  }\n\n  get headersReady() {\n    return this._headersReady;\n  }\n\n  get filename() {\n    return this._filename;\n  }\n\n  get isRangeSupported() {\n    return this._stream._isRangeSupported;\n  }\n\n  get isStreamingSupported() {\n    return this._stream._isStreamingSupported;\n  }\n\n  get contentLength() {\n    return this._stream._contentLength;\n  }\n\n  async read() {\n    if (this._queuedChunks.length > 0) {\n      const chunk = this._queuedChunks.shift();\n      return { value: chunk, done: false };\n    }\n    if (this._done) {\n      return { value: undefined, done: true };\n    }\n    const requestCapability = createPromiseCapability();\n    this._requests.push(requestCapability);\n    return requestCapability.promise;\n  }\n\n  cancel(reason) {\n    this._done = true;\n    this._requests.forEach(function (requestCapability) {\n      requestCapability.resolve({ value: undefined, done: true });\n    });\n    this._requests = [];\n  }\n\n  progressiveDone() {\n    if (this._done) {\n      return;\n    }\n    this._done = true;\n  }\n}\n\n/** @implements {IPDFStreamRangeReader} */\nclass PDFDataTransportStreamRangeReader {\n  constructor(stream, begin, end) {\n    this._stream = stream;\n    this._begin = begin;\n    this._end = end;\n    this._queuedChunk = null;\n    this._requests = [];\n    this._done = false;\n\n    this.onProgress = null;\n  }\n\n  _enqueue(chunk) {\n    if (this._done) {\n      return; // ignore new data\n    }\n    if (this._requests.length === 0) {\n      this._queuedChunk = chunk;\n    } else {\n      const requestsCapability = this._requests.shift();\n      requestsCapability.resolve({ value: chunk, done: false });\n      this._requests.forEach(function (requestCapability) {\n        requestCapability.resolve({ value: undefined, done: true });\n      });\n      this._requests = [];\n    }\n    this._done = true;\n    this._stream._removeRangeReader(this);\n  }\n\n  get isStreamingSupported() {\n    return false;\n  }\n\n  async read() {\n    if (this._queuedChunk) {\n      const chunk = this._queuedChunk;\n      this._queuedChunk = null;\n      return { value: chunk, done: false };\n    }\n    if (this._done) {\n      return { value: undefined, done: true };\n    }\n    const requestCapability = createPromiseCapability();\n    this._requests.push(requestCapability);\n    return requestCapability.promise;\n  }\n\n  cancel(reason) {\n    this._done = true;\n    this._requests.forEach(function (requestCapability) {\n      requestCapability.resolve({ value: undefined, done: true });\n    });\n    this._requests = [];\n    this._stream._removeRangeReader(this);\n  }\n}\n\nexport { PDFDataTransportStream };\n","/* Copyright 2014 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint-disable no-multi-str */\n\nimport { shadow } from \"../shared/util.js\";\n\nclass WebGLContext {\n  constructor({ enable = false }) {\n    this._enabled = enable === true;\n  }\n\n  get isEnabled() {\n    let enabled = this._enabled;\n    if (enabled) {\n      enabled = WebGLUtils.tryInitGL();\n    }\n    return shadow(this, \"isEnabled\", enabled);\n  }\n\n  composeSMask({ layer, mask, properties }) {\n    return WebGLUtils.composeSMask(layer, mask, properties);\n  }\n\n  drawFigures({ width, height, backgroundColor, figures, context }) {\n    return WebGLUtils.drawFigures(\n      width,\n      height,\n      backgroundColor,\n      figures,\n      context\n    );\n  }\n\n  clear() {\n    WebGLUtils.cleanup();\n  }\n}\n\nvar WebGLUtils = (function WebGLUtilsClosure() {\n  function loadShader(gl, code, shaderType) {\n    var shader = gl.createShader(shaderType);\n    gl.shaderSource(shader, code);\n    gl.compileShader(shader);\n    var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);\n    if (!compiled) {\n      var errorMsg = gl.getShaderInfoLog(shader);\n      throw new Error(\"Error during shader compilation: \" + errorMsg);\n    }\n    return shader;\n  }\n  function createVertexShader(gl, code) {\n    return loadShader(gl, code, gl.VERTEX_SHADER);\n  }\n  function createFragmentShader(gl, code) {\n    return loadShader(gl, code, gl.FRAGMENT_SHADER);\n  }\n  function createProgram(gl, shaders) {\n    var program = gl.createProgram();\n    for (var i = 0, ii = shaders.length; i < ii; ++i) {\n      gl.attachShader(program, shaders[i]);\n    }\n    gl.linkProgram(program);\n    var linked = gl.getProgramParameter(program, gl.LINK_STATUS);\n    if (!linked) {\n      var errorMsg = gl.getProgramInfoLog(program);\n      throw new Error(\"Error during program linking: \" + errorMsg);\n    }\n    return program;\n  }\n  function createTexture(gl, image, textureId) {\n    gl.activeTexture(textureId);\n    var texture = gl.createTexture();\n    gl.bindTexture(gl.TEXTURE_2D, texture);\n\n    // Set the parameters so we can render any size image.\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);\n    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);\n\n    // Upload the image into the texture.\n    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);\n    return texture;\n  }\n\n  var currentGL, currentCanvas;\n  function generateGL() {\n    if (currentGL) {\n      return;\n    }\n\n    // The temporary canvas is used in the WebGL context.\n    currentCanvas = document.createElement(\"canvas\");\n    currentGL = currentCanvas.getContext(\"webgl\", {\n      premultipliedalpha: false,\n    });\n  }\n\n  var smaskVertexShaderCode =\n    \"\\\n  attribute vec2 a_position;                                    \\\n  attribute vec2 a_texCoord;                                    \\\n                                                                \\\n  uniform vec2 u_resolution;                                    \\\n                                                                \\\n  varying vec2 v_texCoord;                                      \\\n                                                                \\\n  void main() {                                                 \\\n    vec2 clipSpace = (a_position / u_resolution) * 2.0 - 1.0;   \\\n    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);          \\\n                                                                \\\n    v_texCoord = a_texCoord;                                    \\\n  }                                                             \";\n\n  var smaskFragmentShaderCode =\n    \"\\\n  precision mediump float;                                      \\\n                                                                \\\n  uniform vec4 u_backdrop;                                      \\\n  uniform int u_subtype;                                        \\\n  uniform sampler2D u_image;                                    \\\n  uniform sampler2D u_mask;                                     \\\n                                                                \\\n  varying vec2 v_texCoord;                                      \\\n                                                                \\\n  void main() {                                                 \\\n    vec4 imageColor = texture2D(u_image, v_texCoord);           \\\n    vec4 maskColor = texture2D(u_mask, v_texCoord);             \\\n    if (u_backdrop.a > 0.0) {                                   \\\n      maskColor.rgb = maskColor.rgb * maskColor.a +             \\\n                      u_backdrop.rgb * (1.0 - maskColor.a);     \\\n    }                                                           \\\n    float lum;                                                  \\\n    if (u_subtype == 0) {                                       \\\n      lum = maskColor.a;                                        \\\n    } else {                                                    \\\n      lum = maskColor.r * 0.3 + maskColor.g * 0.59 +            \\\n            maskColor.b * 0.11;                                 \\\n    }                                                           \\\n    imageColor.a *= lum;                                        \\\n    imageColor.rgb *= imageColor.a;                             \\\n    gl_FragColor = imageColor;                                  \\\n  }                                                             \";\n\n  var smaskCache = null;\n\n  function initSmaskGL() {\n    var canvas, gl;\n\n    generateGL();\n    canvas = currentCanvas;\n    currentCanvas = null;\n    gl = currentGL;\n    currentGL = null;\n\n    // setup a GLSL program\n    var vertexShader = createVertexShader(gl, smaskVertexShaderCode);\n    var fragmentShader = createFragmentShader(gl, smaskFragmentShaderCode);\n    var program = createProgram(gl, [vertexShader, fragmentShader]);\n    gl.useProgram(program);\n\n    var cache = {};\n    cache.gl = gl;\n    cache.canvas = canvas;\n    cache.resolutionLocation = gl.getUniformLocation(program, \"u_resolution\");\n    cache.positionLocation = gl.getAttribLocation(program, \"a_position\");\n    cache.backdropLocation = gl.getUniformLocation(program, \"u_backdrop\");\n    cache.subtypeLocation = gl.getUniformLocation(program, \"u_subtype\");\n\n    var texCoordLocation = gl.getAttribLocation(program, \"a_texCoord\");\n    var texLayerLocation = gl.getUniformLocation(program, \"u_image\");\n    var texMaskLocation = gl.getUniformLocation(program, \"u_mask\");\n\n    // provide texture coordinates for the rectangle.\n    var texCoordBuffer = gl.createBuffer();\n    gl.bindBuffer(gl.ARRAY_BUFFER, texCoordBuffer);\n    // prettier-ignore\n    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([\n      0.0, 0.0,\n      1.0, 0.0,\n      0.0, 1.0,\n      0.0, 1.0,\n      1.0, 0.0,\n      1.0, 1.0]), gl.STATIC_DRAW);\n    gl.enableVertexAttribArray(texCoordLocation);\n    gl.vertexAttribPointer(texCoordLocation, 2, gl.FLOAT, false, 0, 0);\n\n    gl.uniform1i(texLayerLocation, 0);\n    gl.uniform1i(texMaskLocation, 1);\n\n    smaskCache = cache;\n  }\n\n  function composeSMask(layer, mask, properties) {\n    var width = layer.width,\n      height = layer.height;\n\n    if (!smaskCache) {\n      initSmaskGL();\n    }\n    var cache = smaskCache,\n      canvas = cache.canvas,\n      gl = cache.gl;\n    canvas.width = width;\n    canvas.height = height;\n    gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);\n    gl.uniform2f(cache.resolutionLocation, width, height);\n\n    if (properties.backdrop) {\n      gl.uniform4f(\n        cache.resolutionLocation,\n        properties.backdrop[0],\n        properties.backdrop[1],\n        properties.backdrop[2],\n        1\n      );\n    } else {\n      gl.uniform4f(cache.resolutionLocation, 0, 0, 0, 0);\n    }\n    gl.uniform1i(\n      cache.subtypeLocation,\n      properties.subtype === \"Luminosity\" ? 1 : 0\n    );\n\n    // Create a textures\n    var texture = createTexture(gl, layer, gl.TEXTURE0);\n    var maskTexture = createTexture(gl, mask, gl.TEXTURE1);\n\n    // Create a buffer and put a single clipspace rectangle in\n    // it (2 triangles)\n    var buffer = gl.createBuffer();\n    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);\n    // prettier-ignore\n    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([\n      0, 0,\n      width, 0,\n      0, height,\n      0, height,\n      width, 0,\n      width, height]), gl.STATIC_DRAW);\n    gl.enableVertexAttribArray(cache.positionLocation);\n    gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);\n\n    // draw\n    gl.clearColor(0, 0, 0, 0);\n    gl.enable(gl.BLEND);\n    gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n    gl.clear(gl.COLOR_BUFFER_BIT);\n\n    gl.drawArrays(gl.TRIANGLES, 0, 6);\n\n    gl.flush();\n\n    gl.deleteTexture(texture);\n    gl.deleteTexture(maskTexture);\n    gl.deleteBuffer(buffer);\n\n    return canvas;\n  }\n\n  var figuresVertexShaderCode =\n    \"\\\n  attribute vec2 a_position;                                    \\\n  attribute vec3 a_color;                                       \\\n                                                                \\\n  uniform vec2 u_resolution;                                    \\\n  uniform vec2 u_scale;                                         \\\n  uniform vec2 u_offset;                                        \\\n                                                                \\\n  varying vec4 v_color;                                         \\\n                                                                \\\n  void main() {                                                 \\\n    vec2 position = (a_position + u_offset) * u_scale;          \\\n    vec2 clipSpace = (position / u_resolution) * 2.0 - 1.0;     \\\n    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);          \\\n                                                                \\\n    v_color = vec4(a_color / 255.0, 1.0);                       \\\n  }                                                             \";\n\n  var figuresFragmentShaderCode =\n    \"\\\n  precision mediump float;                                      \\\n                                                                \\\n  varying vec4 v_color;                                         \\\n                                                                \\\n  void main() {                                                 \\\n    gl_FragColor = v_color;                                     \\\n  }                                                             \";\n\n  var figuresCache = null;\n\n  function initFiguresGL() {\n    var canvas, gl;\n\n    generateGL();\n    canvas = currentCanvas;\n    currentCanvas = null;\n    gl = currentGL;\n    currentGL = null;\n\n    // setup a GLSL program\n    var vertexShader = createVertexShader(gl, figuresVertexShaderCode);\n    var fragmentShader = createFragmentShader(gl, figuresFragmentShaderCode);\n    var program = createProgram(gl, [vertexShader, fragmentShader]);\n    gl.useProgram(program);\n\n    var cache = {};\n    cache.gl = gl;\n    cache.canvas = canvas;\n    cache.resolutionLocation = gl.getUniformLocation(program, \"u_resolution\");\n    cache.scaleLocation = gl.getUniformLocation(program, \"u_scale\");\n    cache.offsetLocation = gl.getUniformLocation(program, \"u_offset\");\n    cache.positionLocation = gl.getAttribLocation(program, \"a_position\");\n    cache.colorLocation = gl.getAttribLocation(program, \"a_color\");\n\n    figuresCache = cache;\n  }\n\n  function drawFigures(width, height, backgroundColor, figures, context) {\n    if (!figuresCache) {\n      initFiguresGL();\n    }\n    var cache = figuresCache,\n      canvas = cache.canvas,\n      gl = cache.gl;\n\n    canvas.width = width;\n    canvas.height = height;\n    gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);\n    gl.uniform2f(cache.resolutionLocation, width, height);\n\n    // count triangle points\n    var count = 0;\n    var i, ii, rows;\n    for (i = 0, ii = figures.length; i < ii; i++) {\n      switch (figures[i].type) {\n        case \"lattice\":\n          rows = (figures[i].coords.length / figures[i].verticesPerRow) | 0;\n          count += (rows - 1) * (figures[i].verticesPerRow - 1) * 6;\n          break;\n        case \"triangles\":\n          count += figures[i].coords.length;\n          break;\n      }\n    }\n    // transfer data\n    var coords = new Float32Array(count * 2);\n    var colors = new Uint8Array(count * 3);\n    var coordsMap = context.coords,\n      colorsMap = context.colors;\n    var pIndex = 0,\n      cIndex = 0;\n    for (i = 0, ii = figures.length; i < ii; i++) {\n      var figure = figures[i],\n        ps = figure.coords,\n        cs = figure.colors;\n      switch (figure.type) {\n        case \"lattice\":\n          var cols = figure.verticesPerRow;\n          rows = (ps.length / cols) | 0;\n          for (var row = 1; row < rows; row++) {\n            var offset = row * cols + 1;\n            for (var col = 1; col < cols; col++, offset++) {\n              coords[pIndex] = coordsMap[ps[offset - cols - 1]];\n              coords[pIndex + 1] = coordsMap[ps[offset - cols - 1] + 1];\n              coords[pIndex + 2] = coordsMap[ps[offset - cols]];\n              coords[pIndex + 3] = coordsMap[ps[offset - cols] + 1];\n              coords[pIndex + 4] = coordsMap[ps[offset - 1]];\n              coords[pIndex + 5] = coordsMap[ps[offset - 1] + 1];\n              colors[cIndex] = colorsMap[cs[offset - cols - 1]];\n              colors[cIndex + 1] = colorsMap[cs[offset - cols - 1] + 1];\n              colors[cIndex + 2] = colorsMap[cs[offset - cols - 1] + 2];\n              colors[cIndex + 3] = colorsMap[cs[offset - cols]];\n              colors[cIndex + 4] = colorsMap[cs[offset - cols] + 1];\n              colors[cIndex + 5] = colorsMap[cs[offset - cols] + 2];\n              colors[cIndex + 6] = colorsMap[cs[offset - 1]];\n              colors[cIndex + 7] = colorsMap[cs[offset - 1] + 1];\n              colors[cIndex + 8] = colorsMap[cs[offset - 1] + 2];\n\n              coords[pIndex + 6] = coords[pIndex + 2];\n              coords[pIndex + 7] = coords[pIndex + 3];\n              coords[pIndex + 8] = coords[pIndex + 4];\n              coords[pIndex + 9] = coords[pIndex + 5];\n              coords[pIndex + 10] = coordsMap[ps[offset]];\n              coords[pIndex + 11] = coordsMap[ps[offset] + 1];\n              colors[cIndex + 9] = colors[cIndex + 3];\n              colors[cIndex + 10] = colors[cIndex + 4];\n              colors[cIndex + 11] = colors[cIndex + 5];\n              colors[cIndex + 12] = colors[cIndex + 6];\n              colors[cIndex + 13] = colors[cIndex + 7];\n              colors[cIndex + 14] = colors[cIndex + 8];\n              colors[cIndex + 15] = colorsMap[cs[offset]];\n              colors[cIndex + 16] = colorsMap[cs[offset] + 1];\n              colors[cIndex + 17] = colorsMap[cs[offset] + 2];\n              pIndex += 12;\n              cIndex += 18;\n            }\n          }\n          break;\n        case \"triangles\":\n          for (var j = 0, jj = ps.length; j < jj; j++) {\n            coords[pIndex] = coordsMap[ps[j]];\n            coords[pIndex + 1] = coordsMap[ps[j] + 1];\n            colors[cIndex] = colorsMap[cs[j]];\n            colors[cIndex + 1] = colorsMap[cs[j] + 1];\n            colors[cIndex + 2] = colorsMap[cs[j] + 2];\n            pIndex += 2;\n            cIndex += 3;\n          }\n          break;\n      }\n    }\n\n    // draw\n    if (backgroundColor) {\n      gl.clearColor(\n        backgroundColor[0] / 255,\n        backgroundColor[1] / 255,\n        backgroundColor[2] / 255,\n        1.0\n      );\n    } else {\n      gl.clearColor(0, 0, 0, 0);\n    }\n    gl.clear(gl.COLOR_BUFFER_BIT);\n\n    var coordsBuffer = gl.createBuffer();\n    gl.bindBuffer(gl.ARRAY_BUFFER, coordsBuffer);\n    gl.bufferData(gl.ARRAY_BUFFER, coords, gl.STATIC_DRAW);\n    gl.enableVertexAttribArray(cache.positionLocation);\n    gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);\n\n    var colorsBuffer = gl.createBuffer();\n    gl.bindBuffer(gl.ARRAY_BUFFER, colorsBuffer);\n    gl.bufferData(gl.ARRAY_BUFFER, colors, gl.STATIC_DRAW);\n    gl.enableVertexAttribArray(cache.colorLocation);\n    gl.vertexAttribPointer(\n      cache.colorLocation,\n      3,\n      gl.UNSIGNED_BYTE,\n      false,\n      0,\n      0\n    );\n\n    gl.uniform2f(cache.scaleLocation, context.scaleX, context.scaleY);\n    gl.uniform2f(cache.offsetLocation, context.offsetX, context.offsetY);\n\n    gl.drawArrays(gl.TRIANGLES, 0, count);\n\n    gl.flush();\n\n    gl.deleteBuffer(coordsBuffer);\n    gl.deleteBuffer(colorsBuffer);\n\n    return canvas;\n  }\n\n  return {\n    tryInitGL() {\n      try {\n        generateGL();\n        return !!currentGL;\n      } catch (ex) {}\n      return false;\n    },\n\n    composeSMask,\n\n    drawFigures,\n\n    cleanup() {\n      if (smaskCache && smaskCache.canvas) {\n        smaskCache.canvas.width = 0;\n        smaskCache.canvas.height = 0;\n      }\n      if (figuresCache && figuresCache.canvas) {\n        figuresCache.canvas.width = 0;\n        figuresCache.canvas.height = 0;\n      }\n      smaskCache = null;\n      figuresCache = null;\n    },\n  };\n})();\n\nexport { WebGLContext };\n","/* Copyright 2014 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport {\n  addLinkAttributes,\n  DOMSVGFactory,\n  getFilenameFromUrl,\n  LinkTarget,\n  PDFDateString,\n} from \"./display_utils.js\";\nimport {\n  AnnotationBorderStyleType,\n  AnnotationType,\n  stringToPDFString,\n  unreachable,\n  Util,\n  warn,\n} from \"../shared/util.js\";\nimport { AnnotationStorage } from \"./annotation_storage.js\";\n\n/**\n * @typedef {Object} AnnotationElementParameters\n * @property {Object} data\n * @property {HTMLDivElement} layer\n * @property {PDFPage} page\n * @property {PageViewport} viewport\n * @property {IPDFLinkService} linkService\n * @property {DownloadManager} downloadManager\n * @property {AnnotationStorage} [annotationStorage]\n * @property {string} [imageResourcesPath] - Path for image resources, mainly\n *   for annotation icons. Include trailing slash.\n * @property {boolean} renderInteractiveForms\n * @property {Object} svgFactory\n */\n\nclass AnnotationElementFactory {\n  /**\n   * @param {AnnotationElementParameters} parameters\n   * @returns {AnnotationElement}\n   */\n  static create(parameters) {\n    const subtype = parameters.data.annotationType;\n\n    switch (subtype) {\n      case AnnotationType.LINK:\n        return new LinkAnnotationElement(parameters);\n\n      case AnnotationType.TEXT:\n        return new TextAnnotationElement(parameters);\n\n      case AnnotationType.WIDGET:\n        const fieldType = parameters.data.fieldType;\n\n        switch (fieldType) {\n          case \"Tx\":\n            return new TextWidgetAnnotationElement(parameters);\n          case \"Btn\":\n            if (parameters.data.radioButton) {\n              return new RadioButtonWidgetAnnotationElement(parameters);\n            } else if (parameters.data.checkBox) {\n              return new CheckboxWidgetAnnotationElement(parameters);\n            }\n            return new PushButtonWidgetAnnotationElement(parameters);\n          case \"Ch\":\n            return new ChoiceWidgetAnnotationElement(parameters);\n        }\n        return new WidgetAnnotationElement(parameters);\n\n      case AnnotationType.POPUP:\n        return new PopupAnnotationElement(parameters);\n\n      case AnnotationType.FREETEXT:\n        return new FreeTextAnnotationElement(parameters);\n\n      case AnnotationType.LINE:\n        return new LineAnnotationElement(parameters);\n\n      case AnnotationType.SQUARE:\n        return new SquareAnnotationElement(parameters);\n\n      case AnnotationType.CIRCLE:\n        return new CircleAnnotationElement(parameters);\n\n      case AnnotationType.POLYLINE:\n        return new PolylineAnnotationElement(parameters);\n\n      case AnnotationType.CARET:\n        return new CaretAnnotationElement(parameters);\n\n      case AnnotationType.INK:\n        return new InkAnnotationElement(parameters);\n\n      case AnnotationType.POLYGON:\n        return new PolygonAnnotationElement(parameters);\n\n      case AnnotationType.HIGHLIGHT:\n        return new HighlightAnnotationElement(parameters);\n\n      case AnnotationType.UNDERLINE:\n        return new UnderlineAnnotationElement(parameters);\n\n      case AnnotationType.SQUIGGLY:\n        return new SquigglyAnnotationElement(parameters);\n\n      case AnnotationType.STRIKEOUT:\n        return new StrikeOutAnnotationElement(parameters);\n\n      case AnnotationType.STAMP:\n        return new StampAnnotationElement(parameters);\n\n      case AnnotationType.FILEATTACHMENT:\n        return new FileAttachmentAnnotationElement(parameters);\n\n      default:\n        return new AnnotationElement(parameters);\n    }\n  }\n}\n\nclass AnnotationElement {\n  constructor(parameters, isRenderable = false, ignoreBorder = false) {\n    this.isRenderable = isRenderable;\n    this.data = parameters.data;\n    this.layer = parameters.layer;\n    this.page = parameters.page;\n    this.viewport = parameters.viewport;\n    this.linkService = parameters.linkService;\n    this.downloadManager = parameters.downloadManager;\n    this.imageResourcesPath = parameters.imageResourcesPath;\n    this.renderInteractiveForms = parameters.renderInteractiveForms;\n    this.svgFactory = parameters.svgFactory;\n    this.annotationStorage = parameters.annotationStorage;\n\n    if (isRenderable) {\n      this.container = this._createContainer(ignoreBorder);\n    }\n  }\n\n  /**\n   * Create an empty container for the annotation's HTML element.\n   *\n   * @private\n   * @param {boolean} ignoreBorder\n   * @memberof AnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  _createContainer(ignoreBorder = false) {\n    const data = this.data,\n      page = this.page,\n      viewport = this.viewport;\n    const container = document.createElement(\"section\");\n    let width = data.rect[2] - data.rect[0];\n    let height = data.rect[3] - data.rect[1];\n\n    container.setAttribute(\"data-annotation-id\", data.id);\n\n    // Do *not* modify `data.rect`, since that will corrupt the annotation\n    // position on subsequent calls to `_createContainer` (see issue 6804).\n    const rect = Util.normalizeRect([\n      data.rect[0],\n      page.view[3] - data.rect[1] + page.view[1],\n      data.rect[2],\n      page.view[3] - data.rect[3] + page.view[1],\n    ]);\n\n    container.style.transform = `matrix(${viewport.transform.join(\",\")})`;\n    container.style.transformOrigin = `-${rect[0]}px -${rect[1]}px`;\n\n    if (!ignoreBorder && data.borderStyle.width > 0) {\n      container.style.borderWidth = `${data.borderStyle.width}px`;\n      if (data.borderStyle.style !== AnnotationBorderStyleType.UNDERLINE) {\n        // Underline styles only have a bottom border, so we do not need\n        // to adjust for all borders. This yields a similar result as\n        // Adobe Acrobat/Reader.\n        width = width - 2 * data.borderStyle.width;\n        height = height - 2 * data.borderStyle.width;\n      }\n\n      const horizontalRadius = data.borderStyle.horizontalCornerRadius;\n      const verticalRadius = data.borderStyle.verticalCornerRadius;\n      if (horizontalRadius > 0 || verticalRadius > 0) {\n        const radius = `${horizontalRadius}px / ${verticalRadius}px`;\n        container.style.borderRadius = radius;\n      }\n\n      switch (data.borderStyle.style) {\n        case AnnotationBorderStyleType.SOLID:\n          container.style.borderStyle = \"solid\";\n          break;\n\n        case AnnotationBorderStyleType.DASHED:\n          container.style.borderStyle = \"dashed\";\n          break;\n\n        case AnnotationBorderStyleType.BEVELED:\n          warn(\"Unimplemented border style: beveled\");\n          break;\n\n        case AnnotationBorderStyleType.INSET:\n          warn(\"Unimplemented border style: inset\");\n          break;\n\n        case AnnotationBorderStyleType.UNDERLINE:\n          container.style.borderBottomStyle = \"solid\";\n          break;\n\n        default:\n          break;\n      }\n\n      if (data.color) {\n        container.style.borderColor = Util.makeCssRgb(\n          data.color[0] | 0,\n          data.color[1] | 0,\n          data.color[2] | 0\n        );\n      } else {\n        // Transparent (invisible) border, so do not draw it at all.\n        container.style.borderWidth = 0;\n      }\n    }\n\n    container.style.left = `${rect[0]}px`;\n    container.style.top = `${rect[1]}px`;\n    container.style.width = `${width}px`;\n    container.style.height = `${height}px`;\n    return container;\n  }\n\n  /**\n   * Create a popup for the annotation's HTML element. This is used for\n   * annotations that do not have a Popup entry in the dictionary, but\n   * are of a type that works with popups (such as Highlight annotations).\n   *\n   * @private\n   * @param {HTMLSectionElement} container\n   * @param {HTMLDivElement|HTMLImageElement|null} trigger\n   * @param {Object} data\n   * @memberof AnnotationElement\n   */\n  _createPopup(container, trigger, data) {\n    // If no trigger element is specified, create it.\n    if (!trigger) {\n      trigger = document.createElement(\"div\");\n      trigger.style.height = container.style.height;\n      trigger.style.width = container.style.width;\n      container.appendChild(trigger);\n    }\n\n    const popupElement = new PopupElement({\n      container,\n      trigger,\n      color: data.color,\n      title: data.title,\n      modificationDate: data.modificationDate,\n      contents: data.contents,\n      hideWrapper: true,\n    });\n    const popup = popupElement.render();\n\n    // Position the popup next to the annotation's container.\n    popup.style.left = container.style.width;\n\n    container.appendChild(popup);\n  }\n\n  /**\n   * Render the annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof AnnotationElement\n   */\n  render() {\n    unreachable(\"Abstract method `AnnotationElement.render` called\");\n  }\n}\n\nclass LinkAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.url ||\n      parameters.data.dest ||\n      parameters.data.action\n    );\n    super(parameters, isRenderable);\n  }\n\n  /**\n   * Render the link annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof LinkAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"linkAnnotation\";\n\n    const { data, linkService } = this;\n    const link = document.createElement(\"a\");\n\n    if (data.url) {\n      addLinkAttributes(link, {\n        url: data.url,\n        target: data.newWindow\n          ? LinkTarget.BLANK\n          : linkService.externalLinkTarget,\n        rel: linkService.externalLinkRel,\n        enabled: linkService.externalLinkEnabled,\n      });\n    } else if (data.action) {\n      this._bindNamedAction(link, data.action);\n    } else {\n      this._bindLink(link, data.dest);\n    }\n\n    this.container.appendChild(link);\n    return this.container;\n  }\n\n  /**\n   * Bind internal links to the link element.\n   *\n   * @private\n   * @param {Object} link\n   * @param {Object} destination\n   * @memberof LinkAnnotationElement\n   */\n  _bindLink(link, destination) {\n    link.href = this.linkService.getDestinationHash(destination);\n    link.onclick = () => {\n      if (destination) {\n        this.linkService.navigateTo(destination);\n      }\n      return false;\n    };\n    if (destination) {\n      link.className = \"internalLink\";\n    }\n  }\n\n  /**\n   * Bind named actions to the link element.\n   *\n   * @private\n   * @param {Object} link\n   * @param {Object} action\n   * @memberof LinkAnnotationElement\n   */\n  _bindNamedAction(link, action) {\n    link.href = this.linkService.getAnchorUrl(\"\");\n    link.onclick = () => {\n      this.linkService.executeNamedAction(action);\n      return false;\n    };\n    link.className = \"internalLink\";\n  }\n}\n\nclass TextAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.title ||\n      parameters.data.contents\n    );\n    super(parameters, isRenderable);\n  }\n\n  /**\n   * Render the text annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof TextAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"textAnnotation\";\n\n    const image = document.createElement(\"img\");\n    image.style.height = this.container.style.height;\n    image.style.width = this.container.style.width;\n    image.src =\n      this.imageResourcesPath +\n      \"annotation-\" +\n      this.data.name.toLowerCase() +\n      \".svg\";\n    image.alt = \"[{{type}} Annotation]\";\n    image.dataset.l10nId = \"text_annotation_type\";\n    image.dataset.l10nArgs = JSON.stringify({ type: this.data.name });\n\n    if (!this.data.hasPopup) {\n      this._createPopup(this.container, image, this.data);\n    }\n\n    this.container.appendChild(image);\n    return this.container;\n  }\n}\n\nclass WidgetAnnotationElement extends AnnotationElement {\n  /**\n   * Render the widget annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof WidgetAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    // Show only the container for unsupported field types.\n    return this.container;\n  }\n}\n\nclass TextWidgetAnnotationElement extends WidgetAnnotationElement {\n  constructor(parameters) {\n    const isRenderable =\n      parameters.renderInteractiveForms ||\n      (!parameters.data.hasAppearance && !!parameters.data.fieldValue);\n    super(parameters, isRenderable);\n  }\n\n  /**\n   * Render the text widget annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof TextWidgetAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    const TEXT_ALIGNMENT = [\"left\", \"center\", \"right\"];\n    const storage = this.annotationStorage;\n    const id = this.data.id;\n\n    this.container.className = \"textWidgetAnnotation\";\n\n    let element = null;\n    if (this.renderInteractiveForms) {\n      // NOTE: We cannot set the values using `element.value` below, since it\n      //       prevents the AnnotationLayer rasterizer in `test/driver.js`\n      //       from parsing the elements correctly for the reference tests.\n      const textContent = storage.getOrCreateValue(id, this.data.fieldValue);\n\n      if (this.data.multiLine) {\n        element = document.createElement(\"textarea\");\n        element.textContent = textContent;\n      } else {\n        element = document.createElement(\"input\");\n        element.type = \"text\";\n        element.setAttribute(\"value\", textContent);\n      }\n\n      element.addEventListener(\"input\", function (event) {\n        storage.setValue(id, event.target.value);\n      });\n\n      element.disabled = this.data.readOnly;\n      element.name = this.data.fieldName;\n\n      if (this.data.maxLen !== null) {\n        element.maxLength = this.data.maxLen;\n      }\n\n      if (this.data.comb) {\n        const fieldWidth = this.data.rect[2] - this.data.rect[0];\n        const combWidth = fieldWidth / this.data.maxLen;\n\n        element.classList.add(\"comb\");\n        element.style.letterSpacing = `calc(${combWidth}px - 1ch)`;\n      }\n    } else {\n      element = document.createElement(\"div\");\n      element.textContent = this.data.fieldValue;\n      element.style.verticalAlign = \"middle\";\n      element.style.display = \"table-cell\";\n\n      let font = null;\n      if (\n        this.data.fontRefName &&\n        this.page.commonObjs.has(this.data.fontRefName)\n      ) {\n        font = this.page.commonObjs.get(this.data.fontRefName);\n      }\n      this._setTextStyle(element, font);\n    }\n\n    if (this.data.textAlignment !== null) {\n      element.style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment];\n    }\n\n    this.container.appendChild(element);\n    return this.container;\n  }\n\n  /**\n   * Apply text styles to the text in the element.\n   *\n   * @private\n   * @param {HTMLDivElement} element\n   * @param {Object} font\n   * @memberof TextWidgetAnnotationElement\n   */\n  _setTextStyle(element, font) {\n    // TODO: This duplicates some of the logic in CanvasGraphics.setFont().\n    const style = element.style;\n    style.fontSize = `${this.data.fontSize}px`;\n    style.direction = this.data.fontDirection < 0 ? \"rtl\" : \"ltr\";\n\n    if (!font) {\n      return;\n    }\n\n    let bold = \"normal\";\n    if (font.black) {\n      bold = \"900\";\n    } else if (font.bold) {\n      bold = \"bold\";\n    }\n    style.fontWeight = bold;\n    style.fontStyle = font.italic ? \"italic\" : \"normal\";\n\n    // Use a reasonable default font if the font doesn't specify a fallback.\n    const fontFamily = font.loadedName ? `\"${font.loadedName}\", ` : \"\";\n    const fallbackName = font.fallbackName || \"Helvetica, sans-serif\";\n    style.fontFamily = fontFamily + fallbackName;\n  }\n}\n\nclass CheckboxWidgetAnnotationElement extends WidgetAnnotationElement {\n  constructor(parameters) {\n    super(parameters, parameters.renderInteractiveForms);\n  }\n\n  /**\n   * Render the checkbox widget annotation's HTML element\n   * in the empty container.\n   *\n   * @public\n   * @memberof CheckboxWidgetAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    const storage = this.annotationStorage;\n    const data = this.data;\n    const id = data.id;\n    const value = storage.getOrCreateValue(\n      id,\n      data.fieldValue && data.fieldValue !== \"Off\"\n    );\n\n    this.container.className = \"buttonWidgetAnnotation checkBox\";\n\n    const element = document.createElement(\"input\");\n    element.disabled = data.readOnly;\n    element.type = \"checkbox\";\n    element.name = this.data.fieldName;\n    if (value) {\n      element.setAttribute(\"checked\", true);\n    }\n\n    element.addEventListener(\"change\", function (event) {\n      storage.setValue(id, event.target.checked);\n    });\n\n    this.container.appendChild(element);\n    return this.container;\n  }\n}\n\nclass RadioButtonWidgetAnnotationElement extends WidgetAnnotationElement {\n  constructor(parameters) {\n    super(parameters, parameters.renderInteractiveForms);\n  }\n\n  /**\n   * Render the radio button widget annotation's HTML element\n   * in the empty container.\n   *\n   * @public\n   * @memberof RadioButtonWidgetAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"buttonWidgetAnnotation radioButton\";\n    const storage = this.annotationStorage;\n    const data = this.data;\n    const id = data.id;\n    const value = storage.getOrCreateValue(\n      id,\n      data.fieldValue === data.buttonValue\n    );\n\n    const element = document.createElement(\"input\");\n    element.disabled = data.readOnly;\n    element.type = \"radio\";\n    element.name = data.fieldName;\n    if (value) {\n      element.setAttribute(\"checked\", true);\n    }\n\n    element.addEventListener(\"change\", function (event) {\n      const name = event.target.name;\n      for (const radio of document.getElementsByName(name)) {\n        if (radio !== event.target) {\n          storage.setValue(\n            radio.parentNode.getAttribute(\"data-annotation-id\"),\n            false\n          );\n        }\n      }\n      storage.setValue(id, event.target.checked);\n    });\n\n    this.container.appendChild(element);\n    return this.container;\n  }\n}\n\nclass PushButtonWidgetAnnotationElement extends LinkAnnotationElement {\n  /**\n   * Render the push button widget annotation's HTML element\n   * in the empty container.\n   *\n   * @public\n   * @memberof PushButtonWidgetAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    // The rendering and functionality of a push button widget annotation is\n    // equal to that of a link annotation, but may have more functionality, such\n    // as performing actions on form fields (resetting, submitting, et cetera).\n    const container = super.render();\n    container.className = \"buttonWidgetAnnotation pushButton\";\n    return container;\n  }\n}\n\nclass ChoiceWidgetAnnotationElement extends WidgetAnnotationElement {\n  constructor(parameters) {\n    super(parameters, parameters.renderInteractiveForms);\n  }\n\n  /**\n   * Render the choice widget annotation's HTML element in the empty\n   * container.\n   *\n   * @public\n   * @memberof ChoiceWidgetAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"choiceWidgetAnnotation\";\n    const storage = this.annotationStorage;\n    const id = this.data.id;\n\n    // For printing/saving we currently only support choice widgets with one\n    // option selection. Therefore, listboxes (#12189) and comboboxes (#12224)\n    // are not properly printed/saved yet, so we only store the first item in\n    // the field value array instead of the entire array. Once support for those\n    // two field types is implemented, we should use the same pattern as the\n    // other interactive widgets where the return value of `getOrCreateValue` is\n    // used and the full array of field values is stored.\n    storage.getOrCreateValue(\n      id,\n      this.data.fieldValue.length > 0 ? this.data.fieldValue[0] : null\n    );\n\n    const selectElement = document.createElement(\"select\");\n    selectElement.disabled = this.data.readOnly;\n    selectElement.name = this.data.fieldName;\n\n    if (!this.data.combo) {\n      // List boxes have a size and (optionally) multiple selection.\n      selectElement.size = this.data.options.length;\n      if (this.data.multiSelect) {\n        selectElement.multiple = true;\n      }\n    }\n\n    // Insert the options into the choice field.\n    for (const option of this.data.options) {\n      const optionElement = document.createElement(\"option\");\n      optionElement.textContent = option.displayValue;\n      optionElement.value = option.exportValue;\n      if (this.data.fieldValue.includes(option.exportValue)) {\n        optionElement.setAttribute(\"selected\", true);\n      }\n      selectElement.appendChild(optionElement);\n    }\n\n    selectElement.addEventListener(\"input\", function (event) {\n      const options = event.target.options;\n      const value = options[options.selectedIndex].value;\n      storage.setValue(id, value);\n    });\n\n    this.container.appendChild(selectElement);\n    return this.container;\n  }\n}\n\nclass PopupAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(parameters.data.title || parameters.data.contents);\n    super(parameters, isRenderable);\n  }\n\n  /**\n   * Render the popup annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof PopupAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    // Do not render popup annotations for parent elements with these types as\n    // they create the popups themselves (because of custom trigger divs).\n    const IGNORE_TYPES = [\n      \"Line\",\n      \"Square\",\n      \"Circle\",\n      \"PolyLine\",\n      \"Polygon\",\n      \"Ink\",\n    ];\n\n    this.container.className = \"popupAnnotation\";\n\n    if (IGNORE_TYPES.includes(this.data.parentType)) {\n      return this.container;\n    }\n\n    const selector = `[data-annotation-id=\"${this.data.parentId}\"]`;\n    const parentElement = this.layer.querySelector(selector);\n    if (!parentElement) {\n      return this.container;\n    }\n\n    const popup = new PopupElement({\n      container: this.container,\n      trigger: parentElement,\n      color: this.data.color,\n      title: this.data.title,\n      modificationDate: this.data.modificationDate,\n      contents: this.data.contents,\n    });\n\n    // Position the popup next to the parent annotation's container.\n    // PDF viewers ignore a popup annotation's rectangle.\n    const parentLeft = parseFloat(parentElement.style.left);\n    const parentWidth = parseFloat(parentElement.style.width);\n    this.container.style.transformOrigin = `-${parentLeft + parentWidth}px -${\n      parentElement.style.top\n    }`;\n    this.container.style.left = `${parentLeft + parentWidth}px`;\n\n    this.container.appendChild(popup.render());\n    return this.container;\n  }\n}\n\nclass PopupElement {\n  constructor(parameters) {\n    this.container = parameters.container;\n    this.trigger = parameters.trigger;\n    this.color = parameters.color;\n    this.title = parameters.title;\n    this.modificationDate = parameters.modificationDate;\n    this.contents = parameters.contents;\n    this.hideWrapper = parameters.hideWrapper || false;\n\n    this.pinned = false;\n  }\n\n  /**\n   * Render the popup's HTML element.\n   *\n   * @public\n   * @memberof PopupElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    const BACKGROUND_ENLIGHT = 0.7;\n\n    const wrapper = document.createElement(\"div\");\n    wrapper.className = \"popupWrapper\";\n\n    // For Popup annotations we hide the entire section because it contains\n    // only the popup. However, for Text annotations without a separate Popup\n    // annotation, we cannot hide the entire container as the image would\n    // disappear too. In that special case, hiding the wrapper suffices.\n    this.hideElement = this.hideWrapper ? wrapper : this.container;\n    this.hideElement.setAttribute(\"hidden\", true);\n\n    const popup = document.createElement(\"div\");\n    popup.className = \"popup\";\n\n    const color = this.color;\n    if (color) {\n      // Enlighten the color.\n      const r = BACKGROUND_ENLIGHT * (255 - color[0]) + color[0];\n      const g = BACKGROUND_ENLIGHT * (255 - color[1]) + color[1];\n      const b = BACKGROUND_ENLIGHT * (255 - color[2]) + color[2];\n      popup.style.backgroundColor = Util.makeCssRgb(r | 0, g | 0, b | 0);\n    }\n\n    const title = document.createElement(\"h1\");\n    title.textContent = this.title;\n    popup.appendChild(title);\n\n    // The modification date is shown in the popup instead of the creation\n    // date if it is available and can be parsed correctly, which is\n    // consistent with other viewers such as Adobe Acrobat.\n    const dateObject = PDFDateString.toDateObject(this.modificationDate);\n    if (dateObject) {\n      const modificationDate = document.createElement(\"span\");\n      modificationDate.textContent = \"{{date}}, {{time}}\";\n      modificationDate.dataset.l10nId = \"annotation_date_string\";\n      modificationDate.dataset.l10nArgs = JSON.stringify({\n        date: dateObject.toLocaleDateString(),\n        time: dateObject.toLocaleTimeString(),\n      });\n      popup.appendChild(modificationDate);\n    }\n\n    const contents = this._formatContents(this.contents);\n    popup.appendChild(contents);\n\n    // Attach the event listeners to the trigger element.\n    this.trigger.addEventListener(\"click\", this._toggle.bind(this));\n    this.trigger.addEventListener(\"mouseover\", this._show.bind(this, false));\n    this.trigger.addEventListener(\"mouseout\", this._hide.bind(this, false));\n    popup.addEventListener(\"click\", this._hide.bind(this, true));\n\n    wrapper.appendChild(popup);\n    return wrapper;\n  }\n\n  /**\n   * Format the contents of the popup by adding newlines where necessary.\n   *\n   * @private\n   * @param {string} contents\n   * @memberof PopupElement\n   * @returns {HTMLParagraphElement}\n   */\n  _formatContents(contents) {\n    const p = document.createElement(\"p\");\n    const lines = contents.split(/(?:\\r\\n?|\\n)/);\n    for (let i = 0, ii = lines.length; i < ii; ++i) {\n      const line = lines[i];\n      p.appendChild(document.createTextNode(line));\n      if (i < ii - 1) {\n        p.appendChild(document.createElement(\"br\"));\n      }\n    }\n    return p;\n  }\n\n  /**\n   * Toggle the visibility of the popup.\n   *\n   * @private\n   * @memberof PopupElement\n   */\n  _toggle() {\n    if (this.pinned) {\n      this._hide(true);\n    } else {\n      this._show(true);\n    }\n  }\n\n  /**\n   * Show the popup.\n   *\n   * @private\n   * @param {boolean} pin\n   * @memberof PopupElement\n   */\n  _show(pin = false) {\n    if (pin) {\n      this.pinned = true;\n    }\n    if (this.hideElement.hasAttribute(\"hidden\")) {\n      this.hideElement.removeAttribute(\"hidden\");\n      this.container.style.zIndex += 1;\n    }\n  }\n\n  /**\n   * Hide the popup.\n   *\n   * @private\n   * @param {boolean} unpin\n   * @memberof PopupElement\n   */\n  _hide(unpin = true) {\n    if (unpin) {\n      this.pinned = false;\n    }\n    if (!this.hideElement.hasAttribute(\"hidden\") && !this.pinned) {\n      this.hideElement.setAttribute(\"hidden\", true);\n      this.container.style.zIndex -= 1;\n    }\n  }\n}\n\nclass FreeTextAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.title ||\n      parameters.data.contents\n    );\n    super(parameters, isRenderable, /* ignoreBorder = */ true);\n  }\n\n  /**\n   * Render the free text annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof FreeTextAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"freeTextAnnotation\";\n\n    if (!this.data.hasPopup) {\n      this._createPopup(this.container, null, this.data);\n    }\n    return this.container;\n  }\n}\n\nclass LineAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.title ||\n      parameters.data.contents\n    );\n    super(parameters, isRenderable, /* ignoreBorder = */ true);\n  }\n\n  /**\n   * Render the line annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof LineAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"lineAnnotation\";\n\n    // Create an invisible line with the same starting and ending coordinates\n    // that acts as the trigger for the popup. Only the line itself should\n    // trigger the popup, not the entire container.\n    const data = this.data;\n    const width = data.rect[2] - data.rect[0];\n    const height = data.rect[3] - data.rect[1];\n    const svg = this.svgFactory.create(width, height);\n\n    // PDF coordinates are calculated from a bottom left origin, so transform\n    // the line coordinates to a top left origin for the SVG element.\n    const line = this.svgFactory.createElement(\"svg:line\");\n    line.setAttribute(\"x1\", data.rect[2] - data.lineCoordinates[0]);\n    line.setAttribute(\"y1\", data.rect[3] - data.lineCoordinates[1]);\n    line.setAttribute(\"x2\", data.rect[2] - data.lineCoordinates[2]);\n    line.setAttribute(\"y2\", data.rect[3] - data.lineCoordinates[3]);\n    // Ensure that the 'stroke-width' is always non-zero, since otherwise it\n    // won't be possible to open/close the popup (note e.g. issue 11122).\n    line.setAttribute(\"stroke-width\", data.borderStyle.width || 1);\n    line.setAttribute(\"stroke\", \"transparent\");\n\n    svg.appendChild(line);\n    this.container.append(svg);\n\n    // Create the popup ourselves so that we can bind it to the line instead\n    // of to the entire container (which is the default).\n    this._createPopup(this.container, line, data);\n\n    return this.container;\n  }\n}\n\nclass SquareAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.title ||\n      parameters.data.contents\n    );\n    super(parameters, isRenderable, /* ignoreBorder = */ true);\n  }\n\n  /**\n   * Render the square annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof SquareAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"squareAnnotation\";\n\n    // Create an invisible square with the same rectangle that acts as the\n    // trigger for the popup. Only the square itself should trigger the\n    // popup, not the entire container.\n    const data = this.data;\n    const width = data.rect[2] - data.rect[0];\n    const height = data.rect[3] - data.rect[1];\n    const svg = this.svgFactory.create(width, height);\n\n    // The browser draws half of the borders inside the square and half of\n    // the borders outside the square by default. This behavior cannot be\n    // changed programmatically, so correct for that here.\n    const borderWidth = data.borderStyle.width;\n    const square = this.svgFactory.createElement(\"svg:rect\");\n    square.setAttribute(\"x\", borderWidth / 2);\n    square.setAttribute(\"y\", borderWidth / 2);\n    square.setAttribute(\"width\", width - borderWidth);\n    square.setAttribute(\"height\", height - borderWidth);\n    // Ensure that the 'stroke-width' is always non-zero, since otherwise it\n    // won't be possible to open/close the popup (note e.g. issue 11122).\n    square.setAttribute(\"stroke-width\", borderWidth || 1);\n    square.setAttribute(\"stroke\", \"transparent\");\n    square.setAttribute(\"fill\", \"none\");\n\n    svg.appendChild(square);\n    this.container.append(svg);\n\n    // Create the popup ourselves so that we can bind it to the square instead\n    // of to the entire container (which is the default).\n    this._createPopup(this.container, square, data);\n\n    return this.container;\n  }\n}\n\nclass CircleAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.title ||\n      parameters.data.contents\n    );\n    super(parameters, isRenderable, /* ignoreBorder = */ true);\n  }\n\n  /**\n   * Render the circle annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof CircleAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"circleAnnotation\";\n\n    // Create an invisible circle with the same ellipse that acts as the\n    // trigger for the popup. Only the circle itself should trigger the\n    // popup, not the entire container.\n    const data = this.data;\n    const width = data.rect[2] - data.rect[0];\n    const height = data.rect[3] - data.rect[1];\n    const svg = this.svgFactory.create(width, height);\n\n    // The browser draws half of the borders inside the circle and half of\n    // the borders outside the circle by default. This behavior cannot be\n    // changed programmatically, so correct for that here.\n    const borderWidth = data.borderStyle.width;\n    const circle = this.svgFactory.createElement(\"svg:ellipse\");\n    circle.setAttribute(\"cx\", width / 2);\n    circle.setAttribute(\"cy\", height / 2);\n    circle.setAttribute(\"rx\", width / 2 - borderWidth / 2);\n    circle.setAttribute(\"ry\", height / 2 - borderWidth / 2);\n    // Ensure that the 'stroke-width' is always non-zero, since otherwise it\n    // won't be possible to open/close the popup (note e.g. issue 11122).\n    circle.setAttribute(\"stroke-width\", borderWidth || 1);\n    circle.setAttribute(\"stroke\", \"transparent\");\n    circle.setAttribute(\"fill\", \"none\");\n\n    svg.appendChild(circle);\n    this.container.append(svg);\n\n    // Create the popup ourselves so that we can bind it to the circle instead\n    // of to the entire container (which is the default).\n    this._createPopup(this.container, circle, data);\n\n    return this.container;\n  }\n}\n\nclass PolylineAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.title ||\n      parameters.data.contents\n    );\n    super(parameters, isRenderable, /* ignoreBorder = */ true);\n\n    this.containerClassName = \"polylineAnnotation\";\n    this.svgElementName = \"svg:polyline\";\n  }\n\n  /**\n   * Render the polyline annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof PolylineAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = this.containerClassName;\n\n    // Create an invisible polyline with the same points that acts as the\n    // trigger for the popup. Only the polyline itself should trigger the\n    // popup, not the entire container.\n    const data = this.data;\n    const width = data.rect[2] - data.rect[0];\n    const height = data.rect[3] - data.rect[1];\n    const svg = this.svgFactory.create(width, height);\n\n    // Convert the vertices array to a single points string that the SVG\n    // polyline element expects (\"x1,y1 x2,y2 ...\"). PDF coordinates are\n    // calculated from a bottom left origin, so transform the polyline\n    // coordinates to a top left origin for the SVG element.\n    let points = [];\n    for (const coordinate of data.vertices) {\n      const x = coordinate.x - data.rect[0];\n      const y = data.rect[3] - coordinate.y;\n      points.push(x + \",\" + y);\n    }\n    points = points.join(\" \");\n\n    const polyline = this.svgFactory.createElement(this.svgElementName);\n    polyline.setAttribute(\"points\", points);\n    // Ensure that the 'stroke-width' is always non-zero, since otherwise it\n    // won't be possible to open/close the popup (note e.g. issue 11122).\n    polyline.setAttribute(\"stroke-width\", data.borderStyle.width || 1);\n    polyline.setAttribute(\"stroke\", \"transparent\");\n    polyline.setAttribute(\"fill\", \"none\");\n\n    svg.appendChild(polyline);\n    this.container.append(svg);\n\n    // Create the popup ourselves so that we can bind it to the polyline\n    // instead of to the entire container (which is the default).\n    this._createPopup(this.container, polyline, data);\n\n    return this.container;\n  }\n}\n\nclass PolygonAnnotationElement extends PolylineAnnotationElement {\n  constructor(parameters) {\n    // Polygons are specific forms of polylines, so reuse their logic.\n    super(parameters);\n\n    this.containerClassName = \"polygonAnnotation\";\n    this.svgElementName = \"svg:polygon\";\n  }\n}\n\nclass CaretAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.title ||\n      parameters.data.contents\n    );\n    super(parameters, isRenderable, /* ignoreBorder = */ true);\n  }\n\n  /**\n   * Render the caret annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof CaretAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"caretAnnotation\";\n\n    if (!this.data.hasPopup) {\n      this._createPopup(this.container, null, this.data);\n    }\n    return this.container;\n  }\n}\n\nclass InkAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.title ||\n      parameters.data.contents\n    );\n    super(parameters, isRenderable, /* ignoreBorder = */ true);\n\n    this.containerClassName = \"inkAnnotation\";\n\n    // Use the polyline SVG element since it allows us to use coordinates\n    // directly and to draw both straight lines and curves.\n    this.svgElementName = \"svg:polyline\";\n  }\n\n  /**\n   * Render the ink annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof InkAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = this.containerClassName;\n\n    // Create an invisible polyline with the same points that acts as the\n    // trigger for the popup.\n    const data = this.data;\n    const width = data.rect[2] - data.rect[0];\n    const height = data.rect[3] - data.rect[1];\n    const svg = this.svgFactory.create(width, height);\n\n    for (const inkList of data.inkLists) {\n      // Convert the ink list to a single points string that the SVG\n      // polyline element expects (\"x1,y1 x2,y2 ...\"). PDF coordinates are\n      // calculated from a bottom left origin, so transform the polyline\n      // coordinates to a top left origin for the SVG element.\n      let points = [];\n      for (const coordinate of inkList) {\n        const x = coordinate.x - data.rect[0];\n        const y = data.rect[3] - coordinate.y;\n        points.push(`${x},${y}`);\n      }\n      points = points.join(\" \");\n\n      const polyline = this.svgFactory.createElement(this.svgElementName);\n      polyline.setAttribute(\"points\", points);\n      // Ensure that the 'stroke-width' is always non-zero, since otherwise it\n      // won't be possible to open/close the popup (note e.g. issue 11122).\n      polyline.setAttribute(\"stroke-width\", data.borderStyle.width || 1);\n      polyline.setAttribute(\"stroke\", \"transparent\");\n      polyline.setAttribute(\"fill\", \"none\");\n\n      // Create the popup ourselves so that we can bind it to the polyline\n      // instead of to the entire container (which is the default).\n      this._createPopup(this.container, polyline, data);\n\n      svg.appendChild(polyline);\n    }\n\n    this.container.append(svg);\n    return this.container;\n  }\n}\n\nclass HighlightAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.title ||\n      parameters.data.contents\n    );\n    super(parameters, isRenderable, /* ignoreBorder = */ true);\n  }\n\n  /**\n   * Render the highlight annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof HighlightAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"highlightAnnotation\";\n\n    if (!this.data.hasPopup) {\n      this._createPopup(this.container, null, this.data);\n    }\n    return this.container;\n  }\n}\n\nclass UnderlineAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.title ||\n      parameters.data.contents\n    );\n    super(parameters, isRenderable, /* ignoreBorder = */ true);\n  }\n\n  /**\n   * Render the underline annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof UnderlineAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"underlineAnnotation\";\n\n    if (!this.data.hasPopup) {\n      this._createPopup(this.container, null, this.data);\n    }\n    return this.container;\n  }\n}\n\nclass SquigglyAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.title ||\n      parameters.data.contents\n    );\n    super(parameters, isRenderable, /* ignoreBorder = */ true);\n  }\n\n  /**\n   * Render the squiggly annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof SquigglyAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"squigglyAnnotation\";\n\n    if (!this.data.hasPopup) {\n      this._createPopup(this.container, null, this.data);\n    }\n    return this.container;\n  }\n}\n\nclass StrikeOutAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.title ||\n      parameters.data.contents\n    );\n    super(parameters, isRenderable, /* ignoreBorder = */ true);\n  }\n\n  /**\n   * Render the strikeout annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof StrikeOutAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"strikeoutAnnotation\";\n\n    if (!this.data.hasPopup) {\n      this._createPopup(this.container, null, this.data);\n    }\n    return this.container;\n  }\n}\n\nclass StampAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    const isRenderable = !!(\n      parameters.data.hasPopup ||\n      parameters.data.title ||\n      parameters.data.contents\n    );\n    super(parameters, isRenderable, /* ignoreBorder = */ true);\n  }\n\n  /**\n   * Render the stamp annotation's HTML element in the empty container.\n   *\n   * @public\n   * @memberof StampAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"stampAnnotation\";\n\n    if (!this.data.hasPopup) {\n      this._createPopup(this.container, null, this.data);\n    }\n    return this.container;\n  }\n}\n\nclass FileAttachmentAnnotationElement extends AnnotationElement {\n  constructor(parameters) {\n    super(parameters, /* isRenderable = */ true);\n\n    const { filename, content } = this.data.file;\n    this.filename = getFilenameFromUrl(filename);\n    this.content = content;\n\n    if (this.linkService.eventBus) {\n      this.linkService.eventBus.dispatch(\"fileattachmentannotation\", {\n        source: this,\n        id: stringToPDFString(filename),\n        filename,\n        content,\n      });\n    }\n  }\n\n  /**\n   * Render the file attachment annotation's HTML element in the empty\n   * container.\n   *\n   * @public\n   * @memberof FileAttachmentAnnotationElement\n   * @returns {HTMLSectionElement}\n   */\n  render() {\n    this.container.className = \"fileAttachmentAnnotation\";\n\n    const trigger = document.createElement(\"div\");\n    trigger.style.height = this.container.style.height;\n    trigger.style.width = this.container.style.width;\n    trigger.addEventListener(\"dblclick\", this._download.bind(this));\n\n    if (!this.data.hasPopup && (this.data.title || this.data.contents)) {\n      this._createPopup(this.container, trigger, this.data);\n    }\n\n    this.container.appendChild(trigger);\n    return this.container;\n  }\n\n  /**\n   * Download the file attachment associated with this annotation.\n   *\n   * @private\n   * @memberof FileAttachmentAnnotationElement\n   */\n  _download() {\n    if (!this.downloadManager) {\n      warn(\"Download cannot be started due to unavailable download manager\");\n      return;\n    }\n    this.downloadManager.downloadData(this.content, this.filename, \"\");\n  }\n}\n\n/**\n * @typedef {Object} AnnotationLayerParameters\n * @property {PageViewport} viewport\n * @property {HTMLDivElement} div\n * @property {Array} annotations\n * @property {PDFPage} page\n * @property {IPDFLinkService} linkService\n * @property {DownloadManager} downloadManager\n * @property {string} [imageResourcesPath] - Path for image resources, mainly\n *   for annotation icons. Include trailing slash.\n * @property {boolean} renderInteractiveForms\n */\n\nclass AnnotationLayer {\n  /**\n   * Render a new annotation layer with all annotation elements.\n   *\n   * @public\n   * @param {AnnotationLayerParameters} parameters\n   * @memberof AnnotationLayer\n   */\n  static render(parameters) {\n    const sortedAnnotations = [],\n      popupAnnotations = [];\n    // Ensure that Popup annotations are handled last, since they're dependant\n    // upon the parent annotation having already been rendered (please refer to\n    // the `PopupAnnotationElement.render` method); fixes issue 11362.\n    for (const data of parameters.annotations) {\n      if (!data) {\n        continue;\n      }\n      if (data.annotationType === AnnotationType.POPUP) {\n        popupAnnotations.push(data);\n        continue;\n      }\n      sortedAnnotations.push(data);\n    }\n    if (popupAnnotations.length) {\n      sortedAnnotations.push(...popupAnnotations);\n    }\n\n    for (const data of sortedAnnotations) {\n      const element = AnnotationElementFactory.create({\n        data,\n        layer: parameters.div,\n        page: parameters.page,\n        viewport: parameters.viewport,\n        linkService: parameters.linkService,\n        downloadManager: parameters.downloadManager,\n        imageResourcesPath: parameters.imageResourcesPath || \"\",\n        renderInteractiveForms:\n          typeof parameters.renderInteractiveForms === \"boolean\"\n            ? parameters.renderInteractiveForms\n            : true,\n        svgFactory: new DOMSVGFactory(),\n        annotationStorage:\n          parameters.annotationStorage || new AnnotationStorage(),\n      });\n      if (element.isRenderable) {\n        parameters.div.appendChild(element.render());\n      }\n    }\n  }\n\n  /**\n   * Update the annotation elements on existing annotation layer.\n   *\n   * @public\n   * @param {AnnotationLayerParameters} parameters\n   * @memberof AnnotationLayer\n   */\n  static update(parameters) {\n    for (const data of parameters.annotations) {\n      const element = parameters.div.querySelector(\n        `[data-annotation-id=\"${data.id}\"]`\n      );\n      if (element) {\n        element.style.transform = `matrix(${parameters.viewport.transform.join(\n          \",\"\n        )})`;\n      }\n    }\n    parameters.div.removeAttribute(\"hidden\");\n  }\n}\n\nexport { AnnotationLayer };\n","/* Copyright 2015 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  AbortException,\n  createPromiseCapability,\n  Util,\n} from \"../shared/util.js\";\n\n/**\n * Text layer render parameters.\n *\n * @typedef {Object} TextLayerRenderParameters\n * @property {import(\"./api\").TextContent} [textContent] - Text content to\n *   render (the object is returned by the page's `getTextContent` method).\n * @property {ReadableStream} [textContentStream] - Text content stream to\n *   render (the stream is returned by the page's `streamTextContent` method).\n * @property {HTMLElement} container - HTML element that will contain text runs.\n * @property {import(\"./display_utils\").PageViewport} viewport - The target\n *   viewport to properly layout the text runs.\n * @property {Array<HTMLElement>} [textDivs] - HTML elements that are correspond\n *   to the text items of the textContent input. This is output and shall be\n *   initially be set to empty array.\n * @property {Array<string>} [textContentItemsStr] - Strings that correspond to\n *    the `str` property of the text items of textContent input. This is output\n *   and shall be initially be set to empty array.\n * @property {number} [timeout] - Delay in milliseconds before rendering of the\n *   text runs occurs.\n * @property {boolean} [enhanceTextSelection] - Whether to turn on the text\n *   selection enhancement.\n */\n\n/**\n * @typedef {Object} TextLayerRenderTask\n * @property {Promise<void>} promise\n * @property {() => void} cancel\n * @property {(expandDivs: boolean) => void} expandTextDivs\n */\n\n/**\n * @type {(renderParameters: TextLayerRenderParameters) => TextLayerRenderTask}\n */\nvar renderTextLayer = (function renderTextLayerClosure() {\n  var MAX_TEXT_DIVS_TO_RENDER = 100000;\n\n  var NonWhitespaceRegexp = /\\S/;\n\n  function isAllWhitespace(str) {\n    return !NonWhitespaceRegexp.test(str);\n  }\n\n  function appendText(task, geom, styles) {\n    // Initialize all used properties to keep the caches monomorphic.\n    var textDiv = document.createElement(\"span\");\n    var textDivProperties = {\n      angle: 0,\n      canvasWidth: 0,\n      isWhitespace: false,\n      originalTransform: null,\n      paddingBottom: 0,\n      paddingLeft: 0,\n      paddingRight: 0,\n      paddingTop: 0,\n      scale: 1,\n    };\n\n    task._textDivs.push(textDiv);\n    if (isAllWhitespace(geom.str)) {\n      textDivProperties.isWhitespace = true;\n      task._textDivProperties.set(textDiv, textDivProperties);\n      return;\n    }\n\n    var tx = Util.transform(task._viewport.transform, geom.transform);\n    var angle = Math.atan2(tx[1], tx[0]);\n    var style = styles[geom.fontName];\n    if (style.vertical) {\n      angle += Math.PI / 2;\n    }\n    var fontHeight = Math.sqrt(tx[2] * tx[2] + tx[3] * tx[3]);\n    var fontAscent = fontHeight;\n    if (style.ascent) {\n      fontAscent = style.ascent * fontAscent;\n    } else if (style.descent) {\n      fontAscent = (1 + style.descent) * fontAscent;\n    }\n\n    let left, top;\n    if (angle === 0) {\n      left = tx[4];\n      top = tx[5] - fontAscent;\n    } else {\n      left = tx[4] + fontAscent * Math.sin(angle);\n      top = tx[5] - fontAscent * Math.cos(angle);\n    }\n    // Setting the style properties individually, rather than all at once,\n    // should be OK since the `textDiv` isn't appended to the document yet.\n    textDiv.style.left = `${left}px`;\n    textDiv.style.top = `${top}px`;\n    textDiv.style.fontSize = `${fontHeight}px`;\n    textDiv.style.fontFamily = style.fontFamily;\n\n    textDiv.textContent = geom.str;\n    // `fontName` is only used by the FontInspector, and we only use `dataset`\n    // here to make the font name available in the debugger.\n    if (task._fontInspectorEnabled) {\n      textDiv.dataset.fontName = geom.fontName;\n    }\n    if (angle !== 0) {\n      textDivProperties.angle = angle * (180 / Math.PI);\n    }\n    // We don't bother scaling single-char text divs, because it has very\n    // little effect on text highlighting. This makes scrolling on docs with\n    // lots of such divs a lot faster.\n    let shouldScaleText = false;\n    if (geom.str.length > 1) {\n      shouldScaleText = true;\n    } else if (geom.transform[0] !== geom.transform[3]) {\n      const absScaleX = Math.abs(geom.transform[0]),\n        absScaleY = Math.abs(geom.transform[3]);\n      // When the horizontal/vertical scaling differs significantly, also scale\n      // even single-char text to improve highlighting (fixes issue11713.pdf).\n      if (\n        absScaleX !== absScaleY &&\n        Math.max(absScaleX, absScaleY) / Math.min(absScaleX, absScaleY) > 1.5\n      ) {\n        shouldScaleText = true;\n      }\n    }\n    if (shouldScaleText) {\n      if (style.vertical) {\n        textDivProperties.canvasWidth = geom.height * task._viewport.scale;\n      } else {\n        textDivProperties.canvasWidth = geom.width * task._viewport.scale;\n      }\n    }\n    task._textDivProperties.set(textDiv, textDivProperties);\n    if (task._textContentStream) {\n      task._layoutText(textDiv);\n    }\n\n    if (task._enhanceTextSelection) {\n      var angleCos = 1,\n        angleSin = 0;\n      if (angle !== 0) {\n        angleCos = Math.cos(angle);\n        angleSin = Math.sin(angle);\n      }\n      var divWidth =\n        (style.vertical ? geom.height : geom.width) * task._viewport.scale;\n      var divHeight = fontHeight;\n\n      var m, b;\n      if (angle !== 0) {\n        m = [angleCos, angleSin, -angleSin, angleCos, left, top];\n        b = Util.getAxialAlignedBoundingBox([0, 0, divWidth, divHeight], m);\n      } else {\n        b = [left, top, left + divWidth, top + divHeight];\n      }\n\n      task._bounds.push({\n        left: b[0],\n        top: b[1],\n        right: b[2],\n        bottom: b[3],\n        div: textDiv,\n        size: [divWidth, divHeight],\n        m,\n      });\n    }\n  }\n\n  function render(task) {\n    if (task._canceled) {\n      return;\n    }\n    var textDivs = task._textDivs;\n    var capability = task._capability;\n    var textDivsLength = textDivs.length;\n\n    // No point in rendering many divs as it would make the browser\n    // unusable even after the divs are rendered.\n    if (textDivsLength > MAX_TEXT_DIVS_TO_RENDER) {\n      task._renderingDone = true;\n      capability.resolve();\n      return;\n    }\n\n    if (!task._textContentStream) {\n      for (var i = 0; i < textDivsLength; i++) {\n        task._layoutText(textDivs[i]);\n      }\n    }\n\n    task._renderingDone = true;\n    capability.resolve();\n  }\n\n  function findPositiveMin(ts, offset, count) {\n    let result = 0;\n    for (let i = 0; i < count; i++) {\n      const t = ts[offset++];\n      if (t > 0) {\n        result = result ? Math.min(t, result) : t;\n      }\n    }\n    return result;\n  }\n\n  function expand(task) {\n    var bounds = task._bounds;\n    var viewport = task._viewport;\n\n    var expanded = expandBounds(viewport.width, viewport.height, bounds);\n    for (var i = 0; i < expanded.length; i++) {\n      var div = bounds[i].div;\n      var divProperties = task._textDivProperties.get(div);\n      if (divProperties.angle === 0) {\n        divProperties.paddingLeft = bounds[i].left - expanded[i].left;\n        divProperties.paddingTop = bounds[i].top - expanded[i].top;\n        divProperties.paddingRight = expanded[i].right - bounds[i].right;\n        divProperties.paddingBottom = expanded[i].bottom - bounds[i].bottom;\n        task._textDivProperties.set(div, divProperties);\n        continue;\n      }\n      // Box is rotated -- trying to find padding so rotated div will not\n      // exceed its expanded bounds.\n      var e = expanded[i],\n        b = bounds[i];\n      var m = b.m,\n        c = m[0],\n        s = m[1];\n      // Finding intersections with expanded box.\n      var points = [[0, 0], [0, b.size[1]], [b.size[0], 0], b.size];\n      var ts = new Float64Array(64);\n      points.forEach(function (p, j) {\n        var t = Util.applyTransform(p, m);\n        ts[j + 0] = c && (e.left - t[0]) / c;\n        ts[j + 4] = s && (e.top - t[1]) / s;\n        ts[j + 8] = c && (e.right - t[0]) / c;\n        ts[j + 12] = s && (e.bottom - t[1]) / s;\n\n        ts[j + 16] = s && (e.left - t[0]) / -s;\n        ts[j + 20] = c && (e.top - t[1]) / c;\n        ts[j + 24] = s && (e.right - t[0]) / -s;\n        ts[j + 28] = c && (e.bottom - t[1]) / c;\n\n        ts[j + 32] = c && (e.left - t[0]) / -c;\n        ts[j + 36] = s && (e.top - t[1]) / -s;\n        ts[j + 40] = c && (e.right - t[0]) / -c;\n        ts[j + 44] = s && (e.bottom - t[1]) / -s;\n\n        ts[j + 48] = s && (e.left - t[0]) / s;\n        ts[j + 52] = c && (e.top - t[1]) / -c;\n        ts[j + 56] = s && (e.right - t[0]) / s;\n        ts[j + 60] = c && (e.bottom - t[1]) / -c;\n      });\n      // Not based on math, but to simplify calculations, using cos and sin\n      // absolute values to not exceed the box (it can but insignificantly).\n      var boxScale = 1 + Math.min(Math.abs(c), Math.abs(s));\n      divProperties.paddingLeft = findPositiveMin(ts, 32, 16) / boxScale;\n      divProperties.paddingTop = findPositiveMin(ts, 48, 16) / boxScale;\n      divProperties.paddingRight = findPositiveMin(ts, 0, 16) / boxScale;\n      divProperties.paddingBottom = findPositiveMin(ts, 16, 16) / boxScale;\n      task._textDivProperties.set(div, divProperties);\n    }\n  }\n\n  function expandBounds(width, height, boxes) {\n    var bounds = boxes.map(function (box, i) {\n      return {\n        x1: box.left,\n        y1: box.top,\n        x2: box.right,\n        y2: box.bottom,\n        index: i,\n        x1New: undefined,\n        x2New: undefined,\n      };\n    });\n    expandBoundsLTR(width, bounds);\n    var expanded = new Array(boxes.length);\n    bounds.forEach(function (b) {\n      var i = b.index;\n      expanded[i] = {\n        left: b.x1New,\n        top: 0,\n        right: b.x2New,\n        bottom: 0,\n      };\n    });\n\n    // Rotating on 90 degrees and extending extended boxes. Reusing the bounds\n    // array and objects.\n    boxes.map(function (box, i) {\n      var e = expanded[i],\n        b = bounds[i];\n      b.x1 = box.top;\n      b.y1 = width - e.right;\n      b.x2 = box.bottom;\n      b.y2 = width - e.left;\n      b.index = i;\n      b.x1New = undefined;\n      b.x2New = undefined;\n    });\n    expandBoundsLTR(height, bounds);\n\n    bounds.forEach(function (b) {\n      var i = b.index;\n      expanded[i].top = b.x1New;\n      expanded[i].bottom = b.x2New;\n    });\n    return expanded;\n  }\n\n  function expandBoundsLTR(width, bounds) {\n    // Sorting by x1 coordinate and walk by the bounds in the same order.\n    bounds.sort(function (a, b) {\n      return a.x1 - b.x1 || a.index - b.index;\n    });\n\n    // First we see on the horizon is a fake boundary.\n    var fakeBoundary = {\n      x1: -Infinity,\n      y1: -Infinity,\n      x2: 0,\n      y2: Infinity,\n      index: -1,\n      x1New: 0,\n      x2New: 0,\n    };\n    var horizon = [\n      {\n        start: -Infinity,\n        end: Infinity,\n        boundary: fakeBoundary,\n      },\n    ];\n\n    bounds.forEach(function (boundary) {\n      // Searching for the affected part of horizon.\n      // TODO red-black tree or simple binary search\n      var i = 0;\n      while (i < horizon.length && horizon[i].end <= boundary.y1) {\n        i++;\n      }\n      var j = horizon.length - 1;\n      while (j >= 0 && horizon[j].start >= boundary.y2) {\n        j--;\n      }\n\n      var horizonPart, affectedBoundary;\n      var q,\n        k,\n        maxXNew = -Infinity;\n      for (q = i; q <= j; q++) {\n        horizonPart = horizon[q];\n        affectedBoundary = horizonPart.boundary;\n        var xNew;\n        if (affectedBoundary.x2 > boundary.x1) {\n          // In the middle of the previous element, new x shall be at the\n          // boundary start. Extending if further if the affected boundary\n          // placed on top of the current one.\n          xNew =\n            affectedBoundary.index > boundary.index\n              ? affectedBoundary.x1New\n              : boundary.x1;\n        } else if (affectedBoundary.x2New === undefined) {\n          // We have some space in between, new x in middle will be a fair\n          // choice.\n          xNew = (affectedBoundary.x2 + boundary.x1) / 2;\n        } else {\n          // Affected boundary has x2new set, using it as new x.\n          xNew = affectedBoundary.x2New;\n        }\n        if (xNew > maxXNew) {\n          maxXNew = xNew;\n        }\n      }\n\n      // Set new x1 for current boundary.\n      boundary.x1New = maxXNew;\n\n      // Adjusts new x2 for the affected boundaries.\n      for (q = i; q <= j; q++) {\n        horizonPart = horizon[q];\n        affectedBoundary = horizonPart.boundary;\n        if (affectedBoundary.x2New === undefined) {\n          // Was not set yet, choosing new x if possible.\n          if (affectedBoundary.x2 > boundary.x1) {\n            // Current and affected boundaries intersect. If affected boundary\n            // is placed on top of the current, shrinking the affected.\n            if (affectedBoundary.index > boundary.index) {\n              affectedBoundary.x2New = affectedBoundary.x2;\n            }\n          } else {\n            affectedBoundary.x2New = maxXNew;\n          }\n        } else if (affectedBoundary.x2New > maxXNew) {\n          // Affected boundary is touching new x, pushing it back.\n          affectedBoundary.x2New = Math.max(maxXNew, affectedBoundary.x2);\n        }\n      }\n\n      // Fixing the horizon.\n      var changedHorizon = [],\n        lastBoundary = null;\n      for (q = i; q <= j; q++) {\n        horizonPart = horizon[q];\n        affectedBoundary = horizonPart.boundary;\n        // Checking which boundary will be visible.\n        var useBoundary =\n          affectedBoundary.x2 > boundary.x2 ? affectedBoundary : boundary;\n        if (lastBoundary === useBoundary) {\n          // Merging with previous.\n          changedHorizon[changedHorizon.length - 1].end = horizonPart.end;\n        } else {\n          changedHorizon.push({\n            start: horizonPart.start,\n            end: horizonPart.end,\n            boundary: useBoundary,\n          });\n          lastBoundary = useBoundary;\n        }\n      }\n      if (horizon[i].start < boundary.y1) {\n        changedHorizon[0].start = boundary.y1;\n        changedHorizon.unshift({\n          start: horizon[i].start,\n          end: boundary.y1,\n          boundary: horizon[i].boundary,\n        });\n      }\n      if (boundary.y2 < horizon[j].end) {\n        changedHorizon[changedHorizon.length - 1].end = boundary.y2;\n        changedHorizon.push({\n          start: boundary.y2,\n          end: horizon[j].end,\n          boundary: horizon[j].boundary,\n        });\n      }\n\n      // Set x2 new of boundary that is no longer visible (see overlapping case\n      // above).\n      // TODO more efficient, e.g. via reference counting.\n      for (q = i; q <= j; q++) {\n        horizonPart = horizon[q];\n        affectedBoundary = horizonPart.boundary;\n        if (affectedBoundary.x2New !== undefined) {\n          continue;\n        }\n        var used = false;\n        for (\n          k = i - 1;\n          !used && k >= 0 && horizon[k].start >= affectedBoundary.y1;\n          k--\n        ) {\n          used = horizon[k].boundary === affectedBoundary;\n        }\n        for (\n          k = j + 1;\n          !used && k < horizon.length && horizon[k].end <= affectedBoundary.y2;\n          k++\n        ) {\n          used = horizon[k].boundary === affectedBoundary;\n        }\n        for (k = 0; !used && k < changedHorizon.length; k++) {\n          used = changedHorizon[k].boundary === affectedBoundary;\n        }\n        if (!used) {\n          affectedBoundary.x2New = maxXNew;\n        }\n      }\n\n      Array.prototype.splice.apply(\n        horizon,\n        [i, j - i + 1].concat(changedHorizon)\n      );\n    });\n\n    // Set new x2 for all unset boundaries.\n    horizon.forEach(function (horizonPart) {\n      var affectedBoundary = horizonPart.boundary;\n      if (affectedBoundary.x2New === undefined) {\n        affectedBoundary.x2New = Math.max(width, affectedBoundary.x2);\n      }\n    });\n  }\n\n  /**\n   * Text layer rendering task.\n   *\n   * @param {TextContent} textContent\n   * @param {HTMLElement} container\n   * @param {PageViewport} viewport\n   * @param {Array} textDivs\n   * @param {boolean} enhanceTextSelection\n   * @private\n   */\n  function TextLayerRenderTask({\n    textContent,\n    textContentStream,\n    container,\n    viewport,\n    textDivs,\n    textContentItemsStr,\n    enhanceTextSelection,\n  }) {\n    this._textContent = textContent;\n    this._textContentStream = textContentStream;\n    this._container = container;\n    this._document = container.ownerDocument;\n    this._viewport = viewport;\n    this._textDivs = textDivs || [];\n    this._textContentItemsStr = textContentItemsStr || [];\n    this._enhanceTextSelection = !!enhanceTextSelection;\n    this._fontInspectorEnabled = !!(\n      globalThis.FontInspector && globalThis.FontInspector.enabled\n    );\n\n    this._reader = null;\n    this._layoutTextLastFontSize = null;\n    this._layoutTextLastFontFamily = null;\n    this._layoutTextCtx = null;\n    this._textDivProperties = new WeakMap();\n    this._renderingDone = false;\n    this._canceled = false;\n    this._capability = createPromiseCapability();\n    this._renderTimer = null;\n    this._bounds = [];\n\n    // Always clean-up the temporary canvas once rendering is no longer pending.\n    this._capability.promise\n      .finally(() => {\n        if (this._layoutTextCtx) {\n          // Zeroing the width and height cause Firefox to release graphics\n          // resources immediately, which can greatly reduce memory consumption.\n          this._layoutTextCtx.canvas.width = 0;\n          this._layoutTextCtx.canvas.height = 0;\n          this._layoutTextCtx = null;\n        }\n      })\n      .catch(() => {\n        /* Avoid \"Uncaught promise\" messages in the console. */\n      });\n  }\n  TextLayerRenderTask.prototype = {\n    get promise() {\n      return this._capability.promise;\n    },\n\n    cancel: function TextLayer_cancel() {\n      this._canceled = true;\n      if (this._reader) {\n        this._reader.cancel(new AbortException(\"TextLayer task cancelled.\"));\n        this._reader = null;\n      }\n      if (this._renderTimer !== null) {\n        clearTimeout(this._renderTimer);\n        this._renderTimer = null;\n      }\n      this._capability.reject(new Error(\"TextLayer task cancelled.\"));\n    },\n\n    _processItems(items, styleCache) {\n      for (let i = 0, len = items.length; i < len; i++) {\n        this._textContentItemsStr.push(items[i].str);\n        appendText(this, items[i], styleCache);\n      }\n    },\n\n    _layoutText(textDiv) {\n      const textDivProperties = this._textDivProperties.get(textDiv);\n      if (textDivProperties.isWhitespace) {\n        return;\n      }\n\n      let transform = \"\";\n      if (textDivProperties.canvasWidth !== 0) {\n        const { fontSize, fontFamily } = textDiv.style;\n\n        // Only build font string and set to context if different from last.\n        if (\n          fontSize !== this._layoutTextLastFontSize ||\n          fontFamily !== this._layoutTextLastFontFamily\n        ) {\n          this._layoutTextCtx.font = `${fontSize} ${fontFamily}`;\n          this._layoutTextLastFontSize = fontSize;\n          this._layoutTextLastFontFamily = fontFamily;\n        }\n        // Only measure the width for multi-char text divs, see `appendText`.\n        const { width } = this._layoutTextCtx.measureText(textDiv.textContent);\n\n        if (width > 0) {\n          textDivProperties.scale = textDivProperties.canvasWidth / width;\n          transform = `scaleX(${textDivProperties.scale})`;\n        }\n      }\n      if (textDivProperties.angle !== 0) {\n        transform = `rotate(${textDivProperties.angle}deg) ${transform}`;\n      }\n      if (transform.length > 0) {\n        if (this._enhanceTextSelection) {\n          textDivProperties.originalTransform = transform;\n        }\n        textDiv.style.transform = transform;\n      }\n      this._textDivProperties.set(textDiv, textDivProperties);\n      this._container.appendChild(textDiv);\n    },\n\n    _render: function TextLayer_render(timeout) {\n      const capability = createPromiseCapability();\n      let styleCache = Object.create(null);\n\n      // The temporary canvas is used to measure text length in the DOM.\n      const canvas = this._document.createElement(\"canvas\");\n      if (\n        typeof PDFJSDev === \"undefined\" ||\n        PDFJSDev.test(\"MOZCENTRAL || GENERIC\")\n      ) {\n        canvas.mozOpaque = true;\n      }\n      this._layoutTextCtx = canvas.getContext(\"2d\", { alpha: false });\n\n      if (this._textContent) {\n        const textItems = this._textContent.items;\n        const textStyles = this._textContent.styles;\n        this._processItems(textItems, textStyles);\n        capability.resolve();\n      } else if (this._textContentStream) {\n        const pump = () => {\n          this._reader.read().then(({ value, done }) => {\n            if (done) {\n              capability.resolve();\n              return;\n            }\n\n            Object.assign(styleCache, value.styles);\n            this._processItems(value.items, styleCache);\n            pump();\n          }, capability.reject);\n        };\n\n        this._reader = this._textContentStream.getReader();\n        pump();\n      } else {\n        throw new Error(\n          'Neither \"textContent\" nor \"textContentStream\"' +\n            \" parameters specified.\"\n        );\n      }\n\n      capability.promise.then(() => {\n        styleCache = null;\n        if (!timeout) {\n          // Render right away\n          render(this);\n        } else {\n          // Schedule\n          this._renderTimer = setTimeout(() => {\n            render(this);\n            this._renderTimer = null;\n          }, timeout);\n        }\n      }, this._capability.reject);\n    },\n\n    expandTextDivs: function TextLayer_expandTextDivs(expandDivs) {\n      if (!this._enhanceTextSelection || !this._renderingDone) {\n        return;\n      }\n      if (this._bounds !== null) {\n        expand(this);\n        this._bounds = null;\n      }\n      const transformBuf = [],\n        paddingBuf = [];\n\n      for (var i = 0, ii = this._textDivs.length; i < ii; i++) {\n        const div = this._textDivs[i];\n        const divProps = this._textDivProperties.get(div);\n\n        if (divProps.isWhitespace) {\n          continue;\n        }\n        if (expandDivs) {\n          transformBuf.length = 0;\n          paddingBuf.length = 0;\n\n          if (divProps.originalTransform) {\n            transformBuf.push(divProps.originalTransform);\n          }\n          if (divProps.paddingTop > 0) {\n            paddingBuf.push(`${divProps.paddingTop}px`);\n            transformBuf.push(`translateY(${-divProps.paddingTop}px)`);\n          } else {\n            paddingBuf.push(0);\n          }\n          if (divProps.paddingRight > 0) {\n            paddingBuf.push(`${divProps.paddingRight / divProps.scale}px`);\n          } else {\n            paddingBuf.push(0);\n          }\n          if (divProps.paddingBottom > 0) {\n            paddingBuf.push(`${divProps.paddingBottom}px`);\n          } else {\n            paddingBuf.push(0);\n          }\n          if (divProps.paddingLeft > 0) {\n            paddingBuf.push(`${divProps.paddingLeft / divProps.scale}px`);\n            transformBuf.push(\n              `translateX(${-divProps.paddingLeft / divProps.scale}px)`\n            );\n          } else {\n            paddingBuf.push(0);\n          }\n\n          div.style.padding = paddingBuf.join(\" \");\n          if (transformBuf.length) {\n            div.style.transform = transformBuf.join(\" \");\n          }\n        } else {\n          div.style.padding = null;\n          div.style.transform = divProps.originalTransform;\n        }\n      }\n    },\n  };\n\n  // eslint-disable-next-line no-shadow\n  function renderTextLayer(renderParameters) {\n    var task = new TextLayerRenderTask({\n      textContent: renderParameters.textContent,\n      textContentStream: renderParameters.textContentStream,\n      container: renderParameters.container,\n      viewport: renderParameters.viewport,\n      textDivs: renderParameters.textDivs,\n      textContentItemsStr: renderParameters.textContentItemsStr,\n      enhanceTextSelection: renderParameters.enhanceTextSelection,\n    });\n    task._render(renderParameters.timeout);\n    return task;\n  }\n\n  return renderTextLayer;\n})();\n\nexport { renderTextLayer };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* globals __non_webpack_require__ */\n/* eslint no-var: error */\n\nimport {\n  createObjectURL,\n  FONT_IDENTITY_MATRIX,\n  IDENTITY_MATRIX,\n  ImageKind,\n  isNum,\n  OPS,\n  TextRenderingMode,\n  Util,\n  warn,\n} from \"../shared/util.js\";\nimport { DOMSVGFactory } from \"./display_utils.js\";\nimport { isNodeJS } from \"../shared/is_node.js\";\n\n/** @type {any} */\nlet SVGGraphics = function () {\n  throw new Error(\"Not implemented: SVGGraphics\");\n};\n\nif (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) {\n  const SVG_DEFAULTS = {\n    fontStyle: \"normal\",\n    fontWeight: \"normal\",\n    fillColor: \"#000000\",\n  };\n  const XML_NS = \"http://www.w3.org/XML/1998/namespace\";\n  const XLINK_NS = \"http://www.w3.org/1999/xlink\";\n  const LINE_CAP_STYLES = [\"butt\", \"round\", \"square\"];\n  const LINE_JOIN_STYLES = [\"miter\", \"round\", \"bevel\"];\n\n  const convertImgDataToPng = (function () {\n    const PNG_HEADER = new Uint8Array([\n      0x89,\n      0x50,\n      0x4e,\n      0x47,\n      0x0d,\n      0x0a,\n      0x1a,\n      0x0a,\n    ]);\n    const CHUNK_WRAPPER_SIZE = 12;\n\n    const crcTable = new Int32Array(256);\n    for (let i = 0; i < 256; i++) {\n      let c = i;\n      for (let h = 0; h < 8; h++) {\n        if (c & 1) {\n          c = 0xedb88320 ^ ((c >> 1) & 0x7fffffff);\n        } else {\n          c = (c >> 1) & 0x7fffffff;\n        }\n      }\n      crcTable[i] = c;\n    }\n\n    function crc32(data, start, end) {\n      let crc = -1;\n      for (let i = start; i < end; i++) {\n        const a = (crc ^ data[i]) & 0xff;\n        const b = crcTable[a];\n        crc = (crc >>> 8) ^ b;\n      }\n      return crc ^ -1;\n    }\n\n    function writePngChunk(type, body, data, offset) {\n      let p = offset;\n      const len = body.length;\n\n      data[p] = (len >> 24) & 0xff;\n      data[p + 1] = (len >> 16) & 0xff;\n      data[p + 2] = (len >> 8) & 0xff;\n      data[p + 3] = len & 0xff;\n      p += 4;\n\n      data[p] = type.charCodeAt(0) & 0xff;\n      data[p + 1] = type.charCodeAt(1) & 0xff;\n      data[p + 2] = type.charCodeAt(2) & 0xff;\n      data[p + 3] = type.charCodeAt(3) & 0xff;\n      p += 4;\n\n      data.set(body, p);\n      p += body.length;\n\n      const crc = crc32(data, offset + 4, p);\n      data[p] = (crc >> 24) & 0xff;\n      data[p + 1] = (crc >> 16) & 0xff;\n      data[p + 2] = (crc >> 8) & 0xff;\n      data[p + 3] = crc & 0xff;\n    }\n\n    function adler32(data, start, end) {\n      let a = 1;\n      let b = 0;\n      for (let i = start; i < end; ++i) {\n        a = (a + (data[i] & 0xff)) % 65521;\n        b = (b + a) % 65521;\n      }\n      return (b << 16) | a;\n    }\n\n    /**\n     * @param {Uint8Array} literals The input data.\n     * @returns {Uint8Array} The DEFLATE-compressed data stream in zlib format.\n     *   This is the required format for compressed streams in the PNG format:\n     *   http://www.libpng.org/pub/png/spec/1.2/PNG-Compression.html\n     */\n    function deflateSync(literals) {\n      if (!isNodeJS) {\n        // zlib is certainly not available outside of Node.js. We can either use\n        // the pako library for client-side DEFLATE compression, or use the\n        // canvas API of the browser to obtain a more optimal PNG file.\n        return deflateSyncUncompressed(literals);\n      }\n      try {\n        // NOTE: This implementation is far from perfect, but already way better\n        // than not applying any compression.\n        //\n        // A better algorithm will try to choose a good predictor/filter and\n        // then choose a suitable zlib compression strategy (e.g. 3,Z_RLE).\n        //\n        // Node v0.11.12 zlib.deflateSync is introduced (and returns a Buffer).\n        // Node v3.0.0   Buffer inherits from Uint8Array.\n        // Node v8.0.0   zlib.deflateSync accepts Uint8Array as input.\n        let input;\n        // eslint-disable-next-line no-undef\n        if (parseInt(process.versions.node) >= 8) {\n          input = literals;\n        } else {\n          // eslint-disable-next-line no-undef\n          input = Buffer.from(literals);\n        }\n        const output = __non_webpack_require__(\"zlib\").deflateSync(input, {\n          level: 9,\n        });\n        return output instanceof Uint8Array ? output : new Uint8Array(output);\n      } catch (e) {\n        warn(\n          \"Not compressing PNG because zlib.deflateSync is unavailable: \" + e\n        );\n      }\n\n      return deflateSyncUncompressed(literals);\n    }\n\n    // An implementation of DEFLATE with compression level 0 (Z_NO_COMPRESSION).\n    function deflateSyncUncompressed(literals) {\n      let len = literals.length;\n      const maxBlockLength = 0xffff;\n\n      const deflateBlocks = Math.ceil(len / maxBlockLength);\n      const idat = new Uint8Array(2 + len + deflateBlocks * 5 + 4);\n      let pi = 0;\n      idat[pi++] = 0x78; // compression method and flags\n      idat[pi++] = 0x9c; // flags\n\n      let pos = 0;\n      while (len > maxBlockLength) {\n        // writing non-final DEFLATE blocks type 0 and length of 65535\n        idat[pi++] = 0x00;\n        idat[pi++] = 0xff;\n        idat[pi++] = 0xff;\n        idat[pi++] = 0x00;\n        idat[pi++] = 0x00;\n        idat.set(literals.subarray(pos, pos + maxBlockLength), pi);\n        pi += maxBlockLength;\n        pos += maxBlockLength;\n        len -= maxBlockLength;\n      }\n\n      // writing non-final DEFLATE blocks type 0\n      idat[pi++] = 0x01;\n      idat[pi++] = len & 0xff;\n      idat[pi++] = (len >> 8) & 0xff;\n      idat[pi++] = ~len & 0xffff & 0xff;\n      idat[pi++] = ((~len & 0xffff) >> 8) & 0xff;\n      idat.set(literals.subarray(pos), pi);\n      pi += literals.length - pos;\n\n      const adler = adler32(literals, 0, literals.length); // checksum\n      idat[pi++] = (adler >> 24) & 0xff;\n      idat[pi++] = (adler >> 16) & 0xff;\n      idat[pi++] = (adler >> 8) & 0xff;\n      idat[pi++] = adler & 0xff;\n      return idat;\n    }\n\n    function encode(imgData, kind, forceDataSchema, isMask) {\n      const width = imgData.width;\n      const height = imgData.height;\n      let bitDepth, colorType, lineSize;\n      const bytes = imgData.data;\n\n      switch (kind) {\n        case ImageKind.GRAYSCALE_1BPP:\n          colorType = 0;\n          bitDepth = 1;\n          lineSize = (width + 7) >> 3;\n          break;\n        case ImageKind.RGB_24BPP:\n          colorType = 2;\n          bitDepth = 8;\n          lineSize = width * 3;\n          break;\n        case ImageKind.RGBA_32BPP:\n          colorType = 6;\n          bitDepth = 8;\n          lineSize = width * 4;\n          break;\n        default:\n          throw new Error(\"invalid format\");\n      }\n\n      // prefix every row with predictor 0\n      const literals = new Uint8Array((1 + lineSize) * height);\n      let offsetLiterals = 0,\n        offsetBytes = 0;\n      for (let y = 0; y < height; ++y) {\n        literals[offsetLiterals++] = 0; // no prediction\n        literals.set(\n          bytes.subarray(offsetBytes, offsetBytes + lineSize),\n          offsetLiterals\n        );\n        offsetBytes += lineSize;\n        offsetLiterals += lineSize;\n      }\n\n      if (kind === ImageKind.GRAYSCALE_1BPP && isMask) {\n        // inverting for image masks\n        offsetLiterals = 0;\n        for (let y = 0; y < height; y++) {\n          offsetLiterals++; // skipping predictor\n          for (let i = 0; i < lineSize; i++) {\n            literals[offsetLiterals++] ^= 0xff;\n          }\n        }\n      }\n\n      const ihdr = new Uint8Array([\n        (width >> 24) & 0xff,\n        (width >> 16) & 0xff,\n        (width >> 8) & 0xff,\n        width & 0xff,\n        (height >> 24) & 0xff,\n        (height >> 16) & 0xff,\n        (height >> 8) & 0xff,\n        height & 0xff,\n        bitDepth, // bit depth\n        colorType, // color type\n        0x00, // compression method\n        0x00, // filter method\n        0x00, // interlace method\n      ]);\n      const idat = deflateSync(literals);\n\n      // PNG consists of: header, IHDR+data, IDAT+data, and IEND.\n      const pngLength =\n        PNG_HEADER.length + CHUNK_WRAPPER_SIZE * 3 + ihdr.length + idat.length;\n      const data = new Uint8Array(pngLength);\n      let offset = 0;\n      data.set(PNG_HEADER, offset);\n      offset += PNG_HEADER.length;\n      writePngChunk(\"IHDR\", ihdr, data, offset);\n      offset += CHUNK_WRAPPER_SIZE + ihdr.length;\n      writePngChunk(\"IDATA\", idat, data, offset);\n      offset += CHUNK_WRAPPER_SIZE + idat.length;\n      writePngChunk(\"IEND\", new Uint8Array(0), data, offset);\n\n      return createObjectURL(data, \"image/png\", forceDataSchema);\n    }\n\n    // eslint-disable-next-line no-shadow\n    return function convertImgDataToPng(imgData, forceDataSchema, isMask) {\n      const kind =\n        imgData.kind === undefined ? ImageKind.GRAYSCALE_1BPP : imgData.kind;\n      return encode(imgData, kind, forceDataSchema, isMask);\n    };\n  })();\n\n  class SVGExtraState {\n    constructor() {\n      this.fontSizeScale = 1;\n      this.fontWeight = SVG_DEFAULTS.fontWeight;\n      this.fontSize = 0;\n\n      this.textMatrix = IDENTITY_MATRIX;\n      this.fontMatrix = FONT_IDENTITY_MATRIX;\n      this.leading = 0;\n      this.textRenderingMode = TextRenderingMode.FILL;\n      this.textMatrixScale = 1;\n\n      // Current point (in user coordinates)\n      this.x = 0;\n      this.y = 0;\n\n      // Start of text line (in text coordinates)\n      this.lineX = 0;\n      this.lineY = 0;\n\n      // Character and word spacing\n      this.charSpacing = 0;\n      this.wordSpacing = 0;\n      this.textHScale = 1;\n      this.textRise = 0;\n\n      // Default foreground and background colors\n      this.fillColor = SVG_DEFAULTS.fillColor;\n      this.strokeColor = \"#000000\";\n\n      this.fillAlpha = 1;\n      this.strokeAlpha = 1;\n      this.lineWidth = 1;\n      this.lineJoin = \"\";\n      this.lineCap = \"\";\n      this.miterLimit = 0;\n\n      this.dashArray = [];\n      this.dashPhase = 0;\n\n      this.dependencies = [];\n\n      // Clipping\n      this.activeClipUrl = null;\n      this.clipGroup = null;\n\n      this.maskId = \"\";\n    }\n\n    clone() {\n      return Object.create(this);\n    }\n\n    setCurrentPoint(x, y) {\n      this.x = x;\n      this.y = y;\n    }\n  }\n\n  // eslint-disable-next-line no-inner-declarations\n  function opListToTree(opList) {\n    let opTree = [];\n    const tmp = [];\n\n    for (const opListElement of opList) {\n      if (opListElement.fn === \"save\") {\n        opTree.push({ fnId: 92, fn: \"group\", items: [] });\n        tmp.push(opTree);\n        opTree = opTree[opTree.length - 1].items;\n        continue;\n      }\n\n      if (opListElement.fn === \"restore\") {\n        opTree = tmp.pop();\n      } else {\n        opTree.push(opListElement);\n      }\n    }\n    return opTree;\n  }\n\n  /**\n   * Format a float number as a string.\n   *\n   * @param value {number} - The float number to format.\n   * @returns {string}\n   */\n  // eslint-disable-next-line no-inner-declarations\n  function pf(value) {\n    if (Number.isInteger(value)) {\n      return value.toString();\n    }\n    const s = value.toFixed(10);\n    let i = s.length - 1;\n    if (s[i] !== \"0\") {\n      return s;\n    }\n\n    // Remove trailing zeros.\n    do {\n      i--;\n    } while (s[i] === \"0\");\n    return s.substring(0, s[i] === \".\" ? i : i + 1);\n  }\n\n  /**\n   * Format a transform matrix as a string. The standard rotation, scale and\n   * translation matrices are replaced by their shorter forms, and for\n   * identity matrices an empty string is returned to save memory.\n   *\n   * @param m {Array} - The transform matrix to format.\n   * @returns {string}\n   */\n  // eslint-disable-next-line no-inner-declarations\n  function pm(m) {\n    if (m[4] === 0 && m[5] === 0) {\n      if (m[1] === 0 && m[2] === 0) {\n        if (m[0] === 1 && m[3] === 1) {\n          return \"\";\n        }\n        return `scale(${pf(m[0])} ${pf(m[3])})`;\n      }\n      if (m[0] === m[3] && m[1] === -m[2]) {\n        const a = (Math.acos(m[0]) * 180) / Math.PI;\n        return `rotate(${pf(a)})`;\n      }\n    } else {\n      if (m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1) {\n        return `translate(${pf(m[4])} ${pf(m[5])})`;\n      }\n    }\n    return (\n      `matrix(${pf(m[0])} ${pf(m[1])} ${pf(m[2])} ${pf(m[3])} ${pf(m[4])} ` +\n      `${pf(m[5])})`\n    );\n  }\n\n  // The counts below are relevant for all pages, so they have to be global\n  // instead of being members of `SVGGraphics` (which is recreated for\n  // each page).\n  let clipCount = 0;\n  let maskCount = 0;\n  let shadingCount = 0;\n\n  // eslint-disable-next-line no-shadow\n  SVGGraphics = class SVGGraphics {\n    constructor(commonObjs, objs, forceDataSchema = false) {\n      this.svgFactory = new DOMSVGFactory();\n\n      this.current = new SVGExtraState();\n      this.transformMatrix = IDENTITY_MATRIX; // Graphics state matrix\n      this.transformStack = [];\n      this.extraStack = [];\n      this.commonObjs = commonObjs;\n      this.objs = objs;\n      this.pendingClip = null;\n      this.pendingEOFill = false;\n\n      this.embedFonts = false;\n      this.embeddedFonts = Object.create(null);\n      this.cssStyle = null;\n      this.forceDataSchema = !!forceDataSchema;\n\n      // In `src/shared/util.js` the operator names are mapped to IDs.\n      // The list below represents the reverse of that, i.e., it maps IDs\n      // to operator names.\n      this._operatorIdMapping = [];\n      for (const op in OPS) {\n        this._operatorIdMapping[OPS[op]] = op;\n      }\n    }\n\n    save() {\n      this.transformStack.push(this.transformMatrix);\n      const old = this.current;\n      this.extraStack.push(old);\n      this.current = old.clone();\n    }\n\n    restore() {\n      this.transformMatrix = this.transformStack.pop();\n      this.current = this.extraStack.pop();\n      this.pendingClip = null;\n      this.tgrp = null;\n    }\n\n    group(items) {\n      this.save();\n      this.executeOpTree(items);\n      this.restore();\n    }\n\n    loadDependencies(operatorList) {\n      const fnArray = operatorList.fnArray;\n      const argsArray = operatorList.argsArray;\n\n      for (let i = 0, ii = fnArray.length; i < ii; i++) {\n        if (fnArray[i] !== OPS.dependency) {\n          continue;\n        }\n\n        for (const obj of argsArray[i]) {\n          const objsPool = obj.startsWith(\"g_\") ? this.commonObjs : this.objs;\n          const promise = new Promise(resolve => {\n            objsPool.get(obj, resolve);\n          });\n          this.current.dependencies.push(promise);\n        }\n      }\n      return Promise.all(this.current.dependencies);\n    }\n\n    transform(a, b, c, d, e, f) {\n      const transformMatrix = [a, b, c, d, e, f];\n      this.transformMatrix = Util.transform(\n        this.transformMatrix,\n        transformMatrix\n      );\n      this.tgrp = null;\n    }\n\n    getSVG(operatorList, viewport) {\n      this.viewport = viewport;\n\n      const svgElement = this._initialize(viewport);\n      return this.loadDependencies(operatorList).then(() => {\n        this.transformMatrix = IDENTITY_MATRIX;\n        this.executeOpTree(this.convertOpList(operatorList));\n        return svgElement;\n      });\n    }\n\n    convertOpList(operatorList) {\n      const operatorIdMapping = this._operatorIdMapping;\n      const argsArray = operatorList.argsArray;\n      const fnArray = operatorList.fnArray;\n      const opList = [];\n      for (let i = 0, ii = fnArray.length; i < ii; i++) {\n        const fnId = fnArray[i];\n        opList.push({\n          fnId,\n          fn: operatorIdMapping[fnId],\n          args: argsArray[i],\n        });\n      }\n      return opListToTree(opList);\n    }\n\n    executeOpTree(opTree) {\n      for (const opTreeElement of opTree) {\n        const fn = opTreeElement.fn;\n        const fnId = opTreeElement.fnId;\n        const args = opTreeElement.args;\n\n        switch (fnId | 0) {\n          case OPS.beginText:\n            this.beginText();\n            break;\n          case OPS.dependency:\n            // Handled in `loadDependencies`, so no warning should be shown.\n            break;\n          case OPS.setLeading:\n            this.setLeading(args);\n            break;\n          case OPS.setLeadingMoveText:\n            this.setLeadingMoveText(args[0], args[1]);\n            break;\n          case OPS.setFont:\n            this.setFont(args);\n            break;\n          case OPS.showText:\n            this.showText(args[0]);\n            break;\n          case OPS.showSpacedText:\n            this.showText(args[0]);\n            break;\n          case OPS.endText:\n            this.endText();\n            break;\n          case OPS.moveText:\n            this.moveText(args[0], args[1]);\n            break;\n          case OPS.setCharSpacing:\n            this.setCharSpacing(args[0]);\n            break;\n          case OPS.setWordSpacing:\n            this.setWordSpacing(args[0]);\n            break;\n          case OPS.setHScale:\n            this.setHScale(args[0]);\n            break;\n          case OPS.setTextMatrix:\n            this.setTextMatrix(\n              args[0],\n              args[1],\n              args[2],\n              args[3],\n              args[4],\n              args[5]\n            );\n            break;\n          case OPS.setTextRise:\n            this.setTextRise(args[0]);\n            break;\n          case OPS.setTextRenderingMode:\n            this.setTextRenderingMode(args[0]);\n            break;\n          case OPS.setLineWidth:\n            this.setLineWidth(args[0]);\n            break;\n          case OPS.setLineJoin:\n            this.setLineJoin(args[0]);\n            break;\n          case OPS.setLineCap:\n            this.setLineCap(args[0]);\n            break;\n          case OPS.setMiterLimit:\n            this.setMiterLimit(args[0]);\n            break;\n          case OPS.setFillRGBColor:\n            this.setFillRGBColor(args[0], args[1], args[2]);\n            break;\n          case OPS.setStrokeRGBColor:\n            this.setStrokeRGBColor(args[0], args[1], args[2]);\n            break;\n          case OPS.setStrokeColorN:\n            this.setStrokeColorN(args);\n            break;\n          case OPS.setFillColorN:\n            this.setFillColorN(args);\n            break;\n          case OPS.shadingFill:\n            this.shadingFill(args[0]);\n            break;\n          case OPS.setDash:\n            this.setDash(args[0], args[1]);\n            break;\n          case OPS.setRenderingIntent:\n            this.setRenderingIntent(args[0]);\n            break;\n          case OPS.setFlatness:\n            this.setFlatness(args[0]);\n            break;\n          case OPS.setGState:\n            this.setGState(args[0]);\n            break;\n          case OPS.fill:\n            this.fill();\n            break;\n          case OPS.eoFill:\n            this.eoFill();\n            break;\n          case OPS.stroke:\n            this.stroke();\n            break;\n          case OPS.fillStroke:\n            this.fillStroke();\n            break;\n          case OPS.eoFillStroke:\n            this.eoFillStroke();\n            break;\n          case OPS.clip:\n            this.clip(\"nonzero\");\n            break;\n          case OPS.eoClip:\n            this.clip(\"evenodd\");\n            break;\n          case OPS.paintSolidColorImageMask:\n            this.paintSolidColorImageMask();\n            break;\n          case OPS.paintImageXObject:\n            this.paintImageXObject(args[0]);\n            break;\n          case OPS.paintInlineImageXObject:\n            this.paintInlineImageXObject(args[0]);\n            break;\n          case OPS.paintImageMaskXObject:\n            this.paintImageMaskXObject(args[0]);\n            break;\n          case OPS.paintFormXObjectBegin:\n            this.paintFormXObjectBegin(args[0], args[1]);\n            break;\n          case OPS.paintFormXObjectEnd:\n            this.paintFormXObjectEnd();\n            break;\n          case OPS.closePath:\n            this.closePath();\n            break;\n          case OPS.closeStroke:\n            this.closeStroke();\n            break;\n          case OPS.closeFillStroke:\n            this.closeFillStroke();\n            break;\n          case OPS.closeEOFillStroke:\n            this.closeEOFillStroke();\n            break;\n          case OPS.nextLine:\n            this.nextLine();\n            break;\n          case OPS.transform:\n            this.transform(\n              args[0],\n              args[1],\n              args[2],\n              args[3],\n              args[4],\n              args[5]\n            );\n            break;\n          case OPS.constructPath:\n            this.constructPath(args[0], args[1]);\n            break;\n          case OPS.endPath:\n            this.endPath();\n            break;\n          case 92:\n            this.group(opTreeElement.items);\n            break;\n          default:\n            warn(`Unimplemented operator ${fn}`);\n            break;\n        }\n      }\n    }\n\n    setWordSpacing(wordSpacing) {\n      this.current.wordSpacing = wordSpacing;\n    }\n\n    setCharSpacing(charSpacing) {\n      this.current.charSpacing = charSpacing;\n    }\n\n    nextLine() {\n      this.moveText(0, this.current.leading);\n    }\n\n    setTextMatrix(a, b, c, d, e, f) {\n      const current = this.current;\n      current.textMatrix = current.lineMatrix = [a, b, c, d, e, f];\n      current.textMatrixScale = Math.sqrt(a * a + b * b);\n\n      current.x = current.lineX = 0;\n      current.y = current.lineY = 0;\n\n      current.xcoords = [];\n      current.ycoords = [];\n      current.tspan = this.svgFactory.createElement(\"svg:tspan\");\n      current.tspan.setAttributeNS(null, \"font-family\", current.fontFamily);\n      current.tspan.setAttributeNS(\n        null,\n        \"font-size\",\n        `${pf(current.fontSize)}px`\n      );\n      current.tspan.setAttributeNS(null, \"y\", pf(-current.y));\n\n      current.txtElement = this.svgFactory.createElement(\"svg:text\");\n      current.txtElement.appendChild(current.tspan);\n    }\n\n    beginText() {\n      const current = this.current;\n      current.x = current.lineX = 0;\n      current.y = current.lineY = 0;\n      current.textMatrix = IDENTITY_MATRIX;\n      current.lineMatrix = IDENTITY_MATRIX;\n      current.textMatrixScale = 1;\n      current.tspan = this.svgFactory.createElement(\"svg:tspan\");\n      current.txtElement = this.svgFactory.createElement(\"svg:text\");\n      current.txtgrp = this.svgFactory.createElement(\"svg:g\");\n      current.xcoords = [];\n      current.ycoords = [];\n    }\n\n    moveText(x, y) {\n      const current = this.current;\n      current.x = current.lineX += x;\n      current.y = current.lineY += y;\n\n      current.xcoords = [];\n      current.ycoords = [];\n      current.tspan = this.svgFactory.createElement(\"svg:tspan\");\n      current.tspan.setAttributeNS(null, \"font-family\", current.fontFamily);\n      current.tspan.setAttributeNS(\n        null,\n        \"font-size\",\n        `${pf(current.fontSize)}px`\n      );\n      current.tspan.setAttributeNS(null, \"y\", pf(-current.y));\n    }\n\n    showText(glyphs) {\n      const current = this.current;\n      const font = current.font;\n      const fontSize = current.fontSize;\n      if (fontSize === 0) {\n        return;\n      }\n\n      const fontSizeScale = current.fontSizeScale;\n      const charSpacing = current.charSpacing;\n      const wordSpacing = current.wordSpacing;\n      const fontDirection = current.fontDirection;\n      const textHScale = current.textHScale * fontDirection;\n      const vertical = font.vertical;\n      const spacingDir = vertical ? 1 : -1;\n      const defaultVMetrics = font.defaultVMetrics;\n      const widthAdvanceScale = fontSize * current.fontMatrix[0];\n\n      let x = 0;\n      for (const glyph of glyphs) {\n        if (glyph === null) {\n          // Word break\n          x += fontDirection * wordSpacing;\n          continue;\n        } else if (isNum(glyph)) {\n          x += (spacingDir * glyph * fontSize) / 1000;\n          continue;\n        }\n\n        const spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;\n        const character = glyph.fontChar;\n        let scaledX, scaledY;\n        let width = glyph.width;\n        if (vertical) {\n          let vx;\n          const vmetric = glyph.vmetric || defaultVMetrics;\n          vx = glyph.vmetric ? vmetric[1] : width * 0.5;\n          vx = -vx * widthAdvanceScale;\n          const vy = vmetric[2] * widthAdvanceScale;\n\n          width = vmetric ? -vmetric[0] : width;\n          scaledX = vx / fontSizeScale;\n          scaledY = (x + vy) / fontSizeScale;\n        } else {\n          scaledX = x / fontSizeScale;\n          scaledY = 0;\n        }\n\n        if (glyph.isInFont || font.missingFile) {\n          current.xcoords.push(current.x + scaledX);\n          if (vertical) {\n            current.ycoords.push(-current.y + scaledY);\n          }\n          current.tspan.textContent += character;\n        } else {\n          // TODO: To assist with text selection, we should replace the missing\n          // character with a space character if charWidth is not zero.\n          // But we cannot just do \"character = ' '\", because the ' ' character\n          // might actually map to a different glyph.\n        }\n\n        let charWidth;\n        if (vertical) {\n          charWidth = width * widthAdvanceScale - spacing * fontDirection;\n        } else {\n          charWidth = width * widthAdvanceScale + spacing * fontDirection;\n        }\n\n        x += charWidth;\n      }\n      current.tspan.setAttributeNS(\n        null,\n        \"x\",\n        current.xcoords.map(pf).join(\" \")\n      );\n      if (vertical) {\n        current.tspan.setAttributeNS(\n          null,\n          \"y\",\n          current.ycoords.map(pf).join(\" \")\n        );\n      } else {\n        current.tspan.setAttributeNS(null, \"y\", pf(-current.y));\n      }\n\n      if (vertical) {\n        current.y -= x;\n      } else {\n        current.x += x * textHScale;\n      }\n\n      current.tspan.setAttributeNS(null, \"font-family\", current.fontFamily);\n      current.tspan.setAttributeNS(\n        null,\n        \"font-size\",\n        `${pf(current.fontSize)}px`\n      );\n      if (current.fontStyle !== SVG_DEFAULTS.fontStyle) {\n        current.tspan.setAttributeNS(null, \"font-style\", current.fontStyle);\n      }\n      if (current.fontWeight !== SVG_DEFAULTS.fontWeight) {\n        current.tspan.setAttributeNS(null, \"font-weight\", current.fontWeight);\n      }\n\n      const fillStrokeMode =\n        current.textRenderingMode & TextRenderingMode.FILL_STROKE_MASK;\n      if (\n        fillStrokeMode === TextRenderingMode.FILL ||\n        fillStrokeMode === TextRenderingMode.FILL_STROKE\n      ) {\n        if (current.fillColor !== SVG_DEFAULTS.fillColor) {\n          current.tspan.setAttributeNS(null, \"fill\", current.fillColor);\n        }\n        if (current.fillAlpha < 1) {\n          current.tspan.setAttributeNS(null, \"fill-opacity\", current.fillAlpha);\n        }\n      } else if (current.textRenderingMode === TextRenderingMode.ADD_TO_PATH) {\n        // Workaround for Firefox: We must set fill=\"transparent\" because\n        // fill=\"none\" would generate an empty clipping path.\n        current.tspan.setAttributeNS(null, \"fill\", \"transparent\");\n      } else {\n        current.tspan.setAttributeNS(null, \"fill\", \"none\");\n      }\n\n      if (\n        fillStrokeMode === TextRenderingMode.STROKE ||\n        fillStrokeMode === TextRenderingMode.FILL_STROKE\n      ) {\n        const lineWidthScale = 1 / (current.textMatrixScale || 1);\n        this._setStrokeAttributes(current.tspan, lineWidthScale);\n      }\n\n      // Include the text rise in the text matrix since the `pm` function\n      // creates the SVG element's `translate` entry (work on a copy to avoid\n      // altering the original text matrix).\n      let textMatrix = current.textMatrix;\n      if (current.textRise !== 0) {\n        textMatrix = textMatrix.slice();\n        textMatrix[5] += current.textRise;\n      }\n\n      current.txtElement.setAttributeNS(\n        null,\n        \"transform\",\n        `${pm(textMatrix)} scale(${pf(textHScale)}, -1)`\n      );\n      current.txtElement.setAttributeNS(XML_NS, \"xml:space\", \"preserve\");\n      current.txtElement.appendChild(current.tspan);\n      current.txtgrp.appendChild(current.txtElement);\n\n      this._ensureTransformGroup().appendChild(current.txtElement);\n    }\n\n    setLeadingMoveText(x, y) {\n      this.setLeading(-y);\n      this.moveText(x, y);\n    }\n\n    addFontStyle(fontObj) {\n      if (!fontObj.data) {\n        throw new Error(\n          \"addFontStyle: No font data available, \" +\n            'ensure that the \"fontExtraProperties\" API parameter is set.'\n        );\n      }\n      if (!this.cssStyle) {\n        this.cssStyle = this.svgFactory.createElement(\"svg:style\");\n        this.cssStyle.setAttributeNS(null, \"type\", \"text/css\");\n        this.defs.appendChild(this.cssStyle);\n      }\n\n      const url = createObjectURL(\n        fontObj.data,\n        fontObj.mimetype,\n        this.forceDataSchema\n      );\n      this.cssStyle.textContent +=\n        `@font-face { font-family: \"${fontObj.loadedName}\";` +\n        ` src: url(${url}); }\\n`;\n    }\n\n    setFont(details) {\n      const current = this.current;\n      const fontObj = this.commonObjs.get(details[0]);\n      let size = details[1];\n      current.font = fontObj;\n\n      if (\n        this.embedFonts &&\n        !fontObj.missingFile &&\n        !this.embeddedFonts[fontObj.loadedName]\n      ) {\n        this.addFontStyle(fontObj);\n        this.embeddedFonts[fontObj.loadedName] = fontObj;\n      }\n\n      current.fontMatrix = fontObj.fontMatrix\n        ? fontObj.fontMatrix\n        : FONT_IDENTITY_MATRIX;\n\n      let bold = \"normal\";\n      if (fontObj.black) {\n        bold = \"900\";\n      } else if (fontObj.bold) {\n        bold = \"bold\";\n      }\n      const italic = fontObj.italic ? \"italic\" : \"normal\";\n\n      if (size < 0) {\n        size = -size;\n        current.fontDirection = -1;\n      } else {\n        current.fontDirection = 1;\n      }\n      current.fontSize = size;\n      current.fontFamily = fontObj.loadedName;\n      current.fontWeight = bold;\n      current.fontStyle = italic;\n\n      current.tspan = this.svgFactory.createElement(\"svg:tspan\");\n      current.tspan.setAttributeNS(null, \"y\", pf(-current.y));\n      current.xcoords = [];\n      current.ycoords = [];\n    }\n\n    endText() {\n      const current = this.current;\n      if (\n        current.textRenderingMode & TextRenderingMode.ADD_TO_PATH_FLAG &&\n        current.txtElement &&\n        current.txtElement.hasChildNodes()\n      ) {\n        // If no glyphs are shown (i.e. no child nodes), no clipping occurs.\n        current.element = current.txtElement;\n        this.clip(\"nonzero\");\n        this.endPath();\n      }\n    }\n\n    // Path properties\n    setLineWidth(width) {\n      if (width > 0) {\n        this.current.lineWidth = width;\n      }\n    }\n\n    setLineCap(style) {\n      this.current.lineCap = LINE_CAP_STYLES[style];\n    }\n\n    setLineJoin(style) {\n      this.current.lineJoin = LINE_JOIN_STYLES[style];\n    }\n\n    setMiterLimit(limit) {\n      this.current.miterLimit = limit;\n    }\n\n    setStrokeAlpha(strokeAlpha) {\n      this.current.strokeAlpha = strokeAlpha;\n    }\n\n    setStrokeRGBColor(r, g, b) {\n      this.current.strokeColor = Util.makeCssRgb(r, g, b);\n    }\n\n    setFillAlpha(fillAlpha) {\n      this.current.fillAlpha = fillAlpha;\n    }\n\n    setFillRGBColor(r, g, b) {\n      this.current.fillColor = Util.makeCssRgb(r, g, b);\n      this.current.tspan = this.svgFactory.createElement(\"svg:tspan\");\n      this.current.xcoords = [];\n      this.current.ycoords = [];\n    }\n\n    setStrokeColorN(args) {\n      this.current.strokeColor = this._makeColorN_Pattern(args);\n    }\n\n    setFillColorN(args) {\n      this.current.fillColor = this._makeColorN_Pattern(args);\n    }\n\n    shadingFill(args) {\n      const width = this.viewport.width;\n      const height = this.viewport.height;\n      const inv = Util.inverseTransform(this.transformMatrix);\n      const bl = Util.applyTransform([0, 0], inv);\n      const br = Util.applyTransform([0, height], inv);\n      const ul = Util.applyTransform([width, 0], inv);\n      const ur = Util.applyTransform([width, height], inv);\n      const x0 = Math.min(bl[0], br[0], ul[0], ur[0]);\n      const y0 = Math.min(bl[1], br[1], ul[1], ur[1]);\n      const x1 = Math.max(bl[0], br[0], ul[0], ur[0]);\n      const y1 = Math.max(bl[1], br[1], ul[1], ur[1]);\n\n      const rect = this.svgFactory.createElement(\"svg:rect\");\n      rect.setAttributeNS(null, \"x\", x0);\n      rect.setAttributeNS(null, \"y\", y0);\n      rect.setAttributeNS(null, \"width\", x1 - x0);\n      rect.setAttributeNS(null, \"height\", y1 - y0);\n      rect.setAttributeNS(null, \"fill\", this._makeShadingPattern(args));\n      if (this.current.fillAlpha < 1) {\n        rect.setAttributeNS(null, \"fill-opacity\", this.current.fillAlpha);\n      }\n      this._ensureTransformGroup().appendChild(rect);\n    }\n\n    /**\n     * @private\n     */\n    _makeColorN_Pattern(args) {\n      if (args[0] === \"TilingPattern\") {\n        return this._makeTilingPattern(args);\n      }\n      return this._makeShadingPattern(args);\n    }\n\n    /**\n     * @private\n     */\n    _makeTilingPattern(args) {\n      const color = args[1];\n      const operatorList = args[2];\n      const matrix = args[3] || IDENTITY_MATRIX;\n      const [x0, y0, x1, y1] = args[4];\n      const xstep = args[5];\n      const ystep = args[6];\n      const paintType = args[7];\n\n      const tilingId = `shading${shadingCount++}`;\n      const [tx0, ty0] = Util.applyTransform([x0, y0], matrix);\n      const [tx1, ty1] = Util.applyTransform([x1, y1], matrix);\n      const [xscale, yscale] = Util.singularValueDecompose2dScale(matrix);\n      const txstep = xstep * xscale;\n      const tystep = ystep * yscale;\n\n      const tiling = this.svgFactory.createElement(\"svg:pattern\");\n      tiling.setAttributeNS(null, \"id\", tilingId);\n      tiling.setAttributeNS(null, \"patternUnits\", \"userSpaceOnUse\");\n      tiling.setAttributeNS(null, \"width\", txstep);\n      tiling.setAttributeNS(null, \"height\", tystep);\n      tiling.setAttributeNS(null, \"x\", `${tx0}`);\n      tiling.setAttributeNS(null, \"y\", `${ty0}`);\n\n      // Save current state.\n      const svg = this.svg;\n      const transformMatrix = this.transformMatrix;\n      const fillColor = this.current.fillColor;\n      const strokeColor = this.current.strokeColor;\n\n      const bbox = this.svgFactory.create(tx1 - tx0, ty1 - ty0);\n      this.svg = bbox;\n      this.transformMatrix = matrix;\n      if (paintType === 2) {\n        const cssColor = Util.makeCssRgb(...color);\n        this.current.fillColor = cssColor;\n        this.current.strokeColor = cssColor;\n      }\n      this.executeOpTree(this.convertOpList(operatorList));\n\n      // Restore saved state.\n      this.svg = svg;\n      this.transformMatrix = transformMatrix;\n      this.current.fillColor = fillColor;\n      this.current.strokeColor = strokeColor;\n\n      tiling.appendChild(bbox.childNodes[0]);\n      this.defs.appendChild(tiling);\n      return `url(#${tilingId})`;\n    }\n\n    /**\n     * @private\n     */\n    _makeShadingPattern(args) {\n      switch (args[0]) {\n        case \"RadialAxial\":\n          const shadingId = `shading${shadingCount++}`;\n          const colorStops = args[3];\n          let gradient;\n\n          switch (args[1]) {\n            case \"axial\":\n              const point0 = args[4];\n              const point1 = args[5];\n              gradient = this.svgFactory.createElement(\"svg:linearGradient\");\n              gradient.setAttributeNS(null, \"id\", shadingId);\n              gradient.setAttributeNS(null, \"gradientUnits\", \"userSpaceOnUse\");\n              gradient.setAttributeNS(null, \"x1\", point0[0]);\n              gradient.setAttributeNS(null, \"y1\", point0[1]);\n              gradient.setAttributeNS(null, \"x2\", point1[0]);\n              gradient.setAttributeNS(null, \"y2\", point1[1]);\n              break;\n            case \"radial\":\n              const focalPoint = args[4];\n              const circlePoint = args[5];\n              const focalRadius = args[6];\n              const circleRadius = args[7];\n              gradient = this.svgFactory.createElement(\"svg:radialGradient\");\n              gradient.setAttributeNS(null, \"id\", shadingId);\n              gradient.setAttributeNS(null, \"gradientUnits\", \"userSpaceOnUse\");\n              gradient.setAttributeNS(null, \"cx\", circlePoint[0]);\n              gradient.setAttributeNS(null, \"cy\", circlePoint[1]);\n              gradient.setAttributeNS(null, \"r\", circleRadius);\n              gradient.setAttributeNS(null, \"fx\", focalPoint[0]);\n              gradient.setAttributeNS(null, \"fy\", focalPoint[1]);\n              gradient.setAttributeNS(null, \"fr\", focalRadius);\n              break;\n            default:\n              throw new Error(`Unknown RadialAxial type: ${args[1]}`);\n          }\n          for (const colorStop of colorStops) {\n            const stop = this.svgFactory.createElement(\"svg:stop\");\n            stop.setAttributeNS(null, \"offset\", colorStop[0]);\n            stop.setAttributeNS(null, \"stop-color\", colorStop[1]);\n            gradient.appendChild(stop);\n          }\n          this.defs.appendChild(gradient);\n          return `url(#${shadingId})`;\n        case \"Mesh\":\n          warn(\"Unimplemented pattern Mesh\");\n          return null;\n        case \"Dummy\":\n          return \"hotpink\";\n        default:\n          throw new Error(`Unknown IR type: ${args[0]}`);\n      }\n    }\n\n    setDash(dashArray, dashPhase) {\n      this.current.dashArray = dashArray;\n      this.current.dashPhase = dashPhase;\n    }\n\n    constructPath(ops, args) {\n      const current = this.current;\n      let x = current.x,\n        y = current.y;\n      let d = [];\n      let j = 0;\n\n      for (const op of ops) {\n        switch (op | 0) {\n          case OPS.rectangle:\n            x = args[j++];\n            y = args[j++];\n            const width = args[j++];\n            const height = args[j++];\n            const xw = x + width;\n            const yh = y + height;\n            d.push(\n              \"M\",\n              pf(x),\n              pf(y),\n              \"L\",\n              pf(xw),\n              pf(y),\n              \"L\",\n              pf(xw),\n              pf(yh),\n              \"L\",\n              pf(x),\n              pf(yh),\n              \"Z\"\n            );\n            break;\n          case OPS.moveTo:\n            x = args[j++];\n            y = args[j++];\n            d.push(\"M\", pf(x), pf(y));\n            break;\n          case OPS.lineTo:\n            x = args[j++];\n            y = args[j++];\n            d.push(\"L\", pf(x), pf(y));\n            break;\n          case OPS.curveTo:\n            x = args[j + 4];\n            y = args[j + 5];\n            d.push(\n              \"C\",\n              pf(args[j]),\n              pf(args[j + 1]),\n              pf(args[j + 2]),\n              pf(args[j + 3]),\n              pf(x),\n              pf(y)\n            );\n            j += 6;\n            break;\n          case OPS.curveTo2:\n            d.push(\n              \"C\",\n              pf(x),\n              pf(y),\n              pf(args[j]),\n              pf(args[j + 1]),\n              pf(args[j + 2]),\n              pf(args[j + 3])\n            );\n            x = args[j + 2];\n            y = args[j + 3];\n            j += 4;\n            break;\n          case OPS.curveTo3:\n            x = args[j + 2];\n            y = args[j + 3];\n            d.push(\n              \"C\",\n              pf(args[j]),\n              pf(args[j + 1]),\n              pf(x),\n              pf(y),\n              pf(x),\n              pf(y)\n            );\n            j += 4;\n            break;\n          case OPS.closePath:\n            d.push(\"Z\");\n            break;\n        }\n      }\n\n      d = d.join(\" \");\n\n      if (\n        current.path &&\n        ops.length > 0 &&\n        ops[0] !== OPS.rectangle &&\n        ops[0] !== OPS.moveTo\n      ) {\n        // If a path does not start with an OPS.rectangle or OPS.moveTo, it has\n        // probably been divided into two OPS.constructPath operators by\n        // OperatorList. Append the commands to the previous path element.\n        d = current.path.getAttributeNS(null, \"d\") + d;\n      } else {\n        current.path = this.svgFactory.createElement(\"svg:path\");\n        this._ensureTransformGroup().appendChild(current.path);\n      }\n\n      current.path.setAttributeNS(null, \"d\", d);\n      current.path.setAttributeNS(null, \"fill\", \"none\");\n\n      // Saving a reference in current.element so that it can be addressed\n      // in 'fill' and 'stroke'\n      current.element = current.path;\n      current.setCurrentPoint(x, y);\n    }\n\n    endPath() {\n      const current = this.current;\n\n      // Painting operators end a path.\n      current.path = null;\n\n      if (!this.pendingClip) {\n        return;\n      }\n      if (!current.element) {\n        this.pendingClip = null;\n        return;\n      }\n\n      // Add the current path to a clipping path.\n      const clipId = `clippath${clipCount++}`;\n      const clipPath = this.svgFactory.createElement(\"svg:clipPath\");\n      clipPath.setAttributeNS(null, \"id\", clipId);\n      clipPath.setAttributeNS(null, \"transform\", pm(this.transformMatrix));\n\n      // A deep clone is needed when text is used as a clipping path.\n      const clipElement = current.element.cloneNode(true);\n      if (this.pendingClip === \"evenodd\") {\n        clipElement.setAttributeNS(null, \"clip-rule\", \"evenodd\");\n      } else {\n        clipElement.setAttributeNS(null, \"clip-rule\", \"nonzero\");\n      }\n      this.pendingClip = null;\n      clipPath.appendChild(clipElement);\n      this.defs.appendChild(clipPath);\n\n      if (current.activeClipUrl) {\n        // The previous clipping group content can go out of order -- resetting\n        // cached clipGroups.\n        current.clipGroup = null;\n        this.extraStack.forEach(function (prev) {\n          prev.clipGroup = null;\n        });\n        // Intersect with the previous clipping path.\n        clipPath.setAttributeNS(null, \"clip-path\", current.activeClipUrl);\n      }\n      current.activeClipUrl = `url(#${clipId})`;\n\n      this.tgrp = null;\n    }\n\n    clip(type) {\n      this.pendingClip = type;\n    }\n\n    closePath() {\n      const current = this.current;\n      if (current.path) {\n        const d = `${current.path.getAttributeNS(null, \"d\")}Z`;\n        current.path.setAttributeNS(null, \"d\", d);\n      }\n    }\n\n    setLeading(leading) {\n      this.current.leading = -leading;\n    }\n\n    setTextRise(textRise) {\n      this.current.textRise = textRise;\n    }\n\n    setTextRenderingMode(textRenderingMode) {\n      this.current.textRenderingMode = textRenderingMode;\n    }\n\n    setHScale(scale) {\n      this.current.textHScale = scale / 100;\n    }\n\n    setRenderingIntent(intent) {\n      // This operation is ignored since we haven't found a use case for it yet.\n    }\n\n    setFlatness(flatness) {\n      // This operation is ignored since we haven't found a use case for it yet.\n    }\n\n    setGState(states) {\n      for (const [key, value] of states) {\n        switch (key) {\n          case \"LW\":\n            this.setLineWidth(value);\n            break;\n          case \"LC\":\n            this.setLineCap(value);\n            break;\n          case \"LJ\":\n            this.setLineJoin(value);\n            break;\n          case \"ML\":\n            this.setMiterLimit(value);\n            break;\n          case \"D\":\n            this.setDash(value[0], value[1]);\n            break;\n          case \"RI\":\n            this.setRenderingIntent(value);\n            break;\n          case \"FL\":\n            this.setFlatness(value);\n            break;\n          case \"Font\":\n            this.setFont(value);\n            break;\n          case \"CA\":\n            this.setStrokeAlpha(value);\n            break;\n          case \"ca\":\n            this.setFillAlpha(value);\n            break;\n          default:\n            warn(`Unimplemented graphic state operator ${key}`);\n            break;\n        }\n      }\n    }\n\n    fill() {\n      const current = this.current;\n      if (current.element) {\n        current.element.setAttributeNS(null, \"fill\", current.fillColor);\n        current.element.setAttributeNS(null, \"fill-opacity\", current.fillAlpha);\n        this.endPath();\n      }\n    }\n\n    stroke() {\n      const current = this.current;\n      if (current.element) {\n        this._setStrokeAttributes(current.element);\n        current.element.setAttributeNS(null, \"fill\", \"none\");\n        this.endPath();\n      }\n    }\n\n    /**\n     * @private\n     */\n    _setStrokeAttributes(element, lineWidthScale = 1) {\n      const current = this.current;\n      let dashArray = current.dashArray;\n      if (lineWidthScale !== 1 && dashArray.length > 0) {\n        dashArray = dashArray.map(function (value) {\n          return lineWidthScale * value;\n        });\n      }\n      element.setAttributeNS(null, \"stroke\", current.strokeColor);\n      element.setAttributeNS(null, \"stroke-opacity\", current.strokeAlpha);\n      element.setAttributeNS(null, \"stroke-miterlimit\", pf(current.miterLimit));\n      element.setAttributeNS(null, \"stroke-linecap\", current.lineCap);\n      element.setAttributeNS(null, \"stroke-linejoin\", current.lineJoin);\n      element.setAttributeNS(\n        null,\n        \"stroke-width\",\n        pf(lineWidthScale * current.lineWidth) + \"px\"\n      );\n      element.setAttributeNS(\n        null,\n        \"stroke-dasharray\",\n        dashArray.map(pf).join(\" \")\n      );\n      element.setAttributeNS(\n        null,\n        \"stroke-dashoffset\",\n        pf(lineWidthScale * current.dashPhase) + \"px\"\n      );\n    }\n\n    eoFill() {\n      if (this.current.element) {\n        this.current.element.setAttributeNS(null, \"fill-rule\", \"evenodd\");\n      }\n      this.fill();\n    }\n\n    fillStroke() {\n      // Order is important since stroke wants fill to be none.\n      // First stroke, then if fill needed, it will be overwritten.\n      this.stroke();\n      this.fill();\n    }\n\n    eoFillStroke() {\n      if (this.current.element) {\n        this.current.element.setAttributeNS(null, \"fill-rule\", \"evenodd\");\n      }\n      this.fillStroke();\n    }\n\n    closeStroke() {\n      this.closePath();\n      this.stroke();\n    }\n\n    closeFillStroke() {\n      this.closePath();\n      this.fillStroke();\n    }\n\n    closeEOFillStroke() {\n      this.closePath();\n      this.eoFillStroke();\n    }\n\n    paintSolidColorImageMask() {\n      const rect = this.svgFactory.createElement(\"svg:rect\");\n      rect.setAttributeNS(null, \"x\", \"0\");\n      rect.setAttributeNS(null, \"y\", \"0\");\n      rect.setAttributeNS(null, \"width\", \"1px\");\n      rect.setAttributeNS(null, \"height\", \"1px\");\n      rect.setAttributeNS(null, \"fill\", this.current.fillColor);\n\n      this._ensureTransformGroup().appendChild(rect);\n    }\n\n    paintImageXObject(objId) {\n      const imgData = objId.startsWith(\"g_\")\n        ? this.commonObjs.get(objId)\n        : this.objs.get(objId);\n      if (!imgData) {\n        warn(`Dependent image with object ID ${objId} is not ready yet`);\n        return;\n      }\n      this.paintInlineImageXObject(imgData);\n    }\n\n    paintInlineImageXObject(imgData, mask) {\n      const width = imgData.width;\n      const height = imgData.height;\n\n      const imgSrc = convertImgDataToPng(imgData, this.forceDataSchema, !!mask);\n      const cliprect = this.svgFactory.createElement(\"svg:rect\");\n      cliprect.setAttributeNS(null, \"x\", \"0\");\n      cliprect.setAttributeNS(null, \"y\", \"0\");\n      cliprect.setAttributeNS(null, \"width\", pf(width));\n      cliprect.setAttributeNS(null, \"height\", pf(height));\n      this.current.element = cliprect;\n      this.clip(\"nonzero\");\n\n      const imgEl = this.svgFactory.createElement(\"svg:image\");\n      imgEl.setAttributeNS(XLINK_NS, \"xlink:href\", imgSrc);\n      imgEl.setAttributeNS(null, \"x\", \"0\");\n      imgEl.setAttributeNS(null, \"y\", pf(-height));\n      imgEl.setAttributeNS(null, \"width\", pf(width) + \"px\");\n      imgEl.setAttributeNS(null, \"height\", pf(height) + \"px\");\n      imgEl.setAttributeNS(\n        null,\n        \"transform\",\n        `scale(${pf(1 / width)} ${pf(-1 / height)})`\n      );\n      if (mask) {\n        mask.appendChild(imgEl);\n      } else {\n        this._ensureTransformGroup().appendChild(imgEl);\n      }\n    }\n\n    paintImageMaskXObject(imgData) {\n      const current = this.current;\n      const width = imgData.width;\n      const height = imgData.height;\n      const fillColor = current.fillColor;\n\n      current.maskId = `mask${maskCount++}`;\n      const mask = this.svgFactory.createElement(\"svg:mask\");\n      mask.setAttributeNS(null, \"id\", current.maskId);\n\n      const rect = this.svgFactory.createElement(\"svg:rect\");\n      rect.setAttributeNS(null, \"x\", \"0\");\n      rect.setAttributeNS(null, \"y\", \"0\");\n      rect.setAttributeNS(null, \"width\", pf(width));\n      rect.setAttributeNS(null, \"height\", pf(height));\n      rect.setAttributeNS(null, \"fill\", fillColor);\n      rect.setAttributeNS(null, \"mask\", `url(#${current.maskId})`);\n\n      this.defs.appendChild(mask);\n      this._ensureTransformGroup().appendChild(rect);\n\n      this.paintInlineImageXObject(imgData, mask);\n    }\n\n    paintFormXObjectBegin(matrix, bbox) {\n      if (Array.isArray(matrix) && matrix.length === 6) {\n        this.transform(\n          matrix[0],\n          matrix[1],\n          matrix[2],\n          matrix[3],\n          matrix[4],\n          matrix[5]\n        );\n      }\n\n      if (bbox) {\n        const width = bbox[2] - bbox[0];\n        const height = bbox[3] - bbox[1];\n\n        const cliprect = this.svgFactory.createElement(\"svg:rect\");\n        cliprect.setAttributeNS(null, \"x\", bbox[0]);\n        cliprect.setAttributeNS(null, \"y\", bbox[1]);\n        cliprect.setAttributeNS(null, \"width\", pf(width));\n        cliprect.setAttributeNS(null, \"height\", pf(height));\n        this.current.element = cliprect;\n        this.clip(\"nonzero\");\n        this.endPath();\n      }\n    }\n\n    paintFormXObjectEnd() {}\n\n    /**\n     * @private\n     */\n    _initialize(viewport) {\n      const svg = this.svgFactory.create(viewport.width, viewport.height);\n\n      // Create the definitions element.\n      const definitions = this.svgFactory.createElement(\"svg:defs\");\n      svg.appendChild(definitions);\n      this.defs = definitions;\n\n      // Create the root group element, which acts a container for all other\n      // groups and applies the viewport transform.\n      const rootGroup = this.svgFactory.createElement(\"svg:g\");\n      rootGroup.setAttributeNS(null, \"transform\", pm(viewport.transform));\n      svg.appendChild(rootGroup);\n\n      // For the construction of the SVG image we are only interested in the\n      // root group, so we expose it as the entry point of the SVG image for\n      // the other code in this class.\n      this.svg = rootGroup;\n\n      return svg;\n    }\n\n    /**\n     * @private\n     */\n    _ensureClipGroup() {\n      if (!this.current.clipGroup) {\n        const clipGroup = this.svgFactory.createElement(\"svg:g\");\n        clipGroup.setAttributeNS(null, \"clip-path\", this.current.activeClipUrl);\n        this.svg.appendChild(clipGroup);\n        this.current.clipGroup = clipGroup;\n      }\n      return this.current.clipGroup;\n    }\n\n    /**\n     * @private\n     */\n    _ensureTransformGroup() {\n      if (!this.tgrp) {\n        this.tgrp = this.svgFactory.createElement(\"svg:g\");\n        this.tgrp.setAttributeNS(null, \"transform\", pm(this.transformMatrix));\n        if (this.current.activeClipUrl) {\n          this._ensureClipGroup().appendChild(this.tgrp);\n        } else {\n          this.svg.appendChild(this.tgrp);\n        }\n      }\n      return this.tgrp;\n    }\n  };\n}\n\nexport { SVGGraphics };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* globals __non_webpack_require__ */\n\nimport {\n  AbortException,\n  assert,\n  createPromiseCapability,\n  MissingPDFException,\n} from \"../shared/util.js\";\nimport {\n  extractFilenameFromHeader,\n  validateRangeRequestCapabilities,\n} from \"./network_utils.js\";\n\nif (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"MOZCENTRAL\")) {\n  throw new Error(\n    'Module \"./node_stream.js\" shall not be used with MOZCENTRAL builds.'\n  );\n}\n\nconst fs = __non_webpack_require__(\"fs\");\nconst http = __non_webpack_require__(\"http\");\nconst https = __non_webpack_require__(\"https\");\nconst url = __non_webpack_require__(\"url\");\n\nconst fileUriRegex = /^file:\\/\\/\\/[a-zA-Z]:\\//;\n\nfunction parseUrl(sourceUrl) {\n  const parsedUrl = url.parse(sourceUrl);\n  if (parsedUrl.protocol === \"file:\" || parsedUrl.host) {\n    return parsedUrl;\n  }\n  // Prepending 'file:///' to Windows absolute path.\n  if (/^[a-z]:[/\\\\]/i.test(sourceUrl)) {\n    return url.parse(`file:///${sourceUrl}`);\n  }\n  // Changes protocol to 'file:' if url refers to filesystem.\n  if (!parsedUrl.host) {\n    parsedUrl.protocol = \"file:\";\n  }\n  return parsedUrl;\n}\n\nclass PDFNodeStream {\n  constructor(source) {\n    this.source = source;\n    this.url = parseUrl(source.url);\n    this.isHttp =\n      this.url.protocol === \"http:\" || this.url.protocol === \"https:\";\n    // Check if url refers to filesystem.\n    this.isFsUrl = this.url.protocol === \"file:\";\n    this.httpHeaders = (this.isHttp && source.httpHeaders) || {};\n\n    this._fullRequestReader = null;\n    this._rangeRequestReaders = [];\n  }\n\n  get _progressiveDataLength() {\n    return this._fullRequestReader ? this._fullRequestReader._loaded : 0;\n  }\n\n  getFullReader() {\n    assert(\n      !this._fullRequestReader,\n      \"PDFNodeStream.getFullReader can only be called once.\"\n    );\n    this._fullRequestReader = this.isFsUrl\n      ? new PDFNodeStreamFsFullReader(this)\n      : new PDFNodeStreamFullReader(this);\n    return this._fullRequestReader;\n  }\n\n  getRangeReader(start, end) {\n    if (end <= this._progressiveDataLength) {\n      return null;\n    }\n    const rangeReader = this.isFsUrl\n      ? new PDFNodeStreamFsRangeReader(this, start, end)\n      : new PDFNodeStreamRangeReader(this, start, end);\n    this._rangeRequestReaders.push(rangeReader);\n    return rangeReader;\n  }\n\n  cancelAllRequests(reason) {\n    if (this._fullRequestReader) {\n      this._fullRequestReader.cancel(reason);\n    }\n\n    const readers = this._rangeRequestReaders.slice(0);\n    readers.forEach(function (reader) {\n      reader.cancel(reason);\n    });\n  }\n}\n\nclass BaseFullReader {\n  constructor(stream) {\n    this._url = stream.url;\n    this._done = false;\n    this._storedError = null;\n    this.onProgress = null;\n    const source = stream.source;\n    this._contentLength = source.length; // optional\n    this._loaded = 0;\n    this._filename = null;\n\n    this._disableRange = source.disableRange || false;\n    this._rangeChunkSize = source.rangeChunkSize;\n    if (!this._rangeChunkSize && !this._disableRange) {\n      this._disableRange = true;\n    }\n\n    this._isStreamingSupported = !source.disableStream;\n    this._isRangeSupported = !source.disableRange;\n\n    this._readableStream = null;\n    this._readCapability = createPromiseCapability();\n    this._headersCapability = createPromiseCapability();\n  }\n\n  get headersReady() {\n    return this._headersCapability.promise;\n  }\n\n  get filename() {\n    return this._filename;\n  }\n\n  get contentLength() {\n    return this._contentLength;\n  }\n\n  get isRangeSupported() {\n    return this._isRangeSupported;\n  }\n\n  get isStreamingSupported() {\n    return this._isStreamingSupported;\n  }\n\n  async read() {\n    await this._readCapability.promise;\n    if (this._done) {\n      return { value: undefined, done: true };\n    }\n    if (this._storedError) {\n      throw this._storedError;\n    }\n\n    const chunk = this._readableStream.read();\n    if (chunk === null) {\n      this._readCapability = createPromiseCapability();\n      return this.read();\n    }\n    this._loaded += chunk.length;\n    if (this.onProgress) {\n      this.onProgress({\n        loaded: this._loaded,\n        total: this._contentLength,\n      });\n    }\n    // Ensure that `read()` method returns ArrayBuffer.\n    const buffer = new Uint8Array(chunk).buffer;\n    return { value: buffer, done: false };\n  }\n\n  cancel(reason) {\n    // Call `this._error()` method when cancel is called\n    // before _readableStream is set.\n    if (!this._readableStream) {\n      this._error(reason);\n      return;\n    }\n    this._readableStream.destroy(reason);\n  }\n\n  _error(reason) {\n    this._storedError = reason;\n    this._readCapability.resolve();\n  }\n\n  _setReadableStream(readableStream) {\n    this._readableStream = readableStream;\n    readableStream.on(\"readable\", () => {\n      this._readCapability.resolve();\n    });\n\n    readableStream.on(\"end\", () => {\n      // Destroy readable to minimize resource usage.\n      readableStream.destroy();\n      this._done = true;\n      this._readCapability.resolve();\n    });\n\n    readableStream.on(\"error\", reason => {\n      this._error(reason);\n    });\n\n    // We need to stop reading when range is supported and streaming is\n    // disabled.\n    if (!this._isStreamingSupported && this._isRangeSupported) {\n      this._error(new AbortException(\"streaming is disabled\"));\n    }\n\n    // Destroy ReadableStream if already in errored state.\n    if (this._storedError) {\n      this._readableStream.destroy(this._storedError);\n    }\n  }\n}\n\nclass BaseRangeReader {\n  constructor(stream) {\n    this._url = stream.url;\n    this._done = false;\n    this._storedError = null;\n    this.onProgress = null;\n    this._loaded = 0;\n    this._readableStream = null;\n    this._readCapability = createPromiseCapability();\n    const source = stream.source;\n    this._isStreamingSupported = !source.disableStream;\n  }\n\n  get isStreamingSupported() {\n    return this._isStreamingSupported;\n  }\n\n  async read() {\n    await this._readCapability.promise;\n    if (this._done) {\n      return { value: undefined, done: true };\n    }\n    if (this._storedError) {\n      throw this._storedError;\n    }\n\n    const chunk = this._readableStream.read();\n    if (chunk === null) {\n      this._readCapability = createPromiseCapability();\n      return this.read();\n    }\n    this._loaded += chunk.length;\n    if (this.onProgress) {\n      this.onProgress({ loaded: this._loaded });\n    }\n    // Ensure that `read()` method returns ArrayBuffer.\n    const buffer = new Uint8Array(chunk).buffer;\n    return { value: buffer, done: false };\n  }\n\n  cancel(reason) {\n    // Call `this._error()` method when cancel is called\n    // before _readableStream is set.\n    if (!this._readableStream) {\n      this._error(reason);\n      return;\n    }\n    this._readableStream.destroy(reason);\n  }\n\n  _error(reason) {\n    this._storedError = reason;\n    this._readCapability.resolve();\n  }\n\n  _setReadableStream(readableStream) {\n    this._readableStream = readableStream;\n    readableStream.on(\"readable\", () => {\n      this._readCapability.resolve();\n    });\n\n    readableStream.on(\"end\", () => {\n      // Destroy readableStream to minimize resource usage.\n      readableStream.destroy();\n      this._done = true;\n      this._readCapability.resolve();\n    });\n\n    readableStream.on(\"error\", reason => {\n      this._error(reason);\n    });\n\n    // Destroy readableStream if already in errored state.\n    if (this._storedError) {\n      this._readableStream.destroy(this._storedError);\n    }\n  }\n}\n\nfunction createRequestOptions(parsedUrl, headers) {\n  return {\n    protocol: parsedUrl.protocol,\n    auth: parsedUrl.auth,\n    host: parsedUrl.hostname,\n    port: parsedUrl.port,\n    path: parsedUrl.path,\n    method: \"GET\",\n    headers,\n  };\n}\n\nclass PDFNodeStreamFullReader extends BaseFullReader {\n  constructor(stream) {\n    super(stream);\n\n    const handleResponse = response => {\n      if (response.statusCode === 404) {\n        const error = new MissingPDFException(`Missing PDF \"${this._url}\".`);\n        this._storedError = error;\n        this._headersCapability.reject(error);\n        return;\n      }\n      this._headersCapability.resolve();\n      this._setReadableStream(response);\n\n      const getResponseHeader = name => {\n        // Make sure that headers name are in lower case, as mentioned\n        // here: https://nodejs.org/api/http.html#http_message_headers.\n        return this._readableStream.headers[name.toLowerCase()];\n      };\n      const {\n        allowRangeRequests,\n        suggestedLength,\n      } = validateRangeRequestCapabilities({\n        getResponseHeader,\n        isHttp: stream.isHttp,\n        rangeChunkSize: this._rangeChunkSize,\n        disableRange: this._disableRange,\n      });\n\n      this._isRangeSupported = allowRangeRequests;\n      // Setting right content length.\n      this._contentLength = suggestedLength || this._contentLength;\n\n      this._filename = extractFilenameFromHeader(getResponseHeader);\n    };\n\n    this._request = null;\n    if (this._url.protocol === \"http:\") {\n      this._request = http.request(\n        createRequestOptions(this._url, stream.httpHeaders),\n        handleResponse\n      );\n    } else {\n      this._request = https.request(\n        createRequestOptions(this._url, stream.httpHeaders),\n        handleResponse\n      );\n    }\n\n    this._request.on(\"error\", reason => {\n      this._storedError = reason;\n      this._headersCapability.reject(reason);\n    });\n    // Note: `request.end(data)` is used to write `data` to request body\n    // and notify end of request. But one should always call `request.end()`\n    // even if there is no data to write -- (to notify the end of request).\n    this._request.end();\n  }\n}\n\nclass PDFNodeStreamRangeReader extends BaseRangeReader {\n  constructor(stream, start, end) {\n    super(stream);\n\n    this._httpHeaders = {};\n    for (const property in stream.httpHeaders) {\n      const value = stream.httpHeaders[property];\n      if (typeof value === \"undefined\") {\n        continue;\n      }\n      this._httpHeaders[property] = value;\n    }\n    this._httpHeaders.Range = `bytes=${start}-${end - 1}`;\n\n    const handleResponse = response => {\n      if (response.statusCode === 404) {\n        const error = new MissingPDFException(`Missing PDF \"${this._url}\".`);\n        this._storedError = error;\n        return;\n      }\n      this._setReadableStream(response);\n    };\n\n    this._request = null;\n    if (this._url.protocol === \"http:\") {\n      this._request = http.request(\n        createRequestOptions(this._url, this._httpHeaders),\n        handleResponse\n      );\n    } else {\n      this._request = https.request(\n        createRequestOptions(this._url, this._httpHeaders),\n        handleResponse\n      );\n    }\n\n    this._request.on(\"error\", reason => {\n      this._storedError = reason;\n    });\n    this._request.end();\n  }\n}\n\nclass PDFNodeStreamFsFullReader extends BaseFullReader {\n  constructor(stream) {\n    super(stream);\n\n    let path = decodeURIComponent(this._url.path);\n\n    // Remove the extra slash to get right path from url like `file:///C:/`\n    if (fileUriRegex.test(this._url.href)) {\n      path = path.replace(/^\\//, \"\");\n    }\n\n    fs.lstat(path, (error, stat) => {\n      if (error) {\n        if (error.code === \"ENOENT\") {\n          error = new MissingPDFException(`Missing PDF \"${path}\".`);\n        }\n        this._storedError = error;\n        this._headersCapability.reject(error);\n        return;\n      }\n      // Setting right content length.\n      this._contentLength = stat.size;\n\n      this._setReadableStream(fs.createReadStream(path));\n      this._headersCapability.resolve();\n    });\n  }\n}\n\nclass PDFNodeStreamFsRangeReader extends BaseRangeReader {\n  constructor(stream, start, end) {\n    super(stream);\n\n    let path = decodeURIComponent(this._url.path);\n\n    // Remove the extra slash to get right path from url like `file:///C:/`\n    if (fileUriRegex.test(this._url.href)) {\n      path = path.replace(/^\\//, \"\");\n    }\n\n    this._setReadableStream(fs.createReadStream(path, { start, end: end - 1 }));\n  }\n}\n\nexport { PDFNodeStream };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  assert,\n  MissingPDFException,\n  UnexpectedResponseException,\n} from \"../shared/util.js\";\nimport { getFilenameFromContentDispositionHeader } from \"./content_disposition.js\";\n\nfunction validateRangeRequestCapabilities({\n  getResponseHeader,\n  isHttp,\n  rangeChunkSize,\n  disableRange,\n}) {\n  assert(rangeChunkSize > 0, \"Range chunk size must be larger than zero\");\n  const returnValues = {\n    allowRangeRequests: false,\n    suggestedLength: undefined,\n  };\n\n  const length = parseInt(getResponseHeader(\"Content-Length\"), 10);\n  if (!Number.isInteger(length)) {\n    return returnValues;\n  }\n\n  returnValues.suggestedLength = length;\n\n  if (length <= 2 * rangeChunkSize) {\n    // The file size is smaller than the size of two chunks, so it does not\n    // make any sense to abort the request and retry with a range request.\n    return returnValues;\n  }\n\n  if (disableRange || !isHttp) {\n    return returnValues;\n  }\n  if (getResponseHeader(\"Accept-Ranges\") !== \"bytes\") {\n    return returnValues;\n  }\n\n  const contentEncoding = getResponseHeader(\"Content-Encoding\") || \"identity\";\n  if (contentEncoding !== \"identity\") {\n    return returnValues;\n  }\n\n  returnValues.allowRangeRequests = true;\n  return returnValues;\n}\n\nfunction extractFilenameFromHeader(getResponseHeader) {\n  const contentDisposition = getResponseHeader(\"Content-Disposition\");\n  if (contentDisposition) {\n    let filename = getFilenameFromContentDispositionHeader(contentDisposition);\n    if (filename.includes(\"%\")) {\n      try {\n        filename = decodeURIComponent(filename);\n      } catch (ex) {}\n    }\n    if (/\\.pdf$/i.test(filename)) {\n      return filename;\n    }\n  }\n  return null;\n}\n\nfunction createResponseStatusError(status, url) {\n  if (status === 404 || (status === 0 && url.startsWith(\"file:\"))) {\n    return new MissingPDFException('Missing PDF \"' + url + '\".');\n  }\n  return new UnexpectedResponseException(\n    \"Unexpected server response (\" +\n      status +\n      ') while retrieving PDF \"' +\n      url +\n      '\".',\n    status\n  );\n}\n\nfunction validateResponseStatus(status) {\n  return status === 200 || status === 206;\n}\n\nexport {\n  createResponseStatusError,\n  extractFilenameFromHeader,\n  validateRangeRequestCapabilities,\n  validateResponseStatus,\n};\n","/* Copyright 2017 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// This getFilenameFromContentDispositionHeader function is adapted from\n// https://github.com/Rob--W/open-in-browser/blob/7e2e35a38b8b4e981b11da7b2f01df0149049e92/extension/content-disposition.js\n// with the following changes:\n// - Modified to conform to PDF.js's coding style.\n// - Support UTF-8 decoding when TextDecoder is unsupported.\n// - Move return to the end of the function to prevent Babel from dropping the\n//   function declarations.\n\n/**\n * Extract file name from the Content-Disposition HTTP response header.\n *\n * @param {string} contentDisposition\n * @returns {string} Filename, if found in the Content-Disposition header.\n */\nfunction getFilenameFromContentDispositionHeader(contentDisposition) {\n  let needsEncodingFixup = true;\n\n  // filename*=ext-value (\"ext-value\" from RFC 5987, referenced by RFC 6266).\n  let tmp = toParamRegExp(\"filename\\\\*\", \"i\").exec(contentDisposition);\n  if (tmp) {\n    tmp = tmp[1];\n    let filename = rfc2616unquote(tmp);\n    filename = unescape(filename);\n    filename = rfc5987decode(filename);\n    filename = rfc2047decode(filename);\n    return fixupEncoding(filename);\n  }\n\n  // Continuations (RFC 2231 section 3, referenced by RFC 5987 section 3.1).\n  // filename*n*=part\n  // filename*n=part\n  tmp = rfc2231getparam(contentDisposition);\n  if (tmp) {\n    // RFC 2047, section\n    const filename = rfc2047decode(tmp);\n    return fixupEncoding(filename);\n  }\n\n  // filename=value (RFC 5987, section 4.1).\n  tmp = toParamRegExp(\"filename\", \"i\").exec(contentDisposition);\n  if (tmp) {\n    tmp = tmp[1];\n    let filename = rfc2616unquote(tmp);\n    filename = rfc2047decode(filename);\n    return fixupEncoding(filename);\n  }\n\n  // After this line there are only function declarations. We cannot put\n  // \"return\" here for readability because babel would then drop the function\n  // declarations...\n  function toParamRegExp(attributePattern, flags) {\n    return new RegExp(\n      \"(?:^|;)\\\\s*\" +\n        attributePattern +\n        \"\\\\s*=\\\\s*\" +\n        // Captures: value = token | quoted-string\n        // (RFC 2616, section 3.6 and referenced by RFC 6266 4.1)\n        \"(\" +\n        '[^\";\\\\s][^;\\\\s]*' +\n        \"|\" +\n        '\"(?:[^\"\\\\\\\\]|\\\\\\\\\"?)+\"?' +\n        \")\",\n      flags\n    );\n  }\n  function textdecode(encoding, value) {\n    if (encoding) {\n      if (!/^[\\x00-\\xFF]+$/.test(value)) {\n        return value;\n      }\n      try {\n        const decoder = new TextDecoder(encoding, { fatal: true });\n        const bytes = Array.from(value, function (ch) {\n          return ch.charCodeAt(0) & 0xff;\n        });\n        value = decoder.decode(new Uint8Array(bytes));\n        needsEncodingFixup = false;\n      } catch (e) {\n        // TextDecoder constructor threw - unrecognized encoding.\n        // Or TextDecoder API is not available (in IE / Edge).\n        if (/^utf-?8$/i.test(encoding)) {\n          // UTF-8 is commonly used, try to support it in another way:\n          try {\n            value = decodeURIComponent(escape(value));\n            needsEncodingFixup = false;\n          } catch (err) {}\n        }\n      }\n    }\n    return value;\n  }\n  function fixupEncoding(value) {\n    if (needsEncodingFixup && /[\\x80-\\xff]/.test(value)) {\n      // Maybe multi-byte UTF-8.\n      value = textdecode(\"utf-8\", value);\n      if (needsEncodingFixup) {\n        // Try iso-8859-1 encoding.\n        value = textdecode(\"iso-8859-1\", value);\n      }\n    }\n    return value;\n  }\n  function rfc2231getparam(contentDispositionStr) {\n    const matches = [];\n    let match;\n    // Iterate over all filename*n= and filename*n*= with n being an integer\n    // of at least zero. Any non-zero number must not start with '0'.\n    const iter = toParamRegExp(\"filename\\\\*((?!0\\\\d)\\\\d+)(\\\\*?)\", \"ig\");\n    while ((match = iter.exec(contentDispositionStr)) !== null) {\n      let [, n, quot, part] = match; // eslint-disable-line prefer-const\n      n = parseInt(n, 10);\n      if (n in matches) {\n        // Ignore anything after the invalid second filename*0.\n        if (n === 0) {\n          break;\n        }\n        continue;\n      }\n      matches[n] = [quot, part];\n    }\n    const parts = [];\n    for (let n = 0; n < matches.length; ++n) {\n      if (!(n in matches)) {\n        // Numbers must be consecutive. Truncate when there is a hole.\n        break;\n      }\n      let [quot, part] = matches[n]; // eslint-disable-line prefer-const\n      part = rfc2616unquote(part);\n      if (quot) {\n        part = unescape(part);\n        if (n === 0) {\n          part = rfc5987decode(part);\n        }\n      }\n      parts.push(part);\n    }\n    return parts.join(\"\");\n  }\n  function rfc2616unquote(value) {\n    if (value.startsWith('\"')) {\n      const parts = value.slice(1).split('\\\\\"');\n      // Find the first unescaped \" and terminate there.\n      for (let i = 0; i < parts.length; ++i) {\n        const quotindex = parts[i].indexOf('\"');\n        if (quotindex !== -1) {\n          parts[i] = parts[i].slice(0, quotindex);\n          parts.length = i + 1; // Truncates and stop the iteration.\n        }\n        parts[i] = parts[i].replace(/\\\\(.)/g, \"$1\");\n      }\n      value = parts.join('\"');\n    }\n    return value;\n  }\n  function rfc5987decode(extvalue) {\n    // Decodes \"ext-value\" from RFC 5987.\n    const encodingend = extvalue.indexOf(\"'\");\n    if (encodingend === -1) {\n      // Some servers send \"filename*=\" without encoding 'language' prefix,\n      // e.g. in https://github.com/Rob--W/open-in-browser/issues/26\n      // Let's accept the value like Firefox (57) (Chrome 62 rejects it).\n      return extvalue;\n    }\n    const encoding = extvalue.slice(0, encodingend);\n    const langvalue = extvalue.slice(encodingend + 1);\n    // Ignore language (RFC 5987 section 3.2.1, and RFC 6266 section 4.1 ).\n    const value = langvalue.replace(/^[^']*'/, \"\");\n    return textdecode(encoding, value);\n  }\n  function rfc2047decode(value) {\n    // RFC 2047-decode the result. Firefox tried to drop support for it, but\n    // backed out because some servers use it - https://bugzil.la/875615\n    // Firefox's condition for decoding is here: https://searchfox.org/mozilla-central/rev/4a590a5a15e35d88a3b23dd6ac3c471cf85b04a8/netwerk/mime/nsMIMEHeaderParamImpl.cpp#742-748\n\n    // We are more strict and only recognize RFC 2047-encoding if the value\n    // starts with \"=?\", since then it is likely that the full value is\n    // RFC 2047-encoded.\n\n    // Firefox also decodes words even where RFC 2047 section 5 states:\n    // \"An 'encoded-word' MUST NOT appear within a 'quoted-string'.\"\n    if (!value.startsWith(\"=?\") || /[\\x00-\\x19\\x80-\\xff]/.test(value)) {\n      return value;\n    }\n    // RFC 2047, section 2.4\n    // encoded-word = \"=?\" charset \"?\" encoding \"?\" encoded-text \"?=\"\n    // charset = token (but let's restrict to characters that denote a\n    //       possibly valid encoding).\n    // encoding = q or b\n    // encoded-text = any printable ASCII character other than ? or space.\n    //        ... but Firefox permits ? and space.\n    return value.replace(\n      /=\\?([\\w-]*)\\?([QqBb])\\?((?:[^?]|\\?(?!=))*)\\?=/g,\n      function (matches, charset, encoding, text) {\n        if (encoding === \"q\" || encoding === \"Q\") {\n          // RFC 2047 section 4.2.\n          text = text.replace(/_/g, \" \");\n          text = text.replace(/=([0-9a-fA-F]{2})/g, function (match, hex) {\n            return String.fromCharCode(parseInt(hex, 16));\n          });\n          return textdecode(charset, text);\n        } // else encoding is b or B - base64 (RFC 2047 section 4.1)\n        try {\n          text = atob(text);\n        } catch (e) {}\n        return textdecode(charset, text);\n      }\n    );\n  }\n\n  return \"\";\n}\n\nexport { getFilenameFromContentDispositionHeader };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport {\n  assert,\n  createPromiseCapability,\n  stringToBytes,\n} from \"../shared/util.js\";\nimport {\n  createResponseStatusError,\n  extractFilenameFromHeader,\n  validateRangeRequestCapabilities,\n} from \"./network_utils.js\";\n\nif (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"MOZCENTRAL\")) {\n  throw new Error(\n    'Module \"./network.js\" shall not be used with MOZCENTRAL builds.'\n  );\n}\n\nconst OK_RESPONSE = 200;\nconst PARTIAL_CONTENT_RESPONSE = 206;\n\nfunction getArrayBuffer(xhr) {\n  const data = xhr.response;\n  if (typeof data !== \"string\") {\n    return data;\n  }\n  const array = stringToBytes(data);\n  return array.buffer;\n}\n\nclass NetworkManager {\n  constructor(url, args) {\n    this.url = url;\n    args = args || {};\n    this.isHttp = /^https?:/i.test(url);\n    this.httpHeaders = (this.isHttp && args.httpHeaders) || {};\n    this.withCredentials = args.withCredentials || false;\n    this.getXhr =\n      args.getXhr ||\n      function NetworkManager_getXhr() {\n        return new XMLHttpRequest();\n      };\n\n    this.currXhrId = 0;\n    this.pendingRequests = Object.create(null);\n  }\n\n  requestRange(begin, end, listeners) {\n    const args = {\n      begin,\n      end,\n    };\n    for (const prop in listeners) {\n      args[prop] = listeners[prop];\n    }\n    return this.request(args);\n  }\n\n  requestFull(listeners) {\n    return this.request(listeners);\n  }\n\n  request(args) {\n    const xhr = this.getXhr();\n    const xhrId = this.currXhrId++;\n    const pendingRequest = (this.pendingRequests[xhrId] = {\n      xhr,\n    });\n\n    xhr.open(\"GET\", this.url);\n    xhr.withCredentials = this.withCredentials;\n    for (const property in this.httpHeaders) {\n      const value = this.httpHeaders[property];\n      if (typeof value === \"undefined\") {\n        continue;\n      }\n      xhr.setRequestHeader(property, value);\n    }\n    if (this.isHttp && \"begin\" in args && \"end\" in args) {\n      xhr.setRequestHeader(\"Range\", `bytes=${args.begin}-${args.end - 1}`);\n      pendingRequest.expectedStatus = PARTIAL_CONTENT_RESPONSE;\n    } else {\n      pendingRequest.expectedStatus = OK_RESPONSE;\n    }\n    xhr.responseType = \"arraybuffer\";\n\n    if (args.onError) {\n      xhr.onerror = function (evt) {\n        args.onError(xhr.status);\n      };\n    }\n    xhr.onreadystatechange = this.onStateChange.bind(this, xhrId);\n    xhr.onprogress = this.onProgress.bind(this, xhrId);\n\n    pendingRequest.onHeadersReceived = args.onHeadersReceived;\n    pendingRequest.onDone = args.onDone;\n    pendingRequest.onError = args.onError;\n    pendingRequest.onProgress = args.onProgress;\n\n    xhr.send(null);\n\n    return xhrId;\n  }\n\n  onProgress(xhrId, evt) {\n    const pendingRequest = this.pendingRequests[xhrId];\n    if (!pendingRequest) {\n      // Maybe abortRequest was called...\n      return;\n    }\n\n    if (pendingRequest.onProgress) {\n      pendingRequest.onProgress(evt);\n    }\n  }\n\n  onStateChange(xhrId, evt) {\n    const pendingRequest = this.pendingRequests[xhrId];\n    if (!pendingRequest) {\n      // Maybe abortRequest was called...\n      return;\n    }\n\n    const xhr = pendingRequest.xhr;\n    if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) {\n      pendingRequest.onHeadersReceived();\n      delete pendingRequest.onHeadersReceived;\n    }\n\n    if (xhr.readyState !== 4) {\n      return;\n    }\n\n    if (!(xhrId in this.pendingRequests)) {\n      // The XHR request might have been aborted in onHeadersReceived()\n      // callback, in which case we should abort request.\n      return;\n    }\n\n    delete this.pendingRequests[xhrId];\n\n    // Success status == 0 can be on ftp, file and other protocols.\n    if (xhr.status === 0 && this.isHttp) {\n      if (pendingRequest.onError) {\n        pendingRequest.onError(xhr.status);\n      }\n      return;\n    }\n    const xhrStatus = xhr.status || OK_RESPONSE;\n\n    // From http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.2:\n    // \"A server MAY ignore the Range header\". This means it's possible to\n    // get a 200 rather than a 206 response from a range request.\n    const ok_response_on_range_request =\n      xhrStatus === OK_RESPONSE &&\n      pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE;\n\n    if (\n      !ok_response_on_range_request &&\n      xhrStatus !== pendingRequest.expectedStatus\n    ) {\n      if (pendingRequest.onError) {\n        pendingRequest.onError(xhr.status);\n      }\n      return;\n    }\n\n    const chunk = getArrayBuffer(xhr);\n    if (xhrStatus === PARTIAL_CONTENT_RESPONSE) {\n      const rangeHeader = xhr.getResponseHeader(\"Content-Range\");\n      const matches = /bytes (\\d+)-(\\d+)\\/(\\d+)/.exec(rangeHeader);\n      pendingRequest.onDone({\n        begin: parseInt(matches[1], 10),\n        chunk,\n      });\n    } else if (chunk) {\n      pendingRequest.onDone({\n        begin: 0,\n        chunk,\n      });\n    } else if (pendingRequest.onError) {\n      pendingRequest.onError(xhr.status);\n    }\n  }\n\n  getRequestXhr(xhrId) {\n    return this.pendingRequests[xhrId].xhr;\n  }\n\n  isPendingRequest(xhrId) {\n    return xhrId in this.pendingRequests;\n  }\n\n  abortRequest(xhrId) {\n    const xhr = this.pendingRequests[xhrId].xhr;\n    delete this.pendingRequests[xhrId];\n    xhr.abort();\n  }\n}\n\n/** @implements {IPDFStream} */\nclass PDFNetworkStream {\n  constructor(source) {\n    this._source = source;\n    this._manager = new NetworkManager(source.url, {\n      httpHeaders: source.httpHeaders,\n      withCredentials: source.withCredentials,\n    });\n    this._rangeChunkSize = source.rangeChunkSize;\n    this._fullRequestReader = null;\n    this._rangeRequestReaders = [];\n  }\n\n  _onRangeRequestReaderClosed(reader) {\n    const i = this._rangeRequestReaders.indexOf(reader);\n    if (i >= 0) {\n      this._rangeRequestReaders.splice(i, 1);\n    }\n  }\n\n  getFullReader() {\n    assert(\n      !this._fullRequestReader,\n      \"PDFNetworkStream.getFullReader can only be called once.\"\n    );\n    this._fullRequestReader = new PDFNetworkStreamFullRequestReader(\n      this._manager,\n      this._source\n    );\n    return this._fullRequestReader;\n  }\n\n  getRangeReader(begin, end) {\n    const reader = new PDFNetworkStreamRangeRequestReader(\n      this._manager,\n      begin,\n      end\n    );\n    reader.onClosed = this._onRangeRequestReaderClosed.bind(this);\n    this._rangeRequestReaders.push(reader);\n    return reader;\n  }\n\n  cancelAllRequests(reason) {\n    if (this._fullRequestReader) {\n      this._fullRequestReader.cancel(reason);\n    }\n    const readers = this._rangeRequestReaders.slice(0);\n    readers.forEach(function (reader) {\n      reader.cancel(reason);\n    });\n  }\n}\n\n/** @implements {IPDFStreamReader} */\nclass PDFNetworkStreamFullRequestReader {\n  constructor(manager, source) {\n    this._manager = manager;\n\n    const args = {\n      onHeadersReceived: this._onHeadersReceived.bind(this),\n      onDone: this._onDone.bind(this),\n      onError: this._onError.bind(this),\n      onProgress: this._onProgress.bind(this),\n    };\n    this._url = source.url;\n    this._fullRequestId = manager.requestFull(args);\n    this._headersReceivedCapability = createPromiseCapability();\n    this._disableRange = source.disableRange || false;\n    this._contentLength = source.length; // Optional\n    this._rangeChunkSize = source.rangeChunkSize;\n    if (!this._rangeChunkSize && !this._disableRange) {\n      this._disableRange = true;\n    }\n\n    this._isStreamingSupported = false;\n    this._isRangeSupported = false;\n\n    this._cachedChunks = [];\n    this._requests = [];\n    this._done = false;\n    this._storedError = undefined;\n    this._filename = null;\n\n    this.onProgress = null;\n  }\n\n  _onHeadersReceived() {\n    const fullRequestXhrId = this._fullRequestId;\n    const fullRequestXhr = this._manager.getRequestXhr(fullRequestXhrId);\n\n    const getResponseHeader = name => {\n      return fullRequestXhr.getResponseHeader(name);\n    };\n    const {\n      allowRangeRequests,\n      suggestedLength,\n    } = validateRangeRequestCapabilities({\n      getResponseHeader,\n      isHttp: this._manager.isHttp,\n      rangeChunkSize: this._rangeChunkSize,\n      disableRange: this._disableRange,\n    });\n\n    if (allowRangeRequests) {\n      this._isRangeSupported = true;\n    }\n    // Setting right content length.\n    this._contentLength = suggestedLength || this._contentLength;\n\n    this._filename = extractFilenameFromHeader(getResponseHeader);\n\n    if (this._isRangeSupported) {\n      // NOTE: by cancelling the full request, and then issuing range\n      // requests, there will be an issue for sites where you can only\n      // request the pdf once. However, if this is the case, then the\n      // server should not be returning that it can support range requests.\n      this._manager.abortRequest(fullRequestXhrId);\n    }\n\n    this._headersReceivedCapability.resolve();\n  }\n\n  _onDone(args) {\n    if (args) {\n      if (this._requests.length > 0) {\n        const requestCapability = this._requests.shift();\n        requestCapability.resolve({ value: args.chunk, done: false });\n      } else {\n        this._cachedChunks.push(args.chunk);\n      }\n    }\n    this._done = true;\n    if (this._cachedChunks.length > 0) {\n      return;\n    }\n    this._requests.forEach(function (requestCapability) {\n      requestCapability.resolve({ value: undefined, done: true });\n    });\n    this._requests = [];\n  }\n\n  _onError(status) {\n    const url = this._url;\n    const exception = createResponseStatusError(status, url);\n    this._storedError = exception;\n    this._headersReceivedCapability.reject(exception);\n    this._requests.forEach(function (requestCapability) {\n      requestCapability.reject(exception);\n    });\n    this._requests = [];\n    this._cachedChunks = [];\n  }\n\n  _onProgress(data) {\n    if (this.onProgress) {\n      this.onProgress({\n        loaded: data.loaded,\n        total: data.lengthComputable ? data.total : this._contentLength,\n      });\n    }\n  }\n\n  get filename() {\n    return this._filename;\n  }\n\n  get isRangeSupported() {\n    return this._isRangeSupported;\n  }\n\n  get isStreamingSupported() {\n    return this._isStreamingSupported;\n  }\n\n  get contentLength() {\n    return this._contentLength;\n  }\n\n  get headersReady() {\n    return this._headersReceivedCapability.promise;\n  }\n\n  async read() {\n    if (this._storedError) {\n      throw this._storedError;\n    }\n    if (this._cachedChunks.length > 0) {\n      const chunk = this._cachedChunks.shift();\n      return { value: chunk, done: false };\n    }\n    if (this._done) {\n      return { value: undefined, done: true };\n    }\n    const requestCapability = createPromiseCapability();\n    this._requests.push(requestCapability);\n    return requestCapability.promise;\n  }\n\n  cancel(reason) {\n    this._done = true;\n    this._headersReceivedCapability.reject(reason);\n    this._requests.forEach(function (requestCapability) {\n      requestCapability.resolve({ value: undefined, done: true });\n    });\n    this._requests = [];\n    if (this._manager.isPendingRequest(this._fullRequestId)) {\n      this._manager.abortRequest(this._fullRequestId);\n    }\n    this._fullRequestReader = null;\n  }\n}\n\n/** @implements {IPDFStreamRangeReader} */\nclass PDFNetworkStreamRangeRequestReader {\n  constructor(manager, begin, end) {\n    this._manager = manager;\n    const args = {\n      onDone: this._onDone.bind(this),\n      onProgress: this._onProgress.bind(this),\n    };\n    this._requestId = manager.requestRange(begin, end, args);\n    this._requests = [];\n    this._queuedChunk = null;\n    this._done = false;\n\n    this.onProgress = null;\n    this.onClosed = null;\n  }\n\n  _close() {\n    if (this.onClosed) {\n      this.onClosed(this);\n    }\n  }\n\n  _onDone(data) {\n    const chunk = data.chunk;\n    if (this._requests.length > 0) {\n      const requestCapability = this._requests.shift();\n      requestCapability.resolve({ value: chunk, done: false });\n    } else {\n      this._queuedChunk = chunk;\n    }\n    this._done = true;\n    this._requests.forEach(function (requestCapability) {\n      requestCapability.resolve({ value: undefined, done: true });\n    });\n    this._requests = [];\n    this._close();\n  }\n\n  _onProgress(evt) {\n    if (!this.isStreamingSupported && this.onProgress) {\n      this.onProgress({\n        loaded: evt.loaded,\n      });\n    }\n  }\n\n  get isStreamingSupported() {\n    return false;\n  }\n\n  async read() {\n    if (this._queuedChunk !== null) {\n      const chunk = this._queuedChunk;\n      this._queuedChunk = null;\n      return { value: chunk, done: false };\n    }\n    if (this._done) {\n      return { value: undefined, done: true };\n    }\n    const requestCapability = createPromiseCapability();\n    this._requests.push(requestCapability);\n    return requestCapability.promise;\n  }\n\n  cancel(reason) {\n    this._done = true;\n    this._requests.forEach(function (requestCapability) {\n      requestCapability.resolve({ value: undefined, done: true });\n    });\n    this._requests = [];\n    if (this._manager.isPendingRequest(this._requestId)) {\n      this._manager.abortRequest(this._requestId);\n    }\n    this._close();\n  }\n}\n\nexport { PDFNetworkStream };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport {\n  AbortException,\n  assert,\n  createPromiseCapability,\n} from \"../shared/util.js\";\nimport {\n  createResponseStatusError,\n  extractFilenameFromHeader,\n  validateRangeRequestCapabilities,\n  validateResponseStatus,\n} from \"./network_utils.js\";\n\nif (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"MOZCENTRAL\")) {\n  throw new Error(\n    'Module \"./fetch_stream.js\" shall not be used with MOZCENTRAL builds.'\n  );\n}\n\nfunction createFetchOptions(headers, withCredentials, abortController) {\n  return {\n    method: \"GET\",\n    headers,\n    signal: abortController && abortController.signal,\n    mode: \"cors\",\n    credentials: withCredentials ? \"include\" : \"same-origin\",\n    redirect: \"follow\",\n  };\n}\n\nfunction createHeaders(httpHeaders) {\n  const headers = new Headers();\n  for (const property in httpHeaders) {\n    const value = httpHeaders[property];\n    if (typeof value === \"undefined\") {\n      continue;\n    }\n    headers.append(property, value);\n  }\n  return headers;\n}\n\n/** @implements {IPDFStream} */\nclass PDFFetchStream {\n  constructor(source) {\n    this.source = source;\n    this.isHttp = /^https?:/i.test(source.url);\n    this.httpHeaders = (this.isHttp && source.httpHeaders) || {};\n\n    this._fullRequestReader = null;\n    this._rangeRequestReaders = [];\n  }\n\n  get _progressiveDataLength() {\n    return this._fullRequestReader ? this._fullRequestReader._loaded : 0;\n  }\n\n  getFullReader() {\n    assert(\n      !this._fullRequestReader,\n      \"PDFFetchStream.getFullReader can only be called once.\"\n    );\n    this._fullRequestReader = new PDFFetchStreamReader(this);\n    return this._fullRequestReader;\n  }\n\n  getRangeReader(begin, end) {\n    if (end <= this._progressiveDataLength) {\n      return null;\n    }\n    const reader = new PDFFetchStreamRangeReader(this, begin, end);\n    this._rangeRequestReaders.push(reader);\n    return reader;\n  }\n\n  cancelAllRequests(reason) {\n    if (this._fullRequestReader) {\n      this._fullRequestReader.cancel(reason);\n    }\n    const readers = this._rangeRequestReaders.slice(0);\n    readers.forEach(function (reader) {\n      reader.cancel(reason);\n    });\n  }\n}\n\n/** @implements {IPDFStreamReader} */\nclass PDFFetchStreamReader {\n  constructor(stream) {\n    this._stream = stream;\n    this._reader = null;\n    this._loaded = 0;\n    this._filename = null;\n    const source = stream.source;\n    this._withCredentials = source.withCredentials || false;\n    this._contentLength = source.length;\n    this._headersCapability = createPromiseCapability();\n    this._disableRange = source.disableRange || false;\n    this._rangeChunkSize = source.rangeChunkSize;\n    if (!this._rangeChunkSize && !this._disableRange) {\n      this._disableRange = true;\n    }\n\n    if (typeof AbortController !== \"undefined\") {\n      this._abortController = new AbortController();\n    }\n    this._isStreamingSupported = !source.disableStream;\n    this._isRangeSupported = !source.disableRange;\n\n    this._headers = createHeaders(this._stream.httpHeaders);\n\n    const url = source.url;\n    fetch(\n      url,\n      createFetchOptions(\n        this._headers,\n        this._withCredentials,\n        this._abortController\n      )\n    )\n      .then(response => {\n        if (!validateResponseStatus(response.status)) {\n          throw createResponseStatusError(response.status, url);\n        }\n        this._reader = response.body.getReader();\n        this._headersCapability.resolve();\n\n        const getResponseHeader = name => {\n          return response.headers.get(name);\n        };\n        const {\n          allowRangeRequests,\n          suggestedLength,\n        } = validateRangeRequestCapabilities({\n          getResponseHeader,\n          isHttp: this._stream.isHttp,\n          rangeChunkSize: this._rangeChunkSize,\n          disableRange: this._disableRange,\n        });\n\n        this._isRangeSupported = allowRangeRequests;\n        // Setting right content length.\n        this._contentLength = suggestedLength || this._contentLength;\n\n        this._filename = extractFilenameFromHeader(getResponseHeader);\n\n        // We need to stop reading when range is supported and streaming is\n        // disabled.\n        if (!this._isStreamingSupported && this._isRangeSupported) {\n          this.cancel(new AbortException(\"Streaming is disabled.\"));\n        }\n      })\n      .catch(this._headersCapability.reject);\n\n    this.onProgress = null;\n  }\n\n  get headersReady() {\n    return this._headersCapability.promise;\n  }\n\n  get filename() {\n    return this._filename;\n  }\n\n  get contentLength() {\n    return this._contentLength;\n  }\n\n  get isRangeSupported() {\n    return this._isRangeSupported;\n  }\n\n  get isStreamingSupported() {\n    return this._isStreamingSupported;\n  }\n\n  async read() {\n    await this._headersCapability.promise;\n    const { value, done } = await this._reader.read();\n    if (done) {\n      return { value, done };\n    }\n    this._loaded += value.byteLength;\n    if (this.onProgress) {\n      this.onProgress({\n        loaded: this._loaded,\n        total: this._contentLength,\n      });\n    }\n    const buffer = new Uint8Array(value).buffer;\n    return { value: buffer, done: false };\n  }\n\n  cancel(reason) {\n    if (this._reader) {\n      this._reader.cancel(reason);\n    }\n    if (this._abortController) {\n      this._abortController.abort();\n    }\n  }\n}\n\n/** @implements {IPDFStreamRangeReader} */\nclass PDFFetchStreamRangeReader {\n  constructor(stream, begin, end) {\n    this._stream = stream;\n    this._reader = null;\n    this._loaded = 0;\n    const source = stream.source;\n    this._withCredentials = source.withCredentials || false;\n    this._readCapability = createPromiseCapability();\n    this._isStreamingSupported = !source.disableStream;\n\n    if (typeof AbortController !== \"undefined\") {\n      this._abortController = new AbortController();\n    }\n\n    this._headers = createHeaders(this._stream.httpHeaders);\n    this._headers.append(\"Range\", `bytes=${begin}-${end - 1}`);\n\n    const url = source.url;\n    fetch(\n      url,\n      createFetchOptions(\n        this._headers,\n        this._withCredentials,\n        this._abortController\n      )\n    )\n      .then(response => {\n        if (!validateResponseStatus(response.status)) {\n          throw createResponseStatusError(response.status, url);\n        }\n        this._readCapability.resolve();\n        this._reader = response.body.getReader();\n      })\n      .catch(reason => {\n        if (reason && reason.name === \"AbortError\") {\n          return;\n        }\n        throw reason;\n      });\n\n    this.onProgress = null;\n  }\n\n  get isStreamingSupported() {\n    return this._isStreamingSupported;\n  }\n\n  async read() {\n    await this._readCapability.promise;\n    const { value, done } = await this._reader.read();\n    if (done) {\n      return { value, done };\n    }\n    this._loaded += value.byteLength;\n    if (this.onProgress) {\n      this.onProgress({ loaded: this._loaded });\n    }\n    const buffer = new Uint8Array(value).buffer;\n    return { value: buffer, done: false };\n  }\n\n  cancel(reason) {\n    if (this._reader) {\n      this._reader.cancel(reason);\n    }\n    if (this._abortController) {\n      this._abortController.abort();\n    }\n  }\n}\n\nexport { PDFFetchStream };\n","(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"pdfjs-dist/web/pdf_viewer\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"pdfjs-dist/web/pdf_viewer\"] = factory();\n\telse\n\t\troot[\"pdfjs-dist/web/pdf_viewer\"] = factory();\n})(this, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __w_pdfjs_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __w_pdfjs_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__w_pdfjs_require__.m = modules;\n\n \t// expose the module cache\n \t__w_pdfjs_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__w_pdfjs_require__.d = function(exports, name, getter) {\n \t\tif(!__w_pdfjs_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__w_pdfjs_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__w_pdfjs_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __w_pdfjs_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__w_pdfjs_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __w_pdfjs_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__w_pdfjs_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__w_pdfjs_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__w_pdfjs_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__w_pdfjs_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __w_pdfjs_require__(__w_pdfjs_require__.s = 0);\n","/* Copyright 2014 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  AnnotationLayerBuilder,\n  DefaultAnnotationLayerFactory,\n} from \"./annotation_layer_builder.js\";\nimport {\n  DefaultTextLayerFactory,\n  TextLayerBuilder,\n} from \"./text_layer_builder.js\";\nimport { EventBus, NullL10n, ProgressBar } from \"./ui_utils.js\";\nimport { PDFLinkService, SimpleLinkService } from \"./pdf_link_service.js\";\nimport { DownloadManager } from \"./download_manager.js\";\nimport { GenericL10n } from \"./genericl10n.js\";\nimport { PDFFindController } from \"./pdf_find_controller.js\";\nimport { PDFHistory } from \"./pdf_history.js\";\nimport { PDFPageView } from \"./pdf_page_view.js\";\nimport { PDFSinglePageViewer } from \"./pdf_single_page_viewer.js\";\nimport { PDFViewer } from \"./pdf_viewer.js\";\n\n// eslint-disable-next-line no-unused-vars\nconst pdfjsVersion = PDFJSDev.eval(\"BUNDLE_VERSION\");\n// eslint-disable-next-line no-unused-vars\nconst pdfjsBuild = PDFJSDev.eval(\"BUNDLE_BUILD\");\n\nexport {\n  PDFViewer,\n  PDFSinglePageViewer,\n  PDFPageView,\n  PDFLinkService,\n  SimpleLinkService,\n  TextLayerBuilder,\n  DefaultTextLayerFactory,\n  AnnotationLayerBuilder,\n  DefaultAnnotationLayerFactory,\n  PDFHistory,\n  PDFFindController,\n  EventBus,\n  DownloadManager,\n  ProgressBar,\n  GenericL10n,\n  NullL10n,\n};\n","/* Copyright 2014 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AnnotationLayer } from \"pdfjs-lib\";\nimport { NullL10n } from \"./ui_utils.js\";\nimport { SimpleLinkService } from \"./pdf_link_service.js\";\n\n/**\n * @typedef {Object} AnnotationLayerBuilderOptions\n * @property {HTMLDivElement} pageDiv\n * @property {PDFPage} pdfPage\n * @property {AnnotationStorage} [annotationStorage]\n * @property {string} [imageResourcesPath] - Path for image resources, mainly\n *   for annotation icons. Include trailing slash.\n * @property {boolean} renderInteractiveForms\n * @property {IPDFLinkService} linkService\n * @property {DownloadManager} downloadManager\n * @property {IL10n} l10n - Localization service.\n */\n\nclass AnnotationLayerBuilder {\n  /**\n   * @param {AnnotationLayerBuilderOptions} options\n   */\n  constructor({\n    pageDiv,\n    pdfPage,\n    linkService,\n    downloadManager,\n    annotationStorage = null,\n    imageResourcesPath = \"\",\n    renderInteractiveForms = true,\n    l10n = NullL10n,\n  }) {\n    this.pageDiv = pageDiv;\n    this.pdfPage = pdfPage;\n    this.linkService = linkService;\n    this.downloadManager = downloadManager;\n    this.imageResourcesPath = imageResourcesPath;\n    this.renderInteractiveForms = renderInteractiveForms;\n    this.l10n = l10n;\n    this.annotationStorage = annotationStorage;\n\n    this.div = null;\n    this._cancelled = false;\n  }\n\n  /**\n   * @param {PageViewport} viewport\n   * @param {string} intent (default value is 'display')\n   * @returns {Promise<void>} A promise that is resolved when rendering of the\n   *   annotations is complete.\n   */\n  render(viewport, intent = \"display\") {\n    return this.pdfPage.getAnnotations({ intent }).then(annotations => {\n      if (this._cancelled) {\n        return;\n      }\n      if (annotations.length === 0) {\n        return;\n      }\n\n      const parameters = {\n        viewport: viewport.clone({ dontFlip: true }),\n        div: this.div,\n        annotations,\n        page: this.pdfPage,\n        imageResourcesPath: this.imageResourcesPath,\n        renderInteractiveForms: this.renderInteractiveForms,\n        linkService: this.linkService,\n        downloadManager: this.downloadManager,\n        annotationStorage: this.annotationStorage,\n      };\n\n      if (this.div) {\n        // If an annotationLayer already exists, refresh its children's\n        // transformation matrices.\n        AnnotationLayer.update(parameters);\n      } else {\n        // Create an annotation layer div and render the annotations\n        // if there is at least one annotation.\n        this.div = document.createElement(\"div\");\n        this.div.className = \"annotationLayer\";\n        this.pageDiv.appendChild(this.div);\n        parameters.div = this.div;\n\n        AnnotationLayer.render(parameters);\n        this.l10n.translate(this.div);\n      }\n    });\n  }\n\n  cancel() {\n    this._cancelled = true;\n  }\n\n  hide() {\n    if (!this.div) {\n      return;\n    }\n    this.div.setAttribute(\"hidden\", \"true\");\n  }\n}\n\n/**\n * @implements IPDFAnnotationLayerFactory\n */\nclass DefaultAnnotationLayerFactory {\n  /**\n   * @param {HTMLDivElement} pageDiv\n   * @param {PDFPage} pdfPage\n   * @param {AnnotationStorage} [annotationStorage]\n   * @param {string} [imageResourcesPath] - Path for image resources, mainly\n   *   for annotation icons. Include trailing slash.\n   * @param {boolean} renderInteractiveForms\n   * @param {IL10n} l10n\n   * @returns {AnnotationLayerBuilder}\n   */\n  createAnnotationLayerBuilder(\n    pageDiv,\n    pdfPage,\n    annotationStorage = null,\n    imageResourcesPath = \"\",\n    renderInteractiveForms = true,\n    l10n = NullL10n\n  ) {\n    return new AnnotationLayerBuilder({\n      pageDiv,\n      pdfPage,\n      imageResourcesPath,\n      renderInteractiveForms,\n      linkService: new SimpleLinkService(),\n      l10n,\n      annotationStorage,\n    });\n  }\n}\n\nexport { AnnotationLayerBuilder, DefaultAnnotationLayerFactory };\n","/* Copyright 2016 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* globals module, __non_webpack_require__ */\n\n\"use strict\";\n\nlet pdfjsLib;\nif (typeof window !== \"undefined\" && window[\"pdfjs-dist/build/pdf\"]) {\n  pdfjsLib = window[\"pdfjs-dist/build/pdf\"];\n} else {\n  pdfjsLib = __non_webpack_require__(\"../build/pdf.js\");\n}\nmodule.exports = pdfjsLib;\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst CSS_UNITS = 96.0 / 72.0;\nconst DEFAULT_SCALE_VALUE = \"auto\";\nconst DEFAULT_SCALE = 1.0;\nconst MIN_SCALE = 0.1;\nconst MAX_SCALE = 10.0;\nconst UNKNOWN_SCALE = 0;\nconst MAX_AUTO_SCALE = 1.25;\nconst SCROLLBAR_PADDING = 40;\nconst VERTICAL_PADDING = 5;\n\nconst PresentationModeState = {\n  UNKNOWN: 0,\n  NORMAL: 1,\n  CHANGING: 2,\n  FULLSCREEN: 3,\n};\n\nconst RendererType = {\n  CANVAS: \"canvas\",\n  SVG: \"svg\",\n};\n\nconst TextLayerMode = {\n  DISABLE: 0,\n  ENABLE: 1,\n  ENABLE_ENHANCE: 2,\n};\n\nconst ScrollMode = {\n  UNKNOWN: -1,\n  VERTICAL: 0, // Default value.\n  HORIZONTAL: 1,\n  WRAPPED: 2,\n};\n\nconst SpreadMode = {\n  UNKNOWN: -1,\n  NONE: 0, // Default value.\n  ODD: 1,\n  EVEN: 2,\n};\n\n// Used by `PDFViewerApplication`, and by the API unit-tests.\nconst AutoPrintRegExp = /\\bprint\\s*\\(/;\n\n// Replaces {{arguments}} with their values.\nfunction formatL10nValue(text, args) {\n  if (!args) {\n    return text;\n  }\n  return text.replace(/\\{\\{\\s*(\\w+)\\s*\\}\\}/g, (all, name) => {\n    return name in args ? args[name] : \"{{\" + name + \"}}\";\n  });\n}\n\n/**\n * No-op implementation of the localization service.\n * @implements {IL10n}\n */\nconst NullL10n = {\n  async getLanguage() {\n    return \"en-us\";\n  },\n\n  async getDirection() {\n    return \"ltr\";\n  },\n\n  async get(property, args, fallback) {\n    return formatL10nValue(fallback, args);\n  },\n\n  async translate(element) {},\n};\n\n/**\n * Returns scale factor for the canvas. It makes sense for the HiDPI displays.\n * @returns {Object} The object with horizontal (sx) and vertical (sy)\n *                   scales. The scaled property is set to false if scaling is\n *                   not required, true otherwise.\n */\nfunction getOutputScale(ctx) {\n  const devicePixelRatio = window.devicePixelRatio || 1;\n  const backingStoreRatio =\n    ctx.webkitBackingStorePixelRatio ||\n    ctx.mozBackingStorePixelRatio ||\n    ctx.msBackingStorePixelRatio ||\n    ctx.oBackingStorePixelRatio ||\n    ctx.backingStorePixelRatio ||\n    1;\n  const pixelRatio = devicePixelRatio / backingStoreRatio;\n  return {\n    sx: pixelRatio,\n    sy: pixelRatio,\n    scaled: pixelRatio !== 1,\n  };\n}\n\n/**\n * Scrolls specified element into view of its parent.\n * @param {Object} element - The element to be visible.\n * @param {Object} spot - An object with optional top and left properties,\n *   specifying the offset from the top left edge.\n * @param {boolean} skipOverflowHiddenElements - Ignore elements that have\n *   the CSS rule `overflow: hidden;` set. The default is false.\n */\nfunction scrollIntoView(element, spot, skipOverflowHiddenElements = false) {\n  // Assuming offsetParent is available (it's not available when viewer is in\n  // hidden iframe or object). We have to scroll: if the offsetParent is not set\n  // producing the error. See also animationStarted.\n  let parent = element.offsetParent;\n  if (!parent) {\n    console.error(\"offsetParent is not set -- cannot scroll\");\n    return;\n  }\n  let offsetY = element.offsetTop + element.clientTop;\n  let offsetX = element.offsetLeft + element.clientLeft;\n  while (\n    (parent.clientHeight === parent.scrollHeight &&\n      parent.clientWidth === parent.scrollWidth) ||\n    (skipOverflowHiddenElements &&\n      getComputedStyle(parent).overflow === \"hidden\")\n  ) {\n    if (parent.dataset._scaleY) {\n      offsetY /= parent.dataset._scaleY;\n      offsetX /= parent.dataset._scaleX;\n    }\n    offsetY += parent.offsetTop;\n    offsetX += parent.offsetLeft;\n    parent = parent.offsetParent;\n    if (!parent) {\n      return; // no need to scroll\n    }\n  }\n  if (spot) {\n    if (spot.top !== undefined) {\n      offsetY += spot.top;\n    }\n    if (spot.left !== undefined) {\n      offsetX += spot.left;\n      parent.scrollLeft = offsetX;\n    }\n  }\n  parent.scrollTop = offsetY;\n}\n\n/**\n * Helper function to start monitoring the scroll event and converting them into\n * PDF.js friendly one: with scroll debounce and scroll direction.\n */\nfunction watchScroll(viewAreaElement, callback) {\n  const debounceScroll = function (evt) {\n    if (rAF) {\n      return;\n    }\n    // schedule an invocation of scroll for next animation frame.\n    rAF = window.requestAnimationFrame(function viewAreaElementScrolled() {\n      rAF = null;\n\n      const currentX = viewAreaElement.scrollLeft;\n      const lastX = state.lastX;\n      if (currentX !== lastX) {\n        state.right = currentX > lastX;\n      }\n      state.lastX = currentX;\n      const currentY = viewAreaElement.scrollTop;\n      const lastY = state.lastY;\n      if (currentY !== lastY) {\n        state.down = currentY > lastY;\n      }\n      state.lastY = currentY;\n      callback(state);\n    });\n  };\n\n  const state = {\n    right: true,\n    down: true,\n    lastX: viewAreaElement.scrollLeft,\n    lastY: viewAreaElement.scrollTop,\n    _eventHandler: debounceScroll,\n  };\n\n  let rAF = null;\n  viewAreaElement.addEventListener(\"scroll\", debounceScroll, true);\n  return state;\n}\n\n/**\n * Helper function to parse query string (e.g. ?param1=value&parm2=...).\n */\nfunction parseQueryString(query) {\n  const parts = query.split(\"&\");\n  const params = Object.create(null);\n  for (let i = 0, ii = parts.length; i < ii; ++i) {\n    const param = parts[i].split(\"=\");\n    const key = param[0].toLowerCase();\n    const value = param.length > 1 ? param[1] : null;\n    params[decodeURIComponent(key)] = decodeURIComponent(value);\n  }\n  return params;\n}\n\n/**\n * Use binary search to find the index of the first item in a given array which\n * passes a given condition. The items are expected to be sorted in the sense\n * that if the condition is true for one item in the array, then it is also true\n * for all following items.\n *\n * @returns {number} Index of the first array element to pass the test,\n *                   or |items.length| if no such element exists.\n */\nfunction binarySearchFirstItem(items, condition) {\n  let minIndex = 0;\n  let maxIndex = items.length - 1;\n\n  if (maxIndex < 0 || !condition(items[maxIndex])) {\n    return items.length;\n  }\n  if (condition(items[minIndex])) {\n    return minIndex;\n  }\n\n  while (minIndex < maxIndex) {\n    const currentIndex = (minIndex + maxIndex) >> 1;\n    const currentItem = items[currentIndex];\n    if (condition(currentItem)) {\n      maxIndex = currentIndex;\n    } else {\n      minIndex = currentIndex + 1;\n    }\n  }\n  return minIndex; /* === maxIndex */\n}\n\n/**\n *  Approximates float number as a fraction using Farey sequence (max order\n *  of 8).\n *  @param {number} x - Positive float number.\n *  @returns {Array} Estimated fraction: the first array item is a numerator,\n *                   the second one is a denominator.\n */\nfunction approximateFraction(x) {\n  // Fast paths for int numbers or their inversions.\n  if (Math.floor(x) === x) {\n    return [x, 1];\n  }\n  const xinv = 1 / x;\n  const limit = 8;\n  if (xinv > limit) {\n    return [1, limit];\n  } else if (Math.floor(xinv) === xinv) {\n    return [1, xinv];\n  }\n\n  const x_ = x > 1 ? xinv : x;\n  // a/b and c/d are neighbours in Farey sequence.\n  let a = 0,\n    b = 1,\n    c = 1,\n    d = 1;\n  // Limiting search to order 8.\n  while (true) {\n    // Generating next term in sequence (order of q).\n    const p = a + c,\n      q = b + d;\n    if (q > limit) {\n      break;\n    }\n    if (x_ <= p / q) {\n      c = p;\n      d = q;\n    } else {\n      a = p;\n      b = q;\n    }\n  }\n  let result;\n  // Select closest of the neighbours to x.\n  if (x_ - a / b < c / d - x_) {\n    result = x_ === x ? [a, b] : [b, a];\n  } else {\n    result = x_ === x ? [c, d] : [d, c];\n  }\n  return result;\n}\n\nfunction roundToDivide(x, div) {\n  const r = x % div;\n  return r === 0 ? x : Math.round(x - r + div);\n}\n\n/**\n * Gets the size of the specified page, converted from PDF units to inches.\n * @param {Object} An Object containing the properties: {Array} `view`,\n *   {number} `userUnit`, and {number} `rotate`.\n * @returns {Object} An Object containing the properties: {number} `width`\n *   and {number} `height`, given in inches.\n */\nfunction getPageSizeInches({ view, userUnit, rotate }) {\n  const [x1, y1, x2, y2] = view;\n  // We need to take the page rotation into account as well.\n  const changeOrientation = rotate % 180 !== 0;\n\n  const width = ((x2 - x1) / 72) * userUnit;\n  const height = ((y2 - y1) / 72) * userUnit;\n\n  return {\n    width: changeOrientation ? height : width,\n    height: changeOrientation ? width : height,\n  };\n}\n\n/**\n * Helper function for getVisibleElements.\n *\n * @param {number} index - initial guess at the first visible element\n * @param {Array} views - array of pages, into which `index` is an index\n * @param {number} top - the top of the scroll pane\n * @returns {number} less than or equal to `index` that is definitely at or\n *   before the first visible element in `views`, but not by too much. (Usually,\n *   this will be the first element in the first partially visible row in\n *   `views`, although sometimes it goes back one row further.)\n */\nfunction backtrackBeforeAllVisibleElements(index, views, top) {\n  // binarySearchFirstItem's assumption is that the input is ordered, with only\n  // one index where the conditions flips from false to true: [false ...,\n  // true...]. With vertical scrolling and spreads, it is possible to have\n  // [false ..., true, false, true ...]. With wrapped scrolling we can have a\n  // similar sequence, with many more mixed true and false in the middle.\n  //\n  // So there is no guarantee that the binary search yields the index of the\n  // first visible element. It could have been any of the other visible elements\n  // that were preceded by a hidden element.\n\n  // Of course, if either this element or the previous (hidden) element is also\n  // the first element, there's nothing to worry about.\n  if (index < 2) {\n    return index;\n  }\n\n  // That aside, the possible cases are represented below.\n  //\n  //     ****  = fully hidden\n  //     A*B*  = mix of partially visible and/or hidden pages\n  //     CDEF  = fully visible\n  //\n  // (1) Binary search could have returned A, in which case we can stop.\n  // (2) Binary search could also have returned B, in which case we need to\n  // check the whole row.\n  // (3) Binary search could also have returned C, in which case we need to\n  // check the whole previous row.\n  //\n  // There's one other possibility:\n  //\n  //     ****  = fully hidden\n  //     ABCD  = mix of fully and/or partially visible pages\n  //\n  // (4) Binary search could only have returned A.\n\n  // Initially assume that we need to find the beginning of the current row\n  // (case 1, 2, or 4), which means finding a page that is above the current\n  // page's top. If the found page is partially visible, we're definitely not in\n  // case 3, and this assumption is correct.\n  let elt = views[index].div;\n  let pageTop = elt.offsetTop + elt.clientTop;\n\n  if (pageTop >= top) {\n    // The found page is fully visible, so we're actually either in case 3 or 4,\n    // and unfortunately we can't tell the difference between them without\n    // scanning the entire previous row, so we just conservatively assume that\n    // we do need to backtrack to that row. In both cases, the previous page is\n    // in the previous row, so use its top instead.\n    elt = views[index - 1].div;\n    pageTop = elt.offsetTop + elt.clientTop;\n  }\n\n  // Now we backtrack to the first page that still has its bottom below\n  // `pageTop`, which is the top of a page in the first visible row (unless\n  // we're in case 4, in which case it's the row before that).\n  // `index` is found by binary search, so the page at `index - 1` is\n  // invisible and we can start looking for potentially visible pages from\n  // `index - 2`. (However, if this loop terminates on its first iteration,\n  // which is the case when pages are stacked vertically, `index` should remain\n  // unchanged, so we use a distinct loop variable.)\n  for (let i = index - 2; i >= 0; --i) {\n    elt = views[i].div;\n    if (elt.offsetTop + elt.clientTop + elt.clientHeight <= pageTop) {\n      // We have reached the previous row, so stop now.\n      // This loop is expected to terminate relatively quickly because the\n      // number of pages per row is expected to be small.\n      break;\n    }\n    index = i;\n  }\n  return index;\n}\n\n/**\n * Generic helper to find out what elements are visible within a scroll pane.\n *\n * Well, pretty generic. There are some assumptions placed on the elements\n * referenced by `views`:\n *   - If `horizontal`, no left of any earlier element is to the right of the\n *     left of any later element.\n *   - Otherwise, `views` can be split into contiguous rows where, within a row,\n *     no top of any element is below the bottom of any other element, and\n *     between rows, no bottom of any element in an earlier row is below the\n *     top of any element in a later row.\n *\n * (Here, top, left, etc. all refer to the padding edge of the element in\n * question. For pages, that ends up being equivalent to the bounding box of the\n * rendering canvas. Earlier and later refer to index in `views`, not page\n * layout.)\n *\n * @param scrollEl {HTMLElement} - a container that can possibly scroll\n * @param views {Array} - objects with a `div` property that contains an\n *   HTMLElement, which should all be descendents of `scrollEl` satisfying the\n *   above layout assumptions\n * @param sortByVisibility {boolean} - if true, the returned elements are sorted\n *   in descending order of the percent of their padding box that is visible\n * @param horizontal {boolean} - if true, the elements are assumed to be laid\n *   out horizontally instead of vertically\n * @returns {Object} `{ first, last, views: [{ id, x, y, view, percent }] }`\n */\nfunction getVisibleElements(\n  scrollEl,\n  views,\n  sortByVisibility = false,\n  horizontal = false\n) {\n  const top = scrollEl.scrollTop,\n    bottom = top + scrollEl.clientHeight;\n  const left = scrollEl.scrollLeft,\n    right = left + scrollEl.clientWidth;\n\n  // Throughout this \"generic\" function, comments will assume we're working with\n  // PDF document pages, which is the most important and complex case. In this\n  // case, the visible elements we're actually interested is the page canvas,\n  // which is contained in a wrapper which adds no padding/border/margin, which\n  // is itself contained in `view.div` which adds no padding (but does add a\n  // border). So, as specified in this function's doc comment, this function\n  // does all of its work on the padding edge of the provided views, starting at\n  // offsetLeft/Top (which includes margin) and adding clientLeft/Top (which is\n  // the border). Adding clientWidth/Height gets us the bottom-right corner of\n  // the padding edge.\n  function isElementBottomAfterViewTop(view) {\n    const element = view.div;\n    const elementBottom =\n      element.offsetTop + element.clientTop + element.clientHeight;\n    return elementBottom > top;\n  }\n  function isElementRightAfterViewLeft(view) {\n    const element = view.div;\n    const elementRight =\n      element.offsetLeft + element.clientLeft + element.clientWidth;\n    return elementRight > left;\n  }\n\n  const visible = [],\n    numViews = views.length;\n  let firstVisibleElementInd =\n    numViews === 0\n      ? 0\n      : binarySearchFirstItem(\n          views,\n          horizontal ? isElementRightAfterViewLeft : isElementBottomAfterViewTop\n        );\n\n  // Please note the return value of the `binarySearchFirstItem` function when\n  // no valid element is found (hence the `firstVisibleElementInd` check below).\n  if (\n    firstVisibleElementInd > 0 &&\n    firstVisibleElementInd < numViews &&\n    !horizontal\n  ) {\n    // In wrapped scrolling (or vertical scrolling with spreads), with some page\n    // sizes, isElementBottomAfterViewTop doesn't satisfy the binary search\n    // condition: there can be pages with bottoms above the view top between\n    // pages with bottoms below. This function detects and corrects that error;\n    // see it for more comments.\n    firstVisibleElementInd = backtrackBeforeAllVisibleElements(\n      firstVisibleElementInd,\n      views,\n      top\n    );\n  }\n\n  // lastEdge acts as a cutoff for us to stop looping, because we know all\n  // subsequent pages will be hidden.\n  //\n  // When using wrapped scrolling or vertical scrolling with spreads, we can't\n  // simply stop the first time we reach a page below the bottom of the view;\n  // the tops of subsequent pages on the same row could still be visible. In\n  // horizontal scrolling, we don't have that issue, so we can stop as soon as\n  // we pass `right`, without needing the code below that handles the -1 case.\n  let lastEdge = horizontal ? right : -1;\n\n  for (let i = firstVisibleElementInd; i < numViews; i++) {\n    const view = views[i],\n      element = view.div;\n    const currentWidth = element.offsetLeft + element.clientLeft;\n    const currentHeight = element.offsetTop + element.clientTop;\n    const viewWidth = element.clientWidth,\n      viewHeight = element.clientHeight;\n    const viewRight = currentWidth + viewWidth;\n    const viewBottom = currentHeight + viewHeight;\n\n    if (lastEdge === -1) {\n      // As commented above, this is only needed in non-horizontal cases.\n      // Setting lastEdge to the bottom of the first page that is partially\n      // visible ensures that the next page fully below lastEdge is on the\n      // next row, which has to be fully hidden along with all subsequent rows.\n      if (viewBottom >= bottom) {\n        lastEdge = viewBottom;\n      }\n    } else if ((horizontal ? currentWidth : currentHeight) > lastEdge) {\n      break;\n    }\n\n    if (\n      viewBottom <= top ||\n      currentHeight >= bottom ||\n      viewRight <= left ||\n      currentWidth >= right\n    ) {\n      continue;\n    }\n\n    const hiddenHeight =\n      Math.max(0, top - currentHeight) + Math.max(0, viewBottom - bottom);\n    const hiddenWidth =\n      Math.max(0, left - currentWidth) + Math.max(0, viewRight - right);\n    const percent =\n      (((viewHeight - hiddenHeight) * (viewWidth - hiddenWidth) * 100) /\n        viewHeight /\n        viewWidth) |\n      0;\n    visible.push({\n      id: view.id,\n      x: currentWidth,\n      y: currentHeight,\n      view,\n      percent,\n    });\n  }\n\n  const first = visible[0],\n    last = visible[visible.length - 1];\n\n  if (sortByVisibility) {\n    visible.sort(function (a, b) {\n      const pc = a.percent - b.percent;\n      if (Math.abs(pc) > 0.001) {\n        return -pc;\n      }\n      return a.id - b.id; // ensure stability\n    });\n  }\n  return { first, last, views: visible };\n}\n\n/**\n * Event handler to suppress context menu.\n */\nfunction noContextMenuHandler(evt) {\n  evt.preventDefault();\n}\n\nfunction isDataSchema(url) {\n  let i = 0;\n  const ii = url.length;\n  while (i < ii && url[i].trim() === \"\") {\n    i++;\n  }\n  return url.substring(i, i + 5).toLowerCase() === \"data:\";\n}\n\n/**\n * Returns the filename or guessed filename from the url (see issue 3455).\n * @param {string} url - The original PDF location.\n * @param {string} defaultFilename - The value returned if the filename is\n *   unknown, or the protocol is unsupported.\n * @returns {string} Guessed PDF filename.\n */\nfunction getPDFFileNameFromURL(url, defaultFilename = \"document.pdf\") {\n  if (typeof url !== \"string\") {\n    return defaultFilename;\n  }\n  if (isDataSchema(url)) {\n    console.warn(\n      \"getPDFFileNameFromURL: \" +\n        'ignoring \"data:\" URL for performance reasons.'\n    );\n    return defaultFilename;\n  }\n  const reURI = /^(?:(?:[^:]+:)?\\/\\/[^\\/]+)?([^?#]*)(\\?[^#]*)?(#.*)?$/;\n  //              SCHEME        HOST         1.PATH  2.QUERY   3.REF\n  // Pattern to get last matching NAME.pdf\n  const reFilename = /[^\\/?#=]+\\.pdf\\b(?!.*\\.pdf\\b)/i;\n  const splitURI = reURI.exec(url);\n  let suggestedFilename =\n    reFilename.exec(splitURI[1]) ||\n    reFilename.exec(splitURI[2]) ||\n    reFilename.exec(splitURI[3]);\n  if (suggestedFilename) {\n    suggestedFilename = suggestedFilename[0];\n    if (suggestedFilename.includes(\"%\")) {\n      // URL-encoded %2Fpath%2Fto%2Ffile.pdf should be file.pdf\n      try {\n        suggestedFilename = reFilename.exec(\n          decodeURIComponent(suggestedFilename)\n        )[0];\n      } catch (ex) {\n        // Possible (extremely rare) errors:\n        // URIError \"Malformed URI\", e.g. for \"%AA.pdf\"\n        // TypeError \"null has no properties\", e.g. for \"%2F.pdf\"\n      }\n    }\n  }\n  return suggestedFilename || defaultFilename;\n}\n\nfunction normalizeWheelEventDirection(evt) {\n  let delta = Math.sqrt(evt.deltaX * evt.deltaX + evt.deltaY * evt.deltaY);\n  const angle = Math.atan2(evt.deltaY, evt.deltaX);\n  if (-0.25 * Math.PI < angle && angle < 0.75 * Math.PI) {\n    // All that is left-up oriented has to change the sign.\n    delta = -delta;\n  }\n  return delta;\n}\n\nfunction normalizeWheelEventDelta(evt) {\n  let delta = normalizeWheelEventDirection(evt);\n\n  const MOUSE_DOM_DELTA_PIXEL_MODE = 0;\n  const MOUSE_DOM_DELTA_LINE_MODE = 1;\n  const MOUSE_PIXELS_PER_LINE = 30;\n  const MOUSE_LINES_PER_PAGE = 30;\n\n  // Converts delta to per-page units\n  if (evt.deltaMode === MOUSE_DOM_DELTA_PIXEL_MODE) {\n    delta /= MOUSE_PIXELS_PER_LINE * MOUSE_LINES_PER_PAGE;\n  } else if (evt.deltaMode === MOUSE_DOM_DELTA_LINE_MODE) {\n    delta /= MOUSE_LINES_PER_PAGE;\n  }\n  return delta;\n}\n\nfunction isValidRotation(angle) {\n  return Number.isInteger(angle) && angle % 90 === 0;\n}\n\nfunction isValidScrollMode(mode) {\n  return (\n    Number.isInteger(mode) &&\n    Object.values(ScrollMode).includes(mode) &&\n    mode !== ScrollMode.UNKNOWN\n  );\n}\n\nfunction isValidSpreadMode(mode) {\n  return (\n    Number.isInteger(mode) &&\n    Object.values(SpreadMode).includes(mode) &&\n    mode !== SpreadMode.UNKNOWN\n  );\n}\n\nfunction isPortraitOrientation(size) {\n  return size.width <= size.height;\n}\n\nconst WaitOnType = {\n  EVENT: \"event\",\n  TIMEOUT: \"timeout\",\n};\n\n/**\n * @typedef {Object} WaitOnEventOrTimeoutParameters\n * @property {Object} target - The event target, can for example be:\n *   `window`, `document`, a DOM element, or an {EventBus} instance.\n * @property {string} name - The name of the event.\n * @property {number} delay - The delay, in milliseconds, after which the\n *   timeout occurs (if the event wasn't already dispatched).\n */\n\n/**\n * Allows waiting for an event or a timeout, whichever occurs first.\n * Can be used to ensure that an action always occurs, even when an event\n * arrives late or not at all.\n *\n * @param {WaitOnEventOrTimeoutParameters}\n * @returns {Promise} A promise that is resolved with a {WaitOnType} value.\n */\nfunction waitOnEventOrTimeout({ target, name, delay = 0 }) {\n  return new Promise(function (resolve, reject) {\n    if (\n      typeof target !== \"object\" ||\n      !(name && typeof name === \"string\") ||\n      !(Number.isInteger(delay) && delay >= 0)\n    ) {\n      throw new Error(\"waitOnEventOrTimeout - invalid parameters.\");\n    }\n\n    function handler(type) {\n      if (target instanceof EventBus) {\n        target._off(name, eventHandler);\n      } else {\n        target.removeEventListener(name, eventHandler);\n      }\n\n      if (timeout) {\n        clearTimeout(timeout);\n      }\n      resolve(type);\n    }\n\n    const eventHandler = handler.bind(null, WaitOnType.EVENT);\n    if (target instanceof EventBus) {\n      target._on(name, eventHandler);\n    } else {\n      target.addEventListener(name, eventHandler);\n    }\n\n    const timeoutHandler = handler.bind(null, WaitOnType.TIMEOUT);\n    const timeout = setTimeout(timeoutHandler, delay);\n  });\n}\n\n/**\n * Promise that is resolved when DOM window becomes visible.\n */\nconst animationStarted = new Promise(function (resolve) {\n  if (\n    typeof PDFJSDev !== \"undefined\" &&\n    PDFJSDev.test(\"LIB && TESTING\") &&\n    typeof window === \"undefined\"\n  ) {\n    // Prevent \"ReferenceError: window is not defined\" errors when running the\n    // unit-tests in Node.js/Travis.\n    setTimeout(resolve, 20);\n    return;\n  }\n  window.requestAnimationFrame(resolve);\n});\n\n/**\n * NOTE: Only used to support various PDF viewer tests in `mozilla-central`.\n */\nfunction dispatchDOMEvent(eventName, args = null) {\n  if (typeof PDFJSDev !== \"undefined\" && !PDFJSDev.test(\"MOZCENTRAL\")) {\n    throw new Error(\"Not implemented: dispatchDOMEvent\");\n  }\n  const details = Object.create(null);\n  if (args && args.length > 0) {\n    const obj = args[0];\n    for (const key in obj) {\n      const value = obj[key];\n      if (key === \"source\") {\n        if (value === window || value === document) {\n          return; // No need to re-dispatch (already) global events.\n        }\n        continue; // Ignore the `source` property.\n      }\n      details[key] = value;\n    }\n  }\n  const event = document.createEvent(\"CustomEvent\");\n  event.initCustomEvent(eventName, true, true, details);\n  document.dispatchEvent(event);\n}\n\n/**\n * Simple event bus for an application. Listeners are attached using the `on`\n * and `off` methods. To raise an event, the `dispatch` method shall be used.\n */\nclass EventBus {\n  constructor(options) {\n    this._listeners = Object.create(null);\n\n    if (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"MOZCENTRAL\")) {\n      this._isInAutomation = (options && options.isInAutomation) === true;\n    }\n  }\n\n  /**\n   * @param {string} eventName\n   * @param {function} listener\n   */\n  on(eventName, listener) {\n    this._on(eventName, listener, { external: true });\n  }\n\n  /**\n   * @param {string} eventName\n   * @param {function} listener\n   */\n  off(eventName, listener) {\n    this._off(eventName, listener, { external: true });\n  }\n\n  dispatch(eventName) {\n    const eventListeners = this._listeners[eventName];\n    if (!eventListeners || eventListeners.length === 0) {\n      if (\n        (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"MOZCENTRAL\")) &&\n        this._isInAutomation\n      ) {\n        const args = Array.prototype.slice.call(arguments, 1);\n        dispatchDOMEvent(eventName, args);\n      }\n      return;\n    }\n    // Passing all arguments after the eventName to the listeners.\n    const args = Array.prototype.slice.call(arguments, 1);\n    let externalListeners;\n    // Making copy of the listeners array in case if it will be modified\n    // during dispatch.\n    eventListeners.slice(0).forEach(function ({ listener, external }) {\n      if (external) {\n        if (!externalListeners) {\n          externalListeners = [];\n        }\n        externalListeners.push(listener);\n        return;\n      }\n      listener.apply(null, args);\n    });\n    // Dispatch any \"external\" listeners *after* the internal ones, to give the\n    // viewer components time to handle events and update their state first.\n    if (externalListeners) {\n      externalListeners.forEach(function (listener) {\n        listener.apply(null, args);\n      });\n      externalListeners = null;\n    }\n    if (\n      (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"MOZCENTRAL\")) &&\n      this._isInAutomation\n    ) {\n      dispatchDOMEvent(eventName, args);\n    }\n  }\n\n  /**\n   * @ignore\n   */\n  _on(eventName, listener, options = null) {\n    let eventListeners = this._listeners[eventName];\n    if (!eventListeners) {\n      this._listeners[eventName] = eventListeners = [];\n    }\n    eventListeners.push({\n      listener,\n      external: (options && options.external) === true,\n    });\n  }\n\n  /**\n   * @ignore\n   */\n  _off(eventName, listener, options = null) {\n    const eventListeners = this._listeners[eventName];\n    if (!eventListeners) {\n      return;\n    }\n    for (let i = 0, ii = eventListeners.length; i < ii; i++) {\n      if (eventListeners[i].listener === listener) {\n        eventListeners.splice(i, 1);\n        return;\n      }\n    }\n  }\n}\n\nfunction clamp(v, min, max) {\n  return Math.min(Math.max(v, min), max);\n}\n\nclass ProgressBar {\n  constructor(id, { height, width, units } = {}) {\n    this.visible = true;\n\n    // Fetch the sub-elements for later.\n    this.div = document.querySelector(id + \" .progress\");\n    // Get the loading bar element, so it can be resized to fit the viewer.\n    this.bar = this.div.parentNode;\n\n    // Get options, with sensible defaults.\n    this.height = height || 100;\n    this.width = width || 100;\n    this.units = units || \"%\";\n\n    // Initialize heights.\n    this.div.style.height = this.height + this.units;\n    this.percent = 0;\n  }\n\n  _updateBar() {\n    if (this._indeterminate) {\n      this.div.classList.add(\"indeterminate\");\n      this.div.style.width = this.width + this.units;\n      return;\n    }\n\n    this.div.classList.remove(\"indeterminate\");\n    const progressSize = (this.width * this._percent) / 100;\n    this.div.style.width = progressSize + this.units;\n  }\n\n  get percent() {\n    return this._percent;\n  }\n\n  set percent(val) {\n    this._indeterminate = isNaN(val);\n    this._percent = clamp(val, 0, 100);\n    this._updateBar();\n  }\n\n  setWidth(viewer) {\n    if (!viewer) {\n      return;\n    }\n    const container = viewer.parentNode;\n    const scrollbarWidth = container.offsetWidth - viewer.offsetWidth;\n    if (scrollbarWidth > 0) {\n      this.bar.style.width = `calc(100% - ${scrollbarWidth}px)`;\n    }\n  }\n\n  hide() {\n    if (!this.visible) {\n      return;\n    }\n    this.visible = false;\n    this.bar.classList.add(\"hidden\");\n    document.body.classList.remove(\"loadingInProgress\");\n  }\n\n  show() {\n    if (this.visible) {\n      return;\n    }\n    this.visible = true;\n    document.body.classList.add(\"loadingInProgress\");\n    this.bar.classList.remove(\"hidden\");\n  }\n}\n\n/**\n * Moves all elements of an array that satisfy condition to the end of the\n * array, preserving the order of the rest.\n */\nfunction moveToEndOfArray(arr, condition) {\n  const moved = [],\n    len = arr.length;\n  let write = 0;\n  for (let read = 0; read < len; ++read) {\n    if (condition(arr[read])) {\n      moved.push(arr[read]);\n    } else {\n      arr[write] = arr[read];\n      ++write;\n    }\n  }\n  for (let read = 0; write < len; ++read, ++write) {\n    arr[write] = moved[read];\n  }\n}\n\nexport {\n  AutoPrintRegExp,\n  CSS_UNITS,\n  DEFAULT_SCALE_VALUE,\n  DEFAULT_SCALE,\n  MIN_SCALE,\n  MAX_SCALE,\n  UNKNOWN_SCALE,\n  MAX_AUTO_SCALE,\n  SCROLLBAR_PADDING,\n  VERTICAL_PADDING,\n  isValidRotation,\n  isValidScrollMode,\n  isValidSpreadMode,\n  isPortraitOrientation,\n  PresentationModeState,\n  RendererType,\n  TextLayerMode,\n  ScrollMode,\n  SpreadMode,\n  NullL10n,\n  EventBus,\n  clamp,\n  ProgressBar,\n  getPDFFileNameFromURL,\n  noContextMenuHandler,\n  parseQueryString,\n  backtrackBeforeAllVisibleElements, // only exported for testing\n  getVisibleElements,\n  roundToDivide,\n  getPageSizeInches,\n  approximateFraction,\n  getOutputScale,\n  scrollIntoView,\n  watchScroll,\n  binarySearchFirstItem,\n  normalizeWheelEventDirection,\n  normalizeWheelEventDelta,\n  animationStarted,\n  WaitOnType,\n  waitOnEventOrTimeout,\n  moveToEndOfArray,\n};\n","module.exports = require(\"regenerator-runtime\");\n","/**\n * Copyright (c) 2014-present, Facebook, Inc.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\nvar runtime = (function (exports) {\n  \"use strict\";\n\n  var Op = Object.prototype;\n  var hasOwn = Op.hasOwnProperty;\n  var undefined; // More compressible than void 0.\n  var $Symbol = typeof Symbol === \"function\" ? Symbol : {};\n  var iteratorSymbol = $Symbol.iterator || \"@@iterator\";\n  var asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\";\n  var toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n\n  function define(obj, key, value) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n    return obj[key];\n  }\n  try {\n    // IE 8 has a broken Object.defineProperty that only works on DOM objects.\n    define({}, \"\");\n  } catch (err) {\n    define = function(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    // If outerFn provided and outerFn.prototype is a Generator, then outerFn.prototype instanceof Generator.\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;\n    var generator = Object.create(protoGenerator.prototype);\n    var context = new Context(tryLocsList || []);\n\n    // The ._invoke method unifies the implementations of the .next,\n    // .throw, and .return methods.\n    generator._invoke = makeInvokeMethod(innerFn, self, context);\n\n    return generator;\n  }\n  exports.wrap = wrap;\n\n  // Try/catch helper to minimize deoptimizations. Returns a completion\n  // record like context.tryEntries[i].completion. This interface could\n  // have been (and was previously) designed to take a closure to be\n  // invoked without arguments, but in all the cases we care about we\n  // already have an existing method we want to call, so there's no need\n  // to create a new function object. We can even get away with assuming\n  // the method takes exactly one argument, since that happens to be true\n  // in every case, so we don't have to touch the arguments object. The\n  // only additional allocation required is the completion record, which\n  // has a stable shape and so hopefully should be cheap to allocate.\n  function tryCatch(fn, obj, arg) {\n    try {\n      return { type: \"normal\", arg: fn.call(obj, arg) };\n    } catch (err) {\n      return { type: \"throw\", arg: err };\n    }\n  }\n\n  var GenStateSuspendedStart = \"suspendedStart\";\n  var GenStateSuspendedYield = \"suspendedYield\";\n  var GenStateExecuting = \"executing\";\n  var GenStateCompleted = \"completed\";\n\n  // Returning this object from the innerFn has the same effect as\n  // breaking out of the dispatch switch statement.\n  var ContinueSentinel = {};\n\n  // Dummy constructor functions that we use as the .constructor and\n  // .constructor.prototype properties for functions that return Generator\n  // objects. For full spec compliance, you may wish to configure your\n  // minifier not to mangle the names of these two functions.\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n\n  // This is a polyfill for %IteratorPrototype% for environments that\n  // don't natively support it.\n  var IteratorPrototype = {};\n  IteratorPrototype[iteratorSymbol] = function () {\n    return this;\n  };\n\n  var getProto = Object.getPrototypeOf;\n  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  if (NativeIteratorPrototype &&\n      NativeIteratorPrototype !== Op &&\n      hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {\n    // This environment has a native %IteratorPrototype%; use it instead\n    // of the polyfill.\n    IteratorPrototype = NativeIteratorPrototype;\n  }\n\n  var Gp = GeneratorFunctionPrototype.prototype =\n    Generator.prototype = Object.create(IteratorPrototype);\n  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;\n  GeneratorFunctionPrototype.constructor = GeneratorFunction;\n  GeneratorFunction.displayName = define(\n    GeneratorFunctionPrototype,\n    toStringTagSymbol,\n    \"GeneratorFunction\"\n  );\n\n  // Helper for defining the .next, .throw, and .return methods of the\n  // Iterator interface in terms of a single ._invoke method.\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function(method) {\n      define(prototype, method, function(arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n\n  exports.isGeneratorFunction = function(genFun) {\n    var ctor = typeof genFun === \"function\" && genFun.constructor;\n    return ctor\n      ? ctor === GeneratorFunction ||\n        // For the native GeneratorFunction constructor, the best we can\n        // do is to check its .name property.\n        (ctor.displayName || ctor.name) === \"GeneratorFunction\"\n      : false;\n  };\n\n  exports.mark = function(genFun) {\n    if (Object.setPrototypeOf) {\n      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);\n    } else {\n      genFun.__proto__ = GeneratorFunctionPrototype;\n      define(genFun, toStringTagSymbol, \"GeneratorFunction\");\n    }\n    genFun.prototype = Object.create(Gp);\n    return genFun;\n  };\n\n  // Within the body of any async function, `await x` is transformed to\n  // `yield regeneratorRuntime.awrap(x)`, so that the runtime can test\n  // `hasOwn.call(value, \"__await\")` to determine if the yielded value is\n  // meant to be awaited.\n  exports.awrap = function(arg) {\n    return { __await: arg };\n  };\n\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (record.type === \"throw\") {\n        reject(record.arg);\n      } else {\n        var result = record.arg;\n        var value = result.value;\n        if (value &&\n            typeof value === \"object\" &&\n            hasOwn.call(value, \"__await\")) {\n          return PromiseImpl.resolve(value.__await).then(function(value) {\n            invoke(\"next\", value, resolve, reject);\n          }, function(err) {\n            invoke(\"throw\", err, resolve, reject);\n          });\n        }\n\n        return PromiseImpl.resolve(value).then(function(unwrapped) {\n          // When a yielded Promise is resolved, its final value becomes\n          // the .value of the Promise<{value,done}> result for the\n          // current iteration.\n          result.value = unwrapped;\n          resolve(result);\n        }, function(error) {\n          // If a rejected Promise was yielded, throw the rejection back\n          // into the async generator function so it can be handled there.\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n    }\n\n    var previousPromise;\n\n    function enqueue(method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function(resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n\n      return previousPromise =\n        // If enqueue has been called before, then we want to wait until\n        // all previous Promises have been resolved before calling invoke,\n        // so that results are always delivered in the correct order. If\n        // enqueue has not been called before, then it is important to\n        // call invoke immediately, without waiting on a callback to fire,\n        // so that the async generator function has the opportunity to do\n        // any necessary setup in a predictable way. This predictability\n        // is why the Promise constructor synchronously invokes its\n        // executor callback, and why async functions synchronously\n        // execute code before the first await. Since we implement simple\n        // async functions in terms of async generators, it is especially\n        // important to get this right, even though it requires care.\n        previousPromise ? previousPromise.then(\n          callInvokeWithMethodAndArg,\n          // Avoid propagating failures to Promises returned by later\n          // invocations of the iterator.\n          callInvokeWithMethodAndArg\n        ) : callInvokeWithMethodAndArg();\n    }\n\n    // Define the unified helper method that is used to implement .next,\n    // .throw, and .return (see defineIteratorMethods).\n    this._invoke = enqueue;\n  }\n\n  defineIteratorMethods(AsyncIterator.prototype);\n  AsyncIterator.prototype[asyncIteratorSymbol] = function () {\n    return this;\n  };\n  exports.AsyncIterator = AsyncIterator;\n\n  // Note that simple async functions are implemented on top of\n  // AsyncIterator objects; they just return a Promise for the value of\n  // the final result produced by the iterator.\n  exports.async = function(innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    if (PromiseImpl === void 0) PromiseImpl = Promise;\n\n    var iter = new AsyncIterator(\n      wrap(innerFn, outerFn, self, tryLocsList),\n      PromiseImpl\n    );\n\n    return exports.isGeneratorFunction(outerFn)\n      ? iter // If outerFn is a generator, return the full iterator.\n      : iter.next().then(function(result) {\n          return result.done ? result.value : iter.next();\n        });\n  };\n\n  function makeInvokeMethod(innerFn, self, context) {\n    var state = GenStateSuspendedStart;\n\n    return function invoke(method, arg) {\n      if (state === GenStateExecuting) {\n        throw new Error(\"Generator is already running\");\n      }\n\n      if (state === GenStateCompleted) {\n        if (method === \"throw\") {\n          throw arg;\n        }\n\n        // Be forgiving, per 25.3.3.3.3 of the spec:\n        // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-generatorresume\n        return doneResult();\n      }\n\n      context.method = method;\n      context.arg = arg;\n\n      while (true) {\n        var delegate = context.delegate;\n        if (delegate) {\n          var delegateResult = maybeInvokeDelegate(delegate, context);\n          if (delegateResult) {\n            if (delegateResult === ContinueSentinel) continue;\n            return delegateResult;\n          }\n        }\n\n        if (context.method === \"next\") {\n          // Setting context._sent for legacy support of Babel's\n          // function.sent implementation.\n          context.sent = context._sent = context.arg;\n\n        } else if (context.method === \"throw\") {\n          if (state === GenStateSuspendedStart) {\n            state = GenStateCompleted;\n            throw context.arg;\n          }\n\n          context.dispatchException(context.arg);\n\n        } else if (context.method === \"return\") {\n          context.abrupt(\"return\", context.arg);\n        }\n\n        state = GenStateExecuting;\n\n        var record = tryCatch(innerFn, self, context);\n        if (record.type === \"normal\") {\n          // If an exception is thrown from innerFn, we leave state ===\n          // GenStateExecuting and loop back for another invocation.\n          state = context.done\n            ? GenStateCompleted\n            : GenStateSuspendedYield;\n\n          if (record.arg === ContinueSentinel) {\n            continue;\n          }\n\n          return {\n            value: record.arg,\n            done: context.done\n          };\n\n        } else if (record.type === \"throw\") {\n          state = GenStateCompleted;\n          // Dispatch the exception by looping back around to the\n          // context.dispatchException(context.arg) call above.\n          context.method = \"throw\";\n          context.arg = record.arg;\n        }\n      }\n    };\n  }\n\n  // Call delegate.iterator[context.method](context.arg) and handle the\n  // result, either by returning a { value, done } result from the\n  // delegate iterator, or by modifying context.method and context.arg,\n  // setting context.delegate to null, and returning the ContinueSentinel.\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (method === undefined) {\n      // A .throw or .return when the delegate iterator has no .throw\n      // method always terminates the yield* loop.\n      context.delegate = null;\n\n      if (context.method === \"throw\") {\n        // Note: [\"return\"] must be used for ES3 parsing compatibility.\n        if (delegate.iterator[\"return\"]) {\n          // If the delegate iterator has a return method, give it a\n          // chance to clean up.\n          context.method = \"return\";\n          context.arg = undefined;\n          maybeInvokeDelegate(delegate, context);\n\n          if (context.method === \"throw\") {\n            // If maybeInvokeDelegate(context) changed context.method from\n            // \"return\" to \"throw\", let that override the TypeError below.\n            return ContinueSentinel;\n          }\n        }\n\n        context.method = \"throw\";\n        context.arg = new TypeError(\n          \"The iterator does not provide a 'throw' method\");\n      }\n\n      return ContinueSentinel;\n    }\n\n    var record = tryCatch(method, delegate.iterator, context.arg);\n\n    if (record.type === \"throw\") {\n      context.method = \"throw\";\n      context.arg = record.arg;\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    var info = record.arg;\n\n    if (! info) {\n      context.method = \"throw\";\n      context.arg = new TypeError(\"iterator result is not an object\");\n      context.delegate = null;\n      return ContinueSentinel;\n    }\n\n    if (info.done) {\n      // Assign the result of the finished delegate to the temporary\n      // variable specified by delegate.resultName (see delegateYield).\n      context[delegate.resultName] = info.value;\n\n      // Resume execution at the desired location (see delegateYield).\n      context.next = delegate.nextLoc;\n\n      // If context.method was \"throw\" but the delegate handled the\n      // exception, let the outer generator proceed normally. If\n      // context.method was \"next\", forget context.arg since it has been\n      // \"consumed\" by the delegate iterator. If context.method was\n      // \"return\", allow the original .return call to continue in the\n      // outer generator.\n      if (context.method !== \"return\") {\n        context.method = \"next\";\n        context.arg = undefined;\n      }\n\n    } else {\n      // Re-yield the result returned by the delegate method.\n      return info;\n    }\n\n    // The delegate iterator is finished, so forget it and continue with\n    // the outer generator.\n    context.delegate = null;\n    return ContinueSentinel;\n  }\n\n  // Define Generator.prototype.{next,throw,return} in terms of the\n  // unified ._invoke helper method.\n  defineIteratorMethods(Gp);\n\n  define(Gp, toStringTagSymbol, \"Generator\");\n\n  // A Generator should always return itself as the iterator object when the\n  // @@iterator function is called on it. Some browsers' implementations of the\n  // iterator prototype chain incorrectly implement this, causing the Generator\n  // object to not be returned from this call. This ensures that doesn't happen.\n  // See https://github.com/facebook/regenerator/issues/274 for more details.\n  Gp[iteratorSymbol] = function() {\n    return this;\n  };\n\n  Gp.toString = function() {\n    return \"[object Generator]\";\n  };\n\n  function pushTryEntry(locs) {\n    var entry = { tryLoc: locs[0] };\n\n    if (1 in locs) {\n      entry.catchLoc = locs[1];\n    }\n\n    if (2 in locs) {\n      entry.finallyLoc = locs[2];\n      entry.afterLoc = locs[3];\n    }\n\n    this.tryEntries.push(entry);\n  }\n\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\";\n    delete record.arg;\n    entry.completion = record;\n  }\n\n  function Context(tryLocsList) {\n    // The root entry object (effectively a try statement without a catch\n    // or a finally block) gives us a place to store values thrown from\n    // locations where there is no enclosing try statement.\n    this.tryEntries = [{ tryLoc: \"root\" }];\n    tryLocsList.forEach(pushTryEntry, this);\n    this.reset(true);\n  }\n\n  exports.keys = function(object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    keys.reverse();\n\n    // Rather than returning an object with a next method, we keep\n    // things simple and return the next function itself.\n    return function next() {\n      while (keys.length) {\n        var key = keys.pop();\n        if (key in object) {\n          next.value = key;\n          next.done = false;\n          return next;\n        }\n      }\n\n      // To avoid creating an additional object, we just hang the .value\n      // and .done properties off the next function object itself. This\n      // also ensures that the minifier will not anonymize the function.\n      next.done = true;\n      return next;\n    };\n  };\n\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) {\n        return iteratorMethod.call(iterable);\n      }\n\n      if (typeof iterable.next === \"function\") {\n        return iterable;\n      }\n\n      if (!isNaN(iterable.length)) {\n        var i = -1, next = function next() {\n          while (++i < iterable.length) {\n            if (hasOwn.call(iterable, i)) {\n              next.value = iterable[i];\n              next.done = false;\n              return next;\n            }\n          }\n\n          next.value = undefined;\n          next.done = true;\n\n          return next;\n        };\n\n        return next.next = next;\n      }\n    }\n\n    // Return an iterator with no values.\n    return { next: doneResult };\n  }\n  exports.values = values;\n\n  function doneResult() {\n    return { value: undefined, done: true };\n  }\n\n  Context.prototype = {\n    constructor: Context,\n\n    reset: function(skipTempReset) {\n      this.prev = 0;\n      this.next = 0;\n      // Resetting context._sent for legacy support of Babel's\n      // function.sent implementation.\n      this.sent = this._sent = undefined;\n      this.done = false;\n      this.delegate = null;\n\n      this.method = \"next\";\n      this.arg = undefined;\n\n      this.tryEntries.forEach(resetTryEntry);\n\n      if (!skipTempReset) {\n        for (var name in this) {\n          // Not sure about the optimal order of these conditions:\n          if (name.charAt(0) === \"t\" &&\n              hasOwn.call(this, name) &&\n              !isNaN(+name.slice(1))) {\n            this[name] = undefined;\n          }\n        }\n      }\n    },\n\n    stop: function() {\n      this.done = true;\n\n      var rootEntry = this.tryEntries[0];\n      var rootRecord = rootEntry.completion;\n      if (rootRecord.type === \"throw\") {\n        throw rootRecord.arg;\n      }\n\n      return this.rval;\n    },\n\n    dispatchException: function(exception) {\n      if (this.done) {\n        throw exception;\n      }\n\n      var context = this;\n      function handle(loc, caught) {\n        record.type = \"throw\";\n        record.arg = exception;\n        context.next = loc;\n\n        if (caught) {\n          // If the dispatched exception was caught by a catch block,\n          // then let that catch block handle the exception normally.\n          context.method = \"next\";\n          context.arg = undefined;\n        }\n\n        return !! caught;\n      }\n\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        var record = entry.completion;\n\n        if (entry.tryLoc === \"root\") {\n          // Exception thrown outside of any try block that could handle\n          // it, so set the completion value of the entire function to\n          // throw the exception.\n          return handle(\"end\");\n        }\n\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\");\n          var hasFinally = hasOwn.call(entry, \"finallyLoc\");\n\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            } else if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) {\n              return handle(entry.catchLoc, true);\n            }\n\n          } else if (hasFinally) {\n            if (this.prev < entry.finallyLoc) {\n              return handle(entry.finallyLoc);\n            }\n\n          } else {\n            throw new Error(\"try statement without catch or finally\");\n          }\n        }\n      }\n    },\n\n    abrupt: function(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev &&\n            hasOwn.call(entry, \"finallyLoc\") &&\n            this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n\n      if (finallyEntry &&\n          (type === \"break\" ||\n           type === \"continue\") &&\n          finallyEntry.tryLoc <= arg &&\n          arg <= finallyEntry.finallyLoc) {\n        // Ignore the finally entry if control is not jumping to a\n        // location outside the try/catch block.\n        finallyEntry = null;\n      }\n\n      var record = finallyEntry ? finallyEntry.completion : {};\n      record.type = type;\n      record.arg = arg;\n\n      if (finallyEntry) {\n        this.method = \"next\";\n        this.next = finallyEntry.finallyLoc;\n        return ContinueSentinel;\n      }\n\n      return this.complete(record);\n    },\n\n    complete: function(record, afterLoc) {\n      if (record.type === \"throw\") {\n        throw record.arg;\n      }\n\n      if (record.type === \"break\" ||\n          record.type === \"continue\") {\n        this.next = record.arg;\n      } else if (record.type === \"return\") {\n        this.rval = this.arg = record.arg;\n        this.method = \"return\";\n        this.next = \"end\";\n      } else if (record.type === \"normal\" && afterLoc) {\n        this.next = afterLoc;\n      }\n\n      return ContinueSentinel;\n    },\n\n    finish: function(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) {\n          this.complete(entry.completion, entry.afterLoc);\n          resetTryEntry(entry);\n          return ContinueSentinel;\n        }\n      }\n    },\n\n    \"catch\": function(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (record.type === \"throw\") {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n\n      // The context.catch method must only be called with a location\n      // argument that corresponds to a known catch block.\n      throw new Error(\"illegal catch attempt\");\n    },\n\n    delegateYield: function(iterable, resultName, nextLoc) {\n      this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      };\n\n      if (this.method === \"next\") {\n        // Deliberately forget the last sent value so that we don't\n        // accidentally pass it on to the delegate.\n        this.arg = undefined;\n      }\n\n      return ContinueSentinel;\n    }\n  };\n\n  // Regardless of whether this script is executing as a CommonJS module\n  // or not, return the runtime object so that we can declare the variable\n  // regeneratorRuntime in the outer scope, which allows this module to be\n  // injected easily by `bin/regenerator --include-runtime script.js`.\n  return exports;\n\n}(\n  // If this script is executing as a CommonJS module, use module.exports\n  // as the regeneratorRuntime namespace. Otherwise create a new empty\n  // object. Either way, the resulting object will be used to initialize\n  // the regeneratorRuntime variable at the top of this file.\n  typeof module === \"object\" ? module.exports : {}\n));\n\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  // This module should not be running in strict mode, so the above\n  // assignment should always work unless something is misconfigured. Just\n  // in case runtime.js accidentally runs in strict mode, we can escape\n  // strict mode using a global Function call. This could conceivably fail\n  // if a Content Security Policy forbids using Function, but in that case\n  // the proper solution is to fix the accidental strict mode problem. If\n  // you've misconfigured your bundler to force strict mode and applied a\n  // CSP to forbid Function, and you're not willing to fix either of those\n  // problems, please detail your unique predicament in a GitHub issue.\n  Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n}\n","module.exports = function(module) {\n\tif (!module.webpackPolyfill) {\n\t\tmodule.deprecate = function() {};\n\t\tmodule.paths = [];\n\t\t// module.parent = undefined by default\n\t\tif (!module.children) module.children = [];\n\t\tObject.defineProperty(module, \"loaded\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.l;\n\t\t\t}\n\t\t});\n\t\tObject.defineProperty(module, \"id\", {\n\t\t\tenumerable: true,\n\t\t\tget: function() {\n\t\t\t\treturn module.i;\n\t\t\t}\n\t\t});\n\t\tmodule.webpackPolyfill = 1;\n\t}\n\treturn module;\n};\n","/* Copyright 2015 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { parseQueryString } from \"./ui_utils.js\";\n\n/**\n * @typedef {Object} PDFLinkServiceOptions\n * @property {EventBus} eventBus - The application event bus.\n * @property {number} [externalLinkTarget] - Specifies the `target` attribute\n *   for external links. Must use one of the values from {LinkTarget}.\n *   Defaults to using no target.\n * @property {string} [externalLinkRel] - Specifies the `rel` attribute for\n *   external links. Defaults to stripping the referrer.\n * @property {boolean} [ignoreDestinationZoom] - Ignores the zoom argument,\n *   thus preserving the current zoom level in the viewer, when navigating\n *   to internal destinations. The default value is `false`.\n */\n\n/**\n * Performs navigation functions inside PDF, such as opening specified page,\n * or destination.\n * @implements {IPDFLinkService}\n */\nclass PDFLinkService {\n  /**\n   * @param {PDFLinkServiceOptions} options\n   */\n  constructor({\n    eventBus,\n    externalLinkTarget = null,\n    externalLinkRel = null,\n    externalLinkEnabled = true,\n    ignoreDestinationZoom = false,\n  } = {}) {\n    this.eventBus = eventBus;\n    this.externalLinkTarget = externalLinkTarget;\n    this.externalLinkRel = externalLinkRel;\n    this.externalLinkEnabled = externalLinkEnabled;\n    this._ignoreDestinationZoom = ignoreDestinationZoom;\n\n    this.baseUrl = null;\n    this.pdfDocument = null;\n    this.pdfViewer = null;\n    this.pdfHistory = null;\n\n    this._pagesRefCache = null;\n  }\n\n  setDocument(pdfDocument, baseUrl = null) {\n    this.baseUrl = baseUrl;\n    this.pdfDocument = pdfDocument;\n    this._pagesRefCache = Object.create(null);\n  }\n\n  setViewer(pdfViewer) {\n    this.pdfViewer = pdfViewer;\n  }\n\n  setHistory(pdfHistory) {\n    this.pdfHistory = pdfHistory;\n  }\n\n  /**\n   * @type {number}\n   */\n  get pagesCount() {\n    return this.pdfDocument ? this.pdfDocument.numPages : 0;\n  }\n\n  /**\n   * @type {number}\n   */\n  get page() {\n    return this.pdfViewer.currentPageNumber;\n  }\n\n  /**\n   * @param {number} value\n   */\n  set page(value) {\n    this.pdfViewer.currentPageNumber = value;\n  }\n\n  /**\n   * @type {number}\n   */\n  get rotation() {\n    return this.pdfViewer.pagesRotation;\n  }\n\n  /**\n   * @param {number} value\n   */\n  set rotation(value) {\n    this.pdfViewer.pagesRotation = value;\n  }\n\n  /**\n   * @param {string|Array} dest - The named, or explicit, PDF destination.\n   */\n  navigateTo(dest) {\n    const goToDestination = ({ namedDest, explicitDest }) => {\n      // Dest array looks like that: <page-ref> </XYZ|/FitXXX> <args..>\n      const destRef = explicitDest[0];\n      let pageNumber;\n\n      if (destRef instanceof Object) {\n        pageNumber = this._cachedPageNumber(destRef);\n\n        if (pageNumber === null) {\n          // Fetch the page reference if it's not yet available. This could\n          // only occur during loading, before all pages have been resolved.\n          this.pdfDocument\n            .getPageIndex(destRef)\n            .then(pageIndex => {\n              this.cachePageRef(pageIndex + 1, destRef);\n              goToDestination({ namedDest, explicitDest });\n            })\n            .catch(() => {\n              console.error(\n                `PDFLinkService.navigateTo: \"${destRef}\" is not ` +\n                  `a valid page reference, for dest=\"${dest}\".`\n              );\n            });\n          return;\n        }\n      } else if (Number.isInteger(destRef)) {\n        pageNumber = destRef + 1;\n      } else {\n        console.error(\n          `PDFLinkService.navigateTo: \"${destRef}\" is not ` +\n            `a valid destination reference, for dest=\"${dest}\".`\n        );\n        return;\n      }\n      if (!pageNumber || pageNumber < 1 || pageNumber > this.pagesCount) {\n        console.error(\n          `PDFLinkService.navigateTo: \"${pageNumber}\" is not ` +\n            `a valid page number, for dest=\"${dest}\".`\n        );\n        return;\n      }\n\n      if (this.pdfHistory) {\n        // Update the browser history before scrolling the new destination into\n        // view, to be able to accurately capture the current document position.\n        this.pdfHistory.pushCurrentPosition();\n        this.pdfHistory.push({ namedDest, explicitDest, pageNumber });\n      }\n\n      this.pdfViewer.scrollPageIntoView({\n        pageNumber,\n        destArray: explicitDest,\n        ignoreDestinationZoom: this._ignoreDestinationZoom,\n      });\n    };\n\n    new Promise((resolve, reject) => {\n      if (typeof dest === \"string\") {\n        this.pdfDocument.getDestination(dest).then(destArray => {\n          resolve({\n            namedDest: dest,\n            explicitDest: destArray,\n          });\n        });\n        return;\n      }\n      resolve({\n        namedDest: \"\",\n        explicitDest: dest,\n      });\n    }).then(data => {\n      if (!Array.isArray(data.explicitDest)) {\n        console.error(\n          `PDFLinkService.navigateTo: \"${data.explicitDest}\" is` +\n            ` not a valid destination array, for dest=\"${dest}\".`\n        );\n        return;\n      }\n      goToDestination(data);\n    });\n  }\n\n  /**\n   * @param {string|Array} dest - The PDF destination object.\n   * @returns {string} The hyperlink to the PDF object.\n   */\n  getDestinationHash(dest) {\n    if (typeof dest === \"string\") {\n      return this.getAnchorUrl(\"#\" + escape(dest));\n    }\n    if (Array.isArray(dest)) {\n      const str = JSON.stringify(dest);\n      return this.getAnchorUrl(\"#\" + escape(str));\n    }\n    return this.getAnchorUrl(\"\");\n  }\n\n  /**\n   * Prefix the full url on anchor links to make sure that links are resolved\n   * relative to the current URL instead of the one defined in <base href>.\n   * @param {string} anchor The anchor hash, including the #.\n   * @returns {string} The hyperlink to the PDF object.\n   */\n  getAnchorUrl(anchor) {\n    return (this.baseUrl || \"\") + anchor;\n  }\n\n  /**\n   * @param {string} hash\n   */\n  setHash(hash) {\n    let pageNumber, dest;\n    if (hash.includes(\"=\")) {\n      const params = parseQueryString(hash);\n      if (\"search\" in params) {\n        this.eventBus.dispatch(\"findfromurlhash\", {\n          source: this,\n          query: params.search.replace(/\"/g, \"\"),\n          phraseSearch: params.phrase === \"true\",\n        });\n      }\n      // borrowing syntax from \"Parameters for Opening PDF Files\"\n      if (\"page\" in params) {\n        pageNumber = params.page | 0 || 1;\n      }\n      if (\"zoom\" in params) {\n        // Build the destination array.\n        const zoomArgs = params.zoom.split(\",\"); // scale,left,top\n        const zoomArg = zoomArgs[0];\n        const zoomArgNumber = parseFloat(zoomArg);\n\n        if (!zoomArg.includes(\"Fit\")) {\n          // If the zoomArg is a number, it has to get divided by 100. If it's\n          // a string, it should stay as it is.\n          dest = [\n            null,\n            { name: \"XYZ\" },\n            zoomArgs.length > 1 ? zoomArgs[1] | 0 : null,\n            zoomArgs.length > 2 ? zoomArgs[2] | 0 : null,\n            zoomArgNumber ? zoomArgNumber / 100 : zoomArg,\n          ];\n        } else {\n          if (zoomArg === \"Fit\" || zoomArg === \"FitB\") {\n            dest = [null, { name: zoomArg }];\n          } else if (\n            zoomArg === \"FitH\" ||\n            zoomArg === \"FitBH\" ||\n            zoomArg === \"FitV\" ||\n            zoomArg === \"FitBV\"\n          ) {\n            dest = [\n              null,\n              { name: zoomArg },\n              zoomArgs.length > 1 ? zoomArgs[1] | 0 : null,\n            ];\n          } else if (zoomArg === \"FitR\") {\n            if (zoomArgs.length !== 5) {\n              console.error(\n                'PDFLinkService.setHash: Not enough parameters for \"FitR\".'\n              );\n            } else {\n              dest = [\n                null,\n                { name: zoomArg },\n                zoomArgs[1] | 0,\n                zoomArgs[2] | 0,\n                zoomArgs[3] | 0,\n                zoomArgs[4] | 0,\n              ];\n            }\n          } else {\n            console.error(\n              `PDFLinkService.setHash: \"${zoomArg}\" is not ` +\n                \"a valid zoom value.\"\n            );\n          }\n        }\n      }\n      if (dest) {\n        this.pdfViewer.scrollPageIntoView({\n          pageNumber: pageNumber || this.page,\n          destArray: dest,\n          allowNegativeOffset: true,\n        });\n      } else if (pageNumber) {\n        this.page = pageNumber; // simple page\n      }\n      if (\"pagemode\" in params) {\n        this.eventBus.dispatch(\"pagemode\", {\n          source: this,\n          mode: params.pagemode,\n        });\n      }\n      // Ensure that this parameter is *always* handled last, in order to\n      // guarantee that it won't be overridden (e.g. by the \"page\" parameter).\n      if (\"nameddest\" in params) {\n        this.navigateTo(params.nameddest);\n      }\n    } else {\n      // Named (or explicit) destination.\n      dest = unescape(hash);\n      try {\n        dest = JSON.parse(dest);\n\n        if (!Array.isArray(dest)) {\n          // Avoid incorrectly rejecting a valid named destination, such as\n          // e.g. \"4.3\" or \"true\", because `JSON.parse` converted its type.\n          dest = dest.toString();\n        }\n      } catch (ex) {}\n\n      if (typeof dest === \"string\" || isValidExplicitDestination(dest)) {\n        this.navigateTo(dest);\n        return;\n      }\n      console.error(\n        `PDFLinkService.setHash: \"${unescape(hash)}\" is not ` +\n          \"a valid destination.\"\n      );\n    }\n  }\n\n  /**\n   * @param {string} action\n   */\n  executeNamedAction(action) {\n    // See PDF reference, table 8.45 - Named action\n    switch (action) {\n      case \"GoBack\":\n        if (this.pdfHistory) {\n          this.pdfHistory.back();\n        }\n        break;\n\n      case \"GoForward\":\n        if (this.pdfHistory) {\n          this.pdfHistory.forward();\n        }\n        break;\n\n      case \"NextPage\":\n        if (this.page < this.pagesCount) {\n          this.page++;\n        }\n        break;\n\n      case \"PrevPage\":\n        if (this.page > 1) {\n          this.page--;\n        }\n        break;\n\n      case \"LastPage\":\n        this.page = this.pagesCount;\n        break;\n\n      case \"FirstPage\":\n        this.page = 1;\n        break;\n\n      default:\n        break; // No action according to spec\n    }\n\n    this.eventBus.dispatch(\"namedaction\", {\n      source: this,\n      action,\n    });\n  }\n\n  /**\n   * @param {number} pageNum - page number.\n   * @param {Object} pageRef - reference to the page.\n   */\n  cachePageRef(pageNum, pageRef) {\n    if (!pageRef) {\n      return;\n    }\n    const refStr =\n      pageRef.gen === 0 ? `${pageRef.num}R` : `${pageRef.num}R${pageRef.gen}`;\n    this._pagesRefCache[refStr] = pageNum;\n  }\n\n  _cachedPageNumber(pageRef) {\n    const refStr =\n      pageRef.gen === 0 ? `${pageRef.num}R` : `${pageRef.num}R${pageRef.gen}`;\n    return (this._pagesRefCache && this._pagesRefCache[refStr]) || null;\n  }\n\n  /**\n   * @param {number} pageNumber\n   */\n  isPageVisible(pageNumber) {\n    return this.pdfViewer.isPageVisible(pageNumber);\n  }\n}\n\nfunction isValidExplicitDestination(dest) {\n  if (!Array.isArray(dest)) {\n    return false;\n  }\n  const destLength = dest.length;\n  if (destLength < 2) {\n    return false;\n  }\n  const page = dest[0];\n  if (\n    !(\n      typeof page === \"object\" &&\n      Number.isInteger(page.num) &&\n      Number.isInteger(page.gen)\n    ) &&\n    !(Number.isInteger(page) && page >= 0)\n  ) {\n    return false;\n  }\n  const zoom = dest[1];\n  if (!(typeof zoom === \"object\" && typeof zoom.name === \"string\")) {\n    return false;\n  }\n  let allowNull = true;\n  switch (zoom.name) {\n    case \"XYZ\":\n      if (destLength !== 5) {\n        return false;\n      }\n      break;\n    case \"Fit\":\n    case \"FitB\":\n      return destLength === 2;\n    case \"FitH\":\n    case \"FitBH\":\n    case \"FitV\":\n    case \"FitBV\":\n      if (destLength !== 3) {\n        return false;\n      }\n      break;\n    case \"FitR\":\n      if (destLength !== 6) {\n        return false;\n      }\n      allowNull = false;\n      break;\n    default:\n      return false;\n  }\n  for (let i = 2; i < destLength; i++) {\n    const param = dest[i];\n    if (!(typeof param === \"number\" || (allowNull && param === null))) {\n      return false;\n    }\n  }\n  return true;\n}\n\n/**\n * @implements {IPDFLinkService}\n */\nclass SimpleLinkService {\n  constructor() {\n    this.externalLinkTarget = null;\n    this.externalLinkRel = null;\n    this.externalLinkEnabled = true;\n    this._ignoreDestinationZoom = false;\n  }\n\n  /**\n   * @type {number}\n   */\n  get pagesCount() {\n    return 0;\n  }\n\n  /**\n   * @type {number}\n   */\n  get page() {\n    return 0;\n  }\n\n  /**\n   * @param {number} value\n   */\n  set page(value) {}\n\n  /**\n   * @type {number}\n   */\n  get rotation() {\n    return 0;\n  }\n\n  /**\n   * @param {number} value\n   */\n  set rotation(value) {}\n\n  /**\n   * @param dest - The PDF destination object.\n   */\n  navigateTo(dest) {}\n\n  /**\n   * @param dest - The PDF destination object.\n   * @returns {string} The hyperlink to the PDF object.\n   */\n  getDestinationHash(dest) {\n    return \"#\";\n  }\n\n  /**\n   * @param hash - The PDF parameters/hash.\n   * @returns {string} The hyperlink to the PDF object.\n   */\n  getAnchorUrl(hash) {\n    return \"#\";\n  }\n\n  /**\n   * @param {string} hash\n   */\n  setHash(hash) {}\n\n  /**\n   * @param {string} action\n   */\n  executeNamedAction(action) {}\n\n  /**\n   * @param {number} pageNum - page number.\n   * @param {Object} pageRef - reference to the page.\n   */\n  cachePageRef(pageNum, pageRef) {}\n\n  /**\n   * @param {number} pageNumber\n   */\n  isPageVisible(pageNumber) {\n    return true;\n  }\n}\n\nexport { PDFLinkService, SimpleLinkService };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { renderTextLayer } from \"pdfjs-lib\";\n\nconst EXPAND_DIVS_TIMEOUT = 300; // ms\n\n/**\n * @typedef {Object} TextLayerBuilderOptions\n * @property {HTMLDivElement} textLayerDiv - The text layer container.\n * @property {EventBus} eventBus - The application event bus.\n * @property {number} pageIndex - The page index.\n * @property {PageViewport} viewport - The viewport of the text layer.\n * @property {PDFFindController} findController\n * @property {boolean} enhanceTextSelection - Option to turn on improved\n *   text selection.\n */\n\n/**\n * The text layer builder provides text selection functionality for the PDF.\n * It does this by creating overlay divs over the PDF's text. These divs\n * contain text that matches the PDF text they are overlaying. This object\n * also provides a way to highlight text that is being searched for.\n */\nclass TextLayerBuilder {\n  constructor({\n    textLayerDiv,\n    eventBus,\n    pageIndex,\n    viewport,\n    findController = null,\n    enhanceTextSelection = false,\n  }) {\n    this.textLayerDiv = textLayerDiv;\n    this.eventBus = eventBus;\n    this.textContent = null;\n    this.textContentItemsStr = [];\n    this.textContentStream = null;\n    this.renderingDone = false;\n    this.pageIdx = pageIndex;\n    this.pageNumber = this.pageIdx + 1;\n    this.matches = [];\n    this.viewport = viewport;\n    this.textDivs = [];\n    this.findController = findController;\n    this.textLayerRenderTask = null;\n    this.enhanceTextSelection = enhanceTextSelection;\n\n    this._onUpdateTextLayerMatches = null;\n    this._bindMouse();\n  }\n\n  /**\n   * @private\n   */\n  _finishRendering() {\n    this.renderingDone = true;\n\n    if (!this.enhanceTextSelection) {\n      const endOfContent = document.createElement(\"div\");\n      endOfContent.className = \"endOfContent\";\n      this.textLayerDiv.appendChild(endOfContent);\n    }\n\n    this.eventBus.dispatch(\"textlayerrendered\", {\n      source: this,\n      pageNumber: this.pageNumber,\n      numTextDivs: this.textDivs.length,\n    });\n  }\n\n  /**\n   * Renders the text layer.\n   *\n   * @param {number} [timeout] - Wait for a specified amount of milliseconds\n   *                             before rendering.\n   */\n  render(timeout = 0) {\n    if (!(this.textContent || this.textContentStream) || this.renderingDone) {\n      return;\n    }\n    this.cancel();\n\n    this.textDivs = [];\n    const textLayerFrag = document.createDocumentFragment();\n    this.textLayerRenderTask = renderTextLayer({\n      textContent: this.textContent,\n      textContentStream: this.textContentStream,\n      container: textLayerFrag,\n      viewport: this.viewport,\n      textDivs: this.textDivs,\n      textContentItemsStr: this.textContentItemsStr,\n      timeout,\n      enhanceTextSelection: this.enhanceTextSelection,\n    });\n    this.textLayerRenderTask.promise.then(\n      () => {\n        this.textLayerDiv.appendChild(textLayerFrag);\n        this._finishRendering();\n        this._updateMatches();\n      },\n      function (reason) {\n        // Cancelled or failed to render text layer; skipping errors.\n      }\n    );\n\n    if (!this._onUpdateTextLayerMatches) {\n      this._onUpdateTextLayerMatches = evt => {\n        if (evt.pageIndex === this.pageIdx || evt.pageIndex === -1) {\n          this._updateMatches();\n        }\n      };\n      this.eventBus._on(\n        \"updatetextlayermatches\",\n        this._onUpdateTextLayerMatches\n      );\n    }\n  }\n\n  /**\n   * Cancel rendering of the text layer.\n   */\n  cancel() {\n    if (this.textLayerRenderTask) {\n      this.textLayerRenderTask.cancel();\n      this.textLayerRenderTask = null;\n    }\n    if (this._onUpdateTextLayerMatches) {\n      this.eventBus._off(\n        \"updatetextlayermatches\",\n        this._onUpdateTextLayerMatches\n      );\n      this._onUpdateTextLayerMatches = null;\n    }\n  }\n\n  setTextContentStream(readableStream) {\n    this.cancel();\n    this.textContentStream = readableStream;\n  }\n\n  setTextContent(textContent) {\n    this.cancel();\n    this.textContent = textContent;\n  }\n\n  _convertMatches(matches, matchesLength) {\n    // Early exit if there is nothing to convert.\n    if (!matches) {\n      return [];\n    }\n    const { findController, textContentItemsStr } = this;\n\n    let i = 0,\n      iIndex = 0;\n    const end = textContentItemsStr.length - 1;\n    const queryLen = findController.state.query.length;\n    const result = [];\n\n    for (let m = 0, mm = matches.length; m < mm; m++) {\n      // Calculate the start position.\n      let matchIdx = matches[m];\n\n      // Loop over the divIdxs.\n      while (i !== end && matchIdx >= iIndex + textContentItemsStr[i].length) {\n        iIndex += textContentItemsStr[i].length;\n        i++;\n      }\n\n      if (i === textContentItemsStr.length) {\n        console.error(\"Could not find a matching mapping\");\n      }\n\n      const match = {\n        begin: {\n          divIdx: i,\n          offset: matchIdx - iIndex,\n        },\n      };\n\n      // Calculate the end position.\n      if (matchesLength) {\n        // Multiterm search.\n        matchIdx += matchesLength[m];\n      } else {\n        // Phrase search.\n        matchIdx += queryLen;\n      }\n\n      // Somewhat the same array as above, but use > instead of >= to get\n      // the end position right.\n      while (i !== end && matchIdx > iIndex + textContentItemsStr[i].length) {\n        iIndex += textContentItemsStr[i].length;\n        i++;\n      }\n\n      match.end = {\n        divIdx: i,\n        offset: matchIdx - iIndex,\n      };\n      result.push(match);\n    }\n    return result;\n  }\n\n  _renderMatches(matches) {\n    // Early exit if there is nothing to render.\n    if (matches.length === 0) {\n      return;\n    }\n    const { findController, pageIdx, textContentItemsStr, textDivs } = this;\n\n    const isSelectedPage = pageIdx === findController.selected.pageIdx;\n    const selectedMatchIdx = findController.selected.matchIdx;\n    const highlightAll = findController.state.highlightAll;\n    let prevEnd = null;\n    const infinity = {\n      divIdx: -1,\n      offset: undefined,\n    };\n\n    function beginText(begin, className) {\n      const divIdx = begin.divIdx;\n      textDivs[divIdx].textContent = \"\";\n      appendTextToDiv(divIdx, 0, begin.offset, className);\n    }\n\n    function appendTextToDiv(divIdx, fromOffset, toOffset, className) {\n      const div = textDivs[divIdx];\n      const content = textContentItemsStr[divIdx].substring(\n        fromOffset,\n        toOffset\n      );\n      const node = document.createTextNode(content);\n      if (className) {\n        const span = document.createElement(\"span\");\n        span.className = className;\n        span.appendChild(node);\n        div.appendChild(span);\n        return;\n      }\n      div.appendChild(node);\n    }\n\n    let i0 = selectedMatchIdx,\n      i1 = i0 + 1;\n    if (highlightAll) {\n      i0 = 0;\n      i1 = matches.length;\n    } else if (!isSelectedPage) {\n      // Not highlighting all and this isn't the selected page, so do nothing.\n      return;\n    }\n\n    for (let i = i0; i < i1; i++) {\n      const match = matches[i];\n      const begin = match.begin;\n      const end = match.end;\n      const isSelected = isSelectedPage && i === selectedMatchIdx;\n      const highlightSuffix = isSelected ? \" selected\" : \"\";\n\n      if (isSelected) {\n        // Attempt to scroll the selected match into view.\n        findController.scrollMatchIntoView({\n          element: textDivs[begin.divIdx],\n          pageIndex: pageIdx,\n          matchIndex: selectedMatchIdx,\n        });\n      }\n\n      // Match inside new div.\n      if (!prevEnd || begin.divIdx !== prevEnd.divIdx) {\n        // If there was a previous div, then add the text at the end.\n        if (prevEnd !== null) {\n          appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);\n        }\n        // Clear the divs and set the content until the starting point.\n        beginText(begin);\n      } else {\n        appendTextToDiv(prevEnd.divIdx, prevEnd.offset, begin.offset);\n      }\n\n      if (begin.divIdx === end.divIdx) {\n        appendTextToDiv(\n          begin.divIdx,\n          begin.offset,\n          end.offset,\n          \"highlight\" + highlightSuffix\n        );\n      } else {\n        appendTextToDiv(\n          begin.divIdx,\n          begin.offset,\n          infinity.offset,\n          \"highlight begin\" + highlightSuffix\n        );\n        for (let n0 = begin.divIdx + 1, n1 = end.divIdx; n0 < n1; n0++) {\n          textDivs[n0].className = \"highlight middle\" + highlightSuffix;\n        }\n        beginText(end, \"highlight end\" + highlightSuffix);\n      }\n      prevEnd = end;\n    }\n\n    if (prevEnd) {\n      appendTextToDiv(prevEnd.divIdx, prevEnd.offset, infinity.offset);\n    }\n  }\n\n  _updateMatches() {\n    // Only show matches when all rendering is done.\n    if (!this.renderingDone) {\n      return;\n    }\n    const {\n      findController,\n      matches,\n      pageIdx,\n      textContentItemsStr,\n      textDivs,\n    } = this;\n    let clearedUntilDivIdx = -1;\n\n    // Clear all current matches.\n    for (let i = 0, ii = matches.length; i < ii; i++) {\n      const match = matches[i];\n      const begin = Math.max(clearedUntilDivIdx, match.begin.divIdx);\n      for (let n = begin, end = match.end.divIdx; n <= end; n++) {\n        const div = textDivs[n];\n        div.textContent = textContentItemsStr[n];\n        div.className = \"\";\n      }\n      clearedUntilDivIdx = match.end.divIdx + 1;\n    }\n\n    if (!findController || !findController.highlightMatches) {\n      return;\n    }\n    // Convert the matches on the `findController` into the match format\n    // used for the textLayer.\n    const pageMatches = findController.pageMatches[pageIdx] || null;\n    const pageMatchesLength = findController.pageMatchesLength[pageIdx] || null;\n\n    this.matches = this._convertMatches(pageMatches, pageMatchesLength);\n    this._renderMatches(this.matches);\n  }\n\n  /**\n   * Improves text selection by adding an additional div where the mouse was\n   * clicked. This reduces flickering of the content if the mouse is slowly\n   * dragged up or down.\n   *\n   * @private\n   */\n  _bindMouse() {\n    const div = this.textLayerDiv;\n    let expandDivsTimer = null;\n\n    div.addEventListener(\"mousedown\", evt => {\n      if (this.enhanceTextSelection && this.textLayerRenderTask) {\n        this.textLayerRenderTask.expandTextDivs(true);\n        if (\n          (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"MOZCENTRAL\")) &&\n          expandDivsTimer\n        ) {\n          clearTimeout(expandDivsTimer);\n          expandDivsTimer = null;\n        }\n        return;\n      }\n\n      const end = div.querySelector(\".endOfContent\");\n      if (!end) {\n        return;\n      }\n      if (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"MOZCENTRAL\")) {\n        // On non-Firefox browsers, the selection will feel better if the height\n        // of the `endOfContent` div is adjusted to start at mouse click\n        // location. This avoids flickering when the selection moves up.\n        // However it does not work when selection is started on empty space.\n        let adjustTop = evt.target !== div;\n        if (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) {\n          adjustTop =\n            adjustTop &&\n            window\n              .getComputedStyle(end)\n              .getPropertyValue(\"-moz-user-select\") !== \"none\";\n        }\n        if (adjustTop) {\n          const divBounds = div.getBoundingClientRect();\n          const r = Math.max(0, (evt.pageY - divBounds.top) / divBounds.height);\n          end.style.top = (r * 100).toFixed(2) + \"%\";\n        }\n      }\n      end.classList.add(\"active\");\n    });\n\n    div.addEventListener(\"mouseup\", () => {\n      if (this.enhanceTextSelection && this.textLayerRenderTask) {\n        if (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"MOZCENTRAL\")) {\n          expandDivsTimer = setTimeout(() => {\n            if (this.textLayerRenderTask) {\n              this.textLayerRenderTask.expandTextDivs(false);\n            }\n            expandDivsTimer = null;\n          }, EXPAND_DIVS_TIMEOUT);\n        } else {\n          this.textLayerRenderTask.expandTextDivs(false);\n        }\n        return;\n      }\n\n      const end = div.querySelector(\".endOfContent\");\n      if (!end) {\n        return;\n      }\n      if (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"MOZCENTRAL\")) {\n        end.style.top = \"\";\n      }\n      end.classList.remove(\"active\");\n    });\n  }\n}\n\n/**\n * @implements IPDFTextLayerFactory\n */\nclass DefaultTextLayerFactory {\n  /**\n   * @param {HTMLDivElement} textLayerDiv\n   * @param {number} pageIndex\n   * @param {PageViewport} viewport\n   * @param {boolean} enhanceTextSelection\n   * @param {EventBus} eventBus\n   * @returns {TextLayerBuilder}\n   */\n  createTextLayerBuilder(\n    textLayerDiv,\n    pageIndex,\n    viewport,\n    enhanceTextSelection = false,\n    eventBus\n  ) {\n    return new TextLayerBuilder({\n      textLayerDiv,\n      pageIndex,\n      viewport,\n      enhanceTextSelection,\n      eventBus,\n    });\n  }\n}\n\nexport { TextLayerBuilder, DefaultTextLayerFactory };\n","/* Copyright 2013 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { createObjectURL, createValidAbsoluteUrl } from \"pdfjs-lib\";\nimport { viewerCompatibilityParams } from \"./viewer_compatibility.js\";\n\nif (typeof PDFJSDev !== \"undefined\" && !PDFJSDev.test(\"CHROME || GENERIC\")) {\n  throw new Error(\n    'Module \"pdfjs-web/download_manager\" shall not be used ' +\n      \"outside CHROME and GENERIC builds.\"\n  );\n}\n\nfunction download(blobUrl, filename) {\n  const a = document.createElement(\"a\");\n  if (!a.click) {\n    throw new Error('DownloadManager: \"a.click()\" is not supported.');\n  }\n  a.href = blobUrl;\n  a.target = \"_parent\";\n  // Use a.download if available. This increases the likelihood that\n  // the file is downloaded instead of opened by another PDF plugin.\n  if (\"download\" in a) {\n    a.download = filename;\n  }\n  // <a> must be in the document for IE and recent Firefox versions,\n  // otherwise .click() is ignored.\n  (document.body || document.documentElement).appendChild(a);\n  a.click();\n  a.remove();\n}\n\nclass DownloadManager {\n  downloadUrl(url, filename) {\n    if (!createValidAbsoluteUrl(url, \"http://example.com\")) {\n      return; // restricted/invalid URL\n    }\n    download(url + \"#pdfjs.action=download\", filename);\n  }\n\n  downloadData(data, filename, contentType) {\n    if (navigator.msSaveBlob) {\n      // IE10 and above\n      navigator.msSaveBlob(new Blob([data], { type: contentType }), filename);\n      return;\n    }\n    const blobUrl = createObjectURL(\n      data,\n      contentType,\n      viewerCompatibilityParams.disableCreateObjectURL\n    );\n    download(blobUrl, filename);\n  }\n\n  /**\n   * @param sourceEventType {string} Used to signal what triggered the download.\n   *   The version of PDF.js integrated with Firefox uses this to to determine\n   *   which dialog to show. \"save\" triggers \"save as\" and \"download\" triggers\n   *   the \"open with\" dialog.\n   */\n  download(blob, url, filename, sourceEventType = \"download\") {\n    if (navigator.msSaveBlob) {\n      // IE10 / IE11\n      if (!navigator.msSaveBlob(blob, filename)) {\n        this.downloadUrl(url, filename);\n      }\n      return;\n    }\n\n    if (viewerCompatibilityParams.disableCreateObjectURL) {\n      // URL.createObjectURL is not supported\n      this.downloadUrl(url, filename);\n      return;\n    }\n\n    const blobUrl = URL.createObjectURL(blob);\n    download(blobUrl, filename);\n  }\n}\n\nexport { DownloadManager };\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst compatibilityParams = Object.create(null);\nif (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) {\n  const userAgent =\n    (typeof navigator !== \"undefined\" && navigator.userAgent) || \"\";\n  const platform =\n    (typeof navigator !== \"undefined\" && navigator.platform) || \"\";\n  const maxTouchPoints =\n    (typeof navigator !== \"undefined\" && navigator.maxTouchPoints) || 1;\n\n  const isAndroid = /Android/.test(userAgent);\n  const isIE = /Trident/.test(userAgent);\n  const isIOS =\n    /\\b(iPad|iPhone|iPod)(?=;)/.test(userAgent) ||\n    (platform === \"MacIntel\" && maxTouchPoints > 1);\n  const isIOSChrome = /CriOS/.test(userAgent);\n\n  // Checks if possible to use URL.createObjectURL()\n  // Support: IE, Chrome on iOS\n  (function checkOnBlobSupport() {\n    // Sometimes IE and Chrome on iOS losing the data created with\n    // createObjectURL(), see issues #3977 and #8081.\n    if (isIE || isIOSChrome) {\n      compatibilityParams.disableCreateObjectURL = true;\n    }\n  })();\n\n  // Limit canvas size to 5 mega-pixels on mobile.\n  // Support: Android, iOS\n  (function checkCanvasSizeLimitation() {\n    if (isIOS || isAndroid) {\n      compatibilityParams.maxCanvasPixels = 5242880;\n    }\n  })();\n}\nconst viewerCompatibilityParams = Object.freeze(compatibilityParams);\n\nexport { viewerCompatibilityParams };\n","/* Copyright 2017 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport \"../external/webL10n/l10n.js\";\n\nconst webL10n = document.webL10n;\n\nclass GenericL10n {\n  constructor(lang) {\n    this._lang = lang;\n    this._ready = new Promise((resolve, reject) => {\n      webL10n.setLanguage(lang, () => {\n        resolve(webL10n);\n      });\n    });\n  }\n\n  async getLanguage() {\n    const l10n = await this._ready;\n    return l10n.getLanguage();\n  }\n\n  async getDirection() {\n    const l10n = await this._ready;\n    return l10n.getDirection();\n  }\n\n  async get(property, args, fallback) {\n    const l10n = await this._ready;\n    return l10n.get(property, args, fallback);\n  }\n\n  async translate(element) {\n    const l10n = await this._ready;\n    return l10n.translate(element);\n  }\n}\n\nexport { GenericL10n };\n","/**\n * Copyright (c) 2011-2013 Fabien Cazenave, Mozilla.\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of this software and associated documentation files (the \"Software\"), to\n * deal in the Software without restriction, including without limitation the\n * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or\n * sell copies of the Software, and to permit persons to whom the Software is\n * furnished to do so, subject to the following conditions:\n *\n * The above copyright notice and this permission notice shall be included in\n * all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING\n * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS\n * IN THE SOFTWARE.\n */\n/*\n  Additional modifications for PDF.js project:\n    - Disables language initialization on page loading.\n    - Disables document translation on page loading.\n    - Removes consoleWarn and consoleLog and use console.log/warn directly.\n    - Removes window._ assignment.\n    - Remove compatibility code for OldIE.\n    - Replaces `String.prototype.substr()` with `String.prototype.substring()`.\n    - Removes `fireL10nReadyEvent` since the \"localized\" event it dispatches\n      is unused and may clash with an identically named event in the viewer.\n*/\n\n/*jshint browser: true, devel: true, es5: true, globalstrict: true */\n'use strict';\n\ndocument.webL10n = (function(window, document, undefined) {\n  var gL10nData = {};\n  var gTextData = '';\n  var gTextProp = 'textContent';\n  var gLanguage = '';\n  var gMacros = {};\n  var gReadyState = 'loading';\n\n\n  /**\n   * Synchronously loading l10n resources significantly minimizes flickering\n   * from displaying the app with non-localized strings and then updating the\n   * strings. Although this will block all script execution on this page, we\n   * expect that the l10n resources are available locally on flash-storage.\n   *\n   * As synchronous XHR is generally considered as a bad idea, we're still\n   * loading l10n resources asynchronously -- but we keep this in a setting,\n   * just in case... and applications using this library should hide their\n   * content until the `localized' event happens.\n   */\n\n  var gAsyncResourceLoading = true; // read-only\n\n\n  /**\n   * DOM helpers for the so-called \"HTML API\".\n   *\n   * These functions are written for modern browsers. For old versions of IE,\n   * they're overridden in the 'startup' section at the end of this file.\n   */\n\n  function getL10nResourceLinks() {\n    return document.querySelectorAll('link[type=\"application/l10n\"]');\n  }\n\n  function getL10nDictionary() {\n    var script = document.querySelector('script[type=\"application/l10n\"]');\n    // TODO: support multiple and external JSON dictionaries\n    return script ? JSON.parse(script.innerHTML) : null;\n  }\n\n  function getTranslatableChildren(element) {\n    return element ? element.querySelectorAll('*[data-l10n-id]') : [];\n  }\n\n  function getL10nAttributes(element) {\n    if (!element)\n      return {};\n\n    var l10nId = element.getAttribute('data-l10n-id');\n    var l10nArgs = element.getAttribute('data-l10n-args');\n    var args = {};\n    if (l10nArgs) {\n      try {\n        args = JSON.parse(l10nArgs);\n      } catch (e) {\n        console.warn('could not parse arguments for #' + l10nId);\n      }\n    }\n    return { id: l10nId, args: args };\n  }\n\n  function xhrLoadText(url, onSuccess, onFailure) {\n    onSuccess = onSuccess || function _onSuccess(data) {};\n    onFailure = onFailure || function _onFailure() {};\n\n    var xhr = new XMLHttpRequest();\n    xhr.open('GET', url, gAsyncResourceLoading);\n    if (xhr.overrideMimeType) {\n      xhr.overrideMimeType('text/plain; charset=utf-8');\n    }\n    xhr.onreadystatechange = function() {\n      if (xhr.readyState == 4) {\n        if (xhr.status == 200 || xhr.status === 0) {\n          onSuccess(xhr.responseText);\n        } else {\n          onFailure();\n        }\n      }\n    };\n    xhr.onerror = onFailure;\n    xhr.ontimeout = onFailure;\n\n    // in Firefox OS with the app:// protocol, trying to XHR a non-existing\n    // URL will raise an exception here -- hence this ugly try...catch.\n    try {\n      xhr.send(null);\n    } catch (e) {\n      onFailure();\n    }\n  }\n\n\n  /**\n   * l10n resource parser:\n   *  - reads (async XHR) the l10n resource matching `lang';\n   *  - imports linked resources (synchronously) when specified;\n   *  - parses the text data (fills `gL10nData' and `gTextData');\n   *  - triggers success/failure callbacks when done.\n   *\n   * @param {string} href\n   *    URL of the l10n resource to parse.\n   *\n   * @param {string} lang\n   *    locale (language) to parse. Must be a lowercase string.\n   *\n   * @param {Function} successCallback\n   *    triggered when the l10n resource has been successfully parsed.\n   *\n   * @param {Function} failureCallback\n   *    triggered when the an error has occurred.\n   *\n   * @return {void}\n   *    uses the following global variables: gL10nData, gTextData, gTextProp.\n   */\n\n  function parseResource(href, lang, successCallback, failureCallback) {\n    var baseURL = href.replace(/[^\\/]*$/, '') || './';\n\n    // handle escaped characters (backslashes) in a string\n    function evalString(text) {\n      if (text.lastIndexOf('\\\\') < 0)\n        return text;\n      return text.replace(/\\\\\\\\/g, '\\\\')\n                 .replace(/\\\\n/g, '\\n')\n                 .replace(/\\\\r/g, '\\r')\n                 .replace(/\\\\t/g, '\\t')\n                 .replace(/\\\\b/g, '\\b')\n                 .replace(/\\\\f/g, '\\f')\n                 .replace(/\\\\{/g, '{')\n                 .replace(/\\\\}/g, '}')\n                 .replace(/\\\\\"/g, '\"')\n                 .replace(/\\\\'/g, \"'\");\n    }\n\n    // parse *.properties text data into an l10n dictionary\n    // If gAsyncResourceLoading is false, then the callback will be called\n    // synchronously. Otherwise it is called asynchronously.\n    function parseProperties(text, parsedPropertiesCallback) {\n      var dictionary = {};\n\n      // token expressions\n      var reBlank = /^\\s*|\\s*$/;\n      var reComment = /^\\s*#|^\\s*$/;\n      var reSection = /^\\s*\\[(.*)\\]\\s*$/;\n      var reImport = /^\\s*@import\\s+url\\((.*)\\)\\s*$/i;\n      var reSplit = /^([^=\\s]*)\\s*=\\s*(.+)$/; // TODO: escape EOLs with '\\'\n\n      // parse the *.properties file into an associative array\n      function parseRawLines(rawText, extendedSyntax, parsedRawLinesCallback) {\n        var entries = rawText.replace(reBlank, '').split(/[\\r\\n]+/);\n        var currentLang = '*';\n        var genericLang = lang.split('-', 1)[0];\n        var skipLang = false;\n        var match = '';\n\n        function nextEntry() {\n          // Use infinite loop instead of recursion to avoid reaching the\n          // maximum recursion limit for content with many lines.\n          while (true) {\n            if (!entries.length) {\n              parsedRawLinesCallback();\n              return;\n            }\n            var line = entries.shift();\n\n            // comment or blank line?\n            if (reComment.test(line))\n              continue;\n\n            // the extended syntax supports [lang] sections and @import rules\n            if (extendedSyntax) {\n              match = reSection.exec(line);\n              if (match) { // section start?\n                // RFC 4646, section 4.4, \"All comparisons MUST be performed\n                // in a case-insensitive manner.\"\n\n                currentLang = match[1].toLowerCase();\n                skipLang = (currentLang !== '*') &&\n                    (currentLang !== lang) && (currentLang !== genericLang);\n                continue;\n              } else if (skipLang) {\n                continue;\n              }\n              match = reImport.exec(line);\n              if (match) { // @import rule?\n                loadImport(baseURL + match[1], nextEntry);\n                return;\n              }\n            }\n\n            // key-value pair\n            var tmp = line.match(reSplit);\n            if (tmp && tmp.length == 3) {\n              dictionary[tmp[1]] = evalString(tmp[2]);\n            }\n          }\n        }\n        nextEntry();\n      }\n\n      // import another *.properties file\n      function loadImport(url, callback) {\n        xhrLoadText(url, function(content) {\n          parseRawLines(content, false, callback); // don't allow recursive imports\n        }, function () {\n          console.warn(url + ' not found.');\n          callback();\n        });\n      }\n\n      // fill the dictionary\n      parseRawLines(text, true, function() {\n        parsedPropertiesCallback(dictionary);\n      });\n    }\n\n    // load and parse l10n data (warning: global variables are used here)\n    xhrLoadText(href, function(response) {\n      gTextData += response; // mostly for debug\n\n      // parse *.properties text data into an l10n dictionary\n      parseProperties(response, function(data) {\n\n        // find attribute descriptions, if any\n        for (var key in data) {\n          var id, prop, index = key.lastIndexOf('.');\n          if (index > 0) { // an attribute has been specified\n            id = key.substring(0, index);\n            prop = key.substring(index + 1);\n          } else { // no attribute: assuming text content by default\n            id = key;\n            prop = gTextProp;\n          }\n          if (!gL10nData[id]) {\n            gL10nData[id] = {};\n          }\n          gL10nData[id][prop] = data[key];\n        }\n\n        // trigger callback\n        if (successCallback) {\n          successCallback();\n        }\n      });\n    }, failureCallback);\n  }\n\n  // load and parse all resources for the specified locale\n  function loadLocale(lang, callback) {\n    // RFC 4646, section 2.1 states that language tags have to be treated as\n    // case-insensitive. Convert to lowercase for case-insensitive comparisons.\n    if (lang) {\n      lang = lang.toLowerCase();\n    }\n\n    callback = callback || function _callback() {};\n\n    clear();\n    gLanguage = lang;\n\n    // check all <link type=\"application/l10n\" href=\"...\" /> nodes\n    // and load the resource files\n    var langLinks = getL10nResourceLinks();\n    var langCount = langLinks.length;\n    if (langCount === 0) {\n      // we might have a pre-compiled dictionary instead\n      var dict = getL10nDictionary();\n      if (dict && dict.locales && dict.default_locale) {\n        console.log('using the embedded JSON directory, early way out');\n        gL10nData = dict.locales[lang];\n        if (!gL10nData) {\n          var defaultLocale = dict.default_locale.toLowerCase();\n          for (var anyCaseLang in dict.locales) {\n            anyCaseLang = anyCaseLang.toLowerCase();\n            if (anyCaseLang === lang) {\n              gL10nData = dict.locales[lang];\n              break;\n            } else if (anyCaseLang === defaultLocale) {\n              gL10nData = dict.locales[defaultLocale];\n            }\n          }\n        }\n        callback();\n      } else {\n        console.log('no resource to load, early way out');\n      }\n      // early way out\n      gReadyState = 'complete';\n      return;\n    }\n\n    // start the callback when all resources are loaded\n    var onResourceLoaded = null;\n    var gResourceCount = 0;\n    onResourceLoaded = function() {\n      gResourceCount++;\n      if (gResourceCount >= langCount) {\n        callback();\n        gReadyState = 'complete';\n      }\n    };\n\n    // load all resource files\n    function L10nResourceLink(link) {\n      var href = link.href;\n      // Note: If |gAsyncResourceLoading| is false, then the following callbacks\n      // are synchronously called.\n      this.load = function(lang, callback) {\n        parseResource(href, lang, callback, function() {\n          console.warn(href + ' not found.');\n          // lang not found, used default resource instead\n          console.warn('\"' + lang + '\" resource not found');\n          gLanguage = '';\n          // Resource not loaded, but we still need to call the callback.\n          callback();\n        });\n      };\n    }\n\n    for (var i = 0; i < langCount; i++) {\n      var resource = new L10nResourceLink(langLinks[i]);\n      resource.load(lang, onResourceLoaded);\n    }\n  }\n\n  // clear all l10n data\n  function clear() {\n    gL10nData = {};\n    gTextData = '';\n    gLanguage = '';\n    // TODO: clear all non predefined macros.\n    // There's no such macro /yet/ but we're planning to have some...\n  }\n\n\n  /**\n   * Get rules for plural forms (shared with JetPack), see:\n   * http://unicode.org/repos/cldr-tmp/trunk/diff/supplemental/language_plural_rules.html\n   * https://github.com/mozilla/addon-sdk/blob/master/python-lib/plural-rules-generator.p\n   *\n   * @param {string} lang\n   *    locale (language) used.\n   *\n   * @return {Function}\n   *    returns a function that gives the plural form name for a given integer:\n   *       var fun = getPluralRules('en');\n   *       fun(1)    -> 'one'\n   *       fun(0)    -> 'other'\n   *       fun(1000) -> 'other'.\n   */\n\n  function getPluralRules(lang) {\n    var locales2rules = {\n      'af': 3,\n      'ak': 4,\n      'am': 4,\n      'ar': 1,\n      'asa': 3,\n      'az': 0,\n      'be': 11,\n      'bem': 3,\n      'bez': 3,\n      'bg': 3,\n      'bh': 4,\n      'bm': 0,\n      'bn': 3,\n      'bo': 0,\n      'br': 20,\n      'brx': 3,\n      'bs': 11,\n      'ca': 3,\n      'cgg': 3,\n      'chr': 3,\n      'cs': 12,\n      'cy': 17,\n      'da': 3,\n      'de': 3,\n      'dv': 3,\n      'dz': 0,\n      'ee': 3,\n      'el': 3,\n      'en': 3,\n      'eo': 3,\n      'es': 3,\n      'et': 3,\n      'eu': 3,\n      'fa': 0,\n      'ff': 5,\n      'fi': 3,\n      'fil': 4,\n      'fo': 3,\n      'fr': 5,\n      'fur': 3,\n      'fy': 3,\n      'ga': 8,\n      'gd': 24,\n      'gl': 3,\n      'gsw': 3,\n      'gu': 3,\n      'guw': 4,\n      'gv': 23,\n      'ha': 3,\n      'haw': 3,\n      'he': 2,\n      'hi': 4,\n      'hr': 11,\n      'hu': 0,\n      'id': 0,\n      'ig': 0,\n      'ii': 0,\n      'is': 3,\n      'it': 3,\n      'iu': 7,\n      'ja': 0,\n      'jmc': 3,\n      'jv': 0,\n      'ka': 0,\n      'kab': 5,\n      'kaj': 3,\n      'kcg': 3,\n      'kde': 0,\n      'kea': 0,\n      'kk': 3,\n      'kl': 3,\n      'km': 0,\n      'kn': 0,\n      'ko': 0,\n      'ksb': 3,\n      'ksh': 21,\n      'ku': 3,\n      'kw': 7,\n      'lag': 18,\n      'lb': 3,\n      'lg': 3,\n      'ln': 4,\n      'lo': 0,\n      'lt': 10,\n      'lv': 6,\n      'mas': 3,\n      'mg': 4,\n      'mk': 16,\n      'ml': 3,\n      'mn': 3,\n      'mo': 9,\n      'mr': 3,\n      'ms': 0,\n      'mt': 15,\n      'my': 0,\n      'nah': 3,\n      'naq': 7,\n      'nb': 3,\n      'nd': 3,\n      'ne': 3,\n      'nl': 3,\n      'nn': 3,\n      'no': 3,\n      'nr': 3,\n      'nso': 4,\n      'ny': 3,\n      'nyn': 3,\n      'om': 3,\n      'or': 3,\n      'pa': 3,\n      'pap': 3,\n      'pl': 13,\n      'ps': 3,\n      'pt': 3,\n      'rm': 3,\n      'ro': 9,\n      'rof': 3,\n      'ru': 11,\n      'rwk': 3,\n      'sah': 0,\n      'saq': 3,\n      'se': 7,\n      'seh': 3,\n      'ses': 0,\n      'sg': 0,\n      'sh': 11,\n      'shi': 19,\n      'sk': 12,\n      'sl': 14,\n      'sma': 7,\n      'smi': 7,\n      'smj': 7,\n      'smn': 7,\n      'sms': 7,\n      'sn': 3,\n      'so': 3,\n      'sq': 3,\n      'sr': 11,\n      'ss': 3,\n      'ssy': 3,\n      'st': 3,\n      'sv': 3,\n      'sw': 3,\n      'syr': 3,\n      'ta': 3,\n      'te': 3,\n      'teo': 3,\n      'th': 0,\n      'ti': 4,\n      'tig': 3,\n      'tk': 3,\n      'tl': 4,\n      'tn': 3,\n      'to': 0,\n      'tr': 0,\n      'ts': 3,\n      'tzm': 22,\n      'uk': 11,\n      'ur': 3,\n      've': 3,\n      'vi': 0,\n      'vun': 3,\n      'wa': 4,\n      'wae': 3,\n      'wo': 0,\n      'xh': 3,\n      'xog': 3,\n      'yo': 0,\n      'zh': 0,\n      'zu': 3\n    };\n\n    // utility functions for plural rules methods\n    function isIn(n, list) {\n      return list.indexOf(n) !== -1;\n    }\n    function isBetween(n, start, end) {\n      return start <= n && n <= end;\n    }\n\n    // list of all plural rules methods:\n    // map an integer to the plural form name to use\n    var pluralRules = {\n      '0': function(n) {\n        return 'other';\n      },\n      '1': function(n) {\n        if ((isBetween((n % 100), 3, 10)))\n          return 'few';\n        if (n === 0)\n          return 'zero';\n        if ((isBetween((n % 100), 11, 99)))\n          return 'many';\n        if (n == 2)\n          return 'two';\n        if (n == 1)\n          return 'one';\n        return 'other';\n      },\n      '2': function(n) {\n        if (n !== 0 && (n % 10) === 0)\n          return 'many';\n        if (n == 2)\n          return 'two';\n        if (n == 1)\n          return 'one';\n        return 'other';\n      },\n      '3': function(n) {\n        if (n == 1)\n          return 'one';\n        return 'other';\n      },\n      '4': function(n) {\n        if ((isBetween(n, 0, 1)))\n          return 'one';\n        return 'other';\n      },\n      '5': function(n) {\n        if ((isBetween(n, 0, 2)) && n != 2)\n          return 'one';\n        return 'other';\n      },\n      '6': function(n) {\n        if (n === 0)\n          return 'zero';\n        if ((n % 10) == 1 && (n % 100) != 11)\n          return 'one';\n        return 'other';\n      },\n      '7': function(n) {\n        if (n == 2)\n          return 'two';\n        if (n == 1)\n          return 'one';\n        return 'other';\n      },\n      '8': function(n) {\n        if ((isBetween(n, 3, 6)))\n          return 'few';\n        if ((isBetween(n, 7, 10)))\n          return 'many';\n        if (n == 2)\n          return 'two';\n        if (n == 1)\n          return 'one';\n        return 'other';\n      },\n      '9': function(n) {\n        if (n === 0 || n != 1 && (isBetween((n % 100), 1, 19)))\n          return 'few';\n        if (n == 1)\n          return 'one';\n        return 'other';\n      },\n      '10': function(n) {\n        if ((isBetween((n % 10), 2, 9)) && !(isBetween((n % 100), 11, 19)))\n          return 'few';\n        if ((n % 10) == 1 && !(isBetween((n % 100), 11, 19)))\n          return 'one';\n        return 'other';\n      },\n      '11': function(n) {\n        if ((isBetween((n % 10), 2, 4)) && !(isBetween((n % 100), 12, 14)))\n          return 'few';\n        if ((n % 10) === 0 ||\n            (isBetween((n % 10), 5, 9)) ||\n            (isBetween((n % 100), 11, 14)))\n          return 'many';\n        if ((n % 10) == 1 && (n % 100) != 11)\n          return 'one';\n        return 'other';\n      },\n      '12': function(n) {\n        if ((isBetween(n, 2, 4)))\n          return 'few';\n        if (n == 1)\n          return 'one';\n        return 'other';\n      },\n      '13': function(n) {\n        if ((isBetween((n % 10), 2, 4)) && !(isBetween((n % 100), 12, 14)))\n          return 'few';\n        if (n != 1 && (isBetween((n % 10), 0, 1)) ||\n            (isBetween((n % 10), 5, 9)) ||\n            (isBetween((n % 100), 12, 14)))\n          return 'many';\n        if (n == 1)\n          return 'one';\n        return 'other';\n      },\n      '14': function(n) {\n        if ((isBetween((n % 100), 3, 4)))\n          return 'few';\n        if ((n % 100) == 2)\n          return 'two';\n        if ((n % 100) == 1)\n          return 'one';\n        return 'other';\n      },\n      '15': function(n) {\n        if (n === 0 || (isBetween((n % 100), 2, 10)))\n          return 'few';\n        if ((isBetween((n % 100), 11, 19)))\n          return 'many';\n        if (n == 1)\n          return 'one';\n        return 'other';\n      },\n      '16': function(n) {\n        if ((n % 10) == 1 && n != 11)\n          return 'one';\n        return 'other';\n      },\n      '17': function(n) {\n        if (n == 3)\n          return 'few';\n        if (n === 0)\n          return 'zero';\n        if (n == 6)\n          return 'many';\n        if (n == 2)\n          return 'two';\n        if (n == 1)\n          return 'one';\n        return 'other';\n      },\n      '18': function(n) {\n        if (n === 0)\n          return 'zero';\n        if ((isBetween(n, 0, 2)) && n !== 0 && n != 2)\n          return 'one';\n        return 'other';\n      },\n      '19': function(n) {\n        if ((isBetween(n, 2, 10)))\n          return 'few';\n        if ((isBetween(n, 0, 1)))\n          return 'one';\n        return 'other';\n      },\n      '20': function(n) {\n        if ((isBetween((n % 10), 3, 4) || ((n % 10) == 9)) && !(\n            isBetween((n % 100), 10, 19) ||\n            isBetween((n % 100), 70, 79) ||\n            isBetween((n % 100), 90, 99)\n            ))\n          return 'few';\n        if ((n % 1000000) === 0 && n !== 0)\n          return 'many';\n        if ((n % 10) == 2 && !isIn((n % 100), [12, 72, 92]))\n          return 'two';\n        if ((n % 10) == 1 && !isIn((n % 100), [11, 71, 91]))\n          return 'one';\n        return 'other';\n      },\n      '21': function(n) {\n        if (n === 0)\n          return 'zero';\n        if (n == 1)\n          return 'one';\n        return 'other';\n      },\n      '22': function(n) {\n        if ((isBetween(n, 0, 1)) || (isBetween(n, 11, 99)))\n          return 'one';\n        return 'other';\n      },\n      '23': function(n) {\n        if ((isBetween((n % 10), 1, 2)) || (n % 20) === 0)\n          return 'one';\n        return 'other';\n      },\n      '24': function(n) {\n        if ((isBetween(n, 3, 10) || isBetween(n, 13, 19)))\n          return 'few';\n        if (isIn(n, [2, 12]))\n          return 'two';\n        if (isIn(n, [1, 11]))\n          return 'one';\n        return 'other';\n      }\n    };\n\n    // return a function that gives the plural form name for a given integer\n    var index = locales2rules[lang.replace(/-.*$/, '')];\n    if (!(index in pluralRules)) {\n      console.warn('plural form unknown for [' + lang + ']');\n      return function() { return 'other'; };\n    }\n    return pluralRules[index];\n  }\n\n  // pre-defined 'plural' macro\n  gMacros.plural = function(str, param, key, prop) {\n    var n = parseFloat(param);\n    if (isNaN(n))\n      return str;\n\n    // TODO: support other properties (l20n still doesn't...)\n    if (prop != gTextProp)\n      return str;\n\n    // initialize _pluralRules\n    if (!gMacros._pluralRules) {\n      gMacros._pluralRules = getPluralRules(gLanguage);\n    }\n    var index = '[' + gMacros._pluralRules(n) + ']';\n\n    // try to find a [zero|one|two] key if it's defined\n    if (n === 0 && (key + '[zero]') in gL10nData) {\n      str = gL10nData[key + '[zero]'][prop];\n    } else if (n == 1 && (key + '[one]') in gL10nData) {\n      str = gL10nData[key + '[one]'][prop];\n    } else if (n == 2 && (key + '[two]') in gL10nData) {\n      str = gL10nData[key + '[two]'][prop];\n    } else if ((key + index) in gL10nData) {\n      str = gL10nData[key + index][prop];\n    } else if ((key + '[other]') in gL10nData) {\n      str = gL10nData[key + '[other]'][prop];\n    }\n\n    return str;\n  };\n\n\n  /**\n   * l10n dictionary functions\n   */\n\n  // fetch an l10n object, warn if not found, apply `args' if possible\n  function getL10nData(key, args, fallback) {\n    var data = gL10nData[key];\n    if (!data) {\n      console.warn('#' + key + ' is undefined.');\n      if (!fallback) {\n        return null;\n      }\n      data = fallback;\n    }\n\n    /** This is where l10n expressions should be processed.\n      * The plan is to support C-style expressions from the l20n project;\n      * until then, only two kinds of simple expressions are supported:\n      *   {[ index ]} and {{ arguments }}.\n      */\n    var rv = {};\n    for (var prop in data) {\n      var str = data[prop];\n      str = substIndexes(str, args, key, prop);\n      str = substArguments(str, args, key);\n      rv[prop] = str;\n    }\n    return rv;\n  }\n\n  // replace {[macros]} with their values\n  function substIndexes(str, args, key, prop) {\n    var reIndex = /\\{\\[\\s*([a-zA-Z]+)\\(([a-zA-Z]+)\\)\\s*\\]\\}/;\n    var reMatch = reIndex.exec(str);\n    if (!reMatch || !reMatch.length)\n      return str;\n\n    // an index/macro has been found\n    // Note: at the moment, only one parameter is supported\n    var macroName = reMatch[1];\n    var paramName = reMatch[2];\n    var param;\n    if (args && paramName in args) {\n      param = args[paramName];\n    } else if (paramName in gL10nData) {\n      param = gL10nData[paramName];\n    }\n\n    // there's no macro parser yet: it has to be defined in gMacros\n    if (macroName in gMacros) {\n      var macro = gMacros[macroName];\n      str = macro(str, param, key, prop);\n    }\n    return str;\n  }\n\n  // replace {{arguments}} with their values\n  function substArguments(str, args, key) {\n    var reArgs = /\\{\\{\\s*(.+?)\\s*\\}\\}/g;\n    return str.replace(reArgs, function(matched_text, arg) {\n      if (args && arg in args) {\n        return args[arg];\n      }\n      if (arg in gL10nData) {\n        return gL10nData[arg];\n      }\n      console.log('argument {{' + arg + '}} for #' + key + ' is undefined.');\n      return matched_text;\n    });\n  }\n\n  // translate an HTML element\n  function translateElement(element) {\n    var l10n = getL10nAttributes(element);\n    if (!l10n.id)\n      return;\n\n    // get the related l10n object\n    var data = getL10nData(l10n.id, l10n.args);\n    if (!data) {\n      console.warn('#' + l10n.id + ' is undefined.');\n      return;\n    }\n\n    // translate element (TODO: security checks?)\n    if (data[gTextProp]) { // XXX\n      if (getChildElementCount(element) === 0) {\n        element[gTextProp] = data[gTextProp];\n      } else {\n        // this element has element children: replace the content of the first\n        // (non-empty) child textNode and clear other child textNodes\n        var children = element.childNodes;\n        var found = false;\n        for (var i = 0, l = children.length; i < l; i++) {\n          if (children[i].nodeType === 3 && /\\S/.test(children[i].nodeValue)) {\n            if (found) {\n              children[i].nodeValue = '';\n            } else {\n              children[i].nodeValue = data[gTextProp];\n              found = true;\n            }\n          }\n        }\n        // if no (non-empty) textNode is found, insert a textNode before the\n        // first element child.\n        if (!found) {\n          var textNode = document.createTextNode(data[gTextProp]);\n          element.insertBefore(textNode, element.firstChild);\n        }\n      }\n      delete data[gTextProp];\n    }\n\n    for (var k in data) {\n      element[k] = data[k];\n    }\n  }\n\n  // webkit browsers don't currently support 'children' on SVG elements...\n  function getChildElementCount(element) {\n    if (element.children) {\n      return element.children.length;\n    }\n    if (typeof element.childElementCount !== 'undefined') {\n      return element.childElementCount;\n    }\n    var count = 0;\n    for (var i = 0; i < element.childNodes.length; i++) {\n      count += element.nodeType === 1 ? 1 : 0;\n    }\n    return count;\n  }\n\n  // translate an HTML subtree\n  function translateFragment(element) {\n    element = element || document.documentElement;\n\n    // check all translatable children (= w/ a `data-l10n-id' attribute)\n    var children = getTranslatableChildren(element);\n    var elementCount = children.length;\n    for (var i = 0; i < elementCount; i++) {\n      translateElement(children[i]);\n    }\n\n    // translate element itself if necessary\n    translateElement(element);\n  }\n\n  return {\n    // get a localized string\n    get: function(key, args, fallbackString) {\n      var index = key.lastIndexOf('.');\n      var prop = gTextProp;\n      if (index > 0) { // An attribute has been specified\n        prop = key.substring(index + 1);\n        key = key.substring(0, index);\n      }\n      var fallback;\n      if (fallbackString) {\n        fallback = {};\n        fallback[prop] = fallbackString;\n      }\n      var data = getL10nData(key, args, fallback);\n      if (data && prop in data) {\n        return data[prop];\n      }\n      return '{{' + key + '}}';\n    },\n\n    // debug\n    getData: function() { return gL10nData; },\n    getText: function() { return gTextData; },\n\n    // get|set the document language\n    getLanguage: function() { return gLanguage; },\n    setLanguage: function(lang, callback) {\n      loadLocale(lang, function() {\n        if (callback)\n          callback();\n      });\n    },\n\n    // get the direction (ltr|rtl) of the current language\n    getDirection: function() {\n      // http://www.w3.org/International/questions/qa-scripts\n      // Arabic, Hebrew, Farsi, Pashto, Urdu\n      var rtlList = ['ar', 'he', 'fa', 'ps', 'ur'];\n      var shortCode = gLanguage.split('-', 1)[0];\n      return (rtlList.indexOf(shortCode) >= 0) ? 'rtl' : 'ltr';\n    },\n\n    // translate an element or document fragment\n    translate: translateFragment,\n\n    // this can be used to prevent race conditions\n    getReadyState: function() { return gReadyState; },\n    ready: function(callback) {\n      if (!callback) {\n        return;\n      } else if (gReadyState == 'complete' || gReadyState == 'interactive') {\n        window.setTimeout(function() {\n          callback();\n        });\n      } else if (document.addEventListener) {\n        document.addEventListener('localized', function once() {\n          document.removeEventListener('localized', once);\n          callback();\n        });\n      }\n    }\n  };\n}) (window, document);\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { createPromiseCapability } from \"pdfjs-lib\";\nimport { getCharacterType } from \"./pdf_find_utils.js\";\nimport { scrollIntoView } from \"./ui_utils.js\";\n\nconst FindState = {\n  FOUND: 0,\n  NOT_FOUND: 1,\n  WRAPPED: 2,\n  PENDING: 3,\n};\n\nconst FIND_TIMEOUT = 250; // ms\nconst MATCH_SCROLL_OFFSET_TOP = -50; // px\nconst MATCH_SCROLL_OFFSET_LEFT = -400; // px\n\nconst CHARACTERS_TO_NORMALIZE = {\n  \"\\u2018\": \"'\", // Left single quotation mark\n  \"\\u2019\": \"'\", // Right single quotation mark\n  \"\\u201A\": \"'\", // Single low-9 quotation mark\n  \"\\u201B\": \"'\", // Single high-reversed-9 quotation mark\n  \"\\u201C\": '\"', // Left double quotation mark\n  \"\\u201D\": '\"', // Right double quotation mark\n  \"\\u201E\": '\"', // Double low-9 quotation mark\n  \"\\u201F\": '\"', // Double high-reversed-9 quotation mark\n  \"\\u00BC\": \"1/4\", // Vulgar fraction one quarter\n  \"\\u00BD\": \"1/2\", // Vulgar fraction one half\n  \"\\u00BE\": \"3/4\", // Vulgar fraction three quarters\n};\n\nlet normalizationRegex = null;\nfunction normalize(text) {\n  if (!normalizationRegex) {\n    // Compile the regular expression for text normalization once.\n    const replace = Object.keys(CHARACTERS_TO_NORMALIZE).join(\"\");\n    normalizationRegex = new RegExp(`[${replace}]`, \"g\");\n  }\n  return text.replace(normalizationRegex, function (ch) {\n    return CHARACTERS_TO_NORMALIZE[ch];\n  });\n}\n\n/**\n * @typedef {Object} PDFFindControllerOptions\n * @property {IPDFLinkService} linkService - The navigation/linking service.\n * @property {EventBus} eventBus - The application event bus.\n */\n\n/**\n * Provides search functionality to find a given string in a PDF document.\n */\nclass PDFFindController {\n  /**\n   * @param {PDFFindControllerOptions} options\n   */\n  constructor({ linkService, eventBus }) {\n    this._linkService = linkService;\n    this._eventBus = eventBus;\n\n    this._reset();\n    eventBus._on(\"findbarclose\", this._onFindBarClose.bind(this));\n  }\n\n  get highlightMatches() {\n    return this._highlightMatches;\n  }\n\n  get pageMatches() {\n    return this._pageMatches;\n  }\n\n  get pageMatchesLength() {\n    return this._pageMatchesLength;\n  }\n\n  get selected() {\n    return this._selected;\n  }\n\n  get state() {\n    return this._state;\n  }\n\n  /**\n   * Set a reference to the PDF document in order to search it.\n   * Note that searching is not possible if this method is not called.\n   *\n   * @param {PDFDocumentProxy} pdfDocument - The PDF document to search.\n   */\n  setDocument(pdfDocument) {\n    if (this._pdfDocument) {\n      this._reset();\n    }\n    if (!pdfDocument) {\n      return;\n    }\n    this._pdfDocument = pdfDocument;\n    this._firstPageCapability.resolve();\n  }\n\n  executeCommand(cmd, state) {\n    if (!state) {\n      return;\n    }\n    const pdfDocument = this._pdfDocument;\n\n    if (this._state === null || this._shouldDirtyMatch(cmd, state)) {\n      this._dirtyMatch = true;\n    }\n    this._state = state;\n    if (cmd !== \"findhighlightallchange\") {\n      this._updateUIState(FindState.PENDING);\n    }\n\n    this._firstPageCapability.promise.then(() => {\n      // If the document was closed before searching began, or if the search\n      // operation was relevant for a previously opened document, do nothing.\n      if (\n        !this._pdfDocument ||\n        (pdfDocument && this._pdfDocument !== pdfDocument)\n      ) {\n        return;\n      }\n      this._extractText();\n\n      const findbarClosed = !this._highlightMatches;\n      const pendingTimeout = !!this._findTimeout;\n\n      if (this._findTimeout) {\n        clearTimeout(this._findTimeout);\n        this._findTimeout = null;\n      }\n      if (cmd === \"find\") {\n        // Trigger the find action with a small delay to avoid starting the\n        // search when the user is still typing (saving resources).\n        this._findTimeout = setTimeout(() => {\n          this._nextMatch();\n          this._findTimeout = null;\n        }, FIND_TIMEOUT);\n      } else if (this._dirtyMatch) {\n        // Immediately trigger searching for non-'find' operations, when the\n        // current state needs to be reset and matches re-calculated.\n        this._nextMatch();\n      } else if (cmd === \"findagain\") {\n        this._nextMatch();\n\n        // When the findbar was previously closed, and `highlightAll` is set,\n        // ensure that the matches on all active pages are highlighted again.\n        if (findbarClosed && this._state.highlightAll) {\n          this._updateAllPages();\n        }\n      } else if (cmd === \"findhighlightallchange\") {\n        // If there was a pending search operation, synchronously trigger a new\n        // search *first* to ensure that the correct matches are highlighted.\n        if (pendingTimeout) {\n          this._nextMatch();\n        } else {\n          this._highlightMatches = true;\n        }\n        this._updateAllPages(); // Update the highlighting on all active pages.\n      } else {\n        this._nextMatch();\n      }\n    });\n  }\n\n  scrollMatchIntoView({ element = null, pageIndex = -1, matchIndex = -1 }) {\n    if (!this._scrollMatches || !element) {\n      return;\n    } else if (matchIndex === -1 || matchIndex !== this._selected.matchIdx) {\n      return;\n    } else if (pageIndex === -1 || pageIndex !== this._selected.pageIdx) {\n      return;\n    }\n    this._scrollMatches = false; // Ensure that scrolling only happens once.\n\n    const spot = {\n      top: MATCH_SCROLL_OFFSET_TOP,\n      left: MATCH_SCROLL_OFFSET_LEFT,\n    };\n    scrollIntoView(element, spot, /* skipOverflowHiddenElements = */ true);\n  }\n\n  _reset() {\n    this._highlightMatches = false;\n    this._scrollMatches = false;\n    this._pdfDocument = null;\n    this._pageMatches = [];\n    this._pageMatchesLength = [];\n    this._state = null;\n    // Currently selected match.\n    this._selected = {\n      pageIdx: -1,\n      matchIdx: -1,\n    };\n    // Where the find algorithm currently is in the document.\n    this._offset = {\n      pageIdx: null,\n      matchIdx: null,\n      wrapped: false,\n    };\n    this._extractTextPromises = [];\n    this._pageContents = []; // Stores the normalized text for each page.\n    this._matchesCountTotal = 0;\n    this._pagesToSearch = null;\n    this._pendingFindMatches = Object.create(null);\n    this._resumePageIdx = null;\n    this._dirtyMatch = false;\n    clearTimeout(this._findTimeout);\n    this._findTimeout = null;\n\n    this._firstPageCapability = createPromiseCapability();\n  }\n\n  /**\n   * @type {string} The (current) normalized search query.\n   */\n  get _query() {\n    if (this._state.query !== this._rawQuery) {\n      this._rawQuery = this._state.query;\n      this._normalizedQuery = normalize(this._state.query);\n    }\n    return this._normalizedQuery;\n  }\n\n  _shouldDirtyMatch(cmd, state) {\n    // When the search query changes, regardless of the actual search command\n    // used, always re-calculate matches to avoid errors (fixes bug 1030622).\n    if (state.query !== this._state.query) {\n      return true;\n    }\n    switch (cmd) {\n      case \"findagain\":\n        const pageNumber = this._selected.pageIdx + 1;\n        const linkService = this._linkService;\n        // Only treat a 'findagain' event as a new search operation when it's\n        // *absolutely* certain that the currently selected match is no longer\n        // visible, e.g. as a result of the user scrolling in the document.\n        //\n        // NOTE: If only a simple `this._linkService.page` check was used here,\n        // there's a risk that consecutive 'findagain' operations could \"skip\"\n        // over matches at the top/bottom of pages thus making them completely\n        // inaccessible when there's multiple pages visible in the viewer.\n        if (\n          pageNumber >= 1 &&\n          pageNumber <= linkService.pagesCount &&\n          pageNumber !== linkService.page &&\n          !linkService.isPageVisible(pageNumber)\n        ) {\n          return true;\n        }\n        return false;\n      case \"findhighlightallchange\":\n        return false;\n    }\n    return true;\n  }\n\n  /**\n   * Helper for multi-term search that fills the `matchesWithLength` array\n   * and handles cases where one search term includes another search term (for\n   * example, \"tamed tame\" or \"this is\"). It looks for intersecting terms in\n   * the `matches` and keeps elements with a longer match length.\n   */\n  _prepareMatches(matchesWithLength, matches, matchesLength) {\n    function isSubTerm(currentIndex) {\n      const currentElem = matchesWithLength[currentIndex];\n      const nextElem = matchesWithLength[currentIndex + 1];\n\n      // Check for cases like \"TAMEd TAME\".\n      if (\n        currentIndex < matchesWithLength.length - 1 &&\n        currentElem.match === nextElem.match\n      ) {\n        currentElem.skipped = true;\n        return true;\n      }\n\n      // Check for cases like \"thIS IS\".\n      for (let i = currentIndex - 1; i >= 0; i--) {\n        const prevElem = matchesWithLength[i];\n        if (prevElem.skipped) {\n          continue;\n        }\n        if (prevElem.match + prevElem.matchLength < currentElem.match) {\n          break;\n        }\n        if (\n          prevElem.match + prevElem.matchLength >=\n          currentElem.match + currentElem.matchLength\n        ) {\n          currentElem.skipped = true;\n          return true;\n        }\n      }\n      return false;\n    }\n\n    // Sort the array of `{ match: <match>, matchLength: <matchLength> }`\n    // objects on increasing index first and on the length otherwise.\n    matchesWithLength.sort(function (a, b) {\n      return a.match === b.match\n        ? a.matchLength - b.matchLength\n        : a.match - b.match;\n    });\n    for (let i = 0, len = matchesWithLength.length; i < len; i++) {\n      if (isSubTerm(i)) {\n        continue;\n      }\n      matches.push(matchesWithLength[i].match);\n      matchesLength.push(matchesWithLength[i].matchLength);\n    }\n  }\n\n  /**\n   * Determine if the search query constitutes a \"whole word\", by comparing the\n   * first/last character type with the preceding/following character type.\n   */\n  _isEntireWord(content, startIdx, length) {\n    if (startIdx > 0) {\n      const first = content.charCodeAt(startIdx);\n      const limit = content.charCodeAt(startIdx - 1);\n      if (getCharacterType(first) === getCharacterType(limit)) {\n        return false;\n      }\n    }\n    const endIdx = startIdx + length - 1;\n    if (endIdx < content.length - 1) {\n      const last = content.charCodeAt(endIdx);\n      const limit = content.charCodeAt(endIdx + 1);\n      if (getCharacterType(last) === getCharacterType(limit)) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  _calculatePhraseMatch(query, pageIndex, pageContent, entireWord) {\n    const matches = [];\n    const queryLen = query.length;\n\n    let matchIdx = -queryLen;\n    while (true) {\n      matchIdx = pageContent.indexOf(query, matchIdx + queryLen);\n      if (matchIdx === -1) {\n        break;\n      }\n      if (entireWord && !this._isEntireWord(pageContent, matchIdx, queryLen)) {\n        continue;\n      }\n      matches.push(matchIdx);\n    }\n    this._pageMatches[pageIndex] = matches;\n  }\n\n  _calculateWordMatch(query, pageIndex, pageContent, entireWord) {\n    const matchesWithLength = [];\n\n    // Divide the query into pieces and search for text in each piece.\n    const queryArray = query.match(/\\S+/g);\n    for (let i = 0, len = queryArray.length; i < len; i++) {\n      const subquery = queryArray[i];\n      const subqueryLen = subquery.length;\n\n      let matchIdx = -subqueryLen;\n      while (true) {\n        matchIdx = pageContent.indexOf(subquery, matchIdx + subqueryLen);\n        if (matchIdx === -1) {\n          break;\n        }\n        if (\n          entireWord &&\n          !this._isEntireWord(pageContent, matchIdx, subqueryLen)\n        ) {\n          continue;\n        }\n        // Other searches do not, so we store the length.\n        matchesWithLength.push({\n          match: matchIdx,\n          matchLength: subqueryLen,\n          skipped: false,\n        });\n      }\n    }\n\n    // Prepare arrays for storing the matches.\n    this._pageMatchesLength[pageIndex] = [];\n    this._pageMatches[pageIndex] = [];\n\n    // Sort `matchesWithLength`, remove intersecting terms and put the result\n    // into the two arrays.\n    this._prepareMatches(\n      matchesWithLength,\n      this._pageMatches[pageIndex],\n      this._pageMatchesLength[pageIndex]\n    );\n  }\n\n  _calculateMatch(pageIndex) {\n    let pageContent = this._pageContents[pageIndex];\n    let query = this._query;\n    const { caseSensitive, entireWord, phraseSearch } = this._state;\n\n    if (query.length === 0) {\n      // Do nothing: the matches should be wiped out already.\n      return;\n    }\n\n    if (!caseSensitive) {\n      pageContent = pageContent.toLowerCase();\n      query = query.toLowerCase();\n    }\n\n    if (phraseSearch) {\n      this._calculatePhraseMatch(query, pageIndex, pageContent, entireWord);\n    } else {\n      this._calculateWordMatch(query, pageIndex, pageContent, entireWord);\n    }\n\n    // When `highlightAll` is set, ensure that the matches on previously\n    // rendered (and still active) pages are correctly highlighted.\n    if (this._state.highlightAll) {\n      this._updatePage(pageIndex);\n    }\n    if (this._resumePageIdx === pageIndex) {\n      this._resumePageIdx = null;\n      this._nextPageMatch();\n    }\n\n    // Update the match count.\n    const pageMatchesCount = this._pageMatches[pageIndex].length;\n    if (pageMatchesCount > 0) {\n      this._matchesCountTotal += pageMatchesCount;\n      this._updateUIResultsCount();\n    }\n  }\n\n  _extractText() {\n    // Perform text extraction once if this method is called multiple times.\n    if (this._extractTextPromises.length > 0) {\n      return;\n    }\n\n    let promise = Promise.resolve();\n    for (let i = 0, ii = this._linkService.pagesCount; i < ii; i++) {\n      const extractTextCapability = createPromiseCapability();\n      this._extractTextPromises[i] = extractTextCapability.promise;\n\n      promise = promise.then(() => {\n        return this._pdfDocument\n          .getPage(i + 1)\n          .then(pdfPage => {\n            return pdfPage.getTextContent({\n              normalizeWhitespace: true,\n            });\n          })\n          .then(\n            textContent => {\n              const textItems = textContent.items;\n              const strBuf = [];\n\n              for (let j = 0, jj = textItems.length; j < jj; j++) {\n                strBuf.push(textItems[j].str);\n              }\n\n              // Store the normalized page content (text items) as one string.\n              this._pageContents[i] = normalize(strBuf.join(\"\"));\n              extractTextCapability.resolve(i);\n            },\n            reason => {\n              console.error(\n                `Unable to get text content for page ${i + 1}`,\n                reason\n              );\n              // Page error -- assuming no text content.\n              this._pageContents[i] = \"\";\n              extractTextCapability.resolve(i);\n            }\n          );\n      });\n    }\n  }\n\n  _updatePage(index) {\n    if (this._scrollMatches && this._selected.pageIdx === index) {\n      // If the page is selected, scroll the page into view, which triggers\n      // rendering the page, which adds the text layer. Once the text layer\n      // is built, it will attempt to scroll the selected match into view.\n      this._linkService.page = index + 1;\n    }\n\n    this._eventBus.dispatch(\"updatetextlayermatches\", {\n      source: this,\n      pageIndex: index,\n    });\n  }\n\n  _updateAllPages() {\n    this._eventBus.dispatch(\"updatetextlayermatches\", {\n      source: this,\n      pageIndex: -1,\n    });\n  }\n\n  _nextMatch() {\n    const previous = this._state.findPrevious;\n    const currentPageIndex = this._linkService.page - 1;\n    const numPages = this._linkService.pagesCount;\n\n    this._highlightMatches = true;\n\n    if (this._dirtyMatch) {\n      // Need to recalculate the matches, reset everything.\n      this._dirtyMatch = false;\n      this._selected.pageIdx = this._selected.matchIdx = -1;\n      this._offset.pageIdx = currentPageIndex;\n      this._offset.matchIdx = null;\n      this._offset.wrapped = false;\n      this._resumePageIdx = null;\n      this._pageMatches.length = 0;\n      this._pageMatchesLength.length = 0;\n      this._matchesCountTotal = 0;\n\n      this._updateAllPages(); // Wipe out any previously highlighted matches.\n\n      for (let i = 0; i < numPages; i++) {\n        // Start finding the matches as soon as the text is extracted.\n        if (this._pendingFindMatches[i] === true) {\n          continue;\n        }\n        this._pendingFindMatches[i] = true;\n        this._extractTextPromises[i].then(pageIdx => {\n          delete this._pendingFindMatches[pageIdx];\n          this._calculateMatch(pageIdx);\n        });\n      }\n    }\n\n    // If there's no query there's no point in searching.\n    if (this._query === \"\") {\n      this._updateUIState(FindState.FOUND);\n      return;\n    }\n    // If we're waiting on a page, we return since we can't do anything else.\n    if (this._resumePageIdx) {\n      return;\n    }\n\n    const offset = this._offset;\n    // Keep track of how many pages we should maximally iterate through.\n    this._pagesToSearch = numPages;\n    // If there's already a `matchIdx` that means we are iterating through a\n    // page's matches.\n    if (offset.matchIdx !== null) {\n      const numPageMatches = this._pageMatches[offset.pageIdx].length;\n      if (\n        (!previous && offset.matchIdx + 1 < numPageMatches) ||\n        (previous && offset.matchIdx > 0)\n      ) {\n        // The simple case; we just have advance the matchIdx to select\n        // the next match on the page.\n        offset.matchIdx = previous ? offset.matchIdx - 1 : offset.matchIdx + 1;\n        this._updateMatch(/* found = */ true);\n        return;\n      }\n      // We went beyond the current page's matches, so we advance to\n      // the next page.\n      this._advanceOffsetPage(previous);\n    }\n    // Start searching through the page.\n    this._nextPageMatch();\n  }\n\n  _matchesReady(matches) {\n    const offset = this._offset;\n    const numMatches = matches.length;\n    const previous = this._state.findPrevious;\n\n    if (numMatches) {\n      // There were matches for the page, so initialize `matchIdx`.\n      offset.matchIdx = previous ? numMatches - 1 : 0;\n      this._updateMatch(/* found = */ true);\n      return true;\n    }\n    // No matches, so attempt to search the next page.\n    this._advanceOffsetPage(previous);\n    if (offset.wrapped) {\n      offset.matchIdx = null;\n      if (this._pagesToSearch < 0) {\n        // No point in wrapping again, there were no matches.\n        this._updateMatch(/* found = */ false);\n        // While matches were not found, searching for a page\n        // with matches should nevertheless halt.\n        return true;\n      }\n    }\n    // Matches were not found (and searching is not done).\n    return false;\n  }\n\n  _nextPageMatch() {\n    if (this._resumePageIdx !== null) {\n      console.error(\"There can only be one pending page.\");\n    }\n\n    let matches = null;\n    do {\n      const pageIdx = this._offset.pageIdx;\n      matches = this._pageMatches[pageIdx];\n      if (!matches) {\n        // The matches don't exist yet for processing by `_matchesReady`,\n        // so set a resume point for when they do exist.\n        this._resumePageIdx = pageIdx;\n        break;\n      }\n    } while (!this._matchesReady(matches));\n  }\n\n  _advanceOffsetPage(previous) {\n    const offset = this._offset;\n    const numPages = this._linkService.pagesCount;\n    offset.pageIdx = previous ? offset.pageIdx - 1 : offset.pageIdx + 1;\n    offset.matchIdx = null;\n\n    this._pagesToSearch--;\n\n    if (offset.pageIdx >= numPages || offset.pageIdx < 0) {\n      offset.pageIdx = previous ? numPages - 1 : 0;\n      offset.wrapped = true;\n    }\n  }\n\n  _updateMatch(found = false) {\n    let state = FindState.NOT_FOUND;\n    const wrapped = this._offset.wrapped;\n    this._offset.wrapped = false;\n\n    if (found) {\n      const previousPage = this._selected.pageIdx;\n      this._selected.pageIdx = this._offset.pageIdx;\n      this._selected.matchIdx = this._offset.matchIdx;\n      state = wrapped ? FindState.WRAPPED : FindState.FOUND;\n\n      // Update the currently selected page to wipe out any selected matches.\n      if (previousPage !== -1 && previousPage !== this._selected.pageIdx) {\n        this._updatePage(previousPage);\n      }\n    }\n\n    this._updateUIState(state, this._state.findPrevious);\n    if (this._selected.pageIdx !== -1) {\n      // Ensure that the match will be scrolled into view.\n      this._scrollMatches = true;\n\n      this._updatePage(this._selected.pageIdx);\n    }\n  }\n\n  _onFindBarClose(evt) {\n    const pdfDocument = this._pdfDocument;\n    // Since searching is asynchronous, ensure that the removal of highlighted\n    // matches (from the UI) is async too such that the 'updatetextlayermatches'\n    // events will always be dispatched in the expected order.\n    this._firstPageCapability.promise.then(() => {\n      // Only update the UI if the document is open, and is the current one.\n      if (\n        !this._pdfDocument ||\n        (pdfDocument && this._pdfDocument !== pdfDocument)\n      ) {\n        return;\n      }\n      // Ensure that a pending, not yet started, search operation is aborted.\n      if (this._findTimeout) {\n        clearTimeout(this._findTimeout);\n        this._findTimeout = null;\n      }\n      // Abort any long running searches, to avoid a match being scrolled into\n      // view *after* the findbar has been closed. In this case `this._offset`\n      // will most likely differ from `this._selected`, hence we also ensure\n      // that any new search operation will always start with a clean slate.\n      if (this._resumePageIdx) {\n        this._resumePageIdx = null;\n        this._dirtyMatch = true;\n      }\n      // Avoid the UI being in a pending state when the findbar is re-opened.\n      this._updateUIState(FindState.FOUND);\n\n      this._highlightMatches = false;\n      this._updateAllPages(); // Wipe out any previously highlighted matches.\n    });\n  }\n\n  _requestMatchesCount() {\n    const { pageIdx, matchIdx } = this._selected;\n    let current = 0,\n      total = this._matchesCountTotal;\n    if (matchIdx !== -1) {\n      for (let i = 0; i < pageIdx; i++) {\n        current += (this._pageMatches[i] && this._pageMatches[i].length) || 0;\n      }\n      current += matchIdx + 1;\n    }\n    // When searching starts, this method may be called before the `pageMatches`\n    // have been counted (in `_calculateMatch`). Ensure that the UI won't show\n    // temporarily broken state when the active find result doesn't make sense.\n    if (current < 1 || current > total) {\n      current = total = 0;\n    }\n    return { current, total };\n  }\n\n  _updateUIResultsCount() {\n    this._eventBus.dispatch(\"updatefindmatchescount\", {\n      source: this,\n      matchesCount: this._requestMatchesCount(),\n    });\n  }\n\n  _updateUIState(state, previous) {\n    this._eventBus.dispatch(\"updatefindcontrolstate\", {\n      source: this,\n      state,\n      previous,\n      matchesCount: this._requestMatchesCount(),\n      rawQuery: this._state ? this._state.query : null,\n    });\n  }\n}\n\nexport { FindState, PDFFindController };\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst CharacterType = {\n  SPACE: 0,\n  ALPHA_LETTER: 1,\n  PUNCT: 2,\n  HAN_LETTER: 3,\n  KATAKANA_LETTER: 4,\n  HIRAGANA_LETTER: 5,\n  HALFWIDTH_KATAKANA_LETTER: 6,\n  THAI_LETTER: 7,\n};\n\nfunction isAlphabeticalScript(charCode) {\n  return charCode < 0x2e80;\n}\n\nfunction isAscii(charCode) {\n  return (charCode & 0xff80) === 0;\n}\n\nfunction isAsciiAlpha(charCode) {\n  return (\n    (charCode >= /* a = */ 0x61 && charCode <= /* z = */ 0x7a) ||\n    (charCode >= /* A = */ 0x41 && charCode <= /* Z = */ 0x5a)\n  );\n}\n\nfunction isAsciiDigit(charCode) {\n  return charCode >= /* 0 = */ 0x30 && charCode <= /* 9 = */ 0x39;\n}\n\nfunction isAsciiSpace(charCode) {\n  return (\n    charCode === /* SPACE = */ 0x20 ||\n    charCode === /* TAB = */ 0x09 ||\n    charCode === /* CR = */ 0x0d ||\n    charCode === /* LF = */ 0x0a\n  );\n}\n\nfunction isHan(charCode) {\n  return (\n    (charCode >= 0x3400 && charCode <= 0x9fff) ||\n    (charCode >= 0xf900 && charCode <= 0xfaff)\n  );\n}\n\nfunction isKatakana(charCode) {\n  return charCode >= 0x30a0 && charCode <= 0x30ff;\n}\n\nfunction isHiragana(charCode) {\n  return charCode >= 0x3040 && charCode <= 0x309f;\n}\n\nfunction isHalfwidthKatakana(charCode) {\n  return charCode >= 0xff60 && charCode <= 0xff9f;\n}\n\nfunction isThai(charCode) {\n  return (charCode & 0xff80) === 0x0e00;\n}\n\n/**\n * This function is based on the word-break detection implemented in:\n * https://hg.mozilla.org/mozilla-central/file/tip/intl/lwbrk/WordBreaker.cpp\n */\nfunction getCharacterType(charCode) {\n  if (isAlphabeticalScript(charCode)) {\n    if (isAscii(charCode)) {\n      if (isAsciiSpace(charCode)) {\n        return CharacterType.SPACE;\n      } else if (\n        isAsciiAlpha(charCode) ||\n        isAsciiDigit(charCode) ||\n        charCode === /* UNDERSCORE = */ 0x5f\n      ) {\n        return CharacterType.ALPHA_LETTER;\n      }\n      return CharacterType.PUNCT;\n    } else if (isThai(charCode)) {\n      return CharacterType.THAI_LETTER;\n    } else if (charCode === /* NBSP = */ 0xa0) {\n      return CharacterType.SPACE;\n    }\n    return CharacterType.ALPHA_LETTER;\n  }\n\n  if (isHan(charCode)) {\n    return CharacterType.HAN_LETTER;\n  } else if (isKatakana(charCode)) {\n    return CharacterType.KATAKANA_LETTER;\n  } else if (isHiragana(charCode)) {\n    return CharacterType.HIRAGANA_LETTER;\n  } else if (isHalfwidthKatakana(charCode)) {\n    return CharacterType.HALFWIDTH_KATAKANA_LETTER;\n  }\n  return CharacterType.ALPHA_LETTER;\n}\n\nexport { CharacterType, getCharacterType };\n","/* Copyright 2017 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  isValidRotation,\n  parseQueryString,\n  waitOnEventOrTimeout,\n} from \"./ui_utils.js\";\n\n// Heuristic value used when force-resetting `this._blockHashChange`.\nconst HASH_CHANGE_TIMEOUT = 1000; // milliseconds\n// Heuristic value used when adding the current position to the browser history.\nconst POSITION_UPDATED_THRESHOLD = 50;\n// Heuristic value used when adding a temporary position to the browser history.\nconst UPDATE_VIEWAREA_TIMEOUT = 1000; // milliseconds\n\n/**\n * @typedef {Object} PDFHistoryOptions\n * @property {IPDFLinkService} linkService - The navigation/linking service.\n * @property {EventBus} eventBus - The application event bus.\n */\n\n/**\n * @typedef {Object} InitializeParameters\n * @property {string} fingerprint - The PDF document's unique fingerprint.\n * @property {boolean} [resetHistory] - Reset the browsing history.\n * @property {boolean} [updateUrl] - Attempt to update the document URL, with\n *   the current hash, when pushing/replacing browser history entries.\n */\n\n/**\n * @typedef {Object} PushParameters\n * @property {string} [namedDest] - The named destination. If absent, a\n *   stringified version of `explicitDest` is used.\n * @property {Array} explicitDest - The explicit destination array.\n * @property {number} pageNumber - The page to which the destination points.\n */\n\nfunction getCurrentHash() {\n  return document.location.hash;\n}\n\nclass PDFHistory {\n  /**\n   * @param {PDFHistoryOptions} options\n   */\n  constructor({ linkService, eventBus }) {\n    this.linkService = linkService;\n    this.eventBus = eventBus;\n\n    this._initialized = false;\n    this._fingerprint = \"\";\n    this.reset();\n\n    this._boundEvents = null;\n    this._isViewerInPresentationMode = false;\n    // Ensure that we don't miss either a 'presentationmodechanged' or a\n    // 'pagesinit' event, by registering the listeners immediately.\n    this.eventBus._on(\"presentationmodechanged\", evt => {\n      this._isViewerInPresentationMode = evt.active || evt.switchInProgress;\n    });\n    this.eventBus._on(\"pagesinit\", () => {\n      this._isPagesLoaded = false;\n\n      const onPagesLoaded = evt => {\n        this.eventBus._off(\"pagesloaded\", onPagesLoaded);\n        this._isPagesLoaded = !!evt.pagesCount;\n      };\n      this.eventBus._on(\"pagesloaded\", onPagesLoaded);\n    });\n  }\n\n  /**\n   * Initialize the history for the PDF document, using either the current\n   * browser history entry or the document hash, whichever is present.\n   * @param {InitializeParameters} params\n   */\n  initialize({ fingerprint, resetHistory = false, updateUrl = false }) {\n    if (!fingerprint || typeof fingerprint !== \"string\") {\n      console.error(\n        'PDFHistory.initialize: The \"fingerprint\" must be a non-empty string.'\n      );\n      return;\n    }\n    // Ensure that any old state is always reset upon initialization.\n    if (this._initialized) {\n      this.reset();\n    }\n    const reInitialized =\n      this._fingerprint !== \"\" && this._fingerprint !== fingerprint;\n    this._fingerprint = fingerprint;\n    this._updateUrl = updateUrl === true;\n\n    this._initialized = true;\n    this._bindEvents();\n    const state = window.history.state;\n\n    this._popStateInProgress = false;\n    this._blockHashChange = 0;\n    this._currentHash = getCurrentHash();\n    this._numPositionUpdates = 0;\n\n    this._uid = this._maxUid = 0;\n    this._destination = null;\n    this._position = null;\n\n    if (!this._isValidState(state, /* checkReload = */ true) || resetHistory) {\n      const { hash, page, rotation } = this._parseCurrentHash(\n        /* checkNameddest = */ true\n      );\n\n      if (!hash || reInitialized || resetHistory) {\n        // Ensure that the browser history is reset on PDF document load.\n        this._pushOrReplaceState(null, /* forceReplace = */ true);\n        return;\n      }\n      // Ensure that the browser history is initialized correctly when\n      // the document hash is present on PDF document load.\n      this._pushOrReplaceState(\n        { hash, page, rotation },\n        /* forceReplace = */ true\n      );\n      return;\n    }\n\n    // The browser history contains a valid entry, ensure that the history is\n    // initialized correctly on PDF document load.\n    const destination = state.destination;\n    this._updateInternalState(\n      destination,\n      state.uid,\n      /* removeTemporary = */ true\n    );\n    if (this._uid > this._maxUid) {\n      this._maxUid = this._uid;\n    }\n\n    if (destination.rotation !== undefined) {\n      this._initialRotation = destination.rotation;\n    }\n    if (destination.dest) {\n      this._initialBookmark = JSON.stringify(destination.dest);\n\n      // If the history is updated, e.g. through the user changing the hash,\n      // before the initial destination has become visible, then we do *not*\n      // want to potentially add `this._position` to the browser history.\n      this._destination.page = null;\n    } else if (destination.hash) {\n      this._initialBookmark = destination.hash;\n    } else if (destination.page) {\n      // Fallback case; shouldn't be necessary, but better safe than sorry.\n      this._initialBookmark = `page=${destination.page}`;\n    }\n  }\n\n  /**\n   * Reset the current `PDFHistory` instance, and consequently prevent any\n   * further updates and/or navigation of the browser history.\n   */\n  reset() {\n    if (this._initialized) {\n      this._pageHide(); // Simulate a 'pagehide' event when resetting.\n\n      this._initialized = false;\n      this._unbindEvents();\n    }\n    if (this._updateViewareaTimeout) {\n      clearTimeout(this._updateViewareaTimeout);\n      this._updateViewareaTimeout = null;\n    }\n    this._initialBookmark = null;\n    this._initialRotation = null;\n  }\n\n  /**\n   * Push an internal destination to the browser history.\n   * @param {PushParameters}\n   */\n  push({ namedDest = null, explicitDest, pageNumber }) {\n    if (!this._initialized) {\n      return;\n    }\n    if (namedDest && typeof namedDest !== \"string\") {\n      console.error(\n        \"PDFHistory.push: \" +\n          `\"${namedDest}\" is not a valid namedDest parameter.`\n      );\n      return;\n    } else if (!Array.isArray(explicitDest)) {\n      console.error(\n        \"PDFHistory.push: \" +\n          `\"${explicitDest}\" is not a valid explicitDest parameter.`\n      );\n      return;\n    } else if (\n      !(\n        Number.isInteger(pageNumber) &&\n        pageNumber > 0 &&\n        pageNumber <= this.linkService.pagesCount\n      )\n    ) {\n      // Allow an unset `pageNumber` if and only if the history is still empty;\n      // please refer to the `this._destination.page = null;` comment above.\n      if (pageNumber !== null || this._destination) {\n        console.error(\n          \"PDFHistory.push: \" +\n            `\"${pageNumber}\" is not a valid pageNumber parameter.`\n        );\n        return;\n      }\n    }\n\n    const hash = namedDest || JSON.stringify(explicitDest);\n    if (!hash) {\n      // The hash *should* never be undefined, but if that were to occur,\n      // avoid any possible issues by not updating the browser history.\n      return;\n    }\n\n    let forceReplace = false;\n    if (\n      this._destination &&\n      (isDestHashesEqual(this._destination.hash, hash) ||\n        isDestArraysEqual(this._destination.dest, explicitDest))\n    ) {\n      // When the new destination is identical to `this._destination`, and\n      // its `page` is undefined, replace the current browser history entry.\n      // NOTE: This can only occur if `this._destination` was set either:\n      //  - through the document hash being specified on load.\n      //  - through the user changing the hash of the document.\n      if (this._destination.page) {\n        return;\n      }\n      forceReplace = true;\n    }\n    if (this._popStateInProgress && !forceReplace) {\n      return;\n    }\n\n    this._pushOrReplaceState(\n      {\n        dest: explicitDest,\n        hash,\n        page: pageNumber,\n        rotation: this.linkService.rotation,\n      },\n      forceReplace\n    );\n\n    if (!this._popStateInProgress) {\n      // Prevent the browser history from updating while the new destination is\n      // being scrolled into view, to avoid potentially inconsistent state.\n      this._popStateInProgress = true;\n      // We defer the resetting of `this._popStateInProgress`, to account for\n      // e.g. zooming occuring when the new destination is being navigated to.\n      Promise.resolve().then(() => {\n        this._popStateInProgress = false;\n      });\n    }\n  }\n\n  /**\n   * Push the current position to the browser history.\n   */\n  pushCurrentPosition() {\n    if (!this._initialized || this._popStateInProgress) {\n      return;\n    }\n    this._tryPushCurrentPosition();\n  }\n\n  /**\n   * Go back one step in the browser history.\n   * NOTE: Avoids navigating away from the document, useful for \"named actions\".\n   */\n  back() {\n    if (!this._initialized || this._popStateInProgress) {\n      return;\n    }\n    const state = window.history.state;\n    if (this._isValidState(state) && state.uid > 0) {\n      window.history.back();\n    }\n  }\n\n  /**\n   * Go forward one step in the browser history.\n   * NOTE: Avoids navigating away from the document, useful for \"named actions\".\n   */\n  forward() {\n    if (!this._initialized || this._popStateInProgress) {\n      return;\n    }\n    const state = window.history.state;\n    if (this._isValidState(state) && state.uid < this._maxUid) {\n      window.history.forward();\n    }\n  }\n\n  /**\n   * @type {boolean} Indicating if the user is currently moving through the\n   *   browser history, useful e.g. for skipping the next 'hashchange' event.\n   */\n  get popStateInProgress() {\n    return (\n      this._initialized &&\n      (this._popStateInProgress || this._blockHashChange > 0)\n    );\n  }\n\n  get initialBookmark() {\n    return this._initialized ? this._initialBookmark : null;\n  }\n\n  get initialRotation() {\n    return this._initialized ? this._initialRotation : null;\n  }\n\n  /**\n   * @private\n   */\n  _pushOrReplaceState(destination, forceReplace = false) {\n    const shouldReplace = forceReplace || !this._destination;\n    const newState = {\n      fingerprint: this._fingerprint,\n      uid: shouldReplace ? this._uid : this._uid + 1,\n      destination,\n    };\n\n    if (\n      typeof PDFJSDev !== \"undefined\" &&\n      PDFJSDev.test(\"CHROME\") &&\n      window.history.state &&\n      window.history.state.chromecomState\n    ) {\n      // history.state.chromecomState is managed by chromecom.js.\n      newState.chromecomState = window.history.state.chromecomState;\n    }\n    this._updateInternalState(destination, newState.uid);\n\n    let newUrl;\n    if (this._updateUrl && destination && destination.hash) {\n      const baseUrl = document.location.href.split(\"#\")[0];\n      // Prevent errors in Firefox.\n      if (!baseUrl.startsWith(\"file://\")) {\n        newUrl = `${baseUrl}#${destination.hash}`;\n      }\n    }\n    if (shouldReplace) {\n      window.history.replaceState(newState, \"\", newUrl);\n    } else {\n      this._maxUid = this._uid;\n      window.history.pushState(newState, \"\", newUrl);\n    }\n\n    if (\n      typeof PDFJSDev !== \"undefined\" &&\n      PDFJSDev.test(\"CHROME\") &&\n      top === window\n    ) {\n      // eslint-disable-next-line no-undef\n      chrome.runtime.sendMessage(\"showPageAction\");\n    }\n  }\n\n  /**\n   * @private\n   */\n  _tryPushCurrentPosition(temporary = false) {\n    if (!this._position) {\n      return;\n    }\n    let position = this._position;\n    if (temporary) {\n      position = Object.assign(Object.create(null), this._position);\n      position.temporary = true;\n    }\n\n    if (!this._destination) {\n      this._pushOrReplaceState(position);\n      return;\n    }\n    if (this._destination.temporary) {\n      // Always replace a previous *temporary* position.\n      this._pushOrReplaceState(position, /* forceReplace = */ true);\n      return;\n    }\n    if (this._destination.hash === position.hash) {\n      return; // The current document position has not changed.\n    }\n    if (\n      !this._destination.page &&\n      (POSITION_UPDATED_THRESHOLD <= 0 ||\n        this._numPositionUpdates <= POSITION_UPDATED_THRESHOLD)\n    ) {\n      // `this._destination` was set through the user changing the hash of\n      // the document. Do not add `this._position` to the browser history,\n      // to avoid \"flooding\" it with lots of (nearly) identical entries,\n      // since we cannot ensure that the document position has changed.\n      return;\n    }\n\n    let forceReplace = false;\n    if (\n      this._destination.page >= position.first &&\n      this._destination.page <= position.page\n    ) {\n      // When the `page` of `this._destination` is still visible, do not\n      // update the browsing history when `this._destination` either:\n      //  - contains an internal destination, since in this case we\n      //    cannot ensure that the document position has actually changed.\n      //  - was set through the user changing the hash of the document.\n      if (this._destination.dest || !this._destination.first) {\n        return;\n      }\n      // To avoid \"flooding\" the browser history, replace the current entry.\n      forceReplace = true;\n    }\n    this._pushOrReplaceState(position, forceReplace);\n  }\n\n  /**\n   * @private\n   */\n  _isValidState(state, checkReload = false) {\n    if (!state) {\n      return false;\n    }\n    if (state.fingerprint !== this._fingerprint) {\n      if (checkReload) {\n        // Potentially accept the history entry, even if the fingerprints don't\n        // match, when the viewer was reloaded (see issue 6847).\n        if (\n          typeof state.fingerprint !== \"string\" ||\n          state.fingerprint.length !== this._fingerprint.length\n        ) {\n          return false;\n        }\n        const [perfEntry] = performance.getEntriesByType(\"navigation\");\n        if (!perfEntry || perfEntry.type !== \"reload\") {\n          return false;\n        }\n      } else {\n        // This should only occur in viewers with support for opening more than\n        // one PDF document, e.g. the GENERIC viewer.\n        return false;\n      }\n    }\n    if (!Number.isInteger(state.uid) || state.uid < 0) {\n      return false;\n    }\n    if (state.destination === null || typeof state.destination !== \"object\") {\n      return false;\n    }\n    return true;\n  }\n\n  /**\n   * @private\n   */\n  _updateInternalState(destination, uid, removeTemporary = false) {\n    if (this._updateViewareaTimeout) {\n      // When updating `this._destination`, make sure that we always wait for\n      // the next 'updateviewarea' event before (potentially) attempting to\n      // push the current position to the browser history.\n      clearTimeout(this._updateViewareaTimeout);\n      this._updateViewareaTimeout = null;\n    }\n    if (removeTemporary && destination && destination.temporary) {\n      // When the `destination` comes from the browser history,\n      // we no longer treat it as a *temporary* position.\n      delete destination.temporary;\n    }\n    this._destination = destination;\n    this._uid = uid;\n    // This should always be reset when `this._destination` is updated.\n    this._numPositionUpdates = 0;\n  }\n\n  /**\n   * @private\n   */\n  _parseCurrentHash(checkNameddest = false) {\n    const hash = unescape(getCurrentHash()).substring(1);\n    const params = parseQueryString(hash);\n\n    const nameddest = params.nameddest || \"\";\n    let page = params.page | 0;\n\n    if (\n      !(\n        Number.isInteger(page) &&\n        page > 0 &&\n        page <= this.linkService.pagesCount\n      ) ||\n      (checkNameddest && nameddest.length > 0)\n    ) {\n      page = null;\n    }\n    return { hash, page, rotation: this.linkService.rotation };\n  }\n\n  /**\n   * @private\n   */\n  _updateViewarea({ location }) {\n    if (this._updateViewareaTimeout) {\n      clearTimeout(this._updateViewareaTimeout);\n      this._updateViewareaTimeout = null;\n    }\n\n    this._position = {\n      hash: this._isViewerInPresentationMode\n        ? `page=${location.pageNumber}`\n        : location.pdfOpenParams.substring(1),\n      page: this.linkService.page,\n      first: location.pageNumber,\n      rotation: location.rotation,\n    };\n\n    if (this._popStateInProgress) {\n      return;\n    }\n\n    if (\n      POSITION_UPDATED_THRESHOLD > 0 &&\n      this._isPagesLoaded &&\n      this._destination &&\n      !this._destination.page\n    ) {\n      // If the current destination was set through the user changing the hash\n      // of the document, we will usually not try to push the current position\n      // to the browser history; see `this._tryPushCurrentPosition()`.\n      //\n      // To prevent `this._tryPushCurrentPosition()` from effectively being\n      // reduced to a no-op in this case, we will assume that the position\n      // *did* in fact change if the 'updateviewarea' event was dispatched\n      // more than `POSITION_UPDATED_THRESHOLD` times.\n      this._numPositionUpdates++;\n    }\n\n    if (UPDATE_VIEWAREA_TIMEOUT > 0) {\n      // When closing the browser, a 'pagehide' event will be dispatched which\n      // *should* allow us to push the current position to the browser history.\n      // In practice, it seems that the event is arriving too late in order for\n      // the session history to be successfully updated.\n      // (For additional details, please refer to the discussion in\n      //  https://bugzilla.mozilla.org/show_bug.cgi?id=1153393.)\n      //\n      // To workaround this we attempt to *temporarily* add the current position\n      // to the browser history only when the viewer is *idle*,\n      // i.e. when scrolling and/or zooming does not occur.\n      //\n      // PLEASE NOTE: It's absolutely imperative that the browser history is\n      // *not* updated too often, since that would render the viewer more or\n      // less unusable. Hence the use of a timeout to delay the update until\n      // the viewer has been idle for `UPDATE_VIEWAREA_TIMEOUT` milliseconds.\n      this._updateViewareaTimeout = setTimeout(() => {\n        if (!this._popStateInProgress) {\n          this._tryPushCurrentPosition(/* temporary = */ true);\n        }\n        this._updateViewareaTimeout = null;\n      }, UPDATE_VIEWAREA_TIMEOUT);\n    }\n  }\n\n  /**\n   * @private\n   */\n  _popState({ state }) {\n    const newHash = getCurrentHash(),\n      hashChanged = this._currentHash !== newHash;\n    this._currentHash = newHash;\n\n    if (\n      (typeof PDFJSDev !== \"undefined\" &&\n        PDFJSDev.test(\"CHROME\") &&\n        state &&\n        state.chromecomState &&\n        !this._isValidState(state)) ||\n      !state\n    ) {\n      // This case corresponds to the user changing the hash of the document.\n      this._uid++;\n\n      const { hash, page, rotation } = this._parseCurrentHash();\n      this._pushOrReplaceState(\n        { hash, page, rotation },\n        /* forceReplace = */ true\n      );\n      return;\n    }\n    if (!this._isValidState(state)) {\n      // This should only occur in viewers with support for opening more than\n      // one PDF document, e.g. the GENERIC viewer.\n      return;\n    }\n\n    // Prevent the browser history from updating until the new destination,\n    // as stored in the browser history, has been scrolled into view.\n    this._popStateInProgress = true;\n\n    if (hashChanged) {\n      // When the hash changed, implying that the 'popstate' event will be\n      // followed by a 'hashchange' event, then we do *not* want to update the\n      // browser history when handling the 'hashchange' event (in web/app.js)\n      // since that would *overwrite* the new destination navigated to below.\n      //\n      // To avoid accidentally disabling all future user-initiated hash changes,\n      // if there's e.g. another 'hashchange' listener that stops the event\n      // propagation, we make sure to always force-reset `this._blockHashChange`\n      // after `HASH_CHANGE_TIMEOUT` milliseconds have passed.\n      this._blockHashChange++;\n      waitOnEventOrTimeout({\n        target: window,\n        name: \"hashchange\",\n        delay: HASH_CHANGE_TIMEOUT,\n      }).then(() => {\n        this._blockHashChange--;\n      });\n    }\n\n    // Navigate to the new destination.\n    const destination = state.destination;\n    this._updateInternalState(\n      destination,\n      state.uid,\n      /* removeTemporary = */ true\n    );\n    if (this._uid > this._maxUid) {\n      this._maxUid = this._uid;\n    }\n\n    if (isValidRotation(destination.rotation)) {\n      this.linkService.rotation = destination.rotation;\n    }\n    if (destination.dest) {\n      this.linkService.navigateTo(destination.dest);\n    } else if (destination.hash) {\n      this.linkService.setHash(destination.hash);\n    } else if (destination.page) {\n      // Fallback case; shouldn't be necessary, but better safe than sorry.\n      this.linkService.page = destination.page;\n    }\n\n    // Since `PDFLinkService.navigateTo` is asynchronous, we thus defer the\n    // resetting of `this._popStateInProgress` slightly.\n    Promise.resolve().then(() => {\n      this._popStateInProgress = false;\n    });\n  }\n\n  /**\n   * @private\n   */\n  _pageHide() {\n    // Attempt to push the `this._position` into the browser history when\n    // navigating away from the document. This is *only* done if the history\n    // is empty/temporary, since otherwise an existing browser history entry\n    // will end up being overwritten (given that new entries cannot be pushed\n    // into the browser history when the 'unload' event has already fired).\n    if (!this._destination || this._destination.temporary) {\n      this._tryPushCurrentPosition();\n    }\n  }\n\n  /**\n   * @private\n   */\n  _bindEvents() {\n    if (this._boundEvents) {\n      return; // The event listeners were already added.\n    }\n    this._boundEvents = {\n      updateViewarea: this._updateViewarea.bind(this),\n      popState: this._popState.bind(this),\n      pageHide: this._pageHide.bind(this),\n    };\n\n    this.eventBus._on(\"updateviewarea\", this._boundEvents.updateViewarea);\n    window.addEventListener(\"popstate\", this._boundEvents.popState);\n    window.addEventListener(\"pagehide\", this._boundEvents.pageHide);\n  }\n\n  /**\n   * @private\n   */\n  _unbindEvents() {\n    if (!this._boundEvents) {\n      return; // The event listeners were already removed.\n    }\n    this.eventBus._off(\"updateviewarea\", this._boundEvents.updateViewarea);\n    window.removeEventListener(\"popstate\", this._boundEvents.popState);\n    window.removeEventListener(\"pagehide\", this._boundEvents.pageHide);\n\n    this._boundEvents = null;\n  }\n}\n\nfunction isDestHashesEqual(destHash, pushHash) {\n  if (typeof destHash !== \"string\" || typeof pushHash !== \"string\") {\n    return false;\n  }\n  if (destHash === pushHash) {\n    return true;\n  }\n  const { nameddest } = parseQueryString(destHash);\n  if (nameddest === pushHash) {\n    return true;\n  }\n  return false;\n}\n\nfunction isDestArraysEqual(firstDest, secondDest) {\n  function isEntryEqual(first, second) {\n    if (typeof first !== typeof second) {\n      return false;\n    }\n    if (Array.isArray(first) || Array.isArray(second)) {\n      return false;\n    }\n    if (first !== null && typeof first === \"object\" && second !== null) {\n      if (Object.keys(first).length !== Object.keys(second).length) {\n        return false;\n      }\n      for (const key in first) {\n        if (!isEntryEqual(first[key], second[key])) {\n          return false;\n        }\n      }\n      return true;\n    }\n    return first === second || (Number.isNaN(first) && Number.isNaN(second));\n  }\n\n  if (!(Array.isArray(firstDest) && Array.isArray(secondDest))) {\n    return false;\n  }\n  if (firstDest.length !== secondDest.length) {\n    return false;\n  }\n  for (let i = 0, ii = firstDest.length; i < ii; i++) {\n    if (!isEntryEqual(firstDest[i], secondDest[i])) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport { PDFHistory, isDestHashesEqual, isDestArraysEqual };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  approximateFraction,\n  CSS_UNITS,\n  DEFAULT_SCALE,\n  getOutputScale,\n  NullL10n,\n  RendererType,\n  roundToDivide,\n  TextLayerMode,\n} from \"./ui_utils.js\";\nimport {\n  createPromiseCapability,\n  RenderingCancelledException,\n  SVGGraphics,\n} from \"pdfjs-lib\";\nimport { RenderingStates } from \"./pdf_rendering_queue.js\";\nimport { viewerCompatibilityParams } from \"./viewer_compatibility.js\";\n\n/**\n * @typedef {Object} PDFPageViewOptions\n * @property {HTMLDivElement} container - The viewer element.\n * @property {EventBus} eventBus - The application event bus.\n * @property {number} id - The page unique ID (normally its number).\n * @property {number} scale - The page scale display.\n * @property {PageViewport} defaultViewport - The page viewport.\n * @property {AnnotationStorage} [annotationStorage] - Storage for annotation\n *   data in forms. The default value is `null`.\n * @property {Promise<OptionalContentConfig>} [optionalContentConfigPromise] -\n *   A promise that is resolved with an {@link OptionalContentConfig} instance.\n *   The default value is `null`.\n * @property {PDFRenderingQueue} renderingQueue - The rendering queue object.\n * @property {IPDFTextLayerFactory} textLayerFactory\n * @property {number} [textLayerMode] - Controls if the text layer used for\n *   selection and searching is created, and if the improved text selection\n *   behaviour is enabled. The constants from {TextLayerMode} should be used.\n *   The default value is `TextLayerMode.ENABLE`.\n * @property {IPDFAnnotationLayerFactory} annotationLayerFactory\n * @property {string} [imageResourcesPath] - Path for image resources, mainly\n *   for annotation icons. Include trailing slash.\n * @property {boolean} renderInteractiveForms - Turns on rendering of\n *   interactive form elements. The default value is `true`.\n * @property {string} renderer - 'canvas' or 'svg'. The default is 'canvas'.\n * @property {boolean} [enableWebGL] - Enables WebGL accelerated rendering for\n *   some operations. The default value is `false`.\n * @property {boolean} [useOnlyCssZoom] - Enables CSS only zooming. The default\n *   value is `false`.\n * @property {number} [maxCanvasPixels] - The maximum supported canvas size in\n *   total pixels, i.e. width * height. Use -1 for no limit. The default value\n *   is 4096 * 4096 (16 mega-pixels).\n * @property {IL10n} l10n - Localization service.\n */\n\nconst MAX_CANVAS_PIXELS = viewerCompatibilityParams.maxCanvasPixels || 16777216;\n\n/**\n * @implements {IRenderableView}\n */\nclass PDFPageView {\n  /**\n   * @param {PDFPageViewOptions} options\n   */\n  constructor(options) {\n    const container = options.container;\n    const defaultViewport = options.defaultViewport;\n\n    this.id = options.id;\n    this.renderingId = \"page\" + this.id;\n\n    this.pdfPage = null;\n    this.pageLabel = null;\n    this.rotation = 0;\n    this.scale = options.scale || DEFAULT_SCALE;\n    this.viewport = defaultViewport;\n    this.pdfPageRotate = defaultViewport.rotation;\n    this._annotationStorage = options.annotationStorage || null;\n    this._optionalContentConfigPromise =\n      options.optionalContentConfigPromise || null;\n    this.hasRestrictedScaling = false;\n    this.textLayerMode = Number.isInteger(options.textLayerMode)\n      ? options.textLayerMode\n      : TextLayerMode.ENABLE;\n    this.imageResourcesPath = options.imageResourcesPath || \"\";\n    this.renderInteractiveForms =\n      typeof options.renderInteractiveForms === \"boolean\"\n        ? options.renderInteractiveForms\n        : true;\n    this.useOnlyCssZoom = options.useOnlyCssZoom || false;\n    this.maxCanvasPixels = options.maxCanvasPixels || MAX_CANVAS_PIXELS;\n\n    this.eventBus = options.eventBus;\n    this.renderingQueue = options.renderingQueue;\n    this.textLayerFactory = options.textLayerFactory;\n    this.annotationLayerFactory = options.annotationLayerFactory;\n    this.renderer = options.renderer || RendererType.CANVAS;\n    this.enableWebGL = options.enableWebGL || false;\n    this.l10n = options.l10n || NullL10n;\n\n    this.paintTask = null;\n    this.paintedViewportMap = new WeakMap();\n    this.renderingState = RenderingStates.INITIAL;\n    this.resume = null;\n    this.error = null;\n\n    this.annotationLayer = null;\n    this.textLayer = null;\n    this.zoomLayer = null;\n\n    const div = document.createElement(\"div\");\n    div.className = \"page\";\n    div.style.width = Math.floor(this.viewport.width) + \"px\";\n    div.style.height = Math.floor(this.viewport.height) + \"px\";\n    div.setAttribute(\"data-page-number\", this.id);\n    this.div = div;\n\n    container.appendChild(div);\n  }\n\n  setPdfPage(pdfPage) {\n    this.pdfPage = pdfPage;\n    this.pdfPageRotate = pdfPage.rotate;\n\n    const totalRotation = (this.rotation + this.pdfPageRotate) % 360;\n    this.viewport = pdfPage.getViewport({\n      scale: this.scale * CSS_UNITS,\n      rotation: totalRotation,\n    });\n    this.stats = pdfPage.stats;\n    this.reset();\n  }\n\n  destroy() {\n    this.reset();\n    if (this.pdfPage) {\n      this.pdfPage.cleanup();\n    }\n  }\n\n  /**\n   * @private\n   */\n  async _renderAnnotationLayer() {\n    let error = null;\n    try {\n      await this.annotationLayer.render(this.viewport, \"display\");\n    } catch (ex) {\n      error = ex;\n    } finally {\n      this.eventBus.dispatch(\"annotationlayerrendered\", {\n        source: this,\n        pageNumber: this.id,\n        error,\n      });\n    }\n  }\n\n  /**\n   * @private\n   */\n  _resetZoomLayer(removeFromDOM = false) {\n    if (!this.zoomLayer) {\n      return;\n    }\n    const zoomLayerCanvas = this.zoomLayer.firstChild;\n    this.paintedViewportMap.delete(zoomLayerCanvas);\n    // Zeroing the width and height causes Firefox to release graphics\n    // resources immediately, which can greatly reduce memory consumption.\n    zoomLayerCanvas.width = 0;\n    zoomLayerCanvas.height = 0;\n\n    if (removeFromDOM) {\n      // Note: `ChildNode.remove` doesn't throw if the parent node is undefined.\n      this.zoomLayer.remove();\n    }\n    this.zoomLayer = null;\n  }\n\n  reset(keepZoomLayer = false, keepAnnotations = false) {\n    this.cancelRendering(keepAnnotations);\n    this.renderingState = RenderingStates.INITIAL;\n\n    const div = this.div;\n    div.style.width = Math.floor(this.viewport.width) + \"px\";\n    div.style.height = Math.floor(this.viewport.height) + \"px\";\n\n    const childNodes = div.childNodes;\n    const currentZoomLayerNode = (keepZoomLayer && this.zoomLayer) || null;\n    const currentAnnotationNode =\n      (keepAnnotations && this.annotationLayer && this.annotationLayer.div) ||\n      null;\n    for (let i = childNodes.length - 1; i >= 0; i--) {\n      const node = childNodes[i];\n      if (currentZoomLayerNode === node || currentAnnotationNode === node) {\n        continue;\n      }\n      div.removeChild(node);\n    }\n    div.removeAttribute(\"data-loaded\");\n\n    if (currentAnnotationNode) {\n      // Hide the annotation layer until all elements are resized\n      // so they are not displayed on the already resized page.\n      this.annotationLayer.hide();\n    } else if (this.annotationLayer) {\n      this.annotationLayer.cancel();\n      this.annotationLayer = null;\n    }\n\n    if (!currentZoomLayerNode) {\n      if (this.canvas) {\n        this.paintedViewportMap.delete(this.canvas);\n        // Zeroing the width and height causes Firefox to release graphics\n        // resources immediately, which can greatly reduce memory consumption.\n        this.canvas.width = 0;\n        this.canvas.height = 0;\n        delete this.canvas;\n      }\n      this._resetZoomLayer();\n    }\n    if (this.svg) {\n      this.paintedViewportMap.delete(this.svg);\n      delete this.svg;\n    }\n\n    this.loadingIconDiv = document.createElement(\"div\");\n    this.loadingIconDiv.className = \"loadingIcon\";\n    div.appendChild(this.loadingIconDiv);\n  }\n\n  update(scale, rotation, optionalContentConfigPromise = null) {\n    this.scale = scale || this.scale;\n    // The rotation may be zero.\n    if (typeof rotation !== \"undefined\") {\n      this.rotation = rotation;\n    }\n    if (optionalContentConfigPromise instanceof Promise) {\n      this._optionalContentConfigPromise = optionalContentConfigPromise;\n    }\n\n    const totalRotation = (this.rotation + this.pdfPageRotate) % 360;\n    this.viewport = this.viewport.clone({\n      scale: this.scale * CSS_UNITS,\n      rotation: totalRotation,\n    });\n\n    if (this.svg) {\n      this.cssTransform(this.svg, true);\n\n      this.eventBus.dispatch(\"pagerendered\", {\n        source: this,\n        pageNumber: this.id,\n        cssTransform: true,\n        timestamp: performance.now(),\n      });\n      return;\n    }\n\n    let isScalingRestricted = false;\n    if (this.canvas && this.maxCanvasPixels > 0) {\n      const outputScale = this.outputScale;\n      if (\n        ((Math.floor(this.viewport.width) * outputScale.sx) | 0) *\n          ((Math.floor(this.viewport.height) * outputScale.sy) | 0) >\n        this.maxCanvasPixels\n      ) {\n        isScalingRestricted = true;\n      }\n    }\n\n    if (this.canvas) {\n      if (\n        this.useOnlyCssZoom ||\n        (this.hasRestrictedScaling && isScalingRestricted)\n      ) {\n        this.cssTransform(this.canvas, true);\n\n        this.eventBus.dispatch(\"pagerendered\", {\n          source: this,\n          pageNumber: this.id,\n          cssTransform: true,\n          timestamp: performance.now(),\n        });\n        return;\n      }\n      if (!this.zoomLayer && !this.canvas.hasAttribute(\"hidden\")) {\n        this.zoomLayer = this.canvas.parentNode;\n        this.zoomLayer.style.position = \"absolute\";\n      }\n    }\n    if (this.zoomLayer) {\n      this.cssTransform(this.zoomLayer.firstChild);\n    }\n    this.reset(/* keepZoomLayer = */ true, /* keepAnnotations = */ true);\n  }\n\n  /**\n   * PLEASE NOTE: Most likely you want to use the `this.reset()` method,\n   *              rather than calling this one directly.\n   */\n  cancelRendering(keepAnnotations = false) {\n    if (this.paintTask) {\n      this.paintTask.cancel();\n      this.paintTask = null;\n    }\n    this.resume = null;\n\n    if (this.textLayer) {\n      this.textLayer.cancel();\n      this.textLayer = null;\n    }\n    if (!keepAnnotations && this.annotationLayer) {\n      this.annotationLayer.cancel();\n      this.annotationLayer = null;\n    }\n  }\n\n  cssTransform(target, redrawAnnotations = false) {\n    // Scale target (canvas or svg), its wrapper and page container.\n    const width = this.viewport.width;\n    const height = this.viewport.height;\n    const div = this.div;\n    target.style.width = target.parentNode.style.width = div.style.width =\n      Math.floor(width) + \"px\";\n    target.style.height = target.parentNode.style.height = div.style.height =\n      Math.floor(height) + \"px\";\n    // The canvas may have been originally rotated; rotate relative to that.\n    const relativeRotation =\n      this.viewport.rotation - this.paintedViewportMap.get(target).rotation;\n    const absRotation = Math.abs(relativeRotation);\n    let scaleX = 1,\n      scaleY = 1;\n    if (absRotation === 90 || absRotation === 270) {\n      // Scale x and y because of the rotation.\n      scaleX = height / width;\n      scaleY = width / height;\n    }\n    const cssTransform =\n      \"rotate(\" +\n      relativeRotation +\n      \"deg) \" +\n      \"scale(\" +\n      scaleX +\n      \",\" +\n      scaleY +\n      \")\";\n    target.style.transform = cssTransform;\n\n    if (this.textLayer) {\n      // Rotating the text layer is more complicated since the divs inside the\n      // the text layer are rotated.\n      // TODO: This could probably be simplified by drawing the text layer in\n      // one orientation and then rotating overall.\n      const textLayerViewport = this.textLayer.viewport;\n      const textRelativeRotation =\n        this.viewport.rotation - textLayerViewport.rotation;\n      const textAbsRotation = Math.abs(textRelativeRotation);\n      let scale = width / textLayerViewport.width;\n      if (textAbsRotation === 90 || textAbsRotation === 270) {\n        scale = width / textLayerViewport.height;\n      }\n      const textLayerDiv = this.textLayer.textLayerDiv;\n      let transX, transY;\n      switch (textAbsRotation) {\n        case 0:\n          transX = transY = 0;\n          break;\n        case 90:\n          transX = 0;\n          transY = \"-\" + textLayerDiv.style.height;\n          break;\n        case 180:\n          transX = \"-\" + textLayerDiv.style.width;\n          transY = \"-\" + textLayerDiv.style.height;\n          break;\n        case 270:\n          transX = \"-\" + textLayerDiv.style.width;\n          transY = 0;\n          break;\n        default:\n          console.error(\"Bad rotation value.\");\n          break;\n      }\n\n      textLayerDiv.style.transform =\n        \"rotate(\" +\n        textAbsRotation +\n        \"deg) \" +\n        \"scale(\" +\n        scale +\n        \", \" +\n        scale +\n        \") \" +\n        \"translate(\" +\n        transX +\n        \", \" +\n        transY +\n        \")\";\n      textLayerDiv.style.transformOrigin = \"0% 0%\";\n    }\n\n    if (redrawAnnotations && this.annotationLayer) {\n      this._renderAnnotationLayer();\n    }\n  }\n\n  get width() {\n    return this.viewport.width;\n  }\n\n  get height() {\n    return this.viewport.height;\n  }\n\n  getPagePoint(x, y) {\n    return this.viewport.convertToPdfPoint(x, y);\n  }\n\n  draw() {\n    if (this.renderingState !== RenderingStates.INITIAL) {\n      console.error(\"Must be in new state before drawing\");\n      this.reset(); // Ensure that we reset all state to prevent issues.\n    }\n    const { div, pdfPage } = this;\n\n    if (!pdfPage) {\n      this.renderingState = RenderingStates.FINISHED;\n\n      if (this.loadingIconDiv) {\n        div.removeChild(this.loadingIconDiv);\n        delete this.loadingIconDiv;\n      }\n      return Promise.reject(new Error(\"pdfPage is not loaded\"));\n    }\n\n    this.renderingState = RenderingStates.RUNNING;\n\n    // Wrap the canvas so that if it has a CSS transform for high DPI the\n    // overflow will be hidden in Firefox.\n    const canvasWrapper = document.createElement(\"div\");\n    canvasWrapper.style.width = div.style.width;\n    canvasWrapper.style.height = div.style.height;\n    canvasWrapper.classList.add(\"canvasWrapper\");\n\n    if (this.annotationLayer && this.annotationLayer.div) {\n      // The annotation layer needs to stay on top.\n      div.insertBefore(canvasWrapper, this.annotationLayer.div);\n    } else {\n      div.appendChild(canvasWrapper);\n    }\n\n    let textLayer = null;\n    if (this.textLayerMode !== TextLayerMode.DISABLE && this.textLayerFactory) {\n      const textLayerDiv = document.createElement(\"div\");\n      textLayerDiv.className = \"textLayer\";\n      textLayerDiv.style.width = canvasWrapper.style.width;\n      textLayerDiv.style.height = canvasWrapper.style.height;\n      if (this.annotationLayer && this.annotationLayer.div) {\n        // The annotation layer needs to stay on top.\n        div.insertBefore(textLayerDiv, this.annotationLayer.div);\n      } else {\n        div.appendChild(textLayerDiv);\n      }\n\n      textLayer = this.textLayerFactory.createTextLayerBuilder(\n        textLayerDiv,\n        this.id - 1,\n        this.viewport,\n        this.textLayerMode === TextLayerMode.ENABLE_ENHANCE,\n        this.eventBus\n      );\n    }\n    this.textLayer = textLayer;\n\n    let renderContinueCallback = null;\n    if (this.renderingQueue) {\n      renderContinueCallback = cont => {\n        if (!this.renderingQueue.isHighestPriority(this)) {\n          this.renderingState = RenderingStates.PAUSED;\n          this.resume = () => {\n            this.renderingState = RenderingStates.RUNNING;\n            cont();\n          };\n          return;\n        }\n        cont();\n      };\n    }\n\n    const finishPaintTask = async error => {\n      // The paintTask may have been replaced by a new one, so only remove\n      // the reference to the paintTask if it matches the one that is\n      // triggering this callback.\n      if (paintTask === this.paintTask) {\n        this.paintTask = null;\n      }\n\n      if (error instanceof RenderingCancelledException) {\n        this.error = null;\n        return;\n      }\n\n      this.renderingState = RenderingStates.FINISHED;\n\n      if (this.loadingIconDiv) {\n        div.removeChild(this.loadingIconDiv);\n        delete this.loadingIconDiv;\n      }\n      this._resetZoomLayer(/* removeFromDOM = */ true);\n\n      this.error = error;\n      this.stats = pdfPage.stats;\n\n      this.eventBus.dispatch(\"pagerendered\", {\n        source: this,\n        pageNumber: this.id,\n        cssTransform: false,\n        timestamp: performance.now(),\n      });\n\n      if (error) {\n        throw error;\n      }\n    };\n\n    const paintTask =\n      this.renderer === RendererType.SVG\n        ? this.paintOnSvg(canvasWrapper)\n        : this.paintOnCanvas(canvasWrapper);\n    paintTask.onRenderContinue = renderContinueCallback;\n    this.paintTask = paintTask;\n\n    const resultPromise = paintTask.promise.then(\n      function () {\n        return finishPaintTask(null).then(function () {\n          if (textLayer) {\n            const readableStream = pdfPage.streamTextContent({\n              normalizeWhitespace: true,\n            });\n            textLayer.setTextContentStream(readableStream);\n            textLayer.render();\n          }\n        });\n      },\n      function (reason) {\n        return finishPaintTask(reason);\n      }\n    );\n\n    if (this.annotationLayerFactory) {\n      if (!this.annotationLayer) {\n        this.annotationLayer = this.annotationLayerFactory.createAnnotationLayerBuilder(\n          div,\n          pdfPage,\n          this._annotationStorage,\n          this.imageResourcesPath,\n          this.renderInteractiveForms,\n          this.l10n\n        );\n      }\n      this._renderAnnotationLayer();\n    }\n    div.setAttribute(\"data-loaded\", true);\n\n    this.eventBus.dispatch(\"pagerender\", {\n      source: this,\n      pageNumber: this.id,\n    });\n    return resultPromise;\n  }\n\n  paintOnCanvas(canvasWrapper) {\n    const renderCapability = createPromiseCapability();\n    const result = {\n      promise: renderCapability.promise,\n      onRenderContinue(cont) {\n        cont();\n      },\n      cancel() {\n        renderTask.cancel();\n      },\n    };\n\n    const viewport = this.viewport;\n    const canvas = document.createElement(\"canvas\");\n    this.l10n\n      .get(\"page_canvas\", { page: this.id }, \"Page {{page}}\")\n      .then(msg => {\n        canvas.setAttribute(\"aria-label\", msg);\n      });\n\n    // Keep the canvas hidden until the first draw callback, or until drawing\n    // is complete when `!this.renderingQueue`, to prevent black flickering.\n    canvas.setAttribute(\"hidden\", \"hidden\");\n    let isCanvasHidden = true;\n    const showCanvas = function () {\n      if (isCanvasHidden) {\n        canvas.removeAttribute(\"hidden\");\n        isCanvasHidden = false;\n      }\n    };\n\n    canvasWrapper.appendChild(canvas);\n    this.canvas = canvas;\n\n    if (\n      typeof PDFJSDev === \"undefined\" ||\n      PDFJSDev.test(\"MOZCENTRAL || GENERIC\")\n    ) {\n      canvas.mozOpaque = true;\n    }\n\n    const ctx = canvas.getContext(\"2d\", { alpha: false });\n    const outputScale = getOutputScale(ctx);\n    this.outputScale = outputScale;\n\n    if (this.useOnlyCssZoom) {\n      const actualSizeViewport = viewport.clone({ scale: CSS_UNITS });\n      // Use a scale that makes the canvas have the originally intended size\n      // of the page.\n      outputScale.sx *= actualSizeViewport.width / viewport.width;\n      outputScale.sy *= actualSizeViewport.height / viewport.height;\n      outputScale.scaled = true;\n    }\n\n    if (this.maxCanvasPixels > 0) {\n      const pixelsInViewport = viewport.width * viewport.height;\n      const maxScale = Math.sqrt(this.maxCanvasPixels / pixelsInViewport);\n      if (outputScale.sx > maxScale || outputScale.sy > maxScale) {\n        outputScale.sx = maxScale;\n        outputScale.sy = maxScale;\n        outputScale.scaled = true;\n        this.hasRestrictedScaling = true;\n      } else {\n        this.hasRestrictedScaling = false;\n      }\n    }\n\n    const sfx = approximateFraction(outputScale.sx);\n    const sfy = approximateFraction(outputScale.sy);\n    canvas.width = roundToDivide(viewport.width * outputScale.sx, sfx[0]);\n    canvas.height = roundToDivide(viewport.height * outputScale.sy, sfy[0]);\n    canvas.style.width = roundToDivide(viewport.width, sfx[1]) + \"px\";\n    canvas.style.height = roundToDivide(viewport.height, sfy[1]) + \"px\";\n    // Add the viewport so it's known what it was originally drawn with.\n    this.paintedViewportMap.set(canvas, viewport);\n\n    // Rendering area\n    const transform = !outputScale.scaled\n      ? null\n      : [outputScale.sx, 0, 0, outputScale.sy, 0, 0];\n    const renderContext = {\n      canvasContext: ctx,\n      transform,\n      viewport: this.viewport,\n      enableWebGL: this.enableWebGL,\n      renderInteractiveForms: this.renderInteractiveForms,\n      optionalContentConfigPromise: this._optionalContentConfigPromise,\n    };\n    const renderTask = this.pdfPage.render(renderContext);\n    renderTask.onContinue = function (cont) {\n      showCanvas();\n      if (result.onRenderContinue) {\n        result.onRenderContinue(cont);\n      } else {\n        cont();\n      }\n    };\n\n    renderTask.promise.then(\n      function () {\n        showCanvas();\n        renderCapability.resolve(undefined);\n      },\n      function (error) {\n        showCanvas();\n        renderCapability.reject(error);\n      }\n    );\n    return result;\n  }\n\n  paintOnSvg(wrapper) {\n    if (\n      typeof PDFJSDev !== \"undefined\" &&\n      PDFJSDev.test(\"MOZCENTRAL || CHROME\")\n    ) {\n      // Return a mock object, to prevent errors such as e.g.\n      // \"TypeError: paintTask.promise is undefined\".\n      return {\n        promise: Promise.reject(new Error(\"SVG rendering is not supported.\")),\n        onRenderContinue(cont) {},\n        cancel() {},\n      };\n    }\n\n    let cancelled = false;\n    const ensureNotCancelled = () => {\n      if (cancelled) {\n        throw new RenderingCancelledException(\n          `Rendering cancelled, page ${this.id}`,\n          \"svg\"\n        );\n      }\n    };\n\n    const pdfPage = this.pdfPage;\n    const actualSizeViewport = this.viewport.clone({ scale: CSS_UNITS });\n    const promise = pdfPage.getOperatorList().then(opList => {\n      ensureNotCancelled();\n      const svgGfx = new SVGGraphics(pdfPage.commonObjs, pdfPage.objs);\n      return svgGfx.getSVG(opList, actualSizeViewport).then(svg => {\n        ensureNotCancelled();\n        this.svg = svg;\n        this.paintedViewportMap.set(svg, actualSizeViewport);\n\n        svg.style.width = wrapper.style.width;\n        svg.style.height = wrapper.style.height;\n        this.renderingState = RenderingStates.FINISHED;\n        wrapper.appendChild(svg);\n      });\n    });\n\n    return {\n      promise,\n      onRenderContinue(cont) {\n        cont();\n      },\n      cancel() {\n        cancelled = true;\n      },\n    };\n  }\n\n  /**\n   * @param {string|null} label\n   */\n  setPageLabel(label) {\n    this.pageLabel = typeof label === \"string\" ? label : null;\n\n    if (this.pageLabel !== null) {\n      this.div.setAttribute(\"data-page-label\", this.pageLabel);\n    } else {\n      this.div.removeAttribute(\"data-page-label\");\n    }\n  }\n}\n\nexport { PDFPageView };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst CLEANUP_TIMEOUT = 30000;\n\nconst RenderingStates = {\n  INITIAL: 0,\n  RUNNING: 1,\n  PAUSED: 2,\n  FINISHED: 3,\n};\n\n/**\n * Controls rendering of the views for pages and thumbnails.\n */\nclass PDFRenderingQueue {\n  constructor() {\n    this.pdfViewer = null;\n    this.pdfThumbnailViewer = null;\n    this.onIdle = null;\n    this.highestPriorityPage = null;\n    this.idleTimeout = null;\n    this.printing = false;\n    this.isThumbnailViewEnabled = false;\n  }\n\n  /**\n   * @param {PDFViewer} pdfViewer\n   */\n  setViewer(pdfViewer) {\n    this.pdfViewer = pdfViewer;\n  }\n\n  /**\n   * @param {PDFThumbnailViewer} pdfThumbnailViewer\n   */\n  setThumbnailViewer(pdfThumbnailViewer) {\n    this.pdfThumbnailViewer = pdfThumbnailViewer;\n  }\n\n  /**\n   * @param {IRenderableView} view\n   * @returns {boolean}\n   */\n  isHighestPriority(view) {\n    return this.highestPriorityPage === view.renderingId;\n  }\n\n  /**\n   * @param {Object} currentlyVisiblePages\n   */\n  renderHighestPriority(currentlyVisiblePages) {\n    if (this.idleTimeout) {\n      clearTimeout(this.idleTimeout);\n      this.idleTimeout = null;\n    }\n\n    // Pages have a higher priority than thumbnails, so check them first.\n    if (this.pdfViewer.forceRendering(currentlyVisiblePages)) {\n      return;\n    }\n    // No pages needed rendering, so check thumbnails.\n    if (this.pdfThumbnailViewer && this.isThumbnailViewEnabled) {\n      if (this.pdfThumbnailViewer.forceRendering()) {\n        return;\n      }\n    }\n\n    if (this.printing) {\n      // If printing is currently ongoing do not reschedule cleanup.\n      return;\n    }\n\n    if (this.onIdle) {\n      this.idleTimeout = setTimeout(this.onIdle.bind(this), CLEANUP_TIMEOUT);\n    }\n  }\n\n  /**\n   * @param {Object} visible\n   * @param {Array} views\n   * @param {boolean} scrolledDown\n   */\n  getHighestPriority(visible, views, scrolledDown) {\n    /**\n     * The state has changed. Figure out which page has the highest priority to\n     * render next (if any).\n     *\n     * Priority:\n     * 1. visible pages\n     * 2. if last scrolled down, the page after the visible pages, or\n     *    if last scrolled up, the page before the visible pages\n     */\n    const visibleViews = visible.views;\n\n    const numVisible = visibleViews.length;\n    if (numVisible === 0) {\n      return null;\n    }\n    for (let i = 0; i < numVisible; ++i) {\n      const view = visibleViews[i].view;\n      if (!this.isViewFinished(view)) {\n        return view;\n      }\n    }\n\n    // All the visible views have rendered; try to render next/previous pages.\n    if (scrolledDown) {\n      const nextPageIndex = visible.last.id;\n      // IDs start at 1, so no need to add 1.\n      if (views[nextPageIndex] && !this.isViewFinished(views[nextPageIndex])) {\n        return views[nextPageIndex];\n      }\n    } else {\n      const previousPageIndex = visible.first.id - 2;\n      if (\n        views[previousPageIndex] &&\n        !this.isViewFinished(views[previousPageIndex])\n      ) {\n        return views[previousPageIndex];\n      }\n    }\n    // Everything that needs to be rendered has been.\n    return null;\n  }\n\n  /**\n   * @param {IRenderableView} view\n   * @returns {boolean}\n   */\n  isViewFinished(view) {\n    return view.renderingState === RenderingStates.FINISHED;\n  }\n\n  /**\n   * Render a page or thumbnail view. This calls the appropriate function\n   * based on the views state. If the view is already rendered it will return\n   * `false`.\n   *\n   * @param {IRenderableView} view\n   */\n  renderView(view) {\n    switch (view.renderingState) {\n      case RenderingStates.FINISHED:\n        return false;\n      case RenderingStates.PAUSED:\n        this.highestPriorityPage = view.renderingId;\n        view.resume();\n        break;\n      case RenderingStates.RUNNING:\n        this.highestPriorityPage = view.renderingId;\n        break;\n      case RenderingStates.INITIAL:\n        this.highestPriorityPage = view.renderingId;\n        view\n          .draw()\n          .finally(() => {\n            this.renderHighestPriority();\n          })\n          .catch(reason => {\n            console.error(`renderView: \"${reason}\"`);\n          });\n        break;\n    }\n    return true;\n  }\n}\n\nexport { RenderingStates, PDFRenderingQueue };\n","/* Copyright 2017 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { BaseViewer } from \"./base_viewer.js\";\nimport { shadow } from \"pdfjs-lib\";\n\nclass PDFSinglePageViewer extends BaseViewer {\n  constructor(options) {\n    super(options);\n\n    this.eventBus._on(\"pagesinit\", evt => {\n      // Since the pages are placed in a `DocumentFragment`, make sure that\n      // the current page becomes visible upon loading of the document.\n      this._ensurePageViewVisible();\n    });\n  }\n\n  get _viewerElement() {\n    // Since we only want to display *one* page at a time when using the\n    // `PDFSinglePageViewer`, we cannot append them to the `viewer` DOM element.\n    // Instead, they are placed in a `DocumentFragment`, and only the current\n    // page is displayed in the viewer (refer to `this._ensurePageViewVisible`).\n    return shadow(this, \"_viewerElement\", this._shadowViewer);\n  }\n\n  _resetView() {\n    super._resetView();\n    this._previousPageNumber = 1;\n    this._shadowViewer = document.createDocumentFragment();\n    this._updateScrollDown = null;\n  }\n\n  _ensurePageViewVisible() {\n    const pageView = this._pages[this._currentPageNumber - 1];\n    const previousPageView = this._pages[this._previousPageNumber - 1];\n\n    const viewerNodes = this.viewer.childNodes;\n    switch (viewerNodes.length) {\n      case 0: // Should *only* occur on initial loading.\n        this.viewer.appendChild(pageView.div);\n        break;\n      case 1: // The normal page-switching case.\n        if (viewerNodes[0] !== previousPageView.div) {\n          throw new Error(\n            \"_ensurePageViewVisible: Unexpected previously visible page.\"\n          );\n        }\n        if (pageView === previousPageView) {\n          break; // The correct page is already visible.\n        }\n        // Switch visible pages, and reset the viewerContainer scroll position.\n        this._shadowViewer.appendChild(previousPageView.div);\n        this.viewer.appendChild(pageView.div);\n\n        this.container.scrollTop = 0;\n        break;\n      default:\n        throw new Error(\n          \"_ensurePageViewVisible: Only one page should be visible at a time.\"\n        );\n    }\n    this._previousPageNumber = this._currentPageNumber;\n  }\n\n  _scrollUpdate() {\n    if (this._updateScrollDown) {\n      this._updateScrollDown();\n    }\n    super._scrollUpdate();\n  }\n\n  _scrollIntoView({ pageDiv, pageSpot = null, pageNumber = null }) {\n    if (pageNumber) {\n      // Ensure that `this._currentPageNumber` is correct.\n      this._setCurrentPageNumber(pageNumber);\n    }\n    const scrolledDown = this._currentPageNumber >= this._previousPageNumber;\n\n    this._ensurePageViewVisible();\n    // Ensure that rendering always occurs, to avoid showing a blank page,\n    // even if the current position doesn't change when the page is scrolled.\n    this.update();\n\n    super._scrollIntoView({ pageDiv, pageSpot, pageNumber });\n\n    // Since scrolling is tracked using `requestAnimationFrame`, update the\n    // scroll direction during the next `this._scrollUpdate` invocation.\n    this._updateScrollDown = () => {\n      this.scroll.down = scrolledDown;\n      this._updateScrollDown = null;\n    };\n  }\n\n  _getVisiblePages() {\n    return this._getCurrentVisiblePage();\n  }\n\n  _updateHelper(visiblePages) {}\n\n  get _isScrollModeHorizontal() {\n    // The Scroll/Spread modes are never used in `PDFSinglePageViewer`.\n    return shadow(this, \"_isScrollModeHorizontal\", false);\n  }\n\n  _updateScrollMode() {}\n\n  _updateSpreadMode() {}\n}\n\nexport { PDFSinglePageViewer };\n","/* Copyright 2014 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  CSS_UNITS,\n  DEFAULT_SCALE,\n  DEFAULT_SCALE_VALUE,\n  getVisibleElements,\n  isPortraitOrientation,\n  isValidRotation,\n  isValidScrollMode,\n  isValidSpreadMode,\n  MAX_AUTO_SCALE,\n  moveToEndOfArray,\n  NullL10n,\n  PresentationModeState,\n  RendererType,\n  SCROLLBAR_PADDING,\n  scrollIntoView,\n  ScrollMode,\n  SpreadMode,\n  TextLayerMode,\n  UNKNOWN_SCALE,\n  VERTICAL_PADDING,\n  watchScroll,\n} from \"./ui_utils.js\";\nimport { PDFRenderingQueue, RenderingStates } from \"./pdf_rendering_queue.js\";\nimport { AnnotationLayerBuilder } from \"./annotation_layer_builder.js\";\nimport { createPromiseCapability } from \"pdfjs-lib\";\nimport { PDFPageView } from \"./pdf_page_view.js\";\nimport { SimpleLinkService } from \"./pdf_link_service.js\";\nimport { TextLayerBuilder } from \"./text_layer_builder.js\";\n\nconst DEFAULT_CACHE_SIZE = 10;\n\n/**\n * @typedef {Object} PDFViewerOptions\n * @property {HTMLDivElement} container - The container for the viewer element.\n * @property {HTMLDivElement} [viewer] - The viewer element.\n * @property {EventBus} eventBus - The application event bus.\n * @property {IPDFLinkService} linkService - The navigation/linking service.\n * @property {DownloadManager} [downloadManager] - The download manager\n *   component.\n * @property {PDFFindController} [findController] - The find controller\n *   component.\n * @property {PDFRenderingQueue} [renderingQueue] - The rendering queue object.\n * @property {boolean} [removePageBorders] - Removes the border shadow around\n *   the pages. The default value is `false`.\n * @property {number} [textLayerMode] - Controls if the text layer used for\n *   selection and searching is created, and if the improved text selection\n *   behaviour is enabled. The constants from {TextLayerMode} should be used.\n *   The default value is `TextLayerMode.ENABLE`.\n * @property {string} [imageResourcesPath] - Path for image resources, mainly\n *   mainly for annotation icons. Include trailing slash.\n * @property {boolean} [renderInteractiveForms] - Enables rendering of\n *   interactive form elements. The default value is `true`.\n * @property {boolean} [enablePrintAutoRotate] - Enables automatic rotation of\n *   landscape pages upon printing. The default is `false`.\n * @property {string} renderer - 'canvas' or 'svg'. The default is 'canvas'.\n * @property {boolean} [enableWebGL] - Enables WebGL accelerated rendering for\n *   some operations. The default value is `false`.\n * @property {boolean} [useOnlyCssZoom] - Enables CSS only zooming. The default\n *   value is `false`.\n * @property {number} [maxCanvasPixels] - The maximum supported canvas size in\n *   total pixels, i.e. width * height. Use -1 for no limit. The default value\n *   is 4096 * 4096 (16 mega-pixels).\n * @property {IL10n} l10n - Localization service.\n */\n\nfunction PDFPageViewBuffer(size) {\n  const data = [];\n  this.push = function (view) {\n    const i = data.indexOf(view);\n    if (i >= 0) {\n      data.splice(i, 1);\n    }\n    data.push(view);\n    if (data.length > size) {\n      data.shift().destroy();\n    }\n  };\n  /**\n   * After calling resize, the size of the buffer will be newSize. The optional\n   * parameter pagesToKeep is, if present, an array of pages to push to the back\n   * of the buffer, delaying their destruction. The size of pagesToKeep has no\n   * impact on the final size of the buffer; if pagesToKeep has length larger\n   * than newSize, some of those pages will be destroyed anyway.\n   */\n  this.resize = function (newSize, pagesToKeep) {\n    size = newSize;\n    if (pagesToKeep) {\n      const pageIdsToKeep = new Set();\n      for (let i = 0, iMax = pagesToKeep.length; i < iMax; ++i) {\n        pageIdsToKeep.add(pagesToKeep[i].id);\n      }\n      moveToEndOfArray(data, function (page) {\n        return pageIdsToKeep.has(page.id);\n      });\n    }\n    while (data.length > size) {\n      data.shift().destroy();\n    }\n  };\n}\n\nfunction isSameScale(oldScale, newScale) {\n  if (newScale === oldScale) {\n    return true;\n  }\n  if (Math.abs(newScale - oldScale) < 1e-15) {\n    // Prevent unnecessary re-rendering of all pages when the scale\n    // changes only because of limited numerical precision.\n    return true;\n  }\n  return false;\n}\n\n/**\n * Simple viewer control to display PDF content/pages.\n * @implements {IRenderableView}\n */\nclass BaseViewer {\n  /**\n   * @param {PDFViewerOptions} options\n   */\n  constructor(options) {\n    if (this.constructor === BaseViewer) {\n      throw new Error(\"Cannot initialize BaseViewer.\");\n    }\n    this._name = this.constructor.name;\n\n    this.container = options.container;\n    this.viewer = options.viewer || options.container.firstElementChild;\n\n    if (\n      (typeof PDFJSDev === \"undefined\" ||\n        PDFJSDev.test(\"!PRODUCTION || GENERIC\")) &&\n      !(\n        this.container instanceof HTMLDivElement &&\n        this.viewer instanceof HTMLDivElement\n      )\n    ) {\n      throw new Error(\"Invalid `container` and/or `viewer` option.\");\n    }\n    this.eventBus = options.eventBus;\n    this.linkService = options.linkService || new SimpleLinkService();\n    this.downloadManager = options.downloadManager || null;\n    this.findController = options.findController || null;\n    this.removePageBorders = options.removePageBorders || false;\n    this.textLayerMode = Number.isInteger(options.textLayerMode)\n      ? options.textLayerMode\n      : TextLayerMode.ENABLE;\n    this.imageResourcesPath = options.imageResourcesPath || \"\";\n    this.renderInteractiveForms =\n      typeof options.renderInteractiveForms === \"boolean\"\n        ? options.renderInteractiveForms\n        : true;\n    this.enablePrintAutoRotate = options.enablePrintAutoRotate || false;\n    this.renderer = options.renderer || RendererType.CANVAS;\n    this.enableWebGL = options.enableWebGL || false;\n    this.useOnlyCssZoom = options.useOnlyCssZoom || false;\n    this.maxCanvasPixels = options.maxCanvasPixels;\n    this.l10n = options.l10n || NullL10n;\n\n    this.defaultRenderingQueue = !options.renderingQueue;\n    if (this.defaultRenderingQueue) {\n      // Custom rendering queue is not specified, using default one\n      this.renderingQueue = new PDFRenderingQueue();\n      this.renderingQueue.setViewer(this);\n    } else {\n      this.renderingQueue = options.renderingQueue;\n    }\n\n    this.scroll = watchScroll(this.container, this._scrollUpdate.bind(this));\n    this.presentationModeState = PresentationModeState.UNKNOWN;\n    this._onBeforeDraw = this._onAfterDraw = null;\n    this._resetView();\n\n    if (this.removePageBorders) {\n      this.viewer.classList.add(\"removePageBorders\");\n    }\n    // Defer the dispatching of this event, to give other viewer components\n    // time to initialize *and* register 'baseviewerinit' event listeners.\n    Promise.resolve().then(() => {\n      this.eventBus.dispatch(\"baseviewerinit\", { source: this });\n    });\n  }\n\n  get pagesCount() {\n    return this._pages.length;\n  }\n\n  getPageView(index) {\n    return this._pages[index];\n  }\n\n  /**\n   * @type {boolean} - True if all {PDFPageView} objects are initialized.\n   */\n  get pageViewsReady() {\n    if (!this._pagesCapability.settled) {\n      return false;\n    }\n    // Prevent printing errors when 'disableAutoFetch' is set, by ensuring\n    // that *all* pages have in fact been completely loaded.\n    return this._pages.every(function (pageView) {\n      return pageView && pageView.pdfPage;\n    });\n  }\n\n  /**\n   * @type {number}\n   */\n  get currentPageNumber() {\n    return this._currentPageNumber;\n  }\n\n  /**\n   * @param {number} val - The page number.\n   */\n  set currentPageNumber(val) {\n    if (!Number.isInteger(val)) {\n      throw new Error(\"Invalid page number.\");\n    }\n    if (!this.pdfDocument) {\n      return;\n    }\n    // The intent can be to just reset a scroll position and/or scale.\n    if (!this._setCurrentPageNumber(val, /* resetCurrentPageView = */ true)) {\n      console.error(\n        `${this._name}.currentPageNumber: \"${val}\" is not a valid page.`\n      );\n    }\n  }\n\n  /**\n   * @returns {boolean} Whether the pageNumber is valid (within bounds).\n   * @private\n   */\n  _setCurrentPageNumber(val, resetCurrentPageView = false) {\n    if (this._currentPageNumber === val) {\n      if (resetCurrentPageView) {\n        this._resetCurrentPageView();\n      }\n      return true;\n    }\n\n    if (!(0 < val && val <= this.pagesCount)) {\n      return false;\n    }\n    this._currentPageNumber = val;\n\n    this.eventBus.dispatch(\"pagechanging\", {\n      source: this,\n      pageNumber: val,\n      pageLabel: this._pageLabels && this._pageLabels[val - 1],\n    });\n\n    if (resetCurrentPageView) {\n      this._resetCurrentPageView();\n    }\n    return true;\n  }\n\n  /**\n   * @type {string|null} Returns the current page label, or `null` if no page\n   *   labels exist.\n   */\n  get currentPageLabel() {\n    return this._pageLabels && this._pageLabels[this._currentPageNumber - 1];\n  }\n\n  /**\n   * @param {string} val - The page label.\n   */\n  set currentPageLabel(val) {\n    if (!this.pdfDocument) {\n      return;\n    }\n    let page = val | 0; // Fallback page number.\n    if (this._pageLabels) {\n      const i = this._pageLabels.indexOf(val);\n      if (i >= 0) {\n        page = i + 1;\n      }\n    }\n    // The intent can be to just reset a scroll position and/or scale.\n    if (!this._setCurrentPageNumber(page, /* resetCurrentPageView = */ true)) {\n      console.error(\n        `${this._name}.currentPageLabel: \"${val}\" is not a valid page.`\n      );\n    }\n  }\n\n  /**\n   * @type {number}\n   */\n  get currentScale() {\n    return this._currentScale !== UNKNOWN_SCALE\n      ? this._currentScale\n      : DEFAULT_SCALE;\n  }\n\n  /**\n   * @param {number} val - Scale of the pages in percents.\n   */\n  set currentScale(val) {\n    if (isNaN(val)) {\n      throw new Error(\"Invalid numeric scale.\");\n    }\n    if (!this.pdfDocument) {\n      return;\n    }\n    this._setScale(val, false);\n  }\n\n  /**\n   * @type {string}\n   */\n  get currentScaleValue() {\n    return this._currentScaleValue;\n  }\n\n  /**\n   * @param val - The scale of the pages (in percent or predefined value).\n   */\n  set currentScaleValue(val) {\n    if (!this.pdfDocument) {\n      return;\n    }\n    this._setScale(val, false);\n  }\n\n  /**\n   * @type {number}\n   */\n  get pagesRotation() {\n    return this._pagesRotation;\n  }\n\n  /**\n   * @param {number} rotation - The rotation of the pages (0, 90, 180, 270).\n   */\n  set pagesRotation(rotation) {\n    if (!isValidRotation(rotation)) {\n      throw new Error(\"Invalid pages rotation angle.\");\n    }\n    if (!this.pdfDocument) {\n      return;\n    }\n    if (this._pagesRotation === rotation) {\n      return; // The rotation didn't change.\n    }\n    this._pagesRotation = rotation;\n\n    const pageNumber = this._currentPageNumber;\n\n    for (let i = 0, ii = this._pages.length; i < ii; i++) {\n      const pageView = this._pages[i];\n      pageView.update(pageView.scale, rotation);\n    }\n    // Prevent errors in case the rotation changes *before* the scale has been\n    // set to a non-default value.\n    if (this._currentScaleValue) {\n      this._setScale(this._currentScaleValue, true);\n    }\n\n    this.eventBus.dispatch(\"rotationchanging\", {\n      source: this,\n      pagesRotation: rotation,\n      pageNumber,\n    });\n\n    if (this.defaultRenderingQueue) {\n      this.update();\n    }\n  }\n\n  get firstPagePromise() {\n    return this.pdfDocument ? this._firstPageCapability.promise : null;\n  }\n\n  get onePageRendered() {\n    return this.pdfDocument ? this._onePageRenderedCapability.promise : null;\n  }\n\n  get pagesPromise() {\n    return this.pdfDocument ? this._pagesCapability.promise : null;\n  }\n\n  /**\n   * @private\n   */\n  get _viewerElement() {\n    // In most viewers, e.g. `PDFViewer`, this should return `this.viewer`.\n    throw new Error(\"Not implemented: _viewerElement\");\n  }\n\n  /**\n   * @private\n   */\n  _onePageRenderedOrForceFetch() {\n    // Unless the viewer *and* its pages are visible, rendering won't start and\n    // `this._onePageRenderedCapability` thus won't be resolved.\n    // To ensure that automatic printing, on document load, still works even in\n    // those cases we force-allow fetching of all pages when:\n    //  - The viewer is hidden in the DOM, e.g. in a `display: none` <iframe>\n    //    element; fixes bug 1618621.\n    //  - The viewer is visible, but none of the pages are (e.g. if the\n    //    viewer is very small); fixes bug 1618955.\n    if (\n      !this.container.offsetParent ||\n      this._getVisiblePages().views.length === 0\n    ) {\n      return Promise.resolve();\n    }\n    return this._onePageRenderedCapability.promise;\n  }\n\n  /**\n   * @param pdfDocument {PDFDocument}\n   */\n  setDocument(pdfDocument) {\n    if (this.pdfDocument) {\n      this._cancelRendering();\n      this._resetView();\n\n      if (this.findController) {\n        this.findController.setDocument(null);\n      }\n    }\n\n    this.pdfDocument = pdfDocument;\n    if (!pdfDocument) {\n      return;\n    }\n    const pagesCount = pdfDocument.numPages;\n    const firstPagePromise = pdfDocument.getPage(1);\n\n    const annotationStorage = pdfDocument.annotationStorage;\n    const optionalContentConfigPromise = pdfDocument.getOptionalContentConfig();\n\n    this._pagesCapability.promise.then(() => {\n      this.eventBus.dispatch(\"pagesloaded\", {\n        source: this,\n        pagesCount,\n      });\n    });\n\n    this._onBeforeDraw = evt => {\n      const pageView = this._pages[evt.pageNumber - 1];\n      if (!pageView) {\n        return;\n      }\n      // Add the page to the buffer at the start of drawing. That way it can be\n      // evicted from the buffer and destroyed even if we pause its rendering.\n      this._buffer.push(pageView);\n    };\n    this.eventBus._on(\"pagerender\", this._onBeforeDraw);\n\n    this._onAfterDraw = evt => {\n      if (evt.cssTransform || this._onePageRenderedCapability.settled) {\n        return;\n      }\n      this._onePageRenderedCapability.resolve();\n\n      this.eventBus._off(\"pagerendered\", this._onAfterDraw);\n      this._onAfterDraw = null;\n    };\n    this.eventBus._on(\"pagerendered\", this._onAfterDraw);\n\n    // Fetch a single page so we can get a viewport that will be the default\n    // viewport for all pages\n    firstPagePromise\n      .then(firstPdfPage => {\n        this._firstPageCapability.resolve(firstPdfPage);\n        this._optionalContentConfigPromise = optionalContentConfigPromise;\n\n        const scale = this.currentScale;\n        const viewport = firstPdfPage.getViewport({ scale: scale * CSS_UNITS });\n        const textLayerFactory =\n          this.textLayerMode !== TextLayerMode.DISABLE ? this : null;\n\n        for (let pageNum = 1; pageNum <= pagesCount; ++pageNum) {\n          const pageView = new PDFPageView({\n            container: this._viewerElement,\n            eventBus: this.eventBus,\n            id: pageNum,\n            scale,\n            defaultViewport: viewport.clone(),\n            annotationStorage,\n            optionalContentConfigPromise,\n            renderingQueue: this.renderingQueue,\n            textLayerFactory,\n            textLayerMode: this.textLayerMode,\n            annotationLayerFactory: this,\n            imageResourcesPath: this.imageResourcesPath,\n            renderInteractiveForms: this.renderInteractiveForms,\n            renderer: this.renderer,\n            enableWebGL: this.enableWebGL,\n            useOnlyCssZoom: this.useOnlyCssZoom,\n            maxCanvasPixels: this.maxCanvasPixels,\n            l10n: this.l10n,\n          });\n          this._pages.push(pageView);\n        }\n        // Set the first `pdfPage` immediately, since it's already loaded,\n        // rather than having to repeat the `PDFDocumentProxy.getPage` call in\n        // the `this._ensurePdfPageLoaded` method before rendering can start.\n        const firstPageView = this._pages[0];\n        if (firstPageView) {\n          firstPageView.setPdfPage(firstPdfPage);\n          this.linkService.cachePageRef(1, firstPdfPage.ref);\n        }\n        if (this._spreadMode !== SpreadMode.NONE) {\n          this._updateSpreadMode();\n        }\n\n        // Fetch all the pages since the viewport is needed before printing\n        // starts to create the correct size canvas. Wait until one page is\n        // rendered so we don't tie up too many resources early on.\n        this._onePageRenderedOrForceFetch().then(() => {\n          if (this.findController) {\n            this.findController.setDocument(pdfDocument); // Enable searching.\n          }\n\n          // In addition to 'disableAutoFetch' being set, also attempt to reduce\n          // resource usage when loading *very* long/large documents.\n          if (pdfDocument.loadingParams.disableAutoFetch || pagesCount > 7500) {\n            // XXX: Printing is semi-broken with auto fetch disabled.\n            this._pagesCapability.resolve();\n            return;\n          }\n          let getPagesLeft = pagesCount - 1; // The first page was already loaded.\n\n          if (getPagesLeft <= 0) {\n            this._pagesCapability.resolve();\n            return;\n          }\n          for (let pageNum = 2; pageNum <= pagesCount; ++pageNum) {\n            pdfDocument.getPage(pageNum).then(\n              pdfPage => {\n                const pageView = this._pages[pageNum - 1];\n                if (!pageView.pdfPage) {\n                  pageView.setPdfPage(pdfPage);\n                }\n                this.linkService.cachePageRef(pageNum, pdfPage.ref);\n                if (--getPagesLeft === 0) {\n                  this._pagesCapability.resolve();\n                }\n              },\n              reason => {\n                console.error(\n                  `Unable to get page ${pageNum} to initialize viewer`,\n                  reason\n                );\n                if (--getPagesLeft === 0) {\n                  this._pagesCapability.resolve();\n                }\n              }\n            );\n          }\n        });\n\n        this.eventBus.dispatch(\"pagesinit\", { source: this });\n\n        if (this.defaultRenderingQueue) {\n          this.update();\n        }\n      })\n      .catch(reason => {\n        console.error(\"Unable to initialize viewer\", reason);\n      });\n  }\n\n  /**\n   * @param {Array|null} labels\n   */\n  setPageLabels(labels) {\n    if (!this.pdfDocument) {\n      return;\n    }\n    if (!labels) {\n      this._pageLabels = null;\n    } else if (\n      !(Array.isArray(labels) && this.pdfDocument.numPages === labels.length)\n    ) {\n      this._pageLabels = null;\n      console.error(`${this._name}.setPageLabels: Invalid page labels.`);\n    } else {\n      this._pageLabels = labels;\n    }\n    // Update all the `PDFPageView` instances.\n    for (let i = 0, ii = this._pages.length; i < ii; i++) {\n      const pageView = this._pages[i];\n      const label = this._pageLabels && this._pageLabels[i];\n      pageView.setPageLabel(label);\n    }\n  }\n\n  _resetView() {\n    this._pages = [];\n    this._currentPageNumber = 1;\n    this._currentScale = UNKNOWN_SCALE;\n    this._currentScaleValue = null;\n    this._pageLabels = null;\n    this._buffer = new PDFPageViewBuffer(DEFAULT_CACHE_SIZE);\n    this._location = null;\n    this._pagesRotation = 0;\n    this._optionalContentConfigPromise = null;\n    this._pagesRequests = new WeakMap();\n    this._firstPageCapability = createPromiseCapability();\n    this._onePageRenderedCapability = createPromiseCapability();\n    this._pagesCapability = createPromiseCapability();\n    this._scrollMode = ScrollMode.VERTICAL;\n    this._spreadMode = SpreadMode.NONE;\n\n    if (this._onBeforeDraw) {\n      this.eventBus._off(\"pagerender\", this._onBeforeDraw);\n      this._onBeforeDraw = null;\n    }\n    if (this._onAfterDraw) {\n      this.eventBus._off(\"pagerendered\", this._onAfterDraw);\n      this._onAfterDraw = null;\n    }\n    // Remove the pages from the DOM...\n    this.viewer.textContent = \"\";\n    // ... and reset the Scroll mode CSS class(es) afterwards.\n    this._updateScrollMode();\n  }\n\n  _scrollUpdate() {\n    if (this.pagesCount === 0) {\n      return;\n    }\n    this.update();\n  }\n\n  _scrollIntoView({ pageDiv, pageSpot = null, pageNumber = null }) {\n    scrollIntoView(pageDiv, pageSpot);\n  }\n\n  _setScaleUpdatePages(newScale, newValue, noScroll = false, preset = false) {\n    this._currentScaleValue = newValue.toString();\n\n    if (isSameScale(this._currentScale, newScale)) {\n      if (preset) {\n        this.eventBus.dispatch(\"scalechanging\", {\n          source: this,\n          scale: newScale,\n          presetValue: newValue,\n        });\n      }\n      return;\n    }\n\n    for (let i = 0, ii = this._pages.length; i < ii; i++) {\n      this._pages[i].update(newScale);\n    }\n    this._currentScale = newScale;\n\n    if (!noScroll) {\n      let page = this._currentPageNumber,\n        dest;\n      if (\n        this._location &&\n        !(this.isInPresentationMode || this.isChangingPresentationMode)\n      ) {\n        page = this._location.pageNumber;\n        dest = [\n          null,\n          { name: \"XYZ\" },\n          this._location.left,\n          this._location.top,\n          null,\n        ];\n      }\n      this.scrollPageIntoView({\n        pageNumber: page,\n        destArray: dest,\n        allowNegativeOffset: true,\n      });\n    }\n\n    this.eventBus.dispatch(\"scalechanging\", {\n      source: this,\n      scale: newScale,\n      presetValue: preset ? newValue : undefined,\n    });\n\n    if (this.defaultRenderingQueue) {\n      this.update();\n    }\n  }\n\n  _setScale(value, noScroll = false) {\n    let scale = parseFloat(value);\n\n    if (scale > 0) {\n      this._setScaleUpdatePages(scale, value, noScroll, /* preset = */ false);\n    } else {\n      const currentPage = this._pages[this._currentPageNumber - 1];\n      if (!currentPage) {\n        return;\n      }\n      const noPadding = this.isInPresentationMode || this.removePageBorders;\n      let hPadding = noPadding ? 0 : SCROLLBAR_PADDING;\n      let vPadding = noPadding ? 0 : VERTICAL_PADDING;\n\n      if (!noPadding && this._isScrollModeHorizontal) {\n        [hPadding, vPadding] = [vPadding, hPadding]; // Swap the padding values.\n      }\n      const pageWidthScale =\n        ((this.container.clientWidth - hPadding) / currentPage.width) *\n        currentPage.scale;\n      const pageHeightScale =\n        ((this.container.clientHeight - vPadding) / currentPage.height) *\n        currentPage.scale;\n      switch (value) {\n        case \"page-actual\":\n          scale = 1;\n          break;\n        case \"page-width\":\n          scale = pageWidthScale;\n          break;\n        case \"page-height\":\n          scale = pageHeightScale;\n          break;\n        case \"page-fit\":\n          scale = Math.min(pageWidthScale, pageHeightScale);\n          break;\n        case \"auto\":\n          // For pages in landscape mode, fit the page height to the viewer\n          // *unless* the page would thus become too wide to fit horizontally.\n          const horizontalScale = isPortraitOrientation(currentPage)\n            ? pageWidthScale\n            : Math.min(pageHeightScale, pageWidthScale);\n          scale = Math.min(MAX_AUTO_SCALE, horizontalScale);\n          break;\n        default:\n          console.error(\n            `${this._name}._setScale: \"${value}\" is an unknown zoom value.`\n          );\n          return;\n      }\n      this._setScaleUpdatePages(scale, value, noScroll, /* preset = */ true);\n    }\n  }\n\n  /**\n   * Refreshes page view: scrolls to the current page and updates the scale.\n   * @private\n   */\n  _resetCurrentPageView() {\n    if (this.isInPresentationMode) {\n      // Fixes the case when PDF has different page sizes.\n      this._setScale(this._currentScaleValue, true);\n    }\n\n    const pageView = this._pages[this._currentPageNumber - 1];\n    this._scrollIntoView({ pageDiv: pageView.div });\n  }\n\n  /**\n   * @typedef ScrollPageIntoViewParameters\n   * @property {number} pageNumber - The page number.\n   * @property {Array} [destArray] - The original PDF destination array, in the\n   *   format: <page-ref> </XYZ|/FitXXX> <args..>\n   * @property {boolean} [allowNegativeOffset] - Allow negative page offsets.\n   *   The default value is `false`.\n   * @property {boolean} [ignoreDestinationZoom] - Ignore the zoom argument in\n   *   the destination array. The default value is `false`.\n   */\n\n  /**\n   * Scrolls page into view.\n   * @param {ScrollPageIntoViewParameters} params\n   */\n  scrollPageIntoView({\n    pageNumber,\n    destArray = null,\n    allowNegativeOffset = false,\n    ignoreDestinationZoom = false,\n  }) {\n    if (!this.pdfDocument) {\n      return;\n    }\n    const pageView =\n      Number.isInteger(pageNumber) && this._pages[pageNumber - 1];\n    if (!pageView) {\n      console.error(\n        `${this._name}.scrollPageIntoView: ` +\n          `\"${pageNumber}\" is not a valid pageNumber parameter.`\n      );\n      return;\n    }\n\n    if (this.isInPresentationMode || !destArray) {\n      this._setCurrentPageNumber(pageNumber, /* resetCurrentPageView = */ true);\n      return;\n    }\n    let x = 0,\n      y = 0;\n    let width = 0,\n      height = 0,\n      widthScale,\n      heightScale;\n    const changeOrientation = pageView.rotation % 180 !== 0;\n    const pageWidth =\n      (changeOrientation ? pageView.height : pageView.width) /\n      pageView.scale /\n      CSS_UNITS;\n    const pageHeight =\n      (changeOrientation ? pageView.width : pageView.height) /\n      pageView.scale /\n      CSS_UNITS;\n    let scale = 0;\n    switch (destArray[1].name) {\n      case \"XYZ\":\n        x = destArray[2];\n        y = destArray[3];\n        scale = destArray[4];\n        // If x and/or y coordinates are not supplied, default to\n        // _top_ left of the page (not the obvious bottom left,\n        // since aligning the bottom of the intended page with the\n        // top of the window is rarely helpful).\n        x = x !== null ? x : 0;\n        y = y !== null ? y : pageHeight;\n        break;\n      case \"Fit\":\n      case \"FitB\":\n        scale = \"page-fit\";\n        break;\n      case \"FitH\":\n      case \"FitBH\":\n        y = destArray[2];\n        scale = \"page-width\";\n        // According to the PDF spec, section 12.3.2.2, a `null` value in the\n        // parameter should maintain the position relative to the new page.\n        if (y === null && this._location) {\n          x = this._location.left;\n          y = this._location.top;\n        }\n        break;\n      case \"FitV\":\n      case \"FitBV\":\n        x = destArray[2];\n        width = pageWidth;\n        height = pageHeight;\n        scale = \"page-height\";\n        break;\n      case \"FitR\":\n        x = destArray[2];\n        y = destArray[3];\n        width = destArray[4] - x;\n        height = destArray[5] - y;\n        const hPadding = this.removePageBorders ? 0 : SCROLLBAR_PADDING;\n        const vPadding = this.removePageBorders ? 0 : VERTICAL_PADDING;\n\n        widthScale =\n          (this.container.clientWidth - hPadding) / width / CSS_UNITS;\n        heightScale =\n          (this.container.clientHeight - vPadding) / height / CSS_UNITS;\n        scale = Math.min(Math.abs(widthScale), Math.abs(heightScale));\n        break;\n      default:\n        console.error(\n          `${this._name}.scrollPageIntoView: ` +\n            `\"${destArray[1].name}\" is not a valid destination type.`\n        );\n        return;\n    }\n\n    if (!ignoreDestinationZoom) {\n      if (scale && scale !== this._currentScale) {\n        this.currentScaleValue = scale;\n      } else if (this._currentScale === UNKNOWN_SCALE) {\n        this.currentScaleValue = DEFAULT_SCALE_VALUE;\n      }\n    }\n\n    if (scale === \"page-fit\" && !destArray[4]) {\n      this._scrollIntoView({\n        pageDiv: pageView.div,\n        pageNumber,\n      });\n      return;\n    }\n\n    const boundingRect = [\n      pageView.viewport.convertToViewportPoint(x, y),\n      pageView.viewport.convertToViewportPoint(x + width, y + height),\n    ];\n    let left = Math.min(boundingRect[0][0], boundingRect[1][0]);\n    let top = Math.min(boundingRect[0][1], boundingRect[1][1]);\n\n    if (!allowNegativeOffset) {\n      // Some bad PDF generators will create destinations with e.g. top values\n      // that exceeds the page height. Ensure that offsets are not negative,\n      // to prevent a previous page from becoming visible (fixes bug 874482).\n      left = Math.max(left, 0);\n      top = Math.max(top, 0);\n    }\n    this._scrollIntoView({\n      pageDiv: pageView.div,\n      pageSpot: { left, top },\n      pageNumber,\n    });\n  }\n\n  _updateLocation(firstPage) {\n    const currentScale = this._currentScale;\n    const currentScaleValue = this._currentScaleValue;\n    const normalizedScaleValue =\n      parseFloat(currentScaleValue) === currentScale\n        ? Math.round(currentScale * 10000) / 100\n        : currentScaleValue;\n\n    const pageNumber = firstPage.id;\n    let pdfOpenParams = \"#page=\" + pageNumber;\n    pdfOpenParams += \"&zoom=\" + normalizedScaleValue;\n    const currentPageView = this._pages[pageNumber - 1];\n    const container = this.container;\n    const topLeft = currentPageView.getPagePoint(\n      container.scrollLeft - firstPage.x,\n      container.scrollTop - firstPage.y\n    );\n    const intLeft = Math.round(topLeft[0]);\n    const intTop = Math.round(topLeft[1]);\n    pdfOpenParams += \",\" + intLeft + \",\" + intTop;\n\n    this._location = {\n      pageNumber,\n      scale: normalizedScaleValue,\n      top: intTop,\n      left: intLeft,\n      rotation: this._pagesRotation,\n      pdfOpenParams,\n    };\n  }\n\n  _updateHelper(visiblePages) {\n    throw new Error(\"Not implemented: _updateHelper\");\n  }\n\n  update() {\n    const visible = this._getVisiblePages();\n    const visiblePages = visible.views,\n      numVisiblePages = visiblePages.length;\n\n    if (numVisiblePages === 0) {\n      return;\n    }\n    const newCacheSize = Math.max(DEFAULT_CACHE_SIZE, 2 * numVisiblePages + 1);\n    this._buffer.resize(newCacheSize, visiblePages);\n\n    this.renderingQueue.renderHighestPriority(visible);\n\n    this._updateHelper(visiblePages); // Run any class-specific update code.\n\n    this._updateLocation(visible.first);\n    this.eventBus.dispatch(\"updateviewarea\", {\n      source: this,\n      location: this._location,\n    });\n  }\n\n  containsElement(element) {\n    return this.container.contains(element);\n  }\n\n  focus() {\n    this.container.focus();\n  }\n\n  get _isScrollModeHorizontal() {\n    // Used to ensure that pre-rendering of the next/previous page works\n    // correctly, since Scroll/Spread modes are ignored in Presentation Mode.\n    return this.isInPresentationMode\n      ? false\n      : this._scrollMode === ScrollMode.HORIZONTAL;\n  }\n\n  get isInPresentationMode() {\n    return this.presentationModeState === PresentationModeState.FULLSCREEN;\n  }\n\n  get isChangingPresentationMode() {\n    return this.presentationModeState === PresentationModeState.CHANGING;\n  }\n\n  get isHorizontalScrollbarEnabled() {\n    return this.isInPresentationMode\n      ? false\n      : this.container.scrollWidth > this.container.clientWidth;\n  }\n\n  get isVerticalScrollbarEnabled() {\n    return this.isInPresentationMode\n      ? false\n      : this.container.scrollHeight > this.container.clientHeight;\n  }\n\n  /**\n   * Helper method for `this._getVisiblePages`. Should only ever be used when\n   * the viewer can only display a single page at a time, for example in:\n   *  - `PDFSinglePageViewer`.\n   *  - `PDFViewer` with Presentation Mode active.\n   */\n  _getCurrentVisiblePage() {\n    if (!this.pagesCount) {\n      return { views: [] };\n    }\n    const pageView = this._pages[this._currentPageNumber - 1];\n    // NOTE: Compute the `x` and `y` properties of the current view,\n    // since `this._updateLocation` depends of them being available.\n    const element = pageView.div;\n\n    const view = {\n      id: pageView.id,\n      x: element.offsetLeft + element.clientLeft,\n      y: element.offsetTop + element.clientTop,\n      view: pageView,\n    };\n    return { first: view, last: view, views: [view] };\n  }\n\n  _getVisiblePages() {\n    return getVisibleElements(\n      this.container,\n      this._pages,\n      true,\n      this._isScrollModeHorizontal\n    );\n  }\n\n  /**\n   * @param {number} pageNumber\n   */\n  isPageVisible(pageNumber) {\n    if (!this.pdfDocument) {\n      return false;\n    }\n    if (pageNumber < 1 || pageNumber > this.pagesCount) {\n      console.error(\n        `${this._name}.isPageVisible: \"${pageNumber}\" is out of bounds.`\n      );\n      return false;\n    }\n    return this._getVisiblePages().views.some(function (view) {\n      return view.id === pageNumber;\n    });\n  }\n\n  cleanup() {\n    for (let i = 0, ii = this._pages.length; i < ii; i++) {\n      if (\n        this._pages[i] &&\n        this._pages[i].renderingState !== RenderingStates.FINISHED\n      ) {\n        this._pages[i].reset();\n      }\n    }\n  }\n\n  /**\n   * @private\n   */\n  _cancelRendering() {\n    for (let i = 0, ii = this._pages.length; i < ii; i++) {\n      if (this._pages[i]) {\n        this._pages[i].cancelRendering();\n      }\n    }\n  }\n\n  /**\n   * @param {PDFPageView} pageView\n   * @returns {Promise} Returns a promise containing a {PDFPageProxy} object.\n   * @private\n   */\n  _ensurePdfPageLoaded(pageView) {\n    if (pageView.pdfPage) {\n      return Promise.resolve(pageView.pdfPage);\n    }\n    if (this._pagesRequests.has(pageView)) {\n      return this._pagesRequests.get(pageView);\n    }\n    const promise = this.pdfDocument\n      .getPage(pageView.id)\n      .then(pdfPage => {\n        if (!pageView.pdfPage) {\n          pageView.setPdfPage(pdfPage);\n        }\n        this._pagesRequests.delete(pageView);\n        return pdfPage;\n      })\n      .catch(reason => {\n        console.error(\"Unable to get page for page view\", reason);\n        // Page error -- there is nothing that can be done.\n        this._pagesRequests.delete(pageView);\n      });\n    this._pagesRequests.set(pageView, promise);\n    return promise;\n  }\n\n  forceRendering(currentlyVisiblePages) {\n    const visiblePages = currentlyVisiblePages || this._getVisiblePages();\n    const scrollAhead = this._isScrollModeHorizontal\n      ? this.scroll.right\n      : this.scroll.down;\n    const pageView = this.renderingQueue.getHighestPriority(\n      visiblePages,\n      this._pages,\n      scrollAhead\n    );\n    if (pageView) {\n      this._ensurePdfPageLoaded(pageView).then(() => {\n        this.renderingQueue.renderView(pageView);\n      });\n      return true;\n    }\n    return false;\n  }\n\n  /**\n   * @param {HTMLDivElement} textLayerDiv\n   * @param {number} pageIndex\n   * @param {PageViewport} viewport\n   * @param {boolean} enhanceTextSelection\n   * @param {EventBus} eventBus\n   * @returns {TextLayerBuilder}\n   */\n  createTextLayerBuilder(\n    textLayerDiv,\n    pageIndex,\n    viewport,\n    enhanceTextSelection = false,\n    eventBus\n  ) {\n    return new TextLayerBuilder({\n      textLayerDiv,\n      eventBus,\n      pageIndex,\n      viewport,\n      findController: this.isInPresentationMode ? null : this.findController,\n      enhanceTextSelection: this.isInPresentationMode\n        ? false\n        : enhanceTextSelection,\n    });\n  }\n\n  /**\n   * @param {HTMLDivElement} pageDiv\n   * @param {PDFPage} pdfPage\n   * @param {string} [imageResourcesPath] - Path for image resources, mainly\n   *   for annotation icons. Include trailing slash.\n   * @param {boolean} renderInteractiveForms\n   * @param {IL10n} l10n\n   * @returns {AnnotationLayerBuilder}\n   */\n  createAnnotationLayerBuilder(\n    pageDiv,\n    pdfPage,\n    annotationStorage = null,\n    imageResourcesPath = \"\",\n    renderInteractiveForms = false,\n    l10n = NullL10n\n  ) {\n    return new AnnotationLayerBuilder({\n      pageDiv,\n      pdfPage,\n      annotationStorage,\n      imageResourcesPath,\n      renderInteractiveForms,\n      linkService: this.linkService,\n      downloadManager: this.downloadManager,\n      l10n,\n    });\n  }\n\n  /**\n   * @type {boolean} Whether all pages of the PDF document have identical\n   *   widths and heights.\n   */\n  get hasEqualPageSizes() {\n    const firstPageView = this._pages[0];\n    for (let i = 1, ii = this._pages.length; i < ii; ++i) {\n      const pageView = this._pages[i];\n      if (\n        pageView.width !== firstPageView.width ||\n        pageView.height !== firstPageView.height\n      ) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  /**\n   * Returns sizes of the pages.\n   * @returns {Array} Array of objects with width/height/rotation fields.\n   */\n  getPagesOverview() {\n    const pagesOverview = this._pages.map(function (pageView) {\n      const viewport = pageView.pdfPage.getViewport({ scale: 1 });\n      return {\n        width: viewport.width,\n        height: viewport.height,\n        rotation: viewport.rotation,\n      };\n    });\n    if (!this.enablePrintAutoRotate) {\n      return pagesOverview;\n    }\n    return pagesOverview.map(function (size) {\n      if (isPortraitOrientation(size)) {\n        return size;\n      }\n      return {\n        width: size.height,\n        height: size.width,\n        rotation: (size.rotation + 90) % 360,\n      };\n    });\n  }\n\n  /**\n   * @type {Promise<OptionalContentConfig | null>}\n   */\n  get optionalContentConfigPromise() {\n    if (!this.pdfDocument) {\n      return Promise.resolve(null);\n    }\n    if (!this._optionalContentConfigPromise) {\n      // Prevent issues if the getter is accessed *before* the `onePageRendered`\n      // promise has resolved; won't (normally) happen in the default viewer.\n      return this.pdfDocument.getOptionalContentConfig();\n    }\n    return this._optionalContentConfigPromise;\n  }\n\n  /**\n   * @param {Promise<OptionalContentConfig>} promise - A promise that is\n   *   resolved with an {@link OptionalContentConfig} instance.\n   */\n  set optionalContentConfigPromise(promise) {\n    if (!(promise instanceof Promise)) {\n      throw new Error(`Invalid optionalContentConfigPromise: ${promise}`);\n    }\n    if (!this.pdfDocument) {\n      return;\n    }\n    if (!this._optionalContentConfigPromise) {\n      // Ignore the setter *before* the `onePageRendered` promise has resolved,\n      // since it'll be overwritten anyway; won't happen in the default viewer.\n      return;\n    }\n    this._optionalContentConfigPromise = promise;\n\n    for (const pageView of this._pages) {\n      pageView.update(pageView.scale, pageView.rotation, promise);\n    }\n    this.update();\n\n    this.eventBus.dispatch(\"optionalcontentconfigchanged\", {\n      source: this,\n      promise,\n    });\n  }\n\n  /**\n   * @type {number} One of the values in {ScrollMode}.\n   */\n  get scrollMode() {\n    return this._scrollMode;\n  }\n\n  /**\n   * @param {number} mode - The direction in which the document pages should be\n   *   laid out within the scrolling container.\n   *   The constants from {ScrollMode} should be used.\n   */\n  set scrollMode(mode) {\n    if (this._scrollMode === mode) {\n      return; // The Scroll mode didn't change.\n    }\n    if (!isValidScrollMode(mode)) {\n      throw new Error(`Invalid scroll mode: ${mode}`);\n    }\n    this._scrollMode = mode;\n    this.eventBus.dispatch(\"scrollmodechanged\", { source: this, mode });\n\n    this._updateScrollMode(/* pageNumber = */ this._currentPageNumber);\n  }\n\n  _updateScrollMode(pageNumber = null) {\n    const scrollMode = this._scrollMode,\n      viewer = this.viewer;\n\n    viewer.classList.toggle(\n      \"scrollHorizontal\",\n      scrollMode === ScrollMode.HORIZONTAL\n    );\n    viewer.classList.toggle(\"scrollWrapped\", scrollMode === ScrollMode.WRAPPED);\n\n    if (!this.pdfDocument || !pageNumber) {\n      return;\n    }\n    // Non-numeric scale values can be sensitive to the scroll orientation.\n    // Call this before re-scrolling to the current page, to ensure that any\n    // changes in scale don't move the current page.\n    if (this._currentScaleValue && isNaN(this._currentScaleValue)) {\n      this._setScale(this._currentScaleValue, true);\n    }\n    this._setCurrentPageNumber(pageNumber, /* resetCurrentPageView = */ true);\n    this.update();\n  }\n\n  /**\n   * @type {number} One of the values in {SpreadMode}.\n   */\n  get spreadMode() {\n    return this._spreadMode;\n  }\n\n  /**\n   * @param {number} mode - Group the pages in spreads, starting with odd- or\n   *   even-number pages (unless `SpreadMode.NONE` is used).\n   *   The constants from {SpreadMode} should be used.\n   */\n  set spreadMode(mode) {\n    if (this._spreadMode === mode) {\n      return; // The Spread mode didn't change.\n    }\n    if (!isValidSpreadMode(mode)) {\n      throw new Error(`Invalid spread mode: ${mode}`);\n    }\n    this._spreadMode = mode;\n    this.eventBus.dispatch(\"spreadmodechanged\", { source: this, mode });\n\n    this._updateSpreadMode(/* pageNumber = */ this._currentPageNumber);\n  }\n\n  _updateSpreadMode(pageNumber = null) {\n    if (!this.pdfDocument) {\n      return;\n    }\n    const viewer = this.viewer,\n      pages = this._pages;\n    // Temporarily remove all the pages from the DOM.\n    viewer.textContent = \"\";\n\n    if (this._spreadMode === SpreadMode.NONE) {\n      for (let i = 0, iMax = pages.length; i < iMax; ++i) {\n        viewer.appendChild(pages[i].div);\n      }\n    } else {\n      const parity = this._spreadMode - 1;\n      let spread = null;\n      for (let i = 0, iMax = pages.length; i < iMax; ++i) {\n        if (spread === null) {\n          spread = document.createElement(\"div\");\n          spread.className = \"spread\";\n          viewer.appendChild(spread);\n        } else if (i % 2 === parity) {\n          spread = spread.cloneNode(false);\n          viewer.appendChild(spread);\n        }\n        spread.appendChild(pages[i].div);\n      }\n    }\n\n    if (!pageNumber) {\n      return;\n    }\n    this._setCurrentPageNumber(pageNumber, /* resetCurrentPageView = */ true);\n    this.update();\n  }\n}\n\nexport { BaseViewer };\n","/* Copyright 2014 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { BaseViewer } from \"./base_viewer.js\";\nimport { shadow } from \"pdfjs-lib\";\n\nclass PDFViewer extends BaseViewer {\n  get _viewerElement() {\n    return shadow(this, \"_viewerElement\", this.viewer);\n  }\n\n  _scrollIntoView({ pageDiv, pageSpot = null, pageNumber = null }) {\n    if (!pageSpot && !this.isInPresentationMode) {\n      const left = pageDiv.offsetLeft + pageDiv.clientLeft;\n      const right = left + pageDiv.clientWidth;\n      const { scrollLeft, clientWidth } = this.container;\n      if (\n        this._isScrollModeHorizontal ||\n        left < scrollLeft ||\n        right > scrollLeft + clientWidth\n      ) {\n        pageSpot = { left: 0, top: 0 };\n      }\n    }\n    super._scrollIntoView({ pageDiv, pageSpot, pageNumber });\n  }\n\n  _getVisiblePages() {\n    if (this.isInPresentationMode) {\n      // The algorithm in `getVisibleElements` doesn't work in all browsers and\n      // configurations (e.g. Chrome) when Presentation Mode is active.\n      return this._getCurrentVisiblePage();\n    }\n    return super._getVisiblePages();\n  }\n\n  _updateHelper(visiblePages) {\n    if (this.isInPresentationMode) {\n      return;\n    }\n    let currentId = this._currentPageNumber;\n    let stillFullyVisible = false;\n\n    for (const page of visiblePages) {\n      if (page.percent < 100) {\n        break;\n      }\n      if (page.id === currentId) {\n        stillFullyVisible = true;\n        break;\n      }\n    }\n    if (!stillFullyVisible) {\n      currentId = visiblePages[0].id;\n    }\n    this._setCurrentPageNumber(currentId);\n  }\n}\n\nexport { PDFViewer };\n","import { PDFLinkService } from 'pdfjs-dist/es5/web/pdf_viewer';\r\n\r\nvar pendingOperation = Promise.resolve();\r\n\r\nexport default function(PDFJS) {\r\n\r\n\tfunction isPDFDocumentLoadingTask(obj) {\r\n\r\n\t\treturn typeof(obj) === 'object' && obj !== null && obj.__PDFDocumentLoadingTask === true;\r\n\t\t// or: return obj.constructor.name === 'PDFDocumentLoadingTask';\r\n\t}\r\n\r\n\tfunction createLoadingTask(src, options) {\r\n\r\n\t\tvar source;\r\n\t\tif ( typeof(src) === 'string' )\r\n\t\t\tsource = { url: src };\r\n\t\telse if ( src instanceof Uint8Array )\r\n\t\t\tsource = { data: src };\r\n\t\telse if ( typeof(src) === 'object' && src !== null )\r\n\t\t\tsource = Object.assign({}, src);\r\n\t\telse\r\n\t\t\tthrow new TypeError('invalid src type');\r\n\r\n\t\t// source.verbosity = PDFJS.VerbosityLevel.INFOS;\r\n\t\t// source.pdfBug = true;\r\n\t\t// source.stopAtErrors = true;\r\n\r\n\t\tif ( options && options.withCredentials )\r\n\t\t\tsource.withCredentials = options.withCredentials;\r\n\r\n\t\tvar loadingTask = PDFJS.getDocument(source);\r\n\t\tloadingTask.__PDFDocumentLoadingTask = true; // since PDFDocumentLoadingTask is not public\r\n\r\n\t\tif ( options && options.onPassword )\r\n\t\t\tloadingTask.onPassword = options.onPassword;\r\n\r\n\t\tif ( options && options.onProgress )\r\n\t\t\tloadingTask.onProgress = options.onProgress;\r\n\r\n\t\treturn loadingTask;\r\n\t}\r\n\r\n\r\n\tfunction PDFJSWrapper(canvasElt, annotationLayerElt, emitEvent) {\r\n\r\n\t\tvar pdfDoc = null;\r\n\t\tvar pdfPage = null;\r\n\t\tvar pdfRender = null;\r\n\t\tvar canceling = false;\r\n\r\n\t\tcanvasElt.getContext('2d').save();\r\n\r\n\t\tfunction clearCanvas() {\r\n\r\n\t\t\tcanvasElt.getContext('2d').clearRect(0, 0, canvasElt.width, canvasElt.height);\r\n\t\t}\r\n\r\n\t\tfunction clearAnnotations() {\r\n\r\n\t\t\twhile ( annotationLayerElt.firstChild )\r\n\t\t\t\tannotationLayerElt.removeChild(annotationLayerElt.firstChild);\r\n\t\t}\r\n\r\n\t\tthis.destroy = function() {\r\n\r\n\t\t\tif ( pdfDoc === null )\r\n\t\t\t\treturn;\r\n\r\n\t\t\t// Aborts all network requests and destroys worker.\r\n\t\t\tpendingOperation = pdfDoc.destroy();\r\n\t\t\tpdfDoc = null;\r\n\t\t}\r\n\r\n\t\tthis.getResolutionScale = function() {\r\n\r\n\t\t\treturn canvasElt.offsetWidth / canvasElt.width;\r\n\t\t}\r\n\r\n\t\tthis.printPage = function(dpi, pageNumberOnly) {\r\n\r\n\t\t\tif ( pdfPage === null )\r\n\t\t\t\treturn;\r\n\r\n\t\t\t// 1in == 72pt\r\n\t\t\t// 1in == 96px\r\n\t\t\tvar PRINT_RESOLUTION = dpi === undefined ? 150 : dpi;\r\n\t\t\tvar PRINT_UNITS = PRINT_RESOLUTION / 72.0;\r\n\t\t\tvar CSS_UNITS = 96.0 / 72.0;\r\n\r\n\t\t\tvar iframeElt = document.createElement('iframe');\r\n\r\n\t\t\tfunction removeIframe() {\r\n\r\n\t\t\t\tiframeElt.parentNode.removeChild(iframeElt);\r\n\t\t\t}\r\n\r\n\t\t\tnew Promise(function(resolve, reject) {\r\n\r\n\t\t\t\tiframeElt.frameBorder = '0';\r\n\t\t\t\tiframeElt.scrolling = 'no';\r\n\t\t\t\tiframeElt.width = '0px;'\r\n\t\t\t\tiframeElt.height = '0px;'\r\n\t\t\t\tiframeElt.style.cssText = 'position: absolute; top: 0; left: 0';\r\n\r\n\t\t\t\tiframeElt.onload = function() {\r\n\r\n\t\t\t\t\tresolve(this.contentWindow);\r\n\t\t\t\t}\r\n\r\n\t\t\t\twindow.document.body.appendChild(iframeElt);\r\n\t\t\t})\r\n\t\t\t.then(function(win) {\r\n\r\n\t\t\t\twin.document.title = '';\r\n\r\n\t\t\t\treturn pdfDoc.getPage(1)\r\n\t\t\t\t.then(function(page) {\r\n\r\n\t\t\t\t\tvar viewport = page.getViewport({ scale: 1 });\r\n\t\t\t\t\twin.document.head.appendChild(win.document.createElement('style')).textContent =\r\n\t\t\t\t\t\t'@supports ((size:A4) and (size:1pt 1pt)) {' +\r\n\t\t\t\t\t\t\t'@page { margin: 1pt; size: ' + ((viewport.width * PRINT_UNITS) / CSS_UNITS) + 'pt ' + ((viewport.height * PRINT_UNITS) / CSS_UNITS) + 'pt; }' +\r\n\t\t\t\t\t\t'}' +\r\n\r\n\t\t\t\t\t\t'@media print {' +\r\n\t\t\t\t\t\t\t'body { margin: 0 }' +\r\n\t\t\t\t\t\t\t'canvas { page-break-before: avoid; page-break-after: always; page-break-inside: avoid }' +\r\n\t\t\t\t\t\t'}'+\r\n\r\n\t\t\t\t\t\t'@media screen {' +\r\n\t\t\t\t\t\t\t'body { margin: 0 }' +\r\n\t\t\t\t\t\t'}'+\r\n\r\n\t\t\t\t\t\t''\r\n\t\t\t\t\treturn win;\r\n\t\t\t\t})\r\n\t\t\t})\r\n\t\t\t.then(function(win) {\r\n\r\n\t\t\t\tvar allPages = [];\r\n\r\n\t\t\t\tfor ( var pageNumber = 1; pageNumber <= pdfDoc.numPages; ++pageNumber ) {\r\n\r\n\t\t\t\t\tif ( pageNumberOnly !== undefined && pageNumberOnly.indexOf(pageNumber) === -1 )\r\n\t\t\t\t\t\tcontinue;\r\n\r\n\t\t\t\t\tallPages.push(\r\n\t\t\t\t\t\tpdfDoc.getPage(pageNumber)\r\n\t\t\t\t\t\t.then(function(page) {\r\n\r\n\t\t\t\t\t\t\tvar viewport = page.getViewport({ scale: 1 });\r\n\r\n\t\t\t\t\t\t\tvar printCanvasElt = win.document.body.appendChild(win.document.createElement('canvas'));\r\n\t\t\t\t\t\t\tprintCanvasElt.width = (viewport.width * PRINT_UNITS);\r\n\t\t\t\t\t\t\tprintCanvasElt.height = (viewport.height * PRINT_UNITS);\r\n\r\n\t\t\t\t\t\t\treturn page.render({\r\n\t\t\t\t\t\t\t\tcanvasContext: printCanvasElt.getContext('2d'),\r\n\t\t\t\t\t\t\t\ttransform: [ // Additional transform, applied just before viewport transform.\r\n\t\t\t\t\t\t\t\t\tPRINT_UNITS, 0, 0,\r\n\t\t\t\t\t\t\t\t\tPRINT_UNITS, 0, 0\r\n\t\t\t\t\t\t\t\t],\r\n\t\t\t\t\t\t\t\tviewport: viewport,\r\n\t\t\t\t\t\t\t\tintent: 'print'\r\n\t\t\t\t\t\t\t}).promise;\r\n\t\t\t\t\t\t})\r\n\t\t\t\t\t);\r\n\t\t\t\t}\r\n\r\n\t\t\t\tPromise.all(allPages)\r\n\t\t\t\t.then(function() {\r\n\r\n\t\t\t\t\twin.focus(); // Required for IE\r\n\t\t\t\t\tif (win.document.queryCommandSupported('print')) {\r\n\t\t\t\t\t\twin.document.execCommand('print', false, null);\r\n\t\t\t\t\t\t} else {\r\n\t\t\t\t\t\twin.print();\r\n\t\t\t\t\t  }\r\n\t\t\t\t\tremoveIframe();\r\n\t\t\t\t})\r\n\t\t\t\t.catch(function(err) {\r\n\r\n\t\t\t\t\tremoveIframe();\r\n\t\t\t\t\temitEvent('error', err);\r\n\t\t\t\t})\r\n\t\t\t})\r\n\t\t}\r\n\r\n\t\tthis.renderPage = function(rotate) {\r\n\t\t\tif ( pdfRender !== null ) {\r\n\r\n\t\t\t\tif ( canceling )\r\n\t\t\t\t\treturn;\r\n\t\t\t\tcanceling = true;\r\n\t\t\t\tpdfRender.cancel().catch(function(err) {\r\n\t\t\t\t\temitEvent('error', err);\r\n\t\t\t\t});\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\tif ( pdfPage === null )\r\n\t\t\t\treturn;\r\n\r\n\t\t\tvar pageRotate = (pdfPage.rotate === undefined ? 0 : pdfPage.rotate) + (rotate === undefined ? 0 : rotate);\r\n\r\n\t\t\tvar scale = canvasElt.offsetWidth / pdfPage.getViewport({ scale: 1 }).width * (window.devicePixelRatio || 1);\r\n\t\t\tvar viewport = pdfPage.getViewport({ scale: scale, rotation:pageRotate });\r\n\r\n\t\t\temitEvent('page-size', viewport.width, viewport.height, scale);\r\n\r\n\t\t\tcanvasElt.width = viewport.width;\r\n\t\t\tcanvasElt.height = viewport.height;\r\n\r\n\t\t\tpdfRender = pdfPage.render({\r\n\t\t\t\tcanvasContext: canvasElt.getContext('2d'),\r\n\t\t\t\tviewport: viewport\r\n\t\t\t});\r\n\r\n\t\t\tannotationLayerElt.style.visibility = 'hidden';\r\n\t\t\tclearAnnotations();\r\n\r\n\t\t\tvar viewer = {\r\n\t\t\t\tscrollPageIntoView: function(params) {\r\n\t\t\t\t\temitEvent('link-clicked', params.pageNumber)\r\n\t\t\t\t},\r\n\t\t\t};\r\n\r\n\t\t\tvar linkService = new PDFLinkService();\r\n\t\t\tlinkService.setDocument(pdfDoc);\r\n\t\t\tlinkService.setViewer(viewer);\r\n\r\n\t\t\tpendingOperation = pendingOperation.then(function() {\r\n\r\n\t\t\t\tvar getAnnotationsOperation =\r\n\t\t\t\tpdfPage.getAnnotations({ intent: 'display' })\r\n\t\t\t\t.then(function(annotations) {\r\n\r\n\t\t\t\t\tPDFJS.AnnotationLayer.render({\r\n\t\t\t\t\t\tviewport: viewport.clone({ dontFlip: true }),\r\n\t\t\t\t\t\tdiv: annotationLayerElt,\r\n\t\t\t\t\t\tannotations: annotations,\r\n\t\t\t\t\t\tpage: pdfPage,\r\n\t\t\t\t\t\tlinkService: linkService,\r\n\t\t\t\t\t\trenderInteractiveForms: false\r\n\t\t\t\t\t});\r\n\t\t\t\t});\r\n\r\n\t\t\t\tvar pdfRenderOperation =\r\n\t\t\t\tpdfRender.promise\r\n\t\t\t\t.then(function() {\r\n\r\n\t\t\t\t\tannotationLayerElt.style.visibility = '';\r\n\t\t\t\t\tcanceling = false;\r\n\t\t\t\t\tpdfRender = null;\r\n\t\t\t\t})\r\n\t\t\t\t.catch(function(err) {\r\n\r\n\t\t\t\t\tpdfRender = null;\r\n\t\t\t\t\tif ( err instanceof PDFJS.RenderingCancelledException ) {\r\n\r\n\t\t\t\t\t\tcanceling = false;\r\n\t\t\t\t\t\tthis.renderPage(rotate);\r\n\t\t\t\t\t\treturn;\r\n\t\t\t\t\t}\r\n\t\t\t\t\temitEvent('error', err);\r\n\t\t\t\t}.bind(this))\r\n\r\n\t\t\t\treturn Promise.all([getAnnotationsOperation, pdfRenderOperation]);\r\n\t\t\t}.bind(this));\r\n\t\t}\r\n\r\n\r\n\t\tthis.forEachPage = function(pageCallback) {\r\n\r\n\t\t\tvar numPages = pdfDoc.numPages;\r\n\r\n\t\t\t(function next(pageNum) {\r\n\r\n\t\t\t\tpdfDoc.getPage(pageNum)\r\n\t\t\t\t.then(pageCallback)\r\n\t\t\t\t.then(function() {\r\n\r\n\t\t\t\t\tif ( ++pageNum <= numPages )\r\n\t\t\t\t\t\tnext(pageNum);\r\n\t\t\t\t})\r\n\t\t\t})(1);\r\n\t\t}\r\n\r\n\r\n\t\tthis.loadPage = function(pageNumber, rotate) {\r\n\r\n\t\t\tpdfPage = null;\r\n\r\n\t\t\tif ( pdfDoc === null )\r\n\t\t\t\treturn;\r\n\r\n\t\t\tpendingOperation = pendingOperation.then(function() {\r\n\r\n\t\t\t\treturn pdfDoc.getPage(pageNumber);\r\n\t\t\t})\r\n\t\t\t.then(function(page) {\r\n\r\n\t\t\t\tpdfPage = page;\r\n\t\t\t\tthis.renderPage(rotate);\r\n\t\t\t\temitEvent('page-loaded', page.pageNumber);\r\n\t\t\t}.bind(this))\r\n\t\t\t.catch(function(err) {\r\n\r\n\t\t\t\tclearCanvas();\r\n\t\t\t\tclearAnnotations();\r\n\t\t\t\temitEvent('error', err);\r\n\t\t\t});\r\n\t\t}\r\n\r\n\t\tthis.loadDocument = function(src) {\r\n\r\n\t\t\tpdfDoc = null;\r\n\t\t\tpdfPage = null;\r\n\r\n\t\t\temitEvent('num-pages', undefined);\r\n\r\n\t\t\tif ( !src ) {\r\n\r\n\t\t\t\tcanvasElt.removeAttribute('width');\r\n\t\t\t\tcanvasElt.removeAttribute('height');\r\n\t\t\t\tclearAnnotations();\r\n\t\t\t\treturn;\r\n\t\t\t}\r\n\r\n\t\t\t// wait for pending operation ends\r\n\t\t\tpendingOperation = pendingOperation.then(function() {\r\n\r\n\t\t\t\tvar loadingTask;\r\n\t\t\t\tif ( isPDFDocumentLoadingTask(src) ) {\r\n\r\n\t\t\t\t\tif ( src.destroyed ) {\r\n\r\n\t\t\t\t\t\temitEvent('error', new Error('loadingTask has been destroyed'));\r\n\t\t\t\t\t\treturn\r\n\t\t\t\t\t}\r\n\r\n\t\t\t\t\tloadingTask = src;\r\n\t\t\t\t} else {\r\n\r\n\t\t\t\t\tloadingTask = createLoadingTask(src, {\r\n\t\t\t\t\t\tonPassword: function(updatePassword, reason) {\r\n\r\n\t\t\t\t\t\t\tvar reasonStr;\r\n\t\t\t\t\t\t\tswitch (reason) {\r\n\t\t\t\t\t\t\t\tcase PDFJS.PasswordResponses.NEED_PASSWORD:\r\n\t\t\t\t\t\t\t\t\treasonStr = 'NEED_PASSWORD';\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t\tcase PDFJS.PasswordResponses.INCORRECT_PASSWORD:\r\n\t\t\t\t\t\t\t\t\treasonStr = 'INCORRECT_PASSWORD';\r\n\t\t\t\t\t\t\t\t\tbreak;\r\n\t\t\t\t\t\t\t}\r\n\t\t\t\t\t\t\temitEvent('password', updatePassword, reasonStr);\r\n\t\t\t\t\t\t},\r\n\t\t\t\t\t\tonProgress: function(status) {\r\n\r\n\t\t\t\t\t\t\tvar ratio = status.loaded / status.total;\r\n\t\t\t\t\t\t\temitEvent('progress', Math.min(ratio, 1));\r\n\t\t\t\t\t\t}\r\n\t\t\t\t\t});\r\n\t\t\t\t}\r\n\r\n\t\t\t\treturn loadingTask.promise;\r\n\t\t\t})\r\n\t\t\t.then(function(pdf) {\r\n\r\n\t\t\t\tpdfDoc = pdf;\r\n\t\t\t\temitEvent('num-pages', pdf.numPages);\r\n\t\t\t\temitEvent('loaded');\r\n\t\t\t})\r\n\t\t\t.catch(function(err) {\r\n\r\n\t\t\t\tclearCanvas();\r\n\t\t\t\tclearAnnotations();\r\n\t\t\t\temitEvent('error', err);\r\n\t\t\t})\r\n\t\t}\r\n\r\n\t\tannotationLayerElt.style.transformOrigin = '0 0';\r\n\t}\r\n\r\n\treturn {\r\n\t\tcreateLoadingTask: createLoadingTask,\r\n\t\tPDFJSWrapper: PDFJSWrapper,\r\n\t}\r\n}\r\n"],"names":["render","staticRenderFns","props","initial","type","default","data","size","width","height","methods","reset","expand","shrink","update","watch","deep","handler","style","on","create","scroll","beforeDestroy","mounted","removeOnresizeEvent","component","pdfjsWrapper","createLoadingTask","PDFJSWrapper","h","attrs","ref","class","resizeSensor","resize","this","src","String","Object","Uint8Array","page","Number","rotate","pdf","loadDocument","loadPage","renderPage","$el","parentNode","$refs","canvas","offsetWidth","resolutionScale","getResolutionScale","print","dpi","pageList","printPage","annotationLayer","$emit","bind","$on","destroyed","destroy","PDFJS","module","exports","Worker","root","i","l","modules","__w_pdfjs_require__","enumerable","value","require","isNodeJS","PDFNodeStream","setPDFNetworkStreamFactory","params","PDFFetchStream","PDFNetworkStream","isValidFetchUrl","url","DEFAULT_LINK_REL","SVG_NS","BaseCanvasFactory","constructor","unreachable","canvasAndContext","context","DOMCanvasFactory","ownerDocument","globalThis","document","_this","_document","createElement","getContext","BaseCMapReaderFactory","baseUrl","isCompressed","name","NONE","compressionType","CMapCompressionType","BINARY","_fetchData","reason","_this2","DOMCMapReaderFactory","isFetchSupported","baseURI","fetch","response","ok","statusText","_this3","arrayBuffer","cMapData","stringToBytes","text","request","XMLHttpRequest","open","responseType","onreadystatechange","readyState","DONE","status","responseText","resolve","reject","Error","send","DOMSVGFactory","assert","svg","createElementNS","setAttribute","PageViewport","viewBox","scale","rotation","offsetX","offsetY","dontFlip","rotateD","offsetCanvasY","centerX","centerY","rotateA","rotateB","rotateC","offsetCanvasX","Math","abs","transform","clone","slice","convertToViewportPoint","_util","x","convertToViewportRectangle","topLeft","rect","bottomRight","convertToPdfPoint","RenderingCancelledException","_this4","msg","LinkTarget","SELF","BLANK","PARENT","TOP","addLinkAttributes","link","target","rel","enabled","urlNullRemoved","removeNullCharacters","href","title","onclick","targetStr","getFilenameFromUrl","anchor","indexOf","query","end","min","length","lastIndexOf","pdfDateStringRegex","StatTimer","started","times","time","warn","Date","now","timeEnd","push","start","outBuf","longest","_time","duration","Response","prototype","ReadableStream","URL","protocol","loadScript","script","onload","onerror","documentElement","appendChild","deprecated","details","PDFDateString","input","isString","RegExp","matches","exec","year","parseInt","month","day","hour","minute","second","universalTimeRelation","offsetHour","offsetMinute","UTC","runtime","undefined","Op","hasOwn","hasOwnProperty","$Symbol","Symbol","iteratorSymbol","iterator","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","obj","defineProperty","configurable","writable","key","wrap","innerFn","protoGenerator","outerFn","Generator","generator","Context","tryLocsList","_invoke","makeInvokeMethod","tryCatch","fn","arg","call","err","GenStateSuspendedStart","GenStateSuspendedYield","GenStateExecuting","GenStateCompleted","ContinueSentinel","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","getPrototypeOf","NativeIteratorPrototype","values","Gp","defineIteratorMethods","method","AsyncIterator","invoke","record","result","_typeof","PromiseImpl","__await","unwrapped","error","previousPromise","enqueue","callInvokeWithMethodAndArg","then","state","doneResult","delegate","delegateResult","maybeInvokeDelegate","sent","_sent","dispatchException","abrupt","done","TypeError","info","next","nextLoc","pushTryEntry","locs","entry","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","forEach","iterable","iteratorMethod","isNaN","displayName","isGeneratorFunction","genFun","ctor","mark","setPrototypeOf","__proto__","awrap","async","Promise","iter","toString","keys","object","reverse","pop","prev","skipTempReset","charAt","stop","rootEntry","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","finish","thrown","delegateYield","resultName","regeneratorRuntime","Function","webpackPolyfill","deprecate","paths","children","get","IDENTITY_MATRIX","FONT_IDENTITY_MATRIX","PermissionFlag","PRINT","MODIFY_CONTENTS","COPY","MODIFY_ANNOTATIONS","FILL_INTERACTIVE_FORMS","COPY_FOR_ACCESSIBILITY","ASSEMBLE","PRINT_HIGH_QUALITY","TextRenderingMode","FILL","STROKE","FILL_STROKE","INVISIBLE","FILL_ADD_TO_PATH","STROKE_ADD_TO_PATH","FILL_STROKE_ADD_TO_PATH","ADD_TO_PATH","FILL_STROKE_MASK","ADD_TO_PATH_FLAG","ImageKind","GRAYSCALE_1BPP","RGB_24BPP","RGBA_32BPP","AnnotationType","TEXT","LINK","FREETEXT","LINE","SQUARE","CIRCLE","POLYGON","POLYLINE","HIGHLIGHT","UNDERLINE","SQUIGGLY","STRIKEOUT","STAMP","CARET","INK","POPUP","FILEATTACHMENT","SOUND","MOVIE","WIDGET","SCREEN","PRINTERMARK","TRAPNET","WATERMARK","THREED","REDACT","AnnotationStateModelType","MARKED","REVIEW","AnnotationMarkedState","UNMARKED","AnnotationReviewState","ACCEPTED","REJECTED","CANCELLED","COMPLETED","AnnotationReplyType","GROUP","REPLY","AnnotationFlag","HIDDEN","NOZOOM","NOROTATE","NOVIEW","READONLY","LOCKED","TOGGLENOVIEW","LOCKEDCONTENTS","AnnotationFieldFlag","REQUIRED","NOEXPORT","MULTILINE","PASSWORD","NOTOGGLETOOFF","RADIO","PUSHBUTTON","COMBO","EDIT","SORT","FILESELECT","MULTISELECT","DONOTSPELLCHECK","DONOTSCROLL","COMB","RICHTEXT","RADIOSINUNISON","COMMITONSELCHANGE","AnnotationBorderStyleType","SOLID","DASHED","BEVELED","INSET","StreamType","UNKNOWN","FLATE","LZW","DCT","JPX","JBIG","A85","AHX","CCF","RLX","FontType","TYPE1","TYPE1C","CIDFONTTYPE0","CIDFONTTYPE0C","TRUETYPE","CIDFONTTYPE2","TYPE3","OPENTYPE","TYPE0","MMTYPE1","VerbosityLevel","ERRORS","WARNINGS","INFOS","STREAM","OPS","dependency","setLineWidth","setLineCap","setLineJoin","setMiterLimit","setDash","setRenderingIntent","setFlatness","setGState","save","restore","moveTo","lineTo","curveTo","curveTo2","curveTo3","closePath","rectangle","stroke","closeStroke","fill","eoFill","fillStroke","eoFillStroke","closeFillStroke","closeEOFillStroke","endPath","clip","eoClip","beginText","endText","setCharSpacing","setWordSpacing","setHScale","setLeading","setFont","setTextRenderingMode","setTextRise","moveText","setLeadingMoveText","setTextMatrix","nextLine","showText","showSpacedText","nextLineShowText","nextLineSetSpacingShowText","setCharWidth","setCharWidthAndBounds","setStrokeColorSpace","setFillColorSpace","setStrokeColor","setStrokeColorN","setFillColor","setFillColorN","setStrokeGray","setFillGray","setStrokeRGBColor","setFillRGBColor","setStrokeCMYKColor","setFillCMYKColor","shadingFill","beginInlineImage","beginImageData","endInlineImage","paintXObject","markPoint","markPointProps","beginMarkedContent","beginMarkedContentProps","endMarkedContent","beginCompat","endCompat","paintFormXObjectBegin","paintFormXObjectEnd","beginGroup","endGroup","beginAnnotations","endAnnotations","beginAnnotation","endAnnotation","paintJpegXObject","paintImageMaskXObject","paintImageMaskXObjectGroup","paintImageXObject","paintInlineImageXObject","paintInlineImageXObjectGroup","paintImageXObjectRepeat","paintImageMaskXObjectRepeat","paintSolidColorImageMask","constructPath","UNSUPPORTED_FEATURES","unknown","forms","javaScript","smask","shadingPattern","font","errorTilingPattern","errorExtGState","errorXObject","errorFontLoadType3","errorFontState","errorFontMissing","errorFontTranslate","errorColorSpace","errorOperatorList","errorFontToUnicode","errorFontLoadNative","errorFontGetPath","errorMarkedContent","PasswordResponses","NEED_PASSWORD","INCORRECT_PASSWORD","verbosity","setVerbosityLevel","level","isInteger","getVerbosityLevel","cond","isSameOrigin","base","origin","other","otherUrl","_isValidProtocol","createValidAbsoluteUrl","absoluteUrl","shadow","BaseException","message","PasswordException","code","UnknownErrorException","InvalidPDFException","MissingPDFException","UnexpectedResponseException","FormatError","AbortException","NullCharactersRegExp","str","bytesToString","bytes","MAX_ARGUMENT_COUNT","strBuf","chunkEnd","chunk","subarray","fromCharCode","apply","charCodeAt","arrayByteLength","arr","byteLength","arraysToBytes","resultLength","pos","item","_i","itemLength","set","string32","isLittleEndian","buffer8","view32","Uint32Array","buffer","IsLittleEndianCached","isEvalSupported","IsEvalSupportedCached","rgbBuf","Util","r","g","b","m1","m2","p","m","xt","yt","d","p1","applyTransform","p2","p3","p4","max","v","transpose","a","c","first","sqrt","sx","sy","rect1","rect2","compare","orderedX","orderedY","normalizeRect","PDFStringTranslateTable","stringToPDFString","_i2","_i3","escapeString","stringToUTF8String","decodeURIComponent","escape","utf8StringToString","unescape","encodeURIComponent","isBool","isNum","isArrayBuffer","isArrayEqual","arr1","arr2","element","index","getModificationDate","date","getUTCFullYear","padStart","getUTCHours","getUTCMinutes","getUTCSeconds","createPromiseCapability","capability","isSettled","promise","createObjectURL","digits","forceDataSchema","blob","Blob","contentType","ii","b1","b2","b3","d1","d2","d3","d4","_pdfjsCompatibilityChecked","hasDOM","userAgent","navigator","isIE","test","btoa","_is_node","Buffer","atob","Element","remove","removeChild","div","classList","add","contains","OriginalDOMTokenListAdd","DOMTokenList","OriginalDOMTokenListRemove","tokens","token","toggle","force","arguments","OriginalPushState","window","history","pushState","OriginalReplaceState","replaceState","args","startsWith","endsWith","includes","Array","from","assign","fromEntries","log2","allSettled","isReadableStreamSupported","controller","close","Map","entries","Set","WeakMap","WeakSet","codePointAt","fromCodePoint","padEnd","process","versions","nw","electron","$","global","getOwnPropertyDescriptor","f","createNonEnumerableProperty","redefine","setGlobal","copyConstructorProperties","isForced","options","source","FORCED","targetProperty","sourceProperty","descriptor","TARGET","GLOBAL","STATIC","stat","noTargetGet","forced","sham","check","it","self","DESCRIPTORS","propertyIsEnumerableModule","createPropertyDescriptor","toIndexedObject","toPrimitive","has","IE8_DOM_DEFINE","nativeGetOwnPropertyDescriptor","O","P","fails","nativePropertyIsEnumerable","propertyIsEnumerable","NASHORN_BUG","V","bitmap","IndexedObject","requireObjectCoercible","classof","split","isObject","PREFERRED_STRING","val","valueOf","EXISTS","definePropertyModule","anObject","nativeDefineProperty","Attributes","inspectSource","InternalStateModule","getInternalState","enforceInternalState","enforce","TEMPLATE","unsafe","simple","join","store","functionToString","SHARED","NATIVE_WEAK_MAP","objectHas","sharedKey","hiddenKeys","getterFor","TYPE","wmget","wmhas","wmset","metadata","STATE","shared","uid","IS_PURE","version","mode","copyright","id","postfix","random","ownKeys","getOwnPropertyDescriptorModule","getBuiltIn","getOwnPropertyNamesModule","getOwnPropertySymbolsModule","getOwnPropertySymbols","concat","path","aFunction","variable","namespace","internalObjectKeys","enumBugKeys","getOwnPropertyNames","names","toLength","toAbsoluteIndex","createMethod","IS_INCLUDES","$this","el","fromIndex","toInteger","argument","ceil","floor","integer","replacement","feature","detection","normalize","POLYFILL","NATIVE","string","replace","toLowerCase","entryUnbind","notARegExp","correctIsRegExpLogic","nativeStartsWith","CORRECT_IS_REGEXP_LOGIC","MDN_POLYFILL_BUG","proto","searchString","that","search","isRegExp","wellKnownSymbol","MATCH","NATIVE_SYMBOL","USE_SYMBOL_AS_UID","WellKnownSymbolsStore","createWellKnownSymbol","withoutSetter","METHOD_NAME","regexp","e","CONSTRUCTOR","METHOD","nativeEndsWith","endPosition","len","$includes","addToUnscopables","arrayMethodUsesToLength","USES_TO_LENGTH","ACCESSORS","UNSCOPABLES","ArrayPrototype","activeXDocument","defineProperties","html","documentCreateElement","GT","LT","PROTOTYPE","SCRIPT","IE_PROTO","EmptyConstructor","scriptTag","content","NullProtoObjectViaActiveX","write","temp","parentWindow","NullProtoObjectViaIFrame","iframeDocument","iframe","JS","display","contentWindow","F","NullProtoObject","domain","ActiveXObject","Properties","objectKeys","cache","thrower","argument0","argument1","defineIterator","STRING_ITERATOR","setInternalState","iterated","point","CONVERT_TO_STRING","S","position","codeAt","createIteratorConstructor","setToStringTag","Iterators","IteratorsCore","BUGGY_SAFARI_ITERATORS","ITERATOR","KEYS","VALUES","ENTRIES","returnThis","Iterable","NAME","IteratorConstructor","DEFAULT","IS_SET","CurrentIteratorPrototype","KEY","getIterationMethod","KIND","defaultIterator","IterablePrototype","TO_STRING_TAG","INCORRECT_VALUES_NAME","nativeIterator","anyNativeIterator","PrototypeOfArrayIteratorPrototype","arrayIterator","toObject","CORRECT_PROTOTYPE_GETTER","ObjectPrototype","TAG","aPossiblePrototype","setter","CORRECT_SETTER","checkCorrectnessOfIteration","INCORRECT_ITERATION","callWithSafeIterationClosing","isArrayIteratorMethod","createProperty","getIteratorMethod","arrayLike","step","C","argumentsLength","mapfn","mapping","returnMethod","propertyKey","TO_STRING_TAG_SUPPORT","classofRaw","CORRECT_ARGUMENTS","tryGet","tag","callee","SAFE_CLOSING","called","iteratorWithReturn","SKIP_CLOSING","ITERATION_SUPPORT","nativeAssign","A","B","symbol","alphabet","chr","T","j","ARRAY_ITERATOR","kind","Arguments","iterate","k","Result","stopped","AS_ENTRIES","IS_ITERATOR","iterFn","boundFunction","log","LN2","number","isFinite","ArrayBufferViewCore","speciesConstructor","aTypedArray","aTypedArrayConstructor","exportTypedArrayMethod","$slice","Int8Array","list","NATIVE_ARRAY_BUFFER","Int8ArrayPrototype","Uint8ClampedArray","Uint8ClampedArrayPrototype","TypedArray","TypedArrayPrototype","isPrototypeOf","TYPED_ARRAY_TAG","NATIVE_ARRAY_BUFFER_VIEWS","opera","TYPED_ARRAY_TAG_REQIRED","TypedArrayConstructorsList","Int16Array","Uint16Array","Int32Array","Float32Array","Float64Array","isView","klass","isTypedArray","ARRAY","TypedArrayConstructor","property","exportTypedArrayStaticMethod","ArrayBuffer","DataView","SPECIES","defaultConstructor","DOMIterables","ArrayIteratorMethods","ArrayValues","COLLECTION_NAME","Collection","CollectionPrototype","CSSRuleList","CSSStyleDeclaration","CSSValueList","ClientRectList","DOMRectList","DOMStringList","DataTransferItemList","FileList","HTMLAllCollection","HTMLCollection","HTMLFormElement","HTMLSelectElement","MediaList","MimeTypeArray","NamedNodeMap","NodeList","PaintRequestList","Plugin","PluginArray","SVGLengthList","SVGNumberList","SVGPathSegList","SVGPointList","SVGStringList","SVGTransformList","SourceBufferList","StyleSheetList","TextTrackCueList","TextTrackList","TouchList","Internal","OwnPromiseCapability","PromiseWrapper","nativeThen","NativePromise","redefineAll","setSpecies","anInstance","task","microtask","promiseResolve","hostReportErrors","newPromiseCapabilityModule","perform","V8_VERSION","PROMISE","getInternalPromiseState","PromiseConstructor","$fetch","newPromiseCapability","newGenericPromiseCapability","IS_NODE","DISPATCH_EVENT","createEvent","dispatchEvent","UNHANDLED_REJECTION","REJECTION_HANDLED","PENDING","FULFILLED","HANDLED","UNHANDLED","GLOBAL_CORE_JS_PROMISE","PromiseRejectionEvent","FakePromise","all","isThenable","notify","isReject","notified","chain","reactions","exited","reaction","fail","rejection","onHandleUnhandled","enter","exit","onUnhandled","event","initEvent","IS_UNHANDLED","isUnhandled","emit","parent","unwrap","internalReject","internalResolve","wrapper","executor","onFulfilled","onRejected","$promiseResolve","counter","remaining","alreadyCalled","race","CONSTRUCTOR_NAME","Constructor","defer","channel","port","IS_IOS","location","setImmediate","clear","clearImmediate","MessageChannel","Dispatch","queue","ONREADYSTATECHANGE","run","runner","listener","post","postMessage","host","nextTick","port2","port1","onmessage","addEventListener","importScripts","setTimeout","flush","head","last","node","macrotask","MutationObserver","WebKitMutationObserver","queueMicrotaskDescriptor","queueMicrotask","createTextNode","observe","characterData","promiseCapability","PromiseCapability","$$resolve","$$reject","console","match","v8","NON_GENERIC","real","onFinally","isFunction","EOF","USE_NATIVE_URL","arrayFrom","toASCII","URLSearchParamsModule","NativeURL","URLSearchParams","getInternalSearchParamsState","getState","getInternalURLState","pow","INVALID_AUTHORITY","INVALID_SCHEME","INVALID_HOST","INVALID_PORT","ALPHA","ALPHANUMERIC","DIGIT","HEX_START","OCT","DEC","HEX","FORBIDDEN_HOST_CODE_POINT","FORBIDDEN_HOST_CODE_POINT_EXCLUDING_PERCENT","LEADING_AND_TRAILING_C0_CONTROL_OR_SPACE","TAB_AND_NEW_LINE","parseHost","codePoints","parseIPv6","isSpecial","parseIPv4","percentEncode","C0ControlPercentEncodeSet","partsLength","numbers","part","radix","ipv4","parts","numbersSeen","ipv4Piece","swaps","swap","address","pieceIndex","compress","pointer","char","findLongestZeroSequence","ipv6","maxIndex","maxLength","currStart","currLength","serializeHost","ignore0","unshift","fragmentPercentEncodeSet","pathPercentEncodeSet","userinfoPercentEncodeSet","specialSchemes","ftp","file","http","https","ws","wss","scheme","includesCredentials","username","password","cannotHaveUsernamePasswordPort","cannotBeABaseURL","isWindowsDriveLetter","normalized","startsWithWindowsDriveLetter","third","shortenURLsPath","pathSize","isSingleDot","segment","isDoubleDot","SCHEME_START","SCHEME","NO_SCHEME","SPECIAL_RELATIVE_OR_AUTHORITY","PATH_OR_AUTHORITY","RELATIVE","RELATIVE_SLASH","SPECIAL_AUTHORITY_SLASHES","SPECIAL_AUTHORITY_IGNORE_SLASHES","AUTHORITY","HOST","HOSTNAME","PORT","FILE","FILE_SLASH","FILE_HOST","PATH_START","PATH","CANNOT_BE_A_BASE_URL_PATH","QUERY","FRAGMENT","parseURL","stateOverride","bufferCodePoints","failure","seenAt","seenBracket","seenPasswordToken","fragment","codePoint","encodedCodePoints","shift","URLConstructor","baseState","urlString","searchParams","searchParamsState","updateSearchParams","updateURL","serializeURL","getOrigin","getProtocol","getUsername","getPassword","getHost","hostname","getHostname","getPort","pathname","getPathname","getSearch","getSearchParams","hash","getHash","URLPrototype","output","accessorDescriptor","getter","nativeCreateObjectURL","nativeRevokeObjectURL","revokeObjectURL","toJSON","sort","maxInt","tMin","tMax","skew","damp","initialBias","initialN","delimiter","regexNonASCII","regexSeparators","OVERFLOW_ERROR","baseMinusTMin","stringFromCharCode","ucs2decode","extra","digitToBasic","digit","adapt","delta","numPoints","firstTime","encode","currentValue","inputLength","n","bias","basicLength","handledCPCount","handledCPCountPlusOne","RangeError","q","t","qMinusT","baseMinusT","label","encoded","labels","getIterator","Headers","URL_SEARCH_PARAMS","URL_SEARCH_PARAMS_ITERATOR","getInternalParamsState","getInternalIteratorState","plus","sequences","percentSequence","percentDecode","sequence","deserialize","find","replacer","serialize","parseSearchParams","attribute","attributes","validateArgumentsLength","passed","required","URLSearchParamsIterator","URLSearchParamsConstructor","entryIterator","entryNext","init","URLSearchParamsPrototype","append","splice","getAll","found","entriesIndex","sliceIndex","callback","body","headers","factory","SymbolPolyfill","description","noop","NumberIsNaN","rethrowAssertionErrorRejection","typeIsObject","createArrayFromList","elements","ArrayBufferCopy","dest","destOffset","srcOffset","IsFiniteNonNegativeNumber","IsNonNegativeNumber","Infinity","Call","CreateAlgorithmFromUnderlyingMethod","underlyingObject","methodName","algoArgCount","extraArgs","PromiseCall","fullArgs","promiseResolvedWith","InvokeOrNoop","promiseRejectedWith","TransferArrayBuffer","IsDetachedBuffer","ValidateAndNormalizeHighWaterMark","highWaterMark","MakeSizeAlgorithmFromSizeFunction","originalPromise","originalPromiseThen","originalPromiseResolve","originalPromiseReject","newPromise","PerformPromiseThen","uponPromise","uponFulfillment","uponRejection","transformPromiseWith","fulfillmentHandler","rejectionHandler","setPromiseIsHandledToTrue","QUEUE_MAX_ARRAY_SIZE","SimpleQueue","_cursor","_size","_front","_elements","_next","_back","oldBack","newBack","oldFront","newFront","oldCursor","newCursor","peek","front","cursor","ReadableStreamCreateReadResult","forAuthorCode","ReadableStreamReaderGenericInitialize","reader","stream","_forAuthorCode","_ownerReadableStream","_reader","_state","defaultReaderClosedPromiseInitialize","defaultReaderClosedPromiseInitializeAsResolved","defaultReaderClosedPromiseInitializeAsRejected","_storedError","ReadableStreamReaderGenericCancel","ReadableStreamCancel","ReadableStreamReaderGenericRelease","defaultReaderClosedPromiseReject","defaultReaderClosedPromiseResetToRejected","readerLockException","_closedPromise","_closedPromise_resolve","_closedPromise_reject","defaultReaderClosedPromiseResolve","CancelSteps","PullSteps","AcquireReadableStreamDefaultReader","ReadableStreamDefaultReader","ReadableStreamAddReadRequest","readRequest","_resolve","_reject","_readRequests","ReadableStreamFulfillReadRequest","ReadableStreamGetNumReadRequests","ReadableStreamHasDefaultReader","IsReadableStreamDefaultReader","_a","AsyncIteratorPrototype","IsReadableStream","IsReadableStreamLocked","defaultReaderBrandCheckException","cancel","read","ReadableStreamDefaultReaderRead","releaseLock","_disturbed","_readableStreamController","ReadableStreamAsyncIteratorPrototype","IsReadableStreamAsyncIterator","streamAsyncIteratorBrandCheckException","_asyncIteratorReader","return","_preventCancel","AcquireReadableStreamAsyncIterator","preventCancel","Boolean","DequeueValue","container","pair","_queue","_queueTotalSize","EnqueueValueWithSize","PeekQueueValue","ResetQueue","AbortSteps","ErrorSteps","WritableStream","underlyingSink","strategy","InitializeWritableStream","sizeAlgorithm","SetUpWritableStreamDefaultControllerFromUnderlyingSink","IsWritableStream","streamBrandCheckException","IsWritableStreamLocked","abort","WritableStreamAbort","WritableStreamCloseQueuedOrInFlight","WritableStreamClose","getWriter","AcquireWritableStreamDefaultWriter","WritableStreamDefaultWriter","CreateWritableStream","startAlgorithm","writeAlgorithm","closeAlgorithm","abortAlgorithm","WritableStreamDefaultController","SetUpWritableStreamDefaultController","_writer","_writableStreamController","_writeRequests","_inFlightWriteRequest","_closeRequest","_inFlightCloseRequest","_pendingAbortRequest","_backpressure","_promise","wasAlreadyErroring","_reason","_wasAlreadyErroring","WritableStreamStartErroring","closeRequest","writer","defaultWriterReadyPromiseResolve","WritableStreamDefaultControllerClose","WritableStreamAddWriteRequest","writeRequest","WritableStreamDealWithRejection","WritableStreamFinishErroring","WritableStreamDefaultWriterEnsureReadyPromiseRejected","WritableStreamHasOperationMarkedInFlight","_started","storedError","abortRequest","WritableStreamRejectCloseAndClosedPromiseIfNeeded","WritableStreamFinishInFlightWrite","WritableStreamFinishInFlightWriteWithError","WritableStreamFinishInFlightClose","defaultWriterClosedPromiseResolve","WritableStreamFinishInFlightCloseWithError","WritableStreamMarkCloseRequestInFlight","WritableStreamMarkFirstWriteRequestInFlight","defaultWriterClosedPromiseReject","WritableStreamUpdateBackpressure","backpressure","defaultWriterReadyPromiseReset","_ownerWritableStream","defaultWriterReadyPromiseInitialize","defaultWriterReadyPromiseInitializeAsResolved","defaultWriterClosedPromiseInitialize","defaultWriterReadyPromiseInitializeAsRejected","defaultWriterClosedPromiseInitializeAsResolved","defaultWriterClosedPromiseInitializeAsRejected","IsWritableStreamDefaultWriter","defaultWriterBrandCheckException","defaultWriterLockException","WritableStreamDefaultWriterGetDesiredSize","_readyPromise","WritableStreamDefaultWriterAbort","WritableStreamDefaultWriterClose","WritableStreamDefaultWriterRelease","WritableStreamDefaultWriterWrite","WritableStreamDefaultWriterCloseWithErrorPropagation","WritableStreamDefaultWriterEnsureClosedPromiseRejected","_closedPromiseState","defaultWriterClosedPromiseResetToRejected","_readyPromiseState","defaultWriterReadyPromiseReject","defaultWriterReadyPromiseResetToRejected","WritableStreamDefaultControllerGetDesiredSize","releasedError","chunkSize","WritableStreamDefaultControllerGetChunkSize","WritableStreamDefaultControllerWrite","IsWritableStreamDefaultController","_controlledWritableStream","WritableStreamDefaultControllerError","_abortAlgorithm","WritableStreamDefaultControllerClearAlgorithms","_strategySizeAlgorithm","_strategyHWM","_writeAlgorithm","_closeAlgorithm","WritableStreamDefaultControllerGetBackpressure","startResult","startPromise","WritableStreamDefaultControllerAdvanceQueueIfNeeded","chunkSizeE","WritableStreamDefaultControllerErrorIfNeeded","writeRecord","enqueueE","WritableStreamDefaultControllerProcessClose","WritableStreamDefaultControllerProcessWrite","sinkClosePromise","sinkWritePromise","desiredSize","_readyPromise_resolve","_readyPromise_reject","isAbortSignal","aborted","NativeDOMException","DOMException","isDOMExceptionConstructor","createDOMExceptionPolyfill","captureStackTrace","DOMException$1","ReadableStreamPipeTo","preventClose","preventAbort","signal","shuttingDown","currentWrite","actions","shutdownWithAction","map","action","pipeLoop","resolveLoop","rejectLoop","pipeStep","isOrBecomesErrored","shutdown","isOrBecomesClosed","destClosed_1","waitForWritesToFinish","oldCurrentWrite","originalIsError","originalError","doTheRest","finalize","newError","isError","removeEventListener","ReadableStreamDefaultController","IsReadableStreamDefaultController","defaultControllerBrandCheckException","ReadableStreamDefaultControllerGetDesiredSize","ReadableStreamDefaultControllerCanCloseOrEnqueue","ReadableStreamDefaultControllerClose","ReadableStreamDefaultControllerEnqueue","ReadableStreamDefaultControllerError","_cancelAlgorithm","ReadableStreamDefaultControllerClearAlgorithms","_controlledReadableStream","_closeRequested","ReadableStreamClose","ReadableStreamDefaultControllerCallPullIfNeeded","pendingPromise","shouldPull","ReadableStreamDefaultControllerShouldCallPull","_pulling","pullPromise","_pullAlgorithm","_pullAgain","ReadableStreamError","ReadableStreamDefaultControllerHasBackpressure","SetUpReadableStreamDefaultController","pullAlgorithm","cancelAlgorithm","SetUpReadableStreamDefaultControllerFromUnderlyingSource","underlyingSource","ReadableStreamTee","cloneForBranch2","reason1","reason2","branch1","branch2","resolveCancelPromise","reading","canceled1","canceled2","cancelPromise","readPromise","value1","value2","cancel1Algorithm","compositeReason","cancelResult","cancel2Algorithm","CreateReadableStream","NumberIsInteger","ReadableStreamBYOBRequest","IsReadableStreamBYOBRequest","byobRequestBrandCheckException","_view","respond","bytesWritten","_associatedReadableByteStreamController","ReadableByteStreamControllerRespond","respondWithNewView","view","ReadableByteStreamControllerRespondWithNewView","ReadableByteStreamController","IsReadableByteStreamController","byteStreamControllerBrandCheckException","_byobRequest","_pendingPullIntos","firstDescriptor","byteOffset","bytesFilled","byobRequest","SetUpReadableStreamBYOBRequest","ReadableByteStreamControllerGetDesiredSize","_controlledReadableByteStream","ReadableByteStreamControllerClose","ReadableByteStreamControllerEnqueue","ReadableByteStreamControllerError","ReadableByteStreamControllerClearAlgorithms","ReadableByteStreamControllerHandleQueueDrain","viewE","autoAllocateChunkSize","_autoAllocateChunkSize","bufferE","pullIntoDescriptor","elementSize","readerType","ReadableByteStreamControllerCallPullIfNeeded","ReadableByteStreamControllerShouldCallPull","ReadableByteStreamControllerClearPendingPullIntos","ReadableByteStreamControllerInvalidateBYOBRequest","ReadableByteStreamControllerCommitPullIntoDescriptor","filledView","ReadableByteStreamControllerConvertPullIntoDescriptor","ReadableStreamFulfillReadIntoRequest","ReadableByteStreamControllerEnqueueChunkToQueue","ReadableByteStreamControllerFillPullIntoDescriptorFromQueue","currentAlignedBytes","maxBytesToCopy","maxBytesFilled","maxAlignedBytes","totalBytesToCopyRemaining","ready","headOfQueue","bytesToCopy","destStart","ReadableByteStreamControllerFillHeadPullIntoDescriptor","ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue","ReadableByteStreamControllerShiftPendingPullInto","ReadableByteStreamControllerPullInto","BYTES_PER_ELEMENT","ReadableStreamAddReadIntoRequest","emptyView","ReadableByteStreamControllerRespondInClosedState","ReadableStreamHasBYOBReader","ReadableStreamGetNumReadIntoRequests","ReadableByteStreamControllerRespondInReadableState","remainderSize","remainder","ReadableByteStreamControllerRespondInternal","firstPendingPullInto","transferredBuffer","transferredView","SetUpReadableByteStreamController","SetUpReadableByteStreamControllerFromUnderlyingSource","underlyingByteSource","AcquireReadableStreamBYOBReader","ReadableStreamBYOBReader","readIntoRequest","_readIntoRequests","IsReadableStreamBYOBReader","byobReaderBrandCheckException","ReadableStreamBYOBReaderRead","InitializeReadableStream","typeString","streamBrandCheckException$1","getReader","pipeThrough","_b","readable","_c","pipeTo","tee","branches","sourceCancelPromise","ByteLengthQueuingStrategy","CountQueuingStrategy","TransformStream","transformer","writableStrategy","readableStrategy","writableSizeFunction","writableHighWaterMark","readableSizeFunction","readableHighWaterMark","writableType","writableSizeAlgorithm","readableType","startPromise_resolve","readableSizeAlgorithm","InitializeTransformStream","SetUpTransformStreamDefaultControllerFromTransformer","_transformStreamController","IsTransformStream","streamBrandCheckException$2","_readable","_writable","TransformStreamDefaultSinkWriteAlgorithm","TransformStreamDefaultSinkAbortAlgorithm","TransformStreamDefaultSinkCloseAlgorithm","TransformStreamDefaultSourcePullAlgorithm","TransformStreamErrorWritableAndUnblockWrite","_backpressureChangePromise","_backpressureChangePromise_resolve","TransformStreamSetBackpressure","TransformStreamError","TransformStreamDefaultControllerClearAlgorithms","TransformStreamDefaultController","IsTransformStreamDefaultController","defaultControllerBrandCheckException$1","readableController","_controlledTransformStream","TransformStreamDefaultControllerEnqueue","TransformStreamDefaultControllerError","terminate","TransformStreamDefaultControllerTerminate","SetUpTransformStreamDefaultController","transformAlgorithm","flushAlgorithm","_transformAlgorithm","_flushAlgorithm","transformResultE","transformMethod","TransformStreamDefaultControllerPerformTransform","transformPromise","backpressureChangePromise","flushPromise","collection","collectionStrong","InternalMetadataModule","inheritIfRequired","common","IS_MAP","IS_WEAK","ADDER","NativeConstructor","NativePrototype","exported","fixMethod","nativeMethod","getConstructor","instance","HASNT_CHAINING","THROWS_ON_PRIMITIVES","ACCEPT_ITERABLES","BUGGY_ZERO","$instance","dummy","setStrong","FREEZING","METADATA","isExtensible","setMetadata","objectID","weakData","fastKey","getWeakData","onFreeze","meta","preventExtensions","Wrapper","NewTarget","NewTargetPrototype","internalStateGetterFor","previous","getEntry","removed","callbackfn","ITERATOR_NAME","getInternalCollectionState","InternalWeakMap","collectionWeak","enforceIternalState","IS_IE11","$WeakMap","WeakMapPrototype","nativeDelete","nativeHas","nativeGet","nativeSet","frozen","ArrayIterationModule","$has","findIndex","uncaughtFrozenStore","UncaughtFrozenStore","findUncaughtFrozen","arraySpeciesCreate","IS_FILTER","IS_SOME","IS_EVERY","IS_FIND_INDEX","NO_HOLES","specificCreate","filter","some","every","isArray","originalArray","nativeFromCodePoint","INCORRECT_LENGTH","arrayMethodHasSpeciesSupport","IS_CONCAT_SPREADABLE","MAX_SAFE_INTEGER","MAXIMUM_ALLOWED_INDEX_EXCEEDED","IS_CONCAT_SPREADABLE_SUPPORT","array","SPECIES_SUPPORT","isConcatSpreadable","spreadable","E","foo","nativeObjectCreate","getOwnPropertyNamesExternal","wrappedWellKnownSymbolModule","defineWellKnownSymbol","$forEach","SYMBOL","TO_PRIMITIVE","$stringify","nativeGetOwnPropertyNames","AllSymbols","ObjectPrototypeSymbols","StringToSymbolRegistry","SymbolToStringRegistry","QObject","USE_SETTER","findChild","setSymbolDescriptor","ObjectPrototypeDescriptor","isSymbol","$defineProperty","$defineProperties","properties","$getOwnPropertySymbols","$propertyIsEnumerable","$create","$getOwnPropertyDescriptor","$getOwnPropertyNames","IS_OBJECT_PROTOTYPE","keyFor","sym","useSetter","useSimple","FORCED_JSON_STRINGIFY","stringify","space","$replacer","windowNames","getWindowNames","NativeSymbol","EmptyStringDescriptionStore","SymbolWrapper","symbolPrototype","symbolToString","native","desc","JSON","$padStart","WEBKIT_BUG","repeat","IS_END","fillString","fillLen","stringFiller","stringLength","fillStr","intMaxLength","count","$padEnd","$values","TO_ENTRIES","$entries","DEFAULT_RANGE_CHUNK_SIZE","RENDERING_CANCELLED_TIMEOUT","DefaultCanvasFactory","_display_utils","DefaultCMapReaderFactory","createPDFNetworkStream","pdfNetworkStreamFactory","getDocument","PDFDocumentLoadingTask","PDFDataRangeTransport","range","rangeTransport","worker","pdfBytes","rangeChunkSize","CMapReaderFactory","ignoreErrors","stopAtErrors","fontExtraProperties","pdfBug","maxImageSize","disableFontFace","apiCompatibilityParams","disableRange","disableStream","disableAutoFetch","workerParams","GlobalWorkerOptions","workerPort","PDFWorker","fromPort","_worker","docId","workerIdPromise","_fetchDocument","networkStreamPromise","networkStream","initialData","progressiveDone","httpHeaders","withCredentials","workerId","messageHandler","postMessageTransfers","transport","WorkerTransport","_transport","_capability","pdfDataRangeTransport","apiVersion","docBaseUrl","nextDocumentId","onPassword","onProgress","onUnsupportedFeature","_createClass","transportDestroyed","_rangeListeners","_progressListeners","_progressiveReadListeners","_progressiveDoneListeners","_readyCapability","addRangeListener","addProgressListener","addProgressiveReadListener","addProgressiveDoneListener","onDataRange","begin","onDataProgress","loaded","total","onDataProgressiveRead","requestDataRange","PDFDocumentProxy","_pdfInfo","pdfInfo","getPage","pageNumber","getPageIndex","getDestinations","getDestination","getPageLabels","getPageLayout","getPageMode","getViewerPreferences","getOpenAction","getAttachments","getJavaScript","getOutline","getOptionalContentConfig","getPermissions","getMetadata","getData","getStats","startCleanup","saveDocument","annotationStorage","_annotation_storage","numPages","fingerprint","loadingParams","loadingTask","PDFPageProxy","_pageIndex","pageIndex","_pageInfo","pageInfo","_ownerDocument","_stats","_pdfBug","commonObjs","objs","PDFObjects","cleanupAfterRender","pendingCleanup","_intentStates","getViewport","getAnnotations","intent","annotationsPromise","annotationsIntent","canvasContext","viewport","enableWebGL","renderInteractiveForms","imageLayer","canvasFactory","background","optionalContentConfigPromise","renderingIntent","intentState","streamReaderCancelTimeout","clearTimeout","canvasFactoryInstance","webGLContext","enable","displayReadyCapability","operatorList","fnArray","argsArray","lastChunk","_pumpOperatorList","renderTasks","internalRenderTask","_this5","_tryCleanup","InternalRenderTask","useRequestAnimationFrame","renderTask","transparency","optionalContentConfig","initializeGraphics","operatorListChanged","opListReadCapability","opListTask","streamTextContent","normalizeWhitespace","disableCombineTextItems","TEXT_CONTENT_CHUNK_SIZE","combineTextItems","textContent","getTextContent","readableStream","pump","styles","items","pageCache","waitOn","_abortOperatorList","completed","resetStats","_startRenderPage","_renderPageChunk","operatorListChunk","sendWithStream","streamReader","_this6","_this7","curIntentState","cleanup","userUnit","LoopbackPort","_listeners","_defer","_deferred","cloneValue","cloned","transferable","transfers","_this8","PDFWorkerClosure","pdfWorkerPorts","isWorkerDisabled","fallbackWorkerSrc","nextFakeWorkerId","fakeWorkerCapability","pdfjsFilePath","currentScript","workerSrc","getMainThreadWorkerMessageHandler","mainWorkerMessageHandler","pdfjsWorker","WorkerMessageHandler","setupFakeWorkerGlobal","loader","eval","getWorkerSrc","createCDNWrapper","_port","_webWorker","_messageHandler","_initializeFromPort","_initialize","terminateEarly","onWorkerError","_this9","_setupFakeWorker","supportTransfers","sendTest","testObj","_this10","workerHandler","setup","fontLoader","_onUnsupportedFeature","_params","cMapUrl","cMapPacked","destroyCapability","_passwordCapability","_networkStream","_fullReader","_lastProgress","pagePromises","downloadInfoCapability","setupMessageHandler","_destroy","terminated","sendWithPromise","_this11","_this12","getFullReader","evt","sink","onPull","onCancel","readyReason","headersCapability","fullReader","headersReady","isStreamingSupported","isRangeSupported","contentLength","rangeReader","ex","updatePassword","exportedData","exportedError","fontRegistry","FontInspector","registerFont","fontAdded","imageData","pageProxy","MAX_IMAGE_SIZE_TO_STORE","fetched","builtInCMap","featureId","_numPages","_this13","filename","resetModified","results","contentDispositionFilename","_this14","_this15","cleanupSuccessful","_objs","_ensureObj","objId","resolved","RenderTask","_internalRenderTask","onContinue","canvasInRendering","operatorListIdx","running","graphicsReadyCallback","graphicsReady","_useRequestAnimationFrame","cancelled","_continueBound","_continue","_scheduleNextBound","_scheduleNext","_nextBound","_canvas","StepperManager","stepper","nextBreakPoint","getNextBreakPoint","gfx","beginDrawing","endDrawing","updateOperatorList","requestAnimationFrame","_this16","executeOperatorList","build","FontLoader","BaseFontLoader","nativeFontFaces","styleElement","addNativeFontFace","nativeFontFace","fonts","insertRule","styleSheet","sheet","rule","cssRules","attached","missingFile","isFontLoadingAPISupported","createNativeFontFace","family","createFontFaceRule","isSyncFontLoadingSupported","_queueLoadingCallback","_prepareFontLoadEvent","supported","requests","nextRequestId","completeRequest","otherRequest","loadingContext","int32","offset","spliceString","s","chunk1","substring","chunk2","ctx","isFontReady","fillText","getImageData","loadTestFontId","_loadTestFont","COMMENT_OFFSET","CFF_CHECKSUM_OFFSET","XXXX_VALUE","checksum","loadedName","visibility","top","left","span","fontFamily","getLoadTestFont","FontFaceObject","compiledGlyphs","translatedData","FontFace","mimetype","getPathGenerator","character","current","cmds","js","cmd","_ii","NodeCanvasFactory","NodeCMapReaderFactory","Canvas","__non_webpack_require__","createCanvas","fs","readFile","AnnotationStorage","_storage","_modified","onSetModified","onResetModified","getOrCreateValue","defaultValue","setValue","_setModified","compatibilityParams","freeze","MIN_FONT_SIZE","MAX_FONT_SIZE","MAX_GROUP_SIZE","MIN_WIDTH_FACTOR","COMPILE_TYPE3_GLYPHS","MAX_SIZE_TO_COMPILE","FULL_CHUNK_HEIGHT","addContextCurrentTransform","mozCurrentTransform","_originalSave","_originalRestore","_originalRotate","_originalScale","_originalTranslate","translate","_originalTransform","_originalSetTransform","setTransform","_transformMatrix","_transformStack","ad_bc","bc_ad","old","y","angle","cosValue","cos","sinValue","sin","CachedCanvases","getCanvas","canvasEntry","compileType3Glyph","imgData","POINT_TO_PROCESS_LIMIT","width1","points","POINT_TYPES","lineSize","data0","mask","elem","j0","sum","steps","outlines","pp","coords","p0","drawOutline","beginPath","kk","o","ll","CanvasExtraState","alphaIsShape","fontSize","fontSizeScale","textMatrix","textMatrixScale","fontMatrix","leading","lineX","lineY","charSpacing","wordSpacing","textHScale","textRenderingMode","textRise","fillColor","strokeColor","patternFill","fillAlpha","strokeAlpha","lineWidth","activeSMask","resumeSMaskCtx","transferMaps","setCurrentPoint","CanvasGraphics","EXECUTION_TIME","EXECUTION_STEPS","canvasCtx","stateStack","pendingClip","pendingEOFill","res","xobjs","groupStack","processingType3","baseTransform","baseTransformStack","groupLevel","smaskStack","smaskCounter","tempSMask","contentVisible","markedContentStack","cachedCanvases","_cachedGetSinglePixelWidth","putBinaryImageData","ImageData","putImageData","destPos","elemsInThisChunk","transferMapGray","partialChunkHeight","fullChunks","totalChunks","chunkImgData","createImageData","srcPos","transferMapRed","transferMapGreen","transferMapBlue","srcLength","dest32","dest32DataLength","fullSrcDiff","white","black","thisChunkHeight","srcDiff","kEnd","kEndUnrolled","srcByte","hasTransferMaps","putBinaryImageMask","copyCtxState","sourceCtx","destCtx","setLineDash","getLineDash","lineDashOffset","resetCtxToDefault","strokeStyle","fillStyle","fillRule","globalAlpha","lineCap","lineJoin","miterLimit","globalCompositeOperation","composeSMaskBackdrop","alpha","r0","g0","b0","alpha_","composeSMaskAlpha","maskData","transferMap","layerData","composeSMaskLuminosity","genericComposeSMask","composeFn","hasBackdrop","backdrop","subtype","PIXELS_TO_PROCESS","row","chunkHeight","maskCtx","layerCtx","composeSMask","isEnabled","composed","layer","drawImage","LINE_CAP_STYLES","LINE_JOIN_STYLES","NORMAL_CLIP","EO_CLIP","fillRect","transparentCanvas","compositeCtx","beginLayout","executionStartIdx","argsArrayLen","fnId","chunkOperations","continueCallback","endTime","breakIt","depObjId","objsPool","endSMaskGroup","endLayout","limit","dashArray","dashPhase","states","suspendSMaskGroup","beginSMaskGroup","drawnWidth","drawnHeight","cacheId","scratchCanvas","currentCtx","currentTransform","groupCtx","scaleY","startTransformInverse","mozCurrentTransformInverse","deltaTransform","clearRect","resumeSMaskGroup","ops","getSinglePixelWidth","xw","yh","bezierCurveTo","consumePath","getPattern","isPatternFill","needRestore","pendingTextPaths","addToPath","spacing","fontRefName","fontObj","fontDirection","isType3Font","bold","italic","typeface","fallbackName","browserFontSize","rise","paintChar","fillStrokeMode","isAddToPathSet","patternTransform","strokeText","isFontSubpixelAAEnabled","glyphs","glyphsLength","vertical","spacingDir","defaultVMetrics","widthAdvanceScale","simpleFillText","pattern","glyph","scaledX","scaledAccentY","vmetric","vy","charWidth","restoreNeeded","fontChar","accent","vx","scaledY","remeasure","measuredWidth","measureText","characterScaleX","isInFont","scaledAccentX","showType3Text","spacingLength","isTextInvisible","charProcOperatorList","operatorListId","transformed","xWidth","llx","urx","ury","lly","getColorN_Pattern","IR","color","canvasGraphicsFactory","createCanvasGraphics","getShadingPatternFromIR","patternIR","inv","bl","br","ul","ur","x0","y0","x1","y1","matrix","bbox","group","isolated","knockout","bounds","canvasBounds","scaleX","imageSmoothingEnabled","mozImageSmoothingEnabled","img","compiled","maskCanvas","skewX","skewY","positions","images","image","w","imgToPaint","tmpCanvas","widthScale","heightScale","HTMLElement","tmpCtx","paintWidth","paintHeight","tmpCanvasId","newWidth","newHeight","getCanvasPosition","appendImage","visible","isVisible","isContentVisible","inverse","op","ShadingIRs","applyBoundingBox","Path2D","region","RadialAxial","fromIR","raw","colorStops","r1","grad","createLinearGradient","createRadialGradient","addColorStop","createMeshCanvas","drawTriangle","tmp","colors","rowSize","c1","c2","c3","x2","y2","x3","y3","xa","cab","xb","cbb","c1r","c1g","c1b","c2r","c2g","c2b","c3r","c3g","c3b","minY","round","maxY","_k","car","cag","_k2","cbr","cbg","x1_","x2_","drawFigure","ps","figure","cs","verticesPerRow","rows","cols","EXPECTED_SCALE","MAX_PATTERN_SIZE","BORDER_SIZE","boundsWidth","boundsHeight","combinesScale","paddedWidth","paddedHeight","drawFigures","backgroundColor","figures","shadingIR","Mesh","owner","matrixScale","temporaryPatternCanvas","Dummy","TilingPattern","PaintType","COLORED","UNCOLORED","xstep","ystep","paintType","tilingType","createPatternCanvas","curMatrixScale","combinedScale","dimx","getSizeAndScale","dimy","graphics","setFillAndStrokeStyleToContext","clipBbox","maxSize","realOutputSize","bboxWidth","bboxHeight","cssColor","CallbackKind","DATA","ERROR","StreamKind","CANCEL","CANCEL_COMPLETE","CLOSE","ENQUEUE","PULL","PULL_COMPLETE","START_COMPLETE","wrapReason","MessageHandler","sourceName","targetName","comObj","callbackId","streamId","streamSinks","streamControllers","callbackCapabilities","actionHandler","_onComObjOnMessage","cbSourceName","cbTargetName","ah","actionName","_postMessage","startCapability","startCall","pullCall","cancelCall","isClosed","pull","pullCapability","cancelCapability","queueingStrategy","_createStreamSink","streamSink","isCancelled","lastDesiredSize","sinkCapability","success","_processStreamMessage","_deleteStreamController","Metadata","_repair","parser","_xml_parser","xmlDocument","parseFromString","_metadataMap","_parse","codes","chars","rdf","nodeName","firstChild","nextSibling","hasChildNodes","childNodes","jj","trim","XMLParserErrorCode","NoError","EndOfDocument","UnterminatedCdat","UnterminatedXmlDeclaration","UnterminatedDoctypeDeclaration","UnterminatedComment","MalformedElement","OutOfMemory","UnterminatedAttributeValue","UnterminatedElement","ElementNeverBegun","isWhitespace","ch","isWhitespaceString","XMLParserBase","_resolveEntities","entity","_parseContent","skipWs","attrName","attrValue","attrEndChar","attrEndIndex","parsed","_parseProcessingInstruction","attrStart","parseXml","ch2","onError","onEndElement","pi","onPi","onComment","onCdata","q2","complexDoctype","doctypeContent","onDoctype","onBeginElement","onText","onResolveEntity","SimpleDOMNode","nodeValue","child","SimpleXMLParser","_currentFragment","_stack","_errorCode","lastElement","OptionalContentGroup","OptionalContentConfig","creator","_order","_groups","order","groups","_group","off","expression","policy","ids","_id","_id2","_id3","setVisibility","getGroup","PDFDataTransportStream","_queuedChunks","_progressiveDone","_pdfDataRangeTransport","_isStreamingSupported","_isRangeSupported","_contentLength","_fullRequestReader","_rangeReaders","_onProgressiveDone","transportReady","_onReceiveData","_enqueue","_begin","_onProgress","firstReader","_removeRangeReader","queuedChunks","getRangeReader","_progressiveDataLength","PDFDataTransportStreamRangeReader","cancelAllRequests","readers","_loaded","PDFDataTransportStreamReader","_stream","_done","_filename","_requests","_headersReady","requestCapability","_end","_queuedChunk","requestsCapability","WebGLContext","_enabled","WebGLUtils","tryInitGL","loadShader","gl","shader","createShader","shaderType","shaderSource","compileShader","getShaderParameter","COMPILE_STATUS","errorMsg","getShaderInfoLog","createVertexShader","VERTEX_SHADER","createFragmentShader","FRAGMENT_SHADER","createProgram","program","shaders","attachShader","linkProgram","linked","getProgramParameter","LINK_STATUS","getProgramInfoLog","createTexture","activeTexture","textureId","texture","bindTexture","texParameteri","CLAMP_TO_EDGE","NEAREST","texImage2D","currentGL","currentCanvas","generateGL","premultipliedalpha","smaskVertexShaderCode","smaskFragmentShaderCode","smaskCache","initSmaskGL","vertexShader","fragmentShader","useProgram","resolutionLocation","getUniformLocation","positionLocation","getAttribLocation","backdropLocation","subtypeLocation","texCoordLocation","texLayerLocation","texMaskLocation","texCoordBuffer","createBuffer","bindBuffer","bufferData","STATIC_DRAW","enableVertexAttribArray","vertexAttribPointer","uniform1i","drawingBufferHeight","uniform2f","uniform4f","TEXTURE0","maskTexture","TEXTURE1","clearColor","BLEND","blendFunc","ONE_MINUS_SRC_ALPHA","COLOR_BUFFER_BIT","drawArrays","deleteTexture","deleteBuffer","figuresVertexShaderCode","figuresFragmentShaderCode","figuresCache","initFiguresGL","scaleLocation","offsetLocation","colorLocation","coordsMap","colorsMap","pIndex","cIndex","col","coordsBuffer","colorsBuffer","AnnotationElementFactory","parameters","annotationType","fieldType","radioButton","checkBox","AnnotationElement","isRenderable","ignoreBorder","linkService","downloadManager","imageResourcesPath","svgFactory","_createContainer","transformOrigin","borderStyle","borderWidth","horizontalRadius","horizontalCornerRadius","verticalRadius","verticalCornerRadius","radius","borderRadius","borderBottomStyle","borderColor","_createPopup","trigger","popupElement","PopupElement","modificationDate","contents","hideWrapper","popup","LinkAnnotationElement","className","newWindow","externalLinkTarget","externalLinkRel","externalLinkEnabled","_bindNamedAction","_bindLink","getDestinationHash","destination","getAnchorUrl","TextAnnotationElement","hasPopup","alt","dataset","l10nId","l10nArgs","WidgetAnnotationElement","TextWidgetAnnotationElement","hasAppearance","fieldValue","TEXT_ALIGNMENT","storage","multiLine","disabled","readOnly","fieldName","maxLen","comb","fieldWidth","combWidth","letterSpacing","verticalAlign","_setTextStyle","textAlignment","textAlign","direction","fontWeight","fontStyle","CheckboxWidgetAnnotationElement","checked","RadioButtonWidgetAnnotationElement","buttonValue","getElementsByName","radio","getAttribute","PushButtonWidgetAnnotationElement","ChoiceWidgetAnnotationElement","selectElement","combo","multiSelect","multiple","option","optionElement","displayValue","exportValue","PopupAnnotationElement","IGNORE_TYPES","parentType","selector","parentId","parentElement","querySelector","parentLeft","parseFloat","parentWidth","pinned","BACKGROUND_ENLIGHT","hideElement","dateObject","toLocaleDateString","toLocaleTimeString","_formatContents","_toggle","_show","_hide","lines","line","pin","hasAttribute","removeAttribute","zIndex","unpin","FreeTextAnnotationElement","LineAnnotationElement","lineCoordinates","SquareAnnotationElement","square","CircleAnnotationElement","circle","PolylineAnnotationElement","containerClassName","vertices","coordinate","polyline","svgElementName","PolygonAnnotationElement","CaretAnnotationElement","InkAnnotationElement","inkLists","inkList","HighlightAnnotationElement","UnderlineAnnotationElement","SquigglyAnnotationElement","StrikeOutAnnotationElement","StampAnnotationElement","FileAttachmentAnnotationElement","eventBus","_download","downloadData","AnnotationLayer","sortedAnnotations","popupAnnotations","annotations","_data","renderTextLayer","MAX_TEXT_DIVS_TO_RENDER","NonWhitespaceRegexp","isAllWhitespace","appendText","textDiv","textDivProperties","canvasWidth","originalTransform","paddingBottom","paddingLeft","paddingRight","paddingTop","_textDivs","geom","_textDivProperties","tx","_viewport","atan2","fontName","PI","fontHeight","fontAscent","ascent","descent","_fontInspectorEnabled","shouldScaleText","absScaleX","absScaleY","_textContentStream","_layoutText","_enhanceTextSelection","angleCos","angleSin","divWidth","divHeight","_bounds","right","bottom","_canceled","textDivs","textDivsLength","_renderingDone","findPositiveMin","ts","expanded","expandBounds","divProperties","boxScale","boxes","box","x1New","x2New","expandBoundsLTR","fakeBoundary","horizon","boundary","horizonPart","affectedBoundary","maxXNew","xNew","changedHorizon","lastBoundary","useBoundary","used","TextLayerRenderTask","textContentStream","textContentItemsStr","enhanceTextSelection","_textContent","_container","_textContentItemsStr","_layoutTextLastFontSize","_layoutTextLastFontFamily","_layoutTextCtx","_renderTimer","renderParameters","_render","timeout","_processItems","styleCache","mozOpaque","textItems","textStyles","expandTextDivs","expandDivs","transformBuf","paddingBuf","divProps","padding","SVGGraphics","opListToTree","opList","opTree","opListElement","pf","toFixed","pm","acos","SVG_DEFAULTS","XML_NS","XLINK_NS","convertImgDataToPng","PNG_HEADER","CHUNK_WRAPPER_SIZE","crcTable","crc32","crc","writePngChunk","adler32","deflateSync","literals","deflateSyncUncompressed","maxBlockLength","deflateBlocks","idat","adler","colorType","bitDepth","offsetLiterals","offsetBytes","isMask","ihdr","pngLength","SVGExtraState","dependencies","activeClipUrl","clipGroup","maskId","clipCount","maskCount","shadingCount","transformMatrix","transformStack","extraStack","embedFonts","embeddedFonts","cssStyle","_operatorIdMapping","tgrp","executeOpTree","loadDependencies","getSVG","svgElement","convertOpList","operatorIdMapping","opTreeElement","lineMatrix","xcoords","ycoords","tspan","setAttributeNS","txtElement","txtgrp","lineWidthScale","_setStrokeAttributes","_ensureTransformGroup","addFontStyle","defs","setStrokeAlpha","setFillAlpha","_makeColorN_Pattern","_makeShadingPattern","_makeTilingPattern","tilingId","tx0","ty0","tx1","ty1","xscale","yscale","txstep","tystep","tiling","gradient","shadingId","point0","point1","focalPoint","circlePoint","focalRadius","circleRadius","colorStop","getAttributeNS","clipId","clipPath","clipElement","cloneNode","imgSrc","cliprect","imgEl","definitions","rootGroup","_ensureClipGroup","fileUriRegex","parseUrl","sourceUrl","parsedUrl","parse","isHttp","isFsUrl","_rangeRequestReaders","PDFNodeStreamFsFullReader","PDFNodeStreamFullReader","PDFNodeStreamFsRangeReader","PDFNodeStreamRangeReader","BaseFullReader","_url","_disableRange","_rangeChunkSize","_readableStream","_readCapability","_headersCapability","_error","_setReadableStream","BaseRangeReader","createRequestOptions","auth","handleResponse","statusCode","getResponseHeader","validateRangeRequestCapabilities","allowRangeRequests","suggestedLength","extractFilenameFromHeader","lstat","createReadStream","returnValues","contentEncoding","contentDisposition","getFilenameFromContentDispositionHeader","createResponseStatusError","validateResponseStatus","needsEncodingFixup","toParamRegExp","rfc2616unquote","rfc5987decode","rfc2047decode","fixupEncoding","rfc2231getparam","_filename2","attributePattern","flags","textdecode","encoding","decoder","TextDecoder","fatal","decode","contentDispositionStr","quot","_n2","_quot","_part","quotindex","extvalue","encodingend","langvalue","hex","OK_RESPONSE","PARTIAL_CONTENT_RESPONSE","getArrayBuffer","xhr","NetworkManager","getXhr","currXhrId","pendingRequests","requestRange","prop","listeners","requestFull","xhrId","pendingRequest","setRequestHeader","expectedStatus","onStateChange","onprogress","onHeadersReceived","onDone","xhrStatus","ok_response_on_range_request","rangeHeader","getRequestXhr","isPendingRequest","_source","_manager","_onRangeRequestReaderClosed","PDFNetworkStreamFullRequestReader","PDFNetworkStreamRangeRequestReader","onClosed","manager","_onHeadersReceived","_onDone","_onError","_fullRequestId","_headersReceivedCapability","_cachedChunks","fullRequestXhrId","fullRequestXhr","lengthComputable","_requestId","_close","createFetchOptions","abortController","credentials","redirect","createHeaders","PDFFetchStreamReader","PDFFetchStreamRangeReader","_withCredentials","AbortController","_abortController","_headers","AnnotationLayerBuilder","pageDiv","pdfPage","_ref$annotationStorag","_ref$imageResourcesPa","_ref$renderInteractiv","_ref$l10n","l10n","_classCallCheck","_cancelled","DefaultAnnotationLayerFactory","createAnnotationLayerBuilder","_pdf_link_service","pdfjsLib","CSS_UNITS","DEFAULT_SCALE_VALUE","DEFAULT_SCALE","MIN_SCALE","MAX_SCALE","UNKNOWN_SCALE","MAX_AUTO_SCALE","SCROLLBAR_PADDING","VERTICAL_PADDING","PresentationModeState","NORMAL","CHANGING","FULLSCREEN","RendererType","CANVAS","SVG","TextLayerMode","DISABLE","ENABLE","ENABLE_ENHANCE","ScrollMode","VERTICAL","HORIZONTAL","WRAPPED","SpreadMode","ODD","EVEN","AutoPrintRegExp","formatL10nValue","NullL10n","getLanguage","getDirection","fallback","getOutputScale","devicePixelRatio","backingStoreRatio","webkitBackingStorePixelRatio","pixelRatio","scaled","scrollIntoView","spot","skipOverflowHiddenElements","offsetParent","offsetTop","clientTop","offsetLeft","clientLeft","clientHeight","clientWidth","scrollWidth","getComputedStyle","overflow","_scaleY","_scaleX","scrollLeft","scrollTop","watchScroll","viewAreaElement","debounceScroll","rAF","currentX","lastX","currentY","lastY","down","_eventHandler","parseQueryString","param","binarySearchFirstItem","condition","minIndex","currentIndex","currentItem","approximateFraction","xinv","x_","roundToDivide","getPageSizeInches","changeOrientation","backtrackBeforeAllVisibleElements","views","elt","pageTop","getVisibleElements","sortByVisibility","horizontal","scrollEl","isElementBottomAfterViewTop","elementBottom","isElementRightAfterViewLeft","elementRight","numViews","firstVisibleElementInd","lastEdge","currentWidth","currentHeight","viewWidth","viewHeight","viewRight","viewBottom","hiddenHeight","hiddenWidth","percent","pc","noContextMenuHandler","preventDefault","isDataSchema","getPDFFileNameFromURL","defaultFilename","reURI","reFilename","splitURI","suggestedFilename","normalizeWheelEventDirection","deltaX","deltaY","normalizeWheelEventDelta","MOUSE_DOM_DELTA_PIXEL_MODE","MOUSE_DOM_DELTA_LINE_MODE","MOUSE_PIXELS_PER_LINE","MOUSE_LINES_PER_PAGE","deltaMode","isValidRotation","isValidScrollMode","isValidSpreadMode","isPortraitOrientation","WaitOnType","EVENT","TIMEOUT","waitOnEventOrTimeout","_ref2$delay","delay","EventBus","_off","eventHandler","_on","timeoutHandler","animationStarted","eventName","external","dispatch","eventListeners","externalListeners","clamp","ProgressBar","units","bar","_indeterminate","progressSize","_percent","setWidth","viewer","scrollbarWidth","_updateBar","moveToEndOfArray","moved","_read","accidentalStrictMode","PDFLinkService","_ref$externalLinkTarg","_ref$externalLinkRel","_ref$externalLinkEnab","_ref$ignoreDestinatio","ignoreDestinationZoom","_ignoreDestinationZoom","pdfDocument","pdfViewer","pdfHistory","_pagesRefCache","setDocument","setViewer","setHistory","navigateTo","goToDestination","namedDest","explicitDest","destRef","pagesCount","pushCurrentPosition","destArray","setHash","phraseSearch","phrase","zoomArgs","zoom","zoomArg","zoomArgNumber","scrollPageIntoView","allowNegativeOffset","pagemode","nameddest","isValidExplicitDestination","executeNamedAction","back","forward","cachePageRef","pageRef","refStr","gen","num","pageNum","_cachedPageNumber","isPageVisible","currentPageNumber","pagesRotation","destLength","allowNull","SimpleLinkService","EXPAND_DIVS_TIMEOUT","TextLayerBuilder","textLayerDiv","_ref$findController","findController","_ref$enhanceTextSelec","renderingDone","pageIdx","textLayerRenderTask","_onUpdateTextLayerMatches","_bindMouse","endOfContent","numTextDivs","textLayerFrag","createDocumentFragment","_finishRendering","_updateMatches","setTextContentStream","setTextContent","_convertMatches","iIndex","queryLen","mm","matchIdx","divIdx","matchesLength","_renderMatches","isSelectedPage","selected","selectedMatchIdx","highlightAll","prevEnd","infinity","i0","i1","isSelected","highlightSuffix","scrollMatchIntoView","matchIndex","appendTextToDiv","n0","n1","fromOffset","toOffset","clearedUntilDivIdx","highlightMatches","pageMatches","pageMatchesLength","expandDivsTimer","adjustTop","divBounds","getBoundingClientRect","DefaultTextLayerFactory","createTextLayerBuilder","click","blobUrl","download","DownloadManager","downloadUrl","msSaveBlob","viewerCompatibilityParams","disableCreateObjectURL","platform","maxTouchPoints","isAndroid","isIOS","isIOSChrome","maxCanvasPixels","webL10n","GenericL10n","_lang","lang","_ready","setLanguage","gL10nData","gTextData","gTextProp","gLanguage","gMacros","gReadyState","gAsyncResourceLoading","getL10nResourceLinks","querySelectorAll","getL10nDictionary","getTranslatableChildren","getL10nAttributes","xhrLoadText","onSuccess","onFailure","overrideMimeType","ontimeout","parseResource","successCallback","failureCallback","baseURL","evalString","parseProperties","parsedPropertiesCallback","dictionary","reBlank","reComment","reSection","reImport","reSplit","parseRawLines","rawText","extendedSyntax","parsedRawLinesCallback","currentLang","genericLang","skipLang","nextEntry","loadImport","loadLocale","langLinks","langCount","onResourceLoaded","gResourceCount","resource","L10nResourceLink","load","dict","default_locale","locales","defaultLocale","anyCaseLang","getPluralRules","locales2rules","isIn","isBetween","pluralRules","getL10nData","rv","substIndexes","substArguments","reIndex","reMatch","macroName","paramName","macro","reArgs","matched_text","translateElement","getChildElementCount","nodeType","textNode","insertBefore","childElementCount","translateFragment","elementCount","plural","_pluralRules","fallbackString","getText","rtlList","shortCode","getReadyState","once","FindState","FOUND","NOT_FOUND","FIND_TIMEOUT","MATCH_SCROLL_OFFSET_TOP","MATCH_SCROLL_OFFSET_LEFT","CHARACTERS_TO_NORMALIZE","normalizationRegex","PDFFindController","_linkService","_eventBus","_reset","_onFindBarClose","_pdfDocument","_firstPageCapability","executeCommand","_shouldDirtyMatch","_dirtyMatch","_updateUIState","_extractText","findbarClosed","_highlightMatches","pendingTimeout","_findTimeout","_nextMatch","_updateAllPages","_ref2$pageIndex","_ref2$matchIndex","_scrollMatches","_selected","_pageMatches","_pageMatchesLength","_offset","wrapped","_extractTextPromises","_pageContents","_matchesCountTotal","_pagesToSearch","_pendingFindMatches","_resumePageIdx","_prepareMatches","isSubTerm","currentElem","matchesWithLength","nextElem","skipped","prevElem","matchLength","_isEntireWord","startIdx","getCharacterType","endIdx","_limit","_calculatePhraseMatch","pageContent","entireWord","_calculateWordMatch","queryArray","subquery","subqueryLen","_calculateMatch","_query","caseSensitive","_updatePage","_nextPageMatch","pageMatchesCount","_updateUIResultsCount","extractTextCapability","_loop","findPrevious","currentPageIndex","numPageMatches","_updateMatch","_advanceOffsetPage","_matchesReady","numMatches","previousPage","matchesCount","_requestMatchesCount","rawQuery","_rawQuery","_normalizedQuery","CharacterType","SPACE","ALPHA_LETTER","PUNCT","HAN_LETTER","KATAKANA_LETTER","HIRAGANA_LETTER","HALFWIDTH_KATAKANA_LETTER","THAI_LETTER","isAlphabeticalScript","charCode","isAscii","isAsciiAlpha","isAsciiDigit","isAsciiSpace","isHan","isKatakana","isHiragana","isHalfwidthKatakana","isThai","HASH_CHANGE_TIMEOUT","POSITION_UPDATED_THRESHOLD","UPDATE_VIEWAREA_TIMEOUT","getCurrentHash","PDFHistory","_initialized","_fingerprint","_boundEvents","_isViewerInPresentationMode","active","switchInProgress","onPagesLoaded","_ref2$resetHistory","resetHistory","_ref2$updateUrl","updateUrl","reInitialized","_updateUrl","_bindEvents","_popStateInProgress","_blockHashChange","_currentHash","_numPositionUpdates","_uid","_maxUid","_destination","_position","_isValidState","_parseCurrentHash","_pushOrReplaceState","_updateInternalState","_initialRotation","_initialBookmark","_pageHide","_unbindEvents","_updateViewareaTimeout","forceReplace","isDestHashesEqual","isDestArraysEqual","_tryPushCurrentPosition","newUrl","shouldReplace","newState","temporary","checkReload","performance","getEntriesByType","_performance$getEntri2","perfEntry","removeTemporary","checkNameddest","_updateViewarea","pdfOpenParams","_popState","newHash","hashChanged","updateViewarea","popState","pageHide","destHash","pushHash","firstDest","secondDest","isEntryEqual","MAX_CANVAS_PIXELS","PDFPageView","defaultViewport","renderingId","pageLabel","_ui_utils","pdfPageRotate","_annotationStorage","_optionalContentConfigPromise","hasRestrictedScaling","textLayerMode","useOnlyCssZoom","renderingQueue","textLayerFactory","annotationLayerFactory","renderer","paintTask","paintedViewportMap","renderingState","RenderingStates","INITIAL","resume","textLayer","zoomLayer","setPdfPage","totalRotation","stats","removeFromDOM","zoomLayerCanvas","keepZoomLayer","keepAnnotations","cancelRendering","currentZoomLayerNode","currentAnnotationNode","hide","_resetZoomLayer","loadingIconDiv","cssTransform","timestamp","isScalingRestricted","outputScale","redrawAnnotations","relativeRotation","absRotation","textLayerViewport","textRelativeRotation","textAbsRotation","transY","transX","_renderAnnotationLayer","getPagePoint","FINISHED","RUNNING","canvasWrapper","renderContinueCallback","cont","PAUSED","finishPaintTask","_pdfjsLib","_context2","paintOnSvg","paintOnCanvas","onRenderContinue","resultPromise","renderCapability","isCanvasHidden","showCanvas","actualSizeViewport","pixelsInViewport","maxScale","sfx","sfy","renderContext","ensureNotCancelled","getOperatorList","svgGfx","setPageLabel","CLEANUP_TIMEOUT","PDFRenderingQueue","pdfThumbnailViewer","onIdle","highestPriorityPage","idleTimeout","printing","isThumbnailViewEnabled","setThumbnailViewer","isHighestPriority","renderHighestPriority","forceRendering","currentlyVisiblePages","getHighestPriority","visibleViews","numVisible","isViewFinished","scrolledDown","nextPageIndex","previousPageIndex","renderView","PDFSinglePageViewer","_ensurePageViewVisible","_get","_previousPageNumber","_shadowViewer","_updateScrollDown","pageView","_pages","_currentPageNumber","previousPageView","viewerNodes","_ref$pageSpot","pageSpot","_ref$pageNumber","_scrollIntoView","_setCurrentPageNumber","_getCurrentVisiblePage","_updateHelper","_base_viewer","DEFAULT_CACHE_SIZE","PDFPageViewBuffer","newSize","pagesToKeep","pageIdsToKeep","iMax","isSameScale","oldScale","newScale","BaseViewer","_name","firstElementChild","HTMLDivElement","removePageBorders","enablePrintAutoRotate","defaultRenderingQueue","_pdf_rendering_queue","_scrollUpdate","presentationModeState","_onBeforeDraw","_onAfterDraw","_resetView","getPageView","resetCurrentPageView","_resetCurrentPageView","_pageLabels","_getVisiblePages","_onePageRenderedCapability","_cancelRendering","firstPagePromise","_pagesCapability","settled","firstPdfPage","currentScale","_viewerElement","firstPageView","_updateSpreadMode","getPagesLeft","_pageNum","setPageLabels","_currentScale","_currentScaleValue","_buffer","_location","_pagesRotation","_pagesRequests","_scrollMode","_spreadMode","_updateScrollMode","_setScaleUpdatePages","noScroll","preset","newValue","presetValue","isInPresentationMode","isChangingPresentationMode","_setScale","currentPage","noPadding","hPadding","vPadding","_isScrollModeHorizontal","pageWidthScale","pageHeightScale","horizontalScale","_ref3$destArray","_ref3$allowNegativeOf","_ref3$ignoreDestinati","pageWidth","pageHeight","currentScaleValue","boundingRect","_updateLocation","normalizedScaleValue","firstPage","currentPageView","intLeft","intTop","visiblePages","numVisiblePages","newCacheSize","containsElement","focus","_ensurePdfPageLoaded","scrollAhead","pagesOverview","scrollMode","pages","parity","spread","_iMax","scrollHeight","_step","_iterator","PDFViewer","currentId","stillFullyVisible","pendingOperation","isPDFDocumentLoadingTask","__PDFDocumentLoadingTask","canvasElt","annotationLayerElt","emitEvent","pdfDoc","pdfRender","canceling","clearCanvas","clearAnnotations","pageNumberOnly","PRINT_RESOLUTION","PRINT_UNITS","iframeElt","frameBorder","scrolling","cssText","win","allPages","printCanvasElt","queryCommandSupported","execCommand","removeIframe","catch","pageRotate","getAnnotationsOperation","pdfRenderOperation","forEachPage","pageCallback","reasonStr","ratio"],"sourceRoot":""}